@agiflowai/one-mcp 0.3.11 → 0.3.13

package/dist/{http-pwzeCOpM.cjs → http-SFQFxDCq.cjs}

@@ -789,14 +789,22 @@ var ConfigFetcherService = class {
 	*/
 	mergeConfigurations(localConfig, remoteConfig, mergeStrategy) {
 		switch (mergeStrategy) {
-			case "local-priority": return { mcpServers: {
-				...remoteConfig.mcpServers,
-				...localConfig.mcpServers
-			} };
-			case "remote-priority": return { mcpServers: {
-				...localConfig.mcpServers,
-				...remoteConfig.mcpServers
-			} };
+			case "local-priority": return {
+				id: localConfig.id ?? remoteConfig.id,
+				mcpServers: {
+					...remoteConfig.mcpServers,
+					...localConfig.mcpServers
+				},
+				skills: localConfig.skills ?? remoteConfig.skills
+			};
+			case "remote-priority": return {
+				id: remoteConfig.id ?? localConfig.id,
+				mcpServers: {
+					...localConfig.mcpServers,
+					...remoteConfig.mcpServers
+				},
+				skills: remoteConfig.skills ?? localConfig.skills
+			};
 			case "merge-deep": {
 				const merged = { ...remoteConfig.mcpServers };
 				for (const [serverName, localServerConfig] of Object.entries(localConfig.mcpServers)) if (merged[serverName]) {
@@ -823,7 +831,11 @@ var ConfigFetcherService = class {
 						config: mergedConfig
 					};
 				} else merged[serverName] = localServerConfig;
-				return { mcpServers: merged };
+				return {
+					id: localConfig.id ?? remoteConfig.id,
+					mcpServers: merged,
+					skills: localConfig.skills ?? remoteConfig.skills
+				};
 			}
 			default: throw new Error(`Unknown merge strategy: ${mergeStrategy}`);
 		}
@@ -844,213 +856,6 @@ var ConfigFetcherService = class {
 	}
 };
 
-//#endregion
-//#region src/services/McpClientManagerService.ts
-/** Default connection timeout in milliseconds (30 seconds) */
-const DEFAULT_CONNECTION_TIMEOUT_MS = 3e4;
-/**
-* MCP Client wrapper for managing individual server connections
-* This is an internal class used by McpClientManagerService
-*/
-var McpClient = class {
-	serverName;
-	serverInstruction;
-	toolBlacklist;
-	omitToolDescription;
-	prompts;
-	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.prompts = config.prompts;
-		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
-	* Uses the timeout from server config, falling back to default (30s)
-	*/
-	async connectToServer(serverName, config) {
-		const timeoutMs = config.timeout ?? DEFAULT_CONNECTION_TIMEOUT_MS;
-		if (this.clients.has(serverName)) throw new Error(`Client for ${serverName} is already connected`);
-		const client = new __modelcontextprotocol_sdk_client_index_js.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,
-			prompts: config.prompts
-		});
-		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 === "http") await this.connectHttpClient(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 __modelcontextprotocol_sdk_client_stdio_js.StdioClientTransport({
-			command: config.command,
-			args: config.args,
-			env: {
-				...process.env,
-				...config.env ?? {}
-			}
-		});
-		await mcpClient["client"].connect(transport);
-		const childProcess = transport["_process"];
-		if (childProcess) mcpClient.setChildProcess(childProcess);
-	}
-	async connectHttpClient(mcpClient, config) {
-		const transport = new __modelcontextprotocol_sdk_client_streamableHttp_js.StreamableHTTPClientTransport(new URL(config.url), { requestInit: config.headers ? { headers: config.headers } : void 0 });
-		await mcpClient["client"].connect(transport);
-	}
-	async connectSseClient(mcpClient, config) {
-		const transport = new __modelcontextprotocol_sdk_client_sse_js.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/utils/findConfigFile.ts
 /**
@@ -1316,8 +1121,565 @@ function generateServerId(length = DEFAULT_ID_LENGTH) {
 			remaining--;
 		}
 	}
-	return result;
-}
+	return result;
+}
+
+//#endregion
+//#region src/constants/index.ts
+/**
+* Shared constants for one-mcp package
+*/
+/**
+* Prefix added to skill names when they clash with MCP tool names.
+* This ensures skills can be uniquely identified even when a tool has the same name.
+*/
+const SKILL_PREFIX = "skill__";
+/**
+* Log prefix for skill detection messages.
+* Used to easily filter skill detection logs in stderr output.
+*/
+const LOG_PREFIX_SKILL_DETECTION = "[skill-detection]";
+/**
+* Log prefix for general MCP capability discovery messages.
+*/
+const LOG_PREFIX_CAPABILITY_DISCOVERY = "[capability-discovery]";
+/**
+* Prefix for prompt-based skill locations.
+* Format: "prompt:{serverName}:{promptName}"
+*/
+const PROMPT_LOCATION_PREFIX = "prompt:";
+/**
+* Default server ID used when no ID is provided via CLI or config.
+* This fallback is used when auto-generation also fails.
+*/
+const DEFAULT_SERVER_ID = "unknown";
+
+//#endregion
+//#region src/services/DefinitionsCacheService.ts
+/**
+* DefinitionsCacheService
+*
+* Provides shared discovery, caching, and serialization for startup-time MCP
+* capability metadata. This avoids repeated remote enumeration during
+* mcp-serve startup and describe_tools generation.
+*/
+function isYamlPath(filePath) {
+	return filePath.endsWith(".yaml") || filePath.endsWith(".yml");
+}
+function toErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function sanitizeConfigPathForFilename(configFilePath) {
+	const absoluteConfigPath = (0, node_path.resolve)(configFilePath);
+	const normalizedPath = absoluteConfigPath.length >= 2 && absoluteConfigPath[1] === ":" && (absoluteConfigPath[0] >= "A" && absoluteConfigPath[0] <= "Z" || absoluteConfigPath[0] >= "a" && absoluteConfigPath[0] <= "z") ? `${absoluteConfigPath[0].toLowerCase()}${absoluteConfigPath.slice(1)}` : absoluteConfigPath;
+	let result = "";
+	let previousWasUnderscore = false;
+	for (const char of normalizedPath) {
+		if (char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9" || char === "." || char === "_" || char === "-") {
+			result += char;
+			previousWasUnderscore = false;
+			continue;
+		}
+		if (!previousWasUnderscore) {
+			result += "_";
+			previousWasUnderscore = true;
+		}
+	}
+	let start = 0;
+	let end = result.length;
+	while (start < end && result[start] === "_") start += 1;
+	while (end > start && result[end - 1] === "_") end -= 1;
+	return result.slice(start, end);
+}
+function cloneCache(cache) {
+	return {
+		...cache,
+		failures: [...cache.failures ?? []],
+		skills: (cache.skills ?? []).map((skill) => ({ ...skill })),
+		servers: Object.fromEntries(Object.entries(cache.servers).map(([serverName, server]) => [serverName, {
+			...server,
+			tools: (server.tools ?? []).map((tool) => ({ ...tool })),
+			resources: (server.resources ?? []).map((resource) => ({ ...resource })),
+			prompts: (server.prompts ?? []).map((prompt) => ({
+				...prompt,
+				arguments: prompt.arguments?.map((arg) => ({ ...arg }))
+			})),
+			promptSkills: (server.promptSkills ?? []).map((promptSkill) => ({
+				...promptSkill,
+				skill: { ...promptSkill.skill }
+			}))
+		}]))
+	};
+}
+var DefinitionsCacheService = class {
+	clientManager;
+	skillService;
+	cacheData;
+	liveDefinitionsPromise = null;
+	mergedDefinitionsPromise = null;
+	constructor(clientManager, skillService, options) {
+		this.clientManager = clientManager;
+		this.skillService = skillService;
+		this.cacheData = options?.cacheData;
+	}
+	static async readFromFile(filePath) {
+		const content = await (0, node_fs_promises.readFile)(filePath, "utf-8");
+		const parsed = isYamlPath(filePath) ? js_yaml.default.load(content) : JSON.parse(content);
+		if (!parsed || typeof parsed !== "object") throw new Error("Definitions cache must be an object");
+		const cache = parsed;
+		if (cache.version !== 1 || !cache.servers) throw new Error("Definitions cache is missing required fields");
+		return {
+			...cache,
+			failures: Array.isArray(cache.failures) ? cache.failures : [],
+			skills: Array.isArray(cache.skills) ? cache.skills : [],
+			servers: Object.fromEntries(Object.entries(cache.servers).map(([serverName, server]) => [serverName, {
+				...server,
+				tools: Array.isArray(server.tools) ? server.tools : [],
+				resources: Array.isArray(server.resources) ? server.resources : [],
+				prompts: Array.isArray(server.prompts) ? server.prompts : [],
+				promptSkills: Array.isArray(server.promptSkills) ? server.promptSkills : []
+			}]))
+		};
+	}
+	static async writeToFile(filePath, cache) {
+		const serialized = isYamlPath(filePath) ? js_yaml.default.dump(cache, { noRefs: true }) : JSON.stringify(cache, null, 2);
+		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(filePath), { recursive: true });
+		await (0, node_fs_promises.writeFile)(filePath, serialized, "utf-8");
+	}
+	static getDefaultCachePath(configFilePath) {
+		const sanitizedPath = sanitizeConfigPathForFilename(configFilePath);
+		return (0, node_path.join)((0, node_os.homedir)(), ".aicode-toolkit", `${sanitizedPath}.definitions-cache.json`);
+	}
+	static generateConfigHash(config) {
+		return (0, node_crypto.createHash)("sha256").update(JSON.stringify(config)).digest("hex");
+	}
+	static isCacheValid(cache, options) {
+		if (options.configHash && cache.configHash && cache.configHash !== options.configHash) return false;
+		if (options.oneMcpVersion && cache.oneMcpVersion && cache.oneMcpVersion !== options.oneMcpVersion) return false;
+		return true;
+	}
+	static async clearFile(filePath) {
+		await (0, node_fs_promises.rm)(filePath, { force: true });
+	}
+	clearLiveCache() {
+		this.liveDefinitionsPromise = null;
+		this.mergedDefinitionsPromise = null;
+	}
+	setCacheData(cacheData) {
+		this.cacheData = cacheData;
+		this.mergedDefinitionsPromise = null;
+	}
+	async collectForCache(options) {
+		const liveDefinitions = await this.collectLiveDefinitions(options);
+		this.setCacheData(liveDefinitions);
+		this.liveDefinitionsPromise = Promise.resolve(cloneCache(liveDefinitions));
+		return cloneCache(liveDefinitions);
+	}
+	async getDefinitions() {
+		if (this.mergedDefinitionsPromise) return this.mergedDefinitionsPromise;
+		this.mergedDefinitionsPromise = (async () => {
+			const clients = this.clientManager.getAllClients();
+			if (!this.cacheData) return this.getLiveDefinitions();
+			const missingServers = clients.map((client) => client.serverName).filter((serverName) => !this.cacheData?.servers[serverName]);
+			if (missingServers.length === 0) return cloneCache(this.cacheData);
+			const liveDefinitions = await this.getLiveDefinitions();
+			const merged = cloneCache(this.cacheData);
+			for (const serverName of missingServers) {
+				const serverDefinition = liveDefinitions.servers[serverName];
+				if (serverDefinition) merged.servers[serverName] = serverDefinition;
+			}
+			const failureMap = /* @__PURE__ */ new Map();
+			for (const failure of [...merged.failures, ...liveDefinitions.failures]) failureMap.set(failure.serverName, failure.error);
+			merged.failures = Array.from(failureMap.entries()).map(([serverName, error]) => ({
+				serverName,
+				error
+			}));
+			if (merged.skills.length === 0 && liveDefinitions.skills.length > 0) merged.skills = liveDefinitions.skills.map((skill) => ({ ...skill }));
+			return merged;
+		})();
+		return this.mergedDefinitionsPromise;
+	}
+	async getServerDefinitions() {
+		const definitions = await this.getDefinitions();
+		const serverOrder = this.clientManager.getKnownServerNames();
+		if (serverOrder.length === 0) return Object.values(definitions.servers);
+		return serverOrder.map((serverName) => definitions.servers[serverName]).filter((server) => server !== void 0);
+	}
+	async getServersForTool(toolName) {
+		return (await this.getServerDefinitions()).filter((serverDefinition) => serverDefinition.tools.some((tool) => tool.name === toolName)).map((serverDefinition) => serverDefinition.serverName);
+	}
+	async getServersForResource(uri) {
+		return (await this.getServerDefinitions()).filter((serverDefinition) => serverDefinition.resources.some((resource) => resource.uri === uri)).map((serverDefinition) => serverDefinition.serverName);
+	}
+	async getPromptSkillByName(skillName) {
+		const definitions = await this.getDefinitions();
+		for (const [serverName, server] of Object.entries(definitions.servers)) for (const promptSkill of server.promptSkills) if (promptSkill.skill.name === skillName) return {
+			serverName,
+			promptName: promptSkill.promptName,
+			skill: promptSkill.skill,
+			autoDetected: promptSkill.autoDetected
+		};
+	}
+	async getCachedFileSkills() {
+		return (await this.getDefinitions()).skills.map((skill) => ({ ...skill }));
+	}
+	async getLiveDefinitions() {
+		if (!this.liveDefinitionsPromise) this.liveDefinitionsPromise = this.collectLiveDefinitions();
+		return this.liveDefinitionsPromise;
+	}
+	async collectLiveDefinitions(options) {
+		const clients = this.clientManager.getAllClients();
+		const failures = [];
+		const servers = {};
+		const serverResults = await Promise.all(clients.map(async (client) => {
+			try {
+				const tools = await client.listTools();
+				const resources = await this.listResourcesSafe(client);
+				const prompts = await this.listPromptsSafe(client);
+				const blacklist = new Set(client.toolBlacklist || []);
+				const filteredTools = tools.filter((tool) => !blacklist.has(tool.name));
+				const promptSkills = await this.collectPromptSkillsForClient(client, prompts);
+				return {
+					serverName: client.serverName,
+					serverInstruction: client.serverInstruction,
+					omitToolDescription: client.omitToolDescription,
+					toolBlacklist: client.toolBlacklist,
+					tools: filteredTools.map((tool) => ({
+						name: tool.name,
+						description: tool.description,
+						inputSchema: tool.inputSchema,
+						_meta: tool._meta
+					})),
+					resources,
+					prompts,
+					promptSkills
+				};
+			} catch (error) {
+				failures.push({
+					serverName: client.serverName,
+					error: toErrorMessage(error)
+				});
+				return null;
+			}
+		}));
+		for (const serverDefinition of serverResults) if (serverDefinition) servers[serverDefinition.serverName] = serverDefinition;
+		return {
+			version: 1,
+			oneMcpVersion: options?.oneMcpVersion,
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			configPath: options?.configPath,
+			configHash: options?.configHash,
+			serverId: options?.serverId,
+			servers,
+			skills: await this.collectFileSkills(),
+			failures
+		};
+	}
+	async collectFileSkills() {
+		if (!this.skillService) return [];
+		return (await this.skillService.getSkills()).map((skill) => this.toCachedFileSkill(skill));
+	}
+	toCachedFileSkill(skill) {
+		return {
+			name: skill.name,
+			description: skill.description,
+			location: skill.location,
+			basePath: skill.basePath
+		};
+	}
+	async listPromptsSafe(client) {
+		try {
+			return (await client.listPrompts()).map((prompt) => ({
+				name: prompt.name,
+				description: prompt.description,
+				arguments: prompt.arguments?.map((arg) => ({ ...arg }))
+			}));
+		} catch (error) {
+			console.error(`${LOG_PREFIX_SKILL_DETECTION} Failed to list prompts from ${client.serverName}: ${toErrorMessage(error)}`);
+			return [];
+		}
+	}
+	async listResourcesSafe(client) {
+		try {
+			return (await client.listResources()).map((resource) => ({
+				uri: resource.uri,
+				name: resource.name,
+				description: resource.description,
+				mimeType: resource.mimeType
+			}));
+		} catch (error) {
+			console.error(`${LOG_PREFIX_CAPABILITY_DISCOVERY} Failed to list resources from ${client.serverName}: ${toErrorMessage(error)}`);
+			return [];
+		}
+	}
+	async collectPromptSkillsForClient(client, prompts) {
+		const configuredPromptNames = new Set(client.prompts ? Object.keys(client.prompts) : []);
+		const promptSkills = [];
+		if (client.prompts) {
+			for (const [promptName, promptConfig] of Object.entries(client.prompts)) if (promptConfig.skill) promptSkills.push({
+				promptName,
+				skill: { ...promptConfig.skill }
+			});
+		}
+		const autoDetectedSkills = await Promise.all(prompts.map(async (prompt) => {
+			if (configuredPromptNames.has(prompt.name)) return null;
+			try {
+				const skillExtraction = extractSkillFrontMatter((await client.getPrompt(prompt.name)).messages?.map((message) => {
+					const content = message.content;
+					if (typeof content === "string") return content;
+					if (content && typeof content === "object" && "text" in content) return String(content.text);
+					return "";
+				}).join("\n") || "");
+				if (!skillExtraction) return null;
+				return {
+					promptName: prompt.name,
+					skill: skillExtraction.skill,
+					autoDetected: true
+				};
+			} catch (error) {
+				console.error(`${LOG_PREFIX_SKILL_DETECTION} Failed to fetch prompt '${prompt.name}' from ${client.serverName}: ${toErrorMessage(error)}`);
+				return null;
+			}
+		}));
+		for (const autoDetectedSkill of autoDetectedSkills) if (autoDetectedSkill) promptSkills.push(autoDetectedSkill);
+		return promptSkills;
+	}
+};
+
+//#endregion
+//#region src/services/McpClientManagerService.ts
+/** Default connection timeout in milliseconds (30 seconds) */
+const DEFAULT_CONNECTION_TIMEOUT_MS = 3e4;
+/**
+* MCP Client wrapper for managing individual server connections
+* This is an internal class used by McpClientManagerService
+*/
+var McpClient = class {
+	serverName;
+	serverInstruction;
+	toolBlacklist;
+	omitToolDescription;
+	prompts;
+	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.prompts = config.prompts;
+		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();
+	serverConfigs = /* @__PURE__ */ new Map();
+	connectionPromises = /* @__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
+	* Uses the timeout from server config, falling back to default (30s)
+	*/
+	async connectToServer(serverName, config) {
+		this.serverConfigs.set(serverName, config);
+		await this.ensureConnected(serverName);
+	}
+	registerServerConfigs(configs) {
+		for (const [serverName, config] of Object.entries(configs)) this.serverConfigs.set(serverName, config);
+	}
+	getKnownServerNames() {
+		return Array.from(this.serverConfigs.keys());
+	}
+	async ensureConnected(serverName) {
+		const existingClient = this.clients.get(serverName);
+		if (existingClient) return existingClient;
+		const inflightConnection = this.connectionPromises.get(serverName);
+		if (inflightConnection) return await inflightConnection;
+		const config = this.serverConfigs.get(serverName);
+		if (!config) throw new Error(`No configuration found for server "${serverName}"`);
+		const connectionPromise = this.createConnection(serverName, config);
+		this.connectionPromises.set(serverName, connectionPromise);
+		try {
+			return await connectionPromise;
+		} finally {
+			this.connectionPromises.delete(serverName);
+		}
+	}
+	async createConnection(serverName, config) {
+		const timeoutMs = config.timeout ?? DEFAULT_CONNECTION_TIMEOUT_MS;
+		const client = new __modelcontextprotocol_sdk_client_index_js.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,
+			prompts: config.prompts
+		});
+		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);
+			return 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 === "http") await this.connectHttpClient(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 __modelcontextprotocol_sdk_client_stdio_js.StdioClientTransport({
+			command: config.command,
+			args: config.args,
+			env: {
+				...process.env,
+				...config.env ?? {}
+			}
+		});
+		await mcpClient["client"].connect(transport);
+		const childProcess = transport["_process"];
+		if (childProcess) mcpClient.setChildProcess(childProcess);
+	}
+	async connectHttpClient(mcpClient, config) {
+		const transport = new __modelcontextprotocol_sdk_client_streamableHttp_js.StreamableHTTPClientTransport(new URL(config.url), { requestInit: config.headers ? { headers: config.headers } : void 0 });
+		await mcpClient["client"].connect(transport);
+	}
+	async connectSseClient(mcpClient, config) {
+		const transport = new __modelcontextprotocol_sdk_client_sse_js.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();
+		this.connectionPromises.clear();
+	}
+	/**
+	* Check if a server is connected
+	*/
+	isConnected(serverName) {
+		return this.clients.has(serverName);
+	}
+};
 
 //#endregion
 //#region src/services/SkillService.ts
