@wingman-ai/gateway 0.5.3 → 0.5.4

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

@@ -1,284 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { MCPClientManager } from "../config/mcpClientManager.js";
-const testLogger = {
-    debug: ()=>{},
-    info: ()=>{},
-    warn: ()=>{},
-    error: ()=>{}
-};
-const getClientConfig = (manager)=>manager.buildClientConfig();
-describe("MCPClientManager runtime env", ()=>{
-    it("injects workdir for stdio servers", ()=>{
-        const executionWorkspace = "/tmp/wingman-workdir";
-        const configs = [
-            {
-                servers: [
-                    {
-                        name: "fal-ai",
-                        transport: "stdio",
-                        command: "bun",
-                        args: [
-                            "run",
-                            "src/tools/mcp-fal-ai.ts"
-                        ],
-                        env: {
-                            EXISTING: "value"
-                        }
-                    }
-                ]
-            }
-        ];
-        const manager = new MCPClientManager(configs, testLogger, {
-            executionWorkspace
-        });
-        const clientConfig = getClientConfig(manager);
-        const env = clientConfig.mcpServers["fal-ai"].env;
-        expect(env.EXISTING).toBe("value");
-        expect(env.WINGMAN_WORKDIR).toBe(executionWorkspace);
-    });
-    it("does not inject workdir when no execution workspace is provided", ()=>{
-        const configs = [
-            {
-                servers: [
-                    {
-                        name: "fal-ai",
-                        transport: "stdio",
-                        command: "bun",
-                        args: [
-                            "run",
-                            "src/tools/mcp-fal-ai.ts"
-                        ],
-                        env: {
-                            EXISTING: "value"
-                        }
-                    }
-                ]
-            }
-        ];
-        const manager = new MCPClientManager(configs, testLogger);
-        const clientConfig = getClientConfig(manager);
-        const env = clientConfig.mcpServers["fal-ai"].env;
-        expect(env.EXISTING).toBe("value");
-        expect(env.WINGMAN_WORKDIR).toBeUndefined();
-    });
-    it("resolves env placeholders", ()=>{
-        const original = process.env.FAL_API_KEY;
-        process.env.FAL_API_KEY = "test-key";
-        try {
-            const configs = [
-                {
-                    servers: [
-                        {
-                            name: "fal-ai",
-                            transport: "stdio",
-                            command: "bun",
-                            args: [
-                                "run",
-                                "src/tools/mcp-fal-ai.ts"
-                            ],
-                            env: {
-                                FAL_API_KEY: "${FAL_API_KEY}"
-                            }
-                        }
-                    ]
-                }
-            ];
-            const manager = new MCPClientManager(configs, testLogger);
-            const clientConfig = getClientConfig(manager);
-            expect(clientConfig.mcpServers["fal-ai"].env.FAL_API_KEY).toBe("test-key");
-        } finally{
-            if ("string" == typeof original) process.env.FAL_API_KEY = original;
-            else delete process.env.FAL_API_KEY;
-        }
-    });
-    it("passes through per-server default tool timeout", ()=>{
-        const configs = [
-            {
-                servers: [
-                    {
-                        name: "fal-ai",
-                        transport: "stdio",
-                        command: "bun",
-                        args: [
-                            "run",
-                            "src/tools/mcp-fal-ai.ts"
-                        ],
-                        defaultToolTimeout: 300000,
-                        env: {
-                            EXISTING: "value"
-                        }
-                    }
-                ]
-            }
-        ];
-        const manager = new MCPClientManager(configs, testLogger);
-        const clientConfig = getClientConfig(manager);
-        expect(clientConfig.mcpServers["fal-ai"].defaultToolTimeout).toBe(300000);
-    });
-    it("wraps stdio servers with proxy command when enabled", ()=>{
-        const configs = [
-            {
-                servers: [
-                    {
-                        name: "fal-ai",
-                        transport: "stdio",
-                        command: "bun",
-                        args: [
-                            "run",
-                            "src/tools/mcp-fal-ai.ts"
-                        ],
-                        env: {
-                            EXISTING: "value"
-                        }
-                    }
-                ]
-            }
-        ];
-        const manager = new MCPClientManager(configs, testLogger, {
-            proxyConfig: {
-                enabled: true,
-                command: "uvx",
-                baseArgs: [
-                    "invariant-gateway@latest",
-                    "mcp"
-                ],
-                projectName: "wingman-gateway",
-                apiKey: "test-api-key",
-                apiUrl: "https://explorer.invariantlabs.ai"
-            }
-        });
-        const clientConfig = getClientConfig(manager);
-        const server = clientConfig.mcpServers["fal-ai"];
-        expect(server.command).toBe("uvx");
-        expect(server.args).toEqual([
-            "invariant-gateway@latest",
-            "mcp",
-            "--project-name",
-            "wingman-gateway",
-            "--exec",
-            "bun",
-            "run",
-            "src/tools/mcp-fal-ai.ts"
-        ]);
-        expect(server.env.EXISTING).toBe("value");
-        expect(server.env.INVARIANT_API_KEY).toBe("test-api-key");
-        expect(server.env.INVARIANT_API_URL).toBe("https://explorer.invariantlabs.ai");
-        expect(server.env.GUARDRAILS_API_URL).toBe("https://explorer.invariantlabs.ai");
-    });
-    it("keeps MCP multimodal output handling in artifact mode", ()=>{
-        const configs = [
-            {
-                servers: [
-                    {
-                        name: "fal-ai",
-                        transport: "stdio",
-                        command: "bun",
-                        args: [
-                            "run",
-                            "src/tools/mcp-fal-ai.ts"
-                        ]
-                    }
-                ]
-            }
-        ];
-        const manager = new MCPClientManager(configs, testLogger);
-        const clientConfig = getClientConfig(manager);
-        expect(clientConfig.outputHandling).toEqual({
-            image: "artifact",
-            audio: "artifact",
-            resource: "artifact"
-        });
-    });
-    it("lists resources from MCP client", async ()=>{
-        const listResources = vi.fn().mockResolvedValue({
-            fal: [
-                {
-                    uri: "fal://jobs/123",
-                    name: "Job 123",
-                    description: "Generated asset",
-                    mimeType: "application/json"
-                }
-            ]
-        });
-        const manager = new MCPClientManager([], testLogger);
-        manager.client = {
-            listResources
-        };
-        const result = await manager.listResources([
-            "fal"
-        ]);
-        expect(listResources).toHaveBeenCalledWith("fal");
-        expect(result).toEqual({
-            fal: [
-                {
-                    uri: "fal://jobs/123",
-                    name: "Job 123",
-                    description: "Generated asset",
-                    mimeType: "application/json"
-                }
-            ]
-        });
-    });
-    it("lists resource templates from MCP client", async ()=>{
-        const listResourceTemplates = vi.fn().mockResolvedValue({
-            fal: [
-                {
-                    uriTemplate: "fal://jobs/{jobId}",
-                    name: "Fal Job",
-                    description: "Job by ID",
-                    mimeType: "application/json"
-                }
-            ]
-        });
-        const manager = new MCPClientManager([], testLogger);
-        manager.client = {
-            listResourceTemplates
-        };
-        const result = await manager.listResourceTemplates([
-            "fal"
-        ]);
-        expect(listResourceTemplates).toHaveBeenCalledWith("fal");
-        expect(result).toEqual({
-            fal: [
-                {
-                    uriTemplate: "fal://jobs/{jobId}",
-                    name: "Fal Job",
-                    description: "Job by ID",
-                    mimeType: "application/json"
-                }
-            ]
-        });
-    });
-    it("reads resources from MCP client", async ()=>{
-        const readResource = vi.fn().mockResolvedValue([
-            {
-                uri: "fal://jobs/123",
-                mimeType: "application/json",
-                text: '{"status":"completed"}'
-            }
-        ]);
-        const manager = new MCPClientManager([], testLogger);
-        manager.client = {
-            readResource
-        };
-        const result = await manager.readResource("fal", "fal://jobs/123");
-        expect(readResource).toHaveBeenCalledWith("fal", "fal://jobs/123");
-        expect(result).toEqual([
-            {
-                uri: "fal://jobs/123",
-                mimeType: "application/json",
-                text: '{"status":"completed"}'
-            }
-        ]);
-    });
-    it("calls close on cleanup", async ()=>{
-        const close = vi.fn().mockResolvedValue(void 0);
-        const manager = new MCPClientManager([], testLogger);
-        manager.client = {
-            close
-        };
-        await manager.cleanup();
-        expect(close).toHaveBeenCalledTimes(1);
-        expect(manager.client).toBeNull();
-    });
-});

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

