ai-retry 0.10.3 → 1.0.0-beta.1

package/README.md

@@ -19,13 +19,16 @@ It supports two types of retries:
 
 ### Installation
 
-This library only supports AI SDK v5.
+Install the beta version of `ai-retry` to support AI SDK v6.
+
+> [!NOTE]
+> AI SDK v6 is still in beta, so break changes are expected.
 
 > [!NOTE]
 > AI SDK v6 support is available in the [v6 branch](https://github.com/zirkelc/ai-retry/tree/v6).
 
 ```bash
-npm install ai-retry
+npm install ai-retry@beta
 ```
 
 ### Usage
@@ -94,6 +97,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 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 { S as RetryableOptions, _ as RetryContext, a as LanguageModel, b as Retryable, c as LanguageModelStream, d as ResolvableLanguageModel, f as ResolvableModel, g as RetryAttempt, h as Retry, i as GatewayLanguageModelId, l as LanguageModelStreamPart, m as Retries, n as EmbeddingModelCallOptions, o as LanguageModelCallOptions, p as ResolvedModel, r as EmbeddingModelEmbed, s as LanguageModelGenerate, t as EmbeddingModel, u as ProviderOptions, v as RetryErrorAttempt, x as RetryableModelOptions, y as RetryResultAttempt } from "./types-D7G-2JLh.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;
 /**
@@ -32,42 +35,32 @@ declare function isResultAttempt(attempt: RetryAttempt<any>): attempt is RetryRe
  * These types are also emitted by `onChunk` callbacks.
  * @see https://github.com/vercel/ai/blob/1fe4bd4144bff927f5319d9d206e782a73979ccb/packages/ai/src/generate-text/stream-text.ts#L686-L697
  */
-declare const isStreamContentPart: (part: LanguageModelStreamPart) => part is _ai_sdk_provider0.LanguageModelV2Source | _ai_sdk_provider0.LanguageModelV2ToolCall | {
-  type: "tool-result";
-  toolCallId: string;
-  toolName: string;
-  result: unknown;
-  isError?: boolean;
-  providerExecuted?: boolean;
-  providerMetadata?: _ai_sdk_provider0.SharedV2ProviderMetadata;
-} | {
+declare const isStreamContentPart: (part: LanguageModelStreamPart) => part is _ai_sdk_provider0.LanguageModelV3Source | _ai_sdk_provider0.LanguageModelV3ToolCall | _ai_sdk_provider0.LanguageModelV3ToolResult | {
   type: "text-delta";
   id: string;
-  providerMetadata?: _ai_sdk_provider0.SharedV2ProviderMetadata;
+  providerMetadata?: _ai_sdk_provider0.SharedV3ProviderMetadata;
   delta: string;
 } | {
   type: "reasoning-delta";
   id: string;
-  providerMetadata?: _ai_sdk_provider0.SharedV2ProviderMetadata;
+  providerMetadata?: _ai_sdk_provider0.SharedV3ProviderMetadata;
   delta: string;
 } | {
   type: "tool-input-start";
   id: string;
   toolName: string;
-  providerMetadata?: _ai_sdk_provider0.SharedV2ProviderMetadata;
+  providerMetadata?: _ai_sdk_provider0.SharedV3ProviderMetadata;
   providerExecuted?: boolean;
+  dynamic?: boolean;
+  title?: string;
 } | {
   type: "tool-input-delta";
   id: string;
   delta: string;
-  providerMetadata?: _ai_sdk_provider0.SharedV2ProviderMetadata;
+  providerMetadata?: _ai_sdk_provider0.SharedV3ProviderMetadata;
 } | {
   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, GatewayLanguageModelId, LanguageModel, LanguageModelCallOptions, LanguageModelGenerate, 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-BXFlA2mh.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
+			};
 		}
 	}
 }
