ai 7.0.135 → 7.0.137

package/dist/internal/index.d.ts

@@ -606,9 +606,9 @@ type LanguageModelCallOptions = {
  * Timeout configuration for API calls. Can be specified as:
  * - A number representing milliseconds
  * - An object with `totalMs` property for the total timeout in milliseconds
- * - An object with `stepMs` property for the timeout of each step in milliseconds
+ * - An object with `stepMs` property for the timeout of each complete step, including model generation, retries, and local tool execution, in milliseconds
  * - An object with `firstChunkMs` property for the timeout until the first content chunk of each step (streaming only)
- * - An object with `chunkMs` property for the timeout between content chunks (streaming only)
+ * - An object with `chunkMs` property for the timeout between meaningful model output chunks, starting with the first output and ending when the model response ends (streaming only)
  * - An object with `toolMs` property for the default timeout for all tool executions
  * - An object with `tools` property for per-tool timeout overrides using `{toolName}Ms` keys
  */

package/dist/internal/index.js

@@ -111,7 +111,7 @@ function asAsyncIterableStream(stream) {
 }
 //#endregion
 //#region src/version.ts
-const VERSION = "7.0.135";
+const VERSION = "7.0.137";
 //#endregion
 //#region src/util/download/download.ts
 /**

package/docs/03-ai-sdk-core/15-tools-and-tool-calling.mdx

@@ -400,7 +400,7 @@ You can also combine multiple conditions in an array or create custom conditions
   results.
 </Note>
 
-By default, when you use `generateText` or `streamText`, it triggers a single generation. This works well for many use cases where you can rely on the model's training data to generate a response. However, when you provide tools, the model now has the choice to either generate a normal text response, or generate a tool call. If the model generates a tool call, its generation is complete and that step is finished.
+By default, when you use `generateText` or `streamText`, it triggers a single generation. This works well for many use cases where you can rely on the model's training data to generate a response. However, when you provide tools, the model now has the choice to either generate a normal text response, or generate a tool call. A step includes one model generation and the execution of any local tools requested by that generation. If the model generates a tool call, the model generation finishes first; the step finishes after its local tool execution completes.
 
 You may want the model to generate text after the tool has been executed, either to summarize the tool results in the context of the users query. In many cases, you may also want the model to use multiple tools in a single response. This is where multi-step calls come in.
 

package/docs/03-ai-sdk-core/17-mcp-events.mdx

@@ -19,8 +19,12 @@ endpoint receives the events.
 ## Choose who manages subscriptions
 
 Use `experimental_events: { adapter }` when a backend manages subscriptions,
-webhook delivery and renewal. The adapter exposes managed watch handles and
-requires no AI SDK event store. See [managed subscriptions](/docs/reference/ai-sdk-core/mcp-events#managed-subscriptions).
+webhook delivery and renewal. Supply an adapter whose
+`createAdapter({ transport })` receives the MCP transport type and URL
+(or just the type for custom transports) and returns bound
+managed watch operations. No AI SDK event store is required. A backend SDK helper can
+return this adapter directly, so callers do not need an inline `createAdapter`
+wrapper. See [managed subscriptions](/docs/reference/ai-sdk-core/mcp-events#managed-subscriptions).
 
 Use `experimental_events: { store }` when your application directly registers
 MCP webhooks, persists their secrets and schedules renewal. The following flow

package/docs/03-ai-sdk-core/25-settings.mdx

@@ -142,12 +142,14 @@ This is a convenience parameter that creates an abort signal internally. It can
 You can specify the timeout either as a number (milliseconds) or as an object with the following properties:
 
 - `totalMs`: The total timeout for the entire call including all steps.
-- `stepMs`: The timeout for each individual step (LLM call). This is useful for multi-step generations where you want to limit the time spent on each step independently.
+- `stepMs`: The timeout for each complete step, including model generation, retries, and local tool execution. The budget is cumulative across provider attempts within the step.
 - `firstChunkMs`: The timeout until the first content-bearing output of each step (streaming only). Text deltas, reasoning deltas, tool-input deltas, generated files, and tool calls satisfy the timeout. Response metadata, stream starts, empty deltas, raw chunks, and transport activity do not satisfy or reset it.
-- `chunkMs`: The timeout between content-bearing output chunks after output has started (streaming only). Non-content chunks do not reset it. This is useful for detecting streams that stall after generation begins.
+- `chunkMs`: The timeout between meaningful model output chunks after output has started (streaming only). It starts with the first meaningful output; it does not limit the wait for that first output. Non-content chunks do not reset it. This is useful for detecting streams that stall after generation begins.
 - `toolMs`: The default timeout for all tool executions. If a tool takes longer, it aborts and returns a tool-error so the model can respond or retry.
 - `tools`: Per-tool timeout overrides using `{toolName}Ms` keys (e.g. `weatherMs`, `slowApiMs`). Takes precedence over `toolMs`. Tool names are type-checked for autocomplete.
 
+The `firstChunkMs` and `chunkMs` timers stop when the model response finishes, errors, closes, or is cancelled. Each provider retry or later model call gets fresh output timeout budgets. Retry backoff and local tool execution are outside these budgets. Provider-executed tools remain within the model response. The `stepMs` and `totalMs` budgets remain active across retries and local tool execution.
+
 #### Example: 5 second timeout (number format)
 
 ```ts

package/docs/03-ai-sdk-core/32-decisions.mdx

@@ -82,8 +82,9 @@ from `ai`. A part has one of these shapes:
 - JSON: `{ type: 'json', value: JSONValue }`.
 
 Language-model decision adapters accept image files only. The underlying model
-must support the file data form. Gateway and TypeSafe AI accept text and JSON
-state only.
+must support the file data form. Gateway forwards image files to the routed
+decision model, which must support image input. TypeSafe AI accepts text and
+JSON state only.
 
 Arrays passed directly as `state` contain parts. To send a JSON array, put it
 inside an object (`state: { records }`) or a JSON part

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

@@ -479,7 +479,7 @@ To see `generateText` in action, check out [these examples](#examples).
       type: 'number | { totalMs?: number; stepMs?: number; toolMs?: number; tools?: Partial<Record<`${toolName}Ms`, number>> }',
       isOptional: true,
       description:
-        'Timeout in milliseconds. Can be specified as a number or as an object with totalMs, stepMs, toolMs, and/or tools properties. totalMs sets the total timeout for the entire call. stepMs sets the timeout for each individual step (LLM call). toolMs sets the default timeout for all tool executions. tools sets per-tool timeout overrides using the pattern {toolName}Ms (e.g. weatherMs, slowApiMs) that take precedence over toolMs - tool names are type-checked for autocomplete. If a tool takes longer than its timeout, it aborts and returns a tool-error so the model can respond or retry. Can be used alongside abortSignal.',
+        'Timeout in milliseconds. Can be specified as a number or as an object with totalMs, stepMs, toolMs, and/or tools properties. totalMs sets the total timeout for the entire call. stepMs sets the timeout for each complete step, including model generation, retries, and local tool execution. toolMs sets the default timeout for all tool executions. tools sets per-tool timeout overrides using the pattern {toolName}Ms (e.g. weatherMs, slowApiMs) that take precedence over toolMs - tool names are type-checked for autocomplete. If a tool takes longer than its timeout, it aborts and returns a tool-error so the model can respond or retry. Can be used alongside abortSignal.',
     },
     {
       name: 'headers',
@@ -1251,7 +1251,7 @@ To see `generateText` in action, check out [these examples](#examples).
       type: '(event: GenerateTextStepStartEvent) => PromiseLike<void> | void',
       isOptional: true,
       description:
-        'Callback that is called when a step (LLM call) begins, before the provider is called. Errors thrown in this callback are silently caught and do not break the generation flow.',
+        'Callback that is called when a step begins, before the provider is called. Errors thrown in this callback are silently caught and do not break the generation flow.',
       properties: [
         {
           type: 'GenerateTextStepStartEvent',

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

@@ -487,7 +487,7 @@ To see `streamText` in action, check out [these examples](#examples).
       type: 'number | { totalMs?: number; stepMs?: number; firstChunkMs?: number; chunkMs?: number; toolMs?: number; tools?: Partial<Record<`${toolName}Ms`, number>> }',
       isOptional: true,
       description:
-        'Timeout in milliseconds. Can be specified as a number or as an object with totalMs, stepMs, firstChunkMs, chunkMs, toolMs, and/or tools properties. totalMs sets the total timeout for the entire call. stepMs sets the timeout for each individual step (LLM call). firstChunkMs sets the timeout until the first content-bearing output in each step; metadata, stream starts, empty deltas, raw chunks, and transport activity do not satisfy it. chunkMs sets the timeout between content-bearing output chunks after output has started; non-content chunks do not reset it. toolMs sets the default timeout for all tool executions. tools sets per-tool timeout overrides using the pattern {toolName}Ms (e.g. weatherMs, slowApiMs) that take precedence over toolMs - tool names are type-checked for autocomplete. If a tool takes longer than its timeout, it aborts and returns a tool-error so the model can respond or retry. Can be used alongside abortSignal.',
+        'Timeout in milliseconds. Can be specified as a number or as an object with totalMs, stepMs, firstChunkMs, chunkMs, toolMs, and/or tools properties. totalMs sets the total timeout for the entire call. stepMs sets the timeout for each complete step, including model generation, retries, and local tool execution. firstChunkMs sets the timeout until the first content-bearing output in each step; metadata, stream starts, empty deltas, raw chunks, and transport activity do not satisfy it. chunkMs starts with the first meaningful model output and limits gaps between subsequent meaningful model output chunks. Both output timers stop when the model response finishes and start fresh for each retry or later model call. Local tool results, including preliminary results, do not reset them; local tool execution is outside their scope. Provider-executed tools remain within the model response. toolMs sets the default timeout for all tool executions. tools sets per-tool timeout overrides using the pattern {toolName}Ms (e.g. weatherMs, slowApiMs) that take precedence over toolMs - tool names are type-checked for autocomplete. If a tool takes longer than its timeout, it aborts and returns a tool-error so the model can respond or retry. Can be used alongside abortSignal.',
     },
     {
       name: 'headers',
@@ -2265,7 +2265,7 @@ To see `streamText` in action, check out [these examples](#examples).
       type: '(event: GenerateTextStepStartEvent) => PromiseLike<void> | void',
       isOptional: true,
       description:
-        'Callback that is called when a step (LLM call) begins, before the provider is called. Errors thrown in this callback are silently caught and do not break the generation flow.',
+        'Callback that is called when a step begins, before the provider is called. Errors thrown in this callback are silently caught and do not break the generation flow.',
       properties: [
         {
           type: 'GenerateTextStepStartEvent',

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

@@ -306,7 +306,7 @@ To see `ToolLoopAgent` in action, check out [these examples](#examples).
       type: 'GenerateTextOnStepStartCallback',
       isOptional: true,
       description:
-        'Callback that is called when a step (LLM call) begins, before the provider is called. Each step represents a single LLM invocation. If also specified in `generate()` or `stream()`, both callbacks are called (constructor first).',
+        'Callback that is called when a step begins, before the provider is called. Each step includes a model generation and any associated local tool execution; provider retries remain within the same step. If also specified in `generate()` or `stream()`, both callbacks are called (constructor first).',
       properties: [
         {
           type: 'GenerateTextStepStartEvent',
@@ -726,7 +726,7 @@ const result = await agent.generate({
       type: 'number | { totalMs?: number; stepMs?: number; firstChunkMs?: number; chunkMs?: number }',
       isOptional: true,
       description:
-        'Timeout in milliseconds. Can be specified as a number or as an object with totalMs, stepMs, firstChunkMs, and/or chunkMs properties. firstChunkMs and chunkMs have no effect on generate(); they are streaming-only and are enforced by stream(). Can be used alongside abortSignal.',
+        'Timeout in milliseconds. Can be specified as a number or as an object with totalMs, stepMs, firstChunkMs, and/or chunkMs properties. stepMs limits each complete step, including model generation, retries, and local tool execution. firstChunkMs and chunkMs have no effect on generate(); they are streaming-only and are enforced by stream(). Can be used alongside abortSignal.',
     },
     {
       name: 'experimental_sandbox',
@@ -754,7 +754,7 @@ const result = await agent.generate({
       type: 'GenerateTextOnStepStartCallback',
       isOptional: true,
       description:
-        'Callback that is called when a step (LLM call) begins, before the provider is called. If also specified in the constructor, both callbacks are called (constructor first).',
+        'Callback that is called when a step begins, before the provider is called. If also specified in the constructor, both callbacks are called (constructor first).',
     },
     {
       name: 'onToolExecutionStart',
@@ -842,7 +842,7 @@ for await (const chunk of stream.textStream) {
       type: 'number | { totalMs?: number; stepMs?: number; firstChunkMs?: number; chunkMs?: number }',
       isOptional: true,
       description:
-        'Timeout in milliseconds. Can be specified as a number or as an object with totalMs, stepMs, firstChunkMs, and/or chunkMs properties. firstChunkMs limits the wait for the first content-bearing output in each model-call step. chunkMs limits gaps between later content-bearing output chunks. Can be used alongside abortSignal.',
+        'Timeout in milliseconds. Can be specified as a number or as an object with totalMs, stepMs, firstChunkMs, and/or chunkMs properties. stepMs limits each complete step, including model generation, retries, and local tool execution. firstChunkMs limits the wait for the first content-bearing output in each model-call step. chunkMs starts with the first meaningful model output and limits gaps between subsequent meaningful model output chunks. Both output timers stop when the model response finishes and start fresh for each retry or later model call; they exclude retry backoff and local tool execution. Tool results, including preliminary results, do not reset them. Provider-executed tools remain within the model response. Can be used alongside abortSignal.',
     },
     {
       name: 'experimental_sandbox',
@@ -877,7 +877,7 @@ for await (const chunk of stream.textStream) {
       type: 'GenerateTextOnStepStartCallback',
       isOptional: true,
       description:
-        'Callback that is called when a step (LLM call) begins, before the provider is called. If also specified in the constructor, both callbacks are called (constructor first).',
+        'Callback that is called when a step begins, before the provider is called. If also specified in the constructor, both callbacks are called (constructor first).',
     },
     {
       name: 'onToolExecutionStart',

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

@@ -59,10 +59,10 @@ experimental webhook delivery, see the [MCP Events guide](/docs/ai-sdk-core/mcp-
                     },
                     {
                       name: 'adapter',
-                      type: 'Experimental_MCPEventsAdapter',
+                      type: 'Experimental_MCPEventAdapter',
                       isOptional: true,
                       description:
-                        'Delegates subscription management to a backend. Cannot be combined with store or validateArguments. No local event store or refresh loop is required.',
+                        "Required in managed mode. Creates bound subscription operations once before transport startup, receiving transport metadata: { type, url } for HTTP/SSE or { type: 'custom' } for custom transports. Cannot be combined with store or validateArguments. No local event store or refresh loop is required.",
                     },
                     {
                       name: 'validateArguments',

package/docs/07-reference/01-ai-sdk-core/24-mcp-events.mdx

@@ -99,9 +99,11 @@ for the definition fields. Pagination is explicit; this method does not fetch al
 ## Managed Subscriptions
 
 Configure `experimental_events: { adapter }` to delegate subscription lifecycle
-operations to a backend. The adapter implements `Experimental_MCPEventsAdapter`
-from `@ai-sdk/mcp`; it is bound to the authorized account and destination by your
-application or integration package.
+operations to a backend. The `adapter` configuration requires an
+`Experimental_MCPEventAdapter` from `@ai-sdk/mcp`. Its
+`createAdapter({ transport })` method returns `Experimental_MCPEventOperations` bound
+to the authorized account, endpoint and destination by your application or
+integration package.
 
 ```ts
 import { createMCPClient } from '@ai-sdk/mcp';
@@ -143,7 +145,123 @@ try {
 Use the same authorized account for discovery and subscription management.
 Never derive account identity, destination or authorization from model arguments.
 
-### Adapter Contract
+### Using an Adapter Helper
+
+A backend SDK or application helper can return `Experimental_MCPEventAdapter`
+directly. Pass the helper's result as `adapter`; you do not need another object
+wrapper or an inline `createAdapter` callback:
+
+```ts
+import { createMCPClient } from '@ai-sdk/mcp';
+import { createBackendEventsAdapter } from './my-events-adapter';
+
+const client = await createMCPClient({
+  transport: { type: 'http', url: 'https://service.example/mcp' },
+  experimental_events: {
+    adapter: createBackendEventsAdapter({
+      accountId: authenticatedUser.id,
+      destination: { path: '/hooks' },
+    }),
+  },
+});
+```
+
+The helper holds the authorized account and delivery configuration. AI SDK supplies
+the transport type and URL to its `createAdapter` method internally, so the application
+configures that URL only once. When a backend SDK exports this helper, import it
+from that SDK instead of an application module. Use the same authorized account
+for the MCP transport and the backend's subscription operations.
+
+### Implementing an Adapter Helper
+
+Backend integration authors implement `createAdapter` inside their helper:
+
+```ts filename="my-events-adapter.ts"
+import type { Experimental_MCPEventAdapter } from '@ai-sdk/mcp';
+import { createBackendEventOperations } from './my-events-backend';
+
+type BackendEventsConfig = {
+  accountId: string;
+  destination: { path: string };
+  mcpUrl?: string;
+};
+
+export function createBackendEventsAdapter(
+  config: BackendEventsConfig,
+): Experimental_MCPEventAdapter {
+  return {
+    createAdapter({ transport }) {
+      return createBackendEventOperations({
+        ...config,
+        mcpUrl:
+          config.mcpUrl ??
+          (transport.type === 'custom' ? undefined : transport.url),
+      });
+    },
+  };
+}
+```
+
+These helpers and `BackendEventsConfig` are illustrative application or backend
+SDK code, not AI SDK exports. `createBackendEventOperations` returns
+`Experimental_MCPEventOperations` bound to the authorized account, endpoint
+and destination. The helper above lets an explicit `mcpUrl` override the transport
+URL for backend operations; it does not change the MCP client's transport or
+catalog discovery. The backend still authorizes the selected endpoint.
+
+The AI SDK adapter contract is:
+
+```ts
+interface MCPEventAdapter {
+  createAdapter(context: {
+    transport: { type: 'http' | 'sse'; url: string } | { type: 'custom' };
+  }): MCPEventOperations;
+}
+```
+
+The interface is exported as `Experimental_MCPEventAdapter`. The client
+calls `createAdapter` once, before starting the transport, and uses the returned
+operations for managed subscriptions. The return value must be an object with
+callable `subscribe`, `getSubscription`, `listSubscriptions`, and `unsubscribe`
+methods. Nullish values, missing or non-callable methods, and Promise/thenable
+results reject `createMCPClient` with `MCPClientError` before the transport starts.
+Errors thrown by `createAdapter` also reject initialization without starting the
+transport. Bound operations are no longer accepted directly in
+`experimental_events.adapter`. To migrate existing subscription operations, wrap them explicitly:
+
+```ts
+experimental_events: {
+  adapter: {
+    createAdapter: () => existingOperations,
+  },
+}
+```
+
+Only reuse bound operations when their account, endpoint and destination are correct
+for every client using them. The former subscription operations interface is now
+exported as `Experimental_MCPEventOperations`; `Experimental_MCPEventAdapter`
+names the configured integration with `createAdapter`.
+
+For HTTP and SSE transport configurations, the context contains a fresh
+`transport: { type, url }` object. `url` is the configured string, including its
+path and query, not a resolved redirect target. Custom `MCPTransport` instances
+receive `transport: { type: 'custom' }`, with no `url` property; arbitrary
+properties on the instance are not inspected.
+
+This is a description of the transport, not the full configuration or live
+instance. Headers, auth providers, fetch functions, session callbacks and
+`start`/`send`/`close` methods are not passed to the adapter. The `transport`
+grouping leaves room for other client context without mixing it with transport
+metadata. No negotiated protocol version is supplied before initialization.
+
+Return separately bound operations for each client instead of mutating shared
+endpoint state. Adapters may prefer their own explicit endpoint override or
+resolve a configured endpoint when `transport.type` is `'custom'`. That policy belongs to
+the adapter; it does not change the client's transport or catalog discovery.
+The managed backend must still authorize an endpoint before sending credentials
+there. Receiving the transport URL does not grant that authorization.
+
+### Managed Operations Contract
 
 ```ts
 import type { JSONObject } from '@ai-sdk/provider';
@@ -184,7 +302,7 @@ These types are exported as `Experimental_ManagedSubscription` and
 a positive `ttlMs`, an ISO deadline in `expiresAt`, or `expiresAt: null` to
 monitor until stopped. The backend validates these values and enforces its limits.
 
-`Experimental_MCPEventsAdapter` has four operations:
+`Experimental_MCPEventOperations` has four operations:
 
 | Operation           | Input                                             | Result                             |
 | ------------------- | ------------------------------------------------- | ---------------------------------- |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.135",
+  "version": "7.0.137",
   "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,7 +42,7 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.109",
+    "@ai-sdk/gateway": "4.0.110",
     "@ai-sdk/provider": "4.0.26",
     "@ai-sdk/provider-utils": "5.0.58"
   },

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

@@ -2275,6 +2275,9 @@ class DefaultStreamTextResult<
           if (chunkTimeoutId != null) {
             clearTimeout(chunkTimeoutId);
           }
+          if (abortSignal?.aborted) {
+            return;
+          }
           chunkTimeoutId = setAbortTimeout({
             abortController: chunkAbortController,
             label: 'Chunk',
@@ -2289,6 +2292,11 @@ class DefaultStreamTextResult<
           }
         }
 
+        function clearModelOutputTimeouts() {
+          clearFirstChunkTimeout();
+          clearChunkTimeout();
+        }
+
         function clearStepTimeout() {
           if (stepTimeoutId != null) {
             clearTimeout(stepTimeoutId);
@@ -2297,8 +2305,7 @@ class DefaultStreamTextResult<
 
         function clearStepTimeouts() {
           clearStepTimeout();
-          clearFirstChunkTimeout();
-          clearChunkTimeout();
+          clearModelOutputTimeouts();
         }
 
         function cleanupStepTimeouts() {
@@ -2509,7 +2516,6 @@ class DefaultStreamTextResult<
           let automaticStreamRetryCount = 0;
           let callbackStreamRetryCount = 0;
           let bufferedAttemptParts: LanguageModelStreamPart<TOOLS>[] = [];
-          const outputChunksHandledBeforeBuffering = new WeakSet<object>();
           const openTextParts = new Set<string>();
           const openReasoningParts = new Set<string>();
           let enqueueStreamRetryAttemptBoundary = false;
@@ -2561,7 +2567,16 @@ class DefaultStreamTextResult<
               };
 
               while (true) {
-                const { done, value } = await languageModelStreamReader.read();
+                let result: ReadableStreamReadResult<
+                  LanguageModelStreamPart<TOOLS>
+                >;
+                try {
+                  result = await languageModelStreamReader.read();
+                } catch (error) {
+                  clearModelOutputTimeouts();
+                  throw error;
+                }
+                const { done, value } = result;
 
                 if (enqueueStreamRetryAttemptBoundary) {
                   controller.enqueue(
@@ -2576,6 +2591,7 @@ class DefaultStreamTextResult<
                 }
 
                 if (done) {
+                  clearModelOutputTimeouts();
                   flushBufferedAttemptParts();
                   controller.close();
                   return;
@@ -2592,22 +2608,24 @@ class DefaultStreamTextResult<
                   value.type === 'tool-error';
 
                 if (value.type === 'model-call-end') {
+                  clearModelOutputTimeouts();
                   flushBufferedAttemptParts();
                   enqueueAttemptPart(value);
                   return;
                 }
 
+                // Observe model output before buffering and tool processing.
+                // Replaying buffered parts must not re-arm finished timers.
+                if (isOutputChunk(value)) {
+                  clearFirstChunkTimeout();
+                  resetChunkTimeout();
+                }
+
                 if (
                   shouldBufferToolParts &&
                   value.type !== 'error' &&
                   (isToolPart || bufferedAttemptParts.length > 0)
                 ) {
-                  if (isOutputChunk(value)) {
-                    clearFirstChunkTimeout();
-                    resetChunkTimeout();
-                    outputChunksHandledBeforeBuffering.add(value);
-                  }
-
                   bufferedAttemptParts.push(value);
                   continue;
                 }
@@ -2617,6 +2635,7 @@ class DefaultStreamTextResult<
                   return;
                 }
 
+                clearModelOutputTimeouts();
                 await notify({
                   event: { chunk: value },
                   callbacks: onChunk,
@@ -2677,10 +2696,12 @@ class DefaultStreamTextResult<
                 response = retryLanguageModelCall.response;
                 languageModelStreamReader =
                   retryLanguageModelCall.stream.getReader();
+                startFirstChunkTimeout();
                 enqueueStreamRetryAttemptBoundary = true;
               }
             },
             cancel(reason) {
+              clearModelOutputTimeouts();
               return languageModelStreamReader.cancel(reason);
             },
           });
@@ -2857,21 +2878,7 @@ class DefaultStreamTextResult<
                   const chunkType = chunk.type;
 
                   if (isOutputChunk(chunk)) {
-                    const timeoutHandledBeforeBuffering =
-                      outputChunksHandledBeforeBuffering.has(chunk);
-
-                    if (
-                      !hasReceivedOutputChunk &&
-                      !timeoutHandledBeforeBuffering
-                    ) {
-                      // Clear before forwarding the first output so a timeout
-                      // cannot race with already-visible generated content.
-                      clearFirstChunkTimeout();
-                    }
                     hasReceivedOutputChunk = true;
-                    if (!timeoutHandledBeforeBuffering) {
-                      resetChunkTimeout();
-                    }
                   }
 
                   switch (chunkType) {

package/src/prompt/request-options.ts

@@ -4,9 +4,9 @@ import type { ToolSet } from '@ai-sdk/provider-utils';
  * Timeout configuration for API calls. Can be specified as:
  * - A number representing milliseconds
  * - An object with `totalMs` property for the total timeout in milliseconds
- * - An object with `stepMs` property for the timeout of each step in milliseconds
+ * - An object with `stepMs` property for the timeout of each complete step, including model generation, retries, and local tool execution, in milliseconds
  * - An object with `firstChunkMs` property for the timeout until the first content chunk of each step (streaming only)
- * - An object with `chunkMs` property for the timeout between content chunks (streaming only)
+ * - An object with `chunkMs` property for the timeout between meaningful model output chunks, starting with the first output and ending when the model response ends (streaming only)
  * - An object with `toolMs` property for the default timeout for all tool executions
  * - An object with `tools` property for per-tool timeout overrides using `{toolName}Ms` keys
  */

package/src/ui-message-stream/read-ui-message-stream.ts

@@ -95,6 +95,7 @@ export function readUIMessageStream<UI_MESSAGE extends UIMessage>({
   consumeStream({
     stream: processUIMessageStream({
       stream,
+      resetStateOnMessageIdChange: true,
       runUpdateMessageJob(
         job: (options: {
           state: StreamingUIMessageState<UI_MESSAGE>;