ai-retry 1.1.0 → 1.2.0

package/README.md

@@ -757,6 +757,46 @@ const retryableModel = createRetryable({
 });
 ```
 
+#### Reset
+
+By default, every new request starts with the base model, even if a previous request was retried with a different model. The `reset` option changes this behavior by making the last successfully retried model **sticky**, that means subsequent requests will continue using that model instead of switching back to the base model. The reset value controls how long the retry model stays sticky before resetting back to the base model.
+
+| Value | Description |
+|-------|-------------|
+| `'after-request'` | Reset immediately after the next request (default) |
+| `` `after-${N}-requests` `` | Keep the retry model for the next **N** requests, then reset |
+| `` `after-${N}-seconds` `` | Keep the retry model for **N** seconds, then reset |
+
+**Reset after each request (default)**
+
+```typescript
+const retryableModel = createRetryable({
+  model: openai('gpt-4o-mini'),
+  retries: [anthropic('claude-sonnet-4-20250514')],
+  reset: 'after-request', // default — always start with the base model
+});
+```
+
+**Keep the retry model for N requests**
+
+```typescript
+const retryableModel = createRetryable({
+  model: openai('gpt-4o-mini'),
+  retries: [anthropic('claude-sonnet-4-20250514')],
+  reset: 'after-5-requests', // use the retry model for 5 more requests before resetting
+});
+```
+
+**Keep the retry model for N seconds**
+
+```typescript
+const retryableModel = createRetryable({
+  model: openai('gpt-4o-mini'),
+  retries: [anthropic('claude-sonnet-4-20250514')],
+  reset: 'after-30-seconds', // use the retry model for 30 seconds before resetting
+});
+```
+
 ### Streaming
 
 Errors during streaming requests can occur in two ways:
@@ -777,6 +817,7 @@ interface RetryableModelOptions<MODEL extends LanguageModelV2 | EmbeddingModelV2
   model: MODEL;
   retries: Array<Retryable<MODEL> | MODEL>;
   disabled?: boolean | (() => boolean);
+  reset?: Reset;
   onError?: (context: RetryContext<MODEL>) => void;
   onRetry?: (context: RetryContext<MODEL>) => void;
 }
@@ -786,9 +827,25 @@ interface RetryableModelOptions<MODEL extends LanguageModelV2 | EmbeddingModelV2
 - `model`: The base model to use for the initial request.
 - `retries`: Array of retryables (functions, models, or retry objects) to attempt on failure.
 - `disabled`: Disable all retry logic. Can be a boolean or function returning boolean. Default: `false` (retries enabled).
+- `reset`: Controls when to reset back to the base model after a successful retry. See [Reset](#reset) for details. Default: `'after-request'`.
 - `onError`: Callback invoked when an error occurs.
 - `onRetry`: Callback invoked before attempting a retry.
 
+#### `Reset`
+
+Controls when the sticky model resets back to the base model after a successful retry.
+
+```ts
+type Reset =
+  | 'after-request'
+  | `after-${number}-requests`
+  | `after-${number}-seconds`;
+```
+
+- `'after-request'` — reset immediately after the next request (default).
+- `` `after-${N}-requests` `` — keep the retry model for the next N requests, then reset.
+- `` `after-${N}-seconds` `` — keep the retry model for N seconds, then reset.
+
 #### `Retryable`
 
 A `Retryable` is a function that receives a `RetryContext` with the current error or result and model and all previous attempts.

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-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-Bty5BU37.mjs";
+import { C as Retryable, S as RetryResultAttempt, T as RetryableOptions, _ as Retries, a as GatewayLanguageModelId, b as RetryContext, c as LanguageModelGenerate, d as LanguageModelStreamPart, f as ProviderOptions, g as ResolvedModel, h as ResolvableModel, i as EmbeddingModelRetryCallOptions, l as LanguageModelRetryCallOptions, m as ResolvableLanguageModel, n as EmbeddingModelCallOptions, o as LanguageModel, p as Reset, r as EmbeddingModelEmbed, s as LanguageModelCallOptions, t as EmbeddingModel, u as LanguageModelStream, v as Retry, w as RetryableModelOptions, x as RetryErrorAttempt, y as RetryAttempt } from "./types-Dk5KMZMd.mjs";
 import * as _ai_sdk_provider0 from "@ai-sdk/provider";
 
 //#region src/create-retryable-model.d.ts
@@ -73,4 +73,4 @@ declare const isAbortError: (error: unknown) => boolean;
  */
 declare const isTimeoutError: (error: unknown) => boolean;
 //#endregion
-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, isAbortError, isEmbeddingModel, isErrorAttempt, isGenerateResult, isLanguageModel, isModel, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString, isTimeoutError };
+export { EmbeddingModel, EmbeddingModelCallOptions, EmbeddingModelEmbed, EmbeddingModelRetryCallOptions, GatewayLanguageModelId, LanguageModel, LanguageModelCallOptions, LanguageModelGenerate, LanguageModelRetryCallOptions, LanguageModelStream, LanguageModelStreamPart, ProviderOptions, Reset, ResolvableLanguageModel, ResolvableModel, ResolvedModel, Retries, Retry, RetryAttempt, RetryContext, RetryErrorAttempt, RetryResultAttempt, Retryable, RetryableModelOptions, RetryableOptions, createRetryable, getModelKey, isAbortError, isEmbeddingModel, isErrorAttempt, isGenerateResult, isLanguageModel, isModel, isObject, isResultAttempt, isStreamContentPart, isStreamResult, isString, isTimeoutError };

package/dist/index.mjs

@@ -3,6 +3,86 @@ import { RetryError, gateway } from "ai";
 import { delay } from "@ai-sdk/provider-utils";
 import { getErrorMessage } from "@ai-sdk/provider";
 
+//#region src/parse-reset.ts
+/**
+* Parses a `Reset` string into a structured object.
+*
+* `'after-request'` is treated as `{ type: 'requests', count: 0 }`,
+* meaning the sticky model expires immediately (default behavior).
+*
+* @example
+* parseReset(`after-request`);      // { type: 'requests', count: 0 }
+* parseReset(`after-5-requests`);   // { type: 'requests', count: 5 }
+* parseReset(`after-30-seconds`);   // { type: 'seconds', count: 30 }
+*/
+function parseReset(reset) {
+	if (reset === `after-request`) return {
+		type: `requests`,
+		count: 0
+	};
+	const requestsMatch = reset.match(/^after-(\d+)-requests$/);
+	if (requestsMatch) return {
+		type: `requests`,
+		count: Number.parseInt(requestsMatch[1], 10)
+	};
+	const secondsMatch = reset.match(/^after-(\d+)-seconds$/);
+	if (secondsMatch) return {
+		type: `seconds`,
+		count: Number.parseInt(secondsMatch[1], 10)
+	};
+	throw new Error(`Invalid reset option: ${reset}`);
+}
+
+//#endregion
+//#region src/base-retryable-model.ts
+var BaseRetryableModel = class {
+	baseModel;
+	currentModel;
+	options;
+	parsedReset;
+	/** The model that last succeeded via retry, used for subsequent requests. */
+	stickyState;
+	constructor(options) {
+		this.options = options;
+		this.baseModel = options.model;
+		this.currentModel = options.model;
+		this.parsedReset = parseReset(options.reset ?? `after-request`);
+	}
+	/**
+	* Determine which model to start the request with,
+	* considering the sticky model and reset policy.
+	*/
+	resolveStartModel() {
+		if (!this.stickyState) return this.baseModel;
+		if (this.parsedReset.type === `requests`) {
+			if (this.stickyState.requestsRemaining > 0) {
+				this.stickyState.requestsRemaining--;
+				return this.stickyState.model;
+			}
+		} else if (Date.now() - this.stickyState.setAt < this.parsedReset.count * 1e3) return this.stickyState.model;
+		this.stickyState = void 0;
+		return this.baseModel;
+	}
+	/**
+	* After a successful request, update sticky model if a retry occurred.
+	*/
+	updateStickyModel(startModel) {
+		if (this.currentModel !== startModel) this.stickyState = {
+			model: this.currentModel,
+			setAt: Date.now(),
+			requestsRemaining: this.parsedReset.type === `requests` ? this.parsedReset.count : 0
+		};
+	}
+	/**
+	* Check if retries are disabled
+	*/
+	isDisabled() {
+		if (this.options.disabled === void 0) return false;
+		return typeof this.options.disabled === `function` ? this.options.disabled() : this.options.disabled;
+	}
+};
+
+//#endregion
 //#region src/calculate-exponential-backoff.ts
 /**
 * Calculates the exponential backoff delay.
@@ -100,11 +180,8 @@ function prepareRetryError(error, attempts) {
 
 //#endregion
 //#region src/retryable-embedding-model.ts
-var RetryableEmbeddingModel = class {
+var RetryableEmbeddingModel = class extends BaseRetryableModel {
 	specificationVersion = "v3";
-	baseModel;
-	currentModel;
-	options;
 	get modelId() {
 		return this.currentModel.modelId;
 	}
@@ -117,18 +194,6 @@ var RetryableEmbeddingModel = class {
 	get supportsParallelCalls() {
 		return this.currentModel.supportsParallelCalls;
 	}
-	constructor(options) {
-		this.options = options;
-		this.baseModel = options.model;
-		this.currentModel = options.model;
-	}
-	/**
-	* Check if retries are disabled
-	*/
-	isDisabled() {
-		if (this.options.disabled === void 0) return false;
-		return typeof this.options.disabled === "function" ? this.options.disabled() : this.options.disabled;
-	}
 	/**
 	* Get the retry call options overrides from a retry configuration.
 	*/
@@ -238,9 +303,10 @@ var RetryableEmbeddingModel = class {
 	}
 	async doEmbed(callOptions) {
 		/**
-		* Always start with the original model
+		* Resolve the starting model (base or sticky)
 		*/
-		this.currentModel = this.baseModel;
+		const startModel = this.resolveStartModel();
+		this.currentModel = startModel;
 		/**
 		* If retries are disabled, bypass retry machinery entirely
 		*/
@@ -251,17 +317,15 @@ var RetryableEmbeddingModel = class {
 			},
 			callOptions
 		});
+		this.updateStickyModel(startModel);
 		return result;
 	}
 };
 
 //#endregion
 //#region src/retryable-language-model.ts
-var RetryableLanguageModel = class {
+var RetryableLanguageModel = class extends BaseRetryableModel {
 	specificationVersion = "v3";
-	baseModel;
-	currentModel;
-	options;
 	get modelId() {
 		return this.currentModel.modelId;
 	}
@@ -271,18 +335,6 @@ var RetryableLanguageModel = class {
 	get supportedUrls() {
 		return this.currentModel.supportedUrls;
 	}
-	constructor(options) {
-		this.options = options;
-		this.baseModel = options.model;
-		this.currentModel = options.model;
-	}
-	/**
-	* Check if retries are disabled
-	*/
-	isDisabled() {
-		if (this.options.disabled === void 0) return false;
-		return typeof this.options.disabled === "function" ? this.options.disabled() : this.options.disabled;
-	}
 	/**
 	* Get the retry call options overrides from a retry configuration.
 	*/
@@ -446,9 +498,10 @@ var RetryableLanguageModel = class {
 	}
 	async doGenerate(callOptions) {
 		/**
-		* Always start with the original model
+		* Resolve the starting model (base or sticky)
 		*/
-		this.currentModel = this.baseModel;
+		const startModel = this.resolveStartModel();
+		this.currentModel = startModel;
 		/**
 		* If retries are disabled, bypass retry machinery entirely
 		*/
@@ -459,13 +512,15 @@ var RetryableLanguageModel = class {
 			},
 			callOptions
 		});
+		this.updateStickyModel(startModel);
 		return result;
 	}
 	async doStream(callOptions) {
 		/**
-		* Always start with the original model
+		* Resolve the starting model (base or sticky)
 		*/
-		this.currentModel = this.baseModel;
+		const startModel = this.resolveStartModel();
+		this.currentModel = startModel;
 		/**
 		* If retries are disabled, bypass retry machinery entirely
 		*/
@@ -479,6 +534,7 @@ var RetryableLanguageModel = class {
 			},
 			callOptions
 		});
+		this.updateStickyModel(startModel);
 		/**
 		* Track the current retry model for computing call options in the stream handler
 		*/
@@ -554,6 +610,7 @@ var RetryableLanguageModel = class {
 				await reader?.cancel();
 				result = retriedResult.result;
 				attempts = retriedResult.attempts;
+				this.updateStickyModel(startModel);
 			} finally {
 				reader?.releaseLock();
 			}

package/dist/retryables/index.d.mts

@@ -1,4 +1,4 @@
-import { S as Retryable, p as ResolvableLanguageModel, t as EmbeddingModel, w as RetryableOptions } from "../types-Bty5BU37.mjs";
+import { C as Retryable, T as RetryableOptions, m as ResolvableLanguageModel, t as EmbeddingModel } from "../types-Dk5KMZMd.mjs";
 
 //#region src/retryables/content-filter-triggered.d.ts
 /**

package/dist/{types-Bty5BU37.d.mts → types-Dk5KMZMd.d.mts}

@@ -70,6 +70,12 @@ interface RetryableModelOptions<MODEL extends LanguageModel | EmbeddingModel> {
   model: MODEL;
   retries: Retries<MODEL>;
   disabled?: boolean | (() => boolean);
+  /**
+   * Controls when to reset back to the base model after a successful retry.
+   *
+   * @default 'after-request'
+   */
+  reset?: Reset;
   onError?: (context: RetryContext<MODEL>) => void;
   onRetry?: (context: RetryContext<MODEL>) => void;
 }
@@ -121,9 +127,17 @@ type Retry<MODEL extends ResolvableLanguageModel | EmbeddingModel> = {
 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'>>;
+/**
+ * Controls when to reset the sticky model back to the base model.
+ *
+ * - `'after-request'` — reset after each request (default, current behavior)
+ * - `` `after-${number}-requests` `` — use the retry model for the next N requests
+ * - `` `after-${number}-seconds` `` — use the retry model for the next N seconds
+ */
+type Reset = 'after-request' | `after-${number}-requests` | `after-${number}-seconds`;
 type LanguageModelGenerate = Awaited<ReturnType<LanguageModel['doGenerate']>>;
 type LanguageModelStream = Awaited<ReturnType<LanguageModel['doStream']>>;
 type EmbeddingModelCallOptions = Parameters<EmbeddingModel['doEmbed']>[0];
 type EmbeddingModelEmbed = Awaited<ReturnType<EmbeddingModel['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 };
+export { Retryable as C, RetryResultAttempt as S, RetryableOptions as T, Retries as _, GatewayLanguageModelId as a, RetryContext as b, LanguageModelGenerate as c, LanguageModelStreamPart as d, ProviderOptions as f, ResolvedModel as g, ResolvableModel as h, EmbeddingModelRetryCallOptions as i, LanguageModelRetryCallOptions as l, ResolvableLanguageModel as m, EmbeddingModelCallOptions as n, LanguageModel as o, Reset as p, EmbeddingModelEmbed as r, LanguageModelCallOptions as s, EmbeddingModel as t, LanguageModelStream as u, Retry as v, RetryableModelOptions as w, RetryErrorAttempt as x, RetryAttempt as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-retry",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "AI SDK Retry",
   "types": "./dist/index.d.mts",
   "type": "module",