ai-retry 0.4.1 → 0.5.1

package/README.md

@@ -21,9 +21,6 @@ It supports two types of retries:
 
 This library only supports AI SDK v5.
 
-> [!WARNING]  
-> `ai-retry` is in an early stage and the API may change in future releases.
-
 ```bash
 npm install ai-retry
 ```
@@ -173,11 +170,10 @@ const retryable = createRetryable({
 
 #### Retry After Delay
 
-Handle retryable errors with delays and respect `retry-after` headers from rate-limited responses. This is useful for handling 429 (Too Many Requests) and 503 (Service Unavailable) errors.
-
-> [!NOTE] 
-> If the response contains a [`retry-after`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Retry-After) header, it will be prioritized over the configured delay.
+If an error is retryable, such as 429 (Too Many Requests) or 503 (Service Unavailable) errors, it will be retried after a delay. 
+The delay and exponential backoff can be configured. If the response contains a [`retry-after`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Retry-After) header, it will be prioritized over the configured delay.
 
+Note that this retryable does not accept a model parameter, it will always retry the model from the latest failed attempt.
 
 ```typescript
 import { retryAfterDelay } from 'ai-retry/retryables';
@@ -190,19 +186,14 @@ const retryableModel = createRetryable({
 
     // Or retry with exponential backoff (2s, 4s, 8s)
     retryAfterDelay({ delay: 2000, backoffFactor: 2, maxAttempts: 3 }),
-    
-    // Or switch to a different model after delay
-    retryAfterDelay(openai('gpt-4-mini'), { delay: 1000 }),
+
+    // Or retry only if the response contains a retry-after header
+    retryAfterDelay({ maxAttempts: 3 }),
   ],
 });
 ```
 
-**Options:**
-- `delay` (required): Delay in milliseconds before retrying
-- `backoffFactor` (optional): Multiplier for exponential backoff (delay × backoffFactor^attempt). If not provided, uses fixed delay.
-- `maxAttempts` (optional): Maximum number of retry attempts for this model
-
-By default, if a [`retry-after-ms`](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/provisioned-get-started#what-should--i-do-when-i-receive-a-429-response) or `retry-after` header is present in the response, it will be prioritized over the configured delay. The delay from the header will be capped at 60 seconds for safety. If no headers are present, the configured delay or exponential backoff will be used.
+By default, if a [`retry-after-ms`](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/provisioned-get-started#what-should--i-do-when-i-receive-a-429-response) or [`retry-after`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Retry-After) header is present in the response, it will be prioritized over the configured delay. The delay from the header will be capped at 60 seconds for safety.
 
 #### Fallbacks
 
@@ -284,22 +275,17 @@ try {
 
 #### Retry Delays
 
-You can add delays before retrying to handle rate limiting or give services time to recover. The delay respects abort signals, so requests can still be cancelled during the delay period.
+You can delay retries with an optional exponential backoff. The delay respects abort signals, so requests can still be cancelled during the delay period.
 
 ```typescript
 const retryableModel = createRetryable({
   model: openai('gpt-4'),
   retries: [
-    // Wait 1 second before retrying
-    () => ({ 
-      model: openai('gpt-4'), 
-      delay: 1_000 
-    }),
-    // Wait 2 seconds before trying a different provider
-    () => ({ 
-      model: anthropic('claude-3-haiku-20240307'), 
-      delay: 2_000 
-    }),
+    // Retry model 3 times with fixed 2s delay
+    () => ({ model: openai('gpt-4'), delay: 2000, maxAttempts: 3 }),
+
+    // Or retry with exponential backoff (2s, 4s, 8s)
+    () => ({ model: openai('gpt-4'), delay: 2000, backoffFactor: 2, maxAttempts: 3 }),
   ],
 });
 
@@ -383,7 +369,7 @@ There are several built-in retryables:
 - [`contentFilterTriggered`](./src/retryables/content-filter-triggered.ts): Content filter was triggered based on the prompt or completion.
 - [`requestTimeout`](./src/retryables/request-timeout.ts): Request timeout occurred.
 - [`requestNotRetryable`](./src/retryables/request-not-retryable.ts): Request failed with a non-retryable error.
-- [`retryAfterDelay`](./src/retryables/retry-after-delay.ts): Retry with exponential backoff and respect `retry-after` headers for rate limiting.
+- [`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.
 
@@ -405,29 +391,32 @@ interface RetryableModelOptions<MODEL extends LanguageModelV2 | EmbeddingModelV2
 #### `Retryable`
 
 A `Retryable` is a function that receives a `RetryContext` with the current error or result and model and all previous attempts.
-It should evaluate the error/result and decide whether to retry by returning a `RetryModel` or to skip by returning `undefined`.
+It should evaluate the error/result and decide whether to retry by returning a `Retry` or to skip by returning `undefined`.
 
 ```ts
 type Retryable = (
   context: RetryContext
-) => RetryModel | Promise<RetryModel> | undefined;
+) => Retry | Promise<Retry> | undefined;
 ```
 
-#### `RetryModel`
+#### `Retry`
 
-A `RetryModel` specifies the model to retry and optional settings like `maxAttempts` and `delay`.
+A `Retry` specifies the model to retry and optional settings like `maxAttempts`, `delay` and `backoffFactor`.
 
 ```typescript
-interface RetryModel {
+interface Retry {
   model: LanguageModelV2 | EmbeddingModelV2;
-  maxAttempts?: number; // Maximum retry attempts per model (default: 1)
-  delay?: number;       // Delay in milliseconds before retrying
+  maxAttempts?: number;   // Maximum retry attempts per model (default: 1)
+  delay?: number;         // Delay in milliseconds before retrying
+  backoffFactor?: number; // Multiplier for exponential backoff
 }
 ```
 
 **Options:**
+- `model`: The model to use for the retry attempt.
 - `maxAttempts`: Maximum number of times this model can be retried. Default is 1.
-- `delay`: Delay in milliseconds to wait before retrying. Useful for rate limiting or giving services time to recover. The delay respects abort signals from the request.
+- `delay`: Delay in milliseconds to wait before retrying. The delay respects abort signals from the request.
+- `backoffFactor`: Multiplier for exponential backoff (`delay × backoffFactor^attempt`). If not provided, uses fixed delay.
 
 #### `RetryContext`
 

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { EmbeddingModelV2, EmbeddingModelV2CallOptions, EmbeddingModelV2Embed, LanguageModelV2, LanguageModelV2Generate, LanguageModelV2Stream, Retries, RetryAttempt, RetryContext, RetryErrorAttempt, RetryModel, RetryResultAttempt, Retryable, RetryableModelOptions } from "./types-BrJaHkFh.js";
+import { a as LanguageModelV2Generate, c as Retry, d as RetryErrorAttempt, f as RetryResultAttempt, h as RetryableOptions, i as LanguageModelV2, l as RetryAttempt, m as RetryableModelOptions, n as EmbeddingModelV2CallOptions, o as LanguageModelV2Stream, p as Retryable, r as EmbeddingModelV2Embed, s as Retries, t as EmbeddingModelV2, u as RetryContext } from "./types-DqwAmcZS.js";
 import * as _ai_sdk_provider0 from "@ai-sdk/provider";
-import { LanguageModelV2StreamPart } from "@ai-sdk/provider";
+import { LanguageModelV2 as LanguageModelV2$1, LanguageModelV2StreamPart } from "@ai-sdk/provider";
 
 //#region src/create-retryable-model.d.ts
 declare function createRetryable<MODEL extends LanguageModelV2>(options: RetryableModelOptions<MODEL>): LanguageModelV2;
@@ -15,6 +15,9 @@ declare const getModelKey: (model: LanguageModelV2 | EmbeddingModelV2) => string
 //#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 isModelV2: (model: unknown) => model is LanguageModelV2$1 | EmbeddingModelV2;
+declare const isLanguageModelV2: (model: unknown) => model is LanguageModelV2$1;
+declare const isEmbeddingModelV2: (model: unknown) => model is EmbeddingModelV2;
 declare const isStreamResult: (result: LanguageModelV2Generate | LanguageModelV2Stream) => result is LanguageModelV2Stream;
 declare const isGenerateResult: (result: LanguageModelV2Generate | LanguageModelV2Stream) => result is LanguageModelV2Generate;
 /**
@@ -64,4 +67,4 @@ declare const isStreamContentPart: (part: LanguageModelV2StreamPart) => part is
   rawValue: unknown;
 };
 //#endregion
-export { EmbeddingModelV2, EmbeddingModelV2CallOptions, EmbeddingModelV2Embed, LanguageModelV2, LanguageModelV2Generate, LanguageModelV2Stream, Retries, RetryAttempt, RetryContext, RetryErrorAttempt, RetryModel, RetryResultAttempt, Retryable, RetryableModelOptions, createRetryable, getModelKey, isErrorAttempt, isGenerateResult, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString };
+export { EmbeddingModelV2, EmbeddingModelV2CallOptions, EmbeddingModelV2Embed, LanguageModelV2, LanguageModelV2Generate, LanguageModelV2Stream, Retries, Retry, RetryAttempt, RetryContext, RetryErrorAttempt, RetryResultAttempt, Retryable, RetryableModelOptions, RetryableOptions, createRetryable, getModelKey, isEmbeddingModelV2, isErrorAttempt, isGenerateResult, isLanguageModelV2, isModelV2, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString };

package/dist/index.js

@@ -1,8 +1,33 @@
-import { getModelKey, isErrorAttempt, isGenerateResult, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString } from "./utils-Dojn0elD.js";
+import { a as isModelV2, c as isStreamContentPart, i as isLanguageModelV2, l as isStreamResult, n as isErrorAttempt, o as isObject, r as isGenerateResult, s as isResultAttempt, t as isEmbeddingModelV2, u as isString } from "./utils-BlCGaP0E.js";
 import { delay } from "@ai-sdk/provider-utils";
 import { getErrorMessage } from "@ai-sdk/provider";
 import { RetryError } from "ai";
 
+//#region src/calculate-exponential-backoff.ts
+/**
+* Calculates the exponential backoff delay.
+*/
+function calculateExponentialBackoff(baseDelay, backoffFactor = 1, attempts) {
+	return baseDelay * Math.max(backoffFactor, 1) ** attempts;
+}
+
+//#endregion
+//#region src/get-model-key.ts
+/**
+* Generate a unique key for a LanguageModelV2 instance.
+*/
+const getModelKey = (model) => {
+	return `${model.provider}/${model.modelId}`;
+};
+
+//#endregion
+//#region src/count-model-attempts.ts
+function countModelAttempts(model, attempts) {
+	const modelKey = getModelKey(model);
+	return attempts.filter((a) => getModelKey(a.model) === modelKey).length;
+}
+
+//#endregion
 //#region src/find-retry-model.ts
 /**
 * Find the next model to retry with based on the retry context
@@ -18,10 +43,7 @@ async function findRetryModel(retries, context) {
 	* Iterate through the applicable retryables to find a model to retry with
 	*/
 	for (const retry of applicableRetries) {
-		const retryModel = typeof retry === "function" ? await retry(context) : {
-			model: retry,
-			maxAttempts: 1
-		};
+		const retryModel = typeof retry === "function" ? await retry(context) : { model: retry };
 		if (retryModel) {
 			/**
 			* The model key uniquely identifies a model instance (provider + modelId)
@@ -97,17 +119,12 @@ var RetryableEmbeddingModel = class {
 			* Skip on the first attempt since no previous attempt exists yet.
 			*/
 			if (previousAttempt) {
-				const currentAttempt = {
-					...previousAttempt,
-					model: this.currentModel
-				};
-				/**
-				* Create a shallow copy of the attempts for testing purposes
-				*/
-				const updatedAttempts = [...attempts];
 				const context = {
-					current: currentAttempt,
-					attempts: updatedAttempts
+					current: {
+						...previousAttempt,
+						model: this.currentModel
+					},
+					attempts: [...attempts]
 				};
 				this.options.onRetry?.(context);
 			}
@@ -119,7 +136,18 @@ var RetryableEmbeddingModel = class {
 			} catch (error) {
 				const { retryModel, attempt } = await this.handleError(error, attempts);
 				attempts.push(attempt);
-				if (retryModel.delay) await delay(retryModel.delay, { abortSignal: input.abortSignal });
+				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: input.abortSignal });
+				}
 				this.currentModel = retryModel.model;
 			}
 		}
@@ -208,17 +236,12 @@ var RetryableLanguageModel = class {
 			* Skip on the first attempt since no previous attempt exists yet.
 			*/
 			if (previousAttempt) {
-				const currentAttempt = {
-					...previousAttempt,
-					model: this.currentModel
-				};
-				/**
-				* Create a shallow copy of the attempts for testing purposes
-				*/
-				const updatedAttempts = [...attempts];
 				const context = {
-					current: currentAttempt,
-					attempts: updatedAttempts
+					current: {
+						...previousAttempt,
+						model: this.currentModel
+					},
+					attempts: [...attempts]
 				};
 				this.options.onRetry?.(context);
 			}
@@ -234,7 +257,18 @@ var RetryableLanguageModel = class {
 					const { retryModel, attempt } = await this.handleResult(result, attempts);
 					attempts.push(attempt);
 					if (retryModel) {
-						if (retryModel.delay) await delay(retryModel.delay, { abortSignal: input.abortSignal });
+						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: input.abortSignal });
+						}
 						this.currentModel = retryModel.model;
 						/**
 						* Continue to the next iteration to retry
@@ -249,7 +283,14 @@ var RetryableLanguageModel = class {
 			} catch (error) {
 				const { retryModel, attempt } = await this.handleError(error, attempts);
 				attempts.push(attempt);
-				if (retryModel.delay) await delay(retryModel.delay, { abortSignal: input.abortSignal });
+				if (retryModel.delay) {
+					/**
+					* Calculate exponential backoff delay based on the number of attempts for this specific model.
+					* The delay grows exponentially: baseDelay * backoffFactor^attempts
+					*/
+					const modelAttemptsCount = countModelAttempts(retryModel.model, attempts);
+					await delay(calculateExponentialBackoff(retryModel.delay, retryModel.backoffFactor, modelAttemptsCount), { abortSignal: input.abortSignal });
+				}
 				this.currentModel = retryModel.model;
 			}
 		}
