ai-retry 0.2.0 → 0.3.0

package/README.md

@@ -247,6 +247,42 @@ try {
 }
 ```
 
+#### Retry Delays
+
+You can add delays before retrying to handle rate limiting or give services time to recover. The delay respects abort signals, so requests can still be cancelled during the delay period.
+
+```typescript
+const retryableModel = createRetryable({
+  model: openai('gpt-4'),
+  retries: [
+    // Wait 1 second before retrying
+    () => ({ 
+      model: openai('gpt-4'), 
+      delay: 1_000 
+    }),
+    // Wait 2 seconds before trying a different provider
+    () => ({ 
+      model: anthropic('claude-3-haiku-20240307'), 
+      delay: 2_000 
+    }),
+  ],
+});
+```
+
+You can also use delays with built-in retryables:
+
+```typescript
+import { serviceOverloaded } from 'ai-retry/retryables';
+
+const retryableModel = createRetryable({
+  model: openai('gpt-4'),
+  retries: [
+    // Wait 5 seconds before retrying on service overload
+    serviceOverloaded(openai('gpt-4'), { maxAttempts: 3, delay: 5_000 }),
+  ],
+});
+```
+
 #### Logging
 
 You can use the following callbacks to log retry attempts and errors:
@@ -318,16 +354,20 @@ type Retryable = (
 
 #### `RetryModel`
 
-A `RetryModel` specifies the model to retry and an optional `maxAttempts` to limit how many times this model can be retried.
-By default, each retryable will only attempt to retry once per model. This can be customized by setting the `maxAttempts` property.
+A `RetryModel` specifies the model to retry and optional settings like `maxAttempts` and `delay`.
 
 ```typescript
 interface RetryModel {
   model: LanguageModelV2 | EmbeddingModelV2;
-  maxAttempts?: number;
+  maxAttempts?: number; // Maximum retry attempts per model (default: 1)
+  delay?: number;       // Delay in milliseconds before retrying
 }
 ```
 
+**Options:**
+- `maxAttempts`: Maximum number of times this model can be retried. Default is 1.
+- `delay`: Delay in milliseconds to wait before retrying. Useful for rate limiting or giving services time to recover. The delay respects abort signals from the request.
+
 #### `RetryContext`
 
 The `RetryContext` object contains information about the current attempt and all previous attempts.

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { EmbeddingModelV2, LanguageModelV2, RetryableModelOptions } from "./types-CHhEGL5x.js";
+import { EmbeddingModelV2, EmbeddingModelV2CallOptions, EmbeddingModelV2Embed, LanguageModelV2, LanguageModelV2Generate, LanguageModelV2Stream, Retries, RetryAttempt, RetryContext, RetryErrorAttempt, RetryModel, RetryResultAttempt, Retryable, RetryableModelOptions } from "./types-BrJaHkFh.js";
 
 //#region src/create-retryable-model.d.ts
 declare function createRetryable<MODEL extends LanguageModelV2>(options: RetryableModelOptions<MODEL>): LanguageModelV2;
@@ -10,4 +10,4 @@ declare function createRetryable<MODEL extends EmbeddingModelV2>(options: Retrya
  */
 declare const getModelKey: (model: LanguageModelV2 | EmbeddingModelV2) => string;
 //#endregion
-export { createRetryable, getModelKey };
+export { EmbeddingModelV2, EmbeddingModelV2CallOptions, EmbeddingModelV2Embed, LanguageModelV2, LanguageModelV2Generate, LanguageModelV2Stream, Retries, RetryAttempt, RetryContext, RetryErrorAttempt, RetryModel, RetryResultAttempt, Retryable, RetryableModelOptions, createRetryable, getModelKey };

package/dist/index.js

@@ -1,7 +1,7 @@
 import { isErrorAttempt, isGenerateResult, isResultAttempt, isStreamContentPart } from "./utils-lRsC105f.js";
-import "@ai-sdk/provider-utils";
-import { RetryError } from "ai";
+import { delay } from "@ai-sdk/provider-utils";
 import { getErrorMessage } from "@ai-sdk/provider";
+import { RetryError } from "ai";
 
 //#region src/get-model-key.ts
 /**
@@ -44,7 +44,7 @@ async function findRetryModel(retries, context) {
 			/**
 			* Check if the model can still be retried based on maxAttempts
 			*/
-			if (retryAttempts.length < maxAttempts) return retryModel.model;
+			if (retryAttempts.length < maxAttempts) return retryModel;
 		}
 	}
 }
@@ -126,9 +126,10 @@ var RetryableEmbeddingModel = class {
 					attempts
 				};
 			} catch (error) {
-				const { nextModel, attempt } = await this.handleError(error, attempts);
+				const { retryModel, attempt } = await this.handleError(error, attempts);
 				attempts.push(attempt);
-				this.currentModel = nextModel;
+				if (retryModel.delay) await delay(retryModel.delay, { abortSignal: input.abortSignal });
+				this.currentModel = retryModel.model;
 			}
 		}
 	}
@@ -150,17 +151,17 @@ var RetryableEmbeddingModel = class {
 			attempts: updatedAttempts
 		};
 		this.options.onError?.(context);
-		const nextModel = await findRetryModel(this.options.retries, context);
+		const retryModel = await findRetryModel(this.options.retries, 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 (!retryModel) {
 			if (updatedAttempts.length > 1) throw prepareRetryError(error, updatedAttempts);
 			throw error;
 		}
 		return {
-			nextModel,
+			retryModel,
 			attempt: errorAttempt
 		};
 	}
@@ -169,7 +170,10 @@ var RetryableEmbeddingModel = class {
 		* Always start with the original model
 		*/
 		this.currentModel = this.baseModel;
-		const { result } = await this.withRetry({ fn: async () => await this.currentModel.doEmbed(options) });
+		const { result } = await this.withRetry({
+			fn: async () => await this.currentModel.doEmbed(options),
+			abortSignal: options.abortSignal
+		});
 		return result;
 	}
 };
@@ -236,10 +240,11 @@ var RetryableLanguageModel = class {
 				* 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);
+					const { retryModel, attempt } = await this.handleResult(result, attempts);
 					attempts.push(attempt);
-					if (nextModel) {
-						this.currentModel = nextModel;
+					if (retryModel) {
+						if (retryModel.delay) await delay(retryModel.delay, { abortSignal: input.abortSignal });
+						this.currentModel = retryModel.model;
 						/**
 						* Continue to the next iteration to retry
 						*/
@@ -251,9 +256,10 @@ var RetryableLanguageModel = class {
 					attempts
 				};
 			} catch (error) {
-				const { nextModel, attempt } = await this.handleError(error, attempts);
+				const { retryModel, attempt } = await this.handleError(error, attempts);
 				attempts.push(attempt);
-				this.currentModel = nextModel;
+				if (retryModel.delay) await delay(retryModel.delay, { abortSignal: input.abortSignal });
+				this.currentModel = retryModel.model;
 			}
 		}
 	}
@@ -275,7 +281,7 @@ var RetryableLanguageModel = class {
 			attempts: updatedAttempts
 		};
 		return {
-			nextModel: await findRetryModel(this.options.retries, context),
+			retryModel: await findRetryModel(this.options.retries, context),
 			attempt: resultAttempt
 		};
 	}
@@ -297,17 +303,17 @@ var RetryableLanguageModel = class {
 			attempts: updatedAttempts
 		};
 		this.options.onError?.(context);
-		const nextModel = await findRetryModel(this.options.retries, context);
+		const retryModel = await findRetryModel(this.options.retries, 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 (!retryModel) {
 			if (updatedAttempts.length > 1) throw prepareRetryError(error, updatedAttempts);
 			throw error;
 		}
 		return {
-			nextModel,
+			retryModel,
 			attempt: errorAttempt
 		};
 	}
@@ -316,7 +322,10 @@ var RetryableLanguageModel = class {
 		* Always start with the original model
 		*/
 		this.currentModel = this.baseModel;
-		const { result } = await this.withRetry({ fn: async () => await this.currentModel.doGenerate(options) });
+		const { result } = await this.withRetry({
+			fn: async () => await this.currentModel.doGenerate(options),
+			abortSignal: options.abortSignal
+		});
 		return result;
 	}
 	async doStream(options) {
@@ -327,7 +336,10 @@ var RetryableLanguageModel = class {
 		/**
 		* 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) });
+		let { result, attempts } = await this.withRetry({
+			fn: async () => await this.currentModel.doStream(options),
+			abortSignal: options.abortSignal
+		});
 		/**
 		* Wrap the original stream to handle retries if an error occurs during streaming.
 		*/
@@ -362,19 +374,21 @@ var RetryableLanguageModel = class {
 				* 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;
+				const { retryModel, attempt } = await this.handleError(error, attempts);
 				/**
 				* Save the attempt
 				*/
 				attempts.push(attempt);
+				if (retryModel.delay) await delay(retryModel.delay, { abortSignal: options.abortSignal });
+				this.currentModel = retryModel.model;
 				/**
 				* 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
+					attempts,
+					abortSignal: options.abortSignal
 				});
 				/**
 				* Cancel the previous reader and stream if we are retrying

package/dist/retryables/index.d.ts

@@ -1,4 +1,4 @@
-import { EmbeddingModelV2, LanguageModelV2, RetryModel, Retryable } from "../types-CHhEGL5x.js";
+import { EmbeddingModelV2, LanguageModelV2, RetryModel, Retryable } from "../types-BrJaHkFh.js";
 
 //#region src/retryables/content-filter-triggered.d.ts
 

package/dist/{types-CHhEGL5x.d.ts → types-BrJaHkFh.d.ts}

@@ -52,6 +52,7 @@ type RetryAttempt<MODEL extends LanguageModelV2 | EmbeddingModelV2$1> = RetryErr
 type RetryModel<MODEL extends LanguageModelV2 | EmbeddingModelV2$1> = {
   model: MODEL;
   maxAttempts?: number;
+  delay?: number;
 };
 /**
  * A function that determines whether to retry with a different model based on the current attempt and all previous attempts.
@@ -59,5 +60,8 @@ type RetryModel<MODEL extends LanguageModelV2 | EmbeddingModelV2$1> = {
 type Retryable<MODEL extends LanguageModelV2 | EmbeddingModelV2$1> = (context: RetryContext<MODEL>) => RetryModel<MODEL> | Promise<RetryModel<MODEL>> | undefined;
 type Retries<MODEL extends LanguageModelV2 | EmbeddingModelV2$1> = Array<Retryable<MODEL> | MODEL>;
 type LanguageModelV2Generate = Awaited<ReturnType<LanguageModelV2['doGenerate']>>;
+type LanguageModelV2Stream = Awaited<ReturnType<LanguageModelV2['doStream']>>;
+type EmbeddingModelV2CallOptions<VALUE> = Parameters<EmbeddingModelV2$1<VALUE>['doEmbed']>[0];
+type EmbeddingModelV2Embed<VALUE> = Awaited<ReturnType<EmbeddingModelV2$1<VALUE>['doEmbed']>>;
 //#endregion
-export { EmbeddingModelV2$1 as EmbeddingModelV2, type LanguageModelV2, RetryModel, Retryable, RetryableModelOptions };
+export { EmbeddingModelV2$1 as EmbeddingModelV2, EmbeddingModelV2CallOptions, EmbeddingModelV2Embed, type LanguageModelV2, LanguageModelV2Generate, LanguageModelV2Stream, Retries, RetryAttempt, RetryContext, RetryErrorAttempt, RetryModel, RetryResultAttempt, Retryable, RetryableModelOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-retry",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "AI SDK Retry",
   "packageManager": "pnpm@9.0.0",
   "main": "./dist/index.js",