@wingman-ai/gateway 0.2.4 → 0.3.0

package/dist/cli/core/sessionManager.cjs

@@ -34,6 +34,7 @@ __webpack_require__.d(__webpack_exports__, {
 const langgraph_checkpoint_sqlite_namespaceObject = require("@langchain/langgraph-checkpoint-sqlite");
 const external_deepagents_namespaceObject = require("deepagents");
 const external_uuid_namespaceObject = require("uuid");
+const external_imagePersistence_cjs_namespaceObject = require("./imagePersistence.cjs");
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -54,9 +55,9 @@ class SessionManager {
         await this.checkpointer.setup();
         this.db = adapter.db;
         this.db.run(`
-      CREATE TABLE IF NOT EXISTS sessions (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
+	      CREATE TABLE IF NOT EXISTS sessions (
+	        id TEXT PRIMARY KEY,
+	        name TEXT NOT NULL,
         agent_name TEXT NOT NULL,
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL,
@@ -66,11 +67,24 @@ class SessionManager {
         metadata TEXT
       );
 
-      CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC);
-      CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_name);
-      CREATE INDEX IF NOT EXISTS idx_sessions_status_updated ON sessions(status, updated_at DESC);
-      CREATE INDEX IF NOT EXISTS idx_sessions_status_agent_updated ON sessions(status, agent_name, updated_at DESC);
-    `);
+	      CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC);
+	      CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_name);
+	      CREATE INDEX IF NOT EXISTS idx_sessions_status_updated ON sessions(status, updated_at DESC);
+	      CREATE INDEX IF NOT EXISTS idx_sessions_status_agent_updated ON sessions(status, agent_name, updated_at DESC);
+
+	      CREATE TABLE IF NOT EXISTS session_pending_messages (
+	        id TEXT PRIMARY KEY,
+	        session_id TEXT NOT NULL,
+	        request_id TEXT NOT NULL,
+	        role TEXT NOT NULL,
+	        content TEXT NOT NULL,
+	        attachments TEXT,
+	        created_at INTEGER NOT NULL
+	      );
+
+	      CREATE INDEX IF NOT EXISTS idx_pending_messages_session_created ON session_pending_messages(session_id, created_at ASC);
+	      CREATE INDEX IF NOT EXISTS idx_pending_messages_session_request ON session_pending_messages(session_id, request_id);
+	    `);
     }
     createSession(agentName, name) {
         if (!this.db) throw new Error("SessionManager not initialized");
@@ -211,6 +225,8 @@ class SessionManager {
         checkpointStmt.run(sessionId);
         const writesStmt = this.db.prepare("DELETE FROM writes WHERE thread_id = ?");
         writesStmt.run(sessionId);
+        const pendingStmt = this.db.prepare("DELETE FROM session_pending_messages WHERE session_id = ?");
+        pendingStmt.run(sessionId);
     }
     clearSessionMessages(sessionId) {
         if (!this.db || !this.checkpointer) throw new Error("SessionManager not initialized");
@@ -218,21 +234,52 @@ class SessionManager {
         checkpointStmt.run(sessionId);
         const writesStmt = this.db.prepare("DELETE FROM writes WHERE thread_id = ?");
         writesStmt.run(sessionId);
+        const pendingStmt = this.db.prepare("DELETE FROM session_pending_messages WHERE session_id = ?");
+        pendingStmt.run(sessionId);
         const sessionStmt = this.db.prepare(`
-      UPDATE sessions
-      SET message_count = 0, last_message_preview = NULL, updated_at = ?
-      WHERE id = ?
-    `);
+	      UPDATE sessions
+	      SET message_count = 0, last_message_preview = NULL, updated_at = ?
+	      WHERE id = ?
+	    `);
         sessionStmt.run(Date.now(), sessionId);
     }
