@wingman-ai/gateway 0.1.0

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

@@ -0,0 +1,114 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const modelFactory_cjs_namespaceObject = require("../config/modelFactory.cjs");
+const anthropic_namespaceObject = require("@langchain/anthropic");
+const openai_namespaceObject = require("@langchain/openai");
+(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 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 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(openai_namespaceObject.ChatOpenAI);
+        });
+        (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",
+                "anthropic:claude-sonnet-4-5-20250929",
+                "openrouter:openai/gpt-4o",
+                "copilot:gpt-4o",
+                "lmstudio:llama-3.1-8b",
+                "ollama:llama3.2"
+            ];
+            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("Copilot:model");
+            const result4 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("LMStudio:model");
+            const result5 = 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);
+        });
+    });
+});
+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

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

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

@@ -0,0 +1,108 @@
+import { describe, expect, it } from "vitest";
+import { ModelFactory } from "../config/modelFactory.js";
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatOpenAI } from "@langchain/openai";
+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 an OpenRouter model", ()=>{
+            const model = ModelFactory.createModel("openrouter:openai/gpt-4o");
+            expect(model).toBeInstanceOf(ChatOpenAI);
+        });
+        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(ChatOpenAI);
+        });
+        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",
+                "anthropic:claude-sonnet-4-5-20250929",
+                "openrouter:openai/gpt-4o",
+                "copilot:gpt-4o",
+                "lmstudio:llama-3.1-8b",
+                "ollama:llama3.2"
+            ];
+            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("Copilot:model");
+            const result4 = ModelFactory.validateModelString("LMStudio:model");
+            const result5 = 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);
+        });
+    });
+});

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

@@ -0,0 +1,33 @@
+"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

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

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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,99 @@
+"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

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

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

@@ -0,0 +1,93 @@
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { AgentLoader } from "../config/agentLoader.js";
+const testDir = join(process.cwd(), ".test-subagents");
+const testAgentsDir = join(testDir, "agents");
+function cleanup() {
+    if (existsSync(testDir)) {
+        unlinkSync(join(testAgentsDir, "parent-agent.json"));
+        process.chdir(process.cwd());
+    }
+}
+try {
+    if (!existsSync(testDir)) mkdirSync(testDir, {
+        recursive: true
+    });
+    if (!existsSync(testAgentsDir)) 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"
+                ]
+            }
+        ]
+    };
+    writeFileSync(join(testAgentsDir, "parent-agent.json"), JSON.stringify(agentWithSubagents, null, 2));
+    const loader1 = new 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"
+                    }
+                ]
+            }
+        ]
+    };
+    writeFileSync(join(testAgentsDir, "parent-agent.json"), JSON.stringify(invalidAgent, null, 2));
+    const loader2 = new 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);
+}

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

