@ai-sdk/code-mode 1.0.20 → 1.0.22

package/dist/runtime/manager.js

@@ -1,794 +0,0 @@
-import { AsyncResource } from "node:async_hooks";
-import { Buffer } from "node:buffer";
-import { randomBytes } from "node:crypto";
-import { Worker } from "node:worker_threads";
-import {
-  isCodeModeApprovalInterruptPayload,
-  normalizeApprovalResolution
-} from "../approval.js";
-import {
-  resolveCodeModeContinuationSecurity,
-  signCodeModeContinuation,
-  verifyCodeModeContinuation
-} from "../continuation-capability.js";
-import {
-  CodeModeAbortedError,
-  CodeModeBridgeLimitError,
-  CodeModeConcurrencyError,
-  CodeModeDetachedBridgeRequestError,
-  CodeModeProtocolError,
-  CodeModeTimeoutError,
-  CodeModeToolApprovalDeniedError,
-  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 continuationSecurity = resolveCodeModeContinuationSecurity(
-    input.options?.continuationSecurity
-  );
-  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 js = transformSource(input.js);
-    assertContinuationInput({
-      js,
-      continuation: input.continuation,
-      interruptResolution: input.interruptResolution,
-      continuationSecurity
-    });
-    const run = startWorkerRun({
-      ...input,
-      js,
-      normalizedOptions,
-      maxWorkers,
-      continuationSecurity
-    });
-    return await run.result;
-  } finally {
-    releaseInvocationSlot(normalizedOptions.memoryLimitBytes);
-  }
-}
-function startWorkerRun({
-  js,
-  tools,
-  toolExecutionOptions,
-  options,
-  continuation,
-  interruptResolution,
-  normalizedOptions,
-  maxWorkers,
-  continuationSecurity
-}) {
-  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();
-  let nestedToolCounter = getMaxNestedToolCounter(continuation?.ledger ?? []);
-  const forwardedContext = toolExecutionOptions?.context ?? toolExecutionOptions?.experimental_context;
-  const forwardedExperimentalContext = toolExecutionOptions?.experimental_context ?? toolExecutionOptions?.context;
-  const baseExecutionOptions = {
-    toolCallId: toolExecutionOptions?.toolCallId ?? continuation?.outerToolCallId ?? 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;
-  let interruptEntryIndex;
-  let interruptDrainCounter = 0;
-  let pendingInterruptDrainId;
-  let interruptResolutionConsumed = interruptResolution === void 0;
-  const seenWorkerRequestIds = /* @__PURE__ */ new Set();
-  const bridgeLedger = cloneLedger(continuation?.ledger ?? []);
-  const determinism = continuation?.determinism ?? createDeterminismState();
-  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;
-    }
-    if (message.type === "bridge-drained") {
-      if (pendingInterruptDrainId === void 0 || message.drainId !== pendingInterruptDrainId) {
-        failTerminal(
-          new CodeModeProtocolError(
-            `Worker sent unexpected bridge drain acknowledgement ${message.drainId}.`,
-            {
-              invocationId,
-              expectedDrainId: pendingInterruptDrainId,
-              receivedDrainId: message.drainId
-            }
-          )
-        );
-        return;
-      }
-      pendingInterruptDrainId = void 0;
-      if (inFlightBridgeRequests === 0) {
-        settleInterrupt();
-      }
-      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,
-    determinism,
-    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) {
-    const replayEntry = bridgeLedger[bridgeIndex - 1];
-    try {
-      if (replayEntry !== void 0) {
-        assertReplayEntryMatches(replayEntry, message, bridgeIndex);
-        if (replayEntry.status === "fulfilled") {
-          postBridgeResponse({
-            type: "bridge-response",
-            invocationId,
-            requestId: message.requestId,
-            success: true,
-            dateNowMs: replayEntry.dateNowMs,
-            valueJson: replayEntry.valueJson
-          });
-          return;
-        }
-        if (replayEntry.status === "rejected") {
-          postBridgeResponse({
-            type: "bridge-response",
-            invocationId,
-            requestId: message.requestId,
-            success: false,
-            dateNowMs: replayEntry.dateNowMs,
-            error: replayEntry.error
-          });
-          return;
-        }
-        if (interruptResolution?.interruptId !== replayEntry.interruptId) {
-          requestInterrupt(bridgeIndex - 1);
-          return;
-        }
-        interruptResolutionConsumed = true;
-        const isApproval = isCodeModeApprovalInterruptPayload(
-          replayEntry.interruptPayload
-        );
-        if (isApproval) {
-          const decision = normalizeApprovalResolution(
-            interruptResolution.resolution
-          );
-          if (!decision.approved) {
-            const error = new CodeModeToolApprovalDeniedError(
-              replayEntry.name,
-              fromJsonPayload(message.inputJson),
-              replayEntry.toolCallId,
-              decision.reason
-            );
-            const dateNowMs3 = Date.now();
-            const guestError = serializeBridgeErrorForGuest(error, "tool");
-            bridgeLedger[bridgeIndex - 1] = {
-              kind: "tool",
-              name: message.toolName,
-              inputJson: message.inputJson,
-              toolCallId: replayEntry.toolCallId,
-              status: "rejected",
-              dateNowMs: dateNowMs3,
-              error: guestError
-            };
-            postBridgeResponse({
-              type: "bridge-response",
-              invocationId,
-              requestId: message.requestId,
-              success: false,
-              dateNowMs: dateNowMs3,
-              error: guestError
-            });
-            return;
-          }
-        }
-        const codeModeInterrupt = isApproval ? void 0 : {
-          interruptId: replayEntry.interruptId,
-          payload: replayEntry.interruptPayload,
-          resolution: interruptResolution.resolution
-        };
-        const outcome2 = await invokeHostTool({
-          toolName: message.toolName,
-          inputJson: message.inputJson,
-          tools,
-          baseExecutionOptions,
-          codeModeOptions: options ?? {},
-          maxToolInputBytes: normalizedOptions.maxToolInputBytes,
-          maxToolOutputBytes: normalizedOptions.maxToolOutputBytes,
-          toolCallId: replayEntry.toolCallId,
-          ...codeModeInterrupt !== void 0 ? { codeModeInterrupt } : {},
-          skipApproval: true
-        });
-        if (outcome2.type === "interrupted") {
-          bridgeLedger[bridgeIndex - 1] = {
-            kind: "tool",
-            name: message.toolName,
-            inputJson: message.inputJson,
-            toolCallId: replayEntry.toolCallId,
-            interruptId: `${replayEntry.toolCallId}:interrupt`,
-            interruptPayload: outcome2.payload,
-            status: "interrupted"
-          };
-          requestInterrupt(bridgeIndex - 1);
-          return;
-        }
-        const dateNowMs2 = Date.now();
-        bridgeLedger[bridgeIndex - 1] = {
-          kind: "tool",
-          name: message.toolName,
-          inputJson: message.inputJson,
-          toolCallId: replayEntry.toolCallId,
-          status: "fulfilled",
-          dateNowMs: dateNowMs2,
-          valueJson: outcome2.valueJson
-        };
-        postBridgeResponse({
-          type: "bridge-response",
-          invocationId,
-          requestId: message.requestId,
-          success: true,
-          dateNowMs: dateNowMs2,
-          valueJson: outcome2.valueJson
-        });
-        return;
-      }
-      const toolCallId = `${baseExecutionOptions.toolCallId}:tool-${++nestedToolCounter}`;
-      const outcome = await invokeHostTool({
-        toolName: message.toolName,
-        inputJson: message.inputJson,
-        tools,
-        baseExecutionOptions,
-        codeModeOptions: options ?? {},
-        maxToolInputBytes: normalizedOptions.maxToolInputBytes,
-        maxToolOutputBytes: normalizedOptions.maxToolOutputBytes,
-        toolCallId
-      });
-      if (outcome.type === "interrupted") {
-        bridgeLedger[bridgeIndex - 1] = {
-          kind: "tool",
-          name: message.toolName,
-          inputJson: message.inputJson,
-          toolCallId,
-          interruptId: `${toolCallId}:interrupt`,
-          interruptPayload: outcome.payload,
-          status: "interrupted"
-        };
-        requestInterrupt(bridgeIndex - 1);
-        return;
-      }
-      const dateNowMs = Date.now();
-      bridgeLedger[bridgeIndex - 1] = {
-        kind: "tool",
-        name: message.toolName,
-        inputJson: message.inputJson,
-        toolCallId,
-        status: "fulfilled",
-        dateNowMs,
-        valueJson: outcome.valueJson
-      };
-      postBridgeResponse({
-        type: "bridge-response",
-        invocationId,
-        requestId: message.requestId,
-        success: true,
-        dateNowMs,
-        valueJson: outcome.valueJson
-      });
-    } catch (error) {
-      if (error instanceof CodeModeProtocolError) {
-        failTerminal(error);
-        return;
-      }
-      const dateNowMs = Date.now();
-      const guestError = serializeBridgeErrorForGuest(error, "tool");
-      const toolCallId = replayEntry?.toolCallId ?? `${baseExecutionOptions.toolCallId}:tool-${nestedToolCounter}`;
-      if (replayEntry === void 0 || replayEntry.status === "interrupted" && interruptResolution?.interruptId === replayEntry.interruptId) {
-        bridgeLedger[bridgeIndex - 1] = {
-          kind: "tool",
-          name: message.toolName,
-          inputJson: message.inputJson,
-          toolCallId,
-          status: "rejected",
-          dateNowMs,
-          error: guestError
-        };
-      }
-      postBridgeResponse({
-        type: "bridge-response",
-        invocationId,
-        requestId: message.requestId,
-        success: false,
-        dateNowMs,
-        error: guestError
-      });
-    } finally {
-      inFlightBridgeRequests--;
-      settleInterruptIfReady();
-    }
-  }
-  function requestInterrupt(entryIndex) {
-    interruptEntryIndex ??= entryIndex;
-  }
-  function settleInterruptIfReady() {
-    if (interruptEntryIndex === void 0 || terminalReached || inFlightBridgeRequests > 0 || pendingInterruptDrainId !== void 0 || !interruptResolutionConsumed) {
-      return;
-    }
-    pendingInterruptDrainId = `${invocationId}:drain-${++interruptDrainCounter}`;
-    postBridgeResponse({
-      type: "bridge-drain",
-      invocationId,
-      drainId: pendingInterruptDrainId
-    });
-  }
-  function settleInterrupt() {
-    if (interruptEntryIndex === void 0 || terminalReached || inFlightBridgeRequests > 0 || !interruptResolutionConsumed) {
-      return;
-    }
-    const entry = bridgeLedger[interruptEntryIndex];
-    if (entry === void 0 || entry.status !== "interrupted") {
-      failTerminal(
-        new CodeModeProtocolError(
-          "Code mode interruption references a missing or resolved ledger entry.",
-          { invocationId, interruptEntryIndex }
-        )
-      );
-      return;
-    }
-    const continuationState = signCodeModeContinuation(
-      {
-        version: 1,
-        js,
-        outerToolCallId: baseExecutionOptions.toolCallId,
-        determinism: { ...determinism },
-        ledger: cloneLedger(bridgeLedger)
-      },
-      continuationSecurity
-    );
-    const interrupt = {
-      type: "code-mode-interrupt",
-      interruptId: entry.interruptId,
-      toolName: entry.name,
-      toolCallId: entry.toolCallId,
-      outerToolCallId: continuationState.outerToolCallId,
-      input: fromJsonPayload(entry.inputJson),
-      payload: structuredClone(entry.interruptPayload),
-      continuation: continuationState
-    };
-    terminalReached = true;
-    abortInvocation(interrupt);
-    cleanupWorker(false);
-    settleCaller(() => resolveResult(interrupt));
-  }
-  function postBridgeResponse(message) {
-    if (terminalReached) {
-      return;
-    }
-    try {
-      worker.postMessage(message);
-    } catch (error) {
-      failTerminal(error);
-    }
-  }
-  function handleReadyMessage(message) {
-    if (terminalReached) {
-      return;
-    }
-    if (interruptEntryIndex !== void 0) {
-      settleInterruptIfReady();
-      return;
-    }
-    if (resultMessage === void 0) {
-      failTerminal(
-        new CodeModeProtocolError(
-          `Code mode worker became ready without a result for ${message.invocationId}.`,
-          { invocationId: message.invocationId }
-        )
-      );
-      return;
-    }
-    if (!interruptResolutionConsumed) {
-      failTerminal(
-        new CodeModeProtocolError(
-          "Code mode continuation completed without consuming its interrupt resolution.",
-          { interruptId: interruptResolution?.interruptId }
-        )
-      );
-      return;
-    }
-    if (continuation !== void 0 && totalBridgeRequests < bridgeLedger.length) {
-      failTerminal(
-        new CodeModeProtocolError(
-          "Code mode continuation returned before replaying the full bridge ledger.",
-          {
-            replayedBridgeRequests: totalBridgeRequests,
-            ledgerEntries: bridgeLedger.length
-          }
-        )
-      );
-      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 assertContinuationInput({
-  js,
-  continuation,
-  interruptResolution,
-  continuationSecurity
-}) {
-  if (continuation === void 0) {
-    if (interruptResolution !== void 0) {
-      throw new CodeModeProtocolError(
-        "A code-mode interrupt resolution was provided without continuation state."
-      );
-    }
-    return;
-  }
-  verifyCodeModeContinuation(continuation, continuationSecurity);
-  if (continuation.version !== 1) {
-    throw new CodeModeProtocolError(
-      "Unsupported code-mode continuation version."
-    );
-  }
-  if (continuation.js !== js) {
-    throw new CodeModeProtocolError(
-      "Code mode continuation source does not match the resumed source."
-    );
-  }
-  if (!Number.isInteger(continuation.determinism.dateNowMs) || !/^[0-9a-f]{32}$/i.test(continuation.determinism.randomSeed)) {
-    throw new CodeModeProtocolError(
-      "Code mode continuation determinism state is malformed."
-    );
-  }
-  for (const entry of continuation.ledger) {
-    if (entry.kind !== "tool" || typeof entry.name !== "string" || typeof entry.inputJson !== "string" || typeof entry.toolCallId !== "string") {
-      throw new CodeModeProtocolError(
-        "Code mode continuation ledger is malformed."
-      );
-    }
-  }
-  if (interruptResolution !== void 0) {
-    const matches = continuation.ledger.filter(
-      (entry) => entry.status === "interrupted" && entry.interruptId === interruptResolution.interruptId
-    );
-    if (matches.length !== 1) {
-      throw new CodeModeProtocolError(
-        "Interrupt resolution does not match exactly one pending continuation ledger entry.",
-        {
-          interruptId: interruptResolution.interruptId,
-          matches: matches.length
-        }
-      );
-    }
-  }
-}
-function assertReplayEntryMatches(entry, message, bridgeIndex) {
-  if (entry.name !== message.toolName || entry.inputJson !== message.inputJson) {
-    throw new CodeModeProtocolError(
-      "Code mode continuation replay diverged from its bridge ledger.",
-      {
-        bridgeIndex,
-        expectedToolName: entry.name,
-        receivedToolName: message.toolName
-      }
-    );
-  }
-}
-function createDeterminismState() {
-  return {
-    dateNowMs: Date.now(),
-    randomSeed: randomBytes(16).toString("hex")
-  };
-}
-function cloneLedger(ledger) {
-  return structuredClone(ledger);
-}
-function getMaxNestedToolCounter(ledger) {
-  let max = 0;
-  for (const entry of ledger) {
-    const match = /:tool-(\d+)$/u.exec(entry.toolCallId);
-    if (match !== null) {
-      max = Math.max(max, Number(match[1]));
-    }
-  }
-  return max;
-}
-function fromJsonPayload(valueJson) {
-  return valueJson === "" ? void 0 : JSON.parse(valueJson);
-}
-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