@wingman-ai/gateway 0.1.0

package/dist/agent/config/agentLoader.cjs

@@ -0,0 +1,242 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    AgentLoader: ()=>AgentLoader
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_js_yaml_namespaceObject = require("js-yaml");
+const external_agentConfig_cjs_namespaceObject = require("./agentConfig.cjs");
+const external_toolRegistry_cjs_namespaceObject = require("./toolRegistry.cjs");
+const external_modelFactory_cjs_namespaceObject = require("./modelFactory.cjs");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+class AgentLoader {
+    resolveConfigPath(...segments) {
+        const baseDir = (0, external_node_path_namespaceObject.isAbsolute)(this.configDir) ? this.configDir : (0, external_node_path_namespaceObject.join)(this.workspace, this.configDir);
+        return (0, external_node_path_namespaceObject.join)(baseDir, ...segments);
+    }
+    loadAllAgentConfigs() {
+        const agents = [];
+        const agentsDir = this.resolveConfigPath("agents");
+        if ((0, external_node_fs_namespaceObject.existsSync)(agentsDir) && (0, external_node_fs_namespaceObject.statSync)(agentsDir).isDirectory()) {
+            logger.info(`Loading agents from directory: ${agentsDir}`);
+            const agentDirs = (0, external_node_fs_namespaceObject.readdirSync)(agentsDir, {
+                withFileTypes: true
+            }).filter((dirent)=>dirent.isDirectory()).map((dirent)=>dirent.name);
+            for (const agentDir of agentDirs){
+                const agentDirPath = (0, external_node_path_namespaceObject.join)(agentsDir, agentDir);
+                const agentJsonPath = (0, external_node_path_namespaceObject.join)(agentDirPath, "agent.json");
+                const agentMarkdownPath = (0, external_node_path_namespaceObject.join)(agentDirPath, "agent.md");
+                const hasJson = (0, external_node_fs_namespaceObject.existsSync)(agentJsonPath);
+                const hasMarkdown = (0, external_node_fs_namespaceObject.existsSync)(agentMarkdownPath);
+                if (!hasJson && !hasMarkdown) {
+                    logger.warn(`Skipping ${agentDir}: agent.json or agent.md not found`);
+                    continue;
+                }
+                try {
+                    const agentFilePath = hasJson ? agentJsonPath : agentMarkdownPath;
+                    const json = hasJson ? this.loadFromJson(agentJsonPath) : this.loadFromMarkdown(agentMarkdownPath, agentDirPath);
+                    const validation = (0, external_agentConfig_cjs_namespaceObject.validateAgentConfig)(json);
+                    if (!validation.success) {
+                        logger.error(`Failed to validate ${agentFilePath}:\n${validation.error}`);
+                        continue;
+                    }
+                    agents.push(validation.data);
+                    logger.info(`Loaded agent config: ${validation.data.name}`);
+                } catch (error) {
+                    logger.error(`Failed to load agent from ${agentDirPath}: ${error}`);
+                }
+            }
+        } else logger.info(`No agents directory found at: ${agentsDir}`);
+        return agents;
+    }
+    parseFrontmatter(content) {
+        const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+        const match = content.match(frontmatterRegex);
+        if (!match) throw new Error("Invalid agent.md format: missing frontmatter");
+        const [, frontmatter, prompt] = match;
+        try {
+            const metadata = external_js_yaml_namespaceObject.load(frontmatter);
+            if (!metadata || "object" != typeof metadata) throw new Error("Frontmatter must be a valid YAML object");
+            return {
+                metadata,
+                prompt: prompt.trim()
+            };
+        } catch (error) {
+            throw new Error(`Failed to parse frontmatter: ${error}`);
+        }
+    }
+    normalizeAgentConfig(config) {
+        if (config.subagents && !config.subAgents) {
+            config.subAgents = config.subagents;
+            delete config.subagents;
+        }
+        if (Array.isArray(config.subAgents)) {
+            for (const subagent of config.subAgents)if (subagent?.subagents && !subagent.subAgents) {
+                subagent.subAgents = subagent.subagents;
+                delete subagent.subagents;
+            }
+        }
+        return config;
+    }
+    loadFromJson(filePath) {
+        const content = (0, external_node_fs_namespaceObject.readFileSync)(filePath, "utf-8");
+        const json = JSON.parse(content);
+        return this.normalizeAgentConfig(json);
+    }
+    loadFromMarkdown(filePath, agentDir) {
+        const content = (0, external_node_fs_namespaceObject.readFileSync)(filePath, "utf-8");
+        const { metadata, prompt } = this.parseFrontmatter(content);
+        const config = this.normalizeAgentConfig({
+            ...metadata,
+            systemPrompt: prompt
+        });
+        if (config.subAgents && Array.isArray(config.subAgents)) {
+            for (const subagent of config.subAgents)if (subagent.promptFile) {
+                const promptPath = (0, external_node_path_namespaceObject.join)(agentDir, subagent.promptFile);
+                if (!(0, external_node_fs_namespaceObject.existsSync)(promptPath)) throw new Error(`Subagent prompt file not found: ${promptPath}`);
+                const subagentContent = (0, external_node_fs_namespaceObject.readFileSync)(promptPath, "utf-8");
+                if (subagentContent.startsWith("---")) {
+                    const parsed = this.parseFrontmatter(subagentContent);
+                    Object.assign(subagent, parsed.metadata);
+                    subagent.systemPrompt = parsed.prompt;
+                } else subagent.systemPrompt = subagentContent.trim();
+                delete subagent.promptFile;
+            }
+        }
+        return config;
+    }
+    async loadAgent(agentName) {
+        let agent;
+        const customAgentsDir = this.resolveConfigPath("agents", agentName);
+        if ((0, external_node_fs_namespaceObject.existsSync)(customAgentsDir) && (0, external_node_fs_namespaceObject.statSync)(customAgentsDir).isDirectory()) {
+            logger.info(`Loading agent from directory: ${customAgentsDir}`);
+            agent = await this.loadFromDirectory(customAgentsDir);
+        }
+        return agent;
+    }
+    async loadFromDirectory(dirPath) {
+        const agentJsonPath = (0, external_node_path_namespaceObject.join)(dirPath, "agent.json");
+        const agentMarkdownPath = (0, external_node_path_namespaceObject.join)(dirPath, "agent.md");
+        const hasJson = (0, external_node_fs_namespaceObject.existsSync)(agentJsonPath);
+        const hasMarkdown = (0, external_node_fs_namespaceObject.existsSync)(agentMarkdownPath);
+        try {
+            if (!hasJson && !hasMarkdown) throw new Error(`Agent config file not found: ${agentJsonPath} or ${agentMarkdownPath}`);
+            const json = hasJson ? this.loadFromJson(agentJsonPath) : this.loadFromMarkdown(agentMarkdownPath, dirPath);
+            logger.info(`Loading agent from ${hasJson ? "JSON" : "markdown"}: ${hasJson ? agentJsonPath : agentMarkdownPath}`);
+            const validation = (0, external_agentConfig_cjs_namespaceObject.validateAgentConfig)(json);
+            if (!validation.success) throw new Error(`Failed to validate ${hasJson ? agentJsonPath : agentMarkdownPath}:\n${validation.error}`);
+            const agent = await this.createAgent(validation.data);
+            if (agent.subagents && agent.subagents.length > 0) {
+                logger.info(`Agent "${agent.name}" has ${agent.subagents.length} subagent(s)`);
+                for (const subagent of agent.subagents)if ("subagents" in subagent && subagent.subagents) {
+                    logger.warn(`Subagent "${subagent.name}" has its own subagents, which is not currently supported. Ignoring nested subagents.`);
+                    subagent.subagents = [];
+                }
+            }
+            logger.info(`Loaded custom agent: ${agent.name} from ${dirPath}`);
+            return agent;
+        } catch (error) {
+            throw new Error(`Failed to load agent from ${dirPath}: ${error}`);
+        }
+    }
+    async createAgent(config) {
+        const agent = {
+            name: config.name,
+            description: config.description,
+            systemPrompt: config.systemPrompt
+        };
+        const buildToolOptions = (source)=>{
+            const mcpConfigs = [];
+            if (source.mcp) mcpConfigs.push(source.mcp);
+            if (source.mcpUseGlobal && this.wingmanConfig?.mcp) mcpConfigs.push(this.wingmanConfig.mcp);
+            return {
+                workspace: this.workspace,
+                blockedCommands: source.blockedCommands,
+                allowScriptExecution: source.allowScriptExecution,
+                timeout: source.commandTimeout,
+                searchConfig: this.wingmanConfig?.search,
+                mcpConfigs
+            };
+        };
+        if (config.tools && config.tools.length > 0) agent.tools = await (0, external_toolRegistry_cjs_namespaceObject.createTools)(config.tools, buildToolOptions(config));
+        if (config.mcp) agent.mcpConfig = config.mcp;
+        if (config.mcpUseGlobal) agent.mcpUseGlobal = true;
+        if (config.model) try {
+            agent.model = external_modelFactory_cjs_namespaceObject.ModelFactory.createModel(config.model);
+            logger.info(`Agent "${config.name}" using model: ${config.model}`);
+        } catch (error) {
+            logger.error(`Failed to create model for agent "${config.name}": ${error}`);
+            logger.info(`Agent "${config.name}" will use default model`);
+        }
+        if (config.subAgents) {
+            const subagents = [];
+            for (const subagent of config.subAgents){
+                const sub = {
+                    name: subagent.name,
+                    description: subagent.description,
+                    systemPrompt: subagent.systemPrompt
+                };
+                if (subagent.tools && subagent.tools.length > 0) sub.tools = await (0, external_toolRegistry_cjs_namespaceObject.createTools)(subagent.tools, buildToolOptions(subagent));
+                if (subagent.model) try {
+                    sub.model = external_modelFactory_cjs_namespaceObject.ModelFactory.createModel(subagent.model);
+                    logger.info(`Subagent "${subagent.name}" using model: ${subagent.model}`);
+                } catch (error) {
+                    logger.error(`Failed to create model for subagent "${subagent.name}": ${error}`);
+                }
+                subagents.push(sub);
+            }
+            agent.subagents = subagents;
+        }
+        return agent;
+    }
+    constructor(configDir = external_agentConfig_cjs_namespaceObject.WingmanDirectory, workspace = process.cwd(), wingmanConfig){
+        _define_property(this, "configDir", void 0);
+        _define_property(this, "workspace", void 0);
+        _define_property(this, "wingmanConfig", void 0);
+        this.configDir = configDir;
+        this.workspace = workspace;
+        this.wingmanConfig = wingmanConfig;
+    }
+}
+exports.AgentLoader = __webpack_exports__.AgentLoader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AgentLoader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/config/agentLoader.d.ts

