ai 4.0.26 → 4.0.28

package/dist/index.mjs

@@ -225,7 +225,7 @@ import { getErrorMessage, isAbortError } from "@ai-sdk/provider-utils";
 
 // util/delay.ts
 async function delay(delayInMs) {
-  return delayInMs === void 0 ? Promise.resolve() : new Promise((resolve) => setTimeout(resolve, delayInMs));
+  return delayInMs == null ? Promise.resolve() : new Promise((resolve) => setTimeout(resolve, delayInMs));
 }
 
 // util/retry-error.ts
@@ -803,43 +803,70 @@ var DefaultEmbedManyResult = class {
 };
 
 // core/generate-image/generate-image.ts
-import { convertBase64ToUint8Array } from "@ai-sdk/provider-utils";
+import {
+  convertBase64ToUint8Array,
+  convertUint8ArrayToBase64
+} from "@ai-sdk/provider-utils";
 async function generateImage({
   model,
   prompt,
   n,
   size,
+  aspectRatio,
+  seed,
   providerOptions,
   maxRetries: maxRetriesArg,
   abortSignal,
   headers
 }) {
   const { retry } = prepareRetries({ maxRetries: maxRetriesArg });
-  const { images } = await retry(
-    () => model.doGenerate({
-      prompt,
-      n: n != null ? n : 1,
-      abortSignal,
-      headers,
-      size,
-      providerOptions: providerOptions != null ? providerOptions : {}
-    })
+  return new DefaultGenerateImageResult(
+    await retry(
+      () => model.doGenerate({
+        prompt,
+        n: n != null ? n : 1,
+        abortSignal,
+        headers,
+        size,
+        aspectRatio,
+        seed,
+        providerOptions: providerOptions != null ? providerOptions : {}
+      })
+    )
   );
-  return new DefaultGenerateImageResult({ base64Images: images });
 }
 var DefaultGenerateImageResult = class {
   constructor(options) {
-    this.images = options.base64Images.map((base64) => ({
-      base64,
-      get uint8Array() {
-        return convertBase64ToUint8Array(this.base64);
-      }
-    }));
+    this.images = options.images.map(
+      (image) => new DefaultGeneratedImage({ imageData: image })
+    );
+    this.warnings = options.warnings;
   }
   get image() {
     return this.images[0];
   }
 };
+var DefaultGeneratedImage = class {
+  constructor({ imageData }) {
+    const isUint8Array = imageData instanceof Uint8Array;
+    this.base64Data = isUint8Array ? void 0 : imageData;
+    this.uint8ArrayData = isUint8Array ? imageData : void 0;
+  }
+  // lazy conversion with caching to avoid unnecessary conversion overhead:
+  get base64() {
+    if (this.base64Data == null) {
+      this.base64Data = convertUint8ArrayToBase64(this.uint8ArrayData);
+    }
+    return this.base64Data;
+  }
+  // lazy conversion with caching to avoid unnecessary conversion overhead:
+  get uint8Array() {
+    if (this.uint8ArrayData == null) {
+      this.uint8ArrayData = convertBase64ToUint8Array(this.base64Data);
+    }
+    return this.uint8ArrayData;
+  }
+};
 
 // core/generate-object/generate-object.ts
 import { createIdGenerator, safeParseJSON } from "@ai-sdk/provider-utils";
@@ -943,7 +970,7 @@ function detectImageMimeType(image) {
 // core/prompt/data-content.ts
 import {
   convertBase64ToUint8Array as convertBase64ToUint8Array2,
-  convertUint8ArrayToBase64
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase642
 } from "@ai-sdk/provider-utils";
 
 // core/prompt/invalid-data-content-error.ts
@@ -988,9 +1015,9 @@ function convertDataContentToBase64String(content) {
     return content;
   }
   if (content instanceof ArrayBuffer) {
-    return convertUint8ArrayToBase64(new Uint8Array(content));
+    return convertUint8ArrayToBase642(new Uint8Array(content));
   }
-  return convertUint8ArrayToBase64(content);
+  return convertUint8ArrayToBase642(content);
 }
 function convertDataContentToUint8Array(content) {
   if (content instanceof Uint8Array) {
@@ -5309,38 +5336,50 @@ var DefaultStreamTextResult = class {
 };
 
 // core/generate-text/smooth-stream.ts
+import { InvalidArgumentError as InvalidArgumentError2 } from "@ai-sdk/provider";
+var CHUNKING_REGEXPS = {
+  word: /\s*\S+\s+/m,
+  line: /[^\n]*\n/m
+};
 function smoothStream({
   delayInMs = 10,
   chunking = "word",
   _internal: { delay: delay2 = delay } = {}
 } = {}) {
-  let buffer = "";
-  return () => new TransformStream({
-    async transform(chunk, controller) {
-      if (chunk.type === "step-finish") {
-        if (buffer.length > 0) {
-          controller.enqueue({ type: "text-delta", textDelta: buffer });
-          buffer = "";
+  const chunkingRegexp = typeof chunking === "string" ? CHUNKING_REGEXPS[chunking] : chunking;
+  if (chunkingRegexp == null) {
+    throw new InvalidArgumentError2({
+      argument: "chunking",
+      message: `Chunking must be "word" or "line" or a RegExp. Received: ${chunking}`
+    });
+  }
+  return () => {
+    let buffer = "";
+    return new TransformStream({
+      async transform(chunk, controller) {
+        if (chunk.type === "step-finish") {
+          if (buffer.length > 0) {
+            controller.enqueue({ type: "text-delta", textDelta: buffer });
+            buffer = "";
+          }
+          controller.enqueue(chunk);
+          return;
         }
-        controller.enqueue(chunk);
-        return;
-      }
-      if (chunk.type !== "text-delta") {
-        controller.enqueue(chunk);
-        return;
-      }
-      buffer += chunk.textDelta;
-      const regexp = chunking === "line" ? /[^\n]*\n/m : /\s*\S+\s+/m;
-      while (regexp.test(buffer)) {
-        const chunk2 = buffer.match(regexp)[0];
-        controller.enqueue({ type: "text-delta", textDelta: chunk2 });
-        buffer = buffer.slice(chunk2.length);
-        if (delayInMs > 0) {
+        if (chunk.type !== "text-delta") {
+          controller.enqueue(chunk);
+          return;
+        }
+        buffer += chunk.textDelta;
+        let match;
+        while ((match = chunkingRegexp.exec(buffer)) != null) {
+          const chunk2 = match[0];
+          controller.enqueue({ type: "text-delta", textDelta: chunk2 });
+          buffer = buffer.slice(chunk2.length);
           await delay2(delayInMs);
         }
       }
-    }
-  });
+    });
+  };
 }
 
 // core/middleware/wrap-language-model.ts
@@ -5524,6 +5563,28 @@ function magnitude(vector) {
   return Math.sqrt(dotProduct(vector, vector));
 }
 
+// core/util/simulate-readable-stream.ts
+function simulateReadableStream({
+  chunks,
+  initialDelayInMs = 0,
+  chunkDelayInMs = 0,
+  _internal
+}) {
+  var _a14;
+  const delay2 = (_a14 = _internal == null ? void 0 : _internal.delay) != null ? _a14 : delay;
+  let index = 0;
+  return new ReadableStream({
+    async pull(controller) {
+      if (index < chunks.length) {
+        await delay2(index === 0 ? initialDelayInMs : chunkDelayInMs);
+        controller.enqueue(chunks[index++]);
+      } else {
+        controller.close();
+      }
+    }
+  });
+}
+
 // streams/assistant-response.ts
 import {
   formatAssistantStreamPart
@@ -5909,6 +5970,7 @@ export {
   pipeDataStreamToResponse,
   processDataStream,
   processTextStream,
+  simulateReadableStream,
   smoothStream,
   streamObject,
   streamText,