ai 7.0.41 → 7.0.43

package/docs/03-agents/02-building-agents.mdx

@@ -129,6 +129,10 @@ const result = await agent.generate({
 });
 ```
 
+Model call settings returned from `prepareStep`, such as `temperature`, apply
+only to the current step. Later steps use the agent's top-level setting unless
+they return another override.
+
 For the full model, including sensitive context filtering and where each context
 value is available, see [Runtime and Tool
 Context](/docs/ai-sdk-core/runtime-and-tool-context).

package/docs/03-agents/04-loop-control.mdx

@@ -180,6 +180,46 @@ const result = await agent.generate({
 });
 ```
 
+### Model Call Settings
+
+Override provider-agnostic model call settings for an individual step. This can
+be useful when tool-calling steps need more deterministic sampling than the
+final response:
+
+```ts
+import { ToolLoopAgent } from 'ai';
+__PROVIDER_IMPORT__;
+
+const agent = new ToolLoopAgent({
+  model: __MODEL__,
+  temperature: 0.7,
+  tools: {
+    // your tools
+  },
+  prepareStep: async ({ stepNumber }) => {
+    if (stepNumber === 0) {
+      return {
+        temperature: 0,
+        maxOutputTokens: 300,
+      };
+    }
+
+    return {};
+  },
+});
+
+const result = await agent.generate({
+  prompt: '...',
+});
+```
+
+`prepareStep` can override `maxOutputTokens`, `temperature`, `topP`, `topK`,
+`presencePenalty`, `frequencyPenalty`, `stopSequences`, `seed`, and
+`reasoning`. These overrides apply only to the current step. When a setting is
+omitted or `undefined`, the top-level value is used for that step. Defined
+falsy values such as `temperature: 0`, `seed: 0`, and an empty
+`stopSequences` array are preserved.
+
 ### Context Management
 
 Long-running agents can accumulate large tool results, reasoning parts, and assistant messages. Use `prepareStep` to mutate the message state that will be used by later steps. This is useful for compaction, and you decide when compaction should happen.

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/36-transcription.mdx

