promptfoo 0.120.26 → 0.121.1

package/dist/src/blobs-qTYm-1PY.js

@@ -0,0 +1,236 @@
+import { g as getConfigDirectoryPath, i as logger } from "./logger-DLcq4dWf.js";
+import { h as getDb, n as blobReferencesTable, t as blobAssetsTable } from "./tables-xKANLRBD.js";
+import * as fs$1 from "node:fs";
+import * as path$1 from "node:path";
+import * as fsPromises$1 from "node:fs/promises";
+import { and, eq } from "drizzle-orm";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/blobs/constants.ts
+const BLOB_MIN_SIZE = 1024;
+const BLOB_MAX_SIZE = 52428800;
+const BLOB_SCHEME = "promptfoo://blob/";
+const DEFAULT_FILESYSTEM_SUBDIR = "blobs";
+//#endregion
+//#region src/blobs/filesystemProvider.ts
+const BLOB_HASH_REGEX = /^[a-f0-9]{64}$/i;
+function computeHash(data) {
+	return createHash("sha256").update(data).digest("hex");
+}
+function buildUri(hash) {
+	return `${BLOB_SCHEME}${hash}`;
+}
+var FilesystemBlobStorageProvider = class {
+	providerId = "filesystem";
+	basePath;
+	constructor(config) {
+		const defaultBase = path$1.join(getConfigDirectoryPath(true), DEFAULT_FILESYSTEM_SUBDIR);
+		this.basePath = path$1.resolve(config?.basePath || defaultBase);
+		this.ensureDirectory();
+	}
+	ensureDirectory() {
+		if (!fs$1.existsSync(this.basePath)) {
+			fs$1.mkdirSync(this.basePath, { recursive: true });
+			logger.debug("[BlobFS] Created blob directory", { basePath: this.basePath });
+		}
+	}
+	assertValidHash(hash) {
+		if (!BLOB_HASH_REGEX.test(hash)) throw new Error(`[BlobFS] Invalid blob hash: "${hash}"`);
+	}
+	resolvePathInBase(unsafePath) {
+		const targetPath = path$1.isAbsolute(unsafePath) ? path$1.resolve(unsafePath) : path$1.resolve(this.basePath, unsafePath);
+		const safeBase = path$1.resolve(this.basePath) + path$1.sep;
+		if (!targetPath.startsWith(safeBase)) throw new Error("[BlobFS] Path traversal attempt detected");
+		return targetPath;
+	}
+	hashToPath(hash) {
+		this.assertValidHash(hash);
+		const dirRelative = path$1.join(hash.slice(0, 2), hash.slice(2, 4));
+		const fileRelative = path$1.join(dirRelative, hash);
+		return this.resolvePathInBase(fileRelative);
+	}
+	async ensureHashDir(hash) {
+		this.assertValidHash(hash);
+		const dirRelative = path$1.join(hash.slice(0, 2), hash.slice(2, 4));
+		const dirPath = this.resolvePathInBase(dirRelative);
+		await fsPromises$1.mkdir(dirPath, { recursive: true });
+	}
+	metadataPath(filePath) {
+		return `${filePath}.meta.json`;
+	}
+	async store(data, mimeType) {
+		const hash = computeHash(data);
+		await this.ensureHashDir(hash);
+		const filePath = this.hashToPath(hash);
+		try {
+			await fsPromises$1.access(filePath);
+			const meta = await this.readMetadata(filePath);
+			return {
+				ref: this.buildRef(hash, meta?.mimeType ?? mimeType, meta?.sizeBytes ?? data.length, meta?.provider ?? this.providerId),
+				deduplicated: true
+			};
+		} catch {}
+		await fsPromises$1.writeFile(filePath, data);
+		const metadata = {
+			mimeType,
+			sizeBytes: data.length,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			provider: this.providerId,
+			key: filePath
+		};
+		await fsPromises$1.writeFile(this.metadataPath(filePath), JSON.stringify(metadata, null, 2));
+		return {
+			ref: this.buildRef(hash, mimeType, data.length, this.providerId),
+			deduplicated: false
+		};
+	}
+	async getByHash(hash) {
+		const filePath = this.hashToPath(hash);
+		let data;
+		try {
+			data = await fsPromises$1.readFile(filePath);
+		} catch (error) {
+			if (error.code === "ENOENT") throw new Error(`Blob not found: ${hash}`);
+			throw error;
+		}
+		const metadata = await this.readMetadata(filePath) || {
+			mimeType: "application/octet-stream",
+			sizeBytes: data.length,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			provider: this.providerId,
+			key: filePath
+		};
+		return {
+			data,
+			metadata
+		};
+	}
+	async exists(hash) {
+		try {
+			const filePath = this.hashToPath(hash);
+			await fsPromises$1.access(filePath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async deleteByHash(hash) {
+		try {
+			const filePath = this.hashToPath(hash);
+			const metaPath = this.metadataPath(filePath);
+			try {
+				await fsPromises$1.unlink(filePath);
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+			try {
+				await fsPromises$1.unlink(metaPath);
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+		} catch {}
+	}
+	async getUrl(_hash, _expiresInSeconds) {
+		return null;
+	}
+	buildRef(hash, mimeType, sizeBytes, provider) {
+		return {
+			uri: buildUri(hash),
+			hash,
+			mimeType,
+			sizeBytes,
+			provider
+		};
+	}
+	async readMetadata(filePath) {
+		const safeFilePath = this.resolvePathInBase(filePath);
+		const metaPath = this.metadataPath(safeFilePath);
+		try {
+			const raw = await fsPromises$1.readFile(metaPath, "utf8");
+			return JSON.parse(raw);
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			logger.warn("[BlobFS] Failed to read metadata", { error });
+			return null;
+		}
+	}
+};
+//#endregion
+//#region src/blobs/index.ts
+let defaultProvider = null;
+function createDefaultProvider() {
+	return new FilesystemBlobStorageProvider();
+}
+function getBlobStorageProvider() {
+	if (!defaultProvider) {
+		defaultProvider = createDefaultProvider();
+		logger.debug("[BlobStorage] Initialized provider", { provider: defaultProvider.providerId });
+	}
+	return defaultProvider;
+}
+async function storeBlob(data, mimeType, refContext) {
+	const provider = getBlobStorageProvider();
+	const result = await provider.store(data, mimeType);
+	const db = getDb();
+	try {
+		db.transaction(() => {
+			const assetInsert = db.insert(blobAssetsTable).values({
+				hash: result.ref.hash,
+				sizeBytes: result.ref.sizeBytes,
+				mimeType: result.ref.mimeType,
+				provider: result.ref.provider
+			}).onConflictDoNothing().run();
+			return (refContext?.evalId && db.insert(blobReferencesTable).values({
+				id: randomUUID(),
+				blobHash: result.ref.hash,
+				evalId: refContext.evalId,
+				testIdx: refContext.testIdx,
+				promptIdx: refContext.promptIdx,
+				location: refContext.location,
+				kind: refContext.kind
+			}).onConflictDoNothing().run()) ?? assetInsert;
+		});
+	} catch (error) {
+		try {
+			await provider.deleteByHash(result.ref.hash);
+		} catch (cleanupError) {
+			logger.warn("[BlobStorage] Failed to rollback blob after DB error", {
+				error: cleanupError,
+				hash: result.ref.hash
+			});
+		}
+		throw error;
+	}
+	return result;
+}
+async function getBlobByHash(hash) {
+	return getBlobStorageProvider().getByHash(hash);
+}
+async function getBlobUrl(hash, expiresInSeconds) {
+	return getBlobStorageProvider().getUrl(hash, expiresInSeconds);
+}
+async function recordBlobReference(hash, refContext) {
+	if (!refContext.evalId) return;
+	if (!await getBlobStorageProvider().exists(hash).catch(() => false)) {
+		logger.debug("[BlobStorage] Attempted to record reference for missing blob", {
+			hash,
+			evalId: refContext.evalId,
+			location: refContext.location
+		});
+		return;
+	}
+	const db = getDb();
+	if (db.select({ id: blobReferencesTable.id }).from(blobReferencesTable).where(and(eq(blobReferencesTable.blobHash, hash), eq(blobReferencesTable.evalId, refContext.evalId))).get()) return;
+	db.insert(blobReferencesTable).values({
+		id: randomUUID(),
+		blobHash: hash,
+		evalId: refContext.evalId,
+		testIdx: refContext.testIdx,
+		promptIdx: refContext.promptIdx,
+		location: refContext.location,
+		kind: refContext.kind
+	}).run();
+}
+//#endregion
+export { BLOB_MAX_SIZE as a, storeBlob as i, getBlobUrl as n, BLOB_MIN_SIZE as o, recordBlobReference as r, getBlobByHash as t };
+
+//# sourceMappingURL=blobs-qTYm-1PY.js.map

package/dist/src/{cache-BLLayYEN.js → cache-8XhNqPKW.js}

@@ -1,13 +1,12 @@
-import { t as __exportAll } from "./chunk-FhC4c-0y.js";
-import { _ as getEnvBool, b as getEnvString, g as getConfigDirectoryPath, i as logger_default, y as getEnvInt } from "./logger-w8Ozp0Td.js";
-import { h as REQUEST_TIMEOUT_MS, n as fetchWithRetries, p as sleep } from "./fetch-18MuNu9i.js";
+import { t as __exportAll } from "./chunk-DEq-mXcV.js";
+import { _ as getEnvBool, b as getEnvString, g as getConfigDirectoryPath, i as logger, y as getEnvInt } from "./logger-CT3IKMKA.js";
+import { d as sleep, n as fetchWithRetries, p as REQUEST_TIMEOUT_MS } from "./fetch-60Gzydls.js";
 import fs from "fs";
 import path from "path";
 import { createCache } from "cache-manager";
 import { Keyv } from "keyv";
 import { KeyvFile } from "keyv-file";
 import { randomBytes } from "crypto";
-
 //#region src/cacheMigration.ts
 /**
 * Migration sunset date: After this date, skip migration entirely.
@@ -39,7 +38,7 @@ function getDirSize(dirPath) {
 			else totalSize += fs.statSync(itemPath).size;
 		}
 	} catch (err) {
-		if (err.code !== "ENOENT") logger_default.warn(`[Cache Migration] Error calculating directory size: ${err.message}`);
+		if (err.code !== "ENOENT") logger.warn(`[Cache Migration] Error calculating directory size: ${err.message}`);
 	}
 	return totalSize;
 }
@@ -54,18 +53,18 @@ function checkDiskSpace(cachePath) {
 			const stats = fs.statfsSync(cachePath);
 			const availableBytes = stats.bavail * stats.bsize;
 			const requiredBytes = cacheSize * 2 + 10 * 1024 * 1024;
-			logger_default.debug(`[Cache Migration] Disk space check: need ${(requiredBytes / 1024 / 1024).toFixed(2)}MB, have ${(availableBytes / 1024 / 1024).toFixed(2)}MB available`);
+			logger.debug(`[Cache Migration] Disk space check: need ${(requiredBytes / 1024 / 1024).toFixed(2)}MB, have ${(availableBytes / 1024 / 1024).toFixed(2)}MB available`);
 			if (availableBytes < requiredBytes) {
-				logger_default.error(`[Cache Migration] Insufficient disk space for migration. Need ${(requiredBytes / 1024 / 1024).toFixed(0)}MB, have ${(availableBytes / 1024 / 1024).toFixed(0)}MB available.`);
+				logger.error(`[Cache Migration] Insufficient disk space for migration. Need ${(requiredBytes / 1024 / 1024).toFixed(0)}MB, have ${(availableBytes / 1024 / 1024).toFixed(0)}MB available.`);
 				return false;
 			}
 			return true;
 		} else {
-			logger_default.debug("[Cache Migration] Disk space check not available on this platform, proceeding");
+			logger.debug("[Cache Migration] Disk space check not available on this platform, proceeding");
 			return true;
 		}
 	} catch (err) {
-		logger_default.warn(`[Cache Migration] Could not check disk space: ${err.message}`);
+		logger.warn(`[Cache Migration] Could not check disk space: ${err.message}`);
 		return true;
 	}
 }
@@ -91,7 +90,7 @@ function isProcessRunning(pid) {
 */
 function acquireMigrationLock(cachePath, attempt = 1) {
 	if (attempt > MAX_LOCK_ATTEMPTS) {
-		logger_default.warn(`[Cache Migration] Failed to acquire lock after ${MAX_LOCK_ATTEMPTS} attempts`);
+		logger.warn(`[Cache Migration] Failed to acquire lock after ${MAX_LOCK_ATTEMPTS} attempts`);
 		return null;
 	}
 	const lockFile = path.join(cachePath, ".migration.lock");
@@ -100,7 +99,7 @@ function acquireMigrationLock(cachePath, attempt = 1) {
 		const fd = fs.openSync(lockFile, "wx");
 		fs.writeSync(fd, process.pid.toString());
 		fs.fsyncSync(fd);
-		logger_default.debug(`[Cache Migration] Lock acquired (PID: ${process.pid})`);
+		logger.debug(`[Cache Migration] Lock acquired (PID: ${process.pid})`);
 		return fd;
 	} catch (err) {
 		if (err.code === "EEXIST") {
@@ -109,20 +108,20 @@ function acquireMigrationLock(cachePath, attempt = 1) {
 				const pid = parseInt(content, 10);
 				if (!isNaN(pid)) {
 					if (isProcessRunning(pid)) {
-						logger_default.info(`[Cache Migration] Another migration is in progress (PID: ${pid})`);
+						logger.info(`[Cache Migration] Another migration is in progress (PID: ${pid})`);
 						return null;
 					}
-					logger_default.warn(`[Cache Migration] Removing stale lock file (PID: ${pid} not found)`);
+					logger.warn(`[Cache Migration] Removing stale lock file (PID: ${pid} not found)`);
 					try {
 						fs.unlinkSync(lockFile);
 						return acquireMigrationLock(cachePath, attempt + 1);
 					} catch (unlinkErr) {
-						logger_default.error(`[Cache Migration] Failed to remove stale lock: ${unlinkErr.message}`);
+						logger.error(`[Cache Migration] Failed to remove stale lock: ${unlinkErr.message}`);
 						return null;
 					}
 				}
 			} catch (readErr) {
-				logger_default.warn(`[Cache Migration] Could not read lock file: ${readErr.message}`);
+				logger.warn(`[Cache Migration] Could not read lock file: ${readErr.message}`);
 			}
 			return null;
 		}
@@ -138,13 +137,13 @@ function releaseMigrationLock(fd, cachePath) {
 	try {
 		fs.closeSync(fd);
 	} catch (err) {
-		logger_default.warn(`[Cache Migration] Failed to close lock file: ${err.message}`);
+		logger.warn(`[Cache Migration] Failed to close lock file: ${err.message}`);
 	}
 	try {
 		fs.unlinkSync(lockFile);
-		logger_default.debug("[Cache Migration] Lock released");
+		logger.debug("[Cache Migration] Lock released");
 	} catch (err) {
-		logger_default.warn(`[Cache Migration] Failed to remove lock file: ${err.message}`);
+		logger.warn(`[Cache Migration] Failed to remove lock file: ${err.message}`);
 	}
 }
 /**
@@ -177,28 +176,28 @@ function readOldCacheEntries(cachePath) {
 	};
 	const entries = /* @__PURE__ */ new Map();
 	if (!fs.existsSync(cachePath)) {
-		logger_default.info(`[Cache Migration] No old cache directory found at ${cachePath}`);
+		logger.info(`[Cache Migration] No old cache directory found at ${cachePath}`);
 		return {
 			entries,
 			stats
 		};
 	}
 	const diskstoreDirs = fs.readdirSync(cachePath, { withFileTypes: true }).filter((dirEntry) => dirEntry.isDirectory() && dirEntry.name.startsWith("diskstore-")).map((dirEntry) => dirEntry.name);
-	logger_default.info(`[Cache Migration] Found ${diskstoreDirs.length} diskstore directories`);
+	logger.info(`[Cache Migration] Found ${diskstoreDirs.length} diskstore directories`);
 	const shouldLogProgress = diskstoreDirs.length > 100;
-	if (shouldLogProgress) logger_default.info(`[Cache Migration] Processing large cache, this may take a moment...`);
+	if (shouldLogProgress) logger.info(`[Cache Migration] Processing large cache, this may take a moment...`);
 	const now = Date.now();
 	let dirCount = 0;
 	for (const dir of diskstoreDirs) {
 		const dirPath = path.join(cachePath, dir);
 		dirCount++;
-		if (shouldLogProgress && dirCount % 100 === 0) logger_default.info(`[Cache Migration] Processed ${dirCount}/${diskstoreDirs.length} directories...`);
+		if (shouldLogProgress && dirCount % 100 === 0) logger.info(`[Cache Migration] Processed ${dirCount}/${diskstoreDirs.length} directories...`);
 		try {
 			const jsonFiles = fs.readdirSync(dirPath).filter((f) => f.endsWith(".json"));
 			for (const file of jsonFiles) {
 				const filePath = path.join(dirPath, file);
 				stats.totalFiles++;
-				if (stats.totalFiles % 1e3 === 0 && stats.totalFiles > 0) logger_default.info(`[Cache Migration] Processed ${stats.totalFiles} files...`);
+				if (stats.totalFiles % 1e3 === 0 && stats.totalFiles > 0) logger.info(`[Cache Migration] Processed ${stats.totalFiles} files...`);
 				try {
 					const content = fs.readFileSync(filePath, "utf-8");
 					const oldEntry = JSON.parse(content);
@@ -249,7 +248,7 @@ function validateCacheFile(cachePath, expectedEntryCount) {
 	if (!Array.isArray(parsed.cache)) throw new Error("Cache file has invalid structure: missing or invalid \"cache\" array");
 	if (typeof parsed.lastExpire !== "number") throw new Error("Cache file has invalid structure: missing or invalid \"lastExpire\" field");
 	if (parsed.cache.length !== expectedEntryCount) throw new Error(`Cache file entry count mismatch: expected ${expectedEntryCount}, got ${parsed.cache.length}`);
-	logger_default.debug(`[Cache Migration] Validated cache file: ${cachePath} (${expectedEntryCount} entries)`);
+	logger.debug(`[Cache Migration] Validated cache file: ${cachePath} (${expectedEntryCount} entries)`);
 }
 /**
 * Write entries in keyv-file format using atomic write operation.
@@ -273,7 +272,7 @@ function writeNewCacheFile(entries, newCachePath) {
 		}
 		fs.writeFileSync(tempFile, serialized, "utf-8");
 		fs.renameSync(tempFile, newCachePath);
-		logger_default.debug(`[Cache Migration] Atomically wrote cache file: ${newCachePath}`);
+		logger.debug(`[Cache Migration] Atomically wrote cache file: ${newCachePath}`);
 		validateCacheFile(newCachePath, entries.size);
 	} catch (err) {
 		try {
@@ -287,7 +286,7 @@ function writeNewCacheFile(entries, newCachePath) {
 */
 function createBackup(cachePath) {
 	const backupPath = `${cachePath}.backup.${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-	logger_default.info(`[Cache Migration] Creating backup at ${backupPath}`);
+	logger.info(`[Cache Migration] Creating backup at ${backupPath}`);
 	if (fs.existsSync(cachePath)) fs.cpSync(cachePath, backupPath, { recursive: true });
 	return backupPath;
 }
@@ -315,11 +314,11 @@ function isMigrationComplete(cacheBasePath, newCacheFile) {
 	if (newCacheFile && fs.existsSync(newCacheFile)) return true;
 	if (newCacheFile) {
 		if (hasOldCacheFormat(cacheBasePath)) {
-			logger_default.warn("[Cache Migration] Marker file exists but migration appears incomplete. Old cache format found but new cache missing. Retrying migration...");
+			logger.warn("[Cache Migration] Marker file exists but migration appears incomplete. Old cache format found but new cache missing. Retrying migration...");
 			try {
 				fs.unlinkSync(markerPath);
 			} catch (err) {
-				logger_default.warn(`[Cache Migration] Failed to remove stale marker: ${err.message}`);
+				logger.warn(`[Cache Migration] Failed to remove stale marker: ${err.message}`);
 			}
 			return false;
 		}
@@ -351,7 +350,7 @@ function cleanupOldCache(cachePath) {
 		throw err;
 	}
 	const diskstoreDirs = dirEntries.filter((dirEntry) => dirEntry.isDirectory() && dirEntry.name.startsWith("diskstore-")).map((dirEntry) => dirEntry.name);
-	logger_default.info(`[Cache Migration] Cleaning up ${diskstoreDirs.length} old cache directories`);
+	logger.info(`[Cache Migration] Cleaning up ${diskstoreDirs.length} old cache directories`);
 	for (const dir of diskstoreDirs) {
 		const dirPath = path.join(cachePath, dir);
 		try {
@@ -360,7 +359,7 @@ function cleanupOldCache(cachePath) {
 				force: true
 			});
 		} catch (err) {
-			logger_default.warn(`[Cache Migration] Failed to remove ${dirPath}: ${err.message}`);
+			logger.warn(`[Cache Migration] Failed to remove ${dirPath}: ${err.message}`);
 		}
 	}
 }
@@ -370,23 +369,23 @@ function cleanupOldCache(cachePath) {
 */
 function cleanupBackup(backupPath, stats) {
 	if (stats.successCount === 0 && stats.failureCount === 0) {
-		logger_default.info(`[Cache Migration] No valid entries found (${stats.skippedExpired} expired only). Removing backup to save space.`);
+		logger.info(`[Cache Migration] No valid entries found (${stats.skippedExpired} expired only). Removing backup to save space.`);
 		try {
 			fs.rmSync(backupPath, {
 				recursive: true,
 				force: true
 			});
-			logger_default.info(`[Cache Migration] Backup removed: ${backupPath}`);
+			logger.info(`[Cache Migration] Backup removed: ${backupPath}`);
 			return true;
 		} catch (err) {
-			logger_default.warn(`[Cache Migration] Failed to remove backup ${backupPath}: ${err.message}`);
+			logger.warn(`[Cache Migration] Failed to remove backup ${backupPath}: ${err.message}`);
 			return false;
 		}
 	} else if (stats.failureCount > 0) {
-		logger_default.info(`[Cache Migration] Backup kept at ${backupPath} due to ${stats.failureCount} migration errors. You may want to investigate these failures.`);
+		logger.info(`[Cache Migration] Backup kept at ${backupPath} due to ${stats.failureCount} migration errors. You may want to investigate these failures.`);
 		return false;
 	} else {
-		logger_default.info(`[Cache Migration] Backup kept at ${backupPath} (migrated ${stats.successCount} valid entries). You can manually delete this backup if you no longer need it.`);
+		logger.info(`[Cache Migration] Backup kept at ${backupPath} (migrated ${stats.successCount} valid entries). You can manually delete this backup if you no longer need it.`);
 		return false;
 	}
 }
@@ -395,10 +394,10 @@ function cleanupBackup(backupPath, stats) {
 * Migrates cache from cache-manager v4 (cache-manager-fs-hash) to v7 (keyv-file)
 */
 function runMigration(cachePath, newCacheFilePath) {
-	logger_default.info("[Cache Migration] Starting cache migration from v4 to v7");
+	logger.info("[Cache Migration] Starting cache migration from v4 to v7");
 	const lock = acquireMigrationLock(cachePath);
 	if (lock === null) {
-		logger_default.info("[Cache Migration] Another migration is in progress, skipping");
+		logger.info("[Cache Migration] Another migration is in progress, skipping");
 		return {
 			success: true,
 			stats: {
@@ -412,7 +411,7 @@ function runMigration(cachePath, newCacheFilePath) {
 	}
 	try {
 		if (isMigrationComplete(cachePath, newCacheFilePath)) {
-			logger_default.info("[Cache Migration] Migration already completed, skipping");
+			logger.info("[Cache Migration] Migration already completed, skipping");
 			return {
 				success: true,
 				stats: {
@@ -425,7 +424,7 @@ function runMigration(cachePath, newCacheFilePath) {
 			};
 		}
 		if (!hasOldCacheFormat(cachePath)) {
-			logger_default.info("[Cache Migration] No old cache format detected, skipping migration");
+			logger.info("[Cache Migration] No old cache format detected, skipping migration");
 			markMigrationComplete(cachePath, {
 				totalFiles: 0,
 				successCount: 0,
@@ -445,7 +444,7 @@ function runMigration(cachePath, newCacheFilePath) {
 			};
 		}
 		if (!checkDiskSpace(cachePath)) {
-			logger_default.error("[Cache Migration] Insufficient disk space, aborting migration");
+			logger.error("[Cache Migration] Insufficient disk space, aborting migration");
 			return {
 				success: false,
 				stats: {
@@ -458,30 +457,30 @@ function runMigration(cachePath, newCacheFilePath) {
 			};
 		}
 		const backupPath = createBackup(cachePath);
-		logger_default.info("[Cache Migration] Reading old cache entries");
+		logger.info("[Cache Migration] Reading old cache entries");
 		const { entries, stats } = readOldCacheEntries(cachePath);
-		logger_default.info(`[Cache Migration] Read ${stats.successCount} entries (${stats.failureCount} failures, ${stats.skippedExpired} expired)`);
+		logger.info(`[Cache Migration] Read ${stats.successCount} entries (${stats.failureCount} failures, ${stats.skippedExpired} expired)`);
 		if (stats.errors.length > 0) {
-			logger_default.warn(`[Cache Migration] Encountered ${stats.errors.length} errors:`);
-			stats.errors.slice(0, 10).forEach((err) => logger_default.warn(`  - ${err}`));
-			if (stats.errors.length > 10) logger_default.warn(`  ... and ${stats.errors.length - 10} more errors`);
+			logger.warn(`[Cache Migration] Encountered ${stats.errors.length} errors:`);
+			stats.errors.slice(0, 10).forEach((err) => logger.warn(`  - ${err}`));
+			if (stats.errors.length > 10) logger.warn(`  ... and ${stats.errors.length - 10} more errors`);
 		}
 		if (entries.size > 0) {
-			logger_default.info(`[Cache Migration] Writing ${entries.size} entries to new cache file: ${newCacheFilePath}`);
+			logger.info(`[Cache Migration] Writing ${entries.size} entries to new cache file: ${newCacheFilePath}`);
 			writeNewCacheFile(entries, newCacheFilePath);
-		} else logger_default.info("[Cache Migration] No entries to migrate");
+		} else logger.info("[Cache Migration] No entries to migrate");
 		cleanupOldCache(cachePath);
 		const backupDeleted = cleanupBackup(backupPath, stats);
 		markMigrationComplete(cachePath, stats);
-		logger_default.info("[Cache Migration] Migration completed successfully");
+		logger.info("[Cache Migration] Migration completed successfully");
 		return {
 			success: true,
 			stats,
 			backupPath: backupDeleted ? void 0 : backupPath
 		};
 	} catch (err) {
-		logger_default.error(`[Cache Migration] Migration failed: ${err.message}`);
-		logger_default.error(`[Cache Migration] Stack trace: ${err.stack}`);
+		logger.error(`[Cache Migration] Migration failed: ${err.message}`);
+		logger.error(`[Cache Migration] Stack trace: ${err.stack}`);
 		return {
 			success: false,
 			stats: {
@@ -508,7 +507,6 @@ function shouldRunMigration(cachePath, newCacheFile) {
 	if (isMigrationComplete(cachePath, newCacheFile)) return false;
 	return hasOldCacheFormat(cachePath);
 }
-
 //#endregion
 //#region src/util/fetch/errors.ts
 /**
@@ -541,7 +539,6 @@ function isTransientConnectionError(error) {
 	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({
@@ -572,23 +569,23 @@ function getCache() {
 		if (cacheType === "disk" && enabled) {
 			cachePath = getEnvString("PROMPTFOO_CACHE_PATH") || path.join(getConfigDirectoryPath(), "cache");
 			if (!fs.existsSync(cachePath)) {
-				logger_default.info(`Creating cache folder at ${cachePath}.`);
+				logger.info(`Creating cache folder at ${cachePath}.`);
 				fs.mkdirSync(cachePath, { recursive: true });
 			}
 			const newCacheFile = path.join(cachePath, "cache.json");
 			if (shouldRunMigration(cachePath, newCacheFile)) {
-				logger_default.info("[Cache] Migrating cache from v4 to v7...");
+				logger.info("[Cache] Migrating cache from v4 to v7...");
 				try {
 					const result = runMigration(cachePath, newCacheFile);
 					if (result.success) {
-						logger_default.info(`[Cache] Migration completed: ${result.stats.successCount} entries migrated, ${result.stats.skippedExpired} expired`);
-						if (result.backupPath) logger_default.info(`[Cache] Backup kept at: ${result.backupPath}`);
+						logger.info(`[Cache] Migration completed: ${result.stats.successCount} entries migrated, ${result.stats.skippedExpired} expired`);
+						if (result.backupPath) logger.info(`[Cache] Backup kept at: ${result.backupPath}`);
 					} else {
-						logger_default.error(`[Cache] Migration failed: ${result.stats.errors.join(", ")}. Falling back to memory cache.`);
+						logger.error(`[Cache] Migration failed: ${result.stats.errors.join(", ")}. Falling back to memory cache.`);
 						migrationFailed = true;
 					}
 				} catch (err) {
-					logger_default.error(`[Cache] Migration error: ${err.message}. Falling back to memory cache.`);
+					logger.error(`[Cache] Migration error: ${err.message}. Falling back to memory cache.`);
 					migrationFailed = true;
 				}
 			}
@@ -599,7 +596,7 @@ function getCache() {
 				});
 				stores.push(keyv);
 			} catch (err) {
-				logger_default.warn(`[Cache] Failed to initialize disk cache: ${err.message}. Using memory cache instead.`);
+				logger.warn(`[Cache] Failed to initialize disk cache: ${err.message}. Using memory cache instead.`);
 			}
 		}
 		cacheInstance = createCache({
@@ -625,7 +622,7 @@ async function fetchAndReadBody(url, options, timeout, maxRetries, isIdempotent)
 		} catch (err) {
 			if (isTransientConnectionError(err) && bodyAttempt < maxBodyRetries) {
 				const backoffMs = Math.pow(2, bodyAttempt) * 1e3;
-				logger_default.debug("[Cache] Body stream failed with transient error, retrying", {
+				logger.debug("[Cache] Body stream failed with transient error, retrying", {
 					attempt: bodyAttempt + 1,
 					maxRetries: maxBodyRetries,
 					backoffMs,
@@ -700,16 +697,16 @@ async function fetchWithCache(url, options = {}, timeout = REQUEST_TIMEOUT_MS, f
 			}
 			if (!data) return;
 			if (format === "json" && parsedData?.error) {
-				logger_default.debug(`Not caching ${url} because it contains an 'error' key: ${parsedData.error}`);
+				logger.debug(`Not caching ${url} because it contains an 'error' key: ${parsedData.error}`);
 				return data;
 			}
-			logger_default.debug(`Storing ${url} response in cache with latencyMs=${fetchLatencyMs}: ${data}`);
+			logger.debug(`Storing ${url} response in cache with latencyMs=${fetchLatencyMs}: ${data}`);
 			return data;
 		} catch (err) {
 			throw new Error(`Error parsing response from ${url}: ${err.message}. Received text: ${responseText}`);
 		}
 	});
-	if (cached && cachedResponse) logger_default.debug(`Returning cached response for ${url}: ${cachedResponse}`);
+	if (cached && cachedResponse) logger.debug(`Returning cached response for ${url}: ${cachedResponse}`);
 	const parsedResponse = JSON.parse(cachedResponse ?? errorResponse);
 	return {
 		cached,
@@ -720,7 +717,7 @@ async function fetchWithCache(url, options = {}, timeout = REQUEST_TIMEOUT_MS, f
 		latencyMs: parsedResponse.latencyMs,
 		deleteFromCache: async () => {
 			await cache.del(cacheKey);
-			logger_default.debug(`Evicted from cache: ${cacheKey}`);
+			logger.debug(`Evicted from cache: ${cacheKey}`);
 		}
 	};
 }
@@ -736,7 +733,7 @@ async function clearCache() {
 function isCacheEnabled() {
 	return enabled;
 }
-
 //#endregion
-export { fetchWithCache as a, NON_TRANSIENT_HTTP_STATUSES as c, enableCache as i, isNonTransientHttpStatus as l, clearCache as n, getCache as o, disableCache as r, isCacheEnabled as s, cache_exports as t, isTransientConnectionError as u };
-//# sourceMappingURL=cache-BLLayYEN.js.map
+export { isCacheEnabled as a, isTransientConnectionError as c, getCache as i, disableCache as n, NON_TRANSIENT_HTTP_STATUSES as o, fetchWithCache as r, isNonTransientHttpStatus as s, cache_exports as t };
+
+//# sourceMappingURL=cache-8XhNqPKW.js.map

package/dist/src/cache-Bbn1Nyrd.cjs

@@ -0,0 +1,5 @@
+require("./logger-Cp1GPUjj.cjs");
+require("./fetch-BxUk8odA.cjs");
+const require_cache = require("./cache-COish3-W.cjs");
+exports.getCache = require_cache.getCache;
+exports.isCacheEnabled = require_cache.isCacheEnabled;

package/dist/src/cache-BwsMSda7.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import "./logger-KkObSCzq.js";
+import "./fetch-BMv0O527.js";
+import "./cloud-Bc9526yV.js";
+import { o as getCache, s as isCacheEnabled } from "./cache-CG0SlR1d.js";
+export { getCache, isCacheEnabled };