ai 7.0.107 → 7.0.109

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-harnesses/02-harness-agent.mdx

@@ -362,6 +362,8 @@ When you only have raw continuation state from `suspendTurn()`, resume with
 const session = await agent.createSession({
   sessionId: chatId,
   continueFrom: continuationState,
+  // Rebind this when the suspended turn used host-only tool context:
+  toolsContext,
 });
 
 const result = await agent.continueStream({ session });
@@ -370,6 +372,11 @@ const result = await agent.continueStream({ session });
 Use `continueStream()` for incremental output, or `continueGenerate()` to drain
 the continued turn and return a `GenerateTextResult`.
 
+`toolsContext` is intentionally not stored in continuation state because it can
+contain credentials or non-serializable host objects. When a suspended turn
+used static or `prepareCall`-derived tool context, pass the same per-tool map to
+`createSession` to rebind it in the process that continues the turn.
+
 ## Stop After a Harness Step
 
 Use `stopWhen` to opt into semantic step boundaries. Predicates run after real

package/docs/03-ai-sdk-harnesses/03-tools.mdx

@@ -93,6 +93,52 @@ const agent = new HarnessAgent({
 When the harness calls `weather`, `HarnessAgent` executes the tool in your host
 process, then submits the result back to the harness runtime.
 
+Host-executed tools can declare a `contextSchema` and receive turn-scoped
+context through `toolsContext`:
+
+```ts
+const lookupAccount = tool({
+  inputSchema: z.object({}),
+  contextSchema: z.object({ userId: z.string() }),
+  execute: async (_, { context }) => {
+    return loadAccount(context.userId);
+  },
+});
+
+const agent = new HarnessAgent({
+  harness: claudeCode,
+  tools: { lookupAccount },
+  toolsContext: {
+    lookupAccount: { userId: 'user-123' },
+  },
+});
+```
+
+Use `prepareCall` to replace `toolsContext` when the value depends on custom
+call options. The type of `toolsContext` follows the tool set: it is rejected
+when no tool declares a context schema, required when a tool requires a
+context object, and optional when every context object is optional.
+`HarnessAgent` validates each entry against the tool's `contextSchema` before
+execution and exposes the configured map in step results and lifecycle
+callbacks.
+
+Tool context remains host-only and is not serialized into suspended-turn state.
+When recreating a session for an unfinished turn, rebind it explicitly:
+
+```ts
+const session = await agent.createSession({
+  sessionId,
+  continueFrom,
+  toolsContext: {
+    lookupAccount: { userId: 'user-123' },
+  },
+});
+```
+
+Missing or invalid context fails validation before the host tool executes. The
+validation error returned to the harness runtime is intentionally generic so
+host-only context values and schema details are not disclosed to the model.
+
 ## Client-Side Tools
 
 Omit `execute` when a browser, user interaction, or another external process

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.109",
   "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.90",
+    "@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/generate-text/tools-context-parameter.ts

@@ -10,13 +10,19 @@ import type {
 type IsEmptyObject<OBJECT> = keyof OBJECT extends never ? true : false;
 
 /**
- * Helper type to make the toolsContext parameter optional, required, or
- * unavailable based on the tool set.
+ * Makes the toolsContext setting optional, required, or unavailable based on
+ * the tool set.
+ */
+export type ToolsContextSettings<TOOLS extends ToolSet> =
+  IsEmptyObject<InferToolSetContext<TOOLS>> extends true
+    ? { toolsContext?: never }
+    : HasRequiredKey<InferToolSetContext<TOOLS>> extends true
+      ? { toolsContext: InferToolSetContext<TOOLS> }
+      : { toolsContext?: InferToolSetContext<TOOLS> };
+
+/**
+ * Helper type for request options that include both tools and their context.
  */
 export type ToolsContextParameter<TOOLS extends ToolSet> = {
   tools?: TOOLS;
-} & (IsEmptyObject<InferToolSetContext<TOOLS>> extends true
-  ? { toolsContext?: never }
-  : HasRequiredKey<InferToolSetContext<TOOLS>> extends true
-    ? { toolsContext: InferToolSetContext<TOOLS> }
-    : { toolsContext?: InferToolSetContext<TOOLS> });
+} & ToolsContextSettings<TOOLS>;

package/src/middleware/extract-reasoning-middleware.ts

@@ -90,12 +90,17 @@ export function extractReasoningMiddleware({
           afterSwitch: boolean;
           isReasoning: boolean;
           buffer: string;
-          idCounter: number;
+          reasoningId: string | undefined;
           textId: string;
         }
       > = createIdMap();
 
-      let delayedTextStart: LanguageModelV4StreamPart | undefined;
+      let reasoningIdCounter = 0;
+
+      const delayedTextStarts: Record<
+        string,
+        Extract<LanguageModelV4StreamPart, { type: 'text-start' }>
+      > = createIdMap();
 
       return {
         stream: stream.pipeThrough(
@@ -107,13 +112,16 @@ export function extractReasoningMiddleware({
               // do not send `text-start` before `reasoning-start`
               // https://github.com/vercel/ai/issues/7774
               if (chunk.type === 'text-start') {
-                delayedTextStart = chunk;
+                delayedTextStarts[chunk.id] = chunk;
                 return;
               }
 
-              if (chunk.type === 'text-end' && delayedTextStart) {
-                controller.enqueue(delayedTextStart);
-                delayedTextStart = undefined;
+              if (
+                chunk.type === 'text-end' &&
+                delayedTextStarts[chunk.id] != null
+              ) {
+                controller.enqueue(delayedTextStarts[chunk.id]);
+                delete delayedTextStarts[chunk.id];
               }
 
               if (chunk.type !== 'text-delta') {
@@ -128,7 +136,7 @@ export function extractReasoningMiddleware({
                   afterSwitch: false,
                   isReasoning: startWithReasoning,
                   buffer: '',
-                  idCounter: 0,
+                  reasoningId: undefined,
                   textId: chunk.id,
                 };
               }
@@ -137,6 +145,10 @@ export function extractReasoningMiddleware({
 
               activeExtraction.buffer += chunk.delta;
 
+              function getReasoningId() {
+                return (activeExtraction.reasoningId ??= `reasoning-${reasoningIdCounter++}`);
+              }
+
               function publish(text: string) {
                 if (text.length > 0) {
                   const prefix =
@@ -154,7 +166,7 @@ export function extractReasoningMiddleware({
                   ) {
                     controller.enqueue({
                       type: 'reasoning-start',
-                      id: `reasoning-${activeExtraction.idCounter}`,
+                      id: getReasoningId(),
                     });
                   }
 
@@ -162,12 +174,14 @@ export function extractReasoningMiddleware({
                     controller.enqueue({
                       type: 'reasoning-delta',
                       delta: prefix + text,
-                      id: `reasoning-${activeExtraction.idCounter}`,
+                      id: getReasoningId(),
                     });
                   } else {
-                    if (delayedTextStart) {
-                      controller.enqueue(delayedTextStart);
-                      delayedTextStart = undefined;
+                    if (delayedTextStarts[activeExtraction.textId] != null) {
+                      controller.enqueue(
+                        delayedTextStarts[activeExtraction.textId],
+                      );
+                      delete delayedTextStarts[activeExtraction.textId];
                     }
                     controller.enqueue({
                       type: 'text-delta',
@@ -221,15 +235,16 @@ export function extractReasoningMiddleware({
                     if (activeExtraction.isFirstReasoning) {
                       controller.enqueue({
                         type: 'reasoning-start',
-                        id: `reasoning-${activeExtraction.idCounter}`,
+                        id: getReasoningId(),
                       });
                     }
 
                     // reasoning part finished:
                     controller.enqueue({
                       type: 'reasoning-end',
-                      id: `reasoning-${activeExtraction.idCounter++}`,
+                      id: getReasoningId(),
                     });
+                    activeExtraction.reasoningId = undefined;
                   }
 
                   activeExtraction.isReasoning = !activeExtraction.isReasoning;