@ai-sdk/code-mode 0.0.1 → 1.0.1

package/dist/runtime/guest-sources.js

@@ -0,0 +1,260 @@
+const HARDENING_SOURCE = `
+(function() {
+  try { delete globalThis.crypto; } catch {}
+  if ('crypto' in globalThis) {
+    Object.defineProperty(globalThis, 'crypto', {
+      value: undefined,
+      writable: false,
+      configurable: false,
+    });
+  }
+  try { delete globalThis.performance; } catch {}
+  if ('performance' in globalThis) {
+    Object.defineProperty(globalThis, 'performance', {
+      value: undefined,
+      writable: false,
+      configurable: false,
+    });
+  }
+
+  Object.defineProperty(globalThis, 'eval', {
+    value: undefined,
+    writable: false,
+    configurable: false,
+  });
+
+  const OriginalFunction = Function;
+  const BlockedFunction = function() {
+    throw new TypeError('Function constructor is not allowed');
+  };
+  BlockedFunction.prototype = OriginalFunction.prototype;
+
+  const AsyncFunction = (async function(){}).constructor;
+  const GeneratorFunction = (function*(){}).constructor;
+  const AsyncGeneratorFunction = (async function*(){}).constructor;
+  for (const proto of [
+    OriginalFunction.prototype,
+    AsyncFunction.prototype,
+    GeneratorFunction.prototype,
+    AsyncGeneratorFunction.prototype,
+  ]) {
+    Object.defineProperty(proto, 'constructor', {
+      value: BlockedFunction,
+      writable: false,
+      configurable: false,
+    });
+  }
+  Object.defineProperty(globalThis, 'Function', {
+    value: BlockedFunction,
+    writable: false,
+    configurable: false,
+  });
+
+  const g = globalThis;
+  const toFreeze = [
+    Object, Object.prototype,
+    OriginalFunction, OriginalFunction.prototype,
+    AsyncFunction, AsyncFunction.prototype,
+    GeneratorFunction, GeneratorFunction.prototype,
+    AsyncGeneratorFunction, AsyncGeneratorFunction.prototype,
+    Array, Array.prototype,
+    String, String.prototype,
+    Number, Number.prototype,
+    g.BigInt, g.BigInt && g.BigInt.prototype,
+    Boolean, Boolean.prototype,
+    g.Symbol, g.Symbol && g.Symbol.prototype,
+    RegExp, RegExp.prototype,
+    Date, Date.prototype,
+    Map, Map.prototype,
+    Set, Set.prototype,
+    WeakMap, WeakMap.prototype,
+    WeakSet, WeakSet.prototype,
+    Promise, Promise.prototype,
+    ArrayBuffer, ArrayBuffer.prototype,
+    g.DataView, g.DataView && g.DataView.prototype,
+    JSON, Math, g.Reflect, g.Proxy,
+  ];
+  for (const name of [
+    'Int8Array','Uint8Array','Uint8ClampedArray',
+    'Int16Array','Uint16Array','Int32Array','Uint32Array',
+    'Float32Array','Float64Array',
+    'BigInt64Array','BigUint64Array',
+  ]) {
+    if (g[name]) toFreeze.push(g[name], g[name].prototype);
+  }
+  for (const obj of toFreeze) {
+    if (obj != null) {
+      try { Object.freeze(obj); } catch {}
+    }
+  }
+})();
+`;
+const BRIDGE_TRACKING_SOURCE = `
+(function() {
+  var nextRecordId = 0;
+  var records = [];
+
+  function detachedError(message, record) {
+    var error = new Error(message);
+    error.name = 'CodeModeDetachedBridgeRequestError';
+    error.code = 'CODE_MODE_DETACHED_BRIDGE_REQUEST';
+    error.details = {
+      id: record.id,
+      kind: record.kind,
+      name: record.name,
+      status: record.status
+    };
+    return error;
+  }
+
+  Object.defineProperty(globalThis, '__codeModeCreateBridgePromise', {
+    value: function(kind, name, start) {
+      var record = {
+        id: ++nextRecordId,
+        kind: String(kind),
+        name: String(name || ''),
+        observed: false,
+        status: 'idle'
+      };
+      var promise;
+      records.push(record);
+
+      function getPromise() {
+        record.observed = true;
+        if (!promise) {
+          record.status = 'pending';
+          promise = Promise.resolve().then(start).then(
+            function(value) {
+              record.status = 'fulfilled';
+              return value;
+            },
+            function(error) {
+              record.status = 'rejected';
+              throw error;
+            }
+          );
+        }
+        return promise;
+      }
+
+      return Object.freeze({
+        then: function(onFulfilled, onRejected) {
+          return getPromise().then(onFulfilled, onRejected);
+        },
+        catch: function(onRejected) {
+          return getPromise().catch(onRejected);
+        },
+        finally: function(onFinally) {
+          return getPromise().finally(onFinally);
+        },
+        get [Symbol.toStringTag]() {
+          return 'Promise';
+        }
+      });
+    },
+    writable: false,
+    configurable: false
+  });
+
+  Object.defineProperty(globalThis, '__codeModeAssertNoDetachedBridgeCalls', {
+    value: function() {
+      for (var i = 0; i < records.length; i++) {
+        var record = records[i];
+        if (!record.observed) {
+          throw detachedError(
+            'Code mode created an unawaited ' + record.kind + ' bridge request: ' + record.name + '.',
+            record
+          );
+        }
+        if (record.status === 'pending') {
+          throw detachedError(
+            'Code mode returned while a ' + record.kind + ' bridge request was still pending: ' + record.name + '.',
+            record
+          );
+        }
+      }
+    },
+    writable: false,
+    configurable: false
+  });
+})();
+`;
+const TOOLS_PROXY_SOURCE = `
+(function(invokeTool) {
+  globalThis.tools = (function makeProxy(path) {
+    return new Proxy(function(){}, {
+      get: function(_target, prop) {
+        if (prop === 'then' || typeof prop === 'symbol') return undefined;
+        return makeProxy(path.concat([String(prop)]));
+      },
+      apply: function(_target, _thisArg, args) {
+        var toolPath = path.join('.');
+        if (!toolPath) throw new Error('Tool path missing in invocation');
+        var inputJson = args.length > 0 ? JSON.stringify(args[0]) : '';
+        if (inputJson === undefined) {
+          throw new Error('Tool input must be JSON-serializable');
+        }
+        return globalThis.__codeModeCreateBridgePromise('tool', toolPath, async function() {
+          var resultJson = await invokeTool(toolPath, inputJson);
+          return resultJson === '' ? undefined : JSON.parse(resultJson);
+        });
+      }
+    });
+  })([]);
+})(__codeModeInvokeTool);
+`;
+const SERIALIZATION_GUARD_SOURCE = `
+(function() {
+  function serializeJsonPayload(value) {
+    if (typeof globalThis.__codeModeAssertNoDetachedBridgeCalls === 'function') {
+      globalThis.__codeModeAssertNoDetachedBridgeCalls();
+    }
+
+    if (value === undefined) {
+      return '';
+    }
+
+    var encoded;
+    try {
+      encoded = JSON.stringify(value);
+    } catch (error) {
+      var message = error && error.message ? String(error.message) : String(error);
+      throw new TypeError('Code mode result is not JSON-serializable: ' + message);
+    }
+
+    if (encoded === undefined) {
+      throw new TypeError('Code mode result is not JSON-serializable.');
+    }
+
+    return encoded;
+  }
+
+  Object.defineProperty(globalThis, '__codeModeSerializeJsonPayload', {
+    value: serializeJsonPayload,
+    writable: false,
+    configurable: false,
+  });
+})();
+`;
+function buildGuestRuntimeSetupSource() {
+  return `
+(function(__codeModeInvokeTool) {
+${HARDENING_SOURCE}
+${BRIDGE_TRACKING_SOURCE}
+${TOOLS_PROXY_SOURCE}
+${SERIALIZATION_GUARD_SOURCE}
+})
+`;
+}
+function wrapUserCode(js) {
+  return `
+globalThis.__codeModeResult = (async () => {
+${js}
+})();
+`;
+}
+export {
+  buildGuestRuntimeSetupSource,
+  wrapUserCode
+};
+//# sourceMappingURL=guest-sources.js.map

