@forwardimpact/libeval 0.1.63 → 0.1.65

package/src/commands/trace.js

@@ -1,9 +1,20 @@
-import { join, dirname } from "node:path";
+import { join, dirname, basename } from "node:path";
 import { isoTimestamp } from "@forwardimpact/libutil";
-import { createTraceCollector } from "@forwardimpact/libeval";
+import { createTraceCollector, sumTraceCost } from "@forwardimpact/libeval";
 import { createTraceQuery } from "../trace-query.js";
 import { createTraceGitHub } from "../trace-github.js";
 import { stripSignatures } from "../signature-filter.js";
+import { runOver, aggregate, compareTwo } from "../trace-multi.js";
+import {
+  renderToolCalls,
+  renderCommands,
+  renderPaths,
+  renderCompare,
+  renderStatsByTool,
+  renderStatsSummary,
+  renderSearch,
+  renderDefault,
+} from "../trace-render.js";
 
 // Every handler receives a libcli `InvocationContext`:
 //   ctx.options — parsed flag values (`cli.parse().values`)
@@ -12,6 +23,58 @@ import { stripSignatures } from "../signature-filter.js";
 // Handlers read/write the filesystem and stdout exclusively through
 // `ctx.deps.runtime` and return `{ ok: true }` on success.
 
