@ai-sdk/code-mode 1.0.20 → 1.0.22

package/dist/run-code-mode.js

@@ -1,6 +1,547 @@
-import { runManagedCodeMode } from "./runtime/manager.js";
+import { Buffer } from "node:buffer";
+import { createHash } from "node:crypto";
+import {
+  createRunner,
+  createSignedContinuationCodec,
+  getHostFunctionContext,
+  RunError
+} from "run";
+import {
+  isCodeModeApprovalInterruptPayload,
+  normalizeApprovalResolution
+} from "./approval.js";
+import {
+  resolveCodeModeContinuationSecurity,
+  signCodeModeContinuation,
+  verifyCodeModeContinuation
+} from "./continuation-capability.js";
+import {
+  CodeModeAbortedError,
+  CodeModeBridgeLimitError,
+  CodeModeConcurrencyError,
+  CodeModeDetachedBridgeRequestError,
+  CodeModeError,
+  CodeModeProtocolError,
+  CodeModeSourceTooLargeError,
+  CodeModeTimeoutError,
+  CodeModeToolApprovalDeniedError
+} from "./errors.js";
+import { invokeHostTool } from "./tool-invocation.js";
+import { fromJsonPayload, toJsonPayload } from "./utils/serialization.js";
+const SOURCE_LINE_OFFSET = 1;
+const MAX_RUN_LIMIT = 2147483647;
+const DEFAULT_TIMEOUT_MS = 3e4;
+const DEFAULT_MEMORY_LIMIT_BYTES = 64 * 1024 * 1024;
+const DEFAULT_STACK_LIMIT_BYTES = 2 * 1024 * 1024;
+const DEFAULT_MAX_RESULT_BYTES = 1024 * 1024;
+const DEFAULT_MAX_CONSOLE_OUTPUT_BYTES = 64 * 1024;
+const DEFAULT_MAX_SOURCE_BYTES = 256 * 1024;
+const DEFAULT_MAX_TOOL_INPUT_BYTES = 1024 * 1024;
+const DEFAULT_MAX_TOOL_OUTPUT_BYTES = 4 * 1024 * 1024;
+const DEFAULT_MAX_BRIDGE_REQUESTS = 256;
+const DEFAULT_MAX_IN_FLIGHT_BRIDGE_REQUESTS = 32;
+let invocationCounter = 0;
 async function runCodeMode(input) {
-  return await runManagedCodeMode(input);
+  const policy = resolveExecutionPolicy(input.options?.executionPolicy);
+  assertSourceSize(input.js, policy.maxSourceBytes);
+  const toolNames = Object.keys(input.tools).sort();
+  const continuationState = prepareContinuation(
+    input,
+    toolNames,
+    policy.maxToolOutputBytes
+  );
+  if (continuationState.nextInterrupt !== void 0) {
+    return continuationState.nextInterrupt;
+  }
+  const outerToolCallId = input.toolExecutionOptions?.toolCallId ?? input.continuation?.outerToolCallId ?? `code-mode-${++invocationCounter}`;
+  const source = createCodeModeSource(input.js, toolNames);
+  const codeModeErrors = [];
+  const hostFunctions = createHostFunctions({
+    codeModeErrors,
+    input,
+    outerToolCallId,
+    policy,
+    toolNames
+  });
+  const continuationSecurity = resolveCodeModeContinuationSecurity(
+    input.options?.continuationSecurity
+  );
+  const runner = createRunner({
+    continuationAudience: "@ai-sdk/code-mode/v2",
+    continuationCodec: createSignedContinuationCodec({
+      maxAgeMs: continuationSecurity.maxAgeMs,
+      secret: createHash("sha256").update(continuationSecurity.signingKey).digest()
+    })
+  });
+  try {
+    const result = await runner.run({
+      source,
+      hostFunctions,
+      limits: toRunLimits(policy, source, input.js),
+      continuationContext: { outerToolCallId, toolNames },
+      ...input.toolExecutionOptions?.abortSignal === void 0 ? {} : { abortSignal: input.toolExecutionOptions.abortSignal },
+      ...continuationState.token === void 0 ? {} : { continuation: continuationState.token },
+      ...continuationState.resolutions === void 0 ? {} : { resolutions: continuationState.resolutions }
+    });
+    if (result.status === "completed") {
+      return fromJsonPayload(
+        toJsonPayload(result.value, policy.maxResultBytes, "Code mode result")
+      );
+    }
+    const pendingInterruptions = toPendingInterruptions({
+      interruptions: result.interruptions,
+      outerToolCallId,
+      toolNames
+    });
+    const continuation = signCodeModeContinuation(
+      {
+        version: 2,
+        js: input.js,
+        outerToolCallId,
+        toolNames,
+        token: result.continuation,
+        pendingInterruptions,
+        resolutions: []
+      },
+      continuationSecurity
+    );
+    return toCodeModeInterrupt(continuation, 0);
+  } catch (error) {
+    const preserved = findPreservedCodeModeError(error, codeModeErrors);
+    if (preserved !== void 0) {
+      throw translateSourceStack(preserved);
+    }
+    throw translateSourceStack(toCodeModeRuntimeError(error));
+  }
+}
+function resolveExecutionPolicy(policy = {}) {
+  return {
+    timeoutMs: policy.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    memoryLimitBytes: policy.memoryLimitBytes ?? DEFAULT_MEMORY_LIMIT_BYTES,
+    maxStackSizeBytes: policy.maxStackSizeBytes ?? DEFAULT_STACK_LIMIT_BYTES,
+    maxResultBytes: policy.maxResultBytes ?? DEFAULT_MAX_RESULT_BYTES,
+    maxConsoleOutputBytes: policy.maxConsoleOutputBytes ?? DEFAULT_MAX_CONSOLE_OUTPUT_BYTES,
+    maxSourceBytes: policy.maxSourceBytes ?? DEFAULT_MAX_SOURCE_BYTES,
+    maxToolInputBytes: policy.maxToolInputBytes ?? DEFAULT_MAX_TOOL_INPUT_BYTES,
+    maxToolOutputBytes: policy.maxToolOutputBytes ?? DEFAULT_MAX_TOOL_OUTPUT_BYTES,
+    maxBridgeRequests: policy.maxBridgeRequests ?? DEFAULT_MAX_BRIDGE_REQUESTS,
+    maxInFlightBridgeRequests: policy.maxInFlightBridgeRequests ?? DEFAULT_MAX_IN_FLIGHT_BRIDGE_REQUESTS
+  };
+}
+function assertSourceSize(source, maxBytes) {
+  if (!isValidRunLimit(maxBytes)) {
+    return;
+  }
+  const bytes = Buffer.byteLength(source);
+  if (bytes > maxBytes) {
+    throw new CodeModeSourceTooLargeError(bytes, maxBytes);
+  }
+}
+function createCodeModeSource(js, toolNames) {
+  const bindings = Object.fromEntries(
+    toolNames.map((toolName, index) => [toolName, `__codeMode.tool${index}`])
+  );
+  const bindingSource = Object.entries(bindings).map(([name, reference]) => `${JSON.stringify(name)}:${reference}`).join(",");
+  return `const __codeModeBindings={${bindingSource}};const tools=new Proxy(Object.create(null),{get(_target,name){const binding=__codeModeBindings[name];return typeof binding==="function"?(input)=>binding(input):(input)=>__codeMode.missing(String(name),input);}});const __codeModeResult=await(async()=>{
+${js}
+})();if(__codeModeResult===undefined)return undefined;return JSON.parse(JSON.stringify(__codeModeResult));`;
+}
+function createHostFunctions({
+  codeModeErrors,
+  input,
+  outerToolCallId,
+  policy,
+  toolNames
+}) {
+  const group = {};
+  for (const [index, toolName] of toolNames.entries()) {
+    group[`tool${index}`] = async (toolInput) => await invokeCodeModeTool({
+      codeModeErrors,
+      input,
+      outerToolCallId,
+      policy,
+      toolInput,
+      toolName
+    });
+  }
+  group.missing = async (toolName, toolInput) => await invokeCodeModeTool({
+    codeModeErrors,
+    input,
+    outerToolCallId,
+    policy,
+    toolInput,
+    toolName: String(toolName)
+  });
+  return { __codeMode: group };
+}
+async function invokeCodeModeTool({
+  codeModeErrors,
+  input,
+  outerToolCallId,
+  policy,
+  toolInput,
+  toolName
+}) {
+  const context = getHostFunctionContext();
+  const toolCallId = `${outerToolCallId}:tool-${context.requestIndex}`;
+  const forwardedContext = input.toolExecutionOptions?.context ?? input.toolExecutionOptions?.experimental_context;
+  const forwardedExperimentalContext = input.toolExecutionOptions?.experimental_context ?? input.toolExecutionOptions?.context;
+  const baseExecutionOptions = {
+    toolCallId: outerToolCallId,
+    messages: input.toolExecutionOptions?.messages ?? [],
+    abortSignal: context.abortSignal,
+    ...forwardedContext === void 0 ? {} : { context: forwardedContext },
+    ...forwardedExperimentalContext === void 0 ? {} : { experimental_context: forwardedExperimentalContext }
+  };
+  let codeModeInterrupt;
+  let skipApproval = false;
+  if (context.resume !== void 0) {
+    const payload = assertInterruptPayload(context.resume.payload);
+    if (isCodeModeApprovalInterruptPayload(payload)) {
+      const decision = normalizeApprovalResolution(context.resume.resolution);
+      if (!decision.approved) {
+        throw new CodeModeToolApprovalDeniedError(
+          toolName,
+          toolInput,
+          toolCallId,
+          decision.reason
+        );
+      }
+      skipApproval = true;
+    } else {
+      codeModeInterrupt = {
+        interruptId: `${toolCallId}:interrupt`,
+        payload,
+        resolution: context.resume.resolution
+      };
+    }
+  }
+  try {
+    const inputJson = toJsonPayload(
+      toolInput,
+      policy.maxToolInputBytes,
+      `Tool "${toolName}" input`
+    );
+    const outcome = await invokeHostTool({
+      toolName,
+      inputJson,
+      tools: input.tools,
+      baseExecutionOptions,
+      codeModeOptions: input.options ?? {},
+      maxToolInputBytes: policy.maxToolInputBytes,
+      maxToolOutputBytes: policy.maxToolOutputBytes,
+      toolCallId,
+      ...codeModeInterrupt === void 0 ? {} : { codeModeInterrupt },
+      skipApproval
+    });
+    if (outcome.type === "interrupted") {
+      return context.interrupt(outcome.payload);
+    }
+    return fromJsonPayload(outcome.valueJson);
+  } catch (error) {
+    if (error instanceof CodeModeError) {
+      codeModeErrors.push(error);
+      throw new RunError(error.message, error.code, error.details);
+    }
+    if (RunError.isInstance(error) || error instanceof Error && error.name === "HostFunctionInterruptSignal") {
+      throw error;
+    }
+    throw new RunError("Host tool failed.", "CODE_MODE_HOST_TOOL_ERROR");
+  }
+}
+function assertInterruptPayload(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || typeof value.kind !== "string") {
+    throw new CodeModeProtocolError(
+      "Code mode interruption payload is malformed."
+    );
+  }
+  return value;
+}
+function toRunLimits(policy, source, userSource) {
+  return {
+    timeoutMs: policy.timeoutMs,
+    memoryLimitBytes: policy.memoryLimitBytes,
+    maxStackSizeBytes: policy.maxStackSizeBytes,
+    maxResultBytes: expandedSerializationLimit(policy.maxResultBytes),
+    maxConsoleOutputBytes: policy.maxConsoleOutputBytes,
+    maxSourceBytes: withSerializationOverhead(
+      policy.maxSourceBytes,
+      Buffer.byteLength(source) - Buffer.byteLength(userSource)
+    ),
+    maxHostFunctionArgumentsBytes: expandedSerializationLimit(
+      policy.maxToolInputBytes
+    ),
+    maxHostFunctionOutputBytes: expandedSerializationLimit(
+      policy.maxToolOutputBytes
+    ),
+    maxBridgeRequests: policy.maxBridgeRequests,
+    maxInFlightBridgeRequests: policy.maxInFlightBridgeRequests
+  };
+}
+function expandedSerializationLimit(value) {
+  if (!isValidRunLimit(value)) {
+    return value;
+  }
+  return Math.min(MAX_RUN_LIMIT, Math.max(4096, value * 2 + 1024));
+}
+function withSerializationOverhead(value, overhead) {
+  return isValidRunLimit(value) ? Math.min(MAX_RUN_LIMIT, value + overhead) : value;
+}
+function isValidRunLimit(value) {
+  return Number.isInteger(value) && value > 0 && value <= MAX_RUN_LIMIT;
+}
+function prepareContinuation(input, toolNames, maxToolOutputBytes) {
+  if (input.continuation === void 0) {
+    if (input.interruptResolution !== void 0) {
+      throw new CodeModeProtocolError(
+        "A code-mode interrupt resolution was provided without continuation state."
+      );
+    }
+    return {};
+  }
+  verifyCodeModeContinuation(
+    input.continuation,
+    input.options?.continuationSecurity
+  );
+  if (input.continuation.js !== input.js) {
+    throw new CodeModeProtocolError(
+      "Code mode continuation source does not match the resumed source."
+    );
+  }
+  if (!stringArraysEqual(input.continuation.toolNames, toolNames)) {
+    throw new CodeModeProtocolError(
+      "Code mode continuation tool names do not match the resumed tools."
+    );
+  }
+  if (input.interruptResolution === void 0) {
+    throw new CodeModeProtocolError(
+      "A code-mode continuation requires an interrupt resolution."
+    );
+  }
+  const resolutionIndex = input.continuation.resolutions.length;
+  const pending = input.continuation.pendingInterruptions[resolutionIndex];
+  if (pending === void 0 || pending.interruptId !== input.interruptResolution.interruptId) {
+    throw new CodeModeProtocolError(
+      "Interrupt resolution does not match the next pending code-mode interruption.",
+      { interruptId: input.interruptResolution.interruptId }
+    );
+  }
+  const resolutionValue = normalizeResolutionForPending(
+    pending,
+    input.interruptResolution.resolution,
+    maxToolOutputBytes
+  );
+  const resolutions = [
+    ...input.continuation.resolutions,
+    {
+      runInterruptionId: pending.runInterruptionId,
+      value: resolutionValue
+    }
+  ];
+  if (resolutions.length < input.continuation.pendingInterruptions.length) {
+    const continuation = signCodeModeContinuation(
+      {
+        ...withoutAuth(input.continuation),
+        resolutions
+      },
+      resolveCodeModeContinuationSecurity(input.options?.continuationSecurity)
+    );
+    return {
+      nextInterrupt: toCodeModeInterrupt(continuation, resolutions.length)
+    };
+  }
+  assertNoDeniedApproval(input.continuation.pendingInterruptions, resolutions);
+  return {
+    token: input.continuation.token,
+    resolutions: resolutions.map((resolution) => ({
+      interruptionId: resolution.runInterruptionId,
+      value: resolution.value
+    }))
+  };
+}
+function normalizeResolutionForPending(pending, resolution, maxToolOutputBytes) {
+  return isCodeModeApprovalInterruptPayload(pending.payload) ? normalizeApprovalResolution(resolution) : fromJsonPayload(
+    toJsonPayload(
+      resolution,
+      maxToolOutputBytes,
+      `Resolution "${pending.interruptId}"`
+    )
+  );
+}
+function assertNoDeniedApproval(pendingInterruptions, resolutions) {
+  for (const [index, pending] of pendingInterruptions.entries()) {
+    if (!isCodeModeApprovalInterruptPayload(pending.payload)) {
+      continue;
+    }
+    const decision = normalizeApprovalResolution(resolutions[index]?.value);
+    if (!decision.approved) {
+      throw new CodeModeToolApprovalDeniedError(
+        pending.toolName,
+        pending.input,
+        pending.toolCallId,
+        decision.reason
+      );
+    }
+  }
+}
+function withoutAuth(continuation) {
+  const { auth: _auth, ...unsigned } = continuation;
+  return unsigned;
+}
+function toPendingInterruptions({
+  interruptions,
+  outerToolCallId,
+  toolNames
+}) {
+  return interruptions.map((interruption) => {
+    const requestIndex = interruptionIndex(interruption.id);
+    const toolName = toolNameForInterruption(interruption, toolNames);
+    const toolCallId = `${outerToolCallId}:tool-${requestIndex}`;
+    return {
+      runInterruptionId: interruption.id,
+      interruptId: `${toolCallId}:interrupt`,
+      toolName,
+      toolCallId,
+      input: interruption.hostFunctionName === "__codeMode.missing" ? interruption.arguments[1] : interruption.arguments[0],
+      payload: assertInterruptPayload(interruption.payload)
+    };
+  });
+}
+function interruptionIndex(interruptionId) {
+  const match = /^interrupt-(\d+)$/u.exec(interruptionId);
+  if (match === null) {
+    throw new CodeModeProtocolError(
+      `Run returned malformed interruption id "${interruptionId}".`
+    );
+  }
+  return Number(match[1]);
+}
+function toolNameForInterruption(interruption, toolNames) {
+  if (interruption.hostFunctionName === "__codeMode.missing") {
+    return String(interruption.arguments[0]);
+  }
+  const match = /^__codeMode\.tool(\d+)$/u.exec(interruption.hostFunctionName);
+  const toolName = match === null ? void 0 : toolNames[Number(match[1])];
+  if (toolName === void 0) {
+    throw new CodeModeProtocolError(
+      `Run returned an unknown code-mode host function "${interruption.hostFunctionName}".`
+    );
+  }
+  return toolName;
+}
+function toCodeModeInterrupt(continuation, index) {
+  const pending = continuation.pendingInterruptions[index];
+  if (pending === void 0) {
+    throw new CodeModeProtocolError(
+      "Code mode continuation has no pending interruption at the requested index."
+    );
+  }
+  return {
+    type: "code-mode-interrupt",
+    interruptId: pending.interruptId,
+    toolName: pending.toolName,
+    toolCallId: pending.toolCallId,
+    outerToolCallId: continuation.outerToolCallId,
+    input: structuredClone(pending.input),
+    payload: structuredClone(pending.payload),
+    continuation
+  };
+}
+function stringArraysEqual(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function findPreservedCodeModeError(error, errors) {
+  if (!RunError.isInstance(error)) {
+    return void 0;
+  }
+  return errors.find((candidate) => candidate.code === error.code);
+}
+function toCodeModeRuntimeError(error) {
+  if (error instanceof TypeError) {
+    error.message = translateLimitPath(error.message);
+  }
+  if (error instanceof Error && error.name === "SyntaxError" && !/syntax|unexpected|expression expected/iu.test(error.message)) {
+    error.message = `Syntax error: ${error.message}`;
+  }
+  if (!RunError.isInstance(error)) {
+    return error;
+  }
+  const details = error.details;
+  switch (error.code) {
+    case "RUN_ABORTED":
+      return copyStack(new CodeModeAbortedError(), error);
+    case "RUN_TIMEOUT":
+      return copyStack(
+        new CodeModeTimeoutError(Number(details?.timeoutMs ?? 0)),
+        error
+      );
+    case "RUN_CONCURRENCY_LIMIT":
+      return copyStack(
+        new CodeModeConcurrencyError(Number(details?.maxWorkers ?? 0)),
+        error
+      );
+    case "RUN_SOURCE_TOO_LARGE":
+      return copyStack(
+        new CodeModeSourceTooLargeError(
+          Number(details?.bytes ?? 0),
+          Number(details?.maxBytes ?? 0)
+        ),
+        error
+      );
+    case "RUN_BRIDGE_LIMIT":
+      return copyStack(
+        new CodeModeBridgeLimitError(error.message, error.details),
+        error
+      );
+    case "RUN_DETACHED_BRIDGE_REQUEST":
+      return copyStack(
+        new CodeModeDetachedBridgeRequestError(error.message, error.details),
+        error
+      );
+    case "RUN_PROTOCOL_ERROR":
+      return copyStack(
+        new CodeModeProtocolError(error.message, error.details),
+        error
+      );
+    default:
+      return error;
+  }
+}
+function translateLimitPath(message) {
+  const paths = {
+    "limits.timeoutMs": "executionPolicy.timeoutMs",
+    "limits.memoryLimitBytes": "executionPolicy.memoryLimitBytes",
+    "limits.maxStackSizeBytes": "executionPolicy.maxStackSizeBytes",
+    "limits.maxResultBytes": "executionPolicy.maxResultBytes",
+    "limits.maxConsoleOutputBytes": "executionPolicy.maxConsoleOutputBytes",
+    "limits.maxSourceBytes": "executionPolicy.maxSourceBytes",
+    "limits.maxHostFunctionArgumentsBytes": "executionPolicy.maxToolInputBytes",
+    "limits.maxHostFunctionOutputBytes": "executionPolicy.maxToolOutputBytes",
+    "limits.maxBridgeRequests": "executionPolicy.maxBridgeRequests",
+    "limits.maxInFlightBridgeRequests": "executionPolicy.maxInFlightBridgeRequests"
+  };
+  for (const [runPath, codeModePath] of Object.entries(paths)) {
+    if (message.includes(runPath)) {
+      return message.replace(runPath, codeModePath);
+    }
+  }
+  return message;
+}
+function copyStack(target, source) {
+  if (source.stack !== void 0) {
+    target.stack = source.stack;
+  }
+  return target;
+}
+function translateSourceStack(error) {
+  if (!(error instanceof Error) || error.stack === void 0) {
+    return error;
+  }
+  error.stack = error.stack.replaceAll(
+    /run\.js:(\d+):(\d+)/gu,
+    (_match, line, column) => `code-mode.js:${Math.max(1, Number(line) - SOURCE_LINE_OFFSET)}:${column}`
+  );
+  return error;
 }
 export {
   runCodeMode

package/dist/run-code-mode.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/run-code-mode.ts"],"sourcesContent":["import { runManagedCodeMode } from './runtime/manager.js';\nimport type { RunCodeModeInput } from './types.js';\n\n/**\n * Runs one code-mode invocation directly without wrapping it as an AI SDK tool.\n *\n * The source is executed in a fresh QuickJS context with the provided host tools\n * and execution limits.\n *\n * @param input - Source code, host tools, forwarded tool execution options, and code-mode options.\n * @returns The JSON-serializable value returned by the sandboxed program.\n */\nexport async function runCodeMode(input: RunCodeModeInput): Promise<unknown> {\n  return await runManagedCodeMode(input);\n}\n"],"mappings":"AAAA,SAAS,0BAA0B;AAYnC,eAAsB,YAAY,OAA2C;AAC3E,SAAO,MAAM,mBAAmB,KAAK;AACvC;","names":[]}
+{"version":3,"sources":["../src/run-code-mode.ts"],"sourcesContent":["import { Buffer } from 'node:buffer';\nimport { createHash } from 'node:crypto';\nimport {\n  createRunner,\n  createSignedContinuationCodec,\n  getHostFunctionContext,\n  RunError,\n  type HostFunctions,\n  type RunInterruption,\n  type RunLimits,\n  type RunResolution,\n} from 'run';\nimport {\n  isCodeModeApprovalInterruptPayload,\n  normalizeApprovalResolution,\n} from './approval.js';\nimport {\n  resolveCodeModeContinuationSecurity,\n  signCodeModeContinuation,\n  verifyCodeModeContinuation,\n} from './continuation-capability.js';\nimport {\n  CodeModeAbortedError,\n  CodeModeBridgeLimitError,\n  CodeModeConcurrencyError,\n  CodeModeDetachedBridgeRequestError,\n  CodeModeError,\n  CodeModeProtocolError,\n  CodeModeSourceTooLargeError,\n  CodeModeTimeoutError,\n  CodeModeToolApprovalDeniedError,\n} from './errors.js';\nimport { invokeHostTool } from './tool-invocation.js';\nimport type {\n  CodeModeContinuation,\n  CodeModeExecutionPolicy,\n  CodeModeInterrupt,\n  CodeModeInterruptExecutionContext,\n  CodeModeInterruptPayload,\n  CodeModePendingInterruption,\n  CodeModePendingResolution,\n  CodeModeToolExecutionOptions,\n  RunCodeModeInput,\n} from './types.js';\nimport { fromJsonPayload, toJsonPayload } from './utils/serialization.js';\n\nconst SOURCE_LINE_OFFSET = 1;\nconst MAX_RUN_LIMIT = 2_147_483_647;\nconst DEFAULT_TIMEOUT_MS = 30_000;\nconst DEFAULT_MEMORY_LIMIT_BYTES = 64 * 1024 * 1024;\nconst DEFAULT_STACK_LIMIT_BYTES = 2 * 1024 * 1024;\nconst DEFAULT_MAX_RESULT_BYTES = 1024 * 1024;\nconst DEFAULT_MAX_CONSOLE_OUTPUT_BYTES = 64 * 1024;\nconst DEFAULT_MAX_SOURCE_BYTES = 256 * 1024;\nconst DEFAULT_MAX_TOOL_INPUT_BYTES = 1024 * 1024;\nconst DEFAULT_MAX_TOOL_OUTPUT_BYTES = 4 * 1024 * 1024;\nconst DEFAULT_MAX_BRIDGE_REQUESTS = 256;\nconst DEFAULT_MAX_IN_FLIGHT_BRIDGE_REQUESTS = 32;\n\nlet invocationCounter = 0;\n\n/**\n * Runs one code-mode invocation directly without wrapping it as an AI SDK tool.\n *\n * The source is executed in a fresh QuickJS context with the provided host tools\n * and execution limits.\n *\n * @param input - Source code, host tools, forwarded tool execution options, and code-mode options.\n * @returns The JSON-serializable value returned by the sandboxed program.\n */\nexport async function runCodeMode(input: RunCodeModeInput): Promise<unknown> {\n  const policy = resolveExecutionPolicy(input.options?.executionPolicy);\n  assertSourceSize(input.js, policy.maxSourceBytes);\n\n  const toolNames = Object.keys(input.tools).sort();\n  const continuationState = prepareContinuation(\n    input,\n    toolNames,\n    policy.maxToolOutputBytes,\n  );\n  if (continuationState.nextInterrupt !== undefined) {\n    return continuationState.nextInterrupt;\n  }\n\n  const outerToolCallId =\n    input.toolExecutionOptions?.toolCallId ??\n    input.continuation?.outerToolCallId ??\n    `code-mode-${++invocationCounter}`;\n  const source = createCodeModeSource(input.js, toolNames);\n  const codeModeErrors: CodeModeError[] = [];\n  const hostFunctions = createHostFunctions({\n    codeModeErrors,\n    input,\n    outerToolCallId,\n    policy,\n    toolNames,\n  });\n  const continuationSecurity = resolveCodeModeContinuationSecurity(\n    input.options?.continuationSecurity,\n  );\n  const runner = createRunner({\n    continuationAudience: '@ai-sdk/code-mode/v2',\n    continuationCodec: createSignedContinuationCodec({\n      maxAgeMs: continuationSecurity.maxAgeMs,\n      secret: createHash('sha256')\n        .update(continuationSecurity.signingKey)\n        .digest(),\n    }),\n  });\n\n  try {\n    const result = await runner.run({\n      source,\n      hostFunctions,\n      limits: toRunLimits(policy, source, input.js),\n      continuationContext: { outerToolCallId, toolNames },\n      ...(input.toolExecutionOptions?.abortSignal === undefined\n        ? {}\n        : { abortSignal: input.toolExecutionOptions.abortSignal }),\n      ...(continuationState.token === undefined\n        ? {}\n        : { continuation: continuationState.token }),\n      ...(continuationState.resolutions === undefined\n        ? {}\n        : { resolutions: continuationState.resolutions }),\n    });\n\n    if (result.status === 'completed') {\n      return fromJsonPayload(\n        toJsonPayload(result.value, policy.maxResultBytes, 'Code mode result'),\n      );\n    }\n\n    const pendingInterruptions = toPendingInterruptions({\n      interruptions: result.interruptions,\n      outerToolCallId,\n      toolNames,\n    });\n    const continuation = signCodeModeContinuation(\n      {\n        version: 2,\n        js: input.js,\n        outerToolCallId,\n        toolNames,\n        token: result.continuation,\n        pendingInterruptions,\n        resolutions: [],\n      },\n      continuationSecurity,\n    );\n    return toCodeModeInterrupt(continuation, 0);\n  } catch (error) {\n    const preserved = findPreservedCodeModeError(error, codeModeErrors);\n    if (preserved !== undefined) {\n      throw translateSourceStack(preserved);\n    }\n    throw translateSourceStack(toCodeModeRuntimeError(error));\n  }\n}\n\ninterface ResolvedExecutionPolicy {\n  timeoutMs: number;\n  memoryLimitBytes: number;\n  maxStackSizeBytes: number;\n  maxResultBytes: number;\n  maxConsoleOutputBytes: number;\n  maxSourceBytes: number;\n  maxToolInputBytes: number;\n  maxToolOutputBytes: number;\n  maxBridgeRequests: number;\n  maxInFlightBridgeRequests: number;\n}\n\nfunction resolveExecutionPolicy(\n  policy: CodeModeExecutionPolicy = {},\n): ResolvedExecutionPolicy {\n  return {\n    timeoutMs: policy.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n    memoryLimitBytes: policy.memoryLimitBytes ?? DEFAULT_MEMORY_LIMIT_BYTES,\n    maxStackSizeBytes: policy.maxStackSizeBytes ?? DEFAULT_STACK_LIMIT_BYTES,\n    maxResultBytes: policy.maxResultBytes ?? DEFAULT_MAX_RESULT_BYTES,\n    maxConsoleOutputBytes:\n      policy.maxConsoleOutputBytes ?? DEFAULT_MAX_CONSOLE_OUTPUT_BYTES,\n    maxSourceBytes: policy.maxSourceBytes ?? DEFAULT_MAX_SOURCE_BYTES,\n    maxToolInputBytes: policy.maxToolInputBytes ?? DEFAULT_MAX_TOOL_INPUT_BYTES,\n    maxToolOutputBytes:\n      policy.maxToolOutputBytes ?? DEFAULT_MAX_TOOL_OUTPUT_BYTES,\n    maxBridgeRequests: policy.maxBridgeRequests ?? DEFAULT_MAX_BRIDGE_REQUESTS,\n    maxInFlightBridgeRequests:\n      policy.maxInFlightBridgeRequests ?? DEFAULT_MAX_IN_FLIGHT_BRIDGE_REQUESTS,\n  };\n}\n\nfunction assertSourceSize(source: string, maxBytes: number): void {\n  if (!isValidRunLimit(maxBytes)) {\n    return;\n  }\n  const bytes = Buffer.byteLength(source);\n  if (bytes > maxBytes) {\n    throw new CodeModeSourceTooLargeError(bytes, maxBytes);\n  }\n}\n\nfunction createCodeModeSource(js: string, toolNames: string[]): string {\n  const bindings = Object.fromEntries(\n    toolNames.map((toolName, index) => [toolName, `__codeMode.tool${index}`]),\n  );\n  const bindingSource = Object.entries(bindings)\n    .map(([name, reference]) => `${JSON.stringify(name)}:${reference}`)\n    .join(',');\n  return `const __codeModeBindings={${bindingSource}};const tools=new Proxy(Object.create(null),{get(_target,name){const binding=__codeModeBindings[name];return typeof binding===\"function\"?(input)=>binding(input):(input)=>__codeMode.missing(String(name),input);}});const __codeModeResult=await(async()=>{\\n${js}\\n})();if(__codeModeResult===undefined)return undefined;return JSON.parse(JSON.stringify(__codeModeResult));`;\n}\n\nfunction createHostFunctions({\n  codeModeErrors,\n  input,\n  outerToolCallId,\n  policy,\n  toolNames,\n}: {\n  codeModeErrors: CodeModeError[];\n  input: RunCodeModeInput;\n  outerToolCallId: string;\n  policy: ResolvedExecutionPolicy;\n  toolNames: string[];\n}): HostFunctions {\n  const group: Record<string, (...args: unknown[]) => Promise<unknown>> = {};\n  for (const [index, toolName] of toolNames.entries()) {\n    group[`tool${index}`] = async (toolInput: unknown) =>\n      await invokeCodeModeTool({\n        codeModeErrors,\n        input,\n        outerToolCallId,\n        policy,\n        toolInput,\n        toolName,\n      });\n  }\n  group.missing = async (toolName: unknown, toolInput: unknown) =>\n    await invokeCodeModeTool({\n      codeModeErrors,\n      input,\n      outerToolCallId,\n      policy,\n      toolInput,\n      toolName: String(toolName),\n    });\n  return { __codeMode: group } as HostFunctions;\n}\n\nasync function invokeCodeModeTool({\n  codeModeErrors,\n  input,\n  outerToolCallId,\n  policy,\n  toolInput,\n  toolName,\n}: {\n  codeModeErrors: CodeModeError[];\n  input: RunCodeModeInput;\n  outerToolCallId: string;\n  policy: ResolvedExecutionPolicy;\n  toolInput: unknown;\n  toolName: string;\n}): Promise<unknown> {\n  const context = getHostFunctionContext();\n  const toolCallId = `${outerToolCallId}:tool-${context.requestIndex}`;\n  const forwardedContext =\n    input.toolExecutionOptions?.context ??\n    input.toolExecutionOptions?.experimental_context;\n  const forwardedExperimentalContext =\n    input.toolExecutionOptions?.experimental_context ??\n    input.toolExecutionOptions?.context;\n  const baseExecutionOptions: CodeModeToolExecutionOptions = {\n    toolCallId: outerToolCallId,\n    messages: input.toolExecutionOptions?.messages ?? [],\n    abortSignal: context.abortSignal,\n    ...(forwardedContext === undefined ? {} : { context: forwardedContext }),\n    ...(forwardedExperimentalContext === undefined\n      ? {}\n      : { experimental_context: forwardedExperimentalContext }),\n  };\n\n  let codeModeInterrupt: CodeModeInterruptExecutionContext | undefined;\n  let skipApproval = false;\n  if (context.resume !== undefined) {\n    const payload = assertInterruptPayload(context.resume.payload);\n    if (isCodeModeApprovalInterruptPayload(payload)) {\n      const decision = normalizeApprovalResolution(context.resume.resolution);\n      if (!decision.approved) {\n        throw new CodeModeToolApprovalDeniedError(\n          toolName,\n          toolInput,\n          toolCallId,\n          decision.reason,\n        );\n      }\n      skipApproval = true;\n    } else {\n      codeModeInterrupt = {\n        interruptId: `${toolCallId}:interrupt`,\n        payload,\n        resolution: context.resume.resolution,\n      };\n    }\n  }\n\n  try {\n    const inputJson = toJsonPayload(\n      toolInput,\n      policy.maxToolInputBytes,\n      `Tool \"${toolName}\" input`,\n    );\n    const outcome = await invokeHostTool({\n      toolName,\n      inputJson,\n      tools: input.tools,\n      baseExecutionOptions,\n      codeModeOptions: input.options ?? {},\n      maxToolInputBytes: policy.maxToolInputBytes,\n      maxToolOutputBytes: policy.maxToolOutputBytes,\n      toolCallId,\n      ...(codeModeInterrupt === undefined ? {} : { codeModeInterrupt }),\n      skipApproval,\n    });\n    if (outcome.type === 'interrupted') {\n      return context.interrupt(outcome.payload);\n    }\n    return fromJsonPayload(outcome.valueJson);\n  } catch (error) {\n    if (error instanceof CodeModeError) {\n      codeModeErrors.push(error);\n      throw new RunError(error.message, error.code, error.details);\n    }\n    if (\n      RunError.isInstance(error) ||\n      (error instanceof Error && error.name === 'HostFunctionInterruptSignal')\n    ) {\n      throw error;\n    }\n    throw new RunError('Host tool failed.', 'CODE_MODE_HOST_TOOL_ERROR');\n  }\n}\n\nfunction assertInterruptPayload(value: unknown): CodeModeInterruptPayload {\n  if (\n    typeof value !== 'object' ||\n    value === null ||\n    Array.isArray(value) ||\n    typeof (value as { kind?: unknown }).kind !== 'string'\n  ) {\n    throw new CodeModeProtocolError(\n      'Code mode interruption payload is malformed.',\n    );\n  }\n  return value as CodeModeInterruptPayload;\n}\n\nfunction toRunLimits(\n  policy: ResolvedExecutionPolicy,\n  source: string,\n  userSource: string,\n): RunLimits {\n  return {\n    timeoutMs: policy.timeoutMs,\n    memoryLimitBytes: policy.memoryLimitBytes,\n    maxStackSizeBytes: policy.maxStackSizeBytes,\n    maxResultBytes: expandedSerializationLimit(policy.maxResultBytes),\n    maxConsoleOutputBytes: policy.maxConsoleOutputBytes,\n    maxSourceBytes: withSerializationOverhead(\n      policy.maxSourceBytes,\n      Buffer.byteLength(source) - Buffer.byteLength(userSource),\n    ),\n    maxHostFunctionArgumentsBytes: expandedSerializationLimit(\n      policy.maxToolInputBytes,\n    ),\n    maxHostFunctionOutputBytes: expandedSerializationLimit(\n      policy.maxToolOutputBytes,\n    ),\n    maxBridgeRequests: policy.maxBridgeRequests,\n    maxInFlightBridgeRequests: policy.maxInFlightBridgeRequests,\n  };\n}\n\nfunction expandedSerializationLimit(value: number): number {\n  if (!isValidRunLimit(value)) {\n    return value;\n  }\n  return Math.min(MAX_RUN_LIMIT, Math.max(4096, value * 2 + 1024));\n}\n\nfunction withSerializationOverhead(value: number, overhead: number): number {\n  return isValidRunLimit(value)\n    ? Math.min(MAX_RUN_LIMIT, value + overhead)\n    : value;\n}\n\nfunction isValidRunLimit(value: number): boolean {\n  return Number.isInteger(value) && value > 0 && value <= MAX_RUN_LIMIT;\n}\n\nfunction prepareContinuation(\n  input: RunCodeModeInput,\n  toolNames: string[],\n  maxToolOutputBytes: number,\n): {\n  token?: string;\n  resolutions?: RunResolution[];\n  nextInterrupt?: CodeModeInterrupt;\n} {\n  if (input.continuation === undefined) {\n    if (input.interruptResolution !== undefined) {\n      throw new CodeModeProtocolError(\n        'A code-mode interrupt resolution was provided without continuation state.',\n      );\n    }\n    return {};\n  }\n\n  verifyCodeModeContinuation(\n    input.continuation,\n    input.options?.continuationSecurity,\n  );\n  if (input.continuation.js !== input.js) {\n    throw new CodeModeProtocolError(\n      'Code mode continuation source does not match the resumed source.',\n    );\n  }\n  if (!stringArraysEqual(input.continuation.toolNames, toolNames)) {\n    throw new CodeModeProtocolError(\n      'Code mode continuation tool names do not match the resumed tools.',\n    );\n  }\n  if (input.interruptResolution === undefined) {\n    throw new CodeModeProtocolError(\n      'A code-mode continuation requires an interrupt resolution.',\n    );\n  }\n\n  const resolutionIndex = input.continuation.resolutions.length;\n  const pending = input.continuation.pendingInterruptions[resolutionIndex];\n  if (\n    pending === undefined ||\n    pending.interruptId !== input.interruptResolution.interruptId\n  ) {\n    throw new CodeModeProtocolError(\n      'Interrupt resolution does not match the next pending code-mode interruption.',\n      { interruptId: input.interruptResolution.interruptId },\n    );\n  }\n  const resolutionValue = normalizeResolutionForPending(\n    pending,\n    input.interruptResolution.resolution,\n    maxToolOutputBytes,\n  );\n  const resolutions: CodeModePendingResolution[] = [\n    ...input.continuation.resolutions,\n    {\n      runInterruptionId: pending.runInterruptionId,\n      value: resolutionValue,\n    },\n  ];\n\n  if (resolutions.length < input.continuation.pendingInterruptions.length) {\n    const continuation = signCodeModeContinuation(\n      {\n        ...withoutAuth(input.continuation),\n        resolutions,\n      },\n      resolveCodeModeContinuationSecurity(input.options?.continuationSecurity),\n    );\n    return {\n      nextInterrupt: toCodeModeInterrupt(continuation, resolutions.length),\n    };\n  }\n\n  assertNoDeniedApproval(input.continuation.pendingInterruptions, resolutions);\n  return {\n    token: input.continuation.token,\n    resolutions: resolutions.map(resolution => ({\n      interruptionId: resolution.runInterruptionId,\n      value: resolution.value,\n    })),\n  };\n}\n\nfunction normalizeResolutionForPending(\n  pending: CodeModePendingInterruption,\n  resolution: unknown,\n  maxToolOutputBytes: number,\n): unknown {\n  return isCodeModeApprovalInterruptPayload(pending.payload)\n    ? normalizeApprovalResolution(resolution)\n    : fromJsonPayload(\n        toJsonPayload(\n          resolution,\n          maxToolOutputBytes,\n          `Resolution \"${pending.interruptId}\"`,\n        ),\n      );\n}\n\nfunction assertNoDeniedApproval(\n  pendingInterruptions: CodeModePendingInterruption[],\n  resolutions: CodeModePendingResolution[],\n): void {\n  for (const [index, pending] of pendingInterruptions.entries()) {\n    if (!isCodeModeApprovalInterruptPayload(pending.payload)) {\n      continue;\n    }\n    const decision = normalizeApprovalResolution(resolutions[index]?.value);\n    if (!decision.approved) {\n      throw new CodeModeToolApprovalDeniedError(\n        pending.toolName,\n        pending.input,\n        pending.toolCallId,\n        decision.reason,\n      );\n    }\n  }\n}\n\nfunction withoutAuth(\n  continuation: CodeModeContinuation,\n): Omit<CodeModeContinuation, 'auth'> {\n  const { auth: _auth, ...unsigned } = continuation;\n  return unsigned;\n}\n\nfunction toPendingInterruptions({\n  interruptions,\n  outerToolCallId,\n  toolNames,\n}: {\n  interruptions: RunInterruption[];\n  outerToolCallId: string;\n  toolNames: string[];\n}): CodeModePendingInterruption[] {\n  return interruptions.map(interruption => {\n    const requestIndex = interruptionIndex(interruption.id);\n    const toolName = toolNameForInterruption(interruption, toolNames);\n    const toolCallId = `${outerToolCallId}:tool-${requestIndex}`;\n    return {\n      runInterruptionId: interruption.id,\n      interruptId: `${toolCallId}:interrupt`,\n      toolName,\n      toolCallId,\n      input:\n        interruption.hostFunctionName === '__codeMode.missing'\n          ? interruption.arguments[1]\n          : interruption.arguments[0],\n      payload: assertInterruptPayload(interruption.payload),\n    };\n  });\n}\n\nfunction interruptionIndex(interruptionId: string): number {\n  const match = /^interrupt-(\\d+)$/u.exec(interruptionId);\n  if (match === null) {\n    throw new CodeModeProtocolError(\n      `Run returned malformed interruption id \"${interruptionId}\".`,\n    );\n  }\n  return Number(match[1]);\n}\n\nfunction toolNameForInterruption(\n  interruption: RunInterruption,\n  toolNames: string[],\n): string {\n  if (interruption.hostFunctionName === '__codeMode.missing') {\n    return String(interruption.arguments[0]);\n  }\n  const match = /^__codeMode\\.tool(\\d+)$/u.exec(interruption.hostFunctionName);\n  const toolName = match === null ? undefined : toolNames[Number(match[1])];\n  if (toolName === undefined) {\n    throw new CodeModeProtocolError(\n      `Run returned an unknown code-mode host function \"${interruption.hostFunctionName}\".`,\n    );\n  }\n  return toolName;\n}\n\nfunction toCodeModeInterrupt(\n  continuation: CodeModeContinuation,\n  index: number,\n): CodeModeInterrupt {\n  const pending = continuation.pendingInterruptions[index];\n  if (pending === undefined) {\n    throw new CodeModeProtocolError(\n      'Code mode continuation has no pending interruption at the requested index.',\n    );\n  }\n  return {\n    type: 'code-mode-interrupt',\n    interruptId: pending.interruptId,\n    toolName: pending.toolName,\n    toolCallId: pending.toolCallId,\n    outerToolCallId: continuation.outerToolCallId,\n    input: structuredClone(pending.input),\n    payload: structuredClone(pending.payload),\n    continuation,\n  };\n}\n\nfunction stringArraysEqual(left: string[], right: string[]): boolean {\n  return (\n    left.length === right.length &&\n    left.every((value, index) => value === right[index])\n  );\n}\n\nfunction findPreservedCodeModeError(\n  error: unknown,\n  errors: CodeModeError[],\n): CodeModeError | undefined {\n  if (!RunError.isInstance(error)) {\n    return undefined;\n  }\n  return errors.find(candidate => candidate.code === error.code);\n}\n\nfunction toCodeModeRuntimeError(error: unknown): unknown {\n  if (error instanceof TypeError) {\n    error.message = translateLimitPath(error.message);\n  }\n  if (\n    error instanceof Error &&\n    error.name === 'SyntaxError' &&\n    !/syntax|unexpected|expression expected/iu.test(error.message)\n  ) {\n    error.message = `Syntax error: ${error.message}`;\n  }\n  if (!RunError.isInstance(error)) {\n    return error;\n  }\n  const details = error.details as Record<string, unknown> | undefined;\n  switch (error.code) {\n    case 'RUN_ABORTED':\n      return copyStack(new CodeModeAbortedError(), error);\n    case 'RUN_TIMEOUT':\n      return copyStack(\n        new CodeModeTimeoutError(Number(details?.timeoutMs ?? 0)),\n        error,\n      );\n    case 'RUN_CONCURRENCY_LIMIT':\n      return copyStack(\n        new CodeModeConcurrencyError(Number(details?.maxWorkers ?? 0)),\n        error,\n      );\n    case 'RUN_SOURCE_TOO_LARGE':\n      return copyStack(\n        new CodeModeSourceTooLargeError(\n          Number(details?.bytes ?? 0),\n          Number(details?.maxBytes ?? 0),\n        ),\n        error,\n      );\n    case 'RUN_BRIDGE_LIMIT':\n      return copyStack(\n        new CodeModeBridgeLimitError(error.message, error.details),\n        error,\n      );\n    case 'RUN_DETACHED_BRIDGE_REQUEST':\n      return copyStack(\n        new CodeModeDetachedBridgeRequestError(error.message, error.details),\n        error,\n      );\n    case 'RUN_PROTOCOL_ERROR':\n      return copyStack(\n        new CodeModeProtocolError(error.message, error.details),\n        error,\n      );\n    default:\n      return error;\n  }\n}\n\nfunction translateLimitPath(message: string): string {\n  const paths: Record<string, string> = {\n    'limits.timeoutMs': 'executionPolicy.timeoutMs',\n    'limits.memoryLimitBytes': 'executionPolicy.memoryLimitBytes',\n    'limits.maxStackSizeBytes': 'executionPolicy.maxStackSizeBytes',\n    'limits.maxResultBytes': 'executionPolicy.maxResultBytes',\n    'limits.maxConsoleOutputBytes': 'executionPolicy.maxConsoleOutputBytes',\n    'limits.maxSourceBytes': 'executionPolicy.maxSourceBytes',\n    'limits.maxHostFunctionArgumentsBytes': 'executionPolicy.maxToolInputBytes',\n    'limits.maxHostFunctionOutputBytes': 'executionPolicy.maxToolOutputBytes',\n    'limits.maxBridgeRequests': 'executionPolicy.maxBridgeRequests',\n    'limits.maxInFlightBridgeRequests':\n      'executionPolicy.maxInFlightBridgeRequests',\n  };\n  for (const [runPath, codeModePath] of Object.entries(paths)) {\n    if (message.includes(runPath)) {\n      return message.replace(runPath, codeModePath);\n    }\n  }\n  return message;\n}\n\nfunction copyStack<T extends Error>(target: T, source: Error): T {\n  if (source.stack !== undefined) {\n    target.stack = source.stack;\n  }\n  return target;\n}\n\nfunction translateSourceStack<T>(error: T): T {\n  if (!(error instanceof Error) || error.stack === undefined) {\n    return error;\n  }\n  error.stack = error.stack.replaceAll(\n    /run\\.js:(\\d+):(\\d+)/gu,\n    (_match, line: string, column: string) =>\n      `code-mode.js:${Math.max(1, Number(line) - SOURCE_LINE_OFFSET)}:${column}`,\n  );\n  return error;\n}\n"],"mappings":"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","names":[]}

package/dist/tool-invocation.js

@@ -6,9 +6,9 @@ import {
   CodeModeToolApprovalRequiredError,
   CodeModeToolError
 } from "./errors.js";
-import { isCodeModeHostInterruptSignal } from "./host-interrupt.js";
 import {
   assertJsonSerializable,
+  fromJsonPayload,
   toJsonPayload
 } from "./utils/serialization.js";
 async function invokeHostTool({
@@ -36,7 +36,7 @@ async function invokeHostTool({
       toolName
     });
   }
-  const input = inputJson === "" ? void 0 : JSON.parse(inputJson);
+  const input = fromJsonPayload(inputJson);
   assertJsonSerializable(input, maxToolInputBytes, `Tool "${toolName}" input`);
   const validation = await raceAgainstAbort(
     validateToolInput(hostTool.inputSchema, input),
@@ -107,27 +107,13 @@ async function invokeHostTool({
       );
     }
   }
-  let output;
-  try {
-    output = await raceAgainstAbort(
-      executeHostTool(hostTool.execute.bind(hostTool), {
-        input: validation.value,
-        options: executionOptions
-      }),
-      executionOptions.abortSignal
-    );
-  } catch (error) {
-    if (isCodeModeHostInterruptSignal(error)) {
-      return {
-        type: "interrupted",
-        toolName,
-        input: validation.value,
-        toolCallId,
-        payload: error.payload
-      };
-    }
-    throw error;
-  }
+  const output = await raceAgainstAbort(
+    executeHostTool(hostTool.execute.bind(hostTool), {
+      input: validation.value,
+      options: executionOptions
+    }),
+    executionOptions.abortSignal
+  );
   return {
     type: "success",
     valueJson: toJsonPayload(