@tangle-network/traces 0.9.6 → 0.9.7

package/dist/{chunk-NP3ZIUR2.js → chunk-NHXPTFKC.js}

@@ -923,7 +923,14 @@ var CORRECTIVE_REACTIONS = ["correction", "frustration", "jargon", "structure"];
 import { createHash as createHash4 } from "crypto";
 import { readdir as readdir3, stat as stat2 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { basename as basename2, join as join2 } from "path";
+import { basename as basename2, join as join2, relative } from "path";
+import {
+  applyLlmSpanOtlpAttributes as applyLlmSpanOtlpAttributes2,
+  LLM_CACHED_TOKENS,
+  LLM_CACHE_WRITE_TOKENS,
+  LLM_INPUT_TOKENS,
+  LLM_OUTPUT_TOKENS
+} from "@tangle-network/agent-eval/trace-attributes";
 var SERVICE2 = "claude-code";
 var EPOCH = (/* @__PURE__ */ new Date(0)).toISOString();
 function asBlocks(content) {
@@ -943,7 +950,15 @@ function stringifyToolResult(content) {
   return "";
 }
 function createClaudeStream(startStep) {
-  return { spans: [], toolSpanByUseId: /* @__PURE__ */ new Map(), step: startStep, sawUserTurn: false };
+  return {
+    spans: [],
+    toolSpanByUseId: /* @__PURE__ */ new Map(),
+    llmSpanByMessageId: /* @__PURE__ */ new Map(),
+    llmContentByMessageId: /* @__PURE__ */ new Map(),
+    toolCountByMessageId: /* @__PURE__ */ new Map(),
+    step: startStep,
+    sawUserTurn: false
+  };
 }
 var ClaudeEventConflictError = class extends Error {
   sourcePath;
@@ -974,6 +989,7 @@ function projectClaudeEvent(event) {
     return {
       kind: "assistant",
       timestamp,
+      messageId: event.message.id ?? null,
       model: event.message.model ?? null,
       inputTokens: event.message.usage?.input_tokens ?? null,
       outputTokens: event.message.usage?.output_tokens ?? null,
@@ -1027,16 +1043,17 @@ function consumeDistinctClaudeEvent(event, ctx, state, seen, sourcePath) {
     }
     seen.set(event.uuid, fingerprint);
   }
-  consumeClaudeEvent(projection, event.uuid ?? `${ctx.idPrefix}step${state.step}`, ctx, state);
+  consumeClaudeEvent(projection, event.uuid ?? `step${state.step}`, ctx, state);
   return true;
 }
 function consumeClaudeEvent(event, uid, ctx, state) {
   if (event.kind === "assistant") {
-    const llmId = `${ctx.idPrefix}${uid}`;
-    state.spans.push(
-      span({
+    const messageId = event.messageId ?? uid;
+    let llmSpan = state.llmSpanByMessageId.get(messageId);
+    if (!llmSpan) {
+      llmSpan = span({
         traceId: ctx.traceId,
-        spanId: llmId,
+        spanId: `${ctx.idPrefix}${uid}`,
         parentSpanId: ctx.rootParent,
         name: "llm.turn",
         kind: "LLM",
@@ -1048,17 +1065,46 @@ function consumeClaudeEvent(event, uid, ctx, state) {
         outputTokens: event.outputTokens,
         cachedInputTokens: event.cachedInputTokens,
         cacheWriteInputTokens: event.cacheWriteInputTokens,
-        step: state.step,
-        content: event.content
-      })
-    );
-    state.step += 1;
-    let toolIdx = 0;
+        step: state.step
+      });
+      state.spans.push(llmSpan);
+      state.llmSpanByMessageId.set(messageId, llmSpan);
+      state.step += 1;
+    } else {
+      includeSpanTimestamp(llmSpan, event.timestamp);
+    }
+    applyLlmSpanOtlpAttributes2(llmSpan.attributes, {
+      model: event.model ?? void 0,
+      inputTokens: maxCapturedUsage(
+        llmSpan.attributes[LLM_INPUT_TOKENS],
+        event.inputTokens
+      ),
+      outputTokens: maxCapturedUsage(
+        llmSpan.attributes[LLM_OUTPUT_TOKENS],
+        event.outputTokens
+      ),
+      cachedTokens: maxCapturedUsage(
+        llmSpan.attributes[LLM_CACHED_TOKENS],
+        event.cachedInputTokens
+      ),
+      cacheWriteTokens: maxCapturedUsage(
+        llmSpan.attributes[LLM_CACHE_WRITE_TOKENS],
+        event.cacheWriteInputTokens
+      )
+    });
+    mergeMessageContent(llmSpan, messageId, event.content, state);
     for (const tool of event.tools) {
+      const existingTool = tool.id ? state.toolSpanByUseId.get(tool.id) : void 0;
+      if (existingTool) {
+        Object.assign(existingTool.attributes, tool.attributes);
+        includeSpanTimestamp(existingTool, event.timestamp);
+        continue;
+      }
+      const toolIdx = state.toolCountByMessageId.get(messageId) ?? 0;
       const toolSpan = span({
         traceId: ctx.traceId,
-        spanId: `${ctx.idPrefix}${uid}:tool:${toolIdx}`,
-        parentSpanId: llmId,
+        spanId: `${llmSpan.span_id}:tool:${toolIdx}`,
+        parentSpanId: llmSpan.span_id,
         name: `tool.${tool.name}`,
         kind: "TOOL",
         startTime: event.timestamp,
@@ -1070,7 +1116,7 @@ function consumeClaudeEvent(event, uid, ctx, state) {
       });
       state.spans.push(toolSpan);
       if (tool.id) state.toolSpanByUseId.set(tool.id, toolSpan);
-      toolIdx += 1;
+      state.toolCountByMessageId.set(messageId, toolIdx + 1);
       state.step += 1;
     }
   } else if (event.kind === "user") {
@@ -1104,6 +1150,28 @@ function consumeClaudeEvent(event, uid, ctx, state) {
     backfillResult(state.toolSpanByUseId.get(event.result.toolUseId), event.timestamp, event.result);
   }
 }
+function maxCapturedUsage(current, next) {
+  const captured = typeof current === "number" && Number.isFinite(current) ? current : void 0;
+  if (next == null) return captured;
+  return captured === void 0 ? next : Math.max(captured, next);
+}
+function includeSpanTimestamp(target, timestamp) {
+  if (!timestamp) return;
+  const time = Date.parse(timestamp);
+  if (!Number.isFinite(time)) return;
+  const start = Date.parse(target.start_time);
+  const end = Date.parse(target.end_time);
+  if (!Number.isFinite(start) || time < start) target.start_time = timestamp;
+  if (!Number.isFinite(end) || time > end) target.end_time = timestamp;
+}
+function mergeMessageContent(llmSpan, messageId, content, state) {
+  if (!content) return;
+  const parts = state.llmContentByMessageId.get(messageId) ?? /* @__PURE__ */ new Set();
+  if (parts.has(content)) return;
+  parts.add(content);
+  state.llmContentByMessageId.set(messageId, parts);
+  llmSpan.attributes.content = capText([...parts].join("\n"));
+}
 function finishClaudeStream(state) {
   return { spans: state.spans, toolSpanByUseId: state.toolSpanByUseId, nextStep: state.step };
 }
@@ -1131,6 +1199,30 @@ function backfillResult(s, endTime, result) {
   Object.assign(s.attributes, result.attributes);
   if (result.isError && result.message) s.status.message = result.message;
 }
+async function listSubagentFiles(root) {
+  const pending = [root];
+  const files = [];
+  while (pending.length > 0) {
+    const dir = pending.pop();
+    if (!dir) continue;
+    let entries;
+    try {
+      entries = await readdir3(dir, { withFileTypes: true });
+    } catch (error) {
+      if (isMissingPathError(error)) continue;
+      throw error;
+    }
+    for (const entry of entries) {
+      const path = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        pending.push(path);
+      } else if (entry.isFile() && /^agent-.*\.jsonl$/.test(entry.name)) {
+        files.push(path);
+      }
+    }
+  }
+  return files.sort();
+}
 var ClaudeAdapter = class {
   harness = "claude-code";
   aliases = ["claude", "claudish", "openclaw", "nanoclaw"];
@@ -1215,47 +1307,59 @@ var ClaudeAdapter = class {
     setRootTimeBounds(root, spans);
     return spans;
   }
-  /** Parse `<session>/subagents/agent-*.jsonl`, parenting each under its Agent call. */
+  /** Parse nested `subagents/.../agent-*.jsonl`, parenting each under its Agent call. */
   async foldSubagents(ref, traceId, main, out, options) {
     const subDir = join2(ref.path.replace(/\.jsonl$/, ""), "subagents");
-    let files;
-    try {
-      files = await readdir3(subDir);
-    } catch (error) {
-      if (isMissingPathError(error)) return;
-      throw error;
-    }
+    const files = await listSubagentFiles(subDir);
     let step = main.nextStep;
+    const parsedAgents = [];
     for (const file of files) {
-      if (!file.endsWith(".jsonl")) continue;
-      const hash2 = basename2(file, ".jsonl");
-      const metaPath = join2(subDir, `${hash2}.meta.json`);
+      const sourceKey = relative(subDir, file).replace(/\.jsonl$/, "").split(/[\\/]/).map((segment) => encodeURIComponent(segment)).join(":");
+      const metaPath = file.replace(/\.jsonl$/, ".meta.json");
       let meta = {};
       try {
         meta = await readJsonFile(metaPath);
       } catch (error) {
         if (!isMissingJsonSource(error)) throw error;
       }
-      const parent = meta.toolUseId && main.toolSpanByUseId.get(meta.toolUseId)?.span_id || `root:${traceId}`;
       const ctx = {
         traceId,
         agent: meta.agentType ? `subagent:${meta.agentType}` : "subagent",
         startStep: step,
-        idPrefix: `${hash2}:`,
-        rootParent: parent
+        idPrefix: `${sourceKey}:`,
+        rootParent: `root:${traceId}`
       };
       const state = createClaudeStream(ctx.startStep);
       const seen = /* @__PURE__ */ new Map();
       for await (const event of readJsonl(
-        join2(subDir, file),
+        file,
         sessionJsonlOptions(ref, options)
       )) {
-        consumeDistinctClaudeEvent(event, ctx, state, seen, join2(subDir, file));
+        consumeDistinctClaudeEvent(event, ctx, state, seen, file);
       }
       const parsed = finishClaudeStream(state);
-      appendAll(out, parsed.spans);
+      parsedAgents.push({
+        agentId: basename2(file, ".jsonl").replace(/^agent-/, ""),
+        meta,
+        parsed
+      });
       step = parsed.nextStep;
     }
+    const byAgentId = /* @__PURE__ */ new Map();
+    for (const agent of parsedAgents) {
+      if (byAgentId.has(agent.agentId)) {
+        throw new Error(`Duplicate Claude subagent id: ${agent.agentId}`);
+      }
+      byAgentId.set(agent.agentId, agent.parsed);
+    }
+    for (const agent of parsedAgents) {
+      const parentTools = agent.meta.parentAgentId ? byAgentId.get(agent.meta.parentAgentId)?.toolSpanByUseId : main.toolSpanByUseId;
+      const parent = agent.meta.toolUseId && parentTools?.get(agent.meta.toolUseId)?.span_id || `root:${traceId}`;
+      for (const item of agent.parsed.spans) {
+        if (item.parent_span_id === `root:${traceId}`) item.parent_span_id = parent;
+      }
+      appendAll(out, agent.parsed.spans);
+    }
   }
 };
 
@@ -3574,15 +3678,15 @@ import { join as join13 } from "path";
 import {
   firstNumberAttr,
   LLM_CACHED_TOKEN_ATTR_KEYS,
-  LLM_CACHED_TOKENS,
+  LLM_CACHED_TOKENS as LLM_CACHED_TOKENS2,
   LLM_CACHE_WRITE_TOKEN_ATTR_KEYS,
-  LLM_CACHE_WRITE_TOKENS,
+  LLM_CACHE_WRITE_TOKENS as LLM_CACHE_WRITE_TOKENS2,
   LLM_COST_ATTR_KEYS,
   LLM_COST_USD,
   LLM_INPUT_TOKEN_ATTR_KEYS,
-  LLM_INPUT_TOKENS,
+  LLM_INPUT_TOKENS as LLM_INPUT_TOKENS2,
   LLM_OUTPUT_TOKEN_ATTR_KEYS,
-  LLM_OUTPUT_TOKENS,
+  LLM_OUTPUT_TOKENS as LLM_OUTPUT_TOKENS2,
   LLM_REASONING_TOKEN_ATTR_KEYS,
   LLM_REASONING_TOKENS
 } from "@tangle-network/agent-eval/trace-attributes";
@@ -3971,11 +4075,11 @@ var COMPUTED_SPAN_ATTRIBUTES = /* @__PURE__ */ new Set([
   "tool.name",
   "llm.input_tokens",
   "llm.output_tokens",
-  LLM_INPUT_TOKENS,
-  LLM_OUTPUT_TOKENS,
+  LLM_INPUT_TOKENS2,
+  LLM_OUTPUT_TOKENS2,
   LLM_REASONING_TOKENS,
-  LLM_CACHED_TOKENS,
-  LLM_CACHE_WRITE_TOKENS,
+  LLM_CACHED_TOKENS2,
+  LLM_CACHE_WRITE_TOKENS2,
   LLM_COST_USD,
   "step",
   "content"

package/dist/cli.js

@@ -40,7 +40,7 @@ import {
   writePolicyEvidenceFile,
   writeSessionIndexFile,
   writeTraceEvidenceExportFile
-} from "./chunk-NP3ZIUR2.js";
+} from "./chunk-NHXPTFKC.js";
 
 // src/cli.ts
 import { readFileSync } from "fs";

package/dist/index.d.ts

@@ -399,7 +399,7 @@ declare function stampSpanWorkdirRepoAttrs(spans: readonly OtlpSpan[]): Promise<
  * (token trajectory) and `message.content[]` tool_use blocks; tool results
  * arrive as `tool_result` blocks in the following user message or as a
  * `tool_result` attachment. Subagent runs live in a sibling
- * `<session>/subagents/agent-*.jsonl` with a `.meta.json` carrying the
+ * nested `<session>/subagents/.../agent-*.jsonl` files with a `.meta.json` carrying the
  * spawning `toolUseId`, so we parent each subagent under its `Agent` call.
  *
  * Shared by the claudish / openclaw / nanoclaw forks via aliases — they
@@ -412,7 +412,7 @@ declare class ClaudeAdapter implements HarnessTraceAdapter {
     private root;
     locate(opts?: LocateOptions): Promise<SessionRef[]>;
     parse(ref: SessionRef, options?: ParseOptions): Promise<OtlpSpan[]>;
-    /** Parse `<session>/subagents/agent-*.jsonl`, parenting each under its Agent call. */
+    /** Parse nested `subagents/.../agent-*.jsonl`, parenting each under its Agent call. */
     private foldSubagents;
 }
 

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/traces",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "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",