@langchain/langgraph-sdk 0.1.10 → 1.0.0

package/dist/ui/messages.js

@@ -1,71 +1,60 @@
-import { RemoveMessage, convertToChunk, coerceMessageLikeToMessage, isBaseMessageChunk, } from "@langchain/core/messages";
+import { RemoveMessage, coerceMessageLikeToMessage, convertToChunk, isBaseMessageChunk } from "@langchain/core/messages";
+
+//#region src/ui/messages.ts
 function tryConvertToChunk(message) {
-    try {
-        return convertToChunk(message);
-    }
-    catch {
-        return null;
-    }
+	try {
+		return convertToChunk(message);
+	} catch {
+		return null;
+	}
 }
 function tryCoerceMessageLikeToMessage(message) {
-    // TODO: this is unnecessary with https://github.com/langchain-ai/langchainjs/pull/8941
-    if (message.type === "remove" && message.id != null) {
-        return new RemoveMessage({ ...message, id: message.id });
-    }
-    return coerceMessageLikeToMessage(message);
+	if (message.type === "remove" && message.id != null) return new RemoveMessage({
+		...message,
+		id: message.id
+	});
+	return coerceMessageLikeToMessage(message);
 }
-export class MessageTupleManager {
-    constructor() {
-        Object.defineProperty(this, "chunks", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        this.chunks = {};
-    }
-    add(serialized, metadata) {
-        // TODO: this is sometimes sent from the API
-        // figure out how to prevent this or move this to LC.js
-        if (serialized.type.endsWith("MessageChunk")) {
-            // eslint-disable-next-line no-param-reassign
-            serialized.type = serialized.type
-                .slice(0, -"MessageChunk".length)
-                .toLowerCase();
-        }
-        const message = tryCoerceMessageLikeToMessage(serialized);
-        const chunk = tryConvertToChunk(message);
-        const { id } = chunk ?? message;
-        if (!id) {
-            console.warn("No message ID found for chunk, ignoring in state", serialized);
-            return null;
-        }
-        this.chunks[id] ??= {};
-        this.chunks[id].metadata = metadata ?? this.chunks[id].metadata;
-        if (chunk) {
-            const prev = this.chunks[id].chunk;
-            this.chunks[id].chunk =
-                (isBaseMessageChunk(prev) ? prev : null)?.concat(chunk) ?? chunk;
-        }
-        else {
-            this.chunks[id].chunk = message;
-        }
-        return id;
-    }
-    clear() {
-        this.chunks = {};
-    }
-    get(id, defaultIndex) {
-        if (id == null)
-            return null;
-        if (this.chunks[id] == null)
-            return null;
-        if (defaultIndex != null)
-            this.chunks[id].index ??= defaultIndex;
-        return this.chunks[id];
-    }
-}
-export const toMessageDict = (chunk) => {
-    const { type, data } = chunk.toDict();
-    return { ...data, type };
+var MessageTupleManager = class {
+	chunks = {};
+	constructor() {
+		this.chunks = {};
+	}
+	add(serialized, metadata) {
+		if (serialized.type.endsWith("MessageChunk")) serialized.type = serialized.type.slice(0, -12).toLowerCase();
+		const message = tryCoerceMessageLikeToMessage(serialized);
+		const chunk = tryConvertToChunk(message);
+		const { id } = chunk ?? message;
+		if (!id) {
+			console.warn("No message ID found for chunk, ignoring in state", serialized);
+			return null;
+		}
+		this.chunks[id] ??= {};
+		this.chunks[id].metadata = metadata ?? this.chunks[id].metadata;
+		if (chunk) {
+			const prev = this.chunks[id].chunk;
+			this.chunks[id].chunk = (isBaseMessageChunk(prev) ? prev : null)?.concat(chunk) ?? chunk;
+		} else this.chunks[id].chunk = message;
+		return id;
+	}
+	clear() {
+		this.chunks = {};
+	}
+	get(id, defaultIndex) {
+		if (id == null) return null;
+		if (this.chunks[id] == null) return null;
+		if (defaultIndex != null) this.chunks[id].index ??= defaultIndex;
+		return this.chunks[id];
+	}
+};
+const toMessageDict = (chunk) => {
+	const { type, data } = chunk.toDict();
+	return {
+		...data,
+		type
+	};
 };
+
+//#endregion
+export { MessageTupleManager, toMessageDict };
+//# sourceMappingURL=messages.js.map

package/dist/ui/messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.js","names":[],"sources":["../../src/ui/messages.ts"],"sourcesContent":["import {\n  type BaseMessage,\n  type BaseMessageChunk,\n  RemoveMessage,\n  convertToChunk,\n  coerceMessageLikeToMessage,\n  isBaseMessageChunk,\n} from \"@langchain/core/messages\";\n\nimport type { Message } from \"../types.messages.js\";\n\nfunction tryConvertToChunk(message: BaseMessage): BaseMessageChunk | null {\n  try {\n    return convertToChunk(message);\n  } catch {\n    return null;\n  }\n}\n\nfunction tryCoerceMessageLikeToMessage(message: Message): BaseMessage {\n  // TODO: this is unnecessary with https://github.com/langchain-ai/langchainjs/pull/8941\n  if (message.type === \"remove\" && message.id != null) {\n    return new RemoveMessage({ ...message, id: message.id });\n  }\n\n  return coerceMessageLikeToMessage(message);\n}\n\nexport class MessageTupleManager {\n  chunks: Record<\n    string,\n    {\n      chunk?: BaseMessageChunk | BaseMessage;\n      metadata?: Record<string, unknown>;\n      index?: number;\n    }\n  > = {};\n\n  constructor() {\n    this.chunks = {};\n  }\n\n  add(\n    serialized: Message,\n    metadata: Record<string, unknown> | undefined\n  ): string | null {\n    // TODO: this is sometimes sent from the API\n    // figure out how to prevent this or move this to LC.js\n    if (serialized.type.endsWith(\"MessageChunk\")) {\n      // eslint-disable-next-line no-param-reassign\n      serialized.type = serialized.type\n        .slice(0, -\"MessageChunk\".length)\n        .toLowerCase() as Message[\"type\"];\n    }\n\n    const message = tryCoerceMessageLikeToMessage(serialized);\n    const chunk = tryConvertToChunk(message);\n\n    const { id } = chunk ?? message;\n    if (!id) {\n      console.warn(\n        \"No message ID found for chunk, ignoring in state\",\n        serialized\n      );\n      return null;\n    }\n\n    this.chunks[id] ??= {};\n    this.chunks[id].metadata = metadata ?? this.chunks[id].metadata;\n    if (chunk) {\n      const prev = this.chunks[id].chunk;\n      this.chunks[id].chunk =\n        (isBaseMessageChunk(prev) ? prev : null)?.concat(chunk) ?? chunk;\n    } else {\n      this.chunks[id].chunk = message;\n    }\n\n    return id;\n  }\n\n  clear() {\n    this.chunks = {};\n  }\n\n  get(id: string | null | undefined, defaultIndex?: number) {\n    if (id == null) return null;\n    if (this.chunks[id] == null) return null;\n    if (defaultIndex != null) this.chunks[id].index ??= defaultIndex;\n    return this.chunks[id];\n  }\n}\n\nexport const toMessageDict = (chunk: BaseMessage): Message => {\n  const { type, data } = chunk.toDict();\n  return { ...data, type } as Message;\n};\n"],"mappings":";;;AAWA,SAAS,kBAAkB,SAA+C;AACxE,KAAI;AACF,SAAO,eAAe;SAChB;AACN,SAAO;;;AAIX,SAAS,8BAA8B,SAA+B;AAEpE,KAAI,QAAQ,SAAS,YAAY,QAAQ,MAAM,KAC7C,QAAO,IAAI,cAAc;EAAE,GAAG;EAAS,IAAI,QAAQ;;AAGrD,QAAO,2BAA2B;;AAGpC,IAAa,sBAAb,MAAiC;CAC/B,SAOI;CAEJ,cAAc;AACZ,OAAK,SAAS;;CAGhB,IACE,YACA,UACe;AAGf,MAAI,WAAW,KAAK,SAAS,gBAE3B,YAAW,OAAO,WAAW,KAC1B,MAAM,GAAG,KACT;EAGL,MAAM,UAAU,8BAA8B;EAC9C,MAAM,QAAQ,kBAAkB;EAEhC,MAAM,EAAE,OAAO,SAAS;AACxB,MAAI,CAAC,IAAI;AACP,WAAQ,KACN,oDACA;AAEF,UAAO;;AAGT,OAAK,OAAO,QAAQ;AACpB,OAAK,OAAO,IAAI,WAAW,YAAY,KAAK,OAAO,IAAI;AACvD,MAAI,OAAO;GACT,MAAM,OAAO,KAAK,OAAO,IAAI;AAC7B,QAAK,OAAO,IAAI,SACb,mBAAmB,QAAQ,OAAO,OAAO,OAAO,UAAU;QAE7D,MAAK,OAAO,IAAI,QAAQ;AAG1B,SAAO;;CAGT,QAAQ;AACN,OAAK,SAAS;;CAGhB,IAAI,IAA+B,cAAuB;AACxD,MAAI,MAAM,KAAM,QAAO;AACvB,MAAI,KAAK,OAAO,OAAO,KAAM,QAAO;AACpC,MAAI,gBAAgB,KAAM,MAAK,OAAO,IAAI,UAAU;AACpD,SAAO,KAAK,OAAO;;;AAIvB,MAAa,iBAAiB,UAAgC;CAC5D,MAAM,EAAE,MAAM,SAAS,MAAM;AAC7B,QAAO;EAAE,GAAG;EAAM"}

