ai-retry 0.11.0 → 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:

package/dist/index.d.mts

@@ -1,7 +1,10 @@
-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 { 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, 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 };
+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
+			};
 		}
 	}
 }
@@ -548,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 { a as LanguageModel, b as RetryableOptions, t as EmbeddingModel, v as Retryable } from "../types-D4wXoA4D.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-D4wXoA4D.d.mts → types-Csx79V-W.d.mts}

@@ -1,15 +1,17 @@
-import { EmbeddingModelV2, LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2Prompt, LanguageModelV2StreamPart, SharedV2ProviderOptions } from "@ai-sdk/provider";
+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 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']>>;
+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.
  */
@@ -51,15 +53,15 @@ type RetryAttempt<MODEL extends LanguageModel | EmbeddingModel> = RetryErrorAtte
 /**
  * The context provided to Retryables with the current attempt and all previous attempts.
  */
-type RetryContext<MODEL extends LanguageModel | EmbeddingModel> = {
+type RetryContext<MODEL extends ResolvableLanguageModel | EmbeddingModel> = {
   /**
    * Current attempt that caused the retry
    */
-  current: RetryAttempt<MODEL>;
+  current: RetryAttempt<ResolvedModel<MODEL>>;
   /**
    * All attempts made so far, including the current one
    */
-  attempts: Array<RetryAttempt<MODEL>>;
+  attempts: Array<RetryAttempt<ResolvedModel<MODEL>>>;
 };
 /**
  * Options for creating a retryable model.
@@ -73,8 +75,16 @@ interface RetryableModelOptions<MODEL extends LanguageModel | EmbeddingModel> {
 }
 /**
  * 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 LanguageModel | EmbeddingModel> = {
+type Retry<MODEL extends ResolvableLanguageModel | EmbeddingModel> = {
   model: MODEL;
   /**
    * Maximum number of attempts for this model.
@@ -108,8 +118,12 @@ type Retry<MODEL extends LanguageModel | EmbeddingModel> = {
 /**
  * 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 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 { 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 };
+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.11.0",
+  "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",