copilot-tracer 1.0.1

package/dist/otlpReceiver.js

@@ -0,0 +1,415 @@
+/**
+ * OTLP HTTP receiver — accepts traces pushed by GitHub Copilot CLI
+ *
+ * REAL attribute names (verified from live traffic Jul 31 2026):
+ *   invoke_agent span attrs:
+ *     gen_ai.input.messages          — user prompt (JSON string)
+ *     gen_ai.output.messages         — assistant response (JSON string)
+ *     gen_ai.usage.input_tokens
+ *     gen_ai.usage.output_tokens
+ *     gen_ai.usage.cache_read.input_tokens   (NOT cache_read_input_tokens)
+ *     github.copilot.cost            — AI credits (NOT github.copilot.ai_credits)
+ *     gen_ai.request.model
+ *     github.copilot.context.skills
+ *   chat <model> span attrs: same as above
+ *   User message event: github.copilot.user.message
+ */
+import { upsertTrace, createSession, deleteTrace } from './db.js';
+import { traceEvents } from './proxy.js';
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function getAttr(attrs, key) {
+    const kv = attrs?.find(a => a.key === key);
+    if (!kv)
+        return undefined;
+    const v = kv.value;
+    if (v.stringValue !== undefined)
+        return v.stringValue;
+    if (v.intValue !== undefined)
+        return typeof v.intValue === 'string' ? parseInt(v.intValue) : v.intValue;
+    if (v.doubleValue !== undefined)
+        return v.doubleValue;
+    return undefined;
+}
+function nanoToMs(nano) {
+    return Math.round(Number(BigInt(nano) / 1000000n));
+}
+function nanoToIso(nano) {
+    return new Date(nanoToMs(nano)).toISOString();
+}
+const inFlight = new Map(); // traceId → InFlight
+// Sessions we've created in DB (avoid duplicate createSession calls)
+const knownSessions = new Set();
+function ensureSession(sessionId) {
+    if (!knownSessions.has(sessionId)) {
+        createSession(sessionId);
+        knownSessions.add(sessionId);
+    }
+}
+// ── Process one batch of spans ────────────────────────────────────────────────
+// Track standalone chat entries so invoke_agent can replace them (multiple chat spans per traceId)
+const pendingChatIds = new Map(); // `chat:${traceId}` → list of entryIds
+// Buffer tool calls that arrive before invoke_agent
+const pendingToolCalls = new Map(); // traceId → tool calls
+function processSpans(spans, sessionId) {
+    for (const span of spans) {
+        // DEBUG — log raw span to stderr when COPILOT_TRACER_DEBUG=1
+        if (process.env.COPILOT_TRACER_DEBUG === '1') {
+            process.stderr.write('[SPAN] ' + JSON.stringify({ name: span.name, attrs: span.attributes?.map(a => a.key), events: span.events?.map(e => ({ name: e.name, attrKeys: e.attributes?.map(a => a.key) })) }) + '\n');
+        }
+        const attrs = span.attributes ?? [];
+        const spanName = span.name;
+        const traceId = span.traceId;
+        const spanId = span.spanId;
+        // ── invoke_agent span = top-level agent turn ──────────────────────────
+        if (spanName === 'invoke_agent') {
+            const startMs = nanoToMs(span.startTimeUnixNano);
+            const endMs = nanoToMs(span.endTimeUnixNano);
+            const durationMs = endMs - startMs;
+            // Extract prompt from gen_ai.input.messages (real attr name from copilot)
+            let promptText = '';
+            let responseText = '';
+            for (const ev of span.events ?? []) {
+                if (ev.name === 'gen_ai.content.prompt') {
+                    const msg = getAttr(ev.attributes, 'gen_ai.prompt');
+                    if (msg)
+                        promptText = String(msg);
+                }
+                if (ev.name === 'gen_ai.content.completion') {
+                    const msg = getAttr(ev.attributes, 'gen_ai.completion');
+                    if (msg)
+                        responseText = String(msg);
+                }
+                // Real copilot event for user message
+                if (ev.name === 'github.copilot.user.message') {
+                    const msg = getAttr(ev.attributes, 'github.copilot.user.message.text')
+                        ?? getAttr(ev.attributes, 'gen_ai.prompt');
+                    if (msg)
+                        promptText = String(msg);
+                }
+            }
+            // Real attribute names from live copilot traffic
+            if (!promptText) {
+                const raw = getAttr(attrs, 'gen_ai.input.messages');
+                if (raw) {
+                    try {
+                        const msgs = JSON.parse(String(raw));
+                        // Copilot format: [{role, parts:[{type, content}]}]
+                        const userMsg = Array.isArray(msgs)
+                            ? msgs.find((m) => m.role === 'user')
+                            : null;
+                        if (userMsg?.parts) {
+                            promptText = userMsg.parts
+                                .filter((p) => p.type === 'text')
+                                .map((p) => {
+                                // Strip system injections like <current_datetime>...</current_datetime>\n\n
+                                let text = p.content ?? '';
+                                text = text.replace(/<current_datetime>[\s\S]*?<\/current_datetime>\s*/g, '');
+                                text = text.replace(/<system_reminder>[\s\S]*?<\/system_reminder>\s*/g, '');
+                                return text.trim();
+                            })
+                                .join(' ')
+                                .trim()
+                                .slice(0, 300);
+                        }
+                        else {
+                            promptText = (userMsg?.content ?? String(raw)).slice(0, 300);
+                        }
+                    }
+                    catch {
+                        promptText = String(raw).slice(0, 300);
+                    }
+                }
+            }
+            if (!responseText) {
+                const raw = getAttr(attrs, 'gen_ai.output.messages');
+                if (raw) {
+                    try {
+                        const msgs = JSON.parse(String(raw));
+                        const assistantMsg = Array.isArray(msgs)
+                            ? msgs.find((m) => m.role === 'assistant')
+                            : null;
+                        if (assistantMsg?.parts) {
+                            responseText = assistantMsg.parts
+                                .filter((p) => p.type === 'text')
+                                .map((p) => p.content ?? '')
+                                .join(' ')
+                                .slice(0, 1000);
+                        }
+                        else {
+                            responseText = (assistantMsg?.content ?? String(raw)).slice(0, 1000);
+                        }
+                    }
+                    catch {
+                        responseText = String(raw).slice(0, 1000);
+                    }
+                }
+            }
+            // Real credit attrs (verified Jul 31 2026):
+            //   github.copilot.nano_aiu  — divide by 1e9 to get credits (matches copilot terminal output)
+            //   github.copilot.cost      — raw cost value (different unit, do NOT use directly)
+            const rawCost = getAttr(attrs, 'github.copilot.cost');
+            const rawNanoAiu = getAttr(attrs, 'github.copilot.nano_aiu');
+            if (process.env.COPILOT_TRACER_DEBUG === '1') {
+                process.stderr.write(`[CREDITS] cost=${rawCost} nano_aiu=${rawNanoAiu}\n`);
+            }
+            // nano_aiu / 1e9 = credits (e.g. 2289375000 / 1e9 = 2.29 credits)
+            const credits = rawNanoAiu !== undefined
+                ? Number(rawNanoAiu) / 1e9
+                : rawCost !== undefined
+                    ? Number(rawCost)
+                    : 0;
+            const inputTokens = Number(getAttr(attrs, 'gen_ai.usage.input_tokens') ?? 0);
+            const outputTokens = Number(getAttr(attrs, 'gen_ai.usage.output_tokens') ?? 0);
+            // Real cached token attr: gen_ai.usage.cache_read.input_tokens (with dot, not underscore)
+            const cachedTokens = Number(getAttr(attrs, 'gen_ai.usage.cache_read.input_tokens')
+                ?? getAttr(attrs, 'gen_ai.usage.cache_read_input_tokens')
+                ?? 0);
+            // Skills from context
+            const skillsRaw = getAttr(attrs, 'github.copilot.context.skills');
+            const skillCount = skillsRaw ? String(skillsRaw).split(',').filter(Boolean).length : 0;
+            const isError = (span.status?.code ?? 0) === 2; // OTEL status ERROR = 2
+            const entry = {
+                id: spanId,
+                sessionId,
+                dateTime: nanoToIso(span.startTimeUnixNano),
+                prompt: promptText || `[agent turn ${spanId.slice(0, 8)}]`,
+                response: responseText || undefined,
+                tokens: {
+                    input: inputTokens,
+                    output: outputTokens,
+                    cached: cachedTokens,
+                    reasoning: 0,
+                    written: outputTokens,
+                    total: inputTokens + outputTokens,
+                },
+                aiCredits: credits,
+                durationMs,
+                toolCalls: [],
+                skillCount,
+                agentCount: 0,
+                mcpCount: 0,
+                status: isError ? 'error' : 'done',
+                error: isError ? (span.status?.message ?? 'error') : undefined,
+            };
+            inFlight.set(traceId, { entry, toolCalls: new Map(), agentSpanId: spanId });
+            // Flush any tool calls that arrived before invoke_agent
+            const buffered = pendingToolCalls.get(traceId) ?? [];
+            if (buffered.length > 0) {
+                const inf = inFlight.get(traceId);
+                for (const tc of buffered) {
+                    inf.entry.toolCalls.push(tc);
+                    inf.toolCalls.set(tc.id, tc);
+                }
+                let skills = 0, agents = 0, mcps = 0;
+                for (const c of inf.entry.toolCalls) {
+                    if (c.type === 'skill')
+                        skills++;
+                    else if (c.type === 'agent')
+                        agents++;
+                    else if (c.type === 'mcp')
+                        mcps++;
+                }
+                inf.entry.skillCount = skills;
+                inf.entry.agentCount = agents;
+                inf.entry.mcpCount = mcps;
+                pendingToolCalls.delete(traceId);
+            }
+            ensureSession(sessionId);
+            upsertTrace(entry);
+            traceEvents.emit('trace:update', entry);
+            traceEvents.emit('trace:done', entry);
+            // Clean up ALL standalone chat entries for this traceId (invoke_agent replaces them all)
+            const chatKey = `chat:${traceId}`;
+            const staleIds = pendingChatIds.get(chatKey) ?? [];
+            for (const staleId of staleIds) {
+                if (staleId !== entry.id)
+                    deleteTrace(staleId);
+            }
+            pendingChatIds.delete(chatKey);
+            continue;
+        }
+        // ── chat span = LLM call — extract token usage + prompt/response ──────
+        if (spanName.startsWith('chat ') || spanName === 'chat') {
+            const model = String(getAttr(attrs, 'gen_ai.request.model') ?? spanName.replace('chat ', ''));
+            const inputTokens = Number(getAttr(attrs, 'gen_ai.usage.input_tokens') ?? 0);
+            const outputTokens = Number(getAttr(attrs, 'gen_ai.usage.output_tokens') ?? 0);
+            const cachedTokens = Number(getAttr(attrs, 'gen_ai.usage.cache_read_input_tokens') ?? 0);
+            const credits = getAttr(attrs, 'github.copilot.ai_credits');
+            // Extract prompt/response from events
+            let promptText = '';
+            let responseText = '';
+            for (const ev of span.events ?? []) {
+                if (ev.name === 'gen_ai.content.prompt') {
+                    promptText = String(getAttr(ev.attributes, 'gen_ai.prompt') ?? '');
+                }
+                if (ev.name === 'gen_ai.content.completion') {
+                    responseText = String(getAttr(ev.attributes, 'gen_ai.completion') ?? '');
+                }
+            }
+            const inf = inFlight.get(traceId);
+            if (inf) {
+                // Update parent invoke_agent entry with richer data
+                if (!inf.entry.prompt && promptText)
+                    inf.entry.prompt = promptText;
+                if (!inf.entry.response && responseText)
+                    inf.entry.response = responseText;
+                if (inf.entry.tokens.total === 0 && inputTokens + outputTokens > 0) {
+                    inf.entry.tokens = { input: inputTokens, output: outputTokens, cached: cachedTokens, reasoning: 0, written: outputTokens, total: inputTokens + outputTokens };
+                }
+                if (!inf.entry.aiCredits && credits)
+                    inf.entry.aiCredits = Number(credits);
+                upsertTrace(inf.entry);
+                traceEvents.emit('trace:update', inf.entry);
+            }
+            else {
+                // Standalone chat span (no parent invoke_agent) — create its own entry
+                const durationMs = nanoToMs(span.endTimeUnixNano) - nanoToMs(span.startTimeUnixNano);
+                const entry = {
+                    id: spanId,
+                    sessionId,
+                    dateTime: nanoToIso(span.startTimeUnixNano),
+                    prompt: promptText || `[LLM call: ${model}]`,
+                    response: responseText || undefined,
+                    tokens: { input: inputTokens, output: outputTokens, cached: cachedTokens, reasoning: 0, written: outputTokens, total: inputTokens + outputTokens },
+                    aiCredits: credits ? Number(credits) : 0,
+                    durationMs,
+                    toolCalls: [],
+                    skillCount: 0, agentCount: 0, mcpCount: 0,
+                    status: 'done',
+                };
+                ensureSession(sessionId);
+                upsertTrace(entry);
+                const chatKey = `chat:${traceId}`;
+                const existing = pendingChatIds.get(chatKey) ?? [];
+                existing.push(entry.id);
+                pendingChatIds.set(chatKey, existing);
+                traceEvents.emit('trace:update', entry);
+                traceEvents.emit('trace:done', entry);
+            }
+            continue;
+        }
+        // ── execute_tool span = tool call ─────────────────────────────────────
+        if (spanName.startsWith('execute_tool') || spanName === 'execute_tool') {
+            const toolName = String(getAttr(attrs, 'gen_ai.tool.name') ?? getAttr(attrs, 'tool.name') ?? spanName.replace('execute_tool ', '').replace('execute_tool', 'unknown'));
+            const toolType = detectToolType(toolName);
+            const durationMs = nanoToMs(span.endTimeUnixNano) - nanoToMs(span.startTimeUnixNano);
+            const isError = (span.status?.code ?? 0) === 2;
+            const call = {
+                id: spanId,
+                name: toolName,
+                type: toolType,
+                input: {},
+                startedAt: nanoToMs(span.startTimeUnixNano),
+                endedAt: nanoToMs(span.endTimeUnixNano),
+                durationMs,
+                error: isError ? (span.status?.message ?? 'error') : undefined,
+            };
+            // Extract tool input from span attrs (real copilot attr names from debug)
+            // gen_ai.tool.call.arguments — JSON string of args
+            // github.copilot.tool.parameters.* — individual params (e.g. github.copilot.tool.parameters.command)
+            // gen_ai.tool.call.result — tool output
+            const argsRaw = getAttr(attrs, 'gen_ai.tool.call.arguments');
+            const resultRaw = getAttr(attrs, 'gen_ai.tool.call.result');
+            if (argsRaw) {
+                try {
+                    call.input = JSON.parse(String(argsRaw));
+                }
+                catch {
+                    call.input = { args: String(argsRaw) };
+                }
+            }
+            // Supplement with individual tool params (e.g. command for bash)
+            const toolParams = {};
+            for (const attr of attrs) {
+                if (attr.key?.startsWith('github.copilot.tool.parameters.')) {
+                    const paramName = attr.key.replace('github.copilot.tool.parameters.', '');
+                    toolParams[paramName] = attr.value?.stringValue ?? attr.value?.intValue ?? attr.value?.boolValue;
+                }
+            }
+            if (Object.keys(toolParams).length > 0)
+                call.input = { ...call.input, ...toolParams };
+            if (resultRaw)
+                call.output = String(resultRaw).slice(0, 500);
+            // Also check events as fallback
+            for (const ev of span.events ?? []) {
+                if (ev.name === 'gen_ai.content.prompt' && !argsRaw) {
+                    call.input = { args: getAttr(ev.attributes, 'gen_ai.prompt') };
+                }
+                if (ev.name === 'gen_ai.content.completion' && !resultRaw) {
+                    call.output = String(getAttr(ev.attributes, 'gen_ai.completion') ?? '').slice(0, 500);
+                }
+            }
+            const inf = inFlight.get(traceId);
+            if (inf) {
+                inf.entry.toolCalls.push(call);
+                inf.toolCalls.set(spanId, call);
+                // Recount
+                let skills = 0, agents = 0, mcps = 0;
+                for (const c of inf.entry.toolCalls) {
+                    if (c.type === 'skill')
+                        skills++;
+                    else if (c.type === 'agent')
+                        agents++;
+                    else if (c.type === 'mcp')
+                        mcps++;
+                }
+                inf.entry.skillCount = skills;
+                inf.entry.agentCount = agents;
+                inf.entry.mcpCount = mcps;
+                upsertTrace(inf.entry);
+                traceEvents.emit('trace:update', inf.entry);
+            }
+            else {
+                // Buffer tool call — invoke_agent hasn't arrived yet
+                const buf = pendingToolCalls.get(traceId) ?? [];
+                buf.push(call);
+                pendingToolCalls.set(traceId, buf);
+            }
+            continue;
+        }
+    }
+}
+function detectToolType(name) {
+    const n = name.toLowerCase();
+    // MCP — either mcp_ prefix, slash-separated server/tool, or gh CLI (copilot uses gh over MCP)
+    if (n.startsWith('mcp_') || n.includes('/') || n === 'gh' || n.startsWith('gh_'))
+        return 'mcp';
+    // Agent — sub-agent delegation
+    if (n.includes('agent') || n.includes('delegate') || n.includes('spawn'))
+        return 'agent';
+    // Skill — named capability loaded from skills context
+    if (n.includes('skill') || n.includes('hermes') || n === 'copilot-tracer')
+        return 'skill';
+    // Builtin — shell, file, search, etc
+    return 'builtin';
+}
+// ── Register OTLP HTTP routes on the Express app ──────────────────────────────
+export function registerOtlpRoutes(app, defaultSessionId) {
+    // OTLP traces — copilot sends JSON (http/json protocol)
+    // body already parsed by express.json() middleware registered before this call
+    app.post('/v1/traces', (req, res) => {
+        try {
+            const payload = req.body;
+            const resourceSpans = payload.resourceSpans ?? [];
+            for (const rs of resourceSpans) {
+                const resAttrs = rs.resource?.attributes ?? [];
+                const sessionFromOtel = getAttr(resAttrs, 'github.copilot.session_id')
+                    ?? getAttr(resAttrs, 'session.id')
+                    ?? getAttr(resAttrs, 'github.copilot.conversation_id');
+                const sessionId = String(sessionFromOtel ?? defaultSessionId);
+                for (const ss of rs.scopeSpans ?? []) {
+                    processSpans(ss.spans ?? [], sessionId);
+                }
+            }
+            res.status(200).json({ partialSuccess: {} });
+        }
+        catch (e) {
+            console.error('[OTLP] parse error:', e);
+            res.status(400).json({ error: 'invalid payload' });
+        }
+    });
+    // Metrics + logs — accept and ignore
+    app.post('/v1/metrics', (_req, res) => res.status(200).json({ partialSuccess: {} }));
+    app.post('/v1/logs', (_req, res) => res.status(200).json({ partialSuccess: {} }));
+    console.log('  📡 OTLP receiver ready on /v1/traces');
+}

