@wingman-ai/gateway 0.5.3 → 0.5.4

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

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

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

@@ -1,377 +0,0 @@
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, 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("refreshes tokens when the codex access token is expiring", async ()=>{
-        const expiringAccessToken = createJwt({
-            exp: Math.floor((Date.now() + 30000) / 1000),
-            client_id: "app_client_123"
-        });
-        const refreshedAccessToken = createJwt({
-            exp: Math.floor((Date.now() + 86400000) / 1000),
-            client_id: "app_client_123"
-        });
-        const staleIdToken = createJwt({
-            aud: [
-                "app_client_123"
-            ],
-            "https://api.openai.com/auth": {
-                chatgpt_account_id: "acct_old"
-            }
-        });
-        const refreshedIdToken = createJwt({
-            aud: [
-                "app_client_123"
-            ],
-            "https://api.openai.com/auth": {
-                chatgpt_account_id: "acct_refreshed"
-            }
-        });
-        writeCodexAuth({
-            tokens: {
-                access_token: expiringAccessToken,
-                refresh_token: "refresh-old",
-                id_token: staleIdToken,
-                account_id: "acct_old"
-            }
-        });
-        const baseFetch = vi.fn(async (input, init)=>{
-            const url = "string" == typeof input ? input : input instanceof URL ? input.toString() : input.url;
-            if ("https://auth.openai.com/oauth/token" === url) {
-                const params = new URLSearchParams(String(init?.body ?? ""));
-                expect(params.get("grant_type")).toBe("refresh_token");
-                expect(params.get("refresh_token")).toBe("refresh-old");
-                expect(params.get("client_id")).toBe("app_client_123");
-                return new Response(JSON.stringify({
-                    access_token: refreshedAccessToken,
-                    refresh_token: "refresh-new",
-                    id_token: refreshedIdToken,
-                    token_type: "bearer",
-                    expires_in: 864000
-                }), {
-                    status: 200,
-                    headers: {
-                        "content-type": "application/json"
-                    }
-                });
-            }
-            expect(url).toBe("https://chatgpt.com/backend-api/codex/responses");
-            const headers = new Headers(init?.headers);
-            expect(headers.get("authorization")).toBe(`Bearer ${refreshedAccessToken}`);
-            expect(headers.get("chatgpt-account-id")).toBe("acct_refreshed");
-            return new Response("{}", {
-                status: 200
-            });
-        });
-        const codexFetch = createCodexFetch({
-            baseFetch
-        });
-        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
-            method: "POST",
-            body: JSON.stringify({
-                model: "codex-mini-latest",
-                input: "hello"
-            })
-        });
-        expect(baseFetch).toHaveBeenCalledTimes(2);
-        const persisted = JSON.parse(readFileSync(getCodexAuthPath(), "utf-8"));
-        expect(persisted.tokens?.access_token).toBe(refreshedAccessToken);
-        expect(persisted.tokens?.refresh_token).toBe("refresh-new");
-        expect(persisted.tokens?.id_token).toBe(refreshedIdToken);
-        expect(persisted.tokens?.account_id).toBe("acct_refreshed");
-        expect(typeof persisted.last_refresh).toBe("string");
-    });
-    it("retries once after auth failure by refreshing codex token", async ()=>{
-        const initialAccessToken = createJwt({
-            exp: Math.floor((Date.now() + 86400000) / 1000),
-            client_id: "app_client_retry"
-        });
-        const refreshedAccessToken = createJwt({
-            exp: Math.floor((Date.now() + 172800000) / 1000),
-            client_id: "app_client_retry"
-        });
-        const idToken = createJwt({
-            aud: [
-                "app_client_retry"
-            ],
-            "https://api.openai.com/auth": {
-                chatgpt_account_id: "acct_retry"
-            }
-        });
-        const refreshedIdToken = createJwt({
-            aud: [
-                "app_client_retry"
-            ],
-            "https://api.openai.com/auth": {
-                chatgpt_account_id: "acct_retry_new"
-            }
-        });
-        writeCodexAuth({
-            tokens: {
-                access_token: initialAccessToken,
-                refresh_token: "refresh-retry",
-                id_token: idToken,
-                account_id: "acct_retry"
-            }
-        });
-        let codexCallCount = 0;
-        const baseFetch = vi.fn(async (input, init)=>{
-            const url = "string" == typeof input ? input : input instanceof URL ? input.toString() : input.url;
-            if ("https://auth.openai.com/oauth/token" === url) {
-                const params = new URLSearchParams(String(init?.body ?? ""));
-                expect(params.get("grant_type")).toBe("refresh_token");
-                expect(params.get("refresh_token")).toBe("refresh-retry");
-                expect(params.get("client_id")).toBe("app_client_retry");
-                return new Response(JSON.stringify({
-                    access_token: refreshedAccessToken,
-                    refresh_token: "refresh-retry-new",
-                    id_token: refreshedIdToken,
-                    token_type: "bearer",
-                    expires_in: 864000
-                }), {
-                    status: 200,
-                    headers: {
-                        "content-type": "application/json"
-                    }
-                });
-            }
-            codexCallCount += 1;
-            const headers = new Headers(init?.headers);
-            if (1 === codexCallCount) {
-                expect(headers.get("authorization")).toBe(`Bearer ${initialAccessToken}`);
-                return new Response("unauthorized", {
-                    status: 401
-                });
-            }
-            expect(codexCallCount).toBe(2);
-            expect(headers.get("authorization")).toBe(`Bearer ${refreshedAccessToken}`);
-            expect(headers.get("chatgpt-account-id")).toBe("acct_retry_new");
-            return new Response("{}", {
-                status: 200
-            });
-        });
-        const codexFetch = createCodexFetch({
-            baseFetch
-        });
-        await codexFetch("https://chatgpt.com/backend-api/codex/responses", {
-            method: "POST",
-            body: JSON.stringify({
-                model: "codex-mini-latest",
-                input: "hello"
-            })
-        });
-        expect(codexCallCount).toBe(2);
-        expect(baseFetch).toHaveBeenCalledTimes(3);
-        const persisted = JSON.parse(readFileSync(getCodexAuthPath(), "utf-8"));
-        expect(persisted.tokens?.access_token).toBe(refreshedAccessToken);
-        expect(persisted.tokens?.refresh_token).toBe("refresh-retry-new");
-        expect(persisted.tokens?.account_id).toBe("acct_retry_new");
-    });
-    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));
-}
-function createJwt(payload) {
-    const header = Buffer.from(JSON.stringify({
-        alg: "HS256",
-        typ: "JWT"
-    })).toString("base64url");
-    const body = Buffer.from(JSON.stringify(payload)).toString("base64url");
-    return `${header}.${body}.signature`;
-}

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