+/** Characters whose presence in a `--file` value marks it as a glob. */
+const GLOB_CHARS = /[*?[\]{}]/;
+
+/**
+ * Resolve the cross-trace `--file` option (`ctx.options.file`) into a sorted
+ * flat list of file paths. A literal path passes through; a value carrying
+ * glob metacharacters expands via `runtime.fsSync.globSync`. The literal-path
+ * fast path means the common single-file and shell-pre-expanded cases never
+ * touch `globSync`.
+ * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime
+ * @param {import("@forwardimpact/libcli").InvocationContext} ctx
+ * @returns {string[]}
+ */
+function resolveFiles(runtime, ctx) {
+  const raw = ctx.options.file;
+  const values = raw === undefined ? [] : Array.isArray(raw) ? raw : [raw];
+  const out = [];
+  for (const value of values) {
+    if (GLOB_CHARS.test(value)) {
+      out.push(...runtime.fsSync.globSync(value));
+    } else {
+      out.push(value);
+    }
+  }
+  return out.sort();
+}
+
+/**
+ * Emit a query result for a cross-trace verb: under `--format json` write the
+ * JSON payload (single-object verbs unwrap when single-file so the envelope
+ * deep-equals today's output); otherwise render text to stdout. Source
+ * attribution is the renderer's job, gated by `multi`.
+ * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime
+ * @param {object|object[]} result
+ * @param {Function} renderer
+ * @param {import("@forwardimpact/libcli").InvocationContext} ctx
+ * @param {boolean} multi
+ * @param {boolean} [unwrap=false] - Single-object verb wrapped in a one-element array.
+ */
+function emit(runtime, result, renderer, ctx, multi, unwrap = false) {
+  if (ctx.options.format === "json") {
+    const payload = unwrap && !multi ? result[0] : result;
+    writeJSON(runtime, payload, ctx.options);
+    return;
+  }
+  const text = renderer(result, {
+    multi,
+    signatures: !!ctx.options.signatures,
+  });
+  runtime.proc.stdout.write(text + "\n");
+}
+
 // --- GitHub commands ---
 
 /**
@@ -26,11 +89,33 @@ export async function runRunsCommand(ctx) {
     runtime,
   });
   const lookback = ctx.options.lookback ?? "7d";
-  const runs = await gh.listRuns({ pattern: ctx.args.pattern, lookback });
+  const runs = await gh.listRuns({
+    pattern: ctx.args.pattern,
+    lookback,
+    participant: ctx.options.participant,
+  });
   writeJSON(runtime, runs, ctx.options);
   return { ok: true };
 }
 
+/**
+ * Resolve a participant's lane trace for a known run id in one keyed lookup.
+ * @param {import("@forwardimpact/libcli").InvocationContext} ctx
+ */
+export async function runFindCommand(ctx) {
+  const { runtime, config } = ctx.deps;
+  const gh = await createTraceGitHub({
+    token: config.ghToken(),
+    repo: ctx.options.repo,
+    runtime,
+  });
+  const result = await gh.findByKey(ctx.args["run-id"], ctx.args.participant, {
+    dir: ctx.options.dir,
+  });
+  writeJSON(runtime, result, ctx.options);
+  return { ok: true };
+}
+
 /**
  * Download a trace artifact and auto-convert to structured JSON.
  * @param {import("@forwardimpact/libcli").InvocationContext} ctx
@@ -72,49 +157,78 @@ export async function runDownloadCommand(ctx) {
 
 // --- Query commands ---
 
+/**
+ * Build the injected loader the orchestrator uses (wires the runtime IO seam).
+ * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime
+ * @returns {(file: string) => import("../trace-query.js").TraceQuery}
+ */
+function loader(runtime) {
+  return (file) => loadTrace(runtime, file);
+}
+
+/** No-files error envelope for a cross-trace verb. */
+function noFiles(verb) {
+  return { ok: false, code: 1, error: `${verb}: no files (use --file)` };
+}
+
 /** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
 export async function runOverviewCommand(ctx) {
   const { runtime } = ctx.deps;
-  writeJSON(runtime, loadTrace(runtime, ctx.args.file).overview(), ctx.options);
+  const files = resolveFiles(runtime, ctx);
+  if (files.length === 0) return noFiles("overview");
+  const result = runOver(files, (tq) => [tq.overview()], loader(runtime));
+  emit(runtime, result, renderDefault, ctx, files.length > 1, true);
   return { ok: true };
 }
 
 /** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
 export async function runCountCommand(ctx) {
   const { runtime } = ctx.deps;
-  runtime.proc.stdout.write(
-    String(loadTrace(runtime, ctx.args.file).count()) + "\n",
+  const files = resolveFiles(runtime, ctx);
+  if (files.length === 0) return noFiles("count");
+  const multi = files.length > 1;
+  const result = runOver(
+    files,
+    (tq) => [{ count: tq.count() }],
+    loader(runtime),
   );
+  for (const r of result) {
+    const prefix = multi && r.source ? `${r.source}:` : "";
+    runtime.proc.stdout.write(`${prefix}${r.count}\n`);
+  }
   return { ok: true };
 }
 
 /** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
 export async function runBatchCommand(ctx) {
   const { runtime } = ctx.deps;
-  writeJSON(
-    runtime,
-    loadTrace(runtime, ctx.args.file).batch(
-      parseInt(ctx.args.from, 10),
-      parseInt(ctx.args.to, 10),
-    ),
-    ctx.options,
+  const result = loadTrace(runtime, ctx.args.file).batch(
+    parseInt(ctx.args.from, 10),
+    parseInt(ctx.args.to, 10),
   );
+  emit(runtime, result, renderDefault, ctx, false);
   return { ok: true };
 }
 
 /** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
 export async function runHeadCommand(ctx) {
   const { runtime } = ctx.deps;
-  const n = ctx.args.n ? parseInt(ctx.args.n, 10) : 10;
-  writeJSON(runtime, loadTrace(runtime, ctx.args.file).head(n), ctx.options);
+  const files = resolveFiles(runtime, ctx);
+  if (files.length === 0) return noFiles("head");
+  const n = ctx.options.lines ? parseInt(ctx.options.lines, 10) : 10;
+  const result = runOver(files, (tq) => tq.head(n), loader(runtime));
+  emit(runtime, result, renderDefault, ctx, files.length > 1);
   return { ok: true };
 }
 
 /** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
 export async function runTailCommand(ctx) {
   const { runtime } = ctx.deps;
-  const n = ctx.args.n ? parseInt(ctx.args.n, 10) : 10;
-  writeJSON(runtime, loadTrace(runtime, ctx.args.file).tail(n), ctx.options);
+  const files = resolveFiles(runtime, ctx);
+  if (files.length === 0) return noFiles("tail");
+  const n = ctx.options.lines ? parseInt(ctx.options.lines, 10) : 10;
+  const result = runOver(files, (tq) => tq.tail(n), loader(runtime));
+  emit(runtime, result, renderDefault, ctx, files.length > 1);
   return { ok: true };
 }
 
@@ -124,105 +238,252 @@ export async function runSearchCommand(ctx) {
   const limit = ctx.options.limit ? parseInt(ctx.options.limit, 10) : 50;
   const context = ctx.options.context ? parseInt(ctx.options.context, 10) : 0;
   const full = ctx.options.full ?? false;
-  writeJSON(
-    runtime,
-    loadTrace(runtime, ctx.args.file).search(ctx.args.pattern, {
-      limit,
-      context,
-      full,
-    }),
-    ctx.options,
-  );
+  const result = loadTrace(runtime, ctx.args.file).search(ctx.args.pattern, {
+    limit,
+    context,
+    full,
+  });
+  emit(runtime, result, renderSearch, ctx, false);
   return { ok: true };
 }
 
 /** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
 export async function runToolsCommand(ctx) {
   const { runtime } = ctx.deps;
-  writeJSON(
-    runtime,
-    loadTrace(runtime, ctx.args.file).toolFrequency(),
-    ctx.options,
+  const files = resolveFiles(runtime, ctx);
+  if (files.length === 0) return noFiles("tools");
+  const result = aggregate(
+    files,
+    (tq) => tq.toolFrequency(),
+    (r) => r.tool,
+    loader(runtime),
   );
+  emit(runtime, result, renderDefault, ctx, files.length > 1);
   return { ok: true };
 }
 
 /** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
 export async function runToolCommand(ctx) {
   const { runtime } = ctx.deps;
-  writeJSON(
-    runtime,
-    loadTrace(runtime, ctx.args.file).tool(ctx.args.name),
-    ctx.options,
-  );
+  const result = loadTrace(runtime, ctx.args.file).tool(ctx.args.name);
+  emit(runtime, result, renderDefault, ctx, false);
   return { ok: true };
 }
 
 /** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
 export async function runErrorsCommand(ctx) {
   const { runtime } = ctx.deps;
-  writeJSON(runtime, loadTrace(runtime, ctx.args.file).errors(), ctx.options);
+  const files = resolveFiles(runtime, ctx);
+  if (files.length === 0) return noFiles("errors");
+  const result = runOver(files, (tq) => tq.errors(), loader(runtime));
+  emit(runtime, result, renderDefault, ctx, files.length > 1);
   return { ok: true };
 }
 
 /** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
 export async function runReasoningCommand(ctx) {
   const { runtime } = ctx.deps;
+  const files = resolveFiles(runtime, ctx);
+  if (files.length === 0) return noFiles("reasoning");
   const from = ctx.options.from ? parseInt(ctx.options.from, 10) : undefined;
   const to = ctx.options.to ? parseInt(ctx.options.to, 10) : undefined;
-  writeJSON(
-    runtime,
-    loadTrace(runtime, ctx.args.file).reasoning({ from, to }),
-    ctx.options,
+  const result = runOver(
+    files,
+    (tq) => tq.reasoning({ from, to }),
+    loader(runtime),
   );
+  emit(runtime, result, renderDefault, ctx, files.length > 1);
   return { ok: true };
 }
 
 /** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
 export async function runTimelineCommand(ctx) {
   const { runtime } = ctx.deps;
-  const lines = loadTrace(runtime, ctx.args.file).timeline();
-  runtime.proc.stdout.write(lines.join("\n") + "\n");
+  const files = resolveFiles(runtime, ctx);
+  if (files.length === 0) return noFiles("timeline");
+  const multi = files.length > 1;
+  for (const file of files) {
+    if (multi) runtime.proc.stdout.write(`# ${basename(file)}\n`);
+    runtime.proc.stdout.write(
+      loadTrace(runtime, file).timeline().join("\n") + "\n",
+    );
+  }
   return { ok: true };
 }
 
+/** Select the per-file `stats` query for the active flag combination. */
+function statsQuery(ctx) {
+  if (ctx.options.summary) return (tq) => tq.statsSummary();
+  if (ctx.options["by-tool"]) return (tq) => tq.statsByTool();
+  return (tq) => tq.stats();
+}
+
+/** Select the `stats` text renderer for the active flag combination. */
+function statsRenderer(ctx) {
+  if (ctx.options.summary) return renderStatsSummary;
+  if (ctx.options["by-tool"]) return renderStatsByTool;
+  return (result) => renderDefault(result);
+}
+
 /** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
 export async function runStatsCommand(ctx) {
   const { runtime } = ctx.deps;
-  writeJSON(runtime, loadTrace(runtime, ctx.args.file).stats(), ctx.options);
+  const files = resolveFiles(runtime, ctx);
+  if (files.length === 0) return noFiles("stats");
+  const multi = files.length > 1;
+  const query = statsQuery(ctx);
+  // stats results are per-file objects; one block per file (no cross-file sum),
+  // tagged with source only when multi-file.
+  const results = files.map((file) => ({
+    result: query(loadTrace(runtime, file)),
+    source: multi ? basename(file) : undefined,
+  }));
+
+  if (ctx.options.format === "json") {
+    const payloads = results.map((r) =>
+      multi ? { ...r.result, source: r.source } : r.result,
+    );
+    writeJSON(runtime, multi ? payloads : payloads[0], ctx.options);
+    return { ok: true };
+  }
+
+  const render = statsRenderer(ctx);
+  const blocks = results.map((r) =>
+    multi ? `# ${r.source}\n${render(r.result)}` : render(r.result),
+  );
+  runtime.proc.stdout.write(blocks.join("\n") + "\n");
+  return { ok: true };
+}
+
+/**
+ * Total run cost across every participant (agent, supervisor, judge, and any
+ * named profile), summed from each `result` event in the trace and attributed
+ * per source. The combined trace from a supervised, facilitated, or discuss
+ * session already interleaves all participants, so one file yields the whole
+ * run's spend. Default output is `{totalCostUsd, bySource}` JSON; `--markdown`
+ * emits a GitHub-flavored block to redirect into `$GITHUB_STEP_SUMMARY`.
+ *
+ * @param {import("@forwardimpact/libcli").InvocationContext} ctx
+ */
+export async function runCostCommand(ctx) {
+  const { runtime } = ctx.deps;
+  const cost = computeTraceCost(
+    runtime.fsSync.readFileSync(ctx.args.file, "utf8"),
+  );
+  if (ctx.options.markdown) {
+    runtime.proc.stdout.write(renderCostMarkdown(cost));
+  } else {
+    writeJSON(runtime, cost, ctx.options);
+  }
   return { ok: true };
 }
 
