@wingman-ai/gateway 0.5.3 → 0.6.0

package/dist/agent/tests/modelFactory.test.js

@@ -1,184 +0,0 @@
-import { ChatAnthropic } from "@langchain/anthropic";
-import { ChatOllama } from "@langchain/ollama";
-import { ChatOpenAI } from "@langchain/openai";
-import { ChatXAI } from "@langchain/xai";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { ModelFactory } from "../config/modelFactory.js";
-import { NativeXAIImageModel } from "../config/xaiImageModel.js";
-const originalAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
-const originalXaiApiKey = process.env.XAI_API_KEY;
-beforeEach(()=>{
-    process.env.ANTHROPIC_API_KEY = "test-anthropic-api-key";
-    process.env.XAI_API_KEY = "test-xai-api-key";
-});
-afterEach(()=>{
-    if (void 0 === originalAnthropicApiKey) delete process.env.ANTHROPIC_API_KEY;
-    else process.env.ANTHROPIC_API_KEY = originalAnthropicApiKey;
-    if (void 0 === originalXaiApiKey) return void delete process.env.XAI_API_KEY;
-    process.env.XAI_API_KEY = originalXaiApiKey;
-});
-describe("ModelFactory", ()=>{
-    describe("createModel", ()=>{
-        it("should create an Anthropic model", ()=>{
-            const model = ModelFactory.createModel("anthropic:claude-opus-4-5");
-            expect(model).toBeInstanceOf(ChatAnthropic);
-        });
-        it("should create an OpenAI model", ()=>{
-            const model = ModelFactory.createModel("openai:gpt-4o");
-            expect(model).toBeInstanceOf(ChatOpenAI);
-        });
-        it("should create a Codex model", ()=>{
-            const model = ModelFactory.createModel("codex:codex-mini-latest");
-            expect(model).toBeInstanceOf(ChatOpenAI);
-            expect(model.useResponsesApi).toBe(true);
-            expect(model.zdrEnabled).toBe(true);
-        });
-        it("should force OpenAI models onto the responses API", ()=>{
-            const model = ModelFactory.createModel("openai:gpt-5.2-codex");
-            expect(model).toBeInstanceOf(ChatOpenAI);
-            expect(model.useResponsesApi).toBe(true);
-        });
-        it("should apply reasoning effort for supported OpenAI reasoning models", ()=>{
-            const model = ModelFactory.createModel("openai:gpt-5.2-codex", {
-                reasoningEffort: "high"
-            });
-            expect(model).toBeInstanceOf(ChatOpenAI);
-            expect(model.reasoning).toEqual({
-                effort: "high"
-            });
-        });
-        it("should ignore reasoning effort for unsupported OpenAI models", ()=>{
-            const model = ModelFactory.createModel("openai:gpt-4o", {
-                reasoningEffort: "medium"
-            });
-            expect(model).toBeInstanceOf(ChatOpenAI);
-            expect(model.reasoning).toBeUndefined();
-        });
-        it("should map reasoning effort to anthropic thinking budget", ()=>{
-            const model = ModelFactory.createModel("anthropic:claude-sonnet-4-5", {
-                reasoningEffort: "medium"
-            });
-            expect(model).toBeInstanceOf(ChatAnthropic);
-            expect(model.thinking).toEqual({
-                type: "enabled",
-                budget_tokens: 4096
-            });
-        });
-        it("should create an OpenRouter model", ()=>{
-            const model = ModelFactory.createModel("openrouter:openai/gpt-4o");
-            expect(model).toBeInstanceOf(ChatOpenAI);
-        });
-        it("should ignore reasoning effort for unsupported providers", ()=>{
-            const model = ModelFactory.createModel("openrouter:openai/gpt-5", {
-                reasoningEffort: "high"
-            });
-            expect(model).toBeInstanceOf(ChatOpenAI);
-            expect(model.reasoning).toBeUndefined();
-        });
-        it("should create a Copilot model", ()=>{
-            const model = ModelFactory.createModel("copilot:gpt-4o");
-            expect(model).toBeInstanceOf(ChatOpenAI);
-        });
-        it("should create an LMStudio model", ()=>{
-            const model = ModelFactory.createModel("lmstudio:llama-3.1-8b");
-            expect(model).toBeInstanceOf(ChatOpenAI);
-        });
-        it("should create an Ollama model", ()=>{
-            const model = ModelFactory.createModel("ollama:llama3.2");
-            expect(model).toBeInstanceOf(ChatOllama);
-            expect(model.baseUrl).toBe("http://localhost:11434");
-        });
-        it("should allow model names with additional colons", ()=>{
-            const model = ModelFactory.createModel("ollama:phi4:14b-q8_0");
-            expect(model).toBeInstanceOf(ChatOllama);
-        });
-        it("should create native xAI image model for grok-imagine-image", ()=>{
-            const model = ModelFactory.createModel("xai:grok-imagine-image");
-            expect(model).toBeInstanceOf(NativeXAIImageModel);
-        });
-        it("should keep text xAI models on ChatXAI", ()=>{
-            const model = ModelFactory.createModel("xai:grok-beta");
-            expect(model).toBeInstanceOf(ChatXAI);
-        });
-        it("should throw error for invalid format (missing colon)", ()=>{
-            expect(()=>{
-                ModelFactory.createModel("anthropic-claude-opus");
-            }).toThrow(/Invalid model format/);
-        });
-        it("should throw error for invalid format (empty provider)", ()=>{
-            expect(()=>{
-                ModelFactory.createModel(":claude-opus-4-5");
-            }).toThrow(/Invalid model format/);
-        });
-        it("should throw error for invalid format (empty model)", ()=>{
-            expect(()=>{
-                ModelFactory.createModel("anthropic:");
-            }).toThrow(/Invalid model format/);
-        });
-        it("should throw error for unsupported provider", ()=>{
-            expect(()=>{
-                ModelFactory.createModel("unsupported:model-name");
-            }).toThrow(/Unknown model provider/);
-        });
-        it("should be case insensitive for provider names", ()=>{
-            const model1 = ModelFactory.createModel("Anthropic:claude-opus-4-5");
-            const model2 = ModelFactory.createModel("ANTHROPIC:claude-opus-4-5");
-            expect(model1).toBeInstanceOf(ChatAnthropic);
-            expect(model2).toBeInstanceOf(ChatAnthropic);
-        });
-    });
-    describe("validateModelString", ()=>{
-        it("should validate correct model strings", ()=>{
-            const validModels = [
-                "anthropic:claude-opus-4-5",
-                "openai:gpt-4o",
-                "codex:codex-mini-latest",
-                "anthropic:claude-sonnet-4-5-20250929",
-                "openrouter:openai/gpt-4o",
-                "copilot:gpt-4o",
-                "lmstudio:llama-3.1-8b",
-                "ollama:llama3.2",
-                "ollama:phi4:14b-q8_0"
-            ];
-            for (const modelString of validModels){
-                const result = ModelFactory.validateModelString(modelString);
-                expect(result.valid).toBe(true);
-                expect(result.error).toBeUndefined();
-            }
-        });
-        it("should reject invalid format", ()=>{
-            const result = ModelFactory.validateModelString("invalid-format");
-            expect(result.valid).toBe(false);
-            expect(result.error).toContain("Invalid format");
-        });
-        it("should reject empty provider", ()=>{
-            const result = ModelFactory.validateModelString(":model-name");
-            expect(result.valid).toBe(false);
-            expect(result.error).toContain("required");
-        });
-        it("should reject empty model", ()=>{
-            const result = ModelFactory.validateModelString("anthropic:");
-            expect(result.valid).toBe(false);
-            expect(result.error).toContain("required");
-        });
-        it("should reject unsupported provider", ()=>{
-            const result = ModelFactory.validateModelString("unsupported:model");
-            expect(result.valid).toBe(false);
-            expect(result.error).toContain("Unknown provider");
-        });
-        it("should accept case variations of providers", ()=>{
-            const result1 = ModelFactory.validateModelString("Anthropic:model");
-            const result2 = ModelFactory.validateModelString("OPENAI:model");
-            const result3 = ModelFactory.validateModelString("CODEX:model");
-            const result4 = ModelFactory.validateModelString("Copilot:model");
-            const result5 = ModelFactory.validateModelString("LMStudio:model");
-            const result6 = ModelFactory.validateModelString("OLLAMA:model");
-            expect(result1.valid).toBe(true);
-            expect(result2.valid).toBe(true);
-            expect(result3.valid).toBe(true);
-            expect(result4.valid).toBe(true);
-            expect(result5.valid).toBe(true);
-            expect(result6.valid).toBe(true);
-        });
-    });
-});