@@ -0,0 +1,42 @@
+import { type WingmanAgentConfig } from "./agentConfig.js";
+import type { WingmanAgent } from "@/types/agents.js";
+import type { WingmanConfigType } from "../../cli/config/schema.js";
+/**
+ * Load and validate agent configurations from multiple sources
+ */
+export declare class AgentLoader {
+    private configDir;
+    private workspace;
+    private wingmanConfig?;
+    constructor(configDir?: string, workspace?: string, wingmanConfig?: WingmanConfigType | undefined);
+    private resolveConfigPath;
+    loadAllAgentConfigs(): WingmanAgentConfig[];
+    /**
+     * Parse frontmatter from markdown content
+     */
+    private parseFrontmatter;
+    /**
+     * Normalize legacy config fields
+     */
+    private normalizeAgentConfig;
+    /**
+     * Load agent configuration from JSON file
+     */
+    private loadFromJson;
+    /**
+     * Load agent configuration from markdown file
+     */
+    private loadFromMarkdown;
+    /**
+     * Load a specific agent configuration by name
+     */
+    loadAgent(agentName: string): Promise<WingmanAgent | undefined>;
+    /**
+     * Load agents from markdown files in a directory
+     */
+    private loadFromDirectory;
+    /**
+     * Create a WingmanAgent instance from a user config
+     */
+    private createAgent;
+}