package/dist/ui/utils.cjs

@@ -1,14 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unique = unique;
-exports.findLast = findLast;
+
+//#region src/ui/utils.ts
 function unique(array) {
-    return [...new Set(array)];
+	return [...new Set(array)];
 }
 function findLast(array, predicate) {
-    for (let i = array.length - 1; i >= 0; i -= 1) {
-        if (predicate(array[i]))
-            return array[i];
-    }
-    return undefined;
+	for (let i = array.length - 1; i >= 0; i -= 1) if (predicate(array[i])) return array[i];
+	return void 0;
 }
+
+//#endregion
+exports.findLast = findLast;
+exports.unique = unique;
+//# sourceMappingURL=utils.cjs.map

package/dist/ui/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","names":[],"sources":["../../src/ui/utils.ts"],"sourcesContent":["export function unique<T>(array: T[]) {\n  return [...new Set(array)] as T[];\n}\n\nexport function findLast<T>(array: T[], predicate: (item: T) => boolean) {\n  for (let i = array.length - 1; i >= 0; i -= 1) {\n    if (predicate(array[i])) return array[i];\n  }\n  return undefined;\n}\n"],"mappings":";;AAAA,SAAgB,OAAU,OAAY;AACpC,QAAO,CAAC,GAAG,IAAI,IAAI;;AAGrB,SAAgB,SAAY,OAAY,WAAiC;AACvE,MAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,EAC1C,KAAI,UAAU,MAAM,IAAK,QAAO,MAAM;AAExC,QAAO"}

