@tangle-network/traces 0.23.0 → 1.0.0

package/dist/chunk-7CBV5RJ2.js

@@ -0,0 +1,535 @@
+import {
+  commandLines,
+  commandTextFromInput,
+  computeSessionFacts
+} from "./chunk-UVE5ANVV.js";
+import {
+  isInheritedSpan,
+  isSubagentSpan,
+  isSynthesizedSpan
+} from "./chunk-TR6O4S4T.js";
+import {
+  appendAll,
+  validateOtlpSpans
+} from "./chunk-NZ5Y7UEL.js";
+import {
+  parseIsoToEpochMs,
+  toolArgumentsFromAttributes
+} from "./chunk-DU534HAX.js";
+
+// src/pipelines.ts
+import { createHash } from "crypto";
+import { basename } from "path";
+import { computeToolUseMetrics } from "@tangle-network/agent-eval";
+import {
+  failureClusterView,
+  stuckLoopView
+} from "@tangle-network/agent-eval/pipelines";
+
+// src/failure-followup.ts
+import { OPENINFERENCE_SPAN_KIND, TOOL_NAME } from "@tangle-network/agent-eval/trace-attributes";
+function argKeyOf(span) {
+  const sha = span.attributes["traces.input.sha256"];
+  if (typeof sha === "string" && sha.length > 0) return `sha:${sha}`;
+  const value = span.attributes["input.value"];
+  if (typeof value === "string" && value.length > 0) return `raw:${value}`;
+  return null;
+}
+function schemeOf(key) {
+  return key.slice(0, key.indexOf(":"));
+}
+var byCallOrder = (a, b) => a.start.localeCompare(b.start) || a.step - b.step;
+function failureFollowUpSequences(spans) {
+  const calls = [];
+  for (const s of spans) {
+    if (s.attributes[OPENINFERENCE_SPAN_KIND] !== "TOOL") continue;
+    const toolName2 = s.attributes[TOOL_NAME];
+    if (typeof toolName2 !== "string" || toolName2.length === 0) continue;
+    calls.push({ span: s, toolName: toolName2, argKey: argKeyOf(s) });
+  }
+  calls.sort(
+    (a, b) => a.span.start_time.localeCompare(b.span.start_time) || (Number(a.span.attributes.step) || 0) - (Number(b.span.attributes.step) || 0)
+  );
+  const sequences = /* @__PURE__ */ new Map();
+  for (const call of calls) {
+    const key = `${call.span.trace_id}|${call.toolName}`;
+    const seq = sequences.get(key);
+    if (seq) seq.push(call);
+    else sequences.set(key, [call]);
+  }
+  const out = [];
+  for (const seq of sequences.values()) {
+    const items = [];
+    for (let i = 0; i < seq.length; i++) {
+      const call = seq[i];
+      if (call.span.status.code !== "ERROR") continue;
+      if (call.span.attributes["traces.expected_blocking"] === true) continue;
+      const followUp = seq[i + 1] ?? null;
+      let kind;
+      if (!followUp) {
+        kind = "none";
+      } else if (call.argKey !== null && followUp.argKey !== null && schemeOf(call.argKey) === schemeOf(followUp.argKey)) {
+        kind = call.argKey === followUp.argKey ? "blind" : "adapted";
+      } else {
+        kind = "args-unknown";
+      }
+      items.push({
+        traceId: call.span.trace_id,
+        toolName: call.toolName,
+        failedSpanId: call.span.span_id,
+        followUpSpanId: followUp?.span.span_id ?? null,
+        kind,
+        followUpSucceeded: !followUp || followUp.span.status.code === "UNSET" ? null : followUp.span.status.code === "OK"
+      });
+    }
+    if (items.length > 0) out.push({ firstStart: seq[0].span.start_time, firstStep: Number(seq[0].span.attributes.step) || 0, items });
+  }
+  return out;
+}
+function failureFollowUpReport(sequences) {
+  const ordered = sequences.map((sequence) => ({ sequence, start: sequence.firstStart, step: sequence.firstStep })).sort(byCallOrder);
+  const items = ordered.flatMap(({ sequence }) => sequence.items);
+  const blindByTool = {};
+  for (const item of items) if (item.kind === "blind") blindByTool[item.toolName] = (blindByTool[item.toolName] ?? 0) + 1;
+  const followedItems = items.filter((item) => item.kind !== "none");
+  return {
+    failures: items.length,
+    followed: followedItems.length,
+    blind: items.filter((item) => item.kind === "blind").length,
+    adapted: items.filter((item) => item.kind === "adapted").length,
+    argsUnknown: items.filter((item) => item.kind === "args-unknown").length,
+    followUpSucceeded: followedItems.filter((item) => item.followUpSucceeded === true).length,
+    blindByTool,
+    items
+  };
+}
+
+// src/runtime-store.ts
+import { InMemoryTraceStore } from "@tangle-network/agent-eval";
+var KIND = {
+  AGENT: "agent",
+  LLM: "llm",
+  TOOL: "tool",
+  CHAIN: "custom",
+  EMBEDDING: "custom",
+  RERANKER: "custom",
+  GUARDRAIL: "custom",
+  PROMPT: "custom",
+  EVALUATOR: "custom",
+  RETRIEVER: "custom",
+  UNKNOWN: "custom"
+};
+async function toRuntimeStore(spans) {
+  const validated = validateOtlpSpans(spans, "runtime store input");
+  const store = new InMemoryTraceStore();
+  const runs = /* @__PURE__ */ new Map();
+  for (const item of validated) {
+    const startedAt = parseIsoToEpochMs(item.start_time);
+    const endedAt = parseIsoToEpochMs(item.end_time);
+    const terminalFailure = item.parent_span_id === null && item.status.code === "ERROR";
+    const current = runs.get(item.trace_id);
+    runs.set(item.trace_id, current ? {
+      startedAt: Math.min(current.startedAt, startedAt),
+      endedAt: Math.max(current.endedAt, endedAt),
+      failed: current.failed || terminalFailure
+    } : { startedAt, endedAt, failed: terminalFailure });
+  }
+  for (const [runId, run] of runs) {
+    await store.appendRun({
+      runId,
+      scenarioId: "session",
+      startedAt: run.startedAt,
+      endedAt: run.endedAt,
+      status: run.failed ? "failed" : "completed"
+    });
+  }
+  for (const s of validated) {
+    const kind = KIND[s.attributes["openinference.span.kind"]] ?? "custom";
+    const startedAt = parseIsoToEpochMs(s.start_time);
+    const endedAt = parseIsoToEpochMs(s.end_time);
+    const attributes = {
+      ...s.attributes,
+      "traces.source.trace_id": s.trace_id,
+      "traces.source.span_id": s.span_id,
+      ...s.parent_span_id === null ? {} : { "traces.source.parent_span_id": s.parent_span_id }
+    };
+    const base = {
+      spanId: runtimeSpanId(s.trace_id, s.span_id),
+      parentSpanId: s.parent_span_id === null ? void 0 : runtimeSpanId(s.trace_id, s.parent_span_id),
+      runId: s.trace_id,
+      name: s.name,
+      startedAt,
+      endedAt,
+      status: s.status.code === "ERROR" ? "error" : s.status.code === "OK" ? "ok" : void 0,
+      error: s.status.message,
+      attributes
+    };
+    const tool = kind === "tool" ? toolArgumentsFromAttributes(s.attributes) : void 0;
+    const span = kind === "tool" ? {
+      ...base,
+      kind: "tool",
+      toolName: String(s.attributes["tool.name"] ?? "tool"),
+      args: tool.args,
+      argsCaptured: tool.argsCaptured,
+      latencyMs: Math.max(0, endedAt - startedAt)
+    } : { ...base, kind };
+    await store.appendSpan(span);
+  }
+  return { store, runIds: [...runs.keys()] };
+}
+function runtimeSpanId(traceId, spanId) {
+  return `${encodeURIComponent(traceId)}:${encodeURIComponent(spanId)}`;
+}
+
+// src/pipelines.ts
+async function tracePipelines(spans, opts) {
+  const { store, runIds } = await toRuntimeStore(spans);
+  const loopEligible = spans.filter((item) => item.attributes["traces.expected_blocking"] !== true);
+  const loopStore = loopEligible.length === spans.length ? store : (await toRuntimeStore(loopEligible)).store;
+  const [stuckLoops, failureClusters, toolUse] = await Promise.all([
+    stuckLoopView(loopStore, { minOccurrences: opts.minLoopOccurrences ?? 3 }),
+    failureClusterView(store),
+    Promise.all(runIds.map((runId) => computeToolUseMetrics(store, runId)))
+  ]);
+  return { stuckLoops, failureClusters, toolUse };
+}
+var clusterKey = (cluster) => `${cluster.failureClass}|${cluster.toolName ?? ""}|${cluster.argPrefix ?? ""}|${cluster.dimension ?? ""}`;
+function createPipelineAccumulator(opts = {}) {
+  const loops = [];
+  let loopRuns = 0;
+  const clusters = /* @__PURE__ */ new Map();
+  let totalFailures = 0;
+  let totalRuns = 0;
+  const toolUse = [];
+  const sequences = [];
+  return {
+    async add(spans) {
+      if (spans.length === 0) return;
+      const groups = /* @__PURE__ */ new Map();
+      for (const span of spans) {
+        const group = groups.get(span.trace_id);
+        if (group) group.push(span);
+        else groups.set(span.trace_id, [span]);
+      }
+      for (const group of groups.values()) {
+        const one = await tracePipelines(group, opts);
+        appendAll(loops, one.stuckLoops.findings);
+        loopRuns += one.stuckLoops.totalRuns;
+        for (const cluster of one.failureClusters.clusters) {
+          const key = clusterKey(cluster);
+          const held = clusters.get(key);
+          if (!held) {
+            clusters.set(key, { ...cluster, scenarioIds: [...cluster.scenarioIds] });
+            continue;
+          }
+          held.runCount += cluster.runCount;
+          for (const id of cluster.scenarioIds) if (!held.scenarioIds.includes(id)) held.scenarioIds.push(id);
+        }
+        totalFailures += one.failureClusters.totalFailures;
+        totalRuns += one.failureClusters.totalRuns;
+        appendAll(toolUse, one.toolUse);
+      }
+      appendAll(sequences, failureFollowUpSequences(spans));
+    },
+    report() {
+      const affected = new Set(loops.map((finding2) => finding2.runId));
+      return {
+        stuckLoops: { findings: [...loops], affectedRunRatio: loopRuns > 0 ? affected.size / loopRuns : 0, totalRuns: loopRuns },
+        failureClusters: { clusters: [...clusters.values()].sort((a, b) => b.runCount - a.runCount), totalFailures, totalRuns },
+        toolUse: [...toolUse],
+        failureFollowUps: failureFollowUpReport(sequences)
+      };
+    }
+  };
+}
+function hash(parts) {
+  return createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
+}
+function asString(value) {
+  if (typeof value === "string" && value.trim()) return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return void 0;
+}
+function spanKind(span) {
+  return asString(span.attributes["openinference.span.kind"])?.toUpperCase() ?? "UNKNOWN";
+}
+function toolName(span) {
+  return asString(span.attributes["tool.name"]) ?? span.name.replace(/^tool\./, "");
+}
+function scriptOf(span) {
+  const input = span.attributes["input.value"];
+  return typeof input === "string" ? commandTextFromInput(input) : void 0;
+}
+function isTool(span) {
+  if (isSynthesizedSpan(span.attributes)) return false;
+  return spanKind(span) === "TOOL" || span.attributes["tool.name"] != null || span.name.startsWith("tool.");
+}
+function isOwnAct(span) {
+  return !isInheritedSpan(span.attributes) && !isSynthesizedSpan(span.attributes) && !isSubagentSpan(span.attributes);
+}
+var PACKAGE_RUNNERS = /* @__PURE__ */ new Set(["pnpm", "npm", "yarn", "bun", "npx", "pnpx", "bunx"]);
+var CHECK_SCRIPT = /^(?:test|tests|vitest|jest|build|typecheck|tsc|lint|check|verify|e2e|ci|gate|signoff|preflight)(?::[\w:-]+)?$/u;
+var CHECK_PROGRAMS = /* @__PURE__ */ new Set(["vitest", "jest", "pytest", "tsc", "eslint", "biome", "mocha", "playwright", "ruff", "mypy", "tox", "bats", "shellcheck", "beelink-gate"]);
+var INTERPRETERS = /* @__PURE__ */ new Set(["python", "python3", "node", "bash", "sh", "zsh", "bun", "deno", "tsx", "ts-node", "ruby"]);
+var CHECK_SCRIPT_FILE = /(?:^|[_.-])(?:test|tests|spec|verify|check|checks|smoke|lint)(?:[_.-]|$)/u;
+var CHECK_SUBCOMMANDS = {
+  cargo: /* @__PURE__ */ new Set(["test", "build", "check", "clippy", "nextest"]),
+  go: /* @__PURE__ */ new Set(["test", "build", "vet"]),
+  make: /* @__PURE__ */ new Set(["test", "check", "build", "lint", "verify"]),
+  forge: /* @__PURE__ */ new Set(["test", "build"]),
+  deno: /* @__PURE__ */ new Set(["test", "check", "lint"]),
+  node: /* @__PURE__ */ new Set(["--test"]),
+  python: /* @__PURE__ */ new Set(["-m"]),
+  python3: /* @__PURE__ */ new Set(["-m"])
+};
+function isCheckCommand(line) {
+  const words = line.split(" ").filter((word) => word.length > 0);
+  const program = basename(words[0] ?? "");
+  if (CHECK_PROGRAMS.has(program)) return true;
+  if (/[./]/u.test(words[0] ?? "") && CHECK_SCRIPT_FILE.test(program)) return true;
+  if (INTERPRETERS.has(program)) {
+    const script = words.slice(1).find((word) => !word.startsWith("-"));
+    if (script !== void 0 && /\.(?:py|sh|js|mjs|cjs|ts|mts|rb)$/u.test(script) && CHECK_SCRIPT_FILE.test(basename(script))) return true;
+  }
+  const sub = CHECK_SUBCOMMANDS[program];
+  if (sub && words[1] !== void 0 && sub.has(words[1])) {
+    return !(program.startsWith("python") && !/^(?:pytest|unittest|mypy)$/u.test(words[2] ?? ""));
+  }
+  if (!PACKAGE_RUNNERS.has(program)) return false;
+  for (let at = 1; at < words.length; at++) {
+    const word = words[at];
+    if (word === "run" || word === "exec" || word === "dlx") continue;
+    if (word.startsWith("-")) {
+      if (/^(?:--filter|-F|-C|--dir|--prefix|-w|--workspace)$/u.test(word)) at++;
+      continue;
+    }
+    return CHECK_SCRIPT.test(word) || CHECK_PROGRAMS.has(basename(word));
+  }
+  return false;
+}
+var WRITE_COMMAND = /^(?:sed (?:-E |-r )?-i|perl -p?i|git apply(?! --(?:check|stat|numstat))|patch |apply_patch)/u;
+var WRITE_TOOL = /^(?:edit|write|multiedit|notebookedit|apply_patch|write_file|create_file|edit_file|str_replace_editor|str_replace_based_edit_tool)$/iu;
+var SCRATCH_PATH = /(?:^|\s)(?:\/private)?\/tmp\/|(?:^|\s)\/var\/folders\/|\/scratchpad\/|\/\.claude\/|\/\.codex[^/]*\//u;
+function writtenPaths(span) {
+  const input = span.attributes["input.value"];
+  if (typeof input !== "string") return [];
+  const patched = [...input.matchAll(/\*\*\* (?:Add|Update|Delete) File: ([^\n"\\]+)/gu)].map((match) => match[1].trim());
+  if (patched.length > 0) return patched;
+  try {
+    const parsed = JSON.parse(input);
+    return [parsed.file_path, parsed.path, parsed.notebook_path].filter((value) => typeof value === "string");
+  } catch {
+    return [];
+  }
+}
+function writesWork(span) {
+  if (!WRITE_TOOL.test(toolName(span))) return false;
+  const paths = writtenPaths(span);
+  return paths.length === 0 || paths.some((path) => !SCRATCH_PATH.test(path));
+}
+var READ_COMMAND = /^(?:cat|less|head|tail|grep|rg|sed -n|nl|ls|find|fd|git show|git diff|git log|jq)\b/u;
+var READ_TOOL = /^(?:read|grep|glob|ls|view|read_file|list_dir|search|find_files)$|grep|find_files/iu;
+var WRAPPERS = /* @__PURE__ */ new Set(["timeout", "env", "nice", "nohup", "setsid", "time", "sudo", "stdbuf", "ionice", "caffeinate"]);
+var SSH_VALUE_OPTION = /^-[BbcDEeFIiJLlmOoPpQRSWw]$/u;
+function runCommands(line, depth = 0) {
+  const words = line.split(" ").filter((word) => word.length > 0);
+  let at = 0;
+  while (at < words.length) {
+    if (/^\w+=/u.test(words[at])) {
+      at++;
+      continue;
+    }
+    if (!WRAPPERS.has(basename(words[at]))) break;
+    at++;
+    while (at < words.length && (words[at].startsWith("-") || /^\d+(?:\.\d+)?[smhd]?$/u.test(words[at]) || /^\w+=/u.test(words[at]))) at++;
+  }
+  const rest = words.slice(at);
+  if (rest.length === 0) return [];
+  if (basename(rest[0]) !== "ssh" || depth >= 2) return [rest.join(" ")];
+  let host = 1;
+  while (host < rest.length && rest[host].startsWith("-")) host += SSH_VALUE_OPTION.test(rest[host]) ? 2 : 1;
+  const remote = rest.slice(host + 1).join(" ");
+  return remote ? commandLines(remote).flatMap((command) => runCommands(command, depth + 1)) : [];
+}
+function expand(line, vars) {
+  return vars.size === 0 ? line : line.replace(/\$\{?(\w+)\}?/gu, (whole, name) => vars.get(name) ?? whole);
+}
+function expandedLines(lines) {
+  const vars = /* @__PURE__ */ new Map();
+  return lines.map((line) => {
+    const assignment = /^(\w+)=(\S+)$/u.exec(line);
+    if (assignment) vars.set(assignment[1], expand(assignment[2], vars));
+    return expand(line, vars);
+  });
+}
+function actionKind(span, commands) {
+  if (isTool(span)) {
+    const lines = expandedLines(commands);
+    if (lines.flatMap((line) => runCommands(line)).some(isCheckCommand)) return "verify";
+    if (writesWork(span) || lines.flatMap((line) => runCommands(line)).some((line) => WRITE_COMMAND.test(line) && !SCRATCH_PATH.test(line))) return "edit";
+    if (READ_TOOL.test(toolName(span)) || commands.length > 0 && commands.every((line) => READ_COMMAND.test(line))) return "read";
+    return "tool";
+  }
+  return "other";
+}
+function classifyLiveActions(spans) {
+  return orderSpans(spans).filter(isOwnAct).map((span) => {
+    const tool = isTool(span) ? toolName(span) : void 0;
+    const script = tool ? scriptOf(span) : void 0;
+    const commands = script === void 0 ? [] : commandLines(script);
+    return {
+      kind: actionKind(span, commands),
+      spanId: span.span_id,
+      span,
+      ...tool ? { toolName: tool } : {},
+      signature: commands.length > 0 ? commands.join("\n") : tool ?? span.name,
+      errored: span.status.code === "ERROR"
+    };
+  });
+}
+function timeOf(span) {
+  const parsed = Date.parse(span.start_time);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function orderSpans(spans) {
+  return [...spans].sort((a, b) => {
+    const stepA = typeof a.attributes.step === "number" ? a.attributes.step : void 0;
+    const stepB = typeof b.attributes.step === "number" ? b.attributes.step : void 0;
+    if (stepA != null && stepB != null && stepA !== stepB) return stepA - stepB;
+    return timeOf(a) - timeOf(b);
+  });
+}
+function evidence(kind, label, value, spanIds) {
+  return { kind, label, value, ...spanIds && spanIds.length > 0 ? { spanIds } : {} };
+}
+function finding(input) {
+  const fingerprint = hash([input.ruleId, ...input.signature]);
+  return {
+    schemaVersion: 1,
+    kind: "traces.live_finding",
+    id: `live.${input.ruleId}.${fingerprint}`,
+    fingerprint,
+    ruleId: input.ruleId,
+    severity: input.severity,
+    title: input.title,
+    claim: input.claim,
+    action: input.action,
+    check: input.check,
+    evidence: input.evidence,
+    session: input.session,
+    observedAt: input.observedAt
+  };
+}
+var oneLine = (text, cap) => {
+  const line = text.replace(/\s+/gu, " ").trim();
+  return line.length > cap ? `${line.slice(0, cap - 1)}\u2026` : line;
+};
+var sameFailingCommandAnalyst = {
+  id: "same-failing-command",
+  analyze(context) {
+    return context.facts().flatMap((facts) => (facts.measurements.waste.failingStreaks.value ?? []).map((streak) => {
+      const command = streak.command === null ? `a ${streak.tool} command` : `\`${oneLine(streak.command, 120)}\``;
+      return finding({
+        ruleId: "same-failing-command",
+        severity: "high",
+        title: "The same command failed again and again",
+        claim: `${command} failed ${streak.runs}\xD7 in a row (${streak.minutes} min).`,
+        action: "Stop rerunning it; read the first failure, change state, or choose a different diagnostic path before another run.",
+        check: "The next action should read the failing output, edit code or config, or run a narrower command before this one runs again.",
+        evidence: [
+          evidence("pattern", "command", streak.command ?? streak.tool, streak.spanIds),
+          evidence("metric", "failed_runs_in_a_row", String(streak.runs)),
+          evidence("metric", "minutes", String(streak.minutes))
+        ],
+        session: context.session,
+        observedAt: context.generatedAt,
+        signature: [streak.command ?? streak.tool, streak.at, String(streak.runs)]
+      });
+    }));
+  }
+};
+var RERUN_CHECKS = 3;
+var verificationWithoutChangeAnalyst = {
+  id: "verification-without-change",
+  analyze(context) {
+    let worst;
+    let runs = /* @__PURE__ */ new Map();
+    const settle = () => {
+      for (const entry of runs) if (!worst || entry[1].length > worst[1].length) worst = entry;
+      runs = /* @__PURE__ */ new Map();
+    };
+    for (const action of context.actions) {
+      if (action.kind === "edit") settle();
+      else if (action.kind === "verify") runs.set(action.signature, [...runs.get(action.signature) ?? [], action.spanId]);
+    }
+    settle();
+    const [signature, spanIds] = worst ?? [];
+    if (signature === void 0 || spanIds === void 0 || spanIds.length < RERUN_CHECKS) return [];
+    return [finding({
+      ruleId: "verification-without-change",
+      severity: spanIds.length >= 5 ? "high" : "medium",
+      title: "A check is rerun without a change",
+      claim: `\`${oneLine(signature, 120)}\` ran ${spanIds.length}\xD7 with no edit between.`,
+      action: "Do not run the check again until the agent edits state or says what new signal the rerun will reveal.",
+      check: "The next action should be an edit, a targeted read, or a different, narrower check.",
+      evidence: [evidence("pattern", "check", signature, spanIds), evidence("metric", "runs_without_an_edit", String(spanIds.length))],
+      session: context.session,
+      observedAt: context.generatedAt,
+      signature: [signature, String(spanIds.length)]
+    })];
+  }
+};
+var highToolErrorRateAnalyst = {
+  id: "high-tool-error-rate",
+  analyze(context) {
+    if (context.tools.length < 4 || context.erroredTools.length / context.tools.length < 0.5) return [];
+    return [finding({
+      ruleId: "high-tool-error-rate",
+      severity: context.erroredTools.length / context.tools.length >= 0.75 ? "high" : "medium",
+      title: "Tool calls are mostly failing",
+      claim: `${context.erroredTools.length}/${context.tools.length} tool call(s) ended with ERROR.`,
+      action: "Switch from broad execution to diagnosis: classify the dominant error, then run one targeted command to validate the fix path.",
+      check: "The next calls should reduce the error ratio or show a new targeted diagnostic result.",
+      evidence: [
+        evidence("metric", "errored_tool_calls", `${context.erroredTools.length}/${context.tools.length}`, context.erroredTools.slice(0, 20).map((span) => span.span_id))
+      ],
+      session: context.session,
+      observedAt: context.generatedAt,
+      signature: [String(context.erroredTools.length), String(context.tools.length)]
+    })];
+  }
+};
+var defaultTraceLiveAnalysts = [
+  sameFailingCommandAnalyst,
+  verificationWithoutChangeAnalyst,
+  highToolErrorRateAnalyst
+];
+function ruleContext(spans, opts) {
+  const ordered = orderSpans(spans);
+  const actions = classifyLiveActions(ordered);
+  const tools = actions.filter((action) => action.toolName !== void 0).map((action) => action.span);
+  let facts = opts.facts;
+  return {
+    spans: ordered,
+    actions,
+    tools,
+    erroredTools: tools.filter((span) => span.status.code === "ERROR"),
+    verificationActions: actions.filter((action) => action.kind === "verify"),
+    changeActions: actions.filter((action) => action.kind === "edit"),
+    session: opts.session,
+    generatedAt: opts.generatedAt,
+    newSpanCount: opts.newSpanCount ?? ordered.length,
+    facts: () => facts ??= computeSessionFacts(ordered)
+  };
+}
+function runRules(context, opts = {}) {
+  return [...opts.analysts ?? defaultTraceLiveAnalysts, ...opts.extraAnalysts ?? []].flatMap((analyst) => [...analyst.analyze(context)]);
+}
+
+export {
+  createPipelineAccumulator,
+  classifyLiveActions,
+  orderSpans,
+  ruleContext,
+  runRules
+};