@@ -1,37 +0,0 @@
-"use strict";
-var __webpack_exports__ = {};
-const external_vitest_namespaceObject = require("vitest");
-const jsonSchema_cjs_namespaceObject = require("../cli/config/jsonSchema.cjs");
-(0, external_vitest_namespaceObject.describe)("wingman config json schema", ()=>{
-    (0, external_vitest_namespaceObject.it)("includes metadata and top-level sections", ()=>{
-        const schema = (0, jsonSchema_cjs_namespaceObject.buildWingmanConfigJsonSchema)();
-        (0, external_vitest_namespaceObject.expect)(schema.$schema).toBe("https://json-schema.org/draft/2020-12/schema");
-        (0, external_vitest_namespaceObject.expect)(schema.$id).toBe(jsonSchema_cjs_namespaceObject.WINGMAN_CONFIG_JSON_SCHEMA_ID);
-        (0, external_vitest_namespaceObject.expect)(schema.title).toBe("Wingman Config");
-        (0, external_vitest_namespaceObject.expect)(schema.type).toBe("object");
-        (0, external_vitest_namespaceObject.expect)(schema.properties).toBeDefined();
-        (0, external_vitest_namespaceObject.expect)(schema.properties.gateway).toBeDefined();
-        (0, external_vitest_namespaceObject.expect)(schema.properties.skills).toBeDefined();
-    });
-    (0, external_vitest_namespaceObject.it)("exposes resilient default scanner args", ()=>{
-        const schema = (0, jsonSchema_cjs_namespaceObject.buildWingmanConfigJsonSchema)();
-        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', {
-    value: true
-});

package/dist/tests/config-json-schema.test.d.ts

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

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

@@ -1,31 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { WINGMAN_CONFIG_JSON_SCHEMA_ID, buildWingmanConfigJsonSchema } from "../cli/config/jsonSchema.js";
-describe("wingman config json schema", ()=>{
-    it("includes metadata and top-level sections", ()=>{
-        const schema = buildWingmanConfigJsonSchema();
-        expect(schema.$schema).toBe("https://json-schema.org/draft/2020-12/schema");
-        expect(schema.$id).toBe(WINGMAN_CONFIG_JSON_SCHEMA_ID);
-        expect(schema.title).toBe("Wingman Config");
-        expect(schema.type).toBe("object");
-        expect(schema.properties).toBeDefined();
-        expect(schema.properties.gateway).toBeDefined();
-        expect(schema.properties.skills).toBeDefined();
-    });
-    it("exposes resilient default scanner args", ()=>{
-        const schema = buildWingmanConfigJsonSchema();
-        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/discord-adapter.test.cjs

@@ -1,89 +0,0 @@
-"use strict";
-var __webpack_exports__ = {};
-const external_vitest_namespaceObject = require("vitest");
-const discord_cjs_namespaceObject = require("../gateway/adapters/discord.cjs");
-(0, external_vitest_namespaceObject.describe)("discord adapter helpers", ()=>{
-    (0, external_vitest_namespaceObject.it)("extracts session override when command matches", ()=>{
-        const result = (0, discord_cjs_namespaceObject.extractSessionOverride)("!session agent:main:cli hello", "!session");
-        (0, external_vitest_namespaceObject.expect)(result.matched).toBe(true);
-        (0, external_vitest_namespaceObject.expect)(result.sessionKey).toBe("agent:main:cli");
-        (0, external_vitest_namespaceObject.expect)(result.content).toBe("hello");
-    });
-    (0, external_vitest_namespaceObject.it)("returns no match when command does not match", ()=>{
-        const result = (0, discord_cjs_namespaceObject.extractSessionOverride)("hello there", "!session");
-        (0, external_vitest_namespaceObject.expect)(result.matched).toBe(false);
-        (0, external_vitest_namespaceObject.expect)(result.sessionKey).toBeUndefined();
-        (0, external_vitest_namespaceObject.expect)(result.content).toBe("hello there");
-    });
-    (0, external_vitest_namespaceObject.it)("handles session command without key", ()=>{
-        const result = (0, discord_cjs_namespaceObject.extractSessionOverride)("!session", "!session");
-        (0, external_vitest_namespaceObject.expect)(result.matched).toBe(true);
-        (0, external_vitest_namespaceObject.expect)(result.sessionKey).toBeUndefined();
-        (0, external_vitest_namespaceObject.expect)(result.content).toBe("");
-    });
-    (0, external_vitest_namespaceObject.it)("resolves channel session mapping with thread fallback", ()=>{
-        const map = {
-            123: "session-a",
-            "parent-1": "session-parent"
-        };
-        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.resolveDiscordChannelSessionKey)("123", map)).toBe("session-a");
-        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.resolveDiscordChannelSessionKey)("missing", map, "parent-1")).toBe("session-parent");
-        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.resolveDiscordChannelSessionKey)("missing", map)).toBeUndefined();
-    });
-    (0, external_vitest_namespaceObject.it)("parses agent id from session key", ()=>{
-        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.parseAgentIdFromSessionKey)("agent:main:webui:thread:abc")).toBe("main");
-        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.parseAgentIdFromSessionKey)("agent:stock-trader:discord:channel:1")).toBe("stock-trader");
-        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.parseAgentIdFromSessionKey)("session-plain")).toBeUndefined();
-        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.parseAgentIdFromSessionKey)(void 0)).toBeUndefined();
-    });
-    (0, external_vitest_namespaceObject.it)("strips bot mention variants", ()=>{
-        const content = "<@123> hello <@!123>";
-        (0, external_vitest_namespaceObject.expect)((0, discord_cjs_namespaceObject.stripDiscordBotMention)(content, "123")).toBe("hello");
-    });
-    (0, external_vitest_namespaceObject.it)("splits long responses into chunks", ()=>{
-        const input = "a".repeat(4500);
-        const chunks = (0, discord_cjs_namespaceObject.splitDiscordMessage)(input, 1900);
-        (0, external_vitest_namespaceObject.expect)(chunks.length).toBeGreaterThan(1);
-        for (const chunk of chunks)(0, external_vitest_namespaceObject.expect)(chunk.length).toBeLessThanOrEqual(1900);
-        const rebuilt = chunks.join("");
-        (0, external_vitest_namespaceObject.expect)(rebuilt).toBe(input);
-    });
-    (0, external_vitest_namespaceObject.it)("extracts uiOnly and textFallback from plain object", ()=>{
-        const meta = (0, discord_cjs_namespaceObject.extractUiMeta)({
-            uiOnly: true,
-            textFallback: "Hello"
-        });
-        (0, external_vitest_namespaceObject.expect)(meta).toEqual({
-            uiOnly: true,
-            textFallback: "Hello"
-        });
-    });
-    (0, external_vitest_namespaceObject.it)("extracts uiOnly and textFallback from stringified payload", ()=>{
-        const meta = (0, discord_cjs_namespaceObject.extractUiMeta)(JSON.stringify({
-            uiOnly: true,
-            textFallback: "Fallback"
-        }));
-        (0, external_vitest_namespaceObject.expect)(meta).toEqual({
-            uiOnly: true,
-            textFallback: "Fallback"
-        });
-    });
-    (0, external_vitest_namespaceObject.it)("extracts uiOnly and textFallback from kwargs.content", ()=>{
-        const meta = (0, discord_cjs_namespaceObject.extractUiMeta)({
-            kwargs: {
-                content: JSON.stringify({
-                    uiOnly: true,
-                    textFallback: "OK"
-                })
-            }
-        });
-        (0, external_vitest_namespaceObject.expect)(meta).toEqual({
-            uiOnly: true,
-            textFallback: "OK"
-        });
-    });
-});
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/tests/discord-adapter.test.d.ts

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