+    persistPendingMessage(input) {
+        if (!this.db) throw new Error("SessionManager not initialized");
+        const attachments = Array.isArray(input.message.attachments) && input.message.attachments.length > 0 ? JSON.stringify(input.message.attachments) : null;
+        const stmt = this.db.prepare(`
+	      INSERT INTO session_pending_messages (
+	        id, session_id, request_id, role, content, attachments, created_at
+	      )
+	      VALUES (?, ?, ?, ?, ?, ?, ?)
+	      ON CONFLICT(id) DO UPDATE SET
+	        role = excluded.role,
+	        content = excluded.content,
+	        attachments = excluded.attachments,
+	        created_at = excluded.created_at
+	    `);
+        stmt.run(input.message.id, input.sessionId, input.requestId, input.message.role, input.message.content || "", attachments, input.message.createdAt);
+    }
+    clearPendingMessagesForRequest(sessionId, requestId) {
+        if (!this.db) throw new Error("SessionManager not initialized");
+        const stmt = this.db.prepare(`
+	      DELETE FROM session_pending_messages
+	      WHERE session_id = ? AND request_id = ?
+	    `);
+        stmt.run(sessionId, requestId);
+    }
     getCheckpointer() {
         if (!this.checkpointer) throw new Error("SessionManager not initialized");
         return this.checkpointer;
     }
     async listMessages(sessionId) {
         if (!this.checkpointer) throw new Error("SessionManager not initialized");
+        const pendingMessages = this.listPendingMessages(sessionId);
         const stateMessages = await this.loadMessagesFromState(sessionId);
-        if (null !== stateMessages) return stateMessages;
+        if (null !== stateMessages) {
+            const mergedStateMessages = mergePendingMessages(stateMessages, pendingMessages);
+            this.persistAssistantImageAttachments(sessionId, mergedStateMessages);
+            return mergedStateMessages;
+        }
         const rawCheckpoints = this.loadRecentCheckpoints(sessionId, 25);
         const fallbackTuple = 0 === rawCheckpoints.length ? await this.checkpointer.getTuple({
             configurable: {
@@ -245,7 +292,10 @@ class SessionManager {
                 fallbackTuple.checkpoint
             ] : []
         ];
-        if (0 === checkpoints.length) return [];
+        if (0 === checkpoints.length) {
+            this.persistAssistantImageAttachments(sessionId, pendingMessages);
+            return pendingMessages;
+        }
         let bestScore = -1;
         let bestMessages = [];
         for (const checkpoint of checkpoints){
@@ -263,8 +313,14 @@ class SessionManager {
                 bestMessages = scored[0].messages;
             }
         }
-        if (0 === bestMessages.length) return [];
-        return filterEmptyAssistantMessages(bestMessages);
+        if (0 === bestMessages.length) {
+            this.persistAssistantImageAttachments(sessionId, pendingMessages);
+            return pendingMessages;
+        }
+        const filteredMessages = filterEmptyAssistantMessages(bestMessages);
+        const mergedMessages = mergePendingMessages(filteredMessages, pendingMessages);
+        this.persistAssistantImageAttachments(sessionId, mergedMessages);
+        return mergedMessages;
     }
     rowToSession(row) {
         return {
@@ -329,6 +385,36 @@ class SessionManager {
             return null;
         }
     }
+    persistAssistantImageAttachments(sessionId, messages) {
+        try {
+            (0, external_imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
+                dbPath: this.dbPath,
+                sessionId,
+                messages: messages
+            });
+        } catch  {}
+    }
+    listPendingMessages(sessionId) {
+        if (!this.db) return [];
+        const stmt = this.db.prepare(`
+	      SELECT id, role, content, attachments, created_at
+	      FROM session_pending_messages
+	      WHERE session_id = ?
+	      ORDER BY created_at ASC, rowid ASC
+	    `);
+        const rows = stmt.all(sessionId);
+        if (!rows.length) return [];
+        return rows.map((row)=>{
+            const attachments = parseSessionAttachments(row.attachments);
+            return {
+                id: row.id,
+                role: row.role,
+                content: row.content || "",
+                attachments,
+                createdAt: row.created_at || Date.now()
+            };
+        }).filter((message)=>"user" === message.role || message.content.trim().length > 0 || (message.attachments?.length || 0) > 0);
+    }
     constructor(dbPath){
         _define_property(this, "checkpointer", null);
         _define_property(this, "stateReaderAgent", null);
@@ -337,6 +423,50 @@ class SessionManager {
         this.dbPath = dbPath;
     }
 }
+function mergePendingMessages(persisted, pending) {
+    if (0 === pending.length) return persisted;
+    if (0 === persisted.length) return pending;
+    const merged = [
+        ...persisted
+    ];
+    for (const candidate of pending){
+        const duplicate = merged.some((message)=>isLikelyDuplicateMessage(message, candidate));
+        if (!duplicate) merged.push(candidate);
+    }
+    merged.sort((a, b)=>{
+        if (a.createdAt === b.createdAt) {
+            if (a.role === b.role) return 0;
+            return "user" === a.role ? -1 : 1;
+        }
+        return a.createdAt - b.createdAt;
+    });
+    return merged;
+}
+function isLikelyDuplicateMessage(left, right) {
+    if (left.id && right.id && left.id === right.id) return true;
+    if (left.role !== right.role) return false;
+    if ((left.content || "").trim() !== (right.content || "").trim()) return false;
+    const leftAttachments = left.attachments || [];
+    const rightAttachments = right.attachments || [];
+    if (leftAttachments.length !== rightAttachments.length) return false;
+    for(let index = 0; index < leftAttachments.length; index += 1)if (!isAttachmentEquivalent(leftAttachments[index], rightAttachments[index])) return false;
+    return Math.abs((left.createdAt || 0) - (right.createdAt || 0)) < 30000;
+}
+function isAttachmentEquivalent(left, right) {
+    if (!left || !right) return left === right;
+    return left.kind === right.kind && (left.dataUrl || "") === (right.dataUrl || "") && (left.name || "") === (right.name || "") && (left.mimeType || "") === (right.mimeType || "") && (left.size || 0) === (right.size || 0);
+}
+function parseSessionAttachments(raw) {
+    if (!raw) return;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) return;
+        const attachments = parsed.filter((item)=>item && "object" == typeof item && "string" == typeof item.kind && "string" == typeof item.dataUrl);
+        return attachments.length > 0 ? attachments : void 0;
+    } catch  {
+        return;
+    }
+}
 function isMessageLike(entry) {
     if (!entry || "object" != typeof entry) return false;
     return "string" == typeof entry.role || "string" == typeof entry.type || "string" == typeof entry?.kwargs?.role || "string" == typeof entry?.additional_kwargs?.role;
@@ -348,22 +478,30 @@ function toSessionMessage(entry, index, baseTime) {
     const role = resolveMessageRole(entry);
     if ("user" !== role && "assistant" !== role) {
         if (isToolMessage(entry)) {
-            const toolContent = extractMessageContent(entry, extractContentBlocks(entry));
+            const blocks = extractContentBlocks(entry);
+            const toolContent = extractMessageContent(entry, blocks);
             const ui = extractUiFromPayload(toolContent);
-            if (ui?.spec) return {
-                id: `msg-${index}`,
-                role: "assistant",
-                content: "",
-                createdAt: baseTime + index,
-                uiBlocks: [
-                    {
-                        spec: ui.spec,
-                        uiOnly: ui.uiOnly,
-                        textFallback: ui.textFallback
-                    }
-                ],
-                uiTextFallback: ui.textFallback
-            };
+            const attachments = extractAttachments(blocks);
+            if (ui?.spec || attachments.length > 0) {
+                const content = toolContent || ui?.textFallback || "";
+                return {
+                    id: `msg-${index}`,
+                    role: "assistant",
+                    content,
+                    attachments: attachments.length > 0 ? attachments : void 0,
+                    createdAt: baseTime + index,
+                    ...ui?.spec ? {
+                        uiBlocks: [
+                            {
+                                spec: ui.spec,
+                                uiOnly: ui.uiOnly,
+                                textFallback: ui.textFallback
+                            }
+                        ],
+                        uiTextFallback: ui.textFallback
+                    } : {}
+                };
+            }
         }
         return null;
     }
@@ -402,11 +540,59 @@ function extractContentBlocks(entry) {
         entry?.content,
         entry?.kwargs?.content,
         entry?.additional_kwargs?.content,
-        entry?.data?.content
+        entry?.data?.content,
+        entry?.artifact,
+        entry?.kwargs?.artifact,
+        entry?.additional_kwargs?.artifact,
+        entry?.data?.artifact
+    ];
+    for (const candidate of candidates){
+        const blocks = extractContentBlocksFromValue(candidate);
+        if (blocks.length > 0) return blocks;
+    }
+    return [];
+}
+function extractContentBlocksFromValue(value, depth = 0) {
+    if (depth > 5 || null == value) return [];
+    if (Array.isArray(value)) {
+        const unwrapped = [];
+        for (const item of value){
+            const parsedBlocks = extractBlocksFromTextLikeItem(item, depth + 1);
+            if (parsedBlocks.length > 0) {
+                unwrapped.push(...parsedBlocks);
+                continue;
+            }
+            unwrapped.push(item);
+        }
+        return unwrapped;
+    }
+    if ("string" == typeof value) {
+        const parsed = tryParseJsonPayload(value);
+        return parsed ? extractContentBlocksFromValue(parsed, depth + 1) : [];
+    }
+    if ("object" != typeof value) return [];
+    const record = value;
+    const candidates = [
+        record.content,
+        record?.kwargs?.content,
+        record?.additional_kwargs?.content,
+        record?.data?.content
     ];
-    for (const candidate of candidates)if (Array.isArray(candidate)) return candidate;
+    for (const candidate of candidates){
+        const blocks = extractContentBlocksFromValue(candidate, depth + 1);
+        if (blocks.length > 0) return blocks;
+    }
     return [];
 }
+function extractBlocksFromTextLikeItem(value, depth = 0) {
+    if (!value || "object" != typeof value || Array.isArray(value)) return [];
+    const record = value;
+    const text = "string" == typeof record.text ? record.text : "string" == typeof record.value && isTextLikeContentType(record.type) ? record.value : "string" == typeof record.output_text ? record.output_text : "string" == typeof record.input_text ? record.input_text : null;
+    if (!text) return [];
+    const parsed = tryParseJsonPayload(text);
+    if (!parsed) return [];
+    return extractContentBlocksFromValue(parsed, depth + 1);
+}
 function extractMessageContent(entry, blocks = []) {
     if (!entry || "object" != typeof entry) return "";
     const candidates = [
@@ -424,18 +610,63 @@ function extractMessageContent(entry, blocks = []) {
 }
 function extractTextContent(value, depth = 0) {
     if (depth > 5 || null == value) return "";
-    if ("string" == typeof value) return value;
+    if ("string" == typeof value) {
+        const parsed = tryParseJsonPayload(value);
+        if (null !== parsed) {
+            const extracted = extractTextContent(parsed, depth + 1).trim();
+            if (extracted) return extracted;
+        }
+        return value;
+    }
     if (Array.isArray(value)) return value.map((entry)=>extractTextContent(entry, depth + 1)).filter((entry)=>entry.length > 0).join("");
     if ("object" != typeof value) return "";
     const record = value;
-    if ("string" == typeof record.text) return record.text;
+    if ("string" == typeof record.text) {
+        const parsed = tryParseJsonPayload(record.text);
+        if (null !== parsed) {
+            const extracted = extractTextContent(parsed, depth + 1).trim();
+            if (extracted) return extracted;
+        }
+        return record.text;
+    }
     if (record.text && "object" == typeof record.text && "string" == typeof record.text.value) return record.text.value;
-    if ("string" == typeof record.output_text) return record.output_text;
-    if ("string" == typeof record.input_text) return record.input_text;
-    if ("string" == typeof record.value && isTextLikeContentType(record.type)) return record.value;
+    if ("string" == typeof record.output_text) {
+        const parsed = tryParseJsonPayload(record.output_text);
+        if (null !== parsed) {
+            const extracted = extractTextContent(parsed, depth + 1).trim();
+            if (extracted) return extracted;
+        }
+        return record.output_text;
+    }
+    if ("string" == typeof record.input_text) {
+        const parsed = tryParseJsonPayload(record.input_text);
+        if (null !== parsed) {
+            const extracted = extractTextContent(parsed, depth + 1).trim();
+            if (extracted) return extracted;
+        }
+        return record.input_text;
+    }
+    if ("string" == typeof record.value && isTextLikeContentType(record.type)) {
+        const parsed = tryParseJsonPayload(record.value);
+        if (null !== parsed) {
+            const extracted = extractTextContent(parsed, depth + 1).trim();
+            if (extracted) return extracted;
+        }
+        return record.value;
+    }
     if ("content" in record) return extractTextContent(record.content, depth + 1);
     return "";
 }
+function tryParseJsonPayload(value) {
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    if (!(trimmed.startsWith("{") || trimmed.startsWith("["))) return null;
+    try {
+        return JSON.parse(trimmed);
+    } catch  {
+        return null;
+    }
+}
 function isTextLikeContentType(type) {
     if ("string" != typeof type) return false;
     const normalized = type.toLowerCase();
@@ -454,10 +685,12 @@ function filterUiOnlyAssistantMessages(messages) {
     let pendingFallback = null;
     for (const entry of messages){
         if (isToolMessage(entry)) {
-            const content = extractMessageContent(entry, extractContentBlocks(entry));
+            const blocks = extractContentBlocks(entry);
+            const content = extractMessageContent(entry, blocks);
             const ui = extractUiFromPayload(content);
+            const attachments = extractAttachments(blocks);
             if (ui?.uiOnly && ui?.textFallback) pendingFallback = ui.textFallback.trim();
-            if (ui?.spec) filtered.push(entry);
+            if (ui?.spec || attachments.length > 0) filtered.push(entry);
             continue;
         }
         const role = resolveMessageRole(entry);
@@ -537,6 +770,30 @@ function extractImageUrl(block) {
         const data = block.source.data;
         if (mediaType && data) return `data:${mediaType};base64,${data}`;
     }
+    if ("image" === block.type) {
+        const sourceType = block.source_type || block.sourceType;
+        const mimeType = block.mime_type || block.mimeType || block.media_type || block.mediaType || "image/png";
+        if ("base64" === sourceType && "string" == typeof block.data) return `data:${mimeType};base64,${block.data}`;
+        if ("url" === sourceType && "string" == typeof block.url) return block.url;
+        if ("string" == typeof block.data) return `data:${mimeType};base64,${block.data}`;
+    }
+    if ("output_image" === block.type) {
+        if ("string" == typeof block.image_url) return block.image_url;
+        if ("string" == typeof block.image_url?.url) return block.image_url.url;
+        if ("string" == typeof block.url) return block.url;
+    }
+    if ("resource_link" === block.type) {
+        const mimeType = "string" == typeof block.mimeType ? block.mimeType.trim().toLowerCase() : "";
+        const uri = "string" == typeof block.uri ? block.uri.trim() : "";
+        if (uri && (!mimeType || mimeType.startsWith("image/"))) return uri;
+    }
+    if ("resource" === block.type && block.resource) {
+        const resource = block.resource;
+        const mimeType = "string" == typeof resource.mimeType ? resource.mimeType.trim().toLowerCase() : "";
+        if (!mimeType || !mimeType.startsWith("image/")) return null;
+        if ("string" == typeof resource.blob && resource.blob.trim()) return `data:${mimeType};base64,${resource.blob.trim()}`;
+        if ("string" == typeof resource.uri && resource.uri.trim()) return resource.uri.trim();
+    }
     return null;
 }
 function extractAudioUrl(block) {

package/dist/cli/core/sessionManager.d.ts

@@ -35,6 +35,7 @@ export interface SessionAttachment {
     name?: string;
     mimeType?: string;
     size?: number;
+    path?: string;
 }
 /**
  * SessionManager handles session metadata and provides unified access to
@@ -90,6 +91,12 @@ export declare class SessionManager {
      * Clear session messages while preserving the session record
      */
     clearSessionMessages(sessionId: string): void;
+    persistPendingMessage(input: {
+        sessionId: string;
+        requestId: string;
+        message: SessionMessage;
+    }): void;
+    clearPendingMessagesForRequest(sessionId: string, requestId: string): void;
     /**
      * Get the checkpointer for use with DeepAgents
      */
@@ -109,6 +116,8 @@ export declare class SessionManager {
     private loadRecentCheckpoints;
     private getStateReaderAgent;
     private loadMessagesFromState;
+    private persistAssistantImageAttachments;
+    private listPendingMessages;
 }
 export declare function extractMessagesFromState(state: any): SessionMessage[] | null;
 export declare function extractAttachments(blocks: any[]): SessionAttachment[];