sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/parsers/codexParser.js

@@ -0,0 +1,906 @@
+/**
+ * @fileoverview Stateful parser converting Codex rollout lines to SessionEvent[].
+ *
+ * Unlike OpenCode's stateless converter, this is stateful because:
+ * - exec_command_begin/end and mcp_tool_call_begin/end need pairing by call_id
+ * - turn_context sets the current model for subsequent events
+ * - token_count repeats its cumulative total on duplicate events, so each
+ *   call is counted only when `total_token_usage` changes
+ *
+ * Moved from sidekick-vscode to sidekick-shared for reuse across packages.
+ *
+ * @module parsers/codexParser
+ */
+import { isAggregateCodexLimit } from '../types/codex';
+import { normalizeToolName } from './openCodeParser';
+import { normalizeProviderUsage } from '../usageNormalization';
+function reportedCompaction(tokensBefore, tokensAfter) {
+    if (typeof tokensBefore !== 'number' ||
+        typeof tokensAfter !== 'number' ||
+        !Number.isFinite(tokensBefore) ||
+        !Number.isFinite(tokensAfter) ||
+        tokensBefore < tokensAfter ||
+        tokensAfter < 0) {
+        return {};
+    }
+    return { compaction: { tokensBefore, tokensAfter } };
+}
+function normalizeRateLimits(rateLimits) {
+    if (!rateLimits?.primary && !rateLimits?.secondary)
+        return undefined;
+    return {
+        primary: rateLimits.primary
+            ? {
+                usedPercent: rateLimits.primary.used_percent || 0,
+                windowMinutes: rateLimits.primary.window_minutes || 0,
+                resetsAt: rateLimits.primary.resets_at || 0,
+            }
+            : undefined,
+        secondary: rateLimits.secondary
+            ? {
+                usedPercent: rateLimits.secondary.used_percent || 0,
+                windowMinutes: rateLimits.secondary.window_minutes || 0,
+                resetsAt: rateLimits.secondary.resets_at || 0,
+            }
+            : undefined,
+    };
+}
+const CODEX_USAGE_FIELDS = [
+    'input_tokens',
+    'cached_input_tokens',
+    'output_tokens',
+    'reasoning_output_tokens',
+    'total_tokens',
+];
+function usageField(usage, field) {
+    const value = usage[field];
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function codexTotalOf(usage) {
+    return (usageField(usage, 'total_tokens') ||
+        usageField(usage, 'input_tokens') + usageField(usage, 'output_tokens'));
+}
+/**
+ * Resolve the usage of the single call a Codex `token_count` event reports.
+ *
+ * Codex emits `token_count` repeatedly — rate-limit refreshes and resumes
+ * resend the same `info` — so summing `last_token_usage` per event counts
+ * those calls again. `total_token_usage` is cumulative, which makes an
+ * unchanged total the reliable duplicate signal. When `last_token_usage` is
+ * missing, the call is the growth of the cumulative total (never the total
+ * itself). A total that drops means the counter restarted; re-baseline on it.
+ */
+export function resolveCodexCallUsage(info, previousTotal) {
+    if (!info)
+        return { usage: null, total: previousTotal };
+    const last = info.last_token_usage ?? null;
+    const total = info.total_token_usage ?? null;
+    if (total && previousTotal) {
+        const unchanged = CODEX_USAGE_FIELDS.every((field) => usageField(total, field) === usageField(previousTotal, field));
+        if (unchanged)
+            return { usage: null, total };
+        if (codexTotalOf(total) < codexTotalOf(previousTotal)) {
+            return { usage: last ?? total, total };
+        }
+    }
+    if (last)
+        return { usage: last, total: total ?? previousTotal };
+    if (!total)
+        return { usage: null, total: previousTotal };
+    const delta = {};
+    let any = false;
+    for (const field of CODEX_USAGE_FIELDS) {
+        const value = Math.max(0, usageField(total, field) - (previousTotal ? usageField(previousTotal, field) : 0));
+        delta[field] = value;
+        if (value > 0)
+            any = true;
+    }
+    return { usage: any ? delta : null, total };
+}
+/**
+ * Codex-specific tool name normalization.
+ * Extends the shared normalizeToolName with Codex-specific mappings.
+ */
+export function normalizeCodexToolName(name) {
+    if (!name)
+        return name;
+    const lower = name.toLowerCase();
+    if (lower === 'local_shell' || lower === 'local_shell_call')
+        return 'Bash';
+    if (lower === 'exec_command')
+        return 'Bash';
+    if (lower === 'write_stdin')
+        return 'Bash';
+    if (lower === 'request_user_input')
+        return 'AskUserQuestion';
+    if (lower === 'update_plan')
+        return 'UpdatePlan';
+    if (lower === 'web_search')
+        return 'WebSearch';
+    return normalizeToolName(name);
+}
+/**
+ * Normalizes Codex tool input fields for downstream monitor compatibility.
+ */
+export function normalizeCodexToolInput(canonicalToolName, rawToolName, input) {
+    const normalized = { ...input };
+    normalized._sidekickRawToolName = rawToolName;
+    // Codex exec_command uses cmd; monitor expects command for Bash context extraction.
+    if (canonicalToolName === 'Bash' &&
+        typeof normalized.cmd === 'string' &&
+        normalized.command === undefined) {
+        normalized.command = normalized.cmd;
+    }
+    // request_user_input currently emits questions; keep as-is (compatible with AskUserQuestion extractor).
+    return normalized;
+}
+function parsePlainTextFailure(output) {
+    if (!output)
+        return false;
+    const exitCodeMatch = /Process exited with code\s+(-?\d+)/i.exec(output);
+    if (exitCodeMatch) {
+        return Number(exitCodeMatch[1]) !== 0;
+    }
+    return /(Permission denied|No such file|not found|SyntaxError|failed|error:)/i.test(output);
+}
+/**
+ * Extracts plain text from Codex message content.
+ */
+function extractTextFromContent(content) {
+    if (typeof content === 'string')
+        return content;
+    const texts = [];
+    for (const part of content) {
+        if (part.text)
+            texts.push(part.text);
+    }
+    return texts.join('\n');
+}
+/**
+ * Extracts file paths from an apply_patch input string.
+ * Matches lines like: `*** Add File: src/math.ts` or `*** Update File: src/index.ts`
+ */
+export function extractPatchFilePaths(input) {
+    const paths = [];
+    const re = /\*\*\* (?:Add|Update|Delete) File: (.+)/g;
+    let m;
+    while ((m = re.exec(input)) !== null) {
+        paths.push(m[1].trim());
+    }
+    return paths;
+}
+/** Default cap on each piece of per-call correlation state the parser keeps. */
+export const DEFAULT_MAX_TRACKED_TOOL_CALLS = 4096;
+/** Adds `key`, refreshing its position, and evicts the oldest past `max`. */
+function rememberBounded(set, key, max) {
+    set.delete(key);
+    set.add(key);
+    while (set.size > max)
+        set.delete(set.values().next().value);
+}
+/** Sets `key`, refreshing its position, and evicts the oldest past `max`. */
+function setBounded(map, key, value, max) {
+    map.delete(key);
+    map.set(key, value);
+    while (map.size > max)
+        map.delete(map.keys().next().value);
+}
+/**
+ * Stateful parser for Codex JSONL rollout lines.
+ *
+ * Maintains internal state for:
+ * - Session metadata (from session_meta)
+ * - Current model (from turn_context)
+ * - Pending exec commands and MCP tool calls (begin/end pairing)
+ * - Previous cumulative token total (to skip duplicate token_count events)
+ */
+export class CodexRolloutParser {
+    sessionMeta = null;
+    currentModel = null;
+    pendingExecCommands = new Map();
+    pendingMcpToolCalls = new Map();
+    lastTokenUsage = null;
+    /** Cumulative `total_token_usage` from the previous token_count event. */
+    prevTotalUsage = null;
+    modelContextWindow = null;
+    lastRateLimits = null;
+    hasAggregateRateLimits = false;
+    inPlanMode = false;
+    emittedToolUseIds = new Set();
+    patchExpandedToolUseIds = new Map();
+    maxTrackedToolCalls;
+    constructor(options = {}) {
+        const max = options.maxTrackedToolCalls;
+        this.maxTrackedToolCalls =
+            typeof max === 'number' && max >= 1 ? Math.floor(max) : DEFAULT_MAX_TRACKED_TOOL_CALLS;
+    }
+    /** Get stored session metadata. */
+    getSessionMeta() {
+        return this.sessionMeta;
+    }
+    /** Get current model from turn_context. */
+    getCurrentModel() {
+        return this.currentModel;
+    }
+    /** Get the last observed token usage snapshot. */
+    getLastTokenUsage() {
+        return this.lastTokenUsage;
+    }
+    /** Get the model context window size from token_count events. */
+    getModelContextWindow() {
+        return this.modelContextWindow;
+    }
+    /** Get the last observed rate limits from token_count events. */
+    getLastRateLimits() {
+        return this.lastRateLimits;
+    }
+    /**
+     * Converts a single rollout line to zero or more session events.
+     */
+    convertLine(line) {
+        switch (line.type) {
+            case 'session_meta':
+                return this.handleSessionMeta(line.timestamp, line.payload);
+            case 'response_item':
+                return this.handleResponseItem(line.timestamp, line.payload);
+            case 'compacted':
+                return this.handleCompacted(line.timestamp, line.payload);
+            case 'turn_context':
+                return this.handleTurnContext(line.payload);
+            case 'event_msg':
+                return this.handleEventMsg(line.timestamp, line.payload);
+            default:
+                return [];
+        }
+    }
+    /** Reset all parser state. */
+    reset() {
+        this.sessionMeta = null;
+        this.currentModel = null;
+        this.pendingExecCommands.clear();
+        this.pendingMcpToolCalls.clear();
+        this.lastTokenUsage = null;
+        this.prevTotalUsage = null;
+        this.modelContextWindow = null;
+        this.lastRateLimits = null;
+        this.hasAggregateRateLimits = false;
+        this.inPlanMode = false;
+        this.emittedToolUseIds.clear();
+        this.patchExpandedToolUseIds.clear();
+    }
+    // --- Handlers ---
+    handleSessionMeta(timestamp, payload) {
+        this.sessionMeta = payload;
+        const text = payload.base_instructions?.text?.trim();
+        return [
+            {
+                type: 'system',
+                ...(text
+                    ? {
+                        message: {
+                            role: 'system',
+                            id: `${payload.id}:base-instructions`,
+                            sourceLabel: 'base instructions',
+                            content: [{ type: 'text', text }],
+                        },
+                    }
+                    : {}),
+                timestamp,
+                cwd: payload.cwd || undefined,
+            },
+        ];
+    }
+    handleResponseItem(timestamp, payload) {
+        // payload IS the item directly (no .item wrapper)
+        if (!payload || !payload.type)
+            return [];
+        switch (payload.type) {
+            case 'message':
+                return this.handleMessage(timestamp, payload);
+            case 'reasoning':
+                return this.handleReasoning(timestamp, payload);
+            case 'function_call':
+                return this.handleFunctionCall(timestamp, payload);
+            case 'function_call_output':
+                return this.handleFunctionCallOutput(timestamp, payload);
+            case 'local_shell_call':
+                return this.handleLocalShellCall(timestamp, payload);
+            case 'custom_tool_call':
+                return this.handleCustomToolCall(timestamp, payload);
+            case 'custom_tool_call_output':
+                return this.handleCustomToolCallOutput(timestamp, payload);
+            default:
+                return [];
+        }
+    }
+    handleMessage(timestamp, item) {
+        const text = extractTextFromContent(item.content);
+        if (!text)
+            return [];
+        if (item.role === 'user') {
+            return [
+                {
+                    type: 'user',
+                    message: {
+                        role: 'user',
+                        id: item.id,
+                        content: [{ type: 'text', text }],
+                    },
+                    timestamp,
+                },
+            ];
+        }
+        if (item.role === 'assistant') {
+            return [
+                {
+                    type: 'assistant',
+                    message: {
+                        role: 'assistant',
+                        id: item.id,
+                        model: this.currentModel || undefined,
+                        content: [{ type: 'text', text }],
+                    },
+                    timestamp,
+                },
+            ];
+        }
+        if (item.role === 'developer' || item.role === 'system') {
+            return [
+                {
+                    type: 'system',
+                    message: {
+                        role: item.role,
+                        id: item.id,
+                        sourceLabel: item.role,
+                        content: [{ type: 'text', text }],
+                    },
+                    timestamp,
+                },
+            ];
+        }
+        return [];
+    }
+    handleReasoning(timestamp, item) {
+        const summaryTexts = (item.summary || [])
+            .filter((s) => s.type === 'summary_text' && s.text)
+            .map((s) => s.text);
+        if (summaryTexts.length === 0)
+            return [];
+        return [
+            {
+                type: 'assistant',
+                message: {
+                    role: 'assistant',
+                    id: item.id,
+                    model: this.currentModel || undefined,
+                    content: [{ type: 'thinking', thinking: summaryTexts.join('\n') }],
+                },
+                timestamp,
+            },
+        ];
+    }
+    handleFunctionCall(timestamp, item) {
+        let parsedArgs = {};
+        try {
+            parsedArgs = JSON.parse(item.arguments);
+        }
+        catch {
+            parsedArgs = { raw: item.arguments };
+        }
+        const canonicalName = normalizeCodexToolName(item.name);
+        const normalizedInput = normalizeCodexToolInput(canonicalName, item.name, parsedArgs);
+        rememberBounded(this.emittedToolUseIds, item.call_id, this.maxTrackedToolCalls);
+        return [
+            {
+                type: 'assistant',
+                message: {
+                    role: 'assistant',
+                    id: item.id,
+                    model: this.currentModel || undefined,
+                    content: [
+                        {
+                            type: 'tool_use',
+                            id: item.call_id,
+                            name: canonicalName,
+                            input: normalizedInput,
+                        },
+                    ],
+                },
+                timestamp,
+            },
+        ];
+    }
+    handleFunctionCallOutput(timestamp, item) {
+        const isError = parsePlainTextFailure(item.output);
+        return [
+            {
+                type: 'user',
+                message: {
+                    role: 'user',
+                    id: `${item.call_id}:result`,
+                    content: [
+                        {
+                            type: 'tool_result',
+                            tool_use_id: item.call_id,
+                            content: item.output,
+                            is_error: isError,
+                        },
+                    ],
+                },
+                timestamp,
+            },
+        ];
+    }
+    handleLocalShellCall(timestamp, item) {
+        const command = item.action?.command?.join(' ') || '';
+        rememberBounded(this.emittedToolUseIds, item.call_id, this.maxTrackedToolCalls);
+        return [
+            {
+                type: 'assistant',
+                message: {
+                    role: 'assistant',
+                    id: item.id,
+                    model: this.currentModel || undefined,
+                    content: [
+                        {
+                            type: 'tool_use',
+                            id: item.call_id,
+                            name: 'Bash',
+                            input: {
+                                command,
+                                workdir: item.action?.workdir,
+                                _sidekickRawToolName: 'local_shell_call',
+                            },
+                        },
+                    ],
+                },
+                timestamp,
+            },
+        ];
+    }
+    handleCustomToolCall(timestamp, item) {
+        if (item.name === 'apply_patch') {
+            const filePaths = extractPatchFilePaths(item.input);
+            if (filePaths.length === 0)
+                return [];
+            const toolUseIds = filePaths.map((fp) => `${item.call_id}-${fp}`);
+            setBounded(this.patchExpandedToolUseIds, item.call_id, toolUseIds, this.maxTrackedToolCalls);
+            for (const id of toolUseIds) {
+                rememberBounded(this.emittedToolUseIds, id, this.maxTrackedToolCalls);
+            }
+            return filePaths.map((fp) => ({
+                type: 'assistant',
+                message: {
+                    role: 'assistant',
+                    id: `${item.call_id}-${fp}`,
+                    model: this.currentModel || undefined,
+                    content: [
+                        {
+                            type: 'tool_use',
+                            id: `${item.call_id}-${fp}`,
+                            name: 'Edit',
+                            input: {
+                                file_path: fp,
+                                _sidekickRawToolName: 'apply_patch',
+                            },
+                        },
+                    ],
+                },
+                timestamp,
+            }));
+        }
+        // Generic custom tool
+        let parsedInput;
+        try {
+            parsedInput = JSON.parse(item.input);
+        }
+        catch {
+            parsedInput = { raw: item.input };
+        }
+        const canonicalName = normalizeCodexToolName(item.name);
+        const normalizedInput = normalizeCodexToolInput(canonicalName, item.name, parsedInput);
+        rememberBounded(this.emittedToolUseIds, item.call_id, this.maxTrackedToolCalls);
+        return [
+            {
+                type: 'assistant',
+                message: {
+                    role: 'assistant',
+                    id: item.call_id,
+                    model: this.currentModel || undefined,
+                    content: [
+                        {
+                            type: 'tool_use',
+                            id: item.call_id,
+                            name: canonicalName,
+                            input: normalizedInput,
+                        },
+                    ],
+                },
+                timestamp,
+            },
+        ];
+    }
+    handleCustomToolCallOutput(timestamp, item) {
+        let isError = false;
+        let duration;
+        try {
+            const parsed = JSON.parse(item.output);
+            isError = parsed?.metadata?.exit_code !== 0 && parsed?.metadata?.exit_code !== undefined;
+            if (parsed?.metadata?.duration_seconds) {
+                duration = Math.round(parsed.metadata.duration_seconds * 1000);
+            }
+        }
+        catch {
+            isError = parsePlainTextFailure(item.output);
+        }
+        const toolUseIds = this.patchExpandedToolUseIds.get(item.call_id) ?? [item.call_id];
+        this.patchExpandedToolUseIds.delete(item.call_id);
+        return toolUseIds.map((toolUseId) => ({
+            type: 'user',
+            message: {
+                role: 'user',
+                id: `${toolUseId}:result`,
+                content: [
+                    {
+                        type: 'tool_result',
+                        tool_use_id: toolUseId,
+                        content: item.output,
+                        is_error: isError,
+                        duration,
+                    },
+                ],
+            },
+            timestamp,
+        }));
+    }
+    handleCompacted(timestamp, payload) {
+        return [
+            {
+                type: 'summary',
+                message: {
+                    role: 'assistant',
+                    id: `compacted-${timestamp}`,
+                    content: payload.summary || 'Context compacted',
+                },
+                timestamp,
+                ...reportedCompaction(payload.tokens_before, payload.tokens_after),
+            },
+        ];
+    }
+    handleTurnContext(payload) {
+        if (payload.model) {
+            this.currentModel = payload.model;
+        }
+        return [];
+    }
+    handleEventMsg(timestamp, event) {
+        // payload IS the event directly (no .event wrapper)
+        if (!event || !event.type)
+            return [];
+        switch (event.type) {
+            case 'token_count': {
+                const e = event;
+                // Store model_context_window if provided (actual limit for current model)
+                if (e.info?.model_context_window) {
+                    this.modelContextWindow = e.info.model_context_window;
+                }
+                // Store rate_limits if provided (subscription quota data). Codex interleaves
+                // multiple families (aggregate "codex" plus per-model ones like codex_bengalfox);
+                // keep the latest aggregate sample so a trailing model-specific event at 0% does
+                // not mask the plan quota. Fall back to a non-aggregate sample only until an
+                // aggregate one has been seen.
+                if (e.rate_limits) {
+                    if (isAggregateCodexLimit(e.rate_limits.limit_id)) {
+                        this.lastRateLimits = e.rate_limits;
+                        this.hasAggregateRateLimits = true;
+                    }
+                    else if (!this.hasAggregateRateLimits) {
+                        this.lastRateLimits = e.rate_limits;
+                    }
+                }
+                // Usage data is nested under info (info can be null). Codex repeats an
+                // unchanged cumulative total on duplicate events; count each call once.
+                const resolved = resolveCodexCallUsage(e.info, this.prevTotalUsage);
+                this.prevTotalUsage = resolved.total;
+                return this.handleTokenCount(timestamp, resolved.usage, e.rate_limits);
+            }
+            // agent_message and user_message are suppressed — they duplicate
+            // response_item/message events which carry richer metadata (id, content parts, role).
+            case 'exec_command_begin': {
+                const e = event;
+                setBounded(this.pendingExecCommands, e.call_id, {
+                    call_id: e.call_id,
+                    command: e.command,
+                    workdir: e.workdir,
+                    timestamp,
+                }, this.maxTrackedToolCalls);
+                return [];
+            }
+            case 'exec_command_end': {
+                const e = event;
+                const pending = this.pendingExecCommands.get(e.call_id);
+                this.pendingExecCommands.delete(e.call_id);
+                const command = pending?.command?.join(' ') || '';
+                const events = [];
+                if (!this.emittedToolUseIds.has(e.call_id)) {
+                    rememberBounded(this.emittedToolUseIds, e.call_id, this.maxTrackedToolCalls);
+                    events.push({
+                        type: 'assistant',
+                        message: {
+                            role: 'assistant',
+                            id: `exec-${e.call_id}`,
+                            model: this.currentModel || undefined,
+                            content: [
+                                {
+                                    type: 'tool_use',
+                                    id: e.call_id,
+                                    name: 'Bash',
+                                    input: {
+                                        command,
+                                        workdir: pending?.workdir,
+                                        _sidekickRawToolName: 'exec_command',
+                                    },
+                                },
+                            ],
+                        },
+                        timestamp: pending?.timestamp || timestamp,
+                    });
+                }
+                const output = [e.stdout, e.stderr].filter(Boolean).join('\n') || '';
+                events.push({
+                    type: 'user',
+                    message: {
+                        role: 'user',
+                        id: `exec-${e.call_id}:result`,
+                        content: [
+                            {
+                                type: 'tool_result',
+                                tool_use_id: e.call_id,
+                                content: output,
+                                is_error: e.exit_code !== 0,
+                                duration: e.duration_ms,
+                            },
+                        ],
+                    },
+                    timestamp,
+                });
+                return events;
+            }
+            case 'mcp_tool_call_begin': {
+                const e = event;
+                setBounded(this.pendingMcpToolCalls, e.call_id, {
+                    call_id: e.call_id,
+                    server_name: e.server_name,
+                    tool_name: e.tool_name,
+                    arguments: e.arguments,
+                    timestamp,
+                }, this.maxTrackedToolCalls);
+                return [];
+            }
+            case 'mcp_tool_call_end': {
+                const e = event;
+                const pendingMcp = this.pendingMcpToolCalls.get(e.call_id);
+                this.pendingMcpToolCalls.delete(e.call_id);
+                const toolName = pendingMcp?.tool_name || 'McpTool';
+                const events = [];
+                if (!this.emittedToolUseIds.has(e.call_id)) {
+                    rememberBounded(this.emittedToolUseIds, e.call_id, this.maxTrackedToolCalls);
+                    events.push({
+                        type: 'assistant',
+                        message: {
+                            role: 'assistant',
+                            id: `mcp-${e.call_id}`,
+                            model: this.currentModel || undefined,
+                            content: [
+                                {
+                                    type: 'tool_use',
+                                    id: e.call_id,
+                                    name: normalizeCodexToolName(toolName),
+                                    input: {
+                                        ...(pendingMcp?.arguments || {}),
+                                        _sidekickRawToolName: toolName,
+                                        _sidekickMcpServerName: pendingMcp?.server_name,
+                                    },
+                                },
+                            ],
+                        },
+                        timestamp: pendingMcp?.timestamp || timestamp,
+                    });
+                }
+                events.push({
+                    type: 'user',
+                    message: {
+                        role: 'user',
+                        id: `mcp-${e.call_id}:result`,
+                        content: [
+                            {
+                                type: 'tool_result',
+                                tool_use_id: e.call_id,
+                                content: e.result || '',
+                                is_error: e.is_error || false,
+                                duration: e.duration_ms,
+                            },
+                        ],
+                    },
+                    timestamp,
+                });
+                return events;
+            }
+            case 'error': {
+                const e = event;
+                return [
+                    {
+                        type: 'assistant',
+                        message: {
+                            role: 'assistant',
+                            id: `error-${timestamp}`,
+                            model: this.currentModel || undefined,
+                            content: [
+                                { type: 'text', text: `[Error${e.code ? ` (${e.code})` : ''}] ${e.message}` },
+                            ],
+                        },
+                        timestamp,
+                    },
+                ];
+            }
+            case 'context_compacted': {
+                const e = event;
+                return [
+                    {
+                        type: 'summary',
+                        message: {
+                            role: 'assistant',
+                            id: `ctx-compacted-${timestamp}`,
+                            content: e.summary || 'Context compacted',
+                        },
+                        timestamp,
+                        ...reportedCompaction(e.tokens_before, e.tokens_after),
+                    },
+                ];
+            }
+            case 'patch_applied': {
+                const e = event;
+                if (!e.file_path)
+                    return [];
+                const patchId = `patch-${timestamp}-${e.file_path}`;
+                return [
+                    {
+                        type: 'assistant',
+                        message: {
+                            role: 'assistant',
+                            id: patchId,
+                            model: this.currentModel || undefined,
+                            content: [
+                                {
+                                    type: 'tool_use',
+                                    id: patchId,
+                                    name: 'Edit',
+                                    input: {
+                                        file_path: e.file_path,
+                                        additions: e.additions ?? 0,
+                                        deletions: e.deletions ?? 0,
+                                        _sidekickRawToolName: 'patch_applied',
+                                    },
+                                },
+                            ],
+                        },
+                        timestamp,
+                    },
+                ];
+            }
+            case 'turn_started':
+            case 'turn_complete':
+            case 'task_started': {
+                const collaborationMode = event.collaboration_mode_kind;
+                if (collaborationMode !== 'plan' || this.inPlanMode)
+                    return [];
+                this.inPlanMode = true;
+                return [
+                    {
+                        type: 'assistant',
+                        message: {
+                            role: 'assistant',
+                            id: `plan-enter-${timestamp}`,
+                            model: this.currentModel || undefined,
+                            content: [
+                                {
+                                    type: 'tool_use',
+                                    id: `plan-enter-${timestamp}`,
+                                    name: 'EnterPlanMode',
+                                    input: {
+                                        source: 'codex_task_started',
+                                        _sidekickRawToolName: 'task_started',
+                                    },
+                                },
+                            ],
+                        },
+                        timestamp,
+                    },
+                ];
+            }
+            case 'task_complete':
+                if (!this.inPlanMode)
+                    return [];
+                this.inPlanMode = false;
+                return [
+                    {
+                        type: 'assistant',
+                        message: {
+                            role: 'assistant',
+                            id: `plan-exit-${timestamp}`,
+                            model: this.currentModel || undefined,
+                            content: [
+                                {
+                                    type: 'tool_use',
+                                    id: `plan-exit-${timestamp}`,
+                                    name: 'ExitPlanMode',
+                                    input: {
+                                        source: 'codex_task_complete',
+                                        _sidekickRawToolName: 'task_complete',
+                                    },
+                                },
+                            ],
+                        },
+                        timestamp,
+                    },
+                ];
+            case 'turn_aborted':
+            case 'agent_reasoning':
+            case 'agent_message':
+            case 'user_message':
+            case 'background':
+                return [];
+            default:
+                return [];
+        }
+    }
+    handleTokenCount(timestamp, usage, rateLimits) {
+        const normalizedRateLimits = normalizeRateLimits(rateLimits);
+        if (!usage && !normalizedRateLimits)
+            return [];
+        const normalizedUsage = usage
+            ? normalizeProviderUsage({
+                semantics: 'openai',
+                provider: 'openai',
+                source: 'codex-token-count',
+                model: this.currentModel || undefined,
+                inputTokens: usage.input_tokens,
+                outputTokens: usage.output_tokens,
+                cacheReadTokens: usage.cached_input_tokens,
+                reasoningTokens: usage.reasoning_output_tokens,
+            })
+            : undefined;
+        const mappedUsage = normalizedUsage
+            ? {
+                // Codex reports cached_input_tokens as a subset of input_tokens,
+                // while MessageUsage categories are disjoint. Normalize once here
+                // so aggregation and pricing do not count cached input twice.
+                input_tokens: normalizedUsage.uncachedInputTokens,
+                output_tokens: normalizedUsage.outputTokens,
+                cache_read_input_tokens: normalizedUsage.cacheReadTokens,
+                cache_creation_input_tokens: normalizedUsage.cacheWriteTokens,
+                reasoning_tokens: normalizedUsage.reasoningTokens,
+            }
+            : undefined;
+        if (usage) {
+            this.lastTokenUsage = usage;
+        }
+        return [
+            {
+                type: 'system',
+                message: {
+                    role: 'system',
+                    id: `token-count-${timestamp}`,
+                    sourceLabel: 'token count',
+                    model: this.currentModel || undefined,
+                    usage: mappedUsage,
+                    normalizedUsage,
+                    content: [],
+                },
+                timestamp,
+                providerMetadata: { providerId: 'codex', source: 'codex-rollout' },
+                rateLimits: normalizedRateLimits,
+            },
+        ];
+    }
+}