ai-retry 0.0.1-alpha.3 → 0.0.1

package/README.md

@@ -1,20 +1,22 @@
-### ai-retry
+# ai-retry: Retry and fallback mechanisms for AI SDK
 
-Intelligent retry and fallback mechanisms for AI SDK models. Automatically handle API failures, content filtering, timeouts, and schema mismatches by switching between different AI models.
+Automatically handle API failures, content filtering and timeouts by switching between different AI models.
 
-#### How?
+`ai-retry` wraps the provided base model with a set of retry conditions (retryables). When a request fails with an error or the response is not satisfying, it iterates through the given retryables to find a suitable fallback model. It automatically tracks which models have been tried and how many attempts have been made to prevent infinite loops.
 
-`ai-retry` wraps the provided base model with a set of retry conditions (retryables). When a request fails due to specific errors (like content filtering or timeouts), it iterates through the given retryables to find a suitable fallback model. It automatically tracks which models have been tried and how many attempts have been made to prevent infinite loops.
+It supports two types of retries:
+- Error-based retries: when the model throws an error (e.g. timeouts, API errors, etc.)
+- Result-based retries: when the model returns a successful response that needs retrying (e.g. content filtering, etc.)
 
 ### Installation
 
 This library only supports AI SDK v5.
 
 > [!WARNING]  
-> `ai-retry` is in alpha stage and the API may change in future releases.
+> `ai-retry` is in an early stage and the API may change in future releases.
 
 ```bash
-npm install ai-retry@alpha
+npm install ai-retry
 ```
 
 ### Usage
@@ -34,13 +36,9 @@ import { contentFilterTriggered, requestTimeout } from 'ai-retry/retryables';
 
 // Create a retryable model
 const retryableModel = createRetryable({
-  // Base model
-  model: azure('gpt-4-mini'), 
-  // Retry strategies
+  model: azure('gpt-4-mini'), // Base model
   retries: [
-    contentFilterTriggered(openai('gpt-4-mini')), 
-    requestTimeout(azure('gpt-4')), 
-    openai('gpt-4-mini'),
+    // Retry strategies and fallbacks...
   ],
 });
 
