promptfoo 0.125.0 → 0.125.1

package/dist/src/eval-pC4qCvLw.js

@@ -1,1920 +0,0 @@
-#!/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-CzjCb5bd.js";
-import { N as isNonTransientHttpStatus, w as NON_TRANSIENT_HTTP_STATUSES } from "./fetch-BhfUnKen.js";
-import { t as invariant } from "./invariant-CbHB1xyx.js";
-import { a as getAuthor } from "./accounts-GKrO1olH.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-pC4qCvLw.js.map