@loop_ouroboros/mcp-hub-lite 1.3.1 → 1.3.3

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

@@ -6,10 +6,11 @@ import { generateGatewayToolsList } from './gateway/tool-list-generator.js';
 import { logger, LOG_MODULES } from '../utils/logger/index.js';
 import { stringifyForLogging } from '../utils/json-utils.js';
 import { normalizeToolName } from '../utils/name-converter.js';
+import { countMatchingTokens } from '../utils/search-matcher.js';
 import { McpError } from '@modelcontextprotocol/sdk/types.js';
 import { MCP_HUB_LITE_SERVER, LIST_SERVERS_TOOL, LIST_TOOLS_TOOL, GET_TOOL_TOOL, CALL_TOOL_TOOL, UPDATE_SERVER_DESCRIPTION_TOOL, LIST_TAGS_TOOL, SEARCH_TOOLS_TOOL, SYSTEM_TOOL_NAMES } from '../models/system-tools.constants.js';
 import { ToolArgsParser } from '../utils/tool-args-parser.js';
-import { hasValidId, selectBestInstance, getServerDescription, getSystemTools, generateDynamicResources, readResource as readResourceUtil } from './hub-tools/index.js';
+import { hasValidId, selectBestInstance, getServerDescription, getSystemTools, generateDynamicResources, readResource as readResourceUtil, serverMetadataCache } from './hub-tools/index.js';
 import { InstanceSelector } from './hub-tools/instance-selector.js';
 import { InstanceSelectionStrategy } from '../models/server.model.js';
 /**
@@ -63,7 +64,7 @@ import { InstanceSelectionStrategy } from '../models/server.model.js';
 export class HubToolsService {
     // Cache removed - listResources() now calls generateDynamicResources() directly
     constructor() {
-        // No cache-related initialization needed
+        serverMetadataCache.initialize();
     }
     /**
      * Retrieves the complete list of system tools provided by this service.
@@ -371,86 +372,54 @@ export class HubToolsService {
                 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);
-            // Find all servers that have this tool
-            const matchingServers = [];
-            const servers = hubManager.getAllServers();
-            for (const server of servers) {
-                if (!hasValidId(server)) {
-                    continue;
-                }
-                const serverInfo = selectBestInstance(server.name, requestOptions, true);
-                if (serverInfo && serverInfo.instance.id) {
-                    const instanceIndex = serverInfo.instance.index;
-                    const tools = mcpConnectionManager.getTools(server.name, instanceIndex);
-                    if (tools.some((tool) => normalizeToolName(tool.name) === normalizeToolName(toolName))) {
-                        matchingServers.push(server.name);
-                    }
-                }
-            }
-            if (matchingServers.length === 0) {
-                logger.error(`Tool '${toolName}' not found in any connected server`, LOG_MODULES.HUB_TOOLS);
-                throw new Error(`Tool '${toolName}' not found`);
-            }
-            if (matchingServers.length > 1) {
-                logger.warn(`Tool '${toolName}' found in multiple servers: ${matchingServers.join(', ')}. Using first match.`, LOG_MODULES.HUB_TOOLS);
-            }
-            // Use the first matching server
-            serverName = matchingServers[0];
+            // Not a system tool — reject with actionable guidance
+            // The aggregated gateway tools (wrapped by tool-list-generator) already hardcode
+            // the correct serverName, so this path should only be hit when LLM manually fills
+            // "mcp-hub-lite" incorrectly. Guide them to use search_tools instead.
+            throw new McpError(-32602, `Cannot call external tool '${toolName}' with serverName "mcp-hub-lite". ` +
+                `Use 'search_tools' to find which server provides this tool, ` +
+                `then call it with the correct serverName.`);
         }
         logger.debug(`Tool call received: serverName=${serverName}, toolName=${toolName}, args=${stringifyForLogging(toolArgs)}`, LOG_MODULES.HUB_TOOLS);
-        // 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);
-        let actualToolName;
-        if (validationServerInfo && validationServerInfo.instance.id) {
-            const instanceIndex = validationServerInfo.instance.index;
-            const tools = mcpConnectionManager.getTools(serverName, instanceIndex);
-            const matchedTool = tools.find((tool) => normalizeToolName(tool.name) === normalizeToolName(toolName));
-            if (!matchedTool) {
-                throw new Error(`Tool '${toolName}' not found in server '${serverName}'. ` +
-                    `Use list_tools(serverName: "${serverName}") to see available tools.`);
-            }
-            actualToolName = matchedTool.name;
+        // Validate tool exists using server-name-level aggregation (no instance selection needed)
+        const aggregatedTools = mcpConnectionManager.getToolsByServerName(serverName);
+        const matchedTool = aggregatedTools.find((tool) => normalizeToolName(tool.name) === normalizeToolName(toolName));
+        if (!matchedTool) {
+            throw new Error(`Tool '${toolName}' not found in server '${serverName}'. ` +
+                `Use list_tools(serverName: "${serverName}") to see available tools.`);
         }
-        const serverInfo = selectBestInstance(serverName, requestOptions, true);
+        let actualToolName = matchedTool.name;
+        const serverInfo = selectBestInstance(serverName, requestOptions);
         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
-            let fallbackServerInfo = selectBestInstance(serverName, undefined, false);
-            // If selectBestInstance returns undefined (e.g., TAG_MATCH_UNIQUE strategy without tags),
-            // fall back to directly selecting an enabled instance with RANDOM strategy
-            if (!fallbackServerInfo) {
-                logger.debug(`selectBestInstance returned undefined for ${serverName}, trying direct instance selection with RANDOM strategy`, LOG_MODULES.HUB_TOOLS);
-                const serverConfig = hubManager.getServerByName(serverName);
-                if (serverConfig && serverConfig.instances.length > 0) {
-                    // Filter: use runtime connected status, NOT config enabled flag
-                    // enabled=false means "do not auto-start" but user can manually start it
-                    const connectedInstances = serverConfig.instances.filter((instance) => {
-                        if (instance.index === undefined)
-                            return false;
-                        const status = mcpConnectionManager.getStatus(serverName, instance.index);
-                        return status?.connected;
-                    });
-                    if (connectedInstances.length > 0) {
-                        // Use RANDOM strategy regardless of server's configured strategy
-                        const selectedInstance = InstanceSelector.selectInstance(serverName, {
-                            ...serverConfig,
-                            template: {
-                                ...serverConfig.template,
-                                instanceSelectionStrategy: InstanceSelectionStrategy.RANDOM
-                            }
-                        }, undefined);
-                        if (selectedInstance) {
-                            fallbackServerInfo = {
-                                name: serverName,
-                                config: serverConfig,
-                                instance: selectedInstance
-                            };
+            // Fallback: force RANDOM strategy on any connected instance
+            // (selectBestInstance may fail for TAG_MATCH_UNIQUE without tags)
+            let fallbackServerInfo;
+            const serverConfig = hubManager.getServerByName(serverName);
+            if (serverConfig && serverConfig.instances.length > 0) {
+                // Filter: use runtime connected status, NOT config enabled flag
+                const connectedInstances = serverConfig.instances.filter((instance) => {
+                    if (instance.index === undefined)
+                        return false;
+                    const status = mcpConnectionManager.getStatus(serverName, instance.index);
+                    return status?.connected;
+                });
+                if (connectedInstances.length > 0) {
+                    const selectedInstance = InstanceSelector.selectInstance(serverName, {
+                        ...serverConfig,
+                        template: {
+                            ...serverConfig.template,
+                            instanceSelectionStrategy: InstanceSelectionStrategy.RANDOM
                         }
+                    }, undefined);
+                    if (selectedInstance) {
+                        fallbackServerInfo = {
+                            name: serverName,
+                            config: serverConfig,
+                            instance: selectedInstance
+                        };
                     }
                 }
             }
@@ -601,11 +570,11 @@ export class HubToolsService {
      * @returns {Promise<Record<string, { description: string; tools: ToolSummary[] }>>}
      * Object mapping server names to their descriptions and matching tools
      */
