@ai-sdk/code-mode 0.0.0-2d998b35-20260731001744

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2023 Vercel, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,99 @@
+# AI SDK Code Mode
+
+`@ai-sdk/code-mode` lets models write JavaScript or TypeScript that calls your
+AI SDK tools. The code runs in an isolated QuickJS sandbox and returns a
+JSON-serializable value.
+
+Use code mode when a model needs to call several tools, transform their results,
+or run them concurrently. Only the tools you provide are available to the
+generated code.
+
+## Installation
+
+```bash
+pnpm add ai @ai-sdk/code-mode
+```
+
+This package runs on the server and requires Node.js 22 or newer.
+
+## Usage
+
+```ts
+import { experimental_codeModeTool as codeModeTool } from '@ai-sdk/code-mode';
+import { generateText, isStepCount, tool } from 'ai';
+import { z } from 'zod';
+
+const getInventory = tool({
+  description: 'Get available inventory for a product.',
+  inputSchema: z.object({ productId: z.string() }),
+  outputSchema: z.object({
+    productId: z.string(),
+    availableUnits: z.number(),
+  }),
+  execute: async ({ productId }) => ({
+    productId,
+    availableUnits: 42,
+  }),
+});
+
+const getDemand = tool({
+  description: 'Get requested units for a product.',
+  inputSchema: z.object({ productId: z.string() }),
+  outputSchema: z.object({
+    productId: z.string(),
+    requestedUnits: z.number(),
+  }),
+  execute: async ({ productId }) => ({
+    productId,
+    requestedUnits: 31,
+  }),
+});
+
+const tools = {
+  code_mode: codeModeTool({
+    executionPolicy: {
+      timeoutMs: 30_000,
+    },
+  }),
+  getInventory,
+  getDemand,
+} as const;
+
+const result = await generateText({
+  model,
+  tools,
+  experimental_toolCallers: ({ code_mode }) => ({
+    getInventory: [code_mode],
+    getDemand: [code_mode],
+  }),
+  stopWhen: isStepCount(10),
+  prompt: 'Compare inventory and demand for product sku_123.',
+});
+```
+
+The model can then generate code like:
+
+```ts
+const [inventory, demand] = await Promise.all([
+  tools.getInventory({ productId: 'sku_123' }),
+  tools.getDemand({ productId: 'sku_123' }),
+]);
+
+return {
+  sufficient: inventory.availableUnits >= demand.requestedUnits,
+  remaining: inventory.availableUnits - demand.requestedUnits,
+};
+```
+
+## Direct Execution
+
+Use `experimental_runCodeMode` to run code directly:
+
+```ts
+import { experimental_runCodeMode as runCodeMode } from '@ai-sdk/code-mode';
+
+const result = await runCodeMode({
+  js: 'return await tools.getInventory({ productId: "sku_123" });',
+  tools: { getInventory },
+});
+```

package/dist/code-mode-tool.js

