agentv 4.18.0-next.1 → 4.19.0

package/dist/chunk-R2QDYORI.js

@@ -0,0 +1,2178 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  external_exports,
+  generateText,
+  getAgentvConfigDir,
+  getAgentvHome,
+  interpolateEnv,
+  normalizeToolCall,
+  parseRepoCheckout,
+  parseRepoClone,
+  parseRepoSource,
+  toCamelCaseDeep,
+  toSnakeCaseDeep
+} from "./chunk-PTYQS37Y.js";
+
+// ../../packages/core/dist/index.js
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { parse } from "yaml";
+import { readFile } from "node:fs/promises";
+import path2 from "node:path";
+import { parse as parse2 } from "yaml";
+import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
+import path3 from "node:path";
+import { execFile } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "node:fs";
+import { cp, mkdtemp, readdir, rm, stat } from "node:fs/promises";
+import os from "node:os";
+import path4 from "node:path";
+import { promisify } from "node:util";
+import {
+  copyFileSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  readdirSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import path5 from "node:path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { homedir } from "node:os";
+import path6 from "node:path";
+import { readdir as readdir3, stat as stat3 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import path7 from "node:path";
+import { readFile as readFile3 } from "node:fs/promises";
+function codeGraderInstruction(graderName, description) {
+  const desc = description ? ` This grader: ${description}.` : "";
+  return `Run \`agentv eval assert ${graderName} --agent-output <agent_output> --agent-input <original_prompt>\` and check the result.${desc} The command accepts --agent-output (the agent's full response text) and --agent-input (the original user prompt). It returns JSON on stdout: {"score": 0-1, "reasoning": "..."}. A score >= 0.5 means pass (exit 0); below 0.5 means fail (exit 1).`;
+}
+function deriveGraderNameFromCommand(command) {
+  if (!Array.isArray(command) || command.length === 0) return void 0;
+  for (const arg of command) {
+    if (typeof arg !== "string") continue;
+    const match = arg.match(/([^/]+)\.(ts|js|mts|mjs)$/);
+    if (match) return match[1] || void 0;
+  }
+  return void 0;
+}
+function assertionToNaturalLanguage(entry) {
+  const type = entry.type;
+  switch (type) {
+    case "skill-trigger":
+      return null;
+    case "rubrics": {
+      if (typeof entry.criteria === "string") {
+        return entry.criteria;
+      }
+      return null;
+    }
+    case "contains":
+      return `Output contains '${entry.value}'`;
+    case "contains-any":
+    case "contains_any": {
+      const values = Array.isArray(entry.value) ? entry.value.join("', '") : entry.value;
+      return `Output contains any of: '${values}'`;
+    }
+    case "contains-all":
+    case "contains_all": {
+      const values = Array.isArray(entry.value) ? entry.value.join("', '") : entry.value;
+      return `Output contains all of: '${values}'`;
+    }
+    case "icontains":
+      return `Output contains (case-insensitive) '${entry.value}'`;
+    case "regex":
+      return `Output matches regex: ${entry.value}`;
+    case "equals":
+      return `Output exactly equals: ${entry.value}`;
+    case "is-json":
+    case "is_json":
+      return "Output is valid JSON";
+    case "starts-with":
+    case "starts_with":
+      return `Output starts with '${entry.value}'`;
+    case "ends-with":
+    case "ends_with":
+      return `Output ends with '${entry.value}'`;
+    case "llm-grader":
+    case "llm_grader": {
+      if (Array.isArray(entry.rubrics) && entry.rubrics.length > 0) {
+        return null;
+      }
+      return typeof entry.prompt === "string" ? entry.prompt : null;
+    }
+    case "tool-trajectory":
+    case "tool_trajectory": {
+      const expectedArr = Array.isArray(entry.expected) ? entry.expected : [];
+      const tools = expectedArr.map((e) => e.tool).filter(Boolean).join(", ");
+      return tools ? `Agent called tools in order: ${tools}` : "Agent followed expected tool trajectory";
+    }
+    case "code-grader":
+    case "code_grader": {
+      const graderName = entry.name ?? deriveGraderNameFromCommand(entry.command) ?? "code-grader";
+      const desc = typeof entry.description === "string" ? entry.description : void 0;
+      return codeGraderInstruction(graderName, desc);
+    }
+    case "field-accuracy":
+    case "field_accuracy": {
+      const fieldPaths = Array.isArray(entry.fields) ? entry.fields.map((f) => f.path).filter(Boolean).join(", ") : "";
+      return fieldPaths ? `Fields ${fieldPaths} match expected values` : "Fields match expected values";
+    }
+    case "latency":
+      return typeof entry.threshold === "number" ? `Response time under ${entry.threshold}ms` : "Response time within threshold";
+    case "cost":
+      return typeof entry.budget === "number" ? `Cost under $${entry.budget}` : "Cost within budget";
+    case "token-usage":
+    case "token_usage":
+      return "Token usage within limits";
+    case "execution-metrics":
+    case "execution_metrics":
+      return "Execution within metric bounds";
+    default: {
+      if (entry.command !== void 0 && type) {
+        return codeGraderInstruction(deriveGraderNameFromCommand(entry.command) ?? type);
+      }
+      if (typeof entry.criteria === "string") return entry.criteria;
+      if (typeof entry.prompt === "string") return entry.prompt;
+      return type ? `${type} assertion` : null;
+    }
+  }
+}
+function assertionToNaturalLanguageList(entry) {
+  if (entry.type === "llm-grader" || entry.type === "llm_grader") {
+    if (Array.isArray(entry.rubrics) && entry.rubrics.length > 0) {
+      return entry.rubrics.map((r) => r.outcome ?? r.criteria ?? r.id).filter((s) => typeof s === "string");
+    }
+  }
+  const nl = assertionToNaturalLanguage(entry);
+  return nl !== null ? [nl] : [];
+}
+function extractTriggerAssertions(assertions) {
+  return assertions.filter((a) => a.type === "skill-trigger");
+}
+function resolveAssertions(rawCase) {
+  if (Array.isArray(rawCase.assertions)) return rawCase.assertions;
+  if (Array.isArray(rawCase.assert)) return rawCase.assert;
+  return [];
+}
+function resolveSuiteAssertions(suite) {
+  if (Array.isArray(suite.assertions)) return suite.assertions;
+  if (Array.isArray(suite.assert)) return suite.assert;
+  return [];
+}
+function extractInput(rawCase) {
+  const files = Array.isArray(rawCase.input_files) ? rawCase.input_files.filter((f) => typeof f === "string") : [];
+  const input = rawCase.input;
+  if (typeof input === "string") {
+    return { prompt: input, files };
+  }
+  if (Array.isArray(input)) {
+    let prompt = "";
+    for (const msg of input) {
+      if (msg.role !== "user") continue;
+      if (typeof msg.content === "string") {
+        prompt = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === "text" && typeof block.value === "string") prompt = block.value;
+          else if (block.type === "file" && typeof block.value === "string")
+            files.push(block.value);
+        }
+      }
+    }
+    return { prompt, files };
+  }
+  return { prompt: "", files };
+}
+function extractExpectedOutput(raw) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw === "string") return raw;
+  if (Array.isArray(raw)) {
+    for (let i = raw.length - 1; i >= 0; i--) {
+      const msg = raw[i];
+      if (typeof msg.content === "string") return msg.content;
+    }
+    return void 0;
+  }
+  return JSON.stringify(raw);
+}
+function transpileEvalYaml(suite, source = "EVAL.yaml") {
+  const warnings = [];
+  const files = /* @__PURE__ */ new Map();
+  if (typeof suite !== "object" || suite === null) {
+    throw new Error(`Invalid EVAL.yaml: expected an object in '${source}'`);
+  }
+  const rawSuite = suite;
+  if (!Array.isArray(rawSuite.tests)) {
+    throw new Error(`Invalid EVAL.yaml: missing 'tests' array in '${source}'`);
+  }
+  if (rawSuite.assert !== void 0 && rawSuite.assertions === void 0) {
+    warnings.push("'assert' is deprecated at the suite level. Use 'assertions' instead.");
+  }
+  const suiteAssertions = resolveSuiteAssertions(rawSuite);
+  const suiteNlAssertions = suiteAssertions.filter((a) => a.type !== "skill-trigger").flatMap(assertionToNaturalLanguageList);
+  function getSkillFile(skillName) {
+    const existing = files.get(skillName);
+    if (existing) return existing;
+    const created = { skill_name: skillName, evals: [] };
+    files.set(skillName, created);
+    return created;
+  }
+  const tests = rawSuite.tests;
+  for (let idx = 0; idx < tests.length; idx++) {
+    const rawCase = tests[idx];
+    const caseAssertions = resolveAssertions(rawCase);
+    if (rawCase.assert !== void 0 && rawCase.assertions === void 0) {
+      const caseId = rawCase.id ?? idx + 1;
+      warnings.push(`Test '${caseId}': 'assert' is deprecated. Use 'assertions' instead.`);
+    }
+    const nlAssertions = [];
+    if (typeof rawCase.criteria === "string" && rawCase.criteria.trim()) {
+      nlAssertions.push(rawCase.criteria.trim());
+    }
+    for (const entry of caseAssertions) {
+      if (entry.type !== "skill-trigger") {
+        nlAssertions.push(...assertionToNaturalLanguageList(entry));
+      }
+    }
+    nlAssertions.push(...suiteNlAssertions);
+    const triggerJudges = extractTriggerAssertions(caseAssertions);
+    const { prompt, files: inputFiles } = extractInput(rawCase);
+    const expectedOutput = extractExpectedOutput(rawCase.expected_output);
+    const numericId = idx + 1;
+    const baseCase = {
+      id: numericId,
+      prompt,
+      ...expectedOutput !== void 0 && { expected_output: expectedOutput },
+      ...inputFiles.length > 0 && { files: inputFiles },
+      assertions: nlAssertions
+    };
+    if (triggerJudges.length === 0) {
+      const noSkillFile2 = getSkillFile("_no-skill");
+      noSkillFile2.evals.push({ ...baseCase });
+    } else {
+      for (const tj of triggerJudges) {
+        const skillName = typeof tj.skill === "string" ? tj.skill : "_no-skill";
+        const shouldTrigger = tj.should_trigger !== false;
+        const skillFile = getSkillFile(skillName);
+        skillFile.evals.push({ ...baseCase, should_trigger: shouldTrigger });
+      }
+    }
+  }
+  const noSkillFile = files.get("_no-skill");
+  if (noSkillFile && noSkillFile.evals.length > 0) {
+    let dominantSkill = null;
+    let maxCount = 0;
+    for (const [name, f] of files) {
+      if (name !== "_no-skill" && f.evals.length > maxCount) {
+        maxCount = f.evals.length;
+        dominantSkill = name;
+      }
+    }
+    if (dominantSkill) {
+      const targetFile = getSkillFile(dominantSkill);
+      for (const evalCase of noSkillFile.evals) {
+        targetFile.evals.push(evalCase);
+      }
+      files.delete("_no-skill");
+    }
+  }
+  return { files, warnings };
+}
+function transpileEvalYamlFile(evalYamlPath) {
+  const content = readFileSync(evalYamlPath, "utf8");
+  const parsed = parse(content);
+  return transpileEvalYaml(parsed, path.basename(evalYamlPath));
+}
+function getOutputFilenames(result) {
+  const names = /* @__PURE__ */ new Map();
+  if (result.files.size === 1) {
+    for (const [skill] of result.files) {
+      names.set(skill, "evals.json");
+    }
+  } else {
+    for (const [skill] of result.files) {
+      const safeName = skill.replace(/[^a-zA-Z0-9_-]/g, "_");
+      names.set(skill, `${safeName}.evals.json`);
+    }
+  }
+  return names;
+}
+var AgentVConfigSchema = external_exports.object({
+  /** Default execution settings */
+  execution: external_exports.object({
+    /** Number of parallel workers (default: 3) */
+    workers: external_exports.number().int().min(1).max(50).optional(),
+    /** Maximum retries on failure (default: 2) */
+    maxRetries: external_exports.number().int().min(0).optional(),
+    /** Agent timeout in milliseconds. No timeout if not set. */
+    agentTimeoutMs: external_exports.number().int().min(0).optional(),
+    /** Enable verbose logging */
+    verbose: external_exports.boolean().optional(),
+    /** Always keep temp workspaces after eval */
+    keepWorkspaces: external_exports.boolean().optional(),
+    /** Write OTLP JSON trace to this path (supports {timestamp} placeholder) */
+    otelFile: external_exports.string().optional()
+  }).optional(),
+  /** Output settings */
+  output: external_exports.object({
+    /** Output format */
+    format: external_exports.enum(["jsonl", "yaml", "json", "xml"]).optional(),
+    /** Output directory */
+    dir: external_exports.string().optional()
+  }).optional(),
+  /** Response caching */
+  cache: external_exports.object({
+    /** Enable response caching */
+    enabled: external_exports.boolean().optional(),
+    /** Cache file path */
+    path: external_exports.string().optional()
+  }).optional(),
+  /** Cost and duration limits */
+  limits: external_exports.object({
+    /** Maximum cost per run in USD */
+    maxCostUsd: external_exports.number().min(0).optional(),
+    /** Maximum duration per run in milliseconds */
+    maxDurationMs: external_exports.number().int().min(0).optional()
+  }).optional()
+});
+function defineConfig(config) {
+  return AgentVConfigSchema.parse(config);
+}
+var CONFIG_FILE_NAMES = [
+  "agentv.config.ts",
+  "agentv.config.js",
+  "agentv.config.mts",
+  "agentv.config.mjs",
+  ".agentv/config.ts",
+  ".agentv/config.js"
+];
+async function loadTsConfig(projectRoot) {
+  const { existsSync: existsSync3 } = await import("node:fs");
+  const { pathToFileURL } = await import("node:url");
+  const { join } = await import("node:path");
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const filePath = join(projectRoot, fileName);
+    if (!existsSync3(filePath)) {
+      continue;
+    }
+    try {
+      const fileUrl = pathToFileURL(filePath).href;
+      const mod = await import(fileUrl);
+      const config = mod.default ?? mod;
+      return AgentVConfigSchema.parse(config);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to load config from ${filePath}: ${msg}`);
+    }
+  }
+  return null;
+}
+var rubricItemSchema = external_exports.object({
+  id: external_exports.string().describe("Short identifier for this rubric (e.g., clarity, completeness)"),
+  outcome: external_exports.string().describe("Concrete expected outcome for this rubric item"),
+  weight: external_exports.number().default(1).describe("Relative importance (default 1.0)"),
+  required: external_exports.boolean().default(true).describe("Whether this is a mandatory requirement")
+});
+var rubricGenerationSchema = external_exports.object({
+  rubrics: external_exports.array(rubricItemSchema).describe("List of evaluation rubrics")
+});
+async function generateRubrics(options) {
+  const { criteria, question, referenceAnswer, provider } = options;
+  const prompt = buildPrompt(criteria, question, referenceAnswer);
+  const model = provider.asLanguageModel?.();
+  if (!model) {
+    throw new Error("Provider does not support language model interface");
+  }
+  const system = `You are an expert at creating evaluation rubrics.
+You must return a valid JSON object matching this schema:
+{
+  "rubrics": [
+    {
+      "id": "string (short identifier)",
+      "outcome": "string (concrete expected outcome for this rubric item)",
+      "weight": number (default 1.0),
+      "required": boolean (default true)
+    }
+  ]
+}`;
+  let result;
+  let lastError;
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    try {
+      const { text } = await generateText({
+        model,
+        system,
+        prompt
+      });
+      const cleaned = text.replace(/```json\n?|```/g, "").trim();
+      result = rubricGenerationSchema.parse(JSON.parse(cleaned));
+      break;
+    } catch (e) {
+      lastError = e instanceof Error ? e : new Error(String(e));
+    }
+  }
+  if (!result) {
+    throw new Error(`Failed to parse generated rubrics after 3 attempts: ${lastError?.message}`);
+  }
+  return result.rubrics;
+}
+function buildPrompt(criteria, question, referenceAnswer) {
+  const parts = [
+    "You are an expert at creating evaluation rubrics.",
+    "Given the expected outcome (and optionally the question and reference answer),",
+    "generate a list of specific, measurable rubric items to evaluate whether an answer meets the expected outcome.",
+    "",
+    "Each rubric should:",
+    "- Be specific and testable",
+    "- Have a short, descriptive ID",
+    "- Include a clear expected outcome statement (what a good answer must demonstrate for this rubric)",
+    "- Indicate if it is required (mandatory) or optional",
+    "- Have an appropriate weight (default 1.0, use higher values for more important aspects)",
+    "",
+    "Generate 3-7 rubric items that comprehensively cover the expected outcome.",
+    "",
+    "[[ ## criteria ## ]]",
+    criteria,
+    ""
+  ];
+  if (question && question.trim().length > 0) {
+    parts.push("[[ ## question ## ]]", question, "");
+  }
+  if (referenceAnswer && referenceAnswer.trim().length > 0) {
+    parts.push("[[ ## reference_answer ## ]]", referenceAnswer, "");
+  }
+  return parts.join("\n");
+}
+function normalizeGitUrl(url) {
+  let normalized = url.replace(/\.git$/, "");
+  try {
+    const parsed = new URL(normalized);
+    parsed.hostname = parsed.hostname.toLowerCase();
+    normalized = parsed.toString().replace(/\/$/, "");
+  } catch {
+  }
+  return normalized;
+}
+async function scanRepoDeps(evalFilePaths) {
+  const seen = /* @__PURE__ */ new Map();
+  const errors = [];
+  for (const filePath of evalFilePaths) {
+    try {
+      const repos = await extractReposFromEvalFile(filePath);
+      for (const repo of repos) {
+        if (!repo.source || repo.source.type !== "git") continue;
+        const ref = repo.checkout?.ref;
+        const key = `${normalizeGitUrl(repo.source.url)}\0${ref ?? ""}`;
+        const existing = seen.get(key);
+        if (existing) {
+          existing.usedBy.push(filePath);
+        } else {
+          const { ref: _ref, ...checkoutRest } = repo.checkout ?? {};
+          const hasCheckout = Object.keys(checkoutRest).length > 0;
+          seen.set(key, {
+            url: repo.source.url,
+            ref,
+            clone: repo.clone,
+            checkout: hasCheckout ? checkoutRest : void 0,
+            usedBy: [filePath]
+          });
+        }
+      }
+    } catch (err) {
+      errors.push({
+        file: filePath,
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return { repos: [...seen.values()], errors };
+}
+async function extractReposFromEvalFile(filePath) {
+  const content = await readFile(filePath, "utf8");
+  const parsed = interpolateEnv(parse2(content), process.env);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
+  const obj = parsed;
+  const evalFileDir = path2.dirname(path2.resolve(filePath));
+  const repos = [];
+  const suiteRepos = await extractReposFromWorkspaceRaw(obj.workspace, evalFileDir);
+  repos.push(...suiteRepos);
+  const tests = Array.isArray(obj.tests) ? obj.tests : [];
+  for (const test of tests) {
+    if (test && typeof test === "object" && !Array.isArray(test)) {
+      const testObj = test;
+      const testRepos = await extractReposFromWorkspaceRaw(testObj.workspace, evalFileDir);
+      repos.push(...testRepos);
+    }
+  }
+  return repos;
+}
+async function extractReposFromWorkspaceRaw(raw, evalFileDir) {
+  if (typeof raw === "string") {
+    const workspaceFilePath = path2.resolve(evalFileDir, raw);
+    const content = await readFile(workspaceFilePath, "utf8");
+    const parsed = interpolateEnv(parse2(content), process.env);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
+    return extractReposFromObject(parsed);
+  }
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    return extractReposFromObject(raw);
+  }
+  return [];
+}
+function extractReposFromObject(obj) {
+  const rawRepos = Array.isArray(obj.repos) ? obj.repos : [];
+  const result = [];
+  for (const r of rawRepos) {
+    if (!r || typeof r !== "object" || Array.isArray(r)) continue;
+    const repo = r;
+    const source = parseRepoSource(repo.source);
+    if (!source) continue;
+    result.push({
+      source,
+      checkout: parseRepoCheckout(repo.checkout),
+      clone: parseRepoClone(repo.clone)
+    });
+  }
+  return result;
+}
+var DEFAULT_CACHE_PATH = ".agentv/cache";
+var ResponseCache = class {
+  cachePath;
+  constructor(cachePath) {
+    this.cachePath = cachePath ?? DEFAULT_CACHE_PATH;
+  }
+  async get(key) {
+    const filePath = this.keyToPath(key);
+    try {
+      const data = await readFile2(filePath, "utf8");
+      return JSON.parse(data);
+    } catch {
+      return void 0;
+    }
+  }
+  async set(key, value) {
+    const filePath = this.keyToPath(key);
+    const dir = path3.dirname(filePath);
+    await mkdir(dir, { recursive: true });
+    await writeFile(filePath, JSON.stringify(value, null, 2), "utf8");
+  }
+  keyToPath(key) {
+    const prefix = key.slice(0, 2);
+    return path3.join(this.cachePath, prefix, `${key}.json`);
+  }
+};
+function shouldEnableCache(params) {
+  if (params.cliNoCache) return false;
+  return params.cliCache || params.yamlCache === true;
+}
+function shouldSkipCacheForTemperature(targetConfig) {
+  const temp = targetConfig.temperature;
+  if (typeof temp === "number" && temp > 0) {
+    return true;
+  }
+  return false;
+}
+var execFileAsync = promisify(execFile);
+function sanitizeRepoSlug(repo) {
+  return repo.trim().replace(/[^A-Za-z0-9._-]+/g, "-");
+}
+function withFriendlyGitHubAuthError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const lower = message.toLowerCase();
+  if (lower.includes("authentication failed") || lower.includes("could not read username") || lower.includes("permission denied") || lower.includes("not logged into any github hosts")) {
+    return new Error(`${message}. Run 'gh auth login' to authenticate.`);
+  }
+  return new Error(message);
+}
+function normalizeResultsExportConfig(config) {
+  return {
+    repo: config.repo.trim(),
+    path: config.path.trim().replace(/^\/+|\/+$/g, ""),
+    auto_push: config.auto_push === true,
+    branch_prefix: config.branch_prefix?.trim() || "eval-results"
+  };
+}
+function resolveResultsRepoUrl(repo) {
+  if (repo.includes("://") || repo.startsWith("git@")) {
+    return repo;
+  }
+  return `https://github.com/${repo}.git`;
+}
+function getResultsRepoCachePaths(repo) {
+  const rootDir = path4.join(getAgentvHome(), "cache", "results-repo", sanitizeRepoSlug(repo));
+  return {
+    rootDir,
+    repoDir: path4.join(rootDir, "repo"),
+    statusFile: path4.join(rootDir, "status.json")
+  };
+}
+function readPersistedStatus(statusFile) {
+  if (!existsSync(statusFile)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync2(statusFile, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writePersistedStatus(statusFile, status) {
+  mkdirSync(path4.dirname(statusFile), { recursive: true });
+  writeFileSync(statusFile, `${JSON.stringify(status, null, 2)}
+`, "utf8");
+}
+async function runCommand(executable, args, options) {
+  try {
+    const { stdout, stderr } = await execFileAsync(executable, [...args], {
+      cwd: options?.cwd,
+      env: process.env
+    });
+    return { stdout, stderr };
+  } catch (error) {
+    if (options?.check === false && error && typeof error === "object") {
+      const execError = error;
+      return {
+        stdout: execError.stdout ?? "",
+        stderr: execError.stderr ?? ""
+      };
+    }
+    throw withFriendlyGitHubAuthError(error);
+  }
+}
+async function runGit(args, options) {
+  return runCommand("git", args, options);
+}
+async function runGh(args, options) {
+  return runCommand("gh", args, options);
+}
+async function resolveDefaultBranch(repoDir) {
+  try {
+    const { stdout } = await runGit(["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd: repoDir });
+    const ref = stdout.trim();
+    const prefix = "refs/remotes/origin/";
+    if (ref.startsWith(prefix)) {
+      return ref.slice(prefix.length);
+    }
+  } catch {
+  }
+  for (const candidate of ["main", "master"]) {
+    try {
+      await runGit(["rev-parse", "--verify", `origin/${candidate}`], { cwd: repoDir });
+      return candidate;
+    } catch {
+    }
+  }
+  return "main";
+}
+async function updateCacheRepo(repoDir, baseBranch) {
+  await runGit(["fetch", "origin", "--prune"], { cwd: repoDir });
+  await runGit(["checkout", baseBranch], { cwd: repoDir });
+  await runGit(["pull", "--ff-only", "origin", baseBranch], { cwd: repoDir });
+}
+function updateStatusFile(config, patch) {
+  const cachePaths = getResultsRepoCachePaths(config.repo);
+  const current = readPersistedStatus(cachePaths.statusFile);
+  writePersistedStatus(cachePaths.statusFile, {
+    ...current,
+    ...patch
+  });
+}
+async function ensureResultsRepoClone(config) {
+  const normalized = normalizeResultsExportConfig(config);
+  const cachePaths = getResultsRepoCachePaths(normalized.repo);
+  mkdirSync(cachePaths.rootDir, { recursive: true });
+  if (!existsSync(cachePaths.repoDir)) {
+    try {
+      await runGit([
+        "clone",
+        "--filter=blob:none",
+        resolveResultsRepoUrl(normalized.repo),
+        cachePaths.repoDir
+      ]);
+      return cachePaths.repoDir;
+    } catch (error) {
+      updateStatusFile(normalized, { last_error: withFriendlyGitHubAuthError(error).message });
+      throw withFriendlyGitHubAuthError(error);
+    }
+  }
+  if (!existsSync(path4.join(cachePaths.repoDir, ".git"))) {
+    throw new Error(`Results repo cache is not a git repository: ${cachePaths.repoDir}`);
+  }
+  return cachePaths.repoDir;
+}
+function getResultsRepoStatus(config) {
+  if (!config) {
+    return {
+      configured: false,
+      available: false,
+      repo: "",
+      cache_dir: ""
+    };
+  }
+  const normalized = normalizeResultsExportConfig(config);
+  const cachePaths = getResultsRepoCachePaths(normalized.repo);
+  const persisted = readPersistedStatus(cachePaths.statusFile);
+  return {
+    configured: true,
+    available: existsSync(cachePaths.repoDir),
+    repo: normalized.repo,
+    path: normalized.path,
+    auto_push: normalized.auto_push,
+    branch_prefix: normalized.branch_prefix,
+    cache_dir: cachePaths.repoDir,
+    last_synced_at: persisted.last_synced_at,
+    last_error: persisted.last_error
+  };
+}
+async function syncResultsRepo(config) {
+  const normalized = normalizeResultsExportConfig(config);
+  try {
+    const repoDir = await ensureResultsRepoClone(normalized);
+    const baseBranch = await resolveDefaultBranch(repoDir);
+    await updateCacheRepo(repoDir, baseBranch);
+    updateStatusFile(normalized, {
+      last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+      last_error: void 0
+    });
+  } catch (error) {
+    updateStatusFile(normalized, {
+      last_error: withFriendlyGitHubAuthError(error).message
+    });
+    throw withFriendlyGitHubAuthError(error);
+  }
+  return getResultsRepoStatus(normalized);
+}
+async function checkoutResultsRepoBranch(config, branchName) {
+  const normalized = normalizeResultsExportConfig(config);
+  const repoDir = await ensureResultsRepoClone(normalized);
+  const baseBranch = await resolveDefaultBranch(repoDir);
+  await updateCacheRepo(repoDir, baseBranch);
+  await runGit(["checkout", "-B", branchName, `origin/${baseBranch}`], { cwd: repoDir });
+  updateStatusFile(normalized, { last_error: void 0 });
+  return {
+    branchName,
+    baseBranch,
+    repoDir
+  };
+}
+async function prepareResultsRepoBranch(config, branchName) {
+  const normalized = normalizeResultsExportConfig(config);
+  const cloneDir = await ensureResultsRepoClone(normalized);
+  const baseBranch = await resolveDefaultBranch(cloneDir);
+  await updateCacheRepo(cloneDir, baseBranch);
+  const worktreeRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-results-repo-"));
+  const worktreeDir = path4.join(worktreeRoot, "repo");
+  await runGit(["worktree", "add", "-B", branchName, worktreeDir, `origin/${baseBranch}`], {
+    cwd: cloneDir
+  });
+  return {
+    branchName,
+    baseBranch,
+    repoDir: worktreeDir,
+    cleanup: async () => {
+      try {
+        await runGit(["worktree", "remove", "--force", worktreeDir], { cwd: cloneDir });
+      } finally {
+        await rm(worktreeRoot, { recursive: true, force: true }).catch(() => void 0);
+      }
+    }
+  };
+}
+async function stageResultsArtifacts(params) {
+  rmSync(params.destinationDir, { recursive: true, force: true });
+  mkdirSync(path4.dirname(params.destinationDir), { recursive: true });
+  await cp(params.sourceDir, params.destinationDir, { recursive: true });
+}
+function resolveResultsRepoRunsDir(config) {
+  const normalized = normalizeResultsExportConfig(config);
+  return path4.join(
+    getResultsRepoCachePaths(normalized.repo).repoDir,
+    ...normalized.path.split("/")
+  );
+}
+async function directorySizeBytes(targetPath) {
+  const entry = await stat(targetPath);
+  if (entry.isFile()) {
+    return entry.size;
+  }
+  let total = 0;
+  for (const child of await readdir(targetPath, { withFileTypes: true })) {
+    total += await directorySizeBytes(path4.join(targetPath, child.name));
+  }
+  return total;
+}
+async function commitAndPushResultsBranch(params) {
+  await runGit(["add", "--all"], { cwd: params.repoDir });
+  const { stdout: diffStdout } = await runGit(["status", "--porcelain"], {
+    cwd: params.repoDir,
+    check: false
+  });
+  if (diffStdout.trim().length === 0) {
+    return false;
+  }
+  await runGit(["commit", "-m", params.commitMessage], { cwd: params.repoDir });
+  await runGit(["push", "-u", "origin", params.branchName], { cwd: params.repoDir });
+  return true;
+}
+async function pushResultsRepoBranch(config, branchName, cwd) {
+  const normalized = normalizeResultsExportConfig(config);
+  await runGit(["push", "-u", "origin", branchName], {
+    cwd: cwd ?? getResultsRepoCachePaths(normalized.repo).repoDir
+  });
+  updateStatusFile(normalized, {
+    last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+    last_error: void 0
+  });
+}
+async function createDraftResultsPr(params) {
+  const { stdout } = await runGh(
+    [
+      "pr",
+      "create",
+      "--draft",
+      "--repo",
+      params.repo,
+      "--base",
+      params.baseBranch,
+      "--head",
+      params.branchName,
+      "--title",
+      params.title,
+      "--body",
+      params.body
+    ],
+    { cwd: params.repoDir }
+  );
+  return stdout.trim();
+}
+function getBenchmarksRegistryPath() {
+  return path5.join(getAgentvConfigDir(), "projects.yaml");
+}
+function migrateProjectsYaml(targetPath) {
+  const dataHome = getAgentvHome();
+  const configDir = getAgentvConfigDir();
+  if (dataHome === configDir) return;
+  const legacyPath = path5.join(dataHome, "projects.yaml");
+  if (!existsSync2(legacyPath)) return;
+  mkdirSync2(path5.dirname(targetPath), { recursive: true });
+  copyFileSync(legacyPath, targetPath);
+}
+function loadBenchmarkRegistry() {
+  const registryPath = getBenchmarksRegistryPath();
+  if (!existsSync2(registryPath)) {
+    migrateProjectsYaml(registryPath);
+  }
+  if (!existsSync2(registryPath)) {
+    return { benchmarks: [] };
+  }
+  try {
+    const raw = readFileSync3(registryPath, "utf-8");
+    const parsed = parseYaml(raw);
+    if (!parsed || !Array.isArray(parsed.benchmarks)) {
+      return { benchmarks: [] };
+    }
+    return { benchmarks: parsed.benchmarks };
+  } catch {
+    return { benchmarks: [] };
+  }
+}
+function saveBenchmarkRegistry(registry) {
+  const registryPath = getBenchmarksRegistryPath();
+  const dir = path5.dirname(registryPath);
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  writeFileSync2(registryPath, stringifyYaml({ benchmarks: registry.benchmarks }), "utf-8");
+}
+function deriveBenchmarkId(dirPath, existingIds) {
+  const base = path5.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  let candidate = base || "benchmark";
+  let suffix = 2;
+  while (existingIds.includes(candidate)) {
+    candidate = `${base}-${suffix}`;
+    suffix++;
+  }
+  return candidate;
+}
+function addBenchmark(benchmarkPath) {
+  const absPath = path5.resolve(benchmarkPath);
+  if (!existsSync2(absPath)) {
+    throw new Error(`Directory not found: ${absPath}`);
+  }
+  if (!existsSync2(path5.join(absPath, ".agentv"))) {
+    throw new Error(`No .agentv/ directory found in ${absPath}. Run an evaluation first.`);
+  }
+  const registry = loadBenchmarkRegistry();
+  const existing = registry.benchmarks.find((p) => p.path === absPath);
+  if (existing) {
+    return existing;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = {
+    id: deriveBenchmarkId(
+      absPath,
+      registry.benchmarks.map((p) => p.id)
+    ),
+    name: path5.basename(absPath),
+    path: absPath,
+    addedAt: now,
+    lastOpenedAt: now
+  };
+  registry.benchmarks.push(entry);
+  saveBenchmarkRegistry(registry);
+  return entry;
+}
+function removeBenchmark(benchmarkId) {
+  const registry = loadBenchmarkRegistry();
+  const idx = registry.benchmarks.findIndex((p) => p.id === benchmarkId);
+  if (idx < 0) return false;
+  registry.benchmarks.splice(idx, 1);
+  saveBenchmarkRegistry(registry);
+  return true;
+}
+function getBenchmark(benchmarkId) {
+  return loadBenchmarkRegistry().benchmarks.find((p) => p.id === benchmarkId);
+}
+function touchBenchmark(benchmarkId) {
+  const registry = loadBenchmarkRegistry();
+  const entry = registry.benchmarks.find((p) => p.id === benchmarkId);
+  if (entry) {
+    entry.lastOpenedAt = (/* @__PURE__ */ new Date()).toISOString();
+    saveBenchmarkRegistry(registry);
+  }
+}
+function discoverBenchmarks(rootDir, maxDepth = 2) {
+  const absRoot = path5.resolve(rootDir);
+  if (!existsSync2(absRoot) || !statSync(absRoot).isDirectory()) {
+    return [];
+  }
+  const results = [];
+  function scan(dir, depth) {
+    if (depth > maxDepth) return;
+    if (existsSync2(path5.join(dir, ".agentv"))) {
+      results.push(dir);
+      return;
+    }
+    if (depth === maxDepth) return;
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+        scan(path5.join(dir, entry.name), depth + 1);
+      }
+    } catch {
+    }
+  }
+  scan(absRoot, 0);
+  return results;
+}
+var STRIPPED_TOP_LEVEL_FIELDS = /* @__PURE__ */ new Set([
+  "requests",
+  "trace",
+  "workspacePath",
+  "output",
+  "beforeAllOutput",
+  "beforeEachOutput",
+  "afterAllOutput",
+  "afterEachOutput",
+  "fileChanges",
+  // Promoted execution metrics (debug, not needed for regression comparison)
+  "tokenUsage",
+  "costUsd",
+  "durationMs",
+  "startTime",
+  "endTime"
+]);
+var STRIPPED_EVALUATOR_FIELDS = /* @__PURE__ */ new Set(["rawRequest", "input"]);
+function trimEvaluatorResult(result) {
+  const trimmed = {};
+  for (const [key, value] of Object.entries(result)) {
+    if (STRIPPED_EVALUATOR_FIELDS.has(key)) continue;
+    if (key === "scores" && Array.isArray(value)) {
+      trimmed[key] = value.map(trimEvaluatorResult);
+    } else {
+      trimmed[key] = value;
+    }
+  }
+  return trimmed;
+}
+function trimBaselineResult(result) {
+  const trimmed = {};
+  for (const [key, value] of Object.entries(result)) {
+    if (STRIPPED_TOP_LEVEL_FIELDS.has(key)) continue;
+    if (key === "scores" && Array.isArray(value)) {
+      trimmed[key] = value.map(trimEvaluatorResult);
+    } else {
+      trimmed[key] = value;
+    }
+  }
+  return trimmed;
+}
+var DEFAULT_CATEGORY = "Uncategorized";
+function deriveCategory(relativePath) {
+  const parts = relativePath.split(/[/\\]/);
+  if (parts.length <= 1) {
+    return DEFAULT_CATEGORY;
+  }
+  const dirs = parts.slice(0, -1).filter((d) => d !== "evals");
+  return dirs.length > 0 ? dirs.join("/") : DEFAULT_CATEGORY;
+}
+var OTEL_BACKEND_PRESETS = {
+  langfuse: {
+    name: "langfuse",
+    endpoint: process.env.LANGFUSE_HOST ? `${process.env.LANGFUSE_HOST}/api/public/otel/v1/traces` : "https://cloud.langfuse.com/api/public/otel/v1/traces",
+    headers: (env) => {
+      const pub = env.LANGFUSE_PUBLIC_KEY ?? "";
+      const secret = env.LANGFUSE_SECRET_KEY ?? "";
+      return { Authorization: `Basic ${Buffer.from(`${pub}:${secret}`).toString("base64")}` };
+    }
+  },
+  braintrust: {
+    name: "braintrust",
+    endpoint: "https://api.braintrust.dev/otel/v1/traces",
+    headers: (env) => {
+      const headers = {
+        Authorization: `Bearer ${env.BRAINTRUST_API_KEY ?? ""}`
+      };
+      const parent = env.BRAINTRUST_PARENT ?? (env.BRAINTRUST_PROJECT_ID ? `project_id:${env.BRAINTRUST_PROJECT_ID}` : void 0) ?? (env.BRAINTRUST_PROJECT ? `project_name:${env.BRAINTRUST_PROJECT}` : void 0);
+      if (parent) {
+        headers["x-bt-parent"] = parent;
+      }
+      return headers;
+    }
+  },
+  confident: {
+    name: "confident",
+    endpoint: "https://otel.confident-ai.com/v1/traces",
+    headers: (env) => ({
+      "x-confident-api-key": env.CONFIDENT_API_KEY ?? ""
+    })
+  }
+};
+var OtelTraceExporter = class {
+  constructor(options) {
+    this.options = options;
+  }
+  provider = null;
+  tracer = null;
+  api = null;
+  // biome-ignore lint/suspicious/noExplicitAny: OTel types loaded dynamically
+  W3CPropagator = null;
+  /** Initialize the OTel SDK. Returns false if OTel packages are not available. */
+  async init() {
+    try {
+      const [sdkTraceNode, resourcesMod, semconvMod, api, coreMod] = await Promise.all([
+        import("./src-PXDA7QIS.js"),
+        import("./esm-UYZ3HJBU.js"),
+        import("./esm-RVQPUGWH.js"),
+        import("./esm-R77SNOF5.js"),
+        import("./esm-ZADQ4XQH-5LX2IKZV.js").catch(() => null)
+      ]);
+      const { NodeTracerProvider: Provider, SimpleSpanProcessor } = sdkTraceNode;
+      const { resourceFromAttributes } = resourcesMod;
+      const { ATTR_SERVICE_NAME } = semconvMod;
+      const resource = resourceFromAttributes({
+        [ATTR_SERVICE_NAME]: this.options.serviceName ?? "agentv"
+      });
+      const processors = [];
+      if (this.options.endpoint) {
+        const otlpHttp = await import("./esm-QNEMCJPL.js");
+        const { OTLPTraceExporter } = otlpHttp;
+        const exporter = new OTLPTraceExporter({
+          url: this.options.endpoint,
+          headers: this.options.headers
+        });
+        processors.push(new SimpleSpanProcessor(exporter));
+      }
+      if (this.options.otlpFilePath) {
+        const { OtlpJsonFileExporter: OtlpJsonFileExporter2 } = await import("./otlp-json-file-exporter-RJFPCKVK-T6N4OGWG.js");
+        processors.push(
+          new SimpleSpanProcessor(new OtlpJsonFileExporter2(this.options.otlpFilePath))
+        );
+      }
+      if (processors.length === 0) {
+        return false;
+      }
+      this.provider = new Provider({
+        resource,
+        spanProcessors: processors
+      });
+      this.provider.register();
+      this.api = api;
+      this.tracer = api.trace.getTracer("agentv", "1.0.0");
+      this.W3CPropagator = coreMod?.W3CTraceContextPropagator ?? null;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Export a single evaluation result as an OTel trace. */
+  async exportResult(result) {
+    if (!this.tracer || !this.api) return;
+    const api = this.api;
+    const tracer = this.tracer;
+    const captureContent = this.options.captureContent ?? false;
+    const startHr = toHrTime(result.startTime ?? result.timestamp);
+    const endHr = toHrTime(result.endTime ?? result.timestamp);
+    let parentCtx = api.ROOT_CONTEXT;
+    const traceparent = process.env.TRACEPARENT;
+    if (traceparent && this.W3CPropagator) {
+      try {
+        const propagator = new this.W3CPropagator();
+        parentCtx = propagator.extract(
+          api.ROOT_CONTEXT,
+          { traceparent, tracestate: process.env.TRACESTATE ?? "" },
+          {
+            get: (carrier, key) => carrier[key],
+            keys: (carrier) => Object.keys(carrier)
+          }
+        );
+      } catch {
+      }
+    }
+    tracer.startActiveSpan(
+      "agentv.eval",
+      { startTime: startHr },
+      parentCtx,
+      (rootSpan) => {
+        rootSpan.setAttribute("gen_ai.operation.name", "evaluate");
+        rootSpan.setAttribute("gen_ai.system", "agentv");
+        rootSpan.setAttribute("agentv.test_id", result.testId);
+        rootSpan.setAttribute("agentv.target", result.target);
+        if (result.suite) rootSpan.setAttribute("agentv.suite", result.suite);
+        rootSpan.setAttribute("agentv.score", result.score);
+        if (captureContent && result.output.length > 0) {
+          const lastMsg = result.output[result.output.length - 1];
+          const text = typeof lastMsg.content === "string" ? lastMsg.content : JSON.stringify(lastMsg.content);
+          rootSpan.setAttribute("agentv.output_text", text);
+        }
+        if (result.durationMs != null)
+          rootSpan.setAttribute("agentv.trace.duration_ms", result.durationMs);
+        if (result.costUsd != null) rootSpan.setAttribute("agentv.trace.cost_usd", result.costUsd);
+        if (result.tokenUsage) {
+          if (result.tokenUsage.input != null) {
+            rootSpan.setAttribute("agentv.trace.token_input", result.tokenUsage.input);
+          }
+          if (result.tokenUsage.output != null) {
+            rootSpan.setAttribute("agentv.trace.token_output", result.tokenUsage.output);
+          }
+          if (result.tokenUsage.cached != null) {
+            rootSpan.setAttribute("agentv.trace.token_cached", result.tokenUsage.cached);
+          }
+        }
+        if (result.trace) {
+          const t = result.trace;
+          rootSpan.setAttribute("agentv.trace.event_count", t.eventCount);
+          rootSpan.setAttribute(
+            "agentv.trace.tool_names",
+            Object.keys(t.toolCalls).sort().join(",")
+          );
+          if (t.llmCallCount != null)
+            rootSpan.setAttribute("agentv.trace.llm_call_count", t.llmCallCount);
+        }
+        if (result.output) {
+          const parentCtx2 = api.trace.setSpan(api.context.active(), rootSpan);
+          if (this.options.groupTurns) {
+            const turns = groupMessagesIntoTurns(result.output);
+            if (turns.length > 1) {
+              for (const [i, turn] of turns.entries()) {
+                api.context.with(parentCtx2, () => {
+                  tracer.startActiveSpan(
+                    `agentv.turn.${i + 1}`,
+                    {},
+                    (turnSpan) => {
+                      const turnCtx = api.trace.setSpan(api.context.active(), turnSpan);
+                      for (const msg of turn.messages) {
+                        this.exportMessage(tracer, api, turnCtx, msg, captureContent);
+                      }
+                      turnSpan.end();
+                    }
+                  );
+                });
+              }
+            } else {
+              for (const msg of result.output) {
+                this.exportMessage(tracer, api, parentCtx2, msg, captureContent);
+              }
+            }
+          } else {
+            for (const msg of result.output) {
+              this.exportMessage(tracer, api, parentCtx2, msg, captureContent);
+            }
+          }
+        }
+        if (result.scores) {
+          for (const score of result.scores) {
+            rootSpan.addEvent(`agentv.grader.${score.name}`, {
+              "agentv.grader.score": score.score,
+              "agentv.grader.type": score.type,
+              ...score.verdict ? { "agentv.grader.verdict": score.verdict } : {}
+            });
+          }
+        }
+        if (result.error) {
+          rootSpan.setStatus({ code: api.SpanStatusCode.ERROR, message: result.error });
+        } else {
+          rootSpan.setStatus({ code: api.SpanStatusCode.OK });
+        }
+        rootSpan.end(endHr);
+      }
+    );
+  }
+  /** Flush pending spans and shut down. */
+  async shutdown() {
+    await this.provider?.shutdown();
+  }
+  /** Create a streaming observer for real-time span export */
+  createStreamingObserver() {
+    if (!this.tracer || !this.api) return null;
+    let parentCtx;
+    const traceparent = process.env.TRACEPARENT;
+    if (traceparent && this.W3CPropagator) {
+      try {
+        const propagator = new this.W3CPropagator();
+        parentCtx = propagator.extract(
+          this.api.ROOT_CONTEXT,
+          { traceparent, tracestate: process.env.TRACESTATE ?? "" },
+          {
+            get: (carrier, key) => carrier[key],
+            keys: (carrier) => Object.keys(carrier)
+          }
+        );
+      } catch {
+      }
+    }
+    return new OtelStreamingObserver(
+      this.tracer,
+      this.api,
+      this.options.captureContent ?? false,
+      parentCtx
+    );
+  }
+  // -----------------------------------------------------------------------
+  // Private helpers
+  // -----------------------------------------------------------------------
+  exportMessage(tracer, api, parentCtx, msg, captureContent) {
+    const isAssistant = msg.role === "assistant";
+    const model = msg.metadata?.model ? String(msg.metadata.model) : void 0;
+    const spanName = isAssistant ? `chat ${model ?? "unknown"}` : `gen_ai.message.${msg.role}`;
+    const startHr = toHrTime(msg.startTime);
+    const endHr = toHrTime(msg.endTime);
+    api.context.with(parentCtx, () => {
+      tracer.startActiveSpan(
+        spanName,
+        { startTime: startHr },
+        parentCtx,
+        (span) => {
+          if (isAssistant) {
+            span.setAttribute("gen_ai.operation.name", "chat");
+          }
+          if (model) {
+            span.setAttribute("gen_ai.request.model", model);
+            span.setAttribute("gen_ai.response.model", model);
+          }
+          if (msg.tokenUsage) {
+            if (msg.tokenUsage.input != null) {
+              span.setAttribute("gen_ai.usage.input_tokens", msg.tokenUsage.input);
+            }
+            if (msg.tokenUsage.output != null) {
+              span.setAttribute("gen_ai.usage.output_tokens", msg.tokenUsage.output);
+            }
+            if (msg.tokenUsage.cached != null) {
+              span.setAttribute("gen_ai.usage.cache_read.input_tokens", msg.tokenUsage.cached);
+            }
+          }
+          if (captureContent && msg.content != null) {
+            span.setAttribute(
+              "gen_ai.output.messages",
+              typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+            );
+          }
+          if (msg.toolCalls) {
+            const msgCtx = api.trace.setSpan(api.context.active(), span);
+            for (const tc of msg.toolCalls) {
+              api.context.with(msgCtx, () => {
+                tracer.startActiveSpan(
+                  `execute_tool ${tc.tool}`,
+                  {},
+                  msgCtx,
+                  (toolSpan) => {
+                    toolSpan.setAttribute("gen_ai.tool.name", tc.tool);
+                    if (tc.id) toolSpan.setAttribute("gen_ai.tool.call.id", tc.id);
+                    if (captureContent) {
+                      if (tc.input != null) {
+                        toolSpan.setAttribute(
+                          "gen_ai.tool.call.arguments",
+                          typeof tc.input === "string" ? tc.input : JSON.stringify(tc.input)
+                        );
+                      }
+                      if (tc.output != null) {
+                        toolSpan.setAttribute(
+                          "gen_ai.tool.call.result",
+                          typeof tc.output === "string" ? tc.output : JSON.stringify(tc.output)
+                        );
+                      }
+                    }
+                    toolSpan.end();
+                  }
+                );
+              });
+            }
+          }
+          span.end(endHr);
+        }
+      );
+    });
+  }
+};
+var OtelStreamingObserver = class {
+  constructor(tracer, api, captureContent, parentCtx) {
+    this.tracer = tracer;
+    this.api = api;
+    this.captureContent = captureContent;
+    this.parentCtx = parentCtx;
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: OTel span type loaded dynamically
+  rootSpan = null;
+  // biome-ignore lint/suspicious/noExplicitAny: OTel context loaded dynamically
+  rootCtx = null;
+  observedChildSpans = false;
+  pendingMetrics = null;
+  /** Create root eval span immediately (visible in backend right away) */
+  startEvalCase(testId, target, evalSet) {
+    this.pendingMetrics = null;
+    this.observedChildSpans = false;
+    const ctx = this.parentCtx ?? this.api.context.active();
+    this.rootSpan = this.tracer.startSpan("agentv.eval", void 0, ctx);
+    this.rootSpan.setAttribute("gen_ai.operation.name", "evaluate");
+    this.rootSpan.setAttribute("gen_ai.system", "agentv");
+    this.rootSpan.setAttribute("agentv.test_id", testId);
+    this.rootSpan.setAttribute("agentv.target", target);
+    if (evalSet) this.rootSpan.setAttribute("agentv.suite", evalSet);
+    this.rootCtx = this.api.trace.setSpan(this.api.context.active(), this.rootSpan);
+  }
+  /** Create and immediately export a tool span */
+  onToolCall(name, input, output, _durationMs, toolCallId) {
+    if (!this.rootCtx) return;
+    this.observedChildSpans = true;
+    this.api.context.with(this.rootCtx, () => {
+      const span = this.tracer.startSpan(`execute_tool ${name}`, void 0, this.rootCtx);
+      span.setAttribute("gen_ai.tool.name", name);
+      if (toolCallId) span.setAttribute("gen_ai.tool.call.id", toolCallId);
+      if (this.captureContent) {
+        if (input != null)
+          span.setAttribute(
+            "gen_ai.tool.call.arguments",
+            typeof input === "string" ? input : JSON.stringify(input)
+          );
+        if (output != null)
+          span.setAttribute(
+            "gen_ai.tool.call.result",
+            typeof output === "string" ? output : JSON.stringify(output)
+          );
+      }
+      span.end();
+    });
+  }
+  /** Create and immediately export an LLM span */
+  onLlmCall(model, tokenUsage) {
+    if (!this.rootCtx) return;
+    this.observedChildSpans = true;
+    this.api.context.with(this.rootCtx, () => {
+      const span = this.tracer.startSpan(`chat ${model}`, void 0, this.rootCtx);
+      span.setAttribute("gen_ai.operation.name", "chat");
+      span.setAttribute("gen_ai.request.model", model);
+      span.setAttribute("gen_ai.response.model", model);
+      if (tokenUsage) {
+        if (tokenUsage.input != null)
+          span.setAttribute("gen_ai.usage.input_tokens", tokenUsage.input);
+        if (tokenUsage.output != null)
+          span.setAttribute("gen_ai.usage.output_tokens", tokenUsage.output);
+        if (tokenUsage.cached != null)
+          span.setAttribute("gen_ai.usage.cache_read.input_tokens", tokenUsage.cached);
+      }
+      span.end();
+    });
+  }
+  /** Record final execution metrics before the root span is finalized. */
+  recordEvalMetrics(result) {
+    this.pendingMetrics = result;
+  }
+  /** Finalize root span with score/verdict after evaluation completes */
+  finalizeEvalCase(score, error) {
+    if (!this.rootSpan) return;
+    this.rootSpan.setAttribute("agentv.score", score);
+    if (this.pendingMetrics?.durationMs != null) {
+      this.rootSpan.setAttribute("agentv.trace.duration_ms", this.pendingMetrics.durationMs);
+    }
+    if (this.pendingMetrics?.costUsd != null) {
+      this.rootSpan.setAttribute("agentv.trace.cost_usd", this.pendingMetrics.costUsd);
+    }
+    if (this.pendingMetrics?.tokenUsage) {
+      if (this.pendingMetrics.tokenUsage.input != null) {
+        this.rootSpan.setAttribute(
+          "agentv.trace.token_input",
+          this.pendingMetrics.tokenUsage.input
+        );
+      }
+      if (this.pendingMetrics.tokenUsage.output != null) {
+        this.rootSpan.setAttribute(
+          "agentv.trace.token_output",
+          this.pendingMetrics.tokenUsage.output
+        );
+      }
+      if (this.pendingMetrics.tokenUsage.cached != null) {
+        this.rootSpan.setAttribute(
+          "agentv.trace.token_cached",
+          this.pendingMetrics.tokenUsage.cached
+        );
+      }
+    }
+    if (this.pendingMetrics?.trace) {
+      this.rootSpan.setAttribute("agentv.trace.event_count", this.pendingMetrics.trace.eventCount);
+      this.rootSpan.setAttribute(
+        "agentv.trace.tool_names",
+        Object.keys(this.pendingMetrics.trace.toolCalls).sort().join(",")
+      );
+      if (this.pendingMetrics.trace.llmCallCount != null) {
+        this.rootSpan.setAttribute(
+          "agentv.trace.llm_call_count",
+          this.pendingMetrics.trace.llmCallCount
+        );
+      }
+    }
+    if (error) {
+      this.rootSpan.setStatus({ code: this.api.SpanStatusCode.ERROR, message: error });
+    } else {
+      this.rootSpan.setStatus({ code: this.api.SpanStatusCode.OK });
+    }
+    this.rootSpan.end();
+    this.rootSpan = null;
+    this.rootCtx = null;
+    this.observedChildSpans = false;
+    this.pendingMetrics = null;
+  }
+  /** Backfill child spans from the completed result when the provider emitted no live callbacks. */
+  completeFromResult(result) {
+    this.recordEvalMetrics({
+      durationMs: result.durationMs,
+      costUsd: result.costUsd,
+      tokenUsage: result.tokenUsage,
+      trace: result.trace
+    });
+    if (this.observedChildSpans || !this.rootCtx) {
+      return;
+    }
+    const model = result.output.find((msg) => msg.role === "assistant")?.metadata?.model ?? result.target ?? "unknown";
+    this.onLlmCall(String(model), result.tokenUsage);
+    for (const message of result.output) {
+      for (const toolCall of message.toolCalls ?? []) {
+        this.onToolCall(
+          toolCall.tool,
+          toolCall.input,
+          toolCall.output,
+          toolCall.durationMs ?? 0,
+          toolCall.id
+        );
+      }
+    }
+  }
+  /** Return the active eval span's trace ID and span ID for Braintrust trace bridging */
+  getActiveSpanIds() {
+    if (!this.rootSpan) return null;
+    try {
+      const spanCtx = this.rootSpan.spanContext?.() ?? this.rootSpan._spanContext;
+      if (!spanCtx?.traceId || !spanCtx?.spanId) return null;
+      return { parentSpanId: spanCtx.spanId, rootSpanId: spanCtx.traceId };
+    } catch {
+      return null;
+    }
+  }
+  /** Get ProviderStreamCallbacks for passing to providers */
+  getStreamCallbacks() {
+    return {
+      onToolCallEnd: (name, input, output, durationMs, toolCallId) => this.onToolCall(name, input, output, durationMs, toolCallId),
+      onLlmCallEnd: (model, tokenUsage) => this.onLlmCall(model, tokenUsage),
+      getActiveSpanIds: () => this.getActiveSpanIds()
+    };
+  }
+};
+function groupMessagesIntoTurns(messages) {
+  const turns = [];
+  let current = [];
+  for (const msg of messages) {
+    if (msg.role === "user" && current.length > 0) {
+      turns.push({ messages: current });
+      current = [];
+    }
+    current.push(msg);
+  }
+  if (current.length > 0) turns.push({ messages: current });
+  return turns;
+}
+function toHrTime(iso) {
+  if (!iso) return void 0;
+  return new Date(iso).getTime();
+}
+var SKIPPED_TYPES = /* @__PURE__ */ new Set(["progress", "system", "file-history-snapshot"]);
+function parseClaudeSession(jsonl) {
+  const messages = [];
+  let sessionId = "";
+  let projectPath;
+  let model;
+  let startTimestamp;
+  let endTimestamp;
+  const usageByRequestId = /* @__PURE__ */ new Map();
+  let lastAssistantRequestId;
+  let lastAssistantIdx = -1;
+  const pendingToolCalls = /* @__PURE__ */ new Map();
+  const lines = jsonl.split("\n").filter((l) => l.trim().length > 0);
+  for (const line of lines) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!event.type) continue;
+    if (event.timestamp) {
+      if (!startTimestamp) startTimestamp = event.timestamp;
+      endTimestamp = event.timestamp;
+    }
+    if (SKIPPED_TYPES.has(event.type)) continue;
+    if (event.isSidechain) continue;
+    if (!sessionId && event.sessionId) {
+      sessionId = event.sessionId;
+    }
+    if (!projectPath && event.cwd) {
+      projectPath = event.cwd;
+    }
+    switch (event.type) {
+      case "user": {
+        const msg = event.message;
+        if (!msg) break;
+        const contentArr = msg.content;
+        if (Array.isArray(contentArr)) {
+          for (const block of contentArr) {
+            if (block.type === "tool_result" && block.tool_use_id) {
+              const pending = pendingToolCalls.get(block.tool_use_id);
+              if (pending) {
+                const existingMsg = messages[pending.msgIdx];
+                const existingCalls = [...existingMsg.toolCalls ?? []];
+                existingCalls[pending.toolIdx] = {
+                  ...existingCalls[pending.toolIdx],
+                  output: extractToolResultContent(block.content)
+                };
+                messages[pending.msgIdx] = { ...existingMsg, toolCalls: existingCalls };
+                pendingToolCalls.delete(block.tool_use_id);
+              }
+            }
+          }
+        }
+        const text = extractTextContent(contentArr);
+        if (text !== void 0) {
+          messages.push({ role: "user", content: text });
+        }
+        break;
+      }
+      case "assistant": {
+        const msg = event.message;
+        if (!msg) break;
+        if (!model && msg.model) {
+          model = msg.model;
+        }
+        if (msg.usage && event.requestId) {
+          usageByRequestId.set(event.requestId, msg.usage);
+        }
+        const { text, toolCalls } = extractAssistantContent(msg.content);
+        if (event.requestId && event.requestId === lastAssistantRequestId && lastAssistantIdx >= 0) {
+          messages[lastAssistantIdx] = {
+            role: "assistant",
+            content: text || void 0,
+            toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+          };
+          registerPendingToolCalls(toolCalls, lastAssistantIdx, pendingToolCalls);
+        } else {
+          if (text || toolCalls.length > 0) {
+            lastAssistantIdx = messages.length;
+            messages.push({
+              role: "assistant",
+              content: text || void 0,
+              toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+            });
+            registerPendingToolCalls(toolCalls, lastAssistantIdx, pendingToolCalls);
+          }
+        }
+        lastAssistantRequestId = event.requestId;
+        break;
+      }
+    }
+  }
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  for (const usage of usageByRequestId.values()) {
+    totalInputTokens += Number(usage.input_tokens ?? 0);
+    totalOutputTokens += Number(usage.output_tokens ?? 0);
+  }
+  const hasUsage = usageByRequestId.size > 0;
+  let durationMs;
+  if (startTimestamp && endTimestamp) {
+    durationMs = new Date(endTimestamp).getTime() - new Date(startTimestamp).getTime();
+  }
+  const source = {
+    provider: "claude",
+    sessionId,
+    projectPath,
+    startedAt: startTimestamp,
+    model
+  };
+  return {
+    messages,
+    source,
+    tokenUsage: hasUsage ? { input: totalInputTokens, output: totalOutputTokens } : void 0,
+    durationMs,
+    costUsd: null
+  };
+}
+function registerPendingToolCalls(toolCalls, msgIdx, pending) {
+  for (let i = 0; i < toolCalls.length; i++) {
+    const id = toolCalls[i].id;
+    if (id) {
+      pending.set(id, { msgIdx, toolIdx: i });
+    }
+  }
+}
+function extractTextContent(content) {
+  if (content === void 0 || content === null) return void 0;
+  if (typeof content === "string") return content;
+  const textParts = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text) {
+      textParts.push(block.text);
+    }
+  }
+  return textParts.length > 0 ? textParts.join("") : void 0;
+}
+function extractAssistantContent(content) {
+  if (content === void 0 || content === null) {
+    return { text: void 0, toolCalls: [] };
+  }
+  if (typeof content === "string") {
+    return { text: content, toolCalls: [] };
+  }
+  const textParts = [];
+  const toolCalls = [];
+  for (const block of content) {
+    switch (block.type) {
+      case "text":
+        if (block.text) textParts.push(block.text);
+        break;
+      case "tool_use":
+        if (block.name) {
+          toolCalls.push(
+            normalizeToolCall("claude", {
+              tool: block.name,
+              input: block.input,
+              id: block.id
+            })
+          );
+        }
+        break;
+    }
+  }
+  return {
+    text: textParts.length > 0 ? textParts.join("") : void 0,
+    toolCalls
+  };
+}
+function extractToolResultContent(content) {
+  if (content === void 0 || content === null) return void 0;
+  if (typeof content === "string") return content;
+  const parts = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text) {
+      parts.push(block.text);
+    }
+  }
+  return parts.length > 0 ? parts.join("") : void 0;
+}
+function parseCodexSession(jsonl) {
+  const messages = [];
+  let sessionId = "";
+  let cwd;
+  let model;
+  let version;
+  let startTimestamp;
+  let endTimestamp;
+  const pendingCalls = /* @__PURE__ */ new Map();
+  const lines = jsonl.split("\n").filter((l) => l.trim().length > 0);
+  for (const line of lines) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!entry.type) continue;
+    if (entry.timestamp) {
+      if (!startTimestamp) startTimestamp = entry.timestamp;
+      endTimestamp = entry.timestamp;
+    }
+    const payload = entry.payload ?? {};
+    switch (entry.type) {
+      case "session_meta": {
+        sessionId = String(payload.id ?? "");
+        cwd = payload.cwd ? String(payload.cwd) : void 0;
+        version = payload.cli_version ? String(payload.cli_version) : void 0;
+        if (payload.model && !model) {
+          model = String(payload.model);
+        }
+        break;
+      }
+      case "turn_context": {
+        if (payload.model && !model) {
+          model = String(payload.model);
+        }
+        if (payload.cwd && !cwd) {
+          cwd = String(payload.cwd);
+        }
+        break;
+      }
+      case "response_item": {
+        const itemType = String(payload.type ?? "");
+        const role = String(payload.role ?? "");
+        switch (itemType) {
+          case "message": {
+            if (role === "developer") break;
+            const content = extractResponseItemContent(payload.content);
+            if (role === "user" && content) {
+              messages.push({ role: "user", content });
+            } else if (role === "assistant" && content) {
+              messages.push({ role: "assistant", content });
+            }
+            break;
+          }
+          case "function_call": {
+            const toolName = String(payload.name ?? "");
+            const callId = String(payload.call_id ?? "");
+            let input;
+            if (typeof payload.arguments === "string") {
+              try {
+                input = JSON.parse(payload.arguments);
+              } catch {
+                input = payload.arguments;
+              }
+            } else {
+              input = payload.arguments;
+            }
+            const toolCall = normalizeToolCall("codex", {
+              tool: toolName,
+              input,
+              id: callId
+            });
+            const msgIdx = messages.length;
+            messages.push({
+              role: "assistant",
+              toolCalls: [toolCall]
+            });
+            if (callId) {
+              pendingCalls.set(callId, { msgIdx, toolIdx: 0 });
+            }
+            break;
+          }
+          case "custom_tool_call": {
+            const toolName = String(payload.name ?? "");
+            const callId = String(payload.call_id ?? "");
+            let input;
+            if (typeof payload.arguments === "string") {
+              try {
+                input = JSON.parse(payload.arguments);
+              } catch {
+                input = payload.arguments;
+              }
+            } else {
+              input = payload.arguments;
+            }
+            const toolCall = normalizeToolCall("codex", {
+              tool: toolName,
+              input,
+              id: callId
+            });
+            const msgIdx = messages.length;
+            messages.push({
+              role: "assistant",
+              toolCalls: [toolCall]
+            });
+            if (callId) {
+              pendingCalls.set(callId, { msgIdx, toolIdx: 0 });
+            }
+            break;
+          }
+          case "function_call_output":
+          case "custom_tool_call_output": {
+            const callId = String(payload.call_id ?? "");
+            const pending = pendingCalls.get(callId);
+            if (pending) {
+              const existingMsg = messages[pending.msgIdx];
+              const existingCalls = [...existingMsg.toolCalls ?? []];
+              existingCalls[pending.toolIdx] = {
+                ...existingCalls[pending.toolIdx],
+                output: payload.output
+              };
+              messages[pending.msgIdx] = { ...existingMsg, toolCalls: existingCalls };
+              pendingCalls.delete(callId);
+            }
+            break;
+          }
+          // Skip reasoning blocks (thinking tokens)
+          case "reasoning":
+            break;
+        }
+        break;
+      }
+    }
+  }
+  let durationMs;
+  if (startTimestamp && endTimestamp) {
+    durationMs = new Date(endTimestamp).getTime() - new Date(startTimestamp).getTime();
+  }
+  const source = {
+    provider: "codex",
+    sessionId,
+    cwd,
+    startedAt: startTimestamp,
+    model,
+    version
+  };
+  return {
+    messages,
+    source,
+    // Codex rollout files don't include token counts (only rate limit info)
+    tokenUsage: void 0,
+    durationMs,
+    costUsd: null
+  };
+}
+function extractResponseItemContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return void 0;
+  const parts = [];
+  for (const block of content) {
+    if (typeof block === "object" && block !== null) {
+      const b = block;
+      if (typeof b.text === "string") {
+        parts.push(b.text);
+      }
+    }
+  }
+  return parts.length > 0 ? parts.join("") : void 0;
+}
+var DEFAULT_SESSIONS_DIR = () => path6.join(homedir(), ".codex", "sessions");
+async function discoverCodexSessions(opts) {
+  const sessionsDir = opts?.sessionsDir ?? DEFAULT_SESSIONS_DIR();
+  const limit = opts?.latest ? 1 : opts?.limit ?? 10;
+  const sessions = [];
+  let yearDirs;
+  try {
+    yearDirs = await readdir2(sessionsDir);
+  } catch {
+    return [];
+  }
+  for (const year of yearDirs) {
+    const yearPath = path6.join(sessionsDir, year);
+    let monthDirs;
+    try {
+      monthDirs = await readdir2(yearPath);
+    } catch {
+      continue;
+    }
+    for (const month of monthDirs) {
+      const monthPath = path6.join(yearPath, month);
+      let dayDirs;
+      try {
+        dayDirs = await readdir2(monthPath);
+      } catch {
+        continue;
+      }
+      for (const day of dayDirs) {
+        if (opts?.date) {
+          const dirDate = `${year}-${month}-${day}`;
+          if (dirDate !== opts.date) continue;
+        }
+        const dayPath = path6.join(monthPath, day);
+        let files;
+        try {
+          files = await readdir2(dayPath);
+        } catch {
+          continue;
+        }
+        for (const file of files) {
+          if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
+          const filePath = path6.join(dayPath, file);
+          const nameWithoutExt = file.replace(/\.jsonl$/, "");
+          const parts = nameWithoutExt.split("-");
+          const sessionId = parts.length >= 6 ? parts.slice(-5).join("-") : nameWithoutExt;
+          let updatedAt;
+          try {
+            const fileStat = await stat2(filePath);
+            updatedAt = fileStat.mtime;
+          } catch {
+            updatedAt = /* @__PURE__ */ new Date(0);
+          }
+          sessions.push({ sessionId, filePath, filename: file, updatedAt });
+        }
+      }
+    }
+  }
+  sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+  return sessions.slice(0, limit);
+}
+var DEFAULT_PROJECTS_DIR = () => path7.join(homedir2(), ".claude", "projects");
+function encodeProjectPath(projectPath) {
+  return projectPath.replace(/\//g, "-");
+}
+async function discoverClaudeSessions(opts) {
+  const projectsDir = opts?.projectsDir ?? DEFAULT_PROJECTS_DIR();
+  const limit = opts?.latest ? 1 : opts?.limit ?? 10;
+  let projectDirs;
+  try {
+    projectDirs = await readdir3(projectsDir);
+  } catch {
+    return [];
+  }
+  if (opts?.projectPath) {
+    const encoded = encodeProjectPath(opts.projectPath);
+    projectDirs = projectDirs.filter((dir) => dir === encoded || dir.includes(encoded));
+  }
+  const sessions = [];
+  for (const projectDir of projectDirs) {
+    const dirPath = path7.join(projectsDir, projectDir);
+    let entries;
+    try {
+      entries = await readdir3(dirPath);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".jsonl")) continue;
+      const sessionId = entry.replace(/\.jsonl$/, "");
+      if (opts?.sessionId && sessionId !== opts.sessionId) continue;
+      const filePath = path7.join(dirPath, entry);
+      let updatedAt;
+      try {
+        const fileStat = await stat3(filePath);
+        updatedAt = fileStat.mtime;
+      } catch {
+        updatedAt = /* @__PURE__ */ new Date(0);
+      }
+      sessions.push({
+        sessionId,
+        filePath,
+        projectDir,
+        updatedAt
+      });
+    }
+  }
+  sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+  return sessions.slice(0, limit);
+}
+function toTranscriptJsonLines(entry, options) {
+  const source = {
+    provider: entry.source.provider,
+    session_id: entry.source.sessionId,
+    model: entry.source.model,
+    timestamp: entry.source.startedAt,
+    git_branch: entry.source.gitBranch,
+    cwd: entry.source.cwd ?? entry.source.projectPath,
+    version: entry.source.version
+  };
+  const transcriptTokenUsage = entry.tokenUsage ? {
+    input: entry.tokenUsage.input,
+    output: entry.tokenUsage.output,
+    cached: entry.tokenUsage.cached,
+    reasoning: entry.tokenUsage.reasoning
+  } : void 0;
+  const testId = options?.testId ?? entry.source.sessionId;
+  const target = options?.target ?? entry.source.provider;
+  return entry.messages.map((message, index) => ({
+    test_id: testId,
+    target,
+    message_index: index,
+    ...toSnakeCaseDeep(message),
+    transcript_token_usage: transcriptTokenUsage,
+    transcript_duration_ms: entry.durationMs,
+    transcript_cost_usd: entry.costUsd,
+    source
+  }));
+}
+function buildReplayMessage(line) {
+  const camelCased = toCamelCaseDeep(line);
+  return {
+    role: camelCased.role,
+    name: camelCased.name,
+    content: camelCased.content,
+    toolCalls: camelCased.toolCalls,
+    startTime: camelCased.startTime,
+    endTime: camelCased.endTime,
+    durationMs: camelCased.durationMs,
+    metadata: camelCased.metadata,
+    tokenUsage: camelCased.tokenUsage
+  };
+}
+function groupTranscriptJsonLines(lines) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const existing = grouped.get(line.test_id);
+    const source = {
+      provider: line.source.provider,
+      sessionId: line.source.session_id,
+      startedAt: line.source.timestamp,
+      model: line.source.model,
+      gitBranch: line.source.git_branch,
+      cwd: line.source.cwd,
+      version: line.source.version
+    };
+    const transcriptTokenUsage = line.transcript_token_usage ? {
+      input: line.transcript_token_usage.input,
+      output: line.transcript_token_usage.output,
+      cached: line.transcript_token_usage.cached,
+      reasoning: line.transcript_token_usage.reasoning
+    } : void 0;
+    if (existing) {
+      existing.messages.push({ index: line.message_index, message: buildReplayMessage(line) });
+      continue;
+    }
+    grouped.set(line.test_id, {
+      target: line.target,
+      tokenUsage: transcriptTokenUsage,
+      durationMs: line.transcript_duration_ms,
+      costUsd: line.transcript_cost_usd,
+      source,
+      messages: [{ index: line.message_index, message: buildReplayMessage(line) }]
+    });
+  }
+  return [...grouped.entries()].map(([testId, entry]) => ({
+    testId,
+    target: entry.target,
+    tokenUsage: entry.tokenUsage,
+    durationMs: entry.durationMs,
+    costUsd: entry.costUsd,
+    source: entry.source,
+    messages: entry.messages.sort((first, second) => first.index - second.index).map((item) => item.message)
+  }));
+}
+async function readTranscriptJsonl(filePath) {
+  const text = await readFile3(filePath, "utf8");
+  return text.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+}
+async function readTranscriptFile(filePath) {
+  return readFile3(filePath, "utf8");
+}
+var TranscriptProvider = class _TranscriptProvider {
+  id;
+  kind = "transcript";
+  targetName;
+  entries;
+  cursor = 0;
+  constructor(targetName, entries) {
+    this.targetName = targetName;
+    this.id = `transcript:${targetName}`;
+    this.entries = entries;
+  }
+  /**
+   * Create a TranscriptProvider from a JSONL file path.
+   */
+  static async fromFile(filePath) {
+    const lines = await readTranscriptJsonl(filePath);
+    if (lines.length === 0) {
+      throw new Error(`Transcript file is empty: ${filePath}`);
+    }
+    const entries = groupTranscriptJsonLines(lines);
+    const providerName = entries[0]?.source.provider ?? "transcript";
+    return new _TranscriptProvider(providerName, entries);
+  }
+  get lineCount() {
+    return this.entries.length;
+  }
+  async invoke(_request) {
+    if (this.cursor >= this.entries.length) {
+      throw new Error(
+        `Transcript exhausted: ${this.entries.length} entr${this.entries.length === 1 ? "y" : "ies"} available but ${this.cursor + 1} invocations attempted. Each transcript entry maps to one test case.`
+      );
+    }
+    const entry = this.entries[this.cursor++];
+    return {
+      output: entry.messages,
+      tokenUsage: entry.tokenUsage ? {
+        input: entry.tokenUsage.input,
+        output: entry.tokenUsage.output,
+        cached: entry.tokenUsage.cached,
+        reasoning: entry.tokenUsage.reasoning
+      } : void 0,
+      durationMs: entry.durationMs,
+      costUsd: entry.costUsd ?? void 0,
+      startTime: entry.source.startedAt
+    };
+  }
+};
+function createAgentKernel() {
+  return { status: "stub" };
+}
+
+export {
+  transpileEvalYaml,
+  transpileEvalYamlFile,
+  getOutputFilenames,
+  defineConfig,
+  loadTsConfig,
+  generateRubrics,
+  scanRepoDeps,
+  ResponseCache,
+  shouldEnableCache,
+  shouldSkipCacheForTemperature,
+  normalizeResultsExportConfig,
+  resolveResultsRepoUrl,
+  getResultsRepoCachePaths,
+  ensureResultsRepoClone,
+  getResultsRepoStatus,
+  syncResultsRepo,
+  checkoutResultsRepoBranch,
+  prepareResultsRepoBranch,
+  stageResultsArtifacts,
+  resolveResultsRepoRunsDir,
+  directorySizeBytes,
+  commitAndPushResultsBranch,
+  pushResultsRepoBranch,
+  createDraftResultsPr,
+  getBenchmarksRegistryPath,
+  loadBenchmarkRegistry,
+  saveBenchmarkRegistry,
+  deriveBenchmarkId,
+  addBenchmark,
+  removeBenchmark,
+  getBenchmark,
+  touchBenchmark,
+  discoverBenchmarks,
+  trimBaselineResult,
+  DEFAULT_CATEGORY,
+  deriveCategory,
+  OTEL_BACKEND_PRESETS,
+  OtelTraceExporter,
+  OtelStreamingObserver,
+  parseClaudeSession,
+  parseCodexSession,
+  discoverCodexSessions,
+  discoverClaudeSessions,
+  toTranscriptJsonLines,
+  groupTranscriptJsonLines,
+  readTranscriptJsonl,
+  readTranscriptFile,
+  TranscriptProvider,
+  createAgentKernel
+};
+//# sourceMappingURL=chunk-R2QDYORI.js.map