@wingman-ai/gateway 0.2.2 → 0.2.4

package/dist/tests/codex-provider.test.cjs

@@ -0,0 +1,210 @@
+"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 codex_cjs_namespaceObject = require("../providers/codex.cjs");
+(0, external_vitest_namespaceObject.describe)("codex provider", ()=>{
+    let codexHome;
+    const originalCodexHome = process.env.CODEX_HOME;
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        codexHome = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-codex-"));
+        process.env.CODEX_HOME = codexHome;
+        delete process.env.CODEX_ACCESS_TOKEN;
+        delete process.env.CHATGPT_ACCESS_TOKEN;
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        if (void 0 === originalCodexHome) delete process.env.CODEX_HOME;
+        else process.env.CODEX_HOME = originalCodexHome;
+        if ((0, external_node_fs_namespaceObject.existsSync)(codexHome)) (0, external_node_fs_namespaceObject.rmSync)(codexHome, {
+            recursive: true,
+            force: true
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("reads access token and account id from codex auth file", ()=>{
+        writeCodexAuth({
+            tokens: {
+                access_token: "codex-access-token",
+                account_id: "acct_123"
+            }
+        });
+        const resolved = (0, codex_cjs_namespaceObject.resolveCodexAuthFromFile)();
+        (0, external_vitest_namespaceObject.expect)(resolved.accessToken).toBe("codex-access-token");
+        (0, external_vitest_namespaceObject.expect)(resolved.accountId).toBe("acct_123");
+        (0, external_vitest_namespaceObject.expect)(resolved.authPath).toBe((0, external_node_path_namespaceObject.join)(codexHome, "auth.json"));
+    });
+    (0, external_vitest_namespaceObject.it)("applies codex auth headers and forces store=false", async ()=>{
+        writeCodexAuth({
+            tokens: {
+                access_token: "file-token",
+                account_id: "acct_file"
+            }
+        });
+        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
+            baseFetch
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            headers: {
+                "x-api-key": "placeholder"
+            },
+            body: JSON.stringify({
+                model: "codex-mini-latest",
+                input: "hello",
+                temperature: 1
+            })
+        });
+        (0, external_vitest_namespaceObject.expect)(baseFetch).toHaveBeenCalledTimes(1);
+        const requestInit = baseFetch.mock.calls[0]?.[1];
+        (0, external_vitest_namespaceObject.expect)(requestInit).toBeDefined();
+        const headers = new Headers(requestInit?.headers);
+        const payload = JSON.parse(String(requestInit?.body));
+        (0, external_vitest_namespaceObject.expect)(headers.get("authorization")).toBe("Bearer file-token");
+        (0, external_vitest_namespaceObject.expect)(headers.get("chatgpt-account-id")).toBe("acct_file");
+        (0, external_vitest_namespaceObject.expect)(headers.get("x-api-key")).toBeNull();
+        (0, external_vitest_namespaceObject.expect)(payload.store).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(payload.temperature).toBeUndefined();
+        (0, external_vitest_namespaceObject.expect)(typeof payload.instructions).toBe("string");
+        (0, external_vitest_namespaceObject.expect)(payload.instructions.length).toBeGreaterThan(0);
+    });
+    (0, external_vitest_namespaceObject.it)("derives instructions from system/developer input when missing", async ()=>{
+        writeCodexAuth({
+            tokens: {
+                access_token: "file-token"
+            }
+        });
+        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
+            baseFetch
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "gpt-5.3-codex",
+                input: [
+                    {
+                        role: "developer",
+                        content: [
+                            {
+                                type: "input_text",
+                                text: "Always run tests first."
+                            }
+                        ]
+                    },
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "input_text",
+                                text: "Fix the bug."
+                            }
+                        ]
+                    }
+                ]
+            })
+        });
+        const requestInit = baseFetch.mock.calls[0]?.[1];
+        const payload = JSON.parse(String(requestInit?.body));
+        (0, external_vitest_namespaceObject.expect)(payload.instructions).toBe("Always run tests first.");
+    });
+    (0, external_vitest_namespaceObject.it)("preserves explicit instructions when provided", async ()=>{
+        writeCodexAuth({
+            tokens: {
+                access_token: "file-token"
+            }
+        });
+        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
+            baseFetch
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "gpt-5.3-codex",
+                instructions: "Use concise answers.",
+                input: "hello"
+            })
+        });
+        const requestInit = baseFetch.mock.calls[0]?.[1];
+        const payload = JSON.parse(String(requestInit?.body));
+        (0, external_vitest_namespaceObject.expect)(payload.instructions).toBe("Use concise answers.");
+    });
+    (0, external_vitest_namespaceObject.it)("overrides explicit store values to false when provided", async ()=>{
+        writeCodexAuth({
+            tokens: {
+                access_token: "file-token"
+            }
+        });
+        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
+            baseFetch
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "gpt-5.3-codex",
+                store: true,
+                input: "hello"
+            })
+        });
+        const requestInit = baseFetch.mock.calls[0]?.[1];
+        const payload = JSON.parse(String(requestInit?.body));
+        (0, external_vitest_namespaceObject.expect)(payload.store).toBe(false);
+    });
+    (0, external_vitest_namespaceObject.it)("uses fallback token when codex auth file is unavailable", async ()=>{
+        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
+            baseFetch,
+            fallbackToken: "fallback-token"
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "codex-mini-latest",
+                input: "hello"
+            })
+        });
+        const requestInit = baseFetch.mock.calls[0]?.[1];
+        (0, external_vitest_namespaceObject.expect)(requestInit).toBeDefined();
+        const headers = new Headers(requestInit?.headers);
+        (0, external_vitest_namespaceObject.expect)(headers.get("authorization")).toBe("Bearer fallback-token");
+    });
+    (0, external_vitest_namespaceObject.it)("throws when no codex token is available", async ()=>{
+        const baseFetch = external_vitest_namespaceObject.vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = (0, codex_cjs_namespaceObject.createCodexFetch)({
+            baseFetch
+        });
+        await (0, external_vitest_namespaceObject.expect)(codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "codex-mini-latest",
+                input: "hello"
+            })
+        })).rejects.toThrow(/Codex credentials missing/);
+    });
+});
+function writeCodexAuth(payload) {
+    const authPath = (0, codex_cjs_namespaceObject.getCodexAuthPath)();
+    (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(authPath), {
+        recursive: true
+    });
+    (0, external_node_fs_namespaceObject.writeFileSync)(authPath, JSON.stringify(payload, null, 2));
+}
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/codex-provider.test.d.ts

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

