ai-retry 1.9.1 → 1.10.0

package/README.md

@@ -1026,6 +1026,7 @@ You can use the following callbacks to log retry attempts and errors:
 - `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.
+- `onFailure` is invoked when the request ultimately fails and no retry could recover it.
 
 ```typescript
 const retryableModel = createRetryable({
@@ -1049,9 +1050,17 @@ const retryableModel = createRetryable({
       `Request handled by ${context.current.model.provider}/${context.current.model.modelId}`,
     );
   },
+  onFailure: (context) => {
+    console.error(
+      `Request failed after ${context.attempts.length} attempts:`,
+      context.error,
+    );
+  },
 });
 ```
 
+`onSuccess` and `onFailure` are counterparts: exactly one of them is invoked per request once its final outcome is known. `onFailure` fires when the error could not be recovered by a retry, whether because no retryable matched, all retries were exhausted, or the retry itself failed. `context.error` is the error surfaced to the caller (a [`RetryError`](#all-retries-failed) wrapping every attempt error when more than one attempt was made, otherwise the original error), and `context.current` is the final failed attempt. Neither callback fires when retries are disabled.
+
 #### 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.
@@ -1210,6 +1219,7 @@ interface RetryableModelOptions<
     context: RetryContext<MODEL>,
   ) => void | OnRetryOverrides<MODEL> | Promise<void | OnRetryOverrides<MODEL>>;
   onSuccess?: (context: SuccessContext<MODEL>) => void;
+  onFailure?: (context: FailureContext<MODEL>) => void;
 }
 ```
 