-    async searchTools(query) {
+    async searchTools(query, limit = 5) {
         if (!query || typeof query !== 'string') {
             throw new Error('query is required and must be a non-empty string');
         }
-        const normalizedQuery = query.toLowerCase();
+        const effectiveLimit = Math.min(Math.max(1, limit), 10);
         const servers = hubManager.getAllServers();
         const result = {};
         for (const server of servers) {
@@ -621,21 +590,26 @@ export class HubToolsService {
             if (tools.length === 0) {
                 continue;
             }
-            const matchingTools = tools
-                .filter((tool) => {
-                const nameMatch = tool.name.toLowerCase().includes(normalizedQuery);
-                const descMatch = tool.description?.toLowerCase().includes(normalizedQuery);
-                return nameMatch || descMatch;
+            const scored = tools
+                .map((tool) => {
+                const matchCount = countMatchingTokens(query, [tool.name, tool.description || '']);
+                return {
+                    tool,
+                    matchCount,
+                    summary: {
+                        name: tool.name,
+                        description: tool.description,
+                        serverName: server.name
+                    }
+                };
             })
-                .map((tool) => ({
-                name: tool.name,
-                description: tool.description,
-                serverName: server.name
-            }));
-            if (matchingTools.length > 0) {
+                .filter((item) => item.matchCount > 0)
+                .sort((a, b) => b.matchCount - a.matchCount)
+                .slice(0, effectiveLimit);
+            if (scored.length > 0) {
                 result[server.name] = {
                     description,
-                    tools: matchingTools
+                    tools: scored.map((item) => item.summary)
                 };
             }
         }

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

@@ -63,7 +63,7 @@ export class SystemToolHandler {
                     if (!searchArgs.query) {
                         throw new McpError(-32802, 'query is required for search_tools');
                     }
-                    result = await hubToolsService.searchTools(searchArgs.query);
+                    result = await hubToolsService.searchTools(searchArgs.query, searchArgs.limit);
                     break;
                 }
                 default:

package/dist/server/src/utils/search-matcher.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Counts how many tokens from a whitespace-delimited query match against any of the given fields.
+ * Returns a large value for empty or whitespace-only queries so they match all results.
+ */
+export declare function countMatchingTokens(query: string, fields: string[]): number;
+//# sourceMappingURL=search-matcher.d.ts.map

package/dist/server/src/utils/search-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-matcher.d.ts","sourceRoot":"","sources":["../../../../src/utils/search-matcher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAwB3E"}

package/dist/server/src/utils/search-matcher.js

@@ -0,0 +1,24 @@
+/**
+ * Counts how many tokens from a whitespace-delimited query match against any of the given fields.
+ * Returns a large value for empty or whitespace-only queries so they match all results.
+ */
+export function countMatchingTokens(query, fields) {
+    if (!query || typeof query !== 'string') {
+        return 0;
+    }
+    const tokens = query
+        .toLowerCase()
+        .split(/[,\s;|]+/)
+        .filter(Boolean);
+    if (tokens.length === 0) {
+        return Number.MAX_SAFE_INTEGER;
+    }
+    const lowerFields = fields.map((f) => (f || '').toLowerCase());
+    let matchCount = 0;
+    for (const token of tokens) {
+        if (lowerFields.some((field) => field.includes(token))) {
+            matchCount++;
+        }
+    }
+    return matchCount;
+}