@agiflowai/one-mcp 0.3.11 → 0.3.12

package/dist/{http-BDeLFFzK.mjs → http-ClRbCldm.mjs}

@@ -1,12 +1,12 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListToolsRequestSchema, isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
-import { access, mkdir, readFile, readdir, stat, unlink, watch, writeFile } from "node:fs/promises";
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { access, mkdir, readFile, readdir, rm, stat, unlink, watch, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import yaml from "js-yaml";
 import { z } from "zod";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { dirname, isAbsolute, join, resolve } from "node:path";
-import { tmpdir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
@@ -760,14 +760,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]) {
@@ -794,7 +802,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}`);
 		}
@@ -815,213 +827,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 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 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 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 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
 /**
@@ -1287,8 +1092,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 = 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 readFile(filePath, "utf-8");
+		const parsed = isYamlPath(filePath) ? yaml.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) ? yaml.dump(cache, { noRefs: true }) : JSON.stringify(cache, null, 2);
+		await mkdir(dirname(filePath), { recursive: true });
+		await writeFile(filePath, serialized, "utf-8");
+	}
+	static getDefaultCachePath(configFilePath) {
+		const sanitizedPath = sanitizeConfigPathForFilename(configFilePath);
+		return join(homedir(), ".aicode-toolkit", `${sanitizedPath}.definitions-cache.json`);
+	}
+	static generateConfigHash(config) {
+		return 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 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 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 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 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 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
@@ -1362,6 +1724,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;
 	/**
@@ -1446,7 +1810,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"}`);
+				}
 			});
 		}
 	}
@@ -1457,6 +1827,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.
@@ -1468,10 +1840,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 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 = join(dirPath, entry);
+			const entryStat = await 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.
@@ -1579,32 +2007,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";
@@ -1643,6 +2045,7 @@ var DescribeToolsTool = class DescribeToolsTool {
 	static TOOL_NAME = "describe_tools";
 	clientManager;
 	skillService;
+	definitionsCacheService;
 	liquid = new Liquid();
 	/** Cache for auto-detected skills from prompt front-matter */
 	autoDetectedSkillsCache = null;
@@ -1654,10 +2057,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.
@@ -1666,6 +2070,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.
@@ -1731,21 +2136,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;
 	}
@@ -1758,22 +2154,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.
@@ -1786,13 +2167,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);
@@ -1821,24 +2197,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
 		*/
@@ -1846,21 +2210,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)) {
@@ -1871,6 +2239,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);
@@ -1940,7 +2316,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",
@@ -1950,25 +2326,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: [],
@@ -2106,6 +2475,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
 /**
@@ -2125,6 +2583,7 @@ var UseToolTool = class UseToolTool {
 	static TOOL_NAME = "use_tool";
 	clientManager;
 	skillService;
+	definitionsCacheService;
 	/** Unique server identifier for this one-mcp instance */
 	serverId;
 	/**
@@ -2133,9 +2592,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;
 	}
 	/**
@@ -2195,17 +2655,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.
@@ -2245,7 +2697,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: [{
@@ -2255,53 +2707,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: [{
@@ -2318,17 +2751,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: [{
@@ -2350,6 +2775,10 @@ IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverI
 	}
 };
 
+//#endregion
+//#region package.json
+var version = "0.3.11";
+
 //#endregion
 //#region src/server/index.ts
 /**
@@ -2365,17 +2794,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 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 {
@@ -2388,38 +2910,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 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(ListToolsRequestSchema, async () => ({ tools: [await describeTools.getDefinition(), useTool.getDefinition()] }));
+	server.setRequestHandler(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(CallToolRequestSchema, async (request) => {
 		const { name, arguments: args } = request.params;
 		if (name === DescribeToolsTool.TOOL_NAME) try {
@@ -2428,36 +3004,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(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(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(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
 				});
@@ -2467,27 +3072,27 @@ async function createServer(options) {
 	});
 	server.setRequestHandler(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;
 }
 
@@ -2837,4 +3442,4 @@ var HttpTransportHandler = class {
 };
 
 //#endregion
-export { UseToolTool as a, findConfigFile as c, createServer as i, McpClientManagerService as l, SseTransportHandler as n, DescribeToolsTool as o, StdioTransportHandler as r, SkillService as s, HttpTransportHandler as t, ConfigFetcherService as u };
+export { version as a, DescribeToolsTool as c, DefinitionsCacheService as d, generateServerId as f, createServer as i, SkillService as l, ConfigFetcherService as m, SseTransportHandler as n, UseToolTool as o, findConfigFile as p, StdioTransportHandler as r, SearchListToolsTool as s, HttpTransportHandler as t, McpClientManagerService as u };