ai 4.0.27 → 4.0.29

package/dist/index.mjs

@@ -803,43 +803,89 @@ 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,
+  n = 1,
   size,
+  aspectRatio,
+  seed,
   providerOptions,
   maxRetries: maxRetriesArg,
   abortSignal,
   headers
 }) {
+  var _a14;
   const { retry } = prepareRetries({ maxRetries: maxRetriesArg });
-  const { images } = await retry(
-    () => model.doGenerate({
-      prompt,
-      n: n != null ? n : 1,
-      abortSignal,
-      headers,
-      size,
-      providerOptions: providerOptions != null ? providerOptions : {}
-    })
+  const maxImagesPerCall = (_a14 = model.maxImagesPerCall) != null ? _a14 : 1;
+  const callCount = Math.ceil(n / maxImagesPerCall);
+  const callImageCounts = Array.from({ length: callCount }, (_, i) => {
+    if (i < callCount - 1) {
+      return maxImagesPerCall;
+    }
+    const remainder = n % maxImagesPerCall;
+    return remainder === 0 ? maxImagesPerCall : remainder;
+  });
+  const results = await Promise.all(
+    callImageCounts.map(
+      async (callImageCount) => retry(
+        () => model.doGenerate({
+          prompt,
+          n: callImageCount,
+          abortSignal,
+          headers,
+          size,
+          aspectRatio,
+          seed,
+          providerOptions: providerOptions != null ? providerOptions : {}
+        })
+      )
+    )
   );
-  return new DefaultGenerateImageResult({ base64Images: images });
+  const images = [];
+  const warnings = [];
+  for (const result of results) {
+    images.push(
+      ...result.images.map((image) => new DefaultGeneratedImage({ image }))
+    );
+    warnings.push(...result.warnings);
+  }
+  return new DefaultGenerateImageResult({ images, warnings });
 }
 var DefaultGenerateImageResult = class {
   constructor(options) {
-    this.images = options.base64Images.map((base64) => ({
-      base64,
-      get uint8Array() {
-        return convertBase64ToUint8Array(this.base64);
-      }
-    }));
+    this.images = options.images;
+    this.warnings = options.warnings;
   }
   get image() {
     return this.images[0];
   }
 };
+var DefaultGeneratedImage = class {
+  constructor({ image }) {
+    const isUint8Array = image instanceof Uint8Array;
+    this.base64Data = isUint8Array ? void 0 : image;
+    this.uint8ArrayData = isUint8Array ? image : 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 +989,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 +1034,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) {