@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

package/dist/server/src/services/hub-tools.service.js

@@ -4,9 +4,10 @@ import { eventBus, EventTypes } from './event-bus.service.js';
 import { gateway } from './gateway.service.js';
 import { logger, LOG_MODULES } from '../utils/logger.js';
 import { stringifyForLogging } from '../utils/json-utils.js';
-import { MCP_HUB_LITE_SERVER, LIST_SERVERS_TOOL, FIND_SERVERS_TOOL, LIST_ALL_TOOLS_IN_SERVER_TOOL, FIND_TOOLS_IN_SERVER_TOOL, GET_TOOL_TOOL, CALL_TOOL_TOOL, FIND_TOOLS_TOOL, SYSTEM_TOOL_NAMES } from '../models/system-tools.constants.js';
+import { McpError } from '@modelcontextprotocol/sdk/types.js';
+import { MCP_HUB_LITE_SERVER, LIST_SERVERS_TOOL, LIST_TOOLS_IN_SERVER_TOOL, GET_TOOL_TOOL, CALL_TOOL_TOOL, UPDATE_SERVER_DESCRIPTION_TOOL, SYSTEM_TOOL_NAMES } from '../models/system-tools.constants.js';
 import { ToolArgsParser } from '../utils/tool-args-parser.js';
