@wingman-ai/gateway 0.1.0

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

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

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

@@ -0,0 +1,126 @@
+import { describe, expect, it } from "vitest";
+import { AgentConfigSchema, validateAgentConfig } from "../config/agentConfig.js";
+describe("Agent Configuration Schema", ()=>{
+    describe("validateAgentConfig", ()=>{
+        it("should validate a valid minimal agent config", ()=>{
+            const config = {
+                name: "test-agent",
+                description: "A test agent",
+                systemPrompt: "You are a test agent"
+            };
+            const result = validateAgentConfig(config);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.name).toBe("test-agent");
+                expect(result.data.description).toBe("A test agent");
+                expect(result.data.systemPrompt).toBe("You are a test agent");
+            }
+        });
+        it("should validate a complete agent config with all fields", ()=>{
+            const config = {
+                name: "data-analyst",
+                description: "Analyzes data",
+                systemPrompt: "You are a data analyst",
+                tools: [
+                    "command_execute",
+                    "think"
+                ],
+                model: "anthropic:claude-opus-4-5",
+                blockedCommands: [
+                    "rm",
+                    "mv"
+                ],
+                allowScriptExecution: true,
+                commandTimeout: 300000
+            };
+            const result = validateAgentConfig(config);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.tools).toEqual([
+                    "command_execute",
+                    "think"
+                ]);
+                expect(result.data.model).toBe("anthropic:claude-opus-4-5");
+                expect(result.data.blockedCommands).toEqual([
+                    "rm",
+                    "mv"
+                ]);
+                expect(result.data.allowScriptExecution).toBe(true);
+                expect(result.data.commandTimeout).toBe(300000);
+            }
+        });
+        it("should allow subagents to override models", ()=>{
+            const config = {
+                name: "parent-agent",
+                description: "Parent agent",
+                systemPrompt: "You are the parent agent",
+                subAgents: [
+                    {
+                        name: "research-agent",
+                        description: "Researches topics",
+                        systemPrompt: "You are a researcher",
+                        model: "openai:gpt-4o"
+                    }
+                ]
+            };
+            const result = validateAgentConfig(config);
+            expect(result.success).toBe(true);
+            if (result.success) expect(result.data.subAgents?.[0].model).toBe("openai:gpt-4o");
+        });
+        it("should fail validation for missing required fields", ()=>{
+            const config = {
+                name: "test-agent"
+            };
+            const result = validateAgentConfig(config);
+            expect(result.success).toBe(false);
+            if (!result.success) {
+                expect(result.error).toContain("description");
+                expect(result.error).toContain("systemPrompt");
+            }
+        });
+        it("should fail validation for invalid tool names", ()=>{
+            const config = {
+                name: "test-agent",
+                description: "Test",
+                systemPrompt: "Test",
+                tools: [
+                    "invalid_tool"
+                ]
+            };
+            const result = validateAgentConfig(config);
+            expect(result.success).toBe(false);
+        });
+        it("should apply default values for optional fields", ()=>{
+            const config = {
+                name: "test-agent",
+                description: "Test",
+                systemPrompt: "Test"
+            };
+            const parsed = AgentConfigSchema.parse(config);
+            expect(parsed.allowScriptExecution).toBe(true);
+            expect(parsed.commandTimeout).toBe(300000);
+        });
+    });
+    describe("Tool names enum", ()=>{
+        it("should accept all valid tool names", ()=>{
+            const validTools = [
+                "internet_search",
+                "web_crawler",
+                "command_execute",
+                "think"
+            ];
+            for (const tool of validTools){
+                const config = {
+                    name: "test",
+                    description: "test",
+                    systemPrompt: "test",
+                    tools: [
+                        tool
+                    ]
+                };
+                const result = validateAgentConfig(config);
+                expect(result.success).toBe(true);
+            }
+        });
+    });
+});

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

