ai-retry 1.2.0 → 1.3.0

package/README.md

@@ -41,7 +41,7 @@ Create a retryable model by providing a base model and a list of retryables or f
 When an error occurs, it will evaluate each retryable in order and use the first one that indicates a retry should be attempted with a different model.
 
 > [!NOTE]
-> `ai-retry` supports both language models and embedding models.
+> `ai-retry` supports language models, embedding models, and image models.
 
 ```typescript
 import { openai } from '@ai-sdk/openai';
@@ -101,6 +101,28 @@ const result = await embed({
 console.log(result.embedding);
 ```
 
+This also works with image models:
+
+```typescript
+import { openai } from '@ai-sdk/openai';
+import { generateImage } from 'ai';
+import { createRetryable } from 'ai-retry';
+
+const retryableModel = createRetryable({
+  model: openai.image('dall-e-3'),
+  retries: [
+    // Retry strategies and fallbacks...
+  ],
+});
+
+const result = await generateImage({
+  model: retryableModel,
+  prompt: 'A sunset over mountains',
+});
+
+console.log(result.images);
+```
+
 #### Vercel AI Gateway
 
 You can use `ai-retry` with Vercel AI Gateway by providing the model as a string. Internally, the model will be resolved with the default `gateway` [provider instance](https://ai-sdk.dev/providers/ai-sdk-providers/ai-gateway#provider-instance) from AI SDK.
@@ -356,9 +378,9 @@ There are several built-in dynamic retryables available for common use cases:
 - [`requestNotRetryable`](./src/retryables/request-not-retryable.ts): Request failed with a non-retryable error.
 - [`retryAfterDelay`](./src/retryables/retry-after-delay.ts): Retry with delay and exponential backoff and respect `retry-after` headers.
 - [`serviceOverloaded`](./src/retryables/service-overloaded.ts): Response with status code 529 (service overloaded).
-  - Use this retryable to handle Anthropic's overloaded errors.
 - [`serviceUnavailable`](./src/retryables/service-unavailable.ts): Response with status code 503 (service unavailable).
 - [`schemaMismatch`](./src/retryables/schema-mismatch.ts): Response JSON doesn't match the expected schema from structured output modes (`Output.object()`, `Output.array()`, `Output.choice()`).
+- [`noImageGenerated`](./src/retryables/no-image-generated.ts): Image generation failed with `NoImageGeneratedError`.
 
 #### Content Filter
 
@@ -412,9 +434,6 @@ const result = await generateText({
 
 Handle service overload errors (status code 529) by switching to a provider.
 
-> [!NOTE] 
-> You can use this retryable to handle Anthropic's overloaded errors.
-
 ```typescript
 import { serviceOverloaded } from 'ai-retry/retryables';
 
@@ -453,6 +472,29 @@ const retryableModel = createRetryable({
 });
 ```
 
+#### No Image Generated
+
+Handle image generation failures by switching to a different model.
+
+```typescript
+import { openai } from '@ai-sdk/openai';
+import { generateImage } from 'ai';
+import { createRetryable } from 'ai-retry';
+import { noImageGenerated } from 'ai-retry/retryables';
+
+const retryableModel = createRetryable({
+  model: openai.image('dall-e-3'),
+  retries: [
+    noImageGenerated(openai.image('dall-e-2')), // Fallback to DALL-E 2
+  ],
+});
+
+const result = await generateImage({
+  model: retryableModel,
+  prompt: 'A sunset over mountains',
+});
+```
+
 #### Request Not Retryable
 
 Handle cases where the base model fails with a non-retryable error.
@@ -736,6 +778,17 @@ The following options can be overridden:
 | [`headers`](https://ai-sdk.dev/docs/reference/ai-sdk-core/embed#headers) | Additional HTTP headers |
 | [`providerOptions`](https://ai-sdk.dev/docs/reference/ai-sdk-core/embed#provideroptions) | Provider-specific options |
 
+##### Image Model Options
+
+| Option | Description |
+|--------|-------------|
+| [`n`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-image#n) | Number of images to generate |
+| [`size`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-image#size) | Size of generated images |
+| [`aspectRatio`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-image#aspectratio) | Aspect ratio of generated images |
+| [`seed`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-image#seed) | Random seed for reproducibility |
+| [`headers`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-image#headers) | Additional HTTP headers |
+| [`providerOptions`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-image#provideroptions) | Provider-specific options |
+
 #### Logging
 
 You can use the following callbacks to log retry attempts and errors:
@@ -763,21 +816,21 @@ By default, every new request starts with the base model, even if a previous req
 
 | Value | Description |
 |-------|-------------|
-| `'after-request'` | Reset immediately after the next request (default) |
-| `` `after-${N}-requests` `` | Keep the retry model for the next **N** requests, then reset |
-| `` `after-${N}-seconds` `` | Keep the retry model for **N** seconds, then reset |
+| `after-request` | Reset immediately after the next request (default) |
+| `after-N-requests` | Keep the retry model for the next **N** requests, then reset |
+| `after-N-seconds` | Keep the retry model for **N** seconds, then reset |
 
-**Reset after each request (default)**
+##### Reset after each request (default)
 
 ```typescript
 const retryableModel = createRetryable({
   model: openai('gpt-4o-mini'),
   retries: [anthropic('claude-sonnet-4-20250514')],
-  reset: 'after-request', // default — always start with the base model
+  reset: 'after-request', // default: always start with the base model
 });
 ```
 
-**Keep the retry model for N requests**
+##### Keep the retry model for N requests
 
 ```typescript
 const retryableModel = createRetryable({
@@ -787,7 +840,7 @@ const retryableModel = createRetryable({
 });
 ```
 
-**Keep the retry model for N seconds**
+##### Keep the retry model for N seconds
 
 ```typescript
 const retryableModel = createRetryable({
@@ -808,12 +861,12 @@ In the second case, errors during stream processing will not always be retried,
 
 ### API Reference
 
-#### `createRetryable(options: RetryableModelOptions): LanguageModelV2 | EmbeddingModelV2`
+#### `createRetryable(options: RetryableModelOptions): LanguageModelV3 | EmbeddingModelV3 | ImageModelV3`
 
-Creates a retryable model that works with both language models and embedding models.
+Creates a retryable model that works with language models, embedding models, and image models.
 
 ```ts
-interface RetryableModelOptions<MODEL extends LanguageModelV2 | EmbeddingModelV2> {
+interface RetryableModelOptions<MODEL extends LanguageModelV3 | EmbeddingModelV3 | ImageModelV3> {
   model: MODEL;
   retries: Array<Retryable<MODEL> | MODEL>;
   disabled?: boolean | (() => boolean);
@@ -827,7 +880,7 @@ interface RetryableModelOptions<MODEL extends LanguageModelV2 | EmbeddingModelV2
 - `model`: The base model to use for the initial request.
 - `retries`: Array of retryables (functions, models, or retry objects) to attempt on failure.
 - `disabled`: Disable all retry logic. Can be a boolean or function returning boolean. Default: `false` (retries enabled).
-- `reset`: Controls when to reset back to the base model after a successful retry. See [Reset](#reset) for details. Default: `'after-request'`.
+- `reset`: Controls when to reset back to the base model after a successful retry. Default: `after-request`.
 - `onError`: Callback invoked when an error occurs.
 - `onRetry`: Callback invoked before attempting a retry.
 
@@ -842,9 +895,9 @@ type Reset =
   | `after-${number}-seconds`;
 ```
 
-- `'after-request'` — reset immediately after the next request (default).
-- `` `after-${N}-requests` `` — keep the retry model for the next N requests, then reset.
-- `` `after-${N}-seconds` `` — keep the retry model for N seconds, then reset.
+- `after-request` — reset immediately after the next request (default).
+- `after-N-requests` — keep the retry model for the next N requests, then reset.
+- `after-N-seconds` — keep the retry model for N seconds, then reset.
 
 #### `Retryable`
 
@@ -859,17 +912,17 @@ type Retryable = (
 
 #### `Retry`
 
-A `Retry` specifies the model to retry and optional settings. The available options depend on the model type (language model or embedding model).
+A `Retry` specifies the model to retry and optional settings. The available options depend on the model type (language model, embedding model, or image model).
 
 ```typescript
 interface Retry {
-  model: LanguageModelV2 | EmbeddingModelV2;
+  model: LanguageModelV3 | EmbeddingModelV3 | ImageModelV3;
   maxAttempts?: number;      // Maximum retry attempts per model (default: 1)
   delay?: number;            // Delay in milliseconds before retrying
   backoffFactor?: number;    // Multiplier for exponential backoff
   timeout?: number;          // Timeout in milliseconds for the retry attempt
   providerOptions?: ProviderOptions; // @deprecated - use options.providerOptions instead
-  options?: LanguageModelV2CallOptions | EmbeddingModelV2CallOptions; // Call options to override for this retry
+  options?: LanguageModelV3CallOptions | EmbeddingModelV3CallOptions | ImageModelV3CallOptions; // Call options to override for this retry
 }
 ```
 
@@ -889,22 +942,22 @@ interface RetryContext {
 A `RetryAttempt` represents a single attempt with a specific model, which can be either an error or a successful result that triggered a retry. Each attempt includes the call options that were used for that specific attempt. For retry attempts, this will reflect any overridden options from the retry configuration.
 
 ```typescript
-// For both language and embedding models
+// For language, embedding, and image models
 type RetryAttempt =
-  | { 
-      type: 'error'; 
-      error: unknown; 
-      model: LanguageModelV2 | EmbeddingModelV2;
-      options: LanguageModelV2CallOptions | EmbeddingModelV2CallOptions;
+  | {
+      type: 'error';
+      error: unknown;
+      model: LanguageModelV3 | EmbeddingModelV3 | ImageModelV3;
+      options: LanguageModelV3CallOptions | EmbeddingModelV3CallOptions | ImageModelV3CallOptions;
     }
-  | { 
-      type: 'result'; 
-      result: LanguageModelV2Generate; 
-      model: LanguageModelV2;
-      options: LanguageModelV2CallOptions;
+  | {
+      type: 'result';
+      result: LanguageModelV3Generate;
+      model: LanguageModelV3;
+      options: LanguageModelV3CallOptions;
     };
 
-// Note: Result-based retries only apply to language models, not embedding models
+// Note: Result-based retries only apply to language models, not embedding or image models
 
 // Type guards for discriminating attempts
 function isErrorAttempt(attempt: RetryAttempt): attempt is RetryErrorAttempt;

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { C as Retryable, S as RetryResultAttempt, T as RetryableOptions, _ as Retries, a as GatewayLanguageModelId, b as RetryContext, c as LanguageModelGenerate, d as LanguageModelStreamPart, f as ProviderOptions, g as ResolvedModel, h as ResolvableModel, i as EmbeddingModelRetryCallOptions, l as LanguageModelRetryCallOptions, m as ResolvableLanguageModel, n as EmbeddingModelCallOptions, o as LanguageModel, p as Reset, r as EmbeddingModelEmbed, s as LanguageModelCallOptions, t as EmbeddingModel, u as LanguageModelStream, v as Retry, w as RetryableModelOptions, x as RetryErrorAttempt, y as RetryAttempt } from "./types-Dk5KMZMd.mjs";
+import { C as RetryAttempt, D as Retryable, E as RetryResultAttempt, O as RetryableModelOptions, S as Retry, T as RetryErrorAttempt, _ as Reset, a as GatewayLanguageModelId, b as ResolvedModel, c as ImageModelGenerate, d as LanguageModelCallOptions, f as LanguageModelGenerate, g as ProviderOptions, h as LanguageModelStreamPart, i as EmbeddingModelRetryCallOptions, k as RetryableOptions, l as ImageModelRetryCallOptions, m as LanguageModelStream, n as EmbeddingModelCallOptions, o as ImageModel, p as LanguageModelRetryCallOptions, r as EmbeddingModelEmbed, s as ImageModelCallOptions, t as EmbeddingModel, u as LanguageModel, v as ResolvableLanguageModel, w as RetryContext, x as Retries, y as ResolvableModel } from "./types-wEZKtEcH.mjs";
 import * as _ai_sdk_provider0 from "@ai-sdk/provider";
 
 //#region src/create-retryable-model.d.ts
@@ -7,19 +7,21 @@ declare function createRetryable<MODEL extends LanguageModel>(options: Omit<Retr
 }): LanguageModel;
 declare function createRetryable<MODEL extends LanguageModel>(options: RetryableModelOptions<MODEL>): LanguageModel;
 declare function createRetryable<MODEL extends EmbeddingModel>(options: RetryableModelOptions<MODEL>): EmbeddingModel;
+declare function createRetryable<MODEL extends ImageModel>(options: RetryableModelOptions<MODEL>): ImageModel;
 //#endregion
 //#region src/get-model-key.d.ts
 /**
- * Generate a unique key for a LanguageModel instance.
+ * Generate a unique key for a model instance.
  */
-declare const getModelKey: (model: LanguageModel | EmbeddingModel) => string;
+declare const getModelKey: (model: LanguageModel | EmbeddingModel | ImageModel) => string;
 //#endregion
 //#region src/utils.d.ts
 declare const isObject: (value: unknown) => value is Record<string, unknown>;
 declare const isString: (value: unknown) => value is string;
-declare const isModel: (model: unknown) => model is LanguageModel | EmbeddingModel;
+declare const isModel: (model: unknown) => model is LanguageModel | EmbeddingModel | ImageModel;
 declare const isLanguageModel: (model: unknown) => model is LanguageModel;
 declare const isEmbeddingModel: (model: unknown) => model is EmbeddingModel;
+declare const isImageModel: (model: unknown) => model is ImageModel;
 declare const isStreamResult: (result: LanguageModelGenerate | LanguageModelStream) => result is LanguageModelStream;
 declare const isGenerateResult: (result: LanguageModelGenerate | LanguageModelStream) => result is LanguageModelGenerate;
 /**
@@ -73,4 +75,4 @@ declare const isAbortError: (error: unknown) => boolean;
  */
 declare const isTimeoutError: (error: unknown) => boolean;
 //#endregion
-export { EmbeddingModel, EmbeddingModelCallOptions, EmbeddingModelEmbed, EmbeddingModelRetryCallOptions, GatewayLanguageModelId, LanguageModel, LanguageModelCallOptions, LanguageModelGenerate, LanguageModelRetryCallOptions, LanguageModelStream, LanguageModelStreamPart, ProviderOptions, Reset, ResolvableLanguageModel, ResolvableModel, ResolvedModel, Retries, Retry, RetryAttempt, RetryContext, RetryErrorAttempt, RetryResultAttempt, Retryable, RetryableModelOptions, RetryableOptions, createRetryable, getModelKey, isAbortError, isEmbeddingModel, isErrorAttempt, isGenerateResult, isLanguageModel, isModel, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString, isTimeoutError };
+export { EmbeddingModel, EmbeddingModelCallOptions, EmbeddingModelEmbed, EmbeddingModelRetryCallOptions, GatewayLanguageModelId, ImageModel, ImageModelCallOptions, ImageModelGenerate, ImageModelRetryCallOptions, LanguageModel, LanguageModelCallOptions, LanguageModelGenerate, LanguageModelRetryCallOptions, LanguageModelStream, LanguageModelStreamPart, ProviderOptions, Reset, ResolvableLanguageModel, ResolvableModel, ResolvedModel, Retries, Retry, RetryAttempt, RetryContext, RetryErrorAttempt, RetryResultAttempt, Retryable, RetryableModelOptions, RetryableOptions, createRetryable, getModelKey, isAbortError, isEmbeddingModel, isErrorAttempt, isGenerateResult, isImageModel, isLanguageModel, isModel, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString, isTimeoutError };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as isLanguageModel, c as isResultAttempt, d as isString, f as isTimeoutError, i as isGenerateResult, l as isStreamContentPart, n as isEmbeddingModel, o as isModel, r as isErrorAttempt, s as isObject, t as isAbortError, u as isStreamResult } from "./utils-fYGELi1C.mjs";
+import { a as isImageModel, c as isObject, d as isStreamResult, f as isString, i as isGenerateResult, l as isResultAttempt, n as isEmbeddingModel, o as isLanguageModel, p as isTimeoutError, r as isErrorAttempt, s as isModel, t as isAbortError, u as isStreamContentPart } from "./utils-CfnsSGrw.mjs";
 import { RetryError, gateway } from "ai";
 import { delay } from "@ai-sdk/provider-utils";
 import { getErrorMessage } from "@ai-sdk/provider";
@@ -94,7 +94,7 @@ function calculateExponentialBackoff(baseDelay, backoffFactor = 1, attempts) {
 //#endregion
 //#region src/get-model-key.ts
 /**
-* Generate a unique key for a LanguageModel instance.
+* Generate a unique key for a model instance.
 */
 const getModelKey = (model) => {
 	return `${model.provider}/${model.modelId}`;
@@ -110,7 +110,7 @@ function countModelAttempts(model, attempts) {
 //#endregion
 //#region src/resolve-model.ts
 /**
-* Resolve a model string via the AI SDK Gateway to a modelinstance
+* Resolve a model string via the AI SDK Gateway to a model instance
 */
 function resolveModel(model) {
 	return isModel(model) ? model : gateway(model);
@@ -133,9 +133,20 @@ async function findRetryModel(retries, context) {
 	*/
 	for (const retry of applicableRetries) {
 		let retryModel;
-		if (typeof retry === "function") retryModel = await retry(context);
-		else if (isObject(retry) && "model" in retry) retryModel = retry;
-		else retryModel = { model: retry };
+		if (typeof retry === `function`)
+ /**
+		* Function retryable - call it with context
+		* The function can be either Retryable<MODEL> or Retryable<ResolvableLanguageModel>
+		* At runtime, both work because the context is structurally compatible
+		* We use type assertion here because TypeScript can't prove the union type compatibility
+		*/
+		retryModel = await retry(context);
+		else if (isObject(retry) && `model` in retry)
+ /** Static Retry object */
+		retryModel = retry;
+		else
+ /** Plain model */
+		retryModel = { model: retry };
 		if (retryModel) {
 			/**
 			* The model can be string or an instance.
@@ -322,6 +333,152 @@ var RetryableEmbeddingModel = class extends BaseRetryableModel {
 	}
 };
 
+//#endregion
+//#region src/retryable-image-model.ts
+var RetryableImageModel = class extends BaseRetryableModel {
+	specificationVersion = "v3";
+	get modelId() {
+		return this.currentModel.modelId;
+	}
+	get provider() {
+		return this.currentModel.provider;
+	}
+	get maxImagesPerCall() {
+		return this.currentModel.maxImagesPerCall;
+	}
+	/**
+	* Get the retry call options overrides from a retry configuration.
+	*/
+	getRetryCallOptions(callOptions, currentRetry) {
+		const retryOptions = currentRetry?.options ?? {};
+		return {
+			...callOptions,
+			n: retryOptions.n ?? callOptions.n,
+			size: retryOptions.size ?? callOptions.size,
+			aspectRatio: retryOptions.aspectRatio ?? callOptions.aspectRatio,
+			seed: retryOptions.seed ?? callOptions.seed,
+			headers: retryOptions.headers ?? callOptions.headers,
+			providerOptions: retryOptions.providerOptions ?? currentRetry?.providerOptions ?? callOptions.providerOptions,
+			abortSignal: currentRetry?.timeout ? AbortSignal.timeout(currentRetry.timeout) : callOptions.abortSignal
+		};
+	}
+	/**
+	* Execute a function with retry logic for handling errors
+	*/
+	async withRetry(input) {
+		/**
+		* Track all attempts.
+		*/
+		const attempts = input.attempts ?? [];
+		/**
+		* Track current retry configuration.
+		*/
+		let currentRetry;
+		while (true) {
+			/**
+			* The previous attempt that triggered a retry, or undefined if this is the first attempt
+			*/
+			const previousAttempt = attempts.at(-1);
+			/**
+			* Call the onRetry handler if provided.
+			* Skip on the first attempt since no previous attempt exists yet.
+			*/
+			if (previousAttempt) {
+				const context = {
+					current: {
+						...previousAttempt,
+						model: this.currentModel
+					},
+					attempts: [...attempts]
+				};
+				this.options.onRetry?.(context);
+			}
+			/**
+			* Get the retry call options overrides for this attempt
+			*/
+			const retryCallOptions = this.getRetryCallOptions(input.callOptions, currentRetry);
+			try {
+				return {
+					result: await input.fn(retryCallOptions),
+					attempts
+				};
+			} catch (error) {
+				/** Don't retry if user manually aborted the request. */
+				/** TimeoutError from AbortSignal.timeout() will still be handled by retry handlers. */
+				if (isAbortError(error)) throw error;
+				const { retryModel, attempt } = await this.handleError(error, attempts, retryCallOptions);
+				attempts.push(attempt);
+				if (retryModel.delay) {
+					/**
+					* Calculate exponential backoff delay based on the number of attempts for this specific model.
+					* The delay grows exponentially: baseDelay * backoffFactor^attempts
+					* Example: With delay=1000ms and backoffFactor=2:
+					* - Attempt 1: 1000ms
+					* - Attempt 2: 2000ms
+					* - Attempt 3: 4000ms
+					*/
+					const modelAttemptsCount = countModelAttempts(retryModel.model, attempts);
+					await delay(calculateExponentialBackoff(retryModel.delay, retryModel.backoffFactor, modelAttemptsCount), { abortSignal: retryCallOptions.abortSignal });
+				}
+				this.currentModel = retryModel.model;
+				currentRetry = retryModel;
+			}
+		}
+	}
+	/**
+	* Handle an error and determine if a retry is needed
+	*/
+	async handleError(error, attempts, callOptions) {
+		const errorAttempt = {
+			type: "error",
+			error,
+			model: this.currentModel,
+			options: callOptions
+		};
+		/**
+		* Save the current attempt
+		*/
+		const updatedAttempts = [...attempts, errorAttempt];
+		const context = {
+			current: errorAttempt,
+			attempts: updatedAttempts
+		};
+		this.options.onError?.(context);
+		const retryModel = await findRetryModel(this.options.retries, context);
+		/**
+		* Handler didn't return any models to try next, rethrow the error.
+		* If we retried the request, wrap the error into a `RetryError` for better visibility.
+		*/
+		if (!retryModel) {
+			if (updatedAttempts.length > 1) throw prepareRetryError(error, updatedAttempts);
+			throw error;
+		}
+		return {
+			retryModel,
+			attempt: errorAttempt
+		};
+	}
+	async doGenerate(callOptions) {
+		/**
+		* Resolve the starting model (base or sticky)
+		*/
+		const startModel = this.resolveStartModel();
+		this.currentModel = startModel;
+		/**
+		* If retries are disabled, bypass retry machinery entirely
+		*/
+		if (this.isDisabled()) return this.currentModel.doGenerate(callOptions);
+		const { result } = await this.withRetry({
+			fn: async (retryCallOptions) => {
+				return this.currentModel.doGenerate(retryCallOptions);
+			},
+			callOptions
+		});
+		this.updateStickyModel(startModel);
+		return result;
+	}
+};
+
 //#endregion
 //#region src/retryable-language-model.ts
 var RetryableLanguageModel = class extends BaseRetryableModel {
@@ -630,6 +787,10 @@ function createRetryable(options) {
 		...options,
 		model
 	});
+	if (isImageModel(model)) return new RetryableImageModel({
+		...options,
+		model
+	});
 	return new RetryableLanguageModel({
 		...options,
 		model
@@ -637,4 +798,4 @@ function createRetryable(options) {
 }
 
 //#endregion
-export { createRetryable, getModelKey, isAbortError, isEmbeddingModel, isErrorAttempt, isGenerateResult, isLanguageModel, isModel, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString, isTimeoutError };
+export { createRetryable, getModelKey, isAbortError, isEmbeddingModel, isErrorAttempt, isGenerateResult, isImageModel, isLanguageModel, isModel, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString, isTimeoutError };

package/dist/retryables/index.d.mts

@@ -1,4 +1,4 @@
-import { C as Retryable, T as RetryableOptions, m as ResolvableLanguageModel, t as EmbeddingModel } from "../types-Dk5KMZMd.mjs";
+import { D as Retryable, k as RetryableOptions, o as ImageModel, t as EmbeddingModel, v as ResolvableLanguageModel } from "../types-wEZKtEcH.mjs";
 
 //#region src/retryables/content-filter-triggered.d.ts
 /**
@@ -6,11 +6,17 @@ import { C as Retryable, T as RetryableOptions, m as ResolvableLanguageModel, t
  */
 declare function contentFilterTriggered<MODEL extends ResolvableLanguageModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
+//#region src/retryables/no-image-generated.d.ts
+/**
+ * Fallback to a different model if image generation fails with NoImageGeneratedError.
+ */
+declare function noImageGenerated<MODEL extends ImageModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
+//#endregion
 //#region src/retryables/request-not-retryable.d.ts
 /**
  * Fallback to a different model if the error is non-retryable.
  */
-declare function requestNotRetryable<MODEL extends ResolvableLanguageModel | EmbeddingModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
+declare function requestNotRetryable<MODEL extends ResolvableLanguageModel | EmbeddingModel | ImageModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
 //#region src/retryables/request-timeout.d.ts
 /**
@@ -18,7 +24,7 @@ declare function requestNotRetryable<MODEL extends ResolvableLanguageModel | Emb
  * Use in combination with the `abortSignal` option.
  * If no timeout is specified, a default of 60 seconds is used.
  */
-declare function requestTimeout<MODEL extends ResolvableLanguageModel | EmbeddingModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
+declare function requestTimeout<MODEL extends ResolvableLanguageModel | EmbeddingModel | ImageModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
 //#region src/retryables/retry-after-delay.d.ts
 /**
@@ -26,7 +32,7 @@ declare function requestTimeout<MODEL extends ResolvableLanguageModel | Embeddin
  * Uses the `Retry-After` or `Retry-After-Ms` headers if present.
  * Otherwise uses the specified `delay` and `backoffFactor` if provided.
  */
-declare function retryAfterDelay<MODEL extends ResolvableLanguageModel | EmbeddingModel>(options: RetryableOptions<MODEL>): Retryable<MODEL>;
+declare function retryAfterDelay<MODEL extends ResolvableLanguageModel | EmbeddingModel | ImageModel>(options: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
 //#region src/retryables/schema-mismatch.d.ts
 /**
@@ -58,13 +64,13 @@ declare function schemaMismatch<MODEL extends ResolvableLanguageModel>(model: MO
  * - Response with `type: "overloaded_error"`
  * - Response with a `message` containing "overloaded"
  */
-declare function serviceOverloaded<MODEL extends ResolvableLanguageModel | EmbeddingModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
+declare function serviceOverloaded<MODEL extends ResolvableLanguageModel | EmbeddingModel | ImageModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
 //#region src/retryables/service-unavailable.d.ts
 /**
  * Fallback to a different model if the provider returns a service unavailable error.
  * This retryable handles HTTP status code 503 (Service Unavailable).
  */
-declare function serviceUnavailable<MODEL extends ResolvableLanguageModel | EmbeddingModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
+declare function serviceUnavailable<MODEL extends ResolvableLanguageModel | EmbeddingModel | ImageModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
-export { contentFilterTriggered, requestNotRetryable, requestTimeout, retryAfterDelay, schemaMismatch, serviceOverloaded, serviceUnavailable };
+export { contentFilterTriggered, noImageGenerated, requestNotRetryable, requestTimeout, retryAfterDelay, schemaMismatch, serviceOverloaded, serviceUnavailable };

package/dist/retryables/index.mjs

@@ -1,5 +1,5 @@
-import { c as isResultAttempt, d as isString, f as isTimeoutError, r as isErrorAttempt, s as isObject } from "../utils-fYGELi1C.mjs";
-import { APICallError } from "ai";
+import { c as isObject, f as isString, l as isResultAttempt, p as isTimeoutError, r as isErrorAttempt } from "../utils-CfnsSGrw.mjs";
+import { APICallError, NoImageGeneratedError } from "ai";
 import { safeParseJSON } from "@ai-sdk/provider-utils";
 import { fromJSONSchema } from "zod";
 
@@ -29,6 +29,25 @@ function contentFilterTriggered(model, options) {
 	};
 }
 
+//#endregion
+//#region src/retryables/no-image-generated.ts
+/**
+* Fallback to a different model if image generation fails with NoImageGeneratedError.
+*/
+function noImageGenerated(model, options) {
+	return (context) => {
+		const { current } = context;
+		if (isErrorAttempt(current)) {
+			const { error } = current;
+			if (NoImageGeneratedError.isInstance(error)) return {
+				model,
+				maxAttempts: 1,
+				...options
+			};
+		}
+	};
+}
+
 //#endregion
 //#region src/retryables/request-not-retryable.ts
 /**
@@ -219,4 +238,4 @@ function serviceUnavailable(model, options) {
 }
 
 //#endregion
-export { contentFilterTriggered, requestNotRetryable, requestTimeout, retryAfterDelay, schemaMismatch, serviceOverloaded, serviceUnavailable };
+export { contentFilterTriggered, noImageGenerated, requestNotRetryable, requestTimeout, retryAfterDelay, schemaMismatch, serviceOverloaded, serviceUnavailable };

package/dist/{types-Dk5KMZMd.d.mts → types-wEZKtEcH.d.mts}

@@ -1,17 +1,19 @@
 import { gateway } from "ai";
-import { EmbeddingModelV3, LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3StreamPart, SharedV3ProviderOptions } from "@ai-sdk/provider";
+import { EmbeddingModelV3, ImageModelV3, ImageModelV3CallOptions, LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3StreamPart, SharedV3ProviderOptions } from "@ai-sdk/provider";
 
 //#region src/types.d.ts
 type Literals<T> = T extends string ? string extends T ? never : T : never;
 type LanguageModel = LanguageModelV3;
 type EmbeddingModel = EmbeddingModelV3;
+type ImageModel = ImageModelV3;
 type LanguageModelCallOptions = LanguageModelV3CallOptions;
 type LanguageModelStreamPart = LanguageModelV3StreamPart;
+type ImageModelCallOptions = ImageModelV3CallOptions;
 type ProviderOptions = SharedV3ProviderOptions;
 type GatewayLanguageModelId = Parameters<(typeof gateway)['languageModel']>[0];
 type ResolvableLanguageModel = LanguageModel | Literals<GatewayLanguageModelId>;
-type ResolvableModel<MODEL extends LanguageModel | EmbeddingModel> = MODEL extends LanguageModel ? ResolvableLanguageModel : EmbeddingModel;
-type ResolvedModel<MODEL extends ResolvableLanguageModel | EmbeddingModel> = MODEL extends ResolvableLanguageModel ? LanguageModel : EmbeddingModel;
+type ResolvableModel<MODEL extends LanguageModel | EmbeddingModel | ImageModel> = MODEL extends LanguageModel ? ResolvableLanguageModel : MODEL extends EmbeddingModel ? EmbeddingModel : ImageModel;
+type ResolvedModel<MODEL extends ResolvableLanguageModel | EmbeddingModel | ImageModel> = MODEL extends ResolvableLanguageModel ? LanguageModel : MODEL extends EmbeddingModel ? EmbeddingModel : ImageModel;
 /**
  * Call options that can be overridden during retry for language models.
  */
@@ -20,10 +22,14 @@ type LanguageModelRetryCallOptions = Partial<Pick<LanguageModelCallOptions, 'pro
  * Call options that can be overridden during retry for embedding models.
  */
 type EmbeddingModelRetryCallOptions = Partial<Pick<EmbeddingModelCallOptions, 'values' | 'headers' | 'providerOptions'>>;
+/**
+ * Call options that can be overridden during retry for image models.
+ */
+type ImageModelRetryCallOptions = Partial<Pick<ImageModelCallOptions, 'n' | 'size' | 'aspectRatio' | 'seed' | 'headers' | 'providerOptions'>>;
 /**
  * A retry attempt with an error
  */
-type RetryErrorAttempt<MODEL extends LanguageModel | EmbeddingModel> = {
+type RetryErrorAttempt<MODEL extends LanguageModel | EmbeddingModel | ImageModel> = {
   type: 'error';
   error: unknown;
   result?: undefined;
@@ -31,7 +37,7 @@ type RetryErrorAttempt<MODEL extends LanguageModel | EmbeddingModel> = {
   /**
    * The call options used for this attempt.
    */
-  options: MODEL extends LanguageModel ? LanguageModelCallOptions : EmbeddingModelCallOptions;
+  options: MODEL extends LanguageModel ? LanguageModelCallOptions : MODEL extends EmbeddingModel ? EmbeddingModelCallOptions : ImageModelCallOptions;
 };
 /**
  * A retry attempt with a successful result
@@ -49,11 +55,11 @@ type RetryResultAttempt = {
 /**
  * A retry attempt with either an error or a result and the model used
  */
-type RetryAttempt<MODEL extends LanguageModel | EmbeddingModel> = RetryErrorAttempt<MODEL> | RetryResultAttempt;
+type RetryAttempt<MODEL extends LanguageModel | EmbeddingModel | ImageModel> = MODEL extends LanguageModel ? RetryErrorAttempt<MODEL> | RetryResultAttempt : RetryErrorAttempt<MODEL>;
 /**
  * The context provided to Retryables with the current attempt and all previous attempts.
  */
-type RetryContext<MODEL extends ResolvableLanguageModel | EmbeddingModel> = {
+type RetryContext<MODEL extends ResolvableLanguageModel | EmbeddingModel | ImageModel> = {
   /**
    * Current attempt that caused the retry
    */
@@ -66,7 +72,7 @@ type RetryContext<MODEL extends ResolvableLanguageModel | EmbeddingModel> = {
 /**
  * Options for creating a retryable model.
  */
-interface RetryableModelOptions<MODEL extends LanguageModel | EmbeddingModel> {
+interface RetryableModelOptions<MODEL extends LanguageModel | EmbeddingModel | ImageModel> {
   model: MODEL;
   retries: Retries<MODEL>;
   disabled?: boolean | (() => boolean);
@@ -90,7 +96,7 @@ interface RetryableModelOptions<MODEL extends LanguageModel | EmbeddingModel> {
  * This flexible approach allows retryable functions to return the exact model type
  * they received without type assertions, while still supporting string-based gateway models.
  */
-type Retry<MODEL extends ResolvableLanguageModel | EmbeddingModel> = {
+type Retry<MODEL extends ResolvableLanguageModel | EmbeddingModel | ImageModel> = {
   model: MODEL;
   /**
    * Maximum number of attempts for this model.
@@ -112,7 +118,7 @@ type Retry<MODEL extends ResolvableLanguageModel | EmbeddingModel> = {
   /**
    * Call options to override for this retry.
    */
-  options?: MODEL extends LanguageModel ? Partial<LanguageModelRetryCallOptions> : Partial<EmbeddingModelRetryCallOptions>;
+  options?: MODEL extends LanguageModel ? Partial<LanguageModelRetryCallOptions> : MODEL extends EmbeddingModel ? Partial<EmbeddingModelRetryCallOptions> : Partial<ImageModelRetryCallOptions>;
   /**
    * @deprecated Use `options.providerOptions` instead.
    * Provider options to override for this retry.
@@ -124,9 +130,9 @@ type Retry<MODEL extends ResolvableLanguageModel | EmbeddingModel> = {
 /**
  * A function that determines whether to retry with a different model based on the current attempt and all previous attempts.
  */
-type Retryable<MODEL extends ResolvableLanguageModel | EmbeddingModel> = (context: RetryContext<MODEL>) => Retry<MODEL> | Promise<Retry<MODEL> | undefined> | undefined;
-type Retries<MODEL extends LanguageModel | EmbeddingModel> = Array<Retryable<ResolvableModel<MODEL>> | Retry<ResolvableModel<MODEL>> | ResolvableModel<MODEL>>;
-type RetryableOptions<MODEL extends ResolvableLanguageModel | EmbeddingModel> = Partial<Omit<Retry<MODEL>, 'model'>>;
+type Retryable<MODEL extends ResolvableLanguageModel | EmbeddingModel | ImageModel> = (context: RetryContext<MODEL>) => Retry<MODEL> | Promise<Retry<MODEL> | undefined> | undefined;
+type Retries<MODEL extends LanguageModel | EmbeddingModel | ImageModel> = Array<Retryable<ResolvableModel<MODEL>> | Retry<ResolvableModel<MODEL>> | ResolvableModel<MODEL>>;
+type RetryableOptions<MODEL extends ResolvableLanguageModel | EmbeddingModel | ImageModel> = Partial<Omit<Retry<MODEL>, 'model'>>;
 /**
  * Controls when to reset the sticky model back to the base model.
  *
@@ -139,5 +145,6 @@ type LanguageModelGenerate = Awaited<ReturnType<LanguageModel['doGenerate']>>;
 type LanguageModelStream = Awaited<ReturnType<LanguageModel['doStream']>>;
 type EmbeddingModelCallOptions = Parameters<EmbeddingModel['doEmbed']>[0];
 type EmbeddingModelEmbed = Awaited<ReturnType<EmbeddingModel['doEmbed']>>;
+type ImageModelGenerate = Awaited<ReturnType<ImageModel['doGenerate']>>;
 //#endregion
-export { Retryable as C, RetryResultAttempt as S, RetryableOptions as T, Retries as _, GatewayLanguageModelId as a, RetryContext as b, LanguageModelGenerate as c, LanguageModelStreamPart as d, ProviderOptions as f, ResolvedModel as g, ResolvableModel as h, EmbeddingModelRetryCallOptions as i, LanguageModelRetryCallOptions as l, ResolvableLanguageModel as m, EmbeddingModelCallOptions as n, LanguageModel as o, Reset as p, EmbeddingModelEmbed as r, LanguageModelCallOptions as s, EmbeddingModel as t, LanguageModelStream as u, Retry as v, RetryableModelOptions as w, RetryErrorAttempt as x, RetryAttempt as y };
+export { RetryAttempt as C, Retryable as D, RetryResultAttempt as E, RetryableModelOptions as O, Retry as S, RetryErrorAttempt as T, Reset as _, GatewayLanguageModelId as a, ResolvedModel as b, ImageModelGenerate as c, LanguageModelCallOptions as d, LanguageModelGenerate as f, ProviderOptions as g, LanguageModelStreamPart as h, EmbeddingModelRetryCallOptions as i, RetryableOptions as k, ImageModelRetryCallOptions as l, LanguageModelStream as m, EmbeddingModelCallOptions as n, ImageModel as o, LanguageModelRetryCallOptions as p, EmbeddingModelEmbed as r, ImageModelCallOptions as s, EmbeddingModel as t, LanguageModel as u, ResolvableLanguageModel as v, RetryContext as w, Retries as x, ResolvableModel as y };

package/dist/{utils-fYGELi1C.mjs → utils-CfnsSGrw.mjs}

@@ -1,9 +1,10 @@
 //#region src/utils.ts
 const isObject = (value) => typeof value === "object" && value !== null;
 const isString = (value) => typeof value === "string";
-const isModel = (model) => isLanguageModel(model) || isEmbeddingModel(model);
-const isLanguageModel = (model) => isObject(model) && "provider" in model && "modelId" in model && "specificationVersion" in model && "doGenerate" in model && model.specificationVersion === "v3";
+const isModel = (model) => isLanguageModel(model) || isEmbeddingModel(model) || isImageModel(model);
+const isLanguageModel = (model) => isObject(model) && "provider" in model && "modelId" in model && "specificationVersion" in model && "doGenerate" in model && "doStream" in model && model.specificationVersion === "v3";
 const isEmbeddingModel = (model) => isObject(model) && "provider" in model && "modelId" in model && "specificationVersion" in model && "doEmbed" in model && model.specificationVersion === "v3";
+const isImageModel = (model) => isObject(model) && "provider" in model && "modelId" in model && "specificationVersion" in model && "doGenerate" in model && model.specificationVersion === "v3" && !("doStream" in model) && !("doEmbed" in model);
 const isStreamResult = (result) => "stream" in result;
 const isGenerateResult = (result) => "content" in result;
 /**
@@ -38,4 +39,4 @@ const isAbortError = (error) => error instanceof Error && error.name === "AbortE
 const isTimeoutError = (error) => error instanceof Error && error.name === "TimeoutError";
 
 //#endregion
-export { isLanguageModel as a, isResultAttempt as c, isString as d, isTimeoutError as f, isGenerateResult as i, isStreamContentPart as l, isEmbeddingModel as n, isModel as o, isErrorAttempt as r, isObject as s, isAbortError as t, isStreamResult as u };
+export { isImageModel as a, isObject as c, isStreamResult as d, isString as f, isGenerateResult as i, isResultAttempt as l, isEmbeddingModel as n, isLanguageModel as o, isTimeoutError as p, isErrorAttempt as r, isModel as s, isAbortError as t, isStreamContentPart as u };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ai-retry",
-  "version": "1.2.0",
-  "description": "AI SDK Retry",
+  "version": "1.3.0",
+  "description": "Retry and fallback mechanisms for AI SDK",
   "types": "./dist/index.d.mts",
   "type": "module",
   "files": [
@@ -34,6 +34,7 @@
     "@ai-sdk/anthropic": "3.0.23",
     "@ai-sdk/azure": "3.0.19",
     "@ai-sdk/gateway": "3.0.23",
+    "@ai-sdk/google": "^3.0.33",
     "@ai-sdk/groq": "3.0.15",
     "@ai-sdk/openai": "3.0.19",
     "@ai-sdk/test-server": "1.0.3",