yepanywhere 0.1.0

package/dist/sessions/codex-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-reader.d.ts","sourceRoot":"","sources":["../../src/sessions/codex-reader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,EAWL,KAAK,YAAY,EAElB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAGV,OAAO,EAEP,cAAc,EACf,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACd,aAAa,EACd,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAWD;;;;;GAKG;AACH,qBAAa,kBAAmB,YAAW,cAAc;IACvD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAC,CAAS;IAG7B,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAQ;gBAEzB,OAAO,EAAE,yBAAyB;IAKxC,YAAY,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAyBhE,iBAAiB,CACrB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAuD3B,UAAU,CACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,YAAY,EACvB,cAAc,CAAC,EAAE,MAAM,EACvB,QAAQ,CAAC,EAAE,iBAAiB,GAC3B,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAsC1B,0BAA0B,CAC9B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,YAAY,EACvB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC;QAAE,OAAO,EAAE,cAAc,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAuB3E;;;OAGG;IACG,gBAAgB,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAI3E;;;OAGG;IACG,eAAe,CACnB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;QAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAI1D;;OAEG;YACW,YAAY;IAqB1B;;OAEG;YACW,eAAe;IAY7B;;OAEG;YACW,cAAc;IAsB5B;;OAEG;YACW,eAAe;IA8B7B;;OAEG;IACH,OAAO,CAAC,YAAY;IAoDpB,OAAO,CAAC,yBAAyB;IAQjC;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAoBrB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAqC3B;;OAEG;IACH,OAAO,CAAC,YAAY;IAUpB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA6CzB;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAapC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,wBAAwB;IA8ChC,OAAO,CAAC,2BAA2B;IASnC;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IA6C3B;;;;;;;OAOG;IACH,OAAO,CAAC,qBAAqB;IAuC7B;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAsC/B;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAgClC;;;;OAIG;IACH,OAAO,CAAC,gCAAgC;IAoBxC;;;;OAIG;IACH,OAAO,CAAC,eAAe;CAiDxB"}

package/dist/sessions/codex-reader.js