@@ -1391,6 +1753,8 @@ var SkillService = class {
 	skillsByName = null;
 	/** Active file watchers for skill directories */
 	watchers = [];
+	/** Polling timers used when native file watching is unavailable */
+	pollingTimers = [];
 	/** Callback invoked when cache is invalidated due to file changes */
 	onCacheInvalidated;
 	/**
@@ -1475,7 +1839,13 @@ var SkillService = class {
 			const abortController = new AbortController();
 			this.watchers.push(abortController);
 			this.watchDirectory(skillsDir, abortController.signal).catch((error) => {
-				if (error?.name !== "AbortError") console.error(`[skill-watcher] Error watching ${skillsDir}: ${error instanceof Error ? error.message : "Unknown error"}`);
+				if (error?.name !== "AbortError") {
+					if (this.isWatchResourceLimitError(error)) {
+						this.startPollingDirectory(skillsDir, abortController.signal);
+						return;
+					}
+					console.error(`[skill-watcher] Error watching ${skillsDir}: ${error instanceof Error ? error.message : "Unknown error"}`);
+				}
 			});
 		}
 	}
@@ -1486,6 +1856,8 @@ var SkillService = class {
 	stopWatching() {
 		for (const controller of this.watchers) controller.abort();
 		this.watchers = [];
+		for (const timer of this.pollingTimers) clearInterval(timer);
+		this.pollingTimers = [];
 	}
 	/**
 	* Watches a directory for changes to SKILL.md files.
@@ -1497,10 +1869,66 @@ var SkillService = class {
 			recursive: true,
 			signal
 		});
-		for await (const event of watcher) if (event.filename?.endsWith("SKILL.md")) {
-			this.clearCache();
-			this.onCacheInvalidated?.();
+		for await (const event of watcher) if (event.filename?.endsWith("SKILL.md")) this.invalidateCache();
+	}
+	invalidateCache() {
+		this.clearCache();
+		this.onCacheInvalidated?.();
+	}
+	isWatchResourceLimitError(error) {
+		return error instanceof Error && "code" in error && (error.code === "EMFILE" || error.code === "ENOSPC");
+	}
+	startPollingDirectory(dirPath, signal) {
+		this.createSkillSnapshot(dirPath).then((initialSnapshot) => {
+			let previousSnapshot = initialSnapshot;
+			const timer = setInterval(() => {
+				if (signal.aborted) {
+					clearInterval(timer);
+					return;
+				}
+				this.createSkillSnapshot(dirPath).then((nextSnapshot) => {
+					if (!this.snapshotsEqual(previousSnapshot, nextSnapshot)) {
+						previousSnapshot = nextSnapshot;
+						this.invalidateCache();
+					}
+				}).catch((error) => {
+					console.error(`[skill-watcher] Polling failed for ${dirPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+				});
+			}, 100);
+			this.pollingTimers.push(timer);
+			signal.addEventListener("abort", () => {
+				clearInterval(timer);
+				this.pollingTimers = this.pollingTimers.filter((activeTimer) => activeTimer !== timer);
+			}, { once: true });
+		});
+	}
+	async createSkillSnapshot(dirPath) {
+		const snapshot = /* @__PURE__ */ new Map();
+		await this.collectSkillSnapshots(dirPath, snapshot);
+		return snapshot;
+	}
+	async collectSkillSnapshots(dirPath, snapshot) {
+		let entries;
+		try {
+			entries = await (0, node_fs_promises.readdir)(dirPath);
+		} catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
+			throw error;
 		}
