eve 0.82.0 → 0.83.0

package/docs/subagents/index.mdx

@@ -34,7 +34,7 @@ The copy uses the root's instructions, connections, auth, and sandbox. It receiv
 
 The parent transfers data to the child through the `message` input it gives the subagent. Do not include sensitive data in a subagent request unless that child and its inherited tools, connections, sandbox, and telemetry path are appropriate for that data.
 
-An authored workflow can open the same root-copy target through `ctx.agent("agent")`. To keep the copied configuration but use another model for that child session, pass a [model override to `ctx.agent`](./tools/workflows#delegate-work-ctxagent). The model-facing built-in tool does not accept a model choice.
+An authored workflow can open the same root-copy target through `ctx.agent("agent")`. To keep the copied configuration but use another model for that child session, pass a [model override to `ctx.agent`](./tools/workflows#delegate-work-ctxagent). The default model-facing tool does not accept a model choice; an authored [`agentWithModel` tool](./concepts/built-in-tools#agent) can expose that choice in its input.
 
 To prevent the root session from delegating to a fresh copy of itself, set `tool: false` on the root agent:
 
@@ -212,7 +212,7 @@ The root built-in `agent` tool is the exception. Its children reuse the root's s
 
 ## What the parent sees
 
-eve lowers every tool-enabled subagent visible to the current agent (the root built-in copy, declared, or [remote](./guides/remote-agents)) into a model-visible tool with the same `{ message, taskId? }` shape. The parent packs `message` with everything the child needs, since the child never sees the parent's history. To require structured output from a child, open a session with it from an authored workflow tool with [`ctx.agent(name)`](./tools/workflows#delegate-work-ctxagent) and pass `outputSchema` to `send()`; the schema applies to that turn, and the session accepts follow-up messages until the workflow run finishes.
+By default, eve lowers every tool-enabled subagent visible to the current agent (the root built-in copy, declared, or [remote](./guides/remote-agents)) into a model-visible tool with the same `{ message, taskId? }` shape. The opt-in [`agentWithModel` root-copy tool](./concepts/built-in-tools#agent) instead uses `{ message, model, taskId? }`. The parent packs `message` with everything the child needs, since the child never sees the parent's history. To require structured output from a child, open a session with it from an authored workflow tool with [`ctx.agent(name)`](./tools/workflows#delegate-work-ctxagent) and pass `outputSchema` to `send()`; the schema applies to that turn, and the session accepts follow-up messages until the workflow run finishes.
 
 Declared subagents can call nested subagents defined under their own directories. eve does not apply a separate depth limit; nesting ends where the authored directory tree ends. The built-in `agent` follows the stricter root-only rule above, so `limits.maxSubagentDepth` no longer exists.
 

package/docs/tools/overview.mdx

@@ -339,6 +339,25 @@ eve writes each returned file to the session sandbox and keeps only a reference
 
 When compaction drops older tool results, each file becomes a text reference such as `Attached file /workspace/.eve/attachments/<hash>/chart.png (image/png)`. The built-in `read_file` tool shows PNG, JPEG, GIF, and WebP images up to 3 MiB and PDFs up to 20 MiB to the model as files, so the agent can open a compacted image or PDF again.
 
+#### Send a file by URL
+
+For large files that already live in object storage, such as PDFs behind a presigned S3 link, return the URL instead of the bytes with `toolOutputPart.fileUrl`:
+
+```ts
+toModelOutput(output) {
+  return toolOutput.content([
+    toolOutputPart.text(`Contract ${output.id}:`),
+    toolOutputPart.fileUrl(output.signedUrl, { mediaType: "application/pdf" }),
+  ]);
+},
+```
+
+eve keeps only the URL in session history and does not write the file to the sandbox. The model provider fetches the URL itself when it supports that for the file's type; otherwise the AI SDK downloads the file before the call. Only `https:` URLs are accepted.
+
+Every later model call sends the same URL again, so it must stay readable for the rest of the session. A presigned URL that expires mid-session makes later model calls fail. The provider still counts the file's input tokens on each call, the same as an inline file.
+
+Unlike a staged file, a URL part has no sandbox path to fall back on. When compaction drops the tool result, the file becomes `Attached file <filename> (<mediaType>)` and the URL is gone. If the agent may need the file again later, also return a text part with an id or path the tool can fetch it by.
+
 Do not return secrets, credentials, unnecessary personal data, or unbounded sensitive content from tools. Filter, minimize, and redact tool outputs before returning them.
 
 ## What to read next

package/docs/tools/workflows.mdx

@@ -90,9 +90,9 @@ or days later, the run resumes, deploys, and returns. The model sees one tool re
   `agent`, `agents`, `ask`, and `reply`; each call it receives carries its own `callId` and
   `abortSignal`.
   A `"use step"` helper that receives `ctx` directly gets a restricted `WorkflowStepToolContext` with
-  `session`, `callId`, `toolName`, `abortSignal`, `getToken`, and `requireAuth`. Read `ctx.agents`, call
+  `session`, `callId`, `toolName`, `abortSignal`, `getSandbox`, `getToken`, and `requireAuth`. Read `ctx.agents`, call
   `ctx.agent()`, and call `ctx.ask()` in the workflow body; pass only the serializable values the step needs.
-  `getSandbox` remains unavailable.
+  Call `getSandbox`, `getToken`, and `requireAuth` in a step: the workflow body throws when it calls them.
 - The tool's input must be a JSON object. Workflow bodies are for static tools under `agent/tools/`,
   not tools returned from `defineDynamic` resolvers.
 
@@ -146,9 +146,21 @@ continue a child from an earlier call. Agent authorization, questions, approvals
 behave as they do for sessions an authored workflow tool opens with `ctx.agent`.
 
 The sandbox resumes after every pending call in the current batch settles. `Promise.all` supports
-fan-out followed by fan-in, but `Promise.race` does not resume after only the first child settles.
-A failed child turn throws at the corresponding `ctx.agent` call, so generated code can catch it.
-The program must return a JSON-serializable value.
+fan-out followed by fan-in. The program must await every `ctx.agent` call before it returns. A call
+that is still pending at that point, such as one that is never awaited or one that loses a
+`Promise.race` or `Promise.any`, fails the workflow.
+
+A failed child turn, an invalid call, or a call over the `maxSubagents` budget throws a
+`WorkflowProgramAgentError` at that `ctx.agent` call, which the program can catch; the message
+says which.
+
+The sandbox converts the program's return value and each `ctx.agent` input with `JSON.stringify`,
+so a `Date` becomes a string and functions and `undefined` members drop. A return value that
+converts to nothing, such as `undefined`, becomes `null`. Each converted value may be up to 1 MiB of
+JSON, each child reply up to 4 MiB of JSON, and the program source up to 256 KiB.
+
+Each start or resume may spend up to 30 seconds running JavaScript and up to 5 minutes in total.
+Time spent waiting for child agents does not count toward either limit.
 
 ### Migrate from `experimental_workflow`
 
@@ -438,6 +450,62 @@ itself contains no credentials.
 Cancelling an authorization wait withdraws its callback. Cancellation uses the existing turn
 cancellation path rather than a separate authorization completion event.
 
+## Use the session sandbox in a step
+
+Pass `ctx` directly to a step helper and call `ctx.getSandbox()` there. The step opens the
+[sandbox](/docs/sandbox) of the session that called the tool, the same sandbox that session's
+turns use. When the session shares its parent's sandbox, as a copy started by the built-in `agent`
+tool does, the step opens that shared sandbox. The step sees files the session wrote, and the
+session's later tool calls see files the step writes:
+
+```ts title="agent/tools/analyze.ts"
+import { defineWorkflowTool, type WorkflowStepToolContext } from "eve/tools";
+import { z } from "zod";
+
+export default defineWorkflowTool({
+  description: "Prepare the input file for an analysis run.",
+  inputSchema: z.object({ value: z.string() }),
+  async task(input, ctx) {
+    "use workflow";
+    await prepareInput(ctx, input);
+    return { path: "/workspace/input.json" };
+  },
+});
+
+async function prepareInput(ctx: WorkflowStepToolContext, input: { value: string }) {
+  "use step";
+  const sandbox = await ctx.getSandbox();
+  await sandbox.writeTextFile({ path: "/workspace/input.json", content: JSON.stringify(input) });
+}
+```
+
+- The workflow body cannot open the sandbox, because it replays. `ctx.getSandbox()` in the body
+  throws and tells you to pass `ctx` to a step helper.
+- The step opens the sandbox directly, with any sandbox provider. If the session recorded its
+  sandbox before it called the tool, the step resumes it. Otherwise, or if that sandbox is gone by
+  the time the step runs, the step opens it the way the session's first turn would: it runs your
+  `defineSandbox()` definition, and the provider finds or creates the sandbox by the session's id. The session's later turns open the same sandbox. Your
+  definition can run once for each caller that opens the sandbox before the session records it,
+  so make its initialization safe to repeat.
+- The step does not own the sandbox. When the step ends, even by throwing, eve lets go of the
+  step's handle and leaves the sandbox running for the session. eve never stops or deletes the
+  sandbox for a step, and `sandbox.stop()` and `sandbox.delete()` in a step fail without a retry,
+  because the session's turns may be using the sandbox.
+- The session removes the sandbox when the session ends, even when only a step opened it. A step
+  that is still running when the session ends can open the sandbox again after that cleanup, and
+  nothing removes the new one.
+- When the eve server shuts down, it stops the sandboxes its sessions opened, but not one that
+  only a step opened. With Docker, that container keeps running until the session ends or you
+  stop it.
+- A step can use the sandbox while the session's turns use it too, as subagents that share a
+  sandbox do. Give each one its own files to write.
+- Steps run at least once and retry after a failure, so make sandbox writes safe to repeat. Write
+  whole files instead of appending to them, or check for earlier output first.
+- When the session shares its parent's sandbox, the step opens it by the parent's session id with
+  the parent's sandbox definition, and the parent removes it when the parent ends.
+- A step runs wherever the workflow runs. A sandbox that lives on one machine, such as just-bash
+  on the local disk, is reachable from a step only on that machine, as in local development.
+
 ## Ask a human: `ctx.ask`
 
 ```ts

package/docs/tutorial/run-analysis.mdx

@@ -29,9 +29,9 @@ Top-level workspace entries get advertised to the model automatically, so it kno
 
 ## Install the chart dependencies
 
-Python needs a sandbox that runs real binaries. For local development, start a Docker-compatible daemon and run `docker info` to verify it is reachable before restarting `npm run dev`. eve also supports [microsandbox](../sandbox#microsandbox) on compatible hosts. The `just-bash` fallback cannot run Python or install packages; installing Python on your laptop does not add it to the sandbox. You can [continue to the next chapter](./remember-definitions) if you do not want to set up a local container or VM yet.
+Python needs a sandbox that runs real binaries. For local development, start a Docker-compatible daemon and run `docker info` to verify it is reachable before restarting `npm run dev`. The `just-bash` fallback cannot run Python or install packages; installing Python on your laptop does not add it to the sandbox. You can [continue to the next chapter](./remember-definitions) if you do not want to set up a local container yet.
 
-The default eve images for Docker, microsandbox, and Vercel Sandbox include Python, but not matplotlib. Add this definition alongside `workspace/` to install matplotlib in a virtual environment. It uses the same environment for installation and chart execution, without changing the system Python:
+The default eve images for Docker and Vercel Sandbox include Python, but not matplotlib. Add this definition alongside `workspace/` to install matplotlib in a virtual environment. It uses the same environment for installation and chart execution, without changing the system Python:
 
 ```ts title="agent/sandbox/sandbox.ts"
 import { DefaultSandbox, defineSandbox } from "eve/sandbox";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.82.0",
+  "version": "0.83.0",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [
@@ -262,11 +262,6 @@
       "import": "./dist/src/public/sandbox/just-bash.js",
       "default": "./dist/src/public/sandbox/just-bash.js"
     },
-    "./sandbox/microsandbox": {
-      "types": "./dist/src/public/sandbox/microsandbox.d.ts",
-      "import": "./dist/src/public/sandbox/microsandbox.js",
-      "default": "./dist/src/public/sandbox/microsandbox.js"
-    },
     "./sandbox/vercel": {
       "types": "./dist/src/public/sandbox/vercel.d.ts",
       "import": "./dist/src/public/sandbox/vercel.js",
@@ -511,6 +506,11 @@
       "import": "./dist/src/public/channels/discord/index.js",
       "default": "./dist/src/public/channels/discord/index.js"
     },
+    "./channels/discord/gateway": {
+      "types": "./dist/src/public/channels/discord/gateway/index.d.ts",
+      "import": "./dist/src/public/channels/discord/gateway/index.js",
+      "default": "./dist/src/public/channels/discord/gateway/index.js"
+    },
     "./channels/twilio": {
       "types": "./dist/src/public/channels/twilio/index.d.ts",
       "import": "./dist/src/public/channels/twilio/index.js",
@@ -561,7 +561,6 @@
   "devDependencies": {
     "@agentclientprotocol/sdk": "1.3.0",
     "@ai-sdk/anthropic": "^4.0.78",
-    "@ai-sdk/code-mode": "^1.0.94",
     "@ai-sdk/google": "^4.0.93",
     "@ai-sdk/mcp": "^2.0.73",
     "@ai-sdk/openai": "^4.0.91",
@@ -600,12 +599,12 @@
     "@vercel/sandbox": "3.3.0",
     "@vercel/schedules": "0.0.0-alpha.11",
     "@vercel/sdk": "1.28.8",
-    "@workflow/core": "5.2.0",
-    "@workflow/errors": "5.0.3",
+    "@workflow/core": "5.2.3",
+    "@workflow/errors": "5.0.5",
     "@workflow/serde": "5.0.0",
-    "@workflow/world": "5.0.3",
-    "@workflow/world-local": "5.1.0",
-    "@workflow/world-vercel": "5.2.0",
+    "@workflow/world": "5.0.5",
+    "@workflow/world-local": "5.1.2",
+    "@workflow/world-vercel": "5.2.3",
     "ai": "^7.0.137",
     "chat": "4.42.0",
     "chokidar": "5.0.0",
@@ -620,13 +619,12 @@
     "just-bash": "3.1.0",
     "just-secrets": "0.0.2",
     "marked": "17.0.6",
-    "microsandbox": "0.5.5",
-    "next": "16.3.4",
+    "next": "16.3.8",
     "picocolors": "1.1.1",
     "playwright-core": "1.63.0",
     "react": "19.2.6",
     "react-test-renderer": "19.2.6",
-    "run": "2.1.2",
+    "run": "2.1.8",
     "semver": "7.8.4",
     "svelte": "^5.0.0",
     "turndown": "7.2.4",
@@ -642,8 +640,7 @@
     "braintrust": "^3.0.0",
     "chat": "^4.42.0",
     "dd-trace": "^6.13.0",
-    "just-bash": "^3.1.0",
-    "microsandbox": "^0.5.0"
+    "just-bash": "^3.1.0"
   },
   "peerDependenciesMeta": {
     "@opentelemetry/api": {
@@ -660,9 +657,6 @@
     },
     "just-bash": {
       "optional": true
-    },
-    "microsandbox": {
-      "optional": true
     }
   },
   "engines": {

package/dist/src/compiled/@ai-sdk/code-mode/_run.d.ts

@@ -1 +0,0 @@
-export declare function setMaxWorkers(maxWorkers?: number): void;

package/dist/src/compiled/@ai-sdk/code-mode/index.d.ts

@@ -1,325 +0,0 @@
-import { Experimental_ToolCallerTool, ModelMessage, Tool } from "ai";
-import { setMaxWorkers as experimental_setMaxWorkers } from "./_run.js";
-//#region src/direct-tool-call.d.ts
-/**
- * Allows the model to call a tool directly.
- *
- * Use a string instead of a Symbol to allow for serializability.
- */
-export declare const DIRECT_TOOL_CALL = "AI_SDK_DIRECT_TOOL_CALL";
-//#endregion
-//#region src/types.d.ts
-/**
- * Host tools made available to sandboxed code through the global `tools` object.
- */
-type CodeModeToolSet = Record<string, Tool<any, any>>;
-/**
- * AI SDK execution metadata forwarded to nested host tool calls.
- */
-interface CodeModeToolExecutionOptions {
-  toolCallId: string;
-  messages: ModelMessage[];
-  abortSignal?: AbortSignal;
-  experimental_context?: unknown;
-  context?: unknown;
-  codeModeInterrupt?: CodeModeInterruptExecutionContext;
-}
-/**
- * AI SDK tool returned by `createCodeModeTool`.
- */
-type CodeModeTool = Tool<CodeModeToolInput, unknown> & {
-  description: string;
-};
-/**
- * Input accepted by the generated code-mode tool.
- */
-interface CodeModeToolInput {
-  /**
-   * JavaScript or type-stripped TypeScript source to execute.
-   *
-   * The source is wrapped in an async function, so top-level `await` and
-   * `return` are supported.
-   */
-  js: string;
-}
-type ApprovalDecision = 'approved' | 'denied' | {
-  approved: boolean;
-  reason?: string;
-};
-interface CodeModeApprovalRequest {
-  toolName: string;
-  input: unknown;
-  toolCallId: string;
-}
-interface CodeModeApprovalResponse {
-  approvalId: string;
-  approved: boolean;
-  reason?: string;
-}
-interface CodeModeInterruptPayload {
-  kind: string;
-  [key: string]: unknown;
-}
-interface CodeModeInterruptResolution<TResolution = unknown> {
-  interruptId: string;
-  resolution: TResolution;
-}
-interface CodeModeInterruptExecutionContext<TPayload extends CodeModeInterruptPayload = CodeModeInterruptPayload, TResolution = unknown> {
-  interruptId: string;
-  payload: TPayload;
-  resolution: TResolution;
-}
-interface CodeModeContinuationAuth {
-  alg: 'HMAC-SHA256';
-  nonce: string;
-  issuedAtMs: number;
-  expiresAtMs: number;
-  signature: string;
-}
-/**
- * Opaque continuation state for an interrupted code-mode invocation.
- *
- * @remarks
- * The token and compatibility metadata are authenticated. Applications should
- * persist this value without reading or modifying its fields.
- */
-interface CodeModeContinuation {
-  version: 2;
-  js: string;
-  outerToolCallId: string;
-  toolNames: string[];
-  token: string;
-  pendingInterruptions: CodeModePendingInterruption[];
-  resolutions: CodeModePendingResolution[];
-  auth: CodeModeContinuationAuth;
-}
-interface CodeModeInterrupt<TPayload extends CodeModeInterruptPayload = CodeModeInterruptPayload> {
-  type: 'code-mode-interrupt';
-  interruptId: string;
-  toolName: string;
-  toolCallId: string;
-  outerToolCallId: string;
-  input: unknown;
-  payload: TPayload;
-  continuation: CodeModeContinuation;
-}
-type CodeModeUnwrappedResult = {
-  status: 'completed';
-  output: unknown;
-} | {
-  status: 'interrupted';
-  interrupt: CodeModeInterrupt;
-};
-interface CodeModeApprovalInterruptPayload extends CodeModeInterruptPayload {
-  kind: 'ai-sdk-code-mode/tool-approval';
-}
-type CodeModeApprovalInterrupt = CodeModeInterrupt<CodeModeApprovalInterruptPayload>;
-/**
- * Execution limits applied to each sandbox invocation.
- */
-interface CodeModeExecutionPolicy {
-  /** @defaultValue `30_000` */
-  timeoutMs?: number;
-  /** @defaultValue `64 * 1024 * 1024` */
-  memoryLimitBytes?: number;
-  /** @defaultValue `2 * 1024 * 1024` */
-  maxStackSizeBytes?: number;
-  /** @defaultValue `1024 * 1024` */
-  maxResultBytes?: number;
-  /** @defaultValue `64 * 1024` */
-  maxConsoleOutputBytes?: number;
-  /** @defaultValue `256 * 1024` */
-  maxSourceBytes?: number;
-  /** @defaultValue `1024 * 1024` */
-  maxToolInputBytes?: number;
-  /** @defaultValue `4 * 1024 * 1024` */
-  maxToolOutputBytes?: number;
-  /** @defaultValue `256` */
-  maxBridgeRequests?: number;
-  /** @defaultValue `32` */
-  maxInFlightBridgeRequests?: number;
-}
-/**
- * Options used by `createCodeModeTool` and `runCodeMode`.
- */
-interface CodeModeOptions {
-  executionPolicy?: CodeModeExecutionPolicy;
-  continuationSecurity?: CodeModeContinuationSecurityOptions;
-  approval?: {
-    /**
-     * @defaultValue `'callback'`
-     */
-    mode?: 'callback' | 'interrupt';
-    onApprovalRequired?: (request: CodeModeApprovalRequest) => Promise<ApprovalDecision> | ApprovalDecision;
-  };
-}
-/**
- * Options for the code-mode tool caller used with `experimental_toolCallers`.
- */
-interface CodeModeToolOptions extends CodeModeOptions {
-  /**
-   * Controls how host tools are presented to the model.
-   *
-   * - `'description'`: include host-tool signatures in the provider-visible
-   *   code-mode tool description.
-   * - `'conversation'`: keep the code-mode tool definition stable and announce
-   *   the current host-tool catalog in a user message.
-   *
-   * @defaultValue `'description'`
-   */
-  toolDiscovery?: 'description' | 'conversation';
-}
-interface CodeModeContinuationSecurityOptions {
-  signingKey?: string | Uint8Array;
-  /**
-   * @defaultValue `60 * 60 * 1000`
-   */
-  maxAgeMs?: number;
-}
-/**
- * Input for `runCodeMode`.
- */
-interface RunCodeModeInput {
-  js: string;
-  tools: CodeModeToolSet;
-  toolExecutionOptions?: Partial<CodeModeToolExecutionOptions>;
-  options?: CodeModeOptions;
-  continuation?: CodeModeContinuation;
-  interruptResolution?: CodeModeInterruptResolution;
-}
-//#endregion
-//#region src/code-mode-tool.d.ts
-/**
- * Creates an AI SDK tool that executes code-mode TypeScript in an isolated
- * sandbox.
- */
-declare function createCodeModeTool(tools: CodeModeToolSet, options?: CodeModeOptions): CodeModeTool;
-/**
- * Creates a code-mode caller whose host tools are bound by the surrounding
- * AI SDK generation call.
- */
-declare function codeModeTool(options?: CodeModeToolOptions): Experimental_ToolCallerTool<CodeModeTool>;
-//#endregion
-//#region src/approval-continuation.d.ts
-declare function isCodeModeApprovalInterrupt(value: unknown, continuationSecurity?: CodeModeContinuationSecurityOptions): value is CodeModeApprovalInterrupt;
-declare function continueCodeModeApproval({ interrupt, approvalResponse, tools, options, toolExecutionOptions }: {
-  interrupt: CodeModeApprovalInterrupt;
-  approvalResponse: CodeModeApprovalResponse;
-  tools: CodeModeToolSet;
-  options?: CodeModeOptions;
-  toolExecutionOptions?: Partial<CodeModeToolExecutionOptions>;
-}): Promise<unknown>;
-declare function toCodeModeApprovalMessages(interrupt: CodeModeApprovalInterrupt): ModelMessage[];
-declare function getCodeModeApprovalResponse(messages: ModelMessage[], interrupt: CodeModeApprovalInterrupt): CodeModeApprovalResponse | undefined;
-//#endregion
-//#region src/errors.d.ts
-/**
- * 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 declare class CodeModeError extends Error {
-  /**
-   * Stable machine-readable error code.
-   */
-  code: string;
-  /**
-   * Optional structured diagnostic details.
-   */
-  readonly details?: unknown;
-  constructor(message: string, code?: string, details?: unknown);
-}
-/**
- * Raised when a sandbox invocation exceeds its timeout.
- */
-export declare class CodeModeTimeoutError extends CodeModeError {
-  constructor(timeoutMs: number);
-}
-/**
- * Raised when the outer AI SDK abort signal aborts a code-mode invocation.
- */
-export declare class CodeModeAbortedError extends CodeModeError {
-  constructor();
-}
-/**
- * Raised when the process-global worker cap has been reached.
- *
- * Configure the cap with `setMaxWorkers`.
- */
-export declare class CodeModeConcurrencyError extends CodeModeError {
-  constructor(maxWorkers: number);
-}
-/**
- * Raised when the provided source exceeds `executionPolicy.maxSourceBytes`.
- */
-export declare class CodeModeSourceTooLargeError extends CodeModeError {
-  constructor(bytes: number, maxBytes: number);
-}
-/**
- * Raised when sandboxed code exceeds bridge request limits.
- */
-export declare class CodeModeBridgeLimitError extends CodeModeError {
-  constructor(message: string, details?: unknown);
-}
-/**
- * Raised when sandboxed code starts host bridge work and returns without
- * awaiting or otherwise observing it.
- */
-export declare class CodeModeDetachedBridgeRequestError extends CodeModeError {
-  constructor(message: string, details?: unknown);
-}
-/**
- * Raised when the main thread and worker protocol observes an invalid or
- * mismatched message.
- */
-export declare class CodeModeProtocolError extends CodeModeError {
-  constructor(message: string, details?: unknown);
-}
-/**
- * Base class for failures caused by nested host tool execution.
- */
-export declare class CodeModeToolError extends CodeModeError {
-  constructor(message: string, details?: unknown);
-}
-export declare class CodeModeToolApprovalRequiredError extends CodeModeToolError {
-  constructor(toolName: string, input: unknown, toolCallId: string);
-}
-export declare class CodeModeToolApprovalDeniedError extends CodeModeToolError {
-  constructor(toolName: string, input: unknown, toolCallId: string, reason?: string);
-}
-//#endregion
-//#region src/host-interrupt.d.ts
-declare function requestCodeModeInterrupt<TPayload extends CodeModeInterruptPayload>(payload: TPayload): never;
-//#endregion
-//#region src/interrupt-continuation.d.ts
-declare function isCodeModeInterrupt(value: unknown, continuationSecurity?: CodeModeContinuationSecurityOptions): value is CodeModeInterrupt;
-declare 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>;
-declare function getCodeModeInterrupt(result: unknown, continuationSecurity?: CodeModeContinuationSecurityOptions): CodeModeInterrupt | undefined;
-declare function unwrapCodeModeResult(result: unknown, continuationSecurity?: CodeModeContinuationSecurityOptions): CodeModeUnwrappedResult;
-//#endregion
-//#region src/run-code-mode.d.ts
-/**
- * Runs one code-mode invocation directly without wrapping it as an AI SDK tool.
- *
- * The source is executed in a fresh QuickJS context with the provided host tools
- * and execution limits.
- *
- * @param input - Source code, host tools, forwarded tool execution options, and code-mode options.
- * @returns The JSON-serializable value returned by the sandboxed program.
- */
-declare function runCodeMode(input: RunCodeModeInput): Promise<unknown>;
-//#endregion
-//#region src/continuation-capability.d.ts
-declare function setCodeModeContinuationSigningKey(key?: string | Uint8Array, options?: {
-  maxAgeMs?: number;
-}): void;
-//#endregion
-export { type ApprovalDecision, type CodeModeApprovalInterrupt, type CodeModeApprovalRequest, type CodeModeApprovalResponse, type CodeModeContinuation, type CodeModeContinuationSecurityOptions, type CodeModeExecutionPolicy, type CodeModeInterrupt, type CodeModeInterruptExecutionContext, type CodeModeInterruptPayload, type CodeModeInterruptResolution, type CodeModeOptions, type CodeModeTool, type CodeModeToolExecutionOptions, type CodeModeToolInput, type CodeModeToolOptions, type CodeModeToolSet, type CodeModeUnwrappedResult, type RunCodeModeInput, codeModeTool as experimental_codeModeTool, continueCodeModeApproval as experimental_continueCodeModeApproval, continueCodeModeInterrupt as experimental_continueCodeModeInterrupt, createCodeModeTool as experimental_createCodeModeTool, getCodeModeApprovalResponse as experimental_getCodeModeApprovalResponse, getCodeModeInterrupt as experimental_getCodeModeInterrupt, isCodeModeApprovalInterrupt as experimental_isCodeModeApprovalInterrupt, isCodeModeInterrupt as experimental_isCodeModeInterrupt, requestCodeModeInterrupt as experimental_requestCodeModeInterrupt, runCodeMode as experimental_runCodeMode, setCodeModeContinuationSigningKey as experimental_setCodeModeContinuationSigningKey, experimental_setMaxWorkers, toCodeModeApprovalMessages as experimental_toCodeModeApprovalMessages, unwrapCodeModeResult as experimental_unwrapCodeModeResult };
-//# sourceMappingURL=index.d.ts.map