promptfoo 0.120.27 → 0.121.1

package/dist/src/extractor-YMU_Gvt8.js

@@ -0,0 +1,374 @@
+import { _ as getEnvBool, i as logger } from "./logger-DLcq4dWf.js";
+import { o as cloudConfig } from "./fetch-4M3YRaqL.js";
+import { c as isLoggedIntoCloud } from "./accounts-BgNJDBE6.js";
+import { i as storeBlob, r as recordBlobReference } from "./blobs-qTYm-1PY.js";
+//#region src/blobs/remoteUpload.ts
+function buildRemoteUrl() {
+	const baseUrl = cloudConfig.getApiHost();
+	const apiKey = cloudConfig.getApiKey();
+	if (!baseUrl || !apiKey || !isLoggedIntoCloud()) return null;
+	try {
+		return new URL("/api/blobs", baseUrl).toString();
+	} catch (error) {
+		logger.debug("[RemoteBlob] Invalid remote blob URL", {
+			error: error instanceof Error ? error.message : String(error),
+			baseUrl
+		});
+		return null;
+	}
+}
+function shouldAttemptRemoteBlobUpload() {
+	return buildRemoteUrl() !== null;
+}
+async function uploadBlobRemote(buffer, mimeType, context) {
+	const url = buildRemoteUrl();
+	const apiKey = cloudConfig.getApiKey();
+	if (!url || !apiKey) return null;
+	try {
+		const { fetchWithProxy } = await import("./fetch-4M3YRaqL.js").then((n) => n.i);
+		const response = await fetchWithProxy(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${apiKey}`
+			},
+			body: JSON.stringify({
+				data: buffer.toString("base64"),
+				mimeType,
+				context
+			})
+		});
+		if (response.status === 404 || response.status === 400) {
+			logger.debug("[RemoteBlob] Remote blob upload unavailable", { status: response.status });
+			return null;
+		}
+		if (!response.ok) {
+			const text = await response.text();
+			logger.debug("[RemoteBlob] Failed to upload blob", {
+				status: response.status,
+				statusText: response.statusText,
+				body: text
+			});
+			return null;
+		}
+		const data = await response.json();
+		if (!data?.ref?.hash) {
+			logger.debug("[RemoteBlob] Remote upload returned malformed response");
+			return null;
+		}
+		return data;
+	} catch (error) {
+		logger.debug("[RemoteBlob] Error uploading blob", { error: error instanceof Error ? error.message : String(error) });
+		return null;
+	}
+}
+//#endregion
+//#region src/blobs/extractor.ts
+const BLOB_URI_REGEX = /^promptfoo:\/\/blob\/([a-f0-9]{64})$/i;
+const BLOB_HASH_REGEX = /^[a-f0-9]{64}$/i;
+function isDataUrl(value) {
+	return /^data:(audio|image)\/[^;]+;base64,/.test(value);
+}
+function extractBase64(value) {
+	const match = value.match(/^data:([^;]+);base64,(.+)$/);
+	if (!match) return null;
+	const mimeType = match[1];
+	try {
+		return {
+			buffer: Buffer.from(match[2], "base64"),
+			mimeType
+		};
+	} catch (error) {
+		logger.warn("[BlobExtractor] Failed to parse base64 data URL", { error });
+		return null;
+	}
+}
+function shouldExternalize(buffer) {
+	const size = buffer.length;
+	return size >= 1024 && size <= 52428800;
+}
+function getKindFromMimeType(mimeType) {
+	return mimeType.startsWith("audio/") ? "audio" : "image";
+}
+/**
+* Normalize audio format to proper MIME type.
+* Some providers return just 'wav' instead of 'audio/wav'.
+* @internal Exported for testing
+*/
+function normalizeAudioMimeType(format) {
+	if (!format) return "audio/wav";
+	const trimmedFormat = format.trim();
+	if (/^audio\/[a-z0-9_+-]+$/i.test(trimmedFormat)) return trimmedFormat;
+	const formatLower = trimmedFormat.toLowerCase();
+	const mimeMap = {
+		wav: "audio/wav",
+		mp3: "audio/mpeg",
+		ogg: "audio/ogg",
+		flac: "audio/flac",
+		aac: "audio/aac",
+		m4a: "audio/mp4",
+		webm: "audio/webm"
+	};
+	if (mimeMap[formatLower]) return mimeMap[formatLower];
+	if (!/^[a-z0-9_-]+$/i.test(formatLower)) {
+		logger.warn("[BlobExtractor] Invalid audio format, using default", { format });
+		return "audio/wav";
+	}
+	return `audio/${formatLower}`;
+}
+function parseBinary(base64OrDataUrl, defaultMimeType) {
+	if (isDataUrl(base64OrDataUrl)) {
+		const parsed = extractBase64(base64OrDataUrl);
+		if (!parsed) return null;
+		return parsed;
+	}
+	try {
+		return {
+			buffer: Buffer.from(base64OrDataUrl, "base64"),
+			mimeType: defaultMimeType
+		};
+	} catch (error) {
+		logger.warn("[BlobExtractor] Failed to parse base64 data", { error });
+		return null;
+	}
+}
+async function maybeStore(base64OrDataUrl, defaultMimeType, context, location, kind) {
+	const parsed = parseBinary(base64OrDataUrl, defaultMimeType);
+	if (!parsed || !shouldExternalize(parsed.buffer)) return null;
+	if (!isBlobStorageEnabled()) return null;
+	const mimeType = parsed.mimeType || "application/octet-stream";
+	const { ref } = await storeBlob(parsed.buffer, mimeType, {
+		...context,
+		location,
+		kind
+	});
+	if (shouldAttemptRemoteBlobUpload()) uploadBlobRemote(parsed.buffer, mimeType, {
+		evalId: context.evalId,
+		testIdx: context.testIdx,
+		promptIdx: context.promptIdx,
+		location,
+		kind
+	}).catch((error) => {
+		logger.debug("[BlobExtractor] Cloud upload failed (non-fatal)", {
+			error: error instanceof Error ? error.message : String(error),
+			hash: ref.hash
+		});
+	});
+	return ref;
+}
+async function externalizeDataUrls(value, context, location) {
+	if (typeof value === "string") {
+		if (!isDataUrl(value)) return {
+			value,
+			mutated: false
+		};
+		const parsed = extractBase64(value);
+		if (!parsed || !shouldExternalize(parsed.buffer)) return {
+			value,
+			mutated: false
+		};
+		const storedRef = await maybeStore(parsed.buffer.toString("base64"), parsed.mimeType, context, location, getKindFromMimeType(parsed.mimeType)) || null;
+		if (!storedRef) return {
+			value,
+			mutated: false
+		};
+		return {
+			value: storedRef.uri,
+			mutated: true
+		};
+	}
+	if (Array.isArray(value)) {
+		let mutated = false;
+		const nextValues = await Promise.all(value.map(async (item, idx) => {
+			const { value: nextValue, mutated: childMutated } = await externalizeDataUrls(item, context, `${location}[${idx}]`);
+			mutated ||= childMutated;
+			return nextValue;
+		}));
+		return mutated ? {
+			value: nextValues,
+			mutated
+		} : {
+			value,
+			mutated: false
+		};
+	}
+	if (value && typeof value === "object") {
+		let mutated = false;
+		const nextObject = { ...value };
+		for (const [key, child] of Object.entries(value)) {
+			const { value: nextValue, mutated: childMutated } = await externalizeDataUrls(child, context, location ? `${location}.${key}` : key);
+			if (childMutated) {
+				nextObject[key] = nextValue;
+				mutated = true;
+			}
+		}
+		return mutated ? {
+			value: nextObject,
+			mutated: true
+		} : {
+			value,
+			mutated: false
+		};
+	}
+	return {
+		value,
+		mutated: false
+	};
+}
+/**
+* Best-effort extraction of binary data from provider responses.
+* Currently focuses on audio.data fields and data URL outputs.
+*/
+async function extractAndStoreBinaryData(response, context) {
+	if (!response) return response;
+	let mutated = false;
+	const next = { ...response };
+	const blobContext = context || {};
+	if (response.audio?.data && typeof response.audio.data === "string") {
+		const stored = await maybeStore(response.audio.data, normalizeAudioMimeType(response.audio.format), blobContext, "response.audio.data", "audio");
+		if (stored) {
+			next.audio = {
+				...response.audio,
+				data: void 0,
+				blobRef: stored
+			};
+			mutated = true;
+			logger.debug("[BlobExtractor] Stored audio blob", {
+				...context,
+				hash: stored.hash
+			});
+		}
+	}
+	if (response.images?.length) next.images = await Promise.all(response.images.map(async (img, idx) => {
+		if (!img.data || typeof img.data !== "string" || !isDataUrl(img.data)) return img;
+		const stored = await maybeStore(img.data, img.mimeType || "image/png", blobContext, `response.images[${idx}].data`, "image");
+		if (stored) {
+			mutated = true;
+			logger.debug("[BlobExtractor] Stored image blob", {
+				...context,
+				hash: stored.hash
+			});
+			return {
+				...img,
+				data: void 0,
+				blobRef: stored
+			};
+		}
+		return img;
+	}));
+	const turns = response.turns;
+	if (Array.isArray(turns)) next.turns = await Promise.all(turns.map(async (turn, idx) => {
+		if (turn?.audio?.data && typeof turn.audio.data === "string") {
+			const stored = await maybeStore(turn.audio.data, normalizeAudioMimeType(turn.audio.format), blobContext, `response.turns[${idx}].audio.data`, "audio");
+			if (stored) {
+				mutated = true;
+				return {
+					...turn,
+					audio: {
+						...turn.audio,
+						data: void 0,
+						blobRef: stored
+					}
+				};
+			}
+		}
+		return turn;
+	}));
+	if (typeof response.output === "string" && isDataUrl(response.output)) {
+		const parsed = extractBase64(response.output);
+		if (parsed && shouldExternalize(parsed.buffer)) {
+			const stored = await maybeStore(parsed.buffer.toString("base64"), parsed.mimeType, blobContext, "response.output", getKindFromMimeType(parsed.mimeType));
+			if (stored) {
+				next.output = stored.uri;
+				mutated = true;
+				logger.debug("[BlobExtractor] Stored output blob", {
+					...context,
+					hash: stored.hash
+				});
+			}
+		}
+	}
+	if (typeof response.output === "string" && response.output.trim().startsWith("{") && (response.isBase64 && response.format === "json" || response.output.includes("\"b64_json\"") || response.output.includes("b64_json"))) try {
+		const parsed = JSON.parse(response.output);
+		if (Array.isArray(parsed.data)) {
+			let jsonMutated = false;
+			const storedUris = [];
+			for (const item of parsed.data) if (item?.b64_json && typeof item.b64_json === "string") {
+				const stored = await maybeStore(item.b64_json, "image/png", blobContext, "response.output.data[].b64_json", "image");
+				if (stored) {
+					item.b64_json = stored.uri;
+					storedUris.push(stored.uri);
+					jsonMutated = true;
+					mutated = true;
+					logger.debug("[BlobExtractor] Stored image blob from b64_json", {
+						...context,
+						hash: stored.hash
+					});
+				}
+			}
+			if (jsonMutated) {
+				if (storedUris.length === 1) next.output = storedUris[0];
+				else if (storedUris.length > 1) next.output = JSON.stringify(storedUris);
+				else next.output = JSON.stringify(parsed);
+				next.metadata = {
+					...response.metadata || {},
+					blobUris: storedUris,
+					originalFormat: response.format
+				};
+			}
+		}
+	} catch (err) {
+		logger.debug("[BlobExtractor] Failed to parse base64 JSON output", {
+			error: err instanceof Error ? err.message : String(err),
+			location: "response.output"
+		});
+	}
+	if (response.metadata) {
+		const { value, mutated: metadataMutated } = await externalizeDataUrls(response.metadata, blobContext, "response.metadata");
+		if (metadataMutated) {
+			next.metadata = value;
+			mutated = true;
+		}
+	}
+	const finalResponse = mutated ? next : response;
+	if (blobContext.evalId) await recordExistingBlobReferences(finalResponse, blobContext, "response");
+	return finalResponse;
+}
+function isBlobStorageEnabled() {
+	return !getEnvBool("PROMPTFOO_INLINE_MEDIA", false);
+}
+function parseBlobHashFromValue(value) {
+	if (!value) return null;
+	if (typeof value === "string") {
+		const match = value.match(BLOB_URI_REGEX);
+		return match ? match[1] : null;
+	}
+	if (typeof value === "object") {
+		const candidate = value;
+		if (candidate.hash && BLOB_HASH_REGEX.test(candidate.hash)) return candidate.hash;
+		if (candidate.uri && typeof candidate.uri === "string") {
+			const match = candidate.uri.match(BLOB_URI_REGEX);
+			if (match) return match[1];
+		}
+	}
+	return null;
+}
+async function recordExistingBlobReferences(value, context, location) {
+	const hash = parseBlobHashFromValue(value);
+	if (hash) {
+		await recordBlobReference(hash, {
+			...context,
+			location
+		});
+		return;
+	}
+	if (Array.isArray(value)) {
+		await Promise.all(value.map((child, idx) => recordExistingBlobReferences(child, context, `${location}[${idx}]`)));
+		return;
+	}
+	if (value && typeof value === "object") for (const [key, child] of Object.entries(value)) await recordExistingBlobReferences(child, context, location ? `${location}.${key}` : key);
+}
+//#endregion
+export { isBlobStorageEnabled as n, shouldAttemptRemoteBlobUpload as r, extractAndStoreBinaryData as t };
+
+//# sourceMappingURL=extractor-YMU_Gvt8.js.map

package/dist/src/{fetch-D3OHf-lV.js → fetch-4M3YRaqL.js}

@@ -1,15 +1,15 @@
-import { _ as getEnvBool, b as getEnvString, c as sanitizeUrl, g as getConfigDirectoryPath, i as logger_default, r as logRequestResponse, w as cliState_default, y as getEnvInt } from "./logger-CG1uZPbQ.js";
-import { t as invariant } from "./invariant-1pAf2CD1.js";
+import { t as __exportAll } from "./chunk-DEq-mXcV.js";
+import { _ as getEnvBool, b as getEnvString, c as sanitizeUrl, g as getConfigDirectoryPath, i as logger, r as logRequestResponse, w as state, y as getEnvInt } from "./logger-DLcq4dWf.js";
+import { t as invariant } from "./invariant-vgHWClmd.js";
 import * as fs$1 from "fs";
 import * as path$1 from "path";
 import path from "path";
 import yaml from "js-yaml";
-import { promisify } from "util";
 import * as fsPromises from "fs/promises";
 import { getProxyForUrl } from "proxy-from-env";
 import { Agent, ProxyAgent } from "undici";
+import { promisify } from "util";
 import { gzip } from "zlib";
-
 //#region src/providers/constants.ts
 const FILE_METADATA_KEY = "_promptfooFileMetadata";
 /**
@@ -17,28 +17,21 @@ const FILE_METADATA_KEY = "_promptfooFileMetadata";
 * Used to distinguish human ratings from automated assertions.
 */
 const HUMAN_ASSERTION_TYPE = "human";
-
 //#endregion
 //#region src/version.ts
 /**
 * Application version from package.json.
 * Injected at build time, or read from npm environment in development.
 */
-const VERSION = "0.120.27";
+const VERSION = "0.121.1";
 /**
 * PostHog analytics key.
 * Only populated during production builds via PROMPTFOO_POSTHOG_KEY env var.
 * Empty string in development/test.
 */
 const POSTHOG_KEY = "phc_E5n5uHnDo2eREJL1uqX1cIlbkoRby4yFWt3V94HqRRg";
-
-//#endregion
-//#region src/constants.ts
-const DEFAULT_QUERY_LIMIT = 100;
-const DEFAULT_MAX_CONCURRENCY = 4;
-const DEFAULT_API_BASE_URL = "https://api.promptfoo.app";
 function getShareApiBaseUrl() {
-	return getEnvString("PROMPTFOO_REMOTE_API_BASE_URL") || DEFAULT_API_BASE_URL;
+	return getEnvString("PROMPTFOO_REMOTE_API_BASE_URL") || "https://api.promptfoo.app";
 }
 function getDefaultShareViewBaseUrl() {
 	return getEnvString("PROMPTFOO_SHARING_APP_BASE_URL", `https://promptfoo.app`);
@@ -46,12 +39,14 @@ function getDefaultShareViewBaseUrl() {
 function getShareViewBaseUrl() {
 	return getEnvString("PROMPTFOO_REMOTE_APP_BASE_URL") || getDefaultShareViewBaseUrl();
 }
+function getDefaultPort() {
+	return getEnvInt("API_PORT", 15500);
+}
 const TERMINAL_MAX_WIDTH = process?.stdout?.isTTY && process?.stdout?.columns && process?.stdout?.columns > 10 ? process?.stdout?.columns - 10 : 120;
 const CLOUD_PROVIDER_PREFIX = "promptfoo://provider/";
 const CONSENT_ENDPOINT = "https://api.promptfoo.dev/consent";
 const EVENTS_ENDPOINT = "https://a.promptfoo.app";
 const R_ENDPOINT = "https://r.promptfoo.app/";
-
 //#endregion
 //#region src/providers/shared.ts
 /**
@@ -290,14 +285,12 @@ function transformTools(tools, format) {
 		default: return tools;
 	}
 }
-
 //#endregion
 //#region src/util/time.ts
 function getCurrentTimestamp() {
 	return Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
 }
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
 //#endregion
 //#region src/globalConfig/globalConfig.ts
 /**
@@ -338,11 +331,7 @@ function writeGlobalConfigPartial(partialConfig) {
 	});
 	writeGlobalConfig(updatedConfig);
 }
-
-//#endregion
-//#region src/globalConfig/cloud.ts
-const CLOUD_API_HOST = "https://api.promptfoo.app";
-const API_HOST = getEnvString("API_HOST", CLOUD_API_HOST);
+const API_HOST = getEnvString("API_HOST", "https://api.promptfoo.app");
 const SHARING_CUTOFF_DATE = /* @__PURE__ */ new Date("2026-03-09T00:00:00Z");
 var CloudConfig = class {
 	config;
@@ -431,11 +420,11 @@ var CloudConfig = class {
 	}
 	async validateAndSetApiToken(token, apiHost) {
 		try {
-			const { fetchWithProxy } = await import("./fetch-ouKnrWK-.js");
+			const { fetchWithProxy } = await Promise.resolve().then(() => fetch_exports);
 			const response = await fetchWithProxy(`${apiHost}/api/v1/users/me`, { headers: { Authorization: `Bearer ${token}` } });
 			if (!response.ok) {
 				const errorMessage = await response.text();
-				logger_default.error(`[Cloud] Failed to validate API token: ${errorMessage}. HTTP Status: ${response.status} - ${response.statusText}.`);
+				logger.error(`[Cloud] Failed to validate API token: ${errorMessage}. HTTP Status: ${response.status} - ${response.statusText}.`);
 				throw new Error("Failed to validate API token: " + response.statusText);
 			}
 			const { user, organization, app, hasActiveLicense } = await response.json();
@@ -456,8 +445,8 @@ var CloudConfig = class {
 		} catch (err) {
 			const error = err;
 			const errorMessage = error instanceof Error ? error.message : String(error);
-			logger_default.error(`[Cloud] Failed to validate API token with host ${apiHost}: ${errorMessage}`);
-			if (error.cause) logger_default.error(`Cause: ${error.cause}`);
+			logger.error(`[Cloud] Failed to validate API token with host ${apiHost}: ${errorMessage}`);
+			if (error.cause) logger.error(`Cause: ${error.cause}`);
 			throw error;
 		}
 	}
@@ -504,7 +493,6 @@ var CloudConfig = class {
 	}
 };
 const cloudConfig = new CloudConfig();
-
 //#endregion
 //#region src/util/fetch/monkeyPatchFetch.ts
 const gzipAsync = promisify(gzip);
@@ -531,9 +519,9 @@ async function monkeyPatchFetch(url, options) {
 			"Content-Encoding": "gzip"
 		};
 	} catch (e) {
-		logger_default.warn(`Failed to compress request body: ${e}`);
+		logger.warn(`Failed to compress request body: ${e}`);
 	}
-	if (typeof url === "string" && url.startsWith(CLOUD_API_HOST) || url instanceof URL && url.host === CLOUD_API_HOST.replace(/^https?:\/\//, "")) {
+	if (typeof url === "string" && url.startsWith("https://api.promptfoo.app") || url instanceof URL && url.host === "https://api.promptfoo.app".replace(/^https?:\/\//, "")) {
 		const token = cloudConfig.getApiKey();
 		opts.headers = {
 			...opts.headers || {},
@@ -558,17 +546,24 @@ async function monkeyPatchFetch(url, options) {
 				response: null
 			});
 			if (isConnectionError(e)) {
-				logger_default.debug(`Connection error, please check your network connectivity to the host: ${url} ${process.env.HTTP_PROXY || process.env.HTTPS_PROXY ? `or Proxy: ${process.env.HTTP_PROXY || process.env.HTTPS_PROXY}` : ""}`);
+				logger.debug(`Connection error, please check your network connectivity to the host: ${url} ${process.env.HTTP_PROXY || process.env.HTTPS_PROXY ? `or Proxy: ${process.env.HTTP_PROXY || process.env.HTTPS_PROXY}` : ""}`);
 				throw e;
 			}
-			logger_default.debug(`Error in fetch: ${JSON.stringify(e, Object.getOwnPropertyNames(e), 2)} ${e instanceof Error ? e.stack : ""}`);
+			logger.debug(`Error in fetch: ${JSON.stringify(e, Object.getOwnPropertyNames(e), 2)} ${e instanceof Error ? e.stack : ""}`);
 		}
 		throw e;
 	}
 }
-
 //#endregion
 //#region src/util/fetch/index.ts
+var fetch_exports = /* @__PURE__ */ __exportAll({
+	fetchWithProxy: () => fetchWithProxy,
+	fetchWithRetries: () => fetchWithRetries,
+	fetchWithTimeout: () => fetchWithTimeout,
+	handleRateLimit: () => handleRateLimit,
+	isRateLimited: () => isRateLimited,
+	isTransientError: () => isTransientError
+});
 let cachedAgent = null;
 let cachedAgentConcurrency;
 let cachedProxyAgents = /* @__PURE__ */ new Map();
@@ -584,7 +579,7 @@ function getConnectionPoolSize() {
 		const parsed = parseInt(envConnections, 10);
 		if (!isNaN(parsed)) return parsed;
 	}
-	return cliState_default.maxConcurrency || DEFAULT_MAX_CONCURRENCY;
+	return state.maxConcurrency || 4;
 }
 function getOrCreateAgent(tlsOptions) {
 	const concurrency = getConnectionPoolSize();
@@ -638,7 +633,7 @@ async function fetchWithProxy(url, options = {}, abortSignal) {
 	if (typeof url === "string") try {
 		const parsedUrl = new URL(url);
 		if (parsedUrl.username || parsedUrl.password) {
-			if (finalOptions.headers && "Authorization" in finalOptions.headers) logger_default.warn("Both URL credentials and Authorization header present - URL credentials will be ignored");
+			if (finalOptions.headers && "Authorization" in finalOptions.headers) logger.warn("Both URL credentials and Authorization header present - URL credentials will be ignored");
 			else {
 				const username = parsedUrl.username || "";
 				const password = parsedUrl.password || "";
@@ -654,20 +649,20 @@ async function fetchWithProxy(url, options = {}, abortSignal) {
 			finalUrlString = finalUrl.toString();
 		}
 	} catch (e) {
-		logger_default.debug(`URL parsing failed in fetchWithProxy: ${e}`);
+		logger.debug(`URL parsing failed in fetchWithProxy: ${e}`);
 	}
 	const tlsOptions = { rejectUnauthorized: !getEnvBool("PROMPTFOO_INSECURE_SSL", true) };
 	const caCertPath = getEnvString("PROMPTFOO_CA_CERT_PATH");
 	if (caCertPath) try {
-		const resolvedPath = path.resolve(cliState_default.basePath || "", caCertPath);
+		const resolvedPath = path.resolve(state.basePath || "", caCertPath);
 		tlsOptions.ca = await fsPromises.readFile(resolvedPath, "utf8");
-		logger_default.debug(`Using custom CA certificate from ${resolvedPath}`);
+		logger.debug(`Using custom CA certificate from ${resolvedPath}`);
 	} catch (e) {
-		logger_default.warn(`Failed to read CA certificate from ${caCertPath}: ${e}`);
+		logger.warn(`Failed to read CA certificate from ${caCertPath}: ${e}`);
 	}
 	const proxyUrl = finalUrlString ? getProxyForUrl(finalUrlString) : "";
 	if (!finalOptions.dispatcher) if (proxyUrl) {
-		logger_default.debug(`Using proxy: ${sanitizeUrl(proxyUrl)}`);
+		logger.debug(`Using proxy: ${sanitizeUrl(proxyUrl)}`);
 		finalOptions.dispatcher = getOrCreateProxyAgent(proxyUrl, tlsOptions);
 	} else finalOptions.dispatcher = getOrCreateAgent(tlsOptions);
 	const maxTransientRetries = options.disableTransientRetries ? 0 : 3;
@@ -675,7 +670,7 @@ async function fetchWithProxy(url, options = {}, abortSignal) {
 		const response = await monkeyPatchFetch(finalUrl, finalOptions);
 		if (!options.disableTransientRetries && isTransientError(response) && attempt < maxTransientRetries) {
 			const backoffMs = Math.pow(2, attempt) * 1e3;
-			logger_default.debug(`Transient error (${response.status} ${response.statusText}), retry ${attempt + 1}/${maxTransientRetries} after ${backoffMs}ms`);
+			logger.debug(`Transient error (${response.status} ${response.statusText}), retry ${attempt + 1}/${maxTransientRetries} after ${backoffMs}ms`);
 			await sleep(backoffMs);
 			continue;
 		}
@@ -725,7 +720,7 @@ async function handleRateLimit(response) {
 		const now = /* @__PURE__ */ new Date();
 		waitTime = Math.max(resetTime.getTime() - now.getTime() + 1e3, 0);
 	} else if (retryAfter) waitTime = Number.parseInt(retryAfter) * 1e3;
-	logger_default.debug(`Rate limited, waiting ${waitTime}ms before retry`);
+	logger.debug(`Rate limited, waiting ${waitTime}ms before retry`);
 	await sleep(waitTime);
 }
 /**
@@ -757,7 +752,7 @@ async function fetchWithRetries(url, options = {}, timeout, maxRetries) {
 			}, timeout);
 			if (getEnvBool("PROMPTFOO_RETRY_5XX") && response.status >= 500 && response.status < 600) throw new Error(`Internal Server Error: ${response.status} ${response.statusText}`);
 			if (response && isRateLimited(response)) {
-				logger_default.debug(`Rate limited on URL ${url}: ${response.status} ${response.statusText}, attempt ${i + 1}/${maxRetries + 1}, waiting before retry...`);
+				logger.debug(`Rate limited on URL ${url}: ${response.status} ${response.statusText}, attempt ${i + 1}/${maxRetries + 1}, waiting before retry...`);
 				lastErrorMessage = `Rate limited: ${response.status} ${response.statusText}`;
 				await handleRateLimit(response);
 				continue;
@@ -772,14 +767,14 @@ async function fetchWithRetries(url, options = {}, timeout, maxRetries) {
 				if (typedError.cause) errorMessage += ` (Cause: ${typedError.cause})`;
 				if (typedError.code) errorMessage += ` (Code: ${typedError.code})`;
 			} else errorMessage = String(error);
-			logger_default.debug(`Request to ${url} failed (attempt #${i + 1}), retrying: ${errorMessage}`);
+			logger.debug(`Request to ${url} failed (attempt #${i + 1}), retrying: ${errorMessage}`);
 			if (i < maxRetries) await sleep(Math.pow(2, i) * (backoff + 1e3 * Math.random()));
 			lastErrorMessage = errorMessage;
 		}
 	}
 	throw new Error(`Request failed after ${maxRetries} retries: ${lastErrorMessage}`);
 }
-
 //#endregion
-export { EVENTS_ENDPOINT as A, toTitleCase as C, CONSENT_ENDPOINT as D, CLOUD_PROVIDER_PREFIX as E, getShareViewBaseUrl as F, POSTHOG_KEY as I, VERSION as L, TERMINAL_MAX_WIDTH as M, getDefaultShareViewBaseUrl as N, DEFAULT_MAX_CONCURRENCY as O, getShareApiBaseUrl as P, FILE_METADATA_KEY as R, parseChatPrompt as S, transformTools as T, isOpenAIToolArray as _, isRateLimited as a, openaiToolChoiceToBedrock as b, cloudConfig as c, writeGlobalConfigPartial as d, getCurrentTimestamp as f, calculateCost as g, REQUEST_TIMEOUT_MS as h, handleRateLimit as i, R_ENDPOINT as j, DEFAULT_QUERY_LIMIT as k, readGlobalConfig as l, LONG_RUNNING_MODEL_TIMEOUT_MS as m, fetchWithRetries as n, isTransientError as o, sleep as p, fetchWithTimeout as r, CloudConfig as s, fetchWithProxy as t, writeGlobalConfig as u, isOpenAIToolChoice as v, transformToolChoice as w, openaiToolsToBedrock as x, isPromptfooSampleTarget as y, HUMAN_ASSERTION_TYPE as z };
-//# sourceMappingURL=fetch-D3OHf-lV.js.map
+export { getDefaultShareViewBaseUrl as A, transformTools as C, R_ENDPOINT as D, EVENTS_ENDPOINT as E, FILE_METADATA_KEY as F, HUMAN_ASSERTION_TYPE as I, getShareViewBaseUrl as M, POSTHOG_KEY as N, TERMINAL_MAX_WIDTH as O, VERSION as P, transformToolChoice as S, CONSENT_ENDPOINT as T, isPromptfooSampleTarget as _, CloudConfig as a, parseChatPrompt as b, writeGlobalConfig as c, sleep as d, LONG_RUNNING_MODEL_TIMEOUT_MS as f, isOpenAIToolChoice as g, isOpenAIToolArray as h, fetch_exports as i, getShareApiBaseUrl as j, getDefaultPort as k, writeGlobalConfigPartial as l, calculateCost as m, fetchWithRetries as n, cloudConfig as o, REQUEST_TIMEOUT_MS as p, fetchWithTimeout as r, readGlobalConfig as s, fetchWithProxy as t, getCurrentTimestamp as u, openaiToolChoiceToBedrock as v, CLOUD_PROVIDER_PREFIX as w, toTitleCase as x, openaiToolsToBedrock as y };
+
+//# sourceMappingURL=fetch-4M3YRaqL.js.map