ai-retry 0.5.0 → 0.6.0

package/README.md

@@ -170,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';
@@ -187,14 +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 }),
   ],
 });
 ```
 
-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
 
@@ -332,6 +331,41 @@ const retryableModel = createRetryable({
 
 The attempts are counted per unique model (provider + modelId). That means if multiple retryables return the same model, it won't be retried again once the `maxAttempts` is reached.
 
+#### Provider Options
+
+You can override provider-specific options for each retry attempt. This is useful when you want to use different configurations for fallback models.
+
+```typescript
+const retryableModel = createRetryable({
+  model: openai('gpt-5'),
+  retries: [
+    // Use different provider options for the retry
+    () => ({
+      model: openai('gpt-4o-2024-08-06'),
+      providerOptions: {
+        openai: {
+          user: 'fallback-user',
+          structuredOutputs: false,
+        },
+      },
+    }),
+  ],
+});
+
+// Original provider options are used for the first attempt
+const result = await generateText({
+  model: retryableModel,
+  prompt: 'Write a story',
+  providerOptions: {
+    openai: {
+      user: 'primary-user',
+    },
+  },
+});
+```
+
+The retry's `providerOptions` will completely replace the original ones during retry attempts. This works for all model types (language and embedding) and all operations (generate, stream, embed).
+
 #### Logging
 
 You can use the following callbacks to log retry attempts and errors:
@@ -370,7 +404,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.
 
@@ -402,14 +436,15 @@ type Retryable = (
 
 #### `Retry`
 
-A `Retry` specifies the model to retry and optional settings like `maxAttempts`, `delay` and `backoffFactor`.
+A `Retry` specifies the model to retry and optional settings like `maxAttempts`, `delay`, `backoffFactor`, and `providerOptions`.
 
 ```typescript
 interface Retry {
   model: LanguageModelV2 | EmbeddingModelV2;
-  maxAttempts?: number;   // Maximum retry attempts per model (default: 1)
-  delay?: number;         // Delay in milliseconds before retrying
-  backoffFactor?: number; // Multiplier for exponential backoff
+  maxAttempts?: number;      // Maximum retry attempts per model (default: 1)
+  delay?: number;            // Delay in milliseconds before retrying
+  backoffFactor?: number;    // Multiplier for exponential backoff
+  providerOptions?: ProviderOptions; // Provider-specific options for the retry
 }
 ```
 
@@ -418,6 +453,7 @@ interface Retry {
 - `maxAttempts`: Maximum number of times this model can be retried. Default is 1.
 - `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.
