promptfoo 0.125.0 → 0.125.1

package/dist/src/cache-iG87oYan.cjs

@@ -0,0 +1,856 @@
+const require_rolldown_runtime = require("./rolldown-runtime-C0BPl7ul.cjs");
+const require_logger = require("./logger-DXUHJBHJ.cjs");
+const require_fetch = require("./fetch-BKlgUg08.cjs");
+const require_shared = require("./shared-D9Bf3UgD.cjs");
+const require_time = require("./time-CY7bOv6D.cjs");
+const require_createHash = require("./createHash-sm6Q6LWg.cjs");
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path, 1);
+let node_async_hooks = require("node:async_hooks");
+let fs = require("fs");
+fs = require_rolldown_runtime.__toESM(fs, 1);
+let node_crypto = require("node:crypto");
+node_crypto = require_rolldown_runtime.__toESM(node_crypto, 1);
+let cache_manager = require("cache-manager");
+let node_events = require("node:events");
+let keyv = require("keyv");
+let keyv_file = require("keyv-file");
+//#region src/cache/storage.ts
+function isEnvelope(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && (!("expires" in value) || value.expires === void 0 || typeof value.expires === "number");
+}
+var DiskStore = class extends node_events.EventEmitter {
+	backend;
+	opts = {};
+	namespace;
+	constructor(backend) {
+		super();
+		this.backend = backend;
+	}
+	async get(key) {
+		const raw = await this.backend.getRaw(key);
+		return typeof raw === "string" ? this.backend.decode(raw) : raw;
+	}
+	async set(key, value) {
+		if (!isEnvelope(value)) throw new TypeError("Cache storage requires a value/expiry envelope");
+		return this.backend.setRaw(key, value);
+	}
+	async delete(key) {
+		return this.backend.delete(key);
+	}
+	async clear() {
+		await this.backend.clear();
+	}
+	async disconnect() {
+		await this.backend.disconnect();
+	}
+};
+/** Preserve cache-manager's Keyv 5 API while storing data through Keyv 6. */
+function createDiskCache(filename, ttl) {
+	const backend = new keyv.Keyv(new keyv.KeyvBridgeAdapter(new keyv_file.KeyvFile({ filename })));
+	const cache = (0, cache_manager.createCache)({
+		ttl,
+		refreshThreshold: 0
+	});
+	const facade = cache.stores[0];
+	const store = new DiskStore(backend);
+	facade.ttl = ttl;
+	facade.store = store;
+	facade.iterator = async function* () {
+		const prefix = facade.useKeyPrefix && facade.namespace ? `${facade.namespace}:` : "";
+		for await (const [key, value] of backend.iterator()) if (!prefix || key.startsWith(prefix)) yield [prefix ? key.slice(prefix.length) : key, value];
+	};
+	return cache;
+}
+//#endregion
+//#region src/cache.ts
+var cache_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	claimCacheKeyOnce: () => claimCacheKeyOnce,
+	clearCache: () => clearCache,
+	disableCache: () => disableCache,
+	enableCache: () => enableCache,
+	fetchWithCache: () => fetchWithCache,
+	getAbortSignalScopedKey: () => getAbortSignalScopedKey,
+	getCache: () => getCache,
+	getCacheClearGeneration: () => getCacheClearGeneration,
+	getCacheTtlMs: () => getCacheTtlMs,
+	getHeadersForCacheKey: () => getHeadersForCacheKey,
+	getScopedCacheKey: () => getScopedCacheKey,
+	isCacheEnabled: () => isCacheEnabled,
+	withCacheEnabled: () => withCacheEnabled,
+	withCacheNamespace: () => withCacheNamespace
+});
+let cacheInstance;
+const namespacedCacheInstances = /* @__PURE__ */ new Map();
+let cacheClearGeneration = 0;
+const CACHE_ENABLED_CONTEXT = Symbol.for("promptfoo.cache.enabledContext.v1");
+const CACHE_NAMESPACE_CONTEXT = Symbol.for("promptfoo.cache.namespaceContext.v1");
+const cacheContextGlobal = globalThis;
+const cacheEnabledStorage = cacheContextGlobal[CACHE_ENABLED_CONTEXT] ??= new node_async_hooks.AsyncLocalStorage();
+const cacheNamespaceStorage = cacheContextGlobal[CACHE_NAMESPACE_CONTEXT] ??= new node_async_hooks.AsyncLocalStorage();
+let enabled = require_logger.getEnvBool("PROMPTFOO_CACHE_ENABLED", true);
+const cacheType = require_logger.getEnvString("PROMPTFOO_CACHE_TYPE") || (require_logger.getEnvString("NODE_ENV") === "test" ? "memory" : "disk");
+/** Default cache TTL: 14 days in seconds */
+const DEFAULT_CACHE_TTL_SECONDS = 1209600;
+/**
+* Get the cache TTL in milliseconds.
+* Reads from PROMPTFOO_CACHE_TTL environment variable (in seconds) or uses default.
+*/
+function getCacheTtlMs() {
+	return require_logger.getEnvInt("PROMPTFOO_CACHE_TTL", DEFAULT_CACHE_TTL_SECONDS) * 1e3;
+}
+/**
+* Get the cache instance with optional namespace isolation.
+*
+* @returns The current cache instance (namespace-aware if inside withCacheNamespace)
+*
+* @example
+* ```typescript
+* import { cache } from 'promptfoo';
+*
+* const cacheInstance = cache.getCache();
+* const value = await cacheInstance.get('my-key');
+* ```
+*/
+function getCache() {
+	const namespace = cacheNamespaceStorage.getStore()?.namespace;
+	if (namespace) return getNamespacedCache(namespace);
+	return getCacheInstance();
+}
+function getCacheInstance() {
+	if (!cacheInstance) {
+		let cachePath = "";
+		let diskCache;
+		if (cacheType === "disk" && enabled) {
+			cachePath = require_logger.getEnvString("PROMPTFOO_CACHE_PATH") || path.default.join(require_logger.getConfigDirectoryPath(), "cache");
+			if (!fs.default.existsSync(cachePath)) {
+				require_logger.logger.info(`Creating cache folder at ${cachePath}.`);
+				fs.default.mkdirSync(cachePath, { recursive: true });
+			}
+			const newCacheFile = path.default.join(cachePath, "cache.json");
+			try {
+				diskCache = createDiskCache(newCacheFile, getCacheTtlMs());
+			} catch (err) {
+				require_logger.logger.warn(`[Cache] Failed to initialize disk cache: ${err.message}. Using memory cache instead.`);
+			}
+		}
+		cacheInstance = diskCache ?? (0, cache_manager.createCache)({
+			ttl: getCacheTtlMs(),
+			refreshThreshold: 0
+		});
+		const clear = cacheInstance.clear.bind(cacheInstance);
+		cacheInstance.clear = async () => {
+			const result = await clear();
+			cacheClearGeneration += 1;
+			return result;
+		};
+	}
+	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 currentNamespaceIncludesRepeatIndex(repeatIndex) {
+	const namespaceParts = getCurrentCacheNamespace()?.split(":") ?? [];
+	return namespaceParts.some((part, index) => part === "repeat" && namespaceParts[index + 1] === String(repeatIndex));
+}
+function shouldApplyRepeatCacheSuffix(repeatIndex) {
+	return repeatIndex != null && repeatIndex > 0 && !currentNamespaceIncludesRepeatIndex(repeatIndex);
+}
+function getScopedCacheKey(cacheKey, namespace = getCurrentCacheNamespace()) {
+	return namespace ? `${namespace}:${cacheKey}` : cacheKey;
+}
+function getCacheClearGeneration() {
+	return cacheClearGeneration;
+}
+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}`);
+		}
+	}
+	cacheClearGeneration += 1;
+	return true;
+}
+/**
+* Run a function with isolated cache namespace.
+*
+* All cache operations within the function will be scoped to the namespace,
+* preventing cache collisions between different test runs or environments.
+*
+* @param namespace Namespace prefix for cache keys (undefined = no namespace)
+* @param fn Async function to run with the namespace
+*
+* @returns Result of the function
+*
+* @example
+* ```typescript
+* import { cache, evaluate } from 'promptfoo';
+*
+* // Run v1 and v2 evals with separate caches
+* const v1Results = await cache.withCacheNamespace('v1', async () => {
+*   return evaluate(testSuiteV1);
+* });
+*
+* const v2Results = await cache.withCacheNamespace('v2', async () => {
+*   return evaluate(testSuiteV2);
+* });
+* ```
+*/
+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);
+}
+function withCacheEnabled(enabledOverride, fn) {
+	if (enabledOverride === void 0) return fn();
+	return cacheEnabledStorage.run({ enabled: enabledOverride }, fn);
+}
+function getEffectiveCacheEnabled() {
+	return cacheEnabledStorage.getStore()?.enabled ?? enabled;
+}
+const inflightFetchResponses = /* @__PURE__ */ new Map();
+const claimedCacheKeys = /* @__PURE__ */ new Set();
+const IGNORED_FETCH_CACHE_OPTION_KEYS = /* @__PURE__ */ new Set(["method", "signal"]);
+const IGNORED_FETCH_CACHE_HEADERS = /* @__PURE__ */ new Set(["traceparent", "tracestate"]);
+const FETCH_CACHE_SECRET_HMAC_CONTEXT = "promptfoo:fetch-cache-secret-key";
+const FETCH_CACHE_SECRET_HMAC_SALT = "promptfoo:fetch-cache-secret-hmac-salt:v1";
+const abortSignalIds = /* @__PURE__ */ new WeakMap();
+let nextAbortSignalId = 0;
+function fingerprintFetchCacheSecret(value) {
+	return { __promptfooSecretFingerprint: node_crypto.default.createHmac("sha256", FETCH_CACHE_SECRET_HMAC_SALT).update(FETCH_CACHE_SECRET_HMAC_CONTEXT).update("\0").update(value).digest("hex") };
+}
+function isSensitiveFetchCacheString(value, fieldName) {
+	return fieldName && require_logger.isSecretField(fieldName) || require_logger.looksLikeSecret(value);
+}
+function getStringForFetchCacheKey(value, fieldName) {
+	if (isSensitiveFetchCacheString(value, fieldName)) return fingerprintFetchCacheSecret(value);
+	return value;
+}
+function hasSensitiveJsonValue(value, fieldName) {
+	if (typeof value === "string") return isSensitiveFetchCacheString(value, fieldName);
+	if (Array.isArray(value)) return value.some((item) => hasSensitiveJsonValue(item, fieldName));
+	if (value && typeof value === "object") return Object.entries(value).some(([key, nestedValue]) => hasSensitiveJsonValue(nestedValue, key));
+	return false;
+}
+function getJsonValueForFetchCacheKey(value, fieldName) {
+	if (typeof value === "string") return getStringForFetchCacheKey(value, fieldName);
+	if (Array.isArray(value)) return value.map((item) => getJsonValueForFetchCacheKey(item, fieldName));
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [key, getJsonValueForFetchCacheKey(nestedValue, key)]));
+	return value;
+}
+function getBodyStringForFetchCacheKey(value) {
+	try {
+		const parsedValue = JSON.parse(value);
+		return hasSensitiveJsonValue(parsedValue) ? {
+			encoding: "json",
+			value: getJsonValueForFetchCacheKey(parsedValue)
+		} : value;
+	} catch {
+		return getStringForFetchCacheKey(value);
+	}
+}
+function hasSensitiveSearchParam(searchParams) {
+	return Array.from(searchParams.entries()).some(([name, value]) => isSensitiveFetchCacheString(value, name));
+}
+function getSearchParamsForFetchCacheKey(searchParams) {
+	if (!hasSensitiveSearchParam(searchParams)) return searchParams.toString();
+	return Array.from(searchParams.entries()).map(([name, value]) => [name, getStringForFetchCacheKey(value, name)]);
+}
+function getUrlForFetchCacheKey(url) {
+	const urlString = url instanceof Request ? url.url : String(url);
+	try {
+		const parsedUrl = new URL(urlString);
+		if (!hasSensitiveSearchParam(parsedUrl.searchParams)) return urlString;
+		parsedUrl.search = "";
+		return {
+			href: parsedUrl.toString(),
+			searchParams: getSearchParamsForFetchCacheKey(new URL(urlString).searchParams)
+		};
+	} catch {
+		return getStringForFetchCacheKey(urlString);
+	}
+}
+function getHeadersForCacheKey(url, options) {
+	const headers = new Headers(require_fetch.getFetchWithProxyHeaders(url, options));
+	const cloudAuth = require_fetch.getCloudBearerToken(url);
+	let cloudAuthHeaderNameForFingerprint;
+	if (cloudAuth) {
+		const cloudAuthHeaderName = require_fetch.getCloudAuthHeaderName();
+		cloudAuthHeaderNameForFingerprint = cloudAuthHeaderName.toLowerCase();
+		if (!headers.has(cloudAuthHeaderName)) headers.set(cloudAuthHeaderName, cloudAuth);
+	}
+	const cloudTaskTeamId = require_fetch.getCloudTaskTeamId(url);
+	if (cloudTaskTeamId && !headers.has("x-promptfoo-team-id")) headers.set(require_fetch.PROMPTFOO_TEAM_ID_HEADER, cloudTaskTeamId);
+	return Array.from(headers.entries()).filter(([name]) => !IGNORED_FETCH_CACHE_HEADERS.has(name)).sort(([nameA, valueA], [nameB, valueB]) => {
+		const nameComparison = nameA.localeCompare(nameB);
+		return nameComparison === 0 ? valueA.localeCompare(valueB) : nameComparison;
+	}).map(([name, value]) => [name, name === cloudAuthHeaderNameForFingerprint ? fingerprintFetchCacheSecret(value) : getStringForFetchCacheKey(value, name)]);
+}
+function hashFetchCacheKey(identity) {
+	return require_createHash.sha256(JSON.stringify(identity));
+}
+function hashBytesForCacheKey(bytes) {
+	const buffer = ArrayBuffer.isView(bytes) ? Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength) : Buffer.from(bytes);
+	return {
+		byteLength: buffer.byteLength,
+		hmacSha256: node_crypto.default.createHmac("sha256", FETCH_CACHE_SECRET_HMAC_SALT).update(`${FETCH_CACHE_SECRET_HMAC_CONTEXT}:bytes`).update("\0").update(buffer).digest("hex")
+	};
+}
+function getBodyForFetchCacheKey(body) {
+	if (body == null) return {
+		cacheable: true,
+		identity: void 0
+	};
+	if (typeof body === "string") return {
+		cacheable: true,
+		identity: {
+			type: "string",
+			value: getBodyStringForFetchCacheKey(body)
+		}
+	};
+	if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) return {
+		cacheable: true,
+		identity: {
+			type: "url-search-params",
+			value: getSearchParamsForFetchCacheKey(body)
+		}
+	};
+	if (body instanceof ArrayBuffer) return {
+		cacheable: true,
+		identity: {
+			type: "array-buffer",
+			...hashBytesForCacheKey(body)
+		}
+	};
+	if (ArrayBuffer.isView(body)) return {
+		cacheable: true,
+		identity: {
+			type: body.constructor.name,
+			...hashBytesForCacheKey(body)
+		}
+	};
+	return {
+		cacheable: false,
+		identity: void 0
+	};
+}
+function getOptionsForFetchCacheKey(options, bodyIdentity) {
+	const identity = {};
+	for (const [key, value] of Object.entries(options).sort(([keyA], [keyB]) => keyA.localeCompare(keyB))) {
+		if (key === "headers" || IGNORED_FETCH_CACHE_OPTION_KEYS.has(key)) continue;
+		if (key === "body") {
+			identity.body = bodyIdentity;
+			continue;
+		}
+		if (value == null || [
+			"boolean",
+			"number",
+			"string"
+		].includes(typeof value)) {
+			identity[key] = value;
+			continue;
+		}
+		return {
+			cacheable: false,
+			identity: void 0
+		};
+	}
+	if (!Object.prototype.hasOwnProperty.call(options, "body") && bodyIdentity !== void 0) identity.body = bodyIdentity;
+	return {
+		cacheable: true,
+		identity
+	};
+}
+function getFetchCacheKey(url, options, method, format, repeatIndex) {
+	const bodyForCacheKey = getBodyForFetchCacheKey(options.body ?? (url instanceof Request ? url.body : void 0));
+	if (!bodyForCacheKey.cacheable) return null;
+	const optionsForCacheKey = getOptionsForFetchCacheKey(options, bodyForCacheKey.identity);
+	if (!optionsForCacheKey.cacheable) return null;
+	const repeatSuffix = shouldApplyRepeatCacheSuffix(repeatIndex) ? `:repeat${repeatIndex}` : "";
+	return getScopedCacheKey(`fetch:v3:${hashFetchCacheKey({
+		format,
+		headers: getHeadersForCacheKey(url, options),
+		method,
+		options: optionsForCacheKey.identity,
+		url: getUrlForFetchCacheKey(url)
+	})}${repeatSuffix}`);
+}
+/** Key in-flight requests by abort signal so only callers cancelled together share one. */
+function getAbortSignalScopedKey(key, signal) {
+	if (!signal) return JSON.stringify([key, null]);
+	let signalId = abortSignalIds.get(signal);
+	if (signalId === void 0) {
+		signalId = ++nextAbortSignalId;
+		abortSignalIds.set(signal, signalId);
+	}
+	return JSON.stringify([key, signalId]);
+}
+/**
+* Atomically claim a cache-scoped one-time action. Disk-backed claims use an exclusive file so
+* separate eval processes cannot both attribute the same background response's usage.
+*/
+function claimCacheKeyOnce(cacheKey) {
+	const scopedCacheKey = getScopedCacheKey(cacheKey);
+	if (claimedCacheKeys.has(scopedCacheKey)) return false;
+	if (cacheType === "disk" && getEffectiveCacheEnabled()) {
+		const cachePath = require_logger.getEnvString("PROMPTFOO_CACHE_PATH") || path.default.join(require_logger.getConfigDirectoryPath(), "cache");
+		const claimsPath = path.default.join(cachePath, "claims");
+		try {
+			fs.default.mkdirSync(claimsPath, { recursive: true });
+			const handle = fs.default.openSync(path.default.join(claimsPath, require_createHash.sha256(scopedCacheKey)), "wx");
+			fs.default.closeSync(handle);
+		} catch (error) {
+			if (error.code === "EEXIST") {
+				claimedCacheKeys.add(scopedCacheKey);
+				return false;
+			}
+			require_logger.logger.warn(`[Cache] Failed to persist a one-time cache claim: ${error.message}. Using a process-local claim instead.`);
+		}
+	}
+	claimedCacheKeys.add(scopedCacheKey);
+	return true;
+}
+function getSanitizedResponse(data, statusText, headers, sanitizeResponse) {
+	return sanitizeResponse ? sanitizeResponse({
+		data,
+		statusText,
+		headers: { ...headers }
+	}) : {
+		data,
+		statusText,
+		headers
+	};
+}
+function serializeFetchResponse(data, status, statusText, headers, latencyMs, sanitizeResponse) {
+	const sanitized = getSanitizedResponse(data, statusText, headers, sanitizeResponse);
+	return JSON.stringify({
+		data: sanitized.data,
+		status,
+		statusText: sanitized.statusText,
+		headers: sanitized.headers,
+		latencyMs
+	});
+}
+function deserializeFetchResponse(response, cached, cache, cacheKey, sanitizeResponse) {
+	const parsedResponse = JSON.parse(response);
+	const sanitized = getSanitizedResponse(parsedResponse.data, parsedResponse.statusText, parsedResponse.headers, sanitizeResponse);
+	return {
+		cached,
+		data: sanitized.data,
+		status: parsedResponse.status,
+		statusText: sanitized.statusText,
+		headers: sanitized.headers,
+		latencyMs: parsedResponse.latencyMs,
+		deleteFromCache: async () => {
+			await cache.del(cacheKey);
+			require_logger.logger.debug(`Evicted from cache: ${cacheKey}`);
+		},
+		updateCache: async (data, status, statusText, headers) => {
+			await cache.set(cacheKey, serializeFetchResponse(data, status, statusText, headers ?? {}, parsedResponse.latencyMs, sanitizeResponse));
+			require_logger.logger.debug(`Updated cached response: ${cacheKey}`);
+		}
+	};
+}
+async function fetchAndReadBody(url, options, timeout, maxRetries, isIdempotent, logEnabled, onRateLimitBackoff) {
+	const retryBudget = Math.max(0, maxRetries ?? require_fetch.getFetchRetryContextMaxRetries() ?? 2);
+	const maxBodyRetries = isIdempotent ? Math.min(2, retryBudget) : 0;
+	for (let bodyAttempt = 0; bodyAttempt <= maxBodyRetries; bodyAttempt++) {
+		const fetchStart = Date.now();
+		const resp = await require_fetch.fetchWithRetries(url, options, timeout, maxRetries, onRateLimitBackoff);
+		const fetchLatencyMs = Date.now() - fetchStart;
+		try {
+			return {
+				respText: await resp.text(),
+				resp,
+				fetchLatencyMs
+			};
+		} catch (err) {
+			if (!options.signal?.aborted && require_fetch.isTransientConnectionError(err) && bodyAttempt < maxBodyRetries) {
+				const backoffMs = Math.pow(2, bodyAttempt) * 1e3;
+				if (logEnabled) require_logger.logger.debug("[Cache] Body stream failed with transient error, retrying", {
+					attempt: bodyAttempt + 1,
+					maxRetries: maxBodyRetries,
+					backoffMs,
+					error: err?.message?.slice(0, 200)
+				});
+				await require_shared.waitForPromiseWithAbort(require_time.sleep(backoffMs), options.signal);
+				require_shared.throwIfAborted(options.signal);
+				continue;
+			}
+			if (require_fetch.isAbortError(err)) throw err;
+			const wrappedError = /* @__PURE__ */ new Error(`Error reading response body from ${require_logger.sanitizeUrlForLogging(require_fetch.getRequestUrlString(url))}: ${err.message}. HTTP ${resp.status} ${resp.statusText}`);
+			wrappedError.cause = err;
+			throw wrappedError;
+		}
+	}
+	throw new Error("Exhausted body retries without returning or throwing");
+}
+function parseFetchResponse(url, response, responseText, format, sanitizeResponse) {
+	try {
+		return format === "json" ? JSON.parse(responseText) : responseText;
+	} catch (err) {
+		const message = `Error parsing response from ${require_logger.sanitizeUrlForLogging(require_fetch.getRequestUrlString(url))}:`;
+		if (sanitizeResponse) throw new Error(`${message} Invalid JSON. HTTP ${response.status}.`);
+		throw new Error(`${message} ${err.message}. HTTP ${response.status} ${response.statusText}. Received text: ${responseText}`);
+	}
+}
+async function prepareFetchResponse(url, options, timeout, maxRetries, isIdempotent, format, logEnabled, sanitizeResponse, onRateLimitBackoff) {
+	const result = await fetchAndReadBody(url, options, timeout, maxRetries, isIdempotent, logEnabled, onRateLimitBackoff);
+	const response = result.resp;
+	const responseText = result.respText;
+	const fetchLatencyMs = result.fetchLatencyMs;
+	const parsedData = parseFetchResponse(url, response, responseText, format, sanitizeResponse);
+	const responseError = format === "json" && parsedData !== null && typeof parsedData === "object" && "error" in parsedData ? parsedData.error : void 0;
+	const serializedResponse = serializeFetchResponse(!response.ok && responseText === "" ? `Empty Response: ${response.status}: ${response.statusText}` : parsedData, response.status, response.statusText, Object.fromEntries(response.headers.entries()), fetchLatencyMs, sanitizeResponse);
+	if (!response.ok) return {
+		response: serializedResponse,
+		cacheable: false
+	};
+	if (responseError) {
+		if (logEnabled) require_logger.logger.debug(`Not caching ${require_logger.sanitizeUrlForLogging(require_fetch.getRequestUrlString(url))} because it contains an 'error' key: ${sanitizeResponse ? serializedResponse : responseError}`);
+		return {
+			response: serializedResponse,
+			cacheable: false
+		};
+	}
+	if (logEnabled) require_logger.logger.debug(`Storing ${require_logger.sanitizeUrlForLogging(require_fetch.getRequestUrlString(url))} response in cache with latencyMs=${fetchLatencyMs}: ${serializedResponse}`);
+	return {
+		response: serializedResponse,
+		cacheable: true
+	};
+}
+/**
+* Fetch a URL with automatic caching.
+*
+* Caches HTTP responses with configurable TTL. Useful for fetching external
+* data files, embeddings, or API responses that don't change frequently.
+*
+* @param url URL to fetch
+* @param options Fetch options (method, headers, body, etc.)
+* @param timeout Request timeout in milliseconds (default: standard timeout)
+* @param format Response format: 'json' or 'text' (default: 'json')
+* @param bustOrOptions Bypass cache or provide cache options for this request
+* @param maxRetries Maximum number of retries on transient errors
+* @param onResponsePrepared Observe each caller's fresh, fully read response before waiting for cache publication
+* @param onRateLimitBackoff Observe this request's selected live fetch backoff before its wait
+*
+* @returns FetchWithCacheResult with data, cache status, and HTTP metadata
+*
+* @example
+* ```typescript
+* import { cache } from 'promptfoo';
+*
+* // Fetch with 1-hour TTL
+* const result = await cache.fetchWithCache(
+*   'https://api.example.com/data',
+*   { method: 'GET' },
+*   undefined,
+*   'json'
+* );
+*
+* console.log(result.cached); // true if from cache
+* console.log(result.data); // the fetched data
+* console.log(result.status); // HTTP status code
+* ```
+*
+* @see withCacheNamespace for cache isolation
+* @see enableCache / disableCache for cache control
+*/
+async function fetchWithCache(url, options = {}, timeout = require_shared.getRequestTimeoutMs(), format = "json", bustOrOptions = false, maxRetries, onResponsePrepared, onRateLimitBackoff) {
+	const signal = require_shared.getEffectiveRequestSignal(url, options);
+	require_shared.throwIfAborted(signal);
+	const fetchOptions = require_fetch.preserveCloudAuthRedirects(url, signal === options.signal ? options : {
+		...options,
+		signal
+	});
+	const { bust = false, repeatIndex, cacheKey: providedCacheKey, sanitizeResponse } = typeof bustOrOptions === "boolean" ? { bust: bustOrOptions } : bustOrOptions ?? {};
+	const logEnabled = new Headers(require_fetch.getFetchWithProxyHeaders(url, fetchOptions)).get("x-promptfoo-silent") !== "true";
+	const method = (fetchOptions.method ?? (url instanceof Request ? url.method : "GET")).toUpperCase();
+	const isIdempotent = [
+		"GET",
+		"HEAD",
+		"OPTIONS",
+		"PUT",
+		"DELETE"
+	].includes(method);
+	const cacheEnabled = getEffectiveCacheEnabled();
+	if (cacheEnabled && !bust && fetchOptions.getAuthHeaders && !providedCacheKey) throw new Error("Request-time authentication requires cache bypass or an explicit principal-scoped cache key.");
+	if (cacheEnabled && !bust && sanitizeResponse && !providedCacheKey) throw new Error("Response sanitization requires cache bypass or an explicit cache key identifying the sanitizer policy.");
+	const repeatSuffix = shouldApplyRepeatCacheSuffix(repeatIndex) ? `:repeat${repeatIndex}` : "";
+	const providedKeyPrefix = fetchOptions.restrictCloudAuthRedirects ? "fetch:cloud-auth:v3" : "fetch:v3";
+	const cacheKey = cacheEnabled && !bust ? providedCacheKey ? getScopedCacheKey(`${providedKeyPrefix}:${providedCacheKey}${repeatSuffix}`) : getFetchCacheKey(url, fetchOptions, method, format, repeatIndex) : null;
+	let notifyRateLimitBackoff;
+	const observerFailure = onRateLimitBackoff ? new Promise((_resolve, reject) => {
+		let failed = false;
+		notifyRateLimitBackoff = (observation) => {
+			if (failed) return;
+			try {
+				onRateLimitBackoff(observation);
+			} catch (error) {
+				failed = true;
+				reject(error);
+			}
+		};
+	}) : void 0;
+	observerFailure?.catch(() => void 0);
+	if (!cacheEnabled || bust || cacheKey == null) {
+		const response = fetchAndReadBody(url, fetchOptions, timeout, maxRetries, isIdempotent, logEnabled, notifyRateLimitBackoff);
+		const { respText, resp, fetchLatencyMs } = await (observerFailure ? Promise.race([response, observerFailure]) : response);
+		const sanitized = getSanitizedResponse(parseFetchResponse(url, resp, respText, format, sanitizeResponse), resp.statusText, Object.fromEntries(resp.headers.entries()), sanitizeResponse);
+		const result = {
+			cached: false,
+			data: sanitized.data,
+			status: resp.status,
+			statusText: sanitized.statusText,
+			headers: sanitized.headers,
+			latencyMs: fetchLatencyMs,
+			deleteFromCache: async () => {}
+		};
+		onResponsePrepared?.(result);
+		return result;
+	}
+	const cache = getCacheInstance();
+	const cachedResponse = await require_shared.waitForPromiseWithAbort(cache.get(cacheKey), signal);
+	require_shared.throwIfAborted(signal);
+	if (cachedResponse != null) {
+		const result = deserializeFetchResponse(cachedResponse, true, cache, cacheKey, sanitizeResponse);
+		if (logEnabled) {
+			const loggedResponse = sanitizeResponse ? serializeFetchResponse(result.data, result.status, result.statusText, result.headers, result.latencyMs) : cachedResponse;
+			require_logger.logger.debug(`Returning cached response for ${require_logger.sanitizeUrlForLogging(require_fetch.getRequestUrlString(url))}: ${loggedResponse}`);
+		}
+		return result;
+	}
+	const inflightCacheKey = getAbortSignalScopedKey(cacheKey, signal);
+	let inflightResponse = inflightFetchResponses.get(inflightCacheKey);
+	const coalesced = inflightResponse !== void 0;
+	if (!inflightResponse) {
+		const rateLimitBackoff = { observers: /* @__PURE__ */ new Set() };
+		const response = prepareFetchResponse(url, fetchOptions, timeout, maxRetries, isIdempotent, format, logEnabled, sanitizeResponse, (observation) => {
+			rateLimitBackoff.latest = observation;
+			for (const observer of rateLimitBackoff.observers) observer(observation);
+		});
+		const publication = response.then(async (preparedResponse) => {
+			if (preparedResponse.cacheable) await cache.set(cacheKey, preparedResponse.response);
+		}).finally(() => {
+			inflightFetchResponses.delete(inflightCacheKey);
+		});
+		publication.catch(() => void 0);
+		inflightResponse = {
+			response,
+			publication,
+			rateLimitBackoff
+		};
+		inflightFetchResponses.set(inflightCacheKey, inflightResponse);
+	}
+	if (notifyRateLimitBackoff) {
+		inflightResponse.rateLimitBackoff.observers.add(notifyRateLimitBackoff);
+		const latest = inflightResponse.rateLimitBackoff.latest;
+		if (latest && latest.resetAt > Date.now()) notifyRateLimitBackoff(latest);
+	}
+	try {
+		const { response, cacheable } = await (observerFailure ? Promise.race([inflightResponse.response, observerFailure]) : inflightResponse.response);
+		const result = deserializeFetchResponse(response, false, cache, cacheKey, sanitizeResponse);
+		if (coalesced) result.coalesced = true;
+		onResponsePrepared?.(result);
+		if (cacheable) {
+			await require_shared.waitForPromiseWithAbort(inflightResponse.publication, signal);
+			require_shared.throwIfAborted(signal);
+		} else await inflightResponse.publication;
+		return result;
+	} finally {
+		if (notifyRateLimitBackoff) inflightResponse.rateLimitBackoff.observers.delete(notifyRateLimitBackoff);
+	}
+}
+/**
+* Enable caching for all provider calls (default behavior).
+*
+* @example
+* ```typescript
+* import { cache } from 'promptfoo';
+* cache.enableCache();
+* ```
+*/
+function enableCache() {
+	enabled = true;
+}
+/**
+* Disable caching. Provider calls will hit the API every time.
+*
+* Useful during development or testing when you want fresh results.
+*
+* @example
+* ```typescript
+* import { cache, evaluate } from 'promptfoo';
+*
+* cache.disableCache();
+* const results = await evaluate(testSuite);  // Always fresh
+* cache.enableCache();
+* ```
+*/
+function disableCache() {
+	enabled = false;
+}
+/**
+* Clear all cached results.
+*
+* Removes all cached provider responses. The cache will refetch on next access.
+*
+* @example
+* ```typescript
+* import { cache, evaluate } from 'promptfoo';
+*
+* await cache.clearCache();
+* const results = await evaluate(testSuite);  // Refetches all
+* ```
+*/
+async function clearCache() {
+	inflightFetchResponses.clear();
+	namespacedCacheInstances.clear();
+	const result = await getCacheInstance().clear();
+	claimedCacheKeys.clear();
+	if (cacheType === "disk") {
+		const cachePath = require_logger.getEnvString("PROMPTFOO_CACHE_PATH") || path.default.join(require_logger.getConfigDirectoryPath(), "cache");
+		fs.default.rmSync(path.default.join(cachePath, "claims"), {
+			force: true,
+			recursive: true
+		});
+	}
+	return result;
+}
+/**
+* Check if caching is currently enabled.
+*
+* @returns true if cache is enabled, false otherwise
+*
+* @example
+* ```typescript
+* import { cache } from 'promptfoo';
+*
+* if (cache.isCacheEnabled()) {
+*   console.log('Cache is active');
+* }
+* ```
+*/
+function isCacheEnabled() {
+	return getEffectiveCacheEnabled();
+}
+//#endregion
+Object.defineProperty(exports, "cache_exports", {
+	enumerable: true,
+	get: function() {
+		return cache_exports;
+	}
+});
+Object.defineProperty(exports, "claimCacheKeyOnce", {
+	enumerable: true,
+	get: function() {
+		return claimCacheKeyOnce;
+	}
+});
+Object.defineProperty(exports, "disableCache", {
+	enumerable: true,
+	get: function() {
+		return disableCache;
+	}
+});
+Object.defineProperty(exports, "fetchWithCache", {
+	enumerable: true,
+	get: function() {
+		return fetchWithCache;
+	}
+});
+Object.defineProperty(exports, "getAbortSignalScopedKey", {
+	enumerable: true,
+	get: function() {
+		return getAbortSignalScopedKey;
+	}
+});
+Object.defineProperty(exports, "getCache", {
+	enumerable: true,
+	get: function() {
+		return getCache;
+	}
+});
+Object.defineProperty(exports, "getCacheClearGeneration", {
+	enumerable: true,
+	get: function() {
+		return getCacheClearGeneration;
+	}
+});
+Object.defineProperty(exports, "getCacheTtlMs", {
+	enumerable: true,
+	get: function() {
+		return getCacheTtlMs;
+	}
+});
+Object.defineProperty(exports, "getScopedCacheKey", {
+	enumerable: true,
+	get: function() {
+		return getScopedCacheKey;
+	}
+});
+Object.defineProperty(exports, "isCacheEnabled", {
+	enumerable: true,
+	get: function() {
+		return isCacheEnabled;
+	}
+});
+Object.defineProperty(exports, "withCacheEnabled", {
+	enumerable: true,
+	get: function() {
+		return withCacheEnabled;
+	}
+});
+Object.defineProperty(exports, "withCacheNamespace", {
+	enumerable: true,
+	get: function() {
+		return withCacheNamespace;
+	}
+});
+
+//# sourceMappingURL=cache-iG87oYan.cjs.map