@tangle-network/traces 0.9.5 → 0.9.6

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

@@ -920,10 +920,12 @@ function classifyReaction(text) {
 var CORRECTIVE_REACTIONS = ["correction", "frustration", "jargon", "structure"];
 
 // src/adapters/claude.ts
+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";
 var SERVICE2 = "claude-code";
+var EPOCH = (/* @__PURE__ */ new Date(0)).toISOString();
 function asBlocks(content) {
   return Array.isArray(content) ? content : [];
 }
@@ -943,10 +945,93 @@ function stringifyToolResult(content) {
 function createClaudeStream(startStep) {
   return { spans: [], toolSpanByUseId: /* @__PURE__ */ new Map(), step: startStep, sawUserTurn: false };
 }
-function consumeClaudeEvent(ev, ctx, state) {
-  const ts = ev.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
-  const uid = ev.uuid ?? `${ctx.idPrefix}step${state.step}`;
-  if (ev.type === "assistant" && ev.message) {
+var ClaudeEventConflictError = class extends Error {
+  sourcePath;
+  eventId;
+  constructor(sourcePath, eventId) {
+    super(`${sourcePath}: Claude transcript event ${JSON.stringify(eventId)} has conflicting payloads`);
+    this.name = "ClaudeEventConflictError";
+    this.sourcePath = sourcePath;
+    this.eventId = eventId;
+  }
+};
+function projectToolResult(toolUseId, isError, output) {
+  return {
+    toolUseId,
+    isError,
+    attributes: toolIoAttributes({ output }),
+    message: stringifyToolResult(output).slice(0, 500)
+  };
+}
+function projectClaudeEvent(event) {
+  const timestamp = event.timestamp ?? EPOCH;
+  if (event.type === "assistant" && event.message) {
+    const tools = [];
+    for (const block of asBlocks(event.message.content)) {
+      if (block.type !== "tool_use" || !block.name) continue;
+      tools.push({ id: block.id || null, name: block.name, attributes: toolIoAttributes({ input: block.input }) });
+    }
+    return {
+      kind: "assistant",
+      timestamp,
+      model: event.message.model ?? null,
+      inputTokens: event.message.usage?.input_tokens ?? null,
+      outputTokens: event.message.usage?.output_tokens ?? null,
+      cachedInputTokens: event.message.usage?.cache_read_input_tokens ?? null,
+      cacheWriteInputTokens: event.message.usage?.cache_creation_input_tokens ?? null,
+      content: textOf2(event.message.content) || null,
+      tools
+    };
+  }
+  if (event.type === "user" && event.message) {
+    const results = [];
+    for (const block of asBlocks(event.message.content)) {
+      if (block.type !== "tool_result" || !block.tool_use_id) continue;
+      results.push(projectToolResult(block.tool_use_id, block.is_error === true, block.content));
+    }
+    const prompt = textOf2(event.message.content);
+    return {
+      kind: "user",
+      timestamp,
+      prompt: prompt || null,
+      ...prompt ? { isSidechain: event.isSidechain === true, userType: event.userType ?? null } : {},
+      results
+    };
+  }
+  if (event.type === "attachment" && event.attachment?.type === "tool_result" && event.attachment.toolUseID) {
+    return {
+      kind: "attachment",
+      timestamp,
+      result: projectToolResult(
+        event.attachment.toolUseID,
+        typeof event.attachment.exitCode === "number" && event.attachment.exitCode !== 0,
+        event.attachment.stderr ?? ""
+      )
+    };
+  }
+  return { kind: "ignored" };
+}
+function fingerprintClaudeEvent(event) {
+  return createHash4("sha256").update(JSON.stringify(event)).digest("hex");
+}
+function consumeDistinctClaudeEvent(event, ctx, state, seen, sourcePath) {
+  const projection = projectClaudeEvent(event);
+  if (event.uuid) {
+    const fingerprint = fingerprintClaudeEvent(projection);
+    const previous = seen.get(event.uuid);
+    if (previous !== void 0) {
+      if (previous !== fingerprint) {
+        throw new ClaudeEventConflictError(sourcePath, event.uuid);
+      }
+      return false;
+    }
+    seen.set(event.uuid, fingerprint);
+  }
+  consumeClaudeEvent(projection, event.uuid ?? `${ctx.idPrefix}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({
@@ -955,47 +1040,45 @@ function consumeClaudeEvent(ev, ctx, state) {
         parentSpanId: ctx.rootParent,
         name: "llm.turn",
         kind: "LLM",
-        startTime: ts,
+        startTime: event.timestamp,
         service: SERVICE2,
         agent: ctx.agent,
-        model: ev.message.model ?? null,
-        inputTokens: ev.message.usage?.input_tokens ?? null,
-        outputTokens: ev.message.usage?.output_tokens ?? null,
-        cachedInputTokens: ev.message.usage?.cache_read_input_tokens ?? null,
-        cacheWriteInputTokens: ev.message.usage?.cache_creation_input_tokens ?? null,
+        model: event.model,
+        inputTokens: event.inputTokens,
+        outputTokens: event.outputTokens,
+        cachedInputTokens: event.cachedInputTokens,
+        cacheWriteInputTokens: event.cacheWriteInputTokens,
         step: state.step,
-        content: textOf2(ev.message.content) || null
+        content: event.content
       })
     );
     state.step += 1;
     let toolIdx = 0;
-    for (const block of asBlocks(ev.message.content)) {
-      if (block.type !== "tool_use" || !block.name) continue;
+    for (const tool of event.tools) {
       const toolSpan = span({
         traceId: ctx.traceId,
         spanId: `${ctx.idPrefix}${uid}:tool:${toolIdx}`,
         parentSpanId: llmId,
-        name: `tool.${block.name}`,
+        name: `tool.${tool.name}`,
         kind: "TOOL",
-        startTime: ts,
+        startTime: event.timestamp,
         service: SERVICE2,
         agent: ctx.agent,
-        tool: block.name,
+        tool: tool.name,
         step: state.step,
-        extra: toolIoAttributes({ input: block.input })
+        extra: tool.attributes
       });
       state.spans.push(toolSpan);
-      if (block.id) state.toolSpanByUseId.set(block.id, toolSpan);
+      if (tool.id) state.toolSpanByUseId.set(tool.id, toolSpan);
       toolIdx += 1;
       state.step += 1;
     }
-  } else if (ev.type === "user" && ev.message) {
-    const prompt = textOf2(ev.message.content);
-    if (prompt) {
+  } else if (event.kind === "user") {
+    if (event.prompt) {
       const actor = claudeActor({
-        text: prompt,
-        isSidechain: ev.isSidechain,
-        userType: ev.userType ?? null,
+        text: event.prompt,
+        isSidechain: event.isSidechain,
+        userType: event.userType ?? null,
         isFirstUserTurn: !state.sawUserTurn
       });
       state.sawUserTurn = true;
@@ -1004,41 +1087,49 @@ function consumeClaudeEvent(ev, ctx, state) {
           traceId: ctx.traceId,
           spanId: `${ctx.idPrefix}${uid}:user`,
           parentSpanId: ctx.rootParent,
-          startTime: ts,
+          startTime: event.timestamp,
           service: SERVICE2,
           agent: ctx.agent,
           step: state.step,
-          content: prompt,
+          content: event.prompt,
           actor
         })
       );
       state.step += 1;
     }
-    for (const block of asBlocks(ev.message.content)) {
-      if (block.type !== "tool_result" || !block.tool_use_id) continue;
-      backfillResult(
-        state.toolSpanByUseId.get(block.tool_use_id),
-        ts,
-        block.is_error === true,
-        block.content
-      );
+    for (const result of event.results) {
+      backfillResult(state.toolSpanByUseId.get(result.toolUseId), event.timestamp, result);
     }
-  } else if (ev.type === "attachment" && ev.attachment?.type === "tool_result" && ev.attachment.toolUseID) {
-    const err = typeof ev.attachment.exitCode === "number" && ev.attachment.exitCode !== 0;
-    backfillResult(state.toolSpanByUseId.get(ev.attachment.toolUseID), ts, err, ev.attachment.stderr ?? "");
+  } else if (event.kind === "attachment") {
+    backfillResult(state.toolSpanByUseId.get(event.result.toolUseId), event.timestamp, event.result);
   }
 }
 function finishClaudeStream(state) {
   return { spans: state.spans, toolSpanByUseId: state.toolSpanByUseId, nextStep: state.step };
 }
-function backfillResult(s, endTime, isError, output) {
+function setRootTimeBounds(root, spans) {
+  let firstTimestamp;
+  let lastTimestamp;
+  for (const item of spans) {
+    if (item === root) continue;
+    for (const source of [item.start_time, item.end_time]) {
+      if (!source) continue;
+      const value = Date.parse(source);
+      if (!Number.isFinite(value)) continue;
+      if (!firstTimestamp || value < firstTimestamp.value) firstTimestamp = { value, source };
+      if (!lastTimestamp || value > lastTimestamp.value) lastTimestamp = { value, source };
+    }
+  }
+  if (firstTimestamp) root.start_time = firstTimestamp.source;
+  if (lastTimestamp) root.end_time = lastTimestamp.source;
+}
+function backfillResult(s, endTime, result) {
   if (!s) return;
   s.end_time = endTime;
-  const code = isError ? "ERROR" : "OK";
+  const code = result.isError ? "ERROR" : "OK";
   s.status = { code };
-  recordToolOutput(s, output);
-  const message = stringifyToolResult(output);
-  if (isError && message) s.status.message = message.slice(0, 500);
+  Object.assign(s.attributes, result.attributes);
+  if (result.isError && result.message) s.status.message = result.message;
 }
 var ClaudeAdapter = class {
   harness = "claude-code";
@@ -1096,17 +1187,10 @@ var ClaudeAdapter = class {
     };
     const state = createClaudeStream(ctx.startStep);
     let discoveredTraceId;
-    let firstTimestamp;
-    let lastTimestamp;
-    let sawEvent = false;
+    const seen = /* @__PURE__ */ new Map();
     for await (const event of readJsonl(ref.path, sessionJsonlOptions(ref, options))) {
-      if (!sawEvent) {
-        firstTimestamp = event.timestamp;
-        sawEvent = true;
-      }
-      lastTimestamp = event.timestamp;
       if (!discoveredTraceId && event.sessionId) discoveredTraceId = event.sessionId;
-      consumeClaudeEvent(event, ctx, state);
+      if (!consumeDistinctClaudeEvent(event, ctx, state, seen, ref.path)) continue;
     }
     const main = finishClaudeStream(state);
     const traceId = discoveredTraceId ?? sourceTraceId;
@@ -1115,21 +1199,20 @@ var ClaudeAdapter = class {
       item.trace_id = traceId;
       if (item.parent_span_id === sourceRootId) item.parent_span_id = rootId;
     }
-    const spans = [
-      span({
-        traceId,
-        spanId: rootId,
-        parentSpanId: null,
-        name: "session",
-        kind: "AGENT",
-        startTime: firstTimestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-        endTime: lastTimestamp,
-        service: SERVICE2,
-        agent: SERVICE2
-      })
-    ];
+    const root = span({
+      traceId,
+      spanId: rootId,
+      parentSpanId: null,
+      name: "session",
+      kind: "AGENT",
+      startTime: (/* @__PURE__ */ new Date(0)).toISOString(),
+      service: SERVICE2,
+      agent: SERVICE2
+    });
+    const spans = [root];
     appendAll(spans, main.spans);
     await this.foldSubagents(ref, traceId, main, spans, options);
+    setRootTimeBounds(root, spans);
     return spans;
   }
   /** Parse `<session>/subagents/agent-*.jsonl`, parenting each under its Agent call. */
@@ -1162,11 +1245,12 @@ var ClaudeAdapter = class {
         rootParent: parent
       };
       const state = createClaudeStream(ctx.startStep);
+      const seen = /* @__PURE__ */ new Map();
       for await (const event of readJsonl(
         join2(subDir, file),
         sessionJsonlOptions(ref, options)
       )) {
-        consumeClaudeEvent(event, ctx, state);
+        consumeDistinctClaudeEvent(event, ctx, state, seen, join2(subDir, file));
       }
       const parsed = finishClaudeStream(state);
       appendAll(out, parsed.spans);
@@ -3483,7 +3567,7 @@ async function applyRedactor(spans, redactor) {
 }
 
 // src/file-export.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { mkdtemp as mkdtemp2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join13 } from "path";
@@ -3521,7 +3605,7 @@ function stableJson(value) {
   });
 }
 function hashId(value, chars = 16) {
-  return createHash4("sha256").update(stableJson(value)).digest("hex").slice(0, chars);
+  return createHash5("sha256").update(stableJson(value)).digest("hex").slice(0, chars);
 }
 function isoTime(value) {
   if (typeof value === "string") {
@@ -5760,7 +5844,7 @@ async function saveReport(path, report) {
 }
 
 // src/live.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 var VERIFY_RE = /\b(test|tests|vitest|jest|pytest|go test|cargo test|tsc|typecheck|lint|biome|eslint|build|check:invariants|preflight)\b/i;
 var CHANGE_RE = /\b(apply_patch|edit|write|create|delete|rename|replace|update|git apply|sed -i|perl -pi|tee\s|cat\s+>)/i;
 var CLAIM_DONE_RE = /\b(done|fixed|complete|completed|implemented|merged|verified|all green|tests pass|ready|works now)\b/i;
@@ -5780,7 +5864,7 @@ var sleep = (ms, signal) => new Promise((resolve2) => {
   signal?.addEventListener("abort", onAbort, { once: true });
 });
 function hash(parts) {
-  return createHash5("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
+  return createHash6("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
 }
 function asString(value) {
   if (typeof value === "string" && value.trim()) return value;

package/dist/cli.js

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

package/dist/index.js

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

package/package.json

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