@@ -0,0 +1,40 @@
+import {
+  experimental_toolCaller,
+  jsonSchema,
+  tool
+} from "ai";
+import { runCodeMode } from "./run-code-mode.js";
+import { buildCodeModeToolDescription } from "./tool-prompt.js";
+function createCodeModeTool(tools, options = {}) {
+  return tool({
+    description: buildCodeModeToolDescription(tools),
+    inputSchema: jsonSchema({
+      type: "object",
+      properties: {
+        js: {
+          type: "string",
+          description: "Code-mode TypeScript source to execute. The tool description lists the available global `tools` API, input types, and call examples."
+        }
+      },
+      required: ["js"],
+      additionalProperties: false
+    }),
+    execute: async (input, executionOptions) => await runCodeMode({
+      js: input.js,
+      tools,
+      toolExecutionOptions: executionOptions,
+      options
+    })
+  });
+}
+function codeModeTool(options = {}) {
+  return experimental_toolCaller(createCodeModeTool({}, options), {
+    type: "local",
+    bind: (tools) => createCodeModeTool(tools, options)
+  });
+}
+export {
+  codeModeTool,
+  createCodeModeTool
+};
+//# sourceMappingURL=code-mode-tool.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/code-mode-tool.ts"],"sourcesContent":["import {\n  experimental_toolCaller,\n  jsonSchema,\n  tool,\n  type Experimental_ToolCallerTool,\n} from 'ai';\nimport { runCodeMode } from './run-code-mode.js';\nimport { buildCodeModeToolDescription } from './tool-prompt.js';\nimport type {\n  CodeModeOptions,\n  CodeModeTool,\n  CodeModeToolInput,\n  CodeModeToolSet,\n} from './types.js';\n\n/**\n * Creates an AI SDK tool that executes code-mode TypeScript in an isolated\n * sandbox.\n */\nexport function createCodeModeTool(\n  tools: CodeModeToolSet,\n  options: CodeModeOptions = {},\n): CodeModeTool {\n  return tool<CodeModeToolInput, unknown, Record<string, unknown>>({\n    description: buildCodeModeToolDescription(tools),\n    inputSchema: jsonSchema<CodeModeToolInput>({\n      type: 'object',\n      properties: {\n        js: {\n          type: 'string',\n          description:\n            'Code-mode TypeScript source to execute. The tool description lists the available global `tools` API, input types, and call examples.',\n        },\n      },\n      required: ['js'],\n      additionalProperties: false,\n    }),\n    execute: async (input, executionOptions) =>\n      await runCodeMode({\n        js: input.js,\n        tools,\n        toolExecutionOptions: executionOptions,\n        options,\n      }),\n  }) as CodeModeTool;\n}\n\n/**\n * Creates a code-mode caller whose host tools are bound by the surrounding\n * AI SDK generation call.\n */\nexport function codeModeTool(\n  options: CodeModeOptions = {},\n): Experimental_ToolCallerTool<CodeModeTool> {\n  return experimental_toolCaller(createCodeModeTool({}, options), {\n    type: 'local',\n    bind: tools =>\n      createCodeModeTool(tools as unknown as CodeModeToolSet, options),\n  });\n}\n"],"mappings":"AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AACP,SAAS,mBAAmB;AAC5B,SAAS,oCAAoC;AAYtC,SAAS,mBACd,OACA,UAA2B,CAAC,GACd;AACd,SAAO,KAA0D;AAAA,IAC/D,aAAa,6BAA6B,KAAK;AAAA,IAC/C,aAAa,WAA8B;AAAA,MACzC,MAAM;AAAA,MACN,YAAY;AAAA,QACV,IAAI;AAAA,UACF,MAAM;AAAA,UACN,aACE;AAAA,QACJ;AAAA,MACF;AAAA,MACA,UAAU,CAAC,IAAI;AAAA,MACf,sBAAsB;AAAA,IACxB,CAAC;AAAA,IACD,SAAS,OAAO,OAAO,qBACrB,MAAM,YAAY;AAAA,MAChB,IAAI,MAAM;AAAA,MACV;AAAA,MACA,sBAAsB;AAAA,MACtB;AAAA,IACF,CAAC;AAAA,EACL,CAAC;AACH;AAMO,SAAS,aACd,UAA2B,CAAC,GACe;AAC3C,SAAO,wBAAwB,mBAAmB,CAAC,GAAG,OAAO,GAAG;AAAA,IAC9D,MAAM;AAAA,IACN,MAAM,WACJ,mBAAmB,OAAqC,OAAO;AAAA,EACnE,CAAC;AACH;","names":[]}

package/dist/errors.js

