ai 6.0.279 → 6.0.280

package/src/generate-image/generate-image.ts

@@ -26,11 +26,21 @@ import {
   imageMediaTypeSignatures,
 } from '../util/detect-media-type';
 import { prepareRetries } from '../util/prepare-retries';
+import { RetryError } from '../util/retry-error';
 import { VERSION } from '../version';
 import type { GenerateImageResult } from './generate-image-result';
 import { convertDataContentToUint8Array } from '../prompt/data-content';
 import { splitDataUrl } from '../prompt/split-data-url';
 
+class RetryableNoImageResultError extends Error {
+  constructor() {
+    super('No image generated.');
+    this.name = 'RetryableNoImageResultError';
+  }
+}
+
+type ImageModelV3Result = Awaited<ReturnType<ImageModelV3['doGenerate']>>;
+
 export type GenerateImagePrompt =
   | string
   | {
@@ -51,7 +61,7 @@ export type GenerateImagePrompt =
  * @param seed - Seed for the image generation.
  * @param providerOptions - Additional provider-specific options that are passed through to the provider
  * as body parameters.
- * @param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+ * @param maxRetries - Maximum number of retries per image model call, including retries after unclassified empty responses. Empty responses marked as not retryable by the provider are not retried. Set to 0 to disable retries. Default: 2.
  * @param abortSignal - An optional abort signal that can be used to cancel the call.
  * @param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
  *
@@ -122,7 +132,9 @@ export async function generateImage({
   providerOptions?: ProviderOptions;
 
   /**
-   * Maximum number of retries per image model call. Set to 0 to disable retries.
+   * Maximum number of retries per image model call, including retries after
+   * unclassified empty responses. Empty responses marked as not retryable by
+   * the provider are not retried. Set to 0 to disable retries.
    *
    * @default 2
    */
@@ -149,6 +161,8 @@ export async function generateImage({
   const { retry } = prepareRetries({
     maxRetries: maxRetriesArg,
     abortSignal,
+    additionalRetryableError: error =>
+      error instanceof RetryableNoImageResultError,
   });
 
   // default to 1 if the model has not specified limits on
@@ -167,26 +181,55 @@ export async function generateImage({
     return remainder === 0 ? maxImagesPerCallWithDefault : remainder;
   });
 
-  const results = await Promise.all(
-    callImageCounts.map(async callImageCount =>
-      retry(() => {
-        const { prompt, files, mask } = normalizePrompt(promptArg);
-
-        return model.doGenerate({
-          prompt,
-          files,
-          mask,
-          n: callImageCount,
-          abortSignal,
-          headers: headersWithUserAgent,
-          size,
-          aspectRatio,
-          seed,
-          providerOptions: providerOptions ?? {},
+  const resultGroups = await Promise.all(
+    callImageCounts.map(async callImageCount => {
+      const callResults: Array<ImageModelV3Result> = [];
+
+      try {
+        await retry(async () => {
+          const { prompt, files, mask } = normalizePrompt(promptArg);
+
+          const result = await model.doGenerate({
+            prompt,
+            files,
+            mask,
+            n: callImageCount,
+            abortSignal,
+            headers: headersWithUserAgent,
+            size,
+            aspectRatio,
+            seed,
+            providerOptions: providerOptions ?? {},
+          });
+
+          callResults.push(result);
+
+          if (result.images.length === 0 && result.isRetryable !== false) {
+            throw new RetryableNoImageResultError();
+          }
+
+          return result;
         });
-      }),
-    ),
+
+        return callResults;
+      } catch (error) {
+        const noImageResultError =
+          error instanceof RetryableNoImageResultError
+            ? error
+            : RetryError.isInstance(error) &&
+                error.lastError instanceof RetryableNoImageResultError
+              ? error.lastError
+              : undefined;
+
+        if (noImageResultError != null) {
+          return callResults;
+        }
+
+        throw error;
+      }
+    }),
   );
+  const results = resultGroups.flat();
 
   // collect result images, warnings, and response metadata
   const images: Array<DefaultGeneratedFile> = [];

package/src/util/data-url.ts

@@ -1,3 +1,8 @@
+// atob needs to be invoked as a function call, not as a method call.
+// Otherwise Cloudflare will throw a
+// "TypeError: Illegal invocation: function called with incorrect this reference"
+const { atob } = globalThis;
+
 /**
  * Converts a data URL of type text/* to a text string.
  */
@@ -10,7 +15,7 @@ export function getTextFromDataUrl(dataUrl: string): string {
   }
 
   try {
-    return globalThis.atob(base64Content);
+    return atob(base64Content);
   } catch (error) {
     throw new Error(`Error decoding data URL`);
   }

package/src/util/prepare-retries.ts

@@ -1,5 +1,8 @@
 import { InvalidArgumentError } from '../error/invalid-argument-error';
-import type { RetryFunction } from '@ai-sdk/provider-utils';
+import type {
+  RetryFunction,
+  ShouldRetryFunction,
+} from '@ai-sdk/provider-utils';
 import { retryWithExponentialBackoffRespectingRetryHeaders } from '../util/retry-with-exponential-backoff';
 
 /**
@@ -8,9 +11,11 @@ import { retryWithExponentialBackoffRespectingRetryHeaders } from '../util/retry
 export function prepareRetries({
   maxRetries,
   abortSignal,
+  additionalRetryableError,
 }: {
   maxRetries: number | undefined;
   abortSignal: AbortSignal | undefined;
+  additionalRetryableError?: ShouldRetryFunction;
 }): {
   maxRetries: number;
   retry: RetryFunction;
@@ -40,6 +45,7 @@ export function prepareRetries({
     retry: retryWithExponentialBackoffRespectingRetryHeaders({
       maxRetries: maxRetriesResult,
       abortSignal,
+      additionalRetryableError,
     }),
   };
 }

package/src/util/retry-with-exponential-backoff.ts

@@ -3,6 +3,7 @@ import { GatewayError } from '@ai-sdk/gateway';
 import {
   retryWithExponentialBackoff,
   type RetryFunction,
+  type ShouldRetryFunction,
 } from '@ai-sdk/provider-utils';
 import { RetryError } from './retry-error';
 
@@ -66,21 +67,25 @@ export const retryWithExponentialBackoffRespectingRetryHeaders = ({
   initialDelayInMs = 2000,
   backoffFactor = 2,
   abortSignal,
+  additionalRetryableError,
 }: {
   maxRetries?: number;
   initialDelayInMs?: number;
   backoffFactor?: number;
   abortSignal?: AbortSignal;
+  additionalRetryableError?: ShouldRetryFunction;
 } = {}): RetryFunction =>
   retryWithExponentialBackoff({
     maxRetries,
     initialDelayInMs,
     backoffFactor,
     abortSignal,
-    shouldRetry: error =>
-      error instanceof Error &&
-      ((APICallError.isInstance(error) && error.isRetryable === true) ||
-        (GatewayError.isInstance(error) && error.isRetryable === true)),
+    shouldRetry: async error =>
+      (error instanceof Error &&
+        ((APICallError.isInstance(error) && error.isRetryable === true) ||
+          (GatewayError.isInstance(error) && error.isRetryable === true))) ||
+      (additionalRetryableError != null &&
+        (await additionalRetryableError(error))),
     getDelayInMs: ({ error, exponentialBackoffDelay }) =>
       getRetryDelayInMs({
         error: error as APICallError | GatewayError,