promptfoo 0.121.2 → 0.121.4

package/dist/src/cache-D5NZmMiT.js

@@ -0,0 +1,310 @@
+import { t as __exportAll } from "./chunk-DEq-mXcV.js";
+import { S as getEnvBool, T as getEnvString, a as logger, w as getEnvInt, x as getConfigDirectoryPath } from "./logger-Ct2S6Yx-.js";
+import { d as sleep, h as REQUEST_TIMEOUT_MS, n as fetchWithRetries } from "./fetch-Di00EQrc.js";
+import fs from "fs";
+import path from "path";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createCache } from "cache-manager";
+import { Keyv } from "keyv";
+import { KeyvFile } from "keyv-file";
+//#region src/util/fetch/errors.ts
+/**
+* Non-transient HTTP status codes that indicate the target is unavailable or misconfigured.
+* These errors will not resolve on retry and should abort the scan immediately.
+*
+* - 401: Unauthorized - authentication required or invalid credentials
+* - 403: Forbidden - valid credentials but access denied
+* - 404: Not Found - target endpoint doesn't exist
+* - 501: Not Implemented - server doesn't support the request method
+*
+* Excluded: 500 (often transient — server crashes, DB timeouts, deployment rollouts,
+* or input-dependent bugs where one prompt triggers it but the next doesn't),
+* 502/503/504 (typically transient gateway issues).
+*/
+const NON_TRANSIENT_HTTP_STATUSES = [
+	401,
+	403,
+	404,
+	501
+];
+function isNonTransientHttpStatus(status) {
+	return NON_TRANSIENT_HTTP_STATUSES.includes(status);
+}
+function isTransientConnectionError(error) {
+	if (!error) return false;
+	const code = error.code;
+	if (code === "ECONNRESET" || code === "EPIPE") return true;
+	const message = (error.message ?? "").toLowerCase();
+	if (message.includes("eproto") && (message.includes("wrong version number") || message.includes("self signed") || message.includes("unable to verify") || message.includes("unknown ca") || message.includes("cert"))) return false;
+	return message.includes("bad record mac") || message.includes("eproto") || message.includes("econnreset") || message.includes("socket hang up");
+}
+//#endregion
+//#region src/cache.ts
+var cache_exports = /* @__PURE__ */ __exportAll({
+	clearCache: () => clearCache,
+	disableCache: () => disableCache,
+	enableCache: () => enableCache,
+	fetchWithCache: () => fetchWithCache,
+	getCache: () => getCache,
+	isCacheEnabled: () => isCacheEnabled,
+	withCacheNamespace: () => withCacheNamespace
+});
+let cacheInstance;
+const namespacedCacheInstances = /* @__PURE__ */ new Map();
+const cacheNamespaceStorage = new AsyncLocalStorage();
+let enabled = getEnvBool("PROMPTFOO_CACHE_ENABLED", true);
+const cacheType = getEnvString("PROMPTFOO_CACHE_TYPE") || (getEnvString("NODE_ENV") === "test" ? "memory" : "disk");
+/** Default cache TTL: 14 days in seconds */
+const DEFAULT_CACHE_TTL_SECONDS = 3600 * 24 * 14;
+/**
+* Get the cache TTL in milliseconds.
+* Reads from PROMPTFOO_CACHE_TTL environment variable (in seconds) or uses default.
+*/
+function getCacheTtlMs() {
+	return getEnvInt("PROMPTFOO_CACHE_TTL", DEFAULT_CACHE_TTL_SECONDS) * 1e3;
+}
+function getCache() {
+	const namespace = cacheNamespaceStorage.getStore()?.namespace;
+	if (namespace) return getNamespacedCache(namespace);
+	return getCacheInstance();
+}
+function getCacheInstance() {
+	if (!cacheInstance) {
+		let cachePath = "";
+		const stores = [];
+		if (cacheType === "disk" && enabled) {
+			cachePath = getEnvString("PROMPTFOO_CACHE_PATH") || path.join(getConfigDirectoryPath(), "cache");
+			if (!fs.existsSync(cachePath)) {
+				logger.info(`Creating cache folder at ${cachePath}.`);
+				fs.mkdirSync(cachePath, { recursive: true });
+			}
+			const newCacheFile = path.join(cachePath, "cache.json");
+			try {
+				const keyv = new Keyv({
+					store: new KeyvFile({ filename: newCacheFile }),
+					ttl: getCacheTtlMs()
+				});
+				stores.push(keyv);
+			} catch (err) {
+				logger.warn(`[Cache] Failed to initialize disk cache: ${err.message}. Using memory cache instead.`);
+			}
+		}
+		cacheInstance = createCache({
+			stores,
+			ttl: getCacheTtlMs(),
+			refreshThreshold: 0
+		});
+	}
+	return cacheInstance;
+}
+function getNamespacedCache(namespace) {
+	const cachedNamespaceInstance = namespacedCacheInstances.get(namespace);
+	if (cachedNamespaceInstance) return cachedNamespaceInstance;
+	const cache = getCacheInstance();
+	const namespacedCache = {
+		...cache,
+		get: (key) => cache.get(getScopedCacheKey(key, namespace)),
+		set: (key, value, ttl) => cache.set(getScopedCacheKey(key, namespace), value, ttl),
+		del: (key) => cache.del(getScopedCacheKey(key, namespace)),
+		mget: (keys) => cache.mget(keys.map((key) => getScopedCacheKey(key, namespace))),
+		mset: async (list) => {
+			const scopedList = list.map(({ key, value, ttl }) => ({
+				key: getScopedCacheKey(key, namespace),
+				value,
+				ttl
+			}));
+			return (await cache.mset(scopedList) ?? scopedList).map(({ key, value, ttl }) => ({
+				key: getUnscopedCacheKey(key, namespace),
+				value,
+				ttl
+			}));
+		},
+		mdel: (keys) => cache.mdel(keys.map((key) => getScopedCacheKey(key, namespace))),
+		ttl: (key) => cache.ttl(getScopedCacheKey(key, namespace)),
+		clear: () => clearNamespacedCache(cache, namespace),
+		wrap: (...args) => cache.wrap(getScopedCacheKey(args[0], namespace), ...args.slice(1))
+	};
+	namespacedCacheInstances.set(namespace, namespacedCache);
+	return namespacedCache;
+}
+function getCurrentCacheNamespace() {
+	return cacheNamespaceStorage.getStore()?.namespace;
+}
+function getScopedCacheKey(cacheKey, namespace = getCurrentCacheNamespace()) {
+	return namespace ? `${namespace}:${cacheKey}` : cacheKey;
+}
+function getUnscopedCacheKey(cacheKey, namespace) {
+	const namespacePrefix = `${namespace}:`;
+	return cacheKey.startsWith(namespacePrefix) ? cacheKey.slice(namespacePrefix.length) : cacheKey;
+}
+async function clearNamespacedCache(cache, namespace) {
+	const namespacePrefix = `${namespace}:`;
+	for (const store of cache.stores) {
+		if (!store.iterator) throw new Error(`[Cache] Cannot clear namespace ${namespace} because a cache store does not support key iteration.`);
+		const keysToDelete = [];
+		for await (const [key] of store.iterator(void 0)) if (typeof key === "string" && key.startsWith(namespacePrefix)) keysToDelete.push(key);
+		if (keysToDelete.length === 0) continue;
+		try {
+			if (store.deleteMany) await store.deleteMany(keysToDelete);
+			else await Promise.all(keysToDelete.map((key) => store.delete(key)));
+		} catch (err) {
+			throw new Error(`[Cache] Failed to clear ${keysToDelete.length} keys for namespace "${namespace}": ${err.message}`);
+		}
+	}
+	return true;
+}
+function withCacheNamespace(namespace, fn) {
+	if (!namespace) return fn();
+	const parentNamespace = getCurrentCacheNamespace();
+	if (parentNamespace === namespace) return fn();
+	const scopedNamespace = parentNamespace ? `${parentNamespace}:${namespace}` : namespace;
+	return cacheNamespaceStorage.run({ namespace: scopedNamespace }, fn);
+}
+const inflightFetchResponses = /* @__PURE__ */ new Map();
+function serializeFetchResponse(data, status, statusText, headers, latencyMs) {
+	return JSON.stringify({
+		data,
+		status,
+		statusText,
+		headers,
+		latencyMs
+	});
+}
+function deserializeFetchResponse(response, cached, cache, cacheKey) {
+	const parsedResponse = JSON.parse(response);
+	return {
+		cached,
+		data: parsedResponse.data,
+		status: parsedResponse.status,
+		statusText: parsedResponse.statusText,
+		headers: parsedResponse.headers,
+		latencyMs: parsedResponse.latencyMs,
+		deleteFromCache: async () => {
+			await cache.del(cacheKey);
+			logger.debug(`Evicted from cache: ${cacheKey}`);
+		}
+	};
+}
+async function fetchAndReadBody(url, options, timeout, maxRetries, isIdempotent) {
+	const maxBodyRetries = isIdempotent ? 2 : 0;
+	for (let bodyAttempt = 0; bodyAttempt <= maxBodyRetries; bodyAttempt++) {
+		const fetchStart = Date.now();
+		const resp = await fetchWithRetries(url, options, timeout, maxRetries);
+		const fetchLatencyMs = Date.now() - fetchStart;
+		try {
+			return {
+				respText: await resp.text(),
+				resp,
+				fetchLatencyMs
+			};
+		} catch (err) {
+			if (isTransientConnectionError(err) && bodyAttempt < maxBodyRetries) {
+				const backoffMs = Math.pow(2, bodyAttempt) * 1e3;
+				logger.debug("[Cache] Body stream failed with transient error, retrying", {
+					attempt: bodyAttempt + 1,
+					maxRetries: maxBodyRetries,
+					backoffMs,
+					error: err?.message?.slice(0, 200)
+				});
+				await sleep(backoffMs);
+				continue;
+			}
+			throw err;
+		}
+	}
+	throw new Error("Exhausted body retries without returning or throwing");
+}
+async function prepareFetchResponse(url, options, timeout, maxRetries, isIdempotent, format) {
+	const result = await fetchAndReadBody(url, options, timeout, maxRetries, isIdempotent);
+	const response = result.resp;
+	const responseText = result.respText;
+	const fetchLatencyMs = result.fetchLatencyMs;
+	const headers = Object.fromEntries(response.headers.entries());
+	try {
+		const parsedData = format === "json" ? JSON.parse(responseText) : responseText;
+		const serializedResponse = serializeFetchResponse(parsedData, response.status, response.statusText, headers, fetchLatencyMs);
+		if (!response.ok) return {
+			response: responseText === "" ? serializeFetchResponse(`Empty Response: ${response.status}: ${response.statusText}`, response.status, response.statusText, headers, fetchLatencyMs) : serializedResponse,
+			cacheable: false
+		};
+		if (format === "json" && parsedData?.error) {
+			logger.debug(`Not caching ${url} because it contains an 'error' key: ${parsedData.error}`);
+			return {
+				response: serializedResponse,
+				cacheable: false
+			};
+		}
+		logger.debug(`Storing ${url} response in cache with latencyMs=${fetchLatencyMs}: ${serializedResponse}`);
+		return {
+			response: serializedResponse,
+			cacheable: true
+		};
+	} catch (err) {
+		throw new Error(`Error parsing response from ${url}: ${err.message}. Received text: ${responseText}`);
+	}
+}
+async function fetchWithCache(url, options = {}, timeout = REQUEST_TIMEOUT_MS, format = "json", bust = false, maxRetries) {
+	const method = (options.method ?? (url instanceof Request ? url.method : "GET")).toUpperCase();
+	const isIdempotent = [
+		"GET",
+		"HEAD",
+		"OPTIONS",
+		"PUT",
+		"DELETE"
+	].includes(method);
+	if (!enabled || bust) {
+		const { respText, resp, fetchLatencyMs } = await fetchAndReadBody(url, options, timeout, maxRetries, isIdempotent);
+		try {
+			return {
+				cached: false,
+				data: format === "json" ? JSON.parse(respText) : respText,
+				status: resp.status,
+				statusText: resp.statusText,
+				headers: Object.fromEntries(resp.headers.entries()),
+				latencyMs: fetchLatencyMs,
+				deleteFromCache: async () => {}
+			};
+		} catch {
+			throw new Error(`Error parsing response as JSON: ${respText}`);
+		}
+	}
+	const copy = Object.assign({}, options);
+	delete copy.headers;
+	const cacheKey = getScopedCacheKey(`fetch:v2:${url}:${JSON.stringify(copy)}`);
+	const cache = getCacheInstance();
+	const cachedResponse = await cache.get(cacheKey);
+	if (cachedResponse != null) {
+		logger.debug(`Returning cached response for ${url}: ${cachedResponse}`);
+		return deserializeFetchResponse(cachedResponse, true, cache, cacheKey);
+	}
+	let inflightResponse = inflightFetchResponses.get(cacheKey);
+	if (!inflightResponse) {
+		inflightResponse = (async () => {
+			const preparedResponse = await prepareFetchResponse(url, options, timeout, maxRetries, isIdempotent, format);
+			if (preparedResponse.cacheable) await cache.set(cacheKey, preparedResponse.response);
+			return preparedResponse.response;
+		})().finally(() => {
+			inflightFetchResponses.delete(cacheKey);
+		});
+		inflightFetchResponses.set(cacheKey, inflightResponse);
+	}
+	return deserializeFetchResponse(await inflightResponse, false, cache, cacheKey);
+}
+function enableCache() {
+	enabled = true;
+}
+function disableCache() {
+	enabled = false;
+}
+async function clearCache() {
+	inflightFetchResponses.clear();
+	namespacedCacheInstances.clear();
+	return getCacheInstance().clear();
+}
+function isCacheEnabled() {
+	return enabled;
+}
+//#endregion
+export { isCacheEnabled as a, isNonTransientHttpStatus as c, getCache as i, isTransientConnectionError as l, disableCache as n, withCacheNamespace as o, fetchWithCache as r, NON_TRANSIENT_HTTP_STATUSES as s, cache_exports as t };
+
+//# sourceMappingURL=cache-D5NZmMiT.js.map

