ai 7.0.107 → 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/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/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.107",
+  "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.87",
+    "@ai-sdk/gateway": "4.0.88",
     "@ai-sdk/provider": "4.0.17",
     "@ai-sdk/provider-utils": "5.0.45"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.88",
-    "@ai-sdk/deepseek": "3.0.49",
+    "@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.71",
+    "@ai-sdk/openai": "4.0.72",
     "@ai-sdk/test-server": "2.0.1",
-    "@ai-sdk/xai": "5.0.4",
+    "@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-text/generate-text.ts

@@ -1079,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,
                     }),
                   ),
               );

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,

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

@@ -373,6 +373,7 @@ export async function streamLanguageModelCall<
       messages: standardizedPrompt.messages,
       repairToolCall,
       refineToolInput,
+      abortSignal,
       callId: effectiveCallId,
       provider: resolvedModel.provider,
       modelId: resolvedModel.modelId,
@@ -400,6 +401,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
   messages,
   repairToolCall,
   refineToolInput,
+  abortSignal,
   callId,
   provider,
   modelId,
@@ -414,6 +416,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
   messages: ModelMessage[];
   repairToolCall: ToolCallRepairFunction<TOOLS> | undefined;
   refineToolInput: ToolInputRefinement<TOOLS> | undefined;
+  abortSignal: AbortSignal | undefined;
   callId: string;
   provider: string;
   modelId: string;
@@ -637,40 +640,47 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
             callbacks: onLanguageModelCallEnd,
           });
 
-          // Preserve the completed model call's usage, metadata, and
-          // performance even when response validation below surfaces a
-          // semantic error.
-          controller.enqueue({
-            type: 'model-call-end',
-            finishReason: chunk.finishReason.unified,
-            rawFinishReason: chunk.finishReason.raw,
-            usage,
-            providerMetadata: chunk.providerMetadata,
-            performance,
-          });
-
           const enforcedToolChoice =
             toolChoice.type === 'required' || toolChoice.type === 'tool'
               ? toolChoice
               : undefined;
 
-          if (
+          const toolChoiceViolationError =
             enforcedToolChoice != null &&
             ![...toolCallsByToolCallId.values()].some(
               toolCall =>
                 enforcedToolChoice.type === 'required' ||
                 toolCall.toolName === enforcedToolChoice.toolName,
             )
-          ) {
+              ? new ToolChoiceViolationError({
+                  toolChoice: enforcedToolChoice,
+                  finishReason: chunk.finishReason.unified,
+                  provider,
+                  modelId,
+                  content: rawModelCallContent,
+                })
+              : undefined;
+
+          // Preserve the completed model call's usage, metadata, and
+          // performance even when response validation below surfaces a
+          // semantic error. Prevent invalid tool calls from being executed
+          // when the model-call-end event reaches the tool executor.
+          controller.enqueue({
+            type: 'model-call-end',
+            finishReason:
+              toolChoiceViolationError == null
+                ? chunk.finishReason.unified
+                : 'error',
+            rawFinishReason: chunk.finishReason.raw,
+            usage,
+            providerMetadata: chunk.providerMetadata,
+            performance,
+          });
+
+          if (toolChoiceViolationError != null) {
             controller.enqueue({
               type: 'error',
-              error: new ToolChoiceViolationError({
-                toolChoice: enforcedToolChoice,
-                finishReason: chunk.finishReason.unified,
-                provider,
-                modelId,
-                content: rawModelCallContent,
-              }),
+              error: toolChoiceViolationError,
             });
             break;
           }
@@ -688,6 +698,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
               refineToolInput,
               instructions,
               messages,
+              abortSignal,
             });
 
             toolCallsByToolCallId.set(toolCall.toolCallId, toolCall);

package/src/generate-text/tool-call-repair-function.ts

@@ -17,6 +17,7 @@ import type { ToolSet } from '@ai-sdk/provider-utils';
  * @param options.tools - The tools that are available.
  * @param options.inputSchema - A function that returns the JSON Schema for a tool.
  * @param options.error - The error that occurred while parsing the tool call.
+ * @param options.abortSignal - An optional signal for cancelling the repair.
  */
 export type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
   instructions: Instructions | undefined;
@@ -29,4 +30,5 @@ export type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
   tools: TOOLS;
   inputSchema: (options: { toolName: string }) => PromiseLike<JSONSchema7>;
   error: NoSuchToolError | InvalidToolInputError;
+  abortSignal?: AbortSignal;
 }) => Promise<LanguageModelV4ToolCall | null>;

package/src/model/as-language-model-v4.ts