package/dist/agent/tests/terminalSessionManager.test.cjs

@@ -1,121 +0,0 @@
-"use strict";
-var __webpack_exports__ = {};
-const external_vitest_namespaceObject = require("vitest");
-const terminal_session_manager_cjs_namespaceObject = require("../tools/terminal_session_manager.cjs");
-async function waitForTerminalCompletion(manager, ownerId, sessionId, timeoutMs = 5000) {
-    const started = Date.now();
-    let lastOutput = "";
-    while(Date.now() - started < timeoutMs){
-        const poll = await manager.pollSession({
-            ownerId,
-            sessionId,
-            waitMs: 200,
-            maxOutputChars: 2000
-        });
-        lastOutput += poll.output;
-        if ("running" !== poll.status) return {
-            ...poll,
-            output: lastOutput
-        };
-    }
-    throw new Error(`Timed out waiting for terminal session ${sessionId}`);
-}
-(0, external_vitest_namespaceObject.describe)("TerminalSessionManager", ()=>{
-    (0, external_vitest_namespaceObject.it)("runs commands and returns output", async ()=>{
-        const manager = new terminal_session_manager_cjs_namespaceObject.TerminalSessionManager();
-        try {
-            const session = manager.startSession({
-                ownerId: "owner-a",
-                command: "node -e \"process.stdout.write('hello\\n')\"",
-                cwd: process.cwd(),
-                env: process.env
-            });
-            const finalState = await waitForTerminalCompletion(manager, "owner-a", session.sessionId);
-            (0, external_vitest_namespaceObject.expect)(finalState.output).toContain("hello");
-            (0, external_vitest_namespaceObject.expect)([
-                "completed",
-                "error",
-                "killed",
-                "timed_out"
-            ]).toContain(finalState.status);
-        } finally{
-            manager.dispose();
-        }
-    });
-    (0, external_vitest_namespaceObject.it)("enforces session ownership", async ()=>{
-        const manager = new terminal_session_manager_cjs_namespaceObject.TerminalSessionManager();
-        try {
-            const session = manager.startSession({
-                ownerId: "owner-allowed",
-                command: 'node -e "setTimeout(() => {}, 500)"',
-                cwd: process.cwd(),
-                env: process.env
-            });
-            await (0, external_vitest_namespaceObject.expect)(manager.pollSession({
-                ownerId: "owner-denied",
-                sessionId: session.sessionId,
-                waitMs: 0
-            })).rejects.toThrow("not accessible");
-        } finally{
-            manager.dispose();
-        }
-    });
-    (0, external_vitest_namespaceObject.it)("supports stdin writes and kill", async ()=>{
-        const manager = new terminal_session_manager_cjs_namespaceObject.TerminalSessionManager();
-        try {
-            const session = manager.startSession({
-                ownerId: "owner-b",
-                command: "cat",
-                cwd: process.cwd(),
-                env: process.env
-            });
-            manager.writeSession({
-                ownerId: "owner-b",
-                sessionId: session.sessionId,
-                chars: "ping\n"
-            });
-            const poll = await manager.pollSession({
-                ownerId: "owner-b",
-                sessionId: session.sessionId,
-                waitMs: 1000,
-                maxOutputChars: 2000
-            });
-            (0, external_vitest_namespaceObject.expect)(poll.output).toContain("ping");
-            const killed = manager.killSession({
-                ownerId: "owner-b",
-                sessionId: session.sessionId,
-                signal: "SIGTERM"
-            });
-            (0, external_vitest_namespaceObject.expect)([
-                "running",
-                "killed",
-                "timed_out",
-                "error",
-                "completed"
-            ]).toContain(killed.status);
-        } finally{
-            manager.dispose();
-        }
-    });
-    (0, external_vitest_namespaceObject.it)("drops buffered output when max buffer is exceeded", async ()=>{
-        const manager = new terminal_session_manager_cjs_namespaceObject.TerminalSessionManager({
-            maxBufferedCharsPerSession: 32
-        });
-        try {
-            const session = manager.startSession({
-                ownerId: "owner-c",
-                command: "node -e \"process.stdout.write('abcdefghijklmnopqrstuvwxyz0123456789')\"",
-                cwd: process.cwd(),
-                env: process.env
-            });
-            const finalState = await waitForTerminalCompletion(manager, "owner-c", session.sessionId);
-            (0, external_vitest_namespaceObject.expect)(finalState.droppedChars).toBeGreaterThan(0);
-        } finally{
-            manager.dispose();
-        }
-    });
-});
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/agent/tests/terminalSessionManager.test.d.ts

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

