lunel-cli 0.1.113 → 0.1.115

package/dist/ai/codex.js

@@ -6,32 +6,49 @@ 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) {
         return nextChunk;
     }
-    if (/[\s]$/.test(previousText) || /^[\s]/.test(nextChunk)) {
-        return `${previousText}${nextChunk}`;
+    if (nextChunk.startsWith(previousText)) {
+        return nextChunk;
     }
-    if (/^[.,!?;:)\]%}"'`]/.test(nextChunk)) {
-        return `${previousText}${nextChunk}`;
+    if (previousText.endsWith(nextChunk)) {
+        return previousText;
     }
-    if (/[(\[{/"'`]$/.test(previousText)) {
-        return `${previousText}${nextChunk}`;
+    const maxOverlap = Math.min(previousText.length, nextChunk.length);
+    for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {
+        if (previousText.slice(-overlap) === nextChunk.slice(0, overlap)) {
+            return previousText + nextChunk.slice(overlap);
+        }
     }
-    return `${previousText} ${nextChunk}`;
+    return previousText + nextChunk;
 }
 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();
     async init() {
@@ -58,7 +75,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");
     }
@@ -140,6 +165,46 @@ 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);
         const result = await this.call("thread/read", {
@@ -162,22 +227,49 @@ 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 = []) {
+    async prompt(sessionId, text, model, agent, files = [], codexOptions) {
         const session = this.ensureLocalSession(sessionId);
         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 {
                         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;
                     }
@@ -211,7 +303,7 @@ export class CodexProvider {
         return {};
     }
     async agents() {
-        return { agents: [] };
+        return { agents: [...CODEX_AGENTS] };
     }
     async providers() {
         const items = await this.fetchModels();
@@ -269,11 +361,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)
@@ -330,10 +464,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;
         }
@@ -413,6 +565,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) {
@@ -489,6 +652,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:
@@ -607,7 +773,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);
@@ -630,8 +796,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);
@@ -706,6 +872,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", {
@@ -786,6 +968,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);
@@ -895,7 +1101,7 @@ 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;
@@ -905,6 +1111,14 @@ export class CodexProvider {
         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;
@@ -957,6 +1171,9 @@ 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;
             for (const item of items) {
                 const itemObject = this.asRecord(item);
                 const type = this.normalizedItemType(this.readString(itemObject.type) ?? "");
@@ -978,88 +1195,208 @@ 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 === "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);
                 }
             }
         }
         return messages;
     }
+    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 === "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);
@@ -1282,15 +1619,50 @@ export class CodexProvider {
             ?? this.readString(this.asRecord(this.asRecord(payload.event).item).id));
     }
     extractTextPayload(payload) {
-        return (this.readString(payload.delta)
-            ?? this.readString(payload.text)
-            ?? this.readString(payload.message)
-            ?? this.readString(this.asRecord(payload.item).text)
-            ?? this.readString(this.asRecord(payload.item).delta)
-            ?? this.readString(this.asRecord(payload.item).message)
-            ?? this.readString(this.asRecord(payload.event).text)
-            ?? this.readString(this.asRecord(payload.event).delta)
-            ?? this.readString(this.asRecord(payload.event).message));
+        return (this.readRawString(payload.delta)
+            ?? this.readRawString(payload.text)
+            ?? this.readRawString(payload.message)
+            ?? this.readRawString(this.asRecord(payload.item).text)
+            ?? this.readRawString(this.asRecord(payload.item).delta)
+            ?? this.readRawString(this.asRecord(payload.item).message)
+            ?? this.readRawString(this.asRecord(payload.event).text)
+            ?? 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")
@@ -1362,6 +1734,9 @@ export class CodexProvider {
     readArray(value) {
         return Array.isArray(value) ? value : [];
     }
+    readRawString(value) {
+        return typeof value === "string" ? value : undefined;
+    }
     readString(value) {
         return typeof value === "string" && value.trim() ? value.trim() : undefined;
     }