ai 3.1.10 → 3.1.11

package/dist/index.d.mts

@@ -2197,12 +2197,9 @@ declare function ReplicateStream(res: Prediction, cb?: AIStreamCallbacksAndOptio
 declare class StreamData {
     private encoder;
     private controller;
-    stream: TransformStream<Uint8Array, Uint8Array>;
-    private isClosedPromise;
-    private isClosedPromiseResolver;
+    stream: ReadableStream<Uint8Array>;
     private isClosed;
-    private data;
-    private messageAnnotations;
+    private warningTimeout;
     constructor();
     close(): Promise<void>;
     append(value: JSONValue): void;

package/dist/index.d.ts

@@ -2197,12 +2197,9 @@ declare function ReplicateStream(res: Prediction, cb?: AIStreamCallbacksAndOptio
 declare class StreamData {
     private encoder;
     private controller;
-    stream: TransformStream<Uint8Array, Uint8Array>;
-    private isClosedPromise;
-    private isClosedPromiseResolver;
+    stream: ReadableStream<Uint8Array>;
     private isClosed;
-    private data;
-    private messageAnnotations;
+    private warningTimeout;
     constructor();
     close(): Promise<void>;
     append(value: JSONValue): void;

package/dist/index.js

@@ -2273,86 +2273,61 @@ var StreamData = class {
   constructor() {
     this.encoder = new TextEncoder();
     this.controller = null;
-    // closing the stream is synchronous, but we want to return a promise
-    // in case we're doing async work
-    this.isClosedPromise = null;
-    this.isClosedPromiseResolver = void 0;
     this.isClosed = false;
-    // array to store appended data
-    this.data = [];
-    this.messageAnnotations = [];
-    this.isClosedPromise = new Promise((resolve) => {
-      this.isClosedPromiseResolver = resolve;
-    });
+    this.warningTimeout = null;
     const self = this;
-    this.stream = new TransformStream({
+    this.stream = new ReadableStream({
       start: async (controller) => {
         self.controller = controller;
-      },
-      transform: async (chunk, controller) => {
-        if (self.data.length > 0) {
-          const encodedData = self.encoder.encode(
-            formatStreamPart("data", self.data)
-          );
-          self.data = [];
-          controller.enqueue(encodedData);
-        }
-        if (self.messageAnnotations.length) {
-          const encodedMessageAnnotations = self.encoder.encode(
-            formatStreamPart("message_annotations", self.messageAnnotations)
-          );
-          self.messageAnnotations = [];
-          controller.enqueue(encodedMessageAnnotations);
+        if (process.env.NODE_ENV === "development") {
+          self.warningTimeout = setTimeout(() => {
+            console.warn(
+              "The data stream is hanging. Did you forget to close it with `data.close()`?"
+            );
+          }, 3e3);
         }
-        controller.enqueue(chunk);
       },
-      async flush(controller) {
-        const warningTimeout = process.env.NODE_ENV === "development" ? setTimeout(() => {
-          console.warn(
-            "The data stream is hanging. Did you forget to close it with `data.close()`?"
-          );
-        }, 3e3) : null;
-        await self.isClosedPromise;
-        if (warningTimeout !== null) {
-          clearTimeout(warningTimeout);
-        }
-        if (self.data.length) {
-          const encodedData = self.encoder.encode(
-            formatStreamPart("data", self.data)
-          );
-          controller.enqueue(encodedData);
-        }
-        if (self.messageAnnotations.length) {
-          const encodedData = self.encoder.encode(
-            formatStreamPart("message_annotations", self.messageAnnotations)
-          );
-          controller.enqueue(encodedData);
-        }
+      pull: (controller) => {
+      },
+      cancel: (reason) => {
+        this.isClosed = true;
       }
     });
   }
   async close() {
-    var _a;
     if (this.isClosed) {
       throw new Error("Data Stream has already been closed.");
     }
     if (!this.controller) {
       throw new Error("Stream controller is not initialized.");
     }
-    (_a = this.isClosedPromiseResolver) == null ? void 0 : _a.call(this);
+    this.controller.close();
     this.isClosed = true;
+    if (this.warningTimeout) {
+      clearTimeout(this.warningTimeout);
+    }
   }
   append(value) {
     if (this.isClosed) {
       throw new Error("Data Stream has already been closed.");
     }
-    this.data.push(value);
+    if (!this.controller) {
+      throw new Error("Stream controller is not initialized.");
+    }
+    this.controller.enqueue(
+      this.encoder.encode(formatStreamPart("data", [value]))
+    );
   }
   appendMessageAnnotation(value) {
     if (this.isClosed) {
       throw new Error("Data Stream has already been closed.");
     }
-    this.messageAnnotations.push(value);
+    if (!this.controller) {
+      throw new Error("Stream controller is not initialized.");
+    }
+    this.controller.enqueue(
+      this.encoder.encode(formatStreamPart("message_annotations", [value]))
+    );
   }
 };
 function createStreamDataTransformer() {
@@ -3126,6 +3101,94 @@ async function ReplicateStream(res, cb, options) {
   );
 }
 
+// core/util/merge-streams.ts
+function mergeStreams(stream1, stream2) {
+  const reader1 = stream1.getReader();
+  const reader2 = stream2.getReader();
+  let lastRead1 = void 0;
+  let lastRead2 = void 0;
+  let stream1Done = false;
+  let stream2Done = false;
+  async function readStream1(controller) {
+    try {
+      if (lastRead1 == null) {
+        lastRead1 = reader1.read();
+      }
+      const result = await lastRead1;
+      lastRead1 = void 0;
+      if (!result.done) {
+        controller.enqueue(result.value);
+      } else {
+        controller.close();
+      }
+    } catch (error) {
+      controller.error(error);
+    }
+  }
+  async function readStream2(controller) {
+    try {
+      if (lastRead2 == null) {
+        lastRead2 = reader2.read();
+      }
+      const result = await lastRead2;
+      lastRead2 = void 0;
+      if (!result.done) {
+        controller.enqueue(result.value);
+      } else {
+        controller.close();
+      }
+    } catch (error) {
+      controller.error(error);
+    }
+  }
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        if (stream1Done) {
+          readStream2(controller);
+          return;
+        }
+        if (stream2Done) {
+          readStream1(controller);
+          return;
+        }
+        if (lastRead1 == null) {
+          lastRead1 = reader1.read();
+        }
+        if (lastRead2 == null) {
+          lastRead2 = reader2.read();
+        }
+        const { result, reader } = await Promise.race([
+          lastRead1.then((result2) => ({ result: result2, reader: reader1 })),
+          lastRead2.then((result2) => ({ result: result2, reader: reader2 }))
+        ]);
+        if (!result.done) {
+          controller.enqueue(result.value);
+        }
+        if (reader === reader1) {
+          lastRead1 = void 0;
+          if (result.done) {
+            readStream2(controller);
+            stream1Done = true;
+          }
+        } else {
+          lastRead2 = void 0;
+          if (result.done) {
+            stream2Done = true;
+            readStream1(controller);
+          }
+        }
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    cancel() {
+      reader1.cancel();
+      reader2.cancel();
+    }
+  });
+}
+
 // shared/parse-complex-response.ts
 function assignAnnotationsToMessage(message, annotations) {
   if (!message || !annotations || !annotations.length)
@@ -3280,7 +3343,7 @@ var experimental_StreamingReactResponse = class {
     let next = new Promise((resolve) => {
       resolveFunc = resolve;
     });
-    const processedStream = (options == null ? void 0 : options.data) != null ? res.pipeThrough((_a = options == null ? void 0 : options.data) == null ? void 0 : _a.stream) : res;
+    const processedStream = (options == null ? void 0 : options.data) != null ? mergeStreams((_a = options == null ? void 0 : options.data) == null ? void 0 : _a.stream, res) : res;
     let lastPayload = void 0;
     parseComplexResponse({
       reader: processedStream.getReader(),
@@ -3318,7 +3381,7 @@ var StreamingTextResponse = class extends Response {
   constructor(res, init, data) {
     let processedStream = res;
     if (data) {
-      processedStream = res.pipeThrough(data.stream);
+      processedStream = mergeStreams(data.stream, res);
     }
     super(processedStream, {
       ...init,