ai 7.0.106 → 7.0.108

package/docs/00-introduction/index.mdx

@@ -26,7 +26,7 @@ For example, here’s how you can generate text with various models using the AI
 The AI SDK has these primary surfaces:
 
 - **[AI SDK Core](/docs/ai-sdk-core):** A unified API for generating text, structured objects, tool calls, and building agents with LLMs.
-- **[AI SDK UI](/docs/ai-sdk-ui):** A set of framework-agnostic hooks for quickly building chat and generative user interface.
+- **[AI SDK UI](/docs/ai-sdk-ui):** A set of framework-agnostic hooks for quickly building chat and generative user interfaces.
 - **[AI SDK Harnesses](/docs/ai-sdk-harnesses):** A uniform API for running established agent harnesses with `HarnessAgent`.
 
 ## Model Providers

package/docs/02-getting-started/03-nextjs-pages-router.mdx

@@ -153,7 +153,7 @@ Pick the approach that best matches how you want to manage providers across your
 
 ## Wire up the UI
 
-Now that you have an API route that can query an LLM, it's time to setup your frontend. The AI SDK's [ UI ](/docs/ai-sdk-ui) package abstract the complexity of a chat interface into one hook, [`useChat`](/docs/reference/ai-sdk-ui/use-chat).
+Now that you have an API route that can query an LLM, it's time to set up your frontend. The AI SDK's [ UI ](/docs/ai-sdk-ui) package abstracts the complexity of a chat interface into one hook, [`useChat`](/docs/reference/ai-sdk-ui/use-chat).
 
 Update your root page (`pages/index.tsx`) with the following code to show a list of chat messages and provide a user message input:
 

package/docs/02-getting-started/05-nuxt.mdx

@@ -154,7 +154,7 @@ model: openai('gpt-5.1');
 
 ## Wire up the UI
 
-Now that you have an API route that can query an LLM, it's time to setup your frontend. The AI SDK's [ UI ](/docs/ai-sdk-ui/overview) package abstract the complexity of a chat interface into one hook, [`useChat`](/docs/reference/ai-sdk-ui/use-chat).
+Now that you have an API route that can query an LLM, it's time to set up your frontend. The AI SDK's [ UI ](/docs/ai-sdk-ui/overview) package abstracts the complexity of a chat interface into one hook, [`useChat`](/docs/reference/ai-sdk-ui/use-chat).
 
 Update your root page (`pages/index.vue`) with the following code to show a list of chat messages and provide a user message input:
 

package/docs/03-ai-sdk-core/16-mcp-tools.mdx

@@ -236,6 +236,37 @@ client infers `native` for loopback, localhost, and custom-scheme redirects,
 and `web` for remote HTTP(S) redirects. You can override this by setting
 `application_type` in the provider's `clientMetadata`.
 
+### Dynamic Client Credential Recovery
+
+To let the SDK replace invalid credentials created through dynamic client
+registration, implement `isClientInformationDynamicallyRegistered` on the
+OAuth client provider. Return `true` only when the current client information
+came from a dynamic registration response. Persist this provenance alongside
+the credentials when the provider is recreated between requests.
+
+```typescript
+const myOAuthClientProvider = {
+  // ...other OAuthClientProvider methods
+
+  async saveClientInformation(clientInformation) {
+    await saveClientRecord({
+      clientInformation,
+      dynamicallyRegistered: true,
+    });
+  },
+
+  async isClientInformationDynamicallyRegistered() {
+    return (await loadClientRecord())?.dynamicallyRegistered === true;
+  },
+};
+```
+
+When this method is omitted or returns `false`, client information is treated
+as pre-registered and is preserved after `invalid_client` and
+`unauthorized_client` errors. The SDK does not infer provenance from fields such
+as `redirect_uris`, because pre-registered clients can contain the same
+metadata as dynamically registered clients.
+
 ### Retrying Transient Tool Failures
 
 MCP tool calls can fail for transient transport reasons, such as rate limits,

package/docs/03-ai-sdk-core/19-tool-search.mdx

