@ai-sdk/code-mode 1.0.6 → 1.0.8

package/dist/tool-invocation.js

@@ -1,5 +1,12 @@
 import { asSchema } from "ai";
-import { CodeModeToolError } from "./errors.js";
+import { CODE_MODE_TOOL_APPROVAL_KIND } from "./approval.js";
+import {
+  CodeModeProtocolError,
+  CodeModeToolApprovalDeniedError,
+  CodeModeToolApprovalRequiredError,
+  CodeModeToolError
+} from "./errors.js";
+import { isCodeModeHostInterruptSignal } from "./host-interrupt.js";
 import {
   assertJsonSerializable,
   toJsonPayload
@@ -9,9 +16,12 @@ async function invokeHostTool({
   inputJson,
   tools,
   baseExecutionOptions,
+  codeModeOptions,
   maxToolInputBytes,
   maxToolOutputBytes,
-  toolCallId
+  toolCallId,
+  codeModeInterrupt,
+  skipApproval = false
 }) {
   throwIfAborted(baseExecutionOptions.abortSignal);
   const hostTool = tools[toolName];
@@ -40,25 +50,92 @@ async function invokeHostTool({
   }
   const executionOptions = {
     ...baseExecutionOptions,
-    toolCallId
+    toolCallId,
+    ...codeModeInterrupt !== void 0 ? { codeModeInterrupt } : {}
   };
-  if (await raceAgainstAbort(
+  const needsApproval = !skipApproval && await raceAgainstAbort(
     requiresApproval(hostTool, validation.value, executionOptions),
     executionOptions.abortSignal
-  )) {
-    throw new CodeModeToolError(
-      `Tool "${toolName}" requires approval, which code mode does not support yet.`,
-      { toolName, input: validation.value, toolCallId }
+  );
+  if (needsApproval) {
+    if (codeModeOptions.approval?.mode === "interrupt") {
+      return {
+        type: "interrupted",
+        toolName,
+        input: validation.value,
+        toolCallId,
+        payload: { kind: CODE_MODE_TOOL_APPROVAL_KIND }
+      };
+    }
+    const approval = await raceAgainstAbort(
+      Promise.resolve(
+        codeModeOptions.approval?.onApprovalRequired?.({
+          toolName,
+          input: validation.value,
+          toolCallId
+        })
+      ),
+      baseExecutionOptions.abortSignal
     );
+    if (approval === void 0) {
+      throw new CodeModeToolApprovalRequiredError(
+        toolName,
+        validation.value,
+        toolCallId
+      );
+    }
+    const approved = typeof approval === "string" ? approval === "approved" : approval?.approved;
+    const reason = typeof approval === "string" ? void 0 : approval?.reason;
+    if (typeof approved !== "boolean") {
+      throw new CodeModeProtocolError(
+        `Tool "${toolName}" approval callback returned a malformed approval decision.`,
+        { toolName, toolCallId }
+      );
+    }
+    if (reason !== void 0 && typeof reason !== "string") {
+      throw new CodeModeProtocolError(
+        `Tool "${toolName}" approval callback returned a malformed approval reason.`,
+        { toolName, toolCallId }
+      );
+    }
+    if (!approved) {
+      throw new CodeModeToolApprovalDeniedError(
+        toolName,
+        validation.value,
+        toolCallId,
+        reason
+      );
+    }
   }
-  const output = await raceAgainstAbort(
-    executeHostTool(hostTool.execute.bind(hostTool), {
-      input: validation.value,
-      options: executionOptions
-    }),
-    executionOptions.abortSignal
-  );
-  return toJsonPayload(output, maxToolOutputBytes, `Tool "${toolName}" output`);
+  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;
+  }
+  return {
+    type: "success",
+    valueJson: toJsonPayload(
+      output,
+      maxToolOutputBytes,
+      `Tool "${toolName}" output`
+    )
+  };
 }
 async function requiresApproval(hostTool, input, options) {
   if (hostTool.needsApproval == null) {

package/dist/tool-invocation.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/tool-invocation.ts"],"sourcesContent":["import { asSchema } from 'ai';\nimport { CodeModeToolError } from './errors.js';\nimport type { CodeModeToolExecutionOptions, CodeModeToolSet } from './types.js';\nimport {\n  assertJsonSerializable,\n  toJsonPayload,\n} from './utils/serialization.js';\n\nexport async function invokeHostTool({\n  toolName,\n  inputJson,\n  tools,\n  baseExecutionOptions,\n  maxToolInputBytes,\n  maxToolOutputBytes,\n  toolCallId,\n}: {\n  toolName: string;\n  inputJson: string;\n  tools: CodeModeToolSet;\n  baseExecutionOptions: CodeModeToolExecutionOptions;\n  maxToolInputBytes: number;\n  maxToolOutputBytes: number;\n  toolCallId: string;\n}): Promise<string> {\n  throwIfAborted(baseExecutionOptions.abortSignal);\n\n  const hostTool = tools[toolName];\n  if (!hostTool) {\n    throw new CodeModeToolError(`Unknown tool: ${toolName}`, {\n      toolName,\n      availableTools: Object.keys(tools),\n    });\n  }\n  if (hostTool.execute == null) {\n    throw new CodeModeToolError(`Tool \"${toolName}\" does not have execute().`, {\n      toolName,\n    });\n  }\n\n  const input = inputJson === '' ? undefined : JSON.parse(inputJson);\n  assertJsonSerializable(input, maxToolInputBytes, `Tool \"${toolName}\" input`);\n\n  const validation = await raceAgainstAbort(\n    validateToolInput(hostTool.inputSchema, input),\n    baseExecutionOptions.abortSignal,\n  );\n  if (!validation.success) {\n    throw new CodeModeToolError(\n      `Invalid input for tool \"${toolName}\": ${validation.error.message}`,\n      { toolName, input, cause: validation.error.message },\n    );\n  }\n\n  const executionOptions: CodeModeToolExecutionOptions = {\n    ...baseExecutionOptions,\n    toolCallId,\n  };\n\n  if (\n    await raceAgainstAbort(\n      requiresApproval(hostTool, validation.value, executionOptions),\n      executionOptions.abortSignal,\n    )\n  ) {\n    throw new CodeModeToolError(\n      `Tool \"${toolName}\" requires approval, which code mode does not support yet.`,\n      { toolName, input: validation.value, toolCallId },\n    );\n  }\n\n  const output = await raceAgainstAbort(\n    executeHostTool(hostTool.execute.bind(hostTool), {\n      input: validation.value,\n      options: executionOptions,\n    }),\n    executionOptions.abortSignal,\n  );\n  return toJsonPayload(output, maxToolOutputBytes, `Tool \"${toolName}\" output`);\n}\n\nasync function requiresApproval(\n  hostTool: CodeModeToolSet[string],\n  input: unknown,\n  options: CodeModeToolExecutionOptions,\n): Promise<boolean> {\n  if (hostTool.needsApproval == null) {\n    return false;\n  }\n  if (typeof hostTool.needsApproval === 'boolean') {\n    return hostTool.needsApproval;\n  }\n  return await hostTool.needsApproval(input as never, options as never);\n}\n\nasync function validateToolInput(\n  schema: CodeModeToolSet[string]['inputSchema'],\n  input: unknown,\n): Promise<\n  { success: true; value: unknown } | { success: false; error: Error }\n> {\n  const normalizedSchema = asSchema(schema);\n  if (normalizedSchema.validate === undefined) {\n    return { success: true, value: input };\n  }\n  return await normalizedSchema.validate(input);\n}\n\nasync function executeHostTool(\n  execute: NonNullable<CodeModeToolSet[string]['execute']>,\n  {\n    input,\n    options,\n  }: {\n    input: unknown;\n    options: CodeModeToolExecutionOptions;\n  },\n): Promise<unknown> {\n  const output = execute(input as never, options as never);\n  if (isAsyncIterable(output)) {\n    let finalOutput: unknown;\n    for await (const part of output) {\n      finalOutput = part;\n    }\n    return finalOutput;\n  }\n  return await output;\n}\n\nfunction isAsyncIterable(value: unknown): value is AsyncIterable<unknown> {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    Symbol.asyncIterator in value &&\n    typeof (value as { [Symbol.asyncIterator]?: unknown })[\n      Symbol.asyncIterator\n    ] === 'function'\n  );\n}\n\nasync function raceAgainstAbort<T>(\n  operation: Promise<T>,\n  abortSignal: AbortSignal | undefined,\n): Promise<T> {\n  if (abortSignal === undefined) {\n    return await operation;\n  }\n  throwIfAborted(abortSignal);\n\n  let rejectOnAbort!: (reason?: unknown) => void;\n  const aborted = new Promise<never>((_resolve, reject) => {\n    rejectOnAbort = reject;\n  });\n  const onAbort = () => {\n    rejectOnAbort(abortReason(abortSignal));\n  };\n\n  abortSignal.addEventListener('abort', onAbort, { once: true });\n  if (abortSignal.aborted) {\n    onAbort();\n  }\n\n  try {\n    return await Promise.race([operation, aborted]);\n  } finally {\n    abortSignal.removeEventListener('abort', onAbort);\n  }\n}\n\nfunction throwIfAborted(abortSignal: AbortSignal | undefined): void {\n  if (abortSignal?.aborted) {\n    throw abortReason(abortSignal);\n  }\n}\n\nfunction abortReason(abortSignal: AbortSignal): unknown {\n  return (\n    abortSignal.reason ??\n    new DOMException('The operation was aborted.', 'AbortError')\n  );\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/tool-invocation.ts"],"sourcesContent":["import { asSchema } from 'ai';\nimport { CODE_MODE_TOOL_APPROVAL_KIND } from './approval.js';\nimport {\n  CodeModeProtocolError,\n  CodeModeToolApprovalDeniedError,\n  CodeModeToolApprovalRequiredError,\n  CodeModeToolError,\n} from './errors.js';\nimport { isCodeModeHostInterruptSignal } from './host-interrupt.js';\nimport type {\n  CodeModeInterruptExecutionContext,\n  CodeModeInterruptPayload,\n  CodeModeOptions,\n  CodeModeToolExecutionOptions,\n  CodeModeToolSet,\n} from './types.js';\nimport {\n  assertJsonSerializable,\n  toJsonPayload,\n} from './utils/serialization.js';\n\nexport type HostToolInvocationResult =\n  | { type: 'success'; valueJson: string }\n  | {\n      type: 'interrupted';\n      toolName: string;\n      input: unknown;\n      toolCallId: string;\n      payload: CodeModeInterruptPayload;\n    };\n\nexport async function invokeHostTool({\n  toolName,\n  inputJson,\n  tools,\n  baseExecutionOptions,\n  codeModeOptions,\n  maxToolInputBytes,\n  maxToolOutputBytes,\n  toolCallId,\n  codeModeInterrupt,\n  skipApproval = false,\n}: {\n  toolName: string;\n  inputJson: string;\n  tools: CodeModeToolSet;\n  baseExecutionOptions: CodeModeToolExecutionOptions;\n  codeModeOptions: CodeModeOptions;\n  maxToolInputBytes: number;\n  maxToolOutputBytes: number;\n  toolCallId: string;\n  codeModeInterrupt?: CodeModeInterruptExecutionContext;\n  skipApproval?: boolean;\n}): Promise<HostToolInvocationResult> {\n  throwIfAborted(baseExecutionOptions.abortSignal);\n\n  const hostTool = tools[toolName];\n  if (!hostTool) {\n    throw new CodeModeToolError(`Unknown tool: ${toolName}`, {\n      toolName,\n      availableTools: Object.keys(tools),\n    });\n  }\n  if (hostTool.execute == null) {\n    throw new CodeModeToolError(`Tool \"${toolName}\" does not have execute().`, {\n      toolName,\n    });\n  }\n\n  const input = inputJson === '' ? undefined : JSON.parse(inputJson);\n  assertJsonSerializable(input, maxToolInputBytes, `Tool \"${toolName}\" input`);\n\n  const validation = await raceAgainstAbort(\n    validateToolInput(hostTool.inputSchema, input),\n    baseExecutionOptions.abortSignal,\n  );\n  if (!validation.success) {\n    throw new CodeModeToolError(\n      `Invalid input for tool \"${toolName}\": ${validation.error.message}`,\n      { toolName, input, cause: validation.error.message },\n    );\n  }\n\n  const executionOptions: CodeModeToolExecutionOptions = {\n    ...baseExecutionOptions,\n    toolCallId,\n    ...(codeModeInterrupt !== undefined ? { codeModeInterrupt } : {}),\n  };\n\n  const needsApproval =\n    !skipApproval &&\n    (await raceAgainstAbort(\n      requiresApproval(hostTool, validation.value, executionOptions),\n      executionOptions.abortSignal,\n    ));\n\n  if (needsApproval) {\n    if (codeModeOptions.approval?.mode === 'interrupt') {\n      return {\n        type: 'interrupted',\n        toolName,\n        input: validation.value,\n        toolCallId,\n        payload: { kind: CODE_MODE_TOOL_APPROVAL_KIND },\n      };\n    }\n\n    const approval = await raceAgainstAbort(\n      Promise.resolve(\n        codeModeOptions.approval?.onApprovalRequired?.({\n          toolName,\n          input: validation.value,\n          toolCallId,\n        }),\n      ),\n      baseExecutionOptions.abortSignal,\n    );\n    if (approval === undefined) {\n      throw new CodeModeToolApprovalRequiredError(\n        toolName,\n        validation.value,\n        toolCallId,\n      );\n    }\n    const approved =\n      typeof approval === 'string'\n        ? approval === 'approved'\n        : approval?.approved;\n    const reason = typeof approval === 'string' ? undefined : approval?.reason;\n    if (typeof approved !== 'boolean') {\n      throw new CodeModeProtocolError(\n        `Tool \"${toolName}\" approval callback returned a malformed approval decision.`,\n        { toolName, toolCallId },\n      );\n    }\n    if (reason !== undefined && typeof reason !== 'string') {\n      throw new CodeModeProtocolError(\n        `Tool \"${toolName}\" approval callback returned a malformed approval reason.`,\n        { toolName, toolCallId },\n      );\n    }\n    if (!approved) {\n      throw new CodeModeToolApprovalDeniedError(\n        toolName,\n        validation.value,\n        toolCallId,\n        reason,\n      );\n    }\n  }\n\n  let output: unknown;\n  try {\n    output = await raceAgainstAbort(\n      executeHostTool(hostTool.execute.bind(hostTool), {\n        input: validation.value,\n        options: executionOptions,\n      }),\n      executionOptions.abortSignal,\n    );\n  } catch (error) {\n    if (isCodeModeHostInterruptSignal(error)) {\n      return {\n        type: 'interrupted',\n        toolName,\n        input: validation.value,\n        toolCallId,\n        payload: error.payload,\n      };\n    }\n    throw error;\n  }\n  return {\n    type: 'success',\n    valueJson: toJsonPayload(\n      output,\n      maxToolOutputBytes,\n      `Tool \"${toolName}\" output`,\n    ),\n  };\n}\n\nasync function requiresApproval(\n  hostTool: CodeModeToolSet[string],\n  input: unknown,\n  options: CodeModeToolExecutionOptions,\n): Promise<boolean> {\n  if (hostTool.needsApproval == null) {\n    return false;\n  }\n  if (typeof hostTool.needsApproval === 'boolean') {\n    return hostTool.needsApproval;\n  }\n  return await hostTool.needsApproval(input as never, options as never);\n}\n\nasync function validateToolInput(\n  schema: CodeModeToolSet[string]['inputSchema'],\n  input: unknown,\n): Promise<\n  { success: true; value: unknown } | { success: false; error: Error }\n> {\n  const normalizedSchema = asSchema(schema);\n  if (normalizedSchema.validate === undefined) {\n    return { success: true, value: input };\n  }\n  return await normalizedSchema.validate(input);\n}\n\nasync function executeHostTool(\n  execute: NonNullable<CodeModeToolSet[string]['execute']>,\n  {\n    input,\n    options,\n  }: {\n    input: unknown;\n    options: CodeModeToolExecutionOptions;\n  },\n): Promise<unknown> {\n  const output = execute(input as never, options as never);\n  if (isAsyncIterable(output)) {\n    let finalOutput: unknown;\n    for await (const part of output) {\n      finalOutput = part;\n    }\n    return finalOutput;\n  }\n  return await output;\n}\n\nfunction isAsyncIterable(value: unknown): value is AsyncIterable<unknown> {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    Symbol.asyncIterator in value &&\n    typeof (value as { [Symbol.asyncIterator]?: unknown })[\n      Symbol.asyncIterator\n    ] === 'function'\n  );\n}\n\nasync function raceAgainstAbort<T>(\n  operation: Promise<T>,\n  abortSignal: AbortSignal | undefined,\n): Promise<T> {\n  if (abortSignal === undefined) {\n    return await operation;\n  }\n  throwIfAborted(abortSignal);\n\n  let rejectOnAbort!: (reason?: unknown) => void;\n  const aborted = new Promise<never>((_resolve, reject) => {\n    rejectOnAbort = reject;\n  });\n  const onAbort = () => {\n    rejectOnAbort(abortReason(abortSignal));\n  };\n\n  abortSignal.addEventListener('abort', onAbort, { once: true });\n  if (abortSignal.aborted) {\n    onAbort();\n  }\n\n  try {\n    return await Promise.race([operation, aborted]);\n  } finally {\n    abortSignal.removeEventListener('abort', onAbort);\n  }\n}\n\nfunction throwIfAborted(abortSignal: AbortSignal | undefined): void {\n  if (abortSignal?.aborted) {\n    throw abortReason(abortSignal);\n  }\n}\n\nfunction abortReason(abortSignal: AbortSignal): unknown {\n  return (\n    abortSignal.reason ??\n    new DOMException('The operation was aborted.', 'AbortError')\n  );\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/code-mode",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "QuickJS-backed code mode tool for AI SDK",
   "keywords": [
     "ai",
@@ -37,7 +37,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "ai": "7.0.49"
+    "ai": "7.0.51"
   },
   "devDependencies": {
     "@types/node": "22.19.19",
@@ -47,7 +47,7 @@
     "typescript": "5.8.3",
     "zod": "3.25.76",
     "@vercel/ai-tsconfig": "0.0.0",
-    "ai": "7.0.49"
+    "ai": "7.0.51"
   },
   "engines": {
     "node": ">=22"

package/src/approval-continuation.ts

@@ -0,0 +1,115 @@
+import type { ModelMessage } from 'ai';
+import {
+  assertCodeModeApprovalResponse,
+  CODE_MODE_TOOL_APPROVAL_KIND,
+} from './approval.js';
+import { CodeModeProtocolError } from './errors.js';
+import {
+  continueCodeModeInterrupt,
+  isCodeModeInterrupt,
+} from './interrupt-continuation.js';
+import type {
+  CodeModeApprovalInterrupt,
+  CodeModeApprovalResponse,
+  CodeModeContinuationSecurityOptions,
+  CodeModeOptions,
+  CodeModeToolExecutionOptions,
+  CodeModeToolSet,
+} from './types.js';
+
+export function isCodeModeApprovalInterrupt(
+  value: unknown,
+  continuationSecurity: CodeModeContinuationSecurityOptions = {},
+): value is CodeModeApprovalInterrupt {
+  return (
+    isCodeModeInterrupt(value, continuationSecurity) &&
+    value.payload.kind === CODE_MODE_TOOL_APPROVAL_KIND
+  );
+}
+
+export async function continueCodeModeApproval({
+  interrupt,
+  approvalResponse,
+  tools,
+  options = {},
+  toolExecutionOptions,
+}: {
+  interrupt: CodeModeApprovalInterrupt;
+  approvalResponse: CodeModeApprovalResponse;
+  tools: CodeModeToolSet;
+  options?: CodeModeOptions;
+  toolExecutionOptions?: Partial<CodeModeToolExecutionOptions>;
+}): Promise<unknown> {
+  assertCodeModeApprovalResponse(approvalResponse);
+  if (approvalResponse.approvalId !== interrupt.interruptId) {
+    throw new CodeModeProtocolError(
+      `Approval response ${approvalResponse.approvalId} does not match pending code-mode approval ${interrupt.interruptId}.`,
+    );
+  }
+
+  return await continueCodeModeInterrupt({
+    interrupt,
+    resolution: {
+      approved: approvalResponse.approved,
+      ...(approvalResponse.reason !== undefined
+        ? { reason: approvalResponse.reason }
+        : {}),
+    },
+    tools,
+    options: {
+      ...options,
+      approval: { ...options.approval, mode: 'interrupt' },
+    },
+    ...(toolExecutionOptions !== undefined ? { toolExecutionOptions } : {}),
+  });
+}
+
+export function toCodeModeApprovalMessages(
+  interrupt: CodeModeApprovalInterrupt,
+): ModelMessage[] {
+  return [
+    {
+      role: 'assistant',
+      content: [
+        {
+          type: 'tool-call',
+          toolCallId: interrupt.toolCallId,
+          toolName: interrupt.toolName,
+          input: interrupt.input,
+        },
+        {
+          type: 'tool-approval-request',
+          approvalId: interrupt.interruptId,
+          toolCallId: interrupt.toolCallId,
+        },
+      ],
+    },
+  ];
+}
+
+export function getCodeModeApprovalResponse(
+  messages: ModelMessage[],
+  interrupt: CodeModeApprovalInterrupt,
+): CodeModeApprovalResponse | undefined {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index];
+    if (message?.role !== 'tool') {
+      continue;
+    }
+    for (const part of message.content) {
+      if (
+        part.type === 'tool-approval-response' &&
+        part.approvalId === interrupt.interruptId &&
+        typeof part.approved === 'boolean' &&
+        (part.reason === undefined || typeof part.reason === 'string')
+      ) {
+        return {
+          approvalId: part.approvalId,
+          approved: part.approved,
+          ...(part.reason !== undefined ? { reason: part.reason } : {}),
+        };
+      }
+    }
+  }
+  return undefined;
+}

package/src/approval.ts

@@ -0,0 +1,60 @@
+import { CodeModeProtocolError } from './errors.js';
+import type {
+  CodeModeApprovalInterruptPayload,
+  CodeModeApprovalResolution,
+  CodeModeApprovalResponse,
+  CodeModeInterruptPayload,
+} from './types.js';
+
+export const CODE_MODE_TOOL_APPROVAL_KIND =
+  'ai-sdk-code-mode/tool-approval' as const;
+
+export function isCodeModeApprovalInterruptPayload(
+  payload: CodeModeInterruptPayload,
+): payload is CodeModeApprovalInterruptPayload {
+  return payload.kind === CODE_MODE_TOOL_APPROVAL_KIND;
+}
+
+export function assertCodeModeApprovalResponse(
+  value: unknown,
+): asserts value is CodeModeApprovalResponse {
+  if (
+    typeof value !== 'object' ||
+    value === null ||
+    Array.isArray(value) ||
+    typeof (value as { approvalId?: unknown }).approvalId !== 'string' ||
+    typeof (value as { approved?: unknown }).approved !== 'boolean' ||
+    ('reason' in value &&
+      (value as { reason?: unknown }).reason !== undefined &&
+      typeof (value as { reason?: unknown }).reason !== 'string')
+  ) {
+    throw new CodeModeProtocolError(
+      'Code mode approval response is malformed.',
+    );
+  }
+}
+
+export function normalizeApprovalResolution(
+  resolution: unknown,
+): CodeModeApprovalResolution {
+  if (
+    typeof resolution !== 'object' ||
+    resolution === null ||
+    Array.isArray(resolution) ||
+    typeof (resolution as { approved?: unknown }).approved !== 'boolean' ||
+    ('reason' in resolution &&
+      (resolution as { reason?: unknown }).reason !== undefined &&
+      typeof (resolution as { reason?: unknown }).reason !== 'string')
+  ) {
+    throw new CodeModeProtocolError(
+      'Code mode approval resolution must be a boolean approval decision.',
+      { resolution },
+    );
+  }
+
+  const { approved, reason } = resolution as CodeModeApprovalResolution;
+  return {
+    approved,
+    ...(reason !== undefined ? { reason } : {}),
+  };
+}

package/src/continuation-capability.ts

@@ -0,0 +1,201 @@
+import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+import { CodeModeProtocolError } from './errors.js';
+import type {
+  CodeModeContinuation,
+  CodeModeContinuationAuth,
+  CodeModeContinuationSecurityOptions,
+  UnsignedCodeModeContinuation,
+} from './types.js';
+
+const SIGNATURE_ALGORITHM = 'HMAC-SHA256';
+const DEFAULT_MAX_AGE_MS = 60 * 60 * 1000;
+
+let defaultSigningKey: Uint8Array = randomBytes(32);
+let defaultMaxAgeMs = DEFAULT_MAX_AGE_MS;
+
+export interface ResolvedCodeModeContinuationSecurity {
+  signingKey: Buffer;
+  maxAgeMs: number;
+}
+
+export function setCodeModeContinuationSigningKey(
+  key?: string | Uint8Array,
+  options: { maxAgeMs?: number } = {},
+): void {
+  const resolved = resolveCodeModeContinuationSecurity({
+    signingKey: key ?? randomBytes(32),
+    maxAgeMs: options.maxAgeMs ?? DEFAULT_MAX_AGE_MS,
+  });
+  defaultSigningKey = resolved.signingKey;
+  defaultMaxAgeMs = resolved.maxAgeMs;
+}
+
+export function resolveCodeModeContinuationSecurity(
+  options: CodeModeContinuationSecurityOptions = {},
+): ResolvedCodeModeContinuationSecurity {
+  const signingKey =
+    options.signingKey === undefined
+      ? Buffer.from(defaultSigningKey)
+      : typeof options.signingKey === 'string'
+        ? Buffer.from(options.signingKey)
+        : Buffer.from(options.signingKey);
+  if (signingKey.byteLength === 0) {
+    throw new TypeError('Continuation signing key must not be empty.');
+  }
+
+  const maxAgeMs = options.maxAgeMs ?? defaultMaxAgeMs;
+  if (
+    !Number.isInteger(maxAgeMs) ||
+    !Number.isFinite(maxAgeMs) ||
+    maxAgeMs <= 0
+  ) {
+    throw new TypeError('Continuation maxAgeMs must be a positive integer.');
+  }
+
+  return { signingKey, maxAgeMs };
+}
+
+export function signCodeModeContinuation(
+  continuation: UnsignedCodeModeContinuation,
+  security = resolveCodeModeContinuationSecurity(),
+): CodeModeContinuation {
+  const issuedAtMs = Date.now();
+  const auth: Omit<CodeModeContinuationAuth, 'signature'> = {
+    alg: SIGNATURE_ALGORITHM,
+    nonce: randomBytes(16).toString('hex'),
+    issuedAtMs,
+    expiresAtMs: issuedAtMs + security.maxAgeMs,
+  };
+  return {
+    ...structuredClone(continuation),
+    auth: {
+      ...auth,
+      signature: signContinuationPayload(
+        { ...continuation, auth },
+        security.signingKey,
+      ),
+    },
+  };
+}
+
+export function verifyCodeModeContinuation(
+  continuation: CodeModeContinuation,
+  security: CodeModeContinuationSecurityOptions = {},
+): void {
+  assertAuthShape(continuation.auth);
+  const now = Date.now();
+  if (continuation.auth.expiresAtMs < now) {
+    throw new CodeModeProtocolError('Code mode continuation has expired.', {
+      expiresAtMs: continuation.auth.expiresAtMs,
+      now,
+    });
+  }
+  if (continuation.auth.issuedAtMs > now + 60_000) {
+    throw new CodeModeProtocolError(
+      'Code mode continuation was issued in the future.',
+      { issuedAtMs: continuation.auth.issuedAtMs, now },
+    );
+  }
+
+  const { signingKey } = resolveCodeModeContinuationSecurity(security);
+  const expected = signContinuationPayload(
+    stripSignature(continuation),
+    signingKey,
+  );
+  if (!constantTimeEqual(continuation.auth.signature, expected)) {
+    throw new CodeModeProtocolError(
+      'Code mode continuation signature is invalid.',
+    );
+  }
+}
+
+export function hasValidCodeModeContinuationCapability(
+  value: unknown,
+  security: CodeModeContinuationSecurityOptions = {},
+): value is CodeModeContinuation {
+  try {
+    verifyCodeModeContinuation(value as CodeModeContinuation, security);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function signContinuationPayload(
+  continuation: UnsignedCodeModeContinuation & {
+    auth: Omit<CodeModeContinuationAuth, 'signature'>;
+  },
+  signingKey: Uint8Array,
+): string {
+  return createHmac('sha256', signingKey)
+    .update(canonicalJson(continuation))
+    .digest('base64url');
+}
+
+function stripSignature(
+  continuation: CodeModeContinuation,
+): UnsignedCodeModeContinuation & {
+  auth: Omit<CodeModeContinuationAuth, 'signature'>;
+} {
+  const { auth, ...rest } = continuation;
+  const { signature: _signature, ...unsignedAuth } = auth;
+  return { ...rest, auth: unsignedAuth };
+}
+
+function assertAuthShape(
+  auth: unknown,
+): asserts auth is CodeModeContinuationAuth {
+  if (
+    typeof auth !== 'object' ||
+    auth === null ||
+    Array.isArray(auth) ||
+    (auth as { alg?: unknown }).alg !== SIGNATURE_ALGORITHM ||
+    typeof (auth as { nonce?: unknown }).nonce !== 'string' ||
+    !/^[0-9a-f]{32}$/i.test((auth as { nonce: string }).nonce) ||
+    typeof (auth as { issuedAtMs?: unknown }).issuedAtMs !== 'number' ||
+    !Number.isInteger((auth as { issuedAtMs: number }).issuedAtMs) ||
+    typeof (auth as { expiresAtMs?: unknown }).expiresAtMs !== 'number' ||
+    !Number.isInteger((auth as { expiresAtMs: number }).expiresAtMs) ||
+    (auth as { expiresAtMs: number }).expiresAtMs <=
+      (auth as { issuedAtMs: number }).issuedAtMs ||
+    typeof (auth as { signature?: unknown }).signature !== 'string' ||
+    (auth as { signature: string }).signature.length === 0
+  ) {
+    throw new CodeModeProtocolError(
+      'Code mode continuation is missing valid signed auth metadata.',
+    );
+  }
+}
+
+function constantTimeEqual(left: string, right: string): boolean {
+  const leftBytes = Buffer.from(left);
+  const rightBytes = Buffer.from(right);
+  return (
+    leftBytes.byteLength === rightBytes.byteLength &&
+    timingSafeEqual(leftBytes, rightBytes)
+  );
+}
+
+function canonicalJson(value: unknown): string {
+  if (value === null) {
+    return 'null';
+  }
+  if (typeof value === 'string') {
+    return JSON.stringify(value);
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalJson).join(',')}]`;
+  }
+  if (typeof value === 'object') {
+    const entries = Object.entries(value as Record<string, unknown>)
+      .filter(([, item]) => item !== undefined)
+      .sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries
+      .map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`)
+      .join(',')}}`;
+  }
+  throw new TypeError('Continuation contains a non-JSON-serializable value.');
+}

package/src/direct-tool-call.ts

@@ -0,0 +1,6 @@
+/**
+ * Allows the model to call a tool directly.
+ *
+ * Use a string instead of a Symbol to allow for serializability.
+ */
+export const DIRECT_TOOL_CALL = 'AI_SDK_DIRECT_TOOL_CALL';

package/src/errors.ts

@@ -112,6 +112,37 @@ export class CodeModeToolError extends CodeModeError {
   }
 }
 
+export class CodeModeToolApprovalRequiredError extends CodeModeToolError {
+  constructor(toolName: string, input: unknown, toolCallId: string) {
+    super(`Tool "${toolName}" requires approval before execution.`, {
+      toolName,
+      input,
+      toolCallId,
+    });
+    this.code = 'CODE_MODE_TOOL_APPROVAL_REQUIRED';
+  }
+}
+
+export class CodeModeToolApprovalDeniedError extends CodeModeToolError {
+  constructor(
+    toolName: string,
+    input: unknown,
+    toolCallId: string,
+    reason?: string,
+  ) {
+    super(
+      `Tool "${toolName}" approval was denied${reason ? `: ${reason}` : '.'}`,
+      {
+        toolName,
+        input,
+        toolCallId,
+        ...(reason !== undefined ? { reason } : {}),
+      },
+    );
+    this.code = 'CODE_MODE_TOOL_APPROVAL_DENIED';
+  }
+}
+
 /**
  * Converts an unknown thrown value into a worker-safe serializable shape.
  *
@@ -250,6 +281,40 @@ export function deserializeError(error: SerializableError): Error {
     return result;
   }
 
+  if (error.code === 'CODE_MODE_TOOL_APPROVAL_REQUIRED') {
+    const details = error.details as
+      | { toolName?: string; input?: unknown; toolCallId?: string }
+      | undefined;
+    const result = new CodeModeToolApprovalRequiredError(
+      details?.toolName ?? 'unknown',
+      details?.input,
+      details?.toolCallId ?? 'unknown',
+    );
+    result.message = error.message;
+    restoreStack(result, error);
+    return result;
+  }
+
+  if (error.code === 'CODE_MODE_TOOL_APPROVAL_DENIED') {
+    const details = error.details as
+      | {
+          toolName?: string;
+          input?: unknown;
+          toolCallId?: string;
+          reason?: string;
+        }
+      | undefined;
+    const result = new CodeModeToolApprovalDeniedError(
+      details?.toolName ?? 'unknown',
+      details?.input,
+      details?.toolCallId ?? 'unknown',
+      details?.reason,
+    );
+    result.message = error.message;
+    restoreStack(result, error);
+    return result;
+  }
+
   const result = new CodeModeError(
     error.message,
     error.code ?? 'CODE_MODE_ERROR',