lunel-cli 0.1.68 → 0.1.70

package/dist/ai/codex.d.ts

@@ -72,13 +72,7 @@ export declare class CodexProvider implements AIProvider {
     private mergeSession;
     private upsertSession;
     private ensureLocalSession;
-    private getTransportThreadId;
-    private findSessionByThreadId;
     private ensureThreadResumed;
-    private shouldTreatAsThreadNotFound;
-    private ensurePromptSessionReady;
-    private createContinuationSession;
-    private handleMissingThread;
     private resolveSessionFromPayload;
     private resolveInFlightTurnId;
     private decodeMessagesFromThreadRead;

package/dist/ai/codex.js

@@ -102,9 +102,8 @@ export class CodexProvider {
     }
     async getMessages(sessionId) {
         const session = this.ensureLocalSession(sessionId);
-        const transportThreadId = this.getTransportThreadId(session);
         const result = await this.call("thread/read", {
-            threadId: transportThreadId,
+            threadId: session.id,
             includeTurns: true,
         });
         const threadObject = this.extractThreadObject(result);
@@ -121,7 +120,6 @@ export class CodexProvider {
             createdAt: this.extractCreatedAt(threadObject) ?? session.createdAt,
             updatedAt: this.extractUpdatedAt(threadObject) ?? session.updatedAt,
             archived: false,
-            transportThreadId,
             cwd: this.extractThreadCwd(threadObject) ?? session.cwd,
         });
         return { messages: session.messages };
@@ -131,12 +129,12 @@ export class CodexProvider {
         session.updatedAt = Date.now();
         (async () => {
             try {
-                let targetSession = await this.ensurePromptSessionReady(session);
+                await this.ensureThreadResumed(session.id);
                 let imageUrlKey = "url";
                 while (true) {
                     try {
                         await this.call("turn/start", {
-                            threadId: this.getTransportThreadId(targetSession),
+                            threadId: session.id,
                             input: this.makeTurnInputPayload(text, files, imageUrlKey),
                             ...(model ? { model: model.providerID === "codex" ? model.modelID : `${model.providerID}/${model.modelID}` } : {}),
                             ...(agent ? { agent } : {}),
@@ -144,11 +142,6 @@ export class CodexProvider {
                         break;
                     }
                     catch (err) {
-                        if (this.shouldTreatAsThreadNotFound(err)) {
-                            targetSession = await this.createContinuationSession(targetSession);
-                            imageUrlKey = "url";
-                            continue;
-                        }
                         if (imageUrlKey === "url"
                             && files.length > 0
                             && this.shouldRetryTurnStartWithImageURLField(err)) {
@@ -169,13 +162,12 @@ export class CodexProvider {
     }
     async abort(sessionId) {
         const session = this.ensureLocalSession(sessionId);
-        const transportThreadId = this.getTransportThreadId(session);
-        const turnId = session.activeTurnId ?? await this.resolveInFlightTurnId(transportThreadId);
+        const turnId = session.activeTurnId ?? await this.resolveInFlightTurnId(session.id);
         if (!turnId) {
             throw new Error(`Session ${sessionId} has no active interruptible Codex turn`);
         }
         session.activeTurnId = turnId;
-        await this.call("turn/interrupt", { threadId: transportThreadId, turnId });
+        await this.call("turn/interrupt", { threadId: session.id, turnId });
         return {};
     }
     async agents() {
@@ -673,9 +665,8 @@ export class CodexProvider {
     }
     async refreshSessionMetadata(sessionId) {
         const session = this.sessions.get(sessionId);
-        const transportThreadId = session ? this.getTransportThreadId(session) : sessionId;
         const result = await this.call("thread/read", {
-            threadId: transportThreadId,
+            threadId: sessionId,
             includeTurns: false,
         });
         const threadObject = this.extractThreadObject(result);
@@ -688,7 +679,6 @@ export class CodexProvider {
             createdAt: this.extractCreatedAt(threadObject) ?? session?.createdAt ?? Date.now(),
             updatedAt: this.extractUpdatedAt(threadObject) ?? session?.updatedAt ?? Date.now(),
             archived: false,
-            transportThreadId,
             cwd: this.extractThreadCwd(threadObject) ?? session?.cwd,
         }, true);
     }
@@ -815,7 +805,6 @@ export class CodexProvider {
                 createdAt: input.createdAt ?? Date.now(),
                 updatedAt: input.updatedAt ?? Date.now(),
                 archived: input.archived ?? false,
-                transportThreadId: input.transportThreadId ?? input.id,
                 cwd: input.cwd,
                 messages: [],
             };
@@ -826,19 +815,17 @@ export class CodexProvider {
             ? Math.max(existing.updatedAt, input.updatedAt)
             : existing.updatedAt;
         existing.archived = input.archived ?? existing.archived ?? false;
-        existing.transportThreadId = input.transportThreadId ?? input.id ?? existing.transportThreadId ?? existing.id;
         existing.cwd = input.cwd ?? existing.cwd;
         return existing;
     }
     upsertSession(input, emitUpdated = false) {
-        const existing = this.findSessionByThreadId(input.id);
+        const existing = this.sessions.get(input.id);
         const before = existing
             ? {
                 title: existing.title,
                 createdAt: existing.createdAt,
                 updatedAt: existing.updatedAt,
                 archived: existing.archived ?? false,
-                transportThreadId: existing.transportThreadId ?? existing.id,
                 cwd: existing.cwd,
             }
             : null;
@@ -849,7 +836,6 @@ export class CodexProvider {
             || before.createdAt !== session.createdAt
             || before.updatedAt !== session.updatedAt
             || before.archived !== (session.archived ?? false)
-            || before.transportThreadId !== (session.transportThreadId ?? session.id)
             || before.cwd !== session.cwd;
         if (emitUpdated && changed) {
             this.emitter?.({ type: "session.updated", properties: { info: this.toSessionInfo(session) } });
@@ -862,20 +848,6 @@ export class CodexProvider {
             return existing;
         return this.upsertSession({ id: sessionId, title: "Conversation", createdAt: Date.now(), updatedAt: Date.now() });
     }
-    getTransportThreadId(session) {
-        return session.transportThreadId ?? session.id;
-    }
-    findSessionByThreadId(threadId) {
-        const direct = this.sessions.get(threadId);
-        if (direct)
-            return direct;
-        for (const session of this.sessions.values()) {
-            if ((session.transportThreadId ?? session.id) === threadId) {
-                return session;
-            }
-        }
-        return undefined;
-    }
     async ensureThreadResumed(threadId) {
         if (!threadId || this.resumedThreadIds.has(threadId)) {
             return;
@@ -883,84 +855,11 @@ export class CodexProvider {
         await this.call("thread/resume", { threadId });
         this.resumedThreadIds.add(threadId);
     }
-    shouldTreatAsThreadNotFound(error) {
-        const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
-        if (message.includes("not materialized") || message.includes("not yet materialized")) {
-            return false;
-        }
-        return (message.includes("thread not found")
-            || message.includes("unknown thread")
-            || message.includes("no rollout found for thread id")
-            || message.includes("no rollout found"));
-    }
-    async ensurePromptSessionReady(session) {
-        const threadId = this.getTransportThreadId(session);
-        try {
-            await this.ensureThreadResumed(threadId);
-            return session;
-        }
-        catch (error) {
-            if (!this.shouldTreatAsThreadNotFound(error)) {
-                throw error;
-            }
-            return this.createContinuationSession(session);
-        }
-    }
-    async createContinuationSession(session) {
-        const previousThreadId = this.getTransportThreadId(session);
-        this.handleMissingThread(session);
-        const result = await this.call("thread/start", {
-            ...(session.cwd ? { cwd: session.cwd } : { cwd: process.cwd() }),
-        });
-        const threadId = this.extractThreadId(result);
-        if (!threadId) {
-            throw new Error("thread/start response missing threadId");
-        }
-        session.transportThreadId = threadId;
-        session.updatedAt = Date.now();
-        session.archived = false;
-        this.upsertSession({
-            id: session.id,
-            title: this.extractThreadTitleFromUnknown(result) ?? session.title,
-            createdAt: session.createdAt,
-            updatedAt: this.extractUpdatedAt(result) ?? Date.now(),
-            archived: false,
-            transportThreadId: threadId,
-            cwd: this.extractThreadCwd(result) ?? session.cwd ?? process.cwd(),
-        }, true);
-        this.resumedThreadIds.add(threadId);
-        const systemMessageId = `system:${crypto.randomUUID()}`;
-        session.messages.push({
-            id: systemMessageId,
-            role: "assistant",
-            parts: [{
-                    id: `${systemMessageId}:text`,
-                    type: "text",
-                    text: `Continued from archived thread \`${previousThreadId}\``,
-                    sessionID: session.id,
-                    messageID: systemMessageId,
-                }],
-            time: Date.now(),
-        });
-        this.emitMessagePartEvent(session.id, systemMessageId, "assistant", {
-            id: `${systemMessageId}:text`,
-            type: "text",
-            text: `Continued from archived thread \`${previousThreadId}\``,
-            sessionID: session.id,
-            messageID: systemMessageId,
-        });
-        return session;
-    }
-    handleMissingThread(session) {
-        const threadId = this.getTransportThreadId(session);
-        this.resumedThreadIds.delete(threadId);
-        session.activeTurnId = undefined;
-    }
     resolveSessionFromPayload(payload) {
         const threadId = this.extractThreadId(payload);
         if (!threadId)
             return undefined;
-        return this.findSessionByThreadId(threadId) ?? this.ensureLocalSession(threadId);
+        return this.ensureLocalSession(threadId);
     }
     async resolveInFlightTurnId(threadId) {
         const result = await this.call("thread/read", { threadId, includeTurns: true });

package/package.json

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