ai-retry 1.1.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:
@@ -757,6 +810,46 @@ const retryableModel = createRetryable({
 });
 ```
 
+#### Reset
+
+By default, every new request starts with the base model, even if a previous request was retried with a different model. The `reset` option changes this behavior by making the last successfully retried model **sticky**, that means subsequent requests will continue using that model instead of switching back to the base model. The reset value controls how long the retry model stays sticky before resetting back to the base model.
+
+| 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 |
+
+##### 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
+});
+```
+
+##### Keep the retry model for N requests
+
+```typescript
+const retryableModel = createRetryable({
+  model: openai('gpt-4o-mini'),
+  retries: [anthropic('claude-sonnet-4-20250514')],
+  reset: 'after-5-requests', // use the retry model for 5 more requests before resetting
+});
+```
+
+##### Keep the retry model for N seconds
+
+```typescript
+const retryableModel = createRetryable({
+  model: openai('gpt-4o-mini'),
+  retries: [anthropic('claude-sonnet-4-20250514')],
+  reset: 'after-30-seconds', // use the retry model for 30 seconds before resetting
+});
+```
+
 ### Streaming
 
 Errors during streaming requests can occur in two ways:
@@ -768,15 +861,16 @@ 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);
+  reset?: Reset;
   onError?: (context: RetryContext<MODEL>) => void;
   onRetry?: (context: RetryContext<MODEL>) => void;
 }
@@ -786,9 +880,25 @@ 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. Default: `after-request`.
 - `onError`: Callback invoked when an error occurs.
 - `onRetry`: Callback invoked before attempting a retry.
 
+#### `Reset`
+
+Controls when the sticky model resets back to the base model after a successful retry.
+
+```ts
+type Reset =
+  | 'after-request'
+  | `after-${number}-requests`
+  | `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.
+
 #### `Retryable`
 
 A `Retryable` is a function that receives a `RetryContext` with the current error or result and model and all previous attempts.
