@ai-sdk/code-mode 1.0.5 → 1.0.7

package/src/host-interrupt.ts

@@ -0,0 +1,49 @@
+import type { CodeModeInterruptPayload } from './types.js';
+
+const CODE_MODE_HOST_INTERRUPT_SIGNAL = Symbol.for(
+  '@ai-sdk/code-mode.host-interrupt',
+);
+
+interface CodeModeHostInterruptSignal extends Error {
+  readonly [CODE_MODE_HOST_INTERRUPT_SIGNAL]: true;
+  readonly payload: CodeModeInterruptPayload;
+}
+
+export function requestCodeModeInterrupt<
+  TPayload extends CodeModeInterruptPayload,
+>(payload: TPayload): never {
+  if (
+    typeof payload !== 'object' ||
+    payload === null ||
+    Array.isArray(payload)
+  ) {
+    throw new TypeError('Code mode interrupt payload must be an object.');
+  }
+  if (typeof payload.kind !== 'string' || payload.kind.length === 0) {
+    throw new TypeError(
+      'Code mode interrupt payload must include a string kind.',
+    );
+  }
+
+  const error = new Error('Code mode host interruption requested.');
+  error.name = 'CodeModeHostInterruptSignal';
+  Object.defineProperties(error, {
+    [CODE_MODE_HOST_INTERRUPT_SIGNAL]: { value: true },
+    payload: { value: payload },
+  });
+  throw error;
+}
+
+export function isCodeModeHostInterruptSignal(
+  value: unknown,
+): value is CodeModeHostInterruptSignal {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    (value as { [CODE_MODE_HOST_INTERRUPT_SIGNAL]?: unknown })[
+      CODE_MODE_HOST_INTERRUPT_SIGNAL
+    ] === true &&
+    typeof (value as { payload?: unknown }).payload === 'object' &&
+    (value as { payload?: unknown }).payload !== null
+  );
+}

package/src/index.ts

@@ -1,7 +1,14 @@
+export { DIRECT_TOOL_CALL } from './direct-tool-call.js';
 export {
   codeModeTool as experimental_codeModeTool,
   createCodeModeTool as experimental_createCodeModeTool,
 } from './code-mode-tool.js';