@@ -0,0 +1,192 @@
+class CodeModeError extends Error {
+  /**
+   * Stable machine-readable error code.
+   */
+  code;
+  /**
+   * Optional structured diagnostic details.
+   */
+  details;
+  constructor(message, code = "CODE_MODE_ERROR", details) {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+    this.details = details;
+  }
+}
+class CodeModeTimeoutError extends CodeModeError {
+  constructor(timeoutMs) {
+    super(
+      `Code mode execution timed out after ${timeoutMs}ms.`,
+      "CODE_MODE_TIMEOUT",
+      { timeoutMs }
+    );
+  }
+}
+class CodeModeAbortedError extends CodeModeError {
+  constructor() {
+    super("Code mode execution was aborted.", "CODE_MODE_ABORTED");
+  }
+}
+class CodeModeConcurrencyError extends CodeModeError {
+  constructor(maxWorkers) {
+    super(
+      `Code mode maxWorkers limit reached (${maxWorkers}).`,
+      "CODE_MODE_CONCURRENCY_LIMIT",
+      { maxWorkers }
+    );
+  }
+}
+class CodeModeSourceTooLargeError extends CodeModeError {
+  constructor(bytes, maxBytes) {
+    super(
+      `Code mode source exceeds the ${maxBytes} byte size limit.`,
+      "CODE_MODE_SOURCE_TOO_LARGE",
+      { bytes, maxBytes }
+    );
+  }
+}
+class CodeModeBridgeLimitError extends CodeModeError {
+  constructor(message, details) {
+    super(message, "CODE_MODE_BRIDGE_LIMIT", details);
+  }
+}
+class CodeModeDetachedBridgeRequestError extends CodeModeError {
+  constructor(message, details) {
+    super(message, "CODE_MODE_DETACHED_BRIDGE_REQUEST", details);
+  }
+}
+class CodeModeProtocolError extends CodeModeError {
+  constructor(message, details) {
+    super(message, "CODE_MODE_PROTOCOL_ERROR", details);
+  }
+}
+class CodeModeToolError extends CodeModeError {
+  constructor(message, details) {
+    super(message, "CODE_MODE_TOOL_ERROR", details);
+  }
+}
+function serializeError(error) {
+  if (error instanceof CodeModeError) {
+    const result = compactError({
+      name: error.name,
+      message: error.message,
+      code: error.code
+    });
+    if (error.stack !== void 0) {
+      result.stack = error.stack;
+    }
+    if (error.details !== void 0) {
+      result.details = error.details;
+    }
+    return result;
+  }
+  if (error instanceof Error) {
+    const result = compactError({
+      name: error.name,
+      message: error.message
+    });
+    if (error.stack !== void 0) {
+      result.stack = error.stack;
+    }
+    const maybeCoded = error;
+    if (typeof maybeCoded.code === "string") {
+      result.code = maybeCoded.code;
+    }
+    if (maybeCoded.details !== void 0) {
+      result.details = maybeCoded.details;
+    }
+    return result;
+  }
+  return {
+    name: "Error",
+    message: String(error)
+  };
+}
+function serializeBridgeErrorForGuest(error, context) {
+  if (error instanceof CodeModeError) {
+    return compactError({
+      name: error.name,
+      message: error.message,
+      code: error.code
+    });
+  }
+  const fallback = context === "tool" ? {
+    message: "Host tool failed.",
+    code: "CODE_MODE_HOST_TOOL_ERROR"
+  } : {
+    message: "Host bridge request failed.",
+    code: "CODE_MODE_HOST_BRIDGE_ERROR"
+  };
+  return {
+    name: "Error",
+    message: fallback.message,
+    code: fallback.code
+  };
+}
+function compactError(error) {
+  return {
+    name: error.name,
+    message: error.message,
+    ...error.stack !== void 0 ? { stack: error.stack } : {},
+    ...error.code !== void 0 ? { code: error.code } : {},
+    ...error.details !== void 0 ? { details: error.details } : {}
+  };
+}
+function deserializeError(error) {
+  if (error.code === "CODE_MODE_SOURCE_TOO_LARGE") {
+    const details = error.details;
+    const result2 = new CodeModeSourceTooLargeError(
+      details?.bytes ?? 0,
+      details?.maxBytes ?? 0
+    );
+    restoreStack(result2, error);
+    return result2;
+  }
+  if (error.code === "CODE_MODE_BRIDGE_LIMIT") {
+    const result2 = new CodeModeBridgeLimitError(error.message, error.details);
+    restoreStack(result2, error);
+    return result2;
+  }
+  if (error.code === "CODE_MODE_DETACHED_BRIDGE_REQUEST") {
+    const result2 = new CodeModeDetachedBridgeRequestError(
+      error.message,
+      error.details
+    );
+    restoreStack(result2, error);
+    return result2;
+  }
+  if (error.code === "CODE_MODE_PROTOCOL_ERROR") {
+    const result2 = new CodeModeProtocolError(error.message, error.details);
+    restoreStack(result2, error);
+    return result2;
+  }
+  const result = new CodeModeError(
+    error.message,
+    error.code ?? "CODE_MODE_ERROR",
+    error.details
+  );
+  result.name = error.name;
+  restoreStack(result, error);
+  return result;
+}
+function restoreStack(error, serialized) {
+  if (serialized.stack) {
+    error.stack = serialized.stack;
+  }
+}
+export {
+  CodeModeAbortedError,
+  CodeModeBridgeLimitError,
+  CodeModeConcurrencyError,
+  CodeModeDetachedBridgeRequestError,
+  CodeModeError,
+  CodeModeProtocolError,
+  CodeModeSourceTooLargeError,
+  CodeModeTimeoutError,
+  CodeModeToolError,
+  deserializeError,
+  serializeBridgeErrorForGuest,
+  serializeError
+};
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts"],"sourcesContent":["import type { SerializableError } from './types.js';\n\n/**\n * Base class for errors raised by code mode.\n *\n * All package-specific errors include a stable `code` string and may include\n * structured `details` for diagnostics.\n */\nexport class CodeModeError extends Error {\n  /**\n   * Stable machine-readable error code.\n   */\n  code: string;\n  /**\n   * Optional structured diagnostic details.\n   */\n  readonly details?: unknown;\n\n  constructor(message: string, code = 'CODE_MODE_ERROR', details?: unknown) {\n    super(message);\n    this.name = new.target.name;\n    this.code = code;\n    this.details = details;\n  }\n}\n\n/**\n * Raised when a sandbox invocation exceeds its timeout.\n */\nexport class CodeModeTimeoutError extends CodeModeError {\n  constructor(timeoutMs: number) {\n    super(\n      `Code mode execution timed out after ${timeoutMs}ms.`,\n      'CODE_MODE_TIMEOUT',\n      { timeoutMs },\n    );\n  }\n}\n\n/**\n * Raised when the outer AI SDK abort signal aborts a code-mode invocation.\n */\nexport class CodeModeAbortedError extends CodeModeError {\n  constructor() {\n    super('Code mode execution was aborted.', 'CODE_MODE_ABORTED');\n  }\n}\n\n/**\n * Raised when the process-global worker cap has been reached.\n *\n * Configure the cap with `setMaxWorkers`.\n */\nexport class CodeModeConcurrencyError extends CodeModeError {\n  constructor(maxWorkers: number) {\n    super(\n      `Code mode maxWorkers limit reached (${maxWorkers}).`,\n      'CODE_MODE_CONCURRENCY_LIMIT',\n      { maxWorkers },\n    );\n  }\n}\n\n/**\n * Raised when the provided source exceeds `executionPolicy.maxSourceBytes`.\n */\nexport class CodeModeSourceTooLargeError extends CodeModeError {\n  constructor(bytes: number, maxBytes: number) {\n    super(\n      `Code mode source exceeds the ${maxBytes} byte size limit.`,\n      'CODE_MODE_SOURCE_TOO_LARGE',\n      { bytes, maxBytes },\n    );\n  }\n}\n\n/**\n * Raised when sandboxed code exceeds bridge request limits.\n */\nexport class CodeModeBridgeLimitError extends CodeModeError {\n  constructor(message: string, details?: unknown) {\n    super(message, 'CODE_MODE_BRIDGE_LIMIT', details);\n  }\n}\n\n/**\n * Raised when sandboxed code starts host bridge work and returns without\n * awaiting or otherwise observing it.\n */\nexport class CodeModeDetachedBridgeRequestError extends CodeModeError {\n  constructor(message: string, details?: unknown) {\n    super(message, 'CODE_MODE_DETACHED_BRIDGE_REQUEST', details);\n  }\n}\n\n/**\n * Raised when the main thread and worker protocol observes an invalid or\n * mismatched message.\n */\nexport class CodeModeProtocolError extends CodeModeError {\n  constructor(message: string, details?: unknown) {\n    super(message, 'CODE_MODE_PROTOCOL_ERROR', details);\n  }\n}\n\n/**\n * Base class for failures caused by nested host tool execution.\n */\nexport class CodeModeToolError extends CodeModeError {\n  constructor(message: string, details?: unknown) {\n    super(message, 'CODE_MODE_TOOL_ERROR', details);\n  }\n}\n\n/**\n * Converts an unknown thrown value into a worker-safe serializable shape.\n *\n * @internal\n */\nexport function serializeError(error: unknown): SerializableError {\n  if (error instanceof CodeModeError) {\n    const result = compactError({\n      name: error.name,\n      message: error.message,\n      code: error.code,\n    });\n    if (error.stack !== undefined) {\n      result.stack = error.stack;\n    }\n    if (error.details !== undefined) {\n      result.details = error.details;\n    }\n    return result;\n  }\n\n  if (error instanceof Error) {\n    const result = compactError({\n      name: error.name,\n      message: error.message,\n    });\n    if (error.stack !== undefined) {\n      result.stack = error.stack;\n    }\n    const maybeCoded = error as Error & { code?: unknown; details?: unknown };\n    if (typeof maybeCoded.code === 'string') {\n      result.code = maybeCoded.code;\n    }\n    if (maybeCoded.details !== undefined) {\n      result.details = maybeCoded.details;\n    }\n    return result;\n  }\n\n  return {\n    name: 'Error',\n    message: String(error),\n  };\n}\n\n/**\n * Converts host bridge failures into a sandbox-visible sanitized shape.\n *\n * This intentionally omits stack traces and diagnostic details. Full host\n * diagnostics remain on the host side.\n *\n * @internal\n */\nexport function serializeBridgeErrorForGuest(\n  error: unknown,\n  context: 'tool' | 'bridge',\n): SerializableError {\n  if (error instanceof CodeModeError) {\n    return compactError({\n      name: error.name,\n      message: error.message,\n      code: error.code,\n    });\n  }\n\n  const fallback =\n    context === 'tool'\n      ? {\n          message: 'Host tool failed.',\n          code: 'CODE_MODE_HOST_TOOL_ERROR',\n        }\n      : {\n          message: 'Host bridge request failed.',\n          code: 'CODE_MODE_HOST_BRIDGE_ERROR',\n        };\n\n  return {\n    name: 'Error',\n    message: fallback.message,\n    code: fallback.code,\n  };\n}\n\nfunction compactError(error: {\n  name: string;\n  message: string;\n  stack?: string;\n  code?: string;\n  details?: unknown;\n}): SerializableError {\n  return {\n    name: error.name,\n    message: error.message,\n    ...(error.stack !== undefined ? { stack: error.stack } : {}),\n    ...(error.code !== undefined ? { code: error.code } : {}),\n    ...(error.details !== undefined ? { details: error.details } : {}),\n  };\n}\n\n/**\n * Rehydrates a serialized worker error into an Error instance.\n *\n * @internal\n */\nexport function deserializeError(error: SerializableError): Error {\n  if (error.code === 'CODE_MODE_SOURCE_TOO_LARGE') {\n    const details = error.details as\n      | { bytes?: number; maxBytes?: number }\n      | undefined;\n    const result = new CodeModeSourceTooLargeError(\n      details?.bytes ?? 0,\n      details?.maxBytes ?? 0,\n    );\n    restoreStack(result, error);\n    return result;\n  }\n\n  if (error.code === 'CODE_MODE_BRIDGE_LIMIT') {\n    const result = new CodeModeBridgeLimitError(error.message, error.details);\n    restoreStack(result, error);\n    return result;\n  }\n\n  if (error.code === 'CODE_MODE_DETACHED_BRIDGE_REQUEST') {\n    const result = new CodeModeDetachedBridgeRequestError(\n      error.message,\n      error.details,\n    );\n    restoreStack(result, error);\n    return result;\n  }\n\n  if (error.code === 'CODE_MODE_PROTOCOL_ERROR') {\n    const result = new CodeModeProtocolError(error.message, error.details);\n    restoreStack(result, error);\n    return result;\n  }\n\n  const result = new CodeModeError(\n    error.message,\n    error.code ?? 'CODE_MODE_ERROR',\n    error.details,\n  );\n  result.name = error.name;\n  restoreStack(result, error);\n  return result;\n}\n\nfunction restoreStack(error: Error, serialized: SerializableError): void {\n  if (serialized.stack) {\n    error.stack = serialized.stack;\n  }\n}\n"],"mappings":"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","names":["result"]}