@@ -1,101 +0,0 @@
-"use strict";
-var __webpack_exports__ = {};
-const external_vitest_namespaceObject = require("vitest");
-const mcp_resources_cjs_namespaceObject = require("../tools/mcp_resources.cjs");
-const createManagerStub = ()=>{
-    const listResources = external_vitest_namespaceObject.vi.fn();
-    const listResourceTemplates = external_vitest_namespaceObject.vi.fn();
-    const readResource = external_vitest_namespaceObject.vi.fn();
-    const manager = {
-        listResources,
-        listResourceTemplates,
-        readResource
-    };
-    return {
-        manager,
-        listResources,
-        listResourceTemplates,
-        readResource
-    };
-};
-(0, external_vitest_namespaceObject.describe)("mcp resource tools", ()=>{
-    (0, external_vitest_namespaceObject.it)("lists resources and templates", async ()=>{
-        const { manager, listResources, listResourceTemplates } = createManagerStub();
-        listResources.mockResolvedValue({
-            fal: [
-                {
-                    uri: "fal://jobs/1",
-                    name: "Job 1",
-                    mimeType: "application/json"
-                }
-            ]
-        });
-        listResourceTemplates.mockResolvedValue({
-            fal: [
-                {
-                    uriTemplate: "fal://jobs/{id}",
-                    name: "Job by id"
-                }
-            ]
-        });
-        const [listTool] = (0, mcp_resources_cjs_namespaceObject.createMCPResourceTools)(manager);
-        const output = await listTool.invoke({
-            includeTemplates: true
-        });
-        const parsed = JSON.parse(String(output));
-        (0, external_vitest_namespaceObject.expect)(listResources).toHaveBeenCalledWith([]);
-        (0, external_vitest_namespaceObject.expect)(listResourceTemplates).toHaveBeenCalledWith([]);
-        (0, external_vitest_namespaceObject.expect)(parsed.resourceCount).toBe(1);
-        (0, external_vitest_namespaceObject.expect)(parsed.resourceTemplateCount).toBe(1);
-        (0, external_vitest_namespaceObject.expect)(parsed.resources.fal[0].uri).toBe("fal://jobs/1");
-    });
-    (0, external_vitest_namespaceObject.it)("reads resource content without inlining binary blobs by default", async ()=>{
-        const { manager, readResource } = createManagerStub();
-        readResource.mockResolvedValue([
-            {
-                uri: "fal://jobs/1",
-                mimeType: "application/json",
-                text: "abcdefghijklmnopqrstuvwxyz",
-                blob: "YWJjZA=="
-            }
-        ]);
-        const tools = (0, mcp_resources_cjs_namespaceObject.createMCPResourceTools)(manager);
-        const readTool = tools.find((entry)=>"mcp_read_resource" === entry.name);
-        if (!readTool) throw new Error("mcp_read_resource tool missing");
-        const output = await readTool.invoke({
-            server: "fal",
-            uri: "fal://jobs/1",
-            maxTextChars: 10
-        });
-        const parsed = JSON.parse(String(output));
-        (0, external_vitest_namespaceObject.expect)(readResource).toHaveBeenCalledWith("fal", "fal://jobs/1");
-        (0, external_vitest_namespaceObject.expect)(parsed.content[0].text).toBe("abcdefghij");
-        (0, external_vitest_namespaceObject.expect)(parsed.content[0].truncated).toBe(true);
-        (0, external_vitest_namespaceObject.expect)(parsed.content[0].blobLength).toBe(8);
-        (0, external_vitest_namespaceObject.expect)(parsed.content[0].blob).toBeUndefined();
-    });
-    (0, external_vitest_namespaceObject.it)("can include binary blobs when requested", async ()=>{
-        const { manager, readResource } = createManagerStub();
-        readResource.mockResolvedValue([
-            {
-                uri: "fal://jobs/2",
-                mimeType: "image/png",
-                blob: "YWJjZA=="
-            }
-        ]);
-        const tools = (0, mcp_resources_cjs_namespaceObject.createMCPResourceTools)(manager);
-        const readTool = tools.find((entry)=>"mcp_read_resource" === entry.name);
-        if (!readTool) throw new Error("mcp_read_resource tool missing");
-        const output = await readTool.invoke({
-            server: "fal",
-            uri: "fal://jobs/2",
-            includeBinary: true
-        });
-        const parsed = JSON.parse(String(output));
-        (0, external_vitest_namespaceObject.expect)(parsed.content[0].blob).toBe("YWJjZA==");
-    });
-});
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

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

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

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

