@tangle-network/traces 0.23.1 → 1.0.1

package/dist/chunk-M3W6TZHQ.js

@@ -0,0 +1,381 @@
+// src/supervisor-run-context.ts
+import { readFile, stat } from "fs/promises";
+import { basename, join } from "path";
+import { materializeTreeView } from "@tangle-network/agent-runtime/kernel";
+import {
+  readRuntimeSupervisorRun
+} from "@tangle-network/agent-eval/supervisor-run";
+var SPAWN_JOURNAL_FILE = "spawn-journal.jsonl";
+var COORDINATION_LOG_FILE = "coordination-log.jsonl";
+var RESULT_FILE = "result.json";
+async function readMaybe(path) {
+  return readFile(path, "utf8").catch(() => null);
+}
+function readJsonlLines(text) {
+  if (text === null) {
+    return { rows: [], invalidRows: 0, partialTail: false, present: false };
+  }
+  const lines = text.split("\n");
+  const partialTail = text.length > 0 && !text.endsWith("\n");
+  if (partialTail) lines.pop();
+  const rows = [];
+  let invalidRows = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        rows.push(parsed);
+      } else invalidRows += 1;
+    } catch {
+      invalidRows += 1;
+    }
+  }
+  return { rows, invalidRows, partialTail, present: true };
+}
+function asRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
+}
+function str(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+var RETIRED_WAIT_KINDS = /* @__PURE__ */ new Set(["waiting", "woken"]);
+function readRunContextJournal(text) {
+  const parsed = readJsonlLines(text);
+  let root = null;
+  let begunAt = null;
+  const events = [];
+  let invalidRows = parsed.invalidRows;
+  let retiredWaitRows = 0;
+  for (const record of parsed.rows) {
+    const recordRoot = str(record.root);
+    if (root === null && recordRoot !== null) root = recordRoot;
+    if (record.kind === "begin") {
+      if (begunAt === null) begunAt = str(record.at);
+      continue;
+    }
+    if (record.kind !== "event") {
+      invalidRows += 1;
+      continue;
+    }
+    const event = asRecord(record.event);
+    if (str(event.kind) === null || str(event.id) === null) {
+      invalidRows += 1;
+      continue;
+    }
+    if (RETIRED_WAIT_KINDS.has(event.kind)) {
+      retiredWaitRows += 1;
+      continue;
+    }
+    events.push(event);
+  }
+  const supervisorIds = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (event.kind !== "spawned") continue;
+    const parent = event.parent;
+    if (typeof parent === "string" && parent.length > 0) supervisorIds.add(parent);
+  }
+  return {
+    root,
+    begunAt,
+    events,
+    supervisorIds,
+    invalidRows,
+    retiredWaitRows,
+    partialTail: parsed.partialTail,
+    present: parsed.present
+  };
+}
+function inferRole(id, parent, supervisorIds) {
+  if (parent === null || parent === void 0) return "supervisor";
+  return supervisorIds.has(id) ? "supervisor" : "worker";
+}
+var EMPTY_COORDINATION = {
+  present: false,
+  steers: [],
+  deliveries: [],
+  questions: [],
+  invalidRows: 0,
+  partialTail: false
+};
+function readCoordinationLog(text) {
+  const parsed = readJsonlLines(text);
+  if (!parsed.present) return EMPTY_COORDINATION;
+  const steers = [];
+  const deliveries = [];
+  const questions = [];
+  let invalidRows = parsed.invalidRows;
+  for (const row of parsed.rows) {
+    const record = asRecord(row.record);
+    const event = asRecord(Object.keys(record).length > 0 ? record.event : row.event);
+    const at = typeof record.at === "number" ? record.at : parseInstant(row.at);
+    switch (event.type) {
+      case "steer": {
+        const down = asRecord(event.down);
+        steers.push({
+          messageId: str(down.messageId),
+          toWorker: str(down.toWorker),
+          instruction: typeof down.instruction === "string" ? down.instruction : "",
+          deliveryMode: str(down.deliveryMode),
+          at
+        });
+        break;
+      }
+      case "delivery": {
+        const receipt = asRecord(event.receipt);
+        deliveries.push({
+          messageId: str(receipt.messageId),
+          delivered: typeof receipt.delivered === "boolean" ? receipt.delivered : null
+        });
+        break;
+      }
+      case "question": {
+        const q = asRecord(event.question);
+        const urgency = str(q.urgency);
+        questions.push({
+          id: str(q.id),
+          from: str(q.from),
+          question: typeof q.question === "string" ? q.question : "",
+          reason: str(q.reason),
+          urgency,
+          status: str(q.status),
+          blocking: urgency === "blocks-run",
+          at: typeof q.openedAt === "number" ? q.openedAt : at
+        });
+        break;
+      }
+      case "settled":
+        break;
+      default:
+        if (str(event.type) === null) invalidRows += 1;
+    }
+  }
+  return {
+    present: true,
+    steers,
+    deliveries,
+    questions,
+    invalidRows,
+    partialTail: parsed.partialTail
+  };
+}
+function parseInstant(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v !== "string") return null;
+  const t = Date.parse(v);
+  return Number.isFinite(t) ? t : null;
+}
+async function readFileRunContext(runDir, opts = {}) {
+  const sources = await readRuntimeSupervisorRun(runDir);
+  const coordination = readCoordinationLog(await readMaybe(join(runDir, COORDINATION_LOG_FILE)));
+  return {
+    ...sources,
+    instanceId: opts.instanceId !== void 0 ? opts.instanceId : sources.instanceId,
+    arm: opts.arm !== void 0 ? opts.arm : basename(runDir),
+    workers: sources.workers !== null && coordination.present ? workerSources(sources.workers, coordination) : sources.workers,
+    ...sources.journal !== null ? {
+      rootTranscriptRef: join(runDir, SPAWN_JOURNAL_FILE),
+      traceCommand: `traces watch ${runDir}`
+    } : {}
+  };
+}
+function fileRunContextSupervisorRunReader(runDir, opts = {}) {
+  return { runRef: runDir, read: () => readFileRunContext(runDir, opts) };
+}
+async function isFileRunContextDir(runDir) {
+  return stat(join(runDir, SPAWN_JOURNAL_FILE)).then((s) => s.isFile()).catch(() => false);
+}
+function parseJsonObject(text) {
+  if (text === null) return null;
+  try {
+    const parsed = JSON.parse(text);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function workerSources(workers, coordination) {
+  const deliveredById = /* @__PURE__ */ new Map();
+  for (const receipt of coordination.deliveries) {
+    if (receipt.messageId !== null) deliveredById.set(receipt.messageId, receipt.delivered);
+  }
+  return workers.map((worker) => {
+    const steers = coordination.steers.filter((steer) => steer.toWorker === worker.workerId);
+    const questions = coordination.questions.filter((question) => question.from === worker.workerId);
+    return {
+      ...worker,
+      events: [
+        ...steers.map((steer) => JSON.stringify({
+          kind: "message",
+          requestId: steer.messageId,
+          delivered: steer.messageId === null ? null : deliveredById.get(steer.messageId) ?? null
+        })),
+        ...questions.map((question) => JSON.stringify({ kind: "message", direction: "up", id: question.id }))
+      ].join("\n"),
+      inbox: steers.map((steer) => JSON.stringify({ id: steer.messageId, message: steer.instruction })).join("\n")
+    };
+  });
+}
+var ZERO_ROLL = {
+  records: 0,
+  iterations: 0,
+  tokensIn: 0,
+  tokensOut: 0,
+  usd: 0,
+  usdKnownRecords: 0,
+  usdUnknownRecords: 0
+};
+function addSpend(roll, spend) {
+  const known = spend.usdKnown !== false;
+  return {
+    records: roll.records + 1,
+    iterations: roll.iterations + (spend.iterations ?? 0),
+    tokensIn: roll.tokensIn + (spend.tokens?.input ?? 0),
+    tokensOut: roll.tokensOut + (spend.tokens?.output ?? 0),
+    usd: roll.usd + (known ? spend.usd ?? 0 : 0),
+    usdKnownRecords: roll.usdKnownRecords + (known ? 1 : 0),
+    usdUnknownRecords: roll.usdUnknownRecords + (known ? 0 : 1)
+  };
+}
+function mergeRolls(a, b) {
+  return {
+    records: a.records + b.records,
+    iterations: a.iterations + b.iterations,
+    tokensIn: a.tokensIn + b.tokensIn,
+    tokensOut: a.tokensOut + b.tokensOut,
+    usd: a.usd + b.usd,
+    usdKnownRecords: a.usdKnownRecords + b.usdKnownRecords,
+    usdUnknownRecords: a.usdUnknownRecords + b.usdUnknownRecords
+  };
+}
+async function readRunContextSnapshot(runDir) {
+  const journal = readRunContextJournal(await readMaybe(join(runDir, SPAWN_JOURNAL_FILE)));
+  const coordination = readCoordinationLog(await readMaybe(join(runDir, COORDINATION_LOG_FILE)));
+  const resultText = await readMaybe(join(runDir, RESULT_FILE));
+  const result = parseResult(resultText);
+  const view = safeTreeView(journal.events);
+  const nodes = view === null ? [] : orderNodes(view, journal);
+  return {
+    runDir,
+    runId: journal.root,
+    present: journal.present,
+    nodes,
+    maxDepth: nodes.reduce((max, n) => Math.max(max, n.depth), 0),
+    begunAt: parseInstant(journal.begunAt),
+    lastEventAt: journal.events.reduce((latest, event) => {
+      const at = parseInstant(event.at);
+      return at === null ? latest : latest === null ? at : Math.max(latest, at);
+    }, null),
+    questions: coordination.questions,
+    steers: coordination.steers,
+    result,
+    terminal: resultText !== null,
+    invalidJournalRows: journal.invalidRows,
+    retiredWaitRows: journal.retiredWaitRows,
+    invalidCoordinationRows: coordination.invalidRows,
+    partialTail: journal.partialTail || coordination.partialTail,
+    treeError: view === null && journal.present ? "spawn journal could not be folded into a tree (a settle or cancel names a node that was never spawned)" : null
+  };
+}
+function safeTreeView(events) {
+  if (events.length === 0) return null;
+  try {
+    return materializeTreeView([...events]);
+  } catch {
+    return null;
+  }
+}
+function orderNodes(view, journal) {
+  const driver = /* @__PURE__ */ new Map();
+  const settled = /* @__PURE__ */ new Map();
+  const childRoll = /* @__PURE__ */ new Map();
+  const spawnedAt = /* @__PURE__ */ new Map();
+  const settledAt = /* @__PURE__ */ new Map();
+  const cancelReason = /* @__PURE__ */ new Map();
+  const parentOf = new Map(view.nodes.map((n) => [n.id, n.parent]));
+  for (const event of journal.events) {
+    const at = parseInstant(event.at);
+    if (event.kind === "spawned") {
+      spawnedAt.set(event.id, at);
+    } else if (event.kind === "metered") {
+      driver.set(event.id, addSpend(driver.get(event.id) ?? ZERO_ROLL, event.spend));
+    } else if (event.kind === "settled") {
+      settled.set(event.id, addSpend(settled.get(event.id) ?? ZERO_ROLL, event.spent));
+      settledAt.set(event.id, at);
+      const parent = parentOf.get(event.id);
+      if (parent !== void 0) {
+        childRoll.set(parent, addSpend(childRoll.get(parent) ?? ZERO_ROLL, event.spent));
+      }
+    } else if (event.kind === "cancelled") {
+      settledAt.set(event.id, at);
+      cancelReason.set(event.id, event.reason);
+    }
+  }
+  const byParent = /* @__PURE__ */ new Map();
+  for (const node of view.nodes) {
+    const key = node.parent ?? null;
+    const bucket = byParent.get(key);
+    if (bucket) bucket.push(node);
+    else byParent.set(key, [node]);
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (id, depth) => {
+    if (seen.has(id)) return;
+    seen.add(id);
+    const node = view.nodes.find((n) => n.id === id);
+    if (node === void 0) return;
+    const spawned = spawnedAt.get(id) ?? null;
+    const closed = settledAt.get(id) ?? null;
+    out.push({
+      id: node.id,
+      parent: node.parent ?? null,
+      label: node.label,
+      depth,
+      role: inferRole(node.id, node.parent, journal.supervisorIds),
+      status: node.status,
+      runtime: node.runtime ?? null,
+      budget: node.budget,
+      driver: driver.get(id) ?? ZERO_ROLL,
+      children: childRoll.get(id) ?? ZERO_ROLL,
+      settled: settled.get(id) ?? ZERO_ROLL,
+      spawnedAt: spawned,
+      settledAt: closed,
+      wallMs: spawned !== null && closed !== null ? closed - spawned : null,
+      outRef: node.outRef ?? null,
+      cancelReason: cancelReason.get(id) ?? null
+    });
+    for (const child of byParent.get(id) ?? []) walk(child.id, depth + 1);
+  };
+  walk(view.root, 0);
+  for (const node of view.nodes) if (!seen.has(node.id)) walk(node.id, 0);
+  return out;
+}
+function parseResult(text) {
+  const result = parseJsonObject(text);
+  if (result === null) return null;
+  const error = asRecord(result.error);
+  return {
+    kind: str(result.kind),
+    reason: str(result.reason),
+    errorName: str(error.name),
+    errorMessage: str(error.message)
+  };
+}
+
+export {
+  SPAWN_JOURNAL_FILE,
+  COORDINATION_LOG_FILE,
+  RESULT_FILE,
+  readRunContextJournal,
+  inferRole,
+  readCoordinationLog,
+  readFileRunContext,
+  fileRunContextSupervisorRunReader,
+  isFileRunContextDir,
+  ZERO_ROLL,
+  addSpend,
+  mergeRolls,
+  readRunContextSnapshot
+};

package/dist/chunk-O52XK7OB.js

@@ -0,0 +1,19 @@
+// src/ask-defaults.ts
+var DEFAULT_ANALYST_MODEL = "gpt-5.6-luna";
+var DEFAULT_QUESTION_MAX_COST_USD = 2;
+var DEFAULT_QUESTION_TIMEOUT_MS = 18e5;
+var DEFAULT_ASK_CONCURRENCY = 4;
+var QUESTION_FIELD_MAX_CHARS = 900;
+var ASK_QUESTION_HEADER = "Answer QUESTION with the trace tools and follow TRACES ASK RULES in analyst_instructions. The trace list is JSON after PREPARED CONTEXT: there. Cite trace://<trace_id>/span/<span_id>.";
+var QUESTION_LABEL = "\n\nQUESTION: ";
+var MAX_TRACE_QUESTION_CHARS = QUESTION_FIELD_MAX_CHARS - ASK_QUESTION_HEADER.length - QUESTION_LABEL.length;
+
+export {
+  DEFAULT_ANALYST_MODEL,
+  DEFAULT_QUESTION_MAX_COST_USD,
+  DEFAULT_QUESTION_TIMEOUT_MS,
+  DEFAULT_ASK_CONCURRENCY,
+  ASK_QUESTION_HEADER,
+  QUESTION_LABEL,
+  MAX_TRACE_QUESTION_CHARS
+};

package/dist/chunk-PYH3PL3N.js

@@ -0,0 +1,62 @@
+// src/finding-rejections.ts
+var REJECTION_MESSAGE = /^(?:\[([^\]]+)\] )?finding rejected: (.+)$/;
+function findingRejection(message, fields) {
+  const match = REJECTION_MESSAGE.exec(message);
+  if (!match) return void 0;
+  const kind = match[2].trim();
+  const reason = kind === "unresolved evidence" && typeof fields?.reason === "string" && fields.reason ? fields.reason : kind;
+  return match[1] ? { analystId: match[1], reason } : { reason };
+}
+function rejectionCause(fields) {
+  if (typeof fields?.reason === "string" && fields.reason) return fields.reason;
+  const issues = fields?.issues;
+  if (typeof issues === "string" && issues) return issues;
+  if (Array.isArray(issues) && issues.length > 0) return issues.map((issue) => String(issue)).join("; ");
+  return void 0;
+}
+function findingRejectionDetail(message, fields) {
+  const rejection = findingRejection(message, fields);
+  if (!rejection) return void 0;
+  const lead = rejectionCause(fields) ?? rejection.reason;
+  const parts = message.endsWith(lead) ? [] : [lead];
+  if (typeof fields?.uri === "string" && fields.uri) parts.push(`uri ${fields.uri}`);
+  if (typeof fields?.required === "number" && typeof fields?.distinct === "number") {
+    parts.push(`${fields.distinct} of ${fields.required} required distinct citation(s)`);
+  }
+  if (typeof fields?.subject === "string" && fields.subject) parts.push(`subject ${fields.subject}`);
+  return parts.join("; ");
+}
+function createFindingRejectionTally(defaultAnalystId = "unknown") {
+  const byAnalyst = /* @__PURE__ */ new Map();
+  return {
+    record(message, fields) {
+      const rejection = findingRejection(message, fields);
+      if (!rejection) return;
+      const analystId = rejection.analystId ?? defaultAnalystId;
+      const reasons = byAnalyst.get(analystId) ?? /* @__PURE__ */ new Map();
+      reasons.set(rejection.reason, (reasons.get(rejection.reason) ?? 0) + 1);
+      byAnalyst.set(analystId, reasons);
+    },
+    counts() {
+      return Object.fromEntries(
+        [...byAnalyst].map(([analystId, reasons]) => [analystId, Object.fromEntries(reasons)])
+      );
+    }
+  };
+}
+function totalFindingRejections(reasons) {
+  return Object.values(reasons ?? {}).reduce((sum, count) => sum + count, 0);
+}
+function formatFindingRejections(reasons) {
+  const total = totalFindingRejections(reasons);
+  if (total === 0) return "";
+  const ordered = Object.entries(reasons ?? {}).filter(([, count]) => count > 0).sort(([a, left], [b, right]) => right - left || a.localeCompare(b)).map(([reason, count]) => `${reason} \xD7${count}`);
+  return `${total} finding(s) rejected: ${ordered.join("; ")}`;
+}
+
+export {
+  findingRejectionDetail,
+  createFindingRejectionTally,
+  totalFindingRejections,
+  formatFindingRejections
+};