@@ -1,8 +1,20 @@
-import type {
-  LanguageModelV2,
-  LanguageModelV3,
-  LanguageModelV4,
+import {
+  type LanguageModelV2,
+  type LanguageModelV3,
+  type LanguageModelV3Content,
+  type LanguageModelV3DataContent,
+  type LanguageModelV3Prompt,
+  type LanguageModelV3StreamPart,
+  type LanguageModelV3ToolResultOutput,
+  type LanguageModelV4,
+  type LanguageModelV4CallOptions,
+  type LanguageModelV4Content,
+  type LanguageModelV4Prompt,
+  type LanguageModelV4StreamPart,
+  type LanguageModelV4ToolResultOutput,
+  type SharedV4FileData,
 } from '@ai-sdk/provider';
+import { convertUint8ArrayToBase64 } from '@ai-sdk/provider-utils';
 import { asLanguageModelV3 } from './as-language-model-v3';
 
 export function asLanguageModelV4(
@@ -18,8 +30,156 @@ export function asLanguageModelV4(
 
   return new Proxy(v3Model, {
     get(target, prop: keyof LanguageModelV3) {
-      if (prop === 'specificationVersion') return 'v4';
-      return target[prop];
+      switch (prop) {
+        case 'specificationVersion':
+          return 'v4';
+        case 'doGenerate':
+          return async (options: LanguageModelV4CallOptions) => {
+            const result = await target.doGenerate({
+              ...options,
+              prompt: convertV4PromptToV3(options.prompt),
+            });
+
+            return {
+              ...result,
+              content: result.content.map(convertV3ContentToV4),
+            };
+          };
+        case 'doStream':
+          return async (options: LanguageModelV4CallOptions) => {
+            const result = await target.doStream({
+              ...options,
+              prompt: convertV4PromptToV3(options.prompt),
+            });
+
+            return {
+              ...result,
+              stream: convertV3StreamToV4(result.stream),
+            };
+          };
+        default:
+          return target[prop];
+      }
     },
   }) as unknown as LanguageModelV4;
 }
+
+function convertV4PromptToV3(
+  prompt: LanguageModelV4Prompt,
+): LanguageModelV3Prompt {
+  return prompt.map(message => {
+    if (message.role === 'system') {
+      return message;
+    }
+
+    return {
+      ...message,
+      content: message.content.map(part => {
+        switch (part.type) {
+          case 'file':
+            return {
+              ...part,
+              data: convertV4FileDataToV3(part.data),
+            };
+          case 'tool-result':
+            return {
+              ...part,
+              output: convertV4ToolResultOutputToV3(part.output),
+            };
+          default:
+            return part;
+        }
+      }),
+    };
+  }) as LanguageModelV3Prompt;
+}
+
+function convertV4FileDataToV3(
+  data: SharedV4FileData,
+): LanguageModelV3DataContent {
+  switch (data.type) {
+    case 'data':
+      return data.data;
+    case 'url':
+      return data.url;
+    case 'reference':
+    case 'text':
+      // pass through unsupported types as is
+      return data as unknown as LanguageModelV3DataContent;
+  }
+}
+
+function convertV4ToolResultOutputToV3(
+  output: LanguageModelV4ToolResultOutput,
+): LanguageModelV3ToolResultOutput {
+  if (output.type !== 'content') {
+    return output;
+  }
+
+  return {
+    ...output,
+    value: output.value.map(part => {
+      if (part.type !== 'file') {
+        return part;
+      }
+
+      switch (part.data.type) {
+        case 'data':
+          return {
+            type: 'file-data' as const,
+            data:
+              typeof part.data.data === 'string'
+                ? part.data.data
+                : convertUint8ArrayToBase64(part.data.data),
+            mediaType: part.mediaType,
+            filename: part.filename,
+            providerOptions: part.providerOptions,
+          };
+        case 'url':
+          return {
+            type: 'file-url' as const,
+            url: part.data.url.toString(),
+            providerOptions: part.providerOptions,
+          };
+        case 'reference':
+          return {
+            type: 'file-id' as const,
+            fileId: part.data.reference,
+            providerOptions: part.providerOptions,
+          };
+        case 'text':
+          return part;
+      }
+    }),
+  } as LanguageModelV3ToolResultOutput;
+}
+
+function convertV3ContentToV4(
+  content: LanguageModelV3Content,
+): LanguageModelV4Content {
+  return content.type === 'file'
+    ? {
+        ...content,
+        data: { type: 'data', data: content.data },
+      }
+    : content;
+}
+
+function convertV3StreamToV4(
+  stream: ReadableStream<LanguageModelV3StreamPart>,
+): ReadableStream<LanguageModelV4StreamPart> {
+  return stream.pipeThrough(
+    new TransformStream<LanguageModelV3StreamPart, LanguageModelV4StreamPart>({
+      transform(chunk, controller) {
+        controller.enqueue(
+          chunk.type === 'file'
+            ? {
+                ...chunk,
+                data: { type: 'data', data: chunk.data },
+              }
+            : chunk,
+        );
+      },
+    }),
+  );
+}