@@ -10,8 +10,10 @@ definition into its initial context. Register tools with `deferLoading: true`;
 search matches their names and descriptions and makes them available on the
 **next model step**.
 
-Use it with `generateText`, `streamText`, or `ToolLoopAgent`. The factory takes no
-arguments; the model supplies a search query.
+Use it with `generateText`, `streamText`, `ToolLoopAgent`, or `WorkflowAgent` from
+`@ai-sdk/workflow`. The factory takes no arguments; the model supplies a search
+query. `WorkflowAgent` supports direct tool calling; the other APIs also support
+cache-preserving code mode.
 
 ## Direct Tool Calling
 

package/docs/04-ai-sdk-ui/02-chatbot.mdx

@@ -323,17 +323,32 @@ When the user clicks the "Regenerate" button, the AI provider will regenerate th
 
 ### Throttling UI Updates
 
-<Note>This feature is currently only available for React.</Note>
-
 By default, the `useChat` hook will trigger a render every time a new chunk is received.
-You can throttle the UI updates with the `throttle` option.
-
-```tsx filename="page.tsx" highlight="2-3"
-const { messages, ... } = useChat({
-  // Throttle the messages and data updates to 50ms:
-  throttle: 50
-})
-```
+React and Vue applications can throttle reactive message updates with the `throttle` option.
+Stream processing and event callbacks remain immediate, and the latest messages are published before the chat enters a terminal `ready` or `error` status.
+
+<Tabs items={['React', 'Vue']}>
+  <Tab>
+    ```tsx filename="page.tsx" highlight="2-3"
+    const { messages, ... } = useChat({
+      // Throttle reactive message updates to 50ms:
+      throttle: 50,
+    });
+    ```
+  </Tab>
+  <Tab>
+    ```vue filename="pages/index.vue" highlight="4-6"
+    <script setup lang="ts">
+    import { useChat } from '@ai-sdk/vue';
+
+    const { messages } = useChat({
+      throttle: 50,
+    });
+    </script>
+    ```
+
+  </Tab>
+</Tabs>
 
 ## Event Callbacks
 
@@ -369,7 +384,7 @@ It's worth noting that you can abort the processing by throwing an error in the
 
 ### Custom headers, body, and credentials
 
-By default, the `useChat` hook sends a HTTP POST request to the `/api/chat` endpoint with the message list as the request body. You can customize the request in two ways:
+By default, the `useChat` hook sends an HTTP POST request to the `/api/chat` endpoint with the message list as the request body. You can customize the request in two ways:
 
 #### Hook-Level Configuration (Applied to all requests)
 

package/docs/04-ai-sdk-ui/05-completion.mdx

