@agiflowai/one-mcp 0.2.0

package/dist/http-B1EDyxR_.mjs

@@ -0,0 +1,1211 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import yaml from "js-yaml";
+import { z } from "zod";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import express from "express";
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+//#region src/utils/mcpConfigSchema.ts
+/**
+* mcpConfigSchema Utilities
+*
+* DESIGN PATTERNS:
+* - Schema-based validation using Zod
+* - Pure functions with no side effects
+* - Type inference from schemas
+* - Transformation from Claude Code format to internal format
+*
+* CODING STANDARDS:
+* - Export individual functions and schemas
+* - Use descriptive function names with verbs
+* - Add JSDoc comments for complex logic
+* - Keep functions small and focused
+*
+* AVOID:
+* - Side effects (mutating external state)
+* - Stateful logic (use services for state)
+* - Loosely typed configs (use Zod for runtime safety)
+*/
+/**
+* Interpolate environment variables in a string
+* Supports ${VAR_NAME} syntax
+*
+* This function replaces environment variable placeholders with their actual values.
+* If an environment variable is not defined, the placeholder is kept as-is and a warning is logged.
+*
+* Examples:
+* - "${HOME}/data" → "/Users/username/data"
+* - "Bearer ${API_KEY}" → "Bearer sk-abc123xyz"
+* - "${DATABASE_URL}/api" → "postgres://localhost:5432/mydb/api"
+*
+* Supported locations for environment variable interpolation:
+* - Stdio config: command, args, env values
+* - HTTP/SSE config: url, header values
+*
+* @param value - String that may contain environment variable references
+* @returns String with environment variables replaced
+*/
+function interpolateEnvVars(value) {
+	return value.replace(/\$\{([^}]+)\}/g, (_, varName) => {
+		const envValue = process.env[varName];
+		if (envValue === void 0) {
+			console.warn(`Environment variable ${varName} is not defined, keeping placeholder`);
+			return `\${${varName}}`;
+		}
+		return envValue;
+	});
+}
+/**
+* Recursively interpolate environment variables in an object
+*
+* @param obj - Object that may contain environment variable references
+* @returns Object with environment variables replaced
+*/
+function interpolateEnvVarsInObject(obj) {
+	if (typeof obj === "string") return interpolateEnvVars(obj);
+	if (Array.isArray(obj)) return obj.map((item) => interpolateEnvVarsInObject(item));
+	if (obj !== null && typeof obj === "object") {
+		const result = {};
+		for (const [key, value] of Object.entries(obj)) result[key] = interpolateEnvVarsInObject(value);
+		return result;
+	}
+	return obj;
+}
+/**
+* Claude Code / Claude Desktop standard MCP config format
+* This is the format users write in their config files
+*/
+const AdditionalConfigSchema = z.object({
+	instruction: z.string().optional(),
+	toolBlacklist: z.array(z.string()).optional(),
+	omitToolDescription: z.boolean().optional()
+}).optional();
+const ClaudeCodeStdioServerSchema = z.object({
+	command: z.string(),
+	args: z.array(z.string()).optional(),
+	env: z.record(z.string(), z.string()).optional(),
+	disabled: z.boolean().optional(),
+	instruction: z.string().optional(),
+	config: AdditionalConfigSchema
+});
+const ClaudeCodeHttpServerSchema = z.object({
+	url: z.string().url(),
+	headers: z.record(z.string(), z.string()).optional(),
+	type: z.enum(["http", "sse"]).optional(),
+	disabled: z.boolean().optional(),
+	instruction: z.string().optional(),
+	config: AdditionalConfigSchema
+});
+const ClaudeCodeServerConfigSchema = z.union([ClaudeCodeStdioServerSchema, ClaudeCodeHttpServerSchema]);
+/**
+* Full Claude Code MCP configuration schema
+*/
+const ClaudeCodeMcpConfigSchema = z.object({ mcpServers: z.record(z.string(), ClaudeCodeServerConfigSchema) });
+/**
+* Internal MCP config format
+* This is the normalized format used internally by the proxy
+*/
+const McpStdioConfigSchema = z.object({
+	command: z.string(),
+	args: z.array(z.string()).optional(),
+	env: z.record(z.string(), z.string()).optional()
+});
+const McpHttpConfigSchema = z.object({
+	url: z.string().url(),
+	headers: z.record(z.string(), z.string()).optional()
+});
+const McpSseConfigSchema = z.object({
+	url: z.string().url(),
+	headers: z.record(z.string(), z.string()).optional()
+});
+const McpServerConfigSchema = z.discriminatedUnion("transport", [
+	z.object({
+		name: z.string(),
+		instruction: z.string().optional(),
+		toolBlacklist: z.array(z.string()).optional(),
+		omitToolDescription: z.boolean().optional(),
+		transport: z.literal("stdio"),
+		config: McpStdioConfigSchema
+	}),
+	z.object({
+		name: z.string(),
+		instruction: z.string().optional(),
+		toolBlacklist: z.array(z.string()).optional(),
+		omitToolDescription: z.boolean().optional(),
+		transport: z.literal("http"),
+		config: McpHttpConfigSchema
+	}),
+	z.object({
+		name: z.string(),
+		instruction: z.string().optional(),
+		toolBlacklist: z.array(z.string()).optional(),
+		omitToolDescription: z.boolean().optional(),
+		transport: z.literal("sse"),
+		config: McpSseConfigSchema
+	})
+]);
+/**
+* Full internal MCP configuration schema
+*/
+const InternalMcpConfigSchema = z.object({ mcpServers: z.record(z.string(), McpServerConfigSchema) });
+/**
+* Transform Claude Code config to internal format
+* Converts standard Claude Code MCP configuration to normalized internal format
+*
+* @param claudeConfig - Claude Code format configuration
+* @returns Internal format configuration
+*/
+function transformClaudeCodeConfig(claudeConfig) {
+	const transformedServers = {};
+	for (const [serverName, serverConfig] of Object.entries(claudeConfig.mcpServers)) {
+		if ("disabled" in serverConfig && serverConfig.disabled === true) continue;
+		if ("command" in serverConfig) {
+			const stdioConfig = serverConfig;
+			const interpolatedCommand = interpolateEnvVars(stdioConfig.command);
+			const interpolatedArgs = stdioConfig.args?.map((arg) => interpolateEnvVars(arg));
+			const interpolatedEnv = stdioConfig.env ? interpolateEnvVarsInObject(stdioConfig.env) : void 0;
+			transformedServers[serverName] = {
+				name: serverName,
+				instruction: stdioConfig.instruction || stdioConfig.config?.instruction,
+				toolBlacklist: stdioConfig.config?.toolBlacklist,
+				omitToolDescription: stdioConfig.config?.omitToolDescription,
+				transport: "stdio",
+				config: {
+					command: interpolatedCommand,
+					args: interpolatedArgs,
+					env: interpolatedEnv
+				}
+			};
+		} else if ("url" in serverConfig) {
+			const httpConfig = serverConfig;
+			const transport = httpConfig.type === "sse" ? "sse" : "http";
+			const interpolatedUrl = interpolateEnvVars(httpConfig.url);
+			const interpolatedHeaders = httpConfig.headers ? interpolateEnvVarsInObject(httpConfig.headers) : void 0;
+			transformedServers[serverName] = {
+				name: serverName,
+				instruction: httpConfig.instruction || httpConfig.config?.instruction,
+				toolBlacklist: httpConfig.config?.toolBlacklist,
+				omitToolDescription: httpConfig.config?.omitToolDescription,
+				transport,
+				config: {
+					url: interpolatedUrl,
+					headers: interpolatedHeaders
+				}
+			};
+		}
+	}
+	return { mcpServers: transformedServers };
+}
+/**
+* Parse and validate MCP config from raw JSON
+* Validates against Claude Code format, transforms to internal format, and validates result
+*
+* @param rawConfig - Raw JSON configuration object
+* @returns Validated and transformed internal configuration
+* @throws ZodError if validation fails
+*/
+function parseMcpConfig(rawConfig) {
+	const internalConfig = transformClaudeCodeConfig(ClaudeCodeMcpConfigSchema.parse(rawConfig));
+	return InternalMcpConfigSchema.parse(internalConfig);
+}
+
+//#endregion
+//#region src/services/ConfigFetcherService.ts
+/**
+* ConfigFetcherService
+*
+* DESIGN PATTERNS:
+* - Service pattern for business logic encapsulation
+* - Single responsibility principle
+* - Caching pattern for performance optimization
+*
+* CODING STANDARDS:
+* - Use async/await for asynchronous operations
+* - Throw descriptive errors for error cases
+* - Keep methods focused and well-named
+* - Document complex logic with comments
+*
+* AVOID:
+* - Mixing concerns (keep focused on single domain)
+* - Direct tool implementation (services should be tool-agnostic)
+*/
+/**
+* Service for fetching and caching MCP server configurations from local file
+*/
+var ConfigFetcherService = class {
+	configFilePath;
+	cacheTtlMs;
+	cachedConfig = null;
+	lastFetchTime = 0;
+	constructor(options) {
+		this.configFilePath = options.configFilePath;
+		this.cacheTtlMs = options.cacheTtlMs || 6e4;
+		if (!this.configFilePath) throw new Error("configFilePath must be provided");
+	}
+	/**
+	* Fetch MCP configuration from local file with caching
+	* @param forceRefresh - Force reload from source, bypassing cache
+	*/
+	async fetchConfiguration(forceRefresh = false) {
+		const now = Date.now();
+		if (!forceRefresh && this.cachedConfig && now - this.lastFetchTime < this.cacheTtlMs) return this.cachedConfig;
+		const config = await this.loadFromFile();
+		if (!config.mcpServers || typeof config.mcpServers !== "object") throw new Error("Invalid MCP configuration: missing or invalid mcpServers");
+		this.cachedConfig = config;
+		this.lastFetchTime = now;
+		return config;
+	}
+	/**
+	* Load configuration from a local file (supports JSON and YAML)
+	*/
+	async loadFromFile() {
+		if (!this.configFilePath) throw new Error("No config file path provided");
+		if (!existsSync(this.configFilePath)) throw new Error(`Config file not found: ${this.configFilePath}`);
+		try {
+			const content = await readFile(this.configFilePath, "utf-8");
+			let rawConfig;
+			if (this.configFilePath.endsWith(".yaml") || this.configFilePath.endsWith(".yml")) rawConfig = yaml.load(content);
+			else rawConfig = JSON.parse(content);
+			return parseMcpConfig(rawConfig);
+		} catch (error) {
+			if (error instanceof Error) throw new Error(`Failed to load config file: ${error.message}`);
+			throw new Error("Failed to load config file: Unknown error");
+		}
+	}
+	/**
+	* Clear the cached configuration
+	*/
+	clearCache() {
+		this.cachedConfig = null;
+		this.lastFetchTime = 0;
+	}
+	/**
+	* Check if cache is valid
+	*/
+	isCacheValid() {
+		const now = Date.now();
+		return this.cachedConfig !== null && now - this.lastFetchTime < this.cacheTtlMs;
+	}
+};
+
+//#endregion
+//#region src/services/McpClientManagerService.ts
+/**
+* MCP Client wrapper for managing individual server connections
+*/
+var McpClient = class {
+	serverName;
+	serverInstruction;
+	toolBlacklist;
+	omitToolDescription;
+	transport;
+	client;
+	childProcess;
+	connected = false;
+	constructor(serverName, transport, client, config) {
+		this.serverName = serverName;
+		this.serverInstruction = config.instruction;
+		this.toolBlacklist = config.toolBlacklist;
+		this.omitToolDescription = config.omitToolDescription;
+		this.transport = transport;
+		this.client = client;
+	}
+	setChildProcess(process$1) {
+		this.childProcess = process$1;
+	}
+	setConnected(connected) {
+		this.connected = connected;
+	}
+	async listTools() {
+		if (!this.connected) throw new Error(`Client for ${this.serverName} is not connected`);
+		return (await this.client.listTools()).tools;
+	}
+	async listResources() {
+		if (!this.connected) throw new Error(`Client for ${this.serverName} is not connected`);
+		return (await this.client.listResources()).resources;
+	}
+	async listPrompts() {
+		if (!this.connected) throw new Error(`Client for ${this.serverName} is not connected`);
+		return (await this.client.listPrompts()).prompts;
+	}
+	async callTool(name, args) {
+		if (!this.connected) throw new Error(`Client for ${this.serverName} is not connected`);
+		return await this.client.callTool({
+			name,
+			arguments: args
+		});
+	}
+	async readResource(uri) {
+		if (!this.connected) throw new Error(`Client for ${this.serverName} is not connected`);
+		return await this.client.readResource({ uri });
+	}
+	async getPrompt(name, args) {
+		if (!this.connected) throw new Error(`Client for ${this.serverName} is not connected`);
+		return await this.client.getPrompt({
+			name,
+			arguments: args
+		});
+	}
+	async close() {
+		if (this.childProcess) this.childProcess.kill();
+		await this.client.close();
+		this.connected = false;
+	}
+};
+/**
+* Service for managing MCP client connections to remote servers
+*/
+var McpClientManagerService = class {
+	clients = /* @__PURE__ */ new Map();
+	constructor() {
+		process.on("exit", () => {
+			this.cleanupOnExit();
+		});
+		process.on("SIGINT", () => {
+			this.cleanupOnExit();
+			process.exit(0);
+		});
+		process.on("SIGTERM", () => {
+			this.cleanupOnExit();
+			process.exit(0);
+		});
+	}
+	/**
+	* Cleanup all resources on exit (child processes)
+	*/
+	cleanupOnExit() {
+		for (const [serverName, client] of this.clients) try {
+			const childProcess = client["childProcess"];
+			if (childProcess && !childProcess.killed) {
+				console.error(`Killing stdio MCP server: ${serverName} (PID: ${childProcess.pid})`);
+				childProcess.kill("SIGTERM");
+				setTimeout(() => {
+					if (!childProcess.killed) {
+						console.error(`Force killing stdio MCP server: ${serverName} (PID: ${childProcess.pid})`);
+						childProcess.kill("SIGKILL");
+					}
+				}, 1e3);
+			}
+		} catch (error) {
+			console.error(`Failed to kill child process for ${serverName}:`, error);
+		}
+	}
+	/**
+	* Connect to an MCP server based on its configuration with timeout
+	*/
+	async connectToServer(serverName, config, timeoutMs = 1e4) {
+		if (this.clients.has(serverName)) throw new Error(`Client for ${serverName} is already connected`);
+		const client = new Client({
+			name: `@agiflowai/one-mcp-client`,
+			version: "0.1.0"
+		}, { capabilities: {} });
+		const mcpClient = new McpClient(serverName, config.transport, client, {
+			instruction: config.instruction,
+			toolBlacklist: config.toolBlacklist,
+			omitToolDescription: config.omitToolDescription
+		});
+		try {
+			await Promise.race([this.performConnection(mcpClient, config), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`Connection timeout after ${timeoutMs}ms`)), timeoutMs))]);
+			mcpClient.setConnected(true);
+			if (!mcpClient.serverInstruction) try {
+				const serverInstruction = mcpClient["client"].getInstructions();
+				if (serverInstruction) mcpClient.serverInstruction = serverInstruction;
+			} catch (error) {
+				console.error(`Failed to get server instruction from ${serverName}:`, error);
+			}
+			this.clients.set(serverName, mcpClient);
+		} catch (error) {
+			await mcpClient.close();
+			throw error;
+		}
+	}
+	/**
+	* Perform the actual connection to MCP server
+	*/
+	async performConnection(mcpClient, config) {
+		if (config.transport === "stdio") await this.connectStdioClient(mcpClient, config.config);
+		else if (config.transport === "sse") await this.connectSseClient(mcpClient, config.config);
+		else throw new Error(`Unsupported transport type: ${config.transport}`);
+	}
+	async connectStdioClient(mcpClient, config) {
+		const transport = new StdioClientTransport({
+			command: config.command,
+			args: config.args,
+			env: config.env
+		});
+		await mcpClient["client"].connect(transport);
+		const childProcess = transport["_process"];
+		if (childProcess) mcpClient.setChildProcess(childProcess);
+	}
+	async connectSseClient(mcpClient, config) {
+		const transport = new SSEClientTransport(new URL(config.url));
+		await mcpClient["client"].connect(transport);
+	}
+	/**
+	* Get a connected client by server name
+	*/
+	getClient(serverName) {
+		return this.clients.get(serverName);
+	}
+	/**
+	* Get all connected clients
+	*/
+	getAllClients() {
+		return Array.from(this.clients.values());
+	}
+	/**
+	* Disconnect from a specific server
+	*/
+	async disconnectServer(serverName) {
+		const client = this.clients.get(serverName);
+		if (client) {
+			await client.close();
+			this.clients.delete(serverName);
+		}
+	}
+	/**
+	* Disconnect from all servers
+	*/
+	async disconnectAll() {
+		const disconnectPromises = Array.from(this.clients.values()).map((client) => client.close());
+		await Promise.all(disconnectPromises);
+		this.clients.clear();
+	}
+	/**
+	* Check if a server is connected
+	*/
+	isConnected(serverName) {
+		return this.clients.has(serverName);
+	}
+};
+
+//#endregion
+//#region src/tools/DescribeToolsTool.ts
+var DescribeToolsTool = class DescribeToolsTool {
+	static TOOL_NAME = "describe_tools";
+	clientManager;
+	constructor(clientManager) {
+		this.clientManager = clientManager;
+	}
+	async getDefinition() {
+		const clients = this.clientManager.getAllClients();
+		const serverDescriptions = await Promise.all(clients.map(async (client) => {
+			try {
+				const tools = await client.listTools();
+				const blacklist = new Set(client.toolBlacklist || []);
+				const filteredTools = tools.filter((t) => !blacklist.has(t.name));
+				const toolList = client.omitToolDescription ? filteredTools.map((t) => t.name).join(", ") : filteredTools.map((t) => `${t.name}: ${t.description || "No description"}`).join("\n");
+				const instructionLine = client.serverInstruction ? `\n- Description: ${client.serverInstruction}` : "";
+				return `\n\n### Server: ${client.serverName}${instructionLine}\n- Available tools:${toolList ? "\n" + toolList : ""}`;
+			} catch (error) {
+				console.error(`Failed to list tools from ${client.serverName}:`, error);
+				const instructionLine = client.serverInstruction ? `\n- Description: ${client.serverInstruction}` : "";
+				return `\n\n**Server: ${client.serverName}**${instructionLine}\n`;
+			}
+		}));
+		return {
+			name: DescribeToolsTool.TOOL_NAME,
+			description: `Learn how to use multiple MCP tools before using them. Below are supported tools and capabilities.
+
+## Available MCP Servers:${serverDescriptions.join("")}
+
+## Usage:
+You MUST call this tool with a list of tool names to learn how to use them properly before use_tool; this includes:
+- Arguments schema needed to pass to the tool use
+- Description about each tool
+
+This tool is optimized for batch queries - you can request multiple tools at once for better performance.`,
+			inputSchema: {
+				type: "object",
+				properties: {
+					toolNames: {
+						type: "array",
+						items: { type: "string" },
+						description: "List of tool names to get detailed information about",
+						minItems: 1
+					},
+					serverName: {
+						type: "string",
+						description: "Optional server name to search within. If not specified, searches all servers."
+					}
+				},
+				required: ["toolNames"],
+				additionalProperties: false
+			}
+		};
+	}
+	async execute(input) {
+		try {
+			const { toolNames, serverName } = input;
+			const clients = this.clientManager.getAllClients();
+			if (!toolNames || toolNames.length === 0) return {
+				content: [{
+					type: "text",
+					text: "No tool names provided. Please specify at least one tool name."
+				}],
+				isError: true
+			};
+			if (serverName) {
+				const client = this.clientManager.getClient(serverName);
+				if (!client) return {
+					content: [{
+						type: "text",
+						text: `Server "${serverName}" not found. Available servers: ${clients.map((c) => c.serverName).join(", ")}`
+					}],
+					isError: true
+				};
+				const tools = await client.listTools();
+				const blacklist = new Set(client.toolBlacklist || []);
+				const filteredTools = tools.filter((t) => !blacklist.has(t.name));
+				const foundTools$1 = [];
+				const notFoundTools$1 = [];
+				for (const toolName of toolNames) {
+					if (blacklist.has(toolName)) {
+						notFoundTools$1.push(toolName);
+						continue;
+					}
+					const tool = filteredTools.find((t) => t.name === toolName);
+					if (tool) foundTools$1.push({
+						server: serverName,
+						tool: {
+							name: tool.name,
+							description: tool.description,
+							inputSchema: tool.inputSchema
+						}
+					});
+					else notFoundTools$1.push(toolName);
+				}
+				if (foundTools$1.length === 0) return {
+					content: [{
+						type: "text",
+						text: `None of the requested tools found on server "${serverName}".\nRequested: ${toolNames.join(", ")}\nAvailable tools: ${tools.map((t) => t.name).join(", ")}`
+					}],
+					isError: true
+				};
+				const result$1 = { tools: foundTools$1 };
+				if (notFoundTools$1.length > 0) {
+					result$1.notFound = notFoundTools$1;
+					result$1.warning = `Some tools were not found on server "${serverName}": ${notFoundTools$1.join(", ")}`;
+				}
+				return { content: [{
+					type: "text",
+					text: JSON.stringify(result$1, null, 2)
+				}] };
+			}
+			const foundTools = [];
+			const notFoundTools = [...toolNames];
+			const toolMatches = /* @__PURE__ */ new Map();
+			const results = await Promise.all(clients.map(async (client) => {
+				try {
+					const tools = await client.listTools();
+					const blacklist = new Set(client.toolBlacklist || []);
+					const filteredTools = tools.filter((t) => !blacklist.has(t.name));
+					const matches = [];
+					for (const toolName of toolNames) {
+						if (blacklist.has(toolName)) continue;
+						const tool = filteredTools.find((t) => t.name === toolName);
+						if (tool) matches.push({
+							toolName,
+							server: client.serverName,
+							tool
+						});
+					}
+					return matches;
+				} catch (error) {
+					console.error(`Failed to list tools from ${client.serverName}:`, error);
+					return [];
+				}
+			}));
+			for (const matches of results) for (const match of matches) {
+				if (!toolMatches.has(match.toolName)) toolMatches.set(match.toolName, []);
+				toolMatches.get(match.toolName).push({
+					server: match.server,
+					tool: match.tool
+				});
+			}
+			const ambiguousTools = [];
+			for (const toolName of toolNames) {
+				const matches = toolMatches.get(toolName);
+				if (!matches || matches.length === 0) continue;
+				if (matches.length === 1) {
+					const match = matches[0];
+					foundTools.push({
+						server: match.server,
+						tool: {
+							name: match.tool.name,
+							description: match.tool.description,
+							inputSchema: match.tool.inputSchema
+						}
+					});
+					const idx = notFoundTools.indexOf(toolName);
+					if (idx > -1) notFoundTools.splice(idx, 1);
+				} else {
+					ambiguousTools.push({
+						toolName,
+						servers: matches.map((m) => m.server)
+					});
+					const idx = notFoundTools.indexOf(toolName);
+					if (idx > -1) notFoundTools.splice(idx, 1);
+				}
+			}
+			if (foundTools.length === 0 && ambiguousTools.length === 0) return {
+				content: [{
+					type: "text",
+					text: `None of the requested tools found on any connected server.\nRequested: ${toolNames.join(", ")}\nUse describe_tools without arguments to see available servers.`
+				}],
+				isError: true
+			};
+			const result = { tools: foundTools };
+			if (notFoundTools.length > 0) result.notFound = notFoundTools;
+			if (ambiguousTools.length > 0) result.ambiguous = ambiguousTools.map((item) => ({
+				toolName: item.toolName,
+				servers: item.servers,
+				message: `Tool "${item.toolName}" found on multiple servers: ${item.servers.join(", ")}. Please specify serverName to disambiguate.`
+			}));
+			const warnings = [];
+			if (notFoundTools.length > 0) warnings.push(`Tools not found: ${notFoundTools.join(", ")}`);
+			if (ambiguousTools.length > 0) warnings.push(`Ambiguous tools (specify serverName): ${ambiguousTools.map((t) => t.toolName).join(", ")}`);
+			if (warnings.length > 0) result.warnings = warnings;
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error describing tools: ${error instanceof Error ? error.message : "Unknown error"}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/tools/UseToolTool.ts
+var UseToolTool = class UseToolTool {
+	static TOOL_NAME = "use_tool";
+	clientManager;
+	constructor(clientManager) {
+		this.clientManager = clientManager;
+	}
+	getDefinition() {
+		return {
+			name: UseToolTool.TOOL_NAME,
+			description: `Execute an MCP tool with provided arguments. You MUST call describe_tools first to discover the tool's correct arguments. Then to use tool:
+- Provide toolName and toolArgs based on the schema
+- If multiple servers provide the same tool, specify serverName
+`,
+			inputSchema: {
+				type: "object",
+				properties: {
+					toolName: {
+						type: "string",
+						description: "Name of the tool to execute"
+					},
+					toolArgs: {
+						type: "object",
+						description: "Arguments to pass to the tool, as discovered from describe_tools"
+					},
+					serverName: {
+						type: "string",
+						description: "Optional server name to disambiguate when multiple servers have the same tool"
+					}
+				},
+				required: ["toolName"],
+				additionalProperties: false
+			}
+		};
+	}
+	async execute(input) {
+		try {
+			const { toolName, toolArgs = {}, serverName } = input;
+			const clients = this.clientManager.getAllClients();
+			if (serverName) {
+				const client$1 = this.clientManager.getClient(serverName);
+				if (!client$1) return {
+					content: [{
+						type: "text",
+						text: `Server "${serverName}" not found. Available servers: ${clients.map((c) => c.serverName).join(", ")}`
+					}],
+					isError: true
+				};
+				if (client$1.toolBlacklist && client$1.toolBlacklist.includes(toolName)) return {
+					content: [{
+						type: "text",
+						text: `Tool "${toolName}" is blacklisted on server "${serverName}" and cannot be executed.`
+					}],
+					isError: true
+				};
+				try {
+					return await client$1.callTool(toolName, toolArgs);
+				} catch (error) {
+					return {
+						content: [{
+							type: "text",
+							text: `Failed to call tool "${toolName}" on server "${serverName}": ${error instanceof Error ? error.message : "Unknown error"}`
+						}],
+						isError: true
+					};
+				}
+			}
+			const matchingServers = [];
+			const results = await Promise.all(clients.map(async (client$1) => {
+				try {
+					if (client$1.toolBlacklist && client$1.toolBlacklist.includes(toolName)) return null;
+					if ((await client$1.listTools()).some((t) => t.name === toolName)) return client$1.serverName;
+				} catch (error) {
+					console.error(`Failed to list tools from ${client$1.serverName}:`, error);
+				}
+				return null;
+			}));
+			matchingServers.push(...results.filter((r) => r !== null));
+			if (matchingServers.length === 0) return {
+				content: [{
+					type: "text",
+					text: `Tool "${toolName}" not found on any connected server. Use describe_tools to see available tools.`
+				}],
+				isError: true
+			};
+			if (matchingServers.length > 1) return {
+				content: [{
+					type: "text",
+					text: `Multiple servers provide tool "${toolName}". Please specify serverName. Available servers: ${matchingServers.join(", ")}`
+				}],
+				isError: true
+			};
+			const targetServerName = matchingServers[0];
+			const client = this.clientManager.getClient(targetServerName);
+			if (!client) return {
+				content: [{
+					type: "text",
+					text: `Internal error: Server "${targetServerName}" was found but is not connected`
+				}],
+				isError: true
+			};
+			try {
+				return await client.callTool(toolName, toolArgs);
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: `Failed to call tool "${toolName}": ${error instanceof Error ? error.message : "Unknown error"}`
+					}],
+					isError: true
+				};
+			}
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error executing tool: ${error instanceof Error ? error.message : "Unknown error"}`
+				}],
+				isError: true
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/server/index.ts
+/**
+* MCP Server Setup
+*
+* DESIGN PATTERNS:
+* - Factory pattern for server creation
+* - Tool registration pattern
+* - Dependency injection for services
+*
+* CODING STANDARDS:
+* - Register all tools, resources, and prompts here
+* - Keep server setup modular and extensible
+* - Import tools from ../tools/ and register them in the handlers
+*/
+async function createServer(options) {
+	const server = new Server({
+		name: "@agiflowai/one-mcp",
+		version: "0.1.0"
+	}, { capabilities: { tools: {} } });
+	const clientManager = new McpClientManagerService();
+	if (options?.configFilePath) try {
+		const config = await new ConfigFetcherService({ configFilePath: options.configFilePath }).fetchConfiguration(options.noCache || false);
+		const connectionPromises = Object.entries(config.mcpServers).map(async ([serverName, serverConfig]) => {
+			try {
+				await clientManager.connectToServer(serverName, serverConfig);
+				console.error(`Connected to MCP server: ${serverName}`);
+			} catch (error) {
+				console.error(`Failed to connect to ${serverName}:`, error);
+			}
+		});
+		await Promise.all(connectionPromises);
+	} catch (error) {
+		console.error("Failed to load MCP configuration:", error);
+	}
+	const describeTools = new DescribeToolsTool(clientManager);
+	const useTool = new UseToolTool(clientManager);
+	server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [await describeTools.getDefinition(), useTool.getDefinition()] }));
+	server.setRequestHandler(CallToolRequestSchema, async (request) => {
+		const { name, arguments: args } = request.params;
+		if (name === DescribeToolsTool.TOOL_NAME) return await describeTools.execute(args);
+		if (name === UseToolTool.TOOL_NAME) return await useTool.execute(args);
+		throw new Error(`Unknown tool: ${name}`);
+	});
+	return server;
+}
+
+//#endregion
+//#region src/transports/stdio.ts
+/**
+* Stdio transport handler for MCP server
+* Used for command-line and direct integrations
+*/
+var StdioTransportHandler = class {
+	server;
+	transport = null;
+	constructor(server) {
+		this.server = server;
+	}
+	async start() {
+		this.transport = new StdioServerTransport();
+		await this.server.connect(this.transport);
+		console.error("@agiflowai/one-mcp MCP server started on stdio");
+	}
+	async stop() {
+		if (this.transport) {
+			await this.transport.close();
+			this.transport = null;
+		}
+	}
+};
+
+//#endregion
+//#region src/transports/sse.ts
+/**
+* Session manager for SSE transports
+*/
+var SseSessionManager = class {
+	sessions = /* @__PURE__ */ new Map();
+	getSession(sessionId) {
+		return this.sessions.get(sessionId)?.transport;
+	}
+	setSession(sessionId, transport, server) {
+		this.sessions.set(sessionId, {
+			transport,
+			server
+		});
+	}
+	deleteSession(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (session) session.server.close();
+		this.sessions.delete(sessionId);
+	}
+	hasSession(sessionId) {
+		return this.sessions.has(sessionId);
+	}
+	clear() {
+		for (const session of this.sessions.values()) session.server.close();
+		this.sessions.clear();
+	}
+};
+/**
+* SSE (Server-Sent Events) transport handler
+* Legacy transport for backwards compatibility (protocol version 2024-11-05)
+* Uses separate endpoints: /sse for SSE stream (GET) and /messages for client messages (POST)
+*/
+var SseTransportHandler = class {
+	serverFactory;
+	app;
+	server = null;
+	sessionManager;
+	config;
+	constructor(serverFactory, config) {
+		this.serverFactory = typeof serverFactory === "function" ? serverFactory : () => serverFactory;
+		this.app = express();
+		this.sessionManager = new SseSessionManager();
+		this.config = {
+			mode: config.mode,
+			port: config.port ?? 3e3,
+			host: config.host ?? "localhost"
+		};
+		this.setupMiddleware();
+		this.setupRoutes();
+	}
+	setupMiddleware() {
+		this.app.use(express.json());
+	}
+	setupRoutes() {
+		this.app.get("/sse", async (req, res) => {
+			await this.handleSseConnection(req, res);
+		});
+		this.app.post("/messages", async (req, res) => {
+			await this.handlePostMessage(req, res);
+		});
+		this.app.get("/health", (_req, res) => {
+			res.json({
+				status: "ok",
+				transport: "sse"
+			});
+		});
+	}
+	async handleSseConnection(_req, res) {
+		try {
+			const mcpServer = this.serverFactory();
+			const transport = new SSEServerTransport("/messages", res);
+			this.sessionManager.setSession(transport.sessionId, transport, mcpServer);
+			res.on("close", () => {
+				this.sessionManager.deleteSession(transport.sessionId);
+			});
+			await mcpServer.connect(transport);
+			console.error(`SSE session established: ${transport.sessionId}`);
+		} catch (error) {
+			console.error("Error handling SSE connection:", error);
+			if (!res.headersSent) res.status(500).send("Internal Server Error");
+		}
+	}
+	async handlePostMessage(req, res) {
+		const sessionId = req.query.sessionId;
+		if (!sessionId) {
+			res.status(400).send("Missing sessionId query parameter");
+			return;
+		}
+		const transport = this.sessionManager.getSession(sessionId);
+		if (!transport) {
+			res.status(404).send("No transport found for sessionId");
+			return;
+		}
+		try {
+			await transport.handlePostMessage(req, res, req.body);
+		} catch (error) {
+			console.error("Error handling post message:", error);
+			if (!res.headersSent) res.status(500).send("Internal Server Error");
+		}
+	}
+	async start() {
+		return new Promise((resolve, reject) => {
+			try {
+				this.server = this.app.listen(this.config.port, this.config.host, () => {
+					console.error(`@agiflowai/one-mcp MCP server started with SSE transport on http://${this.config.host}:${this.config.port}`);
+					console.error(`SSE endpoint: http://${this.config.host}:${this.config.port}/sse`);
+					console.error(`Messages endpoint: http://${this.config.host}:${this.config.port}/messages`);
+					console.error(`Health check: http://${this.config.host}:${this.config.port}/health`);
+					resolve();
+				});
+				this.server.on("error", (error) => {
+					reject(error);
+				});
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+	async stop() {
+		return new Promise((resolve, reject) => {
+			if (this.server) {
+				this.sessionManager.clear();
+				this.server.close((err) => {
+					if (err) reject(err);
+					else {
+						this.server = null;
+						resolve();
+					}
+				});
+			} else resolve();
+		});
+	}
+	getPort() {
+		return this.config.port;
+	}
+	getHost() {
+		return this.config.host;
+	}
+};
+
+//#endregion
+//#region src/transports/http.ts
+/**
+* HTTP Transport Handler
+*
+* DESIGN PATTERNS:
+* - Transport handler pattern implementing TransportHandler interface
+* - Session management for stateful connections
+* - Streamable HTTP protocol (2025-03-26) with resumability support
+* - Factory pattern for creating MCP server instances per session
+*
+* CODING STANDARDS:
+* - Use async/await for all asynchronous operations
+* - Implement proper session lifecycle management
+* - Handle errors gracefully with appropriate HTTP status codes
+* - Provide health check endpoint for monitoring
+* - Clean up resources on shutdown
+*
+* AVOID:
+* - Sharing MCP server instances across sessions (use factory pattern)
+* - Forgetting to clean up sessions on disconnect
+* - Missing error handling for request processing
+* - Hardcoded configuration (use TransportConfig)
+*/
+/**
+* HTTP session manager
+*/
+var HttpFullSessionManager = class {
+	sessions = /* @__PURE__ */ new Map();
+	getSession(sessionId) {
+		return this.sessions.get(sessionId);
+	}
+	setSession(sessionId, transport, server) {
+		this.sessions.set(sessionId, {
+			transport,
+			server
+		});
+	}
+	deleteSession(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (session) session.server.close();
+		this.sessions.delete(sessionId);
+	}
+	hasSession(sessionId) {
+		return this.sessions.has(sessionId);
+	}
+	clear() {
+		for (const session of this.sessions.values()) session.server.close();
+		this.sessions.clear();
+	}
+};
+/**
+* HTTP transport handler using Streamable HTTP (protocol version 2025-03-26)
+* Provides stateful session management with resumability support
+*/
+var HttpTransportHandler = class {
+	serverFactory;
+	app;
+	server = null;
+	sessionManager;
+	config;
+	constructor(serverFactory, config) {
+		this.serverFactory = typeof serverFactory === "function" ? serverFactory : () => serverFactory;
+		this.app = express();
+		this.sessionManager = new HttpFullSessionManager();
+		this.config = {
+			mode: config.mode,
+			port: config.port ?? 3e3,
+			host: config.host ?? "localhost"
+		};
+		this.setupMiddleware();
+		this.setupRoutes();
+	}
+	setupMiddleware() {
+		this.app.use(express.json());
+	}
+	setupRoutes() {
+		this.app.post("/mcp", async (req, res) => {
+			await this.handlePostRequest(req, res);
+		});
+		this.app.get("/mcp", async (req, res) => {
+			await this.handleGetRequest(req, res);
+		});
+		this.app.delete("/mcp", async (req, res) => {
+			await this.handleDeleteRequest(req, res);
+		});
+		this.app.get("/health", (_req, res) => {
+			res.json({
+				status: "ok",
+				transport: "http"
+			});
+		});
+	}
+	async handlePostRequest(req, res) {
+		const sessionId = req.headers["mcp-session-id"];
+		let transport;
+		if (sessionId && this.sessionManager.hasSession(sessionId)) transport = this.sessionManager.getSession(sessionId).transport;
+		else if (!sessionId && isInitializeRequest(req.body)) {
+			const mcpServer = this.serverFactory();
+			transport = new StreamableHTTPServerTransport({
+				sessionIdGenerator: () => randomUUID(),
+				enableJsonResponse: true,
+				onsessioninitialized: (sessionId$1) => {
+					this.sessionManager.setSession(sessionId$1, transport, mcpServer);
+				}
+			});
+			transport.onclose = () => {
+				if (transport.sessionId) this.sessionManager.deleteSession(transport.sessionId);
+			};
+			await mcpServer.connect(transport);
+		} else {
+			res.status(400).json({
+				jsonrpc: "2.0",
+				error: {
+					code: -32e3,
+					message: "Bad Request: No valid session ID provided"
+				},
+				id: null
+			});
+			return;
+		}
+		await transport.handleRequest(req, res, req.body);
+	}
+	async handleGetRequest(req, res) {
+		const sessionId = req.headers["mcp-session-id"];
+		if (!sessionId || !this.sessionManager.hasSession(sessionId)) {
+			res.status(400).send("Invalid or missing session ID");
+			return;
+		}
+		await this.sessionManager.getSession(sessionId).transport.handleRequest(req, res);
+	}
+	async handleDeleteRequest(req, res) {
+		const sessionId = req.headers["mcp-session-id"];
+		if (!sessionId || !this.sessionManager.hasSession(sessionId)) {
+			res.status(400).send("Invalid or missing session ID");
+			return;
+		}
+		await this.sessionManager.getSession(sessionId).transport.handleRequest(req, res);
+		this.sessionManager.deleteSession(sessionId);
+	}
+	async start() {
+		return new Promise((resolve, reject) => {
+			try {
+				this.server = this.app.listen(this.config.port, this.config.host, () => {
+					console.error(`@agiflowai/one-mcp MCP server started on http://${this.config.host}:${this.config.port}/mcp`);
+					console.error(`Health check: http://${this.config.host}:${this.config.port}/health`);
+					resolve();
+				});
+				this.server.on("error", (error) => {
+					reject(error);
+				});
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+	async stop() {
+		return new Promise((resolve, reject) => {
+			if (this.server) {
+				this.sessionManager.clear();
+				this.server.close((err) => {
+					if (err) reject(err);
+					else {
+						this.server = null;
+						resolve();
+					}
+				});
+			} else resolve();
+		});
+	}
+	getPort() {
+		return this.config.port;
+	}
+	getHost() {
+		return this.config.host;
+	}
+};
+
+//#endregion
+export { McpClientManagerService as a, createServer as i, SseTransportHandler as n, ConfigFetcherService as o, StdioTransportHandler as r, HttpTransportHandler as t };