ai 6.0.259 → 6.0.261

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # ai
 
+## 6.0.261
+
+### Patch Changes
+
+- f1afbf9: Fix array-backed language model mocks to return configured results in order from the first call.
+
+## 6.0.260
+
+### Patch Changes
+
+- 98c656f: fix: reject `streamObject` result promises and report failed completion when the provider stream errors
+- b253d52: Filter preliminary tool outputs when `ignoreIncompleteToolCalls` is enabled.
+- 9e15cb4: Prevent automatic tool execution when a model call ends with an unsafe finish reason.
+
 ## 6.0.259
 
 ### Patch Changes

package/dist/index.js

@@ -1304,7 +1304,7 @@ function detectMediaType({
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "6.0.259" : "0.0.0-test";
+var VERSION = true ? "6.0.261" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -3216,6 +3216,11 @@ async function isApprovalNeeded({
   });
 }
 
+// src/generate-text/is-tool-execution-allowed-finish-reason.ts
+function isToolExecutionAllowedFinishReason(finishReason) {
+  return finishReason === "stop" || finishReason === "tool-calls";
+}
+
 // src/generate-text/tool-approval-signature.ts
 var import_provider_utils11 = require("@ai-sdk/provider-utils");
 var encoder = new TextEncoder();
@@ -4979,7 +4984,9 @@ async function generateText({
             clientToolCalls = stepToolCalls.filter(
               (toolCall) => !toolCall.providerExecuted
             );
-            if (stepToolSet != null) {
+            if (stepToolSet != null && isToolExecutionAllowedFinishReason(
+              currentModelResponse.finishReason.unified
+            )) {
               clientToolOutputs.push(
                 ...await executeTools({
                   toolCalls: clientToolCalls.filter(
@@ -6639,32 +6646,33 @@ function createResolvablePromise() {
 
 // src/util/create-stitchable-stream.ts
 function createStitchableStream() {
-  let innerStreamReaders = [];
+  let innerStreams = [];
   let controller = null;
   let isClosed = false;
   let waitForNewStream = createResolvablePromise();
   const terminate = () => {
     isClosed = true;
     waitForNewStream.resolve();
-    innerStreamReaders.forEach((reader) => reader.cancel());
-    innerStreamReaders = [];
+    innerStreams.forEach(({ reader }) => reader.cancel());
+    innerStreams = [];
     controller == null ? void 0 : controller.close();
   };
   const processPull = async () => {
-    if (isClosed && innerStreamReaders.length === 0) {
+    var _a22, _b;
+    if (isClosed && innerStreams.length === 0) {
       controller == null ? void 0 : controller.close();
       return;
     }
-    if (innerStreamReaders.length === 0) {
+    if (innerStreams.length === 0) {
       waitForNewStream = createResolvablePromise();
       await waitForNewStream.promise;
       return processPull();
     }
     try {
-      const { value, done } = await innerStreamReaders[0].read();
+      const { value, done } = await innerStreams[0].reader.read();
       if (done) {
-        innerStreamReaders.shift();
-        if (innerStreamReaders.length === 0 && isClosed) {
+        innerStreams.shift();
+        if (innerStreams.length === 0 && isClosed) {
           controller == null ? void 0 : controller.close();
         } else {
           await processPull();
@@ -6673,8 +6681,9 @@ function createStitchableStream() {
         controller == null ? void 0 : controller.enqueue(value);
       }
     } catch (error) {
+      (_b = (_a22 = innerStreams[0]).onError) == null ? void 0 : _b.call(_a22, error);
       controller == null ? void 0 : controller.error(error);
-      innerStreamReaders.shift();
+      innerStreams.shift();
       terminate();
     }
   };
@@ -6685,18 +6694,21 @@ function createStitchableStream() {
       },
       pull: processPull,
       async cancel() {
-        for (const reader of innerStreamReaders) {
+        for (const { reader } of innerStreams) {
           await reader.cancel();
         }
-        innerStreamReaders = [];
+        innerStreams = [];
         isClosed = true;
       }
     }),
-    addStream: (innerStream) => {
+    addStream: (innerStream, callbacks) => {
       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();
     },
     /**
@@ -6706,7 +6718,7 @@ function createStitchableStream() {
     close: () => {
       isClosed = true;
       waitForNewStream.resolve();
-      if (innerStreamReaders.length === 0) {
+      if (innerStreams.length === 0) {
         controller == null ? void 0 : controller.close();
       }
     },
@@ -6768,6 +6780,7 @@ function runToolsTransformation({
     }
   }
   const outstandingToolResults = /* @__PURE__ */ new Set();
+  const toolCallsToExecute = [];
   const toolCallsByToolCallId = /* @__PURE__ */ new Map();
   let canClose = false;
   let finishChunk = void 0;
@@ -6779,6 +6792,36 @@ function runToolsTransformation({
       closeToolResultsStream();
     }
   }
+  function executeToolCallAfterFinish(toolCall) {
+    const toolExecutionId = generateId2();
+    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();
+    });
+  }
   const forwardStream = new TransformStream({
     async transform(chunk, controller) {
       const chunkType = chunk.type;
@@ -6819,6 +6862,13 @@ function runToolsTransformation({
             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;
         }
         case "tool-approval-request": {
@@ -6850,7 +6900,7 @@ function runToolsTransformation({
               messages
             });
             toolCallsByToolCallId.set(toolCall.toolCallId, toolCall);
-            controller.enqueue(toolCall);
+            controller.enqueue({ ...toolCall });
             if (toolCall.invalid) {
               if (!toolCall.providerExecuted) {
                 enqueueToolResult({
@@ -6902,34 +6952,7 @@ function runToolsTransformation({
               break;
             }
             if (tool2.execute != null && toolCall.providerExecuted !== true) {
-              const toolExecutionId = generateId2();
-              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();
-              });
+              toolCallsToExecute.push(toolCall);
             }
           } catch (error) {
             enqueueToolResult({ type: "error", error });
@@ -9106,7 +9129,7 @@ async function convertToModelMessages(messages, options) {
     messages = messages.map((message) => ({
       ...message,
       parts: message.parts.filter(
-        (part) => !isToolUIPart(part) || part.state === "approval-responded" || part.state === "output-available" || part.state === "output-error" || part.state === "output-denied"
+        (part) => !isToolUIPart(part) || part.state === "approval-responded" || part.state === "output-available" && part.preliminary !== true || part.state === "output-error" || part.state === "output-denied"
       )
     }));
   }
@@ -11281,6 +11304,12 @@ function simulateReadableStream({
 
 // src/generate-object/stream-object.ts
 var originalGenerateId4 = (0, import_provider_utils32.createIdGenerator)({ prefix: "aiobj", size: 24 });
+async function markPromiseAsHandled(promise) {
+  try {
+    await promise;
+  } catch (e) {
+  }
+}
 function streamObject(options) {
   const {
     model,
@@ -11515,6 +11544,7 @@ var DefaultStreamObjectResult = class {
         let providerMetadata;
         let object2;
         let error;
+        let terminalError;
         let accumulatedText = "";
         let textDelta = "";
         let fullResponse = {
@@ -11585,16 +11615,27 @@ var DefaultStreamObjectResult = class {
                   };
                   break;
                 }
+                case "error": {
+                  if (terminalError === void 0) {
+                    const wrappedError = wrapGatewayError(chunk.error);
+                    terminalError = { error: wrappedError };
+                    error = wrappedError;
+                    finishReason = "error";
+                    self.rejectResultPromises(wrappedError);
+                  }
+                  controller.enqueue(chunk);
+                  break;
+                }
                 case "finish": {
                   if (textDelta !== "") {
                     controller.enqueue({ type: "text-delta", textDelta });
                   }
-                  finishReason = chunk.finishReason.unified;
+                  finishReason = terminalError === void 0 ? chunk.finishReason.unified : "error";
                   usage = asLanguageModelUsage(chunk.usage);
                   providerMetadata = chunk.providerMetadata;
                   controller.enqueue({
                     ...chunk,
-                    finishReason: chunk.finishReason.unified,
+                    finishReason,
                     usage,
                     response: fullResponse
                   });
@@ -11603,6 +11644,9 @@ var DefaultStreamObjectResult = class {
                     provider: model.provider,
                     model: model.modelId
                   });
+                  if (terminalError !== void 0) {
+                    break;
+                  }
                   self._usage.resolve(usage);
                   self._providerMetadata.resolve(providerMetadata);
                   self._warnings.resolve(warnings);
@@ -11705,9 +11749,16 @@ var DefaultStreamObjectResult = class {
             }
           })
         );
-        stitchableStream.addStream(transformedStream);
+        stitchableStream.addStream(transformedStream, {
+          onError(error2) {
+            const wrappedError = wrapGatewayError(error2);
+            self.rejectResultPromises(wrappedError);
+            void onError({ error: wrappedError });
+          }
+        });
       }
     }).catch((error) => {
+      self.rejectResultPromises(error);
       stitchableStream.addStream(
         new ReadableStream({
           start(controller) {
@@ -11721,6 +11772,24 @@ var DefaultStreamObjectResult = class {
     });
     this.outputStrategy = outputStrategy;
   }
+  rejectResultPromises(error) {
+    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 });
+  }
+  rejectResultPromise({
+    delayedPromise,
+    error
+  }) {
+    if (delayedPromise.isPending()) {
+      delayedPromise.reject(error);
+      markPromiseAsHandled(delayedPromise.promise);
+    }
+  }
   get object() {
     return this._object.promise;
   }