package/dist/runtime/guest-sources.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/runtime/guest-sources.ts"],"sourcesContent":["const HARDENING_SOURCE = `\n(function() {\n  try { delete globalThis.crypto; } catch {}\n  if ('crypto' in globalThis) {\n    Object.defineProperty(globalThis, 'crypto', {\n      value: undefined,\n      writable: false,\n      configurable: false,\n    });\n  }\n  try { delete globalThis.performance; } catch {}\n  if ('performance' in globalThis) {\n    Object.defineProperty(globalThis, 'performance', {\n      value: undefined,\n      writable: false,\n      configurable: false,\n    });\n  }\n\n  Object.defineProperty(globalThis, 'eval', {\n    value: undefined,\n    writable: false,\n    configurable: false,\n  });\n\n  const OriginalFunction = Function;\n  const BlockedFunction = function() {\n    throw new TypeError('Function constructor is not allowed');\n  };\n  BlockedFunction.prototype = OriginalFunction.prototype;\n\n  const AsyncFunction = (async function(){}).constructor;\n  const GeneratorFunction = (function*(){}).constructor;\n  const AsyncGeneratorFunction = (async function*(){}).constructor;\n  for (const proto of [\n    OriginalFunction.prototype,\n    AsyncFunction.prototype,\n    GeneratorFunction.prototype,\n    AsyncGeneratorFunction.prototype,\n  ]) {\n    Object.defineProperty(proto, 'constructor', {\n      value: BlockedFunction,\n      writable: false,\n      configurable: false,\n    });\n  }\n  Object.defineProperty(globalThis, 'Function', {\n    value: BlockedFunction,\n    writable: false,\n    configurable: false,\n  });\n\n  const g = globalThis;\n  const toFreeze = [\n    Object, Object.prototype,\n    OriginalFunction, OriginalFunction.prototype,\n    AsyncFunction, AsyncFunction.prototype,\n    GeneratorFunction, GeneratorFunction.prototype,\n    AsyncGeneratorFunction, AsyncGeneratorFunction.prototype,\n    Array, Array.prototype,\n    String, String.prototype,\n    Number, Number.prototype,\n    g.BigInt, g.BigInt && g.BigInt.prototype,\n    Boolean, Boolean.prototype,\n    g.Symbol, g.Symbol && g.Symbol.prototype,\n    RegExp, RegExp.prototype,\n    Date, Date.prototype,\n    Map, Map.prototype,\n    Set, Set.prototype,\n    WeakMap, WeakMap.prototype,\n    WeakSet, WeakSet.prototype,\n    Promise, Promise.prototype,\n    ArrayBuffer, ArrayBuffer.prototype,\n    g.DataView, g.DataView && g.DataView.prototype,\n    JSON, Math, g.Reflect, g.Proxy,\n  ];\n  for (const name of [\n    'Int8Array','Uint8Array','Uint8ClampedArray',\n    'Int16Array','Uint16Array','Int32Array','Uint32Array',\n    'Float32Array','Float64Array',\n    'BigInt64Array','BigUint64Array',\n  ]) {\n    if (g[name]) toFreeze.push(g[name], g[name].prototype);\n  }\n  for (const obj of toFreeze) {\n    if (obj != null) {\n      try { Object.freeze(obj); } catch {}\n    }\n  }\n})();\n`;\n\nconst BRIDGE_TRACKING_SOURCE = `\n(function() {\n  var nextRecordId = 0;\n  var records = [];\n\n  function detachedError(message, record) {\n    var error = new Error(message);\n    error.name = 'CodeModeDetachedBridgeRequestError';\n    error.code = 'CODE_MODE_DETACHED_BRIDGE_REQUEST';\n    error.details = {\n      id: record.id,\n      kind: record.kind,\n      name: record.name,\n      status: record.status\n    };\n    return error;\n  }\n\n  Object.defineProperty(globalThis, '__codeModeCreateBridgePromise', {\n    value: function(kind, name, start) {\n      var record = {\n        id: ++nextRecordId,\n        kind: String(kind),\n        name: String(name || ''),\n        observed: false,\n        status: 'idle'\n      };\n      var promise;\n      records.push(record);\n\n      function getPromise() {\n        record.observed = true;\n        if (!promise) {\n          record.status = 'pending';\n          promise = Promise.resolve().then(start).then(\n            function(value) {\n              record.status = 'fulfilled';\n              return value;\n            },\n            function(error) {\n              record.status = 'rejected';\n              throw error;\n            }\n          );\n        }\n        return promise;\n      }\n\n      return Object.freeze({\n        then: function(onFulfilled, onRejected) {\n          return getPromise().then(onFulfilled, onRejected);\n        },\n        catch: function(onRejected) {\n          return getPromise().catch(onRejected);\n        },\n        finally: function(onFinally) {\n          return getPromise().finally(onFinally);\n        },\n        get [Symbol.toStringTag]() {\n          return 'Promise';\n        }\n      });\n    },\n    writable: false,\n    configurable: false\n  });\n\n  Object.defineProperty(globalThis, '__codeModeAssertNoDetachedBridgeCalls', {\n    value: function() {\n      for (var i = 0; i < records.length; i++) {\n        var record = records[i];\n        if (!record.observed) {\n          throw detachedError(\n            'Code mode created an unawaited ' + record.kind + ' bridge request: ' + record.name + '.',\n            record\n          );\n        }\n        if (record.status === 'pending') {\n          throw detachedError(\n            'Code mode returned while a ' + record.kind + ' bridge request was still pending: ' + record.name + '.',\n            record\n          );\n        }\n      }\n    },\n    writable: false,\n    configurable: false\n  });\n})();\n`;\n\nconst TOOLS_PROXY_SOURCE = `\n(function(invokeTool) {\n  globalThis.tools = (function makeProxy(path) {\n    return new Proxy(function(){}, {\n      get: function(_target, prop) {\n        if (prop === 'then' || typeof prop === 'symbol') return undefined;\n        return makeProxy(path.concat([String(prop)]));\n      },\n      apply: function(_target, _thisArg, args) {\n        var toolPath = path.join('.');\n        if (!toolPath) throw new Error('Tool path missing in invocation');\n        var inputJson = args.length > 0 ? JSON.stringify(args[0]) : '';\n        if (inputJson === undefined) {\n          throw new Error('Tool input must be JSON-serializable');\n        }\n        return globalThis.__codeModeCreateBridgePromise('tool', toolPath, async function() {\n          var resultJson = await invokeTool(toolPath, inputJson);\n          return resultJson === '' ? undefined : JSON.parse(resultJson);\n        });\n      }\n    });\n  })([]);\n})(__codeModeInvokeTool);\n`;\n\nconst SERIALIZATION_GUARD_SOURCE = `\n(function() {\n  function serializeJsonPayload(value) {\n    if (typeof globalThis.__codeModeAssertNoDetachedBridgeCalls === 'function') {\n      globalThis.__codeModeAssertNoDetachedBridgeCalls();\n    }\n\n    if (value === undefined) {\n      return '';\n    }\n\n    var encoded;\n    try {\n      encoded = JSON.stringify(value);\n    } catch (error) {\n      var message = error && error.message ? String(error.message) : String(error);\n      throw new TypeError('Code mode result is not JSON-serializable: ' + message);\n    }\n\n    if (encoded === undefined) {\n      throw new TypeError('Code mode result is not JSON-serializable.');\n    }\n\n    return encoded;\n  }\n\n  Object.defineProperty(globalThis, '__codeModeSerializeJsonPayload', {\n    value: serializeJsonPayload,\n    writable: false,\n    configurable: false,\n  });\n})();\n`;\n\nexport function buildGuestRuntimeSetupSource(): string {\n  return `\n(function(__codeModeInvokeTool) {\n${HARDENING_SOURCE}\n${BRIDGE_TRACKING_SOURCE}\n${TOOLS_PROXY_SOURCE}\n${SERIALIZATION_GUARD_SOURCE}\n})\n`;\n}\n\nexport function wrapUserCode(js: string): string {\n  return `\nglobalThis.__codeModeResult = (async () => {\n${js}\n})();\n`;\n}\n"],"mappings":"AAAA,MAAM,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA4FzB,MAAM,yBAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2F/B,MAAM,qBAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAyB3B,MAAM,6BAA6B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkC5B,SAAS,+BAAuC;AACrD,SAAO;AAAA;AAAA,EAEP,gBAAgB;AAAA,EAChB,sBAAsB;AAAA,EACtB,kBAAkB;AAAA,EAClB,0BAA0B;AAAA;AAAA;AAG5B;AAEO,SAAS,aAAa,IAAoB;AAC/C,SAAO;AAAA;AAAA,EAEP,EAAE;AAAA;AAAA;AAGJ;","names":[]}