package/dist/index.d.ts

@@ -0,0 +1,179 @@
+import { Tool, ModelMessage, Experimental_ToolCallerTool } from 'ai';
+
+/**
+ * Host tools made available to sandboxed code through the global `tools` object.
+ */
+type CodeModeToolSet = Record<string, Tool<any, any>>;
+/**
+ * AI SDK execution metadata forwarded to nested host tool calls.
+ */
+interface CodeModeToolExecutionOptions {
+    toolCallId: string;
+    messages: ModelMessage[];
+    abortSignal?: AbortSignal;
+    experimental_context?: unknown;
+    context?: unknown;
+}
+/**
+ * AI SDK tool returned by `createCodeModeTool`.
+ */
+type CodeModeTool = Tool<CodeModeToolInput, unknown> & {
+    description: string;
+};
+/**
+ * Input accepted by the generated code-mode tool.
+ */
+interface CodeModeToolInput {
+    /**
+     * JavaScript or type-stripped TypeScript source to execute.
+     *
+     * The source is wrapped in an async function, so top-level `await` and
+     * `return` are supported.
+     */
+    js: string;
+}
+/**
+ * Execution limits applied to each sandbox invocation.
+ */
+interface CodeModeExecutionPolicy {
+    /** @defaultValue `30_000` */
+    timeoutMs?: number;
+    /** @defaultValue `64 * 1024 * 1024` */
+    memoryLimitBytes?: number;
+    /** @defaultValue `2 * 1024 * 1024` */
+    maxStackSizeBytes?: number;
+    /** @defaultValue `1024 * 1024` */
+    maxResultBytes?: number;
+    /** @defaultValue `64 * 1024` */
+    maxConsoleOutputBytes?: number;
+    /** @defaultValue `256 * 1024` */
+    maxSourceBytes?: number;
+    /** @defaultValue `1024 * 1024` */
+    maxToolInputBytes?: number;
+    /** @defaultValue `4 * 1024 * 1024` */
+    maxToolOutputBytes?: number;
+    /** @defaultValue `256` */
+    maxBridgeRequests?: number;
+    /** @defaultValue `32` */
+    maxInFlightBridgeRequests?: number;
+}
+/**
+ * Options used by `createCodeModeTool` and `runCodeMode`.
+ */
+interface CodeModeOptions {
+    executionPolicy?: CodeModeExecutionPolicy;
+}
+/**
+ * Input for `runCodeMode`.
+ */
+interface RunCodeModeInput {
+    js: string;
+    tools: CodeModeToolSet;
+    toolExecutionOptions?: Partial<CodeModeToolExecutionOptions>;
+    options?: CodeModeOptions;
+}
+
+/**
+ * Creates an AI SDK tool that executes code-mode TypeScript in an isolated
+ * sandbox.
+ */
+declare function createCodeModeTool(tools: CodeModeToolSet, options?: CodeModeOptions): CodeModeTool;
+/**
+ * Creates a code-mode caller whose host tools are bound by the surrounding
+ * AI SDK generation call.
+ */
+declare function codeModeTool(options?: CodeModeOptions): Experimental_ToolCallerTool<CodeModeTool>;
+
+/**
+ * Base class for errors raised by code mode.
+ *
+ * All package-specific errors include a stable `code` string and may include
+ * structured `details` for diagnostics.
+ */
+declare class CodeModeError extends Error {
+    /**
+     * Stable machine-readable error code.
+     */
+    code: string;
+    /**
+     * Optional structured diagnostic details.
+     */
+    readonly details?: unknown;
+    constructor(message: string, code?: string, details?: unknown);
+}
+/**
+ * Raised when a sandbox invocation exceeds its timeout.
+ */
+declare class CodeModeTimeoutError extends CodeModeError {
+    constructor(timeoutMs: number);
+}
+/**
+ * Raised when the outer AI SDK abort signal aborts a code-mode invocation.
+ */
+declare class CodeModeAbortedError extends CodeModeError {
+    constructor();
+}
+/**
+ * Raised when the process-global worker cap has been reached.
+ *
+ * Configure the cap with `setMaxWorkers`.
+ */
+declare class CodeModeConcurrencyError extends CodeModeError {
+    constructor(maxWorkers: number);
+}
+/**
+ * Raised when the provided source exceeds `executionPolicy.maxSourceBytes`.
+ */
+declare class CodeModeSourceTooLargeError extends CodeModeError {
+    constructor(bytes: number, maxBytes: number);
+}
+/**
+ * Raised when sandboxed code exceeds bridge request limits.
+ */
+declare class CodeModeBridgeLimitError extends CodeModeError {
+    constructor(message: string, details?: unknown);
+}
+/**
+ * Raised when sandboxed code starts host bridge work and returns without
+ * awaiting or otherwise observing it.
+ */
+declare class CodeModeDetachedBridgeRequestError extends CodeModeError {
+    constructor(message: string, details?: unknown);
+}
+/**
+ * Raised when the main thread and worker protocol observes an invalid or
+ * mismatched message.
+ */
+declare class CodeModeProtocolError extends CodeModeError {
+    constructor(message: string, details?: unknown);
+}
+/**
+ * Base class for failures caused by nested host tool execution.
+ */
+declare class CodeModeToolError extends CodeModeError {
+    constructor(message: string, details?: unknown);
+}
+
+/**
+ * Runs one code-mode invocation directly without wrapping it as an AI SDK tool.
+ *
+ * The source is executed in a fresh QuickJS context with the provided host tools
+ * and execution limits.
+ *
+ * @param input - Source code, host tools, forwarded tool execution options, and code-mode options.
+ * @returns The JSON-serializable value returned by the sandboxed program.
+ */
+declare function runCodeMode(input: RunCodeModeInput): Promise<unknown>;
+
+/**
+ * Sets the process-global maximum number of active code-mode workers.
+ *
+ * Pass `undefined` or call without an argument to restore the dynamic
+ * memory-based default. The default admits at least one invocation and admits
+ * additional workers only when available memory can cover another worker.
+ *
+ * @param maxWorkers - Positive integer worker cap, or `undefined` to reset.
+ */
+declare function setMaxWorkers(maxWorkers?: number): void;
+
+export { CodeModeAbortedError, CodeModeBridgeLimitError, CodeModeConcurrencyError, CodeModeDetachedBridgeRequestError, CodeModeError, type CodeModeExecutionPolicy, type CodeModeOptions, CodeModeProtocolError, CodeModeSourceTooLargeError, CodeModeTimeoutError, type CodeModeTool, CodeModeToolError, type CodeModeToolExecutionOptions, type CodeModeToolInput, type CodeModeToolSet, type RunCodeModeInput, codeModeTool as experimental_codeModeTool, createCodeModeTool as experimental_createCodeModeTool, runCodeMode as experimental_runCodeMode, setMaxWorkers as experimental_setMaxWorkers };

