@wingman-ai/gateway 0.4.1 → 0.4.3

package/dist/tests/config-json-schema.test.cjs

@@ -18,6 +18,18 @@ const jsonSchema_cjs_namespaceObject = require("../cli/config/jsonSchema.cjs");
         const scannerArgsDefault = schema.properties.skills.properties.security.properties.scannerArgs.default;
         (0, external_vitest_namespaceObject.expect)(scannerArgsDefault).toContain("mcp-scan>=0.4,<0.5");
     });
+    (0, external_vitest_namespaceObject.it)("exposes hybrid defaults for skill sources", ()=>{
+        const schema = (0, jsonSchema_cjs_namespaceObject.buildWingmanConfigJsonSchema)();
+        const repositoriesDefault = schema.properties.skills.properties.repositories.default;
+        const providerDefault = schema.properties.skills.properties.provider.default;
+        (0, external_vitest_namespaceObject.expect)(providerDefault).toBe("hybrid");
+        (0, external_vitest_namespaceObject.expect)(repositoriesDefault).toEqual([
+            {
+                owner: "RussellCanfield",
+                name: "wingman-ai"
+            }
+        ]);
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/tests/config-json-schema.test.js

@@ -16,4 +16,16 @@ describe("wingman config json schema", ()=>{
         const scannerArgsDefault = schema.properties.skills.properties.security.properties.scannerArgs.default;
         expect(scannerArgsDefault).toContain("mcp-scan>=0.4,<0.5");
     });
+    it("exposes hybrid defaults for skill sources", ()=>{
+        const schema = buildWingmanConfigJsonSchema();
+        const repositoriesDefault = schema.properties.skills.properties.repositories.default;
+        const providerDefault = schema.properties.skills.properties.provider.default;
+        expect(providerDefault).toBe("hybrid");
+        expect(repositoriesDefault).toEqual([
+            {
+                owner: "RussellCanfield",
+                name: "wingman-ai"
+            }
+        ]);
+    });
 });

package/dist/tests/gateway-http-security.test.cjs

@@ -93,6 +93,27 @@ function createTestSocket(initialData) {
         (0, external_vitest_namespaceObject.expect)(allowed.status).toBe(204);
         (0, external_vitest_namespaceObject.expect)(allowed.headers.get("access-control-allow-origin")).toBe("http://localhost:5173");
     });