package/dist/agent/tests/terminalSessionManager.test.js

@@ -1,115 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { TerminalSessionManager } from "../tools/terminal_session_manager.js";
-async function waitForTerminalCompletion(manager, ownerId, sessionId, timeoutMs = 5000) {
-    const started = Date.now();
-    let lastOutput = "";
-    while(Date.now() - started < timeoutMs){
-        const poll = await manager.pollSession({
-            ownerId,
-            sessionId,
-            waitMs: 200,
-            maxOutputChars: 2000
-        });
-        lastOutput += poll.output;
-        if ("running" !== poll.status) return {
-            ...poll,
-            output: lastOutput
-        };
-    }
-    throw new Error(`Timed out waiting for terminal session ${sessionId}`);
-}
-describe("TerminalSessionManager", ()=>{
-    it("runs commands and returns output", async ()=>{
-        const manager = new TerminalSessionManager();
-        try {
-            const session = manager.startSession({
-                ownerId: "owner-a",
-                command: "node -e \"process.stdout.write('hello\\n')\"",
-                cwd: process.cwd(),
-                env: process.env
-            });
-            const finalState = await waitForTerminalCompletion(manager, "owner-a", session.sessionId);
-            expect(finalState.output).toContain("hello");
-            expect([
-                "completed",
-                "error",
-                "killed",
-                "timed_out"
-            ]).toContain(finalState.status);
-        } finally{
-            manager.dispose();
-        }
-    });
-    it("enforces session ownership", async ()=>{
-        const manager = new TerminalSessionManager();
-        try {
-            const session = manager.startSession({
-                ownerId: "owner-allowed",
-                command: 'node -e "setTimeout(() => {}, 500)"',
-                cwd: process.cwd(),
-                env: process.env
-            });
-            await expect(manager.pollSession({
-                ownerId: "owner-denied",
-                sessionId: session.sessionId,
-                waitMs: 0
-            })).rejects.toThrow("not accessible");
-        } finally{
-            manager.dispose();
-        }
-    });
-    it("supports stdin writes and kill", async ()=>{
-        const manager = new TerminalSessionManager();
-        try {
-            const session = manager.startSession({
-                ownerId: "owner-b",
-                command: "cat",
-                cwd: process.cwd(),
-                env: process.env
-            });
-            manager.writeSession({
-                ownerId: "owner-b",
-                sessionId: session.sessionId,
-                chars: "ping\n"
-            });
-            const poll = await manager.pollSession({
-                ownerId: "owner-b",
-                sessionId: session.sessionId,
-                waitMs: 1000,
-                maxOutputChars: 2000
-            });
-            expect(poll.output).toContain("ping");
-            const killed = manager.killSession({
-                ownerId: "owner-b",
-                sessionId: session.sessionId,
-                signal: "SIGTERM"
-            });
-            expect([
-                "running",
-                "killed",
-                "timed_out",
-                "error",
-                "completed"
-            ]).toContain(killed.status);
-        } finally{
-            manager.dispose();
-        }
-    });
-    it("drops buffered output when max buffer is exceeded", async ()=>{
-        const manager = new TerminalSessionManager({
-            maxBufferedCharsPerSession: 32
-        });
-        try {
-            const session = manager.startSession({
-                ownerId: "owner-c",
-                command: "node -e \"process.stdout.write('abcdefghijklmnopqrstuvwxyz0123456789')\"",
-                cwd: process.cwd(),
-                env: process.env
-            });
-            const finalState = await waitForTerminalCompletion(manager, "owner-c", session.sessionId);
-            expect(finalState.droppedChars).toBeGreaterThan(0);
-        } finally{
-            manager.dispose();
-        }
-    });
-});

