ai-retry 0.5.1 → 0.6.0

package/README.md

@@ -331,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:
@@ -401,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
 }
 ```
 
@@ -417,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
 

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.1",
+  "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",