@wingman-ai/gateway 0.1.0

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

@@ -0,0 +1,41 @@
+import type { StructuredTool } from "@langchain/core/tools";
+import type { MCPServersConfig } from "@/types/mcp.js";
+import type { Logger } from "@/logger.js";
+/**
+ * Manages MCP server connections and tool retrieval
+ * Handles server lifecycle: initialization, tool loading, and cleanup
+ */
+export declare class MCPClientManager {
+    private client;
+    private logger;
+    private serverConfigs;
+    constructor(configs: MCPServersConfig[], logger: Logger);
+    /**
+     * Merge multiple MCP configurations (global + agent-specific)
+     * Agent-specific servers override global ones with same name
+     */
+    private mergeConfigs;
+    /**
+     * Convert Wingman MCP config to MultiServerMCPClient format
+     */
+    private buildClientConfig;
+    /**
+     * Initialize MCP client and connect to servers
+     */
+    initialize(): Promise<void>;
+    /**
+     * Retrieve all tools from connected MCP servers
+     * Returns LangChain StructuredTools ready for agent use
+     */
+    getTools(): Promise<StructuredTool[]>;
+    private sanitizeToolNames;
+    /**
+     * Cleanup MCP client resources
+     * Call when agent completes or on error
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Check if any MCP servers are configured
+     */
+    hasServers(): boolean;
+}

package/dist/agent/config/mcpClientManager.js

@@ -0,0 +1,134 @@
+import { MultiServerMCPClient } from "@langchain/mcp-adapters";
+import { tool as tools_tool } from "@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 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 tools_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 ?? "";
+}
+export { MCPClientManager };

package/dist/agent/config/modelFactory.cjs