@@ -1,95 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createMCPResourceTools } from "../tools/mcp_resources.js";
-const createManagerStub = ()=>{
-    const listResources = vi.fn();
-    const listResourceTemplates = vi.fn();
-    const readResource = vi.fn();
-    const manager = {
-        listResources,
-        listResourceTemplates,
-        readResource
-    };
-    return {
-        manager,
-        listResources,
-        listResourceTemplates,
-        readResource
-    };
-};
-describe("mcp resource tools", ()=>{
-    it("lists resources and templates", async ()=>{
-        const { manager, listResources, listResourceTemplates } = createManagerStub();
-        listResources.mockResolvedValue({
-            fal: [
-                {
-                    uri: "fal://jobs/1",
-                    name: "Job 1",
-                    mimeType: "application/json"
-                }
-            ]
-        });
-        listResourceTemplates.mockResolvedValue({
-            fal: [
-                {
-                    uriTemplate: "fal://jobs/{id}",
-                    name: "Job by id"
-                }
-            ]
-        });
-        const [listTool] = createMCPResourceTools(manager);
-        const output = await listTool.invoke({
-            includeTemplates: true
-        });
-        const parsed = JSON.parse(String(output));
-        expect(listResources).toHaveBeenCalledWith([]);
-        expect(listResourceTemplates).toHaveBeenCalledWith([]);
-        expect(parsed.resourceCount).toBe(1);
-        expect(parsed.resourceTemplateCount).toBe(1);
-        expect(parsed.resources.fal[0].uri).toBe("fal://jobs/1");
-    });
-    it("reads resource content without inlining binary blobs by default", async ()=>{
-        const { manager, readResource } = createManagerStub();
-        readResource.mockResolvedValue([
-            {
-                uri: "fal://jobs/1",
-                mimeType: "application/json",
-                text: "abcdefghijklmnopqrstuvwxyz",
-                blob: "YWJjZA=="
-            }
-        ]);
-        const tools = createMCPResourceTools(manager);
-        const readTool = tools.find((entry)=>"mcp_read_resource" === entry.name);
-        if (!readTool) throw new Error("mcp_read_resource tool missing");
-        const output = await readTool.invoke({
-            server: "fal",
-            uri: "fal://jobs/1",
-            maxTextChars: 10
-        });
-        const parsed = JSON.parse(String(output));
-        expect(readResource).toHaveBeenCalledWith("fal", "fal://jobs/1");
-        expect(parsed.content[0].text).toBe("abcdefghij");
-        expect(parsed.content[0].truncated).toBe(true);
-        expect(parsed.content[0].blobLength).toBe(8);
-        expect(parsed.content[0].blob).toBeUndefined();
-    });
-    it("can include binary blobs when requested", async ()=>{
-        const { manager, readResource } = createManagerStub();
-        readResource.mockResolvedValue([
-            {
-                uri: "fal://jobs/2",
-                mimeType: "image/png",
-                blob: "YWJjZA=="
-            }
-        ]);
-        const tools = createMCPResourceTools(manager);
-        const readTool = tools.find((entry)=>"mcp_read_resource" === entry.name);
-        if (!readTool) throw new Error("mcp_read_resource tool missing");
-        const output = await readTool.invoke({
-            server: "fal",
-            uri: "fal://jobs/2",
-            includeBinary: true
-        });
-        const parsed = JSON.parse(String(output));
-        expect(parsed.content[0].blob).toBe("YWJjZA==");
-    });
-});

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

