ai-retry 1.9.0 → 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.
@@ -1183,6 +1192,13 @@ In the second case, errors during stream processing will not always be retried,
 > [!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`.
 
+#### Preamble buffering
+
+Every stream begins with a non-content preamble (`stream-start`, then optionally `response-metadata` and `text-start` / `reasoning-start`) that providers emit as soon as the response headers arrive, before any content flows. Because a retry can still happen during this window, `ai-retry` does not forward the preamble immediately. It buffers the leading non-content parts and flushes them only when the first content chunk arrives (or when the stream finishes with no content). If a retry fires before any content, the buffered preamble is discarded and replaced by the fallback's, so the consumer always sees exactly one preamble — the one belonging to the model that actually produced the output, with its own `warnings` and `response-metadata`. Without this, a fallback's `stream-start` would be emitted a second time after the primary's, which some consumers (e.g. `streamText`) reject.
+
+> [!NOTE]
+> One side effect: the consumer's "stream started" signal now arrives at first-content time rather than when the response headers arrive (typically a sub-second difference). For UIs that show a typing indicator off `stream-start` this is negligible.
+
 ### API Reference
 
 #### `createRetryable(options: RetryableModelOptions): LanguageModelV3 | EmbeddingModelV3 | ImageModelV3`
@@ -1203,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;
 }
 ```
 
@@ -1216,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`
 
@@ -1302,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-VgywojZt.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,
@@ -1202,6 +1251,16 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 					let capturedWarnings = [];
 					let capturedResponseMetadata = {};
 					/**
+					* Buffer for the leading non-content parts (`stream-start`,
+					* `response-metadata`, `text-start`, `reasoning-start`, …) of this
+					* attempt. While no content has been forwarded the preamble is held
+					* here rather than enqueued, so a pre-content retry can discard it
+					* and the consumer sees exactly one preamble — the one belonging to
+					* the model that actually produced the output. Reset per attempt;
+					* flushed on the first content part or at completion.
+					*/
+					let preambleBuffer = [];
+					/**
 					* Set when a `finish` part triggers a retry decision. Causes the
 					* inner read loop to exit without enqueuing the finish part, and
 					* the outer loop to re-stream against the next model.
@@ -1270,11 +1329,25 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 								}
 							}
 							/**
-							* Mark that streaming has started once we receive actual content
+							* Mark that streaming has started once we receive actual
+							* content. On the first content part, flush this attempt's
+							* buffered preamble (in order) ahead of the content, then
+							* forward normally from here on.
 							*/
-							if (isStreamContentPart(value)) isStreaming = true;
-							/**
-							* Enqueue the chunk to the consumer of the stream
+							if (isStreamContentPart(value)) {
+								isStreaming = true;
+								for (const buffered of preambleBuffer) controller.enqueue(buffered);
+								preambleBuffer = [];
+								controller.enqueue(value);
+							} else if (!isStreaming)
+ /**
+							* Pre-content part: buffer it so a pre-content retry can
+							* replace it with the next attempt's preamble.
+							*/
+							preambleBuffer.push(value);
+							else
+ /**
+							* Content already flowing: forward directly.
 							*/
 							controller.enqueue(value);
 						}
@@ -1306,7 +1379,13 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 								currentRetry,
 								recorder
 							});
-							await reader?.cancel();
+							/**
+							* Cancelling a reader whose stream has already errored (e.g.
+							* a mid-stream `controller.error`) rejects with that stored
+							* error. Swallow it: the retry already succeeded and that
+							* rejection must not abort the wrapped stream.
+							*/
+							await reader?.cancel().catch(() => {});
 							result = retriedResult.result;
 							attempts = retriedResult.attempts;
 							finalCallOptions = retriedResult.callOptions;
@@ -1318,6 +1397,13 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 							outcome: "success",
 							finishReason: streamFinishReason
 						});
+						/**
+						* A stream that completes with no content part still has its
+						* preamble buffered. Flush it so a zero-content completion emits
+						* its `stream-start` (and any metadata/finish) before closing.
+						*/
+						for (const buffered of preambleBuffer) controller.enqueue(buffered);
+						preambleBuffer = [];
 						controller.close();
 						break;
 					} catch (error) {
@@ -1349,6 +1435,7 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 								error
 							});
 							operationError = finalError;
+							this.emitFailure(attempts, finalError);
 							controller.enqueue({
 								type: "error",
 								error: finalError
@@ -1369,6 +1456,7 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 								error
 							});
 							operationError = error;
+							this.emitFailure(attempts, error);
 							controller.enqueue({
 								type: "error",
 								error
@@ -1408,9 +1496,13 @@ var RetryableLanguageModel = class extends BaseRetryableModel {
 							recorder
 						});
 						/**
-						* Cancel the previous reader and stream if we are retrying
+						* Cancel the previous reader and stream if we are retrying.
+						* Cancelling a reader whose stream has already errored (e.g. a
+						* mid-stream `controller.error`) rejects with that stored
+						* error. Swallow it: the retry already succeeded and that
+						* rejection must not abort the wrapped stream.
 						*/
-						await reader?.cancel();
+						await reader?.cancel().catch(() => {});
 						result = retriedResult.result;
 						attempts = retriedResult.attempts;
 						finalCallOptions = retriedResult.callOptions;

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-VgywojZt.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-VgywojZt.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-VgywojZt.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-VgywojZt.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.0",
+  "version": "1.10.0",
   "description": "Retry and fallback mechanisms for AI SDK",
   "keywords": [
     "ai",