package/dist/index.js

@@ -0,0 +1,33 @@
+import {
+  codeModeTool,
+  createCodeModeTool
+} from "./code-mode-tool.js";
+import {
+  CodeModeAbortedError,
+  CodeModeBridgeLimitError,
+  CodeModeConcurrencyError,
+  CodeModeDetachedBridgeRequestError,
+  CodeModeError,
+  CodeModeProtocolError,
+  CodeModeSourceTooLargeError,
+  CodeModeTimeoutError,
+  CodeModeToolError
+} from "./errors.js";
+import { runCodeMode } from "./run-code-mode.js";
+import { setMaxWorkers } from "./runtime/max-workers.js";
+export {
+  CodeModeAbortedError,
+  CodeModeBridgeLimitError,
+  CodeModeConcurrencyError,
+  CodeModeDetachedBridgeRequestError,
+  CodeModeError,
+  CodeModeProtocolError,
+  CodeModeSourceTooLargeError,
+  CodeModeTimeoutError,
+  CodeModeToolError,
+  codeModeTool as experimental_codeModeTool,
+  createCodeModeTool as experimental_createCodeModeTool,
+  runCodeMode as experimental_runCodeMode,
+  setMaxWorkers as experimental_setMaxWorkers
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export {\n  codeModeTool as experimental_codeModeTool,\n  createCodeModeTool as experimental_createCodeModeTool,\n} from './code-mode-tool.js';\nexport {\n  CodeModeAbortedError,\n  CodeModeBridgeLimitError,\n  CodeModeConcurrencyError,\n  CodeModeDetachedBridgeRequestError,\n  CodeModeError,\n  CodeModeProtocolError,\n  CodeModeSourceTooLargeError,\n  CodeModeTimeoutError,\n  CodeModeToolError,\n} from './errors.js';\nexport { runCodeMode as experimental_runCodeMode } from './run-code-mode.js';\nexport { setMaxWorkers as experimental_setMaxWorkers } from './runtime/max-workers.js';\nexport type {\n  CodeModeExecutionPolicy,\n  CodeModeOptions,\n  CodeModeTool,\n  CodeModeToolExecutionOptions,\n  CodeModeToolInput,\n  CodeModeToolSet,\n  RunCodeModeInput,\n} from './types.js';\n"],"mappings":"AAAA;AAAA,EACkB;AAAA,EACM;AAAA,OACjB;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAwB,mBAAgC;AACxD,SAA0B,qBAAkC;","names":[]}

package/dist/run-code-mode.js

@@ -0,0 +1,8 @@
+import { runManagedCodeMode } from "./runtime/manager.js";
+async function runCodeMode(input) {
+  return await runManagedCodeMode(input);
+}
+export {
+  runCodeMode
+};
+//# sourceMappingURL=run-code-mode.js.map

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

@@ -0,0 +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":[]}