@@ -1223,6 +1233,7 @@ interface RetryableModelOptions<
 - `onError`: Callback invoked when an error occurs.
 - `onRetry`: Callback invoked before attempting a retry. May optionally return an `OnRetryOverrides` object (or a `Promise` of one) to override `options.*` for the upcoming attempt only. See [Dynamic Call Options via `onRetry`](#dynamic-call-options-via-onretry).
 - `onSuccess`: Callback invoked after a successful request. Receives the model that handled the request and all previous attempts.
+- `onFailure`: Callback invoked when the request ultimately fails and no retry could recover it (no retryable matched, all retries exhausted, or the retry itself failed).
 
 #### `Reset`
 
@@ -1309,6 +1320,18 @@ interface SuccessAttempt {
 }
 ```
 
+#### `FailureContext`
+
+The `FailureContext` object is passed to the `onFailure` callback when a request ultimately fails. `current` is the final failed attempt (an error attempt, see [`RetryAttempt`](#retryattempt)) and `error` is the error surfaced to the caller, a [`RetryError`](#all-retries-failed) wrapping every attempt error when more than one attempt was made, otherwise the original error.
+
+```typescript
+interface FailureContext {
+  current: RetryErrorAttempt;
+  attempts: Array<RetryAttempt>;
+  error: unknown;
+}
+```
+
 #### `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/{create-retryable-model-Ch2cqC3Z.mjs → create-retryable-model-D36IQyOQ.mjs}

@@ -515,14 +515,13 @@ var RetryableEmbeddingModel = class extends BaseRetryableModel {
 					callOptions: retryCallOptions
 				};
 			} catch (error) {
+				const { retryModel, attempt, finalError } = await this.handleError(error, attempts, retryCallOptions);
+				attempts.push(attempt);
 				/**
-				* `handleError` throws when no retry matched. Record the attempt as
-				* failed before that error propagates.
+				* No retry matched. Record the attempt as failed and throw the
+				* surfaced error.
 				*/
-				let decision;
-				try {
-					decision = await this.handleError(error, attempts, retryCallOptions);
-				} catch (finalError) {
+				if (!retryModel) {
 					input.recorder?.endAttempt({
 						attempt: attemptNumber,
 						outcome: "failure",
@@ -530,8 +529,6 @@ var RetryableEmbeddingModel = class extends BaseRetryableModel {
 					});
 					throw finalError;
 				}
-				const { retryModel, attempt } = decision;
-				attempts.push(attempt);
 				/**
 				* If the inbound abort signal is already aborted and the chosen
 				* retry does not supply a fresh deadline, the retry would die
@@ -587,19 +584,26 @@ var RetryableEmbeddingModel = class extends BaseRetryableModel {
 		};
 		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
+			attempt: errorAttempt,
+			finalError: retryModel ? void 0 : updatedAttempts.length > 1 ? prepareRetryError(error, updatedAttempts) : error
 		};
 	}
+	/**
+	* Fire the `onFailure` callback for a terminally failed operation. The
+	* final attempt (last entry of `attempts`) is surfaced as `current`.
+	*/
+	emitFailure(attempts, error) {
+		if (!this.options.onFailure) return;
+		const current = attempts.at(-1);
+		if (!current) return;
+		this.options.onFailure({
+			current,
+			attempts,
+			error
+		});
+	}
 	async doEmbed(callOptions) {
 		/**
 		* Resolve the starting model (base or sticky)
@@ -616,13 +620,19 @@ var RetryableEmbeddingModel = class extends BaseRetryableModel {
 			provider: startModel.provider,
 			modelId: startModel.modelId
 		});
+		/**
+		* Shared attempts array, threaded into `withRetry` so it stays populated
+		* (including the final failed attempt) when the retry loop throws.
+		*/
+		const attempts = [];
 		let operationError;
 		try {
-			const { result, attempts, callOptions: finalCallOptions } = await this.withRetry({
+			const { result, callOptions: finalCallOptions } = await this.withRetry({
 				fn: async (retryCallOptions) => {
 					return this.currentModel.doEmbed(retryCallOptions);
 				},
 				callOptions,
+				attempts,
 				recorder
 			});
 			this.updateStickyModel(startModel);
@@ -638,6 +648,7 @@ var RetryableEmbeddingModel = class extends BaseRetryableModel {
 			return result;
 		} catch (error) {
 			operationError = error;
+			this.emitFailure(attempts, error);
 			throw error;
 		} finally {
 			recorder?.endOperation({
@@ -729,14 +740,13 @@ var RetryableImageModel = class extends BaseRetryableModel {
 					callOptions: retryCallOptions
 				};
 			} catch (error) {
+				const { retryModel, attempt, finalError } = await this.handleError(error, attempts, retryCallOptions);
+				attempts.push(attempt);
 				/**
-				* `handleError` throws when no retry matched. Record the attempt as
-				* failed before that error propagates.
+				* No retry matched. Record the attempt as failed and throw the
+				* surfaced error.
 				*/
-				let decision;
-				try {
-					decision = await this.handleError(error, attempts, retryCallOptions);
-				} catch (finalError) {
+				if (!retryModel) {
 					input.recorder?.endAttempt({
 						attempt: attemptNumber,
 						outcome: "failure",
@@ -744,8 +754,6 @@ var RetryableImageModel = class extends BaseRetryableModel {
 					});
 					throw finalError;
 				}
-				const { retryModel, attempt } = decision;
-				attempts.push(attempt);
 				/**
 				* If the inbound abort signal is already aborted and the chosen
 				* retry does not supply a fresh deadline, the retry would die
@@ -801,19 +809,26 @@ var RetryableImageModel = class extends BaseRetryableModel {
 		};
 		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
+			attempt: errorAttempt,
+			finalError: retryModel ? void 0 : updatedAttempts.length > 1 ? prepareRetryError(error, updatedAttempts) : error
 		};
 	}
+	/**
+	* Fire the `onFailure` callback for a terminally failed operation. The
+	* final attempt (last entry of `attempts`) is surfaced as `current`.
+	*/
+	emitFailure(attempts, error) {
+		if (!this.options.onFailure) return;
+		const current = attempts.at(-1);
+		if (!current) return;
+		this.options.onFailure({
+			current,
+			attempts,
+			error
+		});
+	}
 	async doGenerate(callOptions) {
 		/**
 		* Resolve the starting model (base or sticky)
@@ -830,13 +845,19 @@ var RetryableImageModel = class extends BaseRetryableModel {
 			provider: startModel.provider,
 			modelId: startModel.modelId
 		});
+		/**
+		* Shared attempts array, threaded into `withRetry` so it stays populated
+		* (including the final failed attempt) when the retry loop throws.
+		*/
+		const attempts = [];
 		let operationError;
 		try {
-			const { result, attempts, callOptions: finalCallOptions } = await this.withRetry({
+			const { result, callOptions: finalCallOptions } = await this.withRetry({
 				fn: async (retryCallOptions) => {
 					return this.currentModel.doGenerate(retryCallOptions);
 				},
 				callOptions,
+				attempts,
 				recorder
 			});
 			this.updateStickyModel(startModel);
@@ -852,6 +873,7 @@ var RetryableImageModel = class extends BaseRetryableModel {
 			return result;
 		} catch (error) {
 			operationError = error;
+			this.emitFailure(attempts, error);
 			throw error;
 		} finally {
 			recorder?.endOperation({
@@ -1080,6 +1102,20 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 			finalError: retryModel ? void 0 : updatedAttempts.length > 1 ? prepareRetryError(error, updatedAttempts) : error
 		};
 	}
+	/**
+	* Fire the `onFailure` callback for a terminally failed operation. The
+	* final attempt (last entry of `attempts`) is surfaced as `current`.
+	*/
+	emitFailure(attempts, error) {
+		if (!this.options.onFailure) return;
+		const current = attempts.at(-1);
+		if (!current || !isErrorAttempt(current)) return;
+		this.options.onFailure({
+			current,
+			attempts,
+			error
+		});
+	}
 	async doGenerate(callOptions) {
 		/**
 		* Resolve the starting model (base or sticky)
@@ -1096,13 +1132,19 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 			provider: startModel.provider,
 			modelId: startModel.modelId
 		});
+		/**
+		* Shared attempts array, threaded into `withRetry` so it stays populated
+		* (including the final failed attempt) when the retry loop throws.
+		*/
+		const attempts = [];
 		let operationError;
 		try {
-			const { result, attempts, callOptions: finalCallOptions } = await this.withRetry({
+			const { result, callOptions: finalCallOptions } = await this.withRetry({
 				fn: async (retryCallOptions) => {
 					return this.currentModel.doGenerate(retryCallOptions);
 				},
 				callOptions,
+				attempts,
 				recorder
 			});
 			this.updateStickyModel(startModel);
@@ -1118,6 +1160,7 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 			return result;
 		} catch (error) {
 			operationError = error;
+			this.emitFailure(attempts, error);
 			throw error;
 		} finally {
 			recorder?.endOperation({
@@ -1147,7 +1190,11 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 		* Perform the initial call to doStream with retry logic to handle errors before any data is streamed.
 		*/
 		let result;
-		let attempts;
+		/**
+		* Shared attempts array, threaded into `withRetry` so it stays populated
+		* (including the final failed attempt) when the retry loop throws.
+		*/
+		let attempts = [];
 		let finalCallOptions;
 		/**
 		* The open attempt span for the stream currently being consumed, closed
@@ -1160,6 +1207,7 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 					return this.currentModel.doStream(retryCallOptions);
 				},
 				callOptions,
+				attempts,
 				recorder
 			});
 			result = initial.result;
@@ -1171,6 +1219,7 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 			* Every pre-stream attempt failed; record the operation failure before
 			* the error propagates to the caller.
 			*/
+			this.emitFailure(attempts, error);
 			recorder?.endOperation({
 				provider: this.currentModel.provider,
 				modelId: this.currentModel.modelId,
@@ -1386,6 +1435,7 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 								error
 							});
 							operationError = finalError;
+							this.emitFailure(attempts, finalError);
 							controller.enqueue({
 								type: "error",
 								error: finalError
@@ -1406,6 +1456,7 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 								error
 							});
 							operationError = error;
+							this.emitFailure(attempts, error);
 							controller.enqueue({
 								type: "error",
 								error

package/dist/{error-CoF13EJO.d.mts → error-B-rjhfG_.d.mts}

@@ -1,4 +1,4 @@
-import { E as Retry, N as Retryable, k as RetryContext, n as EmbeddingModel, s as ImageModel, x as ResolvableLanguageModel } from "./types-ydxC71oc.mjs";
+import { A as RetryContext, D as Retry, P as Retryable, S as ResolvableLanguageModel, c as ImageModel, n as EmbeddingModel } from "./types-Dik-mH20.mjs";
 
 //#region src/experimental/internal/condition.d.ts
 /**

package/dist/experimental/embedding-model/index.d.mts

@@ -1,5 +1,5 @@
-import { P as RetryableModelOptions, n as EmbeddingModel } from "../../types-ydxC71oc.mjs";
-import "../../error-CoF13EJO.mjs";
+import { F as RetryableModelOptions, n as EmbeddingModel } from "../../types-Dik-mH20.mjs";
+import "../../error-B-rjhfG_.mjs";
 import { aborted, error, httpStatus, timeout } from "./retryables/index.mjs";
 
 //#region src/experimental/embedding-model/index.d.ts

package/dist/experimental/embedding-model/index.mjs

@@ -1,4 +1,4 @@
-import { t as createRetryable$1 } from "../../create-retryable-model-Ch2cqC3Z.mjs";
+import { t as createRetryable$1 } from "../../create-retryable-model-D36IQyOQ.mjs";
 import "../../error-CaTT-xX8.mjs";
 import { aborted, error, httpStatus, timeout } from "./retryables/index.mjs";
 

package/dist/experimental/embedding-model/retryables/index.d.mts

@@ -1,5 +1,5 @@
-import { k as RetryContext } from "../../../types-ydxC71oc.mjs";
-import { n as Condition, t as StatusPattern } from "../../../error-CoF13EJO.mjs";
+import { A as RetryContext } from "../../../types-Dik-mH20.mjs";
+import { n as Condition, t as StatusPattern } from "../../../error-B-rjhfG_.mjs";
 import * as _ai_sdk_provider0 from "@ai-sdk/provider";
 
 //#region src/experimental/embedding-model/retryables/index.d.ts

package/dist/experimental/image-model/index.d.mts

@@ -1,6 +1,6 @@
-import { P as RetryableModelOptions, s as ImageModel } from "../../types-ydxC71oc.mjs";
-import "../../error-CoF13EJO.mjs";
-import { a as noImage, i as timeout, n as error, r as httpStatus, t as aborted } from "../../index-D4w-HLk-.mjs";
+import { F as RetryableModelOptions, c as ImageModel } from "../../types-Dik-mH20.mjs";
+import "../../error-B-rjhfG_.mjs";
+import { a as noImage, i as timeout, n as error, r as httpStatus, t as aborted } from "../../index-ewZ5T6B2.mjs";
 
 //#region src/experimental/image-model/index.d.ts
 declare function createRetryable<MODEL extends ImageModel>(options: RetryableModelOptions<MODEL>): ImageModel;

package/dist/experimental/image-model/index.mjs

@@ -1,4 +1,4 @@
-import { t as createRetryable$1 } from "../../create-retryable-model-Ch2cqC3Z.mjs";
+import { t as createRetryable$1 } from "../../create-retryable-model-D36IQyOQ.mjs";
 import "../../error-CaTT-xX8.mjs";
 import { a as noImage, i as timeout, n as error, r as httpStatus, t as aborted } from "../../retryables-CPAbu_M3.mjs";
 

package/dist/experimental/image-model/retryables/index.d.mts

@@ -1,4 +1,4 @@
-import "../../../types-ydxC71oc.mjs";
-import "../../../error-CoF13EJO.mjs";
-import { a as noImage, i as timeout, n as error, r as httpStatus, t as aborted } from "../../../index-D4w-HLk-.mjs";
+import "../../../types-Dik-mH20.mjs";
+import "../../../error-B-rjhfG_.mjs";
+import { a as noImage, i as timeout, n as error, r as httpStatus, t as aborted } from "../../../index-ewZ5T6B2.mjs";
 export { aborted, error, httpStatus, noImage, timeout };

package/dist/experimental/language-model/index.d.mts

@@ -1,6 +1,6 @@
-import { P as RetryableModelOptions, d as LanguageModel, o as GatewayLanguageModelId } from "../../types-ydxC71oc.mjs";
-import "../../error-CoF13EJO.mjs";
-import { a as result, i as httpStatus, n as error, o as schemaInvalid, r as finishReason, s as timeout, t as aborted } from "../../index-K7qV8HD9.mjs";
+import { F as RetryableModelOptions, f as LanguageModel, s as GatewayLanguageModelId } from "../../types-Dik-mH20.mjs";
+import "../../error-B-rjhfG_.mjs";
+import { a as result, i as httpStatus, n as error, o as schemaInvalid, r as finishReason, s as timeout, t as aborted } from "../../index-DaJrd4dN.mjs";
 
 //#region src/experimental/language-model/index.d.ts
 declare function createRetryable(options: Omit<RetryableModelOptions<LanguageModel>, 'model'> & {

package/dist/experimental/language-model/index.mjs

@@ -1,4 +1,4 @@
-import { t as createRetryable$1 } from "../../create-retryable-model-Ch2cqC3Z.mjs";
+import { t as createRetryable$1 } from "../../create-retryable-model-D36IQyOQ.mjs";
 import "../../error-CaTT-xX8.mjs";
 import { a as result, i as httpStatus, n as error, o as schemaInvalid, r as finishReason, s as timeout, t as aborted } from "../../retryables-M5l_6w9k.mjs";
 

package/dist/experimental/language-model/retryables/index.d.mts

@@ -1,4 +1,4 @@
-import "../../../types-ydxC71oc.mjs";
-import "../../../error-CoF13EJO.mjs";
-import { a as result, i as httpStatus, n as error, o as schemaInvalid, r as finishReason, s as timeout, t as aborted } from "../../../index-K7qV8HD9.mjs";
+import "../../../types-Dik-mH20.mjs";
+import "../../../error-B-rjhfG_.mjs";
+import { a as result, i as httpStatus, n as error, o as schemaInvalid, r as finishReason, s as timeout, t as aborted } from "../../../index-DaJrd4dN.mjs";
 export { aborted, error, finishReason, httpStatus, result, schemaInvalid, timeout };

package/dist/{index-K7qV8HD9.d.mts → index-DaJrd4dN.d.mts}

@@ -1,5 +1,5 @@
-import { k as RetryContext, m as LanguageModelResult, x as ResolvableLanguageModel } from "./types-ydxC71oc.mjs";
-import { n as Condition, t as StatusPattern } from "./error-CoF13EJO.mjs";
+import { A as RetryContext, S as ResolvableLanguageModel, h as LanguageModelResult } from "./types-Dik-mH20.mjs";
+import { n as Condition, t as StatusPattern } from "./error-B-rjhfG_.mjs";
 
 //#region src/experimental/internal/result.d.ts
 /**

package/dist/{index-D4w-HLk-.d.mts → index-ewZ5T6B2.d.mts}

@@ -1,5 +1,5 @@
-import { k as RetryContext, s as ImageModel } from "./types-ydxC71oc.mjs";
-import { n as Condition, t as StatusPattern } from "./error-CoF13EJO.mjs";
+import { A as RetryContext, c as ImageModel } from "./types-Dik-mH20.mjs";
+import { n as Condition, t as StatusPattern } from "./error-B-rjhfG_.mjs";
 import * as _ai_sdk_provider13 from "@ai-sdk/provider";
 
 //#region src/experimental/internal/no-image.d.ts

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { A as RetryErrorAttempt, C as ResolvedModel, D as RetryAttempt, E as Retry, F as RetryableOptions, I as SuccessAttempt, L as SuccessContext, M as RetryTelemetrySettings, N as Retryable, O as RetryCallOptions, P as RetryableModelOptions, S as ResolvableModel, T as Retries, _ as LanguageModelStreamPart, a as EmbeddingModelRetryCallOptions, b as Reset, c as ImageModelCallOptions, d as LanguageModel, f as LanguageModelCallOptions, g as LanguageModelStream, h as LanguageModelRetryCallOptions, i as EmbeddingModelEmbed, j as RetryResultAttempt, k as RetryContext, l as ImageModelGenerate, m as LanguageModelResult, n as EmbeddingModel, o as GatewayLanguageModelId, p as LanguageModelGenerate, r as EmbeddingModelCallOptions, s as ImageModel, t as CallOptions, u as ImageModelRetryCallOptions, v as OnRetryOverrides, w as Result, x as ResolvableLanguageModel, y as ProviderOptions } from "./types-ydxC71oc.mjs";
+import { A as RetryContext, C as ResolvableModel, D as Retry, E as Retries, F as RetryableModelOptions, I as RetryableOptions, L as SuccessAttempt, M as RetryResultAttempt, N as RetryTelemetrySettings, O as RetryAttempt, P as Retryable, R as SuccessContext, S as ResolvableLanguageModel, T as Result, _ as LanguageModelStream, a as EmbeddingModelRetryCallOptions, b as ProviderOptions, c as ImageModel, d as ImageModelRetryCallOptions, f as LanguageModel, g as LanguageModelRetryCallOptions, h as LanguageModelResult, i as EmbeddingModelEmbed, j as RetryErrorAttempt, k as RetryCallOptions, l as ImageModelCallOptions, m as LanguageModelGenerate, n as EmbeddingModel, o as FailureContext, p as LanguageModelCallOptions, r as EmbeddingModelCallOptions, s as GatewayLanguageModelId, t as CallOptions, u as ImageModelGenerate, v as LanguageModelStreamPart, w as ResolvedModel, x as Reset, y as OnRetryOverrides } from "./types-Dik-mH20.mjs";
 
 //#region src/create-retryable-model.d.ts
 declare function createRetryable<MODEL extends LanguageModel>(options: Omit<RetryableModelOptions<LanguageModel>, 'model'> & {
@@ -24,4 +24,4 @@ declare function isErrorAttempt(attempt: RetryAttempt<any>): attempt is RetryErr
  */
 declare function isResultAttempt(attempt: RetryAttempt<any>): attempt is RetryResultAttempt;
 //#endregion
-export { CallOptions, EmbeddingModel, EmbeddingModelCallOptions, EmbeddingModelEmbed, EmbeddingModelRetryCallOptions, GatewayLanguageModelId, ImageModel, ImageModelCallOptions, ImageModelGenerate, ImageModelRetryCallOptions, LanguageModel, LanguageModelCallOptions, LanguageModelGenerate, LanguageModelResult, LanguageModelRetryCallOptions, LanguageModelStream, LanguageModelStreamPart, OnRetryOverrides, ProviderOptions, Reset, ResolvableLanguageModel, ResolvableModel, ResolvedModel, Result, Retries, Retry, RetryAttempt, RetryCallOptions, RetryContext, RetryErrorAttempt, RetryResultAttempt, RetryTelemetrySettings, Retryable, RetryableModelOptions, RetryableOptions, SuccessAttempt, SuccessContext, createRetryable, getModelKey, isErrorAttempt, isResultAttempt };
+export { CallOptions, EmbeddingModel, EmbeddingModelCallOptions, EmbeddingModelEmbed, EmbeddingModelRetryCallOptions, FailureContext, GatewayLanguageModelId, ImageModel, ImageModelCallOptions, ImageModelGenerate, ImageModelRetryCallOptions, LanguageModel, LanguageModelCallOptions, LanguageModelGenerate, LanguageModelResult, LanguageModelRetryCallOptions, LanguageModelStream, LanguageModelStreamPart, OnRetryOverrides, ProviderOptions, Reset, ResolvableLanguageModel, ResolvableModel, ResolvedModel, Result, Retries, Retry, RetryAttempt, RetryCallOptions, RetryContext, RetryErrorAttempt, RetryResultAttempt, RetryTelemetrySettings, Retryable, RetryableModelOptions, RetryableOptions, SuccessAttempt, SuccessContext, createRetryable, getModelKey, isErrorAttempt, isResultAttempt };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { n as getModelKey, t as createRetryable } from "./create-retryable-model-Ch2cqC3Z.mjs";
+import { n as getModelKey, t as createRetryable } from "./create-retryable-model-D36IQyOQ.mjs";
 import { n as isErrorAttempt, s as isResultAttempt } from "./guards-D8UJtxDK.mjs";
 
 export { createRetryable, getModelKey, isErrorAttempt, isResultAttempt };

package/dist/retryables/index.d.mts

@@ -1,4 +1,4 @@
-import { F as RetryableOptions, N as Retryable, n as EmbeddingModel, s as ImageModel, x as ResolvableLanguageModel } from "../types-ydxC71oc.mjs";
+import { I as RetryableOptions, P as Retryable, S as ResolvableLanguageModel, c as ImageModel, n as EmbeddingModel } from "../types-Dik-mH20.mjs";
 
 //#region src/retryables/content-filter-triggered.d.ts
 /**

package/dist/{types-ydxC71oc.d.mts → types-Dik-mH20.d.mts}

@@ -113,6 +113,26 @@ type SuccessContext<MODEL extends ResolvableLanguageModel | EmbeddingModel | Ima
    */
   attempts: Array<RetryAttempt<ResolvedModel<MODEL>>>;
 };
+/**
+ * The context provided to onFailure when an operation terminally fails
+ * (no retry matched, retries exhausted, or the retry itself failed).
+ */
+type FailureContext<MODEL extends ResolvableLanguageModel | EmbeddingModel | ImageModel> = {
+  /**
+   * The final attempt that failed.
+   */
+  current: RetryErrorAttempt<ResolvedModel<MODEL>>;
+  /**
+   * All attempts made, including the final failed one.
+   */
+  attempts: Array<RetryAttempt<ResolvedModel<MODEL>>>;
+  /**
+   * The error surfaced to the caller. When more than one attempt was made,
+   * this is a `RetryError` wrapping every attempt error; otherwise the raw
+   * error.
+   */
+  error: unknown;
+};
 /**
  * Telemetry configuration for retry instrumentation.
  *
@@ -180,6 +200,14 @@ interface RetryableModelOptions<MODEL extends LanguageModel | EmbeddingModel | I
    */
   onRetry?: (context: RetryContext<MODEL>) => void | OnRetryOverrides<MODEL> | Promise<void | OnRetryOverrides<MODEL>>;
   onSuccess?: (context: SuccessContext<MODEL>) => void;
+  /**
+   * Called once when an operation terminally fails and the error could not
+   * be recovered by a retry: no retry matched, all retries were exhausted,
+   * or the retry itself failed. The counterpart to `onSuccess`.
+   *
+   * Not called when retries are disabled.
+   */
+  onFailure?: (context: FailureContext<MODEL>) => void;
 }
 /**
  * A model to retry with and the maximum number of attempts for that model.
@@ -243,4 +271,4 @@ type EmbeddingModelCallOptions = Parameters<EmbeddingModel['doEmbed']>[0];
 type EmbeddingModelEmbed = Awaited<ReturnType<EmbeddingModel['doEmbed']>>;
 type ImageModelGenerate = Awaited<ReturnType<ImageModel['doGenerate']>>;
 //#endregion
-export { RetryErrorAttempt as A, ResolvedModel as C, RetryAttempt as D, Retry as E, RetryableOptions as F, SuccessAttempt as I, SuccessContext as L, RetryTelemetrySettings as M, Retryable as N, RetryCallOptions as O, RetryableModelOptions as P, ResolvableModel as S, Retries as T, LanguageModelStreamPart as _, EmbeddingModelRetryCallOptions as a, Reset as b, ImageModelCallOptions as c, LanguageModel as d, LanguageModelCallOptions as f, LanguageModelStream as g, LanguageModelRetryCallOptions as h, EmbeddingModelEmbed as i, RetryResultAttempt as j, RetryContext as k, ImageModelGenerate as l, LanguageModelResult as m, EmbeddingModel as n, GatewayLanguageModelId as o, LanguageModelGenerate as p, EmbeddingModelCallOptions as r, ImageModel as s, CallOptions as t, ImageModelRetryCallOptions as u, OnRetryOverrides as v, Result as w, ResolvableLanguageModel as x, ProviderOptions as y };
+export { RetryContext as A, ResolvableModel as C, Retry as D, Retries as E, RetryableModelOptions as F, RetryableOptions as I, SuccessAttempt as L, RetryResultAttempt as M, RetryTelemetrySettings as N, RetryAttempt as O, Retryable as P, SuccessContext as R, ResolvableLanguageModel as S, Result as T, LanguageModelStream as _, EmbeddingModelRetryCallOptions as a, ProviderOptions as b, ImageModel as c, ImageModelRetryCallOptions as d, LanguageModel as f, LanguageModelRetryCallOptions as g, LanguageModelResult as h, EmbeddingModelEmbed as i, RetryErrorAttempt as j, RetryCallOptions as k, ImageModelCallOptions as l, LanguageModelGenerate as m, EmbeddingModel as n, FailureContext as o, LanguageModelCallOptions as p, EmbeddingModelCallOptions as r, GatewayLanguageModelId as s, CallOptions as t, ImageModelGenerate as u, LanguageModelStreamPart as v, ResolvedModel as w, Reset as x, OnRetryOverrides as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-retry",
-  "version": "1.9.1",
+  "version": "1.10.0",
   "description": "Retry and fallback mechanisms for AI SDK",
   "keywords": [
     "ai",