@@ -263,13 +304,9 @@ var RetryableLanguageModel = class {
 			result,
 			model: this.currentModel
 		};
-		/**
-		* Save the current attempt
-		*/
-		const updatedAttempts = [...attempts, resultAttempt];
 		const context = {
 			current: resultAttempt,
-			attempts: updatedAttempts
+			attempts: [...attempts, resultAttempt]
 		};
 		return {
 			retryModel: await findRetryModel(this.options.retries, context),
@@ -370,7 +407,14 @@ var RetryableLanguageModel = class {
 				* Save the attempt
 				*/
 				attempts.push(attempt);
-				if (retryModel.delay) await delay(retryModel.delay, { abortSignal: options.abortSignal });
+				if (retryModel.delay) {
+					/**
+					* Calculate exponential backoff delay based on the number of attempts for this specific model.
+					* The delay grows exponentially: baseDelay * backoffFactor^attempts
+					*/
+					const modelAttemptsCount = countModelAttempts(retryModel.model, attempts);
+					await delay(calculateExponentialBackoff(retryModel.delay, retryModel.backoffFactor, modelAttemptsCount), { abortSignal: options.abortSignal });
+				}
 				this.currentModel = retryModel.model;
 				/**
 				* Retry the request by calling doStream again.
@@ -406,4 +450,4 @@ function createRetryable(options) {
 }
 
 //#endregion
-export { createRetryable, getModelKey, isErrorAttempt, isGenerateResult, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString };
+export { createRetryable, getModelKey, isEmbeddingModelV2, isErrorAttempt, isGenerateResult, isLanguageModelV2, isModelV2, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString };

package/dist/retryables/index.d.ts

@@ -1,17 +1,17 @@
-import { EmbeddingModelV2, LanguageModelV2, RetryModel, Retryable } from "../types-BrJaHkFh.js";
+import { h as RetryableOptions, i as LanguageModelV2, p as Retryable, t as EmbeddingModelV2 } from "../types-DqwAmcZS.js";
 
 //#region src/retryables/content-filter-triggered.d.ts
 
 /**
  * Fallback to a different model if the content filter was triggered.
  */
-declare function contentFilterTriggered<MODEL extends LanguageModelV2>(model: MODEL, options?: Omit<RetryModel<MODEL>, 'model'>): Retryable<MODEL>;
+declare function contentFilterTriggered<MODEL extends LanguageModelV2>(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 LanguageModelV2 | EmbeddingModelV2>(model: MODEL, options?: Omit<RetryModel<MODEL>, 'model'>): Retryable<MODEL>;
+declare function requestNotRetryable<MODEL extends LanguageModelV2 | EmbeddingModelV2>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
 //#region src/retryables/request-timeout.d.ts
 /**
@@ -19,20 +19,15 @@ declare function requestNotRetryable<MODEL extends LanguageModelV2 | EmbeddingMo
  * Use in combination with the `abortSignal` option.
  * Works with both `LanguageModelV2` and `EmbeddingModelV2`.
  */
-declare function requestTimeout<MODEL extends LanguageModelV2 | EmbeddingModelV2>(model: MODEL, options?: Omit<RetryModel<MODEL>, 'model'>): Retryable<MODEL>;
+declare function requestTimeout<MODEL extends LanguageModelV2 | EmbeddingModelV2>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
 //#region src/retryables/retry-after-delay.d.ts
-type RetryAfterDelayOptions<MODEL extends LanguageModelV2 | EmbeddingModelV2> = Omit<RetryModel<MODEL>, 'model' | 'delay'> & {
-  delay: number;
-  backoffFactor?: number;
-};
 /**
- * Retry with the same or a different model if the error is retryable with a delay.
+ * Retry the current failed attempt with the same model, if the error is retryable.
  * Uses the `Retry-After` or `Retry-After-Ms` headers if present.
- * Otherwise uses the specified `delay`, or exponential backoff if `backoffFactor` is provided.
+ * Otherwise uses the specified `delay` and `backoffFactor` if provided.
  */
-declare function retryAfterDelay<MODEL extends LanguageModelV2 | EmbeddingModelV2>(model: MODEL, options?: RetryAfterDelayOptions<MODEL>): Retryable<MODEL>;
-declare function retryAfterDelay<MODEL extends LanguageModelV2 | EmbeddingModelV2>(options: RetryAfterDelayOptions<MODEL>): Retryable<MODEL>;
+declare function retryAfterDelay<MODEL extends LanguageModelV2 | EmbeddingModelV2>(options: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
 //#region src/retryables/service-overloaded.d.ts
 /**
@@ -42,6 +37,6 @@ declare function retryAfterDelay<MODEL extends LanguageModelV2 | EmbeddingModelV
  * - Response with `type: "overloaded_error"`
  * - Response with a `message` containing "overloaded"
  */
-declare function serviceOverloaded<MODEL extends LanguageModelV2 | EmbeddingModelV2>(model: MODEL, options?: Omit<RetryModel<MODEL>, 'model'>): Retryable<MODEL>;
+declare function serviceOverloaded<MODEL extends LanguageModelV2 | EmbeddingModelV2>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
 export { contentFilterTriggered, requestNotRetryable, requestTimeout, retryAfterDelay, serviceOverloaded };

package/dist/retryables/index.js

@@ -1,4 +1,4 @@
-import { getModelKey, isErrorAttempt, isObject, isResultAttempt, isString } from "../utils-Dojn0elD.js";
+import { n as isErrorAttempt, o as isObject, s as isResultAttempt, u as isString } from "../utils-BlCGaP0E.js";
 import { isAbortError } from "@ai-sdk/provider-utils";
 import { APICallError } from "ai";
 
@@ -69,15 +69,6 @@ function requestTimeout(model, options) {
 	};
 }
 
-//#endregion
-//#region src/calculate-exponential-backoff.ts
-/**
-* Calculates the exponential backoff delay.
-*/
-function calculateExponentialBackoff(baseDelay, backoffFactor, attempts) {
-	return baseDelay * backoffFactor ** attempts;
-}
-
 //#endregion
 //#region src/parse-retry-headers.ts
 function parseRetryHeaders(headers) {
@@ -100,31 +91,28 @@ function parseRetryHeaders(headers) {
 //#endregion
 //#region src/retryables/retry-after-delay.ts
 const MAX_RETRY_AFTER_MS = 6e4;
-function retryAfterDelay(modelOrOptions, options) {
-	const model = modelOrOptions && "delay" in modelOrOptions ? void 0 : modelOrOptions;
-	const opts = modelOrOptions && "delay" in modelOrOptions ? modelOrOptions : options;
-	if (!opts?.delay) throw new Error("retryAfterDelay: delay is required");
-	const delay$1 = opts.delay;
-	const backoffFactor = Math.max(opts.backoffFactor ?? 1, 1);
+/**
+* Retry the current failed attempt with the same model, if the error is retryable.
+* Uses the `Retry-After` or `Retry-After-Ms` headers if present.
+* Otherwise uses the specified `delay` and `backoffFactor` if provided.
+*/
+function retryAfterDelay(options) {
 	return (context) => {
-		const { current, attempts } = context;
+		const { current } = context;
 		if (isErrorAttempt(current)) {
 			const { error } = current;
 			if (APICallError.isInstance(error) && error.isRetryable === true) {
-				const targetModel = model ?? current.model;
-				const modelKey = getModelKey(targetModel);
-				const modelAttempts = attempts.filter((a) => getModelKey(a.model) === modelKey);
+				const model = current.model;
 				const headerDelay = parseRetryHeaders(error.responseHeaders);
 				if (headerDelay !== null) return {
-					model: targetModel,
+					model,
+					...options,
 					delay: Math.min(headerDelay, MAX_RETRY_AFTER_MS),
-					maxAttempts: opts.maxAttempts
+					backoffFactor: 1
 				};
-				const calculatedDelay = calculateExponentialBackoff(delay$1, backoffFactor, modelAttempts.length);
 				return {
-					model: targetModel,
-					delay: calculatedDelay,
-					maxAttempts: opts.maxAttempts
+					model,
+					...options
 				};
 			}
 		}

package/dist/{types-BrJaHkFh.d.ts → types-DqwAmcZS.d.ts}

@@ -1,11 +1,11 @@
-import { EmbeddingModelV2, LanguageModelV2 } from "@ai-sdk/provider";
+import { EmbeddingModelV2, LanguageModelV2 as LanguageModelV2$1 } from "@ai-sdk/provider";
 
 //#region src/types.d.ts
 type EmbeddingModelV2$1<VALUE = any> = EmbeddingModelV2<VALUE>;
 /**
  * Options for creating a retryable model.
  */
-interface RetryableModelOptions<MODEL extends LanguageModelV2 | EmbeddingModelV2$1> {
+interface RetryableModelOptions<MODEL extends LanguageModelV2$1 | EmbeddingModelV2$1> {
   model: MODEL;
   retries: Retries<MODEL>;
   onError?: (context: RetryContext<MODEL>) => void;
@@ -14,7 +14,7 @@ interface RetryableModelOptions<MODEL extends LanguageModelV2 | EmbeddingModelV2
 /**
  * The context provided to Retryables with the current attempt and all previous attempts.
  */
-type RetryContext<MODEL extends LanguageModelV2 | EmbeddingModelV2$1> = {
+type RetryContext<MODEL extends LanguageModelV2$1 | EmbeddingModelV2$1> = {
   /**
    * Current attempt that caused the retry
    */
@@ -27,7 +27,7 @@ type RetryContext<MODEL extends LanguageModelV2 | EmbeddingModelV2$1> = {
 /**
  * A retry attempt with an error
  */
-type RetryErrorAttempt<MODEL extends LanguageModelV2 | EmbeddingModelV2$1> = {
+type RetryErrorAttempt<MODEL extends LanguageModelV2$1 | EmbeddingModelV2$1> = {
   type: 'error';
   error: unknown;
   result?: undefined;
@@ -40,28 +40,30 @@ type RetryResultAttempt = {
   type: 'result';
   result: LanguageModelV2Generate;
   error?: undefined;
-  model: LanguageModelV2;
+  model: LanguageModelV2$1;
 };
 /**
  * A retry attempt with either an error or a result and the model used
  */
-type RetryAttempt<MODEL extends LanguageModelV2 | EmbeddingModelV2$1> = RetryErrorAttempt<MODEL> | RetryResultAttempt;
+type RetryAttempt<MODEL extends LanguageModelV2$1 | EmbeddingModelV2$1> = RetryErrorAttempt<MODEL> | RetryResultAttempt;
 /**
  * A model to retry with and the maximum number of attempts for that model.
  */
-type RetryModel<MODEL extends LanguageModelV2 | EmbeddingModelV2$1> = {
+type Retry<MODEL extends LanguageModelV2$1 | EmbeddingModelV2$1> = {
   model: MODEL;
   maxAttempts?: number;
   delay?: number;
+  backoffFactor?: number;
 };
 /**
  * A function that determines whether to retry with a different model based on the current attempt and all previous attempts.
  */
-type Retryable<MODEL extends LanguageModelV2 | EmbeddingModelV2$1> = (context: RetryContext<MODEL>) => RetryModel<MODEL> | Promise<RetryModel<MODEL>> | undefined;
-type Retries<MODEL extends LanguageModelV2 | EmbeddingModelV2$1> = Array<Retryable<MODEL> | MODEL>;
-type LanguageModelV2Generate = Awaited<ReturnType<LanguageModelV2['doGenerate']>>;
-type LanguageModelV2Stream = Awaited<ReturnType<LanguageModelV2['doStream']>>;
+type Retryable<MODEL extends LanguageModelV2$1 | EmbeddingModelV2$1> = (context: RetryContext<MODEL>) => Retry<MODEL> | Promise<Retry<MODEL>> | undefined;
+type Retries<MODEL extends LanguageModelV2$1 | EmbeddingModelV2$1> = Array<Retryable<MODEL> | MODEL>;
+type RetryableOptions<MODEL extends LanguageModelV2$1 | EmbeddingModelV2$1> = Partial<Omit<Retry<MODEL>, 'model'>>;
+type LanguageModelV2Generate = Awaited<ReturnType<LanguageModelV2$1['doGenerate']>>;
+type LanguageModelV2Stream = Awaited<ReturnType<LanguageModelV2$1['doStream']>>;
 type EmbeddingModelV2CallOptions<VALUE> = Parameters<EmbeddingModelV2$1<VALUE>['doEmbed']>[0];
 type EmbeddingModelV2Embed<VALUE> = Awaited<ReturnType<EmbeddingModelV2$1<VALUE>['doEmbed']>>;
 //#endregion
-export { EmbeddingModelV2$1 as EmbeddingModelV2, EmbeddingModelV2CallOptions, EmbeddingModelV2Embed, type LanguageModelV2, LanguageModelV2Generate, LanguageModelV2Stream, Retries, RetryAttempt, RetryContext, RetryErrorAttempt, RetryModel, RetryResultAttempt, Retryable, RetryableModelOptions };
+export { LanguageModelV2Generate as a, Retry as c, RetryErrorAttempt as d, RetryResultAttempt as f, RetryableOptions as h, LanguageModelV2$1 as i, RetryAttempt as l, RetryableModelOptions as m, EmbeddingModelV2CallOptions as n, LanguageModelV2Stream as o, Retryable as p, EmbeddingModelV2Embed as r, Retries as s, EmbeddingModelV2$1 as t, RetryContext as u };

package/dist/{utils-Dojn0elD.js → utils-BlCGaP0E.js}

@@ -1,15 +1,9 @@
-//#region src/get-model-key.ts
-/**
-* Generate a unique key for a LanguageModelV2 instance.
-*/
-const getModelKey = (model) => {
-	return `${model.provider}/${model.modelId}`;
-};
-
-//#endregion
 //#region src/utils.ts
 const isObject = (value) => typeof value === "object" && value !== null;
 const isString = (value) => typeof value === "string";
+const isModelV2 = (model) => isLanguageModelV2(model) || isEmbeddingModelV2(model);
+const isLanguageModelV2 = (model) => isObject(model) && "provider" in model && "modelId" in model && "specificationVersion" in model && model.specificationVersion === "v2";
+const isEmbeddingModelV2 = (model) => isObject(model) && "provider" in model && "modelId" in model && "specificationVersion" in model && model.specificationVersion === "v2";
 const isStreamResult = (result) => "stream" in result;
 const isGenerateResult = (result) => "content" in result;
 /**
@@ -34,4 +28,4 @@ const isStreamContentPart = (part) => {
 };
 
 //#endregion
-export { getModelKey, isErrorAttempt, isGenerateResult, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString };
+export { isModelV2 as a, isStreamContentPart as c, isLanguageModelV2 as i, isStreamResult as l, isErrorAttempt as n, isObject as o, isGenerateResult as r, isResultAttempt as s, isEmbeddingModelV2 as t, isString as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-retry",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "AI SDK Retry",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -35,6 +35,7 @@
   "devDependencies": {
     "@ai-sdk/anthropic": "^2.0.18",
     "@ai-sdk/azure": "^2.0.30",
+    "@ai-sdk/groq": "^2.0.24",
     "@ai-sdk/openai": "^2.0.30",
     "@arethetypeswrong/cli": "^0.18.2",
     "@biomejs/biome": "^2.2.4",
@@ -45,7 +46,7 @@
     "msw": "^2.11.2",
     "pkg-pr-new": "^0.0.60",
     "publint": "^0.3.13",
-    "tsdown": "^0.15.2",
+    "tsdown": "^0.15.9",
     "tsx": "^4.20.5",
     "typescript": "^5.9.2",
     "unbuild": "^3.6.1",