// ---------------------------------------------------------------------------// @executor/execution/promise — Promise-native surface for the execution// engine.// ---------------------------------------------------------------------------//// `engine.ts` is Effect-native; this module runs each method with// `Effect.runPromise` at the boundary so hosts that can't compose Effects// (the MCP SDK tool handlers, plain async call sites) can still use the// engine. Callers already inside an Effect context should import directly// from `@executor/execution` to keep trace context intact.// --------------------------------------------------------------------------- import { Effect } from "effect";import type * as Cause from "effect/Cause"; import type {  ElicitationContext,  ElicitationResponse,  Executor as PromiseExecutor,} from "@executor/sdk";import type { CodeExecutionError, CodeExecutor, ExecuteResult } from "@executor/codemode-core"; import {  createExecutionEngine as createEffectExecutionEngine,  type ExecutionEngine as EffectExecutionEngine,  type ExecutionResult,  type PausedExecution,  type ResumeResponse,} from "./engine"; export type ElicitationHandler = (  ctx: ElicitationContext,) => Promise<ElicitationResponse>; export type ExecutionEngineConfig<  E extends Cause.YieldableError = CodeExecutionError,> = {  readonly executor: PromiseExecutor;  readonly codeExecutor: CodeExecutor<E>;}; export type ExecutionEngine = {  readonly execute: (    code: string,    options: { readonly onElicitation: ElicitationHandler },  ) => Promise<ExecuteResult>;  readonly executeWithPause: (code: string) => Promise<ExecutionResult>;  readonly resume: (    executionId: string,    response: ResumeResponse,  ) => Promise<ExecutionResult | null>;  readonly getDescription: () => Promise<string>;}; /** * Wrap a Promise-style executor into the Effect shape the engine consumes. * Only the four method families the engine actually touches need wrapping: * `tools.{invoke,list,schema,definitions}` and `sources.list`. */const wrapPromiseExecutor = (pe: PromiseExecutor): any => ({  scope: (pe as any).scope,  tools: {    invoke: (id: unknown, args: unknown, options: unknown) =>      Effect.tryPromise({        try: () => (pe.tools as any).invoke(id, args, options),        catch: (cause) => cause,      }),    list: (filter?: unknown) =>      Effect.tryPromise({        try: () => (pe.tools as any).list(filter),        catch: (cause) => cause,      }).pipe(Effect.orDie),    schema: (id: unknown) =>      Effect.tryPromise({        try: () => (pe.tools as any).schema(id),        catch: (cause) => cause,      }),    definitions: () =>      Effect.tryPromise({        try: () => (pe.tools as any).definitions(),        catch: (cause) => cause,      }).pipe(Effect.orDie),  },  sources: {    list: () =>      Effect.tryPromise({        try: () => (pe.sources as any).list(),        catch: (cause) => cause,      }).pipe(Effect.orDie),  },}); /** * Promise-wrap an Effect-native `ExecutionEngine` (from `./engine`). * Exposed separately so callers that already hold an Effect engine * (apps/cloud's execution-stack composes both) can convert it for hosts * that need the Promise surface (host-mcp). */export const toPromiseExecutionEngine = <E extends Cause.YieldableError>(  engine: EffectExecutionEngine<E>,): ExecutionEngine => ({  execute: (code, options) =>    Effect.runPromise(      engine.execute(code, {        onElicitation: (ctx) =>          Effect.tryPromise(() => options.onElicitation(ctx)).pipe(Effect.orDie),      }),    ),  executeWithPause: (code) => Effect.runPromise(engine.executeWithPause(code)),  resume: (executionId, response) => Effect.runPromise(engine.resume(executionId, response)),  getDescription: () => Effect.runPromise(engine.getDescription),}); export const createExecutionEngine = <  E extends Cause.YieldableError = CodeExecutionError,>(  config: ExecutionEngineConfig<E>,): ExecutionEngine =>  toPromiseExecutionEngine(    createEffectExecutionEngine({      executor: wrapPromiseExecutor(config.executor),      codeExecutor: config.codeExecutor,    }),  ); // ---------------------------------------------------------------------------// Re-exports — plain types/helpers that don't carry Effect signatures.// --------------------------------------------------------------------------- export { formatExecuteResult, formatPausedExecution } from "./engine"; export type { ExecutionResult, PausedExecution, ResumeResponse }; export { buildExecuteDescription } from "./description";export { ExecutionToolError } from "./errors";