package/dist/tests/codex-provider.test.js

@@ -0,0 +1,204 @@
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createCodexFetch, getCodexAuthPath, resolveCodexAuthFromFile } from "../providers/codex.js";
+describe("codex provider", ()=>{
+    let codexHome;
+    const originalCodexHome = process.env.CODEX_HOME;
+    beforeEach(()=>{
+        codexHome = mkdtempSync(join(tmpdir(), "wingman-codex-"));
+        process.env.CODEX_HOME = codexHome;
+        delete process.env.CODEX_ACCESS_TOKEN;
+        delete process.env.CHATGPT_ACCESS_TOKEN;
+    });
+    afterEach(()=>{
+        if (void 0 === originalCodexHome) delete process.env.CODEX_HOME;
+        else process.env.CODEX_HOME = originalCodexHome;
+        if (existsSync(codexHome)) rmSync(codexHome, {
+            recursive: true,
+            force: true
+        });
+    });
+    it("reads access token and account id from codex auth file", ()=>{
+        writeCodexAuth({
+            tokens: {
+                access_token: "codex-access-token",
+                account_id: "acct_123"
+            }
+        });
+        const resolved = resolveCodexAuthFromFile();
+        expect(resolved.accessToken).toBe("codex-access-token");
+        expect(resolved.accountId).toBe("acct_123");
+        expect(resolved.authPath).toBe(join(codexHome, "auth.json"));
+    });
+    it("applies codex auth headers and forces store=false", async ()=>{
+        writeCodexAuth({
+            tokens: {
+                access_token: "file-token",
+                account_id: "acct_file"
+            }
+        });
+        const baseFetch = vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = createCodexFetch({
+            baseFetch
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            headers: {
+                "x-api-key": "placeholder"
+            },
+            body: JSON.stringify({
+                model: "codex-mini-latest",
+                input: "hello",
+                temperature: 1
+            })
+        });
+        expect(baseFetch).toHaveBeenCalledTimes(1);
+        const requestInit = baseFetch.mock.calls[0]?.[1];
+        expect(requestInit).toBeDefined();
+        const headers = new Headers(requestInit?.headers);
+        const payload = JSON.parse(String(requestInit?.body));
+        expect(headers.get("authorization")).toBe("Bearer file-token");
+        expect(headers.get("chatgpt-account-id")).toBe("acct_file");
+        expect(headers.get("x-api-key")).toBeNull();
+        expect(payload.store).toBe(false);
+        expect(payload.temperature).toBeUndefined();
+        expect(typeof payload.instructions).toBe("string");
+        expect(payload.instructions.length).toBeGreaterThan(0);
+    });
+    it("derives instructions from system/developer input when missing", async ()=>{
+        writeCodexAuth({
+            tokens: {
+                access_token: "file-token"
+            }
+        });
+        const baseFetch = vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = createCodexFetch({
+            baseFetch
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "gpt-5.3-codex",
+                input: [
+                    {
+                        role: "developer",
+                        content: [
+                            {
+                                type: "input_text",
+                                text: "Always run tests first."
+                            }
+                        ]
+                    },
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "input_text",
+                                text: "Fix the bug."
+                            }
+                        ]
+                    }
+                ]
+            })
+        });
+        const requestInit = baseFetch.mock.calls[0]?.[1];
+        const payload = JSON.parse(String(requestInit?.body));
+        expect(payload.instructions).toBe("Always run tests first.");
+    });
+    it("preserves explicit instructions when provided", async ()=>{
+        writeCodexAuth({
+            tokens: {
+                access_token: "file-token"
+            }
+        });
+        const baseFetch = vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = createCodexFetch({
+            baseFetch
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "gpt-5.3-codex",
+                instructions: "Use concise answers.",
+                input: "hello"
+            })
+        });
+        const requestInit = baseFetch.mock.calls[0]?.[1];
+        const payload = JSON.parse(String(requestInit?.body));
+        expect(payload.instructions).toBe("Use concise answers.");
+    });
+    it("overrides explicit store values to false when provided", async ()=>{
+        writeCodexAuth({
+            tokens: {
+                access_token: "file-token"
+            }
+        });
+        const baseFetch = vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = createCodexFetch({
+            baseFetch
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "gpt-5.3-codex",
+                store: true,
+                input: "hello"
+            })
+        });
+        const requestInit = baseFetch.mock.calls[0]?.[1];
+        const payload = JSON.parse(String(requestInit?.body));
+        expect(payload.store).toBe(false);
+    });
+    it("uses fallback token when codex auth file is unavailable", async ()=>{
+        const baseFetch = vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = createCodexFetch({
+            baseFetch,
+            fallbackToken: "fallback-token"
+        });
+        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "codex-mini-latest",
+                input: "hello"
+            })
+        });
+        const requestInit = baseFetch.mock.calls[0]?.[1];
+        expect(requestInit).toBeDefined();
+        const headers = new Headers(requestInit?.headers);
+        expect(headers.get("authorization")).toBe("Bearer fallback-token");
+    });
+    it("throws when no codex token is available", async ()=>{
+        const baseFetch = vi.fn(async (_input, _init)=>new Response("{}", {
+                status: 200
+            }));
+        const codexFetch = createCodexFetch({
+            baseFetch
+        });
+        await expect(codexFetch("https://chatgpt.com/backend-api/codex/responses", {
+            method: "POST",
+            body: JSON.stringify({
+                model: "codex-mini-latest",
+                input: "hello"
+            })
+        })).rejects.toThrow(/Codex credentials missing/);
+    });
+});
+function writeCodexAuth(payload) {
+    const authPath = getCodexAuthPath();
+    mkdirSync(dirname(authPath), {
+        recursive: true
+    });
+    writeFileSync(authPath, JSON.stringify(payload, null, 2));
+}

