ai-retry 0.0.2 → 0.1.0

package/README.md

@@ -24,15 +24,12 @@ npm install ai-retry
 ### Usage
 
 Create a retryable model by providing a base model and a list of retryables or fallback models.
-
-> [!WARNING]  
-> `ai-retry` currently only supports `generateText` and `generateObject` calls.
-> Streaming via `streamText` and `streamObject` is not supported yet.
+When an error occurs, it will evaluate each retryable in order and use the first one that indicates a retry should be attempted with a different model.
 
 ```typescript
 import { azure } from '@ai-sdk/azure';
 import { openai } from '@ai-sdk/openai';
-import { generateText } from 'ai';
+import { generateText, streamText } from 'ai';
 import { createRetryable } from 'ai-retry';
 import { contentFilterTriggered, requestTimeout } from 'ai-retry/retryables';
 
@@ -49,13 +46,25 @@ const result = await generateText({
   model: retryableModel,
   prompt: 'Hello world!',
 });
-```
 
+// Or with streaming
+const result = streamText({
+  model: retryableModel,
+  prompt: 'Write a story about a robot...',
+});
+
+for await (const chunk of result.textStream) {
+  console.log(chunk.text);
+}
+```
 
 #### Content Filter
 
 Automatically switch to a different model when content filtering blocks your request.
 
+> [!WARNING]  
+> This retryable currently does not work with streaming requests, because the content filter is only indicated in the final response.
+
 ```typescript
 import { contentFilterTriggered } from 'ai-retry/retryables';
 
