lunel-cli 0.1.115 → 0.1.116

package/dist/ai/codex.d.ts

@@ -13,6 +13,7 @@ export declare class CodexProvider implements AIProvider {
     private pendingQuestionRequestIds;
     private assistantMessageIdByTurnId;
     private partTextById;
+    private debugLog;
     init(): Promise<void>;
     destroy(): Promise<void>;
     subscribe(emitter: AiEventEmitter): () => void;
@@ -87,6 +88,7 @@ export declare class CodexProvider implements AIProvider {
     private resolveSessionFromPayload;
     private resolveInFlightTurnId;
     private decodeMessagesFromThreadRead;
+    private logThreadReadSummary;
     private decodeStoredToolLikePart;
     private describeStoredToolName;
     private extractStoredToolInput;

package/dist/ai/codex.js

@@ -51,6 +51,12 @@ export class CodexProvider {
     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...");
@@ -100,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) {
@@ -207,6 +216,11 @@ export class CodexProvider {
     }
     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,
@@ -215,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;
         }
@@ -1107,7 +1130,10 @@ export class CodexProvider {
                 return;
         }
         const session = this.sessions.get(threadId);
-        const params = { threadId };
+        const params = {
+            threadId,
+            persistExtendedHistory: true,
+        };
         if (session?.cwd) {
             params.cwd = session.cwd;
         }
@@ -1174,9 +1200,11 @@ export class CodexProvider {
             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") {
@@ -1239,6 +1267,7 @@ export class CodexProvider {
                     || type === "mcptoolcall"
                     || type === "dynamictoolcall"
                     || type === "collabtoolcall"
+                    || type === "collabagenttoolcall"
                     || type === "websearch"
                     || type === "imageview") {
                     assistantMessageId = assistantMessageId ?? (turnId ? `assistant:${turnId}` : itemId);
@@ -1268,9 +1297,53 @@ export class CodexProvider {
                     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";
@@ -1312,6 +1385,9 @@ export class CodexProvider {
         if (type === "imageview") {
             return "image-view";
         }
+        if (type === "collabtoolcall" || type === "collabagenttoolcall") {
+            return "agent";
+        }
         if (type === "enteredreviewmode") {
             return "review";
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunel-cli",
-  "version": "0.1.115",
+  "version": "0.1.116",
   "author": [
     {
       "name": "Soham Bharambe",