ai-retry 1.3.0 → 1.4.0

package/README.md

@@ -478,6 +478,7 @@ Handle image generation failures by switching to a different model.
 
 ```typescript
 import { openai } from '@ai-sdk/openai';
+import { google } from '@ai-sdk/google';
 import { generateImage } from 'ai';
 import { createRetryable } from 'ai-retry';
 import { noImageGenerated } from 'ai-retry/retryables';
@@ -485,7 +486,7 @@ 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
+    noImageGenerated(google.image('gemini-3-pro-image-preview')), // Switch to Gemini if DALL-E fails to generate an image
   ],
 });
 
@@ -792,21 +793,25 @@ The following options can be overridden:
 #### Logging
 
 You can use the following callbacks to log retry attempts and errors:
-- `onError` is invoked if an error occurs. 
+- `onError` is invoked if an error occurs.
 - `onRetry` is invoked before attempting a retry.
+- `onSuccess` is invoked after a successful request with the model that handled it.
 
 ```typescript
 const retryableModel = createRetryable({
   model: openai('gpt-4-mini'),
   retries: [/* your retryables */],
   onError: (context) => {
-    console.error(`Attempt ${context.attempts.length} with ${context.current.model.provider}/${context.current.model.modelId} failed:`, 
+    console.error(`Attempt ${context.attempts.length} with ${context.current.model.provider}/${context.current.model.modelId} failed:`,
       context.current.error
     );
   },
   onRetry: (context) => {
     console.log(`Retrying attempt ${context.attempts.length + 1} with model ${context.current.model.provider}/${context.current.model.modelId}...`);
   },
+  onSuccess: (context) => {
+    console.log(`Request handled by ${context.current.model.provider}/${context.current.model.modelId}`);
+  },
 });
 ```
 
@@ -859,6 +864,9 @@ Errors during streaming requests can occur in two ways:
 
 In the second case, errors during stream processing will not always be retried, because the stream might have already emitted some actual content and the consumer might have processed it. Retrying will be stopped as soon as the first content chunk (e.g. types of `text-delta`, `tool-call`, etc.) is emitted. The type of chunks considered as content are the same as the ones that are passed to [onChunk()](https://github.com/vercel/ai/blob/1fe4bd4144bff927f5319d9d206e782a73979ccb/packages/ai/src/generate-text/stream-text.ts#L684-L697).
 
+> [!IMPORTANT]
+> **Streaming limitation:** Retries and fallbacks only apply before the first content chunk is emitted. Once streaming begins delivering content, the response is committed to the current model. Mid-stream errors will propagate to the caller rather than triggering a fallback. If reliable retries are critical for your use case, consider using `generateText` instead of `streamText`.
+
 ### API Reference
 
 #### `createRetryable(options: RetryableModelOptions): LanguageModelV3 | EmbeddingModelV3 | ImageModelV3`
@@ -873,6 +881,7 @@ interface RetryableModelOptions<MODEL extends LanguageModelV3 | EmbeddingModelV3
   reset?: Reset;
   onError?: (context: RetryContext<MODEL>) => void;
   onRetry?: (context: RetryContext<MODEL>) => void;
+  onSuccess?: (context: SuccessContext<MODEL>) => void;
 }
 ```
 
@@ -883,6 +892,7 @@ interface RetryableModelOptions<MODEL extends LanguageModelV3 | EmbeddingModelV3
 - `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.
+- `onSuccess`: Callback invoked after a successful request. Receives the model that handled the request and all previous attempts.
 
 #### `Reset`
 
@@ -937,6 +947,30 @@ interface RetryContext {
 }
 ```
 
+#### `SuccessContext`
+
+The `SuccessContext` object is passed to the `onSuccess` callback after a successful request.
+
+```typescript
+interface SuccessContext {
+  current: SuccessAttempt;
+  attempts: Array<RetryAttempt>;
+}
+```
+
+#### `SuccessAttempt`
+
+A `SuccessAttempt` represents the successful attempt with the model, result, and call options used. The `result` type depends on the model type.
+
+```typescript
+interface SuccessAttempt {
+  type: 'success';
+  model: LanguageModelV3 | EmbeddingModelV3 | ImageModelV3;
+  result: LanguageModelGenerate | LanguageModelStream | EmbeddingModelEmbed | ImageModelGenerate;
+  options: LanguageModelV3CallOptions | EmbeddingModelV3CallOptions | ImageModelV3CallOptions;
+}
+```
+
 #### `RetryAttempt`
 
 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.

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-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 { A as RetryableModelOptions, C as Retries, D as RetryErrorAttempt, E as RetryContext, M as SuccessAttempt, N as SuccessContext, O as RetryResultAttempt, S as Result, T as RetryAttempt, _ as ProviderOptions, a as EmbeddingModelRetryCallOptions, b as ResolvableModel, c as ImageModelCallOptions, d as LanguageModel, f as LanguageModelCallOptions, g as LanguageModelStreamPart, h as LanguageModelStream, i as EmbeddingModelEmbed, j as RetryableOptions, k as Retryable, l as ImageModelGenerate, m as LanguageModelRetryCallOptions, n as EmbeddingModel, o as GatewayLanguageModelId, p as LanguageModelGenerate, r as EmbeddingModelCallOptions, s as ImageModel, t as CallOptions, u as ImageModelRetryCallOptions, v as Reset, w as Retry, x as ResolvedModel, y as ResolvableLanguageModel } from "./types-CqvBIDad.mjs";
 import * as _ai_sdk_provider0 from "@ai-sdk/provider";
 
 //#region src/create-retryable-model.d.ts
@@ -75,4 +75,4 @@ declare const isAbortError: (error: unknown) => boolean;
  */
 declare const isTimeoutError: (error: unknown) => boolean;
 //#endregion
-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 };
+export { CallOptions, EmbeddingModel, EmbeddingModelCallOptions, EmbeddingModelEmbed, EmbeddingModelRetryCallOptions, GatewayLanguageModelId, ImageModel, ImageModelCallOptions, ImageModelGenerate, ImageModelRetryCallOptions, LanguageModel, LanguageModelCallOptions, LanguageModelGenerate, LanguageModelRetryCallOptions, LanguageModelStream, LanguageModelStreamPart, ProviderOptions, Reset, ResolvableLanguageModel, ResolvableModel, ResolvedModel, Result, Retries, Retry, RetryAttempt, RetryContext, RetryErrorAttempt, RetryResultAttempt, Retryable, RetryableModelOptions, RetryableOptions, SuccessAttempt, SuccessContext, createRetryable, getModelKey, isAbortError, isEmbeddingModel, isErrorAttempt, isGenerateResult, isImageModel, isLanguageModel, isModel, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString, isTimeoutError };

