@wingman-ai/gateway 0.5.3 → 0.5.4

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

@@ -1,218 +0,0 @@
-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",
-                reasoningEffort: "high",
-                blockedCommands: [
-                    "rm",
-                    "mv"
-                ],
-                allowScriptExecution: true,
-                commandTimeout: 300000,
-                browserProfile: "trading",
-                browserTransport: "relay"
-            };
-            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.reasoningEffort).toBe("high");
-                expect(result.data.blockedCommands).toEqual([
-                    "rm",
-                    "mv"
-                ]);
-                expect(result.data.allowScriptExecution).toBe(true);
-                expect(result.data.commandTimeout).toBe(300000);
-                expect(result.data.browserProfile).toBe("trading");
-                expect(result.data.browserTransport).toBe("relay");
-            }
-        });
-        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",
-                        reasoningEffort: "low"
-                    }
-                ]
-            };
-            const result = validateAgentConfig(config);
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.subAgents?.[0].model).toBe("openai:gpt-4o");
-                expect(result.data.subAgents?.[0].reasoningEffort).toBe("low");
-            }
-        });
-        it("should fail when a sub-agent shares the same name as its parent", ()=>{
-            const config = {
-                name: "coding",
-                description: "Parent coding agent",
-                systemPrompt: "You are the parent coding agent",
-                subAgents: [
-                    {
-                        name: "coding",
-                        description: "Nested coding worker",
-                        systemPrompt: "You are a worker"
-                    }
-                ]
-            };
-            const result = validateAgentConfig(config);
-            expect(result.success).toBe(false);
-            if (!result.success) expect(result.error).toContain("Sub-agent name must be different from parent agent name");
-        });
-        it("should fail when sub-agent names are duplicated", ()=>{
-            const config = {
-                name: "parent-agent",
-                description: "Parent agent",
-                systemPrompt: "You are the parent agent",
-                subAgents: [
-                    {
-                        name: "implementor",
-                        description: "First implementor",
-                        systemPrompt: "You implement changes"
-                    },
-                    {
-                        name: "IMPLEMENTOR",
-                        description: "Duplicate implementor",
-                        systemPrompt: "You implement more changes"
-                    }
-                ]
-            };
-            const result = validateAgentConfig(config);
-            expect(result.success).toBe(false);
-            if (!result.success) expect(result.error).toContain("Sub-agent names must be unique within the same parent agent");
-        });
-        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 fail validation for invalid reasoning effort", ()=>{
-            const config = {
-                name: "test-agent",
-                description: "Test",
-                systemPrompt: "Test",
-                reasoningEffort: "extreme"
-            };
-            const result = validateAgentConfig(config);
-            expect(result.success).toBe(false);
-            if (!result.success) expect(result.error).toContain("reasoningEffort");
-        });
-        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);
-        });
-        it("should accept prompt refinement configuration", ()=>{
-            const config = {
-                name: "refiner",
-                description: "Refines its prompt",
-                systemPrompt: "You are a refiner",
-                promptRefinement: true
-            };
-            const result = validateAgentConfig(config);
-            expect(result.success).toBe(true);
-            if (result.success) expect(result.data.promptRefinement?.enabled).toBe(true);
-            const configWithPath = {
-                name: "refiner-2",
-                description: "Refines its prompt with path",
-                systemPrompt: "You are a refiner",
-                promptRefinement: {
-                    instructionsPath: "/memories/agents/refiner-2/instructions.md"
-                }
-            };
-            const resultWithPath = validateAgentConfig(configWithPath);
-            expect(resultWithPath.success).toBe(true);
-            if (resultWithPath.success) {
-                expect(resultWithPath.data.promptRefinement?.instructionsPath).toBe("/memories/agents/refiner-2/instructions.md");
-                expect(resultWithPath.data.promptRefinement?.enabled).toBe(true);
-            }
-        });
-    });
-    describe("Tool names enum", ()=>{
-        it("should accept all valid tool names", ()=>{
-            const validTools = [
-                "internet_search",
-                "web_crawler",
-                "browser_control",
-                "command_execute",
-                "background_terminal",
-                "think",
-                "code_search",
-                "git_status",
-                "ui_registry_list",
-                "ui_registry_get",
-                "ui_present"
-            ];
-            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

@@ -1,335 +0,0 @@
-"use strict";
-var __webpack_exports__ = {};
-const external_node_fs_namespaceObject = require("node:fs");
-const external_node_path_namespaceObject = require("node:path");
-const external_vitest_namespaceObject = require("vitest");
-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 always inject node tools for top-level agents", async ()=>{
-            const agentDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "node-enabled-agent");
-            (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
-                recursive: true
-            });
-            const config = {
-                name: "node-enabled-agent",
-                description: "Agent with default node tools",
-                systemPrompt: "You are node capable"
-            };
-            (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("node-enabled-agent");
-            const toolNames = (agent?.tools || []).map((tool)=>tool.name);
-            (0, external_vitest_namespaceObject.expect)(toolNames).toContain("node_notify");
-            (0, external_vitest_namespaceObject.expect)(toolNames).toContain("node_run");
-        });
-        (0, external_vitest_namespaceObject.it)("should always inject and deduplicate node tools for subagents", async ()=>{
-            const agentDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "node-subagent-parent");
-            (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
-                recursive: true
-            });
-            const config = {
-                name: "node-subagent-parent",
-                description: "Parent agent",
-                systemPrompt: "You are the parent",
-                subAgents: [
-                    {
-                        name: "node-subagent",
-                        description: "Subagent",
-                        systemPrompt: "You are a subagent",
-                        tools: [
-                            "node_run"
-                        ]
-                    }
-                ]
-            };
-            (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("node-subagent-parent");
-            const sub = agent?.subagents?.[0];
-            const toolNames = (sub?.tools || []).map((tool)=>tool.name);
-            (0, external_vitest_namespaceObject.expect)(toolNames).toContain("node_notify");
-            (0, external_vitest_namespaceObject.expect)(toolNames.filter((name)=>"node_run" === name)).toHaveLength(1);
-        });
-        (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");
-        });
-        (0, external_vitest_namespaceObject.it)("should append prompt refinement instructions when enabled", async ()=>{
-            const agentDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "refiner-agent");
-            (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
-                recursive: true
-            });
-            const config = {
-                name: "refiner-agent",
-                description: "Agent that refines its prompt",
-                systemPrompt: "You are a refiner agent",
-                promptRefinement: 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 agent = await loader.loadAgent("refiner-agent");
-            (0, external_vitest_namespaceObject.expect)(agent).toBeDefined();
-            (0, external_vitest_namespaceObject.expect)(agent?.systemPrompt).toContain("[[wingman:prompt-refinement]]");
-            (0, external_vitest_namespaceObject.expect)(agent?.systemPrompt).toContain("/memories/agents/refiner-agent/instructions.md");
-            (0, external_vitest_namespaceObject.expect)(agent?.systemPrompt).toContain("overlay as secondary preference memory");
-        });
-        (0, external_vitest_namespaceObject.it)("should apply reasoningEffort when model supports it", async ()=>{
-            const agentDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "reasoning-agent");
-            (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
-                recursive: true
-            });
-            const config = {
-                name: "reasoning-agent",
-                description: "Agent with reasoning effort",
-                systemPrompt: "You are a reasoner",
-                model: "openai:gpt-5.2-codex",
-                reasoningEffort: "high"
-            };
-            (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("reasoning-agent");
-            const model = agent?.model;
-            (0, external_vitest_namespaceObject.expect)(model.reasoning?.effort).toBe("high");
-        });
-        (0, external_vitest_namespaceObject.it)("should normalize thinkingEffort alias to reasoningEffort", async ()=>{
-            const agentDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "legacy-thinking-agent");
-            (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
-                recursive: true
-            });
-            const config = {
-                name: "legacy-thinking-agent",
-                description: "Agent with legacy thinking effort field",
-                systemPrompt: "You are a reasoner",
-                model: "openai:gpt-5.2-codex",
-                thinkingEffort: "medium"
-            };
-            (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("legacy-thinking-agent");
-            const model = agent?.model;
-            (0, external_vitest_namespaceObject.expect)(model.reasoning?.effort).toBe("medium");
-        });
-    });
-});
-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

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