ai-retry 0.10.3 → 0.12.0

package/README.md

@@ -94,6 +94,41 @@ const result = await embed({
 console.log(result.embedding);
 ```
 
+#### Vercel AI Gateway
+
+You can use `ai-retry` with Vercel AI Gateway by providing the model as a string. Internally, the model will be resolved with the default `gateway` [provider instance](https://ai-sdk.dev/providers/ai-sdk-providers/ai-gateway#provider-instance) from AI SDK.
+
+```typescript
+import { gateway } from 'ai';
+import { createRetryable } from 'ai-retry';
+
+const retryableModel = createRetryable({
+  model: 'openai/gpt-5',
+  retries: [
+    'anthropic/claude-sonnet-4'
+  ]
+});
+
+// Is the same as:
+const retryableModel = createRetryable({
+  model: gateway('openai/gpt-5'),
+  retries: [
+    gateway('anthropic/claude-sonnet-4')
+  ]
+});
+```
+
+By default, the `gateway` provider resolves model strings as language models. If you want to use an embedding model, you need to use the `textEmbeddingModel` method.
+
+```typescript
+import { gateway } from 'ai';
+import { createRetryable } from 'ai-retry';
+
+const retryableModel = createRetryable({
+  model: gateway.textEmbeddingModel('openai/text-embedding-3-large'),
+});
+```
+
 ### Retryables
 
 The objects passed to the `retries` are called retryables and control the retry behavior. We can distinguish between two types of retryables:
@@ -138,6 +173,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 +411,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 +636,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 +754,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 +763,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 +781,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,7 +1,10 @@
-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-TotEvw-5.mjs";
+import { C as RetryableModelOptions, S as Retryable, _ as Retry, a as GatewayLanguageModelId, b as RetryErrorAttempt, c as LanguageModelGenerate, d as LanguageModelStreamPart, f as ProviderOptions, g as Retries, h as ResolvedModel, i as EmbeddingModelRetryCallOptions, l as LanguageModelRetryCallOptions, m as ResolvableModel, n as EmbeddingModelCallOptions, o as LanguageModel, p as ResolvableLanguageModel, r as EmbeddingModelEmbed, s as LanguageModelCallOptions, t as EmbeddingModel, u as LanguageModelStream, v as RetryAttempt, w as RetryableOptions, x as RetryResultAttempt, y as RetryContext } from "./types-Csx79V-W.mjs";
 import * as _ai_sdk_provider0 from "@ai-sdk/provider";
 
 //#region src/create-retryable-model.d.ts
+declare function createRetryable<MODEL extends LanguageModel>(options: Omit<RetryableModelOptions<LanguageModel>, 'model'> & {
+  model: GatewayLanguageModelId;
+}): LanguageModel;
 declare function createRetryable<MODEL extends LanguageModel>(options: RetryableModelOptions<MODEL>): LanguageModel;
 declare function createRetryable<MODEL extends EmbeddingModel>(options: RetryableModelOptions<MODEL>): EmbeddingModel;
 //#endregion
@@ -14,9 +17,9 @@ declare const getModelKey: (model: LanguageModel | EmbeddingModel) => 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 LanguageModel | EmbeddingModel;
-declare const isLanguageModelV2: (model: unknown) => model is LanguageModel;
-declare const isEmbeddingModelV2: (model: unknown) => model is EmbeddingModel;
+declare const isModel: (model: unknown) => model is LanguageModel | EmbeddingModel;
+declare const isLanguageModel: (model: unknown) => model is LanguageModel;
+declare const isEmbeddingModel: (model: unknown) => model is EmbeddingModel;
 declare const isStreamResult: (result: LanguageModelGenerate | LanguageModelStream) => result is LanguageModelStream;
 declare const isGenerateResult: (result: LanguageModelGenerate | LanguageModelStream) => result is LanguageModelGenerate;
 /**
@@ -65,9 +68,5 @@ declare const isStreamContentPart: (part: LanguageModelStreamPart) => part is _a
   type: "raw";
   rawValue: unknown;
 };
-/**
- * Type guard to check if a value is a Retry object (has a model property with a MODEL)
- */
-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, GatewayLanguageModelId, LanguageModel, LanguageModelCallOptions, LanguageModelGenerate, LanguageModelRetryCallOptions, LanguageModelStream, LanguageModelStreamPart, ProviderOptions, ResolvableLanguageModel, ResolvableModel, ResolvedModel, Retries, Retry, RetryAttempt, RetryContext, RetryErrorAttempt, RetryResultAttempt, Retryable, RetryableModelOptions, RetryableOptions, createRetryable, getModelKey, isEmbeddingModel, isErrorAttempt, isGenerateResult, isLanguageModel, isModel, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString };

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { a as isModelV2, c as isRetry, d as isString, i as isLanguageModelV2, l as isStreamContentPart, n as isErrorAttempt, o as isObject, r as isGenerateResult, s as isResultAttempt, t as isEmbeddingModelV2, u as isStreamResult } from "./utils-C26pNHta.mjs";
+import { a as isModel, c as isStreamContentPart, i as isLanguageModel, l as isStreamResult, n as isErrorAttempt, o as isObject, r as isGenerateResult, s as isResultAttempt, t as isEmbeddingModel, u as isString } from "./utils-C_AwyHeC.mjs";
+import { RetryError, gateway } from "ai";
 import { delay } from "@ai-sdk/provider-utils";
 import { getErrorMessage } from "@ai-sdk/provider";
-import { RetryError } from "ai";
 
 //#region src/calculate-exponential-backoff.ts
 /**
@@ -27,6 +27,15 @@ function countModelAttempts(model, attempts) {
 	return attempts.filter((a) => getModelKey(a.model) === modelKey).length;
 }
 
+//#endregion
+//#region src/resolve-model.ts
+/**
+* Resolve a model string via the AI SDK Gateway to a modelinstance
+*/
+function resolveModel(model) {
+	return isModel(model) ? model : gateway(model);
+}
+
 //#endregion
 //#region src/find-retry-model.ts
 /**
@@ -45,13 +54,19 @@ async function findRetryModel(retries, context) {
 	for (const retry of applicableRetries) {
 		let retryModel;
 		if (typeof retry === "function") retryModel = await retry(context);
-		else if (isRetry(retry)) retryModel = retry;
+		else if (isObject(retry) && "model" in retry) retryModel = retry;
 		else retryModel = { model: retry };
 		if (retryModel) {
+			/**
+			* The model can be string or an instance.
+			* If it is a string, we need to resolve it to an instance.
+			*/
+			const modelValue = retryModel.model;
+			const resolvedModel = resolveModel(modelValue);
 			/**
 			* The model key uniquely identifies a model instance (provider + modelId)
 			*/
-			const retryModelKey = getModelKey(retryModel.model);
+			const retryModelKey = getModelKey(resolvedModel);
 			/**
 			* Find all attempts with the same model
 			*/
@@ -60,7 +75,10 @@ async function findRetryModel(retries, context) {
 			/**
 			* Check if the model can still be retried based on maxAttempts
 			*/
-			if (retryAttempts.length < maxAttempts) return retryModel;
+			if (retryAttempts.length < maxAttempts) return {
+				...retryModel,
+				model: resolvedModel
+			};
 		}
 	}
 }
@@ -112,6 +130,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 +173,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 +195,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 +205,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 +235,7 @@ var RetryableEmbeddingModel = class {
 			attempt: errorAttempt
 		};
 	}
-	async doEmbed(options) {
+	async doEmbed(callOptions) {
 		/**
 		* Always start with the original model
 		*/
@@ -207,17 +243,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 +283,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 +314,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 +334,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 +360,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 +375,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 +383,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 +393,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 +412,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 +442,7 @@ var RetryableLanguageModel = class {
 			attempt: errorAttempt
 		};
 	}
-	async doGenerate(options) {
+	async doGenerate(callOptions) {
 		/**
 		* Always start with the original model
 		*/
@@ -392,21 +450,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 +467,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 +511,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 +530,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
@@ -513,9 +566,16 @@ var RetryableLanguageModel = class {
 //#endregion
 //#region src/create-retryable-model.ts
 function createRetryable(options) {
-	if ("doEmbed" in options.model) return new RetryableEmbeddingModel(options);
-	return new RetryableLanguageModel(options);
+	const model = isModel(options.model) ? options.model : gateway(options.model);
+	if (isEmbeddingModel(model)) return new RetryableEmbeddingModel({
+		...options,
+		model
+	});
+	return new RetryableLanguageModel({
+		...options,
+		model
+	});
 }
 
 //#endregion
-export { createRetryable, getModelKey, isEmbeddingModelV2, isErrorAttempt, isGenerateResult, isLanguageModelV2, isModelV2, isObject, isResultAttempt, isRetry, isStreamContentPart, isStreamResult, isString };
+export { createRetryable, getModelKey, isEmbeddingModel, isErrorAttempt, isGenerateResult, isLanguageModel, isModel, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString };

package/dist/retryables/index.d.mts

@@ -1,17 +1,17 @@
-import { _ as RetryableOptions, h as Retryable, i as LanguageModel, t as EmbeddingModel } from "../types-TotEvw-5.mjs";
+import { S as Retryable, p as ResolvableLanguageModel, t as EmbeddingModel, w as RetryableOptions } from "../types-Csx79V-W.mjs";
 
 //#region src/retryables/content-filter-triggered.d.ts
 
 /**
  * Fallback to a different model if the content filter was triggered.
  */
-declare function contentFilterTriggered<MODEL extends LanguageModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
+declare function contentFilterTriggered<MODEL extends ResolvableLanguageModel>(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 LanguageModel | EmbeddingModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
+declare function requestNotRetryable<MODEL extends ResolvableLanguageModel | EmbeddingModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
 //#region src/retryables/request-timeout.d.ts
 /**
@@ -19,7 +19,7 @@ declare function requestNotRetryable<MODEL extends LanguageModel | EmbeddingMode
  * Use in combination with the `abortSignal` option.
  * If no timeout is specified, a default of 60 seconds is used.
  */
-declare function requestTimeout<MODEL extends LanguageModel | EmbeddingModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
+declare function requestTimeout<MODEL extends ResolvableLanguageModel | EmbeddingModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
 //#region src/retryables/retry-after-delay.d.ts
 /**
@@ -27,7 +27,7 @@ declare function requestTimeout<MODEL extends LanguageModel | EmbeddingModel>(mo
  * Uses the `Retry-After` or `Retry-After-Ms` headers if present.
  * Otherwise uses the specified `delay` and `backoffFactor` if provided.
  */
-declare function retryAfterDelay<MODEL extends LanguageModel | EmbeddingModel>(options: RetryableOptions<MODEL>): Retryable<MODEL>;
+declare function retryAfterDelay<MODEL extends ResolvableLanguageModel | EmbeddingModel>(options: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
 //#region src/retryables/service-overloaded.d.ts
 /**
@@ -37,13 +37,13 @@ declare function retryAfterDelay<MODEL extends LanguageModel | EmbeddingModel>(o
  * - Response with `type: "overloaded_error"`
  * - Response with a `message` containing "overloaded"
  */
-declare function serviceOverloaded<MODEL extends LanguageModel | EmbeddingModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
+declare function serviceOverloaded<MODEL extends ResolvableLanguageModel | EmbeddingModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
 //#region src/retryables/service-unavailable.d.ts
 /**
  * Fallback to a different model if the provider returns a service unavailable error.
  * This retryable handles HTTP status code 503 (Service Unavailable).
  */
-declare function serviceUnavailable<MODEL extends LanguageModel | EmbeddingModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
+declare function serviceUnavailable<MODEL extends ResolvableLanguageModel | EmbeddingModel>(model: MODEL, options?: RetryableOptions<MODEL>): Retryable<MODEL>;
 //#endregion
 export { contentFilterTriggered, requestNotRetryable, requestTimeout, retryAfterDelay, serviceOverloaded, serviceUnavailable };

package/dist/retryables/index.mjs

@@ -1,6 +1,6 @@
-import { d as isString, n as isErrorAttempt, o as isObject, s as isResultAttempt } from "../utils-C26pNHta.mjs";
-import { isAbortError } from "@ai-sdk/provider-utils";
+import { n as isErrorAttempt, o as isObject, s as isResultAttempt, u as isString } from "../utils-C_AwyHeC.mjs";
 import { APICallError } from "ai";
+import { isAbortError } from "@ai-sdk/provider-utils";
 
 //#region src/retryables/content-filter-triggered.ts
 /**

package/dist/types-Csx79V-W.d.mts

@@ -0,0 +1,129 @@
+import { gateway } from "ai";
+import { EmbeddingModelV2, LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2StreamPart, SharedV2ProviderOptions } from "@ai-sdk/provider";
+
+//#region src/types.d.ts
+type Literals<T> = T extends string ? string extends T ? never : T : never;
+type LanguageModel = LanguageModelV2;
+type EmbeddingModel<VALUE = any> = EmbeddingModelV2<VALUE>;
+type LanguageModelCallOptions = LanguageModelV2CallOptions;
+type LanguageModelStreamPart = LanguageModelV2StreamPart;
+type ProviderOptions = SharedV2ProviderOptions;
+type GatewayLanguageModelId = Parameters<(typeof gateway)['languageModel']>[0];
+type ResolvableLanguageModel = LanguageModel | Literals<GatewayLanguageModelId>;
+type ResolvableModel<MODEL extends LanguageModel | EmbeddingModel> = MODEL extends LanguageModel ? ResolvableLanguageModel : EmbeddingModel;
+type ResolvedModel<MODEL extends ResolvableLanguageModel | EmbeddingModel> = MODEL extends ResolvableLanguageModel ? LanguageModel : EmbeddingModel;
+/**
+ * Call options that can be overridden during retry for language models.
+ */
+type LanguageModelRetryCallOptions = Partial<Pick<LanguageModelCallOptions, 'prompt' | 'maxOutputTokens' | 'temperature' | 'stopSequences' | 'topP' | 'topK' | 'presencePenalty' | 'frequencyPenalty' | 'seed' | 'headers' | 'providerOptions'>>;
+/**
+ * Call options that can be overridden during retry for embedding models.
+ */
+type EmbeddingModelRetryCallOptions<VALUE = any> = Partial<Pick<EmbeddingModelCallOptions<VALUE>, 'values' | 'headers' | 'providerOptions'>>;
+/**
+ * A retry attempt with an error
+ */
+type RetryErrorAttempt<MODEL extends LanguageModel | EmbeddingModel> = {
+  type: 'error';
+  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
+ */
+type RetryResultAttempt = {
+  type: 'result';
+  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 ResolvableLanguageModel | EmbeddingModel> = {
+  /**
+   * Current attempt that caused the retry
+   */
+  current: RetryAttempt<ResolvedModel<MODEL>>;
+  /**
+   * All attempts made so far, including the current one
+   */
+  attempts: Array<RetryAttempt<ResolvedModel<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.
+ *
+ * The model can be:
+ * - The exact MODEL type (instance)
+ * - A gateway string literal (for LanguageModel only)
+ * - A ResolvableModel<MODEL> (for compatibility with plain model arrays)
+ *
+ * This flexible approach allows retryable functions to return the exact model type
+ * they received without type assertions, while still supporting string-based gateway models.
+ */
+type Retry<MODEL extends ResolvableLanguageModel | 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;
+  /**
+   * 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 ResolvableLanguageModel | EmbeddingModel> = (context: RetryContext<MODEL>) => Retry<MODEL> | Promise<Retry<MODEL> | undefined> | undefined;
+type Retries<MODEL extends LanguageModel | EmbeddingModel> = Array<Retryable<ResolvableModel<MODEL>> | Retry<ResolvableModel<MODEL>> | ResolvableModel<MODEL>>;
+type RetryableOptions<MODEL extends ResolvableLanguageModel | 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 { RetryableModelOptions as C, Retryable as S, Retry as _, GatewayLanguageModelId as a, RetryErrorAttempt as b, LanguageModelGenerate as c, LanguageModelStreamPart as d, ProviderOptions as f, Retries as g, ResolvedModel as h, EmbeddingModelRetryCallOptions as i, LanguageModelRetryCallOptions as l, ResolvableModel as m, EmbeddingModelCallOptions as n, LanguageModel as o, ResolvableLanguageModel as p, EmbeddingModelEmbed as r, LanguageModelCallOptions as s, EmbeddingModel as t, LanguageModelStream as u, RetryAttempt as v, RetryableOptions as w, RetryResultAttempt as x, RetryContext as y };

package/dist/{utils-C26pNHta.mjs → utils-C_AwyHeC.mjs}

@@ -1,9 +1,9 @@
 //#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 isModel = (model) => isLanguageModel(model) || isEmbeddingModel(model);
+const isLanguageModel = (model) => isObject(model) && "provider" in model && "modelId" in model && "specificationVersion" in model && "doGenerate" in model && model.specificationVersion === "v2";
+const isEmbeddingModel = (model) => isObject(model) && "provider" in model && "modelId" in model && "specificationVersion" in model && "doEmbed" in model && model.specificationVersion === "v2";
 const isStreamResult = (result) => "stream" in result;
 const isGenerateResult = (result) => "content" in result;
 /**
@@ -26,10 +26,6 @@ function isResultAttempt(attempt) {
 const isStreamContentPart = (part) => {
 	return part.type === "text-delta" || part.type === "reasoning-delta" || part.type === "source" || part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-input-start" || part.type === "tool-input-delta" || part.type === "raw";
 };
-/**
-* Type guard to check if a value is a Retry object (has a model property with a MODEL)
-*/
-const isRetry = (value) => isObject(value) && "model" in value && isModelV2(value.model);
 
 //#endregion
-export { isModelV2 as a, isRetry as c, isString as d, isLanguageModelV2 as i, isStreamContentPart as l, isErrorAttempt as n, isObject as o, isGenerateResult as r, isResultAttempt as s, isEmbeddingModelV2 as t, isStreamResult as u };
+export { isModel as a, isStreamContentPart as c, isLanguageModel as i, isStreamResult as l, isErrorAttempt as n, isObject as o, isGenerateResult as r, isResultAttempt as s, isEmbeddingModel as t, isString as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-retry",
-  "version": "0.10.3",
+  "version": "0.12.0",
   "description": "AI SDK Retry",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
@@ -35,13 +35,14 @@
   "devDependencies": {
     "@ai-sdk/anthropic": "^2.0.18",
     "@ai-sdk/azure": "^2.0.30",
+    "@ai-sdk/gateway": "^2.0.15",
     "@ai-sdk/groq": "^2.0.24",
     "@ai-sdk/openai": "^2.0.53",
     "@arethetypeswrong/cli": "^0.18.2",
     "@biomejs/biome": "^2.2.4",
     "@total-typescript/tsconfig": "^1.0.4",
     "@types/node": "^24.3.3",
-    "ai": "^5.0.44",
+    "ai": "^5.0.102",
     "husky": "^9.1.7",
     "msw": "^2.11.2",
     "pkg-pr-new": "^0.0.60",

package/dist/types-TotEvw-5.d.mts

@@ -1,76 +0,0 @@
-import { ProviderOptions } from "@ai-sdk/provider-utils";
-import { EmbeddingModelV2, LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2StreamPart } from "@ai-sdk/provider";
-
-//#region src/types.d.ts
-type LanguageModel = LanguageModelV2;
-type EmbeddingModel<VALUE = unknown> = EmbeddingModelV2<VALUE>;
-type LanguageModelCallOptions = LanguageModelV2CallOptions;
-type LanguageModelStreamPart = LanguageModelV2StreamPart;
-/**
- * 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;
-}
-/**
- * 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>>;
-};
-/**
- * A retry attempt with an error
- */
-type RetryErrorAttempt<MODEL extends LanguageModel | EmbeddingModel> = {
-  type: 'error';
-  error: unknown;
-  result?: undefined;
-  model: MODEL;
-};
-/**
- * A retry attempt with a successful result
- */
-type RetryResultAttempt = {
-  type: 'result';
-  result: LanguageModelGenerate;
-  error?: undefined;
-  model: LanguageModel;
-};
-/**
- * A retry attempt with either an error or a result and the model used
- */
-type RetryAttempt<MODEL extends LanguageModel | EmbeddingModel> = RetryErrorAttempt<MODEL> | RetryResultAttempt;
-/**
- * A model to retry with and the maximum number of attempts for that model.
- */
-type Retry<MODEL extends LanguageModel | EmbeddingModel> = {
-  model: MODEL;
-  maxAttempts?: number;
-  delay?: number;
-  backoffFactor?: number;
-  providerOptions?: ProviderOptions;
-  timeout?: 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 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 };