+		await Promise.all(entries.map(async (entry) => {
+			const entryPath = (0, node_path.join)(dirPath, entry);
+			const entryStat = await (0, node_fs_promises.stat)(entryPath);
+			if (entryStat.isDirectory()) {
+				await this.collectSkillSnapshots(entryPath, snapshot);
+				return;
+			}
+			if (entry === "SKILL.md") snapshot.set(entryPath, entryStat.mtimeMs);
+		}));
+	}
+	snapshotsEqual(left, right) {
+		if (left.size !== right.size) return false;
+		for (const [filePath, mtimeMs] of left) if (right.get(filePath) !== mtimeMs) return false;
+		return true;
 	}
 	/**
 	* Load skills from a directory.
@@ -1608,32 +2036,6 @@ var SkillService = class {
 	}
 };
 
-//#endregion
-//#region src/constants/index.ts
-/**
-* Shared constants for one-mcp package
-*/
-/**
-* Prefix added to skill names when they clash with MCP tool names.
-* This ensures skills can be uniquely identified even when a tool has the same name.
-*/
-const SKILL_PREFIX = "skill__";
-/**
-* Log prefix for skill detection messages.
-* Used to easily filter skill detection logs in stderr output.
-*/
-const LOG_PREFIX_SKILL_DETECTION = "[skill-detection]";
-/**
-* Prefix for prompt-based skill locations.
-* Format: "prompt:{serverName}:{promptName}"
-*/
-const PROMPT_LOCATION_PREFIX = "prompt:";
-/**
-* Default server ID used when no ID is provided via CLI or config.
-* This fallback is used when auto-generation also fails.
-*/
-const DEFAULT_SERVER_ID = "unknown";
-
 //#endregion
 //#region src/templates/toolkit-description.liquid?raw
 var toolkit_description_default = "<toolkit id=\"{{ serverId }}\">\n<instruction>\nBefore you use any capabilities below, you MUST call this tool with a list of names to learn how to use them properly; this includes:\n- For tools: Arguments schema needed to pass to use_tool\n- For skills: Detailed instructions that will expand when invoked (Prefer to be explored first when relevant)\n\nThis tool is optimized for batch queries - you can request multiple capabilities at once for better performance.\n\nHow to invoke:\n- For MCP tools: Use use_tool with toolName and toolArgs based on the schema\n- For skills: Use this tool with the skill name to get expanded instructions\n</instruction>\n\n<available_capabilities>\n{% for server in servers -%}\n<group name=\"{{ server.name }}\">\n{% if server.instruction -%}\n<group_instruction>{{ server.instruction }}</group_instruction>\n{% endif -%}\n{% if server.omitToolDescription -%}\n{% for toolName in server.toolNames -%}\n<item name=\"{{ toolName }}\"></item>\n{% endfor -%}\n{% else -%}\n{% for tool in server.tools -%}\n<item name=\"{{ tool.displayName }}\"><description>{{ tool.description | default: \"No description\" }}</description></item>\n{% endfor -%}\n{% endif -%}\n</group>\n{% endfor -%}\n{% if skills.size > 0 -%}\n<group name=\"skills\">\n{% for skill in skills -%}\n<item name=\"{{ skill.displayName }}\"><description>{{ skill.description }}</description></item>\n{% endfor -%}\n</group>\n{% endif -%}\n</available_capabilities>\n</toolkit>\n";