@@ -0,0 +1,664 @@
+/**
+ * CodexSessionReader - Reads Codex sessions from disk.
+ *
+ * Codex stores sessions at ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl
+ * with a different format than Claude:
+ * - session_meta: Session initialization (id, cwd, timestamp)
+ * - response_item: Messages, reasoning, function calls
+ * - event_msg: User/agent messages, token counts
+ * - turn_context: Per-turn configuration
+ *
+ * Unlike Claude's DAG structure, Codex sessions are linear.
+ */
+import { readFile, readdir, stat } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { SESSION_TITLE_MAX_LENGTH, parseCodexSessionEntry, } from "@yep-anywhere/shared";
+// Codex model context window size (200K tokens for GPT-4)
+const CONTEXT_WINDOW_SIZE = 200_000;
+/**
+ * Codex-specific session reader for Codex CLI JSONL files.
+ *
+ * Handles Codex's linear conversation structure with session_meta,
+ * response_item, event_msg, and turn_context entries.
+ */
+export class CodexSessionReader {
+    sessionsDir;
+    projectPath;
+    // Cache of session ID -> file path for quick lookups
+    sessionFileCache = new Map();
+    cacheTimestamp = 0;
+    CACHE_TTL_MS = 5000; // 5 second cache
+    constructor(options) {
+        this.sessionsDir = options.sessionsDir;
+        this.projectPath = options.projectPath;
+    }
+    async listSessions(projectId) {
+        const summaries = [];
+        const sessions = await this.scanSessions();
+        for (const session of sessions) {
+            // Filter by project path if set
+            if (this.projectPath && session.cwd !== this.projectPath) {
+                continue;
+            }
+            const summary = await this.getSessionSummary(session.id, projectId);
+            if (summary) {
+                summaries.push(summary);
+            }
+        }
+        // Sort by updatedAt descending
+        summaries.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+        return summaries;
+    }
+    async getSessionSummary(sessionId, projectId) {
+        const sessionFile = await this.findSessionFile(sessionId);
+        if (!sessionFile)
+            return null;
+        try {
+            const content = await readFile(sessionFile.filePath, "utf-8");
+            const trimmed = content.trim();
+            if (!trimmed)
+                return null;
+            const lines = trimmed.split("\n");
+            const entries = [];
+            for (const line of lines) {
+                const entry = parseCodexSessionEntry(line);
+                if (entry) {
+                    entries.push(entry);
+                }
+            }
+            if (entries.length === 0)
+                return null;
+            // Extract session metadata from first entry
+            const metaEntry = entries.find((e) => e.type === "session_meta");
+            if (!metaEntry)
+                return null;
+            const stats = await stat(sessionFile.filePath);
+            const { title, fullTitle } = this.extractTitle(entries);
+            const messageCount = this.countMessages(entries);
+            const contextUsage = this.extractContextUsage(entries);
+            const model = this.extractModel(entries);
+            // Skip sessions with no actual conversation messages
+            if (messageCount === 0)
+                return null;
+            return {
+                id: sessionId,
+                projectId,
+                title,
+                fullTitle,
+                createdAt: metaEntry.payload.timestamp,
+                updatedAt: stats.mtime.toISOString(),
+                messageCount,
+                status: { state: "idle" },
+                contextUsage,
+                provider: this.determineProvider(metaEntry, model),
+                model,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async getSession(sessionId, projectId, afterMessageId, _options) {
+        const summary = await this.getSessionSummary(sessionId, projectId);
+        if (!summary)
+            return null;
+        const sessionFile = await this.findSessionFile(sessionId);
+        if (!sessionFile)
+            return null;
+        const content = await readFile(sessionFile.filePath, "utf-8");
+        const lines = content.trim().split("\n");
+        const entries = [];
+        for (const line of lines) {
+            const entry = parseCodexSessionEntry(line);
+            if (entry) {
+                entries.push(entry);
+            }
+        }
+        // Filter entries if needed (for incremental fetching)
+        // Note: Codex entries are not 1:1 with messages, so standard ID filtering is tricky
+        // with raw format. We return all entries for now.
+        // Ideally the client handles diffing/appending.
+        const finalEntries = entries;
+        if (afterMessageId) {
+            // Logic to filter entries would go here if strict incremental loading is needed
+        }
+        return {
+            summary,
+            data: {
+                provider: this.determineProviderFromEntries(entries),
+                session: {
+                    entries: finalEntries,
+                },
+            },
+        };
+    }
+    async getSessionSummaryIfChanged(sessionId, projectId, cachedMtime, cachedSize) {
+        const sessionFile = await this.findSessionFile(sessionId);
+        if (!sessionFile)
+            return null;
+        try {
+            const stats = await stat(sessionFile.filePath);
+            const mtime = stats.mtimeMs;
+            const size = stats.size;
+            // If mtime and size match cached values, return null (no change)
+            if (mtime === cachedMtime && size === cachedSize) {
+                return null;
+            }
+            const summary = await this.getSessionSummary(sessionId, projectId);
+            if (!summary)
+                return null;
+            return { summary, mtime, size };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Codex doesn't have subagent sessions like Claude.
+     * Returns empty array for compatibility.
+     */
+    async getAgentMappings() {
+        return [];
+    }
+    /**
+     * Codex doesn't have subagent sessions like Claude.
+     * Returns null for compatibility.
+     */
+    async getAgentSession(_agentId) {
+        return null;
+    }
+    /**
+     * Scan the sessions directory and find all session files.
+     */
+    async scanSessions() {
+        // Check cache
+        if (Date.now() - this.cacheTimestamp < this.CACHE_TTL_MS) {
+            return Array.from(this.sessionFileCache.values());
+        }
+        const sessions = [];
+        const files = await this.findJsonlFiles(this.sessionsDir);
+        for (const filePath of files) {
+            const session = await this.readSessionMeta(filePath);
+            if (session) {
+                sessions.push(session);
+                this.sessionFileCache.set(session.id, session);
+            }
+        }
+        this.cacheTimestamp = Date.now();
+        return sessions;
+    }
+    /**
+     * Find a session file by ID.
+     */
+    async findSessionFile(sessionId) {
+        // Check cache first
+        const cached = this.sessionFileCache.get(sessionId);
+        if (cached)
+            return cached;
+        // Scan if cache miss
+        await this.scanSessions();
+        return this.sessionFileCache.get(sessionId) ?? null;
+    }
+    /**
+     * Recursively find all .jsonl files in a directory.
+     */
+    async findJsonlFiles(dir) {
+        const files = [];
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    const subFiles = await this.findJsonlFiles(fullPath);
+                    files.push(...subFiles);
+                }
+                else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // Ignore errors (permission denied, etc.)
+        }
+        return files;
+    }
+    /**
+     * Read session metadata from the first line of a file.
+     */
+    async readSessionMeta(filePath) {
+        try {
+            const stats = await stat(filePath);
+            const content = await readFile(filePath, { encoding: "utf-8" });
+            const firstNewline = content.indexOf("\n");
+            const firstLine = firstNewline > 0 ? content.slice(0, firstNewline) : content;
+            if (!firstLine.trim())
+                return null;
+            const entry = parseCodexSessionEntry(firstLine);
+            if (!entry || entry.type !== "session_meta")
+                return null;
+            const meta = entry.payload;
+            return {
+                id: meta.id,
+                filePath,
+                cwd: meta.cwd,
+                timestamp: meta.timestamp,
+                mtime: stats.mtimeMs,
+                size: stats.size,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Extract title from entries (first user message).
+     */
+    extractTitle(entries) {
+        const hasResponseItemUser = this.hasResponseItemUserMessages(entries);
+        const skipLeadingSystemPrompts = true;
+        // Find first user message
+        for (const entry of entries) {
+            if (!hasResponseItemUser &&
+                entry.type === "event_msg" &&
+                entry.payload.type === "user_message") {
+                const fullTitle = entry.payload.message.trim();
+                if (skipLeadingSystemPrompts &&
+                    this.isSystemPromptUserMessage(fullTitle)) {
+                    continue;
+                }
+                const title = fullTitle.length <= SESSION_TITLE_MAX_LENGTH
+                    ? fullTitle
+                    : `${fullTitle.slice(0, SESSION_TITLE_MAX_LENGTH - 3)}...`;
+                return { title, fullTitle };
+            }
+            if (entry.type === "response_item") {
+                const payload = entry.payload;
+                if (payload.type === "message" && payload.role === "user") {
+                    const text = payload.content
+                        .map((c) => ("text" in c ? c.text : ""))
+                        .join("\n")
+                        .trim();
+                    if (text &&
+                        !(skipLeadingSystemPrompts && this.isSystemPromptUserMessage(text))) {
+                        const title = text.length <= SESSION_TITLE_MAX_LENGTH
+                            ? text
+                            : `${text.slice(0, SESSION_TITLE_MAX_LENGTH - 3)}...`;
+                        return { title, fullTitle: text };
+                    }
+                }
+            }
+        }
+        return { title: null, fullTitle: null };
+    }
+    isSystemPromptUserMessage(text) {
+        const trimmed = text.trimStart();
+        return (trimmed.startsWith("# AGENTS.md instructions") ||
+            trimmed.startsWith("<environment_context>"));
+    }
+    /**
+     * Count user/assistant messages in entries.
+     *
+     * Matches the logic in convertEntriesToMessages - we count user_message
+     * events and response_item messages, but not agent_message events since
+     * those are streaming duplicates.
+     */
+    countMessages(entries) {
+        let count = 0;
+        const hasResponseItemUser = this.hasResponseItemUserMessages(entries);
+        for (const entry of entries) {
+            if (entry.type === "event_msg") {
+                // Only count user_message events (not agent_message streaming tokens)
+                if (entry.payload.type === "user_message" && !hasResponseItemUser) {
+                    count++;
+                }
+            }
+            else if (entry.type === "response_item") {
+                if (entry.payload.type === "message") {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+    /**
+     * Extract context usage from token_count events.
+     */
+    extractContextUsage(entries) {
+        // Find last token_count event
+        for (let i = entries.length - 1; i >= 0; i--) {
+            const entry = entries[i];
+            if (entry &&
+                entry.type === "event_msg" &&
+                entry.payload.type === "token_count") {
+                const info = entry.payload.info;
+                if (info?.last_token_usage || info?.total_token_usage) {
+                    const usage = info.last_token_usage ?? info.total_token_usage;
+                    if (!usage)
+                        continue;
+                    const inputTokens = usage.input_tokens + (usage.cached_input_tokens ?? 0);
+                    if (inputTokens === 0)
+                        continue;
+                    const contextWindow = info.model_context_window && info.model_context_window > 0
+                        ? info.model_context_window
+                        : CONTEXT_WINDOW_SIZE;
+                    const percentage = Math.min(100, Math.round((inputTokens / contextWindow) * 100));
+                    return { inputTokens, percentage };
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Extract the model from turn_context entries.
+     */
+    extractModel(entries) {
+        // Find first turn_context entry with a model
+        for (const entry of entries) {
+            if (entry.type === "turn_context" && entry.payload.model) {
+                return entry.payload.model;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Determine provider based on session metadata or model.
+     */
+    determineProvider(metaEntry, model) {
+        // Check explicit provider field if available
+        if (metaEntry.payload.model_provider) {
+            const provider = metaEntry.payload.model_provider.toLowerCase();
+            if (provider === "ollama" ||
+                provider === "lmstudio" ||
+                provider === "local") {
+                return "codex-oss";
+            }
+            if (provider === "openai" || provider === "azure") {
+                return "codex";
+            }
+        }
+        // fallback: check model name for known local models if provider not set
+        if (model) {
+            const lowerModel = model.toLowerCase();
+            // Heuristic: models starting with "gpt-" or "o1-" are usually OpenAI
+            if (lowerModel.startsWith("gpt-") || lowerModel.startsWith("o1-")) {
+                return "codex";
+            }
+            // Heuristic: other models often implying local usage (llama, mistral, qwen, etc)
+            // or if we just default to everything else being oss?
+            // For safety, let's just stick to specific local keywords for now to avoid false positives.
+            if (lowerModel.includes("llama") ||
+                lowerModel.includes("mistral") ||
+                lowerModel.includes("qwen") ||
+                lowerModel.includes("gemma") ||
+                lowerModel.includes("deepseek") ||
+                lowerModel.includes("phi")) {
+                return "codex-oss";
+            }
+        }
+        // Default to codex if we can't be sure
+        return "codex";
+    }
+    /**
+     * Helper to determine provider from a list of entries.
+     */
+    determineProviderFromEntries(entries) {
+        const metaEntry = entries.find((e) => e.type === "session_meta");
+        if (!metaEntry)
+            return "codex";
+        const model = this.extractModel(entries);
+        return this.determineProvider(metaEntry, model);
+    }
+    /**
+     * Convert Codex JSONL entries to Message format.
+     *
+     * Codex sessions contain both streaming events (event_msg) and aggregated
+     * response_item entries. We prefer response_item for messages since they
+     * contain the complete text, and only use event_msg for user_message events.
+     *
+     * Unlike Claude's DAG structure, Codex sessions are linear. We create a
+     * parentUuid chain by linking each message to the previous one, which
+     * enables proper ordering and deduplication in the client.
+     *
+     * @deprecated Potentially dead code - conversion now happens in normalization.ts.
+     * This method may be removed once we confirm it's no longer called.
+     */
+    convertEntriesToMessages(entries) {
+        const messages = [];
+        let messageIndex = 0;
+        let lastMessageUuid = null;
+        const hasResponseItemUser = this.hasResponseItemUserMessages(entries);
+        // Track function calls for pairing with outputs
+        const pendingCalls = new Map();
+        for (const entry of entries) {
+            if (entry.type === "response_item") {
+                const msg = this.convertResponseItem(entry, messageIndex++, pendingCalls);
+                if (msg) {
+                    // Set parentUuid to create linear chain for ordering/dedup
+                    msg.parentUuid = lastMessageUuid;
+                    lastMessageUuid = msg.uuid ?? null;
+                    messages.push(msg);
+                }
+            }
+            else if (entry.type === "event_msg") {
+                // Only process user_message events - agent_message events are
+                // duplicates of the response_item data (streaming tokens)
+                if (entry.payload.type === "user_message" && !hasResponseItemUser) {
+                    const msg = this.convertEventMsg(entry, messageIndex++);
+                    if (msg) {
+                        // Set parentUuid to create linear chain for ordering/dedup
+                        msg.parentUuid = lastMessageUuid;
+                        lastMessageUuid = msg.uuid ?? null;
+                        messages.push(msg);
+                    }
+                }
+                // Skip agent_message, agent_reasoning, token_count - these are
+                // streaming events that duplicate response_item content
+            }
+            // Skip session_meta and turn_context for now
+        }
+        return messages;
+    }
+    hasResponseItemUserMessages(entries) {
+        return entries.some((entry) => entry.type === "response_item" &&
+            entry.payload.type === "message" &&
+            entry.payload.role === "user");
+    }
+    /**
+     * Convert a response_item entry to a Message.
+     *
+     * @deprecated Potentially dead code - conversion now happens in normalization.ts.
+     */
+    convertResponseItem(entry, index, pendingCalls) {
+        const payload = entry.payload;
+        const uuid = `codex-${index}-${entry.timestamp}`;
+        switch (payload.type) {
+            case "message":
+                return this.convertMessagePayload(payload, uuid, entry.timestamp);
+            case "reasoning":
+                return this.convertReasoningPayload(payload, uuid, entry.timestamp);
+            case "function_call":
+                // Store for pairing with output
+                pendingCalls.set(payload.call_id, {
+                    name: payload.name,
+                    arguments: payload.arguments,
+                    timestamp: entry.timestamp,
+                });
+                // Create tool_use message
+                return this.convertFunctionCallPayload(payload, uuid, entry.timestamp);
+            case "function_call_output":
+                return this.convertFunctionCallOutputPayload(payload, uuid, entry.timestamp, pendingCalls);
+            case "ghost_snapshot":
+                // Skip git snapshot entries for now
+                return null;
+            default:
+                return null;
+        }
+    }
+    /**
+     * Convert a message payload (user or assistant).
+     *
+     * Codex streams tokens as separate output_text blocks, so we concatenate
+     * them into a single text block for proper rendering.
+     *
+     * @deprecated Potentially dead code - conversion now happens in normalization.ts.
+     */
+    convertMessagePayload(payload, uuid, timestamp) {
+        // Concatenate all text blocks into a single string
+        const fullText = payload.content.map((c) => c.text).join("");
+        // Skip empty messages
+        if (!fullText.trim()) {
+            return {
+                uuid,
+                type: payload.role,
+                message: {
+                    role: payload.role,
+                    content: [],
+                },
+                timestamp,
+            };
+        }
+        const content = [
+            {
+                type: "text",
+                text: fullText,
+            },
+        ];
+        return {
+            uuid,
+            type: payload.role,
+            message: {
+                role: payload.role,
+                content,
+            },
+            timestamp,
+        };
+    }
+    /**
+     * Convert a reasoning payload (thinking).
+     *
+     * @deprecated Potentially dead code - conversion now happens in normalization.ts.
+     */
+    convertReasoningPayload(payload, uuid, timestamp) {
+        // Extract text from summary or encrypted content indicator
+        const summaryText = payload.summary
+            ?.map((s) => s.text)
+            .join("\n")
+            .trim();
+        const content = [];
+        if (summaryText) {
+            content.push({
+                type: "thinking",
+                thinking: summaryText,
+            });
+        }
+        if (payload.encrypted_content) {
+            content.push({
+                type: "text",
+                text: "[Encrypted reasoning content]",
+            });
+        }
+        return {
+            uuid,
+            type: "assistant",
+            message: {
+                role: "assistant",
+                content,
+            },
+            timestamp,
+        };
+    }
+    /**
+     * Convert a function_call payload to tool_use.
+     *
+     * @deprecated Potentially dead code - conversion now happens in normalization.ts.
+     */
+    convertFunctionCallPayload(payload, uuid, timestamp) {
+        let input;
+        try {
+            input = JSON.parse(payload.arguments);
+        }
+        catch {
+            input = { raw: payload.arguments };
+        }
+        const content = [
+            {
+                type: "tool_use",
+                id: payload.call_id,
+                name: payload.name,
+                input,
+            },
+        ];
+        return {
+            uuid,
+            type: "assistant",
+            message: {
+                role: "assistant",
+                content,
+            },
+            timestamp,
+        };
+    }
+    /**
+     * Convert a function_call_output payload to tool_result.
+     *
+     * @deprecated Potentially dead code - conversion now happens in normalization.ts.
+     */
+    convertFunctionCallOutputPayload(payload, uuid, timestamp, _pendingCalls) {
+        return {
+            uuid,
+            type: "tool_result",
+            toolUseResult: {
+                tool_use_id: payload.call_id,
+                content: payload.output,
+            },
+            timestamp,
+        };
+    }
+    /**
+     * Convert an event_msg entry to a Message.
+     *
+     * @deprecated Potentially dead code - conversion now happens in normalization.ts.
+     */
+    convertEventMsg(entry, index) {
+        const payload = entry.payload;
+        const uuid = `codex-event-${index}-${entry.timestamp}`;
+        switch (payload.type) {
+            case "user_message":
+                return {
+                    uuid,
+                    type: "user",
+                    message: {
+                        role: "user",
+                        content: payload.message,
+                    },
+                    timestamp: entry.timestamp,
+                };
+            case "agent_message":
+                return {
+                    uuid,
+                    type: "assistant",
+                    message: {
+                        role: "assistant",
+                        content: [{ type: "text", text: payload.message }],
+                    },
+                    timestamp: entry.timestamp,
+                };
+            case "agent_reasoning":
+                return {
+                    uuid,
+                    type: "assistant",
+                    message: {
+                        role: "assistant",
+                        content: [{ type: "thinking", thinking: payload.text }],
+                    },
+                    timestamp: entry.timestamp,
+                };
+            case "token_count":
+                // Skip token count events in messages
+                return null;
+            default:
+                return null;
+        }
+    }
+}
+//# sourceMappingURL=codex-reader.js.map