@@ -0,0 +1,175 @@
+"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__, {
+    ModelFactory: ()=>ModelFactory
+});
+const anthropic_namespaceObject = require("@langchain/anthropic");
+const openai_namespaceObject = require("@langchain/openai");
+const xai_namespaceObject = require("@langchain/xai");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+const credentials_cjs_namespaceObject = require("../../providers/credentials.cjs");
+const copilot_cjs_namespaceObject = require("../../providers/copilot.cjs");
+const registry_cjs_namespaceObject = require("../../providers/registry.cjs");
+const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+class ModelFactory {
+    static createModel(modelString) {
+        const parts = modelString.split(":");
+        if (2 !== parts.length) throw new Error(`Invalid model format: "${modelString}". Expected format: "provider:model-name"`);
+        const [provider, model] = parts;
+        if (!provider || !model) throw new Error(`Invalid model format: "${modelString}". Both provider and model name are required.`);
+        const normalizedProvider = (0, registry_cjs_namespaceObject.normalizeProviderName)(provider);
+        const providerSpec = normalizedProvider ? (0, registry_cjs_namespaceObject.getProviderSpec)(normalizedProvider) : void 0;
+        if (!providerSpec || "model" !== providerSpec.category) {
+            const supported = (0, registry_cjs_namespaceObject.listProviderSpecs)("model").map((item)=>item.name).join(", ");
+            throw new Error(`Unknown model provider: "${provider}". Supported providers: ${supported}`);
+        }
+        logger.debug(`Creating model: ${normalizedProvider}:${model}`);
+        switch(providerSpec.name){
+            case "anthropic":
+                return ModelFactory.createAnthropicModel(model);
+            case "openai":
+                return ModelFactory.createOpenAIModel(model);
+            case "openrouter":
+                return ModelFactory.createOpenRouterModel(model);
+            case "copilot":
+                return ModelFactory.createCopilotModel(model);
+            case "xai":
+                return ModelFactory.createXAIModel(model);
+            case "lmstudio":
+                return ModelFactory.createLMStudioModel(model);
+            case "ollama":
+                return ModelFactory.createOllamaModel(model);
+        }
+    }
+    static validateModelString(modelString) {
+        const parts = modelString.split(":");
+        if (2 !== parts.length) return {
+            valid: false,
+            error: `Invalid format: "${modelString}". Expected format: "provider:model-name"`
+        };
+        const [provider, model] = parts;
+        if (!provider || !model) return {
+            valid: false,
+            error: "Both provider and model name are required"
+        };
+        const normalizedProvider = (0, registry_cjs_namespaceObject.normalizeProviderName)(provider);
+        const providerSpec = normalizedProvider ? (0, registry_cjs_namespaceObject.getProviderSpec)(normalizedProvider) : void 0;
+        if (!providerSpec || "model" !== providerSpec.category) {
+            const supported = (0, registry_cjs_namespaceObject.listProviderSpecs)("model").map((item)=>item.name).join(", ");
+            return {
+                valid: false,
+                error: `Unknown provider: "${provider}". Supported: ${supported}`
+            };
+        }
+        return {
+            valid: true
+        };
+    }
+    static createAnthropicModel(model) {
+        const token = (0, credentials_cjs_namespaceObject.resolveProviderToken)("anthropic").token;
+        const params = {
+            model,
+            temperature: 1
+        };
+        if (token) params.apiKey = token;
+        return new anthropic_namespaceObject.ChatAnthropic(params);
+    }
+    static createOpenAIModel(model) {
+        const token = (0, credentials_cjs_namespaceObject.resolveProviderToken)("openai").token;
+        const params = {
+            model,
+            temperature: 1
+        };
+        if (token) params.apiKey = token;
+        return new openai_namespaceObject.ChatOpenAI(params);
+    }
+    static createOpenRouterModel(model) {
+        const token = (0, credentials_cjs_namespaceObject.resolveProviderToken)("openrouter").token ?? "";
+        const provider = (0, registry_cjs_namespaceObject.getProviderSpec)("openrouter");
+        return new openai_namespaceObject.ChatOpenAI({
+            model,
+            temperature: 1,
+            apiKey: token,
+            configuration: {
+                baseURL: provider?.baseURL
+            }
+        });
+    }
+    static createCopilotModel(model) {
+        const provider = (0, registry_cjs_namespaceObject.getProviderSpec)("copilot");
+        return new openai_namespaceObject.ChatOpenAI({
+            model,
+            temperature: 1,
+            apiKey: "copilot",
+            configuration: {
+                baseURL: provider?.baseURL,
+                fetch: (0, copilot_cjs_namespaceObject.createCopilotFetch)()
+            }
+        });
+    }
+    static createXAIModel(model) {
+        const token = (0, credentials_cjs_namespaceObject.resolveProviderToken)("xai").token;
+        const params = {
+            model,
+            temperature: 1
+        };
+        if (token) params.apiKey = token;
+        return new xai_namespaceObject.ChatXAI(params);
+    }
+    static createLMStudioModel(model) {
+        const tokenResult = (0, credentials_cjs_namespaceObject.resolveProviderToken)("lmstudio");
+        const provider = (0, registry_cjs_namespaceObject.getProviderSpec)("lmstudio");
+        const apiKey = tokenResult.token ?? "lm-studio";
+        return new openai_namespaceObject.ChatOpenAI({
+            model,
+            temperature: 1,
+            apiKey: apiKey,
+            configuration: {
+                baseURL: provider?.baseURL
+            }
+        });
+    }
+    static createOllamaModel(model) {
+        const tokenResult = (0, credentials_cjs_namespaceObject.resolveProviderToken)("ollama");
+        const provider = (0, registry_cjs_namespaceObject.getProviderSpec)("ollama");
+        const apiKey = tokenResult.token ?? "ollama";
+        return new openai_namespaceObject.ChatOpenAI({
+            model,
+            temperature: 1,
+            apiKey: apiKey,
+            configuration: {
+                baseURL: provider?.baseURL
+            }
+        });
+    }
+}
+exports.ModelFactory = __webpack_exports__.ModelFactory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ModelFactory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,33 @@
+import type { BaseLanguageModel, BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
+/**
+ * Create a LangChain model from a model string
+ *
+ * Format: "provider:model-name"
+ * Examples:
+ *  - "anthropic:claude-opus-4-5"
+ *  - "anthropic:claude-sonnet-4-5"
+ *  - "openai:gpt-4o"
+ *  - "openai:gpt-4-turbo"
+ *  - "openrouter:openai/gpt-4o"
+ *  - "copilot:gpt-4o"
+ */
+export declare class ModelFactory {
+    /**
+     * Parse and create a model from a string specification
+     */
+    static createModel(modelString: string): string | BaseLanguageModel<any, BaseLanguageModelCallOptions> | undefined;
+    /**
+     * Validate model string format without creating the model
+     */
+    static validateModelString(modelString: string): {
+        valid: boolean;
+        error?: string;
+    };
+    private static createAnthropicModel;
+    private static createOpenAIModel;
+    private static createOpenRouterModel;
+    private static createCopilotModel;
+    private static createXAIModel;
+    private static createLMStudioModel;
+    private static createOllamaModel;
+}

package/dist/agent/config/modelFactory.js

@@ -0,0 +1,141 @@
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatOpenAI } from "@langchain/openai";
+import { ChatXAI } from "@langchain/xai";
+import { createLogger } from "../../logger.js";
+import { resolveProviderToken } from "../../providers/credentials.js";
+import { createCopilotFetch } from "../../providers/copilot.js";
+import { getProviderSpec, listProviderSpecs, normalizeProviderName } from "../../providers/registry.js";
+const logger = createLogger();
+class ModelFactory {
+    static createModel(modelString) {
+        const parts = modelString.split(":");
+        if (2 !== parts.length) throw new Error(`Invalid model format: "${modelString}". Expected format: "provider:model-name"`);
+        const [provider, model] = parts;
+        if (!provider || !model) throw new Error(`Invalid model format: "${modelString}". Both provider and model name are required.`);
+        const normalizedProvider = normalizeProviderName(provider);
+        const providerSpec = normalizedProvider ? getProviderSpec(normalizedProvider) : void 0;
+        if (!providerSpec || "model" !== providerSpec.category) {
+            const supported = listProviderSpecs("model").map((item)=>item.name).join(", ");
+            throw new Error(`Unknown model provider: "${provider}". Supported providers: ${supported}`);
+        }
+        logger.debug(`Creating model: ${normalizedProvider}:${model}`);
+        switch(providerSpec.name){
+            case "anthropic":
+                return ModelFactory.createAnthropicModel(model);
+            case "openai":
+                return ModelFactory.createOpenAIModel(model);
+            case "openrouter":
+                return ModelFactory.createOpenRouterModel(model);
+            case "copilot":
+                return ModelFactory.createCopilotModel(model);
+            case "xai":
+                return ModelFactory.createXAIModel(model);
+            case "lmstudio":
+                return ModelFactory.createLMStudioModel(model);
+            case "ollama":
+                return ModelFactory.createOllamaModel(model);
+        }
+    }
+    static validateModelString(modelString) {
+        const parts = modelString.split(":");
+        if (2 !== parts.length) return {
+            valid: false,
+            error: `Invalid format: "${modelString}". Expected format: "provider:model-name"`
+        };
+        const [provider, model] = parts;
+        if (!provider || !model) return {
+            valid: false,
+            error: "Both provider and model name are required"
+        };
+        const normalizedProvider = normalizeProviderName(provider);
+        const providerSpec = normalizedProvider ? getProviderSpec(normalizedProvider) : void 0;
+        if (!providerSpec || "model" !== providerSpec.category) {
+            const supported = listProviderSpecs("model").map((item)=>item.name).join(", ");
+            return {
+                valid: false,
+                error: `Unknown provider: "${provider}". Supported: ${supported}`
+            };
+        }
+        return {
+            valid: true
+        };
+    }
+    static createAnthropicModel(model) {
+        const token = resolveProviderToken("anthropic").token;
+        const params = {
+            model,
+            temperature: 1
+        };
+        if (token) params.apiKey = token;
+        return new ChatAnthropic(params);
+    }
+    static createOpenAIModel(model) {
+        const token = resolveProviderToken("openai").token;
+        const params = {
+            model,
+            temperature: 1
+        };
+        if (token) params.apiKey = token;
+        return new ChatOpenAI(params);
+    }
+    static createOpenRouterModel(model) {
+        const token = resolveProviderToken("openrouter").token ?? "";
+        const provider = getProviderSpec("openrouter");
+        return new ChatOpenAI({
+            model,
+            temperature: 1,
+            apiKey: token,
+            configuration: {
+                baseURL: provider?.baseURL
+            }
+        });
+    }
+    static createCopilotModel(model) {
+        const provider = getProviderSpec("copilot");
+        return new ChatOpenAI({
+            model,
+            temperature: 1,
+            apiKey: "copilot",
+            configuration: {
+                baseURL: provider?.baseURL,
+                fetch: createCopilotFetch()
+            }
+        });
+    }
+    static createXAIModel(model) {
+        const token = resolveProviderToken("xai").token;
+        const params = {
+            model,
+            temperature: 1
+        };
+        if (token) params.apiKey = token;
+        return new ChatXAI(params);
+    }
+    static createLMStudioModel(model) {
+        const tokenResult = resolveProviderToken("lmstudio");
+        const provider = getProviderSpec("lmstudio");
+        const apiKey = tokenResult.token ?? "lm-studio";
+        return new ChatOpenAI({
+            model,
+            temperature: 1,
+            apiKey: apiKey,
+            configuration: {
+                baseURL: provider?.baseURL
+            }
+        });
+    }
+    static createOllamaModel(model) {
+        const tokenResult = resolveProviderToken("ollama");
+        const provider = getProviderSpec("ollama");
+        const apiKey = tokenResult.token ?? "ollama";
+        return new ChatOpenAI({
+            model,
+            temperature: 1,
+            apiKey: apiKey,
+            configuration: {
+                baseURL: provider?.baseURL
+            }
+        });
+    }
+}
+export { ModelFactory };

