@agiflowai/one-mcp 0.2.7 → 0.2.8

package/dist/{http-DSkkpGJU.mjs → http-DeUYygKb.mjs}

@@ -4,7 +4,7 @@ import { access, mkdir, readFile, readdir, stat, unlink, watch, writeFile } from
 import { existsSync } from "node:fs";
 import yaml from "js-yaml";
 import { z } from "zod";
-import { createHash, randomUUID } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -202,6 +202,7 @@ const ClaudeCodeStdioServerSchema = z.object({
 	env: z.record(z.string(), z.string()).optional(),
 	disabled: z.boolean().optional(),
 	instruction: z.string().optional(),
+	timeout: z.number().positive().optional(),
 	config: AdditionalConfigSchema
 });
 const ClaudeCodeHttpServerSchema = z.object({
@@ -210,6 +211,7 @@ const ClaudeCodeHttpServerSchema = z.object({
 	type: z.enum(["http", "sse"]).optional(),
 	disabled: z.boolean().optional(),
 	instruction: z.string().optional(),
+	timeout: z.number().positive().optional(),
 	config: AdditionalConfigSchema
 });
 const ClaudeCodeServerConfigSchema = z.union([ClaudeCodeStdioServerSchema, ClaudeCodeHttpServerSchema]);
@@ -240,6 +242,7 @@ const SkillsConfigSchema = z.object({ paths: z.array(z.string()) });
 * Full Claude Code MCP configuration schema
 */
 const ClaudeCodeMcpConfigSchema = z.object({
+	id: z.string().optional(),
 	mcpServers: z.record(z.string(), ClaudeCodeServerConfigSchema),
 	remoteConfigs: z.array(RemoteConfigSourceSchema).optional(),
 	skills: SkillsConfigSchema.optional()
@@ -280,6 +283,7 @@ const McpServerConfigSchema = z.discriminatedUnion("transport", [
 		toolBlacklist: z.array(z.string()).optional(),
 		omitToolDescription: z.boolean().optional(),
 		prompts: z.record(z.string(), InternalPromptConfigSchema).optional(),
+		timeout: z.number().positive().optional(),
 		transport: z.literal("stdio"),
 		config: McpStdioConfigSchema
 	}),
@@ -289,6 +293,7 @@ const McpServerConfigSchema = z.discriminatedUnion("transport", [
 		toolBlacklist: z.array(z.string()).optional(),
 		omitToolDescription: z.boolean().optional(),
 		prompts: z.record(z.string(), InternalPromptConfigSchema).optional(),
+		timeout: z.number().positive().optional(),
 		transport: z.literal("http"),
 		config: McpHttpConfigSchema
 	}),
@@ -298,6 +303,7 @@ const McpServerConfigSchema = z.discriminatedUnion("transport", [
 		toolBlacklist: z.array(z.string()).optional(),
 		omitToolDescription: z.boolean().optional(),
 		prompts: z.record(z.string(), InternalPromptConfigSchema).optional(),
+		timeout: z.number().positive().optional(),
 		transport: z.literal("sse"),
 		config: McpSseConfigSchema
 	})
@@ -306,6 +312,7 @@ const McpServerConfigSchema = z.discriminatedUnion("transport", [
 * Full internal MCP configuration schema
 */
 const InternalMcpConfigSchema = z.object({
+	id: z.string().optional(),
 	mcpServers: z.record(z.string(), McpServerConfigSchema),
 	skills: SkillsConfigSchema.optional()
 });
@@ -331,6 +338,7 @@ function transformClaudeCodeConfig(claudeConfig) {
 				toolBlacklist: stdioConfig.config?.toolBlacklist,
 				omitToolDescription: stdioConfig.config?.omitToolDescription,
 				prompts: stdioConfig.config?.prompts,
+				timeout: stdioConfig.timeout,
 				transport: "stdio",
 				config: {
 					command: interpolatedCommand,
@@ -349,6 +357,7 @@ function transformClaudeCodeConfig(claudeConfig) {
 				toolBlacklist: httpConfig.config?.toolBlacklist,
 				omitToolDescription: httpConfig.config?.omitToolDescription,
 				prompts: httpConfig.config?.prompts,
+				timeout: httpConfig.timeout,
 				transport,
 				config: {
 					url: interpolatedUrl,
@@ -358,6 +367,7 @@ function transformClaudeCodeConfig(claudeConfig) {
 		}
 	}
 	return {
+		id: claudeConfig.id,
 		mcpServers: transformedServers,
 		skills: claudeConfig.skills
 	};
@@ -518,22 +528,21 @@ var RemoteConfigCacheService = class {
 		try {
 			if (!existsSync(this.cacheDir)) return;
 			const now = Date.now();
-			const files = await readdir(this.cacheDir);
-			let expiredCount = 0;
-			for (const file of files) {
-				if (!file.endsWith(".json")) continue;
+			const jsonFiles = (await readdir(this.cacheDir)).filter((file) => file.endsWith(".json"));
+			const expiredCount = (await Promise.all(jsonFiles.map(async (file) => {
 				const filePath = join(this.cacheDir, file);
 				try {
 					const content = await readFile(filePath, "utf-8");
 					if (now > JSON.parse(content).expiresAt) {
 						await unlink(filePath);
-						expiredCount++;
+						return true;
 					}
+					return false;
 				} catch (error) {
 					await unlink(filePath).catch(() => {});
-					expiredCount++;
+					return true;
 				}
-			}
+			}))).filter(Boolean).length;
 			if (expiredCount > 0) console.error(`Cleaned up ${expiredCount} expired remote config cache entries`);
 		} catch (error) {
 			console.error("Failed to clean expired remote config cache:", error);
@@ -549,14 +558,15 @@ var RemoteConfigCacheService = class {
 				totalSize: 0
 			};
 			const jsonFiles = (await readdir(this.cacheDir)).filter((file) => file.endsWith(".json"));
-			let totalSize = 0;
-			for (const file of jsonFiles) {
+			const totalSize = (await Promise.all(jsonFiles.map(async (file) => {
 				const filePath = join(this.cacheDir, file);
 				try {
 					const content = await readFile(filePath, "utf-8");
-					totalSize += Buffer.byteLength(content, "utf-8");
-				} catch {}
-			}
+					return Buffer.byteLength(content, "utf-8");
+				} catch {
+					return 0;
+				}
+			}))).reduce((sum, size) => sum + size, 0);
 			return {
 				totalEntries: jsonFiles.length,
 				totalSize
@@ -807,6 +817,8 @@ 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
@@ -912,8 +924,10 @@ var McpClientManagerService = class {
 	}
 	/**
 	* 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, timeoutMs = 1e4) {
+	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`,
@@ -1208,6 +1222,71 @@ function extractSkillFrontMatter(content) {
 	return null;
 }
 
+//#endregion
+//#region src/utils/generateServerId.ts
+/**
+* generateServerId Utilities
+*
+* DESIGN PATTERNS:
+* - Pure functions with no side effects
+* - Single responsibility per function
+* - Functional programming approach
+*
+* CODING STANDARDS:
+* - Export individual functions, not classes
+* - Use descriptive function names with verbs
+* - Add JSDoc comments for complex logic
+* - Keep functions small and focused
+*
+* AVOID:
+* - Side effects (mutating external state)
+* - Stateful logic (use services for state)
+* - Complex external dependencies
+*/
+/**
+* Character set for generating human-readable IDs.
+* Excludes confusing characters: 0, O, 1, l, I
+*/
+const CHARSET = "23456789abcdefghjkmnpqrstuvwxyz";
+/**
+* Default length for generated server IDs (6 characters)
+*/
+const DEFAULT_ID_LENGTH = 6;
+/**
+* Generate a short, human-readable server ID.
+*
+* Uses Node.js crypto.randomBytes for cryptographically secure randomness
+* with rejection sampling to avoid modulo bias.
+*
+* The generated ID:
+* - Is 6 characters long by default
+* - Uses only lowercase alphanumeric characters
+* - Excludes confusing characters (0, O, 1, l, I)
+*
+* @param length - Length of the ID to generate (default: 6)
+* @returns A random, human-readable ID
+*
+* @example
+* generateServerId() // "abc234"
+* generateServerId(4) // "x7mn"
+*/
+function generateServerId(length = DEFAULT_ID_LENGTH) {
+	const charsetLength = 31;
+	const maxUnbiased = Math.floor(256 / charsetLength) * charsetLength - 1;
+	let result = "";
+	let remaining = length;
+	while (remaining > 0) {
+		const bytes = randomBytes(remaining);
+		for (let i = 0; i < bytes.length && remaining > 0; i++) {
+			const byte = bytes[i];
+			if (byte > maxUnbiased) continue;
+			result += CHARSET[byte % charsetLength];
+			remaining--;
+		}
+	}
+	return result;
+}
+
 //#endregion
 //#region src/services/SkillService.ts
 /**
@@ -1308,13 +1387,13 @@ var SkillService = class {
 		if (this.cachedSkills !== null) return this.cachedSkills;
 		const skills = [];
 		const loadedSkillNames = /* @__PURE__ */ new Set();
-		for (const skillPath of this.skillPaths) {
+		const allDirSkills = await Promise.all(this.skillPaths.map(async (skillPath) => {
 			const skillsDir = isAbsolute(skillPath) ? skillPath : join(this.cwd, skillPath);
-			const dirSkills = await this.loadSkillsFromDirectory(skillsDir, "project");
-			for (const skill of dirSkills) if (!loadedSkillNames.has(skill.name)) {
-				skills.push(skill);
-				loadedSkillNames.add(skill.name);
-			}
+			return this.loadSkillsFromDirectory(skillsDir, "project");
+		}));
+		for (const dirSkills of allDirSkills) for (const skill of dirSkills) if (!loadedSkillNames.has(skill.name)) {
+			skills.push(skill);
+			loadedSkillNames.add(skill.name);
 		}
 		this.cachedSkills = skills;
 		this.skillsByName = new Map(skills.map((skill) => [skill.name, skill]));
@@ -1352,9 +1431,15 @@ var SkillService = class {
 	*/
 	async startWatching() {
 		this.stopWatching();
-		for (const skillPath of this.skillPaths) {
+		const existenceChecks = await Promise.all(this.skillPaths.map(async (skillPath) => {
 			const skillsDir = isAbsolute(skillPath) ? skillPath : join(this.cwd, skillPath);
-			if (!await pathExists(skillsDir)) continue;
+			return {
+				skillsDir,
+				exists: await pathExists(skillsDir)
+			};
+		}));
+		for (const { skillsDir, exists } of existenceChecks) {
+			if (!exists) continue;
 			const abortController = new AbortController();
 			this.watchers.push(abortController);
 			this.watchDirectory(skillsDir, abortController.signal).catch((error) => {
@@ -1412,34 +1497,49 @@ var SkillService = class {
 		} catch (error) {
 			throw new SkillLoadError(`Failed to read skills directory: ${error instanceof Error ? error.message : "Unknown error"}`, dirPath, error instanceof Error ? error : void 0);
 		}
-		for (const entry of entries) {
+		const entryStats = await Promise.all(entries.map(async (entry) => {
 			const entryPath = join(dirPath, entry);
-			let entryStat;
 			try {
-				entryStat = await stat(entryPath);
+				return {
+					entry,
+					entryPath,
+					stat: await stat(entryPath),
+					error: null
+				};
 			} catch (error) {
 				console.warn(`Skipping entry ${entryPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
-				continue;
+				return {
+					entry,
+					entryPath,
+					stat: null,
+					error
+				};
 			}
+		}));
+		const skillFilesToLoad = [];
+		for (const { entry, entryPath, stat: entryStat } of entryStats) {
+			if (!entryStat) continue;
 			if (entryStat.isDirectory()) {
 				const skillFilePath = join(entryPath, "SKILL.md");
-				try {
-					if (await pathExists(skillFilePath)) {
-						const skill = await this.loadSkillFile(skillFilePath, location);
-						if (skill) skills.push(skill);
-					}
-				} catch (error) {
-					console.warn(`Skipping skill at ${skillFilePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
-					continue;
-				}
-			} else if (entry === "SKILL.md") try {
-				const skill = await this.loadSkillFile(entryPath, location);
-				if (skill) skills.push(skill);
+				skillFilesToLoad.push({
+					filePath: skillFilePath,
+					isRootLevel: false
+				});
+			} else if (entry === "SKILL.md") skillFilesToLoad.push({
+				filePath: entryPath,
+				isRootLevel: true
+			});
+		}
+		const loadResults = await Promise.all(skillFilesToLoad.map(async ({ filePath, isRootLevel }) => {
+			try {
+				if (!isRootLevel && !await pathExists(filePath)) return null;
+				return await this.loadSkillFile(filePath, location);
 			} catch (error) {
-				console.warn(`Skipping skill at ${entryPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
-				continue;
+				console.warn(`Skipping skill at ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+				return null;
 			}
-		}
+		}));
+		for (const skill of loadResults) if (skill) skills.push(skill);
 		return skills;
 	}
 	/**
@@ -1485,7 +1585,7 @@ var SkillService = class {
 * 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$1 = "skill__";
+const SKILL_PREFIX = "skill__";
 /**
 * Log prefix for skill detection messages.
 * Used to easily filter skill detection logs in stderr output.
@@ -1496,10 +1596,15 @@ const LOG_PREFIX_SKILL_DETECTION = "[skill-detection]";
 * 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>\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";
+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";
 
 //#endregion
 //#region src/tools/DescribeToolsTool.ts
@@ -1538,14 +1643,18 @@ var DescribeToolsTool = class DescribeToolsTool {
 	liquid = new Liquid();
 	/** Cache for auto-detected skills from prompt front-matter */
 	autoDetectedSkillsCache = null;
+	/** Unique server identifier for this one-mcp instance */
+	serverId;
 	/**
 	* Creates a new DescribeToolsTool instance
 	* @param clientManager - The MCP client manager for accessing remote servers
 	* @param skillService - Optional skill service for loading skills
+	* @param serverId - Unique server identifier for this one-mcp instance
 	*/
-	constructor(clientManager, skillService) {
+	constructor(clientManager, skillService, serverId) {
 		this.clientManager = clientManager;
 		this.skillService = skillService;
+		this.serverId = serverId || DEFAULT_SERVER_ID;
 	}
 	/**
 	* Clears the cached auto-detected skills from prompt front-matter.
@@ -1572,44 +1681,42 @@ var DescribeToolsTool = class DescribeToolsTool {
 	async detectSkillsFromPromptFrontMatter() {
 		if (this.autoDetectedSkillsCache !== null) return this.autoDetectedSkillsCache;
 		const clients = this.clientManager.getAllClients();
-		const autoDetectedSkills = [];
 		let listPromptsFailures = 0;
 		let fetchPromptFailures = 0;
-		const fetchPromises = [];
-		for (const client of clients) {
+		const autoDetectedSkills = (await Promise.all(clients.map(async (client) => {
+			const detectedSkills = [];
 			const configuredPromptNames = new Set(client.prompts ? Object.keys(client.prompts) : []);
-			const listPromptsPromise = (async () => {
-				try {
-					const prompts = await client.listPrompts();
-					if (!prompts || prompts.length === 0) return;
-					const promptFetchPromises = prompts.map(async (promptInfo) => {
-						if (configuredPromptNames.has(promptInfo.name)) return;
-						try {
-							const skillExtraction = extractSkillFrontMatter(((await client.getPrompt(promptInfo.name)).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);
-								return "";
-							}).join("\n"));
-							if (skillExtraction) autoDetectedSkills.push({
-								serverName: client.serverName,
-								promptName: promptInfo.name,
-								skill: skillExtraction.skill
-							});
-						} catch (error) {
-							fetchPromptFailures++;
-							console.error(`${LOG_PREFIX_SKILL_DETECTION} Failed to fetch prompt '${promptInfo.name}' from ${client.serverName}: ${error instanceof Error ? error.message : "Unknown error"}`);
-						}
-					});
-					await Promise.all(promptFetchPromises);
-				} catch (error) {
-					listPromptsFailures++;
-					console.error(`${LOG_PREFIX_SKILL_DETECTION} Failed to list prompts from ${client.serverName}: ${error instanceof Error ? error.message : "Unknown error"}`);
-				}
-			})();
-			fetchPromises.push(listPromptsPromise);
-		}
-		await Promise.all(fetchPromises);
+			try {
+				const prompts = await client.listPrompts();
+				if (!prompts || prompts.length === 0) return detectedSkills;
+				const promptResults = await Promise.all(prompts.map(async (promptInfo) => {
+					if (configuredPromptNames.has(promptInfo.name)) return null;
+					try {
+						const skillExtraction = extractSkillFrontMatter(((await client.getPrompt(promptInfo.name)).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);
+							return "";
+						}).join("\n"));
+						if (skillExtraction) return {
+							serverName: client.serverName,
+							promptName: promptInfo.name,
+							skill: skillExtraction.skill
+						};
+						return null;
+					} catch (error) {
+						fetchPromptFailures++;
+						console.error(`${LOG_PREFIX_SKILL_DETECTION} Failed to fetch prompt '${promptInfo.name}' from ${client.serverName}: ${error instanceof Error ? error.message : "Unknown error"}`);
+						return null;
+					}
+				}));
+				for (const result of promptResults) if (result) detectedSkills.push(result);
+			} catch (error) {
+				listPromptsFailures++;
+				console.error(`${LOG_PREFIX_SKILL_DETECTION} Failed to list prompts from ${client.serverName}: ${error instanceof Error ? error.message : "Unknown error"}`);
+			}
+			return detectedSkills;
+		}))).flat();
 		if (listPromptsFailures > 0 || fetchPromptFailures > 0) console.error(`${LOG_PREFIX_SKILL_DETECTION} Completed with ${listPromptsFailures} server failure(s) and ${fetchPromptFailures} prompt failure(s). Detected ${autoDetectedSkills.length} skill(s).`);
 		this.autoDetectedSkillsCache = autoDetectedSkills;
 		return autoDetectedSkills;
@@ -1770,14 +1877,15 @@ var DescribeToolsTool = class DescribeToolsTool {
 			const clashesWithMcpTool = allToolNames.has(skill.name);
 			return {
 				name: skill.name,
-				displayName: clashesWithMcpTool ? `${SKILL_PREFIX$1}${skill.name}` : skill.name,
+				displayName: clashesWithMcpTool ? `${SKILL_PREFIX}${skill.name}` : skill.name,
 				description: skill.description
 			};
 		});
 		return {
 			content: await this.liquid.parseAndRender(toolkit_description_default, {
 				servers,
-				skills
+				skills,
+				serverId: this.serverId
 			}),
 			toolNames: allToolNames
 		};
@@ -1859,40 +1967,42 @@ var DescribeToolsTool = class DescribeToolsTool {
 					serverToolsMap.set(client.serverName, []);
 				}
 			}));
-			const foundTools = [];
-			const foundSkills = [];
-			const notFoundItems = [];
-			for (const requestedName of toolNames) {
-				if (requestedName.startsWith(SKILL_PREFIX$1)) {
-					const skillName = requestedName.slice(SKILL_PREFIX$1.length);
+			const lookupResults = await Promise.all(toolNames.map(async (requestedName) => {
+				const result$1 = {
+					tools: [],
+					skills: [],
+					notFound: null
+				};
+				if (requestedName.startsWith(SKILL_PREFIX)) {
+					const skillName = requestedName.slice(SKILL_PREFIX.length);
 					if (this.skillService) {
 						const skill = await this.skillService.getSkill(skillName);
 						if (skill) {
-							foundSkills.push({
+							result$1.skills.push({
 								name: skill.name,
 								location: skill.basePath,
 								instructions: formatSkillInstructions(skill.name, skill.content)
 							});
-							continue;
+							return result$1;
 						}
 					}
 					const promptSkillContent = await this.getPromptSkillContent(skillName);
 					if (promptSkillContent) {
-						foundSkills.push(promptSkillContent);
-						continue;
+						result$1.skills.push(promptSkillContent);
+						return result$1;
 					}
-					notFoundItems.push(requestedName);
-					continue;
+					result$1.notFound = requestedName;
+					return result$1;
 				}
 				const { serverName, actualToolName } = parseToolName(requestedName);
 				if (serverName) {
 					const serverTools = serverToolsMap.get(serverName);
 					if (!serverTools) {
-						notFoundItems.push(requestedName);
-						continue;
+						result$1.notFound = requestedName;
+						return result$1;
 					}
 					const tool = serverTools.find((t) => t.name === actualToolName);
-					if (tool) foundTools.push({
+					if (tool) result$1.tools.push({
 						server: serverName,
 						tool: {
 							name: tool.name,
@@ -1900,52 +2010,61 @@ var DescribeToolsTool = class DescribeToolsTool {
 							inputSchema: tool.inputSchema
 						}
 					});
-					else notFoundItems.push(requestedName);
-				} else {
-					const servers = toolToServers.get(actualToolName);
-					if (!servers || servers.length === 0) {
-						if (this.skillService) {
-							const skill = await this.skillService.getSkill(actualToolName);
-							if (skill) {
-								foundSkills.push({
-									name: skill.name,
-									location: skill.basePath,
-									instructions: formatSkillInstructions(skill.name, skill.content)
-								});
-								continue;
-							}
-						}
-						const promptSkillContent = await this.getPromptSkillContent(actualToolName);
-						if (promptSkillContent) {
-							foundSkills.push(promptSkillContent);
-							continue;
+					else result$1.notFound = requestedName;
+					return result$1;
+				}
+				const servers = toolToServers.get(actualToolName);
+				if (!servers || servers.length === 0) {
+					if (this.skillService) {
+						const skill = await this.skillService.getSkill(actualToolName);
+						if (skill) {
+							result$1.skills.push({
+								name: skill.name,
+								location: skill.basePath,
+								instructions: formatSkillInstructions(skill.name, skill.content)
+							});
+							return result$1;
 						}
-						notFoundItems.push(requestedName);
-						continue;
 					}
-					if (servers.length === 1) {
-						const server = servers[0];
-						const tool = serverToolsMap.get(server).find((t) => t.name === actualToolName);
-						foundTools.push({
-							server,
-							tool: {
-								name: tool.name,
-								description: tool.description,
-								inputSchema: tool.inputSchema
-							}
-						});
-					} else for (const server of servers) {
-						const tool = serverToolsMap.get(server).find((t) => t.name === actualToolName);
-						foundTools.push({
-							server,
-							tool: {
-								name: tool.name,
-								description: tool.description,
-								inputSchema: tool.inputSchema
-							}
-						});
+					const promptSkillContent = await this.getPromptSkillContent(actualToolName);
+					if (promptSkillContent) {
+						result$1.skills.push(promptSkillContent);
+						return result$1;
 					}
+					result$1.notFound = requestedName;
+					return result$1;
+				}
+				if (servers.length === 1) {
+					const server = servers[0];
+					const tool = serverToolsMap.get(server).find((t) => t.name === actualToolName);
+					result$1.tools.push({
+						server,
+						tool: {
+							name: tool.name,
+							description: tool.description,
+							inputSchema: tool.inputSchema
+						}
+					});
+				} else for (const server of servers) {
+					const tool = serverToolsMap.get(server).find((t) => t.name === actualToolName);
+					result$1.tools.push({
+						server,
+						tool: {
+							name: tool.name,
+							description: tool.description,
+							inputSchema: tool.inputSchema
+						}
+					});
 				}
+				return result$1;
+			}));
+			const foundTools = [];
+			const foundSkills = [];
+			const notFoundItems = [];
+			for (const result$1 of lookupResults) {
+				foundTools.push(...result$1.tools);
+				foundSkills.push(...result$1.skills);
+				if (result$1.notFound) notFoundItems.push(result$1.notFound);
 			}
 			if (foundTools.length === 0 && foundSkills.length === 0) return {
 				content: [{
@@ -1988,10 +2107,6 @@ var DescribeToolsTool = class DescribeToolsTool {
 //#endregion
 //#region src/tools/UseToolTool.ts
 /**
-* Prefix used to identify skill invocations (e.g., skill__pdf)
-*/
-const SKILL_PREFIX = "skill__";
-/**
 * UseToolTool executes MCP tools and skills with proper error handling.
 *
 * This tool supports three invocation patterns:
@@ -2008,14 +2123,18 @@ var UseToolTool = class UseToolTool {
 	static TOOL_NAME = "use_tool";
 	clientManager;
 	skillService;
+	/** Unique server identifier for this one-mcp instance */
+	serverId;
 	/**
 	* Creates a new UseToolTool instance
 	* @param clientManager - The MCP client manager for accessing remote servers
 	* @param skillService - Optional skill service for loading and executing skills
+	* @param serverId - Unique server identifier for this one-mcp instance
 	*/
-	constructor(clientManager, skillService) {
+	constructor(clientManager, skillService, serverId) {
 		this.clientManager = clientManager;
 		this.skillService = skillService;
+		this.serverId = serverId || DEFAULT_SERVER_ID;
 	}
 	/**
 	* Returns the MCP tool definition with name, description, and input schema.
@@ -2031,6 +2150,8 @@ var UseToolTool = class UseToolTool {
 			description: `Execute an MCP tool (NOT Skill) with provided arguments. You MUST call describe_tools first to discover the tool's correct arguments. Then to use tool:
 - Provide toolName and toolArgs based on the schema
 - If multiple servers provide the same tool, specify serverName
+
+IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverId}".
 `,
 			inputSchema: {
 				type: "object",
@@ -2117,7 +2238,7 @@ var UseToolTool = class UseToolTool {
 		try {
 			const { toolName: inputToolName, toolArgs = {} } = input;
 			if (inputToolName.startsWith(SKILL_PREFIX)) {
-				const skillName = inputToolName.slice(7);
+				const skillName = inputToolName.slice(SKILL_PREFIX.length);
 				if (this.skillService) {
 					const skill = await this.skillService.getSkill(skillName);
 					if (skill) return this.executeSkill(skill);
@@ -2252,6 +2373,7 @@ async function createServer(options) {
 	} });
 	const clientManager = new McpClientManagerService();
 	let configSkills;
+	let configId;
 	if (options?.configFilePath) {
 		let config;
 		try {
@@ -2263,6 +2385,7 @@ async function createServer(options) {
 			throw new Error(`Failed to load MCP configuration from '${options.configFilePath}': ${error instanceof Error ? error.message : String(error)}`);
 		}
 		configSkills = config.skills;
+		configId = config.id;
 		const failedConnections = [];
 		const connectionPromises = Object.entries(config.mcpServers).map(async ([serverName, serverConfig]) => {
 			try {
@@ -2281,13 +2404,15 @@ async function createServer(options) {
 		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(", ")}`);
 	}
+	const serverId = options?.serverId || configId || generateServerId();
+	console.error(`[one-mcp] Server ID: ${serverId}`);
 	const skillsConfig = options?.skills || configSkills;
 	const toolsRef = { describeTools: null };
 	const skillService = skillsConfig && skillsConfig.paths.length > 0 ? new SkillService(process.cwd(), skillsConfig.paths, { onCacheInvalidated: () => {
 		toolsRef.describeTools?.clearAutoDetectedSkillsCache();
 	} }) : void 0;
-	const describeTools = new DescribeToolsTool(clientManager, skillService);
-	const useTool = new UseToolTool(clientManager, skillService);
+	const describeTools = new DescribeToolsTool(clientManager, skillService, serverId);
+	const useTool = new UseToolTool(clientManager, skillService, serverId);
 	toolsRef.describeTools = describeTools;
 	if (skillService) skillService.startWatching().catch((error) => {
 		console.error(`[skill-watcher] File watcher failed (non-critical): ${error instanceof Error ? error.message : "Unknown error"}`);