ai 3.1.14 → 3.1.16

package/dist/index.mjs

@@ -1168,6 +1168,33 @@ var StreamObjectResult = class {
 };
 var experimental_streamObject = streamObject;
 
+// core/util/is-non-empty-object.ts
+function isNonEmptyObject(object) {
+  return object != null && Object.keys(object).length > 0;
+}
+
+// core/prompt/prepare-tools-and-tool-choice.ts
+function prepareToolsAndToolChoice({
+  tools,
+  toolChoice
+}) {
+  if (!isNonEmptyObject(tools)) {
+    return {
+      tools: void 0,
+      toolChoice: void 0
+    };
+  }
+  return {
+    tools: Object.entries(tools).map(([name, tool2]) => ({
+      type: "function",
+      name,
+      description: tool2.description,
+      parameters: convertZodToJSONSchema(tool2.parameters)
+    })),
+    toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
+  };
+}
+
 // core/generate-text/tool-call.ts
 import {
   InvalidToolArgumentsError,
@@ -1212,6 +1239,7 @@ function parseToolCall({
 async function generateText({
   model,
   tools,
+  toolChoice,
   system,
   prompt,
   messages,
@@ -1226,12 +1254,7 @@ async function generateText({
     return model.doGenerate({
       mode: {
         type: "regular",
-        tools: tools == null ? void 0 : Object.entries(tools).map(([name, tool2]) => ({
-          type: "function",
-          name,
-          description: tool2.description,
-          parameters: convertZodToJSONSchema(tool2.parameters)
-        }))
+        ...prepareToolsAndToolChoice({ tools, toolChoice })
       },
       ...prepareCallSettings(settings),
       inputFormat: validatedPrompt.type,
@@ -1444,11 +1467,13 @@ function runToolsTransformation({
 async function streamText({
   model,
   tools,
+  toolChoice,
   system,
   prompt,
   messages,
   maxRetries,
   abortSignal,
+  onFinish,
   ...settings
 }) {
   const retry = retryWithExponentialBackoff({ maxRetries });
@@ -1457,12 +1482,7 @@ async function streamText({
     () => model.doStream({
       mode: {
         type: "regular",
-        tools: tools == null ? void 0 : Object.entries(tools).map(([name, tool2]) => ({
-          type: "function",
-          name,
-          description: tool2.description,
-          parameters: convertZodToJSONSchema(tool2.parameters)
-        }))
+        ...prepareToolsAndToolChoice({ tools, toolChoice })
       },
       ...prepareCallSettings(settings),
       inputFormat: validatedPrompt.type,
@@ -1476,17 +1496,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 +1518,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);
           }
         }
       })