promptfoo 0.125.0 → 0.125.1

package/dist/src/eval-Cer9dPe9.js

@@ -0,0 +1,1920 @@
+#!/usr/bin/env node
+import { S as sanitizeConfigForOutput, T as sanitizeTracingConfigForPersistence, c as logger, w as sanitizeRuntimeOptions } from "./logger-pCNnmVuz.js";
+import { A as hashPrompt, F as HUMAN_ASSERTION_TYPE, _ as getCachedResultsCount, a as getStripFlags, c as projectPrompt, d as stripTraceLinkageFromMetadata, g as notifyEvaluationsDeleted, h as notifyEvaluationChanged, i as getResultIndexKey, l as projectTracesForOutput, n as PROMPTFOO_METADATA_KEY, o as persistRepeatMetadata, p as invalidateEvaluationCache, s as persistTraceMetadata, t as EvalResult, v as getTotalResultRowCount, y as queryTestIndicesOptimized } from "./evalResult-DzOq5wt9.js";
+import { N as isNonTransientHttpStatus, w as NON_TRANSIENT_HTTP_STATUSES } from "./fetch-RXHsZF-J.js";
+import { t as invariant } from "./invariant-CbHB1xyx.js";
+import { a as getAuthor } from "./accounts-BOxNYxVN.js";
+import { t as getCurrentTimestamp } from "./time-Ct6CnABs.js";
+import { O as ResultFailureReason, St as PLUGIN_CATEGORIES, a as evalResultsTable, c as evalsToPromptsTable, d as promptsTable, f as spansTable, g as getDb, i as datasetsTable, l as evalsToTagsTable, m as tracesTable, nt as riskCategorySeverityMap, o as evalsTable, p as tagsTable, s as evalsToDatasetsTable } from "./tables-BONxKPrt.js";
+import { n as sha256, t as randomSequence } from "./createHash-DqA6GWxE.js";
+import { n as getTraceStore } from "./store-DFoDZ_D2.js";
+import { c as accumulateTokenUsage, d as createEmptyTokenUsage, r as accumulateGenerationTokenUsage } from "./tokenUsageUtils-CHs91tUW.js";
+import { t as getActualPrompt } from "./providerResponse-ChVTuVd0.js";
+import { and, desc, eq, inArray, sql } from "drizzle-orm";
+//#region src/database/evalDeletion.ts
+const SQLITE_MAX_BOUND_PARAMETERS = 999;
+/**
+* Removes spans and traces tied to the given eval ids.
+*
+* `traces.evaluation_id -> evals.id` and `spans.trace_id -> traces.trace_id` are
+* FK-enforced (see `pragma foreign_keys = ON`) without `ON DELETE CASCADE`, so any
+* eval-deletion path must clear spans before traces before the eval row itself.
+*
+* Spans are removed via a correlated subquery so the query stays within SQLite's
+* bound-parameter limit even when an eval has many traces.
+*/
+async function deleteTraceRecordsForEvals(db, evalIds) {
+	for (let i = 0; i < evalIds.length; i += SQLITE_MAX_BOUND_PARAMETERS) {
+		const evalIdBatch = evalIds.slice(i, i + SQLITE_MAX_BOUND_PARAMETERS);
+		await db.delete(spansTable).where(sql`${spansTable.traceId} in (
+          select ${tracesTable.traceId}
+          from ${tracesTable}
+          where ${inArray(tracesTable.evaluationId, evalIdBatch)}
+        )`).run();
+		await db.delete(tracesTable).where(inArray(tracesTable.evaluationId, evalIdBatch)).run();
+	}
+}
+//#endregion
+//#region src/presentation/redteamMetrics.ts
+/** Percentage of tests that failed grading; zero when there are no tests. */
+function calculateAttackSuccessRate(testCount, failCount) {
+	return testCount > 0 ? failCount / testCount * 100 : 0;
+}
+//#endregion
+//#region src/presentation/redteamConfig.ts
+function getRiskCategorySeverityMap(plugins) {
+	const overrides = plugins?.reduce((acc, plugin) => {
+		if (plugin.severity) {
+			acc[plugin.id] = plugin.severity;
+			const policyId = plugin.config?.policy?.id;
+			if (plugin.id === "policy" && policyId) acc[policyId] = plugin.severity;
+		}
+		return acc;
+	}, {}) || {};
+	return {
+		...riskCategorySeverityMap,
+		...overrides
+	};
+}
+//#endregion
+//#region src/util/calculateFilteredMetrics.ts
+/**
+* Calculate metrics for filtered evaluation results.
+*
+* This module implements optimized SQL aggregation to calculate metrics for
+* filtered evaluation datasets. It uses a single GROUP BY query to aggregate
+* ALL prompts at once, achieving significant performance improvements over
+* the naive approach of querying each prompt separately.
+*
+* SECURITY: This module uses Drizzle's sql template strings for parameterized queries
+* to prevent SQL injection. The whereSql parameter is a SQL fragment, not a string,
+* ensuring all user-provided values are properly escaped.
+*
+* Performance targets:
+* - Simple eval (2 prompts, 100 results): <50ms
+* - Complex eval (10 prompts, 1000 results): <150ms
+* - Large eval (10 prompts, 10000 results): <500ms
+*
+* Critical design decisions:
+* 1. Single GROUP BY query for all basic metrics + token usage
+* 2. SQL JSON aggregation for named scores (avoids memory issues)
+* 3. SQL JSON aggregation for assertions (complex nested JSON)
+* 4. OOM protection with MAX_RESULTS_FOR_METRICS limit
+*/
+/**
+* Maximum number of results to process for metrics calculation.
+* Protects against OOM on extremely large filtered datasets.
+*/
+const MAX_RESULTS_FOR_METRICS = 5e4;
+function jsonUsageNumber(column, usagePath, field) {
+	return sql`COALESCE(CAST(json_extract(${column}, ${`${usagePath}.${field}`}) AS INTEGER), 0)`;
+}
+function jsonUsageTotal(column, usagePath, cachedResponsePath) {
+	const explicitTotal = sql`CAST(json_extract(${column}, ${`${usagePath}.total`}) AS INTEGER)`;
+	const prompt = jsonUsageNumber(column, usagePath, "prompt");
+	const completion = jsonUsageNumber(column, usagePath, "completion");
+	const cached = jsonUsageNumber(column, usagePath, "cached");
+	const requests = sql`CAST(json_extract(${column}, ${`${usagePath}.numRequests`}) AS INTEGER)`;
+	const explicitlyCached = cachedResponsePath ? sql`COALESCE(json_extract(${column}, ${cachedResponsePath}), 0) = 1` : sql`0`;
+	return sql`CASE
+    WHEN ${explicitlyCached} THEN
+      CASE
+        WHEN COALESCE(${explicitTotal}, 0) > 0 THEN ${explicitTotal}
+        WHEN ${cached} > 0 THEN ${cached}
+        ELSE ${prompt} + ${completion}
+      END
+    WHEN ${explicitTotal} IS NOT NULL THEN ${explicitTotal}
+    WHEN ${requests} = 0 AND ${cached} > 0 AND (${prompt} + ${completion}) <= ${cached} THEN 0
+    ELSE ${prompt} + ${completion}
+  END`;
+}
+function jsonUsageRequests(column, usagePath, cachedResponsePath) {
+	const explicitlyCached = cachedResponsePath ? sql`COALESCE(json_extract(${column}, ${cachedResponsePath}), 0) = 1` : sql`0`;
+	return sql`CASE
+    WHEN json_extract(${column}, ${usagePath}) IS NULL THEN 0
+    WHEN ${explicitlyCached} THEN
+      MAX(COALESCE(CAST(json_extract(${column}, ${`${usagePath}.numRequests`}) AS INTEGER), 1), 1)
+    ELSE COALESCE(CAST(json_extract(${column}, ${`${usagePath}.numRequests`}) AS INTEGER), 1)
+  END`;
+}
+function jsonUsageCached(column, usagePath, cachedResponsePath) {
+	const cached = jsonUsageNumber(column, usagePath, "cached");
+	if (!cachedResponsePath) return cached;
+	const reportedTotal = sql`COALESCE(
+    CAST(json_extract(${column}, ${`${usagePath}.total`}) AS INTEGER),
+    ${jsonUsageNumber(column, usagePath, "prompt")} + ${jsonUsageNumber(column, usagePath, "completion")}
+  )`;
+	return sql`CASE
+    WHEN COALESCE(json_extract(${column}, ${cachedResponsePath}), 0) = 1 THEN
+      CASE WHEN ${cached} > 0 THEN ${cached} ELSE ${reportedTotal} END
+    ELSE ${cached}
+  END`;
+}
+function jsonUsageField(column, usagePath, field, cachedResponsePath) {
+	switch (field) {
+		case "total": return jsonUsageTotal(column, usagePath, cachedResponsePath);
+		case "numRequests": return jsonUsageRequests(column, usagePath, cachedResponsePath);
+		case "cached": return jsonUsageCached(column, usagePath, cachedResponsePath);
+		default: return jsonUsageNumber(column, usagePath, field);
+	}
+}
+function jsonIncurredUsageField(column, logicalPath, incurredPath, field, options) {
+	const logicalUsage = jsonUsageField(column, logicalPath, field, options?.cachedResponsePath);
+	const incurredUsage = jsonUsageField(column, incurredPath, field);
+	const parentHasIncurredUsage = options?.parentIncurredPath ? sql`json_extract(${column}, ${options.parentIncurredPath}) IS NOT NULL` : sql`0`;
+	const explicitlyCached = options?.cachedResponsePath ? sql`COALESCE(json_extract(${column}, ${options.cachedResponsePath}), 0) = 1` : sql`0`;
+	return sql`CASE
+    WHEN json_extract(${column}, ${incurredPath}) IS NOT NULL THEN ${incurredUsage}
+    WHEN ${parentHasIncurredUsage} OR ${explicitlyCached} THEN 0
+    ELSE ${logicalUsage}
+  END`;
+}
+function getTokenUsageCounts(row, prefix) {
+	return {
+		total: row[`${prefix}total_tokens`] || 0,
+		prompt: row[`${prefix}prompt_tokens`] || 0,
+		completion: row[`${prefix}completion_tokens`] || 0,
+		cached: row[`${prefix}cached_tokens`] || 0,
+		numRequests: (prefix ? row[`${prefix}num_requests`] : row.num_requests_with_tokens) || 0
+	};
+}
+function getFilteredTokenUsage(row) {
+	return {
+		...getTokenUsageCounts(row, ""),
+		attacker: getTokenUsageCounts(row, "attacker_"),
+		assertions: getTokenUsageCounts(row, "grading_"),
+		...row.has_incurred_usage > 0 && { incurredTokenUsage: {
+			...getTokenUsageCounts(row, "incurred_"),
+			attacker: getTokenUsageCounts(row, "incurred_attacker_"),
+			assertions: getTokenUsageCounts(row, "incurred_grading_")
+		} }
+	};
+}
+/**
+* Aggregate filtered rows across all prompts. The count limit bounds the query;
+* three grouped queries collect row metrics, named scores, and assertion counts.
+*/
+async function calculateFilteredMetrics(opts) {
+	const { numPrompts, whereSql } = opts;
+	try {
+		const countResult = await getResultCount(whereSql);
+		if (countResult > MAX_RESULTS_FOR_METRICS) {
+			logger.warn(`Filtered result count ${countResult} exceeds limit ${MAX_RESULTS_FOR_METRICS}`, { evalId: opts.evalId });
+			throw new Error(`Result count ${countResult} exceeds maximum ${MAX_RESULTS_FOR_METRICS}`);
+		}
+		return await calculateWithOptimizedQuery(opts);
+	} catch (error) {
+		logger.error("Failed to calculate filtered metrics", { error });
+		return createEmptyMetricsArray(numPrompts);
+	}
+}
+/**
+* Get count of filtered results (for OOM protection)
+*
+* SECURITY: Uses parameterized SQL query via Drizzle's sql template strings.
+*/
+async function getResultCount(whereSql) {
+	const db = await getDb();
+	const query = sql`
+    SELECT COUNT(*) as count
+    FROM eval_results
+    WHERE ${whereSql}
+  `;
+	return (await db.get(query))?.count || 0;
+}
+/** Aggregate all prompts together using parameterized SQL. */
+async function calculateWithOptimizedQuery(opts) {
+	const { numPrompts, whereSql } = opts;
+	const db = await getDb();
+	const metrics = createEmptyMetricsArray(numPrompts);
+	const response = sql`response`;
+	const gradingResult = sql`grading_result`;
+	const targetPath = "$.tokenUsage";
+	const incurredTargetPath = "$.tokenUsage.incurredTokenUsage";
+	const attackerPath = "$.tokenUsage.attacker";
+	const incurredAttackerPath = "$.tokenUsage.incurredTokenUsage.attacker";
+	const internalGradingPath = "$.tokenUsage.assertions";
+	const incurredInternalGradingPath = "$.tokenUsage.incurredTokenUsage.assertions";
+	const gradingPath = "$.tokensUsed";
+	const incurredGradingPath = "$.tokensUsed.incurredTokenUsage";
+	const gradingCachePath = "$.metadata.cachedResponse";
+	const responseCachePath = "$.cached";
+	const incurredTargetUsage = (field) => jsonIncurredUsageField(response, targetPath, incurredTargetPath, field, { cachedResponsePath: responseCachePath });
+	const incurredAttackerUsage = (field) => jsonIncurredUsageField(response, attackerPath, incurredAttackerPath, field, {
+		cachedResponsePath: responseCachePath,
+		parentIncurredPath: incurredTargetPath
+	});
+	const incurredInternalGradingUsage = (field) => jsonIncurredUsageField(response, internalGradingPath, incurredInternalGradingPath, field, {
+		cachedResponsePath: responseCachePath,
+		parentIncurredPath: incurredTargetPath
+	});
+	const incurredGradingUsage = (field) => jsonIncurredUsageField(gradingResult, gradingPath, incurredGradingPath, field, { cachedResponsePath: gradingCachePath });
+	const basicMetricsQuery = sql`
+    SELECT
+      prompt_idx,
+      SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as pass_count,
+      SUM(CASE WHEN success = 0 AND failure_reason != ${ResultFailureReason.ERROR} THEN 1 ELSE 0 END) as fail_count,
+      SUM(CASE WHEN failure_reason = ${ResultFailureReason.ERROR} THEN 1 ELSE 0 END) as error_count,
+      SUM(CASE WHEN json_extract(${response}, ${responseCachePath}) = 1 THEN 1 ELSE 0 END) as cache_hit_count,
+      SUM(score) as total_score,
+      SUM(latency_ms) as total_latency,
+      SUM(cost) as total_cost,
+      SUM(CASE WHEN json_extract(response, '$.incurredCost') IS NOT NULL
+        OR json_extract(response, '$.cached') = 1 THEN 1 ELSE 0 END) as has_incurred_cost,
+      SUM(COALESCE(json_extract(response, '$.incurredCost'),
+        CASE WHEN json_extract(response, '$.cached') = 1 THEN 0 ELSE cost END, 0)) as incurred_cost,
+      -- Token usage aggregation (token usage is inside response JSON)
+      SUM(${jsonUsageTotal(response, targetPath)}) as total_tokens,
+      SUM(${jsonUsageNumber(response, targetPath, "prompt")}) as prompt_tokens,
+      SUM(${jsonUsageNumber(response, targetPath, "completion")}) as completion_tokens,
+      SUM(${jsonUsageCached(response, targetPath)}) as cached_tokens,
+      SUM(${jsonUsageRequests(response, targetPath)}) as num_requests_with_tokens,
+      SUM(${jsonUsageTotal(response, attackerPath)}) as attacker_total_tokens,
+      SUM(${jsonUsageNumber(response, attackerPath, "prompt")}) as attacker_prompt_tokens,
+      SUM(${jsonUsageNumber(response, attackerPath, "completion")}) as attacker_completion_tokens,
+      SUM(${jsonUsageCached(response, attackerPath)}) as attacker_cached_tokens,
+      SUM(${jsonUsageRequests(response, attackerPath)}) as attacker_num_requests,
+      SUM(
+        ${jsonUsageTotal(response, internalGradingPath)} +
+        ${jsonUsageTotal(gradingResult, gradingPath, gradingCachePath)}
+      ) as grading_total_tokens,
+      SUM(
+        ${jsonUsageNumber(response, internalGradingPath, "prompt")} +
+        ${jsonUsageNumber(gradingResult, gradingPath, "prompt")}
+      ) as grading_prompt_tokens,
+      SUM(
+        ${jsonUsageNumber(response, internalGradingPath, "completion")} +
+        ${jsonUsageNumber(gradingResult, gradingPath, "completion")}
+      ) as grading_completion_tokens,
+      SUM(
+        ${jsonUsageCached(response, internalGradingPath)} +
+        ${jsonUsageCached(gradingResult, gradingPath, gradingCachePath)}
+      ) as grading_cached_tokens,
+      SUM(
+        ${jsonUsageRequests(response, internalGradingPath)} +
+        ${jsonUsageRequests(gradingResult, gradingPath, gradingCachePath)}
+      ) as grading_num_requests,
+      SUM(
+        CASE
+          WHEN json_extract(response, ${incurredTargetPath}) IS NOT NULL
+            OR json_extract(grading_result, ${incurredGradingPath}) IS NOT NULL
+            OR COALESCE(json_extract(response, ${responseCachePath}), 0) = 1
+            OR COALESCE(json_extract(grading_result, ${gradingCachePath}), 0) = 1
+          THEN 1
+          ELSE 0
+        END
+      ) as has_incurred_usage,
+      SUM(${incurredTargetUsage("total")}) as incurred_total_tokens,
+      SUM(${incurredTargetUsage("prompt")}) as incurred_prompt_tokens,
+      SUM(${incurredTargetUsage("completion")}) as incurred_completion_tokens,
+      SUM(${incurredTargetUsage("cached")}) as incurred_cached_tokens,
+      SUM(${incurredTargetUsage("numRequests")}) as incurred_num_requests,
+      SUM(${incurredAttackerUsage("total")}) as incurred_attacker_total_tokens,
+      SUM(${incurredAttackerUsage("prompt")}) as incurred_attacker_prompt_tokens,
+      SUM(${incurredAttackerUsage("completion")}) as incurred_attacker_completion_tokens,
+      SUM(${incurredAttackerUsage("cached")}) as incurred_attacker_cached_tokens,
+      SUM(${incurredAttackerUsage("numRequests")}) as incurred_attacker_num_requests,
+      SUM(
+        ${incurredInternalGradingUsage("total")} + ${incurredGradingUsage("total")}
+      ) as incurred_grading_total_tokens,
+      SUM(
+        ${incurredInternalGradingUsage("prompt")} + ${incurredGradingUsage("prompt")}
+      ) as incurred_grading_prompt_tokens,
+      SUM(
+        ${incurredInternalGradingUsage("completion")} + ${incurredGradingUsage("completion")}
+      ) as incurred_grading_completion_tokens,
+      SUM(
+        ${incurredInternalGradingUsage("cached")} + ${incurredGradingUsage("cached")}
+      ) as incurred_grading_cached_tokens,
+      SUM(
+        ${incurredInternalGradingUsage("numRequests")} + ${incurredGradingUsage("numRequests")}
+      ) as incurred_grading_num_requests
+    FROM eval_results
+    WHERE ${whereSql}
+    GROUP BY prompt_idx
+    ORDER BY prompt_idx
+  `;
+	const basicResults = await db.all(basicMetricsQuery);
+	for (const row of basicResults) {
+		const idx = row.prompt_idx;
+		if (idx < 0 || idx >= numPrompts) {
+			logger.warn(`Invalid prompt_idx ${idx}, expected 0-${numPrompts - 1}`);
+			continue;
+		}
+		metrics[idx] = {
+			score: row.total_score || 0,
+			testPassCount: row.pass_count || 0,
+			testFailCount: row.fail_count || 0,
+			testErrorCount: row.error_count || 0,
+			testCacheHitCount: row.cache_hit_count || 0,
+			totalLatencyMs: row.total_latency || 0,
+			cost: row.total_cost || 0,
+			...row.has_incurred_cost ? { incurredCost: row.incurred_cost || 0 } : {},
+			tokenUsage: getFilteredTokenUsage(row),
+			namedScores: {},
+			namedScoresCount: {},
+			namedScoreWeights: {},
+			assertPassCount: 0,
+			assertFailCount: 0
+		};
+	}
+	await aggregateNamedScores(metrics, whereSql);
+	await aggregateAssertions(metrics, whereSql);
+	logger.debug("Filtered metrics calculated", {
+		numPrompts,
+		metricsCount: basicResults.length
+	});
+	return metrics;
+}
+/**
+* Aggregate named scores using SQL json_each().
+* This is MUCH more efficient than fetching all results and parsing in JavaScript.
+*
+* SECURITY: Uses parameterized SQL query via Drizzle's sql template strings.
+*
+* Uses SQLite's json_each() to parse JSON in the database, avoiding the need
+* to fetch potentially thousands of rows into memory.
+*/
+async function aggregateNamedScores(metrics, whereSql) {
+	const db = await getDb();
+	const query = sql`
+    SELECT
+      prompt_idx,
+      score_entries.key as metric_name,
+      SUM(
+        CASE
+          WHEN weight_entries.value IS NOT NULL THEN
+            CAST(score_entries.value AS REAL) * CAST(weight_entries.value AS REAL)
+          ELSE CAST(score_entries.value AS REAL)
+        END
+      ) as metric_sum,
+      COUNT(*) as metric_count,
+      SUM(
+        CASE
+          WHEN weight_entries.value IS NOT NULL THEN CAST(weight_entries.value AS REAL)
+          ELSE 1
+        END
+      ) as metric_weight_total
+    FROM eval_results
+    JOIN json_each(eval_results.named_scores) as score_entries
+    LEFT JOIN json_each(
+      CASE
+        WHEN grading_result IS NOT NULL
+          AND json_valid(grading_result)
+          AND json_type(json_extract(grading_result, '$.namedScoreWeights')) = 'object'
+        THEN json_extract(grading_result, '$.namedScoreWeights')
+        ELSE json('{}')
+      END
+    ) as weight_entries
+      ON weight_entries.key = score_entries.key
+    WHERE ${whereSql}
+      AND named_scores IS NOT NULL
+      AND json_valid(named_scores)
+    GROUP BY prompt_idx, score_entries.key
+  `;
+	const results = await db.all(query);
+	for (const row of results) {
+		const idx = row.prompt_idx;
+		if (idx >= 0 && idx < metrics.length && metrics[idx]) {
+			metrics[idx].namedScores[row.metric_name] = row.metric_sum;
+			metrics[idx].namedScoresCount[row.metric_name] = row.metric_count;
+			metrics[idx].namedScoreWeights ||= {};
+			metrics[idx].namedScoreWeights[row.metric_name] = row.metric_weight_total;
+		}
+	}
+}
+/**
+* Aggregate assertion counts using SQL json_each().
+* This requires nested JSON extraction for componentResults.
+*
+* SECURITY: Uses parameterized SQL query via Drizzle's sql template strings.
+*
+* The grading_result structure is:
+* {
+*   "componentResults": [
+*     {"pass": true, "assertion": {...}},
+*     {"pass": false, "assertion": {...}}
+*   ]
+* }
+*
+* We need to count pass=true vs pass=false across all results.
+*/
+async function aggregateAssertions(metrics, whereSql) {
+	const db = await getDb();
+	const query = sql`
+    SELECT
+      prompt_idx,
+      SUM(
+        CASE
+          WHEN json_valid(grading_result) AND json_type(json_extract(grading_result, '$.componentResults')) = 'array' THEN
+            (
+              SELECT COUNT(*)
+              FROM json_each(json_extract(grading_result, '$.componentResults'))
+              WHERE CAST(json_extract(json_each.value, '$.pass') AS INTEGER) = 1
+            )
+          ELSE 0
+        END
+      ) as assert_pass_count,
+      SUM(
+        CASE
+          WHEN json_valid(grading_result) AND json_type(json_extract(grading_result, '$.componentResults')) = 'array' THEN
+            (
+              SELECT COUNT(*)
+              FROM json_each(json_extract(grading_result, '$.componentResults'))
+              WHERE CAST(json_extract(json_each.value, '$.pass') AS INTEGER) = 0
+            )
+          ELSE 0
+        END
+      ) as assert_fail_count
+    FROM eval_results
+    WHERE ${whereSql}
+      AND grading_result IS NOT NULL
+    GROUP BY prompt_idx
+  `;
+	const results = await db.all(query);
+	for (const row of results) {
+		const idx = row.prompt_idx;
+		if (idx >= 0 && idx < metrics.length && metrics[idx]) {
+			metrics[idx].assertPassCount = row.assert_pass_count || 0;
+			metrics[idx].assertFailCount = row.assert_fail_count || 0;
+		}
+	}
+}
+/**
+* Create empty metrics array initialized with zeros.
+* Used as fallback when calculation fails or no results found.
+*/
+function createEmptyMetricsArray(numPrompts) {
+	return Array.from({ length: numPrompts }, () => ({
+		score: 0,
+		testPassCount: 0,
+		testFailCount: 0,
+		testErrorCount: 0,
+		testCacheHitCount: 0,
+		assertPassCount: 0,
+		assertFailCount: 0,
+		totalLatencyMs: 0,
+		tokenUsage: {
+			total: 0,
+			prompt: 0,
+			completion: 0,
+			cached: 0,
+			numRequests: 0
+		},
+		namedScores: {},
+		namedScoresCount: {},
+		namedScoreWeights: {},
+		cost: 0
+	}));
+}
+//#endregion
+//#region src/presentation/evalTableCells.ts
+function getTableCellText(result) {
+	let resultText;
+	const rawOutput = result.response?.output;
+	let outputTextDisplay;
+	if (rawOutput !== null && typeof rawOutput === "object") outputTextDisplay = JSON.stringify(rawOutput);
+	else if (rawOutput == null || rawOutput === "") outputTextDisplay = result.error || "";
+	else outputTextDisplay = String(rawOutput);
+	if (result.testCase.assert) {
+		if (result.success) resultText = `${outputTextDisplay || result.error || ""}`;
+		else resultText = `${outputTextDisplay}`;
+	} else if (result.error) resultText = `${result.error}`;
+	else resultText = outputTextDisplay;
+	return resultText;
+}
+function getTableCellMedia(result) {
+	return {
+		audio: result.response?.audio ? {
+			id: result.response.audio.id,
+			expiresAt: result.response.audio.expiresAt,
+			data: result.response.audio.data,
+			blobRef: result.response.audio.blobRef,
+			transcript: result.response.audio.transcript,
+			format: result.response.audio.format,
+			sampleRate: result.response.audio.sampleRate,
+			channels: result.response.audio.channels,
+			duration: result.response.audio.duration
+		} : void 0,
+		video: result.response?.video ? {
+			id: result.response.video.id,
+			blobRef: result.response.video.blobRef,
+			storageRef: result.response.video.storageRef,
+			url: result.response.video.url,
+			format: result.response.video.format,
+			size: result.response.video.size,
+			duration: result.response.video.duration,
+			thumbnail: result.response.video.thumbnail,
+			spritesheet: result.response.video.spritesheet,
+			model: result.response.video.model,
+			aspectRatio: result.response.video.aspectRatio,
+			resolution: result.response.video.resolution
+		} : void 0,
+		images: result.response?.images?.map((img) => ({
+			data: img.data,
+			blobRef: img.blobRef,
+			mimeType: img.mimeType
+		}))
+	};
+}
+//#endregion
+//#region src/presentation/evalResults.ts
+/** Convert version 4+ results to display rows and ordered variable columns. */
+function convertResultsToTable(eval_) {
+	invariant(eval_.prompts, `Prompts are required in this version of the results file, this needs to be results file version >= 4, version: ${eval_.version}`);
+	const results = eval_.results;
+	const rawPersistedVars = eval_.vars;
+	if (rawPersistedVars !== void 0 && !Array.isArray(rawPersistedVars)) logger.warn(`[convertResultsToTable] eval.vars is ${typeof rawPersistedVars}, not string[]; falling back to alphabetical ordering`);
+	const persistedVarSet = new Set(Array.isArray(rawPersistedVars) ? rawPersistedVars : []);
+	const persistedVars = Array.from(persistedVarSet);
+	const varsForHeader = new Set(persistedVars);
+	const varValuesForRow = /* @__PURE__ */ new Map();
+	const rowMap = {};
+	for (const result of results.results) {
+		for (const varName of Object.keys(result.vars || {})) varsForHeader.add(varName);
+		const row = rowMap[result.testIdx] || {
+			description: result.description || void 0,
+			outputs: [],
+			vars: [],
+			test: result.testCase
+		};
+		const actualPrompt = getActualPrompt(result.response) || result.metadata?.redteamFinalPrompt;
+		if (result.vars && actualPrompt) {
+			const varKeys = Object.keys(result.vars);
+			if (varKeys.length === 1 && varKeys[0] !== "harmCategory") result.vars[varKeys[0]] = actualPrompt;
+			else if (varKeys.length > 1) {
+				const keyToUpdate = [
+					"prompt",
+					"query",
+					"question"
+				].find((key) => result.vars[key]);
+				if (keyToUpdate) result.vars[keyToUpdate] = actualPrompt;
+			}
+		}
+		if (!result.vars?.sessionId) {
+			const metadataSessionIds = result.metadata?.sessionIds;
+			if (Array.isArray(metadataSessionIds) && metadataSessionIds.length > 0) {
+				result.vars = result.vars || {};
+				result.vars.sessionId = metadataSessionIds.filter((id) => id != null && id !== "").map(String).join("\n");
+				varsForHeader.add("sessionId");
+			} else if (result.metadata?.sessionId) {
+				result.vars = result.vars || {};
+				result.vars.sessionId = result.metadata.sessionId;
+				varsForHeader.add("sessionId");
+			}
+		}
+		const transformDisplayVars = result.response?.metadata?.transformDisplayVars;
+		if (transformDisplayVars) {
+			result.vars = result.vars || {};
+			for (const [key, value] of Object.entries(transformDisplayVars)) if (!(key in result.vars)) {
+				result.vars[key] = value;
+				varsForHeader.add(key);
+			} else if (result.vars[key] !== value) logger.debug(`[convertResultsToTable] transformDisplayVars key '${key}' collides with result.vars; preserving original value`);
+		}
+		varValuesForRow.set(result.testIdx, result.vars);
+		rowMap[result.testIdx] = row;
+		const resultText = getTableCellText(result);
+		row.outputs[result.promptIdx] = {
+			id: result.id || `${result.testIdx}-${result.promptIdx}`,
+			...result,
+			text: resultText || "",
+			prompt: result.prompt.raw,
+			provider: result.provider?.label || result.provider?.id || "unknown provider",
+			pass: result.success,
+			failureReason: result.failureReason,
+			cost: result.cost || 0,
+			tokenUsage: result.tokenUsage,
+			...getTableCellMedia(result)
+		};
+		invariant(result.promptId, "Prompt ID is required");
+		row.testIdx = result.testIdx;
+	}
+	const rows = Object.values(rowMap);
+	const additionalVars = [...varsForHeader].filter((name) => !persistedVarSet.has(name)).sort();
+	const orderedVars = persistedVars.length > 0 ? [...persistedVars, ...additionalVars] : additionalVars;
+	for (const row of rows) row.vars = orderedVars.map((varName) => {
+		const varValue = varValuesForRow.get(row.testIdx)?.[varName] ?? "";
+		if (typeof varValue === "string") return varValue;
+		return JSON.stringify(varValue, null, 2);
+	});
+	return {
+		head: {
+			prompts: eval_.prompts,
+			vars: orderedVars
+		},
+		body: rows
+	};
+}
+//#endregion
+//#region src/util/eval/repeatStability.ts
+const WILSON_Z_95 = 1.959963984540054;
+const ERROR_FAILURE_REASON = 2;
+function getWilsonScoreInterval(passed, total) {
+	if (total <= 0 || passed < 0 || passed > total) return;
+	const proportion = passed / total;
+	const zSquared = WILSON_Z_95 ** 2;
+	const denominator = 1 + zSquared / total;
+	const center = (proportion + zSquared / (2 * total)) / denominator;
+	const margin = WILSON_Z_95 / denominator * Math.sqrt(proportion * (1 - proportion) / total + zSquared / (4 * total ** 2));
+	return {
+		confidenceLevel: .95,
+		lower: Math.max(0, center - margin),
+		upper: Math.min(1, center + margin)
+	};
+}
+function isCachedResult(result) {
+	if (result.response?.cached === true) return true;
+	if (!result.gradingResult) return false;
+	const pending = [result.gradingResult];
+	const visited = /* @__PURE__ */ new Set();
+	for (let index = 0; index < pending.length; index++) {
+		const gradingResult = pending[index];
+		if (!gradingResult || typeof gradingResult !== "object" || visited.has(gradingResult)) continue;
+		visited.add(gradingResult);
+		if (gradingResult.metadata?.cachedResponse === true) return true;
+		const components = gradingResult.componentResults;
+		if (Array.isArray(components)) for (let childIndex = 0; childIndex < components.length; childIndex++) pending.push(components[childIndex]);
+	}
+	return false;
+}
+function getGroupKey(result) {
+	return `${result.repeatGroupId}\u0000${result.promptIdx}\u0000${result.provider.id}\u0000${result.provider.label}`;
+}
+var RepeatStabilityCalculator = class {
+	groups = /* @__PURE__ */ new Map();
+	addResults(results) {
+		for (const result of results) this.addResult(result);
+	}
+	addResult(result) {
+		if (!result.repeatGroupId || result.repeatIndex === void 0 || !Number.isInteger(result.repeatIndex) || result.repeatIndex < 0) return;
+		const key = getGroupKey(result);
+		const group = this.groups.get(key) ?? {
+			repeatGroupId: result.repeatGroupId,
+			promptIdx: result.promptIdx,
+			provider: {
+				id: result.provider.id,
+				label: result.provider.label
+			},
+			description: result.description ?? result.testCase.description,
+			promptLabel: result.prompt.label,
+			repetitions: 0,
+			passed: 0,
+			failed: 0,
+			errors: 0,
+			cached: 0,
+			scored: 0,
+			unstable: false
+		};
+		group.repetitions++;
+		if (isCachedResult(result)) group.cached++;
+		if (result.failureReason === ERROR_FAILURE_REASON) group.errors++;
+		else if (result.success) {
+			group.passed++;
+			group.scored++;
+		} else {
+			group.failed++;
+			group.scored++;
+		}
+		group.unstable = group.passed > 0 && group.failed > 0;
+		this.groups.set(key, group);
+	}
+	getSummary() {
+		if (this.groups.size === 0) return;
+		const groups = Array.from(this.groups.values()).map(({ scored, ...group }) => ({
+			...group,
+			...scored > 0 && { passRate: group.passed / scored },
+			...scored > 0 && group.cached === 0 && { passRateConfidenceInterval: getWilsonScoreInterval(group.passed, scored) }
+		}));
+		groups.sort((a, b) => a.repeatGroupId.localeCompare(b.repeatGroupId) || a.promptIdx - b.promptIdx || (a.provider.id ?? "").localeCompare(b.provider.id ?? "") || (a.provider.label ?? "").localeCompare(b.provider.label ?? ""));
+		return {
+			totalGroups: groups.length,
+			unstableGroups: groups.filter((group) => group.unstable).length,
+			groupsWithErrors: groups.filter((group) => group.errors > 0).length,
+			cachedResults: groups.reduce((total, group) => total + group.cached, 0),
+			groups
+		};
+	}
+};
+function calculateRepeatStability(results) {
+	const calculator = new RepeatStabilityCalculator();
+	calculator.addResults(results);
+	return calculator.getSummary();
+}
+//#endregion
+//#region src/util/exportToFile/index.ts
+function convertEvalResultToTableCell(result) {
+	const resultText = getTableCellText(result);
+	return {
+		...result,
+		id: result.id || `${result.testIdx}-${result.promptIdx}`,
+		text: resultText || "",
+		prompt: result.prompt.raw,
+		provider: result.provider?.label || result.provider?.id || "unknown provider",
+		pass: result.success,
+		cost: result.cost || 0,
+		...getTableCellMedia(result)
+	};
+}
+function convertTestResultsToTableRow(results, varsForHeader) {
+	const row = {
+		description: results[0].description || void 0,
+		outputs: [],
+		vars: Object.values(varsForHeader).map((varName) => {
+			if (varName === "sessionId") {
+				const sessionIdFromVars = results[0].testCase.vars?.sessionId;
+				if (sessionIdFromVars != null && sessionIdFromVars !== "") return typeof sessionIdFromVars === "string" ? sessionIdFromVars : JSON.stringify(sessionIdFromVars);
+				const metadataSessionIds = results[0].metadata?.sessionIds;
+				if (Array.isArray(metadataSessionIds) && metadataSessionIds.length > 0) return metadataSessionIds.filter((id) => id != null && id !== "").map(String).join("\n");
+				const metadataSessionId = results[0].metadata?.sessionId;
+				if (metadataSessionId != null) return typeof metadataSessionId === "string" ? metadataSessionId : JSON.stringify(metadataSessionId);
+				return "";
+			}
+			const varValue = results[0].testCase.vars?.[varName] ?? "";
+			if (typeof varValue === "string") return varValue;
+			return JSON.stringify(varValue);
+		}),
+		test: results[0].testCase,
+		testIdx: results[0].testIdx
+	};
+	for (const result of results) row.outputs[result.promptIdx] = convertEvalResultToTableCell(result);
+	return row;
+}
+//#endregion
+//#region src/models/eval.ts
+function createEvalId(createdAt = /* @__PURE__ */ new Date()) {
+	return `eval-${randomSequence(3)}-${createdAt.toISOString().slice(0, 19)}`;
+}
+/**
+* Escapes a key for use in a JSON path expression.
+* Handles backslashes and double quotes which have special meaning in JSON paths.
+*/
+function escapeJsonPathKey(key) {
+	return key.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+/**
+* Builds a JSON path for use as a bound SQLite json_extract() parameter.
+*
+* The field name still needs JSON-path escaping so special characters remain
+* inside the quoted key. SQL safety comes from passing the returned path through
+* Drizzle's `sql` templates as a value, never as raw SQL.
+*/
+function buildSafeJsonPath(field) {
+	return `$."${escapeJsonPathKey(field)}"`;
+}
+/**
+* Combines multiple filter conditions using their associated logic operators (AND/OR).
+*
+* @param filterConditions - Array of conditions with their logic operators
+* @returns A single SQL fragment combining all conditions, or null if empty
+*/
+function combineFilterConditions(filterConditions) {
+	if (filterConditions.length === 0) return null;
+	if (filterConditions.length === 1) return filterConditions[0].condition;
+	return filterConditions.reduce((acc, { condition: cond, logicOperator }, idx) => {
+		if (idx === 0) return cond;
+		return typeof logicOperator === "string" && logicOperator.toUpperCase() === "OR" ? sql`${acc} OR ${cond}` : sql`${acc} AND ${cond}`;
+	}, filterConditions[0].condition);
+}
+var EvalQueries = class {
+	static async getVarsFromEvals(evals) {
+		const db = await getDb();
+		if (evals.length === 0) return {};
+		const evalIds = evals.map((e) => e.id);
+		const query = sql`
+      SELECT DISTINCT j.key, eval_id
+      FROM (
+        SELECT eval_id, json_extract(eval_results.test_case, '$.vars') as vars
+        FROM eval_results
+        WHERE eval_id IN (${sql.join(evalIds, sql`, `)})
+      ) t, json_each(t.vars) j
+    `;
+		const vars = (await db.all(query)).reduce((acc, r) => {
+			acc[r.eval_id] = acc[r.eval_id] || [];
+			acc[r.eval_id].push(r.key);
+			return acc;
+		}, {});
+		for (const list of Object.values(vars)) list.sort();
+		return vars;
+	}
+	static async getVarsFromEval(evalId) {
+		const db = await getDb();
+		const query = sql`
+      SELECT DISTINCT j.key
+      FROM (
+        SELECT json_extract(eval_results.test_case, '$.vars') as vars
+        FROM eval_results
+        WHERE eval_results.eval_id = ${evalId}
+      ) t, json_each(t.vars) j
+    `;
+		return (await db.all(query)).map((r) => r.key).sort();
+	}
+	static async setVars(evalId, vars) {
+		const db = await getDb();
+		try {
+			await db.update(evalsTable).set({ vars }).where(eq(evalsTable.id, evalId)).run();
+		} catch (e) {
+			logger.error(`Error setting vars: ${vars} for eval ${evalId}: ${e}`);
+		}
+	}
+	static async getMetadataKeysFromEval(evalId, comparisonEvalIds = []) {
+		const db = await getDb();
+		try {
+			const allEvalIds = [evalId, ...comparisonEvalIds];
+			const query = sql`
+        SELECT DISTINCT j.key FROM (
+          SELECT metadata FROM eval_results
+          WHERE eval_id IN (${sql.join(allEvalIds, sql`, `)})
+            AND metadata IS NOT NULL
+            AND metadata != '{}'
+            AND json_valid(metadata)
+          LIMIT 10000
+        ) t, json_each(t.metadata) j
+        ORDER BY j.key
+        LIMIT 1000
+      `;
+			return (await db.all(query)).map((r) => r.key).filter((key) => key !== PROMPTFOO_METADATA_KEY);
+		} catch (error) {
+			logger.error(`Error fetching metadata keys for eval ${evalId} and comparisons [${comparisonEvalIds.join(", ")}]: ${error}`);
+			return [];
+		}
+	}
+	/**
+	* Queries all unique metadata values for a given metadata key.
+	* @param evalId - The ID of the eval to get the metadata values from.
+	* @param key - The key of the metadata to get the values from.
+	* @returns An array of unique metadata values.
+	*/
+	static async getMetadataValuesFromEval(evalId, key) {
+		const db = await getDb();
+		const trimmedKey = key.trim();
+		if (!trimmedKey) return [];
+		if (trimmedKey === "__promptfoo" || trimmedKey.startsWith(`__promptfoo.`)) return [];
+		try {
+			const jsonPath = buildSafeJsonPath(trimmedKey);
+			const query = sql`
+        SELECT DISTINCT
+          json_extract(${evalResultsTable.metadata}, ${jsonPath}) AS value
+        FROM ${evalResultsTable}
+        WHERE ${evalResultsTable.evalId} = ${evalId}
+          AND ${evalResultsTable.metadata} IS NOT NULL
+          AND ${evalResultsTable.metadata} != '{}'
+          AND json_valid(${evalResultsTable.metadata})
+          AND json_extract(${evalResultsTable.metadata}, ${jsonPath}) IS NOT NULL
+        ORDER BY value
+        LIMIT 1000
+      `;
+			const values = (await db.all(query)).map(({ value }) => String(value).trim()).filter((value) => value.length > 0);
+			return Array.from(new Set(values));
+		} catch (error) {
+			logger.error(`Error fetching metadata values for eval ${evalId} and key ${trimmedKey}: ${error instanceof Error ? error.message : String(error)}`);
+			return [];
+		}
+	}
+};
+var Eval = class Eval {
+	id;
+	createdAt;
+	author;
+	description;
+	config;
+	results;
+	datasetId;
+	prompts;
+	oldResults;
+	persisted;
+	vars;
+	_resultsLoaded = false;
+	runtimeOptions;
+	_shared = false;
+	resultPersistenceFailed = false;
+	/**
+	* The first non-transient HTTP status among the rows added in this run. It stands in for
+	* the database when that cannot be queried afterwards.
+	*/
+	observedTargetErrorStatus;
+	failedResults = /* @__PURE__ */ new Map();
+	failedEvalResults = /* @__PURE__ */ new Map();
+	finalJsonlResults = /* @__PURE__ */ new Map();
+	observedRepeatedResults = false;
+	/** Total wall-clock duration. For redteam evals: generationDurationMs + evaluationDurationMs.
+	*  For non-redteam evals: equals evaluationDurationMs (generation phase is N/A). */
+	durationMs;
+	/** Time spent generating adversarial test cases (redteam only). */
+	generationDurationMs;
+	/** Time spent running the evaluation phase. */
+	evaluationDurationMs;
+	/**
+	* The shareable URL for this evaluation, if it has been shared.
+	* Set by the evaluate() function when sharing is enabled.
+	*/
+	shareableUrl;
+	static async latest() {
+		const db_results = await (await getDb()).select({ id: evalsTable.id }).from(evalsTable).orderBy(desc(evalsTable.createdAt)).limit(1);
+		if (db_results.length === 0) return;
+		return await Eval.findById(db_results[0].id);
+	}
+	static async findById(id) {
+		const db = await getDb();
+		const evalData = await db.select().from(evalsTable).where(eq(evalsTable.id, id)).all();
+		if (evalData.length === 0) return;
+		const datasetResults = await db.select({ datasetId: evalsToDatasetsTable.datasetId }).from(evalsToDatasetsTable).where(eq(evalsToDatasetsTable.evalId, id)).limit(1).all();
+		const eval_ = evalData[0];
+		const datasetId = datasetResults[0]?.datasetId;
+		const resultsObj = eval_.results;
+		const validateDuration = (raw) => typeof raw === "number" && Number.isFinite(raw) && raw >= 0 ? raw : void 0;
+		const rawDurationMs = validateDuration(resultsObj?.["durationMs"]);
+		const generationDurationMs = validateDuration(resultsObj?.["generationDurationMs"]);
+		const evaluationDurationMs = validateDuration(resultsObj?.["evaluationDurationMs"]);
+		const durationMs = rawDurationMs ?? (generationDurationMs != null || evaluationDurationMs != null ? (generationDurationMs ?? 0) + (evaluationDurationMs ?? 0) : void 0);
+		const evalInstance = new Eval(eval_.config, {
+			id: eval_.id,
+			createdAt: new Date(eval_.createdAt),
+			author: eval_.author,
+			description: eval_.description || void 0,
+			prompts: eval_.prompts || [],
+			datasetId,
+			persisted: true,
+			vars: eval_.vars || [],
+			runtimeOptions: eval_.runtimeOptions ?? void 0,
+			durationMs,
+			generationDurationMs,
+			evaluationDurationMs
+		});
+		if (eval_.results && "table" in eval_.results) evalInstance.oldResults = eval_.results;
+		if (!eval_.vars || eval_.vars.length === 0) {
+			const vars = await EvalQueries.getVarsFromEval(id);
+			evalInstance.setVars(vars);
+			await EvalQueries.setVars(id, vars);
+		}
+		return evalInstance;
+	}
+	static async getMany(limit = 100) {
+		return (await (await getDb()).select({
+			id: evalsTable.id,
+			createdAt: evalsTable.createdAt,
+			author: evalsTable.author,
+			description: evalsTable.description,
+			config: evalsTable.config,
+			prompts: evalsTable.prompts
+		}).from(evalsTable).limit(limit).orderBy(desc(evalsTable.createdAt)).all()).map((e) => new Eval(e.config, {
+			id: e.id,
+			createdAt: new Date(e.createdAt),
+			author: e.author,
+			description: e.description || void 0,
+			prompts: e.prompts || [],
+			persisted: true
+		}));
+	}
+	static async create(config, renderedPrompts, opts) {
+		const createdAt = opts?.createdAt || /* @__PURE__ */ new Date();
+		const evalId = opts?.id || createEvalId(createdAt);
+		const author = opts && "author" in opts ? opts.author ?? null : getAuthor();
+		const db = await getDb();
+		const datasetId = sha256(JSON.stringify(config.tests || []));
+		const durationResults = {
+			...opts?.durationMs !== void 0 && { durationMs: opts.durationMs },
+			...opts?.generationDurationMs !== void 0 && { generationDurationMs: opts.generationDurationMs },
+			...opts?.evaluationDurationMs !== void 0 && { evaluationDurationMs: opts.evaluationDurationMs }
+		};
+		await db.transaction(async (tx) => {
+			await tx.insert(evalsTable).values({
+				id: evalId,
+				createdAt: createdAt.getTime(),
+				author,
+				description: config.description,
+				config: sanitizeTracingConfigForPersistence(config),
+				results: durationResults,
+				vars: opts?.vars || [],
+				runtimeOptions: sanitizeRuntimeOptions(opts?.runtimeOptions),
+				prompts: opts?.completedPrompts || [],
+				isRedteam: config.redteam !== void 0
+			}).run();
+			for (const prompt of renderedPrompts) {
+				const label = prompt.label || prompt.display || prompt.raw;
+				const promptId = hashPrompt(prompt);
+				await tx.insert(promptsTable).values({
+					id: promptId,
+					prompt: label
+				}).onConflictDoNothing().run();
+				await tx.insert(evalsToPromptsTable).values({
+					evalId,
+					promptId
+				}).onConflictDoNothing().run();
+				logger.debug(`Inserting prompt ${promptId}`);
+			}
+			if (opts?.results && opts.results.length > 0) {
+				const res = await tx.insert(evalResultsTable).values(opts.results?.map((r) => ({
+					...r,
+					metadata: persistTraceMetadata(persistRepeatMetadata(r.metadata, r.repeatIndex, r.repeatGroupId), r.traceId, r.evaluationId),
+					evalId,
+					id: crypto.randomUUID()
+				}))).run();
+				logger.debug(`Inserted ${res.rowsAffected} eval results`);
+			}
+			await tx.insert(datasetsTable).values({
+				id: datasetId,
+				tests: config.tests
+			}).onConflictDoNothing().run();
+			await tx.insert(evalsToDatasetsTable).values({
+				evalId,
+				datasetId
+			}).onConflictDoNothing().run();
+			logger.debug(`Inserting dataset ${datasetId}`);
+			if (config.tags) for (const [tagKey, tagValue] of Object.entries(config.tags)) {
+				const tagId = sha256(`${tagKey}:${tagValue}`);
+				await tx.insert(tagsTable).values({
+					id: tagId,
+					name: tagKey,
+					value: tagValue
+				}).onConflictDoNothing().run();
+				await tx.insert(evalsToTagsTable).values({
+					evalId,
+					tagId
+				}).onConflictDoNothing().run();
+				logger.debug(`Inserting tag ${tagId}`);
+			}
+		});
+		invalidateEvaluationCache(evalId);
+		return new Eval(config, {
+			id: evalId,
+			author,
+			createdAt,
+			persisted: true,
+			runtimeOptions: sanitizeRuntimeOptions(opts?.runtimeOptions),
+			durationMs: opts?.durationMs,
+			generationDurationMs: opts?.generationDurationMs,
+			evaluationDurationMs: opts?.evaluationDurationMs
+		});
+	}
+	constructor(config, opts) {
+		const createdAt = opts?.createdAt || /* @__PURE__ */ new Date();
+		this.createdAt = createdAt.getTime();
+		this.id = opts?.id || createEvalId(createdAt);
+		this.author = opts?.author ?? null;
+		this.config = config;
+		this.results = [];
+		this.prompts = opts?.prompts || [];
+		this.datasetId = opts?.datasetId;
+		this.persisted = opts?.persisted || false;
+		this._resultsLoaded = false;
+		this.vars = opts?.vars || [];
+		this.runtimeOptions = opts?.runtimeOptions;
+		this.durationMs = opts?.durationMs;
+		this.generationDurationMs = opts?.generationDurationMs;
+		this.evaluationDurationMs = opts?.evaluationDurationMs;
+	}
+	version() {
+		/**
+		* Version 3 is the denormalized version of where the table and results are stored on the eval object.
+		* Version 4 is the normalized version where the results are stored in another database table and the table for visualization is generated by the app.
+		*/
+		return this.oldResults && "table" in this.oldResults ? 3 : 4;
+	}
+	useOldResults() {
+		return this.version() < 4;
+	}
+	setTable(table) {
+		invariant(this.version() < 4, "Eval is not version 3");
+		invariant(this.oldResults, "Old results not found");
+		this.oldResults.table = table;
+	}
+	async save() {
+		const db = await getDb();
+		const updateObj = {
+			config: sanitizeTracingConfigForPersistence(this.config),
+			isRedteam: this.config.redteam !== void 0,
+			prompts: this.prompts,
+			description: this.config.description,
+			author: this.author,
+			updatedAt: getCurrentTimestamp(),
+			vars: Array.from(this.vars),
+			runtimeOptions: sanitizeRuntimeOptions(this.runtimeOptions)
+		};
+		if (this.useOldResults()) {
+			invariant(this.oldResults, "Old results not found");
+			updateObj.results = this.oldResults;
+		} else if (this.durationMs !== void 0 || this.generationDurationMs !== void 0 || this.evaluationDurationMs !== void 0) {
+			let expr = sql`CASE WHEN json_valid(${evalsTable.results}) AND json_type(${evalsTable.results}) = 'object' THEN ${evalsTable.results} ELSE '{}' END`;
+			if (this.durationMs !== void 0) expr = sql`json_set(${expr}, '$.durationMs', ${this.durationMs})`;
+			if (this.generationDurationMs !== void 0) expr = sql`json_set(${expr}, '$.generationDurationMs', ${this.generationDurationMs})`;
+			if (this.evaluationDurationMs !== void 0) expr = sql`json_set(${expr}, '$.evaluationDurationMs', ${this.evaluationDurationMs})`;
+			updateObj.results = expr;
+		}
+		await db.update(evalsTable).set(updateObj).where(eq(evalsTable.id, this.id)).run();
+		notifyEvaluationChanged(this.id);
+		this.persisted = true;
+	}
+	setVars(vars) {
+		this.vars = vars;
+	}
+	addVar(varName) {
+		this.vars.push(varName);
+	}
+	/** Sets the evaluation phase duration and recomputes the total. Called by the evaluator. */
+	setDurationMs(durationMs) {
+		if (!Number.isFinite(durationMs) || durationMs < 0) return;
+		this.evaluationDurationMs = durationMs;
+		this.durationMs = (this.generationDurationMs ?? 0) + durationMs;
+	}
+	/** Sets the generation phase duration and recomputes the total. Called by doRedteamRun. */
+	setGenerationDurationMs(durationMs) {
+		if (!Number.isFinite(durationMs) || durationMs < 0) return;
+		this.generationDurationMs = durationMs;
+		this.durationMs = durationMs + (this.evaluationDurationMs ?? 0);
+	}
+	getPrompts() {
+		if (this.useOldResults()) {
+			invariant(this.oldResults, "Old results not found");
+			return this.oldResults.table?.head.prompts || [];
+		}
+		return this.prompts;
+	}
+	async getTable() {
+		if (this.useOldResults()) return this.oldResults?.table || {
+			head: {
+				prompts: [],
+				vars: []
+			},
+			body: []
+		};
+		return convertResultsToTable(await this.toResultsFile());
+	}
+	async addResult(result) {
+		if (result.repeatGroupId !== void 0) this.observedRepeatedResults = true;
+		const httpStatus = result.response?.metadata?.http?.status;
+		if (this.observedTargetErrorStatus === void 0 && typeof httpStatus === "number" && isNonTransientHttpStatus(httpStatus)) this.observedTargetErrorStatus = httpStatus;
+		const newResult = await EvalResult.createFromEvaluateResult(this.id, result, { persist: this.persisted });
+		if (!this.persisted) this.results.push(newResult);
+		if (this.persisted) notifyEvaluationChanged(this.id);
+	}
+	recordFinalJsonlResult(result) {
+		this.finalJsonlResults.set(getResultIndexKey(result), result);
+		if (result.repeatGroupId !== void 0) this.observedRepeatedResults = true;
+	}
+	getFinalJsonlResults() {
+		return Array.from(this.finalJsonlResults.values());
+	}
+	async getObservedRepeatStability() {
+		return this.observedRepeatedResults ? this.getRepeatStability() : void 0;
+	}
+	recordResultPersistenceFailure(result) {
+		this.resultPersistenceFailed = true;
+		const key = getResultIndexKey(result);
+		this.failedResults.set(key, result);
+		this.failedEvalResults.delete(key);
+	}
+	hasResultPersistenceFailure(result) {
+		return this.failedResults.has(getResultIndexKey(result));
+	}
+	async getFailedResultsByTestIdx(testIdx) {
+		const reconstructed = [];
+		for (const [key, row] of this.failedResults) {
+			if (row.testIdx !== testIdx) continue;
+			let evalResult = this.failedEvalResults.get(key);
+			if (!evalResult) {
+				evalResult = await EvalResult.createFromEvaluateResult(this.id, row, { persist: false });
+				this.failedEvalResults.set(key, evalResult);
+			}
+			reconstructed.push(evalResult);
+		}
+		return reconstructed;
+	}
+	async *fetchResultsBatched(batchSize = 100) {
+		if (!this.persisted) {
+			for (let offset = 0; offset < this.results.length; offset += batchSize) yield this.results.slice(offset, offset + batchSize);
+			return;
+		}
+		for await (const batch of EvalResult.findManyByEvalIdBatched(this.id, { batchSize })) yield batch;
+	}
+	async getResultsCount() {
+		return getCachedResultsCount(this.id);
+	}
+	/**
+	* Get the total count of all result rows for this eval.
+	* Use this when iterating over all results (e.g., for sharing progress).
+	* This may be higher than getResultsCount() when there are multiple prompts/providers.
+	*/
+	async getTotalResultRowCount() {
+		return getTotalResultRowCount(this.id);
+	}
+	/**
+	* Find a non-transient HTTP error status from evaluation results.
+	* Returns the first non-transient status (401, 403, 404, 500, 501) found, or undefined.
+	*
+	* For persisted evals: Uses efficient O(1) database query with LIMIT 1, and also scans
+	* the rows that could not be saved, which the database does not have.
+	* For non-persisted evals: Falls back to scanning in-memory results.
+	*/
+	async findTargetErrorStatus() {
+		const scan = (results) => {
+			for (const result of results) {
+				const status = result.response?.metadata?.http?.status;
+				if (typeof status === "number" && isNonTransientHttpStatus(status)) return status;
+			}
+		};
+		const scanInMemory = () => scan(this.results);
+		if (!this.persisted) return scanInMemory();
+		const unsavedStatus = scan(this.failedResults.values());
+		try {
+			return (await (await getDb()).select({ httpStatus: sql`CAST(json_extract(${evalResultsTable.response}, '$.metadata.http.status') AS INTEGER)` }).from(evalResultsTable).where(and(eq(evalResultsTable.evalId, this.id), sql`json_extract(${evalResultsTable.response}, '$.metadata.http.status') IN (${sql.join(NON_TRANSIENT_HTTP_STATUSES.map((s) => sql`${s}`), sql`, `)})`)).limit(1).get())?.httpStatus ?? unsavedStatus;
+		} catch {
+			return scanInMemory() ?? unsavedStatus ?? this.observedTargetErrorStatus;
+		}
+	}
+	async fetchResultsByTestIdx(testIdx) {
+		return await EvalResult.findManyByEvalId(this.id, { testIdx });
+	}
+	/**
+	* CRITICAL: Builds the WHERE SQL clause for filtering results.
+	* This is the single source of truth for all filtering logic.
+	* Used by both queryTestIndices() (pagination) and getFilteredMetrics().
+	*
+	* SECURITY: This method uses Drizzle's sql template strings for parameterized queries
+	* to prevent SQL injection. All user-provided values are passed as parameters,
+	* not interpolated into the SQL string.
+	*
+	* Any changes to filter logic MUST be made here to ensure consistency
+	* between displayed rows and calculated metrics.
+	*
+	* @returns SQL fragment (without "WHERE" keyword) that can be used in queries
+	*/
+	buildFilterWhereSql(opts) {
+		const mode = opts.filterMode ?? "all";
+		const conditions = [sql`eval_id = ${this.id}`];
+		if (mode === "errors") conditions.push(sql`failure_reason = ${ResultFailureReason.ERROR}`);
+		else if (mode === "failures") conditions.push(sql`success = 0 AND failure_reason != ${ResultFailureReason.ERROR}`);
+		else if (mode === "passes") conditions.push(sql`success = 1`);
+		else if (mode === "highlights") conditions.push(sql`json_extract(grading_result, '$.comment') LIKE ${"!highlight%"}`);
+		else if (mode === "user-rated") conditions.push(sql`
+        EXISTS (
+          SELECT 1
+          FROM json_each(grading_result, '$.componentResults')
+          WHERE json_extract(value, '$.assertion.type') = ${HUMAN_ASSERTION_TYPE}
+        )
+      `);
+		if (opts.filters && opts.filters.length > 0) {
+			const filterConditions = [];
+			opts.filters.forEach((filter) => {
+				let parsedFilter;
+				try {
+					parsedFilter = JSON.parse(filter);
+				} catch {
+					logger.warn("Ignoring malformed eval filter JSON");
+					return;
+				}
+				if (!parsedFilter || typeof parsedFilter !== "object" || Array.isArray(parsedFilter)) {
+					logger.warn("Ignoring invalid eval filter");
+					return;
+				}
+				const { logicOperator, type, operator, value, field } = parsedFilter;
+				if (typeof type !== "string" || typeof operator !== "string" || logicOperator !== void 0 && typeof logicOperator !== "string" || field !== void 0 && typeof field !== "string" || value !== void 0 && typeof value !== "string" && typeof value !== "number") {
+					logger.warn("Ignoring invalid eval filter fields");
+					return;
+				}
+				let condition = null;
+				if (type === "metric") {
+					const metricKey = field || value;
+					if (!metricKey) {
+						logger.warn("Invalid metric filter: missing field and value", { filter });
+						return;
+					}
+					const numericValue = typeof value === "number" ? value : Number.parseFloat(String(value));
+					if (operator === "is_defined" || operator === "equals" && !field) condition = sql`EXISTS (
+              SELECT 1
+              FROM json_each(named_scores)
+              WHERE json_each.key = ${metricKey}
+            )`;
+					else if (Number.isFinite(numericValue)) {
+						if (operator === "eq") condition = sql`EXISTS (
+                SELECT 1
+                FROM json_each(named_scores)
+                WHERE json_each.key = ${metricKey}
+                  AND CAST(json_each.value AS REAL) = ${numericValue}
+              )`;
+						else if (operator === "neq") condition = sql`EXISTS (
+                SELECT 1
+                FROM json_each(named_scores)
+                WHERE json_each.key = ${metricKey}
+                  AND CAST(json_each.value AS REAL) != ${numericValue}
+              )`;
+						else if (operator === "gt") condition = sql`EXISTS (
+                SELECT 1
+                FROM json_each(named_scores)
+                WHERE json_each.key = ${metricKey}
+                  AND CAST(json_each.value AS REAL) > ${numericValue}
+              )`;
+						else if (operator === "gte") condition = sql`EXISTS (
+                SELECT 1
+                FROM json_each(named_scores)
+                WHERE json_each.key = ${metricKey}
+                  AND CAST(json_each.value AS REAL) >= ${numericValue}
+              )`;
+						else if (operator === "lt") condition = sql`EXISTS (
+                SELECT 1
+                FROM json_each(named_scores)
+                WHERE json_each.key = ${metricKey}
+                  AND CAST(json_each.value AS REAL) < ${numericValue}
+              )`;
+						else if (operator === "lte") condition = sql`EXISTS (
+                SELECT 1
+                FROM json_each(named_scores)
+                WHERE json_each.key = ${metricKey}
+                  AND CAST(json_each.value AS REAL) <= ${numericValue}
+              )`;
+					} else {
+						logger.warn("Invalid numeric value in metric filter", {
+							metricKey,
+							value,
+							numericValue,
+							operator
+						});
+						return;
+					}
+				} else if (type === "metadata" && field) {
+					if (operator === "equals") condition = sql`EXISTS (
+              SELECT 1
+              FROM json_each(metadata)
+              WHERE json_each.key = ${field}
+                AND json_each.value = ${value}
+            )`;
+					else if (operator === "contains") condition = sql`EXISTS (
+              SELECT 1
+              FROM json_each(metadata)
+              WHERE json_each.key = ${field}
+                AND json_each.value LIKE ${`%${value}%`}
+            )`;
+					else if (operator === "not_contains") condition = sql`NOT EXISTS (
+              SELECT 1
+              FROM json_each(metadata)
+              WHERE json_each.key = ${field}
+                AND json_each.value LIKE ${`%${value}%`}
+            )`;
+					else if (operator === "exists") condition = sql`EXISTS (
+              SELECT 1
+              FROM json_each(metadata)
+              WHERE json_each.key = ${field}
+                AND LENGTH(TRIM(COALESCE(json_each.value, ''))) > 0
+            )`;
+				} else if (type === "plugin" && typeof value === "string") {
+					const isCategory = Object.keys(PLUGIN_CATEGORIES).includes(value);
+					if (operator === "equals") {
+						if (isCategory) condition = sql`json_extract(metadata, '$.pluginId') LIKE ${`${value}:%`}`;
+						else condition = sql`json_extract(metadata, '$.pluginId') = ${value}`;
+					} else if (operator === "not_equals") {
+						if (isCategory) condition = sql`(json_extract(metadata, '$.pluginId') IS NULL OR (json_extract(metadata, '$.pluginId') != ${value} AND json_extract(metadata, '$.pluginId') NOT LIKE ${`${value}:%`}))`;
+						else condition = sql`(json_extract(metadata, '$.pluginId') IS NULL OR json_extract(metadata, '$.pluginId') != ${value})`;
+					}
+				} else if (type === "strategy" && operator === "equals") {
+					if (value === "basic") condition = sql`(json_extract(metadata, '$.strategyId') IS NULL OR json_extract(metadata, '$.strategyId') = '')`;
+					else condition = sql`json_extract(metadata, '$.strategyId') = ${value}`;
+				} else if (type === "severity" && operator === "equals") {
+					const explicit = sql`json_extract(metadata, '$.severity') = ${value}`;
+					const severityMap = getRiskCategorySeverityMap(this.config?.redteam?.plugins);
+					const pluginConditions = Object.entries(severityMap).filter(([, severity]) => severity === value).map(([pluginId]) => pluginId).map((pluginId) => {
+						return pluginId.includes(":") ? sql`json_extract(metadata, '$.pluginId') = ${pluginId}` : sql`json_extract(metadata, '$.pluginId') LIKE ${`${pluginId}:%`}`;
+					});
+					if (pluginConditions.length > 0) {
+						const pluginMatch = sql.join(pluginConditions, sql` OR `);
+						const overrideOk = sql`(json_extract(metadata, '$.severity') IS NULL OR json_extract(metadata, '$.severity') = ${value})`;
+						condition = sql`(${explicit} OR ((${pluginMatch}) AND ${overrideOk}))`;
+					} else condition = sql`(${explicit})`;
+				} else if (type === "policy" && operator === "equals") condition = sql`(named_scores LIKE '%PolicyViolation:%' AND named_scores LIKE ${`%${value}%`})`;
+				if (condition) filterConditions.push({
+					condition,
+					logicOperator: logicOperator || "AND"
+				});
+			});
+			const filterClause = combineFilterConditions(filterConditions);
+			if (filterClause) conditions.push(sql`(${filterClause})`);
+		}
+		if (opts.searchQuery && opts.searchQuery.trim() !== "") {
+			const searchPattern = `%${opts.searchQuery}%`;
+			const searchConditions = [
+				sql`response LIKE ${searchPattern}`,
+				sql`json_extract(grading_result, '$.reason') LIKE ${searchPattern}`,
+				sql`json_extract(grading_result, '$.comment') LIKE ${searchPattern}`,
+				sql`json_extract(named_scores, '$') LIKE ${searchPattern}`,
+				sql`json_remove(metadata, ${`$.${PROMPTFOO_METADATA_KEY}`}) LIKE ${searchPattern}`,
+				sql`json_extract(test_case, '$.vars') LIKE ${searchPattern}`,
+				sql`json_extract(test_case, '$.metadata') LIKE ${searchPattern}`
+			];
+			const searchClause = sql.join(searchConditions, sql` OR `);
+			conditions.push(sql`(${searchClause})`);
+		}
+		return sql.join(conditions, sql` AND `);
+	}
+	/**
+	* Private helper method to build filter conditions and query for test indices.
+	*
+	* SECURITY: Uses parameterized queries via Drizzle's sql template strings
+	* to prevent SQL injection attacks.
+	*/
+	async queryTestIndices(opts) {
+		const db = await getDb();
+		const offset = opts.offset ?? 0;
+		const limit = opts.limit ?? 50;
+		const whereSql = this.buildFilterWhereSql({
+			filterMode: opts.filterMode,
+			searchQuery: opts.searchQuery,
+			filters: opts.filters
+		});
+		const filteredCountQuery = sql`
+      SELECT COUNT(DISTINCT test_idx) as count
+      FROM eval_results
+      WHERE ${whereSql}
+    `;
+		const countStart = Date.now();
+		const countResult = await db.get(filteredCountQuery);
+		const countEnd = Date.now();
+		logger.debug(`Count query took ${countEnd - countStart}ms`);
+		const filteredCount = countResult?.count || 0;
+		const idxQuery = sql`
+      SELECT DISTINCT test_idx
+      FROM eval_results
+      WHERE ${whereSql}
+      ORDER BY test_idx
+      LIMIT ${limit}
+      OFFSET ${offset}
+    `;
+		const idxStart = Date.now();
+		const rows = await db.all(idxQuery);
+		const idxEnd = Date.now();
+		logger.debug(`Index query took ${idxEnd - idxStart}ms`);
+		return {
+			testIndices: rows.map((row) => row.test_idx),
+			filteredCount
+		};
+	}
+	/**
+	* CRITICAL: Calculates metrics for filtered results.
+	* Uses the SAME WHERE clause as queryTestIndices() to ensure consistency.
+	*
+	* SECURITY: Uses parameterized SQL queries to prevent SQL injection.
+	*
+	* This method is called from the API route when filters are active to provide
+	* metrics that accurately reflect the filtered dataset.
+	*
+	* @returns Array of PromptMetrics, one per prompt
+	*/
+	async getFilteredMetrics(opts) {
+		const whereSql = this.buildFilterWhereSql(opts);
+		return calculateFilteredMetrics({
+			evalId: this.id,
+			numPrompts: this.prompts.length,
+			whereSql
+		});
+	}
+	async getTablePage(opts) {
+		const totalCount = await this.getResultsCount();
+		let testIndices;
+		let filteredCount;
+		if (opts.testIndices && opts.testIndices.length > 0) {
+			testIndices = opts.testIndices;
+			filteredCount = testIndices.length;
+		} else {
+			const hasComplexFilters = opts.filters && opts.filters.length > 0;
+			let queryResult;
+			if (hasComplexFilters) {
+				logger.debug("Using original query for complex filters");
+				queryResult = await this.queryTestIndices({
+					offset: opts.offset,
+					limit: opts.limit,
+					filterMode: opts.filterMode,
+					searchQuery: opts.searchQuery,
+					filters: opts.filters
+				});
+			} else {
+				logger.debug("Using optimized query for table page");
+				queryResult = await queryTestIndicesOptimized(this.id, {
+					offset: opts.offset,
+					limit: opts.limit,
+					filterMode: opts.filterMode,
+					searchQuery: opts.searchQuery,
+					filters: opts.filters
+				});
+			}
+			testIndices = queryResult.testIndices;
+			filteredCount = queryResult.filteredCount;
+		}
+		const varsStart = Date.now();
+		const vars = Array.from(this.vars);
+		const varsEnd = Date.now();
+		logger.debug(`Vars query took ${varsEnd - varsStart}ms`);
+		const body = [];
+		const bodyStart = Date.now();
+		if (testIndices.length === 0) {
+			const bodyEnd = Date.now();
+			logger.debug(`Body query took ${bodyEnd - bodyStart}ms`);
+			return {
+				head: {
+					prompts: this.prompts,
+					vars
+				},
+				body,
+				totalCount,
+				filteredCount,
+				id: this.id
+			};
+		}
+		const allResults = await EvalResult.findManyByEvalIdAndTestIndices(this.id, testIndices);
+		if (allResults.some((result) => {
+			const hasSessionIds = Array.isArray(result.metadata?.sessionIds) && result.metadata.sessionIds.length > 0;
+			const hasSessionId = Boolean(result.metadata?.sessionId);
+			const notInVars = !result.testCase?.vars?.sessionId;
+			return (hasSessionIds || hasSessionId) && notInVars;
+		}) && !vars.includes("sessionId")) vars.push("sessionId");
+		const resultsByTestIdx = /* @__PURE__ */ new Map();
+		for (const result of allResults) {
+			if (!resultsByTestIdx.has(result.testIdx)) resultsByTestIdx.set(result.testIdx, []);
+			resultsByTestIdx.get(result.testIdx).push(result);
+		}
+		for (const testIdx of testIndices) {
+			const results = resultsByTestIdx.get(testIdx) || [];
+			if (results.length > 0) body.push(convertTestResultsToTableRow(results, vars));
+		}
+		const bodyEnd = Date.now();
+		logger.debug(`Body query took ${bodyEnd - bodyStart}ms`);
+		return {
+			head: {
+				prompts: this.prompts,
+				vars
+			},
+			body,
+			totalCount,
+			filteredCount,
+			id: this.id
+		};
+	}
+	async addPrompts(prompts) {
+		this.prompts = prompts;
+		if (this.persisted) {
+			await (await getDb()).update(evalsTable).set({ prompts }).where(eq(evalsTable.id, this.id)).run();
+			notifyEvaluationChanged(this.id);
+		}
+	}
+	async setResults(results) {
+		if (this.persisted && results.length > 0) {
+			await (await getDb()).insert(evalResultsTable).values(results.map((r) => ({
+				...r,
+				metadata: persistTraceMetadata(persistRepeatMetadata(r.metadata, r.repeatIndex, r.repeatGroupId), r.traceId, r.evaluationId),
+				evalId: this.id
+			}))).run();
+			notifyEvaluationChanged(this.id);
+		}
+		if (this.persisted) this.clearResults();
+		else {
+			this.results = results;
+			this._resultsLoaded = true;
+		}
+	}
+	async loadResults() {
+		if (this.persisted) this.results = await EvalResult.findManyByEvalId(this.id);
+		this._resultsLoaded = true;
+	}
+	async getResults() {
+		if (this.useOldResults()) {
+			invariant(this.oldResults, "Old results not found");
+			return this.oldResults.results;
+		}
+		await this.loadResults();
+		this._resultsLoaded = true;
+		return this.results;
+	}
+	clearResults() {
+		this.results = [];
+		this._resultsLoaded = false;
+	}
+	getStats() {
+		const stats = {
+			successes: 0,
+			failures: 0,
+			errors: 0,
+			tokenUsage: createEmptyTokenUsage(),
+			durationMs: this.durationMs,
+			generationDurationMs: this.generationDurationMs,
+			evaluationDurationMs: this.evaluationDurationMs
+		};
+		for (const prompt of this.prompts) {
+			stats.successes += prompt.metrics?.testPassCount ?? 0;
+			stats.failures += prompt.metrics?.testFailCount ?? 0;
+			stats.errors += prompt.metrics?.testErrorCount ?? 0;
+			if (prompt.metrics?.testCacheHitCount) stats.cacheHits = (stats.cacheHits ?? 0) + prompt.metrics.testCacheHitCount;
+			accumulateTokenUsage(stats.tokenUsage, prompt.metrics?.tokenUsage);
+		}
+		accumulateGenerationTokenUsage(stats.tokenUsage, this.config.metadata?.generationAccounting?.tokenUsage);
+		return stats;
+	}
+	async getRepeatStability() {
+		if (this.useOldResults()) return calculateRepeatStability(this.oldResults?.results ?? []);
+		const calculator = new RepeatStabilityCalculator();
+		const recovered = new Map(this.failedResults);
+		for (const [key, result] of this.failedEvalResults) recovered.set(key, result);
+		for (const [key, result] of this.finalJsonlResults) recovered.set(key, result);
+		for await (const batch of this.fetchResultsBatched()) for (const result of batch) {
+			const key = getResultIndexKey(result);
+			calculator.addResult(recovered.get(key) ?? result);
+			recovered.delete(key);
+		}
+		calculator.addResults(recovered.values());
+		return calculator.getSummary();
+	}
+	async toEvaluateSummary() {
+		if (this.useOldResults()) {
+			invariant(this.oldResults, "Old results not found");
+			return {
+				version: 2,
+				timestamp: new Date(this.createdAt).toISOString(),
+				results: this.oldResults.results,
+				table: this.oldResults.table,
+				stats: this.oldResults.stats
+			};
+		}
+		if (this.results.length === 0) await this.loadResults();
+		const stats = await this.getStats();
+		const stripFlags = getStripFlags(this.config.env);
+		const prompts = this.prompts.map((p) => projectPrompt(p, stripFlags.shouldStripPromptText));
+		const calculator = new RepeatStabilityCalculator();
+		const results = this.results.map((result) => {
+			const exported = result.toEvaluateResult(stripFlags);
+			calculator.addResult({
+				...exported,
+				gradingResult: result.gradingResult
+			});
+			return exported;
+		});
+		const repeatStability = calculator.getSummary();
+		return {
+			version: 3,
+			timestamp: new Date(this.createdAt).toISOString(),
+			prompts,
+			results,
+			stats,
+			...repeatStability && { repeatStability }
+		};
+	}
+	async getTraces() {
+		try {
+			return (await getTraceStore().getTracesByEvaluation(this.id)).map((trace) => ({
+				traceId: trace.traceId,
+				evaluationId: trace.evaluationId,
+				testCaseId: trace.testCaseId,
+				metadata: trace.metadata,
+				spans: (trace.spans || []).map((span) => {
+					const durationMs = span.endTime && span.startTime ? (span.endTime - span.startTime) / 1e6 : void 0;
+					const statusCode = span.statusCode === 1 ? "ok" : span.statusCode === 2 ? "error" : "unset";
+					return {
+						spanId: span.spanId,
+						parentSpanId: span.parentSpanId,
+						name: span.name,
+						kind: span.kind || "unspecified",
+						startTime: span.startTime,
+						endTime: span.endTime,
+						durationMs,
+						attributes: span.attributes || {},
+						status: {
+							code: statusCode,
+							message: span.statusMessage
+						},
+						depth: 0,
+						events: span.events || []
+					};
+				})
+			}));
+		} catch (error) {
+			logger.debug(`Failed to fetch traces for eval ${this.id}: ${error}`);
+			return [];
+		}
+	}
+	async toResultsFile() {
+		const traces = await this.getTraces();
+		const stripFlags = getStripFlags(this.config.env);
+		return {
+			version: this.version(),
+			createdAt: new Date(this.createdAt).toISOString(),
+			results: await this.toEvaluateSummary(),
+			config: sanitizeConfigForOutput(this.config, stripFlags),
+			author: this.author || null,
+			prompts: this.getPrompts().map((prompt) => projectPrompt(prompt, stripFlags.shouldStripPromptText)),
+			...this.vars.length > 0 && { vars: [...this.vars] },
+			datasetId: this.datasetId || null,
+			...traces.length > 0 && { traces: projectTracesForOutput(traces, stripFlags) }
+		};
+	}
+	async delete({ notify = true } = {}) {
+		await (await getDb()).transaction(async (tx) => {
+			await deleteTraceRecordsForEvals(tx, [this.id]);
+			await tx.delete(evalsToDatasetsTable).where(eq(evalsToDatasetsTable.evalId, this.id)).run();
+			await tx.delete(evalsToPromptsTable).where(eq(evalsToPromptsTable.evalId, this.id)).run();
+			await tx.delete(evalsToTagsTable).where(eq(evalsToTagsTable.evalId, this.id)).run();
+			await tx.delete(evalResultsTable).where(eq(evalResultsTable.evalId, this.id)).run();
+			await tx.delete(evalsTable).where(eq(evalsTable.id, this.id)).run();
+		});
+		if (notify) notifyEvaluationsDeleted([this.id]);
+	}
+	/**
+	* Creates a deep copy of this eval including all results.
+	* Uses batching to avoid memory exhaustion on large evals.
+	* @param description - Optional description for the new eval
+	* @param distinctTestCount - Optional pre-computed test count to avoid duplicate query
+	*/
+	async copy(description, distinctTestCount) {
+		const newEvalId = createEvalId(/* @__PURE__ */ new Date());
+		const copyDescription = description || `${this.description || "Evaluation"} (Copy)`;
+		const testCount = distinctTestCount ?? await this.getResultsCount();
+		logger.info("Starting eval copy", {
+			sourceEvalId: this.id,
+			targetEvalId: newEvalId,
+			distinctTestCount: testCount
+		});
+		const newConfig = structuredClone(sanitizeTracingConfigForPersistence(this.config));
+		newConfig.description = copyDescription;
+		const newPrompts = structuredClone(this.prompts);
+		const newVars = this.vars ? structuredClone(this.vars) : [];
+		const author = getAuthor();
+		const db = await getDb();
+		let copiedCount = 0;
+		await db.transaction(async (tx) => {
+			await tx.insert(evalsTable).values({
+				id: newEvalId,
+				createdAt: Date.now(),
+				author,
+				description: copyDescription,
+				config: sanitizeTracingConfigForPersistence(newConfig),
+				results: {},
+				prompts: newPrompts,
+				vars: newVars,
+				runtimeOptions: sanitizeRuntimeOptions(this.runtimeOptions),
+				isRedteam: newConfig.redteam !== void 0
+			}).run();
+			const promptRels = await tx.select().from(evalsToPromptsTable).where(eq(evalsToPromptsTable.evalId, this.id)).all();
+			if (promptRels.length > 0) await tx.insert(evalsToPromptsTable).values(promptRels.map((rel) => ({
+				evalId: newEvalId,
+				promptId: rel.promptId
+			}))).onConflictDoNothing().run();
+			if (this.config.tags) for (const [tagKey, tagValue] of Object.entries(this.config.tags)) {
+				const tagId = sha256(`${tagKey}:${tagValue}`);
+				await tx.insert(tagsTable).values({
+					id: tagId,
+					name: tagKey,
+					value: tagValue
+				}).onConflictDoNothing().run();
+				await tx.insert(evalsToTagsTable).values({
+					evalId: newEvalId,
+					tagId
+				}).onConflictDoNothing().run();
+			}
+			const datasetRel = await tx.select().from(evalsToDatasetsTable).where(eq(evalsToDatasetsTable.evalId, this.id)).limit(1).all();
+			if (datasetRel.length > 0) await tx.insert(evalsToDatasetsTable).values({
+				evalId: newEvalId,
+				datasetId: datasetRel[0].datasetId
+			}).onConflictDoNothing().run();
+			const BATCH_SIZE = 1e3;
+			let offset = 0;
+			while (true) {
+				const batch = await tx.select().from(evalResultsTable).where(eq(evalResultsTable.evalId, this.id)).orderBy(evalResultsTable.id).limit(BATCH_SIZE).offset(offset).all();
+				if (batch.length === 0) break;
+				const now = Date.now();
+				const copiedResults = batch.map((result) => ({
+					...result,
+					id: crypto.randomUUID(),
+					evalId: newEvalId,
+					createdAt: now,
+					metadata: stripTraceLinkageFromMetadata(result.metadata),
+					updatedAt: now
+				}));
+				await tx.insert(evalResultsTable).values(copiedResults).run();
+				copiedCount += batch.length;
+				offset += BATCH_SIZE;
+				logger.debug("Copied batch of eval results", {
+					sourceEvalId: this.id,
+					targetEvalId: newEvalId,
+					batchSize: batch.length,
+					rowsCopied: copiedCount,
+					distinctTestCount: testCount
+				});
+			}
+		});
+		notifyEvaluationChanged(newEvalId);
+		logger.info("Eval copy completed successfully", {
+			sourceEvalId: this.id,
+			targetEvalId: newEvalId,
+			rowsCopied: copiedCount,
+			distinctTestCount: testCount
+		});
+		return await Eval.findById(newEvalId);
+	}
+	get shared() {
+		return this._shared;
+	}
+	set shared(shared) {
+		this._shared = shared;
+	}
+};
+/**
+* Queries summaries of all evals, optionally for a given dataset.
+*
+* @param datasetId - An optional dataset ID to filter by.
+* @param type - An optional eval type to filter by.
+* @param includeProviders - An optional flag to include providers in the summary.
+* @returns A list of eval summaries.
+*/
+async function getEvalSummaries(datasetId, type, includeProviders = false) {
+	const db = await getDb();
+	const whereClauses = [];
+	if (datasetId) whereClauses.push(eq(evalsToDatasetsTable.datasetId, datasetId));
+	if (type) {
+		if (type === "redteam") whereClauses.push(eq(evalsTable.isRedteam, true));
+		else whereClauses.push(eq(evalsTable.isRedteam, false));
+	}
+	/**
+	* Deserialize the evals. A few things to note:
+	*
+	* - Test statistics are derived from the prompt metrics as this is the only reliable source of truth
+	* that's written to the evals table.
+	*/
+	return (await db.select({
+		evalId: evalsTable.id,
+		createdAt: evalsTable.createdAt,
+		description: evalsTable.description,
+		datasetId: evalsToDatasetsTable.datasetId,
+		isRedteam: evalsTable.isRedteam,
+		prompts: evalsTable.prompts,
+		config: includeProviders ? evalsTable.config : sql`NULL`
+	}).from(evalsTable).leftJoin(evalsToDatasetsTable, eq(evalsTable.id, evalsToDatasetsTable.evalId)).where(and(...whereClauses)).orderBy(desc(evalsTable.createdAt), desc(evalsTable.id)).all()).map((result) => {
+		const passCount = result.prompts?.reduce((memo, prompt) => {
+			return memo + (prompt.metrics?.testPassCount ?? 0);
+		}, 0) ?? 0;
+		const failCount = result.prompts?.reduce((memo, prompt) => {
+			return memo + (prompt.metrics?.testFailCount ?? 0);
+		}, 0) ?? 0;
+		const testCounts = result.prompts?.map((p) => {
+			return (p.metrics?.testPassCount ?? 0) + (p.metrics?.testFailCount ?? 0) + (p.metrics?.testErrorCount ?? 0);
+		}) ?? [0];
+		const testCount = testCounts.length > 0 ? testCounts[0] : 0;
+		const testRunCount = testCount * (result.prompts?.length ?? 0);
+		const deserializedProviders = [];
+		const providers = result.config?.providers;
+		if (includeProviders) {
+			if (typeof providers === "string") deserializedProviders.push({
+				id: providers,
+				label: null
+			});
+			else if (Array.isArray(providers)) providers.forEach((p) => {
+				if (typeof p === "string") deserializedProviders.push({
+					id: p,
+					label: null
+				});
+				else if (typeof p === "object" && p) {
+					const keys = Object.keys(p);
+					if (keys.length === 1 && !("id" in p)) {
+						const providerId = keys[0];
+						const providerConfig = p[providerId];
+						deserializedProviders.push({
+							id: providerId,
+							label: providerConfig.label ?? null
+						});
+					} else deserializedProviders.push({
+						id: p.id ?? "unknown",
+						label: p.label ?? null
+					});
+				}
+			});
+		}
+		return {
+			evalId: result.evalId,
+			createdAt: result.createdAt,
+			description: result.description,
+			numTests: testCount,
+			datasetId: result.datasetId,
+			isRedteam: Boolean(result.isRedteam),
+			passRate: testRunCount > 0 ? passCount / testRunCount * 100 : 0,
+			label: result.description ? `${result.description} (${result.evalId})` : result.evalId,
+			providers: deserializedProviders,
+			attackSuccessRate: type === "redteam" ? calculateAttackSuccessRate(testRunCount, failCount) : void 0
+		};
+	});
+}
+//#endregion
+export { createEvalId as a, deleteTraceRecordsForEvals as c, combineFilterConditions as i, EvalQueries as n, escapeJsonPathKey as o, buildSafeJsonPath as r, getEvalSummaries as s, Eval as t };
+
+//# sourceMappingURL=eval-Cer9dPe9.js.map