@@ -1,190 +0,0 @@
-"use strict";
-var __webpack_exports__ = {};
-const anthropic_namespaceObject = require("@langchain/anthropic");
-const ollama_namespaceObject = require("@langchain/ollama");
-const openai_namespaceObject = require("@langchain/openai");
-const xai_namespaceObject = require("@langchain/xai");
-const external_vitest_namespaceObject = require("vitest");
-const modelFactory_cjs_namespaceObject = require("../config/modelFactory.cjs");
-const xaiImageModel_cjs_namespaceObject = require("../config/xaiImageModel.cjs");
-const originalAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
-const originalXaiApiKey = process.env.XAI_API_KEY;
-(0, external_vitest_namespaceObject.beforeEach)(()=>{
-    process.env.ANTHROPIC_API_KEY = "test-anthropic-api-key";
-    process.env.XAI_API_KEY = "test-xai-api-key";
-});
-(0, external_vitest_namespaceObject.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;
-});
-(0, external_vitest_namespaceObject.describe)("ModelFactory", ()=>{
-    (0, external_vitest_namespaceObject.describe)("createModel", ()=>{
-        (0, external_vitest_namespaceObject.it)("should create an Anthropic model", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("anthropic:claude-opus-4-5");
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(anthropic_namespaceObject.ChatAnthropic);
-        });
-        (0, external_vitest_namespaceObject.it)("should create an OpenAI model", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openai:gpt-4o");
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
-        });
-        (0, external_vitest_namespaceObject.it)("should create a Codex model", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("codex:codex-mini-latest");
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
-            (0, external_vitest_namespaceObject.expect)(model.useResponsesApi).toBe(true);
-            (0, external_vitest_namespaceObject.expect)(model.zdrEnabled).toBe(true);
-        });
-        (0, external_vitest_namespaceObject.it)("should force OpenAI models onto the responses API", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openai:gpt-5.2-codex");
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
-            (0, external_vitest_namespaceObject.expect)(model.useResponsesApi).toBe(true);
-        });
-        (0, external_vitest_namespaceObject.it)("should apply reasoning effort for supported OpenAI reasoning models", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openai:gpt-5.2-codex", {
-                reasoningEffort: "high"
-            });
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
-            (0, external_vitest_namespaceObject.expect)(model.reasoning).toEqual({
-                effort: "high"
-            });
-        });
-        (0, external_vitest_namespaceObject.it)("should ignore reasoning effort for unsupported OpenAI models", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openai:gpt-4o", {
-                reasoningEffort: "medium"
-            });
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
-            (0, external_vitest_namespaceObject.expect)(model.reasoning).toBeUndefined();
-        });
-        (0, external_vitest_namespaceObject.it)("should map reasoning effort to anthropic thinking budget", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("anthropic:claude-sonnet-4-5", {
-                reasoningEffort: "medium"
-            });
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(anthropic_namespaceObject.ChatAnthropic);
-            (0, external_vitest_namespaceObject.expect)(model.thinking).toEqual({
-                type: "enabled",
-                budget_tokens: 4096
-            });
-        });
-        (0, external_vitest_namespaceObject.it)("should create an OpenRouter model", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openrouter:openai/gpt-4o");
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
-        });
-        (0, external_vitest_namespaceObject.it)("should ignore reasoning effort for unsupported providers", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openrouter:openai/gpt-5", {
-                reasoningEffort: "high"
-            });
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
-            (0, external_vitest_namespaceObject.expect)(model.reasoning).toBeUndefined();
-        });
-        (0, external_vitest_namespaceObject.it)("should create a Copilot model", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("copilot:gpt-4o");
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
-        });
-        (0, external_vitest_namespaceObject.it)("should create an LMStudio model", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("lmstudio:llama-3.1-8b");
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
-        });
-        (0, external_vitest_namespaceObject.it)("should create an Ollama model", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("ollama:llama3.2");
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(ollama_namespaceObject.ChatOllama);
-            (0, external_vitest_namespaceObject.expect)(model.baseUrl).toBe("http://localhost:11434");
-        });
-        (0, external_vitest_namespaceObject.it)("should allow model names with additional colons", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("ollama:phi4:14b-q8_0");
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(ollama_namespaceObject.ChatOllama);
-        });
-        (0, external_vitest_namespaceObject.it)("should create native xAI image model for grok-imagine-image", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("xai:grok-imagine-image");
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(xaiImageModel_cjs_namespaceObject.NativeXAIImageModel);
-        });
-        (0, external_vitest_namespaceObject.it)("should keep text xAI models on ChatXAI", ()=>{
-            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("xai:grok-beta");
-            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(xai_namespaceObject.ChatXAI);
-        });
-        (0, external_vitest_namespaceObject.it)("should throw error for invalid format (missing colon)", ()=>{
-            (0, external_vitest_namespaceObject.expect)(()=>{
-                modelFactory_cjs_namespaceObject.ModelFactory.createModel("anthropic-claude-opus");
-            }).toThrow(/Invalid model format/);
-        });
-        (0, external_vitest_namespaceObject.it)("should throw error for invalid format (empty provider)", ()=>{
-            (0, external_vitest_namespaceObject.expect)(()=>{
-                modelFactory_cjs_namespaceObject.ModelFactory.createModel(":claude-opus-4-5");
-            }).toThrow(/Invalid model format/);
-        });
-        (0, external_vitest_namespaceObject.it)("should throw error for invalid format (empty model)", ()=>{
-            (0, external_vitest_namespaceObject.expect)(()=>{
-                modelFactory_cjs_namespaceObject.ModelFactory.createModel("anthropic:");
-            }).toThrow(/Invalid model format/);
-        });
-        (0, external_vitest_namespaceObject.it)("should throw error for unsupported provider", ()=>{
-            (0, external_vitest_namespaceObject.expect)(()=>{
-                modelFactory_cjs_namespaceObject.ModelFactory.createModel("unsupported:model-name");
-            }).toThrow(/Unknown model provider/);
-        });
-        (0, external_vitest_namespaceObject.it)("should be case insensitive for provider names", ()=>{
-            const model1 = modelFactory_cjs_namespaceObject.ModelFactory.createModel("Anthropic:claude-opus-4-5");
-            const model2 = modelFactory_cjs_namespaceObject.ModelFactory.createModel("ANTHROPIC:claude-opus-4-5");
-            (0, external_vitest_namespaceObject.expect)(model1).toBeInstanceOf(anthropic_namespaceObject.ChatAnthropic);
-            (0, external_vitest_namespaceObject.expect)(model2).toBeInstanceOf(anthropic_namespaceObject.ChatAnthropic);
-        });
-    });
-    (0, external_vitest_namespaceObject.describe)("validateModelString", ()=>{
-        (0, external_vitest_namespaceObject.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_cjs_namespaceObject.ModelFactory.validateModelString(modelString);
-                (0, external_vitest_namespaceObject.expect)(result.valid).toBe(true);
-                (0, external_vitest_namespaceObject.expect)(result.error).toBeUndefined();
-            }
-        });
-        (0, external_vitest_namespaceObject.it)("should reject invalid format", ()=>{
-            const result = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("invalid-format");
-            (0, external_vitest_namespaceObject.expect)(result.valid).toBe(false);
-            (0, external_vitest_namespaceObject.expect)(result.error).toContain("Invalid format");
-        });
-        (0, external_vitest_namespaceObject.it)("should reject empty provider", ()=>{
-            const result = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString(":model-name");
-            (0, external_vitest_namespaceObject.expect)(result.valid).toBe(false);
-            (0, external_vitest_namespaceObject.expect)(result.error).toContain("required");
-        });
-        (0, external_vitest_namespaceObject.it)("should reject empty model", ()=>{
-            const result = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("anthropic:");
-            (0, external_vitest_namespaceObject.expect)(result.valid).toBe(false);
-            (0, external_vitest_namespaceObject.expect)(result.error).toContain("required");
-        });
-        (0, external_vitest_namespaceObject.it)("should reject unsupported provider", ()=>{
-            const result = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("unsupported:model");
-            (0, external_vitest_namespaceObject.expect)(result.valid).toBe(false);
-            (0, external_vitest_namespaceObject.expect)(result.error).toContain("Unknown provider");
-        });
-        (0, external_vitest_namespaceObject.it)("should accept case variations of providers", ()=>{
-            const result1 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("Anthropic:model");
-            const result2 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("OPENAI:model");
-            const result3 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("CODEX:model");
-            const result4 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("Copilot:model");
-            const result5 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("LMStudio:model");
-            const result6 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("OLLAMA:model");
-            (0, external_vitest_namespaceObject.expect)(result1.valid).toBe(true);
-            (0, external_vitest_namespaceObject.expect)(result2.valid).toBe(true);
-            (0, external_vitest_namespaceObject.expect)(result3.valid).toBe(true);
-            (0, external_vitest_namespaceObject.expect)(result4.valid).toBe(true);
-            (0, external_vitest_namespaceObject.expect)(result5.valid).toBe(true);
-            (0, external_vitest_namespaceObject.expect)(result6.valid).toBe(true);
-        });
-    });
-});
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

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

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