@tangle-network/agent-eval 0.128.2 → 0.130.0

package/dist/replay-GnyotH0J.js

@@ -0,0 +1,1741 @@
+import { o as ReplayError } from "./errors-8YnH8WlF.js";
+import { r as hashJson, t as canonicalize } from "./pre-registration-DakwTRXk.js";
+import { s as validateRunRecord } from "./run-record-BuoE80Dq.js";
+import { a as providerFromBaseUrl, i as defaultProviderRedactor } from "./raw-provider-sink-BQd7mzyT.js";
+import { LLM_INPUT_TOKENS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, OPENINFERENCE_SPAN_KIND, TOOL_NAME, applyLlmSpanOtlpAttributes } from "./trace-attributes.js";
+import { S as traceSpanKindToOpenInferenceKind, _ as spanEpochMillis, b as classifyOtlpSpanRole, d as compareSpanTime, h as projectOtlpFlatLine, p as firstStringAttr, x as isOtlpModelCall, y as applyToolSpanOtlpAttributes } from "./tools-BmuN627J.js";
+import { t as analyzeTraces } from "./analyst-LsnNpSkm.js";
+import { i as summarizeTraceErrors, n as recordAggregateMeasurements, r as summarizeExecutionMeasurements, t as readTaskFailureLabels } from "./task-failure-attributes-CQZlB3et.js";
+import { r as extractUsageFromSse, t as extractUsage } from "./extract-usage-BrQ8mCLX.js";
+import { readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+//#region src/trace-analyst/hook.ts
+const DEFAULT_QUESTION = "Summarise what happened in this run. Surface any failure modes, surprising findings, or evidence that the run's verdict is wrong.";
+function traceAnalystOnRunComplete(opts) {
+	return async (ctx) => {
+		if (opts.shouldRun && !opts.shouldRun(ctx)) return;
+		const source = opts.analyze.source;
+		if (source === void 0) {
+			await ctx.store.appendEvent({
+				eventId: `analyst-skip-${ctx.runId}`,
+				runId: ctx.runId,
+				kind: "log",
+				timestamp: Date.now(),
+				payload: {
+					source: "trace_analyst_hook",
+					reason: "no source configured"
+				}
+			});
+			return;
+		}
+		const result = await analyzeTraces({ question: opts.question ?? DEFAULT_QUESTION }, {
+			...opts.analyze,
+			source
+		});
+		if (opts.save) await opts.save(result, ctx);
+		if (opts.gateOn && !opts.gateOn(result, ctx)) await ctx.store.appendEvent({
+			eventId: `analyst-gate-${ctx.runId}`,
+			runId: ctx.runId,
+			kind: "log",
+			timestamp: Date.now(),
+			payload: {
+				source: "trace_analyst_hook",
+				reason: "analyst_gate_failed",
+				findings: result.findings
+			}
+		});
+	};
+}
+//#endregion
+//#region src/trace-analyst/insights.ts
+const DOMAIN_STOP_WORDS = /* @__PURE__ */ new Set([
+	"and",
+	"advanced",
+	"app",
+	"build",
+	"create",
+	"easy",
+	"expert",
+	"extreme",
+	"for",
+	"from",
+	"hard",
+	"implementation",
+	"integrate",
+	"medium",
+	"project",
+	"task",
+	"the",
+	"this",
+	"with",
+	"workflow"
+]);
+function tokenizeDomainWords(value) {
+	return [...value.matchAll(/[A-Za-z][A-Za-z0-9.+#-]{2,}/g)].map((match) => match[0].toLowerCase()).filter((word) => !DOMAIN_STOP_WORDS.has(word));
+}
+function inferDomainKeywords(suite) {
+	const suiteWords = new Set(tokenizeDomainWords(`${suite.name} ${suite.collectionId ?? ""}`));
+	const source = [
+		suite.name,
+		suite.collectionId ?? "",
+		...suite.tasks.flatMap((task) => [
+			task.id,
+			task.name,
+			task.prompt ?? "",
+			task.difficulty ?? "",
+			...task.tags ?? [],
+			...task.gaps ?? []
+		])
+	].join(" ");
+	const counts = /* @__PURE__ */ new Map();
+	for (const word of tokenizeDomainWords(source)) counts.set(word, (counts.get(word) ?? 0) + 1);
+	return [...counts.entries()].filter(([word, count]) => count >= 2 || suiteWords.has(word)).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([word]) => word).slice(0, 18);
+}
+function domainEvidencePattern(keywords) {
+	const escaped = keywords.filter((keyword) => keyword.length >= 3).map((keyword) => keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+	return escaped.length > 0 ? new RegExp(`(?<![A-Za-z0-9])(?:${escaped.join("|")})(?![A-Za-z0-9])`, "i") : /(?<![A-Za-z0-9])(?:sdk|api|css|dns|xml|provider|client|service|integration|webhook|transaction|auth|oauth|graphql|rest)(?![A-Za-z0-9])/i;
+}
+function describeTraceInsightScope(suite) {
+	const taskLabel = suite.tasks.length === 1 ? "1 implementation task" : `${suite.tasks.length} implementation tasks`;
+	const tags = /* @__PURE__ */ new Map();
+	for (const task of suite.tasks) for (const tag of task.tags ?? []) tags.set(tag, (tags.get(tag) ?? 0) + 1);
+	const topTags = [...tags.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 8).map(([tag]) => tag);
+	if (topTags.length > 0) return `${taskLabel} across ${topTags.join(", ")}.`;
+	return `${taskLabel} across ${[...new Set(suite.tasks.map((task) => task.difficulty).filter((value) => Boolean(value)))].join(", ") || "the selected benchmark scope"}.`;
+}
+function planTraceInsightQuestions(input) {
+	const hasFailures = input.suite.tasks.some((task) => task.outcome && task.outcome !== "satisfied");
+	const hasMultipleShots = input.suite.tasks.some((task) => (task.gaps ?? []).some((gap) => /shot|review|retry|continue/i.test(gap)));
+	const questions = [
+		{
+			id: "execution-path",
+			question: "What did the worker actually do before the first meaningful implementation edit?",
+			why: "Separates grounded execution from polished but shallow output."
+		},
+		{
+			id: "research-grounding",
+			question: "Did the worker inspect docs, source, examples, or package references before committing to an implementation path?",
+			why: "Identifies whether failures came from weak retrieval, weak examples, or premature coding."
+		},
+		{
+			id: "domain-proof",
+			question: "Which tasks produced executable domain proof versus UI copy, placeholders, or inferred behavior?",
+			why: "Keeps product-quality claims tied to concrete evidence."
+		},
+		{
+			id: "root-cause",
+			question: "For each major failure cluster, is the likely root cause prompt/scaffold, docs/examples, SDK/API ergonomics, evaluator, runtime, or model behavior?",
+			why: "Turns trace observations into actionable ownership."
+		},
+		{
+			id: "evidence-quality",
+			question: "Which external-facing claims are directly supported by trace ids, span ids, verifier findings, reviewer notes, or generated code?",
+			why: "Prevents unsupported customer-report conclusions."
+		}
+	];
+	if (hasMultipleShots) questions.push({
+		id: "reviewer-lift",
+		question: "Where did reviewer feedback improve score, stall, or regress across shots?",
+		why: "Shows whether the driver loop is learning or merely repeating work."
+	});
+	if (hasFailures) questions.push({
+		id: "optimization-targets",
+		question: "Which prompt, evaluator, scaffold, or workflow changes should feed the next GEPA/autoresearch optimization run?",
+		why: "Connects benchmark evidence to the optimization loop."
+	});
+	return questions;
+}
+function buildTraceInsightContext(input) {
+	return {
+		suite: input.suite,
+		scope: describeTraceInsightScope(input.suite),
+		keywords: inferDomainKeywords(input.suite),
+		questions: planTraceInsightQuestions(input),
+		panel: defaultTraceInsightPanel(),
+		findings: input.findings ?? [],
+		agent: input.agent ?? null,
+		totals: input.totals ?? null
+	};
+}
+function scoreTraceInsightReadiness(context) {
+	const failedTasks = context.suite.tasks.filter((task) => task.outcome && task.outcome !== "satisfied");
+	const findingTaskIds = new Set(context.findings.flatMap((finding) => finding.taskIds));
+	const failedTasksWithFindings = failedTasks.filter((task) => findingTaskIds.has(task.id));
+	const tasksWithGaps = context.suite.tasks.filter((task) => (task.gaps ?? []).length > 0);
+	const gates = [
+		{
+			id: "domain-context",
+			label: "Domain context inferred",
+			passed: context.keywords.length > 0,
+			severity: "high",
+			detail: context.keywords.length > 0 ? `${context.keywords.length} domain terms inferred: ${context.keywords.slice(0, 8).join(", ")}` : "No domain terms were inferred from suite, tasks, prompts, tags, or gaps."
+		},
+		{
+			id: "panel-coverage",
+			label: "Analyst panel planned",
+			passed: context.panel.length >= 4 && context.questions.length >= 5,
+			severity: "high",
+			detail: `${context.panel.length} panel roles and ${context.questions.length} investigation questions planned.`
+		},
+		{
+			id: "failure-coverage",
+			label: "Failures mapped to findings",
+			passed: failedTasks.length === 0 || failedTasksWithFindings.length / failedTasks.length >= .5,
+			severity: "critical",
+			detail: failedTasks.length === 0 ? "No failed tasks in suite." : `${failedTasksWithFindings.length}/${failedTasks.length} failed tasks appear in finding clusters.`
+		},
+		{
+			id: "gap-evidence",
+			label: "Task gaps captured",
+			passed: failedTasks.length === 0 || tasksWithGaps.length / failedTasks.length >= .5,
+			severity: "medium",
+			detail: `${tasksWithGaps.length} tasks include explicit evaluator or analyst gaps.`
+		}
+	];
+	const penalty = gates.reduce((sum, gate) => {
+		if (gate.passed) return sum;
+		if (gate.severity === "critical") return sum + 35;
+		if (gate.severity === "high") return sum + 20;
+		if (gate.severity === "medium") return sum + 10;
+		return sum + 5;
+	}, 0);
+	const score = Math.max(0, Math.min(1, 1 - penalty / 100));
+	return {
+		score,
+		grade: score >= .9 ? "external-ready" : score >= .7 ? "internal-review" : "raw-analysis",
+		gates
+	};
+}
+function defaultTraceInsightPanel() {
+	return [
+		{
+			id: "trace-forensics",
+			name: "Trace Forensics",
+			responsibility: "Reconstruct what the worker did in order, including research, edits, reviewer interventions, verifier feedback, and stop reason."
+		},
+		{
+			id: "root-cause",
+			name: "Root Cause",
+			responsibility: "Map failures to prompt/scaffold, docs/examples, SDK/API/product ergonomics, evaluator, runtime, or model behavior."
+		},
+		{
+			id: "optimization",
+			name: "Optimization",
+			responsibility: "Identify prompt, reviewer, evaluator, scaffold, and GEPA/autoresearch changes that should be tested next."
+		},
+		{
+			id: "external-evidence",
+			name: "External Evidence",
+			responsibility: "Separate customer-safe claims from internal harness findings and reject conclusions without task, trace, span, code, reviewer, or verifier evidence."
+		}
+	];
+}
+function buildTraceInsightPrompt(input) {
+	const context = buildTraceInsightContext(input);
+	const maxRepresentativeTraces = input.maxRepresentativeTraces ?? 6;
+	return `Analyze this benchmark run and produce evidence-backed trace intelligence.
+
+Audience:
+- internal AI/product leadership
+- possible customer-facing report for ${input.suite.name}
+
+Investigation plan:
+${context.questions.map((item, index) => `${index + 1}. ${item.question} (${item.why})`).join("\n")}
+
+Analyst panel:
+${context.panel.map((role) => `- ${role.name}: ${role.responsibility}`).join("\n")}
+
+If the task branches are independent, use subagents for the panel roles above and aggregate their findings. Do not run a panel role unless its answer will change the final report.
+
+Required output:
+1. Executive verdict: what this run proves and does not prove.
+2. The investigation questions you answered and the evidence used.
+3. Failure taxonomy: agent prompting, evaluator/harness, docs/examples, SDK/API/product integration, infra.
+4. Evidence-backed examples with trace ids/task ids and concrete verifier findings.
+5. Highest-ROI fixes for the benchmark harness, prompt/GEPA optimization, and customer-facing product/docs surface.
+6. What is safe for an external report versus what must stay internal.
+7. One rerun plan that would validate lift after optimization.
+
+Budget:
+- Inspect the dataset overview, the failure summary, and at most ${maxRepresentativeTraces} representative traces.
+- Prefer traces named in the failure summary over broad exploration.
+- Do not do exhaustive trace sweeps.
+- Return the final report as soon as the taxonomy and examples are supported.
+
+Run summary:
+${JSON.stringify({
+		suite: input.suite.name,
+		scope: context.scope,
+		inferredKeywords: context.keywords,
+		agent: context.agent,
+		totals: context.totals,
+		findings: context.findings.map((finding) => ({
+			kind: finding.kind,
+			severity: finding.severity,
+			taskCount: finding.taskIds.length,
+			proposedFixClass: finding.proposedFixClass
+		})),
+		failures: input.suite.tasks.filter((task) => task.outcome && task.outcome !== "satisfied").map((task) => ({
+			task: task.id,
+			difficulty: task.difficulty,
+			outcome: task.outcome,
+			score: task.score,
+			gaps: task.gaps ?? []
+		}))
+	}, null, 2)}
+
+Use the trace tools. Do not invent facts. Cite task ids. Separate customer-facing claims from internal harness/model findings.`;
+}
+//#endregion
+//#region src/trace-analyst/otlp-flatten.ts
+const DEFAULT_KIND_MAP = {
+	0: "SPAN_KIND_UNSPECIFIED",
+	1: "SPAN_KIND_INTERNAL",
+	2: "SPAN_KIND_SERVER",
+	3: "SPAN_KIND_CLIENT",
+	4: "SPAN_KIND_PRODUCER",
+	5: "SPAN_KIND_CONSUMER"
+};
+const STATUS_MAP = {
+	0: "STATUS_CODE_UNSET",
+	1: "STATUS_CODE_OK",
+	2: "STATUS_CODE_ERROR"
+};
+/** Unwrap an OTLP attribute-value union to a scalar. */
+function attrValue(v) {
+	if (v.stringValue !== void 0) return v.stringValue;
+	if (v.intValue !== void 0) return Number(v.intValue);
+	if (v.doubleValue !== void 0) return v.doubleValue;
+	if (v.boolValue !== void 0) return v.boolValue;
+	return "";
+}
+function attrsToRecord(attrs) {
+	const out = {};
+	for (const a of attrs) out[a.key] = attrValue(a.value);
+	return out;
+}
+function nanoToIso(nano) {
+	const ms = Number(nano) / 1e6;
+	return Number.isFinite(ms) ? new Date(ms).toISOString() : (/* @__PURE__ */ new Date(0)).toISOString();
+}
+/** Mirror selected attributes into the OpenInference vocabulary in place. */
+function applyOpenInference(attrs) {
+	if ("llm.model" in attrs && !("llm.model_name" in attrs)) attrs[LLM_MODEL_NAME] = attrs["llm.model"];
+	if ("llm.input_tokens" in attrs && !("llm.token_count.prompt" in attrs)) attrs[LLM_INPUT_TOKENS] = attrs["llm.input_tokens"];
+	if ("inference.llm.input_tokens" in attrs && !("llm.token_count.prompt" in attrs)) attrs[LLM_INPUT_TOKENS] = attrs["inference.llm.input_tokens"];
+	if ("llm.output_tokens" in attrs && !("llm.token_count.completion" in attrs)) attrs[LLM_OUTPUT_TOKENS] = attrs["llm.output_tokens"];
+	if ("inference.llm.output_tokens" in attrs && !("llm.token_count.completion" in attrs)) attrs[LLM_OUTPUT_TOKENS] = attrs["inference.llm.output_tokens"];
+	if ("tool.name" in attrs && !("inference.tool.name" in attrs)) attrs["inference.tool.name"] = attrs[TOOL_NAME];
+	if ("span.kind" in attrs && !("openinference.span.kind" in attrs)) attrs[OPENINFERENCE_SPAN_KIND] = String(attrs["span.kind"]).toUpperCase();
+}
+function flattenOtlpExportToNdjson(otlpExport, opts = {}) {
+	const vocab = opts.attributeVocabulary ?? "openinference";
+	const kindMap = {
+		...DEFAULT_KIND_MAP,
+		...opts.kindMap
+	};
+	const lines = [];
+	for (const rs of otlpExport.resourceSpans ?? []) {
+		const resource = { attributes: attrsToRecord(rs.resource?.attributes ?? []) };
+		for (const scope of rs.scopeSpans ?? []) for (const span of scope.spans ?? []) {
+			const attributes = attrsToRecord(span.attributes ?? []);
+			if (vocab === "openinference") applyOpenInference(attributes);
+			const line = {
+				trace_id: span.traceId,
+				span_id: span.spanId,
+				parent_span_id: span.parentSpanId ?? null,
+				name: span.name,
+				kind: kindMap[span.kind] ?? "SPAN_KIND_UNSPECIFIED",
+				start_time: nanoToIso(span.startTimeUnixNano),
+				end_time: nanoToIso(span.endTimeUnixNano),
+				status: {
+					code: STATUS_MAP[span.status?.code ?? 0] ?? "STATUS_CODE_UNSET",
+					...span.status?.message ? { message: span.status.message } : {}
+				},
+				resource,
+				attributes
+			};
+			if (span.events && span.events.length > 0) line.events = span.events.map((e) => ({
+				name: e.name,
+				timeUnixNano: e.timeUnixNano,
+				...e.attributes ? { attributes: attrsToRecord(e.attributes) } : {}
+			}));
+			lines.push(line);
+		}
+	}
+	return lines;
+}
+//#endregion
+//#region src/trace-analyst/otlp-to-run-records.ts
+/**
+* `otlpToRunRecords` — fold an OTLP traces.jsonl (one OTLP span per line;
+* the form AppWorld / HALO emit via their OpenInference OTLP exporter, the
+* same shape `flattenOtlpExportToNdjson` produces) into validated
+* `RunRecord[]` — one record per `trace_id` by default, or per caller-defined
+* logical run when one task is fragmented across multiple OTLP traces.
+*
+* This is the offline ingestion primitive the AppWorld proposer bench and the
+* hosted Intelligence product both stand on: traces in, paper-grade rows
+* out, ready for `compareOptimizationMethods` / `analyzeRuns` / the promotion gate.
+*
+* Aggregation per trace:
+*   - tokenUsage: reconcile input, output, cache-read, and cache-write across
+*     nested model-call wrappers without double-counting parent aggregates.
+*   - costUsd: reconcile complete observed model-call cost when present; else priced via
+*     `opts.priceUsdPerToken` from the aggregated tokens; else `null` with a
+*     loud `raw.cost_unpriced = 1` marker.
+*   - task failure class and detail: read from process-root
+*     `tangle.task.failure_*` attributes; malformed or conflicting values throw.
+*   - terminalFailureReason: the failed root's normalized status message,
+*     when one unambiguous root supplies terminal failure evidence.
+*   - terminalOutcome: reduced from root-span status only. Child tool errors
+*     remain visible in `error_span_count` and `execution_error_count` without
+*     changing the run outcome. Root, guardrail, evaluator, propagated, and
+*     unknown errors retain separate counters.
+*   - model: the dominant LLM model in the trace (snapshot-padded to satisfy
+*     `validateRunRecord` when the trace's model is a bare alias).
+*   - outcome score: `opts.scoreForTrace` (AppWorld `world.evaluate()` →
+*     TGC/SGC) when supplied. Traces without an external task-quality signal
+*     remain unlabeled; execution errors never become a task score.
+*   - prompt / completion: carried into `raw` as token-count signals and,
+*     when the first/last LLM span exposes `input.value` / `output.value`,
+*     the verbatim text is preserved on the optional `promptText` /
+*     `completionText` of the returned `OtlpTraceRunRecord`.
+*
+* Fail-loud: an OTLP file with zero valid spans throws. A trace with no
+* spans is impossible (a trace exists only because a span referenced it).
+* `validateRunRecord` runs on every row — a malformed projection throws
+* rather than silently producing a half-record.
+*/
+/**
+* Parse + aggregate an OTLP traces.jsonl string into validated
+* `RunRecord[]` (one per trace). Use {@link otlpToTraceRunRecords} when you
+* also want the verbatim prompt/completion text alongside each record.
+*/
+function otlpToRunRecords(otlpJsonl, opts) {
+	return otlpToTraceRunRecords(otlpJsonl, opts).map((r) => r.record);
+}
+/**
+* Aggregate already-parsed OTLP flat rows without serializing them back to
+* JSONL. This is the in-memory counterpart to {@link otlpToRunRecords}; both
+* paths share projection, reconciliation, validation, and ordering.
+*/
+function otlpRowsToRunRecords(rows, opts) {
+	return otlpRowsToTraceRunRecords(rows, opts).map((row) => row.record);
+}
+/** As {@link otlpToRunRecords} but returns the prompt/completion text too. */
+function otlpToTraceRunRecords(otlpJsonl, opts) {
+	return traceRunRecordsFromSpans(groupSpansByLogicalRun(groupJsonlSpansByTrace(otlpJsonl), opts.logicalRunIdForTrace), opts);
+}
+/** Parsed-row counterpart to {@link otlpToTraceRunRecords}. */
+function otlpRowsToTraceRunRecords(rows, opts) {
+	return traceRunRecordsFromSpans(groupSpansByLogicalRun(groupRowsByTrace(rows), opts.logicalRunIdForTrace), opts);
+}
+function traceRunRecordsFromSpans(byTrace, opts) {
+	const splitTag = opts.splitTag ?? "holdout";
+	const commitSha = opts.commitSha ?? "unknown";
+	const promptHash = opts.promptHash ?? "unknown";
+	const configHash = opts.configHash ?? "unknown";
+	const seed = opts.seed ?? 0;
+	const fallbackModel = opts.fallbackModel ?? "unknown@otlp";
+	if (byTrace.size === 0) throw new Error("otlpToRunRecords: OTLP input produced zero valid spans — every row was empty, malformed, or missing trace_id/span_id");
+	const traceIds = [...byTrace.keys()].sort();
+	const out = [];
+	for (const traceId of traceIds) {
+		const spans = byTrace.get(traceId);
+		const agg = aggregateTrace(traceId, spans, fallbackModel);
+		const score = resolveScore(opts, traceId, agg);
+		const { costUsd, costProvenance } = resolveCost(opts, agg);
+		const raw = {
+			source_trace_count: agg.sourceTraceCount,
+			span_count: agg.spanCount,
+			llm_span_count: agg.llmSpanCount,
+			tool_span_count: agg.toolSpanCount,
+			agent_span_count: agg.agentSpanCount,
+			error_span_count: agg.errorSpanCount,
+			execution_error_count: agg.executionErrorCount,
+			process_error_count: agg.processErrorCount,
+			guardrail_error_count: agg.guardrailErrorCount,
+			judge_error_count: agg.judgeErrorCount,
+			propagated_error_count: agg.propagatedErrorCount,
+			unclassified_error_count: agg.unclassifiedErrorCount,
+			prompt_tokens: agg.tokenUsage.input,
+			completion_tokens: agg.tokenUsage.output
+		};
+		if (agg.tokenUsage.reasoning !== void 0) raw.reasoning_tokens = agg.tokenUsage.reasoning;
+		if (agg.tokenUsage.cached !== void 0) raw.cached_tokens = agg.tokenUsage.cached;
+		if (agg.tokenUsage.cacheWrite !== void 0) raw.cache_write_tokens = agg.tokenUsage.cacheWrite;
+		if (agg.costMeasurement.value !== void 0 && !agg.costMeasurement.complete) raw.partial_observed_cost_usd = agg.costMeasurement.value;
+		recordAggregateMeasurements(raw, agg.aggregateMeasurement);
+		if (costProvenance.kind === "uncaptured") raw.cost_unpriced = 1;
+		const outcome = { raw };
+		if (score !== void 0) if (splitTag === "holdout") outcome.holdoutScore = score;
+		else outcome.searchScore = score;
+		const { promptText, completionText } = extractPromptCompletion(spans, agg.callSpanIds);
+		const judgeMetadata = opts.judgeMetadataForTrace?.(traceId);
+		const taskFailure = readTaskFailureLabels(spans.filter((span) => span.parent_span_id === null && isTerminalRootCandidate(span)), `otlpToRunRecords: run '${traceId}'`);
+		const record = validateRunRecord({
+			runId: `otlp:${opts.experimentId}:${opts.candidateId}:${traceId}`,
+			experimentId: opts.experimentId,
+			candidateId: opts.candidateId,
+			seed,
+			model: ensureSnapshot(agg.model, fallbackModel),
+			promptHash,
+			configHash,
+			commitSha,
+			wallMs: agg.wallMs,
+			costUsd,
+			costProvenance,
+			tokenUsage: agg.tokenUsage,
+			terminalOutcome: agg.terminalOutcome,
+			...agg.terminalFailureMessage ? { terminalFailureReason: agg.terminalFailureMessage } : {},
+			...judgeMetadata ? { judgeMetadata } : {},
+			outcome,
+			...taskFailure,
+			splitTag,
+			scenarioId: traceId
+		});
+		out.push({
+			record,
+			...promptText !== void 0 ? { promptText } : {},
+			...completionText !== void 0 ? { completionText } : {}
+		});
+	}
+	return out;
+}
+function* yieldJsonlRows(otlpJsonl) {
+	for (const line of otlpJsonl.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.length === 0) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch {
+			continue;
+		}
+		if (parsed && typeof parsed === "object") yield parsed;
+	}
+}
+function groupJsonlSpansByTrace(otlpJsonl) {
+	return groupRowsByTrace(yieldJsonlRows(otlpJsonl));
+}
+function groupRowsByTrace(rows) {
+	const byTrace = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (!row || typeof row !== "object") continue;
+		const span = projectOtlpFlatLine(row);
+		if (!span) continue;
+		const arr = byTrace.get(span.trace_id);
+		if (arr) arr.push(span);
+		else byTrace.set(span.trace_id, [span]);
+	}
+	return byTrace;
+}
+function groupSpansByLogicalRun(byTrace, logicalRunIdForTrace) {
+	if (!logicalRunIdForTrace) return byTrace;
+	const byRun = /* @__PURE__ */ new Map();
+	for (const [traceId, spans] of byTrace) {
+		const suppliedRunId = logicalRunIdForTrace(traceId);
+		if (typeof suppliedRunId !== "string" || suppliedRunId.trim().length === 0) throw new Error(`otlpToRunRecords: logicalRunIdForTrace('${traceId}') returned an empty run id`);
+		const runId = suppliedRunId.trim();
+		const target = byRun.get(runId) ?? [];
+		for (const span of spans) target.push({
+			...span,
+			span_id: qualifySpanId(traceId, span.span_id),
+			parent_span_id: span.parent_span_id ? qualifySpanId(traceId, span.parent_span_id) : null
+		});
+		byRun.set(runId, target);
+	}
+	return byRun;
+}
+function qualifySpanId(traceId, spanId) {
+	const prefix = `${traceId}:`;
+	return spanId.startsWith(prefix) ? spanId : `${prefix}${spanId}`;
+}
+function aggregateTrace(traceId, spans, fallbackModel) {
+	const ordered = [...spans].sort((a, b) => compareSpanTime(a.start_time, b.start_time) || a.span_id.localeCompare(b.span_id));
+	const measurements = summarizeExecutionMeasurements(ordered.map((span) => ({
+		id: span.span_id,
+		...span.parent_span_id ? { parentId: span.parent_span_id } : {},
+		attributes: span.attributes,
+		modelCall: isOtlpModelCall({
+			kind: span.kind,
+			name: span.name,
+			attributes: span.attributes
+		}),
+		aggregate: span.kind !== "LLM" && span.kind !== "UNKNOWN"
+	})));
+	let toolSpanCount = 0;
+	let agentSpanCount = 0;
+	let firstErrorMessage;
+	const modelVotes = /* @__PURE__ */ new Map();
+	let earliest = ordered[0]?.start_time ?? "";
+	let latest = ordered[0]?.end_time ?? "";
+	for (const s of ordered) {
+		if (s.start_time && (!earliest || compareSpanTime(s.start_time, earliest) < 0)) earliest = s.start_time;
+		if (s.end_time && (!latest || compareSpanTime(s.end_time, latest) > 0)) latest = s.end_time;
+		if (s.kind === "TOOL") toolSpanCount += 1;
+		else if (s.kind === "AGENT") agentSpanCount += 1;
+		if (s.status === "ERROR") {
+			if (firstErrorMessage === void 0) firstErrorMessage = (s.status_message ?? `${s.name} — STATUS_CODE_ERROR`).slice(0, 500);
+		}
+	}
+	const callSpanIds = new Set(measurements.callSpanIds);
+	for (const span of ordered) {
+		if (!callSpanIds.has(span.span_id)) continue;
+		const model = firstStringAttr(span.attributes, LLM_MODEL_ATTR_KEYS) ?? span.model_name;
+		if (model) modelVotes.set(model, (modelVotes.get(model) ?? 0) + 1);
+	}
+	const model = topVote(modelVotes) ?? firstModelAttr(ordered) ?? fallbackModel;
+	let wallMs = 0;
+	const a = spanEpochMillis(earliest);
+	const b = spanEpochMillis(latest);
+	if (a !== null && b !== null) wallMs = Math.max(0, b - a);
+	const sourceTraceIds = [...new Set(spans.map((span) => span.trace_id))].sort();
+	const terminal = terminalEvidenceFromRoots(ordered);
+	const errorSummary = summarizeTraceErrors(ordered.map((span) => ({
+		id: span.span_id,
+		...span.parent_span_id ? { parentId: span.parent_span_id } : {},
+		role: errorRoleForProjectedSpan(span),
+		error: span.status === "ERROR",
+		processRoot: span.parent_span_id === null && isTerminalRootCandidate(span)
+	})));
+	return {
+		traceId,
+		sourceTraceCount: sourceTraceIds.length,
+		sourceTraceIds,
+		spanCount: spans.length,
+		llmSpanCount: measurements.modelCallCount,
+		toolSpanCount,
+		agentSpanCount,
+		errorSpanCount: errorSummary.total,
+		executionErrorCount: errorSummary.execution,
+		processErrorCount: errorSummary.process,
+		guardrailErrorCount: errorSummary.guardrail,
+		judgeErrorCount: errorSummary.evaluation,
+		propagatedErrorCount: errorSummary.propagated,
+		unclassifiedErrorCount: errorSummary.unclassified,
+		tokenUsage: measurements.tokenUsage,
+		firstErrorMessage,
+		model,
+		startTime: earliest,
+		endTime: latest,
+		wallMs,
+		terminalOutcome: terminal.outcome,
+		...terminal.failureMessage ? { terminalFailureMessage: terminal.failureMessage } : {},
+		callSpanIds: measurements.callSpanIds,
+		costMeasurement: measurements.cost,
+		...measurements.aggregate ? { aggregateMeasurement: measurements.aggregate } : {}
+	};
+}
+function terminalEvidenceFromRoots(spans) {
+	const roots = spans.filter((span) => span.parent_span_id === null && isTerminalRootCandidate(span));
+	if (roots.length !== 1) return { outcome: "unknown" };
+	const root = roots[0];
+	if (root.status === "ERROR") return {
+		outcome: "failed",
+		failureMessage: (root.status_message ?? `${root.name} — STATUS_CODE_ERROR`).slice(0, 500)
+	};
+	if (root.status === "OK") return { outcome: "succeeded" };
+	return { outcome: "unknown" };
+}
+function isTerminalRootCandidate(span) {
+	const role = errorRoleForProjectedSpan(span);
+	return role !== "LLM" && role !== "TOOL" && role !== "EVALUATOR" && role !== "GUARDRAIL";
+}
+function errorRoleForProjectedSpan(span) {
+	return classifyOtlpSpanRole({
+		kind: span.kind,
+		name: span.name,
+		attributes: span.attributes
+	});
+}
+function resolveScore(opts, traceId, agg) {
+	const supplied = opts.scoreForTrace?.(traceId, agg);
+	if (supplied !== void 0) {
+		if (!Number.isFinite(supplied)) throw new Error(`otlpToRunRecords: scoreForTrace('${traceId}') returned non-finite ${supplied}`);
+		return supplied;
+	}
+}
+function resolveCost(opts, agg) {
+	const observedCost = agg.costMeasurement;
+	if (observedCost.complete && observedCost.value !== void 0) return {
+		costUsd: observedCost.value,
+		costProvenance: {
+			kind: "observed",
+			usd: observedCost.value
+		}
+	};
+	if (agg.aggregateMeasurement?.costUsd !== void 0) return {
+		costUsd: agg.aggregateMeasurement.costUsd,
+		costProvenance: {
+			kind: "observed",
+			usd: agg.aggregateMeasurement.costUsd
+		}
+	};
+	if (opts.priceUsdPerToken !== void 0) {
+		const costUsd = (agg.tokenUsage.input + agg.tokenUsage.output) * opts.priceUsdPerToken;
+		return {
+			costUsd,
+			costProvenance: {
+				kind: "estimated",
+				usd: costUsd
+			}
+		};
+	}
+	return {
+		costUsd: null,
+		costProvenance: {
+			kind: "uncaptured",
+			usd: null
+		}
+	};
+}
+function extractPromptCompletion(spans, callSpanIds) {
+	const callIds = new Set(callSpanIds);
+	const measuredCalls = spans.filter((span) => callIds.has(span.span_id));
+	const llm = (measuredCalls.length > 0 ? measuredCalls : spans.filter((s) => s.kind === "LLM")).sort((a, b) => compareSpanTime(a.start_time, b.start_time) || a.span_id.localeCompare(b.span_id));
+	if (llm.length === 0) return {};
+	const promptText = firstStringAttr(llm[0].attributes, [
+		"input.value",
+		"llm.input_messages",
+		"gen_ai.prompt"
+	]) ?? void 0;
+	const last = llm[llm.length - 1];
+	const completionText = firstStringAttr(last.attributes, [
+		"output.value",
+		"llm.output_messages",
+		"gen_ai.completion"
+	]) ?? void 0;
+	return {
+		...promptText !== void 0 ? { promptText } : {},
+		...completionText !== void 0 ? { completionText } : {}
+	};
+}
+function topVote(votes) {
+	let best = null;
+	let bestN = 0;
+	for (const [k, n] of votes) if (n > bestN || n === bestN && best !== null && k < best) {
+		best = k;
+		bestN = n;
+	}
+	return best;
+}
+function firstModelAttr(spans) {
+	for (const s of spans) {
+		const m = firstStringAttr(s.attributes, LLM_MODEL_ATTR_KEYS) ?? s.model_name;
+		if (m) return m;
+	}
+	return null;
+}
+/**
+* `validateRunRecord` rejects bare model aliases (`gpt-4o`) that remap
+* silently. AppWorld/HALO traces frequently carry such bare ids (or a null
+* model). When the model already encodes a snapshot we keep it; otherwise we
+* append the fallback snapshot token so the row is admissible without lying
+* about the model — the bare base name is preserved verbatim before `@`.
+*/
+function ensureSnapshot(model, fallbackModel) {
+	if (modelHasSnapshot(model)) return model;
+	return `${model}${fallbackModel.includes("@") ? fallbackModel.slice(fallbackModel.indexOf("@")) : "@otlp"}`;
+}
+function modelHasSnapshot(model) {
+	if (model.includes("@")) return true;
+	if (/-\d{8}$/.test(model)) return true;
+	if (/-\d{4}-\d{2}-\d{2}$/.test(model)) return true;
+	if (/:date-/.test(model)) return true;
+	return false;
+}
+//#endregion
+//#region src/trace/capture-fetch.ts
+/**
+* Wrap a provider `fetch` and record request, response, and error events.
+*
+* The returned value is a plain `typeof fetch`. Capture is best-effort by
+* default; set `failClosed` when telemetry loss must stop the provider call.
+*/
+const DEFAULT_BODY_CAP = 2 * 1024 * 1024;
+function headersToRecord(headers) {
+	if (!headers) return void 0;
+	const out = {};
+	headers.forEach((value, key) => {
+		out[key.toLowerCase()] = value;
+	});
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function parseMaybeJson(text) {
+	if (text.length === 0) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+/** Best-effort request-body read across the `fetch` input forms. */
+async function readRequestBody(input, init) {
+	if (typeof init?.body === "string") return parseMaybeJson(init.body);
+	if (init?.body != null) return void 0;
+	if (input instanceof Request) try {
+		return parseMaybeJson(await input.clone().text());
+	} catch {
+		return;
+	}
+}
+function endpointFromUrl(url, baseUrl) {
+	const normalisedBase = baseUrl.replace(/\/+$/, "");
+	if (url.startsWith(normalisedBase)) return url.slice(normalisedBase.length) || "/";
+	try {
+		return new URL(url).pathname;
+	} catch {
+		return url;
+	}
+}
+function captureFetchToRawSink(fetch, sink, ctx, opts = {}) {
+	const provider = ctx.provider ?? providerFromBaseUrl(ctx.baseUrl);
+	const redactor = opts.redactor ?? defaultProviderRedactor;
+	const bodyCap = opts.responseBodyByteCap ?? DEFAULT_BODY_CAP;
+	let warned = false;
+	const baseEvent = (direction, endpoint) => ({
+		eventId: crypto.randomUUID(),
+		runId: ctx.runId,
+		spanId: ctx.spanId,
+		provider,
+		model: ctx.model,
+		endpoint,
+		baseUrl: ctx.baseUrl,
+		attemptIndex: 0,
+		direction,
+		timestamp: Date.now(),
+		redactedFields: []
+	});
+	const record = async (event) => {
+		try {
+			await sink.record(redactor(event));
+		} catch (err) {
+			if (opts.failClosed) throw err;
+			if (!warned) {
+				warned = true;
+				console.warn(`captureFetchToRawSink: sink.record failed (capture is best-effort) — ${err instanceof Error ? err.message : String(err)}`);
+			}
+		}
+	};
+	return async (input, init) => {
+		const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+		const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+		const endpoint = endpointFromUrl(url, ctx.baseUrl);
+		const reqHeaders = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+		await record({
+			...baseEvent("request", endpoint),
+			requestHeaders: {
+				...headersToRecord(reqHeaders),
+				"x-http-method": method
+			},
+			requestBody: await readRequestBody(input, init)
+		});
+		const start = Date.now();
+		let response;
+		try {
+			response = await fetch(input, init);
+		} catch (err) {
+			await record({
+				...baseEvent("error", endpoint),
+				durationMs: Date.now() - start,
+				errorMessage: err instanceof Error ? err.message : String(err)
+			});
+			throw err;
+		}
+		let responseBody;
+		let rawText;
+		const redactedFields = [];
+		try {
+			rawText = await response.clone().text();
+			if (rawText.length > bodyCap) {
+				responseBody = rawText.slice(0, bodyCap);
+				redactedFields.push("body_truncated");
+			} else responseBody = parseMaybeJson(rawText);
+		} catch {
+			responseBody = void 0;
+		}
+		if (opts.onUsage && rawText !== void 0) try {
+			const parsedForUsage = parseMaybeJson(rawText);
+			const usage = extractUsage(parsedForUsage) ?? (typeof parsedForUsage === "string" ? extractUsageFromSse(rawText, { mode: opts.sseUsageMode }) : null);
+			if (usage) opts.onUsage(usage, ctx);
+		} catch (err) {
+			if (opts.failClosed) throw err;
+		}
+		await record({
+			...baseEvent("response", endpoint),
+			durationMs: Date.now() - start,
+			statusCode: response.status,
+			responseHeaders: headersToRecord(response.headers),
+			responseBody,
+			redactedFields
+		});
+		return response;
+	};
+}
+//#endregion
+//#region src/trace/otel.ts
+/**
+* OpenTelemetry JSON export — maps TraceSchema v1 to OTLP/JSON so
+* traces render natively in Jaeger / Honeycomb / Langfuse / Grafana.
+*
+* Wire format only. We do NOT depend on the @opentelemetry SDK — that
+* would drag in polyfills incompatible with Workers/Edge. Consumers
+* push the JSON to their collector of choice via HTTP.
+*
+* Reference: OTLP 1.3.2 (ResourceSpans / ScopeSpans / Span).
+*/
+const OTEL_AGENT_EVAL_SCOPE = {
+	name: "@tangle-network/agent-eval",
+	version: "0.3.0"
+};
+/** Export a single run's spans + events in OTLP/JSON. */
+async function exportRunAsOtlp(store, runId, resourceAttrs = {}) {
+	const run = await store.getRun(runId);
+	if (!run) throw new Error(`run ${runId} not found`);
+	const spans = await store.spans({ runId });
+	const events = await store.events({ runId });
+	const eventsBySpan = /* @__PURE__ */ new Map();
+	for (const e of events) {
+		if (!e.spanId) continue;
+		const arr = eventsBySpan.get(e.spanId) ?? [];
+		arr.push(e);
+		eventsBySpan.set(e.spanId, arr);
+	}
+	const traceId = runToTraceId(run);
+	const otlpSpans = spans.map((s) => spanToOtlp(s, traceId, eventsBySpan.get(s.spanId) ?? []));
+	return { resourceSpans: [{
+		resource: { attributes: toAttributes$1({
+			"service.name": "agent-eval",
+			"run.id": run.runId,
+			"run.scenario_id": run.scenarioId,
+			"run.variant_id": run.variantId ?? "",
+			"run.dataset_version": run.datasetVersion ?? "",
+			"run.code_sha": run.codeSha ?? "",
+			"run.model_fingerprint": run.modelFingerprint ?? "",
+			...resourceAttrs
+		}) },
+		scopeSpans: [{
+			scope: OTEL_AGENT_EVAL_SCOPE,
+			spans: otlpSpans
+		}]
+	}] };
+}
+function spanToOtlp(span, traceId, events) {
+	const endedAt = span.endedAt ?? span.startedAt;
+	return {
+		traceId,
+		spanId: padSpanId$2(span.spanId),
+		parentSpanId: span.parentSpanId ? padSpanId$2(span.parentSpanId) : void 0,
+		name: span.name,
+		kind: 1,
+		startTimeUnixNano: msToNs$1(span.startedAt),
+		endTimeUnixNano: msToNs$1(endedAt),
+		attributes: toAttributes$1(flattenSpanAttributes(span)),
+		events: events.map((e) => ({
+			timeUnixNano: msToNs$1(e.timestamp),
+			name: e.kind,
+			attributes: toAttributes$1(flattenPayload(e.payload))
+		})),
+		status: span.status === "error" ? {
+			code: 2,
+			message: span.error
+		} : { code: 1 }
+	};
+}
+function flattenSpanAttributes(span) {
+	const base = {};
+	if (span.attributes) {
+		for (const [k, v] of Object.entries(span.attributes)) if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") base[k] = v;
+	}
+	base[OPENINFERENCE_SPAN_KIND] = traceSpanKindToOpenInferenceKind(span.kind);
+	if (span.kind === "llm") applyLlmSpanOtlpAttributes(base, span);
+	else if (span.kind === "tool") applyToolSpanOtlpAttributes(base, span);
+	else if (span.kind === "retrieval") {
+		base["retrieval.query"] = span.query;
+		base["retrieval.hits"] = span.hits.length;
+	} else if (span.kind === "judge") {
+		base["judge.id"] = span.judgeId;
+		base["judge.dimension"] = span.dimension;
+		base["judge.score"] = span.score;
+		base["judge.target_span_id"] = span.targetSpanId;
+	} else if (span.kind === "sandbox") {
+		if (span.image) base["sandbox.image"] = span.image;
+		if (span.exitCode !== void 0) base["sandbox.exit_code"] = span.exitCode;
+		if (span.testsPassed !== void 0) base["sandbox.tests_passed"] = span.testsPassed;
+		if (span.testsTotal !== void 0) base["sandbox.tests_total"] = span.testsTotal;
+	}
+	return base;
+}
+function flattenPayload(payload) {
+	const out = {};
+	for (const [k, v] of Object.entries(payload)) if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") out[k] = v;
+	else out[k] = JSON.stringify(v);
+	return out;
+}
+function toAttributes$1(record) {
+	return Object.entries(record).map(([key, value]) => ({
+		key,
+		value: typeof value === "number" ? Number.isInteger(value) ? { intValue: value.toString() } : { doubleValue: value } : typeof value === "boolean" ? { boolValue: value } : { stringValue: value }
+	}));
+}
+function msToNs$1(ms) {
+	return (BigInt(Math.floor(ms)) * 1000000n).toString();
+}
+function padSpanId$2(id) {
+	return id.replace(/-/g, "").slice(0, 16).padEnd(16, "0");
+}
+function runToTraceId(run) {
+	return run.runId.replace(/-/g, "").slice(0, 32).padEnd(32, "0");
+}
+//#endregion
+//#region src/trace/otel-bridge.ts
+/**
+* Create a RunCompleteHook that exports all spans from the completed run
+* to the OTEL exporter, then flushes.
+*/
+function otelRunCompleteHook(exporter) {
+	return async (ctx) => {
+		const spans = await ctx.store.spans({ runId: ctx.runId });
+		for (const span of spans) if (span.endedAt) exporter.exportSpan(storeSpanToExportable(span, ctx.runId));
+		await exporter.flush();
+	};
+}
+/**
+* Create an auto-exporting TraceStore wrapper that intercepts updateSpan
+* calls. When a span gets an endedAt, it's exported immediately. This
+* gives real-time streaming instead of batch-at-end.
+*
+* This is the preferred integration path: wrap the store before
+* constructing the TraceEmitter.
+*/
+function createOtelTracingStore(inner, exporter, traceId) {
+	return {
+		async appendRun(run) {
+			return inner.appendRun(run);
+		},
+		async updateRun(runId, patch) {
+			return inner.updateRun(runId, patch);
+		},
+		async appendSpan(span) {
+			if (span.endedAt) exporter.exportSpan(storeSpanToExportable(span, traceId));
+			return inner.appendSpan(span);
+		},
+		async updateSpan(spanId, patch) {
+			await inner.updateSpan(spanId, patch);
+			if (patch.endedAt) {
+				const found = (await inner.spans({ runId: traceId })).find((s) => s.spanId === spanId);
+				if (found) exporter.exportSpan(storeSpanToExportable(found, traceId));
+			}
+		},
+		async appendEvent(event) {
+			return inner.appendEvent(event);
+		},
+		async appendBudgetEntry(entry) {
+			return inner.appendBudgetEntry(entry);
+		},
+		async appendArtifact(artifact) {
+			return inner.appendArtifact(artifact);
+		},
+		getRun: inner.getRun.bind(inner),
+		listRuns: inner.listRuns.bind(inner),
+		spans: inner.spans.bind(inner),
+		events: inner.events.bind(inner),
+		budget: inner.budget.bind(inner),
+		artifacts: inner.artifacts.bind(inner)
+	};
+}
+function storeSpanToExportable(span, traceId) {
+	const llm = span.kind === "llm" ? span : void 0;
+	const tool = span.kind === "tool" ? span : void 0;
+	return {
+		traceId,
+		spanId: span.spanId,
+		parentSpanId: span.parentSpanId,
+		name: span.name,
+		kind: span.kind,
+		startedAt: span.startedAt,
+		endedAt: span.endedAt,
+		status: span.status,
+		error: span.error,
+		model: llm?.model,
+		inputTokens: llm?.inputTokens,
+		outputTokens: llm?.outputTokens,
+		reasoningTokens: llm?.reasoningTokens,
+		cachedTokens: llm?.cachedTokens,
+		cacheWriteTokens: llm?.cacheWriteTokens,
+		costUsd: llm?.costUsd,
+		tool: tool ? {
+			toolName: tool.toolName,
+			args: tool.args,
+			argsCaptured: tool.argsCaptured,
+			result: tool.result,
+			latencyMs: tool.latencyMs
+		} : void 0,
+		attributes: span.attributes
+	};
+}
+//#endregion
+//#region src/trace/otel-export.ts
+/**
+* OTEL span exporter — streams spans to an OTLP/HTTP collector.
+*
+* Reads OTEL_EXPORTER_OTLP_ENDPOINT + OTEL_EXPORTER_OTLP_HEADERS from env
+* when no explicit config is given. Batches spans and flushes periodically
+* or when the batch fills. No @opentelemetry SDK dependency — minimal
+* OTLP/JSON serializer (~120 LOC) using the existing otel.ts helpers.
+*/
+/**
+* Create an OTEL exporter. Returns undefined when no endpoint is configured
+* (neither via config nor env) — callers should check before attaching.
+*/
+function createOtelExporter(config) {
+	const resolvedEndpoint = config?.endpoint ?? (typeof process !== "undefined" ? process.env.OTEL_EXPORTER_OTLP_ENDPOINT : void 0);
+	if (!resolvedEndpoint) return void 0;
+	const endpoint = resolvedEndpoint;
+	const headers = config?.headers ?? parseHeadersFromEnv();
+	const batchSize = config?.batchSize ?? 64;
+	const flushIntervalMs = config?.flushIntervalMs ?? 5e3;
+	const serviceName = config?.serviceName ?? "agent-eval";
+	const resourceAttrs = config?.resourceAttributes ?? {};
+	const pending = [];
+	let timer;
+	let stopped = false;
+	const exporter = {
+		exportSpan(span) {
+			if (stopped) return;
+			pending.push(toOtlpSpan(span));
+			if (pending.length >= batchSize) doFlush();
+		},
+		async flush() {
+			await doFlush();
+		},
+		async shutdown() {
+			stopped = true;
+			if (timer !== void 0) {
+				clearInterval(timer);
+				timer = void 0;
+			}
+			await doFlush();
+		}
+	};
+	timer = setInterval(() => {
+		if (pending.length > 0) doFlush();
+	}, flushIntervalMs);
+	if (typeof timer === "object" && "unref" in timer) timer.unref();
+	async function doFlush() {
+		if (pending.length === 0) return;
+		const batch = pending.splice(0);
+		const body = { resourceSpans: [{
+			resource: { attributes: toAttributes({
+				"service.name": serviceName,
+				...resourceAttrs
+			}) },
+			scopeSpans: [{
+				scope: OTEL_AGENT_EVAL_SCOPE,
+				spans: batch
+			}]
+		}] };
+		const url = `${endpoint.replace(/\/+$/, "")}/v1/traces`;
+		try {
+			await fetch(url, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					...headers
+				},
+				body: JSON.stringify(body)
+			});
+		} catch {}
+	}
+	return exporter;
+}
+function parseHeadersFromEnv() {
+	if (typeof process === "undefined") return {};
+	const raw = process.env.OTEL_EXPORTER_OTLP_HEADERS;
+	if (!raw) return {};
+	const out = {};
+	for (const pair of raw.split(",")) {
+		const eq = pair.indexOf("=");
+		if (eq < 0) continue;
+		const key = pair.slice(0, eq).trim();
+		const value = pair.slice(eq + 1).trim();
+		if (key) out[key] = value;
+	}
+	return out;
+}
+function toOtlpSpan(span) {
+	const endedAt = span.endedAt ?? span.startedAt;
+	const attrs = {};
+	if (span.attributes) {
+		for (const [k, v] of Object.entries(span.attributes)) if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") attrs[k] = v;
+	}
+	attrs[OPENINFERENCE_SPAN_KIND] = traceSpanKindToOpenInferenceKind(span.kind);
+	applyLlmSpanOtlpAttributes(attrs, span);
+	if (span.tool) applyToolSpanOtlpAttributes(attrs, span.tool);
+	return {
+		traceId: padTraceId$1(span.traceId),
+		spanId: padSpanId$1(span.spanId),
+		parentSpanId: span.parentSpanId ? padSpanId$1(span.parentSpanId) : void 0,
+		name: span.name,
+		kind: 1,
+		startTimeUnixNano: msToNs(span.startedAt),
+		endTimeUnixNano: msToNs(endedAt),
+		attributes: toAttributes(attrs),
+		status: span.status === "error" ? {
+			code: 2,
+			message: span.error
+		} : { code: 1 }
+	};
+}
+function toAttributes(record) {
+	return Object.entries(record).map(([key, value]) => ({
+		key,
+		value: typeof value === "number" ? Number.isInteger(value) ? { intValue: value.toString() } : { doubleValue: value } : typeof value === "boolean" ? { boolValue: value } : { stringValue: value }
+	}));
+}
+function msToNs(ms) {
+	return (BigInt(Math.floor(ms)) * 1000000n).toString();
+}
+function padSpanId$1(id) {
+	return id.replace(/-/g, "").slice(0, 16).padEnd(16, "0");
+}
+function padTraceId$1(id) {
+	return id.replace(/-/g, "").slice(0, 32).padEnd(32, "0");
+}
+//#endregion
+//#region src/trace/store-to-otlp.ts
+/**
+* Convert agent-eval's internal trace shape (`FileSystemTraceStore` → `Run`,
+* `Span`, `TraceEvent`) into the OTLP-flat JSONL the trace analyst
+* (`analyzeTraces` + `OtlpFileTraceStore`) reads.
+*
+* Eval harnesses shard a `FileSystemTraceStore` per cell (persona / variant)
+* under a run directory. The analyst consumes a single OTLP-NDJSON file keyed
+* on `trace_id` + `span_id` with `start_time`/`end_time` in ISO-8601 and
+* resource + `attributes` rolled up per-span. This module walks every shard,
+* projects each `Span` (plus events pinned to it) into the flat OTLP shape,
+* and emits one NDJSON file.
+*
+* Generic OTLP/OpenInference fields are always emitted (`service.name`,
+* `agent.name`, `run.id`/`run.status`, `openinference.span.kind`,
+* `llm.model_name`, …). Domain attributes (`legal.*`, `tax.*`, …) are injected
+* per-run via {@link TraceStoreToOtlpOptions.resourceAttributes} /
+* {@link TraceStoreToOtlpOptions.runAttributes} so consumers don't re-roll the
+* walker.
+*/
+/**
+* Read every per-cell shard under each source root and write a flat OTLP-JSONL
+* view of the corpus to `outPath`. Each cell directory is a
+* `FileSystemTraceStore` — NDJSON append-only with size-based rotation;
+* `updateRun`/`updateSpan` append `{ id, ...patch, _update: true }` rows
+* rather than rewriting, so readers must merge those patches in (done here).
+*
+* A `string` source is treated as a celled root.
+*/
+function convertTraceStoresToOtlp(source, outPath, opts = {}) {
+	const sources = Array.isArray(source) ? [...source] : typeof source === "string" ? [{
+		root: source,
+		layout: "celled"
+	}] : [source];
+	const defaultServiceName = opts.serviceName ?? "agent-eval";
+	const resourceAttributes = opts.resourceAttributes ?? (() => ({}));
+	const runAttributes = opts.runAttributes ?? (() => ({}));
+	const lines = [];
+	let spanCount = 0;
+	let runCount = 0;
+	let cellCount = 0;
+	let cellErrorCount = 0;
+	for (const src of sources) {
+		const serviceName = src.serviceName ?? defaultServiceName;
+		const cellDirs = src.layout === "flat" ? [{
+			label: "<root>",
+			dir: src.root
+		}] : listCells(src.root).map((name) => ({
+			label: name,
+			dir: join(src.root, name)
+		}));
+		for (const cell of cellDirs) try {
+			const result = projectCell({
+				cellDir: cell.dir,
+				serviceName,
+				resourceAttributes,
+				runAttributes
+			});
+			for (const line of result.lines) lines.push(line);
+			spanCount += result.spanCount;
+			runCount += result.runCount;
+			cellCount += 1;
+		} catch (err) {
+			console.warn(`[traces-to-otlp] cell ${cell.label} (${cell.dir}) skipped: ${err instanceof Error ? err.message : String(err)}`);
+			cellErrorCount += 1;
+		}
+	}
+	writeFileSync(outPath, lines.join("\n") + (lines.length > 0 ? "\n" : ""));
+	return {
+		spanCount,
+		runCount,
+		cellCount,
+		cellErrorCount
+	};
+}
+function projectCell(args) {
+	const { cellDir, serviceName, resourceAttributes, runAttributes } = args;
+	const lines = [];
+	let runCount = 0;
+	let spanCount = 0;
+	const runs = readMergedShards(cellDir, "runs", "runId");
+	const spans = readMergedShards(cellDir, "spans", "spanId");
+	const events = readShards(cellDir, "events");
+	const runByRunId = /* @__PURE__ */ new Map();
+	for (const r of runs) runByRunId.set(r.runId, r);
+	const spanBySpanId = /* @__PURE__ */ new Map();
+	for (const s of spans) spanBySpanId.set(s.spanId, s);
+	const eventsBySpanId = /* @__PURE__ */ new Map();
+	for (const e of events) {
+		if (e.kind === "state_mutation" && e.payload && typeof e.payload === "object") {
+			const entity = e.payload.entity;
+			if (entity === "run") {
+				const run = e.payload.run;
+				if (run?.runId) runByRunId.set(run.runId, run);
+				continue;
+			}
+			if (entity === "run.update") {
+				const patch = e.payload.patch;
+				if (patch && e.runId) {
+					const prior = runByRunId.get(e.runId);
+					if (prior) runByRunId.set(e.runId, {
+						...prior,
+						...patch
+					});
+				}
+				continue;
+			}
+			if (entity === "span") {
+				const span = e.payload.span;
+				if (span?.spanId) spanBySpanId.set(span.spanId, span);
+				continue;
+			}
+			if (entity === "span.update") {
+				const spanId = e.payload.spanId;
+				const patch = e.payload.patch;
+				if (spanId && patch) {
+					const prior = spanBySpanId.get(spanId);
+					if (prior) spanBySpanId.set(spanId, {
+						...prior,
+						...patch
+					});
+				}
+				continue;
+			}
+		}
+		if (!e.spanId) continue;
+		const arr = eventsBySpanId.get(e.spanId) ?? [];
+		arr.push(e);
+		eventsBySpanId.set(e.spanId, arr);
+	}
+	for (const run of runByRunId.values()) {
+		const traceId = padTraceId(run.runId);
+		const agentName = run.variantId ?? run.scenarioId;
+		const sharedResource = { attributes: {
+			"service.name": serviceName,
+			"agent.name": agentName,
+			"run.id": run.runId,
+			"run.status": run.status,
+			...resourceAttributes(run)
+		} };
+		const runSpanId = padSpanId(`run-${run.runId}`);
+		const runStart = msToIso(run.startedAt);
+		const runEnd = msToIso(run.endedAt ?? run.startedAt);
+		const runStatus = run.outcome?.failureClass && run.outcome.failureClass !== "success" ? "STATUS_CODE_ERROR" : "STATUS_CODE_OK";
+		const runAttrs = {
+			[OPENINFERENCE_SPAN_KIND]: "AGENT",
+			"agent.name": agentName,
+			"agent.workflow.name": serviceName,
+			...runAttributes(run)
+		};
+		lines.push(JSON.stringify(toLine({
+			traceId,
+			spanId: runSpanId,
+			parentSpanId: "",
+			name: `run.${agentName}`,
+			kind: "SPAN_KIND_INTERNAL",
+			startTime: runStart,
+			endTime: runEnd,
+			statusCode: runStatus,
+			statusMessage: run.outcome?.notes ?? "",
+			resource: sharedResource,
+			attributes: runAttrs
+		})));
+		runCount += 1;
+		for (const span of spanBySpanId.values()) {
+			if (span.runId !== run.runId) continue;
+			const spanAttrs = spanToAttributes(span, eventsBySpanId.get(span.spanId) ?? []);
+			const statusCode = span.status === "error" ? "STATUS_CODE_ERROR" : "STATUS_CODE_OK";
+			lines.push(JSON.stringify(toLine({
+				traceId,
+				spanId: padSpanId(span.spanId),
+				parentSpanId: span.parentSpanId ? padSpanId(span.parentSpanId) : runSpanId,
+				name: span.name,
+				kind: spanKindToOtlpKind(span.kind),
+				startTime: msToIso(span.startedAt),
+				endTime: msToIso(span.endedAt ?? span.startedAt),
+				statusCode,
+				statusMessage: span.error ?? "",
+				resource: sharedResource,
+				attributes: spanAttrs
+			})));
+			spanCount += 1;
+		}
+	}
+	return {
+		lines,
+		runCount,
+		spanCount
+	};
+}
+function listCells(root) {
+	try {
+		return readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+	} catch {
+		return [];
+	}
+}
+/**
+* Read every NDJSON shard for `name` under `cellDir`, ordered by mtime so
+* rotated files apply before the active one. Yields raw rows including any
+* `_update: true` patches.
+*/
+function readShards(cellDir, name) {
+	let entries;
+	try {
+		entries = readdirSync(cellDir);
+	} catch {
+		return [];
+	}
+	const shards = entries.filter((f) => (f === `${name}.ndjson` || f.startsWith(`${name}.`)) && f.endsWith(".ndjson")).map((f) => ({
+		file: f,
+		path: join(cellDir, f)
+	})).map((s) => {
+		let mtime = 0;
+		try {
+			mtime = statSync(s.path).mtimeMs;
+		} catch {}
+		return {
+			...s,
+			mtime
+		};
+	}).sort((a, b) => a.mtime - b.mtime || a.file.localeCompare(b.file));
+	const rows = [];
+	for (const shard of shards) {
+		let text;
+		try {
+			text = readFileSync(shard.path, "utf-8");
+		} catch {
+			continue;
+		}
+		for (const line of text.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			try {
+				rows.push(JSON.parse(trimmed));
+			} catch {}
+		}
+	}
+	return rows;
+}
+/**
+* Read NDJSON shards and merge `{ ...patch, _update: true }` rows into the
+* prior record keyed on `idKey` — mirrors the in-memory merge
+* `FileSystemTraceStore` keeps but doesn't replay on cross-process load.
+*/
+function readMergedShards(cellDir, name, idKey) {
+	const rows = readShards(cellDir, name);
+	const byId = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const id = row[idKey];
+		if (!id) continue;
+		const prior = byId.get(id);
+		if (prior && row._update) byId.set(id, {
+			...prior,
+			...row,
+			_update: void 0
+		});
+		else byId.set(id, row);
+	}
+	return [...byId.values()];
+}
+function spanToAttributes(span, events) {
+	const attrs = { [OPENINFERENCE_SPAN_KIND]: traceSpanKindToOpenInferenceKind(span.kind) };
+	if (span.kind === "llm") {
+		applyLlmSpanOtlpAttributes(attrs, span);
+		if (Array.isArray(span.messages)) attrs["llm.input_messages"] = JSON.stringify(span.messages.slice(-6));
+		if (typeof span.output === "string") attrs["llm.output_messages"] = JSON.stringify([{
+			role: "assistant",
+			content: span.output
+		}]);
+	} else if (span.kind === "tool") applyToolSpanOtlpAttributes(attrs, span);
+	else if (span.kind === "judge") {
+		attrs["judge.id"] = span.judgeId;
+		attrs["judge.dimension"] = span.dimension;
+		attrs["judge.score"] = span.score;
+		attrs["judge.target_span_id"] = span.targetSpanId;
+	}
+	if (span.attributes) for (const [k, v] of Object.entries(span.attributes)) attrs[`agent_eval.${k}`] = v;
+	if (events.length > 0) {
+		attrs["agent_eval.event_count"] = events.length;
+		attrs["agent_eval.event_kinds"] = JSON.stringify(events.map((e) => e.kind));
+	}
+	return attrs;
+}
+function spanKindToOtlpKind(kind) {
+	switch (kind) {
+		case "llm": return "SPAN_KIND_CLIENT";
+		case "retrieval": return "SPAN_KIND_CLIENT";
+		default: return "SPAN_KIND_INTERNAL";
+	}
+}
+function toLine(args) {
+	return {
+		trace_id: args.traceId,
+		span_id: args.spanId,
+		parent_span_id: args.parentSpanId,
+		name: args.name,
+		kind: args.kind,
+		start_time: args.startTime,
+		end_time: args.endTime,
+		status: {
+			code: args.statusCode,
+			message: args.statusMessage
+		},
+		resource: args.resource,
+		attributes: args.attributes
+	};
+}
+function msToIso(ms) {
+	if (!Number.isFinite(ms) || ms <= 0) return (/* @__PURE__ */ new Date(0)).toISOString();
+	return new Date(ms).toISOString();
+}
+/** OTLP wants 16-hex span ids; eval traces use UUID-ish strings. Hex-strip +
+*  take 16, else deterministic FNV fold. */
+function padSpanId(id) {
+	const cleaned = id.replace(/[^a-f0-9]/gi, "").toLowerCase();
+	if (cleaned.length >= 16) return cleaned.slice(0, 16);
+	return foldTo16Hex(id);
+}
+/** OTLP wants 32-hex trace ids; fold deterministically when too short. */
+function padTraceId(id) {
+	const cleaned = id.replace(/[^a-f0-9]/gi, "").toLowerCase();
+	if (cleaned.length >= 32) return cleaned.slice(0, 32);
+	return foldTo32Hex(id);
+}
+function foldTo16Hex(s) {
+	let h1 = 2166136261;
+	for (const ch of s) {
+		h1 ^= ch.charCodeAt(0);
+		h1 = Math.imul(h1, 16777619) >>> 0;
+	}
+	const part = h1.toString(16).padStart(8, "0");
+	return (part + part).slice(0, 16);
+}
+function foldTo32Hex(s) {
+	return foldTo16Hex(s) + foldTo16Hex(`${s}::trace`).slice(0, 16);
+}
+//#endregion
+//#region src/replay.ts
+/**
+* Replay-from-raw-events — turn every captured campaign run into a
+* re-runnable artifact.
+*
+* `RawProviderSink` captures every provider HTTP envelope; `runEvalCampaign`
+* makes that capture the default. Together they make every past run a
+* complete fingerprint of what happened on the wire — enough to replay
+* the run without burning new LLM cost.
+*
+* Three use cases this primitive enables:
+*
+*   1. **Post-hoc judging** — apply a new judge / rubric / scoring callback
+*      to last week's runs without re-calling any LLM. The cost of trying
+*      a new rubric drops from "another full sweep" to a CPU-bound replay.
+*   2. **Determinism audits** — replay the same campaign and verify the
+*      raw responses match byte-for-byte. Any drift is a non-determinism
+*      bug (in the harness, the prompt builder, the sandbox, …).
+*   3. **Free judge calibration** — run two judges on identical responses
+*      and measure inter-judge agreement without doubling LLM spend.
+*
+* The interface is deliberately fetch-shaped. Inject `createReplayFetch`
+* into `LlmClientOptions.fetch` and every `callLlm` transparently reads
+* from the cache instead of calling the network. No new code path through
+* the LLM client is needed; the cache hit is invisible to the runner.
+*/
+var ReplayCacheMissError = class extends ReplayError {
+	url;
+	requestKey;
+	constructor(url, requestKey, message) {
+		super(message ?? `replay cache miss for ${url} (key=${requestKey})`);
+		this.url = url;
+		this.requestKey = requestKey;
+	}
+};
+/**
+* In-memory deterministic cache of (request → response) keyed on a stable
+* hash of the request body. Built from a `RawProviderSink` containing
+* paired `request` and `response` events from a previous run.
+*
+* The cache is the source of truth for replay; `createReplayFetch` is a
+* thin wrapper that reads from it.
+*/
+var ReplayCache = class ReplayCache {
+	byKey = /* @__PURE__ */ new Map();
+	orphans = 0;
+	byProvider = {};
+	byModel = {};
+	/**
+	* Build a cache from a sink's events. The sink must implement `list()`.
+	* Filter by `runId` / `spanId` to scope to a specific replay.
+	*/
+	static async fromSink(sink, filter = {}) {
+		if (!sink.list) throw new ReplayError("ReplayCache.fromSink: sink must implement list() to be replayable.");
+		const events = await sink.list(filter);
+		return ReplayCache.fromEvents(events);
+	}
+	/** Build a cache from an in-memory event list. */
+	static async fromEvents(events) {
+		const cache = new ReplayCache();
+		const groups = /* @__PURE__ */ new Map();
+		for (const e of events) {
+			const k = `${e.runId ?? ""}::${e.spanId ?? ""}::${e.attemptIndex}`;
+			const g = groups.get(k) ?? {};
+			if (e.direction === "request") g.req = e;
+			else g.res = e;
+			groups.set(k, g);
+		}
+		for (const g of groups.values()) {
+			if (!g.req) continue;
+			if (!g.res) {
+				cache.orphans += 1;
+				continue;
+			}
+			const key = await requestKey(g.req);
+			cache.byKey.set(key, {
+				request: g.req,
+				response: g.res
+			});
+			cache.byProvider[g.req.provider] = (cache.byProvider[g.req.provider] ?? 0) + 1;
+			cache.byModel[g.req.model] = (cache.byModel[g.req.model] ?? 0) + 1;
+		}
+		return cache;
+	}
+	/** Number of cacheable (request, response) pairs in the cache. */
+	size() {
+		return this.byKey.size;
+	}
+	stats() {
+		return {
+			total: this.byKey.size,
+			byProvider: { ...this.byProvider },
+			byModel: { ...this.byModel },
+			orphanRequests: this.orphans
+		};
+	}
+	/** Iterate every cached `(request, response)` pair in insertion order. */
+	*entries() {
+		for (const entry of this.byKey.values()) yield entry;
+	}
+	/**
+	* Look up a cached response by hashing the (model, messages, temperature,
+	* maxTokens, response_format) shape. Returns `undefined` on miss; the
+	* caller decides whether to throw, fall back to the network, or skip.
+	*/
+	async lookup(requestBody) {
+		const key = await keyFromBody(requestBody);
+		return this.byKey.get(key);
+	}
+};
+/**
+* Build a `fetch`-shaped function that serves cached responses out of a
+* `ReplayCache` for any URL ending in `/chat/completions`. Pass through
+* `LlmClientOptions.fetch` and `callLlm` becomes free.
+*
+* Non-`/chat/completions` URLs are passed straight to the fallback fetch
+* (default: `globalThis.fetch`). This matters because non-LLM HTTP work
+* (judge HTTP servers, sandbox callbacks) sometimes flows through the same
+* `fetch` and shouldn't be intercepted.
+*/
+function createReplayFetch(cache, opts = {}) {
+	const onMiss = opts.onMiss ?? "throw";
+	const fallback = opts.fallbackFetch ?? globalThis.fetch?.bind(globalThis);
+	return (async (input, init) => {
+		const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+		if (!/\/chat\/completions(?:[?#].*)?$/.test(url)) {
+			if (!fallback) throw new ReplayError(`replay fetch: non-completions URL ${url} but no fallbackFetch configured`);
+			return fallback(input, init);
+		}
+		let bodyParsed;
+		if (init?.body && typeof init.body === "string") try {
+			bodyParsed = JSON.parse(init.body);
+		} catch {}
+		const hit = bodyParsed === void 0 ? void 0 : await cache.lookup(bodyParsed);
+		if (hit) {
+			opts.onHit?.({
+				url,
+				provider: hit.request.provider,
+				model: hit.request.model
+			});
+			const status = hit.response.statusCode ?? 200;
+			const headers = new Headers(Object.entries(hit.response.responseHeaders ?? { "Content-Type": "application/json" }));
+			const bodyText = typeof hit.response.responseBody === "string" ? hit.response.responseBody : JSON.stringify(hit.response.responseBody ?? {});
+			return new Response(bodyText, {
+				status,
+				headers
+			});
+		}
+		opts.onMissNotify?.({
+			url,
+			requestBody: bodyParsed
+		});
+		if (onMiss === "throw") throw new ReplayCacheMissError(url, bodyParsed === void 0 ? "<unparseable>" : await keyFromBody(bodyParsed));
+		if (onMiss === "fail-closed") return new Response(JSON.stringify({ error: "replay_cache_miss" }), { status: 599 });
+		if (!fallback) throw new ReplayError("replay fetch: onMiss=fallback but no fallbackFetch configured");
+		return fallback(input, init);
+	});
+}
+/**
+* Convenience iterator over `(request, response)` pairs in a sink — for
+* post-hoc scoring that doesn't need a `fetch` shim. The judge or scorer
+* runs purely in-process over cached LLM outputs.
+*/
+async function* iterateRawCalls(sink, filter = {}) {
+	if (!sink.list) throw new ReplayError("iterateRawCalls: sink must implement list().");
+	const events = await sink.list(filter);
+	const cache = await ReplayCache.fromEvents(events);
+	for (const entry of cache.entries()) yield entry;
+}
+/**
+* Canonical request key.
+*
+* `model + messages + temperature + max_tokens|max_completion_tokens +
+* response_format` are the dimensions that affect the response shape.
+* Other fields (timestamp headers, provider-specific metadata) are
+* intentionally excluded so a request hashes the same across re-runs.
+*/
+async function requestKey(event) {
+	return keyFromBody(event.requestBody);
+}
+async function keyFromBody(body) {
+	if (body == null || typeof body !== "object") return hashJson({ raw: String(body) });
+	const b = body;
+	return hashJson(canonicalize({
+		model: b.model ?? null,
+		messages: b.messages ?? null,
+		temperature: b.temperature ?? null,
+		max_tokens: b.max_tokens ?? null,
+		max_completion_tokens: b.max_completion_tokens ?? null,
+		response_format: b.response_format ?? null
+	}));
+}
+//#endregion
+export { planTraceInsightQuestions as C, traceAnalystOnRunComplete as E, inferDomainKeywords as S, tokenizeDomainWords as T, buildTraceInsightContext as _, convertTraceStoresToOtlp as a, describeTraceInsightScope as b, otelRunCompleteHook as c, captureFetchToRawSink as d, otlpRowsToRunRecords as f, flattenOtlpExportToNdjson as g, otlpToTraceRunRecords as h, iterateRawCalls as i, OTEL_AGENT_EVAL_SCOPE as l, otlpToRunRecords as m, ReplayCacheMissError as n, createOtelExporter as o, otlpRowsToTraceRunRecords as p, createReplayFetch as r, createOtelTracingStore as s, ReplayCache as t, exportRunAsOtlp as u, buildTraceInsightPrompt as v, scoreTraceInsightReadiness as w, domainEvidencePattern as x, defaultTraceInsightPanel as y };
+
+//# sourceMappingURL=replay-GnyotH0J.js.map