@loop_ouroboros/mcp-hub-lite 1.0.1 → 1.1.0

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/search/search-cache.d.ts

@@ -109,24 +109,5 @@ export declare class SearchCacheService {
      * ```
      */
     invalidate(): void;
-    /**
-     * Updates a specific tool in the cache (deprecated method).
-     *
-     * This method is currently deprecated because the serverId field has been
-     * removed from the Tool interface. It logs a warning message and performs
-     * no actual operations. The method is kept for backward compatibility but
-     * should not be used in new code.
-     *
-     * @deprecated This method is deprecated and does nothing. ServerId field
-     *             has been removed from the Tool interface, making this method
-     *             obsolete.
-     *
-     * @example
-     * ```typescript
-     * // This will log a warning but do nothing
-     * cache.updateTool();
-     * ```
-     */
-    updateTool(): void;
 }
 //# sourceMappingURL=search-cache.d.ts.map

package/dist/server/src/services/search/search-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-cache.d.ts","sourceRoot":"","sources":["../../../../../src/services/search/search-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AAGzD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAa;IAEvC;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,IAAI,OAAO;IAMlB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,GAAG,IAAI,IAAI,EAAE,GAAG,IAAI;IASpB;;;;;;;;;;;;;;;OAeG;IACH,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAKxB;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,IAAI,IAAI;IAKlB;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,IAAI,IAAI;CAQnB"}
+{"version":3,"file":"search-cache.d.ts","sourceRoot":"","sources":["../../../../../src/services/search/search-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAa;IAEvC;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,IAAI,OAAO;IAMlB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,GAAG,IAAI,IAAI,EAAE,GAAG,IAAI;IASpB;;;;;;;;;;;;;;;OAeG;IACH,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAKxB;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,IAAI,IAAI;CAInB"}

package/dist/server/src/services/search/search-cache.js

@@ -1,4 +1,3 @@
-import { logger, LOG_MODULES } from '../../utils/logger.js';
 /**
  * Search cache service that provides time-based caching for search results.
  *
@@ -125,27 +124,4 @@ export class SearchCacheService {
         this.cache = null;
         this.lastUpdate = 0;
     }
-    /**
-     * Updates a specific tool in the cache (deprecated method).
-     *
-     * This method is currently deprecated because the serverId field has been
-     * removed from the Tool interface. It logs a warning message and performs
-     * no actual operations. The method is kept for backward compatibility but
-     * should not be used in new code.
-     *
-     * @deprecated This method is deprecated and does nothing. ServerId field
-     *             has been removed from the Tool interface, making this method
-     *             obsolete.
-     *
-     * @example
-     * ```typescript
-     * // This will log a warning but do nothing
-     * cache.updateTool();
-     * ```
-     */
-    updateTool() {
-        // Since serverId field has been removed from Tool interface, this method needs refactoring
-        // Currently kept but not performing any operations, or modify according to actual requirements
-        logger.warn('updateTool method is deprecated because serverId field is removed from Tool', LOG_MODULES.SEARCH);
-    }
 }

package/dist/server/src/services/search/search-core.service.d.ts

@@ -60,16 +60,16 @@ export declare class SearchCoreService {
      *
      * This method first checks if tools are available in the cache. If cached data exists,
      * it returns the cached tools immediately. Otherwise, it fetches tools from all connected
-     * MCP servers, applies server-level filtering based on allowedTools configuration,
+     * MCP servers, applies server-level filtering based on aggregatedTools configuration,
      * caches the result, and returns the filtered tools.
      *
      * @returns A promise that resolves to an array of Tool objects from all connected servers.
      *
      * @remarks
-     * - Tools are filtered based on each server's allowedTools configuration
-     * - If allowedTools is null or undefined, all tools from that server are included
-     * - If allowedTools is an empty array, no tools from that server are included
-     * - Tools are filtered using strict name matching against the allowedTools list
+     * - Tools are filtered based on each server's aggregatedTools configuration
+     * - If aggregatedTools is null or undefined, all tools from that server are included
+     * - If aggregatedTools is an empty array, no tools from that server are included
+     * - Tools are filtered using strict name matching against the aggregatedTools list
      */
     private getToolsWithCache;
     /**

package/dist/server/src/services/search/search-core.service.js

@@ -101,16 +101,16 @@ export class SearchCoreService {
      *
      * This method first checks if tools are available in the cache. If cached data exists,
      * it returns the cached tools immediately. Otherwise, it fetches tools from all connected
-     * MCP servers, applies server-level filtering based on allowedTools configuration,
+     * MCP servers, applies server-level filtering based on aggregatedTools configuration,
      * caches the result, and returns the filtered tools.
      *
      * @returns A promise that resolves to an array of Tool objects from all connected servers.
      *
      * @remarks
-     * - Tools are filtered based on each server's allowedTools configuration
-     * - If allowedTools is null or undefined, all tools from that server are included
-     * - If allowedTools is an empty array, no tools from that server are included
-     * - Tools are filtered using strict name matching against the allowedTools list
+     * - Tools are filtered based on each server's aggregatedTools configuration
+     * - If aggregatedTools is null or undefined, all tools from that server are included
+     * - If aggregatedTools is an empty array, no tools from that server are included
+     * - Tools are filtered using strict name matching against the aggregatedTools list
      */
     async getToolsWithCache() {
         const cached = this.cacheService.get();
@@ -119,17 +119,17 @@ export class SearchCoreService {
         }
         // Use new server name-level cache to get all tools
         const tools = mcpConnectionManager.getAllToolsByServerName();
-        // Get configuration based on server name and apply allowedTools filtering
+        // Get configuration based on server name and apply aggregatedTools filtering
         const filteredTools = tools.filter((tool) => {
             const serverConfig = hubManager.getServerByName(tool.serverName);
             if (!serverConfig)
                 return true;
-            const allowed = serverConfig.allowedTools;
-            if (allowed == null)
-                return true; // No allowedTools configured, show all tools
-            if (allowed.length === 0)
+            const aggregated = serverConfig.template.aggregatedTools;
+            if (aggregated == null)
+                return false; // No aggregatedTools configured, don't show any tools
+            if (aggregated.length === 0)
                 return false; // Empty array, don't show any tools
-            return allowed.includes(tool.name); // Strict filtering
+            return aggregated.includes(tool.name); // Strict filtering
         });
         this.cacheService.set(filteredTools);
         return filteredTools;