ai 3.1.13 → 3.1.15

package/dist/index.mjs

@@ -1449,6 +1449,7 @@ async function streamText({
   messages,
   maxRetries,
   abortSignal,
+  onFinish,
   ...settings
 }) {
   const retry = retryWithExponentialBackoff({ maxRetries });
@@ -1476,17 +1477,20 @@ async function streamText({
       generatorStream: stream
     }),
     warnings,
-    rawResponse
+    rawResponse,
+    onFinish
   });
 }
 var StreamTextResult = class {
   constructor({
     stream,
     warnings,
-    rawResponse
+    rawResponse,
+    onFinish
   }) {
     this.warnings = warnings;
     this.rawResponse = rawResponse;
+    this.onFinish = onFinish;
     let resolveUsage;
     this.usage = new Promise((resolve) => {
       resolveUsage = resolve;
@@ -1495,13 +1499,70 @@ var StreamTextResult = class {
     this.finishReason = new Promise((resolve) => {
       resolveFinishReason = resolve;
     });
+    let resolveText;
+    this.text = new Promise((resolve) => {
+      resolveText = resolve;
+    });
+    let resolveToolCalls;
+    this.toolCalls = new Promise((resolve) => {
+      resolveToolCalls = resolve;
+    });
+    let resolveToolResults;
+    this.toolResults = new Promise((resolve) => {
+      resolveToolResults = resolve;
+    });
+    let finishReason;
+    let usage;
+    let text = "";
+    const toolCalls = [];
+    const toolResults = [];
+    const self = this;
     this.originalStream = stream.pipeThrough(
       new TransformStream({
         async transform(chunk, controller) {
           controller.enqueue(chunk);
+          if (chunk.type === "text-delta") {
+            text += chunk.textDelta;
+          }
+          if (chunk.type === "tool-call") {
+            toolCalls.push(chunk);
+          }
+          if (chunk.type === "tool-result") {
+            toolResults.push(chunk);
+          }
           if (chunk.type === "finish") {
-            resolveUsage(chunk.usage);
-            resolveFinishReason(chunk.finishReason);
+            usage = chunk.usage;
+            finishReason = chunk.finishReason;
+            resolveUsage(usage);
+            resolveFinishReason(finishReason);
+            resolveText(text);
+            resolveToolCalls(toolCalls);
+          }
+        },
+        // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
+        async flush(controller) {
+          var _a;
+          try {
+            resolveToolResults(toolResults);
+            await ((_a = self.onFinish) == null ? void 0 : _a.call(self, {
+              finishReason: finishReason != null ? finishReason : "unknown",
+              usage: usage != null ? usage : {
+                promptTokens: NaN,
+                completionTokens: NaN,
+                totalTokens: NaN
+              },
+              text,
+              toolCalls,
+              // The tool results are inferred as a never[] type, because they are
+              // optional and the execute method with an inferred result type is
+              // optional as well. Therefore we need to cast the toolResults to any.
+              // The type exposed to the users will be correctly inferred.
+              toolResults,
+              rawResponse,
+              warnings
+            }));
+          } catch (error) {
+            controller.error(error);
           }
         }
       })