@wingman-ai/gateway 0.2.4 → 0.3.0

package/dist/tests/falSummary.test.cjs

@@ -0,0 +1,51 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const summary_cjs_namespaceObject = require("../tools/fal/summary.cjs");
+(0, external_vitest_namespaceObject.describe)("fal summary", ()=>{
+    (0, external_vitest_namespaceObject.it)("formats summary text with status, model, and files", ()=>{
+        const summary = (0, summary_cjs_namespaceObject.buildFalGenerationSummary)({
+            toolName: "generate_image_or_texture",
+            jobId: "job-123",
+            status: "completed",
+            modelId: "fal-ai/nano-banana-pro",
+            reviewState: "accepted",
+            media: [
+                {
+                    modality: "image",
+                    path: "/repo/apps/wingman/generated/images/asset.png",
+                    mimeType: "image/png"
+                }
+            ],
+            cwd: "/repo/apps/wingman"
+        });
+        (0, external_vitest_namespaceObject.expect)(summary).toContain("FAL job `job-123`");
+        (0, external_vitest_namespaceObject.expect)(summary).toContain("**completed**");
+        (0, external_vitest_namespaceObject.expect)(summary).toContain("- Model: `fal-ai/nano-banana-pro`");
+        (0, external_vitest_namespaceObject.expect)(summary).toContain("- Assets: 1");
+        (0, external_vitest_namespaceObject.expect)(summary).toContain("[image] ./generated/images/asset.png image/png");
+    });
+    (0, external_vitest_namespaceObject.it)("includes review instruction when pending", ()=>{
+        const summary = (0, summary_cjs_namespaceObject.buildFalGenerationSummary)({
+            toolName: "generate_video_from_image",
+            jobId: "job-456",
+            status: "awaiting_review",
+            modelId: "fal-ai/kling-video/o3/standard/image-to-video",
+            reviewState: "pending",
+            media: []
+        });
+        (0, external_vitest_namespaceObject.expect)(summary).toContain("Review required");
+        (0, external_vitest_namespaceObject.expect)(summary).toContain("fal_generation_status");
+    });
+    (0, external_vitest_namespaceObject.it)("formats home paths with tilde when outside cwd", ()=>{
+        const formatted = (0, summary_cjs_namespaceObject.formatFalPath)("/Users/demo/Projects/output.mp4", {
+            cwd: "/repo/apps/wingman",
+            homeDir: "/Users/demo"
+        });
+        (0, external_vitest_namespaceObject.expect)(formatted).toBe("~/Projects/output.mp4");
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/dist/tests/falSummary.test.js

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { buildFalGenerationSummary, formatFalPath } from "../tools/fal/summary.js";
+describe("fal summary", ()=>{
+    it("formats summary text with status, model, and files", ()=>{
+        const summary = buildFalGenerationSummary({
+            toolName: "generate_image_or_texture",
+            jobId: "job-123",
+            status: "completed",
+            modelId: "fal-ai/nano-banana-pro",
+            reviewState: "accepted",
+            media: [
+                {
+                    modality: "image",
+                    path: "/repo/apps/wingman/generated/images/asset.png",
+                    mimeType: "image/png"
+                }
+            ],
+            cwd: "/repo/apps/wingman"
+        });
+        expect(summary).toContain("FAL job `job-123`");
+        expect(summary).toContain("**completed**");
+        expect(summary).toContain("- Model: `fal-ai/nano-banana-pro`");
+        expect(summary).toContain("- Assets: 1");
+        expect(summary).toContain("[image] ./generated/images/asset.png image/png");
+    });
+    it("includes review instruction when pending", ()=>{
+        const summary = buildFalGenerationSummary({
+            toolName: "generate_video_from_image",
+            jobId: "job-456",
+            status: "awaiting_review",
+            modelId: "fal-ai/kling-video/o3/standard/image-to-video",
+            reviewState: "pending",
+            media: []
+        });
+        expect(summary).toContain("Review required");
+        expect(summary).toContain("fal_generation_status");
+    });
+    it("formats home paths with tilde when outside cwd", ()=>{
+        const formatted = formatFalPath("/Users/demo/Projects/output.mp4", {
+            cwd: "/repo/apps/wingman",
+            homeDir: "/Users/demo"
+        });
+        expect(formatted).toBe("~/Projects/output.mp4");
+    });
+});

package/dist/tests/gateway.test.cjs

@@ -1,5 +1,8 @@
 "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 index_cjs_namespaceObject = require("../gateway/index.cjs");
 function _define_property(obj, key, value) {
@@ -38,6 +41,9 @@ external_vitest_namespaceObject.vi.mock("@/cli/core/agentInvoker.js", ()=>({
                         cancelled: true
                     };
                 }
+                if ("return-no-event" === content) return {
+                    streaming: true
+                };
                 this.outputManager?.emitAgentComplete?.({
                     streaming: true
                 });
@@ -54,7 +60,9 @@ external_vitest_namespaceObject.vi.mock("@/cli/core/agentInvoker.js", ()=>({
 describeIfBun("Gateway", ()=>{
     let server;
     let port = 0;
+    let testWorkspace;
     (0, external_vitest_namespaceObject.beforeAll)(async ()=>{
+        testWorkspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-gateway-test-"));
         const instance = new index_cjs_namespaceObject.GatewayServer({
             port: 0,
             host: "localhost",
@@ -62,7 +70,10 @@ describeIfBun("Gateway", ()=>{
             auth: {
                 mode: "none"
             },
-            logLevel: "silent"
+            logLevel: "silent",
+            workspace: testWorkspace,
+            configDir: ".wingman-test-config",
+            stateDir: ".wingman-test-state"
         });
         await instance.start();
         server = instance;
@@ -72,6 +83,10 @@ describeIfBun("Gateway", ()=>{
     });
     (0, external_vitest_namespaceObject.afterAll)(async ()=>{
         if (server) await server.stop();
+        if (testWorkspace) (0, external_node_fs_namespaceObject.rmSync)(testWorkspace, {
+            recursive: true,
+            force: true
+        });
     });
     const connectClient = (instanceId, clientType = "test")=>new Promise((resolve, reject)=>{
             const ws = new WebSocket(`ws://localhost:${port}/ws`);
@@ -117,6 +132,24 @@ describeIfBun("Gateway", ()=>{
             };
             ws.addEventListener("message", handler);
         });
+    const collectMessages = (ws, predicate, durationMs = 600)=>new Promise((resolve)=>{
+            const matches = [];
+            const handler = (event)=>{
+                let msg;
+                try {
+                    msg = JSON.parse(event.data);
+                } catch  {
+                    return;
+                }
+                if (!predicate(msg)) return;
+                matches.push(msg);
+            };
+            ws.addEventListener("message", handler);
+            setTimeout(()=>{
+                ws.removeEventListener("message", handler);
+                resolve(matches);
+            }, durationMs);
+        });
     (0, external_vitest_namespaceObject.it)("should start the gateway server", async ()=>{
         const response = await fetch(`http://localhost:${port}/health`);
         (0, external_vitest_namespaceObject.expect)(response.ok).toBe(true);
@@ -354,6 +387,49 @@ describeIfBun("Gateway", ()=>{
         (0, external_vitest_namespaceObject.expect)(errorMsg.payload?.agentId).toBe("main");
         requester.close();
     });
+    (0, external_vitest_namespaceObject.it)("should emit agent-complete when invocation returns without terminal output events", async ()=>{
+        const requester = await connectClient("session-complete-fallback-requester");
+        const requestId = "req-complete-fallback";
+        const sessionId = "session-complete-fallback";
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: requestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "return-no-event"
+            },
+            timestamp: Date.now()
+        }));
+        const completeMsg = await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-complete");
+        (0, external_vitest_namespaceObject.expect)(completeMsg.payload?.sessionId).toBe(sessionId);
+        (0, external_vitest_namespaceObject.expect)(completeMsg.payload?.agentId).toBe("main");
+        (0, external_vitest_namespaceObject.expect)(completeMsg.payload?.result).toEqual({
+            streaming: true
+        });
+        requester.close();
+    });
+    (0, external_vitest_namespaceObject.it)("should emit a single agent-complete terminal event per request", async ()=>{
+        const requester = await connectClient("session-single-complete-requester");
+        const requestId = "req-single-complete";
+        const sessionId = "session-single-complete";
+        const completionEventsPromise = collectMessages(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-complete", 1000);
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: requestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "single-complete"
+            },
+            timestamp: Date.now()
+        }));
+        const completionEvents = await completionEventsPromise;
+        (0, external_vitest_namespaceObject.expect)(completionEvents).toHaveLength(1);
+        (0, external_vitest_namespaceObject.expect)(completionEvents[0].payload?.sessionId).toBe(sessionId);
+        (0, external_vitest_namespaceObject.expect)(completionEvents[0].payload?.agentId).toBe("main");
+        requester.close();
+    });
     (0, external_vitest_namespaceObject.it)("should cancel an in-flight agent request", async ()=>{
         const requester = await connectClient("session-cancel-requester");
         const requestId = "req-cancel-test";
@@ -460,6 +536,9 @@ describeIfBun("Gateway", ()=>{
         }));
         const cancelAck = await waitForMessage(requester, (msg)=>"ack" === msg.type && msg.payload?.action === "req:agent:cancel" && msg.payload?.requestId === secondRequestId && msg.payload?.status === "cancelled_queued", 10000);
         (0, external_vitest_namespaceObject.expect)(cancelAck.payload?.status).toBe("cancelled_queued");
+        const cancelEvent = await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === secondRequestId && msg.payload?.type === "agent-error" && /cancel/i.test(String(msg.payload?.error || "")), 10000);
+        (0, external_vitest_namespaceObject.expect)(cancelEvent.payload?.sessionId).toBe(sessionId);
+        (0, external_vitest_namespaceObject.expect)(cancelEvent.payload?.agentId).toBe("main");
         await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === firstRequestId && msg.payload?.type === "agent-complete", 10000);
         const queuedRequests = server.queuedSessionRequests;
         const isStillQueued = [
@@ -496,6 +575,35 @@ describeIfBun("Gateway", ()=>{
         (0, external_vitest_namespaceObject.expect)(updated?.messageCount).toBe(0);
         (0, external_vitest_namespaceObject.expect)(updated?.lastMessagePreview).toBeNull();
     });
+    (0, external_vitest_namespaceObject.it)("persists failed first-turn messages so the thread survives reload", async ()=>{
+        const requester = await connectClient("persist-failed-turn-requester");
+        const sessionId = `session-persist-failed-${Date.now()}`;
+        const requestId = `req-persist-failed-${Date.now()}`;
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: requestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "throw-no-event"
+            },
+            timestamp: Date.now()
+        }));
+        await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-error", 10000);
+        const sessionsRes = await fetch(`http://localhost:${port}/api/sessions?limit=100`);
+        (0, external_vitest_namespaceObject.expect)(sessionsRes.ok).toBe(true);
+        const sessions = await sessionsRes.json();
+        const created = sessions.find((session)=>session.id === sessionId);
+        (0, external_vitest_namespaceObject.expect)(created).toBeTruthy();
+        (0, external_vitest_namespaceObject.expect)(created?.messageCount).toBe(1);
+        const messagesRes = await fetch(`http://localhost:${port}/api/sessions/${encodeURIComponent(sessionId)}/messages?agentId=main`);
+        (0, external_vitest_namespaceObject.expect)(messagesRes.ok).toBe(true);
+        const messages = await messagesRes.json();
+        (0, external_vitest_namespaceObject.expect)(messages.some((message)=>"user" === message.role)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(messages.some((message)=>"user" === message.role && message.content.includes("throw-no-event"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(messages.some((message)=>"assistant" === message.role && message.content.includes("Synthetic invocation failure"))).toBe(true);
+        requester.close();
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/tests/gateway.test.js

@@ -1,3 +1,6 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
 import { GatewayClient, GatewayServer } from "../gateway/index.js";
 function _define_property(obj, key, value) {
@@ -36,6 +39,9 @@ vi.mock("@/cli/core/agentInvoker.js", ()=>({
                         cancelled: true
                     };
                 }
+                if ("return-no-event" === content) return {
+                    streaming: true
+                };
                 this.outputManager?.emitAgentComplete?.({
                     streaming: true
                 });
@@ -52,7 +58,9 @@ vi.mock("@/cli/core/agentInvoker.js", ()=>({
 describeIfBun("Gateway", ()=>{
     let server;
     let port = 0;
+    let testWorkspace;
     beforeAll(async ()=>{
+        testWorkspace = mkdtempSync(join(tmpdir(), "wingman-gateway-test-"));
         const instance = new GatewayServer({
             port: 0,
             host: "localhost",
@@ -60,7 +68,10 @@ describeIfBun("Gateway", ()=>{
             auth: {
                 mode: "none"
             },
-            logLevel: "silent"
+            logLevel: "silent",
+            workspace: testWorkspace,
+            configDir: ".wingman-test-config",
+            stateDir: ".wingman-test-state"
         });
         await instance.start();
         server = instance;
@@ -70,6 +81,10 @@ describeIfBun("Gateway", ()=>{
     });
     afterAll(async ()=>{
         if (server) await server.stop();
+        if (testWorkspace) rmSync(testWorkspace, {
+            recursive: true,
+            force: true
+        });
     });
     const connectClient = (instanceId, clientType = "test")=>new Promise((resolve, reject)=>{
             const ws = new WebSocket(`ws://localhost:${port}/ws`);
@@ -115,6 +130,24 @@ describeIfBun("Gateway", ()=>{
             };
             ws.addEventListener("message", handler);
         });
+    const collectMessages = (ws, predicate, durationMs = 600)=>new Promise((resolve)=>{
+            const matches = [];
+            const handler = (event)=>{
+                let msg;
+                try {
+                    msg = JSON.parse(event.data);
+                } catch  {
+                    return;
+                }
+                if (!predicate(msg)) return;
+                matches.push(msg);
+            };
+            ws.addEventListener("message", handler);
+            setTimeout(()=>{
+                ws.removeEventListener("message", handler);
+                resolve(matches);
+            }, durationMs);
+        });
     it("should start the gateway server", async ()=>{
         const response = await fetch(`http://localhost:${port}/health`);
         expect(response.ok).toBe(true);
@@ -352,6 +385,49 @@ describeIfBun("Gateway", ()=>{
         expect(errorMsg.payload?.agentId).toBe("main");
         requester.close();
     });
+    it("should emit agent-complete when invocation returns without terminal output events", async ()=>{
+        const requester = await connectClient("session-complete-fallback-requester");
+        const requestId = "req-complete-fallback";
+        const sessionId = "session-complete-fallback";
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: requestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "return-no-event"
+            },
+            timestamp: Date.now()
+        }));
+        const completeMsg = await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-complete");
+        expect(completeMsg.payload?.sessionId).toBe(sessionId);
+        expect(completeMsg.payload?.agentId).toBe("main");
+        expect(completeMsg.payload?.result).toEqual({
+            streaming: true
+        });
+        requester.close();
+    });
+    it("should emit a single agent-complete terminal event per request", async ()=>{
+        const requester = await connectClient("session-single-complete-requester");
+        const requestId = "req-single-complete";
+        const sessionId = "session-single-complete";
+        const completionEventsPromise = collectMessages(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-complete", 1000);
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: requestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "single-complete"
+            },
+            timestamp: Date.now()
+        }));
+        const completionEvents = await completionEventsPromise;
+        expect(completionEvents).toHaveLength(1);
+        expect(completionEvents[0].payload?.sessionId).toBe(sessionId);
+        expect(completionEvents[0].payload?.agentId).toBe("main");
+        requester.close();
+    });
     it("should cancel an in-flight agent request", async ()=>{
         const requester = await connectClient("session-cancel-requester");
         const requestId = "req-cancel-test";
@@ -458,6 +534,9 @@ describeIfBun("Gateway", ()=>{
         }));
         const cancelAck = await waitForMessage(requester, (msg)=>"ack" === msg.type && msg.payload?.action === "req:agent:cancel" && msg.payload?.requestId === secondRequestId && msg.payload?.status === "cancelled_queued", 10000);
         expect(cancelAck.payload?.status).toBe("cancelled_queued");
+        const cancelEvent = await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === secondRequestId && msg.payload?.type === "agent-error" && /cancel/i.test(String(msg.payload?.error || "")), 10000);
+        expect(cancelEvent.payload?.sessionId).toBe(sessionId);
+        expect(cancelEvent.payload?.agentId).toBe("main");
         await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === firstRequestId && msg.payload?.type === "agent-complete", 10000);
         const queuedRequests = server.queuedSessionRequests;
         const isStillQueued = [
@@ -494,4 +573,33 @@ describeIfBun("Gateway", ()=>{
         expect(updated?.messageCount).toBe(0);
         expect(updated?.lastMessagePreview).toBeNull();
     });
+    it("persists failed first-turn messages so the thread survives reload", async ()=>{
+        const requester = await connectClient("persist-failed-turn-requester");
+        const sessionId = `session-persist-failed-${Date.now()}`;
+        const requestId = `req-persist-failed-${Date.now()}`;
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: requestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "throw-no-event"
+            },
+            timestamp: Date.now()
+        }));
+        await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-error", 10000);
+        const sessionsRes = await fetch(`http://localhost:${port}/api/sessions?limit=100`);
+        expect(sessionsRes.ok).toBe(true);
+        const sessions = await sessionsRes.json();
+        const created = sessions.find((session)=>session.id === sessionId);
+        expect(created).toBeTruthy();
+        expect(created?.messageCount).toBe(1);
+        const messagesRes = await fetch(`http://localhost:${port}/api/sessions/${encodeURIComponent(sessionId)}/messages?agentId=main`);
+        expect(messagesRes.ok).toBe(true);
+        const messages = await messagesRes.json();
+        expect(messages.some((message)=>"user" === message.role)).toBe(true);
+        expect(messages.some((message)=>"user" === message.role && message.content.includes("throw-no-event"))).toBe(true);
+        expect(messages.some((message)=>"assistant" === message.role && message.content.includes("Synthetic invocation failure"))).toBe(true);
+        requester.close();
+    });
 });

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 {};