package/dist/proxy.js

@@ -0,0 +1,231 @@
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+import { upsertTrace } from './db.js';
+export const traceEvents = new EventEmitter();
+const activeTraces = new Map(); // keyed by sessionId
+const pendingPrompts = new Map(); // id → sessionId
+// GitHub AI Credits: 1 credit = $0.01 USD
+// Rates based on official Copilot model pricing (credits per 1k tokens)
+const CREDITS_PER_1K = {
+    'claude-sonnet-5': { input: 0.3, output: 1.5, reasoning: 3.75 },
+    'claude-sonnet-4.6': { input: 0.3, output: 1.5, reasoning: 3.75 },
+    'claude-sonnet-4': { input: 0.3, output: 1.5, reasoning: 3.75 },
+    'claude-haiku-4.5': { input: 0.025, output: 0.125, reasoning: 0.25 },
+    'claude-opus-5': { input: 1.5, output: 7.5, reasoning: 7.5 },
+    'claude-opus-4': { input: 1.5, output: 7.5, reasoning: 7.5 },
+    'gpt-4.1': { input: 0.2, output: 0.8, reasoning: 0.8 },
+    'gpt-4o': { input: 0.25, output: 1.0, reasoning: 1.0 },
+    'gemini-2.0-flash': { input: 0.01, output: 0.04, reasoning: 0.04 },
+    'gemini-1.5-pro': { input: 0.125, output: 0.5, reasoning: 0.5 },
+    'default': { input: 0.3, output: 1.5, reasoning: 3.75 }, // fallback
+};
+function calcCredits(tokens, model = 'default') {
+    const key = Object.keys(CREDITS_PER_1K).find(k => model.toLowerCase().includes(k)) ?? 'default';
+    const rate = CREDITS_PER_1K[key];
+    return ((tokens.input / 1000) * rate.input +
+        (tokens.written / 1000) * rate.output +
+        (tokens.reasoning / 1000) * rate.reasoning);
+}
+function countByType(calls) {
+    let skills = 0, agents = 0, mcps = 0;
+    for (const c of calls) {
+        if (c.type === 'skill')
+            skills++;
+        else if (c.type === 'agent')
+            agents++;
+        else if (c.type === 'mcp')
+            mcps++;
+        if (c.children) {
+            const sub = countByType(c.children);
+            skills += sub.skills;
+            agents += sub.agents;
+            mcps += sub.mcps;
+        }
+    }
+    return { skills, agents, mcps };
+}
+export function handleAcpMessage(sessionId, msg, direction) {
+    // ── OUTBOUND (client → copilot) ──────────────────────────────────────────
+    if (direction === 'out') {
+        // session/prompt: user sent a new prompt
+        if (msg.method === 'session/prompt' && msg.params) {
+            const params = msg.params;
+            const acpSessionId = String(params.sessionId ?? sessionId);
+            // Extract prompt text from ACP prompt array: [{type:"text", text:"..."}]
+            let promptText = '';
+            const promptArr = params.prompt;
+            if (Array.isArray(promptArr)) {
+                promptText = promptArr
+                    .filter(p => p.type === 'text' && p.text)
+                    .map(p => p.text)
+                    .join(' ');
+            }
+            if (!promptText)
+                promptText = JSON.stringify(params);
+            const traceId = String(msg.id ?? randomUUID());
+            const entry = {
+                id: traceId,
+                sessionId, // use the tracer session ID, not ACP session ID
+                dateTime: new Date().toISOString(),
+                prompt: promptText,
+                tokens: { input: 0, output: 0, cached: 0, reasoning: 0, written: 0, total: 0 },
+                aiCredits: 0,
+                durationMs: 0,
+                toolCalls: [],
+                skillCount: 0,
+                agentCount: 0,
+                mcpCount: 0,
+                status: 'running',
+            };
+            // Store keyed by ACP session ID for notification correlation
+            activeTraces.set(acpSessionId, { entry, startMs: Date.now(), toolCallStack: [], promptId: msg.id });
+            if (msg.id !== undefined)
+                pendingPrompts.set(msg.id, acpSessionId);
+            upsertTrace(entry);
+            traceEvents.emit('trace:update', entry);
+        }
+        // session/command or tool_call_result going back — nothing to capture on out direction for tools
+    }
+    // ── INBOUND (copilot → client) ───────────────────────────────────────────
+    if (direction === 'in') {
+        // session/update notifications — all streaming events
+        if (msg.method === 'session/update' && msg.params) {
+            const params = msg.params;
+            const acpSessionId = String(params.sessionId ?? sessionId);
+            const update = (params.update ?? {});
+            const updateType = String(update.sessionUpdate ?? '');
+            const active = activeTraces.get(acpSessionId);
+            if (!active)
+                return;
+            if (updateType === 'agent_message_chunk') {
+                // Text chunk of AI response — accumulate
+                const content = update.content ?? {};
+                if (content.text) {
+                    active.entry.response = (active.entry.response ?? '') + content.text;
+                }
+            }
+            else if (updateType === 'tool_call_start' || updateType === 'tool_call_begin') {
+                // Tool call starting
+                const toolName = String(update.toolName ?? update.name ?? 'unknown');
+                const toolType = detectToolType(toolName);
+                const callId = String(update.callId ?? update.id ?? randomUUID());
+                const call = {
+                    id: callId,
+                    name: toolName,
+                    type: toolType,
+                    input: (update.arguments ?? update.input ?? {}),
+                    startedAt: Date.now(),
+                };
+                active.entry.toolCalls.push(call);
+                active.toolCallStack.push(call);
+                upsertTrace(active.entry);
+                traceEvents.emit('trace:update', active.entry);
+            }
+            else if (updateType === 'tool_call_end' || updateType === 'tool_call_result' || updateType === 'tool_call_complete') {
+                // Tool call completed
+                const callId = String(update.callId ?? update.id ?? '');
+                const call = active.toolCallStack.find(c => c.id === callId);
+                if (call) {
+                    call.output = update.result ?? update.output;
+                    call.endedAt = Date.now();
+                    call.durationMs = call.endedAt - call.startedAt;
+                    upsertTrace(active.entry);
+                    traceEvents.emit('trace:update', active.entry);
+                }
+            }
+            else if (updateType === 'usage_update' || updateType === 'token_usage') {
+                // Token usage update
+                const usage = (update.usage ?? update.tokens ?? {});
+                const model = String(update.model ?? update.modelId ?? 'default');
+                active.entry.tokens = {
+                    input: usage.input_tokens ?? usage.prompt_tokens ?? active.entry.tokens.input,
+                    output: usage.output_tokens ?? usage.completion_tokens ?? active.entry.tokens.output,
+                    cached: usage.cache_read_input_tokens ?? usage.cached_tokens ?? active.entry.tokens.cached,
+                    reasoning: usage.reasoning_tokens ?? active.entry.tokens.reasoning,
+                    written: usage.output_tokens ?? active.entry.tokens.written,
+                    total: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
+                };
+                const rawCredits = typeof update.ai_credits === 'number' ? update.ai_credits
+                    : typeof update.credits === 'number' ? update.credits
+                        : null;
+                if (rawCredits !== null)
+                    active.entry.aiCredits = rawCredits;
+                else
+                    active.entry.aiCredits = calcCredits(active.entry.tokens, model);
+                upsertTrace(active.entry);
+                traceEvents.emit('trace:update', active.entry);
+            }
+        }
+        // Response to session/prompt request — completion signal
+        if (msg.id !== undefined && msg.result !== undefined && !msg.method) {
+            const acpSessionId = pendingPrompts.get(msg.id);
+            if (acpSessionId) {
+                const active = activeTraces.get(acpSessionId);
+                if (active) {
+                    const result = msg.result;
+                    const stopReason = String(result.stopReason ?? 'end_turn');
+                    active.entry.durationMs = Date.now() - active.startMs;
+                    active.entry.status = stopReason === 'end_turn' ? 'done' : 'done';
+                    // If no tokens from usage_update, estimate from text length
+                    if (active.entry.tokens.total === 0 && active.entry.response) {
+                        const roughTokens = Math.ceil(active.entry.response.length / 4);
+                        active.entry.tokens.output = roughTokens;
+                        active.entry.tokens.written = roughTokens;
+                        active.entry.tokens.total = roughTokens;
+                        active.entry.aiCredits = calcCredits(active.entry.tokens);
+                    }
+                    const counts = countByType(active.entry.toolCalls);
+                    active.entry.skillCount = counts.skills;
+                    active.entry.agentCount = counts.agents;
+                    active.entry.mcpCount = counts.mcps;
+                    upsertTrace(active.entry);
+                    traceEvents.emit('trace:update', active.entry);
+                    traceEvents.emit('trace:done', active.entry);
+                    pendingPrompts.delete(msg.id);
+                    activeTraces.delete(acpSessionId);
+                }
+            }
+        }
+        // Error response
+        if (msg.error) {
+            // Try to match by pending prompt id
+            if (msg.id !== undefined) {
+                const acpSessionId = pendingPrompts.get(msg.id);
+                if (acpSessionId) {
+                    const active = activeTraces.get(acpSessionId);
+                    if (active) {
+                        active.entry.status = 'error';
+                        active.entry.error = msg.error.message;
+                        active.entry.durationMs = Date.now() - active.startMs;
+                        upsertTrace(active.entry);
+                        traceEvents.emit('trace:update', active.entry);
+                        pendingPrompts.delete(msg.id);
+                        activeTraces.delete(acpSessionId);
+                        return;
+                    }
+                }
+            }
+            // Fallback: mark any running trace as error
+            for (const [id, active] of activeTraces) {
+                if (active.entry.status === 'running') {
+                    active.entry.status = 'error';
+                    active.entry.error = msg.error.message;
+                    active.entry.durationMs = Date.now() - active.startMs;
+                    upsertTrace(active.entry);
+                    traceEvents.emit('trace:update', active.entry);
+                    activeTraces.delete(id);
+                    break;
+                }
+            }
+        }
+    }
+}
+function detectToolType(name) {
+    if (name.startsWith('mcp_') || name.includes('/'))
+        return 'mcp';
+    if (name.includes('skill') || name.includes('hermes'))
+        return 'skill';
+    if (name.includes('agent') || name.includes('delegate'))
+        return 'agent';
+    return 'builtin';
+}