ai 7.0.42 → 7.0.44

package/dist/internal/index.js

@@ -85,7 +85,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.42" : "0.0.0-test";
+var VERSION = true ? "7.0.44" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/docs/03-ai-sdk-core/18-code-mode.mdx

@@ -0,0 +1,246 @@
+---
+title: Code Mode
+description: Let models orchestrate AI SDK tools with sandboxed JavaScript and TypeScript.
+---
+
+# Code Mode
+
+Code mode lets a model write JavaScript or TypeScript that calls your AI SDK
+tools. The generated code runs in an isolated QuickJS sandbox and returns a JSON-serializable result.
+
+Instead of calling tools one at a time, a model can use code mode to:
+
+- call independent tools concurrently
+- transform and combine tool results
+- filter large tool responses before returning them to the model
+- use JavaScript control flow for multi-step operations
+
+Code mode is provided by the `@ai-sdk/code-mode` package.
+
+<Note type="warning">
+  Code mode is experimental and its APIs may change in future releases. It
+  requires Node.js 22 or newer and is not available in browser or edge runtimes.
+</Note>
+
+## Installation
+
+```bash
+pnpm add ai @ai-sdk/code-mode zod
+```
+
+## Using Code Mode with `generateText`
+
+Define your tools in one tool set and use `experimental_toolCallers` to select
+which tools code mode can call:
+
+```ts
+import { experimental_codeModeTool as codeModeTool } from '@ai-sdk/code-mode';
+import { generateText, isStepCount, tool } from 'ai';
+import { z } from 'zod';
+
+const getInventory = tool({
+  description: 'Get available inventory for a product.',
+  inputSchema: z.object({
+    productId: z.string(),
+  }),
+  outputSchema: z.object({
+    productId: z.string(),
+    availableUnits: z.number(),
+  }),
+  execute: async ({ productId }) => ({
+    productId,
+    availableUnits: 42,
+  }),
+});
+
+const getDemand = tool({
+  description: 'Get requested units for a product.',
+  inputSchema: z.object({
+    productId: z.string(),
+  }),
+  outputSchema: z.object({
+    productId: z.string(),
+    requestedUnits: z.number(),
+  }),
+  execute: async ({ productId }) => ({
+    productId,
+    requestedUnits: 31,
+  }),
+});
+
+const tools = {
+  code_mode: codeModeTool({
+    executionPolicy: {
+      timeoutMs: 30_000,
+    },
+  }),
+  getInventory,
+  getDemand,
+} as const;
+
+const result = await generateText({
+  model: __MODEL__,
+  tools,
+  experimental_toolCallers: ({ code_mode }) => ({
+    getInventory: [code_mode],
+    getDemand: [code_mode],
+  }),
+  stopWhen: isStepCount(10),
+  prompt: 'Compare inventory and demand for product sku_123.',
+});
+```
+
+The keys returned by `experimental_toolCallers` are the tools being governed.
+The values identify their allowed callers. In this example, `getInventory` and
+`getDemand` are available through `code_mode`, but they are not exposed to the
+model as directly callable tools. Include `'direct'` when a tool should also be
+callable directly:
+
+```ts
+experimental_toolCallers: ({ code_mode }) => ({
+  getInventory: ['direct', code_mode],
+});
+```
+
+Tools without an `experimental_toolCallers` entry keep their existing direct
+tool-calling behavior.
+
+The code mode tool description includes TypeScript signatures generated from
+the input and output schemas of its allowed tools. Descriptions,
+`inputExamples`, and precise schemas help the model write correct code.
+
+For the example above, the model can generate a program like:
+
+```ts
+const [inventory, demand] = await Promise.all([
+  tools.getInventory({ productId: 'sku_123' }),
+  tools.getDemand({ productId: 'sku_123' }),
+]);
+
+return {
+  sufficient: inventory.availableUnits >= demand.requestedUnits,
+  remaining: inventory.availableUnits - demand.requestedUnits,
+};
+```
+
+Each provided tool is available through the global `tools` object. Tool names
+that are not valid JavaScript identifiers use bracket notation:
+
+```ts
+const user = await tools['lookup-user']({ userId: 'user_123' });
+return { id: user.id, plan: user.plan };
+```
+
+## Writing Code Mode Programs
+
+Generated programs support:
+
+- JavaScript and type-stripped TypeScript
+- top-level `await` and `return`
+- standard JavaScript control flow and data transformations
+- `Promise.all` for concurrent tool calls
+- `JSON.parse` and `JSON.stringify`
+- `console.log`, `console.info`, `console.debug`, and `console.error`
+
+Every tool call is asynchronous and must be awaited or otherwise observed.
+Returning while tool calls are still detached fails the invocation and aborts
+the outstanding work.
+
+Programs and tool inputs and outputs cross the sandbox boundary as JSON. Return
+only JSON-serializable values. TypeScript support is limited to removing type
+syntax; code mode does not perform type checking or provide a full TypeScript
+compiler.
+
+## Direct Execution
+
+Use `experimental_runCodeMode` when you want to execute a program directly
+instead of exposing code mode to a model:
+
+```ts
+import { experimental_runCodeMode as runCodeMode } from '@ai-sdk/code-mode';
+
+const result = await runCodeMode({
+  js: `
+    const inventory = await tools.getInventory({
+      productId: 'sku_123',
+    });
+
+    return {
+      productId: inventory.productId,
+      available: inventory.availableUnits > 0,
+    };
+  `,
+  tools: { getInventory },
+});
+```
+
+`runCodeMode` returns the value returned by the program. It uses the same
+sandbox and execution limits as the AI SDK tool.
+
+## Execution Limits
+
+Every invocation has limits for runtime, memory, source size, results, tool
+payloads, console output, and tool calls. Override them with
+`executionPolicy`:
+
+```ts
+const codeMode = codeModeTool({
+  executionPolicy: {
+    timeoutMs: 30_000,
+    memoryLimitBytes: 64 * 1024 * 1024,
+    maxResultBytes: 1024 * 1024,
+    maxBridgeRequests: 100,
+    maxInFlightBridgeRequests: 10,
+  },
+});
+```
+
+The available limits are:
+
+- `timeoutMs`: total execution time
+- `memoryLimitBytes`: QuickJS memory
+- `maxStackSizeBytes`: QuickJS stack
+- `maxSourceBytes`: generated source code
+- `maxResultBytes`: returned result
+- `maxConsoleOutputBytes`: combined console output
+- `maxToolInputBytes`: input for each tool call
+- `maxToolOutputBytes`: output from each tool call
+- `maxBridgeRequests`: total tool calls
+- `maxInFlightBridgeRequests`: concurrent tool calls
+
+Use `experimental_setMaxWorkers` to set a process-wide cap on concurrent code
+mode workers:
+
+```ts
+import { experimental_setMaxWorkers as setMaxWorkers } from '@ai-sdk/code-mode';
+
+setMaxWorkers(4);
+```
+
+Without an explicit cap, code mode chooses one based on available memory, up to
+32 workers.
+
+## Isolation and Tool Access
+
+Each invocation receives a fresh QuickJS context. Sandboxed code cannot access:
+
+- Node.js globals such as `process`, `require`, or `module`
+- the host file system or module loader
+- `fetch`, WebCrypto, or performance APIs
+- `eval` or dynamic `Function` construction
+
+Network or system access must be implemented in a tool and explicitly provided
+to code mode.
+
+<Note type="warning">
+  Treat the sandbox as defense in depth. Generated code and tool arguments are
+  untrusted. Tools execute in your host application, outside the QuickJS
+  sandbox, and every capability exposed by a provided tool is available to the
+  generated program. Enforce authorization and validate inputs inside each tool.
+</Note>
+
+Tool input schemas are validated before their `execute` functions run. Abort
+signals and AI SDK tool execution context are forwarded to nested tool calls.
+
+Code mode does not currently support approval flows for nested tool calls.
+Tools that require approval are rejected instead of being executed.

