ai-retry 1.0.0-beta.0 → 1.0.0-beta.1

package/README.md

@@ -24,6 +24,9 @@ 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@beta
 ```
@@ -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 Retryable, a as LanguageModel, c as LanguageModelStream, d as Retries, f as Retry, g as RetryResultAttempt, h as RetryErrorAttempt, i as EmbeddingModelV3, l as LanguageModelStreamPart, m as RetryContext, n as EmbeddingModelCallOptions, o as LanguageModelCallOptions, p as RetryAttempt, r as EmbeddingModelEmbed, s as LanguageModelGenerate, t as EmbeddingModel, u as LanguageModelV3, v as RetryableModelOptions, y as RetryableOptions } from "./types-D7Pm83wM.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
@@ -59,9 +62,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, EmbeddingModelV3, LanguageModel, LanguageModelCallOptions, LanguageModelGenerate, LanguageModelStream, LanguageModelStreamPart, LanguageModelV3, Retries, Retry, RetryAttempt, RetryContext, RetryErrorAttempt, RetryResultAttempt, Retryable, RetryableModelOptions, RetryableOptions, createRetryable, getModelKey, isEmbeddingModel, isErrorAttempt, isGenerateResult, isLanguageModel, isModel, 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 isModel, c as isRetry, d as isString, i as isLanguageModel, l as isStreamContentPart, n as isErrorAttempt, o as isObject, r as isGenerateResult, s as isResultAttempt, t as isEmbeddingModel, u as isStreamResult } from "./utils-BnNgdhF6.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
+			};
 		}
 	}
 }
@@ -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, isEmbeddingModel, isErrorAttempt, isGenerateResult, isLanguageModel, isModel, 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 Retryable, a as LanguageModel, t as EmbeddingModel, y as RetryableOptions } from "../types-D7Pm83wM.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-BnNgdhF6.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-BnNgdhF6.mjs → utils-BXFlA2mh.mjs}

@@ -2,8 +2,8 @@
 const isObject = (value) => typeof value === "object" && value !== null;
 const isString = (value) => typeof value === "string";
 const isModel = (model) => isLanguageModel(model) || isEmbeddingModel(model);
-const isLanguageModel = (model) => isObject(model) && "provider" in model && "modelId" in model && "specificationVersion" in model && model.specificationVersion === "v3";
-const isEmbeddingModel = (model) => isObject(model) && "provider" in model && "modelId" in model && "specificationVersion" in model && model.specificationVersion === "v3";
+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 && isModel(value.model);
 
 //#endregion
-export { isModel as a, isRetry as c, isString as d, isLanguageModel as i, isStreamContentPart as l, isErrorAttempt as n, isObject as o, isGenerateResult as r, isResultAttempt as s, isEmbeddingModel 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": "1.0.0-beta.0",
+  "version": "1.0.0-beta.1",
   "description": "AI SDK Retry",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
@@ -35,6 +35,7 @@
   "devDependencies": {
     "@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",
@@ -49,8 +50,7 @@
     "publint": "^0.3.15",
     "tsdown": "^0.16.7",
     "tsx": "^4.20.6",
-    "typescript": "^5.9.3",
-    "unbuild": "^3.6.1",
+    "typescript": "^5.9.2",
     "vitest": "^4.0.14",
     "zod": "^4.1.13"
   },
@@ -59,9 +59,9 @@
     "@ai-sdk/provider-utils": "4.0.0-beta.34"
   },
   "scripts": {
-    "publish:alpha": "pnpm version prerelease --preid alpha && pnpm publish --tag alpha",
     "build": "tsdown",
     "test": "vitest",
+    "typecheck": "tsc --noEmit",
     "lint": "biome check . --write"
   }
 }

package/dist/types-D7Pm83wM.d.mts

@@ -1,77 +0,0 @@
-import { ProviderOptions } from "@ai-sdk/provider-utils";
-import { EmbeddingModelV3, LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3StreamPart } from "@ai-sdk/provider";
-
-//#region src/types.d.ts
-type EmbeddingModelV3$1<VALUE = any> = EmbeddingModelV3<VALUE>;
-type EmbeddingModel<VALUE = any> = EmbeddingModelV3<VALUE>;
-type LanguageModel = LanguageModelV3;
-type LanguageModelCallOptions = LanguageModelV3CallOptions;
-type LanguageModelStreamPart = LanguageModelV3StreamPart;
-/**
- * Options for creating a retryable model.
- */
-interface RetryableModelOptions<MODEL extends LanguageModel | EmbeddingModel<any>> {
-  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<any>> = {
-  /**
-   * 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<any>> = {
-  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<any>> = RetryErrorAttempt<MODEL> | RetryResultAttempt;
-/**
- * A model to retry with and the maximum number of attempts for that model.
- */
-type Retry<MODEL extends LanguageModel | EmbeddingModel<any>> = {
-  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<any>> = (context: RetryContext<MODEL>) => Retry<MODEL> | Promise<Retry<MODEL>> | undefined;
-type Retries<MODEL extends LanguageModel | EmbeddingModel<any>> = Array<Retryable<MODEL> | Retry<MODEL> | MODEL>;
-type RetryableOptions<MODEL extends LanguageModel | EmbeddingModel<any>> = 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> = Awaited<ReturnType<EmbeddingModel<VALUE>['doEmbed']>>;
-//#endregion
-export { Retryable as _, LanguageModel as a, LanguageModelStream as c, Retries as d, Retry as f, RetryResultAttempt as g, RetryErrorAttempt as h, EmbeddingModelV3$1 as i, LanguageModelStreamPart as l, RetryContext as m, EmbeddingModelCallOptions as n, LanguageModelCallOptions as o, RetryAttempt as p, EmbeddingModelEmbed as r, LanguageModelGenerate as s, EmbeddingModel as t, LanguageModelV3 as u, RetryableModelOptions as v, RetryableOptions as y };