@@ -169,7 +169,7 @@ const { ... } = useCompletion({
 
 ## Configure Request Options
 
-By default, the `useCompletion` hook sends a HTTP POST request to the `/api/completion` endpoint with the prompt as part of the request body. You can customize the request by passing additional options to the `useCompletion` hook:
+By default, the `useCompletion` hook sends an HTTP POST request to the `/api/completion` endpoint with the prompt as part of the request body. You can customize the request by passing additional options to the `useCompletion` hook:
 
 ```tsx
 const { messages, input, handleInputChange, handleSubmit } = useCompletion({

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

@@ -929,6 +929,13 @@ To see `generateText` in action, check out [these examples](#examples).
               description:
                 'The error that occurred while parsing the tool call.',
             },
+            {
+              name: 'abortSignal',
+              type: 'AbortSignal',
+              isOptional: true,
+              description:
+                'An optional signal for cancelling the tool call repair.',
+            },
           ],
         },
       ],

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

@@ -980,6 +980,13 @@ To see `streamText` in action, check out [these examples](#examples).
               description:
                 'The error that occurred while parsing the tool call.',
             },
+            {
+              name: 'abortSignal',
+              type: 'AbortSignal',
+              isOptional: true,
+              description:
+                'An optional signal for cancelling the tool call repair.',
+            },
           ],
         },
       ],

package/docs/07-reference/01-ai-sdk-core/23-tool-search.mdx

@@ -7,8 +7,9 @@ description: Search deferred tools and load their definitions on demand for dire
 
 Creates a tool that searches the surrounding generation's deferred tools by name
 and description. The factory takes no arguments. Use it with `generateText`,
-`streamText`, or `ToolLoopAgent`, either with direct tool calling or with code mode
-configured with `toolDiscovery: 'conversation'`.
+`streamText`, `ToolLoopAgent`, or `WorkflowAgent` from `@ai-sdk/workflow`.
+`WorkflowAgent` supports direct tool calling. The other APIs also support code
+mode configured with `toolDiscovery: 'conversation'`.
 
 ```ts
 import { toolSearch } from 'ai';

package/docs/07-reference/02-ai-sdk-ui/01-use-chat.mdx

@@ -338,7 +338,7 @@ Allows you to easily create a conversational user interface for your chatbot app
       type: 'number',
       isOptional: true,
       description:
-        'Custom throttle wait in ms for the chat messages and data updates. Default is undefined, which disables throttling.',
+        'React and Vue only. Custom throttle wait time in milliseconds for reactive chat message updates. Positive values reduce UI update frequency without delaying stream processing or callbacks, and the latest messages are published before a ready or error status. Default is undefined, which disables throttling.',
     },
     {
       name: 'resume',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.106",
+  "version": "7.0.108",
   "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,20 +42,20 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.86",
+    "@ai-sdk/gateway": "4.0.88",
     "@ai-sdk/provider": "4.0.17",
-    "@ai-sdk/provider-utils": "5.0.44"
+    "@ai-sdk/provider-utils": "5.0.45"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.87",
-    "@ai-sdk/deepseek": "3.0.48",
-    "@ai-sdk/google": "4.0.75",
-    "@ai-sdk/groq": "4.0.45",
-    "@ai-sdk/huggingface": "2.0.52",
-    "@ai-sdk/moonshotai": "3.0.53",
-    "@ai-sdk/openai": "4.0.70",
+    "@ai-sdk/amazon-bedrock": "5.0.89",
+    "@ai-sdk/deepseek": "3.0.50",
+    "@ai-sdk/google": "4.0.76",
+    "@ai-sdk/groq": "4.0.46",
+    "@ai-sdk/huggingface": "2.0.53",
+    "@ai-sdk/moonshotai": "3.0.54",
+    "@ai-sdk/openai": "4.0.72",
     "@ai-sdk/test-server": "2.0.1",
-    "@ai-sdk/xai": "5.0.3",
+    "@ai-sdk/xai": "5.0.5",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

package/src/generate-speech/generate-speech.ts

@@ -155,14 +155,19 @@ export async function generateSpeech({
     model: resolvedModel.modelId,
   });
 
+  const detectedMediaType = detectMediaType({
+    data: result.audio,
+    topLevelType: 'audio',
+  });
+
   return new DefaultSpeechResult({
     audio: new DefaultGeneratedAudioFile({
       data: result.audio,
       mediaType:
-        detectMediaType({
-          data: result.audio,
-          topLevelType: 'audio',
-        }) ?? 'audio/mp3',
+        detectedMediaType ??
+        getResponseAudioMediaType(result.response.headers) ??
+        getOutputFormatMediaType(outputFormat) ??
+        'audio/mp3',
     }),
     warnings: result.warnings,
     responses: [result.response],
@@ -170,6 +175,41 @@ export async function generateSpeech({
   });
 }
 
+function getResponseAudioMediaType(
+  headers: Record<string, string> | undefined,
+): string | undefined {
+  const mediaType = Object.entries(headers ?? {}).find(
+    ([name]) => name.toLowerCase() === 'content-type',
+  )?.[1];
+
+  if (mediaType == null) {
+    return undefined;
+  }
+
+  const normalizedMediaType = mediaType.split(';', 1)[0].trim().toLowerCase();
+
+  if (normalizedMediaType.length === 0) {
+    return undefined;
+  }
+
+  return normalizedMediaType.startsWith('audio/')
+    ? normalizedMediaType
+    : undefined;
+}
+
+function getOutputFormatMediaType(outputFormat: string | undefined) {
+  if (outputFormat == null) {
+    return undefined;
+  }
+
+  const normalizedOutputFormat = outputFormat.trim().toLowerCase();
+
+  return normalizedOutputFormat === 'pcm' ||
+    normalizedOutputFormat === 'audio/pcm'
+    ? 'audio/pcm'
+    : undefined;
+}
+
 class DefaultSpeechResult implements SpeechResult {
   readonly audio: GeneratedAudioFile;
   readonly warnings: Array<Warning>;

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

@@ -118,6 +118,7 @@ import type {
   OnToolExecutionEndCallback,
   OnToolExecutionStartCallback,
 } from './tool-execution-events';
+import { validateToolContext } from './validate-tool-context';
 import type { ToolInputRefinement } from './tool-input-refinement';
 import type { ToolOrder } from './tool-order';
 import type { ToolOutput } from './tool-output';
@@ -1078,11 +1079,12 @@ export async function generateText<
                   .map(toolCall =>
                     parseToolCall({
                       toolCall,
-                      tools: stepExecutionTools as TOOLS,
+                      tools: stepModelTools as TOOLS,
                       repairToolCall,
                       refineToolInput,
                       instructions: stepInstructions,
                       messages: stepMessages,
+                      abortSignal: mergedAbortSignal,
                     }),
                   ),
               );
@@ -1183,23 +1185,34 @@ export async function generateText<
                   continue;
                 }
 
-                if (tool.onInputStart != null) {
-                  await tool.onInputStart({
-                    toolCallId: toolCall.toolCallId,
-                    messages: stepMessages,
-                    abortSignal: mergedAbortSignal,
-                    context: runtimeContext,
+                if (
+                  tool.onInputStart != null ||
+                  tool.onInputAvailable != null
+                ) {
+                  const context = await validateToolContext({
+                    toolName: toolCall.toolName,
+                    context: getOwn(toolsContext, toolCall.toolName),
+                    contextSchema: tool.contextSchema,
                   });
-                }
 
-                if (tool?.onInputAvailable != null) {
-                  await tool.onInputAvailable({
-                    input: toolCall.input,
-                    toolCallId: toolCall.toolCallId,
-                    messages: stepMessages,
-                    abortSignal: mergedAbortSignal,
-                    context: runtimeContext,
-                  });
+                  if (tool.onInputStart != null) {
+                    await tool.onInputStart({
+                      toolCallId: toolCall.toolCallId,
+                      messages: stepMessages,
+                      abortSignal: mergedAbortSignal,
+                      context,
+                    });
+                  }
+
+                  if (tool.onInputAvailable != null) {
+                    await tool.onInputAvailable({
+                      input: toolCall.input,
+                      toolCallId: toolCall.toolCallId,
+                      messages: stepMessages,
+                      abortSignal: mergedAbortSignal,
+                      context,
+                    });
+                  }
                 }
 
                 const toolApprovalStatus = await resolveToolApproval({

package/src/generate-text/invoke-tool-callbacks-from-stream.ts

@@ -1,4 +1,8 @@
-import type { Context, ModelMessage, ToolSet } from '@ai-sdk/provider-utils';
+import type {
+  InferToolSetContext,
+  ModelMessage,
+  ToolSet,
+} from '@ai-sdk/provider-utils';
 import { createIdMap } from '../util/create-id-map';
 import { getOwn } from '../util/get-own';
 import type { LanguageModelStreamPart } from './stream-language-model-call';
@@ -6,30 +10,61 @@ import {
   isStreamRetryAttemptBoundaryPart,
   type StreamRetryAttemptBoundaryPart,
 } from './stream-retry-attempt-boundary';
+import { validateToolContext } from './validate-tool-context';
 
 type ToolCallbackStreamPart<TOOLS extends ToolSet> =
   | LanguageModelStreamPart<TOOLS>
   | StreamRetryAttemptBoundaryPart;
 
-export function invokeToolCallbacksFromStream<
-  TOOLS extends ToolSet,
-  RUNTIME_CONTEXT extends Context,
->({
+export function invokeToolCallbacksFromStream<TOOLS extends ToolSet>({
   stream,
   tools,
   stepInputMessages,
   abortSignal,
-  runtimeContext,
+  toolsContext,
 }: {
   stream: ReadableStream<ToolCallbackStreamPart<TOOLS>>;
   tools: TOOLS | undefined;
   stepInputMessages: Array<ModelMessage>;
   abortSignal: AbortSignal | undefined;
-  runtimeContext: RUNTIME_CONTEXT;
+  toolsContext: InferToolSetContext<TOOLS>;
 }): ReadableStream<ToolCallbackStreamPart<TOOLS>> {
   if (tools == null) return stream;
 
-  const ongoingToolCallToolNames: Record<string, string> = createIdMap();
+  let ongoingToolCalls: Record<
+    string,
+    {
+      toolName: string;
+      validatedContext: Promise<unknown> | undefined;
+    }
+  > = createIdMap();
+
+  const getValidatedContext = ({
+    toolCallId,
+    toolName,
+  }: {
+    toolCallId: string;
+    toolName: string;
+  }): Promise<unknown> => {
+    const ongoingToolCall = ongoingToolCalls[toolCallId];
+
+    if (ongoingToolCall?.validatedContext != null) {
+      return ongoingToolCall.validatedContext;
+    }
+
+    const tool = getOwn(tools, toolName);
+    const validatedContext = validateToolContext({
+      toolName,
+      context: getOwn(toolsContext, toolName),
+      contextSchema: tool?.contextSchema,
+    });
+
+    if (ongoingToolCall != null) {
+      ongoingToolCall.validatedContext = validatedContext;
+    }
+
+    return validatedContext;
+  };
 
   return stream.pipeThrough(
     new TransformStream({
@@ -37,12 +72,16 @@ export function invokeToolCallbacksFromStream<
         controller.enqueue(chunk);
 
         if (isStreamRetryAttemptBoundaryPart(chunk)) {
+          ongoingToolCalls = createIdMap();
           return;
         }
 
         switch (chunk.type) {
           case 'tool-input-start': {
-            ongoingToolCallToolNames[chunk.id] = chunk.toolName;
+            ongoingToolCalls[chunk.id] = {
+              toolName: chunk.toolName,
+              validatedContext: undefined,
+            };
 
             const tool = getOwn(tools, chunk.toolName);
             if (tool?.onInputStart != null) {
@@ -50,7 +89,10 @@ export function invokeToolCallbacksFromStream<
                 toolCallId: chunk.id,
                 messages: stepInputMessages,
                 abortSignal,
-                context: runtimeContext,
+                context: await getValidatedContext({
+                  toolCallId: chunk.id,
+                  toolName: chunk.toolName,
+                }),
               });
             }
 
@@ -58,7 +100,7 @@ export function invokeToolCallbacksFromStream<
           }
 
           case 'tool-input-delta': {
-            const toolName = ongoingToolCallToolNames[chunk.id];
+            const toolName = ongoingToolCalls[chunk.id]?.toolName;
             const tool = getOwn(tools, toolName);
 
             if (tool?.onInputDelta != null) {
@@ -67,7 +109,10 @@ export function invokeToolCallbacksFromStream<
                 toolCallId: chunk.id,
                 messages: stepInputMessages,
                 abortSignal,
-                context: runtimeContext,
+                context: await getValidatedContext({
+                  toolCallId: chunk.id,
+                  toolName,
+                }),
               });
             }
 
@@ -75,19 +120,26 @@ export function invokeToolCallbacksFromStream<
           }
 
           case 'tool-call': {
-            const toolName = ongoingToolCallToolNames[chunk.toolCallId];
+            const toolName = ongoingToolCalls[chunk.toolCallId]?.toolName;
             const tool = getOwn(tools, toolName);
 
-            delete ongoingToolCallToolNames[chunk.toolCallId];
-
             if (!chunk.invalid && tool?.onInputAvailable != null) {
+              const validatedContext = getValidatedContext({
+                toolCallId: chunk.toolCallId,
+                toolName,
+              });
+
+              delete ongoingToolCalls[chunk.toolCallId];
+
               await tool.onInputAvailable({
                 input: chunk.input,
                 toolCallId: chunk.toolCallId,
                 messages: stepInputMessages,
                 abortSignal,
-                context: runtimeContext,
+                context: await validatedContext,
               });
+            } else {
+              delete ongoingToolCalls[chunk.toolCallId];
             }
           }
         }

package/src/generate-text/parse-tool-call.ts

@@ -23,6 +23,7 @@ export async function parseToolCall<TOOLS extends ToolSet>({
   refineToolInput,
   messages,
   instructions,
+  abortSignal,
 }: {
   toolCall: LanguageModelV4ToolCall;
   tools: TOOLS | undefined;
@@ -30,6 +31,7 @@ export async function parseToolCall<TOOLS extends ToolSet>({
   refineToolInput?: ToolInputRefinement<TOOLS> | undefined;
   instructions: Instructions | undefined;
   messages: ModelMessage[];
+  abortSignal?: AbortSignal;
 }): Promise<TypedToolCall<TOOLS>> {
   try {
     if (tools == null) {
@@ -63,19 +65,25 @@ export async function parseToolCall<TOOLS extends ToolSet>({
       let repairedToolCall: LanguageModelV4ToolCall | null = null;
 
       try {
-        repairedToolCall = await repairToolCall({
-          toolCall,
-          tools,
-          inputSchema: async ({ toolName }) => {
-            const inputSchema = getOwn(tools, toolName)?.inputSchema;
-            return await asSchema(inputSchema).jsonSchema;
-          },
-          instructions,
-          system: instructions,
-          messages,
-          error,
+        abortSignal?.throwIfAborted();
+        repairedToolCall = await waitForPromiseWithAbortSignal({
+          promise: repairToolCall({
+            toolCall,
+            tools,
+            inputSchema: async ({ toolName }) => {
+              const inputSchema = getOwn(tools, toolName)?.inputSchema;
+              return await asSchema(inputSchema).jsonSchema;
+            },
+            instructions,
+            system: instructions,
+            messages,
+            error,
+            abortSignal,
+          }),
+          abortSignal,
         });
       } catch (repairError) {
+        abortSignal?.throwIfAborted();
         throw new ToolCallRepairError({
           cause: repairError,
           originalError: error,
@@ -87,12 +95,18 @@ export async function parseToolCall<TOOLS extends ToolSet>({
         throw error;
       }
 
-      return await refineParsedToolCallInput({
+      const parsedRepairedToolCall = await refineParsedToolCallInput({
         toolCall: await doParseToolCall({ toolCall: repairedToolCall, tools }),
         refineToolInput,
       });
+
+      abortSignal?.throwIfAborted();
+
+      return parsedRepairedToolCall;
     }
   } catch (error) {
+    abortSignal?.throwIfAborted();
+
     // use parsed input when possible
     const parsedInput = await safeParseJSON({ text: toolCall.input });
     const input = parsedInput.success ? parsedInput.value : toolCall.input;
@@ -115,6 +129,44 @@ export async function parseToolCall<TOOLS extends ToolSet>({
   }
 }
 
+async function waitForPromiseWithAbortSignal<T>({
+  promise,
+  abortSignal,
+}: {
+  promise: PromiseLike<T>;
+  abortSignal: AbortSignal | undefined;
+}): Promise<T> {
+  if (abortSignal == null) {
+    return await promise;
+  }
+
+  return await new Promise<T>((resolve, reject) => {
+    const cleanup = () => {
+      abortSignal.removeEventListener('abort', onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(abortSignal.reason);
+    };
+
+    Promise.resolve(promise)
+      .then(value => {
+        cleanup();
+        resolve(value);
+      })
+      .catch(error => {
+        cleanup();
+        reject(error);
+      });
+
+    abortSignal.addEventListener('abort', onAbort, { once: true });
+
+    if (abortSignal.aborted) {
+      onAbort();
+    }
+  });
+}
+
 async function refineParsedToolCallInput<TOOLS extends ToolSet>({
   toolCall,
   refineToolInput,