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

package/dist/utils/options.js

@@ -0,0 +1,76 @@
+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;
+function normalizeOptions(options = {}) {
+  const executionPolicy = options.executionPolicy ?? {};
+  return {
+    timeoutMs: positiveInteger(
+      executionPolicy.timeoutMs,
+      DEFAULT_TIMEOUT_MS,
+      "executionPolicy.timeoutMs"
+    ),
+    memoryLimitBytes: positiveInteger(
+      executionPolicy.memoryLimitBytes,
+      DEFAULT_MEMORY_LIMIT_BYTES,
+      "executionPolicy.memoryLimitBytes"
+    ),
+    maxStackSizeBytes: positiveInteger(
+      executionPolicy.maxStackSizeBytes,
+      DEFAULT_STACK_LIMIT_BYTES,
+      "executionPolicy.maxStackSizeBytes"
+    ),
+    maxResultBytes: positiveInteger(
+      executionPolicy.maxResultBytes,
+      DEFAULT_MAX_RESULT_BYTES,
+      "executionPolicy.maxResultBytes"
+    ),
+    maxConsoleOutputBytes: positiveInteger(
+      executionPolicy.maxConsoleOutputBytes,
+      DEFAULT_MAX_CONSOLE_OUTPUT_BYTES,
+      "executionPolicy.maxConsoleOutputBytes"
+    ),
+    maxSourceBytes: positiveInteger(
+      executionPolicy.maxSourceBytes,
+      DEFAULT_MAX_SOURCE_BYTES,
+      "executionPolicy.maxSourceBytes"
+    ),
+    maxToolInputBytes: positiveInteger(
+      executionPolicy.maxToolInputBytes,
+      DEFAULT_MAX_TOOL_INPUT_BYTES,
+      "executionPolicy.maxToolInputBytes"
+    ),
+    maxToolOutputBytes: positiveInteger(
+      executionPolicy.maxToolOutputBytes,
+      DEFAULT_MAX_TOOL_OUTPUT_BYTES,
+      "executionPolicy.maxToolOutputBytes"
+    ),
+    maxBridgeRequests: positiveInteger(
+      executionPolicy.maxBridgeRequests,
+      DEFAULT_MAX_BRIDGE_REQUESTS,
+      "executionPolicy.maxBridgeRequests"
+    ),
+    maxInFlightBridgeRequests: positiveInteger(
+      executionPolicy.maxInFlightBridgeRequests,
+      DEFAULT_MAX_IN_FLIGHT_BRIDGE_REQUESTS,
+      "executionPolicy.maxInFlightBridgeRequests"
+    )
+  };
+}
+function positiveInteger(value, fallback, path) {
+  const resolved = value ?? fallback;
+  if (!Number.isInteger(resolved) || resolved <= 0) {
+    throw new TypeError(`${path} must be a positive integer.`);
+  }
+  return resolved;
+}
+export {
+  normalizeOptions
+};
+//# sourceMappingURL=options.js.map

