@use-lattice/litmus 0.121.3

package/dist/src/esm-DMVc93eh.js

@@ -0,0 +1,379 @@
+import { r as logger } from "./logger-C40ZGil9.js";
+import { createRequire } from "node:module";
+import path from "path";
+import path$1 from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import vm from "node:vm";
+import { resolveModulePath } from "exsolve";
+//#region node_modules/tsdown/esm-shims.js
+const getFilename = () => fileURLToPath(import.meta.url);
+const getDirname = () => path$1.dirname(getFilename());
+const __dirname = /* @__PURE__ */ getDirname();
+//#endregion
+//#region src/util/pathUtils.ts
+/**
+* Path resolution utilities that work with both regular paths and file:// URLs
+*/
+/**
+* Check if a file path is absolute, handling both regular paths and URLs
+* @param filePath - The file path to check
+* @returns True if the path is absolute
+*/
+function isAbsolute(filePath) {
+	if (!filePath) return false;
+	if (/^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(filePath)) {
+		if (filePath.startsWith("file://")) try {
+			return path.isAbsolute(fileURLToPath(filePath));
+		} catch {
+			return true;
+		}
+		return true;
+	}
+	return path.isAbsolute(filePath);
+}
+/**
+* Safely resolves a path - only calls resolve() if the last path is relative
+* Leaves absolute paths and absolute URLs unchanged
+*
+* @param paths - The path segments to resolve
+* @returns The resolved path if last path is relative, or the last path if it's absolute
+*/
+function safeResolve(...paths) {
+	const lastPath = paths[paths.length - 1] || "";
+	if (isAbsolute(lastPath)) return lastPath;
+	return path.resolve(...paths);
+}
+/**
+* Safely joins paths - only joins if the last path is relative
+* If the last path is absolute or an absolute URL, returns it directly
+*
+* @param paths - The path segments to join
+* @returns The joined path if last path is relative, or the last path if it's absolute
+*/
+function safeJoin(...paths) {
+	const lastPath = paths[paths.length - 1] || "";
+	if (isAbsolute(lastPath)) return lastPath;
+	return path.join(...paths);
+}
+//#endregion
+//#region src/esm.ts
+/**
+* Mapping of wrapper types to their subdirectory names.
+* These correspond to the directory structure under src/ and dist/src/.
+*/
+const WRAPPER_SUBDIRS = {
+	python: "python",
+	ruby: "ruby",
+	golang: "golang"
+};
+/**
+* Cache for wrapper directory paths to avoid repeated path construction.
+*/
+const wrapperDirCache = {};
+/**
+* Returns the directory containing wrapper scripts for the specified language.
+*
+* This function provides a consistent way to locate wrapper scripts (wrapper.py,
+* wrapper.rb, wrapper.go, etc.) that works correctly in both development and
+* production (bundled) environments.
+*
+* Directory resolution:
+* - Development (tsx): src/{python|ruby|golang}/
+* - Production (bundled): dist/src/{python|ruby|golang}/
+*
+* Results are cached for performance.
+*
+* @param type - The wrapper type ('python', 'ruby', or 'golang')
+* @returns The absolute path to the wrapper directory
+*
+* @example
+* ```typescript
+* // Get Python wrapper path
+* const pythonDir = getWrapperDir('python');
+* const wrapperPath = path.join(pythonDir, 'wrapper.py');
+*
+* // Get Ruby wrapper path
+* const rubyDir = getWrapperDir('ruby');
+* const wrapperPath = path.join(rubyDir, 'wrapper.rb');
+* ```
+*/
+function getWrapperDir(type) {
+	if (wrapperDirCache[type]) return wrapperDirCache[type];
+	const baseDir = getDirectory();
+	const result = path$1.join(baseDir, WRAPPER_SUBDIRS[type]);
+	wrapperDirCache[type] = result;
+	logger.debug(`Resolved ${type} wrapper directory: ${result}`);
+	return result;
+}
+/**
+* Resolves the entry point path for an npm package, handling ESM-only packages
+* with restrictive `exports` fields.
+*
+* ## Why this function exists
+*
+* Some ESM-only packages (like `@openai/codex-sdk`) have restrictive `exports` fields:
+*
+* ```json
+* {
+*   "type": "module",
+*   "exports": {
+*     ".": { "import": "./dist/index.js" }
+*   }
+* }
+* ```
+*
+* This causes problems with Node.js's `require.resolve()`:
+* - `require.resolve('@openai/codex-sdk')` fails with "No exports main defined"
+*   because there's no `"require"` or `"default"` condition.
+*
+* ## Solution
+*
+* This function uses `exsolve` which implements Node's ESM resolution algorithm,
+* correctly handling all `exports` field variations:
+* - Direct string exports: `"exports": "./index.js"`
+* - Shorthand object: `"exports": { ".": "./index.js" }`
+* - Conditional exports: `"exports": { ".": { "import": "./index.js" } }`
+* - Nested conditionals, array fallbacks, pattern exports, etc.
+*
+* @param packageName - The npm package name (e.g., '@openai/codex-sdk')
+* @param baseDir - The directory to resolve from (should contain node_modules)
+* @returns The absolute path to the package entry point, or null if not found
+*
+* @example
+* ```typescript
+* // Resolve from current directory
+* const codexPath = resolvePackageEntryPoint('@openai/codex-sdk', process.cwd());
+* if (codexPath) {
+*   const module = await importModule(codexPath);
+* }
+* ```
+*/
+function resolvePackageEntryPoint(packageName, baseDir) {
+	const from = pathToFileURL(path$1.join(baseDir, "package.json")).href;
+	const resolved = resolveModulePath(packageName, {
+		from,
+		conditions: [
+			"node",
+			"import",
+			"require",
+			"default"
+		],
+		try: true
+	});
+	return resolved ? path$1.normalize(resolved) : null;
+}
+/**
+* ESM replacement for __dirname - guarded for dual CJS/ESM builds.
+*
+* This is the canonical way to get the current directory in dual ESM/CJS code.
+* Use this instead of implementing the try-catch pattern in each file.
+*
+* Build contexts:
+* - ESM (production/bundled): BUILD_FORMAT='esm', import.meta.url is valid
+* - CJS (library build): BUILD_FORMAT='cjs', import.meta.url may be empty, __dirname available
+* - Development (tsx): BUILD_FORMAT=undefined, import.meta.url is valid
+* - Vitest tests: BUILD_FORMAT=undefined, import.meta is valid in ESM mode
+*
+* The try-catch is necessary because `import.meta` syntax itself causes a SyntaxError
+* in CJS environments (Node require), not just an undefined value.
+*/
+function getDirectory() {
+	try {
+		const url = import.meta.url;
+		if (url && url !== "") return path$1.dirname(fileURLToPath(url));
+	} catch {}
+	if (typeof __dirname !== "undefined") return __dirname;
+	throw new Error("Unable to determine directory: neither import.meta.url nor __dirname available. This indicates an unsupported module environment.");
+}
+/**
+* ESM-only module loader - simplified without eval() or CommonJS fallback
+* Uses Node.js native ESM import with proper URL resolution
+*/
+async function importModule(modulePath, functionName) {
+	logger.debug(`Attempting to import module: ${JSON.stringify({
+		resolvedPath: safeResolve(modulePath),
+		moduleId: modulePath
+	})}`);
+	try {
+		if (modulePath.endsWith(".ts") || modulePath.endsWith(".mjs")) {
+			logger.debug("TypeScript/ESM module detected, importing tsx/cjs");
+			await import("tsx/cjs");
+		}
+		const resolvedPath = pathToFileURL(safeResolve(modulePath));
+		const resolvedPathStr = resolvedPath.toString();
+		logger.debug(`Attempting ESM import from: ${resolvedPathStr}`);
+		const importedModule = await import(resolvedPathStr);
+		const mod = importedModule?.default?.default || importedModule?.default || importedModule;
+		logger.debug(`Successfully imported module: ${JSON.stringify({
+			resolvedPath,
+			moduleId: modulePath
+		})}`);
+		if (functionName) {
+			logger.debug(`Returning named export: ${functionName}`);
+			return mod[functionName];
+		}
+		return mod;
+	} catch (err) {
+		const errorMessage = err instanceof Error ? err.message : String(err);
+		if (modulePath.endsWith(".js") && isCjsInEsmError(errorMessage)) {
+			logger.debug(`ESM import failed for ${modulePath}, attempting vm-based CJS fallback: ${errorMessage}`);
+			try {
+				const resolvedPath = safeResolve(modulePath);
+				const mod = loadCjsModule(resolvedPath);
+				logger.debug(`Successfully loaded module via CJS fallback: ${JSON.stringify({
+					resolvedPath,
+					moduleId: modulePath
+				})}`);
+				if (functionName) {
+					logger.debug(`Returning named export: ${functionName}`);
+					return mod[functionName];
+				}
+				return mod;
+			} catch (cjsErr) {
+				const cjsErrorMessage = cjsErr instanceof Error ? cjsErr.message : String(cjsErr);
+				logger.error(`ESM import failed for ${modulePath}: ${errorMessage}`);
+				logger.error(`CJS fallback also failed: ${cjsErrorMessage}`);
+				const combinedError = /* @__PURE__ */ new Error(`Failed to load module ${modulePath}:\n  ESM import error: ${errorMessage}\n  CJS fallback error: ${cjsErrorMessage}\nTo fix this, either:\n  1. Rename the file to .cjs (recommended for CommonJS)\n  2. Convert to ESM syntax (import/export)\n  3. Ensure the file has valid JavaScript syntax`);
+				combinedError.cause = {
+					esmError: err,
+					cjsError: cjsErr
+				};
+				throw combinedError;
+			}
+		}
+		const e = err;
+		if (e.stack) logger.debug(e.stack);
+		if (err.code === "ERR_MODULE_NOT_FOUND") {
+			const resolvedModulePath = safeResolve(modulePath);
+			try {
+				await fsPromises.access(resolvedModulePath);
+				logger.error(`ESM import failed: ${err}`);
+			} catch {
+				const enoentError = /* @__PURE__ */ new Error(`ENOENT: no such file or directory, open '${resolvedModulePath}'`);
+				enoentError.code = "ENOENT";
+				enoentError.path = resolvedModulePath;
+				throw enoentError;
+			}
+		} else logger.error(`ESM import failed: ${err}`);
+		throw err;
+	}
+}
+/**
+* Detects if an error message indicates a CommonJS module being loaded in ESM context.
+*/
+function isCjsInEsmError(message) {
+	return [
+		"require is not defined",
+		"module is not defined",
+		"exports is not defined",
+		"__dirname is not defined",
+		"__filename is not defined",
+		"Cannot use import statement",
+		"ERR_REQUIRE_ESM"
+	].some((pattern) => message.includes(pattern));
+}
+/**
+* Loads a CommonJS module by executing it in a vm context with proper CJS globals.
+* This bypasses Node.js's module type detection which is based on package.json "type" field.
+*
+* SECURITY NOTE: This is NOT a security sandbox. The executed code has full access to
+* the file system, network, etc. via the injected require function and process object.
+* This is intentional - it's designed for loading trusted user configuration files
+* (custom providers, assertions, hooks) that need full Node.js capabilities.
+*/
+function loadCjsModule(modulePath) {
+	const code = fs.readFileSync(modulePath, "utf-8");
+	const dirname = path$1.dirname(modulePath);
+	const filename = modulePath;
+	const moduleRequire = createRequire(pathToFileURL(modulePath).href);
+	const moduleObj = { exports: {} };
+	const context = vm.createContext({
+		module: moduleObj,
+		exports: moduleObj.exports,
+		require: moduleRequire,
+		__dirname: dirname,
+		__filename: filename,
+		global: globalThis,
+		globalThis,
+		console,
+		process,
+		Buffer,
+		setTimeout,
+		setInterval,
+		setImmediate,
+		clearTimeout,
+		clearInterval,
+		clearImmediate,
+		queueMicrotask,
+		URL,
+		URLSearchParams,
+		TextEncoder,
+		TextDecoder,
+		atob: globalThis.atob,
+		btoa: globalThis.btoa,
+		fetch: globalThis.fetch,
+		Request: globalThis.Request,
+		Response: globalThis.Response,
+		Headers: globalThis.Headers,
+		AbortController: globalThis.AbortController,
+		AbortSignal: globalThis.AbortSignal,
+		Event: globalThis.Event,
+		EventTarget: globalThis.EventTarget,
+		Error,
+		TypeError,
+		ReferenceError,
+		SyntaxError,
+		RangeError,
+		Array,
+		Object,
+		String,
+		Number,
+		Boolean,
+		Symbol,
+		Map,
+		Set,
+		WeakMap,
+		WeakSet,
+		Promise,
+		Proxy,
+		Reflect,
+		JSON,
+		Math,
+		Date,
+		RegExp,
+		Int8Array,
+		Uint8Array,
+		Uint8ClampedArray,
+		Int16Array,
+		Uint16Array,
+		Int32Array,
+		Uint32Array,
+		Float32Array,
+		Float64Array,
+		BigInt64Array,
+		BigUint64Array,
+		DataView,
+		ArrayBuffer,
+		SharedArrayBuffer: globalThis.SharedArrayBuffer,
+		Atomics: globalThis.Atomics,
+		BigInt,
+		eval: void 0,
+		Function,
+		isNaN,
+		isFinite,
+		parseFloat,
+		parseInt,
+		decodeURI,
+		decodeURIComponent,
+		encodeURI,
+		encodeURIComponent
+	});
+	vm.runInContext(code, context, { filename: modulePath });
+	return moduleObj.exports;
+}
+//#endregion
+export { safeJoin as a, resolvePackageEntryPoint as i, getWrapperDir as n, safeResolve as o, importModule as r, getDirectory as t };
+
+//# sourceMappingURL=esm-DMVc93eh.js.map

