ai 3.1.13 → 3.1.15

package/dist/index.d.mts

@@ -922,10 +922,13 @@ If set and supported by the model, calls will generate deterministic results.
 @param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
 @param abortSignal - An optional abort signal that can be used to cancel the call.
 
+@param onFinish - Callback that is called when the LLM response and all request tool executions
+(for tools that have an `execute` function) are finished.
+
 @return
 A result object for accessing different stream types and additional information.
  */
-declare function streamText<TOOLS extends Record<string, CoreTool>>({ model, tools, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
+declare function streamText<TOOLS extends Record<string, CoreTool>>({ model, tools, system, prompt, messages, maxRetries, abortSignal, onFinish, ...settings }: CallSettings & Prompt & {
     /**
 The language model to use.
      */
@@ -934,6 +937,45 @@ The language model to use.
 The tools that the model can call. The model needs to support calling tools.
     */
     tools?: TOOLS;
+    /**
+Callback that is called when the LLM response and all request tool executions
+(for tools that have an `execute` function) are finished.
+     */
+    onFinish?: (event: {
+        /**
+  The reason why the generation finished.
+         */
+        finishReason: FinishReason;
+        /**
+  The token usage of the generated response.
+   */
+        usage: TokenUsage;
+        /**
+  The full text that has been generated.
+         */
+        text: string;
+        /**
+  The tool calls that have been executed.
+         */
+        toolCalls?: ToToolCall<TOOLS>[];
+        /**
+  The tool results that have been generated.
+         */
+        toolResults?: ToToolResult<TOOLS>[];
+        /**
+  Optional raw response data.
+         */
+        rawResponse?: {
+            /**
+    Response headers.
+             */
+            headers?: Record<string, string>;
+        };
+        /**
+  Warnings from the model provider (e.g. unsupported settings).
+         */
+        warnings?: CallWarning[];
+    }) => Promise<void> | void;
 }): Promise<StreamTextResult<TOOLS>>;
 type TextStreamPart<TOOLS extends Record<string, CoreTool>> = {
     type: 'text-delta';
@@ -960,12 +1002,13 @@ A result object for accessing different stream types and additional information.
  */
 declare class StreamTextResult<TOOLS extends Record<string, CoreTool>> {
     private originalStream;
+    private onFinish?;
     /**
   Warnings from the model provider (e.g. unsupported settings).
      */
     readonly warnings: CallWarning[] | undefined;
     /**
-  The token usage of the generated text. Resolved when the response is finished.
+  The token usage of the generated response. Resolved when the response is finished.
      */
     readonly usage: Promise<TokenUsage>;
     /**
@@ -973,20 +1016,33 @@ declare class StreamTextResult<TOOLS extends Record<string, CoreTool>> {
      */
     readonly finishReason: Promise<FinishReason>;
     /**
+  The full text that has been generated. Resolved when the response is finished.
+     */
+    readonly text: Promise<string>;
+    /**
+  The tool calls that have been executed. Resolved when the response is finished.
+     */
+    readonly toolCalls: Promise<ToToolCall<TOOLS>[]>;
+    /**
+  The tool results that have been generated. Resolved when the all tool executions are finished.
+     */
+    readonly toolResults: Promise<ToToolResult<TOOLS>[]>;
+    /**
   Optional raw response data.
      */
-    rawResponse?: {
+    readonly rawResponse?: {
         /**
     Response headers.
          */
         headers?: Record<string, string>;
     };
-    constructor({ stream, warnings, rawResponse, }: {
+    constructor({ stream, warnings, rawResponse, onFinish, }: {
         stream: ReadableStream<TextStreamPart<TOOLS>>;
         warnings: CallWarning[] | undefined;
         rawResponse?: {
             headers?: Record<string, string>;
         };
+        onFinish?: Parameters<typeof streamText>[0]['onFinish'];
     });
     /**
   Split out a new stream from the original stream.

package/dist/index.d.ts

@@ -922,10 +922,13 @@ If set and supported by the model, calls will generate deterministic results.
 @param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
 @param abortSignal - An optional abort signal that can be used to cancel the call.
 
+@param onFinish - Callback that is called when the LLM response and all request tool executions
+(for tools that have an `execute` function) are finished.
+
 @return
 A result object for accessing different stream types and additional information.
  */
-declare function streamText<TOOLS extends Record<string, CoreTool>>({ model, tools, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
+declare function streamText<TOOLS extends Record<string, CoreTool>>({ model, tools, system, prompt, messages, maxRetries, abortSignal, onFinish, ...settings }: CallSettings & Prompt & {
     /**
 The language model to use.
      */
@@ -934,6 +937,45 @@ The language model to use.
 The tools that the model can call. The model needs to support calling tools.
     */
     tools?: TOOLS;
+    /**
+Callback that is called when the LLM response and all request tool executions
+(for tools that have an `execute` function) are finished.
+     */
+    onFinish?: (event: {
+        /**
+  The reason why the generation finished.
+         */
+        finishReason: FinishReason;
+        /**
+  The token usage of the generated response.
+   */
+        usage: TokenUsage;
+        /**
+  The full text that has been generated.
+         */
+        text: string;
+        /**
+  The tool calls that have been executed.
+         */
+        toolCalls?: ToToolCall<TOOLS>[];
+        /**
+  The tool results that have been generated.
+         */
+        toolResults?: ToToolResult<TOOLS>[];
+        /**
+  Optional raw response data.
+         */
+        rawResponse?: {
+            /**
+    Response headers.
+             */
+            headers?: Record<string, string>;
+        };
+        /**
+  Warnings from the model provider (e.g. unsupported settings).
+         */
+        warnings?: CallWarning[];
+    }) => Promise<void> | void;
 }): Promise<StreamTextResult<TOOLS>>;
 type TextStreamPart<TOOLS extends Record<string, CoreTool>> = {
     type: 'text-delta';
@@ -960,12 +1002,13 @@ A result object for accessing different stream types and additional information.
  */
 declare class StreamTextResult<TOOLS extends Record<string, CoreTool>> {
     private originalStream;
+    private onFinish?;
     /**
   Warnings from the model provider (e.g. unsupported settings).
      */
     readonly warnings: CallWarning[] | undefined;
     /**
-  The token usage of the generated text. Resolved when the response is finished.
+  The token usage of the generated response. Resolved when the response is finished.
      */
     readonly usage: Promise<TokenUsage>;
     /**
@@ -973,20 +1016,33 @@ declare class StreamTextResult<TOOLS extends Record<string, CoreTool>> {
      */
     readonly finishReason: Promise<FinishReason>;
     /**
+  The full text that has been generated. Resolved when the response is finished.
+     */
+    readonly text: Promise<string>;
+    /**
+  The tool calls that have been executed. Resolved when the response is finished.
+     */
+    readonly toolCalls: Promise<ToToolCall<TOOLS>[]>;
+    /**
+  The tool results that have been generated. Resolved when the all tool executions are finished.
+     */
+    readonly toolResults: Promise<ToToolResult<TOOLS>[]>;
+    /**
   Optional raw response data.
      */
-    rawResponse?: {
+    readonly rawResponse?: {
         /**
     Response headers.
          */
         headers?: Record<string, string>;
     };
-    constructor({ stream, warnings, rawResponse, }: {
+    constructor({ stream, warnings, rawResponse, onFinish, }: {
         stream: ReadableStream<TextStreamPart<TOOLS>>;
         warnings: CallWarning[] | undefined;
         rawResponse?: {
             headers?: Record<string, string>;
         };
+        onFinish?: Parameters<typeof streamText>[0]['onFinish'];
     });
     /**
   Split out a new stream from the original stream.

package/dist/index.js

@@ -1543,6 +1543,7 @@ async function streamText({
   messages,
   maxRetries,
   abortSignal,
+  onFinish,
   ...settings
 }) {
   const retry = retryWithExponentialBackoff({ maxRetries });
@@ -1570,17 +1571,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;
@@ -1589,13 +1593,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);
           }
         }
       })