package/dist/utils/options.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/options.ts"],"sourcesContent":["import type { CodeModeOptions, NormalizedCodeModeOptions } from '../types.js';\n\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\nexport function normalizeOptions(\n  options: CodeModeOptions = {},\n): NormalizedCodeModeOptions {\n  const executionPolicy = options.executionPolicy ?? {};\n\n  return {\n    timeoutMs: positiveInteger(\n      executionPolicy.timeoutMs,\n      DEFAULT_TIMEOUT_MS,\n      'executionPolicy.timeoutMs',\n    ),\n    memoryLimitBytes: positiveInteger(\n      executionPolicy.memoryLimitBytes,\n      DEFAULT_MEMORY_LIMIT_BYTES,\n      'executionPolicy.memoryLimitBytes',\n    ),\n    maxStackSizeBytes: positiveInteger(\n      executionPolicy.maxStackSizeBytes,\n      DEFAULT_STACK_LIMIT_BYTES,\n      'executionPolicy.maxStackSizeBytes',\n    ),\n    maxResultBytes: positiveInteger(\n      executionPolicy.maxResultBytes,\n      DEFAULT_MAX_RESULT_BYTES,\n      'executionPolicy.maxResultBytes',\n    ),\n    maxConsoleOutputBytes: positiveInteger(\n      executionPolicy.maxConsoleOutputBytes,\n      DEFAULT_MAX_CONSOLE_OUTPUT_BYTES,\n      'executionPolicy.maxConsoleOutputBytes',\n    ),\n    maxSourceBytes: positiveInteger(\n      executionPolicy.maxSourceBytes,\n      DEFAULT_MAX_SOURCE_BYTES,\n      'executionPolicy.maxSourceBytes',\n    ),\n    maxToolInputBytes: positiveInteger(\n      executionPolicy.maxToolInputBytes,\n      DEFAULT_MAX_TOOL_INPUT_BYTES,\n      'executionPolicy.maxToolInputBytes',\n    ),\n    maxToolOutputBytes: positiveInteger(\n      executionPolicy.maxToolOutputBytes,\n      DEFAULT_MAX_TOOL_OUTPUT_BYTES,\n      'executionPolicy.maxToolOutputBytes',\n    ),\n    maxBridgeRequests: positiveInteger(\n      executionPolicy.maxBridgeRequests,\n      DEFAULT_MAX_BRIDGE_REQUESTS,\n      'executionPolicy.maxBridgeRequests',\n    ),\n    maxInFlightBridgeRequests: positiveInteger(\n      executionPolicy.maxInFlightBridgeRequests,\n      DEFAULT_MAX_IN_FLIGHT_BRIDGE_REQUESTS,\n      'executionPolicy.maxInFlightBridgeRequests',\n    ),\n  };\n}\n\nfunction positiveInteger(\n  value: number | undefined,\n  fallback: number,\n  path: string,\n): number {\n  const resolved = value ?? fallback;\n  if (!Number.isInteger(resolved) || resolved <= 0) {\n    throw new TypeError(`${path} must be a positive integer.`);\n  }\n  return resolved;\n}\n"],"mappings":"AAEA,MAAM,qBAAqB;AAC3B,MAAM,6BAA6B,KAAK,OAAO;AAC/C,MAAM,4BAA4B,IAAI,OAAO;AAC7C,MAAM,2BAA2B,OAAO;AACxC,MAAM,mCAAmC,KAAK;AAC9C,MAAM,2BAA2B,MAAM;AACvC,MAAM,+BAA+B,OAAO;AAC5C,MAAM,gCAAgC,IAAI,OAAO;AACjD,MAAM,8BAA8B;AACpC,MAAM,wCAAwC;AAEvC,SAAS,iBACd,UAA2B,CAAC,GACD;AAC3B,QAAM,kBAAkB,QAAQ,mBAAmB,CAAC;AAEpD,SAAO;AAAA,IACL,WAAW;AAAA,MACT,gBAAgB;AAAA,MAChB;AAAA,MACA;AAAA,IACF;AAAA,IACA,kBAAkB;AAAA,MAChB,gBAAgB;AAAA,MAChB;AAAA,MACA;AAAA,IACF;AAAA,IACA,mBAAmB;AAAA,MACjB,gBAAgB;AAAA,MAChB;AAAA,MACA;AAAA,IACF;AAAA,IACA,gBAAgB;AAAA,MACd,gBAAgB;AAAA,MAChB;AAAA,MACA;AAAA,IACF;AAAA,IACA,uBAAuB;AAAA,MACrB,gBAAgB;AAAA,MAChB;AAAA,MACA;AAAA,IACF;AAAA,IACA,gBAAgB;AAAA,MACd,gBAAgB;AAAA,MAChB;AAAA,MACA;AAAA,IACF;AAAA,IACA,mBAAmB;AAAA,MACjB,gBAAgB;AAAA,MAChB;AAAA,MACA;AAAA,IACF;AAAA,IACA,oBAAoB;AAAA,MAClB,gBAAgB;AAAA,MAChB;AAAA,MACA;AAAA,IACF;AAAA,IACA,mBAAmB;AAAA,MACjB,gBAAgB;AAAA,MAChB;AAAA,MACA;AAAA,IACF;AAAA,IACA,2BAA2B;AAAA,MACzB,gBAAgB;AAAA,MAChB;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,gBACP,OACA,UACA,MACQ;AACR,QAAM,WAAW,SAAS;AAC1B,MAAI,CAAC,OAAO,UAAU,QAAQ,KAAK,YAAY,GAAG;AAChD,UAAM,IAAI,UAAU,GAAG,IAAI,8BAA8B;AAAA,EAC3D;AACA,SAAO;AACT;","names":[]}

