ai 7.0.89 → 7.0.91

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

@@ -127,7 +127,15 @@ import {
   isStopConditionMet,
   type StopCondition,
 } from './stop-condition';
-import { streamLanguageModelCall } from './stream-language-model-call';
+import {
+  streamLanguageModelCall,
+  type LanguageModelStreamPart,
+} from './stream-language-model-call';
+import {
+  createStreamRetryAttemptBoundaryPart,
+  isStreamRetryAttemptBoundaryPart,
+  type StreamRetryAttemptBoundaryPart,
+} from './stream-retry-attempt-boundary';
 import type {
   ConsumeStreamOptions,
   StreamTextResult,
@@ -193,9 +201,14 @@ const isOutputChunkType = {
   'model-call-end': false,
   error: false,
   raw: false,
-} as const satisfies Record<ExecuteToolsStreamPart['type'], boolean>;
-
-function isOutputChunk(chunk: ExecuteToolsStreamPart): boolean {
+} as const satisfies Record<
+  Exclude<ExecuteToolsStreamPart, StreamRetryAttemptBoundaryPart>['type'],
+  boolean
+>;
+
+function isOutputChunk(
+  chunk: Exclude<ExecuteToolsStreamPart, StreamRetryAttemptBoundaryPart>,
+): boolean {
   if (!isOutputChunkType[chunk.type]) {
     return false;
   }
@@ -257,14 +270,29 @@ export type StreamTextTransform<TOOLS extends ToolSet> = (options: {
   stopStream: () => void;
 }) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
 
+/** A result that requests recovery from a streamed provider error. */
+export type StreamTextOnErrorResult = { retry: true };
+
 /**
- * Callback that is set using the `onError` option.
+ * Existing observer callback that is set using the `onError` option.
  *
  * @param event - The event that is passed to the callback.
  */
-export type StreamTextOnErrorCallback = Callback<{
+export type StreamTextOnErrorCallback = Callback<{ error: unknown }>;
+
+/**
+ * Retry-capable callback that is set using the `onError` option.
+ *
+ * @param event - The event that is passed to the callback.
+ */
+export type StreamTextOnErrorRetryCallback = (event: {
   error: unknown;
-}>;
+}) =>
+  | PromiseLike<void | StreamTextOnErrorResult>
+  | void
+  | StreamTextOnErrorResult;
+
+type StreamTextOnErrorHandler = (event: { error: unknown }) => void;
 
 /**
  * Callback that is set using the `onChunk` option.
@@ -344,6 +372,7 @@ export type StreamTextOnAbortCallback<
  * If set and supported by the model, calls will generate deterministic results.
  *
  * @param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+ * @param streamRetries - Maximum number of retries for provider errors received after streaming starts. Set to 0 to disable automatic stream retries while allowing `onError` to request retries. Omit to disable all stream retry behavior. Default: 0.
  * @param abortSignal - An optional abort signal that can be used to cancel the call.
  * @param timeout - An optional timeout in milliseconds. The call will be aborted if it takes longer than the specified timeout.
  * @param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
@@ -388,6 +417,7 @@ export function streamText<
   messages,
   allowSystemInMessages,
   maxRetries,
+  streamRetries,
   abortSignal,
   timeout,
   headers,
@@ -410,9 +440,7 @@ export function streamText<
   experimental_download: download,
   includeRawChunks,
   onChunk,
-  onError = ({ error }) => {
-    console.error(error);
-  },
+  onError: onErrorArg,
   onFinish,
   onEnd = onFinish,
   onAbort,
@@ -597,9 +625,35 @@ export function streamText<
     /**
      * Callback that is invoked when an error occurs during streaming.
      * You can use it to log errors.
+     * Return `{ retry: true }` to retry the current model step after a provider
+     * error is received from the response stream when `streamRetries` is
+     * explicitly configured.
      * The stream processing will pause until the callback promise is resolved.
      */
-    onError?: StreamTextOnErrorCallback;
+    onError?:
+      | StreamTextOnErrorCallback
+      | StreamTextOnErrorRetryCallback
+      | StreamTextOnErrorHandler;
+
+    /**
+     * Maximum number of automatic retries for provider errors received after
+     * response streaming has started. Each retry reruns only the current model
+     * step. Completed earlier steps and their tool results are preserved.
+     *
+     * Partial output from a failed attempt that was already emitted cannot be
+     * retracted and remains in consumer-facing streams. It is excluded from
+     * the recovered step result, structured output parsing, response messages,
+     * and subsequent model steps.
+     *
+     * Set to `0` to disable automatic retries while allowing `onError` to
+     * request one retry. When automatic retries are configured, `onError` can
+     * request at most one additional retry after they are exhausted. Omit this
+     * option to disable all stream retry behavior and preserve incremental tool
+     * streaming for existing `onError` observers.
+     *
+     * @default 0 (stream retry behavior disabled when omitted)
+     */
+    streamRetries?: number;
 
     /**
      * Callback that is called when the LLM response and all request tool executions
@@ -781,6 +835,11 @@ export function streamText<
     firstChunkTimeoutMs != null ? new AbortController() : undefined;
   const chunkAbortController =
     chunkTimeoutMs != null ? new AbortController() : undefined;
+  const onError: StreamTextOnErrorHandler =
+    onErrorArg ??
+    (({ error }) => {
+      console.error(error);
+    });
   const resolvedOnStart = onStart ?? experimental_onStart;
   const resolvedOnStepStart = onStepStart ?? experimental_onStepStart;
   const resolvedOnLanguageModelCallStart =
@@ -798,6 +857,7 @@ export function streamText<
     headers,
     settings,
     maxRetries,
+    streamRetries,
     abortSignal: mergeAbortSignals(
       abortSignal,
       totalTimeoutMs,
@@ -836,6 +896,7 @@ export function streamText<
     timeout,
     onChunk,
     onError,
+    canRetryStreamViaOnError: streamRetries !== undefined && onErrorArg != null,
     onEnd,
     onAbort,
     onStepFinish: resolvedOnStepEnd,
@@ -864,6 +925,31 @@ export type EnrichedStreamPart<TOOLS extends ToolSet, PARTIAL_OUTPUT> = {
   partialOutput: PARTIAL_OUTPUT | undefined;
 };
 
+type StreamRetryBoundaryMetadata = {
+  request: LanguageModelRequestMetadata;
+  warnings: Array<CallWarning>;
+};
+
+const streamRetryBoundarySymbol = Symbol('streamRetryBoundary');
+
+type StreamRetryBoundaryPart = {
+  [streamRetryBoundarySymbol]: StreamRetryBoundaryMetadata;
+};
+
+type InternalTextStreamPart<TOOLS extends ToolSet> =
+  | TextStreamPart<TOOLS>
+  | StreamRetryBoundaryPart;
+
+type InternalEnrichedStreamPart<TOOLS extends ToolSet, PARTIAL_OUTPUT> =
+  | EnrichedStreamPart<TOOLS, PARTIAL_OUTPUT>
+  | StreamRetryBoundaryPart;
+
+function isStreamRetryBoundaryPart(
+  part: object,
+): part is StreamRetryBoundaryPart {
+  return streamRetryBoundarySymbol in part;
+}
+
 async function markPromiseAsHandled<T>(promise: Promise<T>): Promise<void> {
   try {
     await promise;
@@ -876,8 +962,8 @@ function createOutputTransformStream<
 >(
   output: OUTPUT,
 ): TransformStream<
-  TextStreamPart<TOOLS>,
-  EnrichedStreamPart<TOOLS, InferPartialOutput<OUTPUT>>
+  InternalTextStreamPart<TOOLS>,
+  InternalEnrichedStreamPart<TOOLS, InferPartialOutput<OUTPUT>>
 > {
   let firstTextChunkId: string | undefined = undefined;
   let text = '';
@@ -885,32 +971,61 @@ function createOutputTransformStream<
   let textProviderMetadata: ProviderMetadata | undefined = undefined;
   let lastPublishedValue = '';
 
+  function resetAttemptState() {
+    firstTextChunkId = undefined;
+    text = '';
+    textChunk = '';
+    textProviderMetadata = undefined;
+    lastPublishedValue = '';
+  }
+
+  function enqueueChunk({
+    controller,
+    chunk,
+  }: {
+    controller: TransformStreamDefaultController<
+      InternalEnrichedStreamPart<TOOLS, InferPartialOutput<OUTPUT>>
+    >;
+    chunk: EnrichedStreamPart<TOOLS, InferPartialOutput<OUTPUT>>;
+  }) {
+    controller.enqueue(chunk);
+  }
+
   function publishTextChunk({
     controller,
     partialOutput = undefined,
   }: {
     controller: TransformStreamDefaultController<
-      EnrichedStreamPart<TOOLS, InferPartialOutput<OUTPUT>>
+      InternalEnrichedStreamPart<TOOLS, InferPartialOutput<OUTPUT>>
     >;
     partialOutput?: InferPartialOutput<OUTPUT>;
   }) {
-    controller.enqueue({
-      part: {
-        type: 'text-delta',
-        id: firstTextChunkId!,
-        text: textChunk,
-        providerMetadata: textProviderMetadata,
+    enqueueChunk({
+      controller,
+      chunk: {
+        part: {
+          type: 'text-delta',
+          id: firstTextChunkId!,
+          text: textChunk,
+          providerMetadata: textProviderMetadata,
+        },
+        partialOutput,
       },
-      partialOutput,
     });
     textChunk = '';
   }
 
   return new TransformStream<
-    TextStreamPart<TOOLS>,
-    EnrichedStreamPart<TOOLS, InferPartialOutput<OUTPUT>>
+    InternalTextStreamPart<TOOLS>,
+    InternalEnrichedStreamPart<TOOLS, InferPartialOutput<OUTPUT>>
   >({
     async transform(chunk, controller) {
+      if (isStreamRetryBoundaryPart(chunk)) {
+        resetAttemptState();
+        controller.enqueue(chunk);
+        return;
+      }
+
       // ensure that we publish the last text chunk before the step finish:
       if (chunk.type === 'finish-step' && textChunk.length > 0) {
         publishTextChunk({ controller });
@@ -921,7 +1036,10 @@ function createOutputTransformStream<
         chunk.type !== 'text-start' &&
         chunk.type !== 'text-end'
       ) {
-        controller.enqueue({ part: chunk, partialOutput: undefined });
+        enqueueChunk({
+          controller,
+          chunk: { part: chunk, partialOutput: undefined },
+        });
         return;
       }
 
@@ -930,12 +1048,18 @@ function createOutputTransformStream<
       if (firstTextChunkId == null) {
         firstTextChunkId = chunk.id;
       } else if (chunk.id !== firstTextChunkId) {
-        controller.enqueue({ part: chunk, partialOutput: undefined });
+        enqueueChunk({
+          controller,
+          chunk: { part: chunk, partialOutput: undefined },
+        });
         return;
       }
 
       if (chunk.type === 'text-start') {
-        controller.enqueue({ part: chunk, partialOutput: undefined });
+        enqueueChunk({
+          controller,
+          chunk: { part: chunk, partialOutput: undefined },
+        });
         return;
       }
 
@@ -943,7 +1067,10 @@ function createOutputTransformStream<
         if (textChunk.length > 0) {
           publishTextChunk({ controller });
         }
-        controller.enqueue({ part: chunk, partialOutput: undefined });
+        enqueueChunk({
+          controller,
+          chunk: { part: chunk, partialOutput: undefined },
+        });
         return;
       }
 
@@ -952,7 +1079,10 @@ function createOutputTransformStream<
       textProviderMetadata = chunk.providerMetadata ?? textProviderMetadata;
 
       if (chunk.text.length === 0 && chunk.providerMetadata != null) {
-        controller.enqueue({ part: chunk, partialOutput: undefined });
+        enqueueChunk({
+          controller,
+          chunk: { part: chunk, partialOutput: undefined },
+        });
         return;
       }
 
@@ -976,6 +1106,95 @@ function createOutputTransformStream<
   });
 }
 
+function applyStreamTextTransforms<TOOLS extends ToolSet>({
+  stream,
+  transforms,
+  tools,
+  stopStream,
+}: {
+  stream: ReadableStream<InternalTextStreamPart<TOOLS>>;
+  transforms: Array<StreamTextTransform<TOOLS>>;
+  tools: TOOLS;
+  stopStream: () => void;
+}): ReadableStream<InternalTextStreamPart<TOOLS>> {
+  const sourceReader = stream.getReader();
+  let sourceDone = false;
+  let pendingBoundary: StreamRetryBoundaryPart | undefined;
+  let transformedSegmentReader:
+    | ReadableStreamDefaultReader<TextStreamPart<TOOLS>>
+    | undefined;
+
+  const createTransformedSegmentReader = () => {
+    let segment = new ReadableStream<TextStreamPart<TOOLS>>(
+      {
+        async pull(controller) {
+          const { done, value } = await sourceReader.read();
+
+          if (done) {
+            sourceDone = true;
+            controller.close();
+            return;
+          }
+
+          if (isStreamRetryBoundaryPart(value)) {
+            pendingBoundary = value;
+            controller.close();
+            return;
+          }
+
+          controller.enqueue(value);
+        },
+        cancel(reason) {
+          return sourceReader.cancel(reason);
+        },
+      },
+      // Do not prefetch the next source chunk. `stopStream` is invoked from a
+      // user transform and must close the gate before another chunk enters it.
+      { highWaterMark: 0 },
+    );
+
+    for (const transform of transforms) {
+      segment = segment.pipeThrough(
+        transform({
+          tools,
+          stopStream,
+        }),
+      );
+    }
+
+    return segment.getReader();
+  };
+
+  return new ReadableStream<InternalTextStreamPart<TOOLS>>({
+    async pull(controller) {
+      transformedSegmentReader ??= createTransformedSegmentReader();
+
+      const { done, value } = await transformedSegmentReader.read();
+
+      if (!done) {
+        controller.enqueue(value);
+        return;
+      }
+
+      transformedSegmentReader = undefined;
+
+      if (pendingBoundary != null) {
+        controller.enqueue(pendingBoundary);
+        pendingBoundary = undefined;
+        return;
+      }
+
+      if (sourceDone) {
+        controller.close();
+      }
+    },
+    async cancel(reason) {
+      await transformedSegmentReader?.cancel(reason);
+      await sourceReader.cancel(reason);
+    },
+  });
+}
+
 class DefaultStreamTextResult<
   TOOLS extends ToolSet,
   RUNTIME_CONTEXT extends Context,
@@ -1000,7 +1219,7 @@ class DefaultStreamTextResult<
   private outputPromise: Promise<InferCompleteOutput<OUTPUT>> | undefined;
 
   private readonly addStream: (
-    stream: ReadableStream<TextStreamPart<TOOLS>>,
+    stream: ReadableStream<InternalTextStreamPart<TOOLS>>,
     callbacks?: {
       onError?: (error: unknown) => void;
       onCancel?: () => void;
@@ -1023,6 +1242,7 @@ class DefaultStreamTextResult<
     headers,
     settings,
     maxRetries: maxRetriesArg,
+    streamRetries: streamRetriesArg,
     abortSignal,
     stepTimeoutMs,
     stepAbortController,
@@ -1056,6 +1276,7 @@ class DefaultStreamTextResult<
     timeout,
     onChunk,
     onError,
+    canRetryStreamViaOnError,
     onEnd,
     onAbort,
     onStepFinish,
@@ -1075,6 +1296,7 @@ class DefaultStreamTextResult<
     headers: Record<string, string | undefined> | undefined;
     settings: LanguageModelCallOptions;
     maxRetries: number | undefined;
+    streamRetries: number | undefined;
     abortSignal: AbortSignal | undefined;
     stepTimeoutMs: number | undefined;
     stepAbortController: AbortController | undefined;
@@ -1117,7 +1339,8 @@ class DefaultStreamTextResult<
 
     // callbacks:
     onChunk: undefined | StreamTextOnChunkCallback<TOOLS>;
-    onError: StreamTextOnErrorCallback;
+    onError: StreamTextOnErrorHandler;
+    canRetryStreamViaOnError: boolean;
     onEnd:
       | undefined
       | StreamTextOnEndCallback<
@@ -1241,20 +1464,36 @@ class DefaultStreamTextResult<
       }
     > = createIdMap();
     let recordedNoOutputError: NoOutputGeneratedError | undefined;
+    const errorsHandledForStreamRetry = new Set<unknown>();
 
     const eventProcessor = new TransformStream<
-      EnrichedStreamPart<TOOLS, InferPartialOutput<OUTPUT>>,
+      InternalEnrichedStreamPart<TOOLS, InferPartialOutput<OUTPUT>>,
       EnrichedStreamPart<TOOLS, InferPartialOutput<OUTPUT>>
     >({
       async transform(chunk, controller) {
-        controller.enqueue(chunk); // forward the chunk to the next stream
+        if (isStreamRetryBoundaryPart(chunk)) {
+          const retryBoundary = chunk[streamRetryBoundarySymbol];
+          recordedContent = [];
+          activeReasoningContent = createIdMap();
+          activeTextContent = createIdMap();
+          recordedRequest = retryBoundary.request;
+          recordedRequestMessages = retryBoundary.request.messages ?? [];
+          recordedWarnings = retryBoundary.warnings;
+          return;
+        }
 
         const { part } = chunk;
+        controller.enqueue(chunk); // forward the chunk to the next stream
 
-        await notify({
-          event: { chunk: part },
-          callbacks: onChunk,
-        });
+        const callbacksHandledForStreamRetry =
+          part.type === 'error' && errorsHandledForStreamRetry.has(part.error);
+
+        if (!callbacksHandledForStreamRetry) {
+          await notify({
+            event: { chunk: part },
+            callbacks: onChunk,
+          });
+        }
 
         if (part.type === 'error') {
           const error = wrapGatewayError(part.error);
@@ -1263,10 +1502,16 @@ class DefaultStreamTextResult<
             recordedNoOutputError = error;
           }
 
-          await notify({
-            event: { error },
-            callbacks: onError,
-          });
+          if (callbacksHandledForStreamRetry) {
+            errorsHandledForStreamRetry.delete(part.error);
+          } else {
+            await notify({
+              event: { error },
+              callbacks: async event => {
+                await onError(event);
+              },
+            });
+          }
         }
 
         if (
@@ -1581,13 +1826,14 @@ class DefaultStreamTextResult<
     });
 
     // initialize the stitchable stream and the transformed stream:
-    const stitchableStream = createStitchableStream<TextStreamPart<TOOLS>>();
+    const stitchableStream =
+      createStitchableStream<InternalTextStreamPart<TOOLS>>();
     this.addStream = stitchableStream.addStream;
     this.closeStream = stitchableStream.close;
 
     // resilient stream that handles abort signals and errors:
     const reader = stitchableStream.stream.getReader();
-    let stream = new ReadableStream<TextStreamPart<TOOLS>>({
+    let stream = new ReadableStream<InternalTextStreamPart<TOOLS>>({
       async start(controller) {
         // send start event:
         controller.enqueue({ type: 'start' });
@@ -1659,19 +1905,18 @@ class DefaultStreamTextResult<
       }),
     );
 
-    // transform the stream before output parsing
-    // to enable replacement of stream segments:
-    for (const transform of transforms) {
-      stream = stream.pipeThrough(
-        transform({
-          tools: tools as TOOLS,
-          stopStream() {
-            stitchableStream.terminate();
-            isRunning = false;
-          },
-        }),
-      );
-    }
+    // Transform each retry attempt independently. The retry boundary is
+    // intercepted outside user transforms, so transforms may filter or
+    // reconstruct any public stream part without losing logical isolation.
+    stream = applyStreamTextTransforms({
+      stream,
+      transforms,
+      tools: tools as TOOLS,
+      stopStream() {
+        stitchableStream.terminate();
+        isRunning = false;
+      },
+    });
 
     this.baseStream = stream
       .pipeThrough(createOutputTransformStream(output ?? text()))
@@ -1681,6 +1926,12 @@ class DefaultStreamTextResult<
       maxRetries: maxRetriesArg,
       abortSignal,
     });
+    const { maxRetries: streamRetries } = prepareRetries({
+      maxRetries: streamRetriesArg,
+      abortSignal,
+      parameter: 'streamRetries',
+      defaultMaxRetries: 0,
+    });
 
     const callSettings = prepareLanguageModelCallOptions(settings);
 
@@ -2128,79 +2379,262 @@ class DefaultStreamTextResult<
           const stepStartTimestampMs = now();
 
           const { retry } = prepareRetries({ maxRetries, abortSignal });
+          let hasNotifiedStepStart = false;
+
+          const callLanguageModel = () =>
+            runInStepTracingChannelContext(() =>
+              retry(async () =>
+                streamLanguageModelCall({
+                  model: prepareStepResult?.model ?? model,
+                  tools: stepModelTools as TOOLS,
+                  toolOrder: stepToolOrder,
+                  toolChoice: prepareStepResult?.toolChoice ?? toolChoice,
+                  instructions: stepInstructions,
+                  messages: stepMessages,
+                  allowSystemInMessages,
+                  repairToolCall,
+                  refineToolInput,
+                  abortSignal,
+                  headers,
+                  includeRawChunks: include.rawChunks,
+                  providerOptions: stepProviderOptions,
+                  download,
+                  output,
+                  callId,
+                  executeLanguageModelCallInTelemetryContext:
+                    telemetryDispatcher.executeLanguageModelCall,
+                  toolsContext,
+                  experimental_sandbox: stepSandbox,
+                  onLanguageModelCallStart: filterNullable(
+                    onLanguageModelCallStart,
+                    telemetryDispatcher.onLanguageModelCallStart as
+                      | undefined
+                      | OnLanguageModelCallStartCallback,
+                  ),
+                  onLanguageModelCallEnd: filterNullable(
+                    onLanguageModelCallEnd,
+                    telemetryDispatcher.onLanguageModelCallEnd as
+                      | undefined
+                      | OnLanguageModelCallEndCallback<TOOLS>,
+                  ),
+                  onStart: async ({ promptMessages }) => {
+                    if (hasNotifiedStepStart) {
+                      return;
+                    }
+                    hasNotifiedStepStart = true;
+
+                    await notify({
+                      event: {
+                        callId,
+                        provider: stepModel.provider,
+                        modelId: stepModel.modelId,
+                        stepNumber: recordedSteps.length,
+                        instructions: stepInstructions,
+                        messages: stepMessages,
+                        tools,
+                        toolChoice: prepareStepResult?.toolChoice ?? toolChoice,
+                        activeTools:
+                          prepareStepResult?.activeTools ?? activeTools,
+                        toolOrder: stepToolOrder,
+                        steps: [...recordedSteps],
+                        providerOptions: stepProviderOptions,
+                        runtimeContext,
+                        toolsContext,
+                        output,
+                        promptMessages,
+                        stepTools,
+                        stepToolChoice,
+                      },
+                      callbacks: [onStepStart, telemetryDispatcher.onStepStart],
+                    });
+                  },
+                  _internal: {
+                    now,
+                  },
+                  ...stepCallSettings,
+                }),
+              ),
+            );
+
+          const initialLanguageModelCall = await callLanguageModel();
+          let request = initialLanguageModelCall.request;
+          let response = initialLanguageModelCall.response;
+          let languageModelStreamReader =
+            initialLanguageModelCall.stream.getReader();
+          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;
+          const shouldBufferToolParts =
+            streamRetries > 0 || canRetryStreamViaOnError;
+
+          const languageModelStream = new ReadableStream<
+            LanguageModelStreamPart<TOOLS> | StreamRetryAttemptBoundaryPart
+          >({
+            async pull(controller) {
+              const enqueueAttemptPart = (
+                part: LanguageModelStreamPart<TOOLS>,
+              ) => {
+                switch (part.type) {
+                  case 'text-start':
+                    openTextParts.add(part.id);
+                    break;
+                  case 'text-end':
+                    openTextParts.delete(part.id);
+                    break;
+                  case 'reasoning-start':
+                    openReasoningParts.add(part.id);
+                    break;
+                  case 'reasoning-end':
+                    openReasoningParts.delete(part.id);
+                    break;
+                }
+
+                controller.enqueue(part);
+              };
+
+              const flushBufferedAttemptParts = () => {
+                for (const part of bufferedAttemptParts) {
+                  enqueueAttemptPart(part);
+                }
+                bufferedAttemptParts = [];
+              };
+
+              const closeOpenAttemptParts = () => {
+                for (const id of openTextParts) {
+                  controller.enqueue({ type: 'text-end', id });
+                }
+                openTextParts.clear();
+
+                for (const id of openReasoningParts) {
+                  controller.enqueue({ type: 'reasoning-end', id });
+                }
+                openReasoningParts.clear();
+              };
+
+              while (true) {
+                const { done, value } = await languageModelStreamReader.read();
+
+                if (enqueueStreamRetryAttemptBoundary) {
+                  controller.enqueue(
+                    createStreamRetryAttemptBoundaryPart({
+                      warnings:
+                        !done && value.type === 'model-call-start'
+                          ? value.warnings
+                          : [],
+                    }),
+                  );
+                  enqueueStreamRetryAttemptBoundary = false;
+                }
+
+                if (done) {
+                  flushBufferedAttemptParts();
+                  controller.close();
+                  return;
+                }
+
+                const isToolPart =
+                  value.type === 'tool-input-start' ||
+                  value.type === 'tool-input-delta' ||
+                  value.type === 'tool-input-end' ||
+                  value.type === 'tool-call' ||
+                  value.type === 'tool-approval-request' ||
+                  value.type === 'tool-approval-response' ||
+                  value.type === 'tool-result' ||
+                  value.type === 'tool-error';
+
+                if (value.type === 'model-call-end') {
+                  flushBufferedAttemptParts();
+                  enqueueAttemptPart(value);
+                  return;
+                }
+
+                if (
+                  shouldBufferToolParts &&
+                  value.type !== 'error' &&
+                  (isToolPart || bufferedAttemptParts.length > 0)
+                ) {
+                  if (isOutputChunk(value)) {
+                    clearFirstChunkTimeout();
+                    resetChunkTimeout();
+                    outputChunksHandledBeforeBuffering.add(value);
+                  }
 
-          const {
-            stream: languageModelStream,
-            request,
-            response,
-          } = await runInStepTracingChannelContext(() =>
-            retry(async () =>
-              streamLanguageModelCall({
-                model: prepareStepResult?.model ?? model,
-                tools: stepModelTools as TOOLS,
-                toolOrder: stepToolOrder,
-                toolChoice: prepareStepResult?.toolChoice ?? toolChoice,
-                instructions: stepInstructions,
-                messages: stepMessages,
-                allowSystemInMessages,
-                repairToolCall,
-                refineToolInput,
-                abortSignal,
-                headers,
-                includeRawChunks: include.rawChunks,
-                providerOptions: stepProviderOptions,
-                download,
-                output,
-                callId,
-                executeLanguageModelCallInTelemetryContext:
-                  telemetryDispatcher.executeLanguageModelCall,
-                toolsContext,
-                experimental_sandbox: stepSandbox,
-                onLanguageModelCallStart: filterNullable(
-                  onLanguageModelCallStart,
-                  telemetryDispatcher.onLanguageModelCallStart as
-                    | undefined
-                    | OnLanguageModelCallStartCallback,
-                ),
-                onLanguageModelCallEnd: filterNullable(
-                  onLanguageModelCallEnd,
-                  telemetryDispatcher.onLanguageModelCallEnd as
-                    | undefined
-                    | OnLanguageModelCallEndCallback<TOOLS>,
-                ),
-                onStart: async ({ promptMessages }) => {
-                  await notify({
-                    event: {
-                      callId,
-                      provider: stepModel.provider,
-                      modelId: stepModel.modelId,
-                      stepNumber: recordedSteps.length,
-                      instructions: stepInstructions,
-                      messages: stepMessages,
-                      tools,
-                      toolChoice: prepareStepResult?.toolChoice ?? toolChoice,
-                      activeTools:
-                        prepareStepResult?.activeTools ?? activeTools,
-                      toolOrder: stepToolOrder,
-                      steps: [...recordedSteps],
-                      providerOptions: stepProviderOptions,
-                      runtimeContext,
-                      toolsContext,
-                      output,
-                      promptMessages,
-                      stepTools,
-                      stepToolChoice,
-                    },
-                    callbacks: [onStepStart, telemetryDispatcher.onStepStart],
+                  bufferedAttemptParts.push(value);
+                  continue;
+                }
+
+                if (value.type !== 'error') {
+                  enqueueAttemptPart(value);
+                  return;
+                }
+
+                await notify({
+                  event: { chunk: value },
+                  callbacks: onChunk,
+                });
+                const error = wrapGatewayError(value.error);
+                let onErrorResult: unknown;
+                try {
+                  onErrorResult = await onError({ error });
+                } catch {}
+                const callbackRequestedRetry =
+                  canRetryStreamViaOnError &&
+                  typeof onErrorResult === 'object' &&
+                  onErrorResult != null &&
+                  'retry' in onErrorResult &&
+                  onErrorResult.retry === true;
+                const automaticRetry =
+                  automaticStreamRetryCount < streamRetries;
+                const callbackRetry =
+                  !automaticRetry &&
+                  callbackRequestedRetry &&
+                  callbackStreamRetryCount < 1;
+
+                if (!automaticRetry && !callbackRetry) {
+                  flushBufferedAttemptParts();
+                  errorsHandledForStreamRetry.add(value.error);
+                  controller.enqueue(value);
+                  return;
+                }
+
+                if (automaticRetry) {
+                  automaticStreamRetryCount++;
+                } else {
+                  callbackStreamRetryCount++;
+                }
+
+                await languageModelStreamReader.cancel(error);
+                bufferedAttemptParts = [];
+                closeOpenAttemptParts();
+
+                let retryLanguageModelCall: Awaited<
+                  ReturnType<typeof callLanguageModel>
+                >;
+                try {
+                  retryLanguageModelCall = await callLanguageModel();
+                } catch (retryError) {
+                  controller.enqueue({
+                    type: 'error',
+                    error: retryError,
                   });
-                },
-                _internal: {
-                  now,
-                },
-                ...stepCallSettings,
-              }),
-            ),
-          );
+                  controller.close();
+                  return;
+                }
+                request = retryLanguageModelCall.request;
+                response = retryLanguageModelCall.response;
+                languageModelStreamReader =
+                  retryLanguageModelCall.stream.getReader();
+                enqueueStreamRetryAttemptBoundary = true;
+              }
+            },
+            cancel(reason) {
+              return languageModelStreamReader.cancel(reason);
+            },
+          });
 
           startFirstChunkTimeout();
 
@@ -2259,14 +2693,14 @@ class DefaultStreamTextResult<
 
           // Conditionally include request.body based on include settings.
           // Large payloads (e.g., base64-encoded images) can cause memory issues.
-          const stepRequest: LanguageModelRequestMetadata = {
+          const getStepRequest = (): LanguageModelRequestMetadata => ({
             ...request,
             body: include.requestBody ? request?.body : undefined,
             messages: include.requestMessages
               ? cloneModelMessages(stepMessages)
               : undefined,
-          };
-          recordedRequestMessages = stepRequest.messages ?? [];
+          });
+          recordedRequestMessages = getStepRequest().messages ?? [];
 
           const stepToolCalls: TypedToolCall<TOOLS>[] = [];
           const stepToolOutputs: ToolOutput<TOOLS>[] = [];
@@ -2287,10 +2721,10 @@ class DefaultStreamTextResult<
           let stepUsage: LanguageModelUsage = createNullLanguageModelUsage();
           let stepProviderMetadata: ProviderMetadata | undefined;
           let stepFirstChunk = true;
-          let modelCallPerformance: Omit<
+          const createModelCallPerformance = (): Omit<
             StepResultPerformance,
             'stepTimeMs' | 'toolExecutionMs'
-          > = {
+          > => ({
             responseTimeMs: 0,
             effectiveOutputTokensPerSecond: 0,
             outputTokensPerSecond: undefined,
@@ -2298,26 +2732,63 @@ class DefaultStreamTextResult<
             effectiveTotalTokensPerSecond: 0,
             timeToFirstOutputMs: undefined,
             timeBetweenOutputChunksMs: undefined,
-          };
+          });
+          let modelCallPerformance = createModelCallPerformance();
           const toolExecutionMs: Record<string, number> = {};
-          let stepResponse: { id: string; timestamp: Date; modelId: string } = {
+          const createStepResponse = () => ({
             id: generateId(),
             timestamp: new Date(),
             modelId: model.modelId,
-          };
+          });
+          let stepResponse: {
+            id: string;
+            timestamp: Date;
+            modelId: string;
+          } = createStepResponse();
 
           // maps provider-assigned IDs to stream-unique IDs for the text and
           // reasoning parts that are active in this step
           const textPartIds = new Map<string, string>();
           const reasoningPartIds = new Map<string, string>();
 
+          const enqueueStepPart = (
+            controller: TransformStreamDefaultController<
+              InternalTextStreamPart<TOOLS>
+            >,
+            part: TextStreamPart<TOOLS>,
+          ) => {
+            controller.enqueue(part);
+          };
+
           self.addStream(
             streamWithToolResults.pipeThrough(
               new TransformStream<
                 ExecuteToolsStreamPart<TOOLS>,
-                TextStreamPart<TOOLS>
+                InternalTextStreamPart<TOOLS>
               >({
                 async transform(chunk, controller): Promise<void> {
+                  if (isStreamRetryAttemptBoundaryPart(chunk)) {
+                    warnings = chunk.warnings;
+                    stepFinishReason = 'other';
+                    stepRawFinishReason = undefined;
+                    hasReceivedTerminalChunk = false;
+                    hasReceivedOutputChunk = false;
+                    stepUsage = createNullLanguageModelUsage();
+                    stepProviderMetadata = undefined;
+                    modelCallPerformance = createModelCallPerformance();
+                    stepResponse = createStepResponse();
+                    textPartIds.clear();
+                    reasoningPartIds.clear();
+
+                    controller.enqueue({
+                      [streamRetryBoundarySymbol]: {
+                        request: getStepRequest(),
+                        warnings,
+                      } satisfies StreamRetryBoundaryMetadata,
+                    });
+                    return;
+                  }
+
                   if (chunk.type === 'model-call-start') {
                     warnings = chunk.warnings;
                     return; // stream start chunks are sent immediately and do not count as first chunk
@@ -2327,9 +2798,9 @@ class DefaultStreamTextResult<
                     stepFirstChunk = false;
 
                     // Step start:
-                    controller.enqueue({
+                    enqueueStepPart(controller, {
                       type: 'start-step',
-                      request: stepRequest,
+                      request: getStepRequest(),
                       warnings: warnings ?? [],
                     });
                   }
@@ -2337,13 +2808,21 @@ class DefaultStreamTextResult<
                   const chunkType = chunk.type;
 
                   if (isOutputChunk(chunk)) {
-                    if (!hasReceivedOutputChunk) {
+                    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;
-                    resetChunkTimeout();
+                    if (!timeoutHandledBeforeBuffering) {
+                      resetChunkTimeout();
+                    }
                   }
 
                   switch (chunkType) {
@@ -2355,14 +2834,14 @@ class DefaultStreamTextResult<
                     case 'tool-input-end':
                     case 'tool-input-delta':
                     case 'tool-approval-request': {
-                      controller.enqueue(chunk);
+                      enqueueStepPart(controller, chunk);
                       break;
                     }
 
                     case 'text-start': {
                       const id = reserveTextPartId(chunk.id);
                       textPartIds.set(chunk.id, id);
-                      controller.enqueue({ ...chunk, id });
+                      enqueueStepPart(controller, { ...chunk, id });
                       break;
                     }
 
@@ -2371,7 +2850,7 @@ class DefaultStreamTextResult<
                         chunk.text.length > 0 ||
                         chunk.providerMetadata != null
                       ) {
-                        controller.enqueue({
+                        enqueueStepPart(controller, {
                           ...chunk,
                           id: textPartIds.get(chunk.id) ?? chunk.id,
                         });
@@ -2380,7 +2859,7 @@ class DefaultStreamTextResult<
                     }
 
                     case 'text-end': {
-                      controller.enqueue({
+                      enqueueStepPart(controller, {
                         ...chunk,
                         id: textPartIds.get(chunk.id) ?? chunk.id,
                       });
@@ -2391,12 +2870,12 @@ class DefaultStreamTextResult<
                     case 'reasoning-start': {
                       const id = reserveReasoningPartId(chunk.id);
                       reasoningPartIds.set(chunk.id, id);
-                      controller.enqueue({ ...chunk, id });
+                      enqueueStepPart(controller, { ...chunk, id });
                       break;
                     }
 
                     case 'reasoning-delta': {
-                      controller.enqueue({
+                      enqueueStepPart(controller, {
                         ...chunk,
                         id: reasoningPartIds.get(chunk.id) ?? chunk.id,
                       });
@@ -2404,7 +2883,7 @@ class DefaultStreamTextResult<
                     }
 
                     case 'reasoning-end': {
-                      controller.enqueue({
+                      enqueueStepPart(controller, {
                         ...chunk,
                         id: reasoningPartIds.get(chunk.id) ?? chunk.id,
                       });
@@ -2413,20 +2892,20 @@ class DefaultStreamTextResult<
                     }
 
                     case 'tool-call': {
-                      controller.enqueue(chunk);
+                      enqueueStepPart(controller, chunk);
                       // store tool calls for onEnd callback and toolCalls promise:
                       stepToolCalls.push(chunk);
                       break;
                     }
 
                     case 'tool-approval-response': {
-                      controller.enqueue(chunk);
+                      enqueueStepPart(controller, chunk);
                       stepToolApprovalResponses.push(chunk);
                       break;
                     }
 
                     case 'tool-result': {
-                      controller.enqueue(chunk);
+                      enqueueStepPart(controller, chunk);
 
                       if (!chunk.preliminary) {
                         stepToolOutputs.push(chunk);
@@ -2436,7 +2915,7 @@ class DefaultStreamTextResult<
                     }
 
                     case 'tool-error': {
-                      controller.enqueue(chunk);
+                      enqueueStepPart(controller, chunk);
                       stepToolOutputs.push(chunk);
                       break;
                     }
@@ -2471,14 +2950,14 @@ class DefaultStreamTextResult<
 
                     case 'error': {
                       hasReceivedTerminalChunk = true;
-                      controller.enqueue(chunk);
+                      enqueueStepPart(controller, chunk);
                       stepFinishReason = 'error';
                       break;
                     }
 
                     case 'raw': {
                       if (include.rawChunks) {
-                        controller.enqueue(chunk);
+                        enqueueStepPart(controller, chunk);
                       }
                       break;
                     }
@@ -2496,7 +2975,7 @@ class DefaultStreamTextResult<
                   // output instead of recording an empty step. incomplete
                   // streams with partial output retain the partial result:
                   if (!hasReceivedTerminalChunk && !hasReceivedOutputChunk) {
-                    controller.enqueue({
+                    enqueueStepPart(controller, {
                       type: 'error',
                       error: new NoOutputGeneratedError({
                         message:
@@ -2528,7 +3007,7 @@ class DefaultStreamTextResult<
                     },
                   };
 
-                  controller.enqueue(finishStepPart);
+                  enqueueStepPart(controller, finishStepPart);
 
                   const combinedUsage = addLanguageModelUsage(usage, stepUsage);
 
@@ -2609,7 +3088,7 @@ class DefaultStreamTextResult<
                         }),
                       );
                     } catch (error) {
-                      controller.enqueue({
+                      enqueueStepPart(controller, {
                         type: 'error',
                         error,
                       });
@@ -2617,7 +3096,7 @@ class DefaultStreamTextResult<
                       self.closeStream();
                     }
                   } else {
-                    controller.enqueue({
+                    enqueueStepPart(controller, {
                       type: 'finish',
                       finishReason: stepFinishReason,
                       rawFinishReason: stepRawFinishReason,