package/dist/tests/discord-adapter.test.js

@@ -1,83 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { extractSessionOverride, extractUiMeta, parseAgentIdFromSessionKey, resolveDiscordChannelSessionKey, splitDiscordMessage, stripDiscordBotMention } from "../gateway/adapters/discord.js";
-describe("discord adapter helpers", ()=>{
-    it("extracts session override when command matches", ()=>{
-        const result = extractSessionOverride("!session agent:main:cli hello", "!session");
-        expect(result.matched).toBe(true);
-        expect(result.sessionKey).toBe("agent:main:cli");
-        expect(result.content).toBe("hello");
-    });
-    it("returns no match when command does not match", ()=>{
-        const result = extractSessionOverride("hello there", "!session");
-        expect(result.matched).toBe(false);
-        expect(result.sessionKey).toBeUndefined();
-        expect(result.content).toBe("hello there");
-    });
-    it("handles session command without key", ()=>{
-        const result = extractSessionOverride("!session", "!session");
-        expect(result.matched).toBe(true);
-        expect(result.sessionKey).toBeUndefined();
-        expect(result.content).toBe("");
-    });
-    it("resolves channel session mapping with thread fallback", ()=>{
-        const map = {
-            123: "session-a",
-            "parent-1": "session-parent"
-        };
-        expect(resolveDiscordChannelSessionKey("123", map)).toBe("session-a");
-        expect(resolveDiscordChannelSessionKey("missing", map, "parent-1")).toBe("session-parent");
-        expect(resolveDiscordChannelSessionKey("missing", map)).toBeUndefined();
-    });
-    it("parses agent id from session key", ()=>{
-        expect(parseAgentIdFromSessionKey("agent:main:webui:thread:abc")).toBe("main");
-        expect(parseAgentIdFromSessionKey("agent:stock-trader:discord:channel:1")).toBe("stock-trader");
-        expect(parseAgentIdFromSessionKey("session-plain")).toBeUndefined();
-        expect(parseAgentIdFromSessionKey(void 0)).toBeUndefined();
-    });
-    it("strips bot mention variants", ()=>{
-        const content = "<@123> hello <@!123>";
-        expect(stripDiscordBotMention(content, "123")).toBe("hello");
-    });
-    it("splits long responses into chunks", ()=>{
-        const input = "a".repeat(4500);
-        const chunks = splitDiscordMessage(input, 1900);
-        expect(chunks.length).toBeGreaterThan(1);
-        for (const chunk of chunks)expect(chunk.length).toBeLessThanOrEqual(1900);
-        const rebuilt = chunks.join("");
-        expect(rebuilt).toBe(input);
-    });
-    it("extracts uiOnly and textFallback from plain object", ()=>{
-        const meta = extractUiMeta({
-            uiOnly: true,
-            textFallback: "Hello"
-        });
-        expect(meta).toEqual({
-            uiOnly: true,
-            textFallback: "Hello"
-        });
-    });
-    it("extracts uiOnly and textFallback from stringified payload", ()=>{
-        const meta = extractUiMeta(JSON.stringify({
-            uiOnly: true,
-            textFallback: "Fallback"
-        }));
-        expect(meta).toEqual({
-            uiOnly: true,
-            textFallback: "Fallback"
-        });
-    });
-    it("extracts uiOnly and textFallback from kwargs.content", ()=>{
-        const meta = extractUiMeta({
-            kwargs: {
-                content: JSON.stringify({
-                    uiOnly: true,
-                    textFallback: "OK"
-                })
-            }
-        });
-        expect(meta).toEqual({
-            uiOnly: true,
-            textFallback: "OK"
-        });
-    });
-});