@wingman-ai/gateway 0.4.2 → 0.4.3

package/dist/tests/sms-api.test.js

@@ -0,0 +1,177 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { createSmsPolicyStateStore, handleSmsApi } from "../gateway/http/sms.js";
+const requireTempDir = (value)=>{
+    if (!value) throw new Error("temp dir not initialized");
+    return value;
+};
+describe("sms policy api", ()=>{
+    let tempDir = null;
+    afterEach(()=>{
+        if (!tempDir) return;
+        rmSync(tempDir, {
+            recursive: true,
+            force: true
+        });
+        tempDir = null;
+    });
+    it("updates, fetches, and resets policy records", async ()=>{
+        tempDir = mkdtempSync(join(tmpdir(), "wingman-sms-api-"));
+        const store = createSmsPolicyStateStore(()=>requireTempDir(tempDir));
+        const target = encodeURIComponent("sms-macos:+15555550000");
+        const ctx = {};
+        const updateReq = new Request(`http://localhost/api/sms/policies/${target}`, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                stopEnabled: true,
+                pauseForMs: 120000,
+                alertMode: "all"
+            })
+        });
+        const updateRes = await handleSmsApi(ctx, store, updateReq, new URL(updateReq.url));
+        expect(updateRes?.status).toBe(200);
+        const updated = await updateRes?.json();
+        expect(updated.paused).toBe(true);
+        expect(updated.pausedUntil).toBeTypeOf("number");
+        expect(updated.stopEnabled).toBe(true);
+        expect(updated.alertMode).toBe("all");
+        const getRes = await handleSmsApi(ctx, store, new Request(`http://localhost/api/sms/policies/${target}`, {
+            method: "GET"
+        }), new URL(`http://localhost/api/sms/policies/${target}`));
+        expect(getRes?.status).toBe(200);
+        const listRes = await handleSmsApi(ctx, store, new Request("http://localhost/api/sms/policies", {
+            method: "GET"
+        }), new URL("http://localhost/api/sms/policies"));
+        expect(listRes?.status).toBe(200);
+        const listPayload = await listRes?.json();
+        expect(listPayload.policies).toHaveLength(1);
+        const deleteRes = await handleSmsApi(ctx, store, new Request(`http://localhost/api/sms/policies/${target}`, {
+            method: "DELETE"
+        }), new URL(`http://localhost/api/sms/policies/${target}`));
+        expect(deleteRes?.status).toBe(200);
+        const reset = await deleteRes?.json();
+        expect(reset.paused).toBe(false);
+        expect(reset.stopEnabled).toBe(false);
+    });
+    it("applies control commands and leaves non-commands as pass-through text", async ()=>{
+        tempDir = mkdtempSync(join(tmpdir(), "wingman-sms-api-"));
+        const store = createSmsPolicyStateStore(()=>requireTempDir(tempDir));
+        const target = encodeURIComponent("sms-macos:+15555550000");
+        const ctx = {
+            router: {
+                selectAgent: ()=>"main",
+                buildSessionKey: ()=>"agent:main:sms-macos:dm:+15555550000"
+            }
+        };
+        const pauseReq = new Request(`http://localhost/api/sms/policies/${target}/command`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                text: "PAUSE 2h",
+                nowMs: 10000
+            })
+        });
+        const pauseRes = await handleSmsApi(ctx, store, pauseReq, new URL(pauseReq.url));
+        expect(pauseRes?.status).toBe(200);
+        const pausedPayload = await pauseRes?.json();
+        expect(pausedPayload.handled).toBe(true);
+        expect(pausedPayload.command?.name).toBe("pause");
+        expect(pausedPayload.policy.paused).toBe(true);
+        const textReq = new Request(`http://localhost/api/sms/policies/${target}/command`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                text: "deploy this now"
+            })
+        });
+        const textRes = await handleSmsApi(ctx, store, textReq, new URL(textReq.url));
+        expect(textRes?.status).toBe(200);
+        const textPayload = await textRes?.json();
+        expect(textPayload.handled).toBe(false);
+        expect(textPayload.passThroughText).toBe("deploy this now");
+    });
+    it("normalizes inbound messages into command, stopped, or agent results", async ()=>{
+        tempDir = mkdtempSync(join(tmpdir(), "wingman-sms-api-"));
+        const store = createSmsPolicyStateStore(()=>requireTempDir(tempDir));
+        const ctx = {
+            router: {
+                selectAgent: ()=>"main",
+                buildSessionKey: ()=>"agent:main:sms-macos:dm:+15555550000"
+            }
+        };
+        const commandReq = new Request("http://localhost/api/sms/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                target: "sms-macos:+15555550000",
+                text: "HELP"
+            })
+        });
+        const commandRes = await handleSmsApi(ctx, store, commandReq, new URL(commandReq.url));
+        expect(commandRes?.status).toBe(200);
+        const commandPayload = await commandRes?.json();
+        expect(commandPayload.kind).toBe("command");
+        expect(commandPayload.handled).toBe(true);
+        const stopReq = new Request("http://localhost/api/sms/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                target: "sms-macos:+15555550000",
+                text: "STOP"
+            })
+        });
+        const stopRes = await handleSmsApi(ctx, store, stopReq, new URL(stopReq.url));
+        expect(stopRes?.status).toBe(200);
+        const blockedReq = new Request("http://localhost/api/sms/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                target: "sms-macos:+15555550000",
+                text: "summarize my build failures"
+            })
+        });
+        const blockedRes = await handleSmsApi(ctx, store, blockedReq, new URL(blockedReq.url));
+        expect(blockedRes?.status).toBe(200);
+        const blockedPayload = await blockedRes?.json();
+        expect(blockedPayload.kind).toBe("stopped");
+        expect(blockedPayload.responseText).toContain("stopped");
+        store.upsert("sms-macos:+15555550000", {
+            stopEnabled: false
+        });
+        const agentReq = new Request("http://localhost/api/sms/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                target: "sms-macos:+15555550000",
+                text: "summarize my build failures",
+                queueIfBusy: true
+            })
+        });
+        const agentRes = await handleSmsApi(ctx, store, agentReq, new URL(agentReq.url));
+        expect(agentRes?.status).toBe(200);
+        const agentPayload = await agentRes?.json();
+        expect(agentPayload.kind).toBe("agent");
+        expect(agentPayload.request.agentId).toBe("main");
+        expect(agentPayload.request.content).toBe("summarize my build failures");
+        expect(agentPayload.request.sessionKey).toBe("agent:main:sms-macos:dm:+15555550000");
+        expect(agentPayload.request.routing?.channel).toBe("sms-macos");
+        expect(agentPayload.request.queueIfBusy).toBe(true);
+    });
+});