package/dist/agent/config/toolRegistry.cjs

@@ -0,0 +1,111 @@
+"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__, {
+    createTools: ()=>createTools,
+    createTool: ()=>createTool,
+    getAvailableTools: ()=>getAvailableTools
+});
+const internet_search_cjs_namespaceObject = require("../tools/internet_search.cjs");
+const web_crawler_cjs_namespaceObject = require("../tools/web_crawler.cjs");
+const command_execute_cjs_namespaceObject = require("../tools/command_execute.cjs");
+const think_cjs_namespaceObject = require("../tools/think.cjs");
+const code_search_cjs_namespaceObject = require("../tools/code_search.cjs");
+const git_status_cjs_namespaceObject = require("../tools/git_status.cjs");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+const external_mcpClientManager_cjs_namespaceObject = require("./mcpClientManager.cjs");
+const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+function createTool(name, options = {}) {
+    const { workspace = process.cwd(), blockedCommands, allowScriptExecution = true, timeout = 300000, searchConfig = {
+        provider: "duckduckgo",
+        maxResults: 5
+    } } = options;
+    logger.debug(`Creating tool: ${name}`, {
+        workspace,
+        blockedCommands,
+        allowScriptExecution,
+        timeout,
+        searchConfig
+    });
+    switch(name){
+        case "internet_search":
+            return (0, internet_search_cjs_namespaceObject.createInternetSearchTool)(searchConfig);
+        case "web_crawler":
+            return web_crawler_cjs_namespaceObject.webCrawler;
+        case "command_execute":
+            return (0, command_execute_cjs_namespaceObject.createCommandExecuteTool)(workspace, process.env, blockedCommands, allowScriptExecution, timeout);
+        case "think":
+            return (0, think_cjs_namespaceObject.createThinkingTool)();
+        case "code_search":
+            return (0, code_search_cjs_namespaceObject.createCodeSearchTool)(workspace);
+        case "git_status":
+            return (0, git_status_cjs_namespaceObject.createGitStatusTool)(workspace);
+        default:
+            logger.warn(`Unknown tool name: ${name}`);
+            return null;
+    }
+}
+async function createTools(toolNames, options = {}) {
+    const tools = [];
+    for (const name of toolNames){
+        const tool = createTool(name, options);
+        if (tool) tools.push(tool);
+        else logger.warn(`Skipping unknown tool: ${name}`);
+    }
+    if (options.mcpConfigs && options.mcpConfigs.length > 0) try {
+        const mcpManager = new external_mcpClientManager_cjs_namespaceObject.MCPClientManager(options.mcpConfigs, logger);
+        await mcpManager.initialize();
+        const mcpTools = await mcpManager.getTools();
+        if (mcpTools.length > 0) {
+            tools.push(...mcpTools);
+            logger.info(`Added ${mcpTools.length} MCP tool(s)`);
+        }
+    } catch (error) {
+        logger.error(`Failed to load MCP tools: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    logger.info(`Created ${tools.length} total tools: ${toolNames.join(", ")}${options.mcpConfigs?.length ? " + MCP tools" : ""}`);
+    return tools;
+}
+function getAvailableTools() {
+    return [
+        "internet_search",
+        "web_crawler",
+        "command_execute",
+        "think",
+        "code_search",
+        "git_status"
+    ];
+}
+exports.createTool = __webpack_exports__.createTool;
+exports.createTools = __webpack_exports__.createTools;
+exports.getAvailableTools = __webpack_exports__.getAvailableTools;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createTool",
+    "createTools",
+    "getAvailableTools"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,25 @@
+import type { StructuredTool } from "@langchain/core/tools";
+import type { AvailableToolName } from "./agentConfig.js";
+import type { SearchConfig } from "../../cli/config/schema.js";
+import type { MCPServersConfig } from "@/types/mcp.js";
+export interface ToolOptions {
+    workspace?: string;
+    blockedCommands?: string[];
+    allowScriptExecution?: boolean;
+    timeout?: number;
+    searchConfig?: SearchConfig;
+    mcpConfigs?: MCPServersConfig[];
+}
+/**
+ * Create a tool by name with optional configuration
+ */
+export declare function createTool(name: AvailableToolName, options?: ToolOptions): StructuredTool | null;
+/**
+ * Create multiple tools from an array of tool names
+ * NOW ALSO includes MCP tools if configured
+ */
+export declare function createTools(toolNames: AvailableToolName[], options?: ToolOptions): Promise<StructuredTool[]>;
+/**
+ * Get list of all available tool names
+ */
+export declare function getAvailableTools(): AvailableToolName[];