lunel-cli 0.1.114 → 0.1.116

package/dist/ai/codex.js

@@ -6,6 +6,18 @@ import * as path from "path";
 import { spawn } from "child_process";
 import { createInterface } from "readline";
 const THREAD_LIST_SOURCE_KINDS = ["cli", "vscode", "appServer", "exec", "unknown"];
+const CODEX_AGENTS = [
+    {
+        name: "Build",
+        mode: "default",
+        description: "Default Codex collaboration mode.",
+    },
+    {
+        name: "plan",
+        mode: "plan",
+        description: "Plan-first Codex collaboration mode.",
+    },
+];
 const DEBUG_MODE = process.env.LUNEL_DEBUG === "1" || process.env.LUNEL_DEBUG_AI === "1";
 function joinStreamingText(previousText, nextChunk) {
     if (!previousText) {
@@ -29,14 +41,22 @@ export class CodexProvider {
     proc = null;
     shuttingDown = false;
     emitter = null;
+    defaultModelContextWindow = null;
     nextId = 1;
     pending = new Map();
     sessions = new Map();
     deletedThreadIds = new Set();
     resumedThreadIds = new Set();
     pendingPermissionRequestIds = new Map();
+    pendingQuestionRequestIds = new Map();
     assistantMessageIdByTurnId = new Map();
     partTextById = new Map();
+    debugLog(message, fields) {
+        if (!DEBUG_MODE)
+            return;
+        const suffix = fields ? ` ${JSON.stringify(fields)}` : "";
+        console.log(`[codex] ${message}${suffix}`);
+    }
     async init() {
         if (DEBUG_MODE)
             console.log("Starting Codex app-server...");
@@ -61,7 +81,15 @@ export class CodexProvider {
                 this.emitter?.({ type: "sse_dead", properties: { error: msg } });
             }
         });
-        await this.call("initialize", { clientInfo: { name: "lunel", version: "1.0" } });
+        await this.call("initialize", {
+            clientInfo: { name: "lunel", version: "1.0" },
+            capabilities: {
+                experimentalApi: true,
+            },
+        });
+        await this.refreshConfigDefaults().catch(() => {
+            // Config defaults are best-effort metadata only.
+        });
         if (DEBUG_MODE)
             console.log("Codex ready.\n");
     }
@@ -78,7 +106,10 @@ export class CodexProvider {
         };
     }
     async createSession(title) {
-        const result = await this.call("thread/start", { cwd: process.cwd() });
+        const result = await this.call("thread/start", {
+            cwd: process.cwd(),
+            persistExtendedHistory: true,
+        });
         const threadObject = this.extractThreadObject(result);
         const threadId = this.extractThreadId(threadObject);
         if (!threadId) {
@@ -143,8 +174,53 @@ export class CodexProvider {
         }
         return { deleted: true };
     }
+    async renameSession(id, title) {
+        const trimmed = title.trim();
+        if (!trimmed) {
+            throw new Error("Session title cannot be empty");
+        }
+        const methodsToTry = [
+            { method: "thread/name/set", params: { threadId: id, name: trimmed } },
+            { method: "thread/name/set", params: { threadId: id, title: trimmed } },
+            { method: "thread/name/update", params: { threadId: id, name: trimmed } },
+            { method: "thread/name/update", params: { threadId: id, title: trimmed } },
+            { method: "thread/metadata/update", params: { threadId: id, title: trimmed } },
+            { method: "thread/update", params: { threadId: id, title: trimmed } },
+            { method: "thread/rename", params: { threadId: id, title: trimmed } },
+        ];
+        let renamed = false;
+        let lastError = null;
+        for (const entry of methodsToTry) {
+            try {
+                await this.call(entry.method, entry.params);
+                renamed = true;
+                break;
+            }
+            catch (err) {
+                lastError = err;
+            }
+        }
+        if (!renamed && lastError) {
+            throw lastError instanceof Error ? lastError : new Error(String(lastError));
+        }
+        const existing = this.sessions.get(id) ?? this.ensureLocalSession(id);
+        const session = this.upsertSession({
+            id,
+            title: trimmed,
+            createdAt: existing.createdAt,
+            updatedAt: Date.now(),
+            archived: existing.archived,
+            cwd: existing.cwd,
+        }, true);
+        return { session: this.toSessionInfo(session) };
+    }
     async getMessages(sessionId) {
         const session = this.ensureLocalSession(sessionId);
+        this.debugLog("getMessages start", {
+            sessionId,
+            existingMessageCount: session.messages.length,
+            existingPartCount: session.messages.reduce((sum, message) => sum + (message.parts?.length || 0), 0),
+        });
         const result = await this.call("thread/read", {
             threadId: session.id,
             includeTurns: true,
@@ -153,7 +229,16 @@ export class CodexProvider {
         if (!threadObject) {
             return { messages: session.messages };
         }
+        this.logThreadReadSummary(sessionId, threadObject);
         const historyMessages = this.decodeMessagesFromThreadRead(sessionId, threadObject);
+        this.debugLog("getMessages decoded thread", {
+            sessionId,
+            turnCount: this.readArray(threadObject.turns).length,
+            decodedMessageCount: historyMessages.length,
+            decodedPartCount: historyMessages.reduce((sum, message) => sum + (message.parts?.length || 0), 0),
+            decodedRoles: historyMessages.map((message) => message.role),
+            decodedPartTypes: historyMessages.flatMap((message) => (message.parts || []).map((part) => String(this.asRecord(part).type ?? "unknown"))),
+        });
         if (historyMessages.length > 0) {
             session.messages = historyMessages;
         }
@@ -165,6 +250,17 @@ export class CodexProvider {
             archived: false,
             cwd: this.extractThreadCwd(threadObject) ?? session.cwd,
         });
+        if (this.defaultModelContextWindow && this.defaultModelContextWindow > 0) {
+            this.emitter?.({
+                type: "session.usage",
+                properties: {
+                    sessionID: sessionId,
+                    tokenUsage: {
+                        modelContextWindow: this.defaultModelContextWindow,
+                    },
+                },
+            });
+        }
         return { messages: session.messages };
     }
     async prompt(sessionId, text, model, agent, files = [], codexOptions) {
@@ -172,26 +268,31 @@ export class CodexProvider {
         session.updatedAt = Date.now();
         (async () => {
             try {
-                await this.ensureThreadResumed(session.id);
+                const effortLevels = ["low", "medium", "high"];
+                const speedDelta = {
+                    fast: -1,
+                    balanced: 0,
+                    quality: 1,
+                };
+                const baseEffort = codexOptions?.reasoningEffort ?? "medium";
+                const baseIndex = effortLevels.indexOf(baseEffort);
+                const adjustedIndex = Math.max(0, Math.min(effortLevels.length - 1, baseIndex + (codexOptions?.speed ? speedDelta[codexOptions.speed] : 0)));
+                const reasoningEffort = effortLevels[adjustedIndex];
+                const modelId = await this.resolveModelId(model);
+                const collaborationMode = this.buildCollaborationMode(agent, modelId, reasoningEffort);
+                // Freshly created sessions already have a live backend thread from
+                // thread/start. Forcing thread/resume here can attach stale state to a
+                // brand-new session and trigger rollout lookup failures on turn/start.
+                await this.ensureThreadResumed(session.id, false, codexOptions, collaborationMode);
                 let imageUrlKey = "url";
                 while (true) {
                     try {
-                        const effortLevels = ["low", "medium", "high"];
-                        const speedDelta = {
-                            fast: -1,
-                            balanced: 0,
-                            quality: 1,
-                        };
-                        const baseEffort = codexOptions?.reasoningEffort ?? "medium";
-                        const baseIndex = effortLevels.indexOf(baseEffort);
-                        const adjustedIndex = Math.max(0, Math.min(effortLevels.length - 1, baseIndex + (codexOptions?.speed ? speedDelta[codexOptions.speed] : 0)));
-                        const reasoningEffort = effortLevels[adjustedIndex];
                         await this.call("turn/start", {
                             threadId: session.id,
                             input: this.makeTurnInputPayload(text, files, imageUrlKey),
-                            ...(model ? { model: model.providerID === "codex" ? model.modelID : `${model.providerID}/${model.modelID}` } : {}),
-                            ...(agent ? { agent } : {}),
+                            ...(modelId ? { model: modelId } : {}),
                             ...(reasoningEffort ? { reasoningEffort } : {}),
+                            ...(collaborationMode ? { collaborationMode } : {}),
                         });
                         break;
                     }
@@ -225,7 +326,7 @@ export class CodexProvider {
         return {};
     }
     async agents() {
-        return { agents: [] };
+        return { agents: [...CODEX_AGENTS] };
     }
     async providers() {
         const items = await this.fetchModels();
@@ -283,11 +384,53 @@ export class CodexProvider {
         });
         return {};
     }
-    async questionReply() {
-        throw new Error("Codex structured user input is not supported by Lunel yet");
+    async questionReply(sessionId, questionId, answers) {
+        const pending = this.pendingQuestionRequestIds.get(questionId);
+        if (!pending) {
+            this.emitter?.({
+                type: "question.replied",
+                properties: { sessionID: sessionId, requestID: questionId, answers, skipped: true },
+            });
+            return {};
+        }
+        const responseAnswers = {};
+        pending.questionIds.forEach((id, index) => {
+            responseAnswers[id] = {
+                answers: Array.isArray(answers[index]) ? answers[index].filter((value) => typeof value === "string") : [],
+            };
+        });
+        this.send({
+            jsonrpc: "2.0",
+            id: pending.requestId,
+            result: { answers: responseAnswers },
+        });
+        this.pendingQuestionRequestIds.delete(questionId);
+        this.emitter?.({
+            type: "question.replied",
+            properties: { sessionID: sessionId, requestID: questionId, answers },
+        });
+        return {};
     }
-    async questionReject() {
-        throw new Error("Codex structured user input is not supported by Lunel yet");
+    async questionReject(sessionId, questionId) {
+        const pending = this.pendingQuestionRequestIds.get(questionId);
+        if (!pending) {
+            this.emitter?.({
+                type: "question.rejected",
+                properties: { sessionID: sessionId, requestID: questionId, skipped: true },
+            });
+            return {};
+        }
+        this.send({
+            jsonrpc: "2.0",
+            id: pending.requestId,
+            result: { answers: {} },
+        });
+        this.pendingQuestionRequestIds.delete(questionId);
+        this.emitter?.({
+            type: "question.rejected",
+            properties: { sessionID: sessionId, requestID: questionId },
+        });
+        return {};
     }
     send(req) {
         if (!this.proc?.stdin?.writable)
@@ -344,10 +487,28 @@ export class CodexProvider {
     handleServerRequest(method, requestId, params) {
         const session = this.resolveSessionFromPayload(params);
         if (method === "item/tool/requestUserInput") {
-            this.send({
-                jsonrpc: "2.0",
-                id: requestId,
-                error: { code: -32601, message: "Structured user input is not supported by Lunel yet" },
+            const questionRequestId = String(requestId);
+            const callId = this.extractItemId(params) ?? undefined;
+            const messageId = session ? this.ensureAssistantMessage(session, this.extractTurnId(params) ?? `session:${session.id}`) : undefined;
+            const questions = this.extractStructuredUserInputQuestions(params);
+            this.pendingQuestionRequestIds.set(questionRequestId, {
+                sessionId: session?.id ?? "",
+                requestId,
+                messageId,
+                callId,
+                questionIds: questions.map((question) => this.readString(this.asRecord(question).id)).filter((value) => Boolean(value)),
+            });
+            this.emitter?.({
+                type: "question.asked",
+                properties: {
+                    id: questionRequestId,
+                    sessionID: session?.id,
+                    questions,
+                    tool: {
+                        ...(messageId ? { messageID: messageId } : {}),
+                        ...(callId ? { callID: callId } : {}),
+                    },
+                },
             });
             return;
         }
@@ -427,6 +588,17 @@ export class CodexProvider {
                     });
                 }
                 return;
+            case "thread/tokenUsage/updated":
+                if (session) {
+                    this.emitter?.({
+                        type: "session.usage",
+                        properties: {
+                            sessionID: session.id,
+                            tokenUsage: params.tokenUsage ?? null,
+                        },
+                    });
+                }
+                return;
             case "turn/completed":
             case "turn/failed":
                 if (session) {
@@ -503,6 +675,9 @@ export class CodexProvider {
                     this.pendingPermissionRequestIds.delete(permissionId);
                     this.emitter?.({ type: "permission.replied", properties: { permissionId } });
                 }
+                if (permissionId && this.pendingQuestionRequestIds.has(permissionId)) {
+                    this.pendingQuestionRequestIds.delete(permissionId);
+                }
                 return;
             }
             default:
@@ -621,7 +796,7 @@ export class CodexProvider {
         const itemId = this.extractItemId(params) ?? this.readString(item.id) ?? normalizedType ?? "tool";
         const fileChangeLike = this.isFileChangeStructuredItem(normalizedType, item, params);
         const emittedPartType = normalizedType === "plan"
-            ? "reasoning"
+            ? "plan"
             : (fileChangeLike ? "file-change" : "tool");
         const partId = `${messageId}:${emittedPartType}:${itemId}`;
         const nextText = this.extractStructuredOutput(params, item, normalizedType);
@@ -644,8 +819,8 @@ export class CodexProvider {
             sessionID: session.id,
             messageID: messageId,
             type: emittedPartType,
-            ...(emittedPartType === "reasoning"
-                ? { text: outputValue ?? "Planning..." }
+            ...(emittedPartType === "plan"
+                ? { text: outputValue ?? (emittedPartType === "plan" ? "Planning..." : "") }
                 : { name, toolName: name, input, output: outputValue, state, ...(patch ? { patch } : {}) }),
         };
         this.upsertLocalMessagePart(session, messageId, part);
@@ -720,6 +895,22 @@ export class CodexProvider {
     async fetchServerThreads() {
         return this.fetchServerThreadsByArchiveState(false);
     }
+    async refreshConfigDefaults() {
+        const result = await this.call("config/read", undefined);
+        const payload = this.asRecord(result);
+        const config = this.asRecord(payload.config ?? result);
+        const raw = config.model_context_window;
+        if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) {
+            this.defaultModelContextWindow = raw;
+            return;
+        }
+        if (typeof raw === "string" && raw.trim()) {
+            const parsed = Number(raw);
+            if (Number.isFinite(parsed) && parsed > 0) {
+                this.defaultModelContextWindow = parsed;
+            }
+        }
+    }
     async refreshSessionMetadata(sessionId) {
         const session = this.sessions.get(sessionId);
         const result = await this.call("thread/read", {
@@ -800,6 +991,30 @@ export class CodexProvider {
         })
             .filter((value) => Boolean(value));
     }
+    async resolveModelId(model) {
+        if (model) {
+            return model.providerID === "codex" ? model.modelID : `${model.providerID}/${model.modelID}`;
+        }
+        const items = await this.fetchModels();
+        return items.find((item) => item.isDefault)?.model ?? items[0]?.model;
+    }
+    buildCollaborationMode(agent, modelId, reasoningEffort) {
+        const normalizedAgent = (agent ?? "").trim().toLowerCase();
+        const mode = normalizedAgent === "build" ? "default" : normalizedAgent;
+        if (mode !== "default" && mode !== "plan") {
+            return undefined;
+        }
+        if (!modelId) {
+            return undefined;
+        }
+        return {
+            mode,
+            settings: {
+                model: modelId,
+                reasoning_effort: reasoningEffort,
+            },
+        };
+    }
     parseThreadListEntry(value, archived = false) {
         const obj = this.asRecord(value);
         const id = this.extractThreadId(obj);
@@ -909,16 +1124,27 @@ export class CodexProvider {
             return existing;
         return this.upsertSession({ id: sessionId, title: "Conversation", createdAt: Date.now(), updatedAt: Date.now() });
     }
-    async ensureThreadResumed(threadId, force = false) {
+    async ensureThreadResumed(threadId, force = false, codexOptions, collaborationMode) {
         if (!threadId || this.resumedThreadIds.has(threadId)) {
             if (!force)
                 return;
         }
         const session = this.sessions.get(threadId);
-        const params = { threadId };
+        const params = {
+            threadId,
+            persistExtendedHistory: true,
+        };
         if (session?.cwd) {
             params.cwd = session.cwd;
         }
+        const permissionMode = codexOptions?.permissionMode ?? "default";
+        if (permissionMode === "full-access") {
+            params.approvalPolicy = "never";
+            params.sandbox = "danger-full-access";
+        }
+        if (collaborationMode) {
+            params.collaborationMode = collaborationMode;
+        }
         const result = await this.call("thread/resume", params);
         const payload = this.asRecord(result);
         const threadValue = payload.thread;
@@ -971,9 +1197,14 @@ export class CodexProvider {
             const turnId = this.readString(turnObject.id);
             const turnTime = this.extractUpdatedAt(turnObject) ?? this.extractCreatedAt(turnObject) ?? Date.now();
             const items = this.readArray(turnObject.items);
+            const assistantParts = [];
+            let assistantMessageId;
+            let assistantTimestamp = turnTime;
+            const turnItemTypes = [];
             for (const item of items) {
                 const itemObject = this.asRecord(item);
                 const type = this.normalizedItemType(this.readString(itemObject.type) ?? "");
+                turnItemTypes.push(type || "unknown");
                 const itemId = this.readString(itemObject.id) ?? crypto.randomUUID();
                 const timestamp = this.extractUpdatedAt(itemObject) ?? this.extractCreatedAt(itemObject) ?? (turnTime + orderOffset++);
                 if (type === "usermessage") {
@@ -992,88 +1223,256 @@ export class CodexProvider {
                     const text = this.decodeItemText(itemObject);
                     if (!text)
                         continue;
-                    messages.push({
-                        id: itemId,
-                        role: "assistant",
-                        parts: [{ id: `${itemId}:text`, type: "text", text, sessionID: threadId, messageID: itemId }],
-                        time: timestamp,
+                    assistantMessageId = assistantMessageId ?? itemId;
+                    assistantTimestamp = Math.max(assistantTimestamp, timestamp);
+                    assistantParts.push({
+                        id: `${assistantMessageId}:text:${itemId}`,
+                        type: "text",
+                        text,
+                        sessionID: threadId,
+                        messageID: assistantMessageId,
                     });
-                    if (turnId)
-                        this.assistantMessageIdByTurnId.set(turnId, itemId);
                     continue;
                 }
                 if (type === "reasoning") {
                     const text = this.decodeReasoningItemText(itemObject);
-                    messages.push({
-                        id: itemId,
-                        role: "assistant",
-                        parts: [{ id: `${itemId}:reasoning`, type: "reasoning", text, sessionID: threadId, messageID: itemId }],
-                        time: timestamp,
+                    assistantMessageId = assistantMessageId ?? (turnId ? `assistant:${turnId}` : itemId);
+                    assistantTimestamp = Math.max(assistantTimestamp, timestamp);
+                    assistantParts.push({
+                        id: `${assistantMessageId}:reasoning:${itemId}`,
+                        type: "reasoning",
+                        text,
+                        sessionID: threadId,
+                        messageID: assistantMessageId,
                     });
                     continue;
                 }
                 if (type === "plan") {
                     const text = this.decodePlanItemText(itemObject);
-                    messages.push({
-                        id: itemId,
-                        role: "assistant",
-                        parts: [{ id: `${itemId}:plan`, type: "reasoning", text, sessionID: threadId, messageID: itemId }],
-                        time: timestamp,
+                    assistantMessageId = assistantMessageId ?? (turnId ? `assistant:${turnId}` : itemId);
+                    assistantTimestamp = Math.max(assistantTimestamp, timestamp);
+                    assistantParts.push({
+                        id: `${assistantMessageId}:plan:${itemId}`,
+                        type: "plan",
+                        text,
+                        sessionID: threadId,
+                        messageID: assistantMessageId,
                     });
                     continue;
                 }
-                if (type === "commandexecution" || type === "enteredreviewmode" || type === "contextcompaction") {
-                    const output = this.decodeCommandExecutionItemText(itemObject, type);
-                    const input = this.extractCommandExecutionInput(itemObject);
-                    messages.push({
-                        id: itemId,
-                        role: "assistant",
-                        parts: [{
-                                id: `${itemId}:tool`,
-                                type: "tool",
-                                name: type === "commandexecution" ? "command" : "system",
-                                toolName: type === "commandexecution" ? "command" : "system",
-                                ...(input ? { input } : {}),
-                                output,
-                                state: "completed",
-                                sessionID: threadId,
-                                messageID: itemId,
-                            }],
-                        time: timestamp,
-                    });
+                if (type === "commandexecution"
+                    || type === "enteredreviewmode"
+                    || type === "exitedreviewmode"
+                    || type === "contextcompaction"
+                    || type === "mcptoolcall"
+                    || type === "dynamictoolcall"
+                    || type === "collabtoolcall"
+                    || type === "collabagenttoolcall"
+                    || type === "websearch"
+                    || type === "imageview") {
+                    assistantMessageId = assistantMessageId ?? (turnId ? `assistant:${turnId}` : itemId);
+                    assistantTimestamp = Math.max(assistantTimestamp, timestamp);
+                    assistantParts.push(this.decodeStoredToolLikePart(type, itemObject, threadId, assistantMessageId, itemId));
                     continue;
                 }
                 if (type === "filechange" || type === "toolcall" || type === "diff") {
-                    const output = this.decodeFileLikeItemText(itemObject);
-                    if (!output)
-                        continue;
-                    const emittedPartType = this.isFileChangeStructuredItem(type, itemObject)
-                        ? "file-change"
-                        : "tool";
-                    const patch = emittedPartType === "file-change"
-                        ? this.extractCanonicalPatch({}, itemObject)
-                        : undefined;
-                    messages.push({
-                        id: itemId,
-                        role: "assistant",
-                        parts: [{
-                                id: `${itemId}:${emittedPartType}`,
-                                type: emittedPartType,
-                                name: type,
-                                toolName: type,
-                                output,
-                                state: "completed",
-                                ...(patch ? { patch } : {}),
-                                sessionID: threadId,
-                                messageID: itemId,
-                            }],
-                        time: timestamp,
-                    });
+                    assistantMessageId = assistantMessageId ?? (turnId ? `assistant:${turnId}` : itemId);
+                    assistantTimestamp = Math.max(assistantTimestamp, timestamp);
+                    assistantParts.push(this.decodeStoredToolLikePart(type, itemObject, threadId, assistantMessageId, itemId));
+                }
+            }
+            if (assistantParts.length > 0) {
+                const resolvedAssistantMessageId = assistantMessageId ?? (turnId ? `assistant:${turnId}` : crypto.randomUUID());
+                messages.push({
+                    id: resolvedAssistantMessageId,
+                    role: "assistant",
+                    parts: assistantParts.map((part) => ({
+                        ...part,
+                        sessionID: threadId,
+                        messageID: resolvedAssistantMessageId,
+                    })),
+                    time: assistantTimestamp,
+                });
+                if (turnId) {
+                    this.assistantMessageIdByTurnId.set(turnId, resolvedAssistantMessageId);
                 }
             }
+            this.debugLog("decoded stored turn", {
+                threadId,
+                turnId: turnId ?? null,
+                itemCount: items.length,
+                itemTypes: turnItemTypes,
+                emittedUserMessages: messages.filter((message) => message.role === "user").length,
+                emittedAssistantParts: assistantParts.length,
+            });
         }
         return messages;
     }
+    logThreadReadSummary(sessionId, threadObject) {
+        const turns = this.readArray(threadObject.turns);
+        const turnSummaries = turns.map((turn, index) => {
+            const turnObject = this.asRecord(turn);
+            const items = this.readArray(turnObject.items);
+            return {
+                index,
+                turnId: this.readString(turnObject.id) ?? null,
+                status: this.readString(turnObject.status) ?? this.readString(this.asRecord(turnObject.status).type) ?? null,
+                itemCount: items.length,
+                itemTypes: items.map((item) => this.normalizedItemType(this.readString(this.asRecord(item).type) ?? "") || "unknown"),
+                itemSummaries: items.map((item) => {
+                    const itemObject = this.asRecord(item);
+                    const type = this.normalizedItemType(this.readString(itemObject.type) ?? "") || "unknown";
+                    return {
+                        id: this.readString(itemObject.id) ?? null,
+                        type,
+                        keys: Object.keys(itemObject).sort(),
+                        textPreview: this.firstString(itemObject, ["text", "summary", "message", "query", "path", "tool", "command"])?.slice(0, 120) ?? null,
+                        hasAggregatedOutput: typeof itemObject.aggregatedOutput === "string" && itemObject.aggregatedOutput.length > 0,
+                        aggregatedOutputLength: typeof itemObject.aggregatedOutput === "string" ? itemObject.aggregatedOutput.length : 0,
+                        changesCount: Array.isArray(itemObject.changes) ? itemObject.changes.length : 0,
+                        hasResult: itemObject.result != null,
+                        hasContentItems: Array.isArray(itemObject.contentItems) && itemObject.contentItems.length > 0,
+                        status: this.readString(itemObject.status) ?? null,
+                    };
+                }),
+            };
+        });
+        console.log(`[codex-history] thread/read summary ${JSON.stringify({
+            sessionId,
+            threadId: this.readString(threadObject.id) ?? null,
+            turnCount: turns.length,
+            turnSummaries,
+        })}`);
+    }
+    decodeStoredToolLikePart(type, itemObject, threadId, messageId, itemId) {
+        if (type === "filechange" || type === "diff" || this.isFileChangeStructuredItem(type, itemObject)) {
+            const output = this.decodeFileLikeItemText(itemObject) ?? this.describeCompletedItemOutput(itemObject, itemObject, type) ?? "File changes";
+            const patch = this.extractCanonicalPatch(itemObject, itemObject);
+            return {
+                id: `${messageId}:file-change:${itemId}`,
+                type: "file-change",
+                name: this.describeToolPart(type, type, itemObject),
+                toolName: this.describeToolPart(type, type, itemObject),
+                output,
+                state: "completed",
+                ...(patch ? { patch } : {}),
+                sessionID: threadId,
+                messageID: messageId,
+            };
+        }
+        const name = this.describeStoredToolName(type, itemObject);
+        const input = this.extractStoredToolInput(type, itemObject);
+        const output = this.extractStoredToolOutput(type, itemObject);
+        return {
+            id: `${messageId}:tool:${itemId}`,
+            type: "tool",
+            name,
+            toolName: name,
+            ...(input !== undefined ? { input } : {}),
+            ...(output !== undefined ? { output } : {}),
+            state: "completed",
+            sessionID: threadId,
+            messageID: messageId,
+        };
+    }
+    describeStoredToolName(type, itemObject) {
+        if (type === "commandexecution") {
+            return "command";
+        }
+        if (type === "websearch") {
+            return "web-search";
+        }
+        if (type === "imageview") {
+            return "image-view";
+        }
+        if (type === "collabtoolcall" || type === "collabagenttoolcall") {
+            return "agent";
+        }
+        if (type === "enteredreviewmode") {
+            return "review";
+        }
+        if (type === "exitedreviewmode") {
+            return "review";
+        }
+        if (type === "contextcompaction") {
+            return "context";
+        }
+        return this.firstString(itemObject, [
+            "name",
+            "toolName",
+            "tool_name",
+            "title",
+            "serverToolName",
+            "server_tool_name",
+            "kind",
+        ]) ?? type;
+    }
+    extractStoredToolInput(type, itemObject) {
+        if (type === "commandexecution") {
+            return this.extractCommandExecutionInput(itemObject, itemObject);
+        }
+        return itemObject.input
+            ?? itemObject.arguments
+            ?? itemObject.args
+            ?? itemObject.query
+            ?? itemObject.path
+            ?? itemObject.url
+            ?? itemObject.command
+            ?? itemObject.pattern
+            ?? undefined;
+    }
+    extractStoredToolOutput(type, itemObject) {
+        if (type === "commandexecution") {
+            return this.decodeStoredCommandExecutionOutput(itemObject);
+        }
+        if (type === "enteredreviewmode") {
+            return `Reviewing ${this.readString(itemObject.review) ?? "changes"}...`;
+        }
+        if (type === "exitedreviewmode") {
+            return this.firstString(itemObject, ["summary", "text", "message"]) ?? "Exited review mode";
+        }
+        if (type === "contextcompaction") {
+            return "Context compacted";
+        }
+        if (type === "imageview") {
+            const path = this.firstString(itemObject, ["path", "file", "filePath", "file_path", "url"]);
+            return path ? `Viewed image ${path}` : "Viewed image";
+        }
+        const direct = this.firstString(itemObject, [
+            "aggregatedOutput",
+            "output",
+            "outputText",
+            "output_text",
+            "text",
+            "message",
+            "summary",
+            "result",
+            "content",
+        ]);
+        if (direct?.trim()) {
+            return direct.trim();
+        }
+        const flattened = this.flattenTextValue(itemObject.output ?? itemObject.result ?? itemObject.content).trim();
+        return flattened || undefined;
+    }
+    decodeStoredCommandExecutionOutput(itemObject) {
+        const aggregatedOutput = this.firstString(itemObject, [
+            "aggregatedOutput",
+            "aggregated_output",
+            "output",
+            "outputText",
+            "output_text",
+            "stdout",
+            "stderr",
+            "text",
+            "message",
+            "summary",
+        ]);
+        if (aggregatedOutput?.trim()) {
+            return aggregatedOutput.trim();
+        }
+        return this.decodeCommandExecutionItemText(itemObject, "commandexecution");
+    }
     decodeUserMessageParts(itemObject, threadId, itemId) {
         const parts = [];
         const content = this.readArray(itemObject.content);
@@ -1306,6 +1705,41 @@ export class CodexProvider {
             ?? this.readRawString(this.asRecord(payload.event).delta)
             ?? this.readRawString(this.asRecord(payload.event).message));
     }
+    extractStructuredUserInputQuestions(payload) {
+        const rawQuestions = this.readArray(payload.questions);
+        const questions = [];
+        for (const value of rawQuestions) {
+            const question = this.asRecord(value);
+            const options = this.readArray(question.options)
+                .map((option) => {
+                const optionObject = this.asRecord(option);
+                const label = this.readString(optionObject.label);
+                const description = this.readString(optionObject.description);
+                if (!label)
+                    return undefined;
+                return {
+                    label,
+                    ...(description ? { description } : {}),
+                };
+            })
+                .filter((value) => Boolean(value));
+            const id = this.readString(question.id);
+            const header = this.readString(question.header);
+            const prompt = this.readString(question.question);
+            if (!id || !header || !prompt) {
+                continue;
+            }
+            questions.push({
+                id,
+                header,
+                question: prompt,
+                ...(options.length > 0 ? { options } : {}),
+                ...(typeof question.isOther === "boolean" ? { isOther: question.isOther } : {}),
+                ...(typeof question.isSecret === "boolean" ? { isSecret: question.isSecret } : {}),
+            });
+        }
+        return questions;
+    }
     extractThreadId(payload) {
         if (!payload || typeof payload !== "object")
             return undefined;