@@ -1672,6 +2074,7 @@ var DescribeToolsTool = class DescribeToolsTool {
 	static TOOL_NAME = "describe_tools";
 	clientManager;
 	skillService;
+	definitionsCacheService;
 	liquid = new liquidjs.Liquid();
 	/** Cache for auto-detected skills from prompt front-matter */
 	autoDetectedSkillsCache = null;
@@ -1683,10 +2086,11 @@ var DescribeToolsTool = class DescribeToolsTool {
 	* @param skillService - Optional skill service for loading skills
 	* @param serverId - Unique server identifier for this one-mcp instance
 	*/
-	constructor(clientManager, skillService, serverId) {
+	constructor(clientManager, skillService, serverId, definitionsCacheService) {
 		this.clientManager = clientManager;
 		this.skillService = skillService;
 		this.serverId = serverId || DEFAULT_SERVER_ID;
+		this.definitionsCacheService = definitionsCacheService || new DefinitionsCacheService(clientManager, skillService);
 	}
 	/**
 	* Clears the cached auto-detected skills from prompt front-matter.
@@ -1695,6 +2099,7 @@ var DescribeToolsTool = class DescribeToolsTool {
 	*/
 	clearAutoDetectedSkillsCache() {
 		this.autoDetectedSkillsCache = null;
+		this.definitionsCacheService.clearLiveCache();
 	}
 	/**
 	* Detects and caches skills from prompt front-matter across all connected MCP servers.
@@ -1760,21 +2165,12 @@ var DescribeToolsTool = class DescribeToolsTool {
 	* @returns Array of skill template data derived from prompts
 	*/
 	async collectPromptSkills() {
-		const clients = this.clientManager.getAllClients();
 		const promptSkills = [];
-		for (const client of clients) {
-			if (!client.prompts) continue;
-			for (const promptConfig of Object.values(client.prompts)) if (promptConfig.skill) promptSkills.push({
-				name: promptConfig.skill.name,
-				displayName: promptConfig.skill.name,
-				description: promptConfig.skill.description
-			});
-		}
-		const autoDetectedSkills = await this.detectSkillsFromPromptFrontMatter();
-		for (const autoSkill of autoDetectedSkills) promptSkills.push({
-			name: autoSkill.skill.name,
-			displayName: autoSkill.skill.name,
-			description: autoSkill.skill.description
+		const serverDefinitions = await this.definitionsCacheService.getServerDefinitions();
+		for (const serverDefinition of serverDefinitions) for (const promptSkill of serverDefinition.promptSkills) promptSkills.push({
+			name: promptSkill.skill.name,
+			displayName: promptSkill.skill.name,
+			description: promptSkill.skill.description
 		});
 		return promptSkills;
 	}
@@ -1787,22 +2183,7 @@ var DescribeToolsTool = class DescribeToolsTool {
 	*/
 	async findPromptSkill(skillName) {
 		if (!skillName) return void 0;
-		const clients = this.clientManager.getAllClients();
-		for (const client of clients) {
-			if (!client.prompts) continue;
-			for (const [promptName, promptConfig] of Object.entries(client.prompts)) if (promptConfig.skill && promptConfig.skill.name === skillName) return {
-				serverName: client.serverName,
-				promptName,
-				skill: promptConfig.skill
-			};
-		}
-		const autoDetectedSkills = await this.detectSkillsFromPromptFrontMatter();
-		for (const autoSkill of autoDetectedSkills) if (autoSkill.skill.name === skillName) return {
-			serverName: autoSkill.serverName,
-			promptName: autoSkill.promptName,
-			skill: autoSkill.skill,
-			autoDetected: true
-		};
+		return await this.definitionsCacheService.getPromptSkillByName(skillName);
 	}
 	/**
 	* Retrieves skill content from a prompt-based skill configuration.
@@ -1815,13 +2196,8 @@ var DescribeToolsTool = class DescribeToolsTool {
 	async getPromptSkillContent(skillName) {
 		const promptSkill = await this.findPromptSkill(skillName);
 		if (!promptSkill) return void 0;
-		const client = this.clientManager.getClient(promptSkill.serverName);
-		if (!client) {
-			console.error(`Client not found for server '${promptSkill.serverName}' when fetching prompt skill '${skillName}'`);
-			return;
-		}
 		try {
-			const rawInstructions = (await client.getPrompt(promptSkill.promptName)).messages?.map((m) => {
+			const rawInstructions = (await (await this.clientManager.ensureConnected(promptSkill.serverName)).getPrompt(promptSkill.promptName)).messages?.map((m) => {
 				const content = m.content;
 				if (typeof content === "string") return content;
 				if (content && typeof content === "object" && "text" in content) return String(content.text);
@@ -1850,24 +2226,12 @@ var DescribeToolsTool = class DescribeToolsTool {
 	* @returns Object with rendered description and set of all tool names
 	*/
 	async buildToolkitDescription() {
-		const clients = this.clientManager.getAllClients();
+		const serverDefinitions = await this.definitionsCacheService.getServerDefinitions();
 		const toolToServers = /* @__PURE__ */ new Map();
-		const serverToolsMap = /* @__PURE__ */ new Map();
-		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));
-				serverToolsMap.set(client.serverName, filteredTools);
-				for (const tool of filteredTools) {
-					if (!toolToServers.has(tool.name)) toolToServers.set(tool.name, []);
-					toolToServers.get(tool.name)?.push(client.serverName);
-				}
-			} catch (error) {
-				console.error(`Failed to list tools from ${client.serverName}:`, error);
-				serverToolsMap.set(client.serverName, []);
-			}
-		}));
+		for (const serverDefinition of serverDefinitions) for (const tool of serverDefinition.tools) {
+			if (!toolToServers.has(tool.name)) toolToServers.set(tool.name, []);
+			toolToServers.get(tool.name)?.push(serverDefinition.serverName);
+		}
 		/**
 		* Formats tool name with server prefix if the tool exists on multiple servers
 		*/
@@ -1875,21 +2239,25 @@ var DescribeToolsTool = class DescribeToolsTool {
 			return (toolToServers.get(toolName) || []).length > 1 ? `${serverName}__${toolName}` : toolName;
 		};
 		const allToolNames = /* @__PURE__ */ new Set();
-		const servers = clients.map((client) => {
-			const formattedTools = (serverToolsMap.get(client.serverName) || []).map((t) => ({
-				displayName: formatToolName(t.name, client.serverName),
+		const servers = serverDefinitions.map((serverDefinition) => {
+			const formattedTools = serverDefinition.tools.map((t) => ({
+				displayName: formatToolName(t.name, serverDefinition.serverName),
 				description: t.description
 			}));
 			for (const tool of formattedTools) allToolNames.add(tool.displayName);
 			return {
-				name: client.serverName,
-				instruction: client.serverInstruction,
-				omitToolDescription: client.omitToolDescription || false,
+				name: serverDefinition.serverName,
+				instruction: serverDefinition.serverInstruction,
+				omitToolDescription: serverDefinition.omitToolDescription || false,
 				tools: formattedTools,
 				toolNames: formattedTools.map((t) => t.displayName)
 			};
 		});
-		const [rawSkills, promptSkills] = await Promise.all([this.skillService ? this.skillService.getSkills() : Promise.resolve([]), this.collectPromptSkills()]);
+		const [rawSkills, cachedSkills, promptSkills] = await Promise.all([
+			this.skillService ? this.skillService.getSkills() : Promise.resolve([]),
+			this.definitionsCacheService.getCachedFileSkills(),
+			this.collectPromptSkills()
+		]);
 		const seenSkillNames = /* @__PURE__ */ new Set();
 		const allSkillsData = [];
 		for (const skill of rawSkills) if (!seenSkillNames.has(skill.name)) {
@@ -1900,6 +2268,14 @@ var DescribeToolsTool = class DescribeToolsTool {
 				description: skill.description
 			});
 		}
+		for (const skill of cachedSkills) if (!seenSkillNames.has(skill.name)) {
+			seenSkillNames.add(skill.name);
+			allSkillsData.push({
+				name: skill.name,
+				displayName: skill.name,
+				description: skill.description
+			});
+		}
 		for (const skill of promptSkills) if (!seenSkillNames.has(skill.name)) {
 			seenSkillNames.add(skill.name);
 			allSkillsData.push(skill);
@@ -1969,7 +2345,7 @@ var DescribeToolsTool = class DescribeToolsTool {
 	async execute(input) {
 		try {
 			const { toolNames } = input;
-			const clients = this.clientManager.getAllClients();
+			const serverDefinitions = await this.definitionsCacheService.getServerDefinitions();
 			if (!toolNames || toolNames.length === 0) return {
 				content: [{
 					type: "text",
@@ -1979,25 +2355,18 @@ var DescribeToolsTool = class DescribeToolsTool {
 			};
 			const serverToolsMap = /* @__PURE__ */ new Map();
 			const toolToServers = /* @__PURE__ */ new Map();
-			await Promise.all(clients.map(async (client) => {
-				try {
-					const tools = await client.listTools();
-					const blacklist = new Set(client.toolBlacklist || []);
-					const typedTools = tools.filter((t) => !blacklist.has(t.name)).map((t) => ({
-						name: t.name,
-						description: t.description,
-						inputSchema: t.inputSchema
-					}));
-					serverToolsMap.set(client.serverName, typedTools);
-					for (const tool of typedTools) {
-						if (!toolToServers.has(tool.name)) toolToServers.set(tool.name, []);
-						toolToServers.get(tool.name)?.push(client.serverName);
-					}
-				} catch (error) {
-					console.error(`Failed to list tools from ${client.serverName}:`, error);
-					serverToolsMap.set(client.serverName, []);
+			for (const serverDefinition of serverDefinitions) {
+				const typedTools = serverDefinition.tools.map((tool) => ({
+					name: tool.name,
+					description: tool.description,
+					inputSchema: tool.inputSchema
+				}));
+				serverToolsMap.set(serverDefinition.serverName, typedTools);
+				for (const tool of typedTools) {
+					if (!toolToServers.has(tool.name)) toolToServers.set(tool.name, []);
+					toolToServers.get(tool.name)?.push(serverDefinition.serverName);
 				}
-			}));
+			}
 			const lookupResults = await Promise.all(toolNames.map(async (requestedName) => {
 				const result$1 = {
 					tools: [],
@@ -2135,6 +2504,95 @@ var DescribeToolsTool = class DescribeToolsTool {
 	}
 };
 
+//#endregion
+//#region src/utils/toolCapabilities.ts
+const TOOL_CAPABILITIES_META_KEY = "agiflowai/capabilities";
+function getToolCapabilities(tool) {
+	const rawCapabilities = tool._meta?.[TOOL_CAPABILITIES_META_KEY];
+	if (!Array.isArray(rawCapabilities)) return [];
+	return rawCapabilities.filter((value) => typeof value === "string");
+}
+function getUniqueSortedCapabilities(tools) {
+	return Array.from(new Set(tools.flatMap((tool) => getToolCapabilities(tool)))).sort();
+}
+
+//#endregion
+//#region src/tools/SearchListToolsTool.ts
+var SearchListToolsTool = class SearchListToolsTool {
+	static TOOL_NAME = "list_tools";
+	constructor(_clientManager, definitionsCacheService) {
+		this._clientManager = _clientManager;
+		this.definitionsCacheService = definitionsCacheService;
+	}
+	formatToolName(toolName, serverName, toolToServers) {
+		return (toolToServers.get(toolName) || []).length > 1 ? `${serverName}__${toolName}` : toolName;
+	}
+	async getDefinition() {
+		const serverDefinitions = await this.definitionsCacheService.getServerDefinitions();
+		const capabilitySummary = serverDefinitions.length > 0 ? serverDefinitions.map((server) => {
+			const capabilities = getUniqueSortedCapabilities(server.tools);
+			const summary = capabilities.length > 0 ? capabilities.join(", ") : server.serverInstruction || "No capability summary available";
+			return `${server.serverName}: ${summary}`;
+		}).join("\n") : "No proxied servers available.";
+		return {
+			name: SearchListToolsTool.TOOL_NAME,
+			description: `Search proxied MCP tools by server capability summary.\n\nAvailable capabilities:\n${capabilitySummary}`,
+			inputSchema: {
+				type: "object",
+				properties: {
+					capability: {
+						type: "string",
+						description: "Optional capability filter. Matches explicit capability tags first, then server summaries, server names, tool names, and tool descriptions."
+					},
+					serverName: {
+						type: "string",
+						description: "Optional server name filter."
+					}
+				},
+				additionalProperties: false
+			}
+		};
+	}
+	async execute(input) {
+		const serverDefinitions = await this.definitionsCacheService.getServerDefinitions();
+		const capabilityFilter = input.capability?.trim().toLowerCase();
+		const serverNameFilter = input.serverName?.trim().toLowerCase();
+		const toolToServers = /* @__PURE__ */ new Map();
+		for (const serverDefinition of serverDefinitions) for (const tool of serverDefinition.tools) {
+			if (!toolToServers.has(tool.name)) toolToServers.set(tool.name, []);
+			toolToServers.get(tool.name)?.push(serverDefinition.serverName);
+		}
+		const filteredServers = serverDefinitions.filter((serverDefinition) => {
+			if (serverNameFilter && serverDefinition.serverName.toLowerCase() !== serverNameFilter) return false;
+			if (!capabilityFilter) return true;
+			if ((serverDefinition.serverInstruction?.toLowerCase() || "").includes(capabilityFilter)) return true;
+			if (getUniqueSortedCapabilities(serverDefinition.tools).some((capability) => capability.toLowerCase().includes(capabilityFilter))) return true;
+			return serverDefinition.tools.some((tool) => {
+				const toolName = this.formatToolName(tool.name, serverDefinition.serverName, toolToServers);
+				const toolCapabilities = getToolCapabilities(tool);
+				return toolName.toLowerCase().includes(capabilityFilter) || (tool.description || "").toLowerCase().includes(capabilityFilter) || toolCapabilities.some((capability) => capability.toLowerCase().includes(capabilityFilter));
+			});
+		}).map((serverDefinition) => ({
+			server: serverDefinition.serverName,
+			capabilities: getUniqueSortedCapabilities(serverDefinition.tools),
+			summary: serverDefinition.serverInstruction,
+			tools: serverDefinition.tools.map((tool) => ({
+				name: this.formatToolName(tool.name, serverDefinition.serverName, toolToServers),
+				description: serverDefinition.omitToolDescription ? void 0 : tool.description,
+				capabilities: getToolCapabilities(tool)
+			}))
+		})).filter((server) => server.tools.length > 0);
+		const result = { servers: filteredServers };
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}],
+			isError: filteredServers.length === 0 ? true : void 0
+		};
+	}
+};
+
 //#endregion
 //#region src/tools/UseToolTool.ts
 /**
@@ -2154,6 +2612,7 @@ var UseToolTool = class UseToolTool {
 	static TOOL_NAME = "use_tool";
 	clientManager;
 	skillService;
+	definitionsCacheService;
 	/** Unique server identifier for this one-mcp instance */
 	serverId;
 	/**
@@ -2162,9 +2621,10 @@ var UseToolTool = class UseToolTool {
 	* @param skillService - Optional skill service for loading and executing skills
 	* @param serverId - Unique server identifier for this one-mcp instance
 	*/
-	constructor(clientManager, skillService, serverId) {
+	constructor(clientManager, skillService, serverId, definitionsCacheService) {
 		this.clientManager = clientManager;
 		this.skillService = skillService;
+		this.definitionsCacheService = definitionsCacheService || new DefinitionsCacheService(clientManager, skillService);
 		this.serverId = serverId || DEFAULT_SERVER_ID;
 	}
 	/**
@@ -2224,17 +2684,9 @@ IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverI
 	* @param skillName - The skill name to search for
 	* @returns PromptSkillMatch if found, undefined otherwise
 	*/
-	findPromptSkill(skillName) {
+	async findPromptSkill(skillName) {
 		if (!skillName) return void 0;
-		const clients = this.clientManager.getAllClients();
-		for (const client of clients) {
-			if (!client.prompts) continue;
-			for (const [promptName, promptConfig] of Object.entries(client.prompts)) if (promptConfig.skill && promptConfig.skill.name === skillName) return {
-				serverName: client.serverName,
-				promptName,
-				skill: promptConfig.skill
-			};
-		}
+		return await this.definitionsCacheService.getPromptSkillByName(skillName);
 	}
 	/**
 	* Returns guidance message for prompt-based skill invocation.
@@ -2274,7 +2726,7 @@ IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverI
 					const skill = await this.skillService.getSkill(skillName);
 					if (skill) return this.executeSkill(skill);
 				}
-				const promptSkill = this.findPromptSkill(skillName);
+				const promptSkill = await this.findPromptSkill(skillName);
 				if (promptSkill) return this.executePromptSkill(promptSkill);
 				return {
 					content: [{
@@ -2284,53 +2736,34 @@ IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverI
 					isError: true
 				};
 			}
-			const clients = this.clientManager.getAllClients();
+			const knownServerNames = this.clientManager.getKnownServerNames();
 			const { serverName, actualToolName } = parseToolName(inputToolName);
-			if (serverName) {
-				const client$1 = this.clientManager.getClient(serverName);
-				if (!client$1) return {
+			if (serverName) try {
+				const client = await this.clientManager.ensureConnected(serverName);
+				if (client.toolBlacklist?.includes(actualToolName)) return {
 					content: [{
 						type: "text",
-						text: `Server "${serverName}" not found. Available servers: ${clients.map((c) => c.serverName).join(", ")}`
+						text: `Tool "${actualToolName}" is blacklisted on server "${serverName}" and cannot be executed.`
 					}],
 					isError: true
 				};
-				if (client$1.toolBlacklist?.includes(actualToolName)) return {
+				return await client.callTool(actualToolName, toolArgs);
+			} catch (error) {
+				return {
 					content: [{
 						type: "text",
-						text: `Tool "${actualToolName}" is blacklisted on server "${serverName}" and cannot be executed.`
+						text: `Failed to call tool "${actualToolName}" on server "${serverName}". Available servers: ${knownServerNames.join(", ")}. ${error instanceof Error ? error.message : "Unknown error"}`
 					}],
 					isError: true
 				};
-				try {
-					return await client$1.callTool(actualToolName, toolArgs);
-				} catch (error) {
-					return {
-						content: [{
-							type: "text",
-							text: `Failed to call tool "${actualToolName}" 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?.includes(actualToolName)) return null;
-					if ((await client$1.listTools()).some((t) => t.name === actualToolName)) 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));
+			const matchingServers = await this.definitionsCacheService.getServersForTool(actualToolName);
 			if (matchingServers.length === 0) {
 				if (this.skillService) {
 					const skill = await this.skillService.getSkill(actualToolName);
 					if (skill) return this.executeSkill(skill);
 				}
-				const promptSkill = this.findPromptSkill(actualToolName);
+				const promptSkill = await this.findPromptSkill(actualToolName);
 				if (promptSkill) return this.executePromptSkill(promptSkill);
 				return {
 					content: [{
@@ -2347,17 +2780,9 @@ IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverI
 				}],
 				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(actualToolName, toolArgs);
+				const targetServerName = matchingServers[0];
+				return await (await this.clientManager.ensureConnected(targetServerName)).callTool(actualToolName, toolArgs);
 			} catch (error) {
 				return {
 					content: [{
@@ -2379,6 +2804,10 @@ IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverI
 	}
 };
 
+//#endregion
+//#region package.json
+var version = "0.3.12";
+
 //#endregion
 //#region src/server/index.ts
 /**
@@ -2394,17 +2823,110 @@ IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverI
 * - Keep server setup modular and extensible
 * - Import tools from ../tools/ and register them in the handlers
 */
+function summarizeServerTools(serverDefinition) {
+	const toolNames = serverDefinition.tools.map((tool) => tool.name);
+	const capabilities = getUniqueSortedCapabilities(serverDefinition.tools);
+	const capabilitySummary = capabilities.length > 0 ? `; capabilities: ${capabilities.join(", ")}` : "";
+	if (toolNames.length === 0) return `${serverDefinition.serverName} (no tools cached${capabilitySummary})`;
+	return `${serverDefinition.serverName} (${toolNames.join(", ")})${capabilitySummary}`;
+}
+function buildFlatToolDescription(serverDefinition, tool) {
+	const parts = [`Proxied from server "${serverDefinition.serverName}" as tool "${tool.name}".`];
+	if (serverDefinition.serverInstruction) parts.push(`Server summary: ${serverDefinition.serverInstruction}`);
+	if (tool.description && !serverDefinition.omitToolDescription) parts.push(tool.description);
+	const capabilities = getToolCapabilities(tool);
+	if (capabilities.length > 0) parts.push(`Capabilities: ${capabilities.join(", ")}`);
+	return parts.join("\n\n");
+}
+function buildFlatToolDefinitions(serverDefinitions) {
+	const toolToServers = /* @__PURE__ */ new Map();
+	for (const serverDefinition of serverDefinitions) for (const tool of serverDefinition.tools) {
+		if (!toolToServers.has(tool.name)) toolToServers.set(tool.name, []);
+		toolToServers.get(tool.name)?.push(serverDefinition.serverName);
+	}
+	const definitions = [];
+	for (const serverDefinition of serverDefinitions) for (const tool of serverDefinition.tools) {
+		const hasClash = (toolToServers.get(tool.name) || []).length > 1;
+		definitions.push({
+			name: hasClash ? `${serverDefinition.serverName}__${tool.name}` : tool.name,
+			description: buildFlatToolDescription(serverDefinition, tool),
+			inputSchema: tool.inputSchema,
+			_meta: tool._meta
+		});
+	}
+	return definitions;
+}
+async function hasAnySkills(definitionsCacheService, skillService) {
+	const [fileSkills, serverDefinitions] = await Promise.all([skillService ? skillService.getSkills() : definitionsCacheService.getCachedFileSkills(), definitionsCacheService.getServerDefinitions()]);
+	return fileSkills.length > 0 || serverDefinitions.some((server) => server.promptSkills.length > 0);
+}
+function buildSkillsDescribeDefinition(serverDefinitions, serverId) {
+	const proxySummary = serverDefinitions.length > 0 ? serverDefinitions.map(summarizeServerTools).join("; ") : "No proxied servers available.";
+	return {
+		name: DescribeToolsTool.TOOL_NAME,
+		description: `Get detailed skill instructions for file-based skills and prompt-based skills proxied by one-mcp.\n\nProxy summary: ${proxySummary}\n\nUse this when you need the full instructions for a skill. For MCP tools, call the flat tool names directly. Only use skills discovered from describe_tools with id="${serverId}".`,
+		inputSchema: {
+			type: "object",
+			properties: { toolNames: {
+				type: "array",
+				items: {
+					type: "string",
+					minLength: 1
+				},
+				description: "List of skill names to get detailed information about",
+				minItems: 1
+			} },
+			required: ["toolNames"],
+			additionalProperties: false
+		}
+	};
+}
+function buildSearchDescribeDefinition(serverDefinitions, serverId) {
+	const summary = serverDefinitions.length > 0 ? serverDefinitions.map(summarizeServerTools).join("; ") : "No proxied servers available.";
+	return {
+		name: DescribeToolsTool.TOOL_NAME,
+		description: `Get detailed schemas and skill instructions for proxied MCP capabilities.\n\nProxy summary: ${summary}\n\nUse list_tools first to search capability summaries and discover tool names. Then use describe_tools to fetch full schemas or skill instructions. Only use capabilities discovered from one-mcp id="${serverId}".`,
+		inputSchema: {
+			type: "object",
+			properties: { toolNames: {
+				type: "array",
+				items: {
+					type: "string",
+					minLength: 1
+				},
+				description: "List of tool or skill names to get detailed information about",
+				minItems: 1
+			} },
+			required: ["toolNames"],
+			additionalProperties: false
+		}
+	};
+}
+function buildProxyInstructions(serverDefinitions, mode, includeSkillsTool) {
+	const summary = serverDefinitions.length > 0 ? serverDefinitions.map(summarizeServerTools).join("; ") : "No proxied servers available.";
+	if (mode === "flat") return [
+		"one-mcp proxies downstream MCP servers and exposes their tools and resources directly.",
+		`Proxied servers and tools: ${summary}`,
+		includeSkillsTool ? "Skills are still exposed through describe_tools when file-based skills or prompt-backed skills are configured." : "No skills are currently exposed through describe_tools."
+	].join("\n\n");
+	if (mode === "search") return [
+		"one-mcp proxies downstream MCP servers in search mode.",
+		`Proxied servers and tools: ${summary}`,
+		"Use list_tools to search capability summaries and discover tool names, describe_tools to fetch schemas or skill instructions, and use_tool to execute tools."
+	].join("\n\n");
+	return [
+		"one-mcp proxies downstream MCP servers in meta mode.",
+		`Proxied servers and tools: ${summary}`,
+		"Use describe_tools to inspect capabilities and use_tool to execute them."
+	].join("\n\n");
+}
 async function createServer(options) {
-	const server = new __modelcontextprotocol_sdk_server_index_js.Server({
-		name: "@agiflowai/one-mcp",
-		version: "0.1.0"
-	}, { capabilities: {
-		tools: {},
-		prompts: {}
-	} });
 	const clientManager = new McpClientManagerService();
 	let configSkills;
 	let configId;
+	let configHash;
+	let effectiveDefinitionsCachePath;
+	let shouldStartFromCache = false;
 	if (options?.configFilePath) {
 		let config;
 		try {
@@ -2417,38 +2939,92 @@ async function createServer(options) {
 		}
 		configSkills = config.skills;
 		configId = config.id;
-		const failedConnections = [];
-		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) {
-				const err = error instanceof Error ? error : new Error(String(error));
-				failedConnections.push({
-					serverName,
-					error: err
-				});
-				console.error(`Failed to connect to ${serverName}:`, error);
-			}
-		});
-		await Promise.all(connectionPromises);
-		if (failedConnections.length > 0 && failedConnections.length < Object.keys(config.mcpServers).length) console.error(`Warning: Some MCP server connections failed: ${failedConnections.map((f) => f.serverName).join(", ")}`);
-		if (failedConnections.length > 0 && failedConnections.length === Object.keys(config.mcpServers).length) throw new Error(`All MCP server connections failed: ${failedConnections.map((f) => `${f.serverName}: ${f.error.message}`).join(", ")}`);
+		configHash = DefinitionsCacheService.generateConfigHash(config);
+		effectiveDefinitionsCachePath = options.definitionsCachePath || DefinitionsCacheService.getDefaultCachePath(options.configFilePath);
+		clientManager.registerServerConfigs(config.mcpServers);
+		if (options.clearDefinitionsCache && effectiveDefinitionsCachePath) {
+			await DefinitionsCacheService.clearFile(effectiveDefinitionsCachePath);
+			console.error(`[definitions-cache] Cleared ${effectiveDefinitionsCachePath}`);
+		}
+		if (effectiveDefinitionsCachePath) try {
+			const cacheData = await DefinitionsCacheService.readFromFile(effectiveDefinitionsCachePath);
+			if (DefinitionsCacheService.isCacheValid(cacheData, {
+				configHash,
+				oneMcpVersion: version
+			})) shouldStartFromCache = true;
+		} catch {}
+		if (!shouldStartFromCache) {
+			const failedConnections = [];
+			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) {
+					const err = error instanceof Error ? error : new Error(String(error));
+					failedConnections.push({
+						serverName,
+						error: err
+					});
+					console.error(`Failed to connect to ${serverName}:`, error);
+				}
+			});
+			await Promise.all(connectionPromises);
+			if (failedConnections.length > 0 && failedConnections.length < Object.keys(config.mcpServers).length) console.error(`Warning: Some MCP server connections failed: ${failedConnections.map((f) => f.serverName).join(", ")}`);
+			if (failedConnections.length > 0 && failedConnections.length === Object.keys(config.mcpServers).length) throw new Error(`All MCP server connections failed: ${failedConnections.map((f) => `${f.serverName}: ${f.error.message}`).join(", ")}`);
+		} else console.error(`[definitions-cache] Using cached definitions from ${effectiveDefinitionsCachePath}`);
 	}
 	const serverId = options?.serverId || configId || generateServerId();
 	console.error(`[one-mcp] Server ID: ${serverId}`);
-	const skillsConfig = options?.skills || configSkills;
+	const skillPaths = (options?.skills || configSkills)?.paths ?? [];
 	const toolsRef = { describeTools: null };
-	const skillService = skillsConfig && skillsConfig.paths.length > 0 ? new SkillService(process.cwd(), skillsConfig.paths, { onCacheInvalidated: () => {
+	const skillService = skillPaths.length > 0 ? new SkillService(process.cwd(), skillPaths, { onCacheInvalidated: () => {
 		toolsRef.describeTools?.clearAutoDetectedSkillsCache();
 	} }) : void 0;
-	const describeTools = new DescribeToolsTool(clientManager, skillService, serverId);
-	const useTool = new UseToolTool(clientManager, skillService, serverId);
+	let definitionsCacheService;
+	if (effectiveDefinitionsCachePath) try {
+		const cacheData = await DefinitionsCacheService.readFromFile(effectiveDefinitionsCachePath);
+		if (DefinitionsCacheService.isCacheValid(cacheData, {
+			configHash,
+			oneMcpVersion: version
+		})) definitionsCacheService = new DefinitionsCacheService(clientManager, skillService, { cacheData });
+		else definitionsCacheService = new DefinitionsCacheService(clientManager, skillService);
+	} catch (error) {
+		console.error(`[definitions-cache] Failed to load ${effectiveDefinitionsCachePath}, falling back to live discovery: ${error instanceof Error ? error.message : "Unknown error"}`);
+		definitionsCacheService = new DefinitionsCacheService(clientManager, skillService);
+	}
+	else definitionsCacheService = new DefinitionsCacheService(clientManager, skillService);
+	const describeTools = new DescribeToolsTool(clientManager, skillService, serverId, definitionsCacheService);
+	const useToolWithCache = new UseToolTool(clientManager, skillService, serverId, definitionsCacheService);
+	const searchListTools = new SearchListToolsTool(clientManager, definitionsCacheService);
 	toolsRef.describeTools = describeTools;
+	const serverDefinitions = await definitionsCacheService.getServerDefinitions();
+	const includeSkillsTool = await hasAnySkills(definitionsCacheService, skillService);
+	const proxyMode = options?.proxyMode || "meta";
+	const server = new __modelcontextprotocol_sdk_server_index_js.Server({
+		name: "@agiflowai/one-mcp",
+		version: "0.1.0"
+	}, {
+		capabilities: {
+			tools: {},
+			resources: {},
+			prompts: {}
+		},
+		instructions: buildProxyInstructions(serverDefinitions, proxyMode, includeSkillsTool)
+	});
 	if (skillService) skillService.startWatching().catch((error) => {
 		console.error(`[skill-watcher] File watcher failed (non-critical): ${error instanceof Error ? error.message : "Unknown error"}`);
 	});
-	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.ListToolsRequestSchema, async () => ({ tools: [await describeTools.getDefinition(), useTool.getDefinition()] }));
+	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.ListToolsRequestSchema, async () => ({ tools: proxyMode === "flat" ? await (async () => {
+		const currentServerDefinitions = await definitionsCacheService.getServerDefinitions();
+		const shouldIncludeSkillsTool = await hasAnySkills(definitionsCacheService, skillService);
+		return [...buildFlatToolDefinitions(currentServerDefinitions), ...shouldIncludeSkillsTool ? [buildSkillsDescribeDefinition(currentServerDefinitions, serverId)] : []];
+	})() : proxyMode === "search" ? await (async () => {
+		return [
+			buildSearchDescribeDefinition(await definitionsCacheService.getServerDefinitions(), serverId),
+			await searchListTools.getDefinition(),
+			useToolWithCache.getDefinition()
+		];
+	})() : [await describeTools.getDefinition(), useToolWithCache.getDefinition()] }));
 	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.CallToolRequestSchema, async (request) => {
 		const { name, arguments: args } = request.params;
 		if (name === DescribeToolsTool.TOOL_NAME) try {
@@ -2457,36 +3033,65 @@ async function createServer(options) {
 			throw new Error(`Failed to execute ${name}: ${error instanceof Error ? error.message : String(error)}`);
 		}
 		if (name === UseToolTool.TOOL_NAME) try {
-			return await useTool.execute(args);
+			return await useToolWithCache.execute(args);
+		} catch (error) {
+			throw new Error(`Failed to execute ${name}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (name === SearchListToolsTool.TOOL_NAME && proxyMode === "search") try {
+			return await searchListTools.execute(args);
 		} catch (error) {
 			throw new Error(`Failed to execute ${name}: ${error instanceof Error ? error.message : String(error)}`);
 		}
+		if (proxyMode === "flat") return await useToolWithCache.execute({
+			toolName: name,
+			toolArgs: args || {}
+		});
 		throw new Error(`Unknown tool: ${name}`);
 	});
+	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.ListResourcesRequestSchema, async () => {
+		const serverDefinitions$1 = await definitionsCacheService.getServerDefinitions();
+		const resourceToServers = /* @__PURE__ */ new Map();
+		for (const serverDefinition of serverDefinitions$1) for (const resource of serverDefinition.resources) {
+			if (!resourceToServers.has(resource.uri)) resourceToServers.set(resource.uri, []);
+			resourceToServers.get(resource.uri)?.push(serverDefinition.serverName);
+		}
+		const resources = [];
+		for (const serverDefinition of serverDefinitions$1) for (const resource of serverDefinition.resources) {
+			const hasClash = (resourceToServers.get(resource.uri) || []).length > 1;
+			resources.push({
+				...resource,
+				uri: hasClash ? `${serverDefinition.serverName}__${resource.uri}` : resource.uri
+			});
+		}
+		return { resources };
+	});
+	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.ReadResourceRequestSchema, async (request) => {
+		const { uri } = request.params;
+		const { serverName, actualToolName: actualUri } = parseToolName(uri);
+		if (serverName) return await (await clientManager.ensureConnected(serverName)).readResource(actualUri);
+		const matchingServers = await definitionsCacheService.getServersForResource(actualUri);
+		if (matchingServers.length === 0) throw new Error(`Resource not found: ${uri}`);
+		if (matchingServers.length > 1) throw new Error(`Resource "${actualUri}" exists on multiple servers: ${matchingServers.join(", ")}. Use the prefixed format (e.g., "${matchingServers[0]}__${actualUri}") to specify which server to use.`);
+		return await (await clientManager.ensureConnected(matchingServers[0])).readResource(actualUri);
+	});
 	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.ListPromptsRequestSchema, async () => {
-		const clients = clientManager.getAllClients();
+		const serverDefinitions$1 = await definitionsCacheService.getServerDefinitions();
 		const promptToServers = /* @__PURE__ */ new Map();
 		const serverPromptsMap = /* @__PURE__ */ new Map();
-		await Promise.all(clients.map(async (client) => {
-			try {
-				const prompts = await client.listPrompts();
-				serverPromptsMap.set(client.serverName, prompts);
-				for (const prompt of prompts) {
-					if (!promptToServers.has(prompt.name)) promptToServers.set(prompt.name, []);
-					promptToServers.get(prompt.name).push(client.serverName);
-				}
-			} catch (error) {
-				console.error(`Failed to list prompts from ${client.serverName}:`, error);
-				serverPromptsMap.set(client.serverName, []);
+		for (const serverDefinition of serverDefinitions$1) {
+			serverPromptsMap.set(serverDefinition.serverName, serverDefinition.prompts);
+			for (const prompt of serverDefinition.prompts) {
+				if (!promptToServers.has(prompt.name)) promptToServers.set(prompt.name, []);
+				promptToServers.get(prompt.name).push(serverDefinition.serverName);
 			}
-		}));
+		}
 		const aggregatedPrompts = [];
-		for (const client of clients) {
-			const prompts = serverPromptsMap.get(client.serverName) || [];
+		for (const serverDefinition of serverDefinitions$1) {
+			const prompts = serverPromptsMap.get(serverDefinition.serverName) || [];
 			for (const prompt of prompts) {
 				const hasClash = (promptToServers.get(prompt.name) || []).length > 1;
 				aggregatedPrompts.push({
-					name: hasClash ? `${client.serverName}__${prompt.name}` : prompt.name,
+					name: hasClash ? `${serverDefinition.serverName}__${prompt.name}` : prompt.name,
 					description: prompt.description,
 					arguments: prompt.arguments
 				});
@@ -2496,27 +3101,27 @@ async function createServer(options) {
 	});
 	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.GetPromptRequestSchema, async (request) => {
 		const { name, arguments: args } = request.params;
-		const clients = clientManager.getAllClients();
+		const serverDefinitions$1 = await definitionsCacheService.getServerDefinitions();
 		const { serverName, actualToolName: actualPromptName } = parseToolName(name);
-		if (serverName) {
-			const client$1 = clientManager.getClient(serverName);
-			if (!client$1) throw new Error(`Server not found: ${serverName}`);
-			return await client$1.getPrompt(actualPromptName, args);
-		}
+		if (serverName) return await (await clientManager.ensureConnected(serverName)).getPrompt(actualPromptName, args);
 		const serversWithPrompt = [];
-		await Promise.all(clients.map(async (client$1) => {
-			try {
-				if ((await client$1.listPrompts()).some((p) => p.name === name)) serversWithPrompt.push(client$1.serverName);
-			} catch (error) {
-				console.error(`Failed to list prompts from ${client$1.serverName}:`, error);
-			}
-		}));
+		for (const serverDefinition of serverDefinitions$1) if (serverDefinition.prompts.some((prompt) => prompt.name === name)) serversWithPrompt.push(serverDefinition.serverName);
 		if (serversWithPrompt.length === 0) throw new Error(`Prompt not found: ${name}`);
 		if (serversWithPrompt.length > 1) throw new Error(`Prompt "${name}" exists on multiple servers: ${serversWithPrompt.join(", ")}. Use the prefixed format (e.g., "${serversWithPrompt[0]}__${name}") to specify which server to use.`);
 		const client = clientManager.getClient(serversWithPrompt[0]);
-		if (!client) throw new Error(`Server not found: ${serversWithPrompt[0]}`);
+		if (!client) return await (await clientManager.ensureConnected(serversWithPrompt[0])).getPrompt(name, args);
 		return await client.getPrompt(name, args);
 	});
+	if (!shouldStartFromCache && effectiveDefinitionsCachePath && options?.configFilePath) definitionsCacheService.collectForCache({
+		configPath: options.configFilePath,
+		configHash,
+		oneMcpVersion: version,
+		serverId
+	}).then((definitionsCache) => DefinitionsCacheService.writeToFile(effectiveDefinitionsCachePath, definitionsCache)).then(() => {
+		console.error(`[definitions-cache] Wrote ${effectiveDefinitionsCachePath}`);
+	}).catch((error) => {
+		console.error(`[definitions-cache] Failed to persist ${effectiveDefinitionsCachePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+	});
 	return server;
 }
 
@@ -2648,14 +3253,14 @@ var SseTransportHandler = class {
 		}
 	}
 	async start() {
-		return new Promise((resolve$1, reject) => {
+		return new Promise((resolve$2, 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$1();
+					resolve$2();
 				});
 				this.server.on("error", (error) => {
 					reject(error);
@@ -2666,17 +3271,17 @@ var SseTransportHandler = class {
 		});
 	}
 	async stop() {
-		return new Promise((resolve$1, reject) => {
+		return new Promise((resolve$2, reject) => {
 			if (this.server) {
 				this.sessionManager.clear();
 				this.server.close((err) => {
 					if (err) reject(err);
 					else {
 						this.server = null;
-						resolve$1();
+						resolve$2();
 					}
 				});
-			} else resolve$1();
+			} else resolve$2();
 		});
 	}
 	getPort() {
@@ -2828,12 +3433,12 @@ var HttpTransportHandler = class {
 		this.sessionManager.deleteSession(sessionId);
 	}
 	async start() {
-		return new Promise((resolve$1, reject) => {
+		return new Promise((resolve$2, 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$1();
+					resolve$2();
 				});
 				this.server.on("error", (error) => {
 					reject(error);
@@ -2844,17 +3449,17 @@ var HttpTransportHandler = class {
 		});
 	}
 	async stop() {
-		return new Promise((resolve$1, reject) => {
+		return new Promise((resolve$2, reject) => {
 			if (this.server) {
 				this.sessionManager.clear();
 				this.server.close((err) => {
 					if (err) reject(err);
 					else {
 						this.server = null;
-						resolve$1();
+						resolve$2();
 					}
 				});
-			} else resolve$1();
+			} else resolve$2();
 		});
 	}
 	getPort() {
@@ -2872,6 +3477,12 @@ Object.defineProperty(exports, 'ConfigFetcherService', {
     return ConfigFetcherService;
   }
 });
+Object.defineProperty(exports, 'DefinitionsCacheService', {
+  enumerable: true,
+  get: function () {
+    return DefinitionsCacheService;
+  }
+});
 Object.defineProperty(exports, 'DescribeToolsTool', {
   enumerable: true,
   get: function () {
@@ -2890,6 +3501,12 @@ Object.defineProperty(exports, 'McpClientManagerService', {
     return McpClientManagerService;
   }
 });
+Object.defineProperty(exports, 'SearchListToolsTool', {
+  enumerable: true,
+  get: function () {
+    return SearchListToolsTool;
+  }
+});
 Object.defineProperty(exports, 'SkillService', {
   enumerable: true,
   get: function () {
@@ -2931,4 +3548,16 @@ Object.defineProperty(exports, 'findConfigFile', {
   get: function () {
     return findConfigFile;
   }
+});
+Object.defineProperty(exports, 'generateServerId', {
+  enumerable: true,
+  get: function () {
+    return generateServerId;
+  }
+});
+Object.defineProperty(exports, 'version', {
+  enumerable: true,
+  get: function () {
+    return version;
+  }
 });