+    (0, external_vitest_namespaceObject.it)("allows tauri loopback origin preflight for desktop clients", async ()=>{
+        const server = createGateway({
+            host: "127.0.0.1",
+            port: 18789,
+            auth: {
+                mode: "token",
+                token: "test-token"
+            },
+            requireAuth: true
+        });
+        const internals = getGatewayInternals(server);
+        const allowed = await internals.handleUiRequest(new Request("http://127.0.0.1:18789/api/providers", {
+            method: "OPTIONS",
+            headers: {
+                Origin: "tauri://localhost",
+                "Access-Control-Request-Method": "GET"
+            }
+        }));
+        (0, external_vitest_namespaceObject.expect)(allowed.status).toBe(204);
+        (0, external_vitest_namespaceObject.expect)(allowed.headers.get("access-control-allow-origin")).toBe("tauri://localhost");
+    });
     (0, external_vitest_namespaceObject.it)("does not trust tailscale identity headers on non-loopback hosts", ()=>{
         const server = createGateway({
             host: "0.0.0.0",

package/dist/tests/gateway-http-security.test.js

@@ -91,6 +91,27 @@ describe("gateway HTTP security", ()=>{
         expect(allowed.status).toBe(204);
         expect(allowed.headers.get("access-control-allow-origin")).toBe("http://localhost:5173");
     });
+    it("allows tauri loopback origin preflight for desktop clients", async ()=>{
+        const server = createGateway({
+            host: "127.0.0.1",
+            port: 18789,
+            auth: {
+                mode: "token",
+                token: "test-token"
+            },
+            requireAuth: true
+        });
+        const internals = getGatewayInternals(server);
+        const allowed = await internals.handleUiRequest(new Request("http://127.0.0.1:18789/api/providers", {
+            method: "OPTIONS",
+            headers: {
+                Origin: "tauri://localhost",
+                "Access-Control-Request-Method": "GET"
+            }
+        }));
+        expect(allowed.status).toBe(204);
+        expect(allowed.headers.get("access-control-allow-origin")).toBe("tauri://localhost");
+    });
     it("does not trust tailscale identity headers on non-loopback hosts", ()=>{
         const server = createGateway({
             host: "0.0.0.0",

package/dist/tests/gateway-origin-policy.test.cjs

@@ -20,6 +20,17 @@ const server_cjs_namespaceObject = require("../gateway/server.cjs");
         });
         (0, external_vitest_namespaceObject.expect)(allowed).toBe(true);
     });
+    (0, external_vitest_namespaceObject.it)("allows tauri loopback origins for desktop clients", ()=>{
+        const allowed = (0, server_cjs_namespaceObject.isGatewayOriginAllowed)({
+            origin: "tauri://localhost",
+            requestUrl: "http://127.0.0.1:18789/api/sessions",
+            gatewayHost: "127.0.0.1",
+            gatewayPort: 18789,
+            controlUiEnabled: true,
+            controlUiPort: 18790
+        });
+        (0, external_vitest_namespaceObject.expect)(allowed).toBe(true);
+    });
     (0, external_vitest_namespaceObject.it)("rejects unrelated internet origins", ()=>{
         const allowed = (0, server_cjs_namespaceObject.isGatewayOriginAllowed)({
             origin: "https://evil.example",
@@ -53,6 +64,17 @@ const server_cjs_namespaceObject = require("../gateway/server.cjs");
         });
         (0, external_vitest_namespaceObject.expect)(allowed).toBe(false);
     });
+    (0, external_vitest_namespaceObject.it)("rejects tauri origins for non-loopback gateways", ()=>{
+        const allowed = (0, server_cjs_namespaceObject.isGatewayOriginAllowed)({
+            origin: "tauri://localhost",
+            requestUrl: "http://192.168.1.50:18789/api/sessions",
+            gatewayHost: "0.0.0.0",
+            gatewayPort: 18789,
+            controlUiEnabled: true,
+            controlUiPort: 18790
+        });
+        (0, external_vitest_namespaceObject.expect)(allowed).toBe(false);
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/tests/gateway-origin-policy.test.js

@@ -18,6 +18,17 @@ describe("gateway origin policy", ()=>{
         });
         expect(allowed).toBe(true);
     });
+    it("allows tauri loopback origins for desktop clients", ()=>{
+        const allowed = isGatewayOriginAllowed({
+            origin: "tauri://localhost",
+            requestUrl: "http://127.0.0.1:18789/api/sessions",
+            gatewayHost: "127.0.0.1",
+            gatewayPort: 18789,
+            controlUiEnabled: true,
+            controlUiPort: 18790
+        });
+        expect(allowed).toBe(true);
+    });
     it("rejects unrelated internet origins", ()=>{
         const allowed = isGatewayOriginAllowed({
             origin: "https://evil.example",
@@ -51,4 +62,15 @@ describe("gateway origin policy", ()=>{
         });
         expect(allowed).toBe(false);
     });
+    it("rejects tauri origins for non-loopback gateways", ()=>{
+        const allowed = isGatewayOriginAllowed({
+            origin: "tauri://localhost",
+            requestUrl: "http://192.168.1.50:18789/api/sessions",
+            gatewayHost: "0.0.0.0",
+            gatewayPort: 18789,
+            controlUiEnabled: true,
+            controlUiPort: 18790
+        });
+        expect(allowed).toBe(false);
+    });
 });

package/dist/tests/gateway.test.cjs

@@ -22,6 +22,40 @@ external_vitest_namespaceObject.vi.mock("@/cli/core/agentInvoker.js", ()=>({
         AgentInvoker: class {
             async invokeAgent(_agentId, content, _sessionId, _attachments, options) {
                 if ("throw-no-event" === content) throw new Error("Synthetic invocation failure");
+                if ("stream-model-failure-no-error" === content) {
+                    this.outputManager?.emitAgentStream?.({
+                        event: "on_chain_end",
+                        run_id: "model-failure-run-1",
+                        name: "ChannelWrite<branch:to:todoListMiddleware.after_model>",
+                        data: {
+                            output: [
+                                {
+                                    lg_name: "Command",
+                                    update: {
+                                        messages: [
+                                            {
+                                                type: "constructor",
+                                                id: [
+                                                    "langchain_core",
+                                                    "messages",
+                                                    "AIMessage"
+                                                ],
+                                                kwargs: {
+                                                    id: "model-failure-msg-1",
+                                                    content: "Model call failed after 3 attempts with Error: xAI image generation failed: Prompt len is larger than the maximum allowed length which is 8000"
+                                                }
+                                            }
+                                        ]
+                                    }
+                                }
+                            ],
+                            input: {}
+                        }
+                    });
+                    return {
+                        streaming: true
+                    };
+                }
                 const signal = options?.signal;
                 await new Promise((resolve)=>{
                     const timer = setTimeout(resolve, 75);
@@ -412,6 +446,29 @@ describeIfBun("Gateway", ()=>{
         });
         requester.close();
     });
+    (0, external_vitest_namespaceObject.it)("does not auto-convert streamed model failure text into agent-error", async ()=>{
+        const requester = await connectClient("session-streamed-failure-requester");
+        const requestId = "req-streamed-failure-no-error";
+        const sessionId = "session-streamed-failure-no-error";
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: requestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "stream-model-failure-no-error"
+            },
+            timestamp: Date.now()
+        }));
+        const streamMsg = await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-stream" && msg.payload?.chunk?.event === "on_chain_end", 10000);
+        (0, external_vitest_namespaceObject.expect)(JSON.stringify(streamMsg.payload?.chunk?.data || {})).toContain("Model call failed after 3 attempts");
+        const completeMsg = await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-complete", 10000);
+        (0, external_vitest_namespaceObject.expect)(completeMsg.payload?.sessionId).toBe(sessionId);
+        (0, external_vitest_namespaceObject.expect)(completeMsg.payload?.agentId).toBe("main");
+        const terminalErrorEvents = await collectMessages(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-error", 400);
+        (0, external_vitest_namespaceObject.expect)(terminalErrorEvents).toHaveLength(0);
+        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";

package/dist/tests/gateway.test.js

@@ -20,6 +20,40 @@ vi.mock("@/cli/core/agentInvoker.js", ()=>({
         AgentInvoker: class {
             async invokeAgent(_agentId, content, _sessionId, _attachments, options) {
                 if ("throw-no-event" === content) throw new Error("Synthetic invocation failure");
+                if ("stream-model-failure-no-error" === content) {
+                    this.outputManager?.emitAgentStream?.({
+                        event: "on_chain_end",
+                        run_id: "model-failure-run-1",
+                        name: "ChannelWrite<branch:to:todoListMiddleware.after_model>",
+                        data: {
+                            output: [
+                                {
+                                    lg_name: "Command",
+                                    update: {
+                                        messages: [
+                                            {
+                                                type: "constructor",
+                                                id: [
+                                                    "langchain_core",
+                                                    "messages",
+                                                    "AIMessage"
+                                                ],
+                                                kwargs: {
+                                                    id: "model-failure-msg-1",
+                                                    content: "Model call failed after 3 attempts with Error: xAI image generation failed: Prompt len is larger than the maximum allowed length which is 8000"
+                                                }
+                                            }
+                                        ]
+                                    }
+                                }
+                            ],
+                            input: {}
+                        }
+                    });
+                    return {
+                        streaming: true
+                    };
+                }
                 const signal = options?.signal;
                 await new Promise((resolve)=>{
                     const timer = setTimeout(resolve, 75);
@@ -410,6 +444,29 @@ describeIfBun("Gateway", ()=>{
         });
         requester.close();
     });
+    it("does not auto-convert streamed model failure text into agent-error", async ()=>{
+        const requester = await connectClient("session-streamed-failure-requester");
+        const requestId = "req-streamed-failure-no-error";
+        const sessionId = "session-streamed-failure-no-error";
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: requestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "stream-model-failure-no-error"
+            },
+            timestamp: Date.now()
+        }));
+        const streamMsg = await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-stream" && msg.payload?.chunk?.event === "on_chain_end", 10000);
+        expect(JSON.stringify(streamMsg.payload?.chunk?.data || {})).toContain("Model call failed after 3 attempts");
+        const completeMsg = await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-complete", 10000);
+        expect(completeMsg.payload?.sessionId).toBe(sessionId);
+        expect(completeMsg.payload?.agentId).toBe("main");
+        const terminalErrorEvents = await collectMessages(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-error", 400);
+        expect(terminalErrorEvents).toHaveLength(0);
+        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";

package/dist/tests/imagePersistence.test.cjs

@@ -128,6 +128,32 @@ const PNG_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQA
         (0, external_vitest_namespaceObject.expect)(firstPath).toBeTruthy();
         (0, external_vitest_namespaceObject.expect)(secondPath).toBe(firstPath);
     });
+    (0, external_vitest_namespaceObject.it)("removes persisted session media directory", ()=>{
+        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 sessionId = "session-cleanup";
+        const messages = [
+            {
+                role: "assistant",
+                attachments: [
+                    {
+                        kind: "image",
+                        dataUrl: PNG_DATA_URL
+                    }
+                ]
+            }
+        ];
+        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
+            dbPath,
+            sessionId,
+            messages
+        });
+        const mediaDir = (0, imagePersistence_cjs_namespaceObject.getSessionMediaDirectory)(dbPath, sessionId);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mediaDir)).toBe(true);
+        (0, imagePersistence_cjs_namespaceObject.removeSessionMediaDirectory)(dbPath, sessionId);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mediaDir)).toBe(false);
+    });
     (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");

package/dist/tests/imagePersistence.test.js

@@ -2,7 +2,7 @@ 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";
+import { getSessionMediaDirectory, parseBase64DataUrl, persistAssistantImagesToDisk, removeSessionMediaDirectory, resolveImageExtension } from "../cli/core/imagePersistence.js";
 const PNG_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO3X6S0AAAAASUVORK5CYII=";
 describe("imagePersistence", ()=>{
     const tempDirs = [];
@@ -126,6 +126,32 @@ describe("imagePersistence", ()=>{
         expect(firstPath).toBeTruthy();
         expect(secondPath).toBe(firstPath);
     });
+    it("removes persisted session media directory", ()=>{
+        const tempDir = mkdtempSync(join(tmpdir(), "wingman-image-store-"));
+        tempDirs.push(tempDir);
+        const dbPath = join(tempDir, "wingman.db");
+        const sessionId = "session-cleanup";
+        const messages = [
+            {
+                role: "assistant",
+                attachments: [
+                    {
+                        kind: "image",
+                        dataUrl: PNG_DATA_URL
+                    }
+                ]
+            }
+        ];
+        persistAssistantImagesToDisk({
+            dbPath,
+            sessionId,
+            messages
+        });
+        const mediaDir = getSessionMediaDirectory(dbPath, sessionId);
+        expect(existsSync(mediaDir)).toBe(true);
+        removeSessionMediaDirectory(dbPath, sessionId);
+        expect(existsSync(mediaDir)).toBe(false);
+    });
     it("parses base64 data URLs and resolves extensions", ()=>{
         const parsed = parseBase64DataUrl(PNG_DATA_URL);
         expect(parsed?.mimeType).toBe("image/png");

package/dist/tests/run-terminal-bench-official-script.test.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_node_path_namespaceObject = require("node:path");
+const external_vitest_namespaceObject = require("vitest");
+const officialCli_cjs_namespaceObject = require("../bench/officialCli.cjs");
+(0, external_vitest_namespaceObject.describe)("run-terminal-bench-official cli args", ()=>{
+    (0, external_vitest_namespaceObject.it)("parses wingman bridge options", ()=>{
+        const parsed = (0, officialCli_cjs_namespaceObject.parseOfficialBenchArgs)([
+            "bun",
+            "run-terminal-bench-official.ts",
+            "--config",
+            "bench/config.tb2-wingman.json",
+            "--task-id",
+            "heterogeneous-dates",
+            "--n-attempts",
+            "3",
+            "--n-tasks",
+            "2",
+            "--wingman-agent",
+            "coding",
+            "--wingman-model",
+            "openai/gpt-5"
+        ]);
+        (0, external_vitest_namespaceObject.expect)(parsed.configPath).toBe((0, external_node_path_namespaceObject.join)(process.cwd(), "bench/config.tb2-wingman.json"));
+        (0, external_vitest_namespaceObject.expect)(parsed.overrides.taskNames).toEqual([
+            "heterogeneous-dates"
+        ]);
+        (0, external_vitest_namespaceObject.expect)(parsed.overrides.nAttempts).toBe(3);
+        (0, external_vitest_namespaceObject.expect)(parsed.overrides.nTasks).toBe(2);
+        (0, external_vitest_namespaceObject.expect)(parsed.overrides.agentKwargs).toEqual({
+            wingman_agent: "coding",
+            wingman_model: "openai:gpt-5"
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("uses all dataset tasks when --all-tasks is set", ()=>{
+        const parsed = (0, officialCli_cjs_namespaceObject.parseOfficialBenchArgs)([
+            "bun",
+            "run-terminal-bench-official.ts",
+            "--task-name",
+            "heterogeneous-dates",
+            "--all-tasks"
+        ]);
+        (0, external_vitest_namespaceObject.expect)(parsed.overrides.taskNames).toEqual([]);
+    });
+    (0, external_vitest_namespaceObject.it)("parses explicit registry options", ()=>{
+        const parsed = (0, officialCli_cjs_namespaceObject.parseOfficialBenchArgs)([
+            "bun",
+            "run-terminal-bench-official.ts",
+            "--registry-url",
+            "https://example.com/registry.json",
+            "--registry-path",
+            "/tmp/registry.json"
+        ]);
+        (0, external_vitest_namespaceObject.expect)(parsed.overrides.registryUrl).toBe("https://example.com/registry.json");
+        (0, external_vitest_namespaceObject.expect)(parsed.overrides.registryPath).toBe("/tmp/registry.json");
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/run-terminal-bench-official-script.test.d.ts

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

package/dist/tests/run-terminal-bench-official-script.test.js

@@ -0,0 +1,55 @@
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { parseOfficialBenchArgs } from "../bench/officialCli.js";
+describe("run-terminal-bench-official cli args", ()=>{
+    it("parses wingman bridge options", ()=>{
+        const parsed = parseOfficialBenchArgs([
+            "bun",
+            "run-terminal-bench-official.ts",
+            "--config",
+            "bench/config.tb2-wingman.json",
+            "--task-id",
+            "heterogeneous-dates",
+            "--n-attempts",
+            "3",
+            "--n-tasks",
+            "2",
+            "--wingman-agent",
+            "coding",
+            "--wingman-model",
+            "openai/gpt-5"
+        ]);
+        expect(parsed.configPath).toBe(join(process.cwd(), "bench/config.tb2-wingman.json"));
+        expect(parsed.overrides.taskNames).toEqual([
+            "heterogeneous-dates"
+        ]);
+        expect(parsed.overrides.nAttempts).toBe(3);
+        expect(parsed.overrides.nTasks).toBe(2);
+        expect(parsed.overrides.agentKwargs).toEqual({
+            wingman_agent: "coding",
+            wingman_model: "openai:gpt-5"
+        });
+    });
+    it("uses all dataset tasks when --all-tasks is set", ()=>{
+        const parsed = parseOfficialBenchArgs([
+            "bun",
+            "run-terminal-bench-official.ts",
+            "--task-name",
+            "heterogeneous-dates",
+            "--all-tasks"
+        ]);
+        expect(parsed.overrides.taskNames).toEqual([]);
+    });
+    it("parses explicit registry options", ()=>{
+        const parsed = parseOfficialBenchArgs([
+            "bun",
+            "run-terminal-bench-official.ts",
+            "--registry-url",
+            "https://example.com/registry.json",
+            "--registry-path",
+            "/tmp/registry.json"
+        ]);
+        expect(parsed.overrides.registryUrl).toBe("https://example.com/registry.json");
+        expect(parsed.overrides.registryPath).toBe("/tmp/registry.json");
+    });
+});

package/dist/tests/sessions-api.test.cjs

@@ -4,6 +4,7 @@ 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 sessionManager_cjs_namespaceObject = require("../cli/core/sessionManager.cjs");
 const sessions_cjs_namespaceObject = require("../gateway/http/sessions.cjs");
 const isBunRuntime = void 0 !== globalThis.Bun;
@@ -11,9 +12,11 @@ const describeIfBun = isBunRuntime ? external_vitest_namespaceObject.describe :
 describeIfBun("sessions API", ()=>{
     let manager;
     let tempDir;
+    let dbPath;
+    const PNG_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO3X6S0AAAAASUVORK5CYII=";
     (0, external_vitest_namespaceObject.beforeEach)(async ()=>{
         tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-sessions-"));
-        const dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "sessions.db");
+        dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "sessions.db");
         manager = new sessionManager_cjs_namespaceObject.SessionManager(dbPath);
         await manager.initialize();
     });
@@ -45,6 +48,23 @@ describeIfBun("sessions API", ()=>{
         (0, external_vitest_namespaceObject.expect)(createRes).not.toBeNull();
         (0, external_vitest_namespaceObject.expect)(createRes?.ok).toBe(true);
         const created = await createRes.json();
+        const mediaDir = (0, imagePersistence_cjs_namespaceObject.getSessionMediaDirectory)(dbPath, created.id);
+        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
+            dbPath,
+            sessionId: created.id,
+            messages: [
+                {
+                    role: "assistant",
+                    attachments: [
+                        {
+                            kind: "image",
+                            dataUrl: PNG_DATA_URL
+                        }
+                    ]
+                }
+            ]
+        });
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mediaDir)).toBe(true);
         manager.updateSession(created.id, {
             messageCount: 2,
             lastMessagePreview: "Hello"
@@ -57,10 +77,58 @@ describeIfBun("sessions API", ()=>{
         (0, external_vitest_namespaceObject.expect)(deleteRes?.ok).toBe(true);
         const payload = await deleteRes.json();
         (0, external_vitest_namespaceObject.expect)(payload.messageCount).toBe(0);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mediaDir)).toBe(false);
         const updated = manager.getSession(created.id);
         (0, external_vitest_namespaceObject.expect)(updated?.messageCount).toBe(0);
         (0, external_vitest_namespaceObject.expect)(updated?.lastMessagePreview).toBeNull();
     });
+    (0, external_vitest_namespaceObject.it)("removes persisted session media when deleting a session", async ()=>{
+        const ctx = {
+            getSessionManager: async ()=>manager,
+            router: {
+                selectAgent: (agentId)=>agentId || "main"
+            }
+        };
+        const createReq = new Request("http://localhost/api/sessions", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                agentId: "main",
+                name: "Delete Session Media"
+            })
+        });
+        const createRes = await (0, sessions_cjs_namespaceObject.handleSessionsApi)(ctx, createReq, new URL(createReq.url));
+        (0, external_vitest_namespaceObject.expect)(createRes).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        const mediaDir = (0, imagePersistence_cjs_namespaceObject.getSessionMediaDirectory)(dbPath, created.id);
+        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
+            dbPath,
+            sessionId: created.id,
+            messages: [
+                {
+                    role: "assistant",
+                    attachments: [
+                        {
+                            kind: "image",
+                            dataUrl: PNG_DATA_URL
+                        }
+                    ]
+                }
+            ]
+        });
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mediaDir)).toBe(true);
+        const deleteReq = new Request(`http://localhost/api/sessions/${encodeURIComponent(created.id)}?agentId=main`, {
+            method: "DELETE"
+        });
+        const deleteRes = await (0, sessions_cjs_namespaceObject.handleSessionsApi)(ctx, deleteReq, new URL(deleteReq.url));
+        (0, external_vitest_namespaceObject.expect)(deleteRes).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(deleteRes?.ok).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mediaDir)).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(manager.getSession(created.id)).toBeNull();
+    });
     (0, external_vitest_namespaceObject.it)("returns pending messages and clears them via DELETE", async ()=>{
         const ctx = {
             getSessionManager: async ()=>manager,