ai 7.0.89 → 7.0.91

package/dist/index.js

@@ -1176,7 +1176,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.89" : "0.0.0-test";
+var VERSION = true ? "7.0.91" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -2828,25 +2828,27 @@ var retryWithExponentialBackoffRespectingRetryHeaders = ({
 // src/util/prepare-retries.ts
 function prepareRetries({
   maxRetries,
-  abortSignal
+  abortSignal,
+  parameter = "maxRetries",
+  defaultMaxRetries = 2
 }) {
   if (maxRetries != null) {
     if (!Number.isInteger(maxRetries)) {
       throw new InvalidArgumentError({
-        parameter: "maxRetries",
+        parameter,
         value: maxRetries,
-        message: "maxRetries must be an integer"
+        message: `${parameter} must be an integer`
       });
     }
     if (maxRetries < 0) {
       throw new InvalidArgumentError({
-        parameter: "maxRetries",
+        parameter,
         value: maxRetries,
-        message: "maxRetries must be >= 0"
+        message: `${parameter} must be >= 0`
       });
     }
   }
-  const maxRetriesResult = maxRetries != null ? maxRetries : 2;
+  const maxRetriesResult = maxRetries != null ? maxRetries : defaultMaxRetries;
   return {
     maxRetries: maxRetriesResult,
     retry: retryWithExponentialBackoffRespectingRetryHeaders({
@@ -8273,6 +8275,20 @@ function createStitchableStream() {
   };
 }
 
+// src/generate-text/stream-retry-attempt-boundary.ts
+var streamRetryAttemptBoundarySymbol = /* @__PURE__ */ Symbol("streamRetryAttemptBoundary");
+function createStreamRetryAttemptBoundaryPart({
+  warnings
+}) {
+  return {
+    [streamRetryAttemptBoundarySymbol]: true,
+    warnings
+  };
+}
+function isStreamRetryAttemptBoundaryPart(part) {
+  return typeof part === "object" && part != null && streamRetryAttemptBoundarySymbol in part;
+}
+
 // src/generate-text/execute-tools-from-stream.ts
 function executeToolsFromStream({
   stream,
@@ -8297,6 +8313,10 @@ function executeToolsFromStream({
     new TransformStream({
       async transform(chunk, controller) {
         controller.enqueue(chunk);
+        if (isStreamRetryAttemptBoundaryPart(chunk)) {
+          toolCallsToExecute.length = 0;
+          return;
+        }
         const chunkType = chunk.type;
         switch (chunkType) {
           case "tool-call": {
@@ -8444,6 +8464,9 @@ function invokeToolCallbacksFromStream({
     new TransformStream({
       async transform(chunk, controller) {
         controller.enqueue(chunk);
+        if (isStreamRetryAttemptBoundaryPart(chunk)) {
+          return;
+        }
         switch (chunk.type) {
           case "tool-input-start": {
             ongoingToolCallToolNames[chunk.id] = chunk.toolName;
@@ -9109,6 +9132,7 @@ function streamText({
   messages,
   allowSystemInMessages,
   maxRetries,
+  streamRetries,
   abortSignal,
   timeout,
   headers,
@@ -9131,9 +9155,7 @@ function streamText({
   experimental_download: download2,
   includeRawChunks,
   onChunk,
-  onError = ({ error }) => {
-    console.error(error);
-  },
+  onError: onErrorArg,
   onFinish,
   onEnd = onFinish,
   onAbort,
@@ -9170,6 +9192,9 @@ function streamText({
   const stepAbortController = stepTimeoutMs != null ? new AbortController() : void 0;
   const firstChunkAbortController = firstChunkTimeoutMs != null ? new AbortController() : void 0;
   const chunkAbortController = chunkTimeoutMs != null ? new AbortController() : void 0;
+  const onError = onErrorArg != null ? onErrorArg : (({ error }) => {
+    console.error(error);
+  });
   const resolvedOnStart = onStart != null ? onStart : experimental_onStart;
   const resolvedOnStepStart = onStepStart != null ? onStepStart : experimental_onStepStart;
   const resolvedOnLanguageModelCallStart = onLanguageModelCallStart != null ? onLanguageModelCallStart : experimental_onLanguageModelCallStart;
@@ -9183,6 +9208,7 @@ function streamText({
     headers,
     settings,
     maxRetries,
+    streamRetries,
     abortSignal: mergeAbortSignals(
       abortSignal,
       totalTimeoutMs,
@@ -9221,6 +9247,7 @@ function streamText({
     timeout,
     onChunk,
     onError,
+    canRetryStreamViaOnError: streamRetries !== void 0 && onErrorArg != null,
     onEnd,
     onAbort,
     onStepFinish: resolvedOnStepEnd,
@@ -9242,6 +9269,10 @@ function streamText({
     }
   });
 }
+var streamRetryBoundarySymbol = /* @__PURE__ */ Symbol("streamRetryBoundary");
+function isStreamRetryBoundaryPart(part) {
+  return streamRetryBoundarySymbol in part;
+}
 async function markPromiseAsHandled(promise) {
   try {
     await promise;
@@ -9254,53 +9285,89 @@ function createOutputTransformStream(output) {
   let textChunk = "";
   let textProviderMetadata = void 0;
   let lastPublishedValue = "";
+  function resetAttemptState() {
+    firstTextChunkId = void 0;
+    text2 = "";
+    textChunk = "";
+    textProviderMetadata = void 0;
+    lastPublishedValue = "";
+  }
+  function enqueueChunk({
+    controller,
+    chunk
+  }) {
+    controller.enqueue(chunk);
+  }
   function publishTextChunk({
     controller,
     partialOutput = void 0
   }) {
-    controller.enqueue({
-      part: {
-        type: "text-delta",
-        id: firstTextChunkId,
-        text: textChunk,
-        providerMetadata: textProviderMetadata
-      },
-      partialOutput
+    enqueueChunk({
+      controller,
+      chunk: {
+        part: {
+          type: "text-delta",
+          id: firstTextChunkId,
+          text: textChunk,
+          providerMetadata: textProviderMetadata
+        },
+        partialOutput
+      }
     });
     textChunk = "";
   }
   return new TransformStream({
     async transform(chunk, controller) {
       var _a25;
+      if (isStreamRetryBoundaryPart(chunk)) {
+        resetAttemptState();
+        controller.enqueue(chunk);
+        return;
+      }
       if (chunk.type === "finish-step" && textChunk.length > 0) {
         publishTextChunk({ controller });
       }
       if (chunk.type !== "text-delta" && chunk.type !== "text-start" && chunk.type !== "text-end") {
-        controller.enqueue({ part: chunk, partialOutput: void 0 });
+        enqueueChunk({
+          controller,
+          chunk: { part: chunk, partialOutput: void 0 }
+        });
         return;
       }
       if (firstTextChunkId == null) {
         firstTextChunkId = chunk.id;
       } else if (chunk.id !== firstTextChunkId) {
-        controller.enqueue({ part: chunk, partialOutput: void 0 });
+        enqueueChunk({
+          controller,
+          chunk: { part: chunk, partialOutput: void 0 }
+        });
         return;
       }
       if (chunk.type === "text-start") {
-        controller.enqueue({ part: chunk, partialOutput: void 0 });
+        enqueueChunk({
+          controller,
+          chunk: { part: chunk, partialOutput: void 0 }
+        });
         return;
       }
       if (chunk.type === "text-end") {
         if (textChunk.length > 0) {
           publishTextChunk({ controller });
         }
-        controller.enqueue({ part: chunk, partialOutput: void 0 });
+        enqueueChunk({
+          controller,
+          chunk: { part: chunk, partialOutput: void 0 }
+        });
         return;
       }
       text2 += chunk.text;
       textChunk += chunk.text;
       textProviderMetadata = (_a25 = chunk.providerMetadata) != null ? _a25 : textProviderMetadata;
       if (chunk.text.length === 0 && chunk.providerMetadata != null) {
-        controller.enqueue({ part: chunk, partialOutput: void 0 });
+        enqueueChunk({
+          controller,
+          chunk: { part: chunk, partialOutput: void 0 }
+        });
         return;
       }
       const result = await output.parsePartialOutput({ text: text2 });
@@ -9314,6 +9381,75 @@ function createOutputTransformStream(output) {
     }
   });
 }
+function applyStreamTextTransforms({
+  stream,
+  transforms,
+  tools,
+  stopStream
+}) {
+  const sourceReader = stream.getReader();
+  let sourceDone = false;
+  let pendingBoundary;
+  let transformedSegmentReader;
+  const createTransformedSegmentReader = () => {
+    let segment = new ReadableStream(
+      {
+        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({
+    async pull(controller) {
+      transformedSegmentReader != null ? transformedSegmentReader : transformedSegmentReader = createTransformedSegmentReader();
+      const { done, value } = await transformedSegmentReader.read();
+      if (!done) {
+        controller.enqueue(value);
+        return;
+      }
+      transformedSegmentReader = void 0;
+      if (pendingBoundary != null) {
+        controller.enqueue(pendingBoundary);
+        pendingBoundary = void 0;
+        return;
+      }
+      if (sourceDone) {
+        controller.close();
+      }
+    },
+    async cancel(reason) {
+      await (transformedSegmentReader == null ? void 0 : transformedSegmentReader.cancel(reason));
+      await sourceReader.cancel(reason);
+    }
+  });
+}
 var DefaultStreamTextResult = class {
   constructor({
     model,
@@ -9321,6 +9457,7 @@ var DefaultStreamTextResult = class {
     headers,
     settings,
     maxRetries: maxRetriesArg,
+    streamRetries: streamRetriesArg,
     abortSignal,
     stepTimeoutMs,
     stepAbortController,
@@ -9354,6 +9491,7 @@ var DefaultStreamTextResult = class {
     timeout,
     onChunk,
     onError,
+    canRetryStreamViaOnError,
     onEnd,
     onAbort,
     onStepFinish,
@@ -9419,24 +9557,44 @@ var DefaultStreamTextResult = class {
     let activeTextContent = createIdMap();
     let activeReasoningContent = createIdMap();
     let recordedNoOutputError;
+    const errorsHandledForStreamRetry = /* @__PURE__ */ new Set();
     const eventProcessor = new TransformStream({
       async transform(chunk, controller) {
-        var _a25, _b25, _c, _d;
-        controller.enqueue(chunk);
+        var _a25, _b25, _c, _d, _e;
+        if (isStreamRetryBoundaryPart(chunk)) {
+          const retryBoundary = chunk[streamRetryBoundarySymbol];
+          recordedContent = [];
+          activeReasoningContent = createIdMap();
+          activeTextContent = createIdMap();
+          recordedRequest = retryBoundary.request;
+          recordedRequestMessages = (_a25 = retryBoundary.request.messages) != null ? _a25 : [];
+          recordedWarnings = retryBoundary.warnings;
+          return;
+        }
         const { part } = chunk;
-        await notify({
-          event: { chunk: part },
-          callbacks: onChunk
-        });
+        controller.enqueue(chunk);
+        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);
           if (NoOutputGeneratedError.isInstance(error)) {
             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 (part.type === "custom" || part.type === "source" || part.type === "tool-call" || part.type === "tool-approval-request" || part.type === "tool-approval-response" || part.type === "tool-error") {
           recordedContent.push(part);
@@ -9462,7 +9620,7 @@ var DefaultStreamTextResult = class {
             return;
           }
           activeText.text += part.text;
-          activeText.providerMetadata = (_a25 = part.providerMetadata) != null ? _a25 : activeText.providerMetadata;
+          activeText.providerMetadata = (_b25 = part.providerMetadata) != null ? _b25 : activeText.providerMetadata;
         }
         if (part.type === "text-end") {
           const activeText = activeTextContent[part.id];
@@ -9476,7 +9634,7 @@ var DefaultStreamTextResult = class {
             });
             return;
           }
-          activeText.providerMetadata = (_b25 = part.providerMetadata) != null ? _b25 : activeText.providerMetadata;
+          activeText.providerMetadata = (_c = part.providerMetadata) != null ? _c : activeText.providerMetadata;
           delete activeTextContent[part.id];
         }
         if (part.type === "reasoning-start") {
@@ -9500,7 +9658,7 @@ var DefaultStreamTextResult = class {
             return;
           }
           activeReasoning.text += part.text;
-          activeReasoning.providerMetadata = (_c = part.providerMetadata) != null ? _c : activeReasoning.providerMetadata;
+          activeReasoning.providerMetadata = (_d = part.providerMetadata) != null ? _d : activeReasoning.providerMetadata;
         }
         if (part.type === "reasoning-end") {
           const activeReasoning = activeReasoningContent[part.id];
@@ -9514,7 +9672,7 @@ var DefaultStreamTextResult = class {
             });
             return;
           }
-          activeReasoning.providerMetadata = (_d = part.providerMetadata) != null ? _d : activeReasoning.providerMetadata;
+          activeReasoning.providerMetadata = (_e = part.providerMetadata) != null ? _e : activeReasoning.providerMetadata;
           delete activeReasoningContent[part.id];
         }
         if (part.type === "file" || part.type === "reasoning-file") {
@@ -9736,22 +9894,26 @@ var DefaultStreamTextResult = class {
         }
       })
     );
-    for (const transform of transforms) {
-      stream = stream.pipeThrough(
-        transform({
-          tools,
-          stopStream() {
-            stitchableStream.terminate();
-            isRunning = false;
-          }
-        })
-      );
-    }
+    stream = applyStreamTextTransforms({
+      stream,
+      transforms,
+      tools,
+      stopStream() {
+        stitchableStream.terminate();
+        isRunning = false;
+      }
+    });
     this.baseStream = stream.pipeThrough(createOutputTransformStream(output != null ? output : text())).pipeThrough(eventProcessor);
     const { maxRetries } = prepareRetries({
       maxRetries: maxRetriesArg,
       abortSignal
     });
+    const { maxRetries: streamRetries } = prepareRetries({
+      maxRetries: streamRetriesArg,
+      abortSignal,
+      parameter: "streamRetries",
+      defaultMaxRetries: 0
+    });
     const callSettings = prepareLanguageModelCallOptions(settings);
     const self = this;
     const callId = generateCallId();
@@ -10090,11 +10252,8 @@ var DefaultStreamTextResult = class {
           });
           const stepStartTimestampMs = now2();
           const { retry } = prepareRetries({ maxRetries, abortSignal });
-          const {
-            stream: languageModelStream,
-            request,
-            response
-          } = await runInStepTracingChannelContext(
+          let hasNotifiedStepStart = false;
+          const callLanguageModel = () => runInStepTracingChannelContext(
             () => retry(
               async () => {
                 var _a27, _b26;
@@ -10128,6 +10287,10 @@ var DefaultStreamTextResult = class {
                   ),
                   onStart: async ({ promptMessages }) => {
                     var _a28, _b27;
+                    if (hasNotifiedStepStart) {
+                      return;
+                    }
+                    hasNotifiedStepStart = true;
                     await notify({
                       event: {
                         callId,
@@ -10160,6 +10323,135 @@ var DefaultStreamTextResult = class {
               }
             )
           );
+          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 = [];
+          const outputChunksHandledBeforeBuffering = /* @__PURE__ */ new WeakSet();
+          const openTextParts = /* @__PURE__ */ new Set();
+          const openReasoningParts = /* @__PURE__ */ new Set();
+          let enqueueStreamRetryAttemptBoundary = false;
+          const shouldBufferToolParts = streamRetries > 0 || canRetryStreamViaOnError;
+          const languageModelStream = new ReadableStream({
+            async pull(controller) {
+              const enqueueAttemptPart = (part) => {
+                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 (isOutputChunk2(value)) {
+                    clearFirstChunkTimeout();
+                    resetChunkTimeout();
+                    outputChunksHandledBeforeBuffering.add(value);
+                  }
+                  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;
+                try {
+                  onErrorResult = await onError({ error });
+                } catch (e) {
+                }
+                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;
+                try {
+                  retryLanguageModelCall = await callLanguageModel();
+                } catch (retryError) {
+                  controller.enqueue({
+                    type: "error",
+                    error: retryError
+                  });
+                  controller.close();
+                  return;
+                }
+                request = retryLanguageModelCall.request;
+                response = retryLanguageModelCall.response;
+                languageModelStreamReader = retryLanguageModelCall.stream.getReader();
+                enqueueStreamRetryAttemptBoundary = true;
+              }
+            },
+            cancel(reason) {
+              return languageModelStreamReader.cancel(reason);
+            }
+          });
           startFirstChunkTimeout();
           const streamAfterToolCallbackInvocation = invokeToolCallbacksFromStream({
             stream: languageModelStream,
@@ -10197,12 +10489,12 @@ var DefaultStreamTextResult = class {
             executeToolInTelemetryContext: telemetryDispatcher.executeTool,
             runInTracingChannelSpan: runInTracingChannelSpanInStep
           });
-          const stepRequest = {
+          const getStepRequest = () => ({
             ...request,
             body: include.requestBody ? request == null ? void 0 : request.body : void 0,
             messages: include.requestMessages ? cloneModelMessages(stepMessages) : void 0
-          };
-          recordedRequestMessages = (_l = stepRequest.messages) != null ? _l : [];
+          });
+          recordedRequestMessages = (_l = getStepRequest().messages) != null ? _l : [];
           const stepToolCalls = [];
           const stepToolOutputs = [];
           const stepToolApprovalResponses = [];
@@ -10214,7 +10506,7 @@ var DefaultStreamTextResult = class {
           let stepUsage = createNullLanguageModelUsage();
           let stepProviderMetadata;
           let stepFirstChunk = true;
-          let modelCallPerformance = {
+          const createModelCallPerformance = () => ({
             responseTimeMs: 0,
             effectiveOutputTokensPerSecond: 0,
             outputTokensPerSecond: void 0,
@@ -10222,39 +10514,67 @@ var DefaultStreamTextResult = class {
             effectiveTotalTokensPerSecond: 0,
             timeToFirstOutputMs: void 0,
             timeBetweenOutputChunksMs: void 0
-          };
+          });
+          let modelCallPerformance = createModelCallPerformance();
           const toolExecutionMs = {};
-          let stepResponse = {
+          const createStepResponse = () => ({
             id: generateId4(),
             timestamp: /* @__PURE__ */ new Date(),
             modelId: model.modelId
-          };
+          });
+          let stepResponse = createStepResponse();
           const textPartIds = /* @__PURE__ */ new Map();
           const reasoningPartIds = /* @__PURE__ */ new Map();
+          const enqueueStepPart = (controller, part) => {
+            controller.enqueue(part);
+          };
           self.addStream(
             streamWithToolResults.pipeThrough(
               new TransformStream({
                 async transform(chunk, controller) {
                   var _a27, _b26, _c2, _d2, _e2, _f2, _g2;
+                  if (isStreamRetryAttemptBoundaryPart(chunk)) {
+                    warnings = chunk.warnings;
+                    stepFinishReason = "other";
+                    stepRawFinishReason = void 0;
+                    hasReceivedTerminalChunk = false;
+                    hasReceivedOutputChunk = false;
+                    stepUsage = createNullLanguageModelUsage();
+                    stepProviderMetadata = void 0;
+                    modelCallPerformance = createModelCallPerformance();
+                    stepResponse = createStepResponse();
+                    textPartIds.clear();
+                    reasoningPartIds.clear();
+                    controller.enqueue({
+                      [streamRetryBoundarySymbol]: {
+                        request: getStepRequest(),
+                        warnings
+                      }
+                    });
+                    return;
+                  }
                   if (chunk.type === "model-call-start") {
                     warnings = chunk.warnings;
                     return;
                   }
                   if (stepFirstChunk) {
                     stepFirstChunk = false;
-                    controller.enqueue({
+                    enqueueStepPart(controller, {
                       type: "start-step",
-                      request: stepRequest,
+                      request: getStepRequest(),
                       warnings: warnings != null ? warnings : []
                     });
                   }
                   const chunkType = chunk.type;
                   if (isOutputChunk2(chunk)) {
-                    if (!hasReceivedOutputChunk) {
+                    const timeoutHandledBeforeBuffering = outputChunksHandledBeforeBuffering.has(chunk);
+                    if (!hasReceivedOutputChunk && !timeoutHandledBeforeBuffering) {
                       clearFirstChunkTimeout();
                     }
                     hasReceivedOutputChunk = true;
-                    resetChunkTimeout();
+                    if (!timeoutHandledBeforeBuffering) {
+                      resetChunkTimeout();
+                    }
                   }
                   switch (chunkType) {
                     case "file":
@@ -10265,18 +10585,18 @@ var DefaultStreamTextResult = class {
                     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;
                     }
                     case "text-delta": {
                       if (chunk.text.length > 0 || chunk.providerMetadata != null) {
-                        controller.enqueue({
+                        enqueueStepPart(controller, {
                           ...chunk,
                           id: (_a27 = textPartIds.get(chunk.id)) != null ? _a27 : chunk.id
                         });
@@ -10284,7 +10604,7 @@ var DefaultStreamTextResult = class {
                       break;
                     }
                     case "text-end": {
-                      controller.enqueue({
+                      enqueueStepPart(controller, {
                         ...chunk,
                         id: (_b26 = textPartIds.get(chunk.id)) != null ? _b26 : chunk.id
                       });
@@ -10294,18 +10614,18 @@ var DefaultStreamTextResult = class {
                     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: (_c2 = reasoningPartIds.get(chunk.id)) != null ? _c2 : chunk.id
                       });
                       break;
                     }
                     case "reasoning-end": {
-                      controller.enqueue({
+                      enqueueStepPart(controller, {
                         ...chunk,
                         id: (_d2 = reasoningPartIds.get(chunk.id)) != null ? _d2 : chunk.id
                       });
@@ -10313,24 +10633,24 @@ var DefaultStreamTextResult = class {
                       break;
                     }
                     case "tool-call": {
-                      controller.enqueue(chunk);
+                      enqueueStepPart(controller, chunk);
                       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);
                       }
                       break;
                     }
                     case "tool-error": {
-                      controller.enqueue(chunk);
+                      enqueueStepPart(controller, chunk);
                       stepToolOutputs.push(chunk);
                       break;
                     }
@@ -10357,13 +10677,13 @@ var DefaultStreamTextResult = class {
                     }
                     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;
                     }
@@ -10376,7 +10696,7 @@ var DefaultStreamTextResult = class {
                 // invoke onEnd callback and resolve toolResults promise when the stream is about to close:
                 async flush(controller) {
                   if (!hasReceivedTerminalChunk && !hasReceivedOutputChunk) {
-                    controller.enqueue({
+                    enqueueStepPart(controller, {
                       type: "error",
                       error: new NoOutputGeneratedError({
                         message: "No output generated. The model stream ended without a finish chunk."
@@ -10403,7 +10723,7 @@ var DefaultStreamTextResult = class {
                       headers: response == null ? void 0 : response.headers
                     }
                   };
-                  controller.enqueue(finishStepPart);
+                  enqueueStepPart(controller, finishStepPart);
                   const combinedUsage = addLanguageModelUsage(usage, stepUsage);
                   await stepFinish.promise;
                   const clientToolCalls = stepToolCalls.filter(
@@ -10452,14 +10772,14 @@ var DefaultStreamTextResult = class {
                         })
                       );
                     } catch (error) {
-                      controller.enqueue({
+                      enqueueStepPart(controller, {
                         type: "error",
                         error
                       });
                       self.closeStream();
                     }
                   } else {
-                    controller.enqueue({
+                    enqueueStepPart(controller, {
                       type: "finish",
                       finishReason: stepFinishReason,
                       rawFinishReason: stepRawFinishReason,