ai-retry 0.10.2 → 0.11.0

package/README.md

@@ -138,6 +138,58 @@ const retryableModel = createRetryable({
 
 In this example, if the base model fails with code 429 or a service overloaded error, it will retry with `gpt-4-mini` on Azure. In any other error case, it will fallback to `claude-3-haiku-20240307` on Anthropic. If the order would be reversed, the static retryable would catch all errors first, and the dynamic retryable would never be reached.
 
+#### Errors vs Results
+
+Dynamic retryables can be further divided based on what triggers them:
+
+- **Error-based retryables** handle API errors where the request throws an error (e.g., timeouts, rate limits, service unavailable, etc.)
+- **Result-based retryables** handle successful responses that still need retrying (e.g., content filtering, guardrails, etc.)
+
+Both types of retryables have the same interface and receive the current attempt as context. You can use the `isErrorAttempt` and `isResultAttempt` type guards to check the type of the current attempt.
+
+```typescript
+import { generateText } from 'ai';
+import { createRetryable, isErrorAttempt, isResultAttempt } from 'ai-retry';
+import type { Retryable } from 'ai-retry';
+
+// Error-based retryable: handles thrown errors (e.g., timeouts, rate limits)
+const errorBasedRetry: Retryable = (context) => {
+  if (isErrorAttempt(context.current)) {
+    const { error } = context.current;
+    // The request threw an error - e.g., network timeout, 429 rate limit
+    console.log('Request failed with error:', error);
+    return { model: anthropic('claude-3-haiku-20240307') };
+  }
+  return undefined;
+};
+
+// Result-based retryable: handles successful responses that need retrying
+const resultBasedRetry: Retryable = (context) => {
+  if (isResultAttempt(context.current)) {
+    const { result } = context.current;
+    // The request succeeded, but the response indicates a problem
+    if (result.finishReason === 'content-filter') {
+      console.log('Content was filtered, trying different model');
+      return { model: openai('gpt-4') };
+    }
+  }
+  return undefined;
+};
+
+const retryableModel = createRetryable({
+  model: azure('gpt-4-mini'),
+  retries: [
+    // Error-based: catches thrown errors like timeouts, rate limits, etc.
+    errorBasedRetry,
+    
+    // Result-based: catches successful responses that need retrying
+    resultBasedRetry,
+  ],
+});
+```
+
+Result-based retryables are only available for generate calls like `generateText` and `generateObject`. They are not available for streaming calls like `streamText` and `streamObject`.
+
 #### Fallbacks
 
 If you don't need precise error matching with custom logic and just want to fallback to different models on any error, you can simply provide a list of models.
@@ -324,11 +376,23 @@ Handle service overload errors (status code 529) by switching to a provider.
 import { serviceOverloaded } from 'ai-retry/retryables';
 
 const retryableModel = createRetryable({
-  model: azure('gpt-4'),
+  model: anthropic('claude-sonnet-4-0'),
   retries: [
-    serviceOverloaded(openai('gpt-4')), // Switch to OpenAI if Azure is overloaded
+    // Retry with delay and exponential backoff
+    serviceOverloaded(anthropic('claude-sonnet-4-0'), {
+      delay: 5_000,
+      backoffFactor: 2,
+      maxAttempts: 5,
+    }),
+    // Or switch to a different provider
+    serviceOverloaded(openai('gpt-4')),
   ],
 });
+
+const result = streamText({
+  model: retryableModel,
+  prompt: 'Write a story about a robot...',
+});
 ```
 
 #### Service Unavailable
@@ -537,6 +601,58 @@ const result = await generateText({
 
 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).
 
+#### Call Options
+
+You can override various call options when retrying requests. This is useful for adjusting parameters like temperature, max tokens, or even the prompt itself for retry attempts. Call options are specified in the `options` field of the retry object.
+
+```typescript
+const retryableModel = createRetryable({
+  model: openai('gpt-4'),
+  retries: [
+    {
+      model: anthropic('claude-3-haiku'),
+      options: {
+        // Override generation parameters for more deterministic output
+        temperature: 0.3,
+        topP: 0.9,
+        maxOutputTokens: 500,
+        // Set a seed for reproducibility
+        seed: 42,
+      },
+    },
+  ],
+});
+```
+
+The following options can be overridden:
+
+> [!NOTE]
+> Override options completely replace the original values (they are not merged). If you don't specify an option, the original value from the request is used.
+
+##### Language Model Options
+
+| Option | Description |
+|--------|-------------|
+| [`prompt`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-text#prompt) | Override the entire prompt for the retry |
+| [`temperature`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-text#temperature) | Temperature setting for controlling randomness |
+| [`topP`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-text#topp) | Nucleus sampling parameter |
+| [`topK`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-text#topk) | Top-K sampling parameter |
+| [`maxOutputTokens`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-text#max-output-tokens) | Maximum number of tokens to generate |
+| [`seed`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-text#seed) | Random seed for deterministic generation |
+| [`stopSequences`](https://ai-sdk.dev/docs/reference/ai-sdk-types/generate-text#stopsequences) | Stop sequences to end generation |
+| [`presencePenalty`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-text#presencepenalty) | Presence penalty for reducing repetition |
+| [`frequencyPenalty`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-text#frequencypenalty) | Frequency penalty for reducing repetition |
+| [`headers`](https://ai-sdk.dev/docs/reference/ai-sdk-core/generate-text#headers) | Additional HTTP headers |
+| [`providerOptions`](https://ai-sdk.dev/docs/reference/ai-sdk-types/generate-text#provideroptions) | Provider-specific options |
+
+##### Embedding Model Options
+
+| Option | Description |
+|--------|-------------|
+| [`values`](https://ai-sdk.dev/docs/reference/ai-sdk-core/embed#values) | Override the values to embed |
+| [`headers`](https://ai-sdk.dev/docs/reference/ai-sdk-core/embed#headers) | Additional HTTP headers |
+| [`providerOptions`](https://ai-sdk.dev/docs/reference/ai-sdk-core/embed#provideroptions) | Provider-specific options |
+
 #### Logging
 
 You can use the following callbacks to log retry attempts and errors:
@@ -603,7 +719,7 @@ type Retryable = (
 
 #### `Retry`
 
-A `Retry` specifies the model to retry and optional settings like `maxAttempts`, `delay`, `backoffFactor`, `timeout`, and `providerOptions`.
+A `Retry` specifies the model to retry and optional settings. The available options depend on the model type (language model or embedding model).
 
 ```typescript
 interface Retry {
@@ -612,18 +728,11 @@ interface Retry {
   delay?: number;            // Delay in milliseconds before retrying
   backoffFactor?: number;    // Multiplier for exponential backoff
   timeout?: number;          // Timeout in milliseconds for the retry attempt
-  providerOptions?: ProviderOptions; // Provider-specific options for the retry
+  providerOptions?: ProviderOptions; // @deprecated - use options.providerOptions instead
+  options?: LanguageModelV2CallOptions | EmbeddingModelV2CallOptions; // Call options to override for this retry
 }
 ```
 
-**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. The delay respects abort signals from the request.
-- `backoffFactor`: Multiplier for exponential backoff (`delay × backoffFactor^attempt`). If not provided, uses fixed delay.
-- `timeout`: Timeout in milliseconds for creating a fresh `AbortSignal.timeout()` for the retry attempt. This replaces any existing abort signal.
-- `providerOptions`: Provider-specific options that override the original request's provider options during retry attempts.
-
 #### `RetryContext`
 
 The `RetryContext` object contains information about the current attempt and all previous attempts.
@@ -637,13 +746,23 @@ interface RetryContext {
 
 #### `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.
+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.
 
 ```typescript
 // For both language and embedding models
 type RetryAttempt =
-  | { type: 'error'; error: unknown; model: LanguageModelV2 | EmbeddingModelV2 }
-  | { type: 'result'; result: LanguageModelV2Generate; model: LanguageModelV2 };
+  | { 
+      type: 'error'; 
+      error: unknown; 
+      model: LanguageModelV2 | EmbeddingModelV2;
+      options: LanguageModelV2CallOptions | EmbeddingModelV2CallOptions;
+    }
+  | { 
+      type: 'result'; 
+      result: LanguageModelV2Generate; 
+      model: LanguageModelV2;
+      options: LanguageModelV2CallOptions;
+    };
 
 // Note: Result-based retries only apply to language models, not embedding models
 

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { _ as RetryableOptions, a as LanguageModelCallOptions, c as LanguageModelStreamPart, d as RetryAttempt, f as RetryContext, g as RetryableModelOptions, h as Retryable, i as LanguageModel, l as Retries, m as RetryResultAttempt, n as EmbeddingModelCallOptions, o as LanguageModelGenerate, p as RetryErrorAttempt, r as EmbeddingModelEmbed, s as LanguageModelStream, t as EmbeddingModel, u as Retry } from "./types-2u5JeDwb.mjs";
+import { _ as RetryResultAttempt, a as LanguageModel, b as RetryableOptions, c as LanguageModelPrompt, d as LanguageModelStreamPart, f as Retries, g as RetryErrorAttempt, h as RetryContext, i as EmbeddingModelRetryCallOptions, l as LanguageModelRetryCallOptions, m as RetryAttempt, n as EmbeddingModelCallOptions, o as LanguageModelCallOptions, p as Retry, r as EmbeddingModelEmbed, s as LanguageModelGenerate, t as EmbeddingModel, u as LanguageModelStream, v as Retryable, y as RetryableModelOptions } from "./types-D4wXoA4D.mjs";
 import * as _ai_sdk_provider0 from "@ai-sdk/provider";
 
 //#region src/create-retryable-model.d.ts
@@ -70,4 +70,4 @@ declare const isStreamContentPart: (part: LanguageModelStreamPart) => part is _a
  */
 declare const isRetry: <MODEL extends LanguageModel | EmbeddingModel>(value: unknown) => value is Retry<MODEL>;
 //#endregion
-export { EmbeddingModel, EmbeddingModelCallOptions, EmbeddingModelEmbed, LanguageModel, LanguageModelCallOptions, LanguageModelGenerate, LanguageModelStream, LanguageModelStreamPart, Retries, Retry, RetryAttempt, RetryContext, RetryErrorAttempt, RetryResultAttempt, Retryable, RetryableModelOptions, RetryableOptions, createRetryable, getModelKey, isEmbeddingModelV2, isErrorAttempt, isGenerateResult, isLanguageModelV2, isModelV2, isObject, isResultAttempt, isRetry, isStreamContentPart, isStreamResult, isString };
+export { EmbeddingModel, EmbeddingModelCallOptions, EmbeddingModelEmbed, EmbeddingModelRetryCallOptions, LanguageModel, LanguageModelCallOptions, LanguageModelGenerate, LanguageModelPrompt, LanguageModelRetryCallOptions, LanguageModelStream, LanguageModelStreamPart, Retries, Retry, RetryAttempt, RetryContext, RetryErrorAttempt, RetryResultAttempt, Retryable, RetryableModelOptions, RetryableOptions, createRetryable, getModelKey, isEmbeddingModelV2, isErrorAttempt, isGenerateResult, isLanguageModelV2, isModelV2, isObject, isResultAttempt, isRetry, isStreamContentPart, isStreamResult, isString };

package/dist/index.mjs

@@ -112,6 +112,19 @@ var RetryableEmbeddingModel = class {
 		return typeof this.options.disabled === "function" ? this.options.disabled() : this.options.disabled;
 	}
 	/**
+	* Get the retry call options overrides from a retry configuration.
+	*/
+	getRetryCallOptions(callOptions, currentRetry) {
+		const retryOptions = currentRetry?.options ?? {};
+		return {
+			...callOptions,
+			values: retryOptions.values ?? callOptions.values,
+			headers: retryOptions.headers ?? callOptions.headers,
+			providerOptions: retryOptions.providerOptions ?? currentRetry?.providerOptions ?? callOptions.providerOptions,
+			abortSignal: currentRetry?.timeout ? AbortSignal.timeout(currentRetry.timeout) : callOptions.abortSignal
+		};
+	}
+	/**
 	* Execute a function with retry logic for handling errors
 	*/
 	async withRetry(input) {
@@ -142,13 +155,17 @@ var RetryableEmbeddingModel = class {
 				};
 				this.options.onRetry?.(context);
 			}
+			/**
+			* Get the retry call options overrides for this attempt
+			*/
+			const retryCallOptions = this.getRetryCallOptions(input.callOptions, currentRetry);
 			try {
 				return {
-					result: await input.fn(currentRetry),
+					result: await input.fn(retryCallOptions),
 					attempts
 				};
 			} catch (error) {
-				const { retryModel, attempt } = await this.handleError(error, attempts);
+				const { retryModel, attempt } = await this.handleError(error, attempts, retryCallOptions);
 				attempts.push(attempt);
 				if (retryModel.delay) {
 					/**
@@ -160,7 +177,7 @@ var RetryableEmbeddingModel = class {
 					* - Attempt 3: 4000ms
 					*/
 					const modelAttemptsCount = countModelAttempts(retryModel.model, attempts);
-					await delay(calculateExponentialBackoff(retryModel.delay, retryModel.backoffFactor, modelAttemptsCount), { abortSignal: input.abortSignal });
+					await delay(calculateExponentialBackoff(retryModel.delay, retryModel.backoffFactor, modelAttemptsCount), { abortSignal: retryCallOptions.abortSignal });
 				}
 				this.currentModel = retryModel.model;
 				currentRetry = retryModel;
@@ -170,11 +187,12 @@ var RetryableEmbeddingModel = class {
 	/**
 	* Handle an error and determine if a retry is needed
 	*/
-	async handleError(error, attempts) {
+	async handleError(error, attempts, callOptions) {
 		const errorAttempt = {
 			type: "error",
 			error,
-			model: this.currentModel
+			model: this.currentModel,
+			options: callOptions
 		};
 		/**
 		* Save the current attempt
@@ -199,7 +217,7 @@ var RetryableEmbeddingModel = class {
 			attempt: errorAttempt
 		};
 	}
-	async doEmbed(options) {
+	async doEmbed(callOptions) {
 		/**
 		* Always start with the original model
 		*/
@@ -207,17 +225,12 @@ var RetryableEmbeddingModel = class {
 		/**
 		* If retries are disabled, bypass retry machinery entirely
 		*/
-		if (this.isDisabled()) return this.currentModel.doEmbed(options);
+		if (this.isDisabled()) return this.currentModel.doEmbed(callOptions);
 		const { result } = await this.withRetry({
-			fn: async (currentRetry) => {
-				const callOptions = {
-					...options,
-					providerOptions: currentRetry?.providerOptions ?? options.providerOptions,
-					abortSignal: currentRetry?.timeout ? AbortSignal.timeout(currentRetry.timeout) : options.abortSignal
-				};
-				return this.currentModel.doEmbed(callOptions);
+			fn: async (retryCallOptions) => {
+				return this.currentModel.doEmbed(retryCallOptions);
 			},
-			abortSignal: options.abortSignal
+			callOptions
 		});
 		return result;
 	}
@@ -252,6 +265,27 @@ var RetryableLanguageModel = class {
 		return typeof this.options.disabled === "function" ? this.options.disabled() : this.options.disabled;
 	}
 	/**
+	* Get the retry call options overrides from a retry configuration.
+	*/
+	getRetryCallOptions(callOptions, currentRetry) {
+		const retryOptions = currentRetry?.options ?? {};
+		return {
+			...callOptions,
+			prompt: retryOptions.prompt ?? callOptions.prompt,
+			maxOutputTokens: retryOptions.maxOutputTokens ?? callOptions.maxOutputTokens,
+			temperature: retryOptions.temperature ?? callOptions.temperature,
+			stopSequences: retryOptions.stopSequences ?? callOptions.stopSequences,
+			topP: retryOptions.topP ?? callOptions.topP,
+			topK: retryOptions.topK ?? callOptions.topK,
+			presencePenalty: retryOptions.presencePenalty ?? callOptions.presencePenalty,
+			frequencyPenalty: retryOptions.frequencyPenalty ?? callOptions.frequencyPenalty,
+			seed: retryOptions.seed ?? callOptions.seed,
+			headers: retryOptions.headers ?? callOptions.headers,
+			providerOptions: retryOptions.providerOptions ?? currentRetry?.providerOptions ?? callOptions.providerOptions,
+			abortSignal: currentRetry?.timeout ? AbortSignal.timeout(currentRetry.timeout) : callOptions.abortSignal
+		};
+	}
+	/**
 	* Execute a function with retry logic for handling errors
 	*/
 	async withRetry(input) {
@@ -262,7 +296,7 @@ var RetryableLanguageModel = class {
 		/**
 		* Track current retry configuration.
 		*/
-		let currentRetry;
+		let currentRetry = input.currentRetry;
 		while (true) {
 			/**
 			* The previous attempt that triggered a retry, or undefined if this is the first attempt
@@ -282,16 +316,20 @@ var RetryableLanguageModel = class {
 				};
 				this.options.onRetry?.(context);
 			}
+			/**
+			* Get the retry call options overrides for this attempt
+			*/
+			const retryCallOptions = this.getRetryCallOptions(input.callOptions, currentRetry);
 			try {
 				/**
 				* Call the function that may need to be retried
 				*/
-				const result = await input.fn(currentRetry);
+				const result = await input.fn(retryCallOptions);
 				/**
 				* Check if the result should trigger a retry (only for generate results, not streams)
 				*/
 				if (isGenerateResult(result)) {
-					const { retryModel, attempt } = await this.handleResult(result, attempts);
+					const { retryModel, attempt } = await this.handleResult(result, attempts, retryCallOptions);
 					attempts.push(attempt);
 					if (retryModel) {
 						if (retryModel.delay) {
@@ -304,7 +342,7 @@ var RetryableLanguageModel = class {
 							* - Attempt 3: 4000ms
 							*/
 							const modelAttemptsCount = countModelAttempts(retryModel.model, attempts);
-							await delay(calculateExponentialBackoff(retryModel.delay, retryModel.backoffFactor, modelAttemptsCount), { abortSignal: input.abortSignal });
+							await delay(calculateExponentialBackoff(retryModel.delay, retryModel.backoffFactor, modelAttemptsCount), { abortSignal: retryCallOptions.abortSignal });
 						}
 						this.currentModel = retryModel.model;
 						currentRetry = retryModel;
@@ -319,7 +357,7 @@ var RetryableLanguageModel = class {
 					attempts
 				};
 			} catch (error) {
-				const { retryModel, attempt } = await this.handleError(error, attempts);
+				const { retryModel, attempt } = await this.handleError(error, attempts, retryCallOptions);
 				attempts.push(attempt);
 				if (retryModel.delay) {
 					/**
@@ -327,7 +365,7 @@ var RetryableLanguageModel = class {
 					* The delay grows exponentially: baseDelay * backoffFactor^attempts
 					*/
 					const modelAttemptsCount = countModelAttempts(retryModel.model, attempts);
-					await delay(calculateExponentialBackoff(retryModel.delay, retryModel.backoffFactor, modelAttemptsCount), { abortSignal: input.abortSignal });
+					await delay(calculateExponentialBackoff(retryModel.delay, retryModel.backoffFactor, modelAttemptsCount), { abortSignal: retryCallOptions.abortSignal });
 				}
 				this.currentModel = retryModel.model;
 				currentRetry = retryModel;
@@ -337,11 +375,12 @@ var RetryableLanguageModel = class {
 	/**
 	* Handle a successful result and determine if a retry is needed
 	*/
-	async handleResult(result, attempts) {
+	async handleResult(result, attempts, callOptions) {
 		const resultAttempt = {
 			type: "result",
 			result,
-			model: this.currentModel
+			model: this.currentModel,
+			options: callOptions
 		};
 		const context = {
 			current: resultAttempt,
@@ -355,11 +394,12 @@ var RetryableLanguageModel = class {
 	/**
 	* Handle an error and determine if a retry is needed
 	*/
-	async handleError(error, attempts) {
+	async handleError(error, attempts, callOptions) {
 		const errorAttempt = {
 			type: "error",
 			error,
-			model: this.currentModel
+			model: this.currentModel,
+			options: callOptions
 		};
 		/**
 		* Save the current attempt
@@ -384,7 +424,7 @@ var RetryableLanguageModel = class {
 			attempt: errorAttempt
 		};
 	}
-	async doGenerate(options) {
+	async doGenerate(callOptions) {
 		/**
 		* Always start with the original model
 		*/
@@ -392,21 +432,16 @@ var RetryableLanguageModel = class {
 		/**
 		* If retries are disabled, bypass retry machinery entirely
 		*/
-		if (this.isDisabled()) return this.currentModel.doGenerate(options);
+		if (this.isDisabled()) return this.currentModel.doGenerate(callOptions);
 		const { result } = await this.withRetry({
-			fn: async (currentRetry) => {
-				const callOptions = {
-					...options,
-					providerOptions: currentRetry?.providerOptions ?? options.providerOptions,
-					abortSignal: currentRetry?.timeout ? AbortSignal.timeout(currentRetry.timeout) : options.abortSignal
-				};
-				return this.currentModel.doGenerate(callOptions);
+			fn: async (retryCallOptions) => {
+				return this.currentModel.doGenerate(retryCallOptions);
 			},
-			abortSignal: options.abortSignal
+			callOptions
 		});
 		return result;
 	}
-	async doStream(options) {
+	async doStream(callOptions) {
 		/**
 		* Always start with the original model
 		*/
@@ -414,22 +449,21 @@ var RetryableLanguageModel = class {
 		/**
 		* If retries are disabled, bypass retry machinery entirely
 		*/
-		if (this.isDisabled()) return this.currentModel.doStream(options);
+		if (this.isDisabled()) return this.currentModel.doStream(callOptions);
 		/**
 		* 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 (currentRetry) => {
-				const callOptions = {
-					...options,
-					providerOptions: currentRetry?.providerOptions ?? options.providerOptions,
-					abortSignal: currentRetry?.timeout ? AbortSignal.timeout(currentRetry.timeout) : options.abortSignal
-				};
-				return this.currentModel.doStream(callOptions);
+			fn: async (retryCallOptions) => {
+				return this.currentModel.doStream(retryCallOptions);
 			},
-			abortSignal: options.abortSignal
+			callOptions
 		});
 		/**
+		* Track the current retry model for computing call options in the stream handler
+		*/
+		let currentRetry;
+		/**
 		* Wrap the original stream to handle retries if an error occurs during streaming.
 		*/
 		const retryableStream = new ReadableStream({ start: async (controller) => {
@@ -459,11 +493,15 @@ var RetryableLanguageModel = class {
 				controller.close();
 				break;
 			} catch (error) {
+				/**
+				* Get the retry call options for the failed attempt
+				*/
+				const retryCallOptions = this.getRetryCallOptions(callOptions, currentRetry);
 				/**
 				* Check if the error from the stream can be retried.
 				* Otherwise it will rethrow the error.
 				*/
-				const { retryModel, attempt } = await this.handleError(error, attempts);
+				const { retryModel, attempt } = await this.handleError(error, attempts, retryCallOptions);
 				/**
 				* Save the attempt
 				*/
@@ -474,24 +512,21 @@ var RetryableLanguageModel = class {
 					* The delay grows exponentially: baseDelay * backoffFactor^attempts
 					*/
 					const modelAttemptsCount = countModelAttempts(retryModel.model, attempts);
-					await delay(calculateExponentialBackoff(retryModel.delay, retryModel.backoffFactor, modelAttemptsCount), { abortSignal: options.abortSignal });
+					await delay(calculateExponentialBackoff(retryModel.delay, retryModel.backoffFactor, modelAttemptsCount), { abortSignal: retryCallOptions.abortSignal });
 				}
 				this.currentModel = retryModel.model;
+				currentRetry = retryModel;
 				/**
 				* Retry the request by calling doStream again.
 				* This will create a new stream.
 				*/
 				const retriedResult = await this.withRetry({
-					fn: async () => {
-						const callOptions = {
-							...options,
-							providerOptions: retryModel.providerOptions ?? options.providerOptions,
-							abortSignal: retryModel.timeout ? AbortSignal.timeout(retryModel.timeout) : options.abortSignal
-						};
-						return this.currentModel.doStream(callOptions);
+					fn: async (retryCallOptions$1) => {
+						return this.currentModel.doStream(retryCallOptions$1);
 					},
+					callOptions,
 					attempts,
-					abortSignal: options.abortSignal
+					currentRetry
 				});
 				/**
 				* Cancel the previous reader and stream if we are retrying

package/dist/retryables/index.d.mts

@@ -1,4 +1,4 @@
-import { _ as RetryableOptions, h as Retryable, i as LanguageModel, t as EmbeddingModel } from "../types-2u5JeDwb.mjs";
+import { a as LanguageModel, b as RetryableOptions, t as EmbeddingModel, v as Retryable } from "../types-D4wXoA4D.mjs";
 
 //#region src/retryables/content-filter-triggered.d.ts
 

package/dist/{types-2u5JeDwb.d.mts → types-D4wXoA4D.d.mts}

@@ -1,34 +1,23 @@
-import { ProviderOptions } from "@ai-sdk/provider-utils";
-import { EmbeddingModelV2, LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2StreamPart } from "@ai-sdk/provider";
+import { EmbeddingModelV2, LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2Prompt, LanguageModelV2StreamPart, SharedV2ProviderOptions } from "@ai-sdk/provider";
 
 //#region src/types.d.ts
 type LanguageModel = LanguageModelV2;
-type EmbeddingModel<VALUE = unknown> = EmbeddingModelV2<VALUE>;
+type EmbeddingModel<VALUE = any> = EmbeddingModelV2<VALUE>;
 type LanguageModelCallOptions = LanguageModelV2CallOptions;
 type LanguageModelStreamPart = LanguageModelV2StreamPart;
+type LanguageModelPrompt = LanguageModelV2Prompt;
+type LanguageModelGenerate = Awaited<ReturnType<LanguageModel['doGenerate']>>;
+type LanguageModelStream = Awaited<ReturnType<LanguageModel['doStream']>>;
+type EmbeddingModelCallOptions<VALUE = any> = Parameters<EmbeddingModel<VALUE>['doEmbed']>[0];
+type EmbeddingModelEmbed<VALUE = any> = Awaited<ReturnType<EmbeddingModel<VALUE>['doEmbed']>>;
 /**
- * Options for creating a retryable model.
+ * Call options that can be overridden during retry for language models.
  */
-interface RetryableModelOptions<MODEL extends LanguageModel | EmbeddingModel> {
-  model: MODEL;
-  retries: Retries<MODEL>;
-  disabled?: boolean | (() => boolean);
-  onError?: (context: RetryContext<MODEL>) => void;
-  onRetry?: (context: RetryContext<MODEL>) => void;
-}
+type LanguageModelRetryCallOptions = Partial<Pick<LanguageModelCallOptions, 'prompt' | 'maxOutputTokens' | 'temperature' | 'stopSequences' | 'topP' | 'topK' | 'presencePenalty' | 'frequencyPenalty' | 'seed' | 'headers' | 'providerOptions'>>;
 /**
- * The context provided to Retryables with the current attempt and all previous attempts.
+ * Call options that can be overridden during retry for embedding models.
  */
-type RetryContext<MODEL extends LanguageModel | EmbeddingModel> = {
-  /**
-   * Current attempt that caused the retry
-   */
-  current: RetryAttempt<MODEL>;
-  /**
-   * All attempts made so far, including the current one
-   */
-  attempts: Array<RetryAttempt<MODEL>>;
-};
+type EmbeddingModelRetryCallOptions<VALUE = any> = Partial<Pick<EmbeddingModelCallOptions<VALUE>, 'values' | 'headers' | 'providerOptions'>>;
 /**
  * A retry attempt with an error
  */
@@ -37,6 +26,10 @@ type RetryErrorAttempt<MODEL extends LanguageModel | EmbeddingModel> = {
   error: unknown;
   result?: undefined;
   model: MODEL;
+  /**
+   * The call options used for this attempt.
+   */
+  options: MODEL extends LanguageModel ? LanguageModelCallOptions : EmbeddingModelCallOptions<any>;
 };
 /**
  * A retry attempt with a successful result
@@ -46,31 +39,77 @@ type RetryResultAttempt = {
   result: LanguageModelGenerate;
   error?: undefined;
   model: LanguageModel;
+  /**
+   * The call options used for this attempt.
+   */
+  options: LanguageModelCallOptions;
 };
 /**
  * A retry attempt with either an error or a result and the model used
  */
 type RetryAttempt<MODEL extends LanguageModel | EmbeddingModel> = RetryErrorAttempt<MODEL> | RetryResultAttempt;
+/**
+ * The context provided to Retryables with the current attempt and all previous attempts.
+ */
+type RetryContext<MODEL extends LanguageModel | EmbeddingModel> = {
+  /**
+   * Current attempt that caused the retry
+   */
+  current: RetryAttempt<MODEL>;
+  /**
+   * All attempts made so far, including the current one
+   */
+  attempts: Array<RetryAttempt<MODEL>>;
+};
+/**
+ * Options for creating a retryable model.
+ */
+interface RetryableModelOptions<MODEL extends LanguageModel | EmbeddingModel> {
+  model: MODEL;
+  retries: Retries<MODEL>;
+  disabled?: boolean | (() => boolean);
+  onError?: (context: RetryContext<MODEL>) => void;
+  onRetry?: (context: RetryContext<MODEL>) => void;
+}
 /**
  * A model to retry with and the maximum number of attempts for that model.
  */
 type Retry<MODEL extends LanguageModel | EmbeddingModel> = {
   model: MODEL;
+  /**
+   * Maximum number of attempts for this model.
+   */
   maxAttempts?: number;
+  /**
+   * Delay in milliseconds before retrying.
+   */
   delay?: number;
+  /**
+   * Factor to multiply the delay by for exponential backoff.
+   */
   backoffFactor?: number;
-  providerOptions?: ProviderOptions;
+  /**
+   * Timeout in milliseconds for the retry request.
+   * Creates a new AbortSignal with this timeout.
+   */
   timeout?: number;
+  /**
+   * Call options to override for this retry.
+   */
+  options?: MODEL extends LanguageModel ? Partial<LanguageModelRetryCallOptions> : Partial<EmbeddingModelRetryCallOptions>;
+  /**
+   * @deprecated Use `options.providerOptions` instead.
+   * Provider options to override for this retry.
+   * If both `providerOptions` and `options.providerOptions` are set,
+   * `options.providerOptions` takes precedence.
+   */
+  providerOptions?: SharedV2ProviderOptions;
 };
 /**
  * A function that determines whether to retry with a different model based on the current attempt and all previous attempts.
  */
-type Retryable<MODEL extends LanguageModel | EmbeddingModel> = (context: RetryContext<MODEL>) => Retry<MODEL> | Promise<Retry<MODEL>> | undefined;
+type Retryable<MODEL extends LanguageModel | EmbeddingModel> = (context: RetryContext<MODEL>) => Retry<MODEL> | Promise<Retry<MODEL> | undefined> | undefined;
 type Retries<MODEL extends LanguageModel | EmbeddingModel> = Array<Retryable<MODEL> | Retry<MODEL> | MODEL>;
 type RetryableOptions<MODEL extends LanguageModel | EmbeddingModel> = Partial<Omit<Retry<MODEL>, 'model'>>;
-type LanguageModelGenerate = Awaited<ReturnType<LanguageModel['doGenerate']>>;
-type LanguageModelStream = Awaited<ReturnType<LanguageModel['doStream']>>;
-type EmbeddingModelCallOptions<VALUE> = Parameters<EmbeddingModel<VALUE>['doEmbed']>[0];
-type EmbeddingModelEmbed<VALUE = any> = Awaited<ReturnType<EmbeddingModel<VALUE>['doEmbed']>>;
 //#endregion
-export { RetryableOptions as _, LanguageModelCallOptions as a, LanguageModelStreamPart as c, RetryAttempt as d, RetryContext as f, RetryableModelOptions as g, Retryable as h, LanguageModel as i, Retries as l, RetryResultAttempt as m, EmbeddingModelCallOptions as n, LanguageModelGenerate as o, RetryErrorAttempt as p, EmbeddingModelEmbed as r, LanguageModelStream as s, EmbeddingModel as t, Retry as u };
+export { RetryResultAttempt as _, LanguageModel as a, RetryableOptions as b, LanguageModelPrompt as c, LanguageModelStreamPart as d, Retries as f, RetryErrorAttempt as g, RetryContext as h, EmbeddingModelRetryCallOptions as i, LanguageModelRetryCallOptions as l, RetryAttempt as m, EmbeddingModelCallOptions as n, LanguageModelCallOptions as o, Retry as p, EmbeddingModelEmbed as r, LanguageModelGenerate as s, EmbeddingModel as t, LanguageModelStream as u, Retryable as v, RetryableModelOptions as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-retry",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "description": "AI SDK Retry",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",