@wingman-ai/gateway 0.2.2 → 0.2.3

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

@@ -0,0 +1,180 @@
+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("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);
@@ -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",

package/dist/tests/gateway.test.js

@@ -14,7 +14,8 @@ const isBun = void 0 !== globalThis.Bun;
 const describeIfBun = isBun ? describe : describe.skip;
 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);
@@ -331,6 +332,26 @@ describeIfBun("Gateway", ()=>{
         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 cancel an in-flight agent request", async ()=>{
         const requester = await connectClient("session-cancel-requester");
         const requestId = "req-cancel-test";
@@ -359,6 +380,92 @@ describeIfBun("Gateway", ()=>{
         ]).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");
+        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",

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

@@ -0,0 +1,57 @@
+"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 provider_cjs_namespaceObject = require("../cli/commands/provider.cjs");
+const codex_cjs_namespaceObject = require("../providers/codex.cjs");
+(0, external_vitest_namespaceObject.describe)("provider command codex login", ()=>{
+    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-provider-codex-"));
+        process.env.CODEX_HOME = codexHome;
+    });
+    (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)("uses existing codex login without requiring a token", async ()=>{
+        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({
+            tokens: {
+                access_token: "codex-access-token",
+                account_id: "acct_123"
+            }
+        }, null, 2));
+        const exitSpy = external_vitest_namespaceObject.vi.spyOn(process, "exit").mockImplementation((code)=>{
+            throw new Error(`process.exit(${code ?? "undefined"})`);
+        });
+        try {
+            await (0, external_vitest_namespaceObject.expect)((0, provider_cjs_namespaceObject.executeProviderCommand)({
+                subcommand: "login",
+                args: [
+                    "codex"
+                ],
+                verbosity: "silent",
+                outputMode: "json",
+                options: {}
+            })).resolves.toBeUndefined();
+            (0, external_vitest_namespaceObject.expect)(exitSpy).not.toHaveBeenCalled();
+        } finally{
+            exitSpy.mockRestore();
+        }
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

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

@@ -0,0 +1,51 @@
+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 { executeProviderCommand } from "../cli/commands/provider.js";
+import { getCodexAuthPath } from "../providers/codex.js";
+describe("provider command codex login", ()=>{
+    let codexHome;
+    const originalCodexHome = process.env.CODEX_HOME;
+    beforeEach(()=>{
+        codexHome = mkdtempSync(join(tmpdir(), "wingman-provider-codex-"));
+        process.env.CODEX_HOME = codexHome;
+    });
+    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("uses existing codex login without requiring a token", async ()=>{
+        const authPath = getCodexAuthPath();
+        mkdirSync(dirname(authPath), {
+            recursive: true
+        });
+        writeFileSync(authPath, JSON.stringify({
+            tokens: {
+                access_token: "codex-access-token",
+                account_id: "acct_123"
+            }
+        }, null, 2));
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation((code)=>{
+            throw new Error(`process.exit(${code ?? "undefined"})`);
+        });
+        try {
+            await expect(executeProviderCommand({
+                subcommand: "login",
+                args: [
+                    "codex"
+                ],
+                verbosity: "silent",
+                outputMode: "json",
+                options: {}
+            })).resolves.toBeUndefined();
+            expect(exitSpy).not.toHaveBeenCalled();
+        } finally{
+            exitSpy.mockRestore();
+        }
+    });
+});

package/dist/tests/sessionStateMessages.test.cjs

@@ -65,6 +65,44 @@ const sessionManager_cjs_namespaceObject = require("../cli/core/sessionManager.c
             content: "keep"
         });
     });
+    (0, external_vitest_namespaceObject.it)("extracts content from responses-style text blocks", ()=>{
+        const state = {
+            createdAt: 2000,
+            values: {
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "input_text",
+                                text: "Build a plan"
+                            }
+                        ]
+                    },
+                    {
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "output_text",
+                                text: "Here is the plan."
+                            }
+                        ]
+                    }
+                ]
+            }
+        };
+        const result = (0, sessionManager_cjs_namespaceObject.extractMessagesFromState)(state);
+        (0, external_vitest_namespaceObject.expect)(result).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(result).toHaveLength(2);
+        (0, external_vitest_namespaceObject.expect)(result?.[0]).toMatchObject({
+            role: "user",
+            content: "Build a plan"
+        });
+        (0, external_vitest_namespaceObject.expect)(result?.[1]).toMatchObject({
+            role: "assistant",
+            content: "Here is the plan."
+        });
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/tests/sessionStateMessages.test.js

@@ -63,4 +63,42 @@ describe("extractMessagesFromState", ()=>{
             content: "keep"
         });
     });
+    it("extracts content from responses-style text blocks", ()=>{
+        const state = {
+            createdAt: 2000,
+            values: {
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "input_text",
+                                text: "Build a plan"
+                            }
+                        ]
+                    },
+                    {
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "output_text",
+                                text: "Here is the plan."
+                            }
+                        ]
+                    }
+                ]
+            }
+        };
+        const result = extractMessagesFromState(state);
+        expect(result).not.toBeNull();
+        expect(result).toHaveLength(2);
+        expect(result?.[0]).toMatchObject({
+            role: "user",
+            content: "Build a plan"
+        });
+        expect(result?.[1]).toMatchObject({
+            role: "assistant",
+            content: "Here is the plan."
+        });
+    });
 });