package/dist/tests/sms-commands.test.cjs

@@ -0,0 +1,90 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const commands_cjs_namespaceObject = require("../gateway/sms/commands.cjs");
+(0, external_vitest_namespaceObject.describe)("sms commands", ()=>{
+    (0, external_vitest_namespaceObject.it)("parses reserved commands as control commands", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, commands_cjs_namespaceObject.interpretSmsInboundMessage)("help")).toEqual({
+            type: "command",
+            command: {
+                name: "help"
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)((0, commands_cjs_namespaceObject.interpretSmsInboundMessage)("STATUS")).toEqual({
+            type: "command",
+            command: {
+                name: "status"
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)((0, commands_cjs_namespaceObject.interpretSmsInboundMessage)("resume")).toEqual({
+            type: "command",
+            command: {
+                name: "resume"
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)((0, commands_cjs_namespaceObject.interpretSmsInboundMessage)("STOP")).toEqual({
+            type: "command",
+            command: {
+                name: "stop"
+            }
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("parses pause commands with optional durations", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, commands_cjs_namespaceObject.interpretSmsInboundMessage)("pause")).toEqual({
+            type: "command",
+            command: {
+                name: "pause",
+                durationMs: null
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)((0, commands_cjs_namespaceObject.interpretSmsInboundMessage)("pause 15m")).toEqual({
+            type: "command",
+            command: {
+                name: "pause",
+                durationMs: 900000
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)((0, commands_cjs_namespaceObject.interpretSmsInboundMessage)("PAUSE 2 H")).toEqual({
+            type: "command",
+            command: {
+                name: "pause",
+                durationMs: 7200000
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)((0, commands_cjs_namespaceObject.interpretSmsInboundMessage)("pause 1d")).toEqual({
+            type: "command",
+            command: {
+                name: "pause",
+                durationMs: 86400000
+            }
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("treats invalid command forms as plain text", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, commands_cjs_namespaceObject.interpretSmsInboundMessage)("pause tomorrow")).toEqual({
+            type: "text",
+            content: "pause tomorrow"
+        });
+        (0, external_vitest_namespaceObject.expect)((0, commands_cjs_namespaceObject.interpretSmsInboundMessage)("pause 0m")).toEqual({
+            type: "text",
+            content: "pause 0m"
+        });
+        (0, external_vitest_namespaceObject.expect)((0, commands_cjs_namespaceObject.interpretSmsInboundMessage)("help me with deploy")).toEqual({
+            type: "text",
+            content: "help me with deploy"
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("supports escaping reserved command words", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, commands_cjs_namespaceObject.interpretSmsInboundMessage)("\\pause")).toEqual({
+            type: "text",
+            content: "pause"
+        });
+        (0, external_vitest_namespaceObject.expect)((0, commands_cjs_namespaceObject.interpretSmsInboundMessage)("\\STATUS")).toEqual({
+            type: "text",
+            content: "STATUS"
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/sms-commands.test.d.ts

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

package/dist/tests/sms-commands.test.js

@@ -0,0 +1,84 @@
+import { describe, expect, it } from "vitest";
+import { interpretSmsInboundMessage } from "../gateway/sms/commands.js";
+describe("sms commands", ()=>{
+    it("parses reserved commands as control commands", ()=>{
+        expect(interpretSmsInboundMessage("help")).toEqual({
+            type: "command",
+            command: {
+                name: "help"
+            }
+        });
+        expect(interpretSmsInboundMessage("STATUS")).toEqual({
+            type: "command",
+            command: {
+                name: "status"
+            }
+        });
+        expect(interpretSmsInboundMessage("resume")).toEqual({
+            type: "command",
+            command: {
+                name: "resume"
+            }
+        });
+        expect(interpretSmsInboundMessage("STOP")).toEqual({
+            type: "command",
+            command: {
+                name: "stop"
+            }
+        });
+    });
+    it("parses pause commands with optional durations", ()=>{
+        expect(interpretSmsInboundMessage("pause")).toEqual({
+            type: "command",
+            command: {
+                name: "pause",
+                durationMs: null
+            }
+        });
+        expect(interpretSmsInboundMessage("pause 15m")).toEqual({
+            type: "command",
+            command: {
+                name: "pause",
+                durationMs: 900000
+            }
+        });
+        expect(interpretSmsInboundMessage("PAUSE 2 H")).toEqual({
+            type: "command",
+            command: {
+                name: "pause",
+                durationMs: 7200000
+            }
+        });
+        expect(interpretSmsInboundMessage("pause 1d")).toEqual({
+            type: "command",
+            command: {
+                name: "pause",
+                durationMs: 86400000
+            }
+        });
+    });
+    it("treats invalid command forms as plain text", ()=>{
+        expect(interpretSmsInboundMessage("pause tomorrow")).toEqual({
+            type: "text",
+            content: "pause tomorrow"
+        });
+        expect(interpretSmsInboundMessage("pause 0m")).toEqual({
+            type: "text",
+            content: "pause 0m"
+        });
+        expect(interpretSmsInboundMessage("help me with deploy")).toEqual({
+            type: "text",
+            content: "help me with deploy"
+        });
+    });
+    it("supports escaping reserved command words", ()=>{
+        expect(interpretSmsInboundMessage("\\pause")).toEqual({
+            type: "text",
+            content: "pause"
+        });
+        expect(interpretSmsInboundMessage("\\STATUS")).toEqual({
+            type: "text",
+            content: "STATUS"
+        });
+    });
+});

package/dist/tests/sms-policy-store.test.cjs

@@ -0,0 +1,69 @@
+"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 policyStore_cjs_namespaceObject = require("../gateway/sms/policyStore.cjs");
+const requireTempDir = (value)=>{
+    if (!value) throw new Error("temp dir not initialized");
+    return value;
+};
+(0, external_vitest_namespaceObject.describe)("sms policy store", ()=>{
+    let tempDir = null;
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        if (!tempDir) return;
+        (0, external_node_fs_namespaceObject.rmSync)(tempDir, {
+            recursive: true,
+            force: true
+        });
+        tempDir = null;
+    });
+    (0, external_vitest_namespaceObject.it)("creates defaults for unknown targets without persisting", ()=>{
+        tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-sms-policy-"));
+        const store = (0, policyStore_cjs_namespaceObject.createSmsPolicyStore)(()=>requireTempDir(tempDir));
+        const record = store.resolve("sms-macos:+15555550000", 1000);
+        (0, external_vitest_namespaceObject.expect)(record.target).toBe("sms-macos:+15555550000");
+        (0, external_vitest_namespaceObject.expect)(record.paused).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(record.stopEnabled).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(store.list()).toHaveLength(0);
+    });
+    (0, external_vitest_namespaceObject.it)("persists updates and clears expired pauses on resolve", ()=>{
+        tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-sms-policy-"));
+        const store = (0, policyStore_cjs_namespaceObject.createSmsPolicyStore)(()=>requireTempDir(tempDir));
+        const target = "sms-macos:+15555550000";
+        const saved = store.upsert(target, {
+            paused: true,
+            pausedUntil: 50000,
+            stopEnabled: true
+        }, 1000);
+        (0, external_vitest_namespaceObject.expect)(saved.paused).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(saved.pausedUntil).toBe(50000);
+        (0, external_vitest_namespaceObject.expect)(saved.stopEnabled).toBe(true);
+        const active = store.resolve(target, 49000);
+        (0, external_vitest_namespaceObject.expect)(active.paused).toBe(true);
+        const expired = store.resolve(target, 50000);
+        (0, external_vitest_namespaceObject.expect)(expired.paused).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(expired.pausedUntil).toBeNull();
+        (0, external_vitest_namespaceObject.expect)(expired.stopEnabled).toBe(true);
+    });
+    (0, external_vitest_namespaceObject.it)("resets policies back to defaults", ()=>{
+        tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-sms-policy-"));
+        const store = (0, policyStore_cjs_namespaceObject.createSmsPolicyStore)(()=>requireTempDir(tempDir));
+        const target = "sms-macos:+15555550000";
+        store.upsert(target, {
+            paused: true,
+            stopEnabled: true
+        }, 1000);
+        (0, external_vitest_namespaceObject.expect)(store.list()).toHaveLength(1);
+        store.reset(target);
+        (0, external_vitest_namespaceObject.expect)(store.list()).toHaveLength(0);
+        const defaultRecord = store.resolve(target, 2000);
+        (0, external_vitest_namespaceObject.expect)(defaultRecord.paused).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(defaultRecord.stopEnabled).toBe(false);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/sms-policy-store.test.d.ts

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

package/dist/tests/sms-policy-store.test.js

@@ -0,0 +1,63 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { createSmsPolicyStore } from "../gateway/sms/policyStore.js";
+const requireTempDir = (value)=>{
+    if (!value) throw new Error("temp dir not initialized");
+    return value;
+};
+describe("sms policy store", ()=>{
+    let tempDir = null;
+    afterEach(()=>{
+        if (!tempDir) return;
+        rmSync(tempDir, {
+            recursive: true,
+            force: true
+        });
+        tempDir = null;
+    });
+    it("creates defaults for unknown targets without persisting", ()=>{
+        tempDir = mkdtempSync(join(tmpdir(), "wingman-sms-policy-"));
+        const store = createSmsPolicyStore(()=>requireTempDir(tempDir));
+        const record = store.resolve("sms-macos:+15555550000", 1000);
+        expect(record.target).toBe("sms-macos:+15555550000");
+        expect(record.paused).toBe(false);
+        expect(record.stopEnabled).toBe(false);
+        expect(store.list()).toHaveLength(0);
+    });
+    it("persists updates and clears expired pauses on resolve", ()=>{
+        tempDir = mkdtempSync(join(tmpdir(), "wingman-sms-policy-"));
+        const store = createSmsPolicyStore(()=>requireTempDir(tempDir));
+        const target = "sms-macos:+15555550000";
+        const saved = store.upsert(target, {
+            paused: true,
+            pausedUntil: 50000,
+            stopEnabled: true
+        }, 1000);
+        expect(saved.paused).toBe(true);
+        expect(saved.pausedUntil).toBe(50000);
+        expect(saved.stopEnabled).toBe(true);
+        const active = store.resolve(target, 49000);
+        expect(active.paused).toBe(true);
+        const expired = store.resolve(target, 50000);
+        expect(expired.paused).toBe(false);
+        expect(expired.pausedUntil).toBeNull();
+        expect(expired.stopEnabled).toBe(true);
+    });
+    it("resets policies back to defaults", ()=>{
+        tempDir = mkdtempSync(join(tmpdir(), "wingman-sms-policy-"));
+        const store = createSmsPolicyStore(()=>requireTempDir(tempDir));
+        const target = "sms-macos:+15555550000";
+        store.upsert(target, {
+            paused: true,
+            stopEnabled: true
+        }, 1000);
+        expect(store.list()).toHaveLength(1);
+        store.reset(target);
+        expect(store.list()).toHaveLength(0);
+        const defaultRecord = store.resolve(target, 2000);
+        expect(defaultRecord.paused).toBe(false);
+        expect(defaultRecord.stopEnabled).toBe(false);
+    });
+});

package/dist/tests/teams-adapter.test.cjs

@@ -0,0 +1,58 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const teams_cjs_namespaceObject = require("../gateway/adapters/teams.cjs");
+(0, external_vitest_namespaceObject.describe)("teams adapter helpers", ()=>{
+    (0, external_vitest_namespaceObject.it)("normalizes endpoint path and falls back to default", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, teams_cjs_namespaceObject.normalizeTeamsEndpointPath)(void 0)).toBe(teams_cjs_namespaceObject.DEFAULT_TEAMS_ENDPOINT_PATH);
+        (0, external_vitest_namespaceObject.expect)((0, teams_cjs_namespaceObject.normalizeTeamsEndpointPath)("")).toBe(teams_cjs_namespaceObject.DEFAULT_TEAMS_ENDPOINT_PATH);
+        (0, external_vitest_namespaceObject.expect)((0, teams_cjs_namespaceObject.normalizeTeamsEndpointPath)("api/teams")).toBe("/api/teams");
+        (0, external_vitest_namespaceObject.expect)((0, teams_cjs_namespaceObject.normalizeTeamsEndpointPath)("/api/teams")).toBe("/api/teams");
+    });
+    (0, external_vitest_namespaceObject.it)("extracts mention entities for the bot", ()=>{
+        const activity = {
+            recipient: {
+                name: "Wingman",
+                id: "bot-1"
+            },
+            entities: [
+                {
+                    type: "mention",
+                    text: "<at>Wingman</at>",
+                    mentioned: {
+                        id: "bot-1",
+                        name: "Wingman"
+                    }
+                }
+            ]
+        };
+        (0, external_vitest_namespaceObject.expect)((0, teams_cjs_namespaceObject.extractTeamsMentionTexts)(activity, "bot-1")).toEqual([
+            "<at>Wingman</at>"
+        ]);
+        (0, external_vitest_namespaceObject.expect)((0, teams_cjs_namespaceObject.isTeamsBotMentioned)(activity, "bot-1")).toBe(true);
+    });
+    (0, external_vitest_namespaceObject.it)("strips mention tags and mention text from messages", ()=>{
+        const text = "<at>Wingman</at> hello there";
+        (0, external_vitest_namespaceObject.expect)((0, teams_cjs_namespaceObject.stripTeamsBotMention)(text, [
+            "<at>Wingman</at>"
+        ])).toBe("hello there");
+    });
+    (0, external_vitest_namespaceObject.it)("splits long responses into chunks", ()=>{
+        const input = "a".repeat(9500);
+        const chunks = (0, teams_cjs_namespaceObject.splitTeamsMessage)(input, 3500);
+        (0, external_vitest_namespaceObject.expect)(chunks.length).toBeGreaterThan(2);
+        for (const chunk of chunks)(0, external_vitest_namespaceObject.expect)(chunk.length).toBeLessThanOrEqual(3500);
+        (0, external_vitest_namespaceObject.expect)(chunks.join("")).toBe(input);
+    });
+    (0, external_vitest_namespaceObject.it)("resolves channel session mapping", ()=>{
+        const map = {
+            "19:channel:id": "agent:wingman:teams:channel"
+        };
+        (0, external_vitest_namespaceObject.expect)((0, teams_cjs_namespaceObject.resolveTeamsChannelSessionKey)("19:channel:id", map)).toBe("agent:wingman:teams:channel");
+        (0, external_vitest_namespaceObject.expect)((0, teams_cjs_namespaceObject.resolveTeamsChannelSessionKey)("missing", map)).toBeUndefined();
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

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

@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+import { DEFAULT_TEAMS_ENDPOINT_PATH, extractTeamsMentionTexts, isTeamsBotMentioned, normalizeTeamsEndpointPath, resolveTeamsChannelSessionKey, splitTeamsMessage, stripTeamsBotMention } from "../gateway/adapters/teams.js";
+describe("teams adapter helpers", ()=>{
+    it("normalizes endpoint path and falls back to default", ()=>{
+        expect(normalizeTeamsEndpointPath(void 0)).toBe(DEFAULT_TEAMS_ENDPOINT_PATH);
+        expect(normalizeTeamsEndpointPath("")).toBe(DEFAULT_TEAMS_ENDPOINT_PATH);
+        expect(normalizeTeamsEndpointPath("api/teams")).toBe("/api/teams");
+        expect(normalizeTeamsEndpointPath("/api/teams")).toBe("/api/teams");
+    });
+    it("extracts mention entities for the bot", ()=>{
+        const activity = {
+            recipient: {
+                name: "Wingman",
+                id: "bot-1"
+            },
+            entities: [
+                {
+                    type: "mention",
+                    text: "<at>Wingman</at>",
+                    mentioned: {
+                        id: "bot-1",
+                        name: "Wingman"
+                    }
+                }
+            ]
+        };
+        expect(extractTeamsMentionTexts(activity, "bot-1")).toEqual([
+            "<at>Wingman</at>"
+        ]);
+        expect(isTeamsBotMentioned(activity, "bot-1")).toBe(true);
+    });
+    it("strips mention tags and mention text from messages", ()=>{
+        const text = "<at>Wingman</at> hello there";
+        expect(stripTeamsBotMention(text, [
+            "<at>Wingman</at>"
+        ])).toBe("hello there");
+    });
+    it("splits long responses into chunks", ()=>{
+        const input = "a".repeat(9500);
+        const chunks = splitTeamsMessage(input, 3500);
+        expect(chunks.length).toBeGreaterThan(2);
+        for (const chunk of chunks)expect(chunk.length).toBeLessThanOrEqual(3500);
+        expect(chunks.join("")).toBe(input);
+    });
+    it("resolves channel session mapping", ()=>{
+        const map = {
+            "19:channel:id": "agent:wingman:teams:channel"
+        };
+        expect(resolveTeamsChannelSessionKey("19:channel:id", map)).toBe("agent:wingman:teams:channel");
+        expect(resolveTeamsChannelSessionKey("missing", map)).toBeUndefined();
+    });
+});

package/dist/tests/terminal-bench-adapters-helpers.test.cjs

@@ -0,0 +1,64 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const helpers_cjs_namespaceObject = require("../bench/adapters/helpers.cjs");
+(0, external_vitest_namespaceObject.describe)("parseWingmanJsonOutput", ()=>{
+    (0, external_vitest_namespaceObject.it)("extracts assistant text from ai-role messages", ()=>{
+        const output = JSON.stringify({
+            type: "agent-complete",
+            result: {
+                messages: [
+                    {
+                        role: "user",
+                        content: "ignore"
+                    },
+                    {
+                        role: "ai",
+                        content: "hello from ai role"
+                    }
+                ]
+            }
+        });
+        const parsed = (0, helpers_cjs_namespaceObject.parseWingmanJsonOutput)(output);
+        (0, external_vitest_namespaceObject.expect)(parsed.assistantText).toBe("hello from ai role");
+    });
+    (0, external_vitest_namespaceObject.it)("extracts assistant text from serialized AIMessage payloads", ()=>{
+        const output = JSON.stringify({
+            type: "agent-complete",
+            result: {
+                messages: [
+                    {
+                        id: [
+                            "langchain_core",
+                            "messages",
+                            "AIMessage"
+                        ],
+                        kwargs: {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "hello from kwargs content"
+                                }
+                            ]
+                        }
+                    }
+                ]
+            }
+        });
+        const parsed = (0, helpers_cjs_namespaceObject.parseWingmanJsonOutput)(output);
+        (0, external_vitest_namespaceObject.expect)(parsed.assistantText).toBe("hello from kwargs content");
+    });
+});
+(0, external_vitest_namespaceObject.describe)("detectAssistantFailureMessage", ()=>{
+    (0, external_vitest_namespaceObject.it)("detects provider bad request failures", ()=>{
+        const error = (0, helpers_cjs_namespaceObject.detectAssistantFailureMessage)("Model call failed after 3 attempts with BadRequestError: 400 status code (no body)");
+        (0, external_vitest_namespaceObject.expect)(error).toContain("BadRequestError");
+    });
+    (0, external_vitest_namespaceObject.it)("ignores normal assistant content", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, helpers_cjs_namespaceObject.detectAssistantFailureMessage)('{"state_analysis":"ok","commands":[],"is_task_complete":false}')).toBeUndefined();
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});