@tangle-network/agent-runtime 0.57.0 → 0.59.0

package/dist/agent.js

@@ -3,7 +3,7 @@ import {
 } from "./chunk-XRYEZPR6.js";
 import {
   createSandboxForSpec
-} from "./chunk-RLDUT4JL.js";
+} from "./chunk-45D64J7B.js";
 import "./chunk-7QYOXFCD.js";
 import "./chunk-WIR4HOOJ.js";
 import {

package/dist/{chunk-RLDUT4JL.js → chunk-45D64J7B.js}

@@ -809,14 +809,14 @@ ${traceSummary}`
   return { findings, learned, report: renderReport(findings) };
 }
 function parseFindings(content) {
-  let obj;
+  let obj2;
   try {
-    obj = JSON.parse(content);
+    obj2 = JSON.parse(content);
   } catch {
     const m = content.match(/\{[\s\S]*\}/);
-    obj = m ? JSON.parse(m[0]) : { findings: [] };
+    obj2 = m ? JSON.parse(m[0]) : { findings: [] };
   }
-  const arr = obj.findings;
+  const arr = obj2.findings;
   return Array.isArray(arr) ? arr : [];
 }
 function renderReport(findings) {
@@ -1888,15 +1888,15 @@ async function emitTrace(emitter, event) {
   await emitter.emit(event);
 }
 function hashJson(value) {
-  let str;
+  let str2;
   try {
-    str = JSON.stringify(value) ?? String(value);
+    str2 = JSON.stringify(value) ?? String(value);
   } catch {
-    str = String(value);
+    str2 = String(value);
   }
   let h = 2166136261;
-  for (let i = 0; i < str.length; i += 1) {
-    h ^= str.charCodeAt(i);
+  for (let i = 0; i < str2.length; i += 1) {
+    h ^= str2.charCodeAt(i);
     h = Math.imul(h, 16777619);
   }
   return (h >>> 0).toString(16).padStart(8, "0");
@@ -3516,9 +3516,14 @@ async function createWorktree(options) {
 }
 async function captureWorktreeDiff(options) {
   const baseRef = options.baseRef ?? options.worktree.baseSha;
-  const patch = await runGitAsync(["diff", baseRef], options.worktree.path, options.runGit);
+  await runGitAsync(["add", "-A"], options.worktree.path, options.runGit);
+  const patch = await runGitAsync(
+    ["diff", "--cached", baseRef],
+    options.worktree.path,
+    options.runGit
+  );
   const shortstat = await runGitAsync(
-    ["diff", "--shortstat", baseRef],
+    ["diff", "--cached", "--shortstat", baseRef],
     options.worktree.path,
     options.runGit
   );
@@ -3750,15 +3755,15 @@ var cliSeamKey = "cli";
 var bridgeSeamKey = "bridge";
 var cliWorktreeSeamKey = "cli-worktree";
 function contentRef(prefix, value) {
-  let str;
+  let str2;
   try {
-    str = JSON.stringify(value) ?? String(value);
+    str2 = JSON.stringify(value) ?? String(value);
   } catch {
-    str = String(value);
+    str2 = String(value);
   }
   let h = 2166136261;
-  for (let i = 0; i < str.length; i += 1) {
-    h ^= str.charCodeAt(i);
+  for (let i = 0; i < str2.length; i += 1) {
+    h ^= str2.charCodeAt(i);
     h = Math.imul(h, 16777619);
   }
   return `${prefix}:${(h >>> 0).toString(16).padStart(8, "0")}`;
@@ -4338,9 +4343,9 @@ function readSeam(ctx, key, who) {
 function taskToPrompt(task) {
   if (typeof task === "string") return task;
   if (task && typeof task === "object") {
-    const obj = task;
+    const obj2 = task;
     for (const k of ["prompt", "content", "task", "message"]) {
-      if (typeof obj[k] === "string") return obj[k];
+      if (typeof obj2[k] === "string") return obj2[k];
     }
   }
   return JSON.stringify(task);
@@ -7038,12 +7043,12 @@ function createCoordinationTools(opts) {
     bus.subscribe((rec) => cb(rec.event));
   }
   const urgencyPriority = (u) => u === "blocks-run" ? 20 : u === "blocks-step" ? 10 : 0;
-  const str = (v, field) => {
+  const str2 = (v, field) => {
     if (typeof v !== "string" || v.length === 0)
       throw new Error(`coordination tools: "${field}" must be a non-empty string`);
     return v;
   };
-  const obj = (raw) => {
+  const obj2 = (raw) => {
     if (!raw || typeof raw !== "object")
       throw new Error("coordination tools: arguments must be an object");
     return raw;
@@ -7085,7 +7090,7 @@ function createCoordinationTools(opts) {
   };
   async function sendDown(type, down, questionId) {
     await bus.publish(
-      type === "answer" ? { type, down, questionId: str(questionId, "questionId") } : { type, down },
+      type === "answer" ? { type, down, questionId: str2(questionId, "questionId") } : { type, down },
       { queue: false }
     );
   }
@@ -7108,13 +7113,13 @@ function createCoordinationTools(opts) {
   };
   const nextQuestionId = (from) => `${from}:q${questionSeq++}`;
   const normalizeQuestion = (q, fallbackFrom) => {
-    const from = str(q.from ?? fallbackFrom, "from");
+    const from = str2(q.from ?? fallbackFrom, "from");
     return {
       id: typeof q.id === "string" && q.id.length > 0 ? q.id : nextQuestionId(from),
       from,
       level: level(q.level),
-      question: str(q.question, "question"),
-      reason: str(q.reason, "reason"),
+      question: str2(q.question, "question"),
+      reason: str2(q.reason, "reason"),
       ...q.options ? { options: q.options } : {},
       urgency: urgency(q.urgency)
     };
@@ -7178,7 +7183,7 @@ function createCoordinationTools(opts) {
         required: ["profile", "task"]
       },
       handler: (raw) => {
-        const a = obj(raw);
+        const a = obj2(raw);
         const agent = opts.makeWorkerAgent(a.profile);
         const res = opts.scope.spawn(agent, a.task, {
           budget: opts.perWorker,
@@ -7192,7 +7197,7 @@ function createCoordinationTools(opts) {
       description: "Inspect a worker status, spend, and settled output artifact when available.",
       inputSchema: { type: "object", properties: { workerId: idArg }, required: ["workerId"] },
       handler: async (raw) => {
-        const id = str(obj(raw).workerId, "workerId");
+        const id = str2(obj2(raw).workerId, "workerId");
         const node = opts.scope.view.nodes.find((n) => n.id === id);
         if (!node) return { error: `unknown workerId ${JSON.stringify(id)}` };
         const output = node.outRef ? await opts.blobs.get(node.outRef) : void 0;
@@ -7220,9 +7225,9 @@ function createCoordinationTools(opts) {
         required: ["workerId", "instruction"]
       },
       handler: async (raw) => {
-        const a = obj(raw);
-        const workerId = str(a.workerId, "workerId");
-        const instruction = str(a.instruction, "instruction");
+        const a = obj2(raw);
+        const workerId = str2(a.workerId, "workerId");
+        const instruction = str2(a.instruction, "instruction");
         const interrupt = a.interrupt === true;
         const delivered = opts.scope.send(workerId, { steer: instruction, interrupt });
         await sendDown("steer", { toWorker: workerId, instruction, delivered });
@@ -7243,7 +7248,7 @@ function createCoordinationTools(opts) {
         }
       },
       handler: async (raw) => {
-        const k = obj(raw).kinds;
+        const k = obj2(raw).kinds;
         const kinds = Array.isArray(k) ? k.filter((x) => x === "settled" || x === "question" || x === "finding") : void 0;
         let ev = bus.pull(kinds);
         if (!ev) {
@@ -7276,8 +7281,8 @@ function createCoordinationTools(opts) {
         required: ["questionId"]
       },
       handler: async (raw) => {
-        const a = obj(raw);
-        const questionId = str(a.questionId, "questionId");
+        const a = obj2(raw);
+        const questionId = str2(a.questionId, "questionId");
         if (typeof a.answer === "string" && a.answer.length > 0) {
           const answer = a.answer;
           const question = decideQuestion(questionId, {
@@ -7330,15 +7335,15 @@ function createCoordinationTools(opts) {
         required: ["from", "level", "question", "reason", "urgency"]
       },
       handler: async (raw) => {
-        const a = obj(raw);
-        const from = str(a.from, "from");
+        const a = obj2(raw);
+        const from = str2(a.from, "from");
         const q = await emitNewQuestion(
           addQuestion(
             {
               from,
               level: level(a.level),
-              question: str(a.question, "question"),
-              reason: str(a.reason, "reason"),
+              question: str2(a.question, "question"),
+              reason: str2(a.reason, "reason"),
               urgency: urgency(a.urgency)
             },
             from,
@@ -7365,7 +7370,7 @@ function createCoordinationTools(opts) {
           });
         }
         stopped = true;
-        const r = obj(raw).reason;
+        const r = obj2(raw).reason;
         reason = typeof r === "string" ? r : void 0;
         return Promise.resolve({ stopped: true });
       }
@@ -7390,14 +7395,14 @@ function createCoordinationTools(opts) {
         required: ["kind", "workerId"]
       },
       handler: async (raw) => {
-        const a = obj(raw);
-        const id = str(a.workerId, "workerId");
+        const a = obj2(raw);
+        const id = str2(a.workerId, "workerId");
         const node = opts.scope.view.nodes.find((n) => n.id === id);
         if (!node) return { error: `unknown workerId ${JSON.stringify(id)}` };
         if (!node.outRef)
           return { error: `worker ${JSON.stringify(id)} has not settled \u2014 no trace to analyze yet` };
         const trace = await opts.blobs.get(node.outRef);
-        return { findings: await opts.analysts?.run(str(a.kind, "kind"), trace) };
+        return { findings: await opts.analysts?.run(str2(a.kind, "kind"), trace) };
       }
     });
   }
@@ -8256,15 +8261,15 @@ function randomTaskId() {
   return `dlg-${t}-${r}`;
 }
 function hashIdempotencyInput(value) {
-  let str;
+  let str2;
   try {
-    str = JSON.stringify(canonicalize(value));
+    str2 = JSON.stringify(canonicalize(value));
   } catch {
-    str = String(value);
+    str2 = String(value);
   }
   let h = 2166136261;
-  for (let i = 0; i < str.length; i += 1) {
-    h ^= str.charCodeAt(i);
+  for (let i = 0; i < str2.length; i += 1) {
+    h ^= str2.charCodeAt(i);
     h = Math.imul(h, 16777619);
   }
   return (h >>> 0).toString(16).padStart(8, "0");
@@ -9711,29 +9716,22 @@ import {
 function defaultToolDetectors() {
   return [repeatedActionDetector({ maxRepeated: 3 }), errorStreakDetector({ maxErrors: 3 })];
 }
-function createDetectorMonitor(opts = {}) {
+function watchTrace(source, opts = {}) {
   const detectors = opts.detectors ?? defaultToolDetectors();
-  return {
-    observeToolStep(step) {
-      let fingerprint;
-      try {
-        fingerprint = `${step.toolName}|${argHash(step.args)}`;
-      } catch {
-        fingerprint = `${step.toolName}|<unhashable>`;
-      }
-      const signals = observeAll(detectors, {
-        // Same fingerprint scheme as agent-eval's batch stuck-loop view: tool name + hashed args.
-        actionFingerprint: fingerprint,
-        ...step.status ? { status: step.status } : {},
-        label: step.toolName
-      });
-      for (const s of signals) void opts.onSignal?.(s);
-      return signals;
-    },
-    reset() {
-      for (const d of detectors) d.reset();
+  return source.onSpan((span) => {
+    let fingerprint;
+    try {
+      fingerprint = `${span.toolName}|${argHash(span.args)}`;
+    } catch {
+      fingerprint = `${span.toolName}|<unhashable>`;
     }
-  };
+    const signals = observeAll(detectors, {
+      actionFingerprint: fingerprint,
+      ...span.status ? { status: span.status } : {},
+      label: span.toolName
+    });
+    for (const s of signals) void opts.onSignal?.(s, span);
+  });
 }
 
 // src/runtime/supervise/router-driver-chat.ts
@@ -9790,46 +9788,199 @@ function safeParse(s) {
   }
 }
 
-// src/runtime/supervise/trajectory-recorder.ts
-import { buildTrajectory, InMemoryTraceStore } from "@tangle-network/agent-eval";
-import { stuckLoopView, toolWasteView } from "@tangle-network/agent-eval/pipelines";
-function createTrajectoryRecorder(runId, now = Date.now) {
-  let steps = [];
+// src/runtime/supervise/trace-source.ts
+function toToolSpan(input, runId, seq, at) {
+  return {
+    spanId: `${runId}-t${seq}`,
+    runId,
+    kind: "tool",
+    name: input.toolName,
+    toolName: input.toolName,
+    args: input.args,
+    status: input.status ?? "ok",
+    startedAt: at,
+    endedAt: at,
+    ...input.result !== void 0 ? { result: input.result } : {}
+  };
+}
+var obj = (v) => v && typeof v === "object" ? v : void 0;
+var str = (v) => typeof v === "string" && v ? v : void 0;
+var decodeOpencodePart = (raw) => {
+  if (str(raw.type)?.toLowerCase() !== "tool" || !str(raw.tool)) return void 0;
+  const part = raw;
+  const state = obj(part.state);
+  const status = state?.status;
+  if (!status || status === "pending" || status === "running") return void 0;
+  return {
+    toolName: part.tool,
+    args: state?.input ?? {},
+    // ToolStateError carries 'error' OR 'failed' — the reverse-engineered decoder missed 'failed'.
+    status: status === "error" || status === "failed" ? "error" : "ok",
+    ...str(part.callID) ? { callId: part.callID } : {}
+  };
+};
+var decodeAnthropicPart = (p) => {
+  if (str(p.type)?.toLowerCase() !== "tool_use") return void 0;
+  const name = str(p.name) ?? str(p.tool);
+  if (!name) return void 0;
+  const id = str(p.id) ?? str(p.tool_use_id);
+  return {
+    toolName: name,
+    args: p.input ?? {},
+    ...id ? { callId: id } : {}
+  };
+};
+var decodeOpenAiPart = (p) => {
+  const type = str(p.type)?.toLowerCase();
+  const fn = obj(p.function);
+  if (type !== "function" && type !== "tool_call") return void 0;
+  const name = str(fn?.name) ?? str(p.name);
+  if (!name) return void 0;
+  const rawArgs = fn?.arguments ?? p.arguments;
+  return {
+    toolName: name,
+    args: typeof rawArgs === "string" ? safeParse2(rawArgs) : rawArgs ?? {},
+    ...str(p.id) ? { callId: p.id } : str(fn?.id) ? { callId: fn?.id } : {}
+  };
+};
+var toolPartDecoders = {
+  opencode: decodeOpencodePart,
+  "claude-code": decodeAnthropicPart,
+  anthropic: decodeAnthropicPart,
+  codex: decodeOpenAiPart,
+  openai: decodeOpenAiPart,
+  router: decodeOpenAiPart,
+  kimi: decodeOpenAiPart
+};
+function decodeToolPart(part, harness) {
+  const p = obj(part);
+  if (!p) return void 0;
+  const specific = harness ? toolPartDecoders[harness] : void 0;
+  if (specific) return specific(p);
+  for (const decode of new Set(Object.values(toolPartDecoders))) {
+    const step = decode(p);
+    if (step) return step;
+  }
+  return void 0;
+}
+function safeParse2(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return s;
+  }
+}
+var runSeq = 0;
+function createPushTraceSource(opts = {}) {
+  const runId = opts.runId ?? `push-${runSeq++}`;
+  const now = opts.now ?? Date.now;
+  const spans = [];
+  const subs = /* @__PURE__ */ new Set();
   return {
-    observeToolStep(step) {
-      steps.push({ ...step, at: now() });
+    record(input) {
+      const span = toToolSpan(input, runId, spans.length, now());
+      spans.push(span);
+      for (const fn of subs) {
+        try {
+          fn(span);
+        } catch {
+        }
+      }
+      return span;
     },
-    async analyze() {
-      const store = new InMemoryTraceStore();
-      for (let i = 0; i < steps.length; i += 1) {
-        const s = steps[i];
-        if (!s) continue;
-        const span = {
-          spanId: `${runId}-t${i}`,
-          runId,
-          kind: "tool",
-          name: s.toolName,
-          toolName: s.toolName,
-          args: s.args,
-          status: s.status ?? "ok",
-          startedAt: s.at,
-          endedAt: s.at,
-          ...s.result !== void 0 ? { result: s.result } : {}
-        };
-        await store.appendSpan(span);
-      }
-      const [trajectory, stuckLoop, toolWaste] = await Promise.all([
-        buildTrajectory(store, runId),
-        stuckLoopView(store, { runId }),
-        toolWasteView(store, { runId })
-      ]);
-      return { trajectory, stuckLoop, toolWaste };
+    source: {
+      onSpan(handler) {
+        subs.add(handler);
+        return () => subs.delete(handler);
+      },
+      collect: () => Promise.resolve([...spans])
+    }
+  };
+}
+function createPartsTraceSource(opts) {
+  const runId = opts.runId ?? `parts-${runSeq++}`;
+  const now = opts.now ?? Date.now;
+  const subs = /* @__PURE__ */ new Set();
+  const seenLive = /* @__PURE__ */ new Set();
+  let liveSeq = 0;
+  let unsub;
+  const startLive = () => {
+    if (unsub || !opts.subscribeParts) return;
+    unsub = opts.subscribeParts((part) => {
+      const step = decodeToolPart(part, opts.harness);
+      if (!step) return;
+      if (step.callId) {
+        if (seenLive.has(step.callId)) return;
+        seenLive.add(step.callId);
+      }
+      const span = toToolSpan(step, runId, liveSeq++, now());
+      for (const fn of subs) {
+        try {
+          fn(span);
+        } catch {
+        }
+      }
+    });
+  };
+  return {
+    onSpan(handler) {
+      subs.add(handler);
+      startLive();
+      return () => {
+        subs.delete(handler);
+        if (subs.size === 0 && unsub) {
+          unsub();
+          unsub = void 0;
+        }
+      };
     },
-    reset() {
-      steps = [];
+    async collect() {
+      const parts = await opts.collectParts();
+      const spans = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const part of parts) {
+        const step = decodeToolPart(part, opts.harness);
+        if (!step) continue;
+        if (step.callId) {
+          if (seen.has(step.callId)) continue;
+          seen.add(step.callId);
+        }
+        spans.push(toToolSpan(step, runId, spans.length, now()));
+      }
+      return spans;
     }
   };
 }
+function sandboxSessionTraceSource(box, sessionId, opts = {}) {
+  return createPartsTraceSource({
+    collectParts: async () => {
+      const msgs = await box.messages({ sessionId });
+      return msgs.flatMap((m) => m.parts ? [...m.parts] : []);
+    },
+    ...opts.harness ? { harness: opts.harness } : {},
+    ...opts.subscribeParts ? { subscribeParts: opts.subscribeParts } : {},
+    runId: opts.runId ?? `box-${sessionId}`,
+    ...opts.now ? { now: opts.now } : {}
+  });
+}
+
+// src/runtime/supervise/trajectory-recorder.ts
+import { buildTrajectory, InMemoryTraceStore } from "@tangle-network/agent-eval";
+import { stuckLoopView, toolWasteView } from "@tangle-network/agent-eval/pipelines";
+async function analyzeTrace(source, runId = "worker") {
+  const spans = await source.collect();
+  const store = new InMemoryTraceStore();
+  for (let i = 0; i < spans.length; i += 1) {
+    const s = spans[i];
+    if (s) await store.appendSpan({ ...s, runId, spanId: `${runId}-t${i}` });
+  }
+  const [trajectory, stuckLoop, toolWaste] = await Promise.all([
+    buildTrajectory(store, runId),
+    stuckLoopView(store, { runId }),
+    toolWasteView(store, { runId })
+  ]);
+  return { trajectory, stuckLoop, toolWaste };
+}
 
 // src/runtime/verifier-environment.ts
 var submitTool = {
@@ -10279,9 +10430,18 @@ export {
   createInProcessTransport,
   serveCoordinationMcp,
   defaultToolDetectors,
-  createDetectorMonitor,
+  watchTrace,
   routerDriverChat,
-  createTrajectoryRecorder,
+  toToolSpan,
+  decodeOpencodePart,
+  decodeAnthropicPart,
+  decodeOpenAiPart,
+  toolPartDecoders,
+  decodeToolPart,
+  createPushTraceSource,
+  createPartsTraceSource,
+  sandboxSessionTraceSource,
+  analyzeTrace,
   createVerifierEnvironment,
   createWaterfallCollector,
   localShell,
@@ -10289,4 +10449,4 @@ export {
   jjWorkspace,
   runInWorkspace
 };
-//# sourceMappingURL=chunk-RLDUT4JL.js.map
+//# sourceMappingURL=chunk-45D64J7B.js.map