@tangle-network/agent-eval 0.144.11 → 0.144.13

package/dist/store-tool-spans-Cq9mFd-q.js

@@ -0,0 +1,667 @@
+import { n as CaptureIntegrityError } from "./errors-Dngq5h35.js";
+import { Q as applyToolSpanOtlpAttributes, i as runTraceAnalyst, tt as traceSpanKindToOpenInferenceKind } from "./kind-factory-CPmSd58s.js";
+import { OPENINFERENCE_SPAN_KIND, applyLlmSpanOtlpAttributes } from "./trace-attributes.js";
+import { r as extractUsageFromSse, t as extractUsage } from "./extract-usage-BrQ8mCLX.js";
+import { a as providerFromBaseUrl, i as defaultProviderRedactor } from "./raw-provider-sink-BQd7mzyT.js";
+import { n as OtlpFileTraceStore, r as createOtlpBufferTraceStore } from "./store-otlp-CsptLYpN.js";
+import { randomUUID } from "node:crypto";
+import { deriveHexId, isW3CSpanId, isW3CTraceId } from "@tangle-network/agent-trace-contract";
+//#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/wire-ids.ts
+/**
+* The ONE mapping from agent-eval's human-readable ids (run ids, span labels)
+* to W3C/OTLP wire ids. Every exporter in this package MUST route through
+* these two functions — two exporters with private paddings once produced
+* DIFFERENT trace ids for the same run, and one emitted invalid hex embedding
+* the raw run id in the wire id (tangle-network/agent-runtime#694).
+*
+* Semantics:
+*  - an id that is ALREADY a valid W3C id passes through unchanged, so a
+*    trace id received from an inbound `traceparent` survives the round-trip
+*    and cross-process correlation is preserved;
+*  - anything else is derived with the contract's `deriveHexId`, the only
+*    legal derivation — deterministic, so every process that derives from the
+*    same human id mints the SAME wire id.
+*/
+/** 32-hex W3C trace id for any id string. */
+function traceIdForWire(id) {
+	return isW3CTraceId(id) ? id : deriveHexId(id, 16);
+}
+/** 16-hex W3C span id for any id string. */
+function spanIdForWire(id) {
+	return isW3CSpanId(id) ? id : deriveHexId(id, 8);
+}
+//#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({
+			"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: spanIdForWire(span.spanId),
+		parentSpanId: span.parentSpanId ? spanIdForWire(span.parentSpanId) : void 0,
+		name: span.name,
+		kind: 1,
+		startTimeUnixNano: msToNs(span.startedAt),
+		endTimeUnixNano: msToNs(endedAt),
+		attributes: toAttributes(flattenSpanAttributes(span)),
+		events: events.map((e) => ({
+			timeUnixNano: msToNs(e.timestamp),
+			name: e.kind,
+			attributes: toAttributes(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(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 runToTraceId(run) {
+	return traceIdForWire(run.runId);
+}
+//#endregion
+//#region src/trace-analyst/prompts.ts
+/** General policy for recursive, evidence-backed trace analysis. */
+const TRACE_ANALYST_ACTOR_DESCRIPTION = `Answer the question by inspecting the OTLP trace dataset with the available tools.
+
+1. Call getDatasetOverview first. Use its real trace ids and dataset size to plan the investigation.
+2. Narrow with queryTraces and countTraces before scanning large payloads.
+3. For a small trace, use viewTrace. For a large trace, use searchTrace and then viewSpans or searchSpan.
+4. Never invent a trace id, span id, tool result, error, frequency, or final outcome.
+5. When a search reports has_more, refine the query before drawing a conclusion.
+6. Use llm_query only over evidence already loaded. A recursive query cannot inspect traces itself.
+7. Cite exact evidence URIs returned by the tools. Include a short exact excerpt when it supports the claim.
+8. Return no finding when the available evidence cannot support one.
+
+The prose answer must directly answer the question and state important uncertainty.
+The findings array contains only actionable or decision-relevant claims supported by inspected evidence.`;
+const TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION = "trace-analyst-research-v1-2026-07-30";
+//#endregion
+//#region src/trace-analyst/analyst.ts
+/**
+* Answer one question by recursively inspecting a trace store.
+*
+* The returned answer, cited findings, engine steps, call counts, and runtime
+* identity are one audit record. A direct one-shot model call is not used.
+*/
+async function analyzeTraces(input, options) {
+	if (typeof input.question !== "string" || !input.question.trim()) throw new TypeError("analyzeTraces: input.question must be a non-empty string");
+	const id = input.id?.trim() || "trace-analysis";
+	const store = typeof options.source === "string" ? new OtlpFileTraceStore({ path: options.source }) : options.source;
+	if (store instanceof OtlpFileTraceStore) await store.ensureIndexed(options.signal ? { signal: options.signal } : void 0);
+	return runTraceAnalyst({
+		definition: {
+			id,
+			description: input.description?.trim() || "Answers a caller-defined question by recursively inspecting trace evidence.",
+			area: input.area?.trim() || "trace-analysis",
+			version: TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION,
+			question: input.question,
+			instructions: options.instructions ?? TRACE_ANALYST_ACTOR_DESCRIPTION,
+			toolGroup: options.toolGroup ?? "all",
+			limits: options.limits
+		},
+		engine: options.engine,
+		store,
+		context: {
+			runId: options.runId ?? id,
+			correlationId: randomUUID(),
+			budgetUsd: options.budgetUsd,
+			costLedger: options.costLedger,
+			costPhase: options.costPhase ?? "trace-analysis",
+			priorFindings: options.priorFindings,
+			upstreamFindings: options.upstreamFindings,
+			recordUsage: options.recordUsage,
+			tags: options.tags,
+			log: options.log,
+			signal: options.signal
+		}
+	});
+}
+//#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/otlp-flat.ts
+function createOtlpFlatLine(input) {
+	return {
+		trace_id: input.traceId,
+		span_id: input.spanId,
+		parent_span_id: input.parentSpanId,
+		name: input.name,
+		kind: input.kind,
+		start_time: input.startTime,
+		end_time: input.endTime,
+		status: {
+			code: input.statusCode,
+			...input.statusMessage !== void 0 ? { message: input.statusMessage } : {}
+		},
+		resource: input.resource,
+		attributes: input.attributes,
+		...input.events && input.events.length > 0 ? { events: input.events } : {}
+	};
+}
+/** Map the canonical trace status while letting each caller choose its legacy default. */
+function spanStatusToOtlp(status, error, defaultCode) {
+	if (status === "error" || error) return "STATUS_CODE_ERROR";
+	if (status === "ok") return "STATUS_CODE_OK";
+	return defaultCode;
+}
+/** Convert epoch milliseconds, returning `undefined` for invalid or out-of-range values. */
+function epochMillisToIso(value) {
+	if (!Number.isFinite(value)) return void 0;
+	try {
+		return new Date(value).toISOString();
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/trace-analyst/store-tool-spans.ts
+/** Missing tool spans cannot distinguish a tool-free run from broken capture. */
+var ToolTraceMissingError = class extends CaptureIntegrityError {
+	constructor() {
+		super("toolSpansToTraceAnalysisStore: no tool spans supplied; trace evidence is missing");
+	}
+};
+/**
+* Snapshot canonical tool spans into the read interface used by trace analysts.
+* One run becomes one trace while arguments, results, errors, and timing remain searchable.
+*/
+function toolSpansToTraceAnalysisStore(spans, options = {}) {
+	if (!spans || spans.length === 0) throw new ToolTraceMissingError();
+	const seen = /* @__PURE__ */ new Set();
+	const lines = spans.map((span, index) => {
+		assertToolSpanIdentity(span, index);
+		const identity = `${span.runId}\u0000${span.spanId}`;
+		if (seen.has(identity)) throw new CaptureIntegrityError(`toolSpansToTraceAnalysisStore: duplicate span '${span.spanId}' in run '${span.runId}'`);
+		seen.add(identity);
+		const attributes = { ...span.attributes ?? {} };
+		applyToolSpanOtlpAttributes(attributes, span);
+		attributes[OPENINFERENCE_SPAN_KIND] = "TOOL";
+		const endedAt = span.endedAt ?? span.startedAt + (span.latencyMs ?? 0);
+		const line = createOtlpFlatLine({
+			traceId: span.runId,
+			spanId: span.spanId,
+			parentSpanId: span.parentSpanId ?? null,
+			name: span.name,
+			kind: "SPAN_KIND_INTERNAL",
+			startTime: toolSpanTimeIso(span.startedAt, span.spanId, "startedAt"),
+			endTime: toolSpanTimeIso(endedAt, span.spanId, "endedAt"),
+			statusCode: spanStatusToOtlp(span.status, span.error, "STATUS_CODE_UNSET"),
+			statusMessage: span.error,
+			resource: { attributes: {} },
+			attributes
+		});
+		try {
+			return JSON.stringify(line);
+		} catch (cause) {
+			throw new CaptureIntegrityError(`toolSpansToTraceAnalysisStore: span '${span.spanId}' in run '${span.runId}' is not JSON-serializable`, { cause });
+		}
+	});
+	return createOtlpBufferTraceStore(Buffer.from(`${lines.join("\n")}\n`, "utf8"), options);
+}
+function assertToolSpanIdentity(span, index) {
+	if (span.kind !== "tool") throw new CaptureIntegrityError(`toolSpansToTraceAnalysisStore: span at index ${index} has kind '${String(span.kind)}', not 'tool'`);
+	if (!span.runId || !span.spanId || !span.name || !span.toolName) throw new CaptureIntegrityError(`toolSpansToTraceAnalysisStore: span at index ${index} is missing runId, spanId, name, or toolName`);
+	if (!Number.isFinite(span.startedAt)) throw new CaptureIntegrityError(`toolSpansToTraceAnalysisStore: span '${span.spanId}' has invalid startedAt`);
+	if (span.endedAt !== void 0 && !Number.isFinite(span.endedAt)) throw new CaptureIntegrityError(`toolSpansToTraceAnalysisStore: span '${span.spanId}' has invalid endedAt`);
+	if (span.endedAt !== void 0 && span.endedAt < span.startedAt) throw new CaptureIntegrityError(`toolSpansToTraceAnalysisStore: span '${span.spanId}' ends before it starts`);
+	if (span.latencyMs !== void 0 && (!Number.isFinite(span.latencyMs) || span.latencyMs < 0)) throw new CaptureIntegrityError(`toolSpansToTraceAnalysisStore: span '${span.spanId}' has invalid latencyMs`);
+}
+function toolSpanTimeIso(value, spanId, field) {
+	const iso = epochMillisToIso(value);
+	if (iso) return iso;
+	throw new CaptureIntegrityError(`toolSpansToTraceAnalysisStore: span '${spanId}' has invalid ${field}`);
+}
+//#endregion
+export { captureFetchToRawSink as S, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION as _, spanStatusToOtlp as a, spanIdForWire as b, defaultTraceInsightPanel as c, inferDomainKeywords as d, planTraceInsightQuestions as f, TRACE_ANALYST_ACTOR_DESCRIPTION as g, analyzeTraces as h, epochMillisToIso as i, describeTraceInsightScope as l, tokenizeDomainWords as m, toolSpansToTraceAnalysisStore as n, buildTraceInsightContext as o, scoreTraceInsightReadiness as p, createOtlpFlatLine as r, buildTraceInsightPrompt as s, ToolTraceMissingError as t, domainEvidencePattern as u, OTEL_AGENT_EVAL_SCOPE as v, traceIdForWire as x, exportRunAsOtlp as y };
+
+//# sourceMappingURL=store-tool-spans-Cq9mFd-q.js.map