package/dist/agent/tests/test-agent-loader.cjs

@@ -1,33 +0,0 @@
-"use strict";
-var __webpack_exports__ = {};
-const agentLoader_cjs_namespaceObject = require("../config/agentLoader.cjs");
-const loader = new agentLoader_cjs_namespaceObject.AgentLoader(".wingman", process.cwd());
-const agents = loader.loadAllAgentConfigs();
-console.log(`Loaded ${agents.length} agents:`);
-agents.forEach((agent)=>{
-    console.log(`  - ${agent.name}: ${agent.description}`);
-    console.log(`    Tools: ${agent.tools?.length || 0}`);
-    console.log(`    Model: ${agent.model ? "Custom" : "Default"}`);
-});
-const expectedAgents = [
-    "researcher",
-    "coding",
-    "planner",
-    "implementor",
-    "reviewer"
-];
-const loadedAgentNames = agents.map((a)=>a.name);
-console.log("\nExpected agents check:");
-expectedAgents.forEach((name)=>{
-    const found = loadedAgentNames.includes(name);
-    console.log(`  ${found ? "✓" : "✗"} ${name}`);
-});
-if (agents.length !== expectedAgents.length) {
-    console.error(`\nERROR: Expected ${expectedAgents.length} agents, but loaded ${agents.length}`);
-    process.exit(1);
-}
-console.log("\n✓ All tests passed!");
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/agent/tests/test-agent-loader.d.ts

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