-import { hasValidId, selectBestInstance, getSystemTools, findServers as findServersUtil, findToolsInServer as findToolsInServerUtil, findTools as findToolsUtil, generateDynamicResources, readResource as readResourceUtil } from './hub-tools/index.js';
+import { hasValidId, selectBestInstance, getServerDescription, getSystemTools, generateDynamicResources, readResource as readResourceUtil } from './hub-tools/index.js';
 /**
  * Central service for managing system tools and MCP server interactions in the MCP Hub Lite gateway.
  *
@@ -18,7 +19,7 @@ import { hasValidId, selectBestInstance, getSystemTools, findServers as findServ
  * ## Core Responsibilities
  *
  * - **System Tool Management**: Exposes a standardized set of system tools for server discovery and management
- * - **Tool Discovery**: Enables searching and listing tools across all connected MCP servers
+ * - **Tool Discovery**: Enables listing tools across all connected MCP servers
  * - **Tool Execution**: Provides safe, monitored execution of tools with comprehensive event tracking
  * - **Resource Management**: Dynamically generates and serves virtual resources representing server state
  * - **Instance Selection**: Handles intelligent server instance selection for multi-instance scenarios
@@ -28,12 +29,9 @@ import { hasValidId, selectBestInstance, getSystemTools, findServers as findServ
  *
  * The service exposes the following system tools through the `getSystemTools()` method:
  * - `list-servers`: Retrieve all connected server names
- * - `find-servers`: Search servers by pattern matching
- * - `list-all-tools-in-server`: List all tools from a specific server
- * - `find-tools-in-server`: Search tools within a specific server
+ * - `list-tools-in-server`: List all tools from a specific server
  * - `get-tool`: Retrieve complete schema for a specific tool
  * - `call-tool`: Execute a tool on a specific server
- * - `find-tools`: Search tools across all connected servers
  *
  * ## Architecture Integration
  *
@@ -55,9 +53,6 @@ import { hasValidId, selectBestInstance, getSystemTools, findServers as findServ
  *
  * // Call a tool on a specific server
  * const result = await hubTools.callTool('file-system-server', 'list-files', { directory: '/home' });
- *
- * // Search for tools across all servers
- * const matchingTools = await hubTools.findTools('search');
  * ```
  */
 export class HubToolsService {
@@ -97,30 +92,34 @@ export class HubToolsService {
         return getSystemTools();
     }
     /**
-     * Lists all connected MCP servers by name.
+     * Lists all connected MCP servers with their descriptions.
      *
      * This method retrieves all configured servers from the hub manager, filters out
-     * invalid entries using the hasValidId type guard, and returns an array of server names.
-     * It provides a simple way to discover available servers in the system.
+     * invalid entries using the hasValidId type guard, and returns a Record mapping
+     * server names to their descriptions. If a server doesn't have a description,
+     * a default description is provided.
      *
-     * @returns {Promise<string[]>} Array of connected server names
+     * @returns {Promise<Record<string, string>>} Record mapping server names to descriptions
      */
     async listServers() {
         const servers = hubManager.getAllServers();
-        return servers.filter(hasValidId).map((server) => server.name);
-    }
-    /**
-     * Finds servers matching a specified regex pattern.
-     *
-     * This method searches through all configured servers using the provided regex pattern,
-     * supporting flexible search options including case sensitivity and search scope
-     * (name, description, or both). It returns an array of matching server names.
-     *
-     * @param {FindServersParams} args - Search parameters
-     * @returns {Promise<string[]>} Array of matching server names
-     */
-    async findServers(args) {
-        return findServersUtil(args.pattern, args.searchIn, args.caseSensitive);
+        const result = {};
+        for (const server of servers.filter(hasValidId)) {
+            // Check if server is actually connected
+            const status = mcpConnectionManager.getStatusByName(server.name);
+            if (!status?.connected) {
+                continue;
+            }
+            // Use non-strict mode for management operations to avoid tag-match-unique errors
+            const serverInfo = selectBestInstance(server.name, undefined, false);
+            if (!serverInfo) {
+                // Skip servers that can't be selected (e.g., tag-match-unique without tags)
+                continue;
+            }
+            const description = getServerDescription(server.config, server.name);
+            result[server.name] = description;
+        }
+        return result;
     }
     /**
      * Lists all tools available from a specific MCP server.
@@ -130,57 +129,44 @@ export class HubToolsService {
      * It uses the selectBestInstance function to resolve server names to instances
      * and leverages the MCP connection manager for tool retrieval.
      *
-     * @param {ListAllToolsInServerParams} args - Server name and request options
-     * @returns {Promise<{ serverName: string; tools: Tool[] }>} Object containing server name and tools array
+     * @param {ListToolsInServerParams} args - Server name and request options
+     * @returns {Promise<{ serverName: string; tools: ToolSummary[] }>} Object containing server name and tools array
      * @throws {Error} If the specified server is not found or not connected
      */
-    async listAllToolsInServer(args) {
+    async listToolsInServer(args) {
         // Handle MCP Hub Lite server (return system tools list)
         if (typeof args.serverName === 'string' && args.serverName === MCP_HUB_LITE_SERVER) {
             // Generate tool list using the same logic as tools/list
             const toolMap = new Map();
             const gatewayTools = gateway.generateGatewayToolsList(toolMap);
-            // Convert to Tool format
-            const tools = gatewayTools.map((tool) => ({
+            // Convert to ToolSummary format (without inputSchema)
+            const toolSummaries = gatewayTools.map((tool) => ({
                 name: tool.name,
                 description: tool.description,
-                inputSchema: tool.inputSchema,
-                serverName: MCP_HUB_LITE_SERVER,
-                annotations: tool.annotations
+                serverName: MCP_HUB_LITE_SERVER
             }));
             return {
                 serverName: args.serverName,
-                tools
+                tools: toolSummaries
             };
         }
-        const serverInfo = selectBestInstance(args.serverName, args.requestOptions);
-        if (!serverInfo) {
+        // Use server name level cache to get tools directly without triggering instance selection
+        // This avoids tag-match-unique errors for multi-instance servers when listing tools
+        const tools = mcpConnectionManager.getToolsByServerName(args.serverName);
+        if (tools.length === 0) {
             throw new Error(`Server not found: ${args.serverName}`);
         }
-        // Get instance ID
-        const serverId = serverInfo.instance.id;
-        // Get tool list from connection manager
-        const tools = mcpConnectionManager.getTools(serverId);
+        // Convert to ToolSummary format (without inputSchema)
+        const toolSummaries = tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            serverName: args.serverName
+        }));
         return {
             serverName: args.serverName,
-            tools
+            tools: toolSummaries
         };
     }
-    /**
-     * Finds tools matching a pattern within a specific MCP server.
-     *
-     * This method searches through all tools available from the specified server using
-     * the provided regex pattern, supporting flexible search options including case
-     * sensitivity and search scope (name, description, or both). It returns matching
-     * tools grouped by server name.
-     *
-     * @param {FindToolsInServerParams} args - Search parameters
-     * @returns {Promise<{ serverName: string; tools: Tool[] }>} Object containing server name and matching tools
-     * @throws {Error} If the specified server is not found or not connected
-     */
-    async findToolsInServer(args) {
-        return findToolsInServerUtil(args.serverName, args.pattern, args.searchIn, args.caseSensitive, args.requestOptions);
-    }
     /**
      * Retrieves the complete schema for a specific tool from a specific server.
      *
@@ -193,12 +179,57 @@ export class HubToolsService {
      * @throws {Error} If the specified server is not found or not connected
      */
     async getTool(args) {
-        const serverInfo = selectBestInstance(args.serverName, args.requestOptions);
-        if (!serverInfo) {
+        // Handle MCP Hub Lite server (return system tool)
+        if (typeof args.serverName === 'string' && args.serverName === MCP_HUB_LITE_SERVER) {
+            const systemTools = getSystemTools();
+            const found = systemTools.find((tool) => tool.name === args.toolName);
+            if (found) {
+                return {
+                    ...found,
+                    serverName: MCP_HUB_LITE_SERVER
+                };
+            }
+            return undefined;
+        }
+        // Use server name level cache to get tools directly without triggering instance selection
+        // This avoids tag-match-unique errors for multi-instance servers when getting tool details
+        const tools = mcpConnectionManager.getToolsByServerName(args.serverName);
+        if (tools.length === 0) {
             throw new Error(`Server not found: ${args.serverName}`);
         }
-        const tools = mcpConnectionManager.getTools(serverInfo.instance.id);
-        return tools.find((tool) => tool.name === args.toolName);
+        return tools.find((t) => t.name === args.toolName);
+    }
+    /**
+     * Updates the description of a specific MCP server.
+     *
+     * This method validates the server exists, updates its description in the configuration,
+     * and persists the change to disk. It leverages the existing hubManager.updateServer()
+     * method which handles configuration persistence and event publishing.
+     *
+     * @param {UpdateServerDescriptionParams} args - Server name and new description
+     * @returns {Promise<{ success: boolean; serverName: string; description: string }>} Confirmation of successful update
+     * @throws {Error} If the server is not found or update fails
+     */
+    async updateServerDescription(args) {
+        // Handle both direct call (UpdateServerDescriptionParams) and call_tool wrapper (CallToolParams with nested toolArgs)
+        const { serverName, description } = 'toolArgs' in args && args.toolArgs ? args.toolArgs : args;
+        // Validate server exists
+        const existing = hubManager.getServerByName(serverName);
+        if (!existing) {
+            throw new Error(`Server not found: ${serverName}`);
+        }
+        // Update server description using existing hubManager
+        await hubManager.updateServer(serverName, { description });
+        // Note: hubManager.updateServer() already:
+        // 1. Updates the in-memory configuration
+        // 2. Persists to disk via configManager
+        // 3. Publishes SERVER_UPDATED event
+        // 4. Triggers cache invalidation in HubToolsService
+        return {
+            success: true,
+            serverName,
+            description
+        };
     }
     /**
      * Calls a specific system tool directly with type-safe conditional return types.
@@ -220,16 +251,8 @@ export class HubToolsService {
                 case LIST_SERVERS_TOOL:
                     result = await this.listServers();
                     break;
-                case FIND_SERVERS_TOOL: {
-                    result = await this.findServers(toolArgs);
-                    break;
-                }
-                case LIST_ALL_TOOLS_IN_SERVER_TOOL: {
-                    result = await this.listAllToolsInServer(toolArgs);
-                    break;
-                }
-                case FIND_TOOLS_IN_SERVER_TOOL: {
-                    result = await this.findToolsInServer(toolArgs);
+                case LIST_TOOLS_IN_SERVER_TOOL: {
+                    result = await this.listToolsInServer(toolArgs);
                     break;
                 }
                 case GET_TOOL_TOOL: {
@@ -248,8 +271,8 @@ export class HubToolsService {
                     });
                     break;
                 }
-                case FIND_TOOLS_TOOL: {
-                    result = await this.findTools(toolArgs);
+                case UPDATE_SERVER_DESCRIPTION_TOOL: {
+                    result = await this.updateServerDescription(toolArgs);
                     break;
                 }
                 default:
@@ -278,7 +301,9 @@ export class HubToolsService {
      */
     async callTool(args) {
         let { serverName, toolName } = args;
-        const { toolArgs, requestOptions } = args;
+        // Support both toolArgs and arguments for backward compatibility
+        const toolArgs = (args.toolArgs || args.arguments || {});
+        const { requestOptions } = args;
         // Parse prefixed tool names (like mcp__mcp-hub-lite__xxx) if applicable
         const parsedTool = ToolArgsParser.parsePrefixedToolName(toolName);
         if (parsedTool) {
@@ -291,9 +316,11 @@ export class HubToolsService {
             serverName = MCP_HUB_LITE_SERVER;
         }
         if (typeof serverName === 'string' && serverName === MCP_HUB_LITE_SERVER) {
-            // Check if it's a system tool
-            if (SYSTEM_TOOL_NAMES.includes(toolName)) {
-                return await this.callSystemTool(toolName, toolArgs);
+            // System tools cannot be called via call_tool - they must be called directly
+            if (Array.isArray(SYSTEM_TOOL_NAMES) &&
+                SYSTEM_TOOL_NAMES.includes(toolName)) {
+                throw new McpError(-32801, `System tools cannot be called via 'call_tool'. Use 'tools/call' with the system tool name directly. ` +
+                    `Example: use 'list_servers' directly instead of call_tool(serverName: "mcp-hub-lite", toolName: "list_servers").`);
             }
             // Not a system tool - find it in all connected servers
             logger.info(`Looking for tool '${toolName}' in all connected servers (gateway mode)`, LOG_MODULES.HUB_TOOLS);
@@ -304,9 +331,10 @@ export class HubToolsService {
                 if (!hasValidId(server)) {
                     continue;
                 }
-                const serverInfo = selectBestInstance(server.name, requestOptions);
+                const serverInfo = selectBestInstance(server.name, requestOptions, true);
                 if (serverInfo && serverInfo.instance.id) {
-                    const tools = mcpConnectionManager.getTools(serverInfo.instance.id);
+                    const instanceIndex = serverInfo.instance.index;
+                    const tools = mcpConnectionManager.getTools(server.name, instanceIndex);
                     if (tools.some((tool) => tool.name === toolName)) {
                         matchingServers.push(server.name);
                     }
@@ -323,29 +351,84 @@ export class HubToolsService {
             serverName = matchingServers[0];
         }
         logger.debug(`Tool call received: serverName=${serverName}, toolName=${toolName}, args=${stringifyForLogging(toolArgs)}`, LOG_MODULES.HUB_TOOLS);
-        const serverInfo = selectBestInstance(serverName, requestOptions);
-        if (!serverInfo) {
-            logger.error(`Server not found: ${serverName}`, LOG_MODULES.HUB_TOOLS);
-            throw new Error(`Server not found: ${serverName}`);
+        // Validate tool exists before doing strict instance selection
+        // Use strictMode=false to get serverInfo without triggering tag-match-unique errors
+        const validationServerInfo = selectBestInstance(serverName, requestOptions, false);
+        if (validationServerInfo && validationServerInfo.instance.id) {
+            const instanceIndex = validationServerInfo.instance.index;
+            const tools = mcpConnectionManager.getTools(serverName, instanceIndex);
+            if (!tools.some((tool) => tool.name === toolName)) {
+                throw new Error(`Tool '${toolName}' not found in server '${serverName}'. ` +
+                    `Use list_tools_in_server(serverName: "${serverName}") to see available tools.`);
+            }
         }
-        const serverId = serverInfo.instance.id;
+        const serverInfo = selectBestInstance(serverName, requestOptions, true);
         const requestId = `tool-call-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        if (!serverInfo) {
+            // Server not found in hubManager, try direct call by name through mcpConnectionManager
+            logger.debug(`Server not found in hubManager, trying direct call by name: ${serverName}`, LOG_MODULES.HUB_TOOLS);
+            // Use selectBestInstance with non-strict mode to find an available instance
+            const fallbackServerInfo = selectBestInstance(serverName, undefined, false);
+            if (!fallbackServerInfo) {
+                logger.error(`Server not found: ${serverName}`, LOG_MODULES.HUB_TOOLS);
+                throw new Error(`Server not found: ${serverName}`);
+            }
+            const instanceIndex = fallbackServerInfo.instance.index;
+            // Publish tool call started event with the resolved serverIndex
+            eventBus.publish(EventTypes.TOOL_CALL_STARTED, {
+                requestId,
+                serverName,
+                serverIndex: instanceIndex,
+                toolName,
+                timestamp: Date.now(),
+                args: toolArgs
+            });
+            try {
+                const result = await mcpConnectionManager.callTool(serverName, instanceIndex, toolName, toolArgs);
+                // Publish tool call completed event
+                eventBus.publish(EventTypes.TOOL_CALL_COMPLETED, {
+                    requestId,
+                    serverName,
+                    serverIndex: instanceIndex,
+                    toolName,
+                    timestamp: Date.now(),
+                    result
+                });
+                logger.debug(`Tool call SUCCESS: serverName=${serverName}, toolName=${toolName}`, LOG_MODULES.HUB_TOOLS);
+                return result;
+            }
+            catch (error) {
+                // Publish tool call error event
+                eventBus.publish(EventTypes.TOOL_CALL_ERROR, {
+                    requestId,
+                    serverName,
+                    serverIndex: instanceIndex,
+                    toolName,
+                    timestamp: Date.now(),
+                    error: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined
+                });
+                logger.error(`Tool call FAILED: serverName=${serverName}, toolName=${toolName}, error=${error instanceof Error ? error.message : String(error)}`, error, LOG_MODULES.HUB_TOOLS);
+                throw error;
+            }
+        }
+        const instanceIndex = serverInfo.instance.index;
         // Publish tool call started event
         eventBus.publish(EventTypes.TOOL_CALL_STARTED, {
             requestId,
-            serverId,
             serverName,
+            serverIndex: instanceIndex,
             toolName,
             timestamp: Date.now(),
             args: toolArgs
         });
         try {
-            const result = await mcpConnectionManager.callTool(serverId, toolName, toolArgs);
+            const result = await mcpConnectionManager.callTool(serverName, instanceIndex, toolName, toolArgs);
             // Publish tool call completed event
             eventBus.publish(EventTypes.TOOL_CALL_COMPLETED, {
                 requestId,
-                serverId,
                 serverName,
+                serverIndex: instanceIndex,
                 toolName,
                 timestamp: Date.now(),
                 result
@@ -357,8 +440,8 @@ export class HubToolsService {
             // Publish tool call error event
             eventBus.publish(EventTypes.TOOL_CALL_ERROR, {
                 requestId,
-                serverId,
                 serverName,
+                serverIndex: instanceIndex,
                 toolName,
                 timestamp: Date.now(),
                 error: error instanceof Error ? error.message : String(error),
@@ -375,14 +458,14 @@ export class HubToolsService {
      * the system tools provided by the MCP Hub Lite server itself. It returns a structured
      * object mapping server names to their respective tool arrays.
      *
-     * @returns {Promise<Record<string, { tools: Tool[] }>>} Object mapping server names to tool arrays
+     * @returns {Promise<Record<string, { tools: ToolSummary[] }>>} Object mapping server names to tool arrays
      */
     async listAllTools() {
         const servers = hubManager.getAllServers();
         const allTools = {};
         // Add system tools under mcp-hub-lite server
         const systemTools = this.getSystemTools().map((tool) => ({
-            ...tool,
+            name: tool.name,
             description: `[System] ${tool.description}`,
             serverName: MCP_HUB_LITE_SERVER
         }));
@@ -393,32 +476,24 @@ export class HubToolsService {
             if (!hasValidId(server)) {
                 continue;
             }
-            const instances = hubManager.getServerInstanceByName(server.name);
+            const instances = hubManager.getServerInstancesByName(server.name);
             for (const instance of instances) {
                 if (instance.id) {
-                    const tools = mcpConnectionManager.getTools(instance.id);
+                    const instanceIndex = instance.index ?? 0;
+                    const tools = mcpConnectionManager.getTools(server.name, instanceIndex);
+                    const toolSummaries = tools.map((tool) => ({
+                        name: tool.name,
+                        description: tool.description,
+                        serverName: server.name
+                    }));
                     allTools[server.name] = {
-                        tools
+                        tools: toolSummaries
                     };
                 }
             }
         }
         return allTools;
     }
-    /**
-     * Finds tools matching a pattern across all connected MCP servers.
-     *
-     * This method searches through all available tools from all connected servers using the
-     * provided regex pattern, supporting flexible search options including case sensitivity
-     * and search scope (name, description, or both). It returns matching tools grouped by
-     * their originating server names.
-     *
-     * @param {FindToolsParams} args - Search parameters
-     * @returns {Promise<Record<string, { tools: Tool[] }>>} Object mapping server names to matching tools
-     */
-    async findTools(args) {
-        return findToolsUtil(args.pattern, args.searchIn, args.caseSensitive, () => this.listAllTools());
-    }
     /**
      * Lists all dynamically generated Hub resources based on connected MCP servers.
      *
@@ -447,7 +522,7 @@ export class HubToolsService {
      * - Resources list: hub://servers/{serverName}/resources
      *
      * @param {string} uri - Resource URI to read (e.g., hub://servers/server-name)
-     * @returns {Promise<ServerMetadata | Tool[] | Resource[]>} Resource content based on URI type
+     * @returns {Promise<ServerMetadata | Tool[] | Resource[] | string>} Resource content based on URI type
      * @throws {Error} If URI format is invalid, server not found, or resource type unknown
      */
     async readResource(uri) {

package/dist/server/src/services/system-tool-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system-tool-handler.d.ts","sourceRoot":"","sources":["../../../../src/services/system-tool-handler.ts"],"names":[],"mappings":"AAsBA;;GAEG;AACH,qBAAa,iBAAiB;IAC5B;;OAEG;WACU,oBAAoB,CAC/B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,OAAO,CAAC,OAAO,CAAC;CAwEpB"}
+{"version":3,"file":"system-tool-handler.d.ts","sourceRoot":"","sources":["../../../../src/services/system-tool-handler.ts"],"names":[],"mappings":"AAoBA;;GAEG;AACH,qBAAa,iBAAiB;IAC5B;;OAEG;WACU,oBAAoB,CAC/B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,OAAO,CAAC,OAAO,CAAC;CA8DpB"}

package/dist/server/src/services/system-tool-handler.js

@@ -1,7 +1,7 @@
 import { hubToolsService } from './hub-tools.service.js';
 import { McpError } from '@modelcontextprotocol/sdk/types.js';
 import { logger, LOG_MODULES } from '../utils/logger.js';
-import { LIST_SERVERS_TOOL, FIND_SERVERS_TOOL, LIST_ALL_TOOLS_IN_SERVER_TOOL, FIND_TOOLS_IN_SERVER_TOOL, GET_TOOL_TOOL, CALL_TOOL_TOOL, FIND_TOOLS_TOOL, MCP_HUB_LITE_SERVER } from '../models/system-tools.constants.js';
+import { LIST_SERVERS_TOOL, LIST_TOOLS_IN_SERVER_TOOL, GET_TOOL_TOOL, CALL_TOOL_TOOL, UPDATE_SERVER_DESCRIPTION_TOOL, MCP_HUB_LITE_SERVER } from '../models/system-tools.constants.js';
 import { stringifyForLogging } from '../utils/json-utils.js';
 /**
  * Unified system tool call handler
@@ -18,19 +18,9 @@ export class SystemToolHandler {
                 case LIST_SERVERS_TOOL:
                     result = await hubToolsService.listServers();
                     break;
-                case FIND_SERVERS_TOOL: {
-                    const findServersArgs = toolArgs;
-                    result = await hubToolsService.findServers(findServersArgs);
-                    break;
-                }
-                case LIST_ALL_TOOLS_IN_SERVER_TOOL: {
-                    const listAllToolsArgs = toolArgs;
-                    result = await hubToolsService.listAllToolsInServer(listAllToolsArgs);
-                    break;
-                }
-                case FIND_TOOLS_IN_SERVER_TOOL: {
-                    const findToolsInServerArgs = toolArgs;
-                    result = await hubToolsService.findToolsInServer(findToolsInServerArgs);
+                case LIST_TOOLS_IN_SERVER_TOOL: {
+                    const listToolsArgs = toolArgs;
+                    result = await hubToolsService.listToolsInServer(listToolsArgs);
                     break;
                 }
                 case GET_TOOL_TOOL: {
@@ -50,9 +40,9 @@ export class SystemToolHandler {
                     });
                     break;
                 }
-                case FIND_TOOLS_TOOL: {
-                    const findToolsArgs = toolArgs;
-                    result = await hubToolsService.findTools(findToolsArgs);
+                case UPDATE_SERVER_DESCRIPTION_TOOL: {
+                    const updateDescArgs = toolArgs;
+                    result = await hubToolsService.updateServerDescription(updateDescArgs);
                     break;
                 }
                 default:

package/dist/server/src/utils/composite-key.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Composite key utilities for server instance identification
+ *
+ * This module provides utilities for generating and parsing composite keys
+ * that uniquely identify a server instance across multiple instances
+ * of the same server name.
+ *
+ * Format: `${serverName}-${serverIndex}`
+ * Example: 'my-server-0', 'my-server-1', 'test-server-0'
+ */
+/**
+ * Generates a composite key from serverName and serverIndex
+ * @param serverName - The server name
+ * @param serverIndex - The instance index
+ * @returns Composite key string
+ * @example getCompositeKey('my-server', 0) => 'my-server-0'
+ */
+export declare function getCompositeKey(serverName: string, serverIndex: number): string;
+/**
+ * Parses a composite key back into serverName and serverIndex
+ * @param key - The composite key to parse
+ * @returns Object with serverName and serverIndex, or null if invalid
+ * @example parseCompositeKey('my-server-0') => { serverName: 'my-server', serverIndex: 0 }
+ */
+export declare function parseCompositeKey(key: string): {
+    serverName: string;
+    serverIndex: number;
+} | null;
+//# sourceMappingURL=composite-key.d.ts.map

package/dist/server/src/utils/composite-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite-key.d.ts","sourceRoot":"","sources":["../../../../src/utils/composite-key.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAE/E;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAYjG"}

package/dist/server/src/utils/composite-key.js

@@ -0,0 +1,39 @@
+/**
+ * Composite key utilities for server instance identification
+ *
+ * This module provides utilities for generating and parsing composite keys
+ * that uniquely identify a server instance across multiple instances
+ * of the same server name.
+ *
+ * Format: `${serverName}-${serverIndex}`
+ * Example: 'my-server-0', 'my-server-1', 'test-server-0'
+ */
+/**
+ * Generates a composite key from serverName and serverIndex
+ * @param serverName - The server name
+ * @param serverIndex - The instance index
+ * @returns Composite key string
+ * @example getCompositeKey('my-server', 0) => 'my-server-0'
+ */
+export function getCompositeKey(serverName, serverIndex) {
+    return `${serverName}-${serverIndex}`;
+}
+/**
+ * Parses a composite key back into serverName and serverIndex
+ * @param key - The composite key to parse
+ * @returns Object with serverName and serverIndex, or null if invalid
+ * @example parseCompositeKey('my-server-0') => { serverName: 'my-server', serverIndex: 0 }
+ */
+export function parseCompositeKey(key) {
+    const lastDashIndex = key.lastIndexOf('-');
+    if (lastDashIndex === -1) {
+        return null;
+    }
+    const serverName = key.slice(0, lastDashIndex);
+    const serverIndexPart = key.slice(lastDashIndex + 1);
+    const serverIndex = parseInt(serverIndexPart, 10);
+    if (isNaN(serverIndex)) {
+        return null;
+    }
+    return { serverName, serverIndex };
+}

package/dist/server/src/utils/error-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../../../../src/utils/error-handler.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,qBAAa,YAAY;IACvB;;OAEG;IACH,MAAM,CAAC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK;IAgBrE;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK;IA6BzF;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK;CAWlE"}
+{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../../../../src/utils/error-handler.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,qBAAa,YAAY;IACvB;;OAEG;IACH,MAAM,CAAC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK;IAgBrE;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK;IA6BzF;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK;CAWlE"}

package/dist/server/src/utils/error-handler.js

@@ -1,5 +1,6 @@
 import { McpError } from '@modelcontextprotocol/sdk/types.js';
-import { logger, LOG_MODULES } from './logger.js';
+import { logger } from './logger.js';
+import { LOG_MODULES } from './logger/log-modules.js';
 /**
  * Unified error handler
  */
@@ -45,7 +46,7 @@ export class ErrorHandler {
      * Handles general errors
      */
     static handleGeneralError(error, message) {
-        logger.error(message, error);
+        logger.error(message, error, LOG_MODULES.ERROR_HANDLER);
         if (error instanceof McpError) {
             throw error;
         }

package/dist/server/src/utils/index.d.ts

@@ -1,2 +1,4 @@
 export { logger, LOG_MODULES } from './logger.js';
+export * from './sort-utils.js';
+export * from './version.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/server/src/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAClD,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC"}

package/dist/server/src/utils/index.js

@@ -1 +1,3 @@
 export { logger, LOG_MODULES } from './logger.js';
+export * from './sort-utils.js';
+export * from './version.js';