@wingman-ai/gateway 0.2.5 → 0.3.0

package/dist/tests/imagePersistence.test.cjs

@@ -0,0 +1,143 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const external_vitest_namespaceObject = require("vitest");
+const imagePersistence_cjs_namespaceObject = require("../cli/core/imagePersistence.cjs");
+const PNG_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO3X6S0AAAAASUVORK5CYII=";
+(0, external_vitest_namespaceObject.describe)("imagePersistence", ()=>{
+    const tempDirs = [];
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        for (const dir of tempDirs)(0, external_node_fs_namespaceObject.rmSync)(dir, {
+            recursive: true,
+            force: true
+        });
+        tempDirs.length = 0;
+    });
+    (0, external_vitest_namespaceObject.it)("persists assistant image data URLs to disk", ()=>{
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-image-store-"));
+        tempDirs.push(tempDir);
+        const dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "wingman.db");
+        const messages = [
+            {
+                role: "assistant",
+                attachments: [
+                    {
+                        kind: "image",
+                        dataUrl: PNG_DATA_URL
+                    }
+                ]
+            }
+        ];
+        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
+            dbPath,
+            sessionId: "session-123",
+            messages
+        });
+        const attachment = messages[0].attachments?.[0];
+        (0, external_vitest_namespaceObject.expect)(typeof attachment?.path).toBe("string");
+        (0, external_vitest_namespaceObject.expect)(attachment?.mimeType).toBe("image/png");
+        (0, external_vitest_namespaceObject.expect)(typeof attachment?.size).toBe("number");
+        (0, external_vitest_namespaceObject.expect)(attachment?.size).toBeGreaterThan(0);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(attachment.path)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.readFileSync)(attachment.path).length).toBe(attachment?.size);
+    });
+    (0, external_vitest_namespaceObject.it)("does not persist non-assistant images", ()=>{
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-image-store-"));
+        tempDirs.push(tempDir);
+        const dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "wingman.db");
+        const messages = [
+            {
+                role: "user",
+                attachments: [
+                    {
+                        kind: "image",
+                        dataUrl: PNG_DATA_URL
+                    }
+                ]
+            }
+        ];
+        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
+            dbPath,
+            sessionId: "session-123",
+            messages
+        });
+        (0, external_vitest_namespaceObject.expect)(messages[0].attachments?.[0].path).toBeUndefined();
+    });
+    (0, external_vitest_namespaceObject.it)("keeps remote image URLs untouched", ()=>{
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-image-store-"));
+        tempDirs.push(tempDir);
+        const dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "wingman.db");
+        const messages = [
+            {
+                role: "assistant",
+                attachments: [
+                    {
+                        kind: "image",
+                        dataUrl: "https://example.com/image.png"
+                    }
+                ]
+            }
+        ];
+        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
+            dbPath,
+            sessionId: "session-123",
+            messages
+        });
+        (0, external_vitest_namespaceObject.expect)(messages[0].attachments?.[0].path).toBeUndefined();
+    });
+    (0, external_vitest_namespaceObject.it)("derives deterministic file paths for repeated image payloads", ()=>{
+        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-image-store-"));
+        tempDirs.push(tempDir);
+        const dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "wingman.db");
+        const messages = [
+            {
+                role: "assistant",
+                attachments: [
+                    {
+                        kind: "image",
+                        dataUrl: PNG_DATA_URL
+                    }
+                ]
+            }
+        ];
+        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
+            dbPath,
+            sessionId: "session-123",
+            messages
+        });
+        const firstPath = messages[0].attachments?.[0].path;
+        const nextMessages = [
+            {
+                role: "assistant",
+                attachments: [
+                    {
+                        kind: "image",
+                        dataUrl: PNG_DATA_URL
+                    }
+                ]
+            }
+        ];
+        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
+            dbPath,
+            sessionId: "session-123",
+            messages: nextMessages
+        });
+        const secondPath = nextMessages[0].attachments?.[0].path;
+        (0, external_vitest_namespaceObject.expect)(firstPath).toBeTruthy();
+        (0, external_vitest_namespaceObject.expect)(secondPath).toBe(firstPath);
+    });
+    (0, external_vitest_namespaceObject.it)("parses base64 data URLs and resolves extensions", ()=>{
+        const parsed = (0, imagePersistence_cjs_namespaceObject.parseBase64DataUrl)(PNG_DATA_URL);
+        (0, external_vitest_namespaceObject.expect)(parsed?.mimeType).toBe("image/png");
+        (0, external_vitest_namespaceObject.expect)(typeof parsed?.data).toBe("string");
+        (0, external_vitest_namespaceObject.expect)((0, imagePersistence_cjs_namespaceObject.resolveImageExtension)("image/jpeg")).toBe("jpg");
+        (0, external_vitest_namespaceObject.expect)((0, imagePersistence_cjs_namespaceObject.resolveImageExtension)("image/svg+xml")).toBe("svg");
+        (0, external_vitest_namespaceObject.expect)((0, imagePersistence_cjs_namespaceObject.resolveImageExtension)("image/custom+format")).toBe("customformat");
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/imagePersistence.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/imagePersistence.test.js

@@ -0,0 +1,137 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { parseBase64DataUrl, persistAssistantImagesToDisk, resolveImageExtension } from "../cli/core/imagePersistence.js";
+const PNG_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO3X6S0AAAAASUVORK5CYII=";
+describe("imagePersistence", ()=>{
+    const tempDirs = [];
+    afterEach(()=>{
+        for (const dir of tempDirs)rmSync(dir, {
+            recursive: true,
+            force: true
+        });
+        tempDirs.length = 0;
+    });
+    it("persists assistant image data URLs to disk", ()=>{
+        const tempDir = mkdtempSync(join(tmpdir(), "wingman-image-store-"));
+        tempDirs.push(tempDir);
+        const dbPath = join(tempDir, "wingman.db");
+        const messages = [
+            {
+                role: "assistant",
+                attachments: [
+                    {
+                        kind: "image",
+                        dataUrl: PNG_DATA_URL
+                    }
+                ]
+            }
+        ];
+        persistAssistantImagesToDisk({
+            dbPath,
+            sessionId: "session-123",
+            messages
+        });
+        const attachment = messages[0].attachments?.[0];
+        expect(typeof attachment?.path).toBe("string");
+        expect(attachment?.mimeType).toBe("image/png");
+        expect(typeof attachment?.size).toBe("number");
+        expect(attachment?.size).toBeGreaterThan(0);
+        expect(existsSync(attachment.path)).toBe(true);
+        expect(readFileSync(attachment.path).length).toBe(attachment?.size);
+    });
+    it("does not persist non-assistant images", ()=>{
+        const tempDir = mkdtempSync(join(tmpdir(), "wingman-image-store-"));
+        tempDirs.push(tempDir);
+        const dbPath = join(tempDir, "wingman.db");
+        const messages = [
+            {
+                role: "user",
+                attachments: [
+                    {
+                        kind: "image",
+                        dataUrl: PNG_DATA_URL
+                    }
+                ]
+            }
+        ];
+        persistAssistantImagesToDisk({
+            dbPath,
+            sessionId: "session-123",
+            messages
+        });
+        expect(messages[0].attachments?.[0].path).toBeUndefined();
+    });
+    it("keeps remote image URLs untouched", ()=>{
+        const tempDir = mkdtempSync(join(tmpdir(), "wingman-image-store-"));
+        tempDirs.push(tempDir);
+        const dbPath = join(tempDir, "wingman.db");
+        const messages = [
+            {
+                role: "assistant",
+                attachments: [
+                    {
+                        kind: "image",
+                        dataUrl: "https://example.com/image.png"
+                    }
+                ]
+            }
+        ];
+        persistAssistantImagesToDisk({
+            dbPath,
+            sessionId: "session-123",
+            messages
+        });
+        expect(messages[0].attachments?.[0].path).toBeUndefined();
+    });
+    it("derives deterministic file paths for repeated image payloads", ()=>{
+        const tempDir = mkdtempSync(join(tmpdir(), "wingman-image-store-"));
+        tempDirs.push(tempDir);
+        const dbPath = join(tempDir, "wingman.db");
+        const messages = [
+            {
+                role: "assistant",
+                attachments: [
+                    {
+                        kind: "image",
+                        dataUrl: PNG_DATA_URL
+                    }
+                ]
+            }
+        ];
+        persistAssistantImagesToDisk({
+            dbPath,
+            sessionId: "session-123",
+            messages
+        });
+        const firstPath = messages[0].attachments?.[0].path;
+        const nextMessages = [
+            {
+                role: "assistant",
+                attachments: [
+                    {
+                        kind: "image",
+                        dataUrl: PNG_DATA_URL
+                    }
+                ]
+            }
+        ];
+        persistAssistantImagesToDisk({
+            dbPath,
+            sessionId: "session-123",
+            messages: nextMessages
+        });
+        const secondPath = nextMessages[0].attachments?.[0].path;
+        expect(firstPath).toBeTruthy();
+        expect(secondPath).toBe(firstPath);
+    });
+    it("parses base64 data URLs and resolves extensions", ()=>{
+        const parsed = parseBase64DataUrl(PNG_DATA_URL);
+        expect(parsed?.mimeType).toBe("image/png");
+        expect(typeof parsed?.data).toBe("string");
+        expect(resolveImageExtension("image/jpeg")).toBe("jpg");
+        expect(resolveImageExtension("image/svg+xml")).toBe("svg");
+        expect(resolveImageExtension("image/custom+format")).toBe("customformat");
+    });
+});

package/dist/tests/sessionMessageAttachments.test.cjs

@@ -50,6 +50,36 @@ const sessionManager_cjs_namespaceObject = require("../cli/core/sessionManager.c
             }
         ]);
     });