package/dist/ui/utils.js

@@ -1,10 +1,12 @@
-export function unique(array) {
-    return [...new Set(array)];
+//#region src/ui/utils.ts
+function unique(array) {
+	return [...new Set(array)];
 }
-export function findLast(array, predicate) {
-    for (let i = array.length - 1; i >= 0; i -= 1) {
-        if (predicate(array[i]))
-            return array[i];
-    }
-    return undefined;
+function findLast(array, predicate) {
+	for (let i = array.length - 1; i >= 0; i -= 1) if (predicate(array[i])) return array[i];
+	return void 0;
 }
+
+//#endregion
+export { findLast, unique };
+//# sourceMappingURL=utils.js.map

package/dist/ui/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/ui/utils.ts"],"sourcesContent":["export function unique<T>(array: T[]) {\n  return [...new Set(array)] as T[];\n}\n\nexport function findLast<T>(array: T[], predicate: (item: T) => boolean) {\n  for (let i = array.length - 1; i >= 0; i -= 1) {\n    if (predicate(array[i])) return array[i];\n  }\n  return undefined;\n}\n"],"mappings":";AAAA,SAAgB,OAAU,OAAY;AACpC,QAAO,CAAC,GAAG,IAAI,IAAI;;AAGrB,SAAgB,SAAY,OAAY,WAAiC;AACvE,MAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,EAC1C,KAAI,UAAU,MAAM,IAAK,QAAO,MAAM;AAExC,QAAO"}

package/dist/utils/async_caller.cjs

@@ -1,193 +1,111 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncCaller = void 0;
-const p_retry_1 = __importDefault(require("p-retry"));
-const p_queue_1 = __importDefault(require("p-queue"));
-const fetch_js_1 = require("../singletons/fetch.cjs");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_fetch = require('../singletons/fetch.cjs');
+const p_retry = require_rolldown_runtime.__toESM(require("p-retry"));
+const p_queue = require_rolldown_runtime.__toESM(require("p-queue"));
+
+//#region src/utils/async_caller.ts
 const STATUS_NO_RETRY = [
-    400, // Bad Request
-    401, // Unauthorized
-    402, // Payment required
-    403, // Forbidden
-    404, // Not Found
-    405, // Method Not Allowed
-    406, // Not Acceptable
-    407, // Proxy Authentication Required
-    408, // Request Timeout
-    409, // Conflict
-    422, // Unprocessable Entity
+	400,
+	401,
+	402,
+	403,
+	404,
+	405,
+	406,
+	407,
+	408,
+	409,
+	422
 ];
 /**
- * Do not rely on globalThis.Response, rather just
- * do duck typing
- */
+* Do not rely on globalThis.Response, rather just
+* do duck typing
+*/
 function isResponse(x) {
-    if (x == null || typeof x !== "object")
-        return false;
-    return "status" in x && "statusText" in x && "text" in x;
+	if (x == null || typeof x !== "object") return false;
+	return "status" in x && "statusText" in x && "text" in x;
 }
 /**
- * Utility error to properly handle failed requests
- */
-class HTTPError extends Error {
-    constructor(status, message, response) {
-        super(`HTTP ${status}: ${message}`);
-        Object.defineProperty(this, "status", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "text", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "response", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.status = status;
-        this.text = message;
-        this.response = response;
-    }
-    static async fromResponse(response, options) {
-        try {
-            return new HTTPError(response.status, await response.text(), options?.includeResponse ? response : undefined);
-        }
-        catch {
-            return new HTTPError(response.status, response.statusText, options?.includeResponse ? response : undefined);
-        }
-    }
-}
+* Utility error to properly handle failed requests
+*/
+var HTTPError = class HTTPError extends Error {
+	status;
+	text;
+	response;
+	constructor(status, message, response) {
+		super(`HTTP ${status}: ${message}`);
+		this.status = status;
+		this.text = message;
+		this.response = response;
+	}
+	static async fromResponse(response, options) {
+		try {
+			return new HTTPError(response.status, await response.text(), options?.includeResponse ? response : void 0);
+		} catch {
+			return new HTTPError(response.status, response.statusText, options?.includeResponse ? response : void 0);
+		}
+	}
+};
 /**
- * A class that can be used to make async calls with concurrency and retry logic.
- *
- * This is useful for making calls to any kind of "expensive" external resource,
- * be it because it's rate-limited, subject to network issues, etc.
- *
- * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
- * to `Infinity`. This means that by default, all calls will be made in parallel.
- *
- * Retries are limited by the `maxRetries` parameter, which defaults to 5. This
- * means that by default, each call will be retried up to 5 times, with an
- * exponential backoff between each attempt.
- */
-class AsyncCaller {
-    constructor(params) {
-        Object.defineProperty(this, "maxConcurrency", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "maxRetries", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "queue", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "onFailedResponseHook", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "customFetch", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.maxConcurrency = params.maxConcurrency ?? Infinity;
-        this.maxRetries = params.maxRetries ?? 4;
-        if ("default" in p_queue_1.default) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.queue = new p_queue_1.default.default({
-                concurrency: this.maxConcurrency,
-            });
-        }
-        else {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.queue = new p_queue_1.default({ concurrency: this.maxConcurrency });
-        }
-        this.onFailedResponseHook = params?.onFailedResponseHook;
-        this.customFetch = params.fetch;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    call(callable, ...args) {
-        const { onFailedResponseHook } = this;
-        return this.queue.add(() => (0, p_retry_1.default)(() => callable(...args).catch(async (error) => {
-            // eslint-disable-next-line no-instanceof/no-instanceof
-            if (error instanceof Error) {
-                throw error;
-            }
-            else if (isResponse(error)) {
-                throw await HTTPError.fromResponse(error, {
-                    includeResponse: !!onFailedResponseHook,
-                });
-            }
-            else {
-                throw new Error(error);
-            }
-        }), {
-            async onFailedAttempt(error) {
-                if (error.message.startsWith("Cancel") ||
-                    error.message.startsWith("TimeoutError") ||
-                    error.message.startsWith("AbortError")) {
-                    throw error;
-                }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                if (error?.code === "ECONNABORTED") {
-                    throw error;
-                }
-                // eslint-disable-next-line no-instanceof/no-instanceof
-                if (error instanceof HTTPError) {
-                    if (STATUS_NO_RETRY.includes(error.status)) {
-                        throw error;
-                    }
-                    if (onFailedResponseHook && error.response) {
-                        await onFailedResponseHook(error.response);
-                    }
-                }
-            },
-            // If needed we can change some of the defaults here,
-            // but they're quite sensible.
-            retries: this.maxRetries,
-            randomize: true,
-        }), { throwOnTimeout: true });
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    callWithOptions(options, callable, ...args) {
-        // Note this doesn't cancel the underlying request,
-        // when available prefer to use the signal option of the underlying call
-        if (options.signal) {
-            return Promise.race([
-                this.call(callable, ...args),
-                new Promise((_, reject) => {
-                    options.signal?.addEventListener("abort", () => {
-                        reject(new Error("AbortError"));
-                    });
-                }),
-            ]);
-        }
-        return this.call(callable, ...args);
-    }
-    fetch(...args) {
-        const fetchFn = this.customFetch ?? (0, fetch_js_1._getFetchImplementation)();
-        return this.call(() => fetchFn(...args).then((res) => (res.ok ? res : Promise.reject(res))));
-    }
-}
+* A class that can be used to make async calls with concurrency and retry logic.
+*
+* This is useful for making calls to any kind of "expensive" external resource,
+* be it because it's rate-limited, subject to network issues, etc.
+*
+* Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
+* to `Infinity`. This means that by default, all calls will be made in parallel.
+*
+* Retries are limited by the `maxRetries` parameter, which defaults to 5. This
+* means that by default, each call will be retried up to 5 times, with an
+* exponential backoff between each attempt.
+*/
+var AsyncCaller = class {
+	maxConcurrency;
+	maxRetries;
+	queue;
+	onFailedResponseHook;
+	customFetch;
+	constructor(params) {
+		this.maxConcurrency = params.maxConcurrency ?? Infinity;
+		this.maxRetries = params.maxRetries ?? 4;
+		if ("default" in p_queue.default) this.queue = new p_queue.default.default({ concurrency: this.maxConcurrency });
+		else this.queue = new p_queue.default({ concurrency: this.maxConcurrency });
+		this.onFailedResponseHook = params?.onFailedResponseHook;
+		this.customFetch = params.fetch;
+	}
+	call(callable, ...args) {
+		const { onFailedResponseHook } = this;
+		return this.queue.add(() => (0, p_retry.default)(() => callable(...args).catch(async (error) => {
+			if (error instanceof Error) throw error;
+			else if (isResponse(error)) throw await HTTPError.fromResponse(error, { includeResponse: !!onFailedResponseHook });
+			else throw new Error(error);
+		}), {
+			async onFailedAttempt(error) {
+				if (error.message.startsWith("Cancel") || error.message.startsWith("TimeoutError") || error.message.startsWith("AbortError")) throw error;
+				if (error?.code === "ECONNABORTED") throw error;
+				if (error instanceof HTTPError) {
+					if (STATUS_NO_RETRY.includes(error.status)) throw error;
+					if (onFailedResponseHook && error.response) await onFailedResponseHook(error.response);
+				}
+			},
+			retries: this.maxRetries,
+			randomize: true
+		}), { throwOnTimeout: true });
+	}
+	callWithOptions(options, callable, ...args) {
+		if (options.signal) return Promise.race([this.call(callable, ...args), new Promise((_, reject) => {
+			options.signal?.addEventListener("abort", () => {
+				reject(/* @__PURE__ */ new Error("AbortError"));
+			});
+		})]);
+		return this.call(callable, ...args);
+	}
+	fetch(...args) {
+		const fetchFn = this.customFetch ?? require_fetch._getFetchImplementation();
+		return this.call(() => fetchFn(...args).then((res) => res.ok ? res : Promise.reject(res)));
+	}
+};
+
+//#endregion
 exports.AsyncCaller = AsyncCaller;
+//# sourceMappingURL=async_caller.cjs.map

package/dist/utils/async_caller.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async_caller.cjs","names":["PQueueMod","_getFetchImplementation"],"sources":["../../src/utils/async_caller.ts"],"sourcesContent":["import pRetry from \"p-retry\";\nimport PQueueMod from \"p-queue\";\nimport { _getFetchImplementation } from \"../singletons/fetch.js\";\n\nconst STATUS_NO_RETRY = [\n  400, // Bad Request\n  401, // Unauthorized\n  402, // Payment required\n  403, // Forbidden\n  404, // Not Found\n  405, // Method Not Allowed\n  406, // Not Acceptable\n  407, // Proxy Authentication Required\n  408, // Request Timeout\n  409, // Conflict\n  422, // Unprocessable Entity\n];\n\ntype ResponseCallback = (response?: Response) => Promise<boolean>;\n\nexport interface AsyncCallerParams {\n  /**\n   * The maximum number of concurrent calls that can be made.\n   * Defaults to `Infinity`, which means no limit.\n   */\n  maxConcurrency?: number;\n  /**\n   * The maximum number of retries that can be made for a single call,\n   * with an exponential backoff between each attempt. Defaults to 6.\n   */\n  maxRetries?: number;\n\n  onFailedResponseHook?: ResponseCallback;\n\n  /**\n   * Specify a custom fetch implementation.\n   *\n   * By default we expect the `fetch` is available in the global scope.\n   */\n  fetch?: typeof fetch | ((...args: any[]) => any); // eslint-disable-line @typescript-eslint/no-explicit-any\n}\n\nexport interface AsyncCallerCallOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Do not rely on globalThis.Response, rather just\n * do duck typing\n */\nfunction isResponse(x: unknown): x is Response {\n  if (x == null || typeof x !== \"object\") return false;\n  return \"status\" in x && \"statusText\" in x && \"text\" in x;\n}\n\n/**\n * Utility error to properly handle failed requests\n */\nclass HTTPError extends Error {\n  status: number;\n\n  text: string;\n\n  response?: Response;\n\n  constructor(status: number, message: string, response?: Response) {\n    super(`HTTP ${status}: ${message}`);\n    this.status = status;\n    this.text = message;\n    this.response = response;\n  }\n\n  static async fromResponse(\n    response: Response,\n    options?: { includeResponse?: boolean }\n  ): Promise<HTTPError> {\n    try {\n      return new HTTPError(\n        response.status,\n        await response.text(),\n        options?.includeResponse ? response : undefined\n      );\n    } catch {\n      return new HTTPError(\n        response.status,\n        response.statusText,\n        options?.includeResponse ? response : undefined\n      );\n    }\n  }\n}\n\n/**\n * A class that can be used to make async calls with concurrency and retry logic.\n *\n * This is useful for making calls to any kind of \"expensive\" external resource,\n * be it because it's rate-limited, subject to network issues, etc.\n *\n * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults\n * to `Infinity`. This means that by default, all calls will be made in parallel.\n *\n * Retries are limited by the `maxRetries` parameter, which defaults to 5. This\n * means that by default, each call will be retried up to 5 times, with an\n * exponential backoff between each attempt.\n */\nexport class AsyncCaller {\n  protected maxConcurrency: AsyncCallerParams[\"maxConcurrency\"];\n\n  protected maxRetries: AsyncCallerParams[\"maxRetries\"];\n\n  private queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"];\n\n  private onFailedResponseHook?: ResponseCallback;\n\n  private customFetch?: typeof fetch;\n\n  constructor(params: AsyncCallerParams) {\n    this.maxConcurrency = params.maxConcurrency ?? Infinity;\n    this.maxRetries = params.maxRetries ?? 4;\n\n    if (\"default\" in PQueueMod) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      this.queue = new (PQueueMod.default as any)({\n        concurrency: this.maxConcurrency,\n      });\n    } else {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      this.queue = new (PQueueMod as any)({ concurrency: this.maxConcurrency });\n    }\n    this.onFailedResponseHook = params?.onFailedResponseHook;\n    this.customFetch = params.fetch;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  call<A extends any[], T extends (...args: A) => Promise<any>>(\n    callable: T,\n    ...args: Parameters<T>\n  ): Promise<Awaited<ReturnType<T>>> {\n    const { onFailedResponseHook } = this;\n    return this.queue.add(\n      () =>\n        pRetry(\n          () =>\n            callable(...(args as Parameters<T>)).catch(async (error) => {\n              // eslint-disable-next-line no-instanceof/no-instanceof\n              if (error instanceof Error) {\n                throw error;\n              } else if (isResponse(error)) {\n                throw await HTTPError.fromResponse(error, {\n                  includeResponse: !!onFailedResponseHook,\n                });\n              } else {\n                throw new Error(error);\n              }\n            }),\n          {\n            async onFailedAttempt(error) {\n              if (\n                error.message.startsWith(\"Cancel\") ||\n                error.message.startsWith(\"TimeoutError\") ||\n                error.message.startsWith(\"AbortError\")\n              ) {\n                throw error;\n              }\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              if ((error as any)?.code === \"ECONNABORTED\") {\n                throw error;\n              }\n\n              // eslint-disable-next-line no-instanceof/no-instanceof\n              if (error instanceof HTTPError) {\n                if (STATUS_NO_RETRY.includes(error.status)) {\n                  throw error;\n                }\n                if (onFailedResponseHook && error.response) {\n                  await onFailedResponseHook(error.response);\n                }\n              }\n            },\n            // If needed we can change some of the defaults here,\n            // but they're quite sensible.\n            retries: this.maxRetries,\n            randomize: true,\n          }\n        ),\n      { throwOnTimeout: true }\n    );\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(\n    options: AsyncCallerCallOptions,\n    callable: T,\n    ...args: Parameters<T>\n  ): Promise<Awaited<ReturnType<T>>> {\n    // Note this doesn't cancel the underlying request,\n    // when available prefer to use the signal option of the underlying call\n    if (options.signal) {\n      return Promise.race([\n        this.call<A, T>(callable, ...args),\n        new Promise<never>((_, reject) => {\n          options.signal?.addEventListener(\"abort\", () => {\n            reject(new Error(\"AbortError\"));\n          });\n        }),\n      ]);\n    }\n    return this.call<A, T>(callable, ...args);\n  }\n\n  fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch> {\n    const fetchFn =\n      this.customFetch ?? (_getFetchImplementation() as typeof fetch);\n    return this.call(() =>\n      fetchFn(...args).then((res) => (res.ok ? res : Promise.reject(res)))\n    );\n  }\n}\n"],"mappings":";;;;;;AAIA,MAAM,kBAAkB;CACtB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;;;;;;AAmCF,SAAS,WAAW,GAA2B;AAC7C,KAAI,KAAK,QAAQ,OAAO,MAAM,SAAU,QAAO;AAC/C,QAAO,YAAY,KAAK,gBAAgB,KAAK,UAAU;;;;;AAMzD,IAAM,YAAN,MAAM,kBAAkB,MAAM;CAC5B;CAEA;CAEA;CAEA,YAAY,QAAgB,SAAiB,UAAqB;AAChE,QAAM,QAAQ,OAAO,IAAI;AACzB,OAAK,SAAS;AACd,OAAK,OAAO;AACZ,OAAK,WAAW;;CAGlB,aAAa,aACX,UACA,SACoB;AACpB,MAAI;AACF,UAAO,IAAI,UACT,SAAS,QACT,MAAM,SAAS,QACf,SAAS,kBAAkB,WAAW;UAElC;AACN,UAAO,IAAI,UACT,SAAS,QACT,SAAS,YACT,SAAS,kBAAkB,WAAW;;;;;;;;;;;;;;;;;AAmB9C,IAAa,cAAb,MAAyB;CACvB,AAAU;CAEV,AAAU;CAEV,AAAQ;CAER,AAAQ;CAER,AAAQ;CAER,YAAY,QAA2B;AACrC,OAAK,iBAAiB,OAAO,kBAAkB;AAC/C,OAAK,aAAa,OAAO,cAAc;AAEvC,MAAI,aAAaA,gBAEf,MAAK,QAAQ,IAAKA,gBAAU,QAAgB,EAC1C,aAAa,KAAK;MAIpB,MAAK,QAAQ,IAAKA,gBAAkB,EAAE,aAAa,KAAK;AAE1D,OAAK,uBAAuB,QAAQ;AACpC,OAAK,cAAc,OAAO;;CAI5B,KACE,UACA,GAAG,MAC8B;EACjC,MAAM,EAAE,yBAAyB;AACjC,SAAO,KAAK,MAAM,qCAIV,SAAS,GAAI,MAAwB,MAAM,OAAO,UAAU;AAE1D,OAAI,iBAAiB,MACnB,OAAM;YACG,WAAW,OACpB,OAAM,MAAM,UAAU,aAAa,OAAO,EACxC,iBAAiB,CAAC,CAAC;OAGrB,OAAM,IAAI,MAAM;MAGtB;GACE,MAAM,gBAAgB,OAAO;AAC3B,QACE,MAAM,QAAQ,WAAW,aACzB,MAAM,QAAQ,WAAW,mBACzB,MAAM,QAAQ,WAAW,cAEzB,OAAM;AAGR,QAAK,OAAe,SAAS,eAC3B,OAAM;AAIR,QAAI,iBAAiB,WAAW;AAC9B,SAAI,gBAAgB,SAAS,MAAM,QACjC,OAAM;AAER,SAAI,wBAAwB,MAAM,SAChC,OAAM,qBAAqB,MAAM;;;GAMvC,SAAS,KAAK;GACd,WAAW;MAGjB,EAAE,gBAAgB;;CAKtB,gBACE,SACA,UACA,GAAG,MAC8B;AAGjC,MAAI,QAAQ,OACV,QAAO,QAAQ,KAAK,CAClB,KAAK,KAAW,UAAU,GAAG,OAC7B,IAAI,SAAgB,GAAG,WAAW;AAChC,WAAQ,QAAQ,iBAAiB,eAAe;AAC9C,2BAAO,IAAI,MAAM;;;AAKzB,SAAO,KAAK,KAAW,UAAU,GAAG;;CAGtC,MAAM,GAAG,MAA0D;EACjE,MAAM,UACJ,KAAK,eAAgBC;AACvB,SAAO,KAAK,WACV,QAAQ,GAAG,MAAM,MAAM,QAAS,IAAI,KAAK,MAAM,QAAQ,OAAO"}

package/dist/utils/async_caller.d.cts

@@ -0,0 +1,53 @@
+//#region src/utils/async_caller.d.ts
+type ResponseCallback = (response?: Response) => Promise<boolean>;
+interface AsyncCallerParams {
+  /**
+   * The maximum number of concurrent calls that can be made.
+   * Defaults to `Infinity`, which means no limit.
+   */
+  maxConcurrency?: number;
+  /**
+   * The maximum number of retries that can be made for a single call,
+   * with an exponential backoff between each attempt. Defaults to 6.
+   */
+  maxRetries?: number;
+  onFailedResponseHook?: ResponseCallback;
+  /**
+   * Specify a custom fetch implementation.
+   *
+   * By default we expect the `fetch` is available in the global scope.
+   */
+  fetch?: typeof fetch | ((...args: any[]) => any); // eslint-disable-line @typescript-eslint/no-explicit-any
+}
+interface AsyncCallerCallOptions {
+  signal?: AbortSignal;
+}
+/**
+ * A class that can be used to make async calls with concurrency and retry logic.
+ *
+ * This is useful for making calls to any kind of "expensive" external resource,
+ * be it because it's rate-limited, subject to network issues, etc.
+ *
+ * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
+ * to `Infinity`. This means that by default, all calls will be made in parallel.
+ *
+ * Retries are limited by the `maxRetries` parameter, which defaults to 5. This
+ * means that by default, each call will be retried up to 5 times, with an
+ * exponential backoff between each attempt.
+ */
+declare class AsyncCaller {
+  protected maxConcurrency: AsyncCallerParams["maxConcurrency"];
+  protected maxRetries: AsyncCallerParams["maxRetries"];
+  private queue;
+  private onFailedResponseHook?;
+  private customFetch?;
+  constructor(params: AsyncCallerParams);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
+  fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;
+}
+//#endregion
+export { AsyncCaller, AsyncCallerParams };
+//# sourceMappingURL=async_caller.d.cts.map

package/dist/utils/async_caller.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async_caller.d.cts","names":["ResponseCallback","Response","Promise","AsyncCallerParams","fetch","AsyncCallerCallOptions","AbortSignal","AsyncCaller","A","T","Parameters","ReturnType","Awaited"],"sources":["../../src/utils/async_caller.d.ts"],"sourcesContent":["type ResponseCallback = (response?: Response) => Promise<boolean>;\nexport interface AsyncCallerParams {\n    /**\n     * The maximum number of concurrent calls that can be made.\n     * Defaults to `Infinity`, which means no limit.\n     */\n    maxConcurrency?: number;\n    /**\n     * The maximum number of retries that can be made for a single call,\n     * with an exponential backoff between each attempt. Defaults to 6.\n     */\n    maxRetries?: number;\n    onFailedResponseHook?: ResponseCallback;\n    /**\n     * Specify a custom fetch implementation.\n     *\n     * By default we expect the `fetch` is available in the global scope.\n     */\n    fetch?: typeof fetch | ((...args: any[]) => any); // eslint-disable-line @typescript-eslint/no-explicit-any\n}\nexport interface AsyncCallerCallOptions {\n    signal?: AbortSignal;\n}\n/**\n * A class that can be used to make async calls with concurrency and retry logic.\n *\n * This is useful for making calls to any kind of \"expensive\" external resource,\n * be it because it's rate-limited, subject to network issues, etc.\n *\n * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults\n * to `Infinity`. This means that by default, all calls will be made in parallel.\n *\n * Retries are limited by the `maxRetries` parameter, which defaults to 5. This\n * means that by default, each call will be retried up to 5 times, with an\n * exponential backoff between each attempt.\n */\nexport declare class AsyncCaller {\n    protected maxConcurrency: AsyncCallerParams[\"maxConcurrency\"];\n    protected maxRetries: AsyncCallerParams[\"maxRetries\"];\n    private queue;\n    private onFailedResponseHook?;\n    private customFetch?;\n    constructor(params: AsyncCallerParams);\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;\n}\nexport {};\n"],"mappings":";KAAKA,gBAAAA,eAA+BC,aAAaC;AAA5CF,UACYG,iBAAAA,CADI;EAAA;;;;EACJA,cAAAA,CAAAA,EAAAA,MAAiB;EAAA;;;;EAmBjBE,UAAAA,CAAAA,EAAAA,MAAAA;EAgBIE,oBAAW,CAAA,EAxBLP,gBAwBK;EAAA;;;;;OAQoBE,CAAAA,EAAAA,OA1BjCE,KA0BiCF,GAAAA,CAAAA,CAAAA,GAAAA,IAAAA,EAAAA,GAAAA,EAAAA,EAAAA,GAAAA,GAAAA,CAAAA,CAAAA,CAAAA;;AAA+CO,UAxBlFJ,sBAAAA,CAwBkFI;QAAXC,CAAAA,EAvB3EJ,WAuB2EI;;;;;;;;;;;;;;;AAGnDN,cAXhBG,WAAAA,CAWgBH;YAAlBM,cAAAA,EAVWP,iBAUXO,CAAAA,gBAAAA,CAAAA;YAA6CN,UAAAA,EATtCD,iBASsCC,CAAAA,YAAAA,CAAAA;UAAlBO,KAAAA;;;sBALtBR;;4CAEsBK,MAAMN,wBAAwBO,YAAYC,WAAWD,KAAKP,QAAQU,QAAQD,WAAWF;;uDAE1ED,MAAMN,uBAAuBG,kCAAkCI,YAAYC,WAAWD,KAAKP,QAAQU,QAAQD,WAAWF;iBAC5JC,kBAAkBN,SAASO,kBAAkBP"}