package/dist/agent/config/agentLoader.js

@@ -0,0 +1,208 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { load } from "js-yaml";
+import { WingmanDirectory, validateAgentConfig } from "./agentConfig.js";
+import { createTools } from "./toolRegistry.js";
+import { ModelFactory } from "./modelFactory.js";
+import { createLogger } from "../../logger.js";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const logger = createLogger();
+class AgentLoader {
+    resolveConfigPath(...segments) {
+        const baseDir = isAbsolute(this.configDir) ? this.configDir : join(this.workspace, this.configDir);
+        return join(baseDir, ...segments);
+    }
+    loadAllAgentConfigs() {
+        const agents = [];
+        const agentsDir = this.resolveConfigPath("agents");
+        if (existsSync(agentsDir) && statSync(agentsDir).isDirectory()) {
+            logger.info(`Loading agents from directory: ${agentsDir}`);
+            const agentDirs = readdirSync(agentsDir, {
+                withFileTypes: true
+            }).filter((dirent)=>dirent.isDirectory()).map((dirent)=>dirent.name);
+            for (const agentDir of agentDirs){
+                const agentDirPath = join(agentsDir, agentDir);
+                const agentJsonPath = join(agentDirPath, "agent.json");
+                const agentMarkdownPath = join(agentDirPath, "agent.md");
+                const hasJson = existsSync(agentJsonPath);
+                const hasMarkdown = existsSync(agentMarkdownPath);
+                if (!hasJson && !hasMarkdown) {
+                    logger.warn(`Skipping ${agentDir}: agent.json or agent.md not found`);
+                    continue;
+                }
+                try {
+                    const agentFilePath = hasJson ? agentJsonPath : agentMarkdownPath;
+                    const json = hasJson ? this.loadFromJson(agentJsonPath) : this.loadFromMarkdown(agentMarkdownPath, agentDirPath);
+                    const validation = validateAgentConfig(json);
+                    if (!validation.success) {
+                        logger.error(`Failed to validate ${agentFilePath}:\n${validation.error}`);
+                        continue;
+                    }
+                    agents.push(validation.data);
+                    logger.info(`Loaded agent config: ${validation.data.name}`);
+                } catch (error) {
+                    logger.error(`Failed to load agent from ${agentDirPath}: ${error}`);
+                }
+            }
+        } else logger.info(`No agents directory found at: ${agentsDir}`);
+        return agents;
+    }
+    parseFrontmatter(content) {
+        const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+        const match = content.match(frontmatterRegex);
+        if (!match) throw new Error("Invalid agent.md format: missing frontmatter");
+        const [, frontmatter, prompt] = match;
+        try {
+            const metadata = load(frontmatter);
+            if (!metadata || "object" != typeof metadata) throw new Error("Frontmatter must be a valid YAML object");
+            return {
+                metadata,
+                prompt: prompt.trim()
+            };
+        } catch (error) {
+            throw new Error(`Failed to parse frontmatter: ${error}`);
+        }
+    }
+    normalizeAgentConfig(config) {
+        if (config.subagents && !config.subAgents) {
+            config.subAgents = config.subagents;
+            delete config.subagents;
+        }
+        if (Array.isArray(config.subAgents)) {
+            for (const subagent of config.subAgents)if (subagent?.subagents && !subagent.subAgents) {
+                subagent.subAgents = subagent.subagents;
+                delete subagent.subagents;
+            }
+        }
+        return config;
+    }
+    loadFromJson(filePath) {
+        const content = readFileSync(filePath, "utf-8");
+        const json = JSON.parse(content);
+        return this.normalizeAgentConfig(json);
+    }
+    loadFromMarkdown(filePath, agentDir) {
+        const content = readFileSync(filePath, "utf-8");
+        const { metadata, prompt } = this.parseFrontmatter(content);
+        const config = this.normalizeAgentConfig({
+            ...metadata,
+            systemPrompt: prompt
+        });
+        if (config.subAgents && Array.isArray(config.subAgents)) {
+            for (const subagent of config.subAgents)if (subagent.promptFile) {
+                const promptPath = join(agentDir, subagent.promptFile);
+                if (!existsSync(promptPath)) throw new Error(`Subagent prompt file not found: ${promptPath}`);
+                const subagentContent = readFileSync(promptPath, "utf-8");
+                if (subagentContent.startsWith("---")) {
+                    const parsed = this.parseFrontmatter(subagentContent);
+                    Object.assign(subagent, parsed.metadata);
+                    subagent.systemPrompt = parsed.prompt;
+                } else subagent.systemPrompt = subagentContent.trim();
+                delete subagent.promptFile;
+            }
+        }
+        return config;
+    }
+    async loadAgent(agentName) {
+        let agent;
+        const customAgentsDir = this.resolveConfigPath("agents", agentName);
+        if (existsSync(customAgentsDir) && statSync(customAgentsDir).isDirectory()) {
+            logger.info(`Loading agent from directory: ${customAgentsDir}`);
+            agent = await this.loadFromDirectory(customAgentsDir);
+        }
+        return agent;
+    }
+    async loadFromDirectory(dirPath) {
+        const agentJsonPath = join(dirPath, "agent.json");
+        const agentMarkdownPath = join(dirPath, "agent.md");
+        const hasJson = existsSync(agentJsonPath);
+        const hasMarkdown = existsSync(agentMarkdownPath);
+        try {
+            if (!hasJson && !hasMarkdown) throw new Error(`Agent config file not found: ${agentJsonPath} or ${agentMarkdownPath}`);
+            const json = hasJson ? this.loadFromJson(agentJsonPath) : this.loadFromMarkdown(agentMarkdownPath, dirPath);
+            logger.info(`Loading agent from ${hasJson ? "JSON" : "markdown"}: ${hasJson ? agentJsonPath : agentMarkdownPath}`);
+            const validation = validateAgentConfig(json);
+            if (!validation.success) throw new Error(`Failed to validate ${hasJson ? agentJsonPath : agentMarkdownPath}:\n${validation.error}`);
+            const agent = await this.createAgent(validation.data);
+            if (agent.subagents && agent.subagents.length > 0) {
+                logger.info(`Agent "${agent.name}" has ${agent.subagents.length} subagent(s)`);
+                for (const subagent of agent.subagents)if ("subagents" in subagent && subagent.subagents) {
+                    logger.warn(`Subagent "${subagent.name}" has its own subagents, which is not currently supported. Ignoring nested subagents.`);
+                    subagent.subagents = [];
+                }
+            }
+            logger.info(`Loaded custom agent: ${agent.name} from ${dirPath}`);
+            return agent;
+        } catch (error) {
+            throw new Error(`Failed to load agent from ${dirPath}: ${error}`);
+        }
+    }
+    async createAgent(config) {
+        const agent = {
+            name: config.name,
+            description: config.description,
+            systemPrompt: config.systemPrompt
+        };
+        const buildToolOptions = (source)=>{
+            const mcpConfigs = [];
+            if (source.mcp) mcpConfigs.push(source.mcp);
+            if (source.mcpUseGlobal && this.wingmanConfig?.mcp) mcpConfigs.push(this.wingmanConfig.mcp);
+            return {
+                workspace: this.workspace,
+                blockedCommands: source.blockedCommands,
+                allowScriptExecution: source.allowScriptExecution,
+                timeout: source.commandTimeout,
+                searchConfig: this.wingmanConfig?.search,
+                mcpConfigs
+            };
+        };
+        if (config.tools && config.tools.length > 0) agent.tools = await createTools(config.tools, buildToolOptions(config));
+        if (config.mcp) agent.mcpConfig = config.mcp;
+        if (config.mcpUseGlobal) agent.mcpUseGlobal = true;
+        if (config.model) try {
+            agent.model = ModelFactory.createModel(config.model);
+            logger.info(`Agent "${config.name}" using model: ${config.model}`);
+        } catch (error) {
+            logger.error(`Failed to create model for agent "${config.name}": ${error}`);
+            logger.info(`Agent "${config.name}" will use default model`);
+        }
+        if (config.subAgents) {
+            const subagents = [];
+            for (const subagent of config.subAgents){
+                const sub = {
+                    name: subagent.name,
+                    description: subagent.description,
+                    systemPrompt: subagent.systemPrompt
+                };
+                if (subagent.tools && subagent.tools.length > 0) sub.tools = await createTools(subagent.tools, buildToolOptions(subagent));
+                if (subagent.model) try {
+                    sub.model = ModelFactory.createModel(subagent.model);
+                    logger.info(`Subagent "${subagent.name}" using model: ${subagent.model}`);
+                } catch (error) {
+                    logger.error(`Failed to create model for subagent "${subagent.name}": ${error}`);
+                }
+                subagents.push(sub);
+            }
+            agent.subagents = subagents;
+        }
+        return agent;
+    }
+    constructor(configDir = WingmanDirectory, workspace = process.cwd(), wingmanConfig){
+        _define_property(this, "configDir", void 0);
+        _define_property(this, "workspace", void 0);
+        _define_property(this, "wingmanConfig", void 0);
+        this.configDir = configDir;
+        this.workspace = workspace;
+        this.wingmanConfig = wingmanConfig;
+    }
+}
+export { AgentLoader };