@@ -0,0 +1,109 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const toolRegistry_cjs_namespaceObject = require("../config/toolRegistry.cjs");
+(0, external_vitest_namespaceObject.describe)("Tool Registry", ()=>{
+    (0, external_vitest_namespaceObject.describe)("createTool", ()=>{
+        (0, external_vitest_namespaceObject.it)("should create internet_search tool", ()=>{
+            const tool = (0, toolRegistry_cjs_namespaceObject.createTool)("internet_search");
+            (0, external_vitest_namespaceObject.expect)(tool).not.toBeNull();
+            (0, external_vitest_namespaceObject.expect)(tool?.name).toBe("internet_search");
+        });
+        (0, external_vitest_namespaceObject.it)("should create web_crawler tool", ()=>{
+            const tool = (0, toolRegistry_cjs_namespaceObject.createTool)("web_crawler");
+            (0, external_vitest_namespaceObject.expect)(tool).not.toBeNull();
+            (0, external_vitest_namespaceObject.expect)(tool?.name).toBe("web_crawler");
+        });
+        (0, external_vitest_namespaceObject.it)("should create command_execute tool with default options", ()=>{
+            const tool = (0, toolRegistry_cjs_namespaceObject.createTool)("command_execute");
+            (0, external_vitest_namespaceObject.expect)(tool).not.toBeNull();
+            (0, external_vitest_namespaceObject.expect)(tool?.name).toBe("command_execute");
+        });
+        (0, external_vitest_namespaceObject.it)("should create command_execute tool with custom options", ()=>{
+            const tool = (0, toolRegistry_cjs_namespaceObject.createTool)("command_execute", {
+                workspace: "/custom/path",
+                blockedCommands: [
+                    "rm",
+                    "mv"
+                ],
+                allowScriptExecution: false,
+                timeout: 60000
+            });
+            (0, external_vitest_namespaceObject.expect)(tool).not.toBeNull();
+            (0, external_vitest_namespaceObject.expect)(tool?.name).toBe("command_execute");
+        });
+        (0, external_vitest_namespaceObject.it)("should create think tool", ()=>{
+            const tool = (0, toolRegistry_cjs_namespaceObject.createTool)("think");
+            (0, external_vitest_namespaceObject.expect)(tool).not.toBeNull();
+            (0, external_vitest_namespaceObject.expect)(tool?.name).toBe("think");
+        });
+        (0, external_vitest_namespaceObject.it)("should return null for unknown tool name", ()=>{
+            const tool = (0, toolRegistry_cjs_namespaceObject.createTool)("unknown_tool");
+            (0, external_vitest_namespaceObject.expect)(tool).toBeNull();
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("createTools", ()=>{
+        (0, external_vitest_namespaceObject.it)("should create multiple tools from array", async ()=>{
+            const tools = await (0, toolRegistry_cjs_namespaceObject.createTools)([
+                "internet_search",
+                "web_crawler",
+                "think"
+            ]);
+            (0, external_vitest_namespaceObject.expect)(tools).toHaveLength(3);
+            (0, external_vitest_namespaceObject.expect)(tools[0].name).toBe("internet_search");
+            (0, external_vitest_namespaceObject.expect)(tools[1].name).toBe("web_crawler");
+            (0, external_vitest_namespaceObject.expect)(tools[2].name).toBe("think");
+        });
+        (0, external_vitest_namespaceObject.it)("should create empty array for empty input", async ()=>{
+            const tools = await (0, toolRegistry_cjs_namespaceObject.createTools)([]);
+            (0, external_vitest_namespaceObject.expect)(tools).toHaveLength(0);
+        });
+        (0, external_vitest_namespaceObject.it)("should skip unknown tool names", async ()=>{
+            const tools = await (0, toolRegistry_cjs_namespaceObject.createTools)([
+                "internet_search",
+                "unknown_tool",
+                "think"
+            ]);
+            (0, external_vitest_namespaceObject.expect)(tools).toHaveLength(2);
+            (0, external_vitest_namespaceObject.expect)(tools[0].name).toBe("internet_search");
+            (0, external_vitest_namespaceObject.expect)(tools[1].name).toBe("think");
+        });
+        (0, external_vitest_namespaceObject.it)("should pass options to all tools", async ()=>{
+            const tools = await (0, toolRegistry_cjs_namespaceObject.createTools)([
+                "command_execute"
+            ], {
+                workspace: "/test/path",
+                timeout: 30000
+            });
+            (0, external_vitest_namespaceObject.expect)(tools).toHaveLength(1);
+            (0, external_vitest_namespaceObject.expect)(tools[0].name).toBe("command_execute");
+        });
+        (0, external_vitest_namespaceObject.it)("should create all available tools", async ()=>{
+            const availableTools = (0, toolRegistry_cjs_namespaceObject.getAvailableTools)();
+            const tools = await (0, toolRegistry_cjs_namespaceObject.createTools)(availableTools);
+            (0, external_vitest_namespaceObject.expect)(tools).toHaveLength(availableTools.length);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("getAvailableTools", ()=>{
+        (0, external_vitest_namespaceObject.it)("should return all available tool names", ()=>{
+            const tools = (0, toolRegistry_cjs_namespaceObject.getAvailableTools)();
+            (0, external_vitest_namespaceObject.expect)(tools).toEqual([
+                "internet_search",
+                "web_crawler",
+                "command_execute",
+                "think",
+                "code_search",
+                "git_status"
+            ]);
+        });
+        (0, external_vitest_namespaceObject.it)("should return a consistent list", ()=>{
+            const tools1 = (0, toolRegistry_cjs_namespaceObject.getAvailableTools)();
+            const tools2 = (0, toolRegistry_cjs_namespaceObject.getAvailableTools)();
+            (0, external_vitest_namespaceObject.expect)(tools1).toEqual(tools2);
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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