package/dist/utils/serialization.js

@@ -0,0 +1,49 @@
+import { CodeModeError } from "../errors.js";
+function assertJsonSerializable(value, maxBytes, label) {
+  void toJsonPayload(value, maxBytes, label);
+}
+function toJsonPayload(value, maxBytes, label) {
+  if (value === void 0) {
+    return "";
+  }
+  return toStrictJsonPayload(value, maxBytes, label);
+}
+function toStrictJsonPayload(value, maxBytes, label) {
+  let encoded;
+  try {
+    encoded = JSON.stringify(value);
+  } catch (error) {
+    throw new CodeModeError(
+      `${label} is not JSON-serializable: ${getErrorMessage(error)}`,
+      "CODE_MODE_SERIALIZATION_ERROR"
+    );
+  }
+  if (encoded === void 0) {
+    throw new CodeModeError(
+      `${label} is not JSON-serializable.`,
+      "CODE_MODE_SERIALIZATION_ERROR"
+    );
+  }
+  assertJsonPayloadSize(encoded, maxBytes, label);
+  return encoded;
+}
+function assertJsonPayloadSize(valueJson, maxBytes, label) {
+  const bytes = new TextEncoder().encode(valueJson).byteLength;
+  if (bytes > maxBytes) {
+    throw new CodeModeError(
+      `${label} exceeds the ${maxBytes} byte size limit.`,
+      "CODE_MODE_SERIALIZATION_ERROR",
+      { bytes, maxBytes }
+    );
+  }
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export {
+  assertJsonPayloadSize,
+  assertJsonSerializable,
+  toJsonPayload,
+  toStrictJsonPayload
+};
+//# sourceMappingURL=serialization.js.map

package/dist/utils/serialization.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/serialization.ts"],"sourcesContent":["import { CodeModeError } from '../errors.js';\n\nexport function assertJsonSerializable(\n  value: unknown,\n  maxBytes: number,\n  label: string,\n): void {\n  void toJsonPayload(value, maxBytes, label);\n}\n\nexport function toJsonPayload(\n  value: unknown,\n  maxBytes: number,\n  label: string,\n): string {\n  if (value === undefined) {\n    return '';\n  }\n\n  return toStrictJsonPayload(value, maxBytes, label);\n}\n\nexport function toStrictJsonPayload(\n  value: unknown,\n  maxBytes: number,\n  label: string,\n): string {\n  let encoded: string | undefined;\n  try {\n    encoded = JSON.stringify(value);\n  } catch (error) {\n    throw new CodeModeError(\n      `${label} is not JSON-serializable: ${getErrorMessage(error)}`,\n      'CODE_MODE_SERIALIZATION_ERROR',\n    );\n  }\n\n  if (encoded === undefined) {\n    throw new CodeModeError(\n      `${label} is not JSON-serializable.`,\n      'CODE_MODE_SERIALIZATION_ERROR',\n    );\n  }\n\n  assertJsonPayloadSize(encoded, maxBytes, label);\n  return encoded;\n}\n\nexport function assertJsonPayloadSize(\n  valueJson: string,\n  maxBytes: number,\n  label: string,\n): void {\n  const bytes = new TextEncoder().encode(valueJson).byteLength;\n  if (bytes > maxBytes) {\n    throw new CodeModeError(\n      `${label} exceeds the ${maxBytes} byte size limit.`,\n      'CODE_MODE_SERIALIZATION_ERROR',\n      { bytes, maxBytes },\n    );\n  }\n}\n\nfunction getErrorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n"],"mappings":"AAAA,SAAS,qBAAqB;AAEvB,SAAS,uBACd,OACA,UACA,OACM;AACN,OAAK,cAAc,OAAO,UAAU,KAAK;AAC3C;AAEO,SAAS,cACd,OACA,UACA,OACQ;AACR,MAAI,UAAU,QAAW;AACvB,WAAO;AAAA,EACT;AAEA,SAAO,oBAAoB,OAAO,UAAU,KAAK;AACnD;AAEO,SAAS,oBACd,OACA,UACA,OACQ;AACR,MAAI;AACJ,MAAI;AACF,cAAU,KAAK,UAAU,KAAK;AAAA,EAChC,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,GAAG,KAAK,8BAA8B,gBAAgB,KAAK,CAAC;AAAA,MAC5D;AAAA,IACF;AAAA,EACF;AAEA,MAAI,YAAY,QAAW;AACzB,UAAM,IAAI;AAAA,MACR,GAAG,KAAK;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,wBAAsB,SAAS,UAAU,KAAK;AAC9C,SAAO;AACT;AAEO,SAAS,sBACd,WACA,UACA,OACM;AACN,QAAM,QAAQ,IAAI,YAAY,EAAE,OAAO,SAAS,EAAE;AAClD,MAAI,QAAQ,UAAU;AACpB,UAAM,IAAI;AAAA,MACR,GAAG,KAAK,gBAAgB,QAAQ;AAAA,MAChC;AAAA,MACA,EAAE,OAAO,SAAS;AAAA,IACpB;AAAA,EACF;AACF;AAEA,SAAS,gBAAgB,OAAwB;AAC/C,SAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D;","names":[]}

package/dist/utils/source-cache.js

@@ -0,0 +1,77 @@
+import { createHash } from "node:crypto";
+import { stripTypeScriptTypes } from "node:module";
+import { CodeModeSourceTooLargeError } from "../errors.js";
+const MAX_CACHE_ENTRIES = 256;
+const MAX_CACHE_BYTES = 4 * 1024 * 1024;
+const MAX_CACHE_ENTRY_BYTES = 64 * 1024;
+const transformedSourceCache = /* @__PURE__ */ new Map();
+let transformedSourceCacheBytes = 0;
+function assertSourceSize(source, maxSourceBytes) {
+  const bytes = byteLength(source);
+  if (bytes > maxSourceBytes) {
+    throw new CodeModeSourceTooLargeError(bytes, maxSourceBytes);
+  }
+}
+function transformSource(source) {
+  const hash = createHash("sha256").update("strip:").update(source).digest("hex");
+  const cached = transformedSourceCache.get(hash);
+  if (cached !== void 0) {
+    transformedSourceCache.delete(hash);
+    transformedSourceCache.set(hash, cached);
+    return cached.source;
+  }
+  const transformed = stripSnippetTypes(source);
+  const transformedBytes = byteLength(transformed);
+  if (transformedBytes <= MAX_CACHE_ENTRY_BYTES) {
+    transformedSourceCache.set(hash, {
+      source: transformed,
+      bytes: transformedBytes
+    });
+    transformedSourceCacheBytes += transformedBytes;
+    evictTransformedSourceCache();
+  }
+  return transformed;
+}
+function getTransformedSourceCacheStats() {
+  return {
+    entries: transformedSourceCache.size,
+    bytes: transformedSourceCacheBytes,
+    maxEntries: MAX_CACHE_ENTRIES,
+    maxBytes: MAX_CACHE_BYTES,
+    maxEntryBytes: MAX_CACHE_ENTRY_BYTES
+  };
+}
+function clearTransformedSourceCache() {
+  transformedSourceCache.clear();
+  transformedSourceCacheBytes = 0;
+}
+function stripSnippetTypes(source) {
+  const prefix = "async function __codeModeUser__(){\n";
+  const suffix = "\n}";
+  const stripped = stripTypeScriptTypes(`${prefix}${source}${suffix}`);
+  if (!stripped.startsWith(prefix) || !stripped.endsWith(suffix)) {
+    return source;
+  }
+  return stripped.slice(prefix.length, -suffix.length);
+}
+function evictTransformedSourceCache() {
+  while (transformedSourceCache.size > MAX_CACHE_ENTRIES || transformedSourceCacheBytes > MAX_CACHE_BYTES) {
+    const oldest = transformedSourceCache.keys().next().value;
+    if (oldest === void 0) {
+      return;
+    }
+    const entry = transformedSourceCache.get(oldest);
+    transformedSourceCache.delete(oldest);
+    transformedSourceCacheBytes -= entry?.bytes ?? 0;
+  }
+}
+function byteLength(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+export {
+  assertSourceSize,
+  clearTransformedSourceCache,
+  getTransformedSourceCacheStats,
+  transformSource
+};
+//# sourceMappingURL=source-cache.js.map

package/dist/utils/source-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/source-cache.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\nimport { stripTypeScriptTypes } from 'node:module';\nimport { CodeModeSourceTooLargeError } from '../errors.js';\n\nconst MAX_CACHE_ENTRIES = 256;\nconst MAX_CACHE_BYTES = 4 * 1024 * 1024;\nconst MAX_CACHE_ENTRY_BYTES = 64 * 1024;\nconst transformedSourceCache = new Map<\n  string,\n  {\n    source: string;\n    bytes: number;\n  }\n>();\nlet transformedSourceCacheBytes = 0;\n\nexport function assertSourceSize(source: string, maxSourceBytes: number): void {\n  const bytes = byteLength(source);\n  if (bytes > maxSourceBytes) {\n    throw new CodeModeSourceTooLargeError(bytes, maxSourceBytes);\n  }\n}\n\nexport function transformSource(source: string): string {\n  const hash = createHash('sha256')\n    .update('strip:')\n    .update(source)\n    .digest('hex');\n  const cached = transformedSourceCache.get(hash);\n  if (cached !== undefined) {\n    transformedSourceCache.delete(hash);\n    transformedSourceCache.set(hash, cached);\n    return cached.source;\n  }\n\n  const transformed = stripSnippetTypes(source);\n  const transformedBytes = byteLength(transformed);\n  if (transformedBytes <= MAX_CACHE_ENTRY_BYTES) {\n    transformedSourceCache.set(hash, {\n      source: transformed,\n      bytes: transformedBytes,\n    });\n    transformedSourceCacheBytes += transformedBytes;\n    evictTransformedSourceCache();\n  }\n  return transformed;\n}\n\nexport function getTransformedSourceCacheStats() {\n  return {\n    entries: transformedSourceCache.size,\n    bytes: transformedSourceCacheBytes,\n    maxEntries: MAX_CACHE_ENTRIES,\n    maxBytes: MAX_CACHE_BYTES,\n    maxEntryBytes: MAX_CACHE_ENTRY_BYTES,\n  };\n}\n\nexport function clearTransformedSourceCache(): void {\n  transformedSourceCache.clear();\n  transformedSourceCacheBytes = 0;\n}\n\nfunction stripSnippetTypes(source: string): string {\n  const prefix = 'async function __codeModeUser__(){\\n';\n  const suffix = '\\n}';\n  const stripped = stripTypeScriptTypes(`${prefix}${source}${suffix}`);\n  if (!stripped.startsWith(prefix) || !stripped.endsWith(suffix)) {\n    return source;\n  }\n  return stripped.slice(prefix.length, -suffix.length);\n}\n\nfunction evictTransformedSourceCache(): void {\n  while (\n    transformedSourceCache.size > MAX_CACHE_ENTRIES ||\n    transformedSourceCacheBytes > MAX_CACHE_BYTES\n  ) {\n    const oldest = transformedSourceCache.keys().next().value;\n    if (oldest === undefined) {\n      return;\n    }\n    const entry = transformedSourceCache.get(oldest);\n    transformedSourceCache.delete(oldest);\n    transformedSourceCacheBytes -= entry?.bytes ?? 0;\n  }\n}\n\nfunction byteLength(value: string): number {\n  return new TextEncoder().encode(value).byteLength;\n}\n"],"mappings":"AAAA,SAAS,kBAAkB;AAC3B,SAAS,4BAA4B;AACrC,SAAS,mCAAmC;AAE5C,MAAM,oBAAoB;AAC1B,MAAM,kBAAkB,IAAI,OAAO;AACnC,MAAM,wBAAwB,KAAK;AACnC,MAAM,yBAAyB,oBAAI,IAMjC;AACF,IAAI,8BAA8B;AAE3B,SAAS,iBAAiB,QAAgB,gBAA8B;AAC7E,QAAM,QAAQ,WAAW,MAAM;AAC/B,MAAI,QAAQ,gBAAgB;AAC1B,UAAM,IAAI,4BAA4B,OAAO,cAAc;AAAA,EAC7D;AACF;AAEO,SAAS,gBAAgB,QAAwB;AACtD,QAAM,OAAO,WAAW,QAAQ,EAC7B,OAAO,QAAQ,EACf,OAAO,MAAM,EACb,OAAO,KAAK;AACf,QAAM,SAAS,uBAAuB,IAAI,IAAI;AAC9C,MAAI,WAAW,QAAW;AACxB,2BAAuB,OAAO,IAAI;AAClC,2BAAuB,IAAI,MAAM,MAAM;AACvC,WAAO,OAAO;AAAA,EAChB;AAEA,QAAM,cAAc,kBAAkB,MAAM;AAC5C,QAAM,mBAAmB,WAAW,WAAW;AAC/C,MAAI,oBAAoB,uBAAuB;AAC7C,2BAAuB,IAAI,MAAM;AAAA,MAC/B,QAAQ;AAAA,MACR,OAAO;AAAA,IACT,CAAC;AACD,mCAA+B;AAC/B,gCAA4B;AAAA,EAC9B;AACA,SAAO;AACT;AAEO,SAAS,iCAAiC;AAC/C,SAAO;AAAA,IACL,SAAS,uBAAuB;AAAA,IAChC,OAAO;AAAA,IACP,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,eAAe;AAAA,EACjB;AACF;AAEO,SAAS,8BAAoC;AAClD,yBAAuB,MAAM;AAC7B,gCAA8B;AAChC;AAEA,SAAS,kBAAkB,QAAwB;AACjD,QAAM,SAAS;AACf,QAAM,SAAS;AACf,QAAM,WAAW,qBAAqB,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE;AACnE,MAAI,CAAC,SAAS,WAAW,MAAM,KAAK,CAAC,SAAS,SAAS,MAAM,GAAG;AAC9D,WAAO;AAAA,EACT;AACA,SAAO,SAAS,MAAM,OAAO,QAAQ,CAAC,OAAO,MAAM;AACrD;AAEA,SAAS,8BAAoC;AAC3C,SACE,uBAAuB,OAAO,qBAC9B,8BAA8B,iBAC9B;AACA,UAAM,SAAS,uBAAuB,KAAK,EAAE,KAAK,EAAE;AACpD,QAAI,WAAW,QAAW;AACxB;AAAA,IACF;AACA,UAAM,QAAQ,uBAAuB,IAAI,MAAM;AAC/C,2BAAuB,OAAO,MAAM;AACpC,mCAA+B,OAAO,SAAS;AAAA,EACjD;AACF;AAEA,SAAS,WAAW,OAAuB;AACzC,SAAO,IAAI,YAAY,EAAE,OAAO,KAAK,EAAE;AACzC;","names":[]}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@ai-sdk/code-mode",
+  "version": "0.0.0-2d998b35-20260731001744",
+  "description": "QuickJS-backed code mode tool for AI SDK",
+  "keywords": [
+    "ai",
+    "ai-sdk",
+    "agents",
+    "code-mode",
+    "quickjs",
+    "sandbox",
+    "tools"
+  ],
+  "type": "module",
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "source": "./src/index.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.test-d.ts",
+    "!src/**/__snapshots__",
+    "!src/**/__fixtures__",
+    "!src/utils/test-helpers.ts",
+    "LICENSE",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "ai": "0.0.0-2d998b35-20260731001744"
+  },
+  "devDependencies": {
+    "@types/node": "22.19.19",
+    "esbuild": "^0.28.1",
+    "quickjs-emscripten": "^0.32.0",
+    "tsup": "^8.5.1",
+    "typescript": "5.8.3",
+    "zod": "3.25.76",
+    "@vercel/ai-tsconfig": "0.0.0",
+    "ai": "0.0.0-2d998b35-20260731001744"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "homepage": "https://ai-sdk.dev/docs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vercel/ai",
+    "directory": "packages/code-mode"
+  },
+  "bugs": {
+    "url": "https://github.com/vercel/ai/issues"
+  },
+  "scripts": {
+    "build": "pnpm clean && tsup --tsconfig tsconfig.build.json && node scripts/embed-inline-worker.mjs",
+    "clean": "del-cli build dist *.tsbuildinfo",
+    "type-check": "tsc --build && tsc -p src/tsconfig.json",
+    "test": "pnpm test:node",
+    "test:watch": "vitest --config vitest.node.config.js",
+    "test:node": "vitest --config vitest.node.config.js --run",
+    "test:e2e": "pnpm build && vitest --config vitest.e2e.config.ts --run"
+  }
+}