+/**
+ * Render a cost summary as a GitHub-flavored markdown block for a CI step
+ * summary: a headline total plus a per-participant table (descending).
+ * @param {{totalCostUsd: number, bySource: Record<string, number>}} cost
+ * @returns {string}
+ */
+function renderCostMarkdown(cost) {
+  const lines = [
+    `### 💰 Run cost: $${cost.totalCostUsd.toFixed(4)}`,
+    "",
+    "Summed across every participant (agent, supervisor, judge, named profiles).",
+  ];
+  const sources = Object.entries(cost.bySource).sort((a, b) => b[1] - a[1]);
+  if (sources.length > 0) {
+    lines.push("", "| Participant | Cost (USD) |", "| --- | --- |");
+    for (const [source, usd] of sources) {
+      lines.push(`| ${source} | ${usd.toFixed(4)} |`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+
 /** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
 export async function runInitCommand(ctx) {
   const { runtime } = ctx.deps;
-  writeJSON(runtime, loadTrace(runtime, ctx.args.file).init(), ctx.options);
+  const files = resolveFiles(runtime, ctx);
+  if (files.length === 0) return noFiles("init");
+  const result = runOver(files, (tq) => [tq.init()], loader(runtime));
+  emit(runtime, result, renderDefault, ctx, files.length > 1, true);
   return { ok: true };
 }
 
 /** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
 export async function runTurnCommand(ctx) {
   const { runtime } = ctx.deps;
-  writeJSON(
-    runtime,
-    loadTrace(runtime, ctx.args.file).turn(parseInt(ctx.args.index, 10)),
-    ctx.options,
+  const result = loadTrace(runtime, ctx.args.file).turn(
+    parseInt(ctx.args.index, 10),
   );
+  emit(runtime, result, renderDefault, ctx, false);
   return { ok: true };
 }
 
 /** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
 export async function runFilterCommand(ctx) {
   const { runtime } = ctx.deps;
+  const files = resolveFiles(runtime, ctx);
+  if (files.length === 0) return noFiles("filter");
   const opts = {};
   if (ctx.options.role) opts.role = ctx.options.role;
   if (ctx.options.tool) opts.toolName = ctx.options.tool;
   if (ctx.options.error) opts.isError = true;
-  writeJSON(
-    runtime,
-    loadTrace(runtime, ctx.args.file).filter(opts),
-    ctx.options,
+  const result = runOver(files, (tq) => tq.filter(opts), loader(runtime));
+  emit(runtime, result, renderDefault, ctx, files.length > 1);
+  return { ok: true };
+}
+
+// --- Aggregator verbs (tool-calls, commands, paths, compare) ---
+
+/** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
+export async function runToolCallsCommand(ctx) {
+  const { runtime } = ctx.deps;
+  const files = resolveFiles(runtime, ctx);
+  if (files.length === 0) return noFiles("tool-calls");
+  const result = runOver(files, (tq) => tq.toolCalls(), loader(runtime));
+  emit(runtime, result, renderToolCalls, ctx, files.length > 1);
+  return { ok: true };
+}
+
+/** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
+export async function runCommandsCommand(ctx) {
+  const { runtime } = ctx.deps;
+  const files = resolveFiles(runtime, ctx);
+  if (files.length === 0) return noFiles("commands");
+  const result = runOver(
+    files,
+    (tq) => tq.commands(ctx.options.match),
+    loader(runtime),
+  );
+  emit(runtime, result, renderCommands, ctx, files.length > 1);
+  return { ok: true };
+}
+
+/** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
+export async function runPathsCommand(ctx) {
+  const { runtime } = ctx.deps;
+  const files = resolveFiles(runtime, ctx);
+  if (files.length === 0) return noFiles("paths");
+  const result = aggregate(
+    files,
+    (tq) => tq.paths(ctx.options.prefix),
+    (r) => r.path,
+    loader(runtime),
   );
+  emit(runtime, result, renderPaths, ctx, files.length > 1);
+  return { ok: true };
+}
+
+/** @param {import("@forwardimpact/libcli").InvocationContext} ctx */
+export async function runCompareCommand(ctx) {
+  const { runtime } = ctx.deps;
+  const result = compareTwo(
+    ctx.args["file-a"],
+    ctx.args["file-b"],
+    loader(runtime),
+  );
+  emit(runtime, result, renderCompare, ctx, false);
   return { ok: true };
 }
 
@@ -309,13 +570,32 @@ function parseBuckets(content) {
 
 // --- Shared helpers ---
 
+/**
+ * Compute total + per-source cost from raw file content. A structured JSON
+ * trace (from `fit-trace download`) carries its total in `summary.totalCostUsd`
+ * but no per-source split; raw NDJSON is summed via `sumTraceCost`.
+ * @param {string} content - Raw file content (structured JSON or NDJSON).
+ * @returns {{totalCostUsd: number, bySource: Record<string, number>}}
+ */
+function computeTraceCost(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed && typeof parsed.summary?.totalCostUsd === "number") {
+      return { totalCostUsd: parsed.summary.totalCostUsd, bySource: {} };
+    }
+  } catch {
+    // Not a single JSON object — treat as NDJSON below.
+  }
+  return sumTraceCost(content.split("\n"));
+}
+
 /**
  * Load a trace file. Supports structured JSON and raw NDJSON.
  * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime
  * @param {string} file
  * @returns {import("../trace-query.js").TraceQuery}
  */
-function loadTrace(runtime, file) {
+export function loadTrace(runtime, file) {
   const content = runtime.fsSync.readFileSync(file, "utf8");
 
   try {

package/src/cost.js

@@ -0,0 +1,79 @@
+/**
+ * Cost aggregation over Claude Code NDJSON traces — the single source of
+ * truth for "how much did this run cost, across every participant?".
+ *
+ * The SDK reports the cumulative session cost on each `result` event as
+ * `total_cost_usd`. Supervised, facilitated, and discuss sessions interleave
+ * one runner's events with another's in a single combined trace, wrapping
+ * each in a `{source, seq, event}` envelope; a plain `run` trace carries bare
+ * events with no envelope. A judge runs as its own session in a separate
+ * trace. In every case the rule is the same: sum the `total_cost_usd` of each
+ * `result` event, and keep a per-source breakdown so callers can attribute
+ * spend to the agent, supervisor, judge, or any named participant.
+ *
+ * This mirrors `TraceCollector.handleResult`, which accumulates the same
+ * figure for its summary footer — kept as a standalone pure helper so the
+ * benchmark runner, the callback command, and `fit-trace cost` share one
+ * implementation rather than each re-deriving it (and drifting).
+ */
+
+/** Bucket key for bare (un-enveloped) `run`-mode events: a lone agent session. */
+export const UNSOURCED = "agent";
+
+/**
+ * Sum `total_cost_usd` across every `result` event in an NDJSON trace.
+ *
+ * @param {Iterable<string>} lines - NDJSON lines (e.g. `content.split("\n")`).
+ *   Blank and malformed lines are skipped.
+ * @returns {{totalCostUsd: number, bySource: Record<string, number>}}
+ *   `totalCostUsd` is the sum across all participants; `bySource` maps each
+ *   envelope `source` (or {@link UNSOURCED} for bare events) to its subtotal.
+ */
+export function sumTraceCost(lines) {
+  let totalCostUsd = 0;
+  /** @type {Record<string, number>} */
+  const bySource = {};
+
+  for (const line of lines) {
+    const parsed = parseCostLine(line);
+    if (!parsed) continue;
+    const { source, cost } = parsed;
+    totalCostUsd += cost;
+    bySource[source] = (bySource[source] ?? 0) + cost;
+  }
+
+  return { totalCostUsd, bySource };
+}
+
+/**
+ * Parse a single NDJSON line and return its `result`-event cost contribution,
+ * or null when the line is blank, malformed, not a result event, or carries
+ * no numeric `total_cost_usd`.
+ *
+ * @param {string} line
+ * @returns {{source: string, cost: number} | null}
+ */
+function parseCostLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+
+  let event;
+  try {
+    event = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+
+  // Unwrap the combined-trace envelope {source, seq, event}; bare events
+  // (plain `run` traces) have a `type` and no `source`.
+  let source = UNSOURCED;
+  if (event.event && !event.type && typeof event.source === "string") {
+    source = event.source;
+    event = event.event;
+  }
+
+  if (event.type !== "result") return null;
+  if (typeof event.total_cost_usd !== "number") return null;
+
+  return { source, cost: event.total_cost_usd };
+}

package/src/index.js

@@ -1,11 +1,13 @@
 export { TraceCollector, createTraceCollector } from "./trace-collector.js";
 export { TraceQuery, createTraceQuery } from "./trace-query.js";
+export { sumTraceCost, UNSOURCED } from "./cost.js";
 export { stripSignatures } from "./signature-filter.js";
 export {
   TraceGitHub,
   createTraceGitHub,
   detectRepoSlug,
   parseGitRemote,
+  participantInNames,
   pickTraceArtifact,
 } from "./trace-github.js";
 export { AgentRunner, createAgentRunner } from "./agent-runner.js";