@@ -83,7 +101,7 @@ function prepareRetryError(error, attempts) {
 //#endregion
 //#region src/retryable-embedding-model.ts
 var RetryableEmbeddingModel = class {
-	specificationVersion = "v2";
+	specificationVersion = "v3";
 	baseModel;
 	currentModel;
 	options;
@@ -226,7 +244,7 @@ var RetryableEmbeddingModel = class {
 //#endregion
 //#region src/retryable-language-model.ts
 var RetryableLanguageModel = class {
-	specificationVersion = "v2";
+	specificationVersion = "v3";
 	baseModel;
 	currentModel;
 	options;
@@ -513,9 +531,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 RetryableOptions, b as Retryable, d as ResolvableLanguageModel, t as EmbeddingModel } from "../types-D7G-2JLh.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-BXFlA2mh.mjs";
 import { APICallError } from "ai";
+import { isAbortError } from "@ai-sdk/provider-utils";
 
 //#region src/retryables/content-filter-triggered.ts
 /**

package/dist/types-D7G-2JLh.d.mts

@@ -0,0 +1,90 @@
+import { gateway } from "ai";
+import { EmbeddingModelV3, LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3StreamPart, SharedV3ProviderOptions } from "@ai-sdk/provider";
+
+//#region src/types.d.ts
+type Literals<T> = T extends string ? string extends T ? never : T : never;
+type LanguageModel = LanguageModelV3;
+type EmbeddingModel<VALUE = any> = EmbeddingModelV3<VALUE>;
+type LanguageModelCallOptions = LanguageModelV3CallOptions;
+type LanguageModelStreamPart = LanguageModelV3StreamPart;
+type ProviderOptions = SharedV3ProviderOptions;
+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;
+/**
+ * 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 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>>>;
+};
+/**
+ * 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.
+ *
+ * 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;
+  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 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 { RetryableOptions as S, RetryContext as _, LanguageModel as a, Retryable as b, LanguageModelStream as c, ResolvableLanguageModel as d, ResolvableModel as f, RetryAttempt as g, Retry as h, GatewayLanguageModelId as i, LanguageModelStreamPart as l, Retries as m, EmbeddingModelCallOptions as n, LanguageModelCallOptions as o, ResolvedModel as p, EmbeddingModelEmbed as r, LanguageModelGenerate as s, EmbeddingModel as t, ProviderOptions as u, RetryErrorAttempt as v, RetryableModelOptions as x, RetryResultAttempt as y };

package/dist/{utils-C26pNHta.mjs → utils-BXFlA2mh.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 === "v3";
+const isEmbeddingModel = (model) => isObject(model) && "provider" in model && "modelId" in model && "specificationVersion" in model && "doEmbed" in model && model.specificationVersion === "v3";
 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": "1.0.0-beta.1",
   "description": "AI SDK Retry",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
@@ -30,20 +30,22 @@
     "url": "git+https://github.com/zirkelc/ai-retry.git"
   },
   "peerDependencies": {
-    "ai": "5.x"
+    "ai": "6.x"
   },
   "devDependencies": {
-    "@ai-sdk/anthropic": "^2.0.18",
-    "@ai-sdk/azure": "^2.0.30",
-    "@ai-sdk/groq": "^2.0.24",
-    "@ai-sdk/openai": "^2.0.53",
+    "@ai-sdk/anthropic": "3.0.0-beta.59",
+    "@ai-sdk/azure": "3.0.0-beta.68",
+    "@ai-sdk/gateway": "2.0.0-beta.66",
+    "@ai-sdk/groq": "3.0.0-beta.36",
+    "@ai-sdk/openai": "3.0.0-beta.66",
+    "@ai-sdk/test-server": "1.0.0-beta.1",
     "@arethetypeswrong/cli": "^0.18.2",
-    "@biomejs/biome": "^2.2.4",
+    "@biomejs/biome": "^2.3.7",
     "@total-typescript/tsconfig": "^1.0.4",
-    "@types/node": "^24.3.3",
-    "ai": "^5.0.44",
+    "@types/node": "^24.10.1",
+    "ai": "6.0.0-beta.116",
     "husky": "^9.1.7",
-    "msw": "^2.11.2",
+    "msw": "^2.12.3",
     "pkg-pr-new": "^0.0.60",
     "publint": "^0.3.15",
     "tsdown": "^0.16.7",
@@ -53,8 +55,8 @@
     "zod": "^4.1.13"
   },
   "dependencies": {
-    "@ai-sdk/provider": "^2.0.0",
-    "@ai-sdk/provider-utils": "^3.0.9"
+    "@ai-sdk/provider": "3.0.0-beta.17",
+    "@ai-sdk/provider-utils": "4.0.0-beta.34"
   },
   "scripts": {
     "build": "tsdown",

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 };