lunel-cli 0.1.60 → 0.1.61

package/dist/ai/codex.d.ts

@@ -74,7 +74,11 @@ export declare class CodexProvider implements AIProvider {
     private resolveSessionFromPayload;
     private resolveInFlightTurnId;
     private decodeMessagesFromThreadRead;
+    private decodeUserMessageParts;
     private decodeItemText;
+    private makeTurnInputPayload;
+    private shouldRetryTurnStartWithImageURLField;
+    private inferImageMimeFromDataUrl;
     private decodeReasoningItemText;
     private decodePlanItemText;
     private decodeCommandExecutionItemText;

package/dist/ai/codex.js

@@ -121,19 +121,31 @@ export class CodexProvider {
         return { messages: session.messages };
     }
     async prompt(sessionId, text, model, agent, files = []) {
-        if (files.length > 0) {
-            throw new Error("Codex image attachments are not supported in Lunel yet");
-        }
         const session = this.ensureLocalSession(sessionId);
         session.updatedAt = Date.now();
         (async () => {
             try {
-                await this.call("turn/start", {
-                    threadId: session.id,
-                    input: [{ type: "text", text }],
-                    ...(model ? { model: model.providerID === "codex" ? model.modelID : `${model.providerID}/${model.modelID}` } : {}),
-                    ...(agent ? { agent } : {}),
-                });
+                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 } : {}),
+                        });
+                        break;
+                    }
+                    catch (err) {
+                        if (imageUrlKey === "url"
+                            && files.length > 0
+                            && this.shouldRetryTurnStartWithImageURLField(err)) {
+                            imageUrlKey = "image_url";
+                            continue;
+                        }
+                        throw err;
+                    }
+                }
             }
             catch (err) {
                 const message = err.message;
@@ -860,13 +872,13 @@ export class CodexProvider {
                 const itemId = this.readString(itemObject.id) ?? crypto.randomUUID();
                 const timestamp = this.extractUpdatedAt(itemObject) ?? this.extractCreatedAt(itemObject) ?? (turnTime + orderOffset++);
                 if (type === "usermessage") {
-                    const text = this.decodeItemText(itemObject);
-                    if (!text)
+                    const parts = this.decodeUserMessageParts(itemObject, threadId, itemId);
+                    if (parts.length === 0)
                         continue;
                     messages.push({
                         id: itemId,
                         role: "user",
-                        parts: [{ id: `${itemId}:text`, type: "text", text, sessionID: threadId, messageID: itemId }],
+                        parts,
                         time: timestamp,
                     });
                     continue;
@@ -957,6 +969,40 @@ export class CodexProvider {
         }
         return messages;
     }
+    decodeUserMessageParts(itemObject, threadId, itemId) {
+        const parts = [];
+        const content = this.readArray(itemObject.content);
+        let fileIndex = 0;
+        for (const entry of content) {
+            const obj = this.asRecord(entry);
+            const type = this.normalizedItemType(this.readString(obj.type) ?? "");
+            if (type === "image" || type === "localimage") {
+                const url = this.readString(obj.url) ?? this.readString(obj.image_url) ?? this.readString(obj.imageUrl);
+                if (!url)
+                    continue;
+                parts.push({
+                    id: `${itemId}:file:${fileIndex++}`,
+                    type: "file",
+                    mime: this.inferImageMimeFromDataUrl(url),
+                    filename: this.readString(obj.filename) ?? this.readString(obj.name) ?? undefined,
+                    url,
+                    sessionID: threadId,
+                    messageID: itemId,
+                });
+            }
+        }
+        const text = this.decodeItemText(itemObject);
+        if (text) {
+            parts.push({
+                id: `${itemId}:text`,
+                type: "text",
+                text,
+                sessionID: threadId,
+                messageID: itemId,
+            });
+        }
+        return parts;
+    }
     decodeItemText(itemObject) {
         const content = this.readArray(itemObject.content);
         const parts = [];
@@ -977,6 +1023,40 @@ export class CodexProvider {
         const joined = parts.join("\n").trim();
         return joined || this.readString(itemObject.text) || this.readString(itemObject.message) || "";
     }
+    makeTurnInputPayload(text, files, imageUrlKey) {
+        const items = [];
+        for (const file of files) {
+            const url = typeof file.url === "string" ? file.url.trim() : "";
+            if (!url)
+                continue;
+            items.push({
+                type: "image",
+                [imageUrlKey]: url,
+            });
+        }
+        const trimmedText = text.trim();
+        if (trimmedText) {
+            items.push({ type: "text", text: trimmedText });
+        }
+        return items;
+    }
+    shouldRetryTurnStartWithImageURLField(error) {
+        const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
+        if (!message.includes("image_url")) {
+            return false;
+        }
+        return (message.includes("missing")
+            || message.includes("unknown field")
+            || message.includes("expected")
+            || message.includes("invalid"));
+    }
+    inferImageMimeFromDataUrl(url) {
+        const match = /^data:([^;,]+)[;,]/i.exec(url);
+        if (match?.[1]) {
+            return match[1];
+        }
+        return "image/jpeg";
+    }
     decodeReasoningItemText(itemObject) {
         const summary = this.flattenTextValue(itemObject.summary).trim();
         const content = this.flattenTextValue(itemObject.content).trim();

package/package.json

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