@tangle-network/traces 0.8.25 → 0.8.26

package/dist/{chunk-SV7GW5LB.js → chunk-6N2KVDOU.js}

@@ -297,7 +297,9 @@ import { computeToolUseMetrics } from "@tangle-network/agent-eval";
 import { stuckLoopView } from "@tangle-network/agent-eval/pipelines";
 async function runPipelines(spans, opts = {}) {
   const { store, runIds } = await toRuntimeStore(spans);
-  const stuckLoops = await stuckLoopView(store, { minOccurrences: opts.minLoopOccurrences ?? 3 });
+  const loopEligible = spans.filter((item) => item.attributes["traces.expected_blocking"] !== true);
+  const { store: loopStore } = await toRuntimeStore(loopEligible);
+  const stuckLoops = await stuckLoopView(loopStore, { minOccurrences: opts.minLoopOccurrences ?? 3 });
   const toolUse = await Promise.all(runIds.map((runId) => computeToolUseMetrics(store, runId)));
   return { stuckLoops, toolUse };
 }
@@ -808,6 +810,33 @@ function outputIsError(output) {
   const error = /"success"\s*:\s*false|exit(?:_| )code["\s:]+[1-9]|\bcommand failed\b|\bENOENT\b|\berror:/i.test(s);
   return { error, message: error ? s.slice(0, 500) : "" };
 }
+function singleNestedToolName(input) {
+  if (!input) return null;
+  const names = [...input.matchAll(/\btools\.([A-Za-z][A-Za-z0-9_]*)\s*\(/g)].map((match) => match[1]);
+  const unique = [...new Set(names)];
+  return unique.length === 1 ? unique[0] : null;
+}
+function toolInputToString(input) {
+  if (typeof input === "string") return input;
+  if (input == null) return void 0;
+  return JSON.stringify(input);
+}
+var verificationCommand = /\b(?:pnpm|npm|yarn|bun)\s+(?:run\s+)?(?:test|typecheck|lint|build|check)(?::[A-Za-z0-9:_-]+)?\b|\b(?:vitest|jest|pytest|tsc|biome|eslint|sha256sum|pdfinfo|pdftotext)\b|\bgo\s+test\b|\bcargo\s+(?:test|check|clippy|build)\b|\bgit\s+(?:status|diff|show|merge-tree)\b|\bgh-drew\s+pr\s+(?:view|checks)\b/i;
+function hasReadOnlyCurl(input) {
+  if (!/\bcurl\b/i.test(input)) return false;
+  const method = input.match(/(?:^|\s)-X(?:=|\s*)([A-Za-z]+)\b/)?.[1] ?? input.match(/(?:^|\s)--request(?:=|\s+)([A-Za-z]+)\b/i)?.[1];
+  if (method && !/^(?:GET|HEAD)$/i.test(method)) return false;
+  return !/(?:^|\s)-(?:d|F|T)(?:\S*|\s+\S+)|(?:^|\s)--(?:data(?:-ascii|-binary|-raw|-urlencode)?|form(?:-string)?|json|upload-file)(?:=|\s)/i.test(input);
+}
+function classifyNestedTool(name, input) {
+  return name === "exec_command" && input && (verificationCommand.test(input) || hasReadOnlyCurl(input)) ? "exec_command.verify" : name;
+}
+function isExpectedBlockingTool(name, input) {
+  if (!input) return false;
+  if (name === "wait") return /\bcell_id\b["']?\s*:/.test(input);
+  if (name === "write_stdin") return /\bsession_id\b["']?\s*:/.test(input);
+  return false;
+}
 async function* walkRollouts(root) {
   let years;
   try {
@@ -901,6 +930,7 @@ var CodexAdapter = class {
       })
     ];
     const toolByCallId = /* @__PURE__ */ new Map();
+    const subagentByThreadId = /* @__PURE__ */ new Map();
     let step = 0;
     let lastLlm = rootId;
     let sawUserTurn = false;
@@ -929,9 +959,14 @@ var CodexAdapter = class {
           lastLlm = id;
           step += 1;
         }
-      } else if (l.type === "response_item" && l.payload?.type === "function_call") {
-        const name = l.payload.name ?? "tool";
+      } else if (l.type === "response_item" && (l.payload?.type === "function_call" || l.payload?.type === "custom_tool_call")) {
+        const outerName = l.payload.name ?? "tool";
         const callId = l.payload.call_id ?? `${step}`;
+        const input = toolInputToString(
+          l.payload.type === "custom_tool_call" ? l.payload.input : l.payload.arguments
+        );
+        const nestedName = l.payload.type === "custom_tool_call" ? singleNestedToolName(input) : null;
+        const name = classifyNestedTool(nestedName ?? outerName, input);
         const toolSpan = span({
           traceId,
           spanId: `tool:${callId}`,
@@ -943,18 +978,68 @@ var CodexAdapter = class {
           agent: SERVICE3,
           tool: name,
           step,
-          content: l.payload.arguments ?? null
+          content: input ?? null,
+          extra: {
+            "traces.codex.call_type": l.payload.type,
+            ...name !== outerName ? { "traces.codex.outer_tool_name": outerName } : {},
+            ...nestedName ? { "traces.codex.nested_tool_name": nestedName } : {},
+            ...isExpectedBlockingTool(name, input) ? { "traces.expected_blocking": true } : {}
+          }
         });
         spans.push(toolSpan);
         toolByCallId.set(callId, toolSpan);
         step += 1;
-      } else if (l.type === "response_item" && l.payload?.type === "function_call_output") {
+      } else if (l.type === "response_item" && (l.payload?.type === "function_call_output" || l.payload?.type === "custom_tool_call_output")) {
         const t = toolByCallId.get(l.payload.call_id ?? "");
         if (t) {
           const { error, message } = outputIsError(l.payload.output);
           t.end_time = ts;
           t.status = error ? { code: "ERROR", message } : { code: "OK" };
         }
+      } else if (l.type === "event_msg" && l.payload?.type === "sub_agent_activity") {
+        const threadId = l.payload.agent_thread_id;
+        const occurredAtMs = l.payload.occurred_at_ms;
+        const eventTime = typeof occurredAtMs === "number" && Number.isFinite(occurredAtMs) ? new Date(occurredAtMs).toISOString() : ts;
+        if (l.payload.kind === "started" && threadId && !subagentByThreadId.has(threadId)) {
+          const agentPath = l.payload.agent_path ?? "subagent";
+          const subagentType = agentPath.split("/").filter(Boolean).at(-1) ?? "subagent";
+          const toolSpan = span({
+            traceId,
+            spanId: `subagent:${threadId}`,
+            parentSpanId: lastLlm,
+            name: "tool.Agent",
+            kind: "TOOL",
+            startTime: eventTime,
+            service: SERVICE3,
+            agent: SERVICE3,
+            tool: "Agent",
+            step,
+            content: JSON.stringify({
+              subagent_type: subagentType,
+              agent_path: agentPath,
+              agent_thread_id: threadId
+            }),
+            extra: {
+              "traces.codex.subagent_path": agentPath,
+              "traces.codex.subagent_thread_id": threadId
+            }
+          });
+          spans.push(toolSpan);
+          subagentByThreadId.set(threadId, toolSpan);
+          step += 1;
+        } else if (l.payload.kind === "completed" && threadId) {
+          const toolSpan = subagentByThreadId.get(threadId);
+          if (toolSpan) {
+            toolSpan.end_time = eventTime;
+            toolSpan.status = { code: "OK" };
+          }
+        } else if (["interrupted", "failed", "timed_out"].includes(l.payload.kind ?? "") && threadId) {
+          const toolSpan = subagentByThreadId.get(threadId);
+          if (toolSpan) {
+            toolSpan.end_time = eventTime;
+            toolSpan.status = { code: "ERROR", message: `subagent ${l.payload.kind}` };
+          }
+        }
       } else if (l.type === "response_item" && l.payload?.type === "message" && l.payload.role === "user") {
         const prompt = textOf3(l.payload.content);
         if (prompt) {

package/dist/cli.js

@@ -44,7 +44,7 @@ import {
   writePolicyEvidenceFile,
   writeSessionIndexFile,
   writeTraceEvidenceExportFile
-} from "./chunk-SV7GW5LB.js";
+} from "./chunk-6N2KVDOU.js";
 
 // src/cli.ts
 import { readFileSync } from "fs";

package/dist/index.d.ts

@@ -314,7 +314,8 @@ declare class ClaudeAdapter implements HarnessTraceAdapter {
  * Line types: `session_meta` (id + cwd), `turn_context`, `event_msg`
  * (carries `token_count` with per-turn `last_token_usage`), and
  * `response_item` (the OpenAI Responses items: `message`, `reasoning`,
- * `function_call`, `function_call_output`).
+ * function/custom tool calls, and their outputs). Current Codex builds also
+ * emit `sub_agent_activity` events for delegated agents.
  *
  * Token trajectory comes from the `token_count` deltas (Codex puts usage
  * on events, not on the message). Tools come from `function_call`, with
@@ -629,7 +630,9 @@ declare const CORRECTIVE_REACTIONS: readonly Reaction[];
  * error rates above, so adding it would only emit a misleading waste %.
  *
  * Both are cheap ($0, deterministic), so they're safe to run continuously in
- * `watch` mode, over the OTLP spans traces already produces.
+ * `watch` mode, over the OTLP spans traces already produces. Calls explicitly
+ * marked as expected blocking stay in usage totals but are excluded from
+ * stuck-loop findings.
  */
 
 interface PipelineReport {

package/dist/index.js

@@ -99,7 +99,7 @@ import {
   writeSessionIndexFile,
   writeTraceEvidenceExportFile,
   writeTraceImprovementArtifacts
-} from "./chunk-SV7GW5LB.js";
+} from "./chunk-6N2KVDOU.js";
 
 // src/collect.ts
 async function collectSessions(opts = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/traces",
-  "version": "0.8.25",
+  "version": "0.8.26",
   "description": "Point it at your coding-agent session traces (Claude Code, Codex, OpenCode, Gemini, Pi, …) and get failure-mode + efficiency findings. CLI + SDK over the @tangle-network/agent-eval analyst suite — observe live sessions, run your own analysts, redact, and upload to the Tangle Intelligence Platform.",
   "type": "module",
   "license": "MIT",