@@ -0,0 +1,235 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+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 TEST_CONFIG_DIR = ".wingman-test";
+(0, external_vitest_namespaceObject.describe)("AgentConfigLoader", ()=>{
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        if ((0, external_node_fs_namespaceObject.existsSync)(TEST_CONFIG_DIR)) (0, external_node_fs_namespaceObject.rmSync)(TEST_CONFIG_DIR, {
+            recursive: true,
+            force: true
+        });
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        if ((0, external_node_fs_namespaceObject.existsSync)(TEST_CONFIG_DIR)) (0, external_node_fs_namespaceObject.rmSync)(TEST_CONFIG_DIR, {
+            recursive: true,
+            force: true
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("loadAllAgentConfigs", ()=>{
+        (0, external_vitest_namespaceObject.it)("should return empty array when no config exists", ()=>{
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toEqual([]);
+        });
+        (0, external_vitest_namespaceObject.it)("should load agent from a single agent directory", ()=>{
+            const agentDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "test-agent");
+            (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            const config = {
+                name: "test-agent",
+                description: "A test agent",
+                systemPrompt: "You are a test agent",
+                tools: [
+                    "think"
+                ]
+            };
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify(config));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toHaveLength(1);
+            (0, external_vitest_namespaceObject.expect)(agents[0].name).toBe("test-agent");
+            (0, external_vitest_namespaceObject.expect)(agents[0].description).toBe("A test agent");
+            (0, external_vitest_namespaceObject.expect)(agents[0].systemPrompt).toBe("You are a test agent");
+            (0, external_vitest_namespaceObject.expect)(agents[0].tools).toHaveLength(1);
+        });
+        (0, external_vitest_namespaceObject.it)("should load agents from a directory of agent.json files", ()=>{
+            const agent1Dir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "agent-1");
+            const agent2Dir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "agent-2");
+            (0, external_node_fs_namespaceObject.mkdirSync)(agent1Dir, {
+                recursive: true
+            });
+            (0, external_node_fs_namespaceObject.mkdirSync)(agent2Dir, {
+                recursive: true
+            });
+            const agent1 = {
+                name: "agent-1",
+                description: "First agent",
+                systemPrompt: "You are agent 1"
+            };
+            const agent2 = {
+                name: "agent-2",
+                description: "Second agent",
+                systemPrompt: "You are agent 2",
+                tools: [
+                    "web_crawler"
+                ]
+            };
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agent1Dir, "agent.json"), JSON.stringify(agent1));
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agent2Dir, "agent.json"), JSON.stringify(agent2));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toHaveLength(2);
+            (0, external_vitest_namespaceObject.expect)(agents.map((agent)=>agent.name)).toContain("agent-1");
+            (0, external_vitest_namespaceObject.expect)(agents.map((agent)=>agent.name)).toContain("agent-2");
+            const agentWithTools = agents.find((agent)=>"agent-2" === agent.name);
+            (0, external_vitest_namespaceObject.expect)(agentWithTools?.tools).toHaveLength(1);
+        });
+        (0, external_vitest_namespaceObject.it)("should prioritize agent.json over agent.md", ()=>{
+            const agentDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "mixed-agent");
+            (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            const jsonConfig = {
+                name: "from-json",
+                description: "From JSON",
+                systemPrompt: "JSON agent"
+            };
+            const markdownConfig = `---
+name: from-markdown
+description: From Markdown
+---
+Markdown agent`;
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify(jsonConfig));
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agentDir, "agent.md"), markdownConfig);
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toHaveLength(1);
+            (0, external_vitest_namespaceObject.expect)(agents[0].name).toBe("from-json");
+        });
+        (0, external_vitest_namespaceObject.it)("should handle malformed JSON gracefully", ()=>{
+            const agentDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "bad-agent");
+            (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agentDir, "agent.json"), "{ invalid json");
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toEqual([]);
+        });
+        (0, external_vitest_namespaceObject.it)("should skip invalid agent configs in directory", ()=>{
+            const validDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "valid-agent");
+            const invalidDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "invalid-agent");
+            (0, external_node_fs_namespaceObject.mkdirSync)(validDir, {
+                recursive: true
+            });
+            (0, external_node_fs_namespaceObject.mkdirSync)(invalidDir, {
+                recursive: true
+            });
+            const validAgent = {
+                name: "valid-agent",
+                description: "Valid agent",
+                systemPrompt: "Valid"
+            };
+            const invalidAgent = {
+                name: "invalid-agent"
+            };
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(validDir, "agent.json"), JSON.stringify(validAgent));
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(invalidDir, "agent.json"), JSON.stringify(invalidAgent));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toHaveLength(1);
+            (0, external_vitest_namespaceObject.expect)(agents[0].name).toBe("valid-agent");
+        });
+        (0, external_vitest_namespaceObject.it)("should create agent with model override", ()=>{
+            const config = {
+                name: "custom-model-agent",
+                description: "Agent with custom model",
+                systemPrompt: "You are a custom agent",
+                model: "anthropic:claude-opus-4-5"
+            };
+            const agentDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "custom-model-agent");
+            (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify(config));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toHaveLength(1);
+            (0, external_vitest_namespaceObject.expect)(agents[0].model).toBeDefined();
+        });
+        (0, external_vitest_namespaceObject.it)("should create agent with command_execute tool and custom options", ()=>{
+            const config = {
+                name: "executor-agent",
+                description: "Executes commands",
+                systemPrompt: "You execute commands",
+                tools: [
+                    "command_execute"
+                ],
+                blockedCommands: [
+                    "rm",
+                    "mv"
+                ],
+                allowScriptExecution: false,
+                commandTimeout: 60000
+            };
+            const agentDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "executor-agent");
+            (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify(config));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toHaveLength(1);
+            (0, external_vitest_namespaceObject.expect)(agents[0].tools).toHaveLength(1);
+            (0, external_vitest_namespaceObject.expect)(agents[0].tools?.[0]).toBe("command_execute");
+        });
+        (0, external_vitest_namespaceObject.it)("should ignore non-JSON files in directory", ()=>{
+            const agentDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "valid-agent");
+            (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            const validAgent = {
+                name: "valid-agent",
+                description: "Valid",
+                systemPrompt: "Valid"
+            };
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify(validAgent));
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agentDir, "readme.md"), "# README");
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agentDir, "notes.txt"), "Some notes");
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toHaveLength(1);
+            (0, external_vitest_namespaceObject.expect)(agents[0].name).toBe("valid-agent");
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("loadAgent", ()=>{
+        (0, external_vitest_namespaceObject.it)("should hydrate subagent tools for runtime use", async ()=>{
+            const agentDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "parent-agent");
+            (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            const config = {
+                name: "parent-agent",
+                description: "Parent agent",
+                systemPrompt: "You are the parent",
+                subAgents: [
+                    {
+                        name: "researcher",
+                        description: "Research subagent",
+                        systemPrompt: "You research things",
+                        tools: [
+                            "think"
+                        ]
+                    }
+                ]
+            };
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify(config));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(TEST_CONFIG_DIR);
+            const agent = await loader.loadAgent("parent-agent");
+            (0, external_vitest_namespaceObject.expect)(agent).toBeDefined();
+            (0, external_vitest_namespaceObject.expect)(agent?.subagents).toBeDefined();
+            (0, external_vitest_namespaceObject.expect)(agent?.subagents?.length).toBe(1);
+            const sub = agent?.subagents?.[0];
+            (0, external_vitest_namespaceObject.expect)(Array.isArray(sub.tools)).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(sub.tools?.[0]).toHaveProperty("name", "think");
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

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

@@ -0,0 +1,229 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { AgentLoader } from "../config/agentLoader.js";
+const TEST_CONFIG_DIR = ".wingman-test";
+describe("AgentConfigLoader", ()=>{
+    beforeEach(()=>{
+        if (existsSync(TEST_CONFIG_DIR)) rmSync(TEST_CONFIG_DIR, {
+            recursive: true,
+            force: true
+        });
+    });
+    afterEach(()=>{
+        if (existsSync(TEST_CONFIG_DIR)) rmSync(TEST_CONFIG_DIR, {
+            recursive: true,
+            force: true
+        });
+    });
+    describe("loadAllAgentConfigs", ()=>{
+        it("should return empty array when no config exists", ()=>{
+            const loader = new AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toEqual([]);
+        });
+        it("should load agent from a single agent directory", ()=>{
+            const agentDir = join(TEST_CONFIG_DIR, "agents", "test-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            const config = {
+                name: "test-agent",
+                description: "A test agent",
+                systemPrompt: "You are a test agent",
+                tools: [
+                    "think"
+                ]
+            };
+            writeFileSync(join(agentDir, "agent.json"), JSON.stringify(config));
+            const loader = new AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toHaveLength(1);
+            expect(agents[0].name).toBe("test-agent");
+            expect(agents[0].description).toBe("A test agent");
+            expect(agents[0].systemPrompt).toBe("You are a test agent");
+            expect(agents[0].tools).toHaveLength(1);
+        });
+        it("should load agents from a directory of agent.json files", ()=>{
+            const agent1Dir = join(TEST_CONFIG_DIR, "agents", "agent-1");
+            const agent2Dir = join(TEST_CONFIG_DIR, "agents", "agent-2");
+            mkdirSync(agent1Dir, {
+                recursive: true
+            });
+            mkdirSync(agent2Dir, {
+                recursive: true
+            });
+            const agent1 = {
+                name: "agent-1",
+                description: "First agent",
+                systemPrompt: "You are agent 1"
+            };
+            const agent2 = {
+                name: "agent-2",
+                description: "Second agent",
+                systemPrompt: "You are agent 2",
+                tools: [
+                    "web_crawler"
+                ]
+            };
+            writeFileSync(join(agent1Dir, "agent.json"), JSON.stringify(agent1));
+            writeFileSync(join(agent2Dir, "agent.json"), JSON.stringify(agent2));
+            const loader = new AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toHaveLength(2);
+            expect(agents.map((agent)=>agent.name)).toContain("agent-1");
+            expect(agents.map((agent)=>agent.name)).toContain("agent-2");
+            const agentWithTools = agents.find((agent)=>"agent-2" === agent.name);
+            expect(agentWithTools?.tools).toHaveLength(1);
+        });
+        it("should prioritize agent.json over agent.md", ()=>{
+            const agentDir = join(TEST_CONFIG_DIR, "agents", "mixed-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            const jsonConfig = {
+                name: "from-json",
+                description: "From JSON",
+                systemPrompt: "JSON agent"
+            };
+            const markdownConfig = `---
+name: from-markdown
+description: From Markdown
+---
+Markdown agent`;
+            writeFileSync(join(agentDir, "agent.json"), JSON.stringify(jsonConfig));
+            writeFileSync(join(agentDir, "agent.md"), markdownConfig);
+            const loader = new AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toHaveLength(1);
+            expect(agents[0].name).toBe("from-json");
+        });
+        it("should handle malformed JSON gracefully", ()=>{
+            const agentDir = join(TEST_CONFIG_DIR, "agents", "bad-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            writeFileSync(join(agentDir, "agent.json"), "{ invalid json");
+            const loader = new AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toEqual([]);
+        });
+        it("should skip invalid agent configs in directory", ()=>{
+            const validDir = join(TEST_CONFIG_DIR, "agents", "valid-agent");
+            const invalidDir = join(TEST_CONFIG_DIR, "agents", "invalid-agent");
+            mkdirSync(validDir, {
+                recursive: true
+            });
+            mkdirSync(invalidDir, {
+                recursive: true
+            });
+            const validAgent = {
+                name: "valid-agent",
+                description: "Valid agent",
+                systemPrompt: "Valid"
+            };
+            const invalidAgent = {
+                name: "invalid-agent"
+            };
+            writeFileSync(join(validDir, "agent.json"), JSON.stringify(validAgent));
+            writeFileSync(join(invalidDir, "agent.json"), JSON.stringify(invalidAgent));
+            const loader = new AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toHaveLength(1);
+            expect(agents[0].name).toBe("valid-agent");
+        });
+        it("should create agent with model override", ()=>{
+            const config = {
+                name: "custom-model-agent",
+                description: "Agent with custom model",
+                systemPrompt: "You are a custom agent",
+                model: "anthropic:claude-opus-4-5"
+            };
+            const agentDir = join(TEST_CONFIG_DIR, "agents", "custom-model-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            writeFileSync(join(agentDir, "agent.json"), JSON.stringify(config));
+            const loader = new AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toHaveLength(1);
+            expect(agents[0].model).toBeDefined();
+        });
+        it("should create agent with command_execute tool and custom options", ()=>{
+            const config = {
+                name: "executor-agent",
+                description: "Executes commands",
+                systemPrompt: "You execute commands",
+                tools: [
+                    "command_execute"
+                ],
+                blockedCommands: [
+                    "rm",
+                    "mv"
+                ],
+                allowScriptExecution: false,
+                commandTimeout: 60000
+            };
+            const agentDir = join(TEST_CONFIG_DIR, "agents", "executor-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            writeFileSync(join(agentDir, "agent.json"), JSON.stringify(config));
+            const loader = new AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toHaveLength(1);
+            expect(agents[0].tools).toHaveLength(1);
+            expect(agents[0].tools?.[0]).toBe("command_execute");
+        });
+        it("should ignore non-JSON files in directory", ()=>{
+            const agentDir = join(TEST_CONFIG_DIR, "agents", "valid-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            const validAgent = {
+                name: "valid-agent",
+                description: "Valid",
+                systemPrompt: "Valid"
+            };
+            writeFileSync(join(agentDir, "agent.json"), JSON.stringify(validAgent));
+            writeFileSync(join(agentDir, "readme.md"), "# README");
+            writeFileSync(join(agentDir, "notes.txt"), "Some notes");
+            const loader = new AgentLoader(TEST_CONFIG_DIR);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toHaveLength(1);
+            expect(agents[0].name).toBe("valid-agent");
+        });
+    });
+    describe("loadAgent", ()=>{
+        it("should hydrate subagent tools for runtime use", async ()=>{
+            const agentDir = join(TEST_CONFIG_DIR, "agents", "parent-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            const config = {
+                name: "parent-agent",
+                description: "Parent agent",
+                systemPrompt: "You are the parent",
+                subAgents: [
+                    {
+                        name: "researcher",
+                        description: "Research subagent",
+                        systemPrompt: "You research things",
+                        tools: [
+                            "think"
+                        ]
+                    }
+                ]
+            };
+            writeFileSync(join(agentDir, "agent.json"), JSON.stringify(config));
+            const loader = new AgentLoader(TEST_CONFIG_DIR);
+            const agent = await loader.loadAgent("parent-agent");
+            expect(agent).toBeDefined();
+            expect(agent?.subagents).toBeDefined();
+            expect(agent?.subagents?.length).toBe(1);
+            const sub = agent?.subagents?.[0];
+            expect(Array.isArray(sub.tools)).toBe(true);
+            expect(sub.tools?.[0]).toHaveProperty("name", "think");
+        });
+    });
+});