ai 3.2.27 → 3.2.28

package/dist/index.mjs

@@ -748,6 +748,44 @@ function createAsyncIterableStream(source, transformer) {
   return transformedStream;
 }
 
+// core/util/delayed-promise.ts
+var DelayedPromise = class {
+  constructor() {
+    this.status = { type: "pending" };
+    this._resolve = void 0;
+    this._reject = void 0;
+  }
+  get value() {
+    if (this.promise) {
+      return this.promise;
+    }
+    this.promise = new Promise((resolve, reject) => {
+      if (this.status.type === "resolved") {
+        resolve(this.status.value);
+      } else if (this.status.type === "rejected") {
+        reject(this.status.error);
+      }
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+    return this.promise;
+  }
+  resolve(value) {
+    var _a;
+    this.status = { type: "resolved", value };
+    if (this.promise) {
+      (_a = this._resolve) == null ? void 0 : _a.call(this, value);
+    }
+  }
+  reject(error) {
+    var _a;
+    this.status = { type: "rejected", error };
+    if (this.promise) {
+      (_a = this._reject) == null ? void 0 : _a.call(this, error);
+    }
+  }
+};
+
 // core/generate-object/stream-object.ts
 async function streamObject({
   model,
@@ -892,12 +930,7 @@ var StreamObjectResult = class {
   }) {
     this.warnings = warnings;
     this.rawResponse = rawResponse;
-    let resolveObject;
-    let rejectObject;
-    this.object = new Promise((resolve, reject) => {
-      resolveObject = resolve;
-      rejectObject = reject;
-    });
+    this.objectPromise = new DelayedPromise();
     let resolveUsage;
     this.usage = new Promise((resolve) => {
       resolveUsage = resolve;
@@ -908,6 +941,7 @@ var StreamObjectResult = class {
     let accumulatedText = "";
     let delta = "";
     let latestObject = void 0;
+    const self = this;
     this.originalStream = stream.pipeThrough(
       new TransformStream({
         async transform(chunk, controller) {
@@ -948,10 +982,10 @@ var StreamObjectResult = class {
               });
               if (validationResult.success) {
                 object = validationResult.value;
-                resolveObject(object);
+                self.objectPromise.resolve(object);
               } else {
                 error = validationResult.error;
-                rejectObject(error);
+                self.objectPromise.reject(error);
               }
               break;
             }
@@ -983,6 +1017,12 @@ var StreamObjectResult = class {
     );
   }
   /**
+  The generated object (typed according to the schema). Resolved when the response is finished.
+     */
+  get object() {
+    return this.objectPromise.value;
+  }
+  /**
   Stream of partial objects. It gets more complete as the stream progresses.
     
   Note that the partial object is not validated. 
@@ -1553,6 +1593,7 @@ import { generateId } from "@ai-sdk/ui-utils";
 function runToolsTransformation({
   tools,
   generatorStream,
+  toolCallStreaming,
   tracer
 }) {
   let canClose = false;
@@ -1563,6 +1604,7 @@ function runToolsTransformation({
       toolResultsStreamController = controller;
     }
   });
+  const activeToolCalls = {};
   const forwardStream = new TransformStream({
     transform(chunk, controller) {
       const chunkType = chunk.type;
@@ -1572,6 +1614,25 @@ function runToolsTransformation({
           controller.enqueue(chunk);
           break;
         }
+        case "tool-call-delta": {
+          if (toolCallStreaming) {
+            if (!activeToolCalls[chunk.toolCallId]) {
+              controller.enqueue({
+                type: "tool-call-streaming-start",
+                toolCallId: chunk.toolCallId,
+                toolName: chunk.toolName
+              });
+              activeToolCalls[chunk.toolCallId] = true;
+            }
+            controller.enqueue({
+              type: "tool-call-delta",
+              toolCallId: chunk.toolCallId,
+              toolName: chunk.toolName,
+              argsTextDelta: chunk.argsTextDelta
+            });
+          }
+          break;
+        }
         case "tool-call": {
           const toolName = chunk.toolName;
           if (tools == null) {
@@ -1657,9 +1718,6 @@ function runToolsTransformation({
           });
           break;
         }
-        case "tool-call-delta": {
-          break;
-        }
         default: {
           const _exhaustiveCheck = chunkType;
           throw new Error(`Unhandled chunk type: ${_exhaustiveCheck}`);
@@ -1712,6 +1770,7 @@ async function streamText({
   abortSignal,
   headers,
   experimental_telemetry: telemetry,
+  experimental_toolCallStreaming: toolCallStreaming = false,
   onFinish,
   ...settings
 }) {
@@ -1772,6 +1831,7 @@ async function streamText({
         stream: runToolsTransformation({
           tools,
           generatorStream: stream,
+          toolCallStreaming,
           tracer
         }),
         warnings,
@@ -1849,6 +1909,8 @@ var StreamTextResult = class {
               resolveText(text);
               resolveToolCalls(toolCalls);
               break;
+            case "tool-call-streaming-start":
+            case "tool-call-delta":
             case "error":
               break;
             default: {
@@ -1992,10 +2054,27 @@ var StreamTextResult = class {
     });
     const streamDataTransformer = new TransformStream({
       transform: async (chunk, controller) => {
-        switch (chunk.type) {
+        const chunkType = chunk.type;
+        switch (chunkType) {
           case "text-delta":
             controller.enqueue(formatStreamPart("text", chunk.textDelta));
             break;
+          case "tool-call-streaming-start":
+            controller.enqueue(
+              formatStreamPart("tool_call_streaming_start", {
+                toolCallId: chunk.toolCallId,
+                toolName: chunk.toolName
+              })
+            );
+            break;
+          case "tool-call-delta":
+            controller.enqueue(
+              formatStreamPart("tool_call_delta", {
+                toolCallId: chunk.toolCallId,
+                argsTextDelta: chunk.argsTextDelta
+              })
+            );
+            break;
           case "tool-call":
             controller.enqueue(
               formatStreamPart("tool_call", {
@@ -2020,6 +2099,12 @@ var StreamTextResult = class {
               formatStreamPart("error", JSON.stringify(chunk.error))
             );
             break;
+          case "finish":
+            break;
+          default: {
+            const exhaustiveCheck = chunkType;
+            throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
+          }
         }
       }
     });
@@ -2182,6 +2267,13 @@ function convertToCoreMessages(messages) {
     experimental_attachments
   } of messages) {
     switch (role) {
+      case "system": {
+        coreMessages.push({
+          role: "system",
+          content
+        });
+        break;
+      }
       case "user": {
         coreMessages.push({
           role: "user",