ai 5.0.239 → 5.0.241

package/dist/index.mjs

@@ -727,7 +727,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "5.0.239" : "0.0.0-test";
+var VERSION = true ? "5.0.241" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -1931,6 +1931,11 @@ var DefaultGeneratedFileWithType = class extends DefaultGeneratedFile {
   }
 };
 
+// src/generate-text/is-tool-execution-allowed-finish-reason.ts
+function isToolExecutionAllowedFinishReason(finishReason) {
+  return finishReason === "stop" || finishReason === "tool-calls";
+}
+
 // src/generate-text/parse-tool-call.ts
 import {
   asSchema as asSchema2,
@@ -2498,7 +2503,9 @@ async function generateText({
           clientToolCalls = stepToolCalls.filter(
             (toolCall) => !toolCall.providerExecuted
           );
-          if (stepToolSet != null) {
+          if (stepToolSet != null && isToolExecutionAllowedFinishReason(
+            currentModelResponse.finishReason
+          )) {
             clientToolOutputs.push(
               ...await executeTools({
                 toolCalls: clientToolCalls.filter(
@@ -4271,32 +4278,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 _a16, _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) {
+        innerStreams.shift();
+        if (innerStreams.length > 0) {
           await processPull();
         } else if (isClosed) {
           controller == null ? void 0 : controller.close();
@@ -4305,8 +4313,9 @@ function createStitchableStream() {
         controller == null ? void 0 : controller.enqueue(value);
       }
     } catch (error) {
+      (_b = (_a16 = innerStreams[0]).onError) == null ? void 0 : _b.call(_a16, error);
       controller == null ? void 0 : controller.error(error);
-      innerStreamReaders.shift();
+      innerStreams.shift();
       terminate();
     }
   };
@@ -4317,18 +4326,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();
     },
     /**
@@ -4338,7 +4350,7 @@ function createStitchableStream() {
     close: () => {
       isClosed = true;
       waitForNewStream.resolve();
-      if (innerStreamReaders.length === 0) {
+      if (innerStreams.length === 0) {
         controller == null ? void 0 : controller.close();
       }
     },
@@ -4404,6 +4416,7 @@ function runToolsTransformation({
     }
   }
   const outstandingToolResults = /* @__PURE__ */ new Set();
+  const pendingToolCalls = [];
   const toolInputs = /* @__PURE__ */ new Map();
   let canClose = false;
   let finishChunk = void 0;
@@ -4415,6 +4428,82 @@ function runToolsTransformation({
       closeToolResultsStream();
     }
   }
+  function executePendingToolCall(toolCall) {
+    const tool2 = tools[toolCall.toolName];
+    const toolExecutionId = generateId();
+    outstandingToolResults.add(toolExecutionId);
+    recordSpan({
+      name: "ai.toolCall",
+      attributes: selectTelemetryAttributes({
+        telemetry,
+        attributes: {
+          ...assembleOperationName({
+            operationId: "ai.toolCall",
+            telemetry
+          }),
+          "ai.toolCall.name": toolCall.toolName,
+          "ai.toolCall.id": toolCall.toolCallId,
+          "ai.toolCall.args": {
+            output: () => JSON.stringify(toolCall.input)
+          }
+        }
+      }),
+      tracer,
+      fn: async (span) => {
+        let output;
+        try {
+          const stream = executeTool2({
+            execute: tool2.execute.bind(tool2),
+            input: toolCall.input,
+            options: {
+              toolCallId: toolCall.toolCallId,
+              messages,
+              abortSignal,
+              experimental_context
+            }
+          });
+          for await (const part of stream) {
+            enqueueToolResult({
+              ...toolCall,
+              type: "tool-result",
+              output: part.output,
+              ...part.type === "preliminary" && {
+                preliminary: true
+              }
+            });
+            if (part.type === "final") {
+              output = part.output;
+            }
+          }
+        } catch (error) {
+          recordErrorOnSpan(span, error);
+          enqueueToolResult({
+            ...toolCall,
+            type: "tool-error",
+            error
+          });
+          outstandingToolResults.delete(toolExecutionId);
+          attemptClose();
+          return;
+        }
+        outstandingToolResults.delete(toolExecutionId);
+        attemptClose();
+        try {
+          span.setAttributes(
+            selectTelemetryAttributes({
+              telemetry,
+              attributes: {
+                "ai.toolCall.result": {
+                  output: () => JSON.stringify(output)
+                }
+              }
+            })
+          );
+        } catch (ignored) {
+        }
+      }
+    });
+  }
   const forwardStream = new TransformStream({
     async transform(chunk, controller) {
       const chunkType = chunk.type;
@@ -4453,6 +4542,13 @@ function runToolsTransformation({
             usage: chunk.usage,
             providerMetadata: chunk.providerMetadata
           };
+          if (isToolExecutionAllowedFinishReason(chunk.finishReason)) {
+            for (const toolCall of pendingToolCalls.splice(0)) {
+              executePendingToolCall(toolCall);
+            }
+          } else {
+            pendingToolCalls.length = 0;
+          }
           break;
         }
         case "tool-call": {
@@ -4488,79 +4584,7 @@ function runToolsTransformation({
               });
             }
             if (tool2.execute != null && toolCall.providerExecuted !== true) {
-              const toolExecutionId = generateId();
-              outstandingToolResults.add(toolExecutionId);
-              recordSpan({
-                name: "ai.toolCall",
-                attributes: selectTelemetryAttributes({
-                  telemetry,
-                  attributes: {
-                    ...assembleOperationName({
-                      operationId: "ai.toolCall",
-                      telemetry
-                    }),
-                    "ai.toolCall.name": toolCall.toolName,
-                    "ai.toolCall.id": toolCall.toolCallId,
-                    "ai.toolCall.args": {
-                      output: () => JSON.stringify(toolCall.input)
-                    }
-                  }
-                }),
-                tracer,
-                fn: async (span) => {
-                  let output;
-                  try {
-                    const stream = executeTool2({
-                      execute: tool2.execute.bind(tool2),
-                      input: toolCall.input,
-                      options: {
-                        toolCallId: toolCall.toolCallId,
-                        messages,
-                        abortSignal,
-                        experimental_context
-                      }
-                    });
-                    for await (const part of stream) {
-                      enqueueToolResult({
-                        ...toolCall,
-                        type: "tool-result",
-                        output: part.output,
-                        ...part.type === "preliminary" && {
-                          preliminary: true
-                        }
-                      });
-                      if (part.type === "final") {
-                        output = part.output;
-                      }
-                    }
-                  } catch (error) {
-                    recordErrorOnSpan(span, error);
-                    enqueueToolResult({
-                      ...toolCall,
-                      type: "tool-error",
-                      error
-                    });
-                    outstandingToolResults.delete(toolExecutionId);
-                    attemptClose();
-                    return;
-                  }
-                  outstandingToolResults.delete(toolExecutionId);
-                  attemptClose();
-                  try {
-                    span.setAttributes(
-                      selectTelemetryAttributes({
-                        telemetry,
-                        attributes: {
-                          "ai.toolCall.result": {
-                            output: () => JSON.stringify(output)
-                          }
-                        }
-                      })
-                    );
-                  } catch (ignored) {
-                  }
-                }
-              });
+              pendingToolCalls.push({ ...toolCall });
             }
           } catch (error) {
             enqueueToolResult({ type: "error", error });
@@ -5985,7 +6009,7 @@ function convertToModelMessages(messages, options) {
     messages = messages.map((message) => ({
       ...message,
       parts: message.parts.filter(
-        (part) => !isToolOrDynamicToolUIPart(part) || part.state !== "input-streaming" && part.state !== "input-available"
+        (part) => !isToolOrDynamicToolUIPart(part) || part.state !== "input-streaming" && part.state !== "input-available" && (part.state !== "output-available" || part.preliminary !== true)
       )
     }));
   }
@@ -7574,6 +7598,12 @@ function simulateReadableStream({
 
 // src/generate-object/stream-object.ts
 var originalGenerateId4 = createIdGenerator4({ prefix: "aiobj", size: 24 });
+async function markPromiseAsHandled(promise) {
+  try {
+    await promise;
+  } catch (e) {
+  }
+}
 function streamObject(options) {
   const {
     model,
@@ -7810,6 +7840,7 @@ var DefaultStreamObjectResult = class {
         let providerMetadata;
         let object2;
         let error;
+        let terminalError;
         let accumulatedText = "";
         let textDelta = "";
         let fullResponse = {
@@ -7880,11 +7911,22 @@ 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;
+                  finishReason = terminalError === void 0 ? chunk.finishReason : "error";
                   usage = chunk.usage;
                   providerMetadata = chunk.providerMetadata;
                   controller.enqueue({
@@ -7893,6 +7935,9 @@ var DefaultStreamObjectResult = class {
                     response: fullResponse
                   });
                   logWarnings(warnings != null ? warnings : []);
+                  if (terminalError !== void 0) {
+                    break;
+                  }
                   self._usage.resolve(usage);
                   self._providerMetadata.resolve(providerMetadata);
                   self._warnings.resolve(warnings);
@@ -7995,9 +8040,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) {
@@ -8011,6 +8063,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;
   }