@tangle-network/agent-eval 0.71.0 → 0.72.3

package/dist/chunk-JHA3ZGSO.js

@@ -0,0 +1,1496 @@
+import {
+  analyzeTraces,
+  firstNumberAttr,
+  firstStringAttr,
+  projectOtlpFlatLine
+} from "./chunk-VUINJM5M.js";
+import {
+  defaultProviderRedactor,
+  providerFromBaseUrl
+} from "./chunk-PC4UYEBM.js";
+import {
+  validateRunRecord
+} from "./chunk-F3SRAAZO.js";
+import {
+  canonicalize,
+  hashJson
+} from "./chunk-VSMTAMNK.js";
+import {
+  ReplayError
+} from "./chunk-3BFEG2F6.js";
+
+// src/trace-analyst/hook.ts
+var 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
+        }
+      });
+    }
+  };
+}
+
+// src/trace-analyst/insights.ts
+var 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(", ")}.`;
+  const difficulties = [
+    ...new Set(
+      suite.tasks.map((task) => task.difficulty).filter((value) => Boolean(value))
+    )
+  ].join(", ");
+  return `${taskLabel} across ${difficulties || "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 >= 0.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 >= 0.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 >= 0.9 ? "external-ready" : score >= 0.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.`;
+}
+
+// src/trace-analyst/otlp-flatten.ts
+var 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"
+};
+var STATUS_MAP = {
+  0: "STATUS_CODE_UNSET",
+  1: "STATUS_CODE_OK",
+  2: "STATUS_CODE_ERROR"
+};
+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();
+}
+function applyOpenInference(attrs) {
+  if ("llm.model" in attrs && !("llm.model_name" in attrs)) {
+    attrs["llm.model_name"] = attrs["llm.model"];
+  }
+  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;
+}
+
+// src/trace-analyst/otlp-to-run-records.ts
+var INPUT_TOKEN_KEYS = [
+  "llm.input_tokens",
+  "inference.llm.input_tokens",
+  "llm.token_count.prompt",
+  "gen_ai.usage.input_tokens",
+  "gen_ai.usage.prompt_tokens"
+];
+var OUTPUT_TOKEN_KEYS = [
+  "llm.output_tokens",
+  "inference.llm.output_tokens",
+  "llm.token_count.completion",
+  "gen_ai.usage.output_tokens",
+  "gen_ai.usage.completion_tokens"
+];
+var CACHED_TOKEN_KEYS = [
+  "llm.cached_tokens",
+  "inference.llm.cached_tokens",
+  "llm.token_count.prompt_cache_hit",
+  "gen_ai.usage.cached_tokens"
+];
+var COST_KEYS = [
+  "llm.cost_usd",
+  "inference.llm.cost.total",
+  "llm.cost.total",
+  "gen_ai.usage.cost"
+];
+var MODEL_KEYS = [
+  "llm.model_name",
+  "inference.llm.model_name",
+  "llm.model",
+  "gen_ai.request.model",
+  "gen_ai.response.model"
+];
+function otlpToRunRecords(otlpJsonl, opts) {
+  return otlpToTraceRunRecords(otlpJsonl, opts).map((r) => r.record);
+}
+function otlpToTraceRunRecords(otlpJsonl, 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";
+  const byTrace = groupSpansByTrace(otlpJsonl);
+  if (byTrace.size === 0) {
+    throw new Error(
+      "otlpToRunRecords: OTLP input produced zero valid spans \u2014 every line 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, costUnpriced } = resolveCost(opts, agg, spans);
+    const raw = {
+      span_count: agg.spanCount,
+      llm_span_count: agg.llmSpanCount,
+      tool_span_count: agg.toolSpanCount,
+      agent_span_count: agg.agentSpanCount,
+      error_span_count: agg.errorSpanCount,
+      prompt_tokens: agg.tokenUsage.input,
+      completion_tokens: agg.tokenUsage.output
+    };
+    if (agg.tokenUsage.cached !== void 0) raw.cached_tokens = agg.tokenUsage.cached;
+    if (costUnpriced) raw.cost_unpriced = 1;
+    const outcome = splitTag === "holdout" ? { holdoutScore: score, raw } : { searchScore: score, raw };
+    const { promptText, completionText } = extractPromptCompletion(spans);
+    const judgeMetadata = opts.judgeMetadataForTrace?.(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,
+      tokenUsage: agg.tokenUsage,
+      ...judgeMetadata ? { judgeMetadata } : {},
+      outcome,
+      ...agg.firstErrorMessage ? { failureMode: agg.firstErrorMessage } : {},
+      splitTag,
+      scenarioId: traceId
+    });
+    out.push({
+      record,
+      ...promptText !== void 0 ? { promptText } : {},
+      ...completionText !== void 0 ? { completionText } : {}
+    });
+  }
+  return out;
+}
+function groupSpansByTrace(otlpJsonl) {
+  const byTrace = /* @__PURE__ */ new Map();
+  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") continue;
+    const span = projectOtlpFlatLine(parsed);
+    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 aggregateTrace(traceId, spans, fallbackModel) {
+  const ordered = [...spans].sort(
+    (a, b) => a.start_time.localeCompare(b.start_time) || a.span_id.localeCompare(b.span_id)
+  );
+  let input = 0;
+  let output = 0;
+  let cached = 0;
+  let sawCached = false;
+  let llmSpanCount = 0;
+  let toolSpanCount = 0;
+  let agentSpanCount = 0;
+  let errorSpanCount = 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 || s.start_time < earliest)) earliest = s.start_time;
+    if (s.end_time && s.end_time > latest) latest = s.end_time;
+    if (s.kind === "LLM") {
+      llmSpanCount += 1;
+      const i = firstNumberAttr(s.attributes, INPUT_TOKEN_KEYS);
+      const o = firstNumberAttr(s.attributes, OUTPUT_TOKEN_KEYS);
+      const c = firstNumberAttr(s.attributes, CACHED_TOKEN_KEYS);
+      if (i !== null) input += i;
+      if (o !== null) output += o;
+      if (c !== null) {
+        cached += c;
+        sawCached = true;
+      }
+      const m = firstStringAttr(s.attributes, MODEL_KEYS) ?? s.model_name;
+      if (m) modelVotes.set(m, (modelVotes.get(m) ?? 0) + 1);
+    } else if (s.kind === "TOOL") {
+      toolSpanCount += 1;
+    } else if (s.kind === "AGENT") {
+      agentSpanCount += 1;
+    }
+    if (s.status === "ERROR") {
+      errorSpanCount += 1;
+      if (firstErrorMessage === void 0) {
+        firstErrorMessage = (s.status_message ?? `${s.name} \u2014 STATUS_CODE_ERROR`).slice(0, 500);
+      }
+    }
+  }
+  const model = topVote(modelVotes) ?? firstModelAttr(ordered) ?? fallbackModel;
+  let wallMs = 0;
+  if (earliest && latest) {
+    const a = Date.parse(earliest);
+    const b = Date.parse(latest);
+    if (!Number.isNaN(a) && !Number.isNaN(b)) wallMs = Math.max(0, b - a);
+  }
+  const tokenUsage = sawCached ? { input, output, cached } : { input, output };
+  return {
+    traceId,
+    spanCount: spans.length,
+    llmSpanCount,
+    toolSpanCount,
+    agentSpanCount,
+    errorSpanCount,
+    tokenUsage,
+    firstErrorMessage,
+    model,
+    startTime: earliest,
+    endTime: latest,
+    wallMs
+  };
+}
+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;
+  }
+  return agg.errorSpanCount > 0 ? 0 : 1;
+}
+function resolveCost(opts, agg, spans) {
+  let perSpanCost = 0;
+  let sawCost = false;
+  for (const s of spans) {
+    if (s.kind !== "LLM") continue;
+    const c = firstNumberAttr(s.attributes, COST_KEYS);
+    if (c !== null) {
+      perSpanCost += c;
+      sawCost = true;
+    }
+  }
+  if (sawCost) return { costUsd: perSpanCost, costUnpriced: false };
+  if (opts.priceUsdPerToken !== void 0) {
+    const totalTokens = agg.tokenUsage.input + agg.tokenUsage.output;
+    return { costUsd: totalTokens * opts.priceUsdPerToken, costUnpriced: false };
+  }
+  return { costUsd: 0, costUnpriced: true };
+}
+function extractPromptCompletion(spans) {
+  const llm = spans.filter((s) => s.kind === "LLM").sort((a, b) => a.start_time.localeCompare(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, MODEL_KEYS) ?? s.model_name;
+    if (m) return m;
+  }
+  return null;
+}
+function ensureSnapshot(model, fallbackModel) {
+  if (modelHasSnapshot(model)) return model;
+  const fallbackTag = fallbackModel.includes("@") ? fallbackModel.slice(fallbackModel.indexOf("@")) : "@otlp";
+  return `${model}${fallbackTag}`;
+}
+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;
+}
+
+// src/trace/store.ts
+var InMemoryTraceStore = class {
+  runs = /* @__PURE__ */ new Map();
+  allSpans = [];
+  allEvents = [];
+  allArtifacts = [];
+  allBudget = [];
+  async appendRun(run) {
+    if (this.runs.has(run.runId)) throw new Error(`run ${run.runId} already exists`);
+    this.runs.set(run.runId, { ...run });
+  }
+  async updateRun(runId, patch) {
+    const existing = this.runs.get(runId);
+    if (!existing) throw new Error(`run ${runId} not found`);
+    this.runs.set(runId, { ...existing, ...patch });
+  }
+  async appendSpan(span) {
+    this.allSpans.push({ ...span });
+  }
+  async updateSpan(spanId, patch) {
+    const idx = this.allSpans.findIndex((s) => s.spanId === spanId);
+    if (idx < 0) throw new Error(`span ${spanId} not found`);
+    this.allSpans[idx] = { ...this.allSpans[idx], ...patch };
+  }
+  async appendEvent(event) {
+    this.allEvents.push({ ...event });
+  }
+  async appendArtifact(artifact) {
+    this.allArtifacts.push({ ...artifact });
+  }
+  async appendBudgetEntry(entry) {
+    this.allBudget.push({ ...entry });
+  }
+  async getRun(runId) {
+    const r = this.runs.get(runId);
+    return r ? { ...r } : void 0;
+  }
+  async listRuns(filter = {}) {
+    return [...this.runs.values()].filter((r) => matchesRun(r, filter));
+  }
+  async spans(filter = {}) {
+    return this.allSpans.filter((s) => matchesSpan(s, filter)).map((s) => ({ ...s }));
+  }
+  async events(filter = {}) {
+    return this.allEvents.filter((e) => matchesEvent(e, filter)).map((e) => ({ ...e }));
+  }
+  async budget(runId) {
+    return this.allBudget.filter((b) => b.runId === runId).map((b) => ({ ...b }));
+  }
+  async artifacts(runId) {
+    return this.allArtifacts.filter((a) => a.runId === runId).map((a) => ({ ...a }));
+  }
+};
+function matchesRun(r, f) {
+  if (f.scenarioId && r.scenarioId !== f.scenarioId) return false;
+  if (f.variantId && r.variantId !== f.variantId) return false;
+  if (f.status && r.status !== f.status) return false;
+  if (f.since !== void 0 && r.startedAt < f.since) return false;
+  if (f.until !== void 0 && r.startedAt > f.until) return false;
+  if (f.tag && r.tags?.[f.tag.key] !== f.tag.value) return false;
+  if (f.parentRunId && r.parentRunId !== f.parentRunId) return false;
+  if (f.projectId && r.projectId !== f.projectId) return false;
+  if (f.chatId && r.chatId !== f.chatId) return false;
+  if (f.layer && r.layer !== f.layer) return false;
+  return true;
+}
+function matchesSpan(s, f) {
+  if (f.runId && s.runId !== f.runId) return false;
+  if (f.parentSpanId && s.parentSpanId !== f.parentSpanId) return false;
+  if (f.kind && s.kind !== f.kind) return false;
+  if (f.name && s.name !== f.name) return false;
+  if (f.toolName && (s.kind !== "tool" || s.toolName !== f.toolName)) return false;
+  if (f.judgeId && (s.kind !== "judge" || s.judgeId !== f.judgeId)) return false;
+  if (f.since !== void 0 && s.startedAt < f.since) return false;
+  if (f.until !== void 0 && s.startedAt > f.until) return false;
+  return true;
+}
+function matchesEvent(e, f) {
+  if (f.runId && e.runId !== f.runId) return false;
+  if (f.spanId && e.spanId !== f.spanId) return false;
+  if (f.kind && e.kind !== f.kind) return false;
+  if (f.since !== void 0 && e.timestamp < f.since) return false;
+  if (f.until !== void 0 && e.timestamp > f.until) return false;
+  return true;
+}
+var FileSystemTraceStore = class {
+  dir;
+  maxBytes;
+  /** Lazy in-memory index for queries — populated on first read. */
+  index;
+  loaded = false;
+  constructor(options) {
+    this.dir = options.dir;
+    this.maxBytes = options.maxBytes ?? 32 * 1024 * 1024;
+  }
+  async ensureDir() {
+    const fs = await import("fs/promises");
+    await fs.mkdir(this.dir, { recursive: true });
+  }
+  async append(name, record) {
+    await this.ensureDir();
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const active = path.join(this.dir, `${name}.ndjson`);
+    try {
+      const stat = await fs.stat(active);
+      if (stat.size >= this.maxBytes) {
+        const rolled = path.join(this.dir, `${name}.${Date.now()}.ndjson`);
+        await fs.rename(active, rolled);
+      }
+    } catch {
+    }
+    await fs.appendFile(active, `${JSON.stringify(record)}
+`, "utf8");
+    if (this.index && !record?._update) {
+      void this.insertInto(name, record);
+    }
+  }
+  async insertInto(name, record) {
+    if (!this.index) return;
+    switch (name) {
+      case "runs":
+        await this.index.appendRun(record);
+        break;
+      case "spans":
+        await this.index.appendSpan(record);
+        break;
+      case "events":
+        await this.index.appendEvent(record);
+        break;
+      case "artifacts":
+        await this.index.appendArtifact(record);
+        break;
+      case "budget":
+        await this.index.appendBudgetEntry(record);
+        break;
+    }
+  }
+  async load() {
+    if (this.loaded && this.index) return this.index;
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const store = new InMemoryTraceStore();
+    try {
+      const entries = await fs.readdir(this.dir);
+      for (const file of entries) {
+        if (!file.endsWith(".ndjson")) continue;
+        const full = path.join(this.dir, file);
+        const content = await fs.readFile(full, "utf8");
+        const base = file.split(".")[0];
+        for (const line of content.split("\n")) {
+          if (!line.trim()) continue;
+          const record = JSON.parse(line);
+          if (base === "runs") {
+            try {
+              await store.appendRun(record);
+            } catch {
+              await store.updateRun(record.runId, record);
+            }
+          } else if (base === "spans") {
+            if (record?._update) {
+              try {
+                await store.updateSpan(record.spanId, record);
+              } catch {
+                await store.appendSpan(record);
+              }
+            } else {
+              await store.appendSpan(record);
+            }
+          } else if (base === "events") {
+            await store.appendEvent(record);
+          } else if (base === "artifacts") {
+            await store.appendArtifact(record);
+          } else if (base === "budget") {
+            await store.appendBudgetEntry(record);
+          }
+        }
+      }
+    } catch {
+    }
+    this.index = store;
+    this.loaded = true;
+    return store;
+  }
+  async appendRun(run) {
+    await this.append("runs", run);
+  }
+  async updateRun(runId, patch) {
+    await this.append("runs", { runId, ...patch, _update: true });
+    if (this.index) await this.index.updateRun(runId, patch);
+  }
+  async appendSpan(span) {
+    await this.append("spans", span);
+  }
+  async updateSpan(spanId, patch) {
+    await this.append("spans", { spanId, ...patch, _update: true });
+    if (this.index) await this.index.updateSpan(spanId, patch);
+  }
+  async appendEvent(event) {
+    await this.append("events", event);
+  }
+  async appendArtifact(artifact) {
+    await this.append("artifacts", artifact);
+  }
+  async appendBudgetEntry(entry) {
+    await this.append("budget", entry);
+  }
+  async getRun(runId) {
+    return (await this.load()).getRun(runId);
+  }
+  async listRuns(filter) {
+    return (await this.load()).listRuns(filter);
+  }
+  async spans(filter) {
+    return (await this.load()).spans(filter);
+  }
+  async events(filter) {
+    return (await this.load()).events(filter);
+  }
+  async budget(runId) {
+    return (await this.load()).budget(runId);
+  }
+  async artifacts(runId) {
+    return (await this.load()).artifacts(runId);
+  }
+};
+
+// src/trace/capture-fetch.ts
+var 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;
+  }
+}
+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 void 0;
+    }
+  }
+  return void 0;
+}
+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(fetch2, 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,
+    // retries are re-invocations one layer up; documented in 0.x
+    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) \u2014 ${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 fetch2(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;
+    const redactedFields = [];
+    try {
+      const raw = await response.clone().text();
+      if (raw.length > bodyCap) {
+        responseBody = raw.slice(0, bodyCap);
+        redactedFields.push("body_truncated");
+      } else {
+        responseBody = parseMaybeJson(raw);
+      }
+    } catch {
+      responseBody = void 0;
+    }
+    await record({
+      ...baseEvent("response", endpoint),
+      durationMs: Date.now() - start,
+      statusCode: response.status,
+      responseHeaders: headersToRecord(response.headers),
+      responseBody,
+      redactedFields
+    });
+    return response;
+  };
+}
+
+// src/trace/otel.ts
+var OTEL_AGENT_EVAL_SCOPE = { name: "@tangle-network/agent-eval", version: "0.3.0" };
+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: padSpanId(span.spanId),
+    parentSpanId: span.parentSpanId ? padSpanId(span.parentSpanId) : void 0,
+    name: span.name,
+    kind: 1,
+    // SPAN_KIND_INTERNAL
+    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 = {
+    "span.kind": span.kind
+  };
+  if (span.kind === "llm") {
+    base["llm.model"] = span.model;
+    if (span.inputTokens !== void 0) base["llm.input_tokens"] = span.inputTokens;
+    if (span.outputTokens !== void 0) base["llm.output_tokens"] = span.outputTokens;
+    if (span.costUsd !== void 0) base["llm.cost_usd"] = span.costUsd;
+    if (span.finishReason) base["llm.finish_reason"] = span.finishReason;
+  } else if (span.kind === "tool") {
+    base["tool.name"] = span.toolName;
+    if (span.latencyMs !== void 0) base["tool.latency_ms"] = span.latencyMs;
+  } 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;
+  }
+  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;
+    }
+  }
+  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 padSpanId(id) {
+  const cleaned = id.replace(/-/g, "");
+  return cleaned.slice(0, 16).padEnd(16, "0");
+}
+function runToTraceId(run) {
+  const cleaned = run.runId.replace(/-/g, "");
+  return cleaned.slice(0, 32).padEnd(32, "0");
+}
+
+// src/trace/otel-bridge.ts
+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();
+  };
+}
+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 spans = await inner.spans({ runId: traceId });
+        const found = spans.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;
+  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,
+    costUsd: llm?.costUsd,
+    attributes: span.attributes
+  };
+}
+
+// src/trace/otel-export.ts
+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) {
+        void 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) void 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: toAttributes2({
+              "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 = {
+    "span.kind": span.kind
+  };
+  if (span.model) attrs["llm.model"] = span.model;
+  if (span.inputTokens !== void 0) attrs["llm.input_tokens"] = span.inputTokens;
+  if (span.outputTokens !== void 0) attrs["llm.output_tokens"] = span.outputTokens;
+  if (span.costUsd !== void 0) attrs["llm.cost_usd"] = span.costUsd;
+  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;
+    }
+  }
+  return {
+    traceId: padTraceId(span.traceId),
+    spanId: padSpanId2(span.spanId),
+    parentSpanId: span.parentSpanId ? padSpanId2(span.parentSpanId) : void 0,
+    name: span.name,
+    kind: 1,
+    // SPAN_KIND_INTERNAL
+    startTimeUnixNano: msToNs2(span.startedAt),
+    endTimeUnixNano: msToNs2(endedAt),
+    attributes: toAttributes2(attrs),
+    status: span.status === "error" ? { code: 2, message: span.error } : { code: 1 }
+  };
+}
+function toAttributes2(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 msToNs2(ms) {
+  return (BigInt(Math.floor(ms)) * 1000000n).toString();
+}
+function padSpanId2(id) {
+  const cleaned = id.replace(/-/g, "");
+  return cleaned.slice(0, 16).padEnd(16, "0");
+}
+function padTraceId(id) {
+  const cleaned = id.replace(/-/g, "");
+  return cleaned.slice(0, 32).padEnd(32, "0");
+}
+
+// src/replay.ts
+var ReplayCacheMissError = class extends ReplayError {
+  constructor(url, requestKey2, message) {
+    super(message ?? `replay cache miss for ${url} (key=${requestKey2})`);
+    this.url = url;
+    this.requestKey = requestKey2;
+  }
+  url;
+  requestKey;
+};
+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);
+  }
+};
+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") {
+      const key = bodyParsed === void 0 ? "<unparseable>" : await keyFromBody(bodyParsed);
+      throw new ReplayCacheMissError(url, key);
+    }
+    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);
+  });
+}
+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;
+}
+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;
+  const reduced = 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
+  });
+  return hashJson(reduced);
+}
+
+export {
+  traceAnalystOnRunComplete,
+  tokenizeDomainWords,
+  inferDomainKeywords,
+  domainEvidencePattern,
+  describeTraceInsightScope,
+  planTraceInsightQuestions,
+  buildTraceInsightContext,
+  scoreTraceInsightReadiness,
+  defaultTraceInsightPanel,
+  buildTraceInsightPrompt,
+  flattenOtlpExportToNdjson,
+  otlpToRunRecords,
+  otlpToTraceRunRecords,
+  InMemoryTraceStore,
+  FileSystemTraceStore,
+  captureFetchToRawSink,
+  OTEL_AGENT_EVAL_SCOPE,
+  exportRunAsOtlp,
+  otelRunCompleteHook,
+  createOtelTracingStore,
+  createOtelExporter,
+  ReplayCacheMissError,
+  ReplayCache,
+  createReplayFetch,
+  iterateRawCalls
+};
+//# sourceMappingURL=chunk-JHA3ZGSO.js.map