@exoscient/control-panel 0.1.0

package/dist/trace.js

@@ -0,0 +1,694 @@
+export function buildTraceItems(events) {
+    const items = [];
+    let assistantBuffer = '';
+    let assistantAt = '';
+    function flushAssistant() {
+        if (assistantBuffer) {
+            items.push({ kind: 'assistant', at: assistantAt, text: assistantBuffer });
+            assistantBuffer = '';
+            assistantAt = '';
+        }
+    }
+    for (const rawEvent of events) {
+        const event = normalizeTraceEvent(rawEvent);
+        if (event.type === 'assistant-delta') {
+            assistantAt || (assistantAt = event.at);
+            assistantBuffer += event.message;
+            continue;
+        }
+        if (event.type === 'assistant-message') {
+            if (!assistantBuffer) {
+                items.push({ kind: 'assistant', at: event.at, text: event.message });
+            }
+            continue;
+        }
+        if (event.type === 'assistant') {
+            flushAssistant();
+            items.push({ kind: 'assistant', at: event.at, text: event.message });
+            continue;
+        }
+        flushAssistant();
+        if (event.type === 'codex-event' || isCodexJsonEvent(event)) {
+            const item = parseCodexEvent(event);
+            if (item)
+                items.push(item);
+            continue;
+        }
+        if (event.type === 'turn-completed') {
+            items.push(parseTurnCompleted(event));
+            continue;
+        }
+        if (event.type === 'thread') {
+            items.push({ kind: 'status', at: event.at, text: 'Conversation thread started.', raw: readableJson(event.message) });
+            continue;
+        }
+        if (event.type === 'status') {
+            items.push({ kind: 'status', at: event.at, text: event.message });
+            continue;
+        }
+        if (event.type === 'output') {
+            items.push({ kind: 'output', at: event.at, stream: event.stream, text: event.message });
+            continue;
+        }
+        if (event.type === 'tokens') {
+            items.push({ kind: 'tokens', at: event.at, text: tokenUsageText(parseJson(event.message)), raw: readableJson(event.message) });
+            continue;
+        }
+        if (event.type === 'error') {
+            items.push({ kind: 'error', at: event.at, text: plainError(event.message), raw: readableJson(event.message) });
+            continue;
+        }
+        if (event.type === 'result') {
+            items.push({ kind: 'result', at: event.at, text: event.message });
+            continue;
+        }
+        items.push({ kind: 'raw', at: event.at, label: event.type, text: readableJson(event.message) });
+    }
+    flushAssistant();
+    return compactTraceItems(items);
+}
+export function traceItemMatchesFilter(item, filters) {
+    if (filters.length === 0)
+        return true;
+    return filters.includes(traceItemCategory(item));
+}
+export function latestContextPressure(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const pressure = contextPressureFromUsage(tokenUsageFromEvent(normalizeTraceEvent(events[index])));
+        if (pressure)
+            return pressure;
+    }
+    return null;
+}
+function traceItemCategory(item) {
+    if (item.kind === 'assistant')
+        return 'narration';
+    if (item.kind === 'file' || item.kind === 'tool')
+        return 'coding';
+    if (item.kind === 'command' || item.kind === 'output')
+        return 'shell';
+    if (item.kind === 'tokens')
+        return 'tokens';
+    if (item.kind === 'status' || item.kind === 'result')
+        return 'status';
+    if (item.kind === 'error')
+        return 'errors';
+    return 'raw';
+}
+function normalizeTraceEvent(event) {
+    const source = isObject(event) ? event : {};
+    const messageValue = valueAtAny(source, ['message', 'Message', 'text', 'Text', 'payload', 'Payload', 'data', 'Data']);
+    const message = traceMessageFromValue(messageValue, source);
+    const traceLine = parseTraceLine(message);
+    const explicitTimestamp = firstString(stringValue(source, 'at'), stringValue(source, 'At'), stringValue(source, 'timestamp'), stringValue(source, 'Timestamp'), stringValue(source, 'time'), stringValue(source, 'Time'), stringValue(source, 'createdAt'), stringValue(source, 'CreatedAt'));
+    const explicitType = firstString(stringValue(source, 'type'), stringValue(source, 'Type'), stringValue(source, 'kind'), stringValue(source, 'Kind'));
+    const lineEvent = traceLine && (!explicitType || explicitType === 'event') ? eventFromTraceLine(traceLine) : null;
+    return {
+        type: lineEvent?.type ?? explicitType ?? 'event',
+        at: explicitTimestamp ?? traceLine?.at ?? '',
+        stream: lineEvent?.stream ?? firstString(stringValue(source, 'stream'), stringValue(source, 'Stream')),
+        message: lineEvent?.message ?? message,
+    };
+}
+function parseTraceLine(message) {
+    const match = message.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2}))\s+#\d+\s+([A-Za-z0-9._/-]+)(?:\s+([\s\S]*))?$/);
+    if (!match)
+        return null;
+    const payloadText = match[3]?.trim() ?? '';
+    const payload = parseJson(payloadText);
+    return { at: match[1], label: match[2], payloadText, payload };
+}
+function eventFromTraceLine(line) {
+    const payloadMessage = objectValue(line.payload, 'message');
+    if (line.label === 'agent.notification' && payloadMessage) {
+        return { type: 'codex-event', at: line.at, message: stringifyCompact(payloadMessage) ?? line.payloadText };
+    }
+    if (line.payload && (stringValue(line.payload, 'method') || stringValue(line.payload, 'type'))) {
+        return { type: 'codex-event', at: line.at, message: stringifyCompact(line.payload) ?? line.payloadText };
+    }
+    if (line.label === 'agent.stderr' || line.label === 'agent.stdout') {
+        return {
+            type: 'output',
+            at: line.at,
+            stream: line.label === 'agent.stderr' ? 'stderr' : 'stdout',
+            message: firstString(stringValue(line.payload, 'line'), line.payloadText) ?? '',
+        };
+    }
+    if (line.label.includes('error') || line.label.includes('failed')) {
+        return { type: 'error', at: line.at, message: firstString(stringValue(line.payload, 'message'), line.payloadText, titleFromTraceLabel(line.label)) ?? titleFromTraceLabel(line.label) };
+    }
+    return {
+        type: 'status',
+        at: line.at,
+        message: firstString(stringValue(line.payload, 'message'), titleFromTraceLabel(line.label)) ?? titleFromTraceLabel(line.label),
+    };
+}
+function titleFromTraceLabel(label) {
+    const text = label
+        .replace(/[._/-]+/g, ' ')
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return text ? `${text.charAt(0).toLocaleUpperCase()}${text.slice(1)}.` : 'Trace event.';
+}
+function traceMessageFromValue(value, source) {
+    if (typeof value === 'string')
+        return value;
+    if (value !== undefined)
+        return stringifyCompact(value) ?? '';
+    return stringifyCompact(source) ?? '';
+}
+function valueAtAny(value, keys) {
+    if (!isObject(value))
+        return undefined;
+    for (const key of keys) {
+        const child = value[key];
+        if (child !== undefined && child !== null)
+            return child;
+    }
+    return undefined;
+}
+function parseCodexEvent(event) {
+    const json = parseJson(event.message);
+    const cliType = stringValue(json, 'type');
+    const method = stringValue(json, 'method') || (cliType ? cliType.replace(/\./g, '/') : undefined) || event.stream || 'AI agent event';
+    const params = objectValue(json, 'params') ?? json;
+    const item = objectValue(params, 'item') || objectValue(params, 'entry') || objectValue(json, 'item') || params || json;
+    const itemType = stringValue(item, 'type') || stringValue(item, 'kind') || '';
+    const title = titleFromMethod(method, itemType);
+    const raw = readableJson(event.message);
+    if (method === 'item/completed' && itemType === 'agent_message') {
+        return {
+            kind: 'assistant',
+            at: event.at,
+            text: stringValue(item, 'text') ?? stringValue(item, 'message') ?? '',
+        };
+    }
+    if (method.includes('error')) {
+        return { kind: 'error', at: event.at, text: plainError(event.message), raw };
+    }
+    if (method === 'configWarning') {
+        return {
+            kind: 'status',
+            at: event.at,
+            text: firstString(stringValue(params, 'summary'), stringValue(params, 'details'), 'Configuration warning.') ?? 'Configuration warning.',
+            raw,
+        };
+    }
+    if (method === 'thread/started') {
+        const thread = objectValue(params, 'thread');
+        const cliVersion = stringValue(thread, 'cliVersion');
+        return {
+            kind: 'status',
+            at: event.at,
+            text: `Thread started${cliVersion ? ` with AI agent runtime ${cliVersion}` : ''}.`,
+            raw,
+        };
+    }
+    if (method === 'thread/status/changed') {
+        const status = objectValue(params, 'status');
+        return {
+            kind: 'status',
+            at: event.at,
+            text: `Thread status: ${stringValue(status, 'type') ?? 'updated'}.`,
+            raw,
+        };
+    }
+    if (method === 'thread/tokenUsage/updated') {
+        return {
+            kind: 'tokens',
+            at: event.at,
+            text: tokenUsageText(objectValue(params, 'tokenUsage')),
+            raw,
+        };
+    }
+    if (method === 'turn/started') {
+        const turn = objectValue(params, 'turn');
+        return {
+            kind: 'status',
+            at: event.at,
+            text: `Turn ${stringValue(turn, 'status') ?? 'started'}.`,
+            raw,
+        };
+    }
+    if (method === 'turn/diff/updated') {
+        return {
+            kind: 'file',
+            at: event.at,
+            title: 'Diff updated',
+            text: stringValue(params, 'diff'),
+            raw,
+        };
+    }
+    if (method === 'item/commandExecution/outputDelta') {
+        return parseCommandOutputDelta(event.at, params, raw);
+    }
+    if (method === 'item/fileChange/outputDelta') {
+        return {
+            kind: 'file',
+            at: event.at,
+            title: 'File change output',
+            text: stringValue(params, 'delta'),
+            raw,
+        };
+    }
+    if (method === 'rawResponseItem/completed') {
+        return parseRawResponseItem(event.at, item, raw);
+    }
+    if (isCommandEvent(method, itemType, item)) {
+        return {
+            kind: 'command',
+            at: event.at,
+            title: itemType === 'commandExecution' ? 'Command Execution' : title,
+            itemId: stringValue(item, 'id') ?? stringValue(params, 'itemId'),
+            command: firstString(stringValue(item, 'command'), stringValue(item, 'cmd'), stringValue(item, 'script'), commandFromToolArguments(item), stringValue(objectValue(item, 'args'), 'cmd'), stringValue(objectValue(item, 'arguments'), 'cmd'), stringValue(params, 'command')),
+            output: firstString(stringValue(item, 'aggregatedOutput'), stringValue(item, 'aggregated_output'), stringValue(item, 'output'), stringValue(item, 'stdout'), stringValue(item, 'stderr'), stringValue(params, 'output'), stringValue(params, 'delta')),
+            status: commandStatus(item) ?? statusFromEvent(method, item),
+            raw,
+        };
+    }
+    if (isFileEvent(method, itemType, item)) {
+        return {
+            kind: 'file',
+            at: event.at,
+            title,
+            path: firstString(stringValue(item, 'path'), stringValue(item, 'file'), stringValue(item, 'filename'), pathFromChanges(item), stringValue(objectValue(item, 'changes'), 'path')),
+            text: firstString(fileChangesText(item), stringValue(item, 'text'), stringValue(item, 'summary'), stringValue(params, 'delta')),
+            raw,
+        };
+    }
+    if (isToolEvent(method, itemType, item)) {
+        return {
+            kind: 'tool',
+            at: event.at,
+            title,
+            input: stringifyCompact(valueAt(item, 'input') ??
+                valueAt(item, 'arguments') ??
+                valueAt(item, 'args') ??
+                valueAt(params, 'input') ??
+                valueAt(params, 'arguments')),
+            output: firstString(stringValue(item, 'output'), stringValue(item, 'result'), stringValue(params, 'delta')),
+            status: statusFromEvent(method, item),
+            raw,
+        };
+    }
+    if (method.includes('started') || method.includes('completed') || method.includes('turn')) {
+        return { kind: 'status', at: event.at, text: title, raw };
+    }
+    return { kind: 'raw', at: event.at, label: title, text: raw };
+}
+function isCodexJsonEvent(event) {
+    const json = parseJson(event.message);
+    return Boolean(json && (stringValue(json, 'type') || stringValue(json, 'method')));
+}
+function parseRawResponseItem(at, item, raw) {
+    const itemType = stringValue(item, 'type') ?? 'response item';
+    const name = stringValue(item, 'name');
+    if (itemType === 'function_call') {
+        const args = parseJson(stringValue(item, 'arguments') ?? '');
+        if (isCommandToolName(name) && !args)
+            return null;
+        return {
+            kind: isCommandToolName(name) ? 'command' : 'tool',
+            at,
+            title: name ?? 'Tool call',
+            command: isCommandToolName(name) ? commandFromArguments(args) : undefined,
+            input: !isCommandToolName(name) ? stringifyCompact(args ?? stringValue(item, 'arguments')) : undefined,
+            status: stringValue(item, 'status') ?? 'called',
+            raw,
+        };
+    }
+    if (itemType === 'function_call_output') {
+        const output = stringValue(item, 'output');
+        if (!output)
+            return null;
+        return {
+            kind: 'tool',
+            at,
+            title: 'Tool output',
+            output,
+            status: outputStatus(output),
+            raw,
+        };
+    }
+    if (itemType === 'custom_tool_call') {
+        const toolName = name ?? 'Custom tool';
+        return {
+            kind: toolName === 'apply_patch' ? 'file' : 'tool',
+            at,
+            title: toolName,
+            text: toolName === 'apply_patch' ? stringValue(item, 'input') : undefined,
+            input: toolName === 'apply_patch' ? undefined : stringValue(item, 'input'),
+            status: stringValue(item, 'status') ?? 'called',
+            raw,
+        };
+    }
+    if (itemType === 'custom_tool_call_output') {
+        return {
+            kind: 'tool',
+            at,
+            title: 'Custom tool output',
+            output: decodedToolOutput(stringValue(item, 'output')),
+            status: outputStatus(stringValue(item, 'output')),
+            raw,
+        };
+    }
+    if (itemType === 'message') {
+        const text = contentText(valueAt(item, 'content'));
+        if (!text)
+            return null;
+        return {
+            kind: stringValue(item, 'role') === 'assistant' ? 'assistant' : 'status',
+            at,
+            text,
+            raw,
+        };
+    }
+    if (itemType === 'reasoning') {
+        const summary = contentText(valueAt(item, 'summary'));
+        return {
+            kind: 'status',
+            at,
+            text: summary ? `Reasoning summary: ${summary}` : 'Reasoning step completed.',
+            raw,
+        };
+    }
+    return { kind: 'raw', at, label: titleFromMethod('rawResponseItem/completed', itemType), text: raw };
+}
+function parseCommandOutputDelta(at, params, raw) {
+    const itemId = stringValue(params, 'itemId');
+    const delta = stringValue(params, 'delta') ?? '';
+    const parsedDelta = parseJson(delta);
+    if (parsedDelta) {
+        const stdout = stringValue(parsedDelta, 'stdout');
+        const stderr = stringValue(parsedDelta, 'stderr');
+        return {
+            kind: 'command',
+            at,
+            title: 'Command Execution',
+            itemId,
+            command: commandFromDelta(parsedDelta),
+            output: firstString(stringValue(parsedDelta, 'output'), stdout || stderr ? `${stdout ?? ''}${stderr ?? ''}` : undefined),
+            status: commandDeltaStatus(parsedDelta),
+            raw,
+        };
+    }
+    return {
+        kind: 'command',
+        at,
+        title: 'Command Execution',
+        itemId,
+        output: delta,
+        raw,
+    };
+}
+function parseTurnCompleted(event) {
+    const json = parseJson(event.message);
+    const usage = objectValue(objectValue(json, 'params'), 'usage') || objectValue(json, 'usage');
+    const usageText = usage ? ` Token use: ${stringifyCompact(usage)}.` : '';
+    return {
+        kind: usage ? 'tokens' : 'status',
+        at: event.at,
+        text: `Turn completed.${usageText}`,
+        raw: readableJson(event.message),
+    };
+}
+function compactTraceItems(items) {
+    const compacted = [];
+    for (const item of items) {
+        const previous = compacted[compacted.length - 1];
+        if (previous?.kind === 'output' && item.kind === 'output' && previous.stream === item.stream) {
+            previous.text += item.text;
+            continue;
+        }
+        if (item.kind === 'command') {
+            const command = findCommandToMerge(compacted, item);
+            if (command) {
+                command.title = item.title || command.title;
+                command.command = item.command ?? command.command;
+                command.output = item.command
+                    ? item.output ?? command.output
+                    : `${command.output ?? ''}${item.output ?? ''}`;
+                command.status = item.status ?? command.status;
+                command.raw = item.raw ?? command.raw;
+                continue;
+            }
+        }
+        if (previous?.kind === 'command' && item.kind === 'command' && previous.title === item.title && !item.command) {
+            previous.output = `${previous.output ?? ''}${item.output ?? ''}`;
+            previous.status = item.status ?? previous.status;
+            previous.raw = item.raw ?? previous.raw;
+            continue;
+        }
+        if (previous?.kind === 'file' && item.kind === 'file' && previous.title === item.title && !item.path) {
+            if (previous.text === item.text) {
+                previous.raw = item.raw ?? previous.raw;
+                continue;
+            }
+            previous.text = `${previous.text ?? ''}${item.text ?? ''}`;
+            previous.raw = item.raw ?? previous.raw;
+            continue;
+        }
+        compacted.push(item);
+    }
+    return compacted;
+}
+function findCommandToMerge(items, item) {
+    if (item.itemId) {
+        for (let index = items.length - 1; index >= 0; index -= 1) {
+            const candidate = items[index];
+            if (candidate.kind === 'command' && candidate.itemId === item.itemId)
+                return candidate;
+        }
+    }
+    const previous = items[items.length - 1];
+    if (previous?.kind === 'command' && !item.command && previous.title === item.title)
+        return previous;
+    return null;
+}
+function isCommandEvent(method, itemType, item) {
+    const text = `${method} ${itemType} ${stringValue(item, 'name') ?? ''}`.toLowerCase();
+    return text.includes('command') || text.includes('shell') || text.includes('exec');
+}
+function isFileEvent(method, itemType, item) {
+    const text = `${method} ${itemType} ${stringValue(item, 'name') ?? ''}`.toLowerCase();
+    return text.includes('file') || text.includes('patch') || text.includes('apply_patch') || Boolean(stringValue(item, 'path'));
+}
+function isToolEvent(method, itemType, item) {
+    const text = `${method} ${itemType} ${stringValue(item, 'name') ?? ''}`.toLowerCase();
+    return text.includes('tool') || Boolean(stringValue(item, 'name'));
+}
+function titleFromMethod(method, itemType) {
+    const base = itemType || method.split('/').filter(Boolean).pop() || method;
+    return base
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/[_-]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function statusFromEvent(method, item) {
+    return firstString(stringValue(item, 'status'), method.includes('completed') ? 'completed' : undefined, method.includes('started') ? 'started' : undefined);
+}
+function commandStatus(item) {
+    const status = stringValue(item, 'status');
+    const exitCode = valueAt(item, 'exitCode') ?? valueAt(item, 'exit_code');
+    const durationMs = valueAt(item, 'durationMs') ?? valueAt(item, 'duration_ms');
+    const parts = [
+        status,
+        typeof exitCode === 'number' ? `exit ${exitCode}` : undefined,
+        typeof durationMs === 'number' ? `${durationMs} ms` : undefined,
+    ].filter(Boolean);
+    return parts.length > 0 ? parts.join(' / ') : undefined;
+}
+function commandFromToolArguments(item) {
+    return commandFromArguments(parseJson(stringValue(item, 'arguments') ?? ''));
+}
+function commandFromArguments(args) {
+    return firstString(stringValue(args, 'cmd'), stringValue(args, 'command'), stringValue(args, 'chars'));
+}
+function commandFromDelta(delta) {
+    const command = valueAt(delta, 'command');
+    if (Array.isArray(command))
+        return command.map((part) => typeof part === 'string' ? part : String(part)).join(' ');
+    return firstString(stringValue(delta, 'command'), stringValue(delta, 'cmd'));
+}
+function commandDeltaStatus(delta) {
+    const exitCode = valueAt(delta, 'exitCode') ?? valueAt(delta, 'exit_code');
+    const status = stringValue(delta, 'status');
+    const parts = [
+        status,
+        typeof exitCode === 'number' ? `exit ${exitCode}` : undefined,
+    ].filter(Boolean);
+    return parts.length > 0 ? parts.join(' / ') : undefined;
+}
+function fileChangesText(item) {
+    const changes = valueAt(item, 'changes');
+    if (!Array.isArray(changes))
+        return undefined;
+    const seen = new Set();
+    return changes
+        .map((change) => {
+        if (!isObject(change))
+            return '';
+        const path = stringValue(change, 'path');
+        const kind = stringValue(change, 'kind');
+        const diff = stringValue(change, 'diff');
+        const text = [path, kind, diff].filter(Boolean).join('\n');
+        if (!text || seen.has(text))
+            return '';
+        seen.add(text);
+        return text;
+    })
+        .filter(Boolean)
+        .join('\n\n');
+}
+function pathFromChanges(item) {
+    const changes = valueAt(item, 'changes');
+    if (!Array.isArray(changes))
+        return undefined;
+    const paths = [...new Set(changes.map((change) => isObject(change) ? stringValue(change, 'path') : undefined).filter(Boolean))];
+    return paths.length === 1 ? paths[0] : undefined;
+}
+function tokenUsageFromEvent(event) {
+    const json = parseJson(event.message);
+    if (!json)
+        return undefined;
+    if (event.type === 'tokens') {
+        return normalizeTokenUsage(json);
+    }
+    if (event.type !== 'codex-event' && !isCodexJsonEvent(event)) {
+        return undefined;
+    }
+    const cliType = stringValue(json, 'type');
+    const method = stringValue(json, 'method') || (cliType ? cliType.replace(/\./g, '/') : undefined) || event.stream;
+    if (method !== 'thread/tokenUsage/updated')
+        return undefined;
+    const params = objectValue(json, 'params') ?? json;
+    return normalizeTokenUsage(params);
+}
+function normalizeTokenUsage(tokenUsage) {
+    return objectValue(tokenUsage, 'tokenUsage') ?? tokenUsage;
+}
+function contextPressureFromUsage(tokenUsage) {
+    const usage = normalizeTokenUsage(tokenUsage);
+    const lastUsage = objectValue(usage, 'last');
+    const last = lastUsage ?? usage;
+    const contextWindow = numberValue(usage, 'modelContextWindow') ?? numberValue(usage, 'model_context_window');
+    const lastInputTokens = numberValue(last, 'inputTokens') ?? numberValue(last, 'input_tokens');
+    const flatInputTokens = lastUsage ? undefined : numberValue(usage, 'inputTokens') ?? numberValue(usage, 'input_tokens');
+    const usedTokens = lastInputTokens ?? flatInputTokens;
+    if (!usedTokens || !contextWindow || contextWindow <= 0)
+        return null;
+    const ratio = usedTokens / contextWindow;
+    const percent = Math.round(ratio * 100);
+    const tone = ratio >= 0.9 ? 'critical' : ratio >= 0.75 ? 'high' : ratio >= 0.5 ? 'medium' : 'low';
+    const source = lastUsage ? 'last-input' : 'reported-input';
+    return {
+        usedTokens,
+        contextWindow,
+        ratio,
+        percent,
+        tone,
+        source,
+        label: `Latest request context: ${percent}% (${usedTokens.toLocaleString()} / ${contextWindow.toLocaleString()} input tokens).`,
+    };
+}
+function tokenUsageText(tokenUsage) {
+    const usage = normalizeTokenUsage(tokenUsage);
+    const total = objectValue(usage, 'total') ?? usage;
+    const last = objectValue(usage, 'last') ?? usage;
+    const contextWindow = numberValue(usage, 'modelContextWindow') ?? numberValue(usage, 'model_context_window');
+    const totalTokens = numberValue(total, 'totalTokens') ?? numberValue(total, 'total_tokens');
+    const inputTokens = numberValue(last, 'inputTokens') ?? numberValue(last, 'input_tokens');
+    const cachedInputTokens = numberValue(last, 'cachedInputTokens') ?? numberValue(last, 'cached_input_tokens');
+    const outputTokens = numberValue(last, 'outputTokens') ?? numberValue(last, 'output_tokens');
+    const reasoningOutputTokens = numberValue(last, 'reasoningOutputTokens') ?? numberValue(last, 'reasoning_output_tokens');
+    const parts = [
+        totalTokens !== undefined ? `${totalTokens.toLocaleString()} total tokens` : undefined,
+        inputTokens !== undefined ? `${inputTokens.toLocaleString()} input` : undefined,
+        cachedInputTokens !== undefined ? `${cachedInputTokens.toLocaleString()} cached input` : undefined,
+        outputTokens !== undefined ? `${outputTokens.toLocaleString()} output` : undefined,
+        reasoningOutputTokens !== undefined ? `${reasoningOutputTokens.toLocaleString()} reasoning` : undefined,
+        contextWindow !== undefined ? `${contextWindow.toLocaleString()} context` : undefined,
+    ].filter(Boolean);
+    return parts.length > 0 ? `Token usage: ${parts.join(' / ')}.` : 'Token usage updated.';
+}
+function contentText(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value
+        .map((entry) => isObject(entry) ? firstString(stringValue(entry, 'text'), stringValue(entry, 'summary')) : undefined)
+        .filter(Boolean)
+        .join('\n');
+}
+function decodedToolOutput(value) {
+    const json = parseJson(value ?? '');
+    return firstString(stringValue(json, 'output'), stringValue(json, 'message'), value);
+}
+function outputStatus(value) {
+    const metadata = objectValue(parseJson(value ?? ''), 'metadata');
+    const exitCode = valueAt(metadata, 'exit_code');
+    return typeof exitCode === 'number' ? `exit ${exitCode}` : undefined;
+}
+function isCommandToolName(name) {
+    return name === 'exec_command' || name === 'write_stdin';
+}
+export function readableJson(value) {
+    try {
+        return JSON.stringify(JSON.parse(value), null, 2);
+    }
+    catch {
+        return value;
+    }
+}
+function plainError(value) {
+    const json = parseJson(value);
+    return firstString(stringValue(json, 'message'), stringValue(json, 'error'), stringValue(objectValue(json, 'error'), 'message'), value) ?? value;
+}
+function parseJson(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return isObject(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function objectValue(value, key) {
+    if (!isObject(value))
+        return undefined;
+    const child = value[key];
+    return isObject(child) ? child : undefined;
+}
+function valueAt(value, key) {
+    return isObject(value) ? value[key] : undefined;
+}
+function numberValue(value, key) {
+    const child = valueAt(value, key);
+    return typeof child === 'number' && Number.isFinite(child) ? child : undefined;
+}
+function stringValue(value, key) {
+    if (!isObject(value))
+        return undefined;
+    const child = value[key];
+    return typeof child === 'string' && child.length > 0 ? child : undefined;
+}
+function firstString(...values) {
+    return values.find((value) => value && value.length > 0);
+}
+function stringifyCompact(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=trace.js.map