Function createToolBridge

packages/kernel/runtime-quickjs/src/index.ts:240–296

(
  context: QuickJSContext,
  toolInvoker: SandboxToolInvoker,
  pendingDeferreds: Set<QuickJSDeferredPromise>,
  runPromise: RunPromise,
)

type RunPromise = <A, E>(effect: Effect.Effect<A, E>) => Promise<A>;

const createToolBridge = (
  context: QuickJSContext,
  toolInvoker: SandboxToolInvoker,
  pendingDeferreds: Set<QuickJSDeferredPromise>,
  runPromise: RunPromise,
): QuickJSHandle =>
  context.newFunction("__executor_invokeTool", (pathHandle, argsHandle) => {
    const path = context.getString(pathHandle);
    const args =
      argsHandle === undefined || context.typeof(argsHandle) === "undefined"
        ? undefined
        : context.dump(argsHandle);
    const deferred = context.newPromise();
    pendingDeferreds.add(deferred);
    deferred.settled.finally(() => {
      pendingDeferreds.delete(deferred);
    });

    void runPromise(toolInvoker.invoke({ path, args })).then(
      (value) => {
        if (!deferred.alive) {
          return;
        }

        const serialized = serializeJson(value, `Tool result for ${path}`);
        if (typeof serialized === "undefined") {
          deferred.resolve();
          return;
        }

        const valueHandle = context.newString(serialized);
        deferred.resolve(valueHandle);
        valueHandle.dispose();
      },
      (cause) => {
        if (!deferred.alive) {
          return;
        }

        // The reject path is reserved for true infra defects. The
        // upstream tool-invoker has already replaced the message with
        // an opaque generic plus a correlation id, but defensively log
        // the cause here and emit a stable generic if upstream changes.
        const message = sandboxDefectMessage(cause);
        try {
          console.error("[executor:quickjs] tool dispatch defect", { path, cause });
        } catch {
          /* ignore logger failures */
        }
        const errorHandle = context.newError(message);
        deferred.reject(errorHandle);
        errorHandle.dispose();
      },
    );

    return deferred.handle;
  });