ai 6.0.259 → 6.0.260

package/dist/internal/index.js

@@ -164,7 +164,7 @@ function detectMediaType({
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "6.0.259" : "0.0.0-test";
+var VERSION = true ? "6.0.260" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/dist/internal/index.mjs

@@ -144,7 +144,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "6.0.259" : "0.0.0-test";
+var VERSION = true ? "6.0.260" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "6.0.259",
+  "version": "6.0.260",
   "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",
   "sideEffects": false,

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

@@ -64,6 +64,12 @@ import { validateObjectGenerationInput } from './validate-object-generation-inpu
 
 const originalGenerateId = createIdGenerator({ prefix: 'aiobj', size: 24 });
 
+async function markPromiseAsHandled<T>(promise: Promise<T>): Promise<void> {
+  try {
+    await promise;
+  } catch {}
+}
+
 /**
  * Callback that is set using the `onError` option.
  *
@@ -586,6 +592,7 @@ class DefaultStreamObjectResult<
         let providerMetadata: ProviderMetadata | undefined;
         let object: RESULT | undefined;
         let error: unknown | undefined;
+        let terminalError: { error: unknown } | undefined;
 
         // pipe chunks through a transformation stream that extracts metadata:
         let accumulatedText = '';
@@ -698,6 +705,19 @@ class DefaultStreamObjectResult<
                     break;
                   }
 
+                  case 'error': {
+                    if (terminalError === undefined) {
+                      const wrappedError = wrapGatewayError(chunk.error);
+                      terminalError = { error: wrappedError };
+                      error = wrappedError;
+                      finishReason = 'error';
+                      self.rejectResultPromises(wrappedError);
+                    }
+
+                    controller.enqueue(chunk);
+                    break;
+                  }
+
                   case 'finish': {
                     // send final text delta:
                     if (textDelta !== '') {
@@ -705,7 +725,10 @@ class DefaultStreamObjectResult<
                     }
 
                     // store finish reason for telemetry:
-                    finishReason = chunk.finishReason.unified;
+                    finishReason =
+                      terminalError === undefined
+                        ? chunk.finishReason.unified
+                        : 'error';
 
                     // store usage and metadata for promises and onFinish callback:
                     usage = asLanguageModelUsage(chunk.usage);
@@ -713,7 +736,7 @@ class DefaultStreamObjectResult<
 
                     controller.enqueue({
                       ...chunk,
-                      finishReason: chunk.finishReason.unified,
+                      finishReason,
                       usage,
                       response: fullResponse,
                     });
@@ -725,6 +748,10 @@ class DefaultStreamObjectResult<
                       model: model.modelId,
                     });
 
+                    if (terminalError !== undefined) {
+                      break;
+                    }
+
                     // resolve promises that can be resolved now:
                     self._usage.resolve(usage);
                     self._providerMetadata.resolve(providerMetadata);
@@ -846,10 +873,18 @@ class DefaultStreamObjectResult<
             }),
           );
 
-        stitchableStream.addStream(transformedStream);
+        stitchableStream.addStream(transformedStream, {
+          onError(error) {
+            const wrappedError = wrapGatewayError(error);
+            self.rejectResultPromises(wrappedError);
+            void onError({ error: wrappedError });
+          },
+        });
       },
     })
       .catch(error => {
+        self.rejectResultPromises(error);
+
         // add an empty stream with an error to break the stream:
         stitchableStream.addStream(
           new ReadableStream({
@@ -867,6 +902,29 @@ class DefaultStreamObjectResult<
     this.outputStrategy = outputStrategy;
   }
 
+  private rejectResultPromises(error: unknown) {
+    this.rejectResultPromise({ delayedPromise: this._object, error });
+    this.rejectResultPromise({ delayedPromise: this._usage, error });
+    this.rejectResultPromise({ delayedPromise: this._providerMetadata, error });
+    this.rejectResultPromise({ delayedPromise: this._warnings, error });
+    this.rejectResultPromise({ delayedPromise: this._request, error });
+    this.rejectResultPromise({ delayedPromise: this._response, error });
+    this.rejectResultPromise({ delayedPromise: this._finishReason, error });
+  }
+
+  private rejectResultPromise<T>({
+    delayedPromise,
+    error,
+  }: {
+    delayedPromise: DelayedPromise<T>;
+    error: unknown;
+  }) {
+    if (delayedPromise.isPending()) {
+      delayedPromise.reject(error);
+      markPromiseAsHandled(delayedPromise.promise);
+    }
+  }
+
   get object() {
     return this._object.promise;
   }

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

@@ -71,6 +71,7 @@ import { filterActiveTools } from './filter-active-tools';
 import type { GenerateTextResult } from './generate-text-result';
 import { DefaultGeneratedFile } from './generated-file';
 import { isApprovalNeeded } from './is-approval-needed';
+import { isToolExecutionAllowedFinishReason } from './is-tool-execution-allowed-finish-reason';
 import { maybeSignApproval } from './tool-approval-signature';
 import { validateApprovedToolApprovals } from './validate-tool-approvals';
 import { text, type Output } from './output';
@@ -1031,7 +1032,12 @@ export async function generateText<
               toolCall => !toolCall.providerExecuted,
             );
 
-            if (stepToolSet != null) {
+            if (
+              stepToolSet != null &&
+              isToolExecutionAllowedFinishReason(
+                currentModelResponse.finishReason.unified,
+              )
+            ) {
               clientToolOutputs.push(
                 ...(await executeTools({
                   toolCalls: clientToolCalls.filter(

package/src/generate-text/is-tool-execution-allowed-finish-reason.ts

@@ -0,0 +1,7 @@
+import type { FinishReason } from '../types';
+
+export function isToolExecutionAllowedFinishReason(
+  finishReason: FinishReason,
+): boolean {
+  return finishReason === 'stop' || finishReason === 'tool-calls';
+}

package/src/generate-text/run-tools-transformation.ts

@@ -28,6 +28,7 @@ import {
   type GeneratedFile,
 } from './generated-file';
 import { isApprovalNeeded } from './is-approval-needed';
+import { isToolExecutionAllowedFinishReason } from './is-tool-execution-allowed-finish-reason';
 import { maybeSignApproval } from './tool-approval-signature';
 import { parseToolCall } from './parse-tool-call';
 import type { ToolApprovalRequestOutput } from './tool-approval-request-output';
@@ -200,6 +201,7 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
 
   // keep track of outstanding tool results for stream closing:
   const outstandingToolResults = new Set<string>();
+  const toolCallsToExecute: Array<TypedToolCall<TOOLS>> = [];
 
   // keep track of parsed tool calls so provider-emitted approval requests can reference them
   // keep track of tool inputs for provider-side tool results
@@ -224,6 +226,41 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
     }
   }
 
+  function executeToolCallAfterFinish(toolCall: TypedToolCall<TOOLS>) {
+    const toolExecutionId = generateId(); // use our own id to guarantee uniqueness
+    outstandingToolResults.add(toolExecutionId);
+
+    executeToolCall({
+      toolCall,
+      tools,
+      tracer,
+      telemetry,
+      messages,
+      abortSignal,
+      experimental_context,
+      stepNumber,
+      model,
+      onToolCallStart,
+      onToolCallFinish,
+      onPreliminaryToolResult: result => {
+        enqueueToolResult(result);
+      },
+    })
+      .then(result => {
+        enqueueToolResult(result);
+      })
+      .catch(error => {
+        enqueueToolResult({
+          type: 'error',
+          error,
+        });
+      })
+      .finally(() => {
+        outstandingToolResults.delete(toolExecutionId);
+        attemptClose();
+      });
+  }
+
   // forward stream
   const forwardStream = new TransformStream<
     LanguageModelV3StreamPart,
@@ -279,6 +316,15 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
             usage: asLanguageModelUsage(chunk.usage),
             providerMetadata: chunk.providerMetadata,
           };
+
+          if (isToolExecutionAllowedFinishReason(chunk.finishReason.unified)) {
+            for (const toolCall of toolCallsToExecute.splice(0)) {
+              executeToolCallAfterFinish(toolCall);
+            }
+          } else {
+            toolCallsToExecute.length = 0;
+          }
+
           break;
         }
 
@@ -315,7 +361,7 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
             });
 
             toolCallsByToolCallId.set(toolCall.toolCallId, toolCall);
-            controller.enqueue(toolCall);
+            controller.enqueue({ ...toolCall });
 
             if (toolCall.invalid) {
               if (!toolCall.providerExecuted) {
@@ -381,41 +427,7 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
 
             // Only execute tools that are not provider-executed:
             if (tool.execute != null && toolCall.providerExecuted !== true) {
-              const toolExecutionId = generateId(); // use our own id to guarantee uniqueness
-              outstandingToolResults.add(toolExecutionId);
-
-              // Note: we don't await the tool execution here (by leaving out 'await' on recordSpan),
-              // because we want to process the next chunk as soon as possible.
-              // This is important for the case where the tool execution takes a long time.
-              executeToolCall({
-                toolCall,
-                tools,
-                tracer,
-                telemetry,
-                messages,
-                abortSignal,
-                experimental_context,
-                stepNumber,
-                model,
-                onToolCallStart,
-                onToolCallFinish,
-                onPreliminaryToolResult: result => {
-                  enqueueToolResult(result);
-                },
-              })
-                .then(result => {
-                  enqueueToolResult(result);
-                })
-                .catch(error => {
-                  enqueueToolResult({
-                    type: 'error',
-                    error,
-                  });
-                })
-                .finally(() => {
-                  outstandingToolResults.delete(toolExecutionId);
-                  attemptClose();
-                });
+              toolCallsToExecute.push(toolCall);
             }
           } catch (error) {
             enqueueToolResult({ type: 'error', error });

package/src/ui/convert-to-model-messages.ts

@@ -58,7 +58,7 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
         part =>
           !isToolUIPart(part) ||
           part.state === 'approval-responded' ||
-          part.state === 'output-available' ||
+          (part.state === 'output-available' && part.preliminary !== true) ||
           part.state === 'output-error' ||
           part.state === 'output-denied',
       ),

package/src/util/create-stitchable-stream.ts

@@ -8,11 +8,19 @@ import { createResolvablePromise } from './create-resolvable-promise';
  */
 export function createStitchableStream<T>(): {
   stream: ReadableStream<T>;
-  addStream: (innerStream: ReadableStream<T>) => void;
+  addStream: (
+    innerStream: ReadableStream<T>,
+    callbacks?: {
+      onError?: (error: unknown) => void;
+    },
+  ) => void;
   close: () => void;
   terminate: () => void;
 } {
-  let innerStreamReaders: ReadableStreamDefaultReader<T>[] = [];
+  let innerStreams: Array<{
+    reader: ReadableStreamDefaultReader<T>;
+    onError?: (error: unknown) => void;
+  }> = [];
   let controller: ReadableStreamDefaultController<T> | null = null;
   let isClosed = false;
   let waitForNewStream = createResolvablePromise<void>();
@@ -21,34 +29,34 @@ export function createStitchableStream<T>(): {
     isClosed = true;
     waitForNewStream.resolve();
 
-    innerStreamReaders.forEach(reader => reader.cancel());
-    innerStreamReaders = [];
+    innerStreams.forEach(({ reader }) => reader.cancel());
+    innerStreams = [];
     controller?.close();
   };
 
   const processPull = async () => {
     // Case 1: Outer stream is closed and no more inner streams
-    if (isClosed && innerStreamReaders.length === 0) {
+    if (isClosed && innerStreams.length === 0) {
       controller?.close();
       return;
     }
 
     // Case 2: No inner streams available, but outer stream is open
     // wait for a new inner stream to be added or the outer stream to close
-    if (innerStreamReaders.length === 0) {
+    if (innerStreams.length === 0) {
       waitForNewStream = createResolvablePromise<void>();
       await waitForNewStream.promise;
       return processPull();
     }
 
     try {
-      const { value, done } = await innerStreamReaders[0].read();
+      const { value, done } = await innerStreams[0].reader.read();
 
       if (done) {
         // Case 3: Current inner stream is done
-        innerStreamReaders.shift(); // Remove the finished stream
+        innerStreams.shift(); // Remove the finished stream
 
-        if (innerStreamReaders.length === 0 && isClosed) {
+        if (innerStreams.length === 0 && isClosed) {
           // when closed and no more inner streams, stop pulling
           controller?.close();
         } else {
@@ -61,8 +69,9 @@ export function createStitchableStream<T>(): {
       }
     } catch (error) {
       // Case 5: Current inner stream throws an error
+      innerStreams[0].onError?.(error);
       controller?.error(error);
-      innerStreamReaders.shift(); // Remove the errored stream
+      innerStreams.shift(); // Remove the errored stream
       terminate(); // we have errored, terminate all streams
     }
   };
@@ -74,19 +83,27 @@ export function createStitchableStream<T>(): {
       },
       pull: processPull,
       async cancel() {
-        for (const reader of innerStreamReaders) {
+        for (const { reader } of innerStreams) {
           await reader.cancel();
         }
-        innerStreamReaders = [];
+        innerStreams = [];
         isClosed = true;
       },
     }),
-    addStream: (innerStream: ReadableStream<T>) => {
+    addStream: (
+      innerStream: ReadableStream<T>,
+      callbacks?: {
+        onError?: (error: unknown) => void;
+      },
+    ) => {
       if (isClosed) {
         throw new Error('Cannot add inner stream: outer stream is closed');
       }
 
-      innerStreamReaders.push(innerStream.getReader());
+      innerStreams.push({
+        reader: innerStream.getReader(),
+        ...callbacks,
+      });
       waitForNewStream.resolve();
     },
 
@@ -98,7 +115,7 @@ export function createStitchableStream<T>(): {
       isClosed = true;
       waitForNewStream.resolve();
 
-      if (innerStreamReaders.length === 0) {
+      if (innerStreams.length === 0) {
         controller?.close();
       }
     },