package/dist/src/evalResult-C3NJPQOo.cjs

@@ -0,0 +1,301 @@
+const require_logger = require("./logger-DyfK9PBt.cjs");
+const require_types = require("./types-5aqHpBwE.cjs");
+const require_fetch = require("./fetch-BTxakTSg.cjs");
+const require_utils = require("./utils-yWamDvmz.cjs");
+const require_tables = require("./tables-3Q2cL7So.cjs");
+const require_extractor = require("./extractor-DnMD3fwt.cjs");
+let drizzle_orm = require("drizzle-orm");
+//#region src/models/evalResult.ts
+function sanitizeProvider(provider) {
+	try {
+		if (require_types.isApiProvider(provider)) return {
+			id: provider.id(),
+			label: provider.label,
+			...provider.config && { config: JSON.parse(require_logger.safeJsonStringify(provider.config)) }
+		};
+		if (require_types.isProviderOptions(provider)) return {
+			id: provider.id,
+			label: provider.label,
+			...provider.config && { config: JSON.parse(require_logger.safeJsonStringify(provider.config)) }
+		};
+		if (typeof provider === "object" && provider) {
+			const providerObj = provider;
+			return {
+				id: typeof providerObj.id === "function" ? providerObj.id() : providerObj.id,
+				label: providerObj.label,
+				...providerObj.config && { config: JSON.parse(require_logger.safeJsonStringify(providerObj.config)) }
+			};
+		}
+	} catch {}
+	return JSON.parse(require_logger.safeJsonStringify(provider));
+}
+/**
+* Sanitize an object for database storage by removing circular references
+* and non-serializable values (functions, Timeout objects, etc.).
+* Uses safeJsonStringify which handles circular references gracefully.
+*
+* This prevents "Converting circular structure to JSON" errors that can occur
+* when Node.js Timeout objects or other non-serializable data leaks into results.
+* See: https://github.com/promptfoo/promptfoo/issues/7266
+*/
+function sanitizeForDb(obj) {
+	if (obj === null || obj === void 0) return obj;
+	try {
+		const serialized = require_logger.safeJsonStringify(obj);
+		if (serialized === void 0) {
+			require_logger.logger.debug("sanitizeForDb: Failed to serialize object, using fallback", {
+				valueType: typeof obj,
+				isArray: Array.isArray(obj)
+			});
+			return Array.isArray(obj) ? [] : null;
+		}
+		return JSON.parse(serialized);
+	} catch (error) {
+		require_logger.logger.debug("sanitizeForDb: Parse error, using fallback", { error });
+		return Array.isArray(obj) ? [] : null;
+	}
+}
+var EvalResult = class EvalResult {
+	static async createFromEvaluateResult(evalId, result, opts) {
+		const persist = opts?.persist == null ? true : opts.persist;
+		const { prompt, error, score, latencyMs, success, provider, gradingResult, namedScores, cost, metadata, failureReason, testCase } = result;
+		const preSanitizeTestCase = {
+			...testCase,
+			...testCase.provider && { provider: sanitizeProvider(testCase.provider) }
+		};
+		const processedResponse = await require_extractor.extractAndStoreBinaryData(result.response, {
+			evalId,
+			testIdx: result.testIdx,
+			promptIdx: result.promptIdx
+		});
+		const args = {
+			id: crypto.randomUUID(),
+			evalId,
+			testCase: sanitizeForDb(preSanitizeTestCase),
+			promptIdx: result.promptIdx,
+			testIdx: result.testIdx,
+			prompt: sanitizeForDb(prompt),
+			promptId: require_utils.hashPrompt(prompt),
+			error: error?.toString(),
+			success,
+			score: score == null ? 0 : score,
+			response: sanitizeForDb(processedResponse || null),
+			gradingResult: sanitizeForDb(gradingResult || null),
+			namedScores: sanitizeForDb(namedScores),
+			provider: sanitizeProvider(provider),
+			latencyMs,
+			cost,
+			metadata: sanitizeForDb(metadata),
+			failureReason
+		};
+		if (persist) return new EvalResult({
+			...(await require_tables.getDb().insert(require_tables.evalResultsTable).values(args).returning())[0],
+			persisted: true
+		});
+		return new EvalResult(args);
+	}
+	static async createManyFromEvaluateResult(results, evalId) {
+		const db = require_tables.getDb();
+		const returnResults = [];
+		const processedResults = [];
+		for (const result of results) {
+			const processedResponse = require_extractor.isBlobStorageEnabled() ? await require_extractor.extractAndStoreBinaryData(result.response, {
+				evalId,
+				testIdx: result.testIdx,
+				promptIdx: result.promptIdx
+			}) : result.response;
+			processedResults.push({
+				...result,
+				response: processedResponse ?? void 0
+			});
+		}
+		db.transaction(() => {
+			for (const result of processedResults) {
+				const sanitizedResult = {
+					...result,
+					testCase: sanitizeForDb(result.testCase),
+					prompt: sanitizeForDb(result.prompt),
+					response: sanitizeForDb(result.response),
+					gradingResult: sanitizeForDb(result.gradingResult),
+					namedScores: sanitizeForDb(result.namedScores),
+					metadata: sanitizeForDb(result.metadata),
+					provider: result.provider ? sanitizeProvider(result.provider) : result.provider
+				};
+				const dbResult = db.insert(require_tables.evalResultsTable).values({
+					...sanitizedResult,
+					evalId,
+					id: crypto.randomUUID()
+				}).returning().get();
+				returnResults.push(new EvalResult({
+					...dbResult,
+					persisted: true
+				}));
+			}
+		});
+		return returnResults;
+	}
+	static async findById(id) {
+		const result = await require_tables.getDb().select().from(require_tables.evalResultsTable).where((0, drizzle_orm.eq)(require_tables.evalResultsTable.id, id));
+		return result.length > 0 ? new EvalResult({
+			...result[0],
+			persisted: true
+		}) : null;
+	}
+	static async findManyByEvalId(evalId, opts) {
+		return (await require_tables.getDb().select().from(require_tables.evalResultsTable).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_tables.evalResultsTable.evalId, evalId), opts?.testIdx == null ? void 0 : (0, drizzle_orm.eq)(require_tables.evalResultsTable.testIdx, opts.testIdx)))).map((result) => new EvalResult({
+			...result,
+			persisted: true
+		}));
+	}
+	static async findManyByEvalIdAndTestIndices(evalId, testIndices) {
+		if (!testIndices.length) return [];
+		return (await require_tables.getDb().select().from(require_tables.evalResultsTable).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_tables.evalResultsTable.evalId, evalId), testIndices.length === 1 ? (0, drizzle_orm.eq)(require_tables.evalResultsTable.testIdx, testIndices[0]) : (0, drizzle_orm.inArray)(require_tables.evalResultsTable.testIdx, testIndices)))).map((result) => new EvalResult({
+			...result,
+			persisted: true
+		}));
+	}
+	/**
+	* Returns a set of completed (testIdx,promptIdx) pairs for a given eval.
+	* Key format: `${testIdx}:${promptIdx}`
+	*
+	* @param evalId - The evaluation ID to query
+	* @param opts.excludeErrors - If true, excludes results with ERROR failureReason (used in retry mode)
+	*/
+	static async getCompletedIndexPairs(evalId, opts) {
+		const db = require_tables.getDb();
+		const whereClause = opts?.excludeErrors ? (0, drizzle_orm.and)((0, drizzle_orm.eq)(require_tables.evalResultsTable.evalId, evalId), (0, drizzle_orm.ne)(require_tables.evalResultsTable.failureReason, require_types.ResultFailureReason.ERROR)) : (0, drizzle_orm.eq)(require_tables.evalResultsTable.evalId, evalId);
+		const rows = await db.select({
+			testIdx: require_tables.evalResultsTable.testIdx,
+			promptIdx: require_tables.evalResultsTable.promptIdx
+		}).from(require_tables.evalResultsTable).where(whereClause);
+		const ret = /* @__PURE__ */ new Set();
+		for (const r of rows) ret.add(`${r.testIdx}:${r.promptIdx}`);
+		return ret;
+	}
+	static async *findManyByEvalIdBatched(evalId, opts) {
+		const db = require_tables.getDb();
+		const batchSize = opts?.batchSize || 100;
+		let offset = 0;
+		while (true) {
+			const results = await db.select().from(require_tables.evalResultsTable).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(require_tables.evalResultsTable.evalId, evalId), (0, drizzle_orm.gte)(require_tables.evalResultsTable.testIdx, offset), (0, drizzle_orm.lt)(require_tables.evalResultsTable.testIdx, offset + batchSize))).all();
+			if (results.length === 0) break;
+			yield results.map((result) => new EvalResult({
+				...result,
+				persisted: true
+			}));
+			offset += batchSize;
+		}
+	}
+	id;
+	evalId;
+	description;
+	promptIdx;
+	testIdx;
+	testCase;
+	prompt;
+	promptId;
+	error;
+	success;
+	score;
+	response;
+	gradingResult;
+	namedScores;
+	provider;
+	latencyMs;
+	cost;
+	metadata;
+	failureReason;
+	persisted;
+	pluginId;
+	constructor(opts) {
+		this.id = opts.id;
+		this.evalId = opts.evalId;
+		this.promptIdx = opts.promptIdx;
+		this.testIdx = opts.testIdx;
+		this.testCase = opts.testCase;
+		this.prompt = opts.prompt;
+		this.promptId = opts.promptId || require_utils.hashPrompt(opts.prompt);
+		this.error = opts.error;
+		this.score = opts.score;
+		this.success = opts.success;
+		this.response = opts.response || void 0;
+		this.gradingResult = opts.gradingResult;
+		this.namedScores = opts.namedScores || {};
+		this.provider = opts.provider;
+		this.latencyMs = opts.latencyMs || 0;
+		this.cost = opts.cost || 0;
+		this.metadata = opts.metadata || {};
+		this.failureReason = require_types.isResultFailureReason(opts.failureReason) ? opts.failureReason : require_types.ResultFailureReason.NONE;
+		this.persisted = opts.persisted || false;
+		this.pluginId = opts.testCase.metadata?.pluginId;
+	}
+	async save() {
+		const db = require_tables.getDb();
+		if (this.persisted) await db.update(require_tables.evalResultsTable).set({
+			...this,
+			updatedAt: require_fetch.getCurrentTimestamp()
+		}).where((0, drizzle_orm.eq)(require_tables.evalResultsTable.id, this.id));
+		else {
+			this.id = (await db.insert(require_tables.evalResultsTable).values(this).returning())[0].id;
+			this.persisted = true;
+		}
+	}
+	toEvaluateResult() {
+		const shouldStripPromptText = require_logger.getEnvBool("PROMPTFOO_STRIP_PROMPT_TEXT", false);
+		const shouldStripResponseOutput = require_logger.getEnvBool("PROMPTFOO_STRIP_RESPONSE_OUTPUT", false);
+		const shouldStripTestVars = require_logger.getEnvBool("PROMPTFOO_STRIP_TEST_VARS", false);
+		const shouldStripGradingResult = require_logger.getEnvBool("PROMPTFOO_STRIP_GRADING_RESULT", false);
+		const shouldStripMetadata = require_logger.getEnvBool("PROMPTFOO_STRIP_METADATA", false);
+		const response = shouldStripResponseOutput && this.response ? {
+			...this.response,
+			output: "[output stripped]"
+		} : this.response;
+		const prompt = shouldStripPromptText ? {
+			...this.prompt,
+			raw: "[prompt stripped]"
+		} : this.prompt;
+		const testCase = shouldStripTestVars ? {
+			...this.testCase,
+			vars: void 0
+		} : this.testCase;
+		return {
+			cost: this.cost,
+			description: this.description || void 0,
+			error: this.error || void 0,
+			gradingResult: shouldStripGradingResult ? null : this.gradingResult,
+			id: this.id,
+			latencyMs: this.latencyMs,
+			namedScores: this.namedScores,
+			prompt,
+			promptId: this.promptId,
+			promptIdx: this.promptIdx,
+			provider: {
+				id: this.provider.id,
+				label: this.provider.label
+			},
+			response,
+			score: this.score,
+			success: this.success,
+			testCase,
+			testIdx: this.testIdx,
+			vars: shouldStripTestVars ? {} : this.testCase.vars || {},
+			metadata: shouldStripMetadata ? {} : this.metadata,
+			failureReason: this.failureReason
+		};
+	}
+};
+//#endregion
+Object.defineProperty(exports, "EvalResult", {
+	enumerable: true,
+	get: function() {
+		return EvalResult;
+	}
+});
+Object.defineProperty(exports, "sanitizeProvider", {
+	enumerable: true,
+	get: function() {
+		return sanitizeProvider;
+	}
+});
+
+//# sourceMappingURL=evalResult-C3NJPQOo.cjs.map