@@ -122,10 +131,10 @@ const result = await generateText({
 
 #### Service Overloaded
 
-Handle service overload errors (HTTP code 529) by switching to a provider.
+Handle service overload errors (status code 529) by switching to a provider.
 
 > [!NOTE] 
-> For Anthropic specifically, use `anthropicServiceOverloaded` instead as Anthropic sometimes returns HTTP 200 OK with an error payload rather than the standard HTTP 529.
+> You can use this retryable to handle Anthropic's overloaded errors.
 
 ```typescript
 import { serviceOverloaded } from 'ai-retry/retryables';
@@ -244,14 +253,25 @@ const retryableModel = createRetryable({
   model: openai('gpt-4-mini'),
   retries: [/* your retryables */],
   onError: (context) => {
-    console.log(`Attempt ${context.totalAttempts} with ${context.current.model.provider}/${context.current.model.modelId} failed:`, context.current.error);
+    console.error(`Attempt ${context.attempts.length} with ${context.current.model.provider}/${context.current.model.modelId} failed:`, 
+      context.current.error
+    );
   },
   onRetry: (context) => {
-    console.log(`Retrying with model ${context.current.model.provider}/${context.current.model.modelId}...`);
+    console.log(`Retrying attempt ${context.attempts.length + 1} with model ${context.current.model.provider}/${context.current.model.modelId}...`);
   },
 });
 ```
 
+### Streaming
+
+Errors during streaming requests can occur in two ways:
+
+1. When the stream is initially created (e.g. network error, API error, etc.) by calling `streamText`.
+2. While the stream is being processed (e.g. timeout, API error, etc.) by reading from the returned `result.textStream` async iterable.
+
+In the second case, errors during stream processing will not always be retried, because the stream might have already emitted some actual content and the consumer might have processed it. Retrying will be stopped as soon as the first content chunk (e.g. types of `text-delta`, `tool-call`, etc.) is emitted. The type of chunks considered as content are the same as the ones that are passed to [onChunk()](https://github.com/vercel/ai/blob/1fe4bd4144bff927f5319d9d206e782a73979ccb/packages/ai/src/generate-text/stream-text.ts#L684-L697).
+
 ### Retryables
 
 A retryable is a function that receives the current attempt and determines whether to retry with a different model based on the error/result and any previous attempts. 
@@ -261,7 +281,7 @@ There are several built-in retryables:
 - [`requestTimeout`](./src/retryables/request-timeout.ts): Request timeout occurred.
 - [`requestNotRetryable`](./src/retryables/request-not-retryable.ts): Request failed with a non-retryable error.
 - [`serviceOverloaded`](./src/retryables/service-overloaded.ts): Response with status code 529 (service overloaded).
-  - [`anthropicServiceOverloaded`](./src/retryables/anthropic-service-overloaded.ts): Anthropic-specific overloaded error handling for both HTTP 529 and 200 OK responses with overloaded error payloads.
+  - Use this retryable to handle Anthropic's overloaded errors.
 
 By default, each retryable will only attempt to retry once per model to avoid infinite loops. You can customize this behavior by returning a `maxAttempts` value from your retryable function.
 
@@ -309,7 +329,6 @@ The `RetryContext` object contains information about the current attempt and all
 interface RetryContext {
   current: RetryAttempt;
   attempts: Array<RetryAttempt>;
-  totalAttempts: number;
 }
 ```
 

package/dist/create-retryable-model-C3mm1hSN.js

@@ -0,0 +1,308 @@
+import { getErrorMessage } from "@ai-sdk/provider-utils";
+import { RetryError } from "ai";
+
+//#region src/get-model-key.ts
+/**
+* Generate a unique key for a LanguageModelV2 instance.
+*/
+const getModelKey = (model) => {
+	return `${model.provider}/${model.modelId}`;
+};
+
+//#endregion
+//#region src/utils.ts
+const isObject = (value) => typeof value === "object" && value !== null;
+const isString = (value) => typeof value === "string";
+const isGenerateResult = (result) => "content" in result;
+/**
+* Check if a stream part is a content part (e.g., text delta, reasoning delta, source, tool call, tool result).
+* 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
+*/
+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";
+};
+
+//#endregion
+//#region src/create-retryable-model.ts
+/**
+* Type guard to check if a retry attempt is an error attempt
+*/
+function isErrorAttempt(attempt) {
+	return attempt.type === "error";
+}
+/**
+* Type guard to check if a retry attempt is a result attempt
+*/
+function isResultAttempt(attempt) {
+	return attempt.type === "result";
+}
+var RetryableModel = class {
+	specificationVersion = "v2";
+	baseModel;
+	currentModel;
+	options;
+	get modelId() {
+		return this.currentModel.modelId;
+	}
+	get provider() {
+		return this.currentModel.provider;
+	}
+	get supportedUrls() {
+		return this.currentModel.supportedUrls;
+	}
+	constructor(options) {
+		this.options = options;
+		this.baseModel = options.model;
+		this.currentModel = options.model;
+	}
+	/**
+	* Find the next model to retry with based on the retry context
+	*/
+	async findNextModel(context) {
+		/**
+		* Filter retryables based on attempt type:
+		* - Result-based attempts: Only consider function retryables (skip plain models)
+		* - Error-based attempts: Consider all retryables (functions + plain models)
+		*/
+		const applicableRetries = isResultAttempt(context.current) ? this.options.retries.filter((retry) => typeof retry === "function") : this.options.retries;
+		/**
+		* Iterate through the applicable retryables to find a model to retry with
+		*/
+		for (const retry of applicableRetries) {
+			const retryModel = typeof retry === "function" ? await retry(context) : {
+				model: retry,
+				maxAttempts: 1
+			};
+			if (retryModel) {
+				/**
+				* The model key uniquely identifies a model instance (provider + modelId)
+				*/
+				const retryModelKey = getModelKey(retryModel.model);
+				/**
+				* Find all attempts with the same model
+				*/
+				const retryAttempts = context.attempts.filter((a) => getModelKey(a.model) === retryModelKey);
+				const maxAttempts = retryModel.maxAttempts ?? 1;
+				/**
+				* Check if the model can still be retried based on maxAttempts
+				*/
+				if (retryAttempts.length < maxAttempts) return retryModel.model;
+			}
+		}
+	}
+	/**
+	* Execute a function with retry logic for handling errors
+	*/
+	async withRetry(input) {
+		/**
+		* Track all attempts.
+		*/
+		const attempts = input.attempts ?? [];
+		while (true) {
+			/**
+			* The previous attempt that triggered a retry, or undefined if this is the first attempt
+			*/
+			const previousAttempt = attempts.at(-1);
+			/**
+			* Call the onRetry handler if provided.
+			* Skip on the first attempt since no previous attempt exists yet.
+			*/
+			if (previousAttempt) {
+				const currentAttempt = {
+					...previousAttempt,
+					model: this.currentModel
+				};
+				/**
+				* Create a shallow copy of the attempts for testing purposes
+				*/
+				const updatedAttempts = [...attempts];
+				const context = {
+					current: currentAttempt,
+					attempts: updatedAttempts,
+					totalAttempts: updatedAttempts.length
+				};
+				this.options.onRetry?.(context);
+			}
+			try {
+				/**
+				* Call the function that may need to be retried
+				*/
+				const result = await input.fn();
+				/**
+				* Check if the result should trigger a retry (only for generate results, not streams)
+				*/
+				if (isGenerateResult(result)) {
+					const { nextModel, attempt } = await this.handleResult(result, attempts);
+					attempts.push(attempt);
+					if (nextModel) {
+						this.currentModel = nextModel;
+						/**
+						* Continue to the next iteration to retry
+						*/
+						continue;
+					}
+				}
+				return {
+					result,
+					attempts
+				};
+			} catch (error) {
+				const { nextModel, attempt } = await this.handleError(error, attempts);
+				attempts.push(attempt);
+				this.currentModel = nextModel;
+			}
+		}
+	}
+	/**
+	* Handle a successful result and determine if a retry is needed
+	*/
+	async handleResult(result, attempts) {
+		const resultAttempt = {
+			type: "result",
+			result,
+			model: this.currentModel
+		};
+		/**
+		* Save the current attempt
+		*/
+		const updatedAttempts = [...attempts, resultAttempt];
+		const resultContext = {
+			current: resultAttempt,
+			attempts: updatedAttempts,
+			totalAttempts: updatedAttempts.length
+		};
+		return {
+			nextModel: await this.findNextModel(resultContext),
+			attempt: resultAttempt
+		};
+	}
+	/**
+	* Handle an error and determine if a retry is needed
+	*/
+	async handleError(error, attempts) {
+		const errorAttempt = {
+			type: "error",
+			error,
+			model: this.currentModel
+		};
+		/**
+		* Save the current attempt
+		*/
+		const updatedAttempts = [...attempts, errorAttempt];
+		const context = {
+			current: errorAttempt,
+			attempts: updatedAttempts,
+			totalAttempts: updatedAttempts.length
+		};
+		this.options.onError?.(context);
+		const nextModel = await this.findNextModel(context);
+		/**
+		* Handler didn't return any models to try next, rethrow the error.
+		* If we retried the request, wrap the error into a `RetryError` for better visibility.
+		*/
+		if (!nextModel) {
+			if (updatedAttempts.length > 1) throw this.prepareRetryError(error, updatedAttempts);
+			throw error;
+		}
+		return {
+			nextModel,
+			attempt: errorAttempt
+		};
+	}
+	async doGenerate(options) {
+		/**
+		* Always start with the original model
+		*/
+		this.currentModel = this.baseModel;
+		const { result } = await this.withRetry({ fn: async () => await this.currentModel.doGenerate(options) });
+		return result;
+	}
+	async doStream(options) {
+		/**
+		* Always start with the original model
+		*/
+		this.currentModel = this.baseModel;
+		/**
+		* 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 () => await this.currentModel.doStream(options) });
+		/**
+		* Wrap the original stream to handle retries if an error occurs during streaming.
+		*/
+		const retryableStream = new ReadableStream({ start: async (controller) => {
+			let reader;
+			let isStreaming = false;
+			while (true) try {
+				reader = result.stream.getReader();
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					/**
+					* If the stream part is an error and no data has been streamed yet, we can retry
+					* Throw the error to trigger the retry logic in withRetry
+					*/
+					if (value.type === "error") {
+						if (!isStreaming) throw value.error;
+					}
+					/**
+					* Mark that streaming has started once we receive actual content
+					*/
+					if (isStreamContentPart(value)) isStreaming = true;
+					/**
+					* Enqueue the chunk to the consumer of the stream
+					*/
+					controller.enqueue(value);
+				}
+				controller.close();
+				break;
+			} catch (error) {
+				/**
+				* Check if the error from the stream can be retried.
+				* Otherwise it will rethrow the error.
+				*/
+				const { nextModel, attempt } = await this.handleError(error, attempts);
+				this.currentModel = nextModel;
+				/**
+				* Save the attempt
+				*/
+				attempts.push(attempt);
+				/**
+				* Retry the request by calling doStream again.
+				* This will create a new stream.
+				*/
+				const retriedResult = await this.withRetry({
+					fn: async () => await this.currentModel.doStream(options),
+					attempts
+				});
+				/**
+				* Cancel the previous reader and stream if we are retrying
+				*/
+				await reader?.cancel();
+				result = retriedResult.result;
+				attempts = retriedResult.attempts;
+			} finally {
+				reader?.releaseLock();
+			}
+		} });
+		return {
+			...result,
+			stream: retryableStream
+		};
+	}
+	prepareRetryError(error, attempts) {
+		const errorMessage = getErrorMessage(error);
+		const errors = attempts.flatMap((a) => isErrorAttempt(a) ? a.error : `Result with finishReason: ${a.result.finishReason}`);
+		return new RetryError(new RetryError({
+			message: `Failed after ${attempts.length} attempts. Last error: ${errorMessage}`,
+			reason: "maxRetriesExceeded",
+			errors
+		}));
+	}
+};
+function createRetryable(config) {
+	return new RetryableModel(config);
+}
+
+//#endregion
+export { createRetryable, getModelKey, isErrorAttempt, isObject, isResultAttempt, isString };

package/dist/{create-retryable-model-DzDFqgQO.d.ts → create-retryable-model-DtspEawi.d.ts}

@@ -8,15 +8,30 @@ type LanguageModelV2Generate = Awaited<ReturnType<LanguageModelV2['doGenerate']>
  * The context provided to Retryables with the current attempt and all previous attempts.
  */
 interface RetryContext<CURRENT extends RetryAttempt = RetryAttempt> {
+  /**
+   * Current attempt that caused the retry
+   */
   current: CURRENT;
+  /**
+   * All attempts made so far, including the current one
+   */
   attempts: Array<RetryAttempt>;
+  /**
+   * @deprecated Use `attempts.length` instead
+   */
   totalAttempts: number;
 }
+/**
+ * A retry attempt with an error
+ */
 type RetryErrorAttempt = {
   type: 'error';
   error: unknown;
   model: LanguageModelV2;
 };
+/**
+ * A retry attempt with a successful result
+ */
 type RetryResultAttempt = {
   type: 'result';
   result: LanguageModelV2Generate;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { CreateRetryableOptions, RetryAttempt, RetryContext, RetryModel, Retryable, createRetryable, isErrorAttempt, isResultAttempt } from "./create-retryable-model-DzDFqgQO.js";
+import { CreateRetryableOptions, RetryAttempt, RetryContext, RetryModel, Retryable, createRetryable, isErrorAttempt, isResultAttempt } from "./create-retryable-model-DtspEawi.js";
 import { LanguageModelV2 } from "@ai-sdk/provider";
 
 //#region src/get-model-key.d.ts

package/dist/index.js

@@ -1,3 +1,3 @@
-import { createRetryable, getModelKey, isErrorAttempt, isResultAttempt } from "./create-retryable-model-CnrFowSg.js";
+import { createRetryable, getModelKey, isErrorAttempt, isResultAttempt } from "./create-retryable-model-C3mm1hSN.js";
 
 export { createRetryable, getModelKey, isErrorAttempt, isResultAttempt };

package/dist/retryables/index.d.ts

@@ -1,4 +1,4 @@
-import { RetryModel, Retryable } from "../create-retryable-model-DzDFqgQO.js";
+import { RetryModel, Retryable } from "../create-retryable-model-DtspEawi.js";
 import { LanguageModelV2 } from "@ai-sdk/provider";
 
 //#region src/retryables/anthropic-service-overloaded.d.ts
@@ -22,6 +22,8 @@ type AnthropicErrorResponse = {
  * HTTP 200 OK
  * {"type":"error","error":{"type":"overloaded_error","message":"Overloaded"}}
  * ```
+ *
+ * @deprecated Use `serviceOverloaded` instead
  */
 declare function anthropicServiceOverloaded(model: LanguageModelV2, options?: Omit<RetryModel, 'model'>): Retryable;
 //#endregion
@@ -44,13 +46,14 @@ declare function requestNotRetryable(model: LanguageModelV2, options?: Omit<Retr
  */
 declare function requestTimeout(model: LanguageModelV2, options?: Omit<RetryModel, 'model'>): Retryable;
 //#endregion
-//#region src/retryables/response-schema-mismatch.d.ts
-declare function responseSchemaMismatch(model: LanguageModelV2, options?: Omit<RetryModel, 'model'>): Retryable;
-//#endregion
 //#region src/retryables/service-overloaded.d.ts
 /**
- * Fallback to a different model if the provider returns a HTTP 529 error.
+ * Fallback to a different model if the provider returns an overloaded error.
+ * This retryable handles the following cases:
+ * - Response with status code 529
+ * - Response with `type: "overloaded_error"`
+ * - Response with a `message` containing "overloaded"
  */
 declare function serviceOverloaded(model: LanguageModelV2, options?: Omit<RetryModel, 'model'>): Retryable;
 //#endregion
-export { AnthropicErrorResponse, anthropicServiceOverloaded, contentFilterTriggered, requestNotRetryable, requestTimeout, responseSchemaMismatch, serviceOverloaded };
+export { AnthropicErrorResponse, anthropicServiceOverloaded, contentFilterTriggered, requestNotRetryable, requestTimeout, serviceOverloaded };

package/dist/retryables/index.js

@@ -1,12 +1,7 @@
-import { isErrorAttempt, isResultAttempt } from "../create-retryable-model-CnrFowSg.js";
+import { isErrorAttempt, isObject, isResultAttempt, isString } from "../create-retryable-model-C3mm1hSN.js";
 import { isAbortError } from "@ai-sdk/provider-utils";
-import { APICallError, NoObjectGeneratedError, TypeValidationError } from "ai";
+import { APICallError } from "ai";
 
-//#region src/utils.ts
-const isObject = (value) => typeof value === "object" && value !== null;
-const isString = (value) => typeof value === "string";
-
-//#endregion
 //#region src/retryables/anthropic-service-overloaded.ts
 /**
 * Fallback if Anthropic returns an "overloaded" error with HTTP 200.
@@ -15,6 +10,8 @@ const isString = (value) => typeof value === "string";
 * HTTP 200 OK
 * {"type":"error","error":{"type":"overloaded_error","message":"Overloaded"}}
 * ```
+*
+* @deprecated Use `serviceOverloaded` instead
 */
 function anthropicServiceOverloaded(model, options) {
 	return (context) => {
@@ -26,14 +23,11 @@ function anthropicServiceOverloaded(model, options) {
 				maxAttempts: 1,
 				...options
 			};
-			if (APICallError.isInstance(error) && error.statusCode === 200) try {
-				const responseBody = JSON.parse(error.responseBody ?? "");
-				if (responseBody.error && isObject(responseBody.error) && isString(responseBody.error.type) && responseBody.error.type === "overloaded_error") return {
-					model,
-					maxAttempts: 1,
-					...options
-				};
-			} catch {}
+			if (isObject(error) && isString(error.type) && error.type === "overloaded_error") return {
+				model,
+				maxAttempts: 1,
+				...options
+			};
 		}
 	};
 }
@@ -105,25 +99,14 @@ function requestTimeout(model, options) {
 	};
 }
 
-//#endregion
-//#region src/retryables/response-schema-mismatch.ts
-function responseSchemaMismatch(model, options) {
-	return (context) => {
-		const { current } = context;
-		if (isErrorAttempt(current)) {
-			if (NoObjectGeneratedError.isInstance(current.error) && current.error.finishReason === "stop" && TypeValidationError.isInstance(current.error.cause)) return {
-				model,
-				maxAttempts: 1,
-				...options
-			};
-		}
-	};
-}
-
 //#endregion
 //#region src/retryables/service-overloaded.ts
 /**
-* Fallback to a different model if the provider returns a HTTP 529 error.
+* Fallback to a different model if the provider returns an overloaded error.
+* This retryable handles the following cases:
+* - Response with status code 529
+* - Response with `type: "overloaded_error"`
+* - Response with a `message` containing "overloaded"
 */
 function serviceOverloaded(model, options) {
 	return (context) => {
@@ -135,9 +118,16 @@ function serviceOverloaded(model, options) {
 				maxAttempts: 1,
 				...options
 			};
+			if (isObject(error)) {
+				if (isString(error.type) && error.type === "overloaded_error" || isString(error.message) && error.message.toLowerCase().includes("overloaded")) return {
+					model,
+					maxAttempts: 1,
+					...options
+				};
+			}
 		}
 	};
 }
 
 //#endregion
-export { anthropicServiceOverloaded, contentFilterTriggered, requestNotRetryable, requestTimeout, responseSchemaMismatch, serviceOverloaded };
+export { anthropicServiceOverloaded, contentFilterTriggered, requestNotRetryable, requestTimeout, serviceOverloaded };

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "ai-retry",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "description": "AI SDK Retry",
+  "packageManager": "pnpm@9.0.0",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -17,6 +18,14 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "prepublishOnly": "pnpm build",
+    "publish:alpha": "pnpm version prerelease --preid alpha && pnpm publish --tag alpha",
+    "build": "tsdown",
+    "test": "vitest",
+    "lint": "biome check . --write",
+    "prepare": "husky"
+  },
   "keywords": [
     "ai",
     "ai-sdk",
@@ -55,11 +64,5 @@
   "dependencies": {
     "@ai-sdk/provider": "^2.0.0",
     "@ai-sdk/provider-utils": "^3.0.9"
-  },
-  "scripts": {
-    "publish:alpha": "pnpm version prerelease --preid alpha && pnpm publish --tag alpha",
-    "build": "tsdown",
-    "test": "vitest",
-    "lint": "biome check . --write"
   }
-}
+}