+    (0, external_vitest_namespaceObject.it)("extracts MCP image blocks with inline base64 payload", ()=>{
+        const blocks = [
+            {
+                type: "image",
+                mimeType: "image/png",
+                data: "abc123"
+            }
+        ];
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.extractImageAttachments)(blocks)).toEqual([
+            {
+                kind: "image",
+                dataUrl: "data:image/png;base64,abc123"
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("extracts resource_link image blocks", ()=>{
+        const blocks = [
+            {
+                type: "resource_link",
+                uri: "/api/fs/file?path=%2Ftmp%2Fgenerated.png",
+                mimeType: "image/png"
+            }
+        ];
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.extractImageAttachments)(blocks)).toEqual([
+            {
+                kind: "image",
+                dataUrl: "/api/fs/file?path=%2Ftmp%2Fgenerated.png"
+            }
+        ]);
+    });
 });
 (0, external_vitest_namespaceObject.describe)("extractAttachments", ()=>{
     (0, external_vitest_namespaceObject.it)("extracts input_audio blocks", ()=>{

package/dist/tests/sessionMessageAttachments.test.js

@@ -48,6 +48,36 @@ describe("extractImageAttachments", ()=>{
             }
         ]);
     });
+    it("extracts MCP image blocks with inline base64 payload", ()=>{
+        const blocks = [
+            {
+                type: "image",
+                mimeType: "image/png",
+                data: "abc123"
+            }
+        ];
+        expect(extractImageAttachments(blocks)).toEqual([
+            {
+                kind: "image",
+                dataUrl: "data:image/png;base64,abc123"
+            }
+        ]);
+    });
+    it("extracts resource_link image blocks", ()=>{
+        const blocks = [
+            {
+                type: "resource_link",
+                uri: "/api/fs/file?path=%2Ftmp%2Fgenerated.png",
+                mimeType: "image/png"
+            }
+        ];
+        expect(extractImageAttachments(blocks)).toEqual([
+            {
+                kind: "image",
+                dataUrl: "/api/fs/file?path=%2Ftmp%2Fgenerated.png"
+            }
+        ]);
+    });
 });
 describe("extractAttachments", ()=>{
     it("extracts input_audio blocks", ()=>{

package/dist/tests/sessionStateMessages.test.cjs

@@ -103,6 +103,132 @@ const sessionManager_cjs_namespaceObject = require("../cli/core/sessionManager.c
             content: "Here is the plan."
         });
     });
+    (0, external_vitest_namespaceObject.it)("promotes tool image outputs into assistant attachments", ()=>{
+        const state = {
+            createdAt: 3000,
+            values: {
+                messages: [
+                    {
+                        role: "user",
+                        content: "Create a puppy image."
+                    },
+                    {
+                        role: "tool",
+                        content: JSON.stringify({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Generated image."
+                                },
+                                {
+                                    type: "resource_link",
+                                    uri: "/api/fs/file?path=%2Ftmp%2Fpuppy.png",
+                                    mimeType: "image/png"
+                                }
+                            ]
+                        })
+                    }
+                ]
+            }
+        };
+        const result = (0, sessionManager_cjs_namespaceObject.extractMessagesFromState)(state);
+        (0, external_vitest_namespaceObject.expect)(result).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(result).toHaveLength(2);
+        (0, external_vitest_namespaceObject.expect)(result?.[1]).toMatchObject({
+            role: "assistant",
+            content: "Generated image.",
+            attachments: [
+                {
+                    kind: "image",
+                    dataUrl: "/api/fs/file?path=%2Ftmp%2Fpuppy.png"
+                }
+            ]
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("extracts tool attachments when MCP payload is wrapped in a text block", ()=>{
+        const state = {
+            createdAt: 4000,
+            values: {
+                messages: [
+                    {
+                        role: "user",
+                        content: "Generate a landscape image."
+                    },
+                    {
+                        role: "tool",
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: "Image ready."
+                                        },
+                                        {
+                                            type: "resource_link",
+                                            uri: "/api/fs/file?path=%2Ftmp%2Flandscape.png",
+                                            mimeType: "image/png"
+                                        }
+                                    ]
+                                })
+                            }
+                        ]
+                    }
+                ]
+            }
+        };
+        const result = (0, sessionManager_cjs_namespaceObject.extractMessagesFromState)(state);
+        (0, external_vitest_namespaceObject.expect)(result).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(result).toHaveLength(2);
+        (0, external_vitest_namespaceObject.expect)(result?.[1]).toMatchObject({
+            role: "assistant",
+            content: "Image ready.",
+            attachments: [
+                {
+                    kind: "image",
+                    dataUrl: "/api/fs/file?path=%2Ftmp%2Flandscape.png"
+                }
+            ]
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("extracts tool image attachments from artifact blocks", ()=>{
+        const state = {
+            createdAt: 5000,
+            values: {
+                messages: [
+                    {
+                        role: "user",
+                        content: "Generate another image."
+                    },
+                    {
+                        role: "tool",
+                        content: "Generated image.",
+                        artifact: [
+                            {
+                                type: "image",
+                                mimeType: "image/png",
+                                data: "abc123"
+                            }
+                        ]
+                    }
+                ]
+            }
+        };
+        const result = (0, sessionManager_cjs_namespaceObject.extractMessagesFromState)(state);
+        (0, external_vitest_namespaceObject.expect)(result).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(result).toHaveLength(2);
+        (0, external_vitest_namespaceObject.expect)(result?.[1]).toMatchObject({
+            role: "assistant",
+            content: "Generated image.",
+            attachments: [
+                {
+                    kind: "image",
+                    dataUrl: "data:image/png;base64,abc123"
+                }
+            ]
+        });
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/tests/sessionStateMessages.test.js

@@ -101,4 +101,130 @@ describe("extractMessagesFromState", ()=>{
             content: "Here is the plan."
         });
     });
+    it("promotes tool image outputs into assistant attachments", ()=>{
+        const state = {
+            createdAt: 3000,
+            values: {
+                messages: [
+                    {
+                        role: "user",
+                        content: "Create a puppy image."
+                    },
+                    {
+                        role: "tool",
+                        content: JSON.stringify({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Generated image."
+                                },
+                                {
+                                    type: "resource_link",
+                                    uri: "/api/fs/file?path=%2Ftmp%2Fpuppy.png",
+                                    mimeType: "image/png"
+                                }
+                            ]
+                        })
+                    }
+                ]
+            }
+        };
+        const result = extractMessagesFromState(state);
+        expect(result).not.toBeNull();
+        expect(result).toHaveLength(2);
+        expect(result?.[1]).toMatchObject({
+            role: "assistant",
+            content: "Generated image.",
+            attachments: [
+                {
+                    kind: "image",
+                    dataUrl: "/api/fs/file?path=%2Ftmp%2Fpuppy.png"
+                }
+            ]
+        });
+    });
+    it("extracts tool attachments when MCP payload is wrapped in a text block", ()=>{
+        const state = {
+            createdAt: 4000,
+            values: {
+                messages: [
+                    {
+                        role: "user",
+                        content: "Generate a landscape image."
+                    },
+                    {
+                        role: "tool",
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: "Image ready."
+                                        },
+                                        {
+                                            type: "resource_link",
+                                            uri: "/api/fs/file?path=%2Ftmp%2Flandscape.png",
+                                            mimeType: "image/png"
+                                        }
+                                    ]
+                                })
+                            }
+                        ]
+                    }
+                ]
+            }
+        };
+        const result = extractMessagesFromState(state);
+        expect(result).not.toBeNull();
+        expect(result).toHaveLength(2);
+        expect(result?.[1]).toMatchObject({
+            role: "assistant",
+            content: "Image ready.",
+            attachments: [
+                {
+                    kind: "image",
+                    dataUrl: "/api/fs/file?path=%2Ftmp%2Flandscape.png"
+                }
+            ]
+        });
+    });
+    it("extracts tool image attachments from artifact blocks", ()=>{
+        const state = {
+            createdAt: 5000,
+            values: {
+                messages: [
+                    {
+                        role: "user",
+                        content: "Generate another image."
+                    },
+                    {
+                        role: "tool",
+                        content: "Generated image.",
+                        artifact: [
+                            {
+                                type: "image",
+                                mimeType: "image/png",
+                                data: "abc123"
+                            }
+                        ]
+                    }
+                ]
+            }
+        };
+        const result = extractMessagesFromState(state);
+        expect(result).not.toBeNull();
+        expect(result).toHaveLength(2);
+        expect(result?.[1]).toMatchObject({
+            role: "assistant",
+            content: "Generated image.",
+            attachments: [
+                {
+                    kind: "image",
+                    dataUrl: "data:image/png;base64,abc123"
+                }
+            ]
+        });
+    });
 });