package/dist/index.mjs

@@ -256,7 +256,8 @@ var RetryableEmbeddingModel = class extends BaseRetryableModel {
 			try {
 				return {
 					result: await input.fn(retryCallOptions),
-					attempts
+					attempts,
+					callOptions: retryCallOptions
 				};
 			} catch (error) {
 				if (isAbortError(error)) throw error;
@@ -322,13 +323,22 @@ var RetryableEmbeddingModel = class extends BaseRetryableModel {
 		* If retries are disabled, bypass retry machinery entirely
 		*/
 		if (this.isDisabled()) return this.currentModel.doEmbed(callOptions);
-		const { result } = await this.withRetry({
+		const { result, attempts, callOptions: finalCallOptions } = await this.withRetry({
 			fn: async (retryCallOptions) => {
 				return this.currentModel.doEmbed(retryCallOptions);
 			},
 			callOptions
 		});
 		this.updateStickyModel(startModel);
+		this.options.onSuccess?.({
+			current: {
+				type: "success",
+				model: this.currentModel,
+				result,
+				options: finalCallOptions
+			},
+			attempts
+		});
 		return result;
 	}
 };
@@ -400,7 +410,8 @@ var RetryableImageModel = class extends BaseRetryableModel {
 			try {
 				return {
 					result: await input.fn(retryCallOptions),
-					attempts
+					attempts,
+					callOptions: retryCallOptions
 				};
 			} catch (error) {
 				/** Don't retry if user manually aborted the request. */
@@ -468,13 +479,22 @@ var RetryableImageModel = class extends BaseRetryableModel {
 		* If retries are disabled, bypass retry machinery entirely
 		*/
 		if (this.isDisabled()) return this.currentModel.doGenerate(callOptions);
-		const { result } = await this.withRetry({
+		const { result, attempts, callOptions: finalCallOptions } = await this.withRetry({
 			fn: async (retryCallOptions) => {
 				return this.currentModel.doGenerate(retryCallOptions);
 			},
 			callOptions
 		});
 		this.updateStickyModel(startModel);
+		this.options.onSuccess?.({
+			current: {
+				type: "success",
+				model: this.currentModel,
+				result,
+				options: finalCallOptions
+			},
+			attempts
+		});
 		return result;
 	}
 };
@@ -582,7 +602,8 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 				}
 				return {
 					result,
-					attempts
+					attempts,
+					callOptions: retryCallOptions
 				};
 			} catch (error) {
 				if (isAbortError(error)) throw error;
@@ -663,13 +684,22 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 		* If retries are disabled, bypass retry machinery entirely
 		*/
 		if (this.isDisabled()) return this.currentModel.doGenerate(callOptions);
-		const { result } = await this.withRetry({
+		const { result, attempts, callOptions: finalCallOptions } = await this.withRetry({
 			fn: async (retryCallOptions) => {
 				return this.currentModel.doGenerate(retryCallOptions);
 			},
 			callOptions
 		});
 		this.updateStickyModel(startModel);
+		this.options.onSuccess?.({
+			current: {
+				type: "success",
+				model: this.currentModel,
+				result,
+				options: finalCallOptions
+			},
+			attempts
+		});
 		return result;
 	}
 	async doStream(callOptions) {
@@ -685,13 +715,22 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 		/**
 		* Perform the initial call to doStream with retry logic to handle errors before any data is streamed.
 		*/
-		let { result, attempts } = await this.withRetry({
+		let { result, attempts, callOptions: finalCallOptions } = await this.withRetry({
 			fn: async (retryCallOptions) => {
 				return this.currentModel.doStream(retryCallOptions);
 			},
 			callOptions
 		});
 		this.updateStickyModel(startModel);
+		this.options.onSuccess?.({
+			current: {
+				type: "success",
+				model: this.currentModel,
+				result,
+				options: finalCallOptions
+			},
+			attempts
+		});
 		/**
 		* Track the current retry model for computing call options in the stream handler
 		*/

package/dist/retryables/index.d.mts

@@ -1,4 +1,4 @@
-import { D as Retryable, k as RetryableOptions, o as ImageModel, t as EmbeddingModel, v as ResolvableLanguageModel } from "../types-wEZKtEcH.mjs";
+import { j as RetryableOptions, k as Retryable, n as EmbeddingModel, s as ImageModel, y as ResolvableLanguageModel } from "../types-CqvBIDad.mjs";
 
 //#region src/retryables/content-filter-triggered.d.ts
 /**

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

@@ -26,6 +26,14 @@ type EmbeddingModelRetryCallOptions = Partial<Pick<EmbeddingModelCallOptions, 'v
  * Call options that can be overridden during retry for image models.
  */
 type ImageModelRetryCallOptions = Partial<Pick<ImageModelCallOptions, 'n' | 'size' | 'aspectRatio' | 'seed' | 'headers' | 'providerOptions'>>;
+/**
+ * Maps a model type to its call options type.
+ */
+type CallOptions<MODEL extends LanguageModel | EmbeddingModel | ImageModel> = MODEL extends LanguageModel ? LanguageModelCallOptions : MODEL extends EmbeddingModel ? EmbeddingModelCallOptions : ImageModelCallOptions;
+/**
+ * Maps a model type to its result type.
+ */
+type Result<MODEL extends LanguageModel | EmbeddingModel | ImageModel> = MODEL extends LanguageModel ? LanguageModelGenerate | LanguageModelStream : MODEL extends EmbeddingModel ? EmbeddingModelEmbed : ImageModelGenerate;
 /**
  * A retry attempt with an error
  */
@@ -37,7 +45,7 @@ type RetryErrorAttempt<MODEL extends LanguageModel | EmbeddingModel | ImageModel
   /**
    * The call options used for this attempt.
    */
-  options: MODEL extends LanguageModel ? LanguageModelCallOptions : MODEL extends EmbeddingModel ? EmbeddingModelCallOptions : ImageModelCallOptions;
+  options: CallOptions<MODEL>;
 };
 /**
  * A retry attempt with a successful result
@@ -69,6 +77,28 @@ type RetryContext<MODEL extends ResolvableLanguageModel | EmbeddingModel | Image
    */
   attempts: Array<RetryAttempt<ResolvedModel<MODEL>>>;
 };
+/**
+ * A successful attempt with the result
+ */
+type SuccessAttempt<MODEL extends LanguageModel | EmbeddingModel | ImageModel> = {
+  type: 'success';
+  model: MODEL;
+  result: Result<MODEL>;
+  options: CallOptions<MODEL>;
+};
+/**
+ * The context provided to onSuccess with the successful attempt and all previous attempts.
+ */
+type SuccessContext<MODEL extends ResolvableLanguageModel | EmbeddingModel | ImageModel> = {
+  /**
+   * The successful attempt
+   */
+  current: SuccessAttempt<ResolvedModel<MODEL>>;
+  /**
+   * All attempts made so far, including the current one
+   */
+  attempts: Array<RetryAttempt<ResolvedModel<MODEL>>>;
+};
 /**
  * Options for creating a retryable model.
  */
@@ -84,6 +114,7 @@ interface RetryableModelOptions<MODEL extends LanguageModel | EmbeddingModel | I
   reset?: Reset;
   onError?: (context: RetryContext<MODEL>) => void;
   onRetry?: (context: RetryContext<MODEL>) => void;
+  onSuccess?: (context: SuccessContext<MODEL>) => void;
 }
 /**
  * A model to retry with and the maximum number of attempts for that model.
@@ -147,4 +178,4 @@ type EmbeddingModelCallOptions = Parameters<EmbeddingModel['doEmbed']>[0];
 type EmbeddingModelEmbed = Awaited<ReturnType<EmbeddingModel['doEmbed']>>;
 type ImageModelGenerate = Awaited<ReturnType<ImageModel['doGenerate']>>;
 //#endregion
-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 };
+export { RetryableModelOptions as A, Retries as C, RetryErrorAttempt as D, RetryContext as E, SuccessAttempt as M, SuccessContext as N, RetryResultAttempt as O, Result as S, RetryAttempt as T, ProviderOptions as _, EmbeddingModelRetryCallOptions as a, ResolvableModel as b, ImageModelCallOptions as c, LanguageModel as d, LanguageModelCallOptions as f, LanguageModelStreamPart as g, LanguageModelStream as h, EmbeddingModelEmbed as i, RetryableOptions as j, Retryable as k, ImageModelGenerate as l, LanguageModelRetryCallOptions as m, EmbeddingModel as n, GatewayLanguageModelId as o, LanguageModelGenerate as p, EmbeddingModelCallOptions as r, ImageModel as s, CallOptions as t, ImageModelRetryCallOptions as u, Reset as v, Retry as w, ResolvedModel as x, ResolvableLanguageModel as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-retry",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Retry and fallback mechanisms for AI SDK",
   "types": "./dist/index.d.mts",
   "type": "module",
@@ -28,7 +28,10 @@
     "url": "git+https://github.com/zirkelc/ai-retry.git"
   },
   "peerDependencies": {
-    "ai": "6.x"
+    "@ai-sdk/provider": "^3.0.0",
+    "@ai-sdk/provider-utils": "^4.0.0",
+    "ai": "6.x",
+    "zod": "^4.0.0"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "3.0.23",
@@ -37,6 +40,8 @@
     "@ai-sdk/google": "^3.0.33",
     "@ai-sdk/groq": "3.0.15",
     "@ai-sdk/openai": "3.0.19",
+    "@ai-sdk/provider": "3.0.5",
+    "@ai-sdk/provider-utils": "4.0.9",
     "@ai-sdk/test-server": "1.0.3",
     "@arethetypeswrong/cli": "^0.18.2",
     "@biomejs/biome": "^2.3.13",
@@ -50,11 +55,7 @@
     "tsdown": "^0.20.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
-  },
-  "dependencies": {
-    "@ai-sdk/provider": "3.0.5",
-    "@ai-sdk/provider-utils": "4.0.9",
+    "vitest": "^4.0.18",
     "zod": "^4.3.6"
   },
   "scripts": {