@tangle-network/traces 0.23.0 → 1.0.0

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
+};