@wingman-ai/gateway 0.5.3 → 0.6.0

package/dist/tests/gateway.test.js

@@ -1,694 +0,0 @@
-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) {
-    if (key in obj) Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-    });
-    else obj[key] = value;
-    return obj;
-}
-const isBun = void 0 !== globalThis.Bun;
-const describeIfBun = isBun ? describe : describe.skip;
-const invokerConstructOptions = [];
-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);
-                    if (signal) {
-                        const onAbort = ()=>{
-                            clearTimeout(timer);
-                            resolve();
-                        };
-                        if (signal.aborted) return void onAbort();
-                        signal.addEventListener("abort", onAbort, {
-                            once: true
-                        });
-                    }
-                });
-                if (signal?.aborted) {
-                    this.outputManager?.emitAgentError?.("Request cancelled");
-                    return {
-                        cancelled: true
-                    };
-                }
-                if ("return-no-event" === content) return {
-                    streaming: true
-                };
-                this.outputManager?.emitAgentComplete?.({
-                    streaming: true
-                });
-                return {
-                    streaming: true
-                };
-            }
-            constructor(options){
-                _define_property(this, "outputManager", void 0);
-                this.outputManager = options?.outputManager;
-                invokerConstructOptions.push(options || {});
-            }
-        }
-    }));
-describeIfBun("Gateway", ()=>{
-    let server;
-    let port = 0;
-    let testWorkspace;
-    beforeAll(async ()=>{
-        invokerConstructOptions.length = 0;
-        testWorkspace = mkdtempSync(join(tmpdir(), "wingman-gateway-test-"));
-        const instance = new GatewayServer({
-            port: 0,
-            host: "localhost",
-            requireAuth: false,
-            auth: {
-                mode: "none"
-            },
-            logLevel: "silent",
-            workspace: testWorkspace,
-            configDir: ".wingman-test-config",
-            stateDir: ".wingman-test-state"
-        });
-        await instance.start();
-        server = instance;
-        port = server.getPort();
-        if (!port) throw new Error("Unable to determine gateway server port");
-        await new Promise((resolve)=>setTimeout(resolve, 500));
-    });
-    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`);
-            const connectId = `connect-${instanceId}-${Date.now()}`;
-            const timeout = setTimeout(()=>reject(new Error("Connect timeout")), 5000);
-            ws.addEventListener("open", ()=>{
-                const message = {
-                    type: "connect",
-                    id: connectId,
-                    client: {
-                        instanceId,
-                        clientType
-                    },
-                    timestamp: Date.now()
-                };
-                ws.send(JSON.stringify(message));
-            });
-            ws.addEventListener("message", (event)=>{
-                const msg = JSON.parse(event.data);
-                if ("res" === msg.type && msg.id === connectId && msg.ok) {
-                    clearTimeout(timeout);
-                    resolve(ws);
-                }
-            });
-            ws.addEventListener("error", ()=>{
-                clearTimeout(timeout);
-                reject(new Error("WebSocket error"));
-            });
-        });
-    const waitForMessage = (ws, predicate, timeoutMs = 5000)=>new Promise((resolve, reject)=>{
-            const timeout = setTimeout(()=>reject(new Error("Message timeout")), timeoutMs);
-            const handler = (event)=>{
-                let msg;
-                try {
-                    msg = JSON.parse(event.data);
-                } catch  {
-                    return;
-                }
-                if (!predicate(msg)) return;
-                clearTimeout(timeout);
-                ws.removeEventListener("message", handler);
-                resolve(msg);
-            };
-            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);
-        const health = await response.json();
-        expect(health.status).toBe("healthy");
-    });
-    it("should connect a client", async ()=>new Promise((resolve, reject)=>{
-            const client = new GatewayClient(`ws://localhost:${port}/ws`, "test-client", {
-                events: {
-                    connected: ()=>{
-                        client.disconnect();
-                        resolve();
-                    },
-                    error: (error)=>{
-                        reject(new Error(error.message));
-                    }
-                }
-            });
-            client.connect().catch(reject);
-            setTimeout(()=>reject(new Error("Connection timeout")), 5000);
-        }));
-    it("should register a client and receive node ID", async ()=>new Promise((resolve, reject)=>{
-            const client = new GatewayClient(`ws://localhost:${port}/ws`, "test-client-2", {
-                events: {
-                    registered: (nodeId, name)=>{
-                        expect(nodeId).toBeTruthy();
-                        expect(name).toBe("test-client-2");
-                        client.disconnect();
-                        resolve();
-                    },
-                    error: (error)=>{
-                        reject(new Error(error.message));
-                    }
-                }
-            });
-            client.connect().catch(reject);
-            setTimeout(()=>reject(new Error("Registration timeout")), 5000);
-        }));
-    it("should join a broadcast group", async ()=>new Promise((resolve, reject)=>{
-            const client = new GatewayClient(`ws://localhost:${port}/ws`, "test-client-3", {
-                events: {
-                    registered: async ()=>{
-                        await client.joinGroup("test-group");
-                    },
-                    joinedGroup: (groupId, groupName)=>{
-                        expect(groupName).toBe("test-group");
-                        client.disconnect();
-                        resolve();
-                    },
-                    error: (error)=>{
-                        reject(new Error(error.message));
-                    }
-                }
-            });
-            client.connect().catch(reject);
-            setTimeout(()=>reject(new Error("Join group timeout")), 5000);
-        }));
-    it("should broadcast messages to group members", async ()=>new Promise((resolve, reject)=>{
-            let client1NodeId = null;
-            let broadcastGroupId = null;
-            const client1 = new GatewayClient(`ws://localhost:${port}/ws`, "broadcaster", {
-                events: {
-                    registered: async (nodeId)=>{
-                        client1NodeId = nodeId;
-                        await client1.joinGroup("broadcast-test");
-                    },
-                    joinedGroup: (groupId)=>{
-                        broadcastGroupId = groupId;
-                        client2.connect().catch(reject);
-                    }
-                }
-            });
-            const client2 = new GatewayClient(`ws://localhost:${port}/ws`, "receiver", {
-                events: {
-                    registered: async ()=>{
-                        await client2.joinGroup("broadcast-test");
-                    },
-                    joinedGroup: ()=>{
-                        client1.broadcast(broadcastGroupId || "broadcast-test", {
-                            message: "Hello from client 1"
-                        });
-                    },
-                    broadcast: (message, fromNodeId)=>{
-                        expect(fromNodeId).toBe(client1NodeId);
-                        expect(message.message).toBe("Hello from client 1");
-                        client1.disconnect();
-                        client2.disconnect();
-                        resolve();
-                    },
-                    error: (error)=>{
-                        reject(new Error(error.message));
-                    }
-                }
-            });
-            client1.connect().catch(reject);
-            setTimeout(()=>reject(new Error("Broadcast test timeout")), 10000);
-        }));
-    it("should handle ping/pong", async ()=>new Promise((resolve, reject)=>{
-            const client = new GatewayClient(`ws://localhost:${port}/ws`, "ping-test", {
-                events: {
-                    registered: ()=>{
-                        client.ping();
-                    },
-                    pong: ()=>{
-                        client.disconnect();
-                        resolve();
-                    },
-                    error: (error)=>{
-                        reject(new Error(error.message));
-                    }
-                }
-            });
-            client.connect().catch(reject);
-            setTimeout(()=>reject(new Error("Ping/pong timeout")), 5000);
-        }));
-    it("should stream agent events to session subscribers", async ()=>{
-        const subscriber = await connectClient("session-subscriber");
-        const sessionId = "session-test";
-        subscriber.send(JSON.stringify({
-            type: "session_subscribe",
-            payload: {
-                sessionId
-            },
-            timestamp: Date.now()
-        }));
-        await waitForMessage(subscriber, (msg)=>"ack" === msg.type && msg.payload?.action === "session_subscribe" && msg.payload?.sessionId === sessionId);
-        const eventPromise = waitForMessage(subscriber, (msg)=>"event:agent" === msg.type && "req-session" === msg.id);
-        const sent = server.broadcastSessionEvent(sessionId, {
-            type: "event:agent",
-            id: "req-session",
-            payload: {
-                type: "agent-stream",
-                sessionId,
-                agentId: "main",
-                chunk: {
-                    content: "hello"
-                }
-            },
-            timestamp: Date.now()
-        });
-        expect(sent).toBe(1);
-        const eventMsg = await eventPromise;
-        expect(eventMsg.payload?.sessionId).toBe(sessionId);
-        subscriber.close();
-    });
-    it("should broadcast user messages to session subscribers", async ()=>{
-        const subscriber = await connectClient("session-input-subscriber");
-        const requester = await connectClient("session-input-requester");
-        const sessionId = "session-input-test";
-        subscriber.send(JSON.stringify({
-            type: "session_subscribe",
-            payload: {
-                sessionId
-            },
-            timestamp: Date.now()
-        }));
-        await waitForMessage(subscriber, (msg)=>"ack" === msg.type && msg.payload?.action === "session_subscribe" && msg.payload?.sessionId === sessionId);
-        const eventPromise = waitForMessage(subscriber, (msg)=>"event:agent" === msg.type && msg.payload?.type === "session-message" && msg.payload?.role === "user");
-        requester.send(JSON.stringify({
-            type: "req:agent",
-            id: "req-session-input",
-            payload: {
-                agentId: "main",
-                sessionKey: sessionId,
-                content: "Hello from test"
-            },
-            timestamp: Date.now()
-        }));
-        const eventMsg = await eventPromise;
-        expect(eventMsg.payload?.content).toBe("Hello from test");
-        expect(eventMsg.payload?.sessionId).toBe(sessionId);
-        expect(eventMsg.payload?.agentId).toBe("main");
-        subscriber.close();
-        requester.close();
-    });
-    it("should broadcast user messages to webui clients without session subscribe", async ()=>{
-        const webuiClient = await connectClient("session-webui-listener", "webui");
-        const requester = await connectClient("session-webui-requester");
-        const sessionId = "session-webui-test";
-        const eventPromise = waitForMessage(webuiClient, (msg)=>"event:agent" === msg.type && msg.payload?.type === "session-message" && msg.payload?.role === "user" && msg.payload?.sessionId === sessionId);
-        requester.send(JSON.stringify({
-            type: "req:agent",
-            id: "req-session-webui",
-            payload: {
-                agentId: "main",
-                sessionKey: sessionId,
-                content: "Hello webui"
-            },
-            timestamp: Date.now()
-        }));
-        const eventMsg = await eventPromise;
-        expect(eventMsg.payload?.content).toBe("Hello webui");
-        expect(eventMsg.payload?.agentId).toBe("main");
-        webuiClient.close();
-        requester.close();
-    });
-    it("should broadcast user messages to desktop clients without session subscribe", async ()=>{
-        const desktopClient = await connectClient("session-desktop-listener", "desktop");
-        const requester = await connectClient("session-desktop-requester");
-        const sessionId = "session-desktop-test";
-        const eventPromise = waitForMessage(desktopClient, (msg)=>"event:agent" === msg.type && msg.payload?.type === "session-message" && msg.payload?.role === "user" && msg.payload?.sessionId === sessionId);
-        requester.send(JSON.stringify({
-            type: "req:agent",
-            id: "req-session-desktop",
-            payload: {
-                agentId: "main",
-                sessionKey: sessionId,
-                content: "Hello desktop"
-            },
-            timestamp: Date.now()
-        }));
-        const eventMsg = await eventPromise;
-        expect(eventMsg.payload?.content).toBe("Hello desktop");
-        expect(eventMsg.payload?.agentId).toBe("main");
-        desktopClient.close();
-        requester.close();
-    });
-    it("should emit agent-error to requester when invocation throws without emitting", async ()=>{
-        const requester = await connectClient("session-error-requester");
-        const requestId = "req-invocation-error";
-        const sessionId = "session-error-test";
-        requester.send(JSON.stringify({
-            type: "req:agent",
-            id: requestId,
-            payload: {
-                agentId: "main",
-                sessionKey: sessionId,
-                content: "throw-no-event"
-            },
-            timestamp: Date.now()
-        }));
-        const errorMsg = await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-error");
-        expect(errorMsg.payload?.error).toContain("Synthetic invocation failure");
-        expect(errorMsg.payload?.sessionId).toBe(sessionId);
-        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("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";
-        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("uses request execution workspace/configDir overrides for agent invocation", async ()=>{
-        const requester = await connectClient("session-workspace-override-requester");
-        const requestId = "req-workspace-override";
-        const sessionId = "session-workspace-override";
-        const workspaceOverride = "/tmp/wingman-override-workspace";
-        const configDirOverride = ".wingman-custom";
-        const beforeCount = invokerConstructOptions.length;
-        requester.send(JSON.stringify({
-            type: "req:agent",
-            id: requestId,
-            payload: {
-                agentId: "main",
-                sessionKey: sessionId,
-                content: "workspace override test",
-                execution: {
-                    workspace: workspaceOverride,
-                    configDir: configDirOverride
-                }
-            },
-            timestamp: Date.now()
-        }));
-        await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-complete", 10000);
-        expect(invokerConstructOptions.length).toBeGreaterThan(beforeCount);
-        const lastOptions = invokerConstructOptions.at(-1) || {};
-        expect(lastOptions.workspace).toBe(workspaceOverride);
-        expect(lastOptions.configDir).toBe(configDirOverride);
-        expect(typeof lastOptions.nodeInvoker).toBe("function");
-        requester.close();
-    });
-    it("should cancel an in-flight agent request", async ()=>{
-        const requester = await connectClient("session-cancel-requester");
-        const requestId = "req-cancel-test";
-        requester.send(JSON.stringify({
-            type: "req:agent",
-            id: requestId,
-            payload: {
-                agentId: "main",
-                sessionKey: "session-cancel-test",
-                content: "cancel me"
-            },
-            timestamp: Date.now()
-        }));
-        requester.send(JSON.stringify({
-            type: "req:agent:cancel",
-            id: "cancel-req-cancel-test",
-            payload: {
-                requestId
-            },
-            timestamp: Date.now()
-        }));
-        const ack = await waitForMessage(requester, (msg)=>"ack" === msg.type && msg.payload?.action === "req:agent:cancel" && msg.payload?.requestId === requestId);
-        expect([
-            "cancelled",
-            "not_found"
-        ]).toContain(ack.payload?.status);
-        requester.close();
-    });
-    it("should queue and dequeue requests for the same session", async ()=>{
-        const requester = await connectClient("session-queue-requester");
-        const sessionId = `session-queue-${Date.now()}`;
-        const firstRequestId = `req-queue-first-${Date.now()}`;
-        const secondRequestId = `req-queue-second-${Date.now()}`;
-        const firstCompletePromise = waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === firstRequestId && msg.payload?.type === "agent-complete", 10000);
-        const queuedAckPromise = waitForMessage(requester, (msg)=>"ack" === msg.type && msg.id === secondRequestId && msg.payload?.action === "req:agent" && msg.payload?.status === "queued", 10000);
-        const queuedEventPromise = waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === secondRequestId && msg.payload?.type === "request-queued", 10000);
-        const dequeuedAckPromise = waitForMessage(requester, (msg)=>"ack" === msg.type && msg.id === secondRequestId && msg.payload?.action === "req:agent" && msg.payload?.status === "dequeued", 10000);
-        const secondCompletePromise = waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === secondRequestId && msg.payload?.type === "agent-complete", 10000);
-        requester.send(JSON.stringify({
-            type: "req:agent",
-            id: firstRequestId,
-            payload: {
-                agentId: "main",
-                sessionKey: sessionId,
-                content: "First queued request"
-            },
-            timestamp: Date.now()
-        }));
-        requester.send(JSON.stringify({
-            type: "req:agent",
-            id: secondRequestId,
-            payload: {
-                agentId: "main",
-                sessionKey: sessionId,
-                content: "Second queued request"
-            },
-            timestamp: Date.now()
-        }));
-        const queuedAck = await queuedAckPromise;
-        expect(queuedAck.payload?.position).toBe(1);
-        const queuedEvent = await queuedEventPromise;
-        expect(queuedEvent.payload?.position).toBe(1);
-        expect(queuedEvent.payload?.sessionId).toBe(sessionId);
-        await firstCompletePromise;
-        const dequeuedAck = await dequeuedAckPromise;
-        expect(dequeuedAck.payload?.remaining).toBe(0);
-        await secondCompletePromise;
-        requester.close();
-    });
-    it("should cancel a queued request", async ()=>{
-        const requester = await connectClient("session-cancel-queued-requester");
-        const sessionId = `session-cancel-queued-${Date.now()}`;
-        const firstRequestId = `req-cancel-queued-first-${Date.now()}`;
-        const secondRequestId = `req-cancel-queued-second-${Date.now()}`;
-        const queuedAckPromise = waitForMessage(requester, (msg)=>"ack" === msg.type && msg.id === secondRequestId && msg.payload?.action === "req:agent" && msg.payload?.status === "queued", 10000);
-        requester.send(JSON.stringify({
-            type: "req:agent",
-            id: firstRequestId,
-            payload: {
-                agentId: "main",
-                sessionKey: sessionId,
-                content: "First request"
-            },
-            timestamp: Date.now()
-        }));
-        requester.send(JSON.stringify({
-            type: "req:agent",
-            id: secondRequestId,
-            payload: {
-                agentId: "main",
-                sessionKey: sessionId,
-                content: "Second request"
-            },
-            timestamp: Date.now()
-        }));
-        await queuedAckPromise;
-        requester.send(JSON.stringify({
-            type: "req:agent:cancel",
-            id: `cancel-${secondRequestId}`,
-            payload: {
-                requestId: secondRequestId
-            },
-            timestamp: Date.now()
-        }));
-        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 = [
-            ...queuedRequests.values()
-        ].some((queue)=>queue.some((item)=>item.msg?.id === secondRequestId));
-        expect(isStillQueued).toBe(false);
-        requester.close();
-    });
-    it("should clear session messages via API", async ()=>{
-        const createRes = await fetch(`http://localhost:${port}/api/sessions`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-                name: "Clear Test"
-            })
-        });
-        expect(createRes.ok).toBe(true);
-        const session = await createRes.json();
-        const sessionAgentId = session.agentId || "main";
-        const manager = await server.getSessionManager(sessionAgentId);
-        manager.updateSession(session.id, {
-            messageCount: 3,
-            lastMessagePreview: "Hello"
-        });
-        const clearRes = await fetch(`http://localhost:${port}/api/sessions/${encodeURIComponent(session.id)}/messages?agentId=${encodeURIComponent(sessionAgentId)}`, {
-            method: "DELETE"
-        });
-        expect(clearRes.ok).toBe(true);
-        const cleared = await clearRes.json();
-        expect(cleared.messageCount).toBe(0);
-        const updated = manager.getSession(session.id);
-        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();
-    });
-});