ai 3.1.9 → 3.1.11

package/dist/index.mjs

@@ -94,6 +94,53 @@ var EmbedResult = class {
   }
 };
 
+// core/util/split-array.ts
+function splitArray(array, chunkSize) {
+  if (chunkSize <= 0) {
+    throw new Error("chunkSize must be greater than 0");
+  }
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+}
+
+// core/embed/embed-many.ts
+async function embedMany({
+  model,
+  values,
+  maxRetries,
+  abortSignal
+}) {
+  const retry = retryWithExponentialBackoff({ maxRetries });
+  const maxEmbeddingsPerCall = model.maxEmbeddingsPerCall;
+  if (maxEmbeddingsPerCall == null) {
+    const modelResponse = await retry(
+      () => model.doEmbed({ values, abortSignal })
+    );
+    return new EmbedManyResult({
+      values,
+      embeddings: modelResponse.embeddings
+    });
+  }
+  const valueChunks = splitArray(values, maxEmbeddingsPerCall);
+  const embeddings = [];
+  for (const chunk of valueChunks) {
+    const modelResponse = await retry(
+      () => model.doEmbed({ values: chunk, abortSignal })
+    );
+    embeddings.push(...modelResponse.embeddings);
+  }
+  return new EmbedManyResult({ values, embeddings });
+}
+var EmbedManyResult = class {
+  constructor(options) {
+    this.values = options.values;
+    this.embeddings = options.embeddings;
+  }
+};
+
 // core/generate-object/generate-object.ts
 import { NoObjectGeneratedError } from "@ai-sdk/provider";
 import { safeParseJSON } from "@ai-sdk/provider-utils";
@@ -1593,7 +1640,7 @@ var StreamTextResult = class {
       "Content-Type": "text/plain; charset=utf-8",
       ...init == null ? void 0 : init.headers
     });
-    const reader = this.textStream.pipeThrough(createCallbacksTransformer(void 0)).pipeThrough(createStreamDataTransformer()).getReader();
+    const reader = this.toAIStream().getReader();
     const read = async () => {
       try {
         while (true) {
@@ -1624,15 +1671,14 @@ var StreamTextResult = class {
       "Content-Type": "text/plain; charset=utf-8",
       ...init == null ? void 0 : init.headers
     });
-    const reader = this.textStream.getReader();
+    const reader = this.textStream.pipeThrough(new TextEncoderStream()).getReader();
     const read = async () => {
-      const encoder = new TextEncoder();
       try {
         while (true) {
           const { done, value } = await reader.read();
           if (done)
             break;
-          response.write(encoder.encode(value));
+          response.write(value);
         }
       } catch (error) {
         throw error;
@@ -1662,23 +1708,13 @@ var StreamTextResult = class {
      */
   toTextStreamResponse(init) {
     var _a;
-    const encoder = new TextEncoder();
-    return new Response(
-      this.textStream.pipeThrough(
-        new TransformStream({
-          transform(chunk, controller) {
-            controller.enqueue(encoder.encode(chunk));
-          }
-        })
-      ),
-      {
-        status: (_a = init == null ? void 0 : init.status) != null ? _a : 200,
-        headers: {
-          "Content-Type": "text/plain; charset=utf-8",
-          ...init == null ? void 0 : init.headers
-        }
+    return new Response(this.textStream.pipeThrough(new TextEncoderStream()), {
+      status: (_a = init == null ? void 0 : init.status) != null ? _a : 200,
+      headers: {
+        "Content-Type": "text/plain; charset=utf-8",
+        ...init == null ? void 0 : init.headers
       }
-    );
+    });
   }
 };
 var experimental_streamText = streamText;
@@ -2162,86 +2198,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() {
@@ -3015,6 +3026,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)
@@ -3169,7 +3268,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(),
@@ -3207,7 +3306,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,
@@ -3248,6 +3347,7 @@ export {
   AnthropicStream,
   AssistantResponse,
   CohereStream,
+  EmbedManyResult,
   EmbedResult,
   EmptyResponseBodyError,
   GenerateObjectResult,
@@ -3286,6 +3386,7 @@ export {
   createEventStreamTransformer,
   createStreamDataTransformer,
   embed,
+  embedMany,
   experimental_AssistantResponse,
   experimental_StreamData,
   experimental_StreamingReactResponse,