package/dist/tests/gateway.test.cjs

@@ -16,7 +16,8 @@ const isBun = void 0 !== globalThis.Bun;
 const describeIfBun = isBun ? external_vitest_namespaceObject.describe : external_vitest_namespaceObject.describe.skip;
 external_vitest_namespaceObject.vi.mock("@/cli/core/agentInvoker.js", ()=>({
         AgentInvoker: class {
-            async invokeAgent(_agentId, _content, _sessionId, _attachments, options) {
+            async invokeAgent(_agentId, content, _sessionId, _attachments, options) {
+                if ("throw-no-event" === content) throw new Error("Synthetic invocation failure");
                 const signal = options?.signal;
                 await new Promise((resolve)=>{
                     const timer = setTimeout(resolve, 75);
@@ -175,14 +176,15 @@ describeIfBun("Gateway", ()=>{
         }));
     (0, external_vitest_namespaceObject.it)("should broadcast messages to group members", async ()=>new Promise((resolve, reject)=>{
             let client1NodeId = null;
-            let messagesReceived = 0;
+            let broadcastGroupId = null;
             const client1 = new index_cjs_namespaceObject.GatewayClient(`ws://localhost:${port}/ws`, "broadcaster", {
                 events: {
                     registered: async (nodeId)=>{
                         client1NodeId = nodeId;
                         await client1.joinGroup("broadcast-test");
                     },
-                    joinedGroup: ()=>{
+                    joinedGroup: (groupId)=>{
+                        broadcastGroupId = groupId;
                         client2.connect().catch(reject);
                     }
                 }
@@ -193,14 +195,13 @@ describeIfBun("Gateway", ()=>{
                         await client2.joinGroup("broadcast-test");
                     },
                     joinedGroup: ()=>{
-                        client1.broadcast("broadcast-test", {
+                        client1.broadcast(broadcastGroupId || "broadcast-test", {
                             message: "Hello from client 1"
                         });
                     },
                     broadcast: (message, fromNodeId)=>{
                         (0, external_vitest_namespaceObject.expect)(fromNodeId).toBe(client1NodeId);
                         (0, external_vitest_namespaceObject.expect)(message.message).toBe("Hello from client 1");
-                        messagesReceived++;
                         client1.disconnect();
                         client2.disconnect();
                         resolve();
@@ -333,6 +334,26 @@ describeIfBun("Gateway", ()=>{
         desktopClient.close();
         requester.close();
     });
+    (0, external_vitest_namespaceObject.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");
+        (0, external_vitest_namespaceObject.expect)(errorMsg.payload?.error).toContain("Synthetic invocation failure");
+        (0, external_vitest_namespaceObject.expect)(errorMsg.payload?.sessionId).toBe(sessionId);
+        (0, external_vitest_namespaceObject.expect)(errorMsg.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";
@@ -361,6 +382,92 @@ describeIfBun("Gateway", ()=>{
         ]).toContain(ack.payload?.status);
         requester.close();
     });
+    (0, external_vitest_namespaceObject.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;
+        (0, external_vitest_namespaceObject.expect)(queuedAck.payload?.position).toBe(1);
+        const queuedEvent = await queuedEventPromise;
+        (0, external_vitest_namespaceObject.expect)(queuedEvent.payload?.position).toBe(1);
+        (0, external_vitest_namespaceObject.expect)(queuedEvent.payload?.sessionId).toBe(sessionId);
+        await firstCompletePromise;
+        const dequeuedAck = await dequeuedAckPromise;
+        (0, external_vitest_namespaceObject.expect)(dequeuedAck.payload?.remaining).toBe(0);
+        await secondCompletePromise;
+        requester.close();
+    });
+    (0, external_vitest_namespaceObject.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);
+        (0, external_vitest_namespaceObject.expect)(cancelAck.payload?.status).toBe("cancelled_queued");
+        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));
+        (0, external_vitest_namespaceObject.expect)(isStillQueued).toBe(false);
+        requester.close();
+    });
     (0, external_vitest_namespaceObject.it)("should clear session messages via API", async ()=>{
         const createRes = await fetch(`http://localhost:${port}/api/sessions`, {
             method: "POST",
@@ -368,18 +475,18 @@ describeIfBun("Gateway", ()=>{
                 "Content-Type": "application/json"
             },
             body: JSON.stringify({
-                agentId: "main",
                 name: "Clear Test"
             })
         });
         (0, external_vitest_namespaceObject.expect)(createRes.ok).toBe(true);
         const session = await createRes.json();
-        const manager = await server.getSessionManager("main");
+        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=main`, {
+        const clearRes = await fetch(`http://localhost:${port}/api/sessions/${encodeURIComponent(session.id)}/messages?agentId=${encodeURIComponent(sessionAgentId)}`, {
             method: "DELETE"
         });
         (0, external_vitest_namespaceObject.expect)(clearRes.ok).toBe(true);