package/dist/create-retryable-model-CnrFowSg.js

@@ -1,221 +0,0 @@
-import { getErrorMessage } from "@ai-sdk/provider-utils";
-import { RetryError } from "ai";
-
-//#region src/get-model-key.ts
-/**
-* Generate a unique key for a LanguageModelV2 instance.
-*/
-const getModelKey = (model) => {
-	return `${model.provider}/${model.modelId}`;
-};
-
-//#endregion
-//#region src/create-retryable-model.ts
-/**
-* Type guard to check if a retry attempt is an error attempt
-*/
-function isErrorAttempt(attempt) {
-	return attempt.type === "error";
-}
-/**
-* Type guard to check if a retry attempt is a result attempt
-*/
-function isResultAttempt(attempt) {
-	return attempt.type === "result";
-}
-var RetryableModel = class {
-	specificationVersion = "v2";
-	baseModel;
-	currentModel;
-	options;
-	get modelId() {
-		return this.currentModel.modelId;
-	}
-	get provider() {
-		return this.currentModel.provider;
-	}
-	get supportedUrls() {
-		return this.currentModel.supportedUrls;
-	}
-	constructor(options) {
-		this.options = options;
-		this.baseModel = options.model;
-		this.currentModel = options.model;
-	}
-	/**
-	* Find the next model to retry with based on the retry context
-	*/
-	async findNextModel(context) {
-		/**
-		* Filter retryables based on attempt type:
-		* - Result-based attempts: Only consider function retryables (skip plain models)
-		* - Error-based attempts: Consider all retryables (functions + plain models)
-		*/
-		const applicableRetries = isResultAttempt(context.current) ? this.options.retries.filter((retry) => typeof retry === "function") : this.options.retries;
-		/**
-		* Iterate through the applicable retryables to find a model to retry with
-		*/
-		for (const retry of applicableRetries) {
-			const retryModel = typeof retry === "function" ? await retry(context) : {
-				model: retry,
-				maxAttempts: 1
-			};
-			if (retryModel) {
-				/**
-				* The model key uniquely identifies a model instance (provider + modelId)
-				*/
-				const retryModelKey = getModelKey(retryModel.model);
-				/**
-				* Find all attempts with the same model
-				*/
-				const retryAttempts = context.attempts.filter((a) => getModelKey(a.model) === retryModelKey);
-				const maxAttempts = retryModel.maxAttempts ?? 1;
-				/**
-				* Check if the model can still be retried based on maxAttempts
-				*/
-				if (retryAttempts.length < maxAttempts) return retryModel.model;
-			}
-		}
-	}
-	async doGenerate(options) {
-		/**
-		* Always start with the original model
-		*/
-		this.currentModel = this.baseModel;
-		/**
-		* Track number of attempts
-		*/
-		let totalAttempts = 0;
-		/**
-		* Track all attempts.
-		*/
-		const attempts = [];
-		/**
-		* The previous attempt that triggered a retry, or undefined if this is the first attempt
-		*/
-		let previousAttempt;
-		while (true) {
-			/**
-			* Call the onRetry handler if provided.
-			* Skip on the first attempt since no previous attempt exists yet.
-			*/
-			if (previousAttempt) {
-				/**
-				* Context for the onRetry handler
-				*/
-				const context = {
-					current: {
-						...previousAttempt,
-						model: this.currentModel
-					},
-					attempts,
-					totalAttempts
-				};
-				/**
-				* Call the onRetry handler if provided
-				*/
-				this.options.onRetry?.(context);
-			}
-			totalAttempts++;
-			try {
-				const result = await this.currentModel.doGenerate(options);
-				/**
-				* Check if the result should trigger a retry
-				*/
-				const resultAttempt = {
-					type: "result",
-					result,
-					model: this.currentModel
-				};
-				/**
-				* Add the current attempt to the list before checking for retries
-				*/
-				attempts.push(resultAttempt);
-				const resultContext = {
-					current: resultAttempt,
-					attempts,
-					totalAttempts
-				};
-				const nextModel = await this.findNextModel(resultContext);
-				if (nextModel) {
-					/**
-					* Set the model for the next attempt
-					*/
-					this.currentModel = nextModel;
-					/**
-					* Set the previous attempt that triggered this retry
-					*/
-					previousAttempt = resultAttempt;
-					/**
-					* Continue to the next iteration to retry
-					*/
-					continue;
-				}
-				/**
-				* No retry needed, remove the attempt since it was successful and return the result
-				*/
-				attempts.pop();
-				return result;
-			} catch (error) {
-				/**
-				* Current attempt with current error
-				*/
-				const errorAttempt = {
-					type: "error",
-					error,
-					model: this.currentModel
-				};
-				/**
-				* Save the current attempt
-				*/
-				attempts.push(errorAttempt);
-				/**
-				* Context for the retryables and onError handler
-				*/
-				const context = {
-					current: errorAttempt,
-					attempts,
-					totalAttempts
-				};
-				/**
-				* Call the onError handler if provided
-				*/
-				this.options.onError?.(context);
-				const nextModel = await this.findNextModel(context);
-				/**
-				* Handler didn't return any models to try next, rethrow the error.
-				* If we retried the request, wrap the error into a `RetryError` for better visibility.
-				*/
-				if (!nextModel) {
-					if (totalAttempts > 1) {
-						const errorMessage = getErrorMessage(error);
-						const errors = attempts.flatMap((a) => isErrorAttempt(a) ? a.error : `Result with finishReason: ${a.result.finishReason}`);
-						throw new RetryError({
-							message: `Failed after ${totalAttempts} attempts. Last error: ${errorMessage}`,
-							reason: "maxRetriesExceeded",
-							errors
-						});
-					}
-					throw error;
-				}
-				/**
-				* Set the model for the next attempt
-				*/
-				this.currentModel = nextModel;
-				/**
-				* Set the previous attempt that triggered this retry
-				*/
-				previousAttempt = errorAttempt;
-			}
-		}
-	}
-	async doStream(options) {
-		throw new Error("Streaming not implemented");
-	}
-};
-function createRetryable(config) {
-	return new RetryableModel(config);
-}
-
-//#endregion
-export { createRetryable, getModelKey, isErrorAttempt, isResultAttempt };