package/docs/03-ai-sdk-core/65-lifecycle-callbacks.mdx

@@ -653,7 +653,7 @@ Called after the provider response has been normalized and parsed, before local
     {
       name: 'modelId',
       type: 'string',
-      description: 'Model identifier for this model call.',
+      description: 'Provider-returned model identifier for this model call.',
     },
     {
       name: 'finishReason',

package/docs/03-ai-sdk-core/index.mdx

@@ -28,6 +28,12 @@ description: Learn about AI SDK Core.
       description: 'Learn how to do tool calling with AI SDK Core.',
       href: '/docs/ai-sdk-core/tools-and-tool-calling',
     },
+    {
+      title: 'Code Mode',
+      description:
+        'Learn how models can orchestrate tools with sandboxed JavaScript and TypeScript.',
+      href: '/docs/ai-sdk-core/code-mode',
+    },
     {
       title: 'Realtime',
       description: 'Learn how to build realtime voice conversations.',

package/docs/07-reference/01-ai-sdk-core/01-generate-text.mdx

@@ -578,6 +578,13 @@ To see `generateText` in action, check out [these examples](#examples).
       description:
         "Approval configuration for this call. Pass a `GenericToolApprovalFunction` to handle all tool calls in one callback with `toolCall`, `tools`, `toolsContext`, `messages`, and `runtimeContext`, or pass a per-tool object where each key can be a status (`'not-applicable'`, `'approved'`, `'denied'`, or `'user-approval'`), an object form such as `{ type: 'denied', reason: 'blocked by policy' }`, or a `SingleToolApprovalFunction` that receives the tool input and options `toolCallId`, `messages`, `toolContext`, and `runtimeContext` (same shape as tool execution options without `abortSignal`, with `context` renamed to `toolContext`). The `RUNTIME_CONTEXT` type parameter matches the call's `runtimeContext`. A `GenericToolApprovalFunction` or `SingleToolApprovalFunction` may return `undefined` for the same effect as `'not-applicable'`. `'not-applicable'` is the default execution path and runs the tool without approval metadata. Use `'approved'`, `'denied'`, or their object forms when you want explicit automatic approval request/response parts in the output. Automatic approvals and denials can include a `reason`, which is forwarded to the emitted approval response. This setting takes precedence over a tool's `needsApproval` default.",
     },
+    {
+      name: 'experimental_toolCallers',
+      type: 'Experimental_ToolCallers<TOOLS>',
+      isOptional: true,
+      description:
+        "Configures which caller tools may invoke each tool. The callback receives typed references for caller-capable tools in the `tools` set and returns an object keyed by callee tool name. Include `'direct'` to keep a configured tool directly callable by the model. Local-only callees are hidden from direct model calls and bound to their local caller for each generation step. Provider caller references are translated to provider-native allowed-caller options. Tools without an entry keep their existing direct tool-calling behavior.",
+    },
     {
       name: 'experimental_refineToolInput',
       type: 'ToolInputRefinement<TOOLS>',
@@ -1406,7 +1413,8 @@ To see `generateText` in action, check out [these examples](#examples).
             {
               name: 'modelId',
               type: 'string',
-              description: 'The specific model identifier for this model call.',
+              description:
+                'The provider-returned model identifier for this model call.',
             },
             {
               name: 'finishReason',

package/docs/07-reference/01-ai-sdk-core/02-stream-text.mdx

@@ -2390,7 +2390,8 @@ To see `streamText` in action, check out [these examples](#examples).
             {
               name: 'modelId',
               type: 'string',
-              description: 'The specific model identifier for this model call.',
+              description:
+                'The provider-returned model identifier for this model call.',
             },
             {
               name: 'finishReason',

package/docs/07-reference/01-ai-sdk-core/23-create-mcp-client.mdx

@@ -162,6 +162,13 @@ It currently does not support accepting notifications from an MCP server, and cu
                 },
               ],
             },
+            {
+              name: 'initializationOptions',
+              type: 'RequestOptions',
+              isOptional: true,
+              description:
+                'Optional signal and timeout settings that bound transport startup and the initialize request. A timeout or abort closes the transport and rejects createMCPClient.',
+            },
             {
               name: 'clientName',
               type: 'string',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.42",
+  "version": "7.0.44",
   "type": "module",
   "description": "AI SDK by Vercel - build apps like ChatGPT, Claude, Gemini, and more with a single interface for any model using the Vercel AI Gateway or go direct to OpenAI, Anthropic, Google, or any other model provider.",
   "license": "Apache-2.0",
@@ -42,9 +42,9 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.32",
+    "@ai-sdk/gateway": "4.0.33",
     "@ai-sdk/provider": "4.0.4",
-    "@ai-sdk/provider-utils": "5.0.15"
+    "@ai-sdk/provider-utils": "5.0.16"
   },
   "devDependencies": {
     "@edge-runtime/vm": "^5.0.0",
@@ -55,7 +55,7 @@
     "tsx": "^4.22.0",
     "typescript": "5.8.3",
     "zod": "3.25.76",
-    "@ai-sdk/test-server": "2.0.0",
+    "@ai-sdk/test-server": "2.0.1",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {

package/src/generate-text/generate-text.ts

@@ -104,6 +104,11 @@ import { toResponseMessages } from './to-response-messages';
 import type { ToolApprovalConfiguration } from './tool-approval-configuration';
 import type { ToolApprovalRequestOutput } from './tool-approval-request-output';
 import type { ToolApprovalResponseOutput } from './tool-approval-response-output';
+import {
+  prepareToolsForToolCallers,
+  resolveToolCallerConfiguration,
+  type Experimental_ToolCallers,
+} from './tool-caller-configuration';
 import type { TypedToolCall } from './tool-call';
 import type { ToolCallRepairFunction } from './tool-call-repair-function';
 import type { TypedToolError } from './tool-error';
@@ -242,6 +247,7 @@ export async function generateText<
   experimental_sandbox: sandbox,
   output,
   toolApproval,
+  experimental_toolCallers,
   experimental_toolApprovalSecret,
   experimental_telemetry,
   telemetry = experimental_telemetry,
@@ -358,6 +364,11 @@ export async function generateText<
      */
     toolApproval?: ToolApprovalConfiguration<TOOLS, RUNTIME_CONTEXT>;
 
+    /**
+     * Configures which caller tools may invoke each tool.
+     */
+    experimental_toolCallers?: Experimental_ToolCallers<NoInfer<TOOLS>>;
+
     /**
      * Secret for HMAC-signing tool approval requests. When set, the server
      * signs each approval request at issuance and verifies the signature when
@@ -560,6 +571,10 @@ export async function generateText<
   };
 
   const model = resolveLanguageModel(modelArg);
+  const resolvedToolCallers = resolveToolCallerConfiguration({
+    tools,
+    toolCallers: experimental_toolCallers,
+  });
   const stopConditions = asArray(stopWhen);
   const resolvedOnStart = onStart ?? experimental_onStart;
   const resolvedOnStepStart = onStepStart ?? experimental_onStepStart;
@@ -863,10 +878,20 @@ export async function generateText<
                 tools,
                 activeTools: prepareStepResult?.activeTools ?? activeTools,
               });
+              const {
+                executionTools: stepExecutionTools,
+                modelTools: stepModelTools,
+              } = prepareToolsForToolCallers({
+                tools: stepActiveTools,
+                toolCallers: resolvedToolCallers,
+              });
               const stepToolOrder = prepareStepResult?.toolOrder ?? toolOrder;
 
               const stepTools = await prepareTools({
-                tools: stepActiveTools,
+                tools: stepModelTools as ActiveToolSubset<
+                  TOOLS,
+                  ActiveTools<NoInfer<TOOLS>>
+                >,
                 toolOrder: stepToolOrder as ToolOrder<
                   ActiveToolSubset<TOOLS, ActiveTools<NoInfer<TOOLS>>>
                 >,
@@ -994,7 +1019,7 @@ export async function generateText<
                   .map(toolCall =>
                     parseToolCall({
                       toolCall,
-                      tools,
+                      tools: stepExecutionTools as TOOLS,
                       repairToolCall,
                       refineToolInput,
                       instructions: stepInstructions,
@@ -1025,7 +1050,7 @@ export async function generateText<
                 event: {
                   callId,
                   provider: stepModel.provider,
-                  modelId: stepModel.modelId,
+                  modelId: currentModelResponse.response.modelId,
                   finishReason: currentModelResponse.finishReason.unified,
                   usage: stepUsage,
                   content: modelCallContent,
@@ -1062,7 +1087,7 @@ export async function generateText<
                   continue; // ignore invalid tool calls
                 }
 
-                const tool = getOwn(tools, toolCall.toolName);
+                const tool = getOwn(stepExecutionTools, toolCall.toolName);
 
                 if (tool == null) {
                   // ignore tool calls for tools that are not available,
@@ -1090,7 +1115,7 @@ export async function generateText<
                 }
 
                 const toolApprovalStatus = await resolveToolApproval({
-                  tools,
+                  tools: stepExecutionTools as TOOLS,
                   toolApproval,
                   toolCall,
                   messages: stepMessages,
@@ -1199,14 +1224,14 @@ export async function generateText<
               );
               const toolExecutionMs: Record<string, number> = {};
 
-              if (tools != null) {
+              if (stepExecutionTools != null) {
                 const toolExecutionResults = await executeTools({
                   toolCalls: clientToolCalls.filter(
                     toolCall =>
                       !toolCall.invalid &&
                       !blockedToolCallIds.has(toolCall.toolCallId),
                   ),
-                  tools,
+                  tools: stepExecutionTools as TOOLS,
                   callId,
                   messages: stepMessages,
                   abortSignal: mergedAbortSignal,
@@ -1268,7 +1293,7 @@ export async function generateText<
               // the client tool's result is sent back.
               for (const toolCall of stepToolCalls) {
                 if (!toolCall.providerExecuted) continue;
-                const tool = getOwn(tools, toolCall.toolName);
+                const tool = getOwn(stepExecutionTools, toolCall.toolName);
                 if (tool?.type === 'provider' && tool.supportsDeferredResults) {
                   // Check if this tool call already has a result in the current response
                   const hasResultInResponse = currentModelResponse.content.some(

package/src/generate-text/index.ts

@@ -80,6 +80,10 @@ export type {
   ToolApprovalConfiguration,
   ToolApprovalStatus,
 } from './tool-approval-configuration';
+export type {
+  Experimental_ToolCallerReference,
+  Experimental_ToolCallers,
+} from './tool-caller-configuration';
 export { detectToolDrift, fingerprintTools } from './tool-fingerprint';
 export type { ToolApprovalRequestOutput } from './tool-approval-request-output';
 export type { ToolApprovalResponseOutput } from './tool-approval-response-output';

package/src/generate-text/stream-language-model-call.ts

@@ -422,6 +422,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
   const textPartIndexes = new Map<string, number>();
   const reasoningPartIndexes = new Map<string, number>();
   let responseId = generateId();
+  let responseModelId = modelId;
   let timeToFirstOutputMs: number | undefined;
   let previousOutputChunkTimestampMs: number | undefined;
   const timeBetweenOutputChunksMs: number[] = [];
@@ -590,7 +591,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
             event: {
               callId,
               provider,
-              modelId,
+              modelId: responseModelId,
               finishReason: chunk.finishReason.unified,
               usage,
               content: modelCallContent,
@@ -739,6 +740,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
 
         case 'response-metadata': {
           responseId = chunk.id ?? responseId;
+          responseModelId = chunk.modelId ?? responseModelId;
 
           controller.enqueue({
             type: 'model-call-response-metadata',