+export {
+  continueCodeModeApproval as experimental_continueCodeModeApproval,
+  getCodeModeApprovalResponse as experimental_getCodeModeApprovalResponse,
+  isCodeModeApprovalInterrupt as experimental_isCodeModeApprovalInterrupt,
+  toCodeModeApprovalMessages as experimental_toCodeModeApprovalMessages,
+} from './approval-continuation.js';
 export {
   CodeModeAbortedError,
   CodeModeBridgeLimitError,
@@ -11,16 +18,37 @@ export {
   CodeModeProtocolError,
   CodeModeSourceTooLargeError,
   CodeModeTimeoutError,
+  CodeModeToolApprovalDeniedError,
+  CodeModeToolApprovalRequiredError,
   CodeModeToolError,
 } from './errors.js';
+export { requestCodeModeInterrupt as experimental_requestCodeModeInterrupt } from './host-interrupt.js';
+export {
+  continueCodeModeInterrupt as experimental_continueCodeModeInterrupt,
+  getCodeModeInterrupt as experimental_getCodeModeInterrupt,
+  isCodeModeInterrupt as experimental_isCodeModeInterrupt,
+  unwrapCodeModeResult as experimental_unwrapCodeModeResult,
+} from './interrupt-continuation.js';
 export { runCodeMode as experimental_runCodeMode } from './run-code-mode.js';
+export { setCodeModeContinuationSigningKey as experimental_setCodeModeContinuationSigningKey } from './continuation-capability.js';
 export { setMaxWorkers as experimental_setMaxWorkers } from './runtime/max-workers.js';
 export type {
+  ApprovalDecision,
+  CodeModeApprovalInterrupt,
+  CodeModeApprovalRequest,
+  CodeModeApprovalResponse,
+  CodeModeContinuation,
+  CodeModeContinuationSecurityOptions,
   CodeModeExecutionPolicy,
+  CodeModeInterrupt,
+  CodeModeInterruptExecutionContext,
+  CodeModeInterruptPayload,
+  CodeModeInterruptResolution,
   CodeModeOptions,
   CodeModeTool,
   CodeModeToolExecutionOptions,
   CodeModeToolInput,
   CodeModeToolSet,
+  CodeModeUnwrappedResult,
   RunCodeModeInput,
 } from './types.js';

package/src/interrupt-continuation.ts

@@ -0,0 +1,173 @@
+import {
+  hasValidCodeModeContinuationCapability,
+  verifyCodeModeContinuation,
+} from './continuation-capability.js';
+import { CodeModeProtocolError } from './errors.js';
+import { runCodeMode } from './run-code-mode.js';
+import type {
+  CodeModeContinuationSecurityOptions,
+  CodeModeInterrupt,
+  CodeModeInterruptPayload,
+  CodeModeInterruptResolution,
+  CodeModeOptions,
+  CodeModeToolExecutionOptions,
+  CodeModeToolSet,
+  CodeModeUnwrappedResult,
+} from './types.js';
+
+export function isCodeModeInterrupt(
+  value: unknown,
+  continuationSecurity: CodeModeContinuationSecurityOptions = {},
+): value is CodeModeInterrupt {
+  if (
+    isRecord(value) &&
+    value.type === 'code-mode-interrupt' &&
+    typeof value.interruptId === 'string' &&
+    typeof value.toolCallId === 'string' &&
+    typeof value.toolName === 'string' &&
+    typeof value.outerToolCallId === 'string' &&
+    isRecord(value.payload) &&
+    typeof value.payload.kind === 'string' &&
+    isRecord(value.continuation) &&
+    hasValidCodeModeContinuationCapability(
+      value.continuation,
+      continuationSecurity,
+    )
+  ) {
+    try {
+      assertInterruptMatchesLedger(value as unknown as CodeModeInterrupt);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+export async function continueCodeModeInterrupt<
+  TPayload extends CodeModeInterruptPayload = CodeModeInterruptPayload,
+  TResolution = unknown,
+>({
+  interrupt,
+  resolution,
+  tools,
+  options = {},
+  toolExecutionOptions,
+}: {
+  interrupt: CodeModeInterrupt<TPayload>;
+  resolution: TResolution;
+  tools: CodeModeToolSet;
+  options?: CodeModeOptions;
+  toolExecutionOptions?: Partial<CodeModeToolExecutionOptions>;
+}): Promise<unknown> {
+  verifyCodeModeContinuation(
+    interrupt.continuation,
+    options.continuationSecurity,
+  );
+  assertInterruptMatchesLedger(interrupt);
+
+  const interruptResolution: CodeModeInterruptResolution<TResolution> = {
+    interruptId: interrupt.interruptId,
+    resolution,
+  };
+  return await runCodeMode({
+    js: interrupt.continuation.js,
+    tools,
+    options,
+    continuation: interrupt.continuation,
+    interruptResolution,
+    ...(toolExecutionOptions !== undefined ? { toolExecutionOptions } : {}),
+  });
+}
+
+export function getCodeModeInterrupt(
+  result: unknown,
+  continuationSecurity: CodeModeContinuationSecurityOptions = {},
+): CodeModeInterrupt | undefined {
+  const direct = readInterruptValue(result, continuationSecurity);
+  if (direct !== undefined) {
+    return direct;
+  }
+  if (!isRecord(result)) {
+    return undefined;
+  }
+
+  for (const key of ['toolResults', 'content'] as const) {
+    const parts = result[key];
+    if (!Array.isArray(parts)) {
+      continue;
+    }
+    for (const part of parts) {
+      if (!isRecord(part)) {
+        continue;
+      }
+      const interrupt = readInterruptValue(part.output, continuationSecurity);
+      if (interrupt !== undefined) {
+        return interrupt;
+      }
+    }
+  }
+  return undefined;
+}
+
+export function unwrapCodeModeResult(
+  result: unknown,
+  continuationSecurity: CodeModeContinuationSecurityOptions = {},
+): CodeModeUnwrappedResult {
+  const interrupt = getCodeModeInterrupt(result, continuationSecurity);
+  return interrupt === undefined
+    ? { status: 'completed', output: result }
+    : { status: 'interrupted', interrupt };
+}
+
+function readInterruptValue(
+  value: unknown,
+  continuationSecurity: CodeModeContinuationSecurityOptions,
+): CodeModeInterrupt | undefined {
+  if (isCodeModeInterrupt(value, continuationSecurity)) {
+    return value;
+  }
+  if (
+    isRecord(value) &&
+    (value.type === 'json' || value.type === 'text') &&
+    'value' in value
+  ) {
+    return readInterruptValue(value.value, continuationSecurity);
+  }
+  return undefined;
+}
+
+function assertInterruptMatchesLedger(interrupt: CodeModeInterrupt): void {
+  if (interrupt.continuation.outerToolCallId !== interrupt.outerToolCallId) {
+    throw new CodeModeProtocolError(
+      'Code-mode interrupt outer tool call id does not match its continuation.',
+    );
+  }
+  const matches = interrupt.continuation.ledger.filter(
+    entry =>
+      entry.status === 'interrupted' &&
+      entry.interruptId === interrupt.interruptId &&
+      entry.toolCallId === interrupt.toolCallId &&
+      entry.name === interrupt.toolName &&
+      jsonEqual(fromJsonPayload(entry.inputJson), interrupt.input) &&
+      jsonEqual(entry.interruptPayload, interrupt.payload),
+  );
+  if (matches.length !== 1) {
+    throw new CodeModeProtocolError(
+      'Code-mode interrupt metadata does not match the signed continuation ledger.',
+      { interruptId: interrupt.interruptId, matches: matches.length },
+    );
+  }
+}
+
+function jsonEqual(left: unknown, right: unknown): boolean {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function fromJsonPayload(valueJson: string): unknown {
+  return valueJson === '' ? undefined : JSON.parse(valueJson);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/src/runtime/guest-sources.ts

@@ -90,6 +90,93 @@ const HARDENING_SOURCE = `
 })();
 `;
 
+const DETERMINISTIC_APIS_SOURCE = `
+var __codeModeResetDateNow = (function(config) {
+  var OriginalDate = Date;
+  var dateNowMs = Number(config && config.dateNowMs);
+  if (!Number.isFinite(dateNowMs)) dateNowMs = 0;
+
+  function resetDateNow(value) {
+    var next = Number(value);
+    if (Number.isFinite(next)) dateNowMs = Math.trunc(next);
+  }
+
+  function nextDateMs() {
+    var value = dateNowMs;
+    dateNowMs += 1;
+    return value;
+  }
+
+  function CodeModeDate() {
+    if (new.target) {
+      if (arguments.length === 0) return new OriginalDate(nextDateMs());
+      return Reflect.construct(OriginalDate, arguments, new.target);
+    }
+    return new OriginalDate(nextDateMs()).toString();
+  }
+
+  Object.defineProperty(CodeModeDate, 'prototype', {
+    value: OriginalDate.prototype,
+    writable: false,
+    configurable: false,
+  });
+  Object.defineProperty(OriginalDate.prototype, 'constructor', {
+    value: CodeModeDate,
+    writable: false,
+    configurable: false,
+  });
+  Object.defineProperty(CodeModeDate, 'now', {
+    value: nextDateMs,
+    writable: false,
+    configurable: false,
+  });
+  Object.defineProperty(CodeModeDate, 'parse', {
+    value: OriginalDate.parse,
+    writable: false,
+    configurable: false,
+  });
+  Object.defineProperty(CodeModeDate, 'UTC', {
+    value: OriginalDate.UTC,
+    writable: false,
+    configurable: false,
+  });
+  Object.defineProperty(globalThis, 'Date', {
+    value: CodeModeDate,
+    writable: false,
+    configurable: false,
+  });
+
+  var randomSeed = String(config && config.randomSeed || '');
+  var mask64 = (1n << 64n) - 1n;
+  function readSeedPart(offset, fallback) {
+    var part = randomSeed.slice(offset, offset + 16);
+    return /^[0-9a-fA-F]{16}$/.test(part) ? BigInt('0x' + part) : fallback;
+  }
+  var randomState0 = readSeedPart(0, 0x243f6a8885a308d3n);
+  var randomState1 = readSeedPart(16, 0x13198a2e03707344n);
+  if ((randomState0 | randomState1) === 0n) {
+    randomState1 = 0x9e3779b97f4a7c15n;
+  }
+  function nextRandom64() {
+    var s1 = randomState0;
+    var s0 = randomState1;
+    randomState0 = s0;
+    s1 = (s1 ^ ((s1 << 23n) & mask64)) & mask64;
+    randomState1 = (s1 ^ s0 ^ (s1 >> 17n) ^ (s0 >> 26n)) & mask64;
+    return (randomState1 + s0) & mask64;
+  }
+  Object.defineProperty(Math, 'random', {
+    value: function() {
+      return Number(nextRandom64() >> 11n) / 9007199254740992;
+    },
+    writable: false,
+    configurable: false,
+  });
+
+  return resetDateNow;
+})(__codeModeDeterminism);
+`;
+
 const BRIDGE_TRACKING_SOURCE = `
 (function() {
   var nextRecordId = 0;
@@ -242,11 +329,15 @@ const SERIALIZATION_GUARD_SOURCE = `
 
 export function buildGuestRuntimeSetupSource(): string {
   return `
-(function(__codeModeInvokeTool) {
+(function(__codeModeInvokeTool, __codeModeDeterminism) {
+${DETERMINISTIC_APIS_SOURCE}
 ${HARDENING_SOURCE}
 ${BRIDGE_TRACKING_SOURCE}
 ${TOOLS_PROXY_SOURCE}
 ${SERIALIZATION_GUARD_SOURCE}
+return Object.freeze({
+  resetDateNow: __codeModeResetDateNow,
+});
 })
 `;
 }