@@ -802,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
 }
 ```
 
@@ -832,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 RetryableModelOptions, S as Retryable, _ as Retry, a as GatewayLanguageModelId, b as RetryErrorAttempt, c as LanguageModelGenerate, d as LanguageModelStreamPart, f as ProviderOptions, g as Retries, h as ResolvedModel, i as EmbeddingModelRetryCallOptions, l as LanguageModelRetryCallOptions, m as ResolvableModel, n as EmbeddingModelCallOptions, o as LanguageModel, p as ResolvableLanguageModel, r as EmbeddingModelEmbed, s as LanguageModelCallOptions, t as EmbeddingModel, u as LanguageModelStream, v as RetryAttempt, w as RetryableOptions, x as RetryResultAttempt, y as RetryContext } from "./types-Bty5BU37.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, 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,8 +1,88 @@
-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";
 
+//#region src/parse-reset.ts
+/**
+* Parses a `Reset` string into a structured object.
+*
+* `'after-request'` is treated as `{ type: 'requests', count: 0 }`,
+* meaning the sticky model expires immediately (default behavior).
+*
+* @example
+* parseReset(`after-request`);      // { type: 'requests', count: 0 }
+* parseReset(`after-5-requests`);   // { type: 'requests', count: 5 }
+* parseReset(`after-30-seconds`);   // { type: 'seconds', count: 30 }
+*/
+function parseReset(reset) {
+	if (reset === `after-request`) return {
+		type: `requests`,
+		count: 0
+	};
+	const requestsMatch = reset.match(/^after-(\d+)-requests$/);
+	if (requestsMatch) return {
+		type: `requests`,
+		count: Number.parseInt(requestsMatch[1], 10)
+	};
+	const secondsMatch = reset.match(/^after-(\d+)-seconds$/);
+	if (secondsMatch) return {
+		type: `seconds`,
+		count: Number.parseInt(secondsMatch[1], 10)
+	};
+	throw new Error(`Invalid reset option: ${reset}`);
+}
+
+//#endregion
+//#region src/base-retryable-model.ts
+var BaseRetryableModel = class {
+	baseModel;
+	currentModel;
+	options;
+	parsedReset;
+	/** The model that last succeeded via retry, used for subsequent requests. */
+	stickyState;
+	constructor(options) {
+		this.options = options;
+		this.baseModel = options.model;
+		this.currentModel = options.model;
+		this.parsedReset = parseReset(options.reset ?? `after-request`);
+	}
+	/**
+	* Determine which model to start the request with,
+	* considering the sticky model and reset policy.
+	*/
+	resolveStartModel() {
+		if (!this.stickyState) return this.baseModel;
+		if (this.parsedReset.type === `requests`) {
+			if (this.stickyState.requestsRemaining > 0) {
+				this.stickyState.requestsRemaining--;
+				return this.stickyState.model;
+			}
+		} else if (Date.now() - this.stickyState.setAt < this.parsedReset.count * 1e3) return this.stickyState.model;
+		this.stickyState = void 0;
+		return this.baseModel;
+	}
+	/**
+	* After a successful request, update sticky model if a retry occurred.
+	*/
+	updateStickyModel(startModel) {
+		if (this.currentModel !== startModel) this.stickyState = {
+			model: this.currentModel,
+			setAt: Date.now(),
+			requestsRemaining: this.parsedReset.type === `requests` ? this.parsedReset.count : 0
+		};
+	}
+	/**
+	* Check if retries are disabled
+	*/
+	isDisabled() {
+		if (this.options.disabled === void 0) return false;
+		return typeof this.options.disabled === `function` ? this.options.disabled() : this.options.disabled;
+	}
+};
+
+//#endregion
 //#region src/calculate-exponential-backoff.ts
 /**
 * Calculates the exponential backoff delay.
@@ -14,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}`;
@@ -30,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);
@@ -53,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.
@@ -100,11 +191,8 @@ function prepareRetryError(error, attempts) {
 
 //#endregion
 //#region src/retryable-embedding-model.ts
-var RetryableEmbeddingModel = class {
+var RetryableEmbeddingModel = class extends BaseRetryableModel {
 	specificationVersion = "v3";
-	baseModel;
-	currentModel;
-	options;
 	get modelId() {
 		return this.currentModel.modelId;
 	}
@@ -117,18 +205,6 @@ var RetryableEmbeddingModel = class {
 	get supportsParallelCalls() {
 		return this.currentModel.supportsParallelCalls;
 	}
-	constructor(options) {
-		this.options = options;
-		this.baseModel = options.model;
-		this.currentModel = options.model;
-	}
-	/**
-	* Check if retries are disabled
-	*/
-	isDisabled() {
-		if (this.options.disabled === void 0) return false;
-		return typeof this.options.disabled === "function" ? this.options.disabled() : this.options.disabled;
-	}
 	/**
 	* Get the retry call options overrides from a retry configuration.
 	*/
@@ -238,9 +314,10 @@ var RetryableEmbeddingModel = class {
 	}
 	async doEmbed(callOptions) {
 		/**
-		* Always start with the original model
+		* Resolve the starting model (base or sticky)
 		*/
-		this.currentModel = this.baseModel;
+		const startModel = this.resolveStartModel();
+		this.currentModel = startModel;
 		/**
 		* If retries are disabled, bypass retry machinery entirely
 		*/
@@ -251,37 +328,169 @@ var RetryableEmbeddingModel = class {
 			},
 			callOptions
 		});
+		this.updateStickyModel(startModel);
 		return result;
 	}
 };
 
 //#endregion
-//#region src/retryable-language-model.ts
-var RetryableLanguageModel = class {
+//#region src/retryable-image-model.ts
+var RetryableImageModel = class extends BaseRetryableModel {
 	specificationVersion = "v3";
-	baseModel;
-	currentModel;
-	options;
 	get modelId() {
 		return this.currentModel.modelId;
 	}
 	get provider() {
 		return this.currentModel.provider;
 	}
-	get supportedUrls() {
-		return this.currentModel.supportedUrls;
+	get maxImagesPerCall() {
+		return this.currentModel.maxImagesPerCall;
 	}
-	constructor(options) {
-		this.options = options;
-		this.baseModel = options.model;
-		this.currentModel = options.model;
+	/**
+	* 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
+		};
 	}
 	/**
-	* Check if retries are disabled
+	* Execute a function with retry logic for handling errors
 	*/
-	isDisabled() {
-		if (this.options.disabled === void 0) return false;
-		return typeof this.options.disabled === "function" ? this.options.disabled() : this.options.disabled;
+	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 {
+	specificationVersion = "v3";
+	get modelId() {
+		return this.currentModel.modelId;
+	}
+	get provider() {
+		return this.currentModel.provider;
+	}
+	get supportedUrls() {
+		return this.currentModel.supportedUrls;
 	}
 	/**
 	* Get the retry call options overrides from a retry configuration.
@@ -446,9 +655,10 @@ var RetryableLanguageModel = class {
 	}
 	async doGenerate(callOptions) {
 		/**
-		* Always start with the original model
+		* Resolve the starting model (base or sticky)
 		*/
-		this.currentModel = this.baseModel;
+		const startModel = this.resolveStartModel();
+		this.currentModel = startModel;
 		/**
 		* If retries are disabled, bypass retry machinery entirely
 		*/
@@ -459,13 +669,15 @@ var RetryableLanguageModel = class {
 			},
 			callOptions
 		});
+		this.updateStickyModel(startModel);
 		return result;
 	}
 	async doStream(callOptions) {
 		/**
-		* Always start with the original model
+		* Resolve the starting model (base or sticky)
 		*/
-		this.currentModel = this.baseModel;
+		const startModel = this.resolveStartModel();
+		this.currentModel = startModel;
 		/**
 		* If retries are disabled, bypass retry machinery entirely
 		*/
@@ -479,6 +691,7 @@ var RetryableLanguageModel = class {
 			},
 			callOptions
 		});
+		this.updateStickyModel(startModel);
 		/**
 		* Track the current retry model for computing call options in the stream handler
 		*/
@@ -554,6 +767,7 @@ var RetryableLanguageModel = class {
 				await reader?.cancel();
 				result = retriedResult.result;
 				attempts = retriedResult.attempts;
+				this.updateStickyModel(startModel);
 			} finally {
 				reader?.releaseLock();
 			}
@@ -573,6 +787,10 @@ function createRetryable(options) {
 		...options,
 		model
 	});
+	if (isImageModel(model)) return new RetryableImageModel({
+		...options,
+		model
+	});
 	return new RetryableLanguageModel({
 		...options,
 		model
@@ -580,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 { S as Retryable, p as ResolvableLanguageModel, t as EmbeddingModel, w as RetryableOptions } from "../types-Bty5BU37.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 { S as Retryable, p as ResolvableLanguageModel, t as EmbeddingModel, w as
  */
 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-Bty5BU37.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,10 +72,16 @@ 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);
+  /**
+   * Controls when to reset back to the base model after a successful retry.
+   *
+   * @default 'after-request'
+   */
+  reset?: Reset;
   onError?: (context: RetryContext<MODEL>) => void;
   onRetry?: (context: RetryContext<MODEL>) => void;
 }
@@ -84,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.
@@ -106,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.
@@ -118,12 +130,21 @@ 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.
+ *
+ * - `'after-request'` — reset after each request (default, current behavior)
+ * - `` `after-${number}-requests` `` — use the retry model for the next N requests
+ * - `` `after-${number}-seconds` `` — use the retry model for the next N seconds
+ */
+type Reset = 'after-request' | `after-${number}-requests` | `after-${number}-seconds`;
 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 { RetryableModelOptions as C, Retryable as S, Retry as _, GatewayLanguageModelId as a, RetryErrorAttempt as b, LanguageModelGenerate as c, LanguageModelStreamPart as d, ProviderOptions as f, Retries as g, ResolvedModel as h, EmbeddingModelRetryCallOptions as i, LanguageModelRetryCallOptions as l, ResolvableModel as m, EmbeddingModelCallOptions as n, LanguageModel as o, ResolvableLanguageModel as p, EmbeddingModelEmbed as r, LanguageModelCallOptions as s, EmbeddingModel as t, LanguageModelStream as u, RetryAttempt as v, RetryableOptions as w, RetryResultAttempt as x, RetryContext 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.1.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",