package/dist/runtime/manager.js

@@ -0,0 +1,414 @@
+import { AsyncResource } from "node:async_hooks";
+import { Buffer } from "node:buffer";
+import { Worker } from "node:worker_threads";
+import {
+  CodeModeAbortedError,
+  CodeModeBridgeLimitError,
+  CodeModeConcurrencyError,
+  CodeModeDetachedBridgeRequestError,
+  CodeModeProtocolError,
+  CodeModeTimeoutError,
+  deserializeError,
+  serializeBridgeErrorForGuest
+} from "../errors.js";
+import { invokeHostTool } from "../tool-invocation.js";
+import { normalizeOptions } from "../utils/options.js";
+import { assertSourceSize, transformSource } from "../utils/source-cache.js";
+import { getMaxWorkers } from "./max-workers.js";
+import { INLINE_CODE_MODE_WORKER_SOURCE } from "./worker-source.js";
+let invocationCounter = 0;
+let activeInvocations = 0;
+let inlineWorkerUrl;
+const idleWorkers = [];
+async function runManagedCodeMode(input) {
+  const normalizedOptions = normalizeOptions(input.options);
+  const maxWorkers = getMaxWorkers({
+    memoryLimitBytes: normalizedOptions.memoryLimitBytes,
+    activeWorkers: activeInvocations
+  });
+  if (activeInvocations >= maxWorkers) {
+    throw new CodeModeConcurrencyError(maxWorkers);
+  }
+  activeInvocations++;
+  try {
+    if (input.toolExecutionOptions?.abortSignal?.aborted) {
+      throw new CodeModeAbortedError();
+    }
+    assertSourceSize(input.js, normalizedOptions.maxSourceBytes);
+    const run = startWorkerRun({
+      ...input,
+      js: transformSource(input.js),
+      normalizedOptions,
+      maxWorkers
+    });
+    return await run.result;
+  } finally {
+    releaseInvocationSlot(normalizedOptions.memoryLimitBytes);
+  }
+}
+function startWorkerRun({
+  js,
+  tools,
+  toolExecutionOptions,
+  normalizedOptions,
+  maxWorkers
+}) {
+  const invocationId = `code-mode-${++invocationCounter}`;
+  const pooledWorker = acquireWorker(maxWorkers);
+  const worker = pooledWorker.worker;
+  const invocationContext = new AsyncResource("ai-sdk-code-mode:invocation");
+  const bindInvocationContext = (handler) => {
+    return (...args) => {
+      invocationContext.runInAsyncScope(handler, void 0, ...args);
+    };
+  };
+  const outerAbortSignal = toolExecutionOptions?.abortSignal;
+  const invocationAbortController = new AbortController();
+  const forwardedContext = toolExecutionOptions?.context ?? toolExecutionOptions?.experimental_context;
+  const forwardedExperimentalContext = toolExecutionOptions?.experimental_context ?? toolExecutionOptions?.context;
+  const baseExecutionOptions = {
+    toolCallId: toolExecutionOptions?.toolCallId ?? invocationId,
+    messages: toolExecutionOptions?.messages ?? [],
+    abortSignal: invocationAbortController.signal,
+    ...forwardedExperimentalContext !== void 0 ? { experimental_context: forwardedExperimentalContext } : {},
+    ...forwardedContext !== void 0 ? { context: forwardedContext } : {}
+  };
+  let resultMessage;
+  let callerSettled = false;
+  let terminalReached = false;
+  let workerCleanedUp = false;
+  let totalBridgeRequests = 0;
+  let inFlightBridgeRequests = 0;
+  const seenWorkerRequestIds = /* @__PURE__ */ new Set();
+  let resolveResult;
+  let rejectResult;
+  const result = new Promise((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
+  const abortInvocation = (reason) => {
+    if (!invocationAbortController.signal.aborted) {
+      invocationAbortController.abort(reason);
+    }
+  };
+  const cleanupWorker = (reuseWorker) => {
+    if (workerCleanedUp) {
+      return;
+    }
+    workerCleanedUp = true;
+    clearTimeout(timeoutHandle);
+    outerAbortSignal?.removeEventListener("abort", onAbort);
+    worker.off("message", onMessage);
+    worker.off("error", onError);
+    worker.off("exit", onExit);
+    invocationContext.emitDestroy();
+    if (reuseWorker) {
+      releaseWorker(pooledWorker);
+    } else {
+      destroyWorker(pooledWorker);
+    }
+  };
+  const settleCaller = (settle) => {
+    if (callerSettled) {
+      return;
+    }
+    callerSettled = true;
+    try {
+      settle();
+    } catch (error) {
+      rejectResult(error);
+    }
+  };
+  const failTerminal = (error) => {
+    if (terminalReached) {
+      return;
+    }
+    terminalReached = true;
+    abortInvocation(error);
+    cleanupWorker(false);
+    settleCaller(() => rejectResult(error));
+  };
+  const onAbort = bindInvocationContext(() => {
+    failTerminal(new CodeModeAbortedError());
+  });
+  const timeoutHandle = setTimeout(
+    bindInvocationContext(() => {
+      failTerminal(new CodeModeTimeoutError(normalizedOptions.timeoutMs));
+    }),
+    normalizedOptions.timeoutMs
+  );
+  const onMessage = bindInvocationContext((message) => {
+    if (message.invocationId !== invocationId) {
+      failTerminal(
+        new CodeModeProtocolError(
+          `Worker message invocationId mismatch: expected ${invocationId}, received ${message.invocationId}.`,
+          {
+            expectedInvocationId: invocationId,
+            receivedInvocationId: message.invocationId,
+            messageType: message.type
+          }
+        )
+      );
+      return;
+    }
+    if (message.type === "result") {
+      if (resultMessage !== void 0) {
+        failTerminal(
+          new CodeModeProtocolError(
+            `Worker sent duplicate result for invocation ${invocationId}.`,
+            { invocationId }
+          )
+        );
+        return;
+      }
+      resultMessage = message;
+      return;
+    }
+    if (message.type === "ready") {
+      handleReadyMessage(message);
+      return;
+    }
+    const bridgeIndex = markWorkerRequest(message);
+    if (bridgeIndex !== void 0) {
+      void handleToolRequest(message, bridgeIndex);
+    }
+  });
+  const onError = bindInvocationContext((error) => {
+    failTerminal(error);
+  });
+  const onExit = bindInvocationContext((code) => {
+    if (!terminalReached) {
+      failTerminal(
+        new Error(
+          `Code mode worker exited before completion with code ${code}.`
+        )
+      );
+    }
+  });
+  worker.on("message", onMessage);
+  worker.on("error", onError);
+  worker.on("exit", onExit);
+  outerAbortSignal?.addEventListener("abort", onAbort, { once: true });
+  if (outerAbortSignal?.aborted) {
+    onAbort();
+  }
+  const runMessage = {
+    type: "run",
+    invocationId,
+    js,
+    options: {
+      timeoutMs: normalizedOptions.timeoutMs,
+      memoryLimitBytes: normalizedOptions.memoryLimitBytes,
+      maxStackSizeBytes: normalizedOptions.maxStackSizeBytes,
+      maxResultBytes: normalizedOptions.maxResultBytes,
+      maxConsoleOutputBytes: normalizedOptions.maxConsoleOutputBytes
+    }
+  };
+  if (!terminalReached) {
+    try {
+      worker.postMessage(runMessage);
+    } catch (error) {
+      failTerminal(error);
+    }
+  }
+  return { result };
+  function markWorkerRequest(message) {
+    if (terminalReached) {
+      return void 0;
+    }
+    if (seenWorkerRequestIds.has(message.requestId)) {
+      failTerminal(
+        new CodeModeProtocolError(
+          `Worker sent duplicate requestId ${message.requestId}.`,
+          { invocationId, requestId: message.requestId }
+        )
+      );
+      return void 0;
+    }
+    seenWorkerRequestIds.add(message.requestId);
+    if (totalBridgeRequests >= normalizedOptions.maxBridgeRequests) {
+      failTerminal(
+        new CodeModeBridgeLimitError(
+          `Code mode exceeded the ${normalizedOptions.maxBridgeRequests} bridge request limit.`,
+          {
+            invocationId,
+            maxBridgeRequests: normalizedOptions.maxBridgeRequests
+          }
+        )
+      );
+      return void 0;
+    }
+    if (inFlightBridgeRequests >= normalizedOptions.maxInFlightBridgeRequests) {
+      failTerminal(
+        new CodeModeBridgeLimitError(
+          `Code mode exceeded the ${normalizedOptions.maxInFlightBridgeRequests} in-flight bridge request limit.`,
+          {
+            invocationId,
+            maxInFlightBridgeRequests: normalizedOptions.maxInFlightBridgeRequests
+          }
+        )
+      );
+      return void 0;
+    }
+    totalBridgeRequests++;
+    inFlightBridgeRequests++;
+    return totalBridgeRequests;
+  }
+  async function handleToolRequest(message, bridgeIndex) {
+    try {
+      const valueJson = await invokeHostTool({
+        toolName: message.toolName,
+        inputJson: message.inputJson,
+        tools,
+        baseExecutionOptions,
+        maxToolInputBytes: normalizedOptions.maxToolInputBytes,
+        maxToolOutputBytes: normalizedOptions.maxToolOutputBytes,
+        toolCallId: `${baseExecutionOptions.toolCallId}:tool-${bridgeIndex}`
+      });
+      postBridgeResponse({
+        type: "bridge-response",
+        invocationId,
+        requestId: message.requestId,
+        success: true,
+        valueJson
+      });
+    } catch (error) {
+      postBridgeResponse({
+        type: "bridge-response",
+        invocationId,
+        requestId: message.requestId,
+        success: false,
+        error: serializeBridgeErrorForGuest(error, "tool")
+      });
+    } finally {
+      inFlightBridgeRequests--;
+    }
+  }
+  function postBridgeResponse(message) {
+    if (terminalReached) {
+      return;
+    }
+    try {
+      worker.postMessage(message);
+    } catch (error) {
+      failTerminal(error);
+    }
+  }
+  function handleReadyMessage(message) {
+    if (terminalReached) {
+      return;
+    }
+    if (resultMessage === void 0) {
+      failTerminal(
+        new CodeModeProtocolError(
+          `Code mode worker became ready without a result for ${message.invocationId}.`,
+          { invocationId: message.invocationId }
+        )
+      );
+      return;
+    }
+    terminalReached = true;
+    const finalResultMessage = resultMessage;
+    if (inFlightBridgeRequests > 0) {
+      const error = finalResultMessage.success ? new CodeModeDetachedBridgeRequestError(
+        `Code mode returned while ${inFlightBridgeRequests} bridge request(s) were still in flight.`,
+        {
+          invocationId,
+          inFlightBridgeRequests,
+          totalBridgeRequests
+        }
+      ) : deserializeResultError(finalResultMessage);
+      abortInvocation(error);
+      cleanupWorker(false);
+      settleCaller(() => rejectResult(error));
+      return;
+    }
+    cleanupWorker(true);
+    settleCaller(
+      () => settleWithResultMessage(finalResultMessage, resolveResult, rejectResult)
+    );
+  }
+}
+function acquireWorker(maxPoolSize) {
+  let pooledWorker = idleWorkers.pop();
+  while (pooledWorker?.destroyed) {
+    pooledWorker = idleWorkers.pop();
+  }
+  pooledWorker ??= createWorker();
+  pooledWorker.worker.removeAllListeners("exit");
+  pooledWorker.worker.ref();
+  trimIdleWorkers(Math.max(0, maxPoolSize - activeInvocations));
+  return pooledWorker;
+}
+function createWorker() {
+  return {
+    worker: new Worker(getInlineWorkerUrl(), { execArgv: [] }),
+    destroyed: false
+  };
+}
+function getInlineWorkerUrl() {
+  inlineWorkerUrl ??= new URL(
+    `data:text/javascript;base64,${Buffer.from(INLINE_CODE_MODE_WORKER_SOURCE).toString("base64")}`
+  );
+  return inlineWorkerUrl;
+}
+function releaseWorker(pooledWorker) {
+  if (pooledWorker.destroyed) {
+    return;
+  }
+  pooledWorker.worker.once("exit", () => {
+    pooledWorker.destroyed = true;
+    const index = idleWorkers.indexOf(pooledWorker);
+    if (index !== -1) {
+      idleWorkers.splice(index, 1);
+    }
+  });
+  pooledWorker.worker.unref();
+  idleWorkers.push(pooledWorker);
+}
+function destroyWorker(pooledWorker) {
+  if (pooledWorker.destroyed) {
+    return;
+  }
+  pooledWorker.destroyed = true;
+  pooledWorker.worker.removeAllListeners();
+  void pooledWorker.worker.terminate();
+}
+function trimIdleWorkers(maxIdleWorkers) {
+  while (idleWorkers.length > maxIdleWorkers) {
+    const pooledWorker = idleWorkers.pop();
+    if (pooledWorker !== void 0) {
+      destroyWorker(pooledWorker);
+    }
+  }
+}
+function releaseInvocationSlot(memoryLimitBytes) {
+  activeInvocations = Math.max(0, activeInvocations - 1);
+  const maxWorkers = getMaxWorkers({
+    memoryLimitBytes,
+    activeWorkers: activeInvocations
+  });
+  trimIdleWorkers(Math.max(0, maxWorkers - activeInvocations));
+}
+function settleWithResultMessage(message, resolve, reject) {
+  if (!message.success) {
+    reject(deserializeResultError(message));
+    return;
+  }
+  resolve(
+    message.valueJson === "" || message.valueJson === void 0 ? void 0 : JSON.parse(message.valueJson)
+  );
+}
+function deserializeResultError(message) {
+  if (message.error === void 0) {
+    return new CodeModeProtocolError(
+      `Code mode worker failed without an error for ${message.invocationId}.`,
+      { invocationId: message.invocationId }
+    );
+  }
+  return deserializeError(message.error);
+}
+export {
+  runManagedCodeMode
+};
+//# sourceMappingURL=manager.js.map