package/dist/agent/config/mcpClientManager.cjs

@@ -0,0 +1,168 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    MCPClientManager: ()=>MCPClientManager
+});
+const mcp_adapters_namespaceObject = require("@langchain/mcp-adapters");
+const tools_namespaceObject = require("@langchain/core/tools");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class MCPClientManager {
+    mergeConfigs(configs) {
+        const serverMap = new Map();
+        for (const config of configs)if (config.servers) for (const server of config.servers)serverMap.set(server.name, server);
+        return Array.from(serverMap.values());
+    }
+    buildClientConfig() {
+        const clientConfig = {};
+        for (const server of this.serverConfigs)if ("stdio" === server.transport) {
+            const stdioServer = server;
+            const resolvedEnv = {};
+            for (const [key, value] of Object.entries(stdioServer.env || {}))resolvedEnv[key] = resolveEnvValue(value);
+            clientConfig[server.name] = {
+                transport: "stdio",
+                command: stdioServer.command,
+                args: stdioServer.args || [],
+                env: resolvedEnv
+            };
+        } else if ("sse" === server.transport) {
+            const sseServer = server;
+            clientConfig[server.name] = {
+                transport: "sse",
+                url: sseServer.url,
+                headers: sseServer.headers || {}
+            };
+        }
+        return clientConfig;
+    }
+    async initialize() {
+        if (0 === this.serverConfigs.length) return void this.logger.debug("No MCP servers configured");
+        try {
+            const clientConfig = this.buildClientConfig();
+            this.logger.info(`Initializing MCP client with ${this.serverConfigs.length} server(s)`);
+            this.client = new mcp_adapters_namespaceObject.MultiServerMCPClient(clientConfig);
+            this.logger.info("MCP client initialized successfully");
+        } catch (error) {
+            this.logger.error(`Failed to initialize MCP client: ${error instanceof Error ? error.message : String(error)}`);
+            throw new Error(`MCP client initialization failed: ${error}`);
+        }
+    }
+    async getTools() {
+        if (!this.client) {
+            this.logger.debug("No MCP client initialized, returning empty tools array");
+            return [];
+        }
+        try {
+            this.logger.debug("Retrieving tools from MCP servers");
+            const tools = await this.client.getTools();
+            const sanitized = this.sanitizeToolNames(tools);
+            this.logger.info(`Retrieved ${sanitized.length} tool(s) from MCP servers`);
+            return sanitized;
+        } catch (error) {
+            this.logger.error(`Failed to retrieve MCP tools: ${error instanceof Error ? error.message : String(error)}`);
+            return [];
+        }
+    }
+    sanitizeToolNames(tools) {
+        const used = new Map();
+        const sanitize = (name)=>{
+            const base = name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 128);
+            return base.length > 0 ? base : "tool";
+        };
+        const uniqueName = (name)=>{
+            let candidate = sanitize(name);
+            let counter = used.get(candidate) || 0;
+            while(used.has(candidate)){
+                counter += 1;
+                const suffix = `_${counter}`;
+                candidate = `${sanitize(name).slice(0, 128 - suffix.length)}${suffix}`;
+            }
+            used.set(candidate, counter);
+            return candidate;
+        };
+        return tools.map((tool)=>{
+            const original = tool.name;
+            const sanitized = uniqueName(original);
+            if (sanitized === original) return tool;
+            const originalLabel = `Original tool name: ${original}`;
+            const description = tool.description ? `${tool.description}\n\n${originalLabel}` : originalLabel;
+            const schema = tool.schema ?? tool.inputSchema;
+            if (!schema) try {
+                tool.name = sanitized;
+                tool.description = description;
+                return tool;
+            } catch  {
+                return tool;
+            }
+            return (0, tools_namespaceObject.tool)(async (input)=>tool.invoke(input), {
+                name: sanitized,
+                description,
+                schema
+            });
+        });
+    }
+    async cleanup() {
+        if (!this.client) return;
+        try {
+            this.logger.debug("Cleaning up MCP client");
+            this.client = null;
+            this.logger.debug("MCP client cleanup complete");
+        } catch (error) {
+            this.logger.warn(`Error during MCP cleanup: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    hasServers() {
+        return this.serverConfigs.length > 0;
+    }
+    constructor(configs, logger){
+        _define_property(this, "client", null);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "serverConfigs", void 0);
+        this.logger = logger;
+        this.serverConfigs = this.mergeConfigs(configs);
+    }
+}
+function resolveEnvValue(value) {
+    const match = value.match(/^\$\{([A-Z0-9_]+)\}$/);
+    if (!match) return value;
+    const envValue = process.env[match[1]];
+    return envValue ?? "";
+}
+exports.MCPClientManager = __webpack_exports__.MCPClientManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "MCPClientManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});