@@ -48,23 +46,11 @@ const retryableModel = createRetryable({
 const result = await generateText({
   model: retryableModel,
   prompt: 'Hello world!',
-  abortSignal: AbortSignal.timeout(10_000), 
 });
 ```
 
-#### Retryables
 
-A retryable is a function that receives the current failed attempt and determines whether to retry with a different model based on the error and any previous attempts. 
-There are several built-in retryables:
-
-- `contentFilterTriggered`: Content filter was triggered based on the prompt or completion.
-- `responseSchemaMismatch`: Structured output validation failed.
-- `requestTimeout`: Request timeout occurred.
-- `requestNotRetryable`: Request failed with a non-retryable error.
-
-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.
-
-##### Content Filter Triggered
+#### Content Filter
 
 Automatically switch to a different model when content filtering blocks your request.
 
@@ -79,6 +65,7 @@ const retryableModel = createRetryable({
 });
 ```
 
+<!--
 ##### Response Schema Mismatch
 
 Retry with different models when structured output validation fails:
@@ -105,13 +92,14 @@ const result = await generateObject({
   prompt: 'Generate a lasagna recipe.',
 });
 ```
+-->
 
-##### Request Timeout
+#### Request Timeout
 
 Handle timeouts by switching to potentially faster models.
 
 > [!NOTE] 
-> You need to set an `abortSignal` with a timeout on your request for this to work. 
+> You need to use an `abortSignal` with a timeout on your request. 
 
 ```typescript
 import { requestTimeout } from 'ai-retry/retryables';
@@ -126,62 +114,70 @@ const retryableModel = createRetryable({
 const result = await generateText({
   model: retryableModel,
   prompt: 'Write a vegetarian lasagna recipe for 4 people.',
-  abortSignal: AbortSignal.timeout(10_000), 
+  abortSignal: AbortSignal.timeout(60_000), 
 });
 ```
 
-##### Request Not Retryable
+#### Request Not Retryable
 
 Handle cases where the base model fails with a non-retryable error.
 
+> [!NOTE] 
+> You can check if an error is retryable with the `isRetryable` property on an [`APICallError`](https://ai-sdk.dev/docs/reference/ai-sdk-errors/ai-api-call-error#ai_apicallerror).
+
+
 ```typescript
 import { requestNotRetryable } from 'ai-retry/retryables';
 
 const retryable = createRetryable({
   model: azure('gpt-4-mini'),
   retries: [
-    requestNotRetryable(openai('gpt-4')), // Switch providers entirely
+    requestNotRetryable(openai('gpt-4')), // Switch provider if error is not retryable
   ],
 });
 ```
 
-##### Custom Retryables
+#### Fallbacks
 
-Create your own retryables for specific use cases:
+If you always want to fallback to a different model on any error, you can simply provide a list of models.
 
 ```typescript
-import type { Retryable } from 'ai-retry';
-
-const customRetry: Retryable = (context) => {
-  const { current, attempts, totalAttempts } = context;
-  
-  // Your custom logic here
-  if (shouldRetryWithDifferentModel(current.error)) {
-    return {
-      model: myFallbackModel,
-      maxAttempts: 3,
-    };
-  }
-  
-  return undefined; // Don't retry
-};
-
-const retryable = createRetryable({
-  model: azure('gpt-4-mini'),
-  retries: [customRetry],
+const retryableModel = createRetryable({
+  model: azure('gpt-4'),
+  retries: [
+    openai('gpt-4'), 
+    anthropic('claude-3-haiku-20240307')
+  ],
 });
 ```
 
-#### Default Fallback
+#### Custom
 
-If you always want to fallback to a different model on any error, you can simply provide a list of models.
+Create your own retryables for specific use cases:
 
 ```typescript
+import { anthropic } from '@ai-sdk/anthropic';
+import { openai } from '@ai-sdk/openai';
+import { APICallError } from 'ai';
+import { createRetryable, isErrorAttempt } from 'ai-retry';
+import type { Retryable } from 'ai-retry';
+
+const rateLimitRetry: Retryable = (context) => {
+  if (isErrorAttempt(context.current)) {
+    const { error } = context.current;
+
+    if (APICallError.isInstance(error) && error.statusCode === 429) {
+      return { model: anthropic('claude-3-haiku-20240307') };
+    }
+  }
+
+  return undefined;
+};
+
 const retryableModel = createRetryable({
-  model: azure('gpt-4'),
+  model: openai('gpt-4'),
   retries: [
-    openai('gpt-4'), 
-    anthropic('claude-3-haiku-20240307')
+    rateLimitRetry
   ],
 });
 ```
@@ -236,6 +232,17 @@ const retryableModel = createRetryable({
 });
 ```
 
+### 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. 
+There are several built-in retryables:
+
+- [`contentFilterTriggered`](./src/retryables/content-filter-triggered.ts): Content filter was triggered based on the prompt or completion.
+- [`requestTimeout`](./src/retryables/request-timeout.ts): Request timeout occurred.
+- [`requestNotRetryable`](./src/retryables/request-not-retryable.ts): Request failed with a non-retryable error.
+
+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.
+
 ### API Reference
 
 #### `createRetryable(options: CreateRetryableOptions): LanguageModelV2`
@@ -247,14 +254,14 @@ interface CreateRetryableOptions {
   model: LanguageModelV2;
   retries: Array<Retryable | LanguageModelV2>;
   onError?: (context: RetryContext) => void;
-  onRetry?: (context: RetryContext) => void;
+  onRetry?: (context: RetryContext) => void; 
 }
 ```
 
 #### `Retryable`
 
-A `Retryable` is a function that receives a `RetryContext` with the current error and model and all previous attempts.
-It should evaluate the error and decide whether to retry by returning a `RetryModel` or to skip by returning `undefined`.
+A `Retryable` is a function that receives a `RetryContext` with the current error or result and model and all previous attempts.
+It should evaluate the error/result and decide whether to retry by returning a `RetryModel` or to skip by returning `undefined`.
 
 ```ts
 type Retryable = (context: RetryContext) => RetryModel | Promise<RetryModel> | undefined;
@@ -286,13 +293,16 @@ interface RetryContext {
 
 #### `RetryAttempt`
 
-A `RetryAttempt` represents a single failed attempt with a specific model.
+A `RetryAttempt` represents a single attempt with a specific model, which can be either an error or a successful result that triggered a retry.
 
 ```typescript
-interface RetryAttempt {
-  error: unknown;
-  model: LanguageModelV2;
-}
+type RetryAttempt = 
+  | { type: 'error'; error: unknown; model: LanguageModelV2 }
+  | { type: 'result'; result: LanguageModelV2Generate; model: LanguageModelV2 };
+
+// Type guards for discriminating attempts
+function isErrorAttempt(attempt: RetryAttempt): attempt is RetryErrorAttempt;
+function isResultAttempt(attempt: RetryAttempt): attempt is RetryResultAttempt;
 ```
 
 ### License

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

@@ -0,0 +1,221 @@
+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 };

package/dist/create-retryable-model-DzDFqgQO.d.ts

@@ -0,0 +1,59 @@
+import { LanguageModelV2 } from "@ai-sdk/provider";
+
+//#region src/types.d.ts
+type LanguageModelV2Generate = Awaited<ReturnType<LanguageModelV2['doGenerate']>>;
+//#endregion
+//#region src/create-retryable-model.d.ts
+/**
+ * The context provided to Retryables with the current attempt and all previous attempts.
+ */
+interface RetryContext<CURRENT extends RetryAttempt = RetryAttempt> {
+  current: CURRENT;
+  attempts: Array<RetryAttempt>;
+  totalAttempts: number;
+}
+type RetryErrorAttempt = {
+  type: 'error';
+  error: unknown;
+  model: LanguageModelV2;
+};
+type RetryResultAttempt = {
+  type: 'result';
+  result: LanguageModelV2Generate;
+  model: LanguageModelV2;
+};
+/**
+ * A retry attempt with either an error or a result and the model used
+ */
+type RetryAttempt = RetryErrorAttempt | RetryResultAttempt;
+/**
+ * Type guard to check if a retry attempt is an error attempt
+ */
+declare function isErrorAttempt(attempt: RetryAttempt): attempt is RetryErrorAttempt;
+/**
+ * Type guard to check if a retry attempt is a result attempt
+ */
+declare function isResultAttempt(attempt: RetryAttempt): attempt is RetryResultAttempt;
+/**
+ * A model to retry with and the maximum number of attempts for that model.
+ */
+type RetryModel = {
+  model: LanguageModelV2;
+  maxAttempts?: number;
+};
+/**
+ * A function that determines whether to retry with a different model based on the current attempt and all previous attempts.
+ */
+type Retryable = (context: RetryContext) => RetryModel | Promise<RetryModel> | undefined;
+/**
+ * Options for creating a retryable model.
+ */
+interface CreateRetryableOptions {
+  model: LanguageModelV2;
+  retries: Array<Retryable | LanguageModelV2>;
+  onError?: (context: RetryContext<RetryErrorAttempt>) => void;
+  onRetry?: (context: RetryContext<RetryErrorAttempt | RetryResultAttempt>) => void;
+}
+declare function createRetryable(config: CreateRetryableOptions): LanguageModelV2;
+//#endregion
+export { CreateRetryableOptions, RetryAttempt, RetryContext, RetryModel, Retryable, createRetryable, isErrorAttempt, isResultAttempt };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { CreateRetryableOptions, RetryAttempt, RetryContext, RetryModel, Retryable, createRetryable } from "./create-retryable-model-DKKgxKLw.js";
+import { CreateRetryableOptions, RetryAttempt, RetryContext, RetryModel, Retryable, createRetryable, isErrorAttempt, isResultAttempt } from "./create-retryable-model-DzDFqgQO.js";
 import { LanguageModelV2 } from "@ai-sdk/provider";
 
 //#region src/get-model-key.d.ts
@@ -7,4 +7,4 @@ import { LanguageModelV2 } from "@ai-sdk/provider";
  */
 declare const getModelKey: (model: LanguageModelV2) => string;
 //#endregion
-export { CreateRetryableOptions, RetryAttempt, RetryContext, RetryModel, Retryable, createRetryable, getModelKey };
+export { CreateRetryableOptions, RetryAttempt, RetryContext, RetryModel, Retryable, createRetryable, getModelKey, isErrorAttempt, isResultAttempt };

package/dist/index.js

@@ -1,161 +1,3 @@
-import { getErrorMessage } from "@ai-sdk/provider-utils";
-import { RetryError } from "ai";
+import { createRetryable, getModelKey, isErrorAttempt, isResultAttempt } from "./create-retryable-model-CnrFowSg.js";
 
-//#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
-function defaultRetryModel(model) {
-	return {
-		model,
-		maxAttempts: 1
-	};
-}
-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;
-	}
-	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 error occured in the previous attempt or undefined if this is the first attempt
-		*/
-		let currentError;
-		while (true) {
-			/**
-			* Call the onRetry handler if provided.
-			* Skip on the first attempt since no error occured yet.
-			*/
-			if (currentError) {
-				/**
-				* Context for the onRetry handler
-				*/
-				const context = {
-					current: {
-						error: currentError,
-						model: this.currentModel
-					},
-					attempts,
-					totalAttempts
-				};
-				/**
-				* Call the onRetry handler if provided
-				*/
-				this.options.onRetry?.(context);
-			}
-			try {
-				totalAttempts++;
-				return await this.currentModel.doGenerate(options);
-			} catch (error) {
-				/**
-				* Save the error of the current attempt for the retry of the next iteration
-				*/
-				currentError = error;
-				/**
-				* Current attempt with current error
-				*/
-				const currentAttempt = {
-					error: currentError,
-					model: this.currentModel
-				};
-				/**
-				* Save the current attempt
-				*/
-				attempts.push(currentAttempt);
-				/**
-				* Context for the retryables and onError handler
-				*/
-				const context = {
-					current: currentAttempt,
-					attempts,
-					totalAttempts
-				};
-				/**
-				* Call the onError handler if provided
-				*/
-				this.options.onError?.(context);
-				let nextModel;
-				/**
-				* Iterate through the retryables to find a model to retry with
-				*/
-				for (const retry of this.options.retries) {
-					const retryModel = typeof retry === "function" ? await retry(context) : defaultRetryModel(retry);
-					if (retryModel) {
-						/**
-						* The model key uniquely identifies a model instance (provider + modelId)
-						*/
-						const retryModelKey = getModelKey(retryModel.model);
-						/**
-						* Check if the model can still be retried based on maxAttempts
-						*/
-						if (attempts.filter((a) => getModelKey(a.model) === retryModelKey).length < retryModel.maxAttempts) {
-							nextModel = retryModel.model;
-							break;
-						}
-					}
-				}
-				/**
-				* 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) => a.error);
-						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;
-			}
-		}
-	}
-	async doStream(options) {
-		throw new Error("Streaming not implemented");
-	}
-};
-function createRetryable(config) {
-	return new RetryableModel(config);
-}
-
-//#endregion
-export { createRetryable, getModelKey };
+export { createRetryable, getModelKey, isErrorAttempt, isResultAttempt };

package/dist/retryables/index.d.ts

@@ -1,4 +1,4 @@
-import { RetryModel, Retryable } from "../create-retryable-model-DKKgxKLw.js";
+import { RetryModel, Retryable } from "../create-retryable-model-DzDFqgQO.js";
 import { LanguageModelV2 } from "@ai-sdk/provider";
 
 //#region src/retryables/content-filter-triggered.d.ts
@@ -6,22 +6,22 @@ import { LanguageModelV2 } from "@ai-sdk/provider";
 /**
  * Fallback to a different model if the content filter was triggered.
  */
-declare function contentFilterTriggered(input: LanguageModelV2 | RetryModel): Retryable;
+declare function contentFilterTriggered(model: LanguageModelV2, options?: Omit<RetryModel, 'model'>): Retryable;
 //#endregion
 //#region src/retryables/request-not-retryable.d.ts
 /**
  * Fallback to a different model if the error is non-retryable.
  */
-declare function requestNotRetryable(input: LanguageModelV2 | RetryModel): Retryable;
+declare function requestNotRetryable(model: LanguageModelV2, options?: Omit<RetryModel, 'model'>): Retryable;
 //#endregion
 //#region src/retryables/request-timeout.d.ts
 /**
  * Fallback to a different model after a timeout/abort error.
  * Use in combination with the `abortSignal` option in `generateText`.
  */
-declare function requestTimeout(input: LanguageModelV2 | RetryModel): Retryable;
+declare function requestTimeout(model: LanguageModelV2, options?: Omit<RetryModel, 'model'>): Retryable;
 //#endregion
 //#region src/retryables/response-schema-mismatch.d.ts
-declare function responseSchemaMismatch(input: LanguageModelV2 | RetryModel): Retryable;
+declare function responseSchemaMismatch(model: LanguageModelV2, options?: Omit<RetryModel, 'model'>): Retryable;
 //#endregion
 export { contentFilterTriggered, requestNotRetryable, requestTimeout, responseSchemaMismatch };

package/dist/retryables/index.js

@@ -1,6 +1,6 @@
+import { isErrorAttempt, isResultAttempt } from "../create-retryable-model-CnrFowSg.js";
 import { isAbortError } from "@ai-sdk/provider-utils";
 import { APICallError, NoObjectGeneratedError, TypeValidationError } from "ai";
-import { APICallError as APICallError$1 } from "@ai-sdk/provider";
 
 //#region src/utils.ts
 const isObject = (value) => typeof value === "object" && value !== null;
@@ -11,18 +11,25 @@ const isString = (value) => typeof value === "string";
 /**
 * Fallback to a different model if the content filter was triggered.
 */
-function contentFilterTriggered(input) {
+function contentFilterTriggered(model, options) {
 	return (context) => {
-		const { error } = context.current;
-		const model = "model" in input ? input.model : input;
-		if (APICallError.isInstance(error) && isObject(error.data) && isObject(error.data.error) && isString(error.data.error.code) && error.data.error.code === "content_filter") return {
-			model,
-			maxAttempts: 1
-		};
-		if (NoObjectGeneratedError.isInstance(error) && error.finishReason === "content-filter") return {
-			model,
-			maxAttempts: 1
-		};
+		const { current } = context;
+		if (isErrorAttempt(current)) {
+			const { error } = current;
+			if (APICallError.isInstance(error) && isObject(error.data) && isObject(error.data.error) && isString(error.data.error.code) && error.data.error.code === "content_filter") return {
+				model,
+				maxAttempts: 1,
+				...options
+			};
+		}
+		if (isResultAttempt(current)) {
+			const { result } = current;
+			if (result.finishReason === "content-filter") return {
+				model,
+				maxAttempts: 1,
+				...options
+			};
+		}
 	};
 }
 
@@ -31,14 +38,16 @@ function contentFilterTriggered(input) {
 /**
 * Fallback to a different model if the error is non-retryable.
 */
-function requestNotRetryable(input) {
+function requestNotRetryable(model, options) {
 	return (context) => {
-		const { error } = context.current;
-		const model = "model" in input ? input.model : input;
-		if (APICallError$1.isInstance(error) && error.isRetryable === false) return {
-			model,
-			maxAttempts: 1
-		};
+		const { current } = context;
+		if (isErrorAttempt(current)) {
+			if (APICallError.isInstance(current.error) && current.error.isRetryable === false) return {
+				model,
+				maxAttempts: 1,
+				...options
+			};
+		}
 	};
 }
 
@@ -48,30 +57,34 @@ function requestNotRetryable(input) {
 * Fallback to a different model after a timeout/abort error.
 * Use in combination with the `abortSignal` option in `generateText`.
 */
-function requestTimeout(input) {
+function requestTimeout(model, options) {
 	return (context) => {
-		const { error } = context.current;
-		const model = "model" in input ? input.model : input;
-		/**
-		* Fallback to the specified model after all retries are exhausted.
-		*/
-		if (isAbortError(error)) return {
-			model,
-			maxAttempts: 1
-		};
+		const { current } = context;
+		if (isErrorAttempt(current)) {
+			/**
+			* Fallback to the specified model after all retries are exhausted.
+			*/
+			if (isAbortError(current.error)) return {
+				model,
+				maxAttempts: 1,
+				...options
+			};
+		}
 	};
 }
 
 //#endregion
 //#region src/retryables/response-schema-mismatch.ts
-function responseSchemaMismatch(input) {
+function responseSchemaMismatch(model, options) {
 	return (context) => {
-		const { error } = context.current;
-		const model = "model" in input ? input.model : input;
-		if (NoObjectGeneratedError.isInstance(error) && error.finishReason === "stop" && TypeValidationError.isInstance(error.cause)) return {
-			model,
-			maxAttempts: 1
-		};
+		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
+			};
+		}
 	};
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-retry",
-  "version": "0.0.1-alpha.3",
+  "version": "0.0.1",
   "description": "AI SDK Retry",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -17,7 +17,12 @@
   "publishConfig": {
     "access": "public"
   },
-  "keywords": [],
+  "keywords": [
+    "ai",
+    "ai-sdk",
+    "retry",
+    "fallback"
+  ],
   "author": "Chris Cook",
   "license": "MIT",
   "repository": {

package/dist/create-retryable-model-DKKgxKLw.d.ts

@@ -1,42 +0,0 @@
-import { LanguageModelV2 } from "@ai-sdk/provider";
-
-//#region src/create-retryable-model.d.ts
-
-/**
- * The context provided to Retryables with the current attempt and all previous attempts.
- */
-interface RetryContext {
-  current: RetryAttempt;
-  attempts: Array<RetryAttempt>;
-  totalAttempts: number;
-}
-/**
- * A retry attempt with the error and model used
- */
-interface RetryAttempt {
-  error: unknown;
-  model: LanguageModelV2;
-}
-/**
- * A model to retry with and the maximum number of attempts for that model.
- */
-type RetryModel = {
-  model: LanguageModelV2;
-  maxAttempts: number;
-};
-/**
- * A function that determines whether to retry with a different model based on the current attempt and all previous attempts.
- */
-type Retryable = (context: RetryContext) => RetryModel | Promise<RetryModel> | undefined;
-/**
- * Options for creating a retryable model.
- */
-interface CreateRetryableOptions {
-  model: LanguageModelV2;
-  retries: Array<Retryable | LanguageModelV2>;
-  onError?: (context: RetryContext) => void;
-  onRetry?: (context: RetryContext) => void;
-}
-declare function createRetryable(config: CreateRetryableOptions): LanguageModelV2;
-//#endregion
-export { CreateRetryableOptions, RetryAttempt, RetryContext, RetryModel, Retryable, createRetryable };