package/dist/agent/tests/test-agent-loader.js

@@ -1,27 +0,0 @@
-import { AgentLoader } from "../config/agentLoader.js";
-const loader = new AgentLoader(".wingman", process.cwd());
-const agents = loader.loadAllAgentConfigs();
-console.log(`Loaded ${agents.length} agents:`);
-agents.forEach((agent)=>{
-    console.log(`  - ${agent.name}: ${agent.description}`);
-    console.log(`    Tools: ${agent.tools?.length || 0}`);
-    console.log(`    Model: ${agent.model ? "Custom" : "Default"}`);
-});
-const expectedAgents = [
-    "researcher",
-    "coding",
-    "planner",
-    "implementor",
-    "reviewer"
-];
-const loadedAgentNames = agents.map((a)=>a.name);
-console.log("\nExpected agents check:");
-expectedAgents.forEach((name)=>{
-    const found = loadedAgentNames.includes(name);
-    console.log(`  ${found ? "✓" : "✗"} ${name}`);
-});
-if (agents.length !== expectedAgents.length) {
-    console.error(`\nERROR: Expected ${expectedAgents.length} agents, but loaded ${agents.length}`);
-    process.exit(1);
-}
-console.log("\n✓ All tests passed!");

package/dist/agent/tests/test-subagent-loading.cjs