package/src/code-mode-tool.ts

@@ -0,0 +1,60 @@
+import {
+  experimental_toolCaller,
+  jsonSchema,
+  tool,
+  type Experimental_ToolCallerTool,
+} from 'ai';
+import { runCodeMode } from './run-code-mode.js';
+import { buildCodeModeToolDescription } from './tool-prompt.js';
+import type {
+  CodeModeOptions,
+  CodeModeTool,
+  CodeModeToolInput,
+  CodeModeToolSet,
+} from './types.js';
+
+/**
+ * Creates an AI SDK tool that executes code-mode TypeScript in an isolated
+ * sandbox.
+ */
+export function createCodeModeTool(
+  tools: CodeModeToolSet,
+  options: CodeModeOptions = {},
+): CodeModeTool {
+  return tool<CodeModeToolInput, unknown, Record<string, unknown>>({
+    description: buildCodeModeToolDescription(tools),
+    inputSchema: jsonSchema<CodeModeToolInput>({
+      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,
+      }),
+  }) as CodeModeTool;
+}
+
+/**
+ * Creates a code-mode caller whose host tools are bound by the surrounding
+ * AI SDK generation call.
+ */
+export function codeModeTool(
+  options: CodeModeOptions = {},
+): Experimental_ToolCallerTool<CodeModeTool> {
+  return experimental_toolCaller(createCodeModeTool({}, options), {
+    type: 'local',
+    bind: tools =>
+      createCodeModeTool(tools as unknown as CodeModeToolSet, options),
+  });
+}