@@ -304,6 +304,7 @@ try {
 | [ElevenLabs](/providers/ai-sdk-providers/elevenlabs#streaming-transcription-models) | `scribe_v2_realtime`     |
 | [Groq](/providers/ai-sdk-providers/groq#transcription-models)                       | `whisper-large-v3-turbo` |
 | [Groq](/providers/ai-sdk-providers/groq#transcription-models)                       | `whisper-large-v3`       |
+| [Mistral](/providers/ai-sdk-providers/mistral#transcription-models)                 | `voxtral-mini-latest`    |
 | [Azure OpenAI](/providers/ai-sdk-providers/azure#transcription-models)              | `whisper-1`              |
 | [Azure OpenAI](/providers/ai-sdk-providers/azure#transcription-models)              | `gpt-4o-transcribe`      |
 | [Azure OpenAI](/providers/ai-sdk-providers/azure#transcription-models)              | `gpt-4o-mini-transcribe` |

package/docs/03-ai-sdk-core/65-devtools.mdx

@@ -105,10 +105,56 @@ the workspace.
 DevTools captures the following information from your AI SDK calls:
 
 - **Input parameters and prompts**: View the complete input sent to your LLM
-- **Output content and tool calls**: Inspect generated text and tool invocations
+- **Output content and tool calls**: Inspect generated text, tool invocations, and tool results
+- **Media previews**: View images, audio, and video included in prompts, tool inputs, and tool outputs
 - **Token usage and timing**: Monitor resource consumption and performance
 - **Raw provider data**: Access provider request and response payloads when body retention is enabled
 
+### Media previews
+
+DevTools recognizes current `file` content parts as well as the deprecated
+`image-*`, `file-*`, and `media` tool-result aliases. Inline image, audio, and
+video data is previewed directly, while the captured JSON shape and metadata
+remain available for inspection. The viewer displays at most 8 previews per
+value, traverses at most 12 nested levels, and embeds inline previews up to 5
+MiB. Longer JSON strings are truncated in the viewer to avoid duplicating large
+base64 payloads. Binary values in recognized media-bearing fields are persisted
+as base64 so they remain previewable; unrelated binary values retain their
+normal JSON representation.
+
+For example, a tool can return media through `toModelOutput`:
+
+```ts
+import { tool } from 'ai';
+import { z } from 'zod';
+
+const captureScreenshot = tool({
+  inputSchema: z.object({}),
+  execute: async () => ({
+    base64: await captureScreenshotAsBase64(),
+  }),
+  toModelOutput: ({ output }) => ({
+    type: 'content',
+    value: [
+      {
+        type: 'file',
+        filename: 'screenshot.png',
+        mediaType: 'image/png',
+        data: { type: 'data', data: output.base64 },
+      },
+    ],
+  }),
+});
+```
+
+Remote `http` and `https` media is not loaded automatically. Select **Load
+preview** in the viewer to fetch it with anonymous CORS and no referrer.
+Cross-origin browser credentials are omitted, but same-origin browser
+credentials may still be included by the browser. URLs containing embedded
+usernames or passwords are rejected. Unsupported media, provider references,
+malformed values, unsafe URL schemes, and inline values over the preview limit
+retain their JSON and metadata fallback without an embedded preview.
+
 Telemetry is enabled automatically, but AI SDK 7 excludes raw request and response bodies from step results by default. To make them available to DevTools for `generateText`, enable body retention on the call:
 
 ```ts highlight="4-7"

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/06-advanced/11-secure-url-fetching.mdx

@@ -27,6 +27,10 @@ When the SDK fetches a URL taken from a provider response, it:
   are rejected too.
 - **Re-validates every redirect hop** — a URL that passes but then redirects to
   an internal address is blocked; the redirect is never followed blindly.
+- **Validates DNS at connection time on Node.js** — every resolved address is
+  checked, and the socket is pinned to the validated DNS result so DNS
+  rebinding cannot introduce a different address between validation and
+  connection.
 - **Strips risky request headers** — proxy-forwarding, cloud-metadata, and
   cookie headers are removed before the request.
 - **Drops credentials across origins** — caller headers (`Authorization`,
@@ -43,28 +47,17 @@ custom `baseURL` pointing at a self-hosted or `localhost` deployment) are
 exempt from these checks — they target exactly the host you told the SDK to
 talk to. Any redirect off that origin is still validated.
 
-## Limitation: DNS resolution and DNS rebinding
+## DNS validation across runtimes
 
-The built-in guard inspects the URL **as a string**. It deliberately does
-**not resolve DNS**, so two attacks remain out of scope at this layer:
+On Node.js, the default validated download fetch uses `node:dns` and an
+`undici` connector hook to validate every resolved address at connection time.
+The connector uses those exact results, closing both hostname-to-private-IP and
+DNS-rebinding bypasses.
 
-1. **Hostname that resolves to a private IP** — a literal host that looks public
-   but whose DNS record points at an internal address.
-2. **DNS rebinding** — a host that resolves to a public IP when validated and a
-   private IP a moment later when the socket actually connects (a
-   time-of-check/time-of-use window).
-
-### Why this isn't built in
-
-Closing these requires resolving DNS and pinning the resolved IP **at connect
-time** — Node-only capabilities (`node:dns`, a custom `undici` dispatcher). The
-SDK's provider utilities are **cross-runtime**: they run on the edge, in the
-browser, and on Bun/Deno, with no Node-only dependencies, so those APIs aren't
-available there. The threat is also specifically a **server-side** one — on the
-edge and in the browser, outbound `fetch` cannot reach a host's internal network
-or metadata endpoint in the first place. So connect-time IP pinning is only
-meaningful, and only available, on a Node server — which is exactly where you
-can add it yourself.
+If you inject or globally replace `fetch`, it is responsible for equivalent DNS
+validation and connection pinning. Other runtimes do not expose Node's
+DNS/socket hooks, so server deployments on those runtimes should restrict
+network egress to private, loopback, link-local, and cloud-metadata ranges.
 
 ## Hardening your deployment
 
@@ -77,9 +70,10 @@ Deny your server's network egress to `169.254.0.0/16`, RFC-1918 ranges, and
 loopback. This is the most robust control and is independent of application
 code.
 
-### 2. Inject a hardened `fetch`
+### 2. Harden an injected `fetch`
 
-Every provider accepts a custom `fetch`. On Node, back it with an `undici`
+The Node.js default is already pinned. If you inject or globally replace
+`fetch`, back it with an `undici`
 `Agent` whose `connect.lookup` validates the resolved IP and lets the socket
 connect only to a safe address — closing both the hostname-to-private and the
 DNS-rebinding windows:
@@ -113,5 +107,5 @@ import { createFal } from '@ai-sdk/fal';
 const fal = createFal({ fetch: safeFetch });
 ```
 
-The SDK's built-in validation and your connect-time pinning are complementary —
-keep both.
+The SDK's URL validation and your custom fetch's connect-time pinning are
+complementary — keep both.

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>',
@@ -597,7 +604,7 @@ To see `generateText` in action, check out [these examples](#examples).
       type: '(options: PrepareStepOptions) => PrepareStepResult<TOOLS> | Promise<PrepareStepResult<TOOLS>>',
       isOptional: true,
       description:
-        'Optional function that you can use to provide different settings for a step. You can modify the model, tool choices, active tools, instructions, input messages, and experimental sandbox for each step.',
+        'Optional function that you can use to provide different settings for a step. You can modify the model, model call settings, tool choices, active tools, instructions, input messages, and experimental sandbox for each step.',
       properties: [
         {
           type: 'PrepareStepFunction<TOOLS>',
@@ -682,6 +689,69 @@ To see `generateText` in action, check out [these examples](#examples).
               description:
                 'Optionally override which LanguageModel instance is used for this step.',
             },
+            {
+              name: 'maxOutputTokens',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Maximum number of tokens to generate for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'temperature',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Temperature for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'topP',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Nucleus sampling value for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'topK',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Top-K sampling value for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'presencePenalty',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Presence penalty for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'frequencyPenalty',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Frequency penalty for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'stopSequences',
+              type: 'string[]',
+              isOptional: true,
+              description:
+                'Stop sequences for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'seed',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Random sampling seed for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'reasoning',
+              type: 'LanguageModelV4CallOptions["reasoning"]',
+              isOptional: true,
+              description:
+                'Reasoning effort for this step. Uses the top-level value when omitted or undefined.',
+            },
             {
               name: 'toolChoice',
               type: 'ToolChoice<TOOLS>',
@@ -2362,7 +2432,8 @@ To see `generateText` in action, check out [these examples](#examples).
     {
       name: 'text',
       type: 'string',
-      description: 'The generated text by the model.',
+      description:
+        'The concatenation of all text parts generated in the final step. It is an empty string if the final step contains no text parts. Inspect `finalStep.content` to distinguish that case.',
     },
     {
       name: 'reasoning',
@@ -2795,7 +2866,8 @@ To see `generateText` in action, check out [these examples](#examples).
             {
               name: 'text',
               type: 'string',
-              description: 'The generated text.',
+              description:
+                'The concatenation of all text parts generated in this step. It is an empty string if the step contains no text parts.',
             },
             {
               name: 'reasoning',

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

@@ -641,7 +641,7 @@ To see `streamText` in action, check out [these examples](#examples).
       type: '(options: PrepareStepOptions) => PrepareStepResult<TOOLS> | Promise<PrepareStepResult<TOOLS>>',
       isOptional: true,
       description:
-        'Optional function that you can use to provide different settings for a step. You can modify the model, tool choices, active tools, instructions, input messages, and experimental sandbox for each step.',
+        'Optional function that you can use to provide different settings for a step. You can modify the model, model call settings, tool choices, active tools, instructions, input messages, and experimental sandbox for each step.',
       properties: [
         {
           type: 'PrepareStepFunction<TOOLS>',
@@ -726,6 +726,69 @@ To see `streamText` in action, check out [these examples](#examples).
               description:
                 'Optionally override which LanguageModel instance is used for this step.',
             },
+            {
+              name: 'maxOutputTokens',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Maximum number of tokens to generate for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'temperature',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Temperature for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'topP',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Nucleus sampling value for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'topK',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Top-K sampling value for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'presencePenalty',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Presence penalty for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'frequencyPenalty',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Frequency penalty for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'stopSequences',
+              type: 'string[]',
+              isOptional: true,
+              description:
+                'Stop sequences for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'seed',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Random sampling seed for this step. Uses the top-level value when omitted or undefined.',
+            },
+            {
+              name: 'reasoning',
+              type: 'LanguageModelV4CallOptions["reasoning"]',
+              isOptional: true,
+              description:
+                'Reasoning effort for this step. Uses the top-level value when omitted or undefined.',
+            },
             {
               name: 'toolChoice',
               type: 'ToolChoice<TOOLS>',

package/docs/07-reference/01-ai-sdk-core/16-tool-loop-agent.mdx

@@ -123,7 +123,7 @@ To see `ToolLoopAgent` in action, check out [these examples](#examples).
       type: 'PrepareStepFunction',
       isOptional: true,
       description:
-        'Optional function to mutate step settings or inject state for each agent step.',
+        'Optional function to mutate step settings or inject state for each agent step, including per-step model call settings such as temperature, maxOutputTokens, sampling controls, penalties, stop sequences, seed, and reasoning. Model call setting overrides apply only to the current step.',
     },
     {
       name: 'include',

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',