@@ -1,99 +0,0 @@
-"use strict";
-var __webpack_exports__ = {};
-const external_node_fs_namespaceObject = require("node:fs");
-const external_node_path_namespaceObject = require("node:path");
-const agentLoader_cjs_namespaceObject = require("../config/agentLoader.cjs");
-const testDir = (0, external_node_path_namespaceObject.join)(process.cwd(), ".test-subagents");
-const testAgentsDir = (0, external_node_path_namespaceObject.join)(testDir, "agents");
-function cleanup() {
-    if ((0, external_node_fs_namespaceObject.existsSync)(testDir)) {
-        (0, external_node_fs_namespaceObject.unlinkSync)((0, external_node_path_namespaceObject.join)(testAgentsDir, "parent-agent.json"));
-        process.chdir(process.cwd());
-    }
-}
-try {
-    if (!(0, external_node_fs_namespaceObject.existsSync)(testDir)) (0, external_node_fs_namespaceObject.mkdirSync)(testDir, {
-        recursive: true
-    });
-    if (!(0, external_node_fs_namespaceObject.existsSync)(testAgentsDir)) (0, external_node_fs_namespaceObject.mkdirSync)(testAgentsDir, {
-        recursive: true
-    });
-    console.log("\n=== Test 1: Agent with subagents ===");
-    const agentWithSubagents = {
-        name: "parent-agent",
-        description: "Parent agent with subagents",
-        systemPrompt: "You are a parent agent that delegates to subagents.",
-        tools: [
-            "think"
-        ],
-        subagents: [
-            {
-                name: "child-1",
-                description: "First child agent",
-                systemPrompt: "You are child agent 1",
-                tools: [
-                    "web_crawler"
-                ]
-            },
-            {
-                name: "child-2",
-                description: "Second child agent",
-                systemPrompt: "You are child agent 2",
-                tools: [
-                    "internet_search"
-                ]
-            }
-        ]
-    };
-    (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(testAgentsDir, "parent-agent.json"), JSON.stringify(agentWithSubagents, null, 2));
-    const loader1 = new agentLoader_cjs_namespaceObject.AgentLoader(".wingman", testDir);
-    const agents1 = loader1.loadAllAgentConfigs();
-    console.log(`Loaded ${agents1.length} agent(s)`);
-    console.log(`Agent name: ${agents1[0]?.name}`);
-    console.log(`Agent has subagents: ${agents1[0]?.subagents ? "Yes" : "No"}`);
-    if (agents1[0]?.subagents) {
-        console.log(`Number of subagents: ${agents1[0].subagents.length}`);
-        agents1[0].subagents.forEach((sub, i)=>{
-            console.log(`  Subagent ${i + 1}: ${sub.name} - ${sub.description}`);
-            console.log(`    Tools: ${sub.tools?.length || 0}`);
-        });
-    }
-    console.log("\n=== Test 2: Validation - Subagents cannot have subagents ===");
-    const invalidAgent = {
-        name: "invalid-agent",
-        description: "Agent with nested subagents (should fail)",
-        systemPrompt: "Invalid config",
-        subagents: [
-            {
-                name: "child",
-                description: "Child with its own subagents",
-                systemPrompt: "Child agent",
-                subagents: [
-                    {
-                        name: "grandchild",
-                        description: "This should fail validation",
-                        systemPrompt: "Grandchild"
-                    }
-                ]
-            }
-        ]
-    };
-    (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(testAgentsDir, "parent-agent.json"), JSON.stringify(invalidAgent, null, 2));
-    const loader2 = new agentLoader_cjs_namespaceObject.AgentLoader(".wingman", testDir);
-    const agents2 = loader2.loadAllAgentConfigs();
-    if (0 === agents2.length) console.log("✓ Validation correctly rejected nested subagents");
-    else {
-        console.log("✗ ERROR: Validation should have rejected nested subagents");
-        process.exit(1);
-    }
-    console.log("\n✓ All subagent tests passed!");
-    cleanup();
-} catch (error) {
-    console.error("Test failed:", error);
-    cleanup();
-    process.exit(1);
-}
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/agent/tests/test-subagent-loading.d.ts

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