package/src/errors.ts

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

package/src/index.ts

@@ -0,0 +1,26 @@
+export {
+  codeModeTool as experimental_codeModeTool,
+  createCodeModeTool as experimental_createCodeModeTool,
+} from './code-mode-tool.js';
+export {
+  CodeModeAbortedError,
+  CodeModeBridgeLimitError,
+  CodeModeConcurrencyError,
+  CodeModeDetachedBridgeRequestError,
+  CodeModeError,
+  CodeModeProtocolError,
+  CodeModeSourceTooLargeError,
+  CodeModeTimeoutError,
+  CodeModeToolError,
+} from './errors.js';
+export { runCodeMode as experimental_runCodeMode } from './run-code-mode.js';
+export { setMaxWorkers as experimental_setMaxWorkers } from './runtime/max-workers.js';
+export type {
+  CodeModeExecutionPolicy,
+  CodeModeOptions,
+  CodeModeTool,
+  CodeModeToolExecutionOptions,
+  CodeModeToolInput,
+  CodeModeToolSet,
+  RunCodeModeInput,
+} from './types.js';

package/src/run-code-mode.ts

@@ -0,0 +1,15 @@
+import { runManagedCodeMode } from './runtime/manager.js';
+import type { RunCodeModeInput } from './types.js';
+
+/**
+ * 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.
+ */
+export async function runCodeMode(input: RunCodeModeInput): Promise<unknown> {
+  return await runManagedCodeMode(input);
+}