+- `providerOptions`: Provider-specific options that override the original request's provider options during retry attempts.
 
 #### `RetryContext`
 

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-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 { 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-DhGbwiB4.js";
 import * as _ai_sdk_provider0 from "@ai-sdk/provider";
 import { LanguageModelV2 as LanguageModelV2$1, LanguageModelV2StreamPart } from "@ai-sdk/provider";
 

package/dist/index.js

@@ -109,6 +109,10 @@ var RetryableEmbeddingModel = class {
 		* Track all attempts.
 		*/
 		const attempts = input.attempts ?? [];
+		/**
+		* Track current retry configuration.
+		*/
+		let currentRetry;
 		while (true) {
 			/**
 			* The previous attempt that triggered a retry, or undefined if this is the first attempt
@@ -130,7 +134,7 @@ var RetryableEmbeddingModel = class {
 			}
 			try {
 				return {
-					result: await input.fn(),
+					result: await input.fn(currentRetry),
 					attempts
 				};
 			} catch (error) {
@@ -149,6 +153,7 @@ var RetryableEmbeddingModel = class {
 					await delay(calculateExponentialBackoff(retryModel.delay, retryModel.backoffFactor, modelAttemptsCount), { abortSignal: input.abortSignal });
 				}
 				this.currentModel = retryModel.model;
+				currentRetry = retryModel;
 			}
 		}
 	}
@@ -190,7 +195,13 @@ var RetryableEmbeddingModel = class {
 		*/
 		this.currentModel = this.baseModel;
 		const { result } = await this.withRetry({
-			fn: async () => await this.currentModel.doEmbed(options),
+			fn: async (currentRetry) => {
+				const callOptions = {
+					...options,
+					providerOptions: currentRetry?.providerOptions ?? options.providerOptions
+				};
+				return this.currentModel.doEmbed(callOptions);
+			},
 			abortSignal: options.abortSignal
 		});
 		return result;
@@ -226,6 +237,10 @@ var RetryableLanguageModel = class {
 		* Track all attempts.
 		*/
 		const attempts = input.attempts ?? [];
+		/**
+		* Track current retry configuration.
+		*/
+		let currentRetry;
 		while (true) {
 			/**
 			* The previous attempt that triggered a retry, or undefined if this is the first attempt
@@ -249,7 +264,7 @@ var RetryableLanguageModel = class {
 				/**
 				* Call the function that may need to be retried
 				*/
-				const result = await input.fn();
+				const result = await input.fn(currentRetry);
 				/**
 				* Check if the result should trigger a retry (only for generate results, not streams)
 				*/
@@ -270,6 +285,7 @@ var RetryableLanguageModel = class {
 							await delay(calculateExponentialBackoff(retryModel.delay, retryModel.backoffFactor, modelAttemptsCount), { abortSignal: input.abortSignal });
 						}
 						this.currentModel = retryModel.model;
+						currentRetry = retryModel;
 						/**
 						* Continue to the next iteration to retry
 						*/
@@ -292,6 +308,7 @@ var RetryableLanguageModel = class {
 					await delay(calculateExponentialBackoff(retryModel.delay, retryModel.backoffFactor, modelAttemptsCount), { abortSignal: input.abortSignal });
 				}
 				this.currentModel = retryModel.model;
+				currentRetry = retryModel;
 			}
 		}
 	}
@@ -351,7 +368,13 @@ var RetryableLanguageModel = class {
 		*/
 		this.currentModel = this.baseModel;
 		const { result } = await this.withRetry({
-			fn: async () => await this.currentModel.doGenerate(options),
+			fn: async (currentRetry) => {
+				const callOptions = {
+					...options,
+					providerOptions: currentRetry?.providerOptions ?? options.providerOptions
+				};
+				return this.currentModel.doGenerate(callOptions);
+			},
 			abortSignal: options.abortSignal
 		});
 		return result;
@@ -365,7 +388,13 @@ var RetryableLanguageModel = class {
 		* Perform the initial call to doStream with retry logic to handle errors before any data is streamed.
 		*/
 		let { result, attempts } = await this.withRetry({
-			fn: async () => await this.currentModel.doStream(options),
+			fn: async (currentRetry) => {
+				const callOptions = {
+					...options,
+					providerOptions: currentRetry?.providerOptions ?? options.providerOptions
+				};
+				return this.currentModel.doStream(callOptions);
+			},
 			abortSignal: options.abortSignal
 		});
 		/**
@@ -421,7 +450,13 @@ var RetryableLanguageModel = class {
 				* This will create a new stream.
 				*/
 				const retriedResult = await this.withRetry({
-					fn: async () => await this.currentModel.doStream(options),
+					fn: async () => {
+						const callOptions = {
+							...options,
+							providerOptions: retryModel.providerOptions ?? options.providerOptions
+						};
+						return this.currentModel.doStream(callOptions);
+					},
 					attempts,
 					abortSignal: options.abortSignal
 				});

package/dist/retryables/index.d.ts

@@ -1,4 +1,4 @@
-import { h as RetryableOptions, i as LanguageModelV2, p as Retryable, t as EmbeddingModelV2 } from "../types-DqwAmcZS.js";
+import { h as RetryableOptions, i as LanguageModelV2, p as Retryable, t as EmbeddingModelV2 } from "../types-DhGbwiB4.js";
 
 //#region src/retryables/content-filter-triggered.d.ts
 
@@ -23,11 +23,10 @@ declare function requestTimeout<MODEL extends LanguageModelV2 | EmbeddingModelV2
 //#endregion
 //#region src/retryables/retry-after-delay.d.ts
 /**
- * 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` with 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?: RetryableOptions<MODEL>): Retryable<MODEL>;
 declare function retryAfterDelay<MODEL extends LanguageModelV2 | EmbeddingModelV2>(options: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
 //#region src/retryables/service-overloaded.d.ts

package/dist/retryables/index.js

@@ -1,4 +1,4 @@
-import { a as isModelV2, n as isErrorAttempt, o as isObject, s as isResultAttempt, u as isString } from "../utils-BlCGaP0E.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,23 +69,6 @@ function requestTimeout(model, options) {
 	};
 }
 
-//#endregion
-//#region src/internal/resolve-retryable-options.ts
-/**
-* Helper to resolve `RetryableOptions` from either a model and/or options object.
-* Used to support function overloads in retryables:
-* - `retryable(model)`
-* - `retryable(model, options)`
-* - `retryable(options)`
-*/
-function resolveRetryableOptions(modelOrOptions, options) {
-	if (isModelV2(modelOrOptions)) return {
-		...options,
-		model: modelOrOptions
-	};
-	return modelOrOptions;
-}
-
 //#endregion
 //#region src/parse-retry-headers.ts
 function parseRetryHeaders(headers) {
@@ -108,23 +91,28 @@ function parseRetryHeaders(headers) {
 //#endregion
 //#region src/retryables/retry-after-delay.ts
 const MAX_RETRY_AFTER_MS = 6e4;
-function retryAfterDelay(modelOrOptions, options) {
-	const resolvedOptions = resolveRetryableOptions(modelOrOptions, options);
+/**
+* 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 } = context;
 		if (isErrorAttempt(current)) {
 			const { error } = current;
 			if (APICallError.isInstance(error) && error.isRetryable === true) {
-				const model = resolvedOptions.model ?? current.model;
+				const model = current.model;
 				const headerDelay = parseRetryHeaders(error.responseHeaders);
 				if (headerDelay !== null) return {
 					model,
-					...resolvedOptions,
-					delay: Math.min(headerDelay, MAX_RETRY_AFTER_MS)
+					...options,
+					delay: Math.min(headerDelay, MAX_RETRY_AFTER_MS),
+					backoffFactor: 1
 				};
 				return {
 					model,
-					...resolvedOptions
+					...options
 				};
 			}
 		}

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

@@ -1,3 +1,4 @@
+import { ProviderOptions } from "@ai-sdk/provider-utils";
 import { EmbeddingModelV2, LanguageModelV2 as LanguageModelV2$1 } from "@ai-sdk/provider";
 
 //#region src/types.d.ts
@@ -54,6 +55,7 @@ type Retry<MODEL extends LanguageModelV2$1 | EmbeddingModelV2$1> = {
   maxAttempts?: number;
   delay?: number;
   backoffFactor?: number;
+  providerOptions?: ProviderOptions;
 };
 /**
  * A function that determines whether to retry with a different model based on the current attempt and all previous attempts.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-retry",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "AI SDK Retry",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -36,7 +36,7 @@
     "@ai-sdk/anthropic": "^2.0.18",
     "@ai-sdk/azure": "^2.0.30",
     "@ai-sdk/groq": "^2.0.24",
-    "@ai-sdk/openai": "^2.0.30",
+    "@ai-sdk/openai": "^2.0.53",
     "@arethetypeswrong/cli": "^0.18.2",
     "@biomejs/biome": "^2.2.4",
     "@total-typescript/tsconfig": "^1.0.4",