package/dist/src/cache-DbLsVWB2.cjs

@@ -0,0 +1,3 @@
+const require_cache = require("./cache-BIyPcp5v.cjs");
+exports.getCache = require_cache.getCache;
+exports.isCacheEnabled = require_cache.isCacheEnabled;

package/dist/src/cache-mb7c8hbp.js

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+import { t as __exportAll } from "./chunk-DRamLcfz.js";
+import { C as getConfigDirectoryPath, D as getEnvInt, O as getEnvString, T as getEnvBool, s as logger } from "./logger-DksKw1Qc.js";
+import { l as sleep, m as REQUEST_TIMEOUT_MS, r as fetchWithRetries } from "./fetch-BEWnXrrG.js";
+import { r as isTransientConnectionError } from "./errors-Cw810C93.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import fs from "fs";
+import path from "path";
+import { createCache } from "cache-manager";
+import { Keyv } from "keyv";
+import { KeyvFile } from "keyv-file";
+//#region src/cache.ts
+var cache_exports = /* @__PURE__ */ __exportAll({
+	clearCache: () => clearCache,
+	disableCache: () => disableCache,
+	enableCache: () => enableCache,
+	fetchWithCache: () => fetchWithCache,
+	getCache: () => getCache,
+	isCacheEnabled: () => isCacheEnabled,
+	withCacheNamespace: () => withCacheNamespace
+});
+let cacheInstance;
+const namespacedCacheInstances = /* @__PURE__ */ new Map();
+const cacheNamespaceStorage = new AsyncLocalStorage();
+let enabled = getEnvBool("PROMPTFOO_CACHE_ENABLED", true);
+const cacheType = getEnvString("PROMPTFOO_CACHE_TYPE") || (getEnvString("NODE_ENV") === "test" ? "memory" : "disk");
+/** Default cache TTL: 14 days in seconds */
+const DEFAULT_CACHE_TTL_SECONDS = 3600 * 24 * 14;
+/**
+* Get the cache TTL in milliseconds.
+* Reads from PROMPTFOO_CACHE_TTL environment variable (in seconds) or uses default.
+*/
+function getCacheTtlMs() {
+	return getEnvInt("PROMPTFOO_CACHE_TTL", DEFAULT_CACHE_TTL_SECONDS) * 1e3;
+}
+function getCache() {
+	const namespace = cacheNamespaceStorage.getStore()?.namespace;
+	if (namespace) return getNamespacedCache(namespace);
+	return getCacheInstance();
+}
+function getCacheInstance() {
+	if (!cacheInstance) {
+		let cachePath = "";
+		const stores = [];
+		if (cacheType === "disk" && enabled) {
+			cachePath = getEnvString("PROMPTFOO_CACHE_PATH") || path.join(getConfigDirectoryPath(), "cache");
+			if (!fs.existsSync(cachePath)) {
+				logger.info(`Creating cache folder at ${cachePath}.`);
+				fs.mkdirSync(cachePath, { recursive: true });
+			}
+			const newCacheFile = path.join(cachePath, "cache.json");
+			try {
+				const keyv = new Keyv({
+					store: new KeyvFile({ filename: newCacheFile }),
+					ttl: getCacheTtlMs()
+				});
+				stores.push(keyv);
+			} catch (err) {
+				logger.warn(`[Cache] Failed to initialize disk cache: ${err.message}. Using memory cache instead.`);
+			}
+		}
+		cacheInstance = createCache({
+			stores,
+			ttl: getCacheTtlMs(),
+			refreshThreshold: 0
+		});
+	}
+	return cacheInstance;
+}
+function getNamespacedCache(namespace) {
+	const cachedNamespaceInstance = namespacedCacheInstances.get(namespace);
+	if (cachedNamespaceInstance) return cachedNamespaceInstance;
+	const cache = getCacheInstance();
+	const namespacedCache = {
+		...cache,
+		get: (key) => cache.get(getScopedCacheKey(key, namespace)),
+		set: (key, value, ttl) => cache.set(getScopedCacheKey(key, namespace), value, ttl),
+		del: (key) => cache.del(getScopedCacheKey(key, namespace)),
+		mget: (keys) => cache.mget(keys.map((key) => getScopedCacheKey(key, namespace))),
+		mset: async (list) => {
+			const scopedList = list.map(({ key, value, ttl }) => ({
+				key: getScopedCacheKey(key, namespace),
+				value,
+				ttl
+			}));
+			return (await cache.mset(scopedList) ?? scopedList).map(({ key, value, ttl }) => ({
+				key: getUnscopedCacheKey(key, namespace),
+				value,
+				ttl
+			}));
+		},
+		mdel: (keys) => cache.mdel(keys.map((key) => getScopedCacheKey(key, namespace))),
+		ttl: (key) => cache.ttl(getScopedCacheKey(key, namespace)),
+		clear: () => clearNamespacedCache(cache, namespace),
+		wrap: (...args) => cache.wrap(getScopedCacheKey(args[0], namespace), ...args.slice(1))
+	};
+	namespacedCacheInstances.set(namespace, namespacedCache);
+	return namespacedCache;
+}
+function getCurrentCacheNamespace() {
+	return cacheNamespaceStorage.getStore()?.namespace;
+}
+function getScopedCacheKey(cacheKey, namespace = getCurrentCacheNamespace()) {
+	return namespace ? `${namespace}:${cacheKey}` : cacheKey;
+}
+function getUnscopedCacheKey(cacheKey, namespace) {
+	const namespacePrefix = `${namespace}:`;
+	return cacheKey.startsWith(namespacePrefix) ? cacheKey.slice(namespacePrefix.length) : cacheKey;
+}
+async function clearNamespacedCache(cache, namespace) {
+	const namespacePrefix = `${namespace}:`;
+	for (const store of cache.stores) {
+		if (!store.iterator) throw new Error(`[Cache] Cannot clear namespace ${namespace} because a cache store does not support key iteration.`);
+		const keysToDelete = [];
+		for await (const [key] of store.iterator(void 0)) if (typeof key === "string" && key.startsWith(namespacePrefix)) keysToDelete.push(key);
+		if (keysToDelete.length === 0) continue;
+		try {
+			if (store.deleteMany) await store.deleteMany(keysToDelete);
+			else await Promise.all(keysToDelete.map((key) => store.delete(key)));
+		} catch (err) {
+			throw new Error(`[Cache] Failed to clear ${keysToDelete.length} keys for namespace "${namespace}": ${err.message}`);
+		}
+	}
+	return true;
+}
+function withCacheNamespace(namespace, fn) {
+	if (!namespace) return fn();
+	const parentNamespace = getCurrentCacheNamespace();
+	if (parentNamespace === namespace) return fn();
+	const scopedNamespace = parentNamespace ? `${parentNamespace}:${namespace}` : namespace;
+	return cacheNamespaceStorage.run({ namespace: scopedNamespace }, fn);
+}
+const inflightFetchResponses = /* @__PURE__ */ new Map();
+function serializeFetchResponse(data, status, statusText, headers, latencyMs) {
+	return JSON.stringify({
+		data,
+		status,
+		statusText,
+		headers,
+		latencyMs
+	});
+}
+function deserializeFetchResponse(response, cached, cache, cacheKey) {
+	const parsedResponse = JSON.parse(response);
+	return {
+		cached,
+		data: parsedResponse.data,
+		status: parsedResponse.status,
+		statusText: parsedResponse.statusText,
+		headers: parsedResponse.headers,
+		latencyMs: parsedResponse.latencyMs,
+		deleteFromCache: async () => {
+			await cache.del(cacheKey);
+			logger.debug(`Evicted from cache: ${cacheKey}`);
+		}
+	};
+}
+async function fetchAndReadBody(url, options, timeout, maxRetries, isIdempotent) {
+	const maxBodyRetries = isIdempotent ? 2 : 0;
+	for (let bodyAttempt = 0; bodyAttempt <= maxBodyRetries; bodyAttempt++) {
+		const fetchStart = Date.now();
+		const resp = await fetchWithRetries(url, options, timeout, maxRetries);
+		const fetchLatencyMs = Date.now() - fetchStart;
+		try {
+			return {
+				respText: await resp.text(),
+				resp,
+				fetchLatencyMs
+			};
+		} catch (err) {
+			if (isTransientConnectionError(err) && bodyAttempt < maxBodyRetries) {
+				const backoffMs = Math.pow(2, bodyAttempt) * 1e3;
+				logger.debug("[Cache] Body stream failed with transient error, retrying", {
+					attempt: bodyAttempt + 1,
+					maxRetries: maxBodyRetries,
+					backoffMs,
+					error: err?.message?.slice(0, 200)
+				});
+				await sleep(backoffMs);
+				continue;
+			}
+			throw err;
+		}
+	}
+	throw new Error("Exhausted body retries without returning or throwing");
+}
+async function prepareFetchResponse(url, options, timeout, maxRetries, isIdempotent, format) {
+	const result = await fetchAndReadBody(url, options, timeout, maxRetries, isIdempotent);
+	const response = result.resp;
+	const responseText = result.respText;
+	const fetchLatencyMs = result.fetchLatencyMs;
+	const headers = Object.fromEntries(response.headers.entries());
+	try {
+		const parsedData = format === "json" ? JSON.parse(responseText) : responseText;
+		const serializedResponse = serializeFetchResponse(parsedData, response.status, response.statusText, headers, fetchLatencyMs);
+		if (!response.ok) return {
+			response: responseText === "" ? serializeFetchResponse(`Empty Response: ${response.status}: ${response.statusText}`, response.status, response.statusText, headers, fetchLatencyMs) : serializedResponse,
+			cacheable: false
+		};
+		if (format === "json" && parsedData?.error) {
+			logger.debug(`Not caching ${url} because it contains an 'error' key: ${parsedData.error}`);
+			return {
+				response: serializedResponse,
+				cacheable: false
+			};
+		}
+		logger.debug(`Storing ${url} response in cache with latencyMs=${fetchLatencyMs}: ${serializedResponse}`);
+		return {
+			response: serializedResponse,
+			cacheable: true
+		};
+	} catch (err) {
+		throw new Error(`Error parsing response from ${url}: ${err.message}. Received text: ${responseText}`);
+	}
+}
+async function fetchWithCache(url, options = {}, timeout = REQUEST_TIMEOUT_MS, format = "json", bust = false, maxRetries) {
+	const method = (options.method ?? (url instanceof Request ? url.method : "GET")).toUpperCase();
+	const isIdempotent = [
+		"GET",
+		"HEAD",
+		"OPTIONS",
+		"PUT",
+		"DELETE"
+	].includes(method);
+	if (!enabled || bust) {
+		const { respText, resp, fetchLatencyMs } = await fetchAndReadBody(url, options, timeout, maxRetries, isIdempotent);
+		try {
+			return {
+				cached: false,
+				data: format === "json" ? JSON.parse(respText) : respText,
+				status: resp.status,
+				statusText: resp.statusText,
+				headers: Object.fromEntries(resp.headers.entries()),
+				latencyMs: fetchLatencyMs,
+				deleteFromCache: async () => {}
+			};
+		} catch {
+			throw new Error(`Error parsing response as JSON: ${respText}`);
+		}
+	}
+	const copy = Object.assign({}, options);
+	delete copy.headers;
+	const cacheKey = getScopedCacheKey(`fetch:v2:${url}:${JSON.stringify(copy)}`);
+	const cache = getCacheInstance();
+	const cachedResponse = await cache.get(cacheKey);
+	if (cachedResponse != null) {
+		logger.debug(`Returning cached response for ${url}: ${cachedResponse}`);
+		return deserializeFetchResponse(cachedResponse, true, cache, cacheKey);
+	}
+	let inflightResponse = inflightFetchResponses.get(cacheKey);
+	if (!inflightResponse) {
+		inflightResponse = (async () => {
+			const preparedResponse = await prepareFetchResponse(url, options, timeout, maxRetries, isIdempotent, format);
+			if (preparedResponse.cacheable) await cache.set(cacheKey, preparedResponse.response);
+			return preparedResponse.response;
+		})().finally(() => {
+			inflightFetchResponses.delete(cacheKey);
+		});
+		inflightFetchResponses.set(cacheKey, inflightResponse);
+	}
+	return deserializeFetchResponse(await inflightResponse, false, cache, cacheKey);
+}
+function enableCache() {
+	enabled = true;
+}
+function disableCache() {
+	enabled = false;
+}
+async function clearCache() {
+	inflightFetchResponses.clear();
+	namespacedCacheInstances.clear();
+	return getCacheInstance().clear();
+}
+function isCacheEnabled() {
+	return enabled;
+}
+//#endregion
+export { fetchWithCache as a, withCacheNamespace as c, enableCache as i, clearCache as n, getCache as o, disableCache as r, isCacheEnabled as s, cache_exports as t };
+
+//# sourceMappingURL=cache-mb7c8hbp.js.map

package/dist/src/{chat-C2jrdPMx.js → chat-0bwXjVP0.js}

@@ -1,16 +1,6 @@
-import { i as logger } from "./logger-DLcq4dWf.js";
-import "./fetch-HaqdX7U1.js";
+import { a as logger } from "./logger-B88EkIn6.js";
 import { t as invariant } from "./invariant-vgHWClmd.js";
-import "./esm-CaIwzWR5.js";
-import "./types-CzW2QFyi.js";
-import "./cache-i1P6crbO.js";
-import "./genaiTracer-70Z8BIuV.js";
-import "./pythonUtils-D6fwaDSg.js";
-import "./util-ZzmqNPlg.js";
-import { t as OpenAiChatCompletionProvider } from "./chat-DJIw17u0.js";
-import "./transform-uAytVuyX.js";
-import "./openai-j-sE2O7r.js";
-import "./util-BV4XUC0n.js";
+import { t as OpenAiChatCompletionProvider } from "./chat-BfPaS15_.js";
 //#region src/providers/hyperbolic/chat.ts
 const HYPERBOLIC_CHAT_MODELS = [
 	{
@@ -296,4 +286,4 @@ function createHyperbolicProvider(providerPath, options = {}) {
 //#endregion
 export { createHyperbolicProvider };
 
-//# sourceMappingURL=chat-C2jrdPMx.js.map
+//# sourceMappingURL=chat-0bwXjVP0.js.map

package/dist/src/{chat-C1Qst7jL.cjs → chat-BPXSW8Bv.cjs}

@@ -1,16 +1,6 @@
-const require_logger = require("./logger-Cp1GPUjj.cjs");
+const require_logger = require("./logger-COuQb2xB.cjs");
 const require_invariant = require("./invariant-kfQ8Bu82.cjs");
-require("./esm-CnNt7sI4.cjs");
-require("./pythonUtils-CTU3Y3lw.cjs");
-require("./types-C_7nyzr1.cjs");
-require("./util-B9vlHIIh.cjs");
-require("./fetch-BPkYtG8K.cjs");
-require("./cache-Dh5WtQps.cjs");
-require("./genaiTracer-DN4dQywX.cjs");
-const require_chat = require("./chat-CgF-J-Jj.cjs");
-require("./transform-DuHvhZpj.cjs");
-require("./openai-Cuif0GEt.cjs");
-require("./util-BzMcevZc.cjs");
+const require_chat = require("./chat-CclRbxGf.cjs");
 //#region src/providers/hyperbolic/chat.ts
 const HYPERBOLIC_CHAT_MODELS = [
 	{
@@ -296,4 +286,4 @@ function createHyperbolicProvider(providerPath, options = {}) {
 //#endregion
 exports.createHyperbolicProvider = createHyperbolicProvider;
 
-//# sourceMappingURL=chat-C1Qst7jL.cjs.map
+//# sourceMappingURL=chat-BPXSW8Bv.cjs.map