@loop_ouroboros/mcp-hub-lite 1.2.8 → 1.3.0

package/dist/server/src/services/event-bus.service.d.ts

@@ -22,7 +22,7 @@
  * automatically manages memory by cleaning up empty event type entries when all listeners
  * are unsubscribed.
  */
-import type { EventData } from '../models/event.model.js';
+type EventData = unknown;
 /**
  * Interface representing a published event with its type and associated data.
  *
@@ -154,6 +154,7 @@ export declare const EventTypes: {
     readonly SERVER_INSTANCE_UPDATED: "server-instance-updated";
     readonly SERVER_INSTANCE_DELETED: "server-instance-deleted";
     readonly TOOLS_UPDATED: "tools";
+    readonly AGGREGATED_TOOLS_CHANGED: "aggregated-tools-changed";
     readonly TOOL_CALL_STARTED: "tool-call-started";
     readonly TOOL_CALL_COMPLETED: "tool-call-completed";
     readonly TOOL_CALL_ERROR: "tool-call-error";
@@ -162,4 +163,5 @@ export declare const EventTypes: {
     readonly CONFIGURATION_UPDATED: "configuration-updated";
 };
 export declare const eventBus: EventBusService;
+export {};
 //# sourceMappingURL=event-bus.service.d.ts.map

package/dist/server/src/services/event-bus.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-bus.service.d.ts","sourceRoot":"","sources":["../../../../src/services/event-bus.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,CAAC;CACjB;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,SAAS,CAAqD;IAEtE;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IAajD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,GAAG,MAAM,IAAI;IAU7E;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,WAAW;IAWnB;;;;;;;;;;;;;;OAcG;IACH,cAAc,IAAI,IAAI;IAItB;;;;;;;;;;;;;;OAcG;IACH,aAAa,IAAI,MAAM,EAAE;IAIzB;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;CAI5C;AAGD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;CA4Bb,CAAC;AAGX,eAAO,MAAM,QAAQ,iBAAwB,CAAC"}
+{"version":3,"file":"event-bus.service.d.ts","sourceRoot":"","sources":["../../../../src/services/event-bus.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,KAAK,SAAS,GAAG,OAAO,CAAC;AAEzB;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,CAAC;CACjB;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,SAAS,CAAqD;IAEtE;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IAajD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,GAAG,MAAM,IAAI;IAU7E;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,WAAW;IAWnB;;;;;;;;;;;;;;OAcG;IACH,cAAc,IAAI,IAAI;IAItB;;;;;;;;;;;;;;OAcG;IACH,aAAa,IAAI,MAAM,EAAE;IAIzB;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;CAI5C;AAGD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;CA6Bb,CAAC;AAGX,eAAO,MAAM,QAAQ,iBAAwB,CAAC"}

package/dist/server/src/services/event-bus.service.js

@@ -181,6 +181,7 @@ export const EventTypes = {
     SERVER_INSTANCE_DELETED: 'server-instance-deleted',
     // Tool related events
     TOOLS_UPDATED: 'tools',
+    AGGREGATED_TOOLS_CHANGED: 'aggregated-tools-changed',
     TOOL_CALL_STARTED: 'tool-call-started',
     TOOL_CALL_COMPLETED: 'tool-call-completed',
     TOOL_CALL_ERROR: 'tool-call-error',

package/dist/server/src/services/gateway/gateway.service.d.ts

@@ -23,6 +23,7 @@ export declare class GatewayService {
     private transport;
     private readonly appVersion;
     constructor();
+    private initToolCache;
     private createServerWithHandlers;
     private registerHandlers;
     /**

package/dist/server/src/services/gateway/gateway.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gateway.service.d.ts","sourceRoot":"","sources":["../../../../../src/services/gateway/gateway.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAepE,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE5D,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,SAAS,CAAqC;IACtD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;;IAOpC,OAAO,CAAC,wBAAwB;IA2BhC,OAAO,CAAC,gBAAgB;IAuDxB;;;;;OAKG;IACI,wBAAwB,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,KAAK,CAAC,WAAW,CAAC;IAIvF;;;;;OAKG;IACI,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM;IAI5C;;;;;OAKG;IACI,kBAAkB,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM;IAIpD;;;;OAIG;IACI,sBAAsB,IAAI,SAAS;IAI1C;;;;OAIG;IACU,KAAK;CAKnB;AAED,eAAO,MAAM,OAAO,gBAAuB,CAAC"}
+{"version":3,"file":"gateway.service.d.ts","sourceRoot":"","sources":["../../../../../src/services/gateway/gateway.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAsBpE,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE5D,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,SAAS,CAAqC;IACtD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;;IAQpC,OAAO,CAAC,aAAa;IA0BrB,OAAO,CAAC,wBAAwB;IA2BhC,OAAO,CAAC,gBAAgB;IAkDxB;;;;;OAKG;IACI,wBAAwB,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,KAAK,CAAC,WAAW,CAAC;IAIvF;;;;;OAKG;IACI,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM;IAI5C;;;;;OAKG;IACI,kBAAkB,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM;IAIpD;;;;OAIG;IACI,sBAAsB,IAAI,SAAS;IAI1C;;;;OAIG;IACU,KAAK;CAKnB;AAED,eAAO,MAAM,OAAO,gBAAuB,CAAC"}

package/dist/server/src/services/gateway/gateway.service.js

@@ -24,7 +24,9 @@ import { getGatewayDebugSetting } from '../../utils/json-utils.js';
 import { MCP_HUB_LITE_SERVER } from '../../models/system-tools.constants.js';
 import { registerInitializeHandlers, registerResourcesHandlers, registerSystemToolsHandlers, registerCallToolHandler } from './request-handlers/index.js';
 import { getAppVersion } from '../../utils/version.js';
-import { generateGatewayToolsList } from './tool-list-generator.js';
+import { eventBus, EventTypes } from '../event-bus.service.js';
+import { hubManager } from '../hub-manager.service.js';
+import { generateGatewayToolsList, rebuildFromScratch, addToCache, removeFromCache } from './tool-list-generator.js';
 import { formatToolArgs, formatToolResponse } from './log-formatter.js';
 export class GatewayService {
     server;
@@ -33,6 +35,31 @@ export class GatewayService {
     constructor() {
         this.appVersion = getAppVersion();
         this.server = this.createServerWithHandlers();
+        this.initToolCache();
+    }
+    initToolCache() {
+        rebuildFromScratch();
+        eventBus.subscribe(EventTypes.TOOLS_UPDATED, (rawData) => {
+            const data = rawData;
+            const serverConfig = hubManager.getServerByName(data.serverName);
+            if (serverConfig?.template?.aggregatedTools?.length) {
+                rebuildFromScratch();
+            }
+        });
+        eventBus.subscribe(EventTypes.SERVER_DISCONNECTED, (rawData) => {
+            const data = rawData;
+            const serverConfig = hubManager.getServerByName(data.serverName);
+            if (!serverConfig || serverConfig.template?.aggregatedTools?.length) {
+                rebuildFromScratch();
+            }
+        });
+        eventBus.subscribe(EventTypes.AGGREGATED_TOOLS_CHANGED, (rawData) => {
+            const data = rawData;
+            if (data.added.length > 0)
+                addToCache(data.name, data.added);
+            if (data.removed.length > 0)
+                removeFromCache(data.name, data.removed);
+        });
     }
     createServerWithHandlers() {
         if (getGatewayDebugSetting()) {
@@ -60,11 +87,6 @@ export class GatewayService {
         if (getGatewayDebugSetting()) {
             logger.debug('Registering handlers on MCP server', LOG_MODULES.GATEWAY_SERVICE);
         }
-        // Local toolMap for this connection
-        const toolMap = new Map();
-        if (getGatewayDebugSetting()) {
-            logger.debug('Created local toolMap for connection', LOG_MODULES.GATEWAY_SERVICE);
-        }
         try {
             registerInitializeHandlers(server);
             if (getGatewayDebugSetting()) {
@@ -96,7 +118,7 @@ export class GatewayService {
             throw error;
         }
         try {
-            registerCallToolHandler(server, toolMap);
+            registerCallToolHandler(server);
             if (getGatewayDebugSetting()) {
                 logger.debug('Call tool handler registered successfully', LOG_MODULES.GATEWAY_SERVICE);
             }

package/dist/server/src/services/gateway/request-handlers/call-tool-handler.d.ts

@@ -2,12 +2,11 @@
  * Call tool request handler for Gateway service.
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { ToolMapEntry } from '../types.js';
 /**
  * Register call tool handler on the MCP server.
  *
  * @param server - MCP server instance to register handlers on
  * @param toolMap - Tool map for routing tool calls
  */
-export declare function registerCallToolHandler(server: McpServer, toolMap: Map<string, ToolMapEntry>): void;
+export declare function registerCallToolHandler(server: McpServer): void;
 //# sourceMappingURL=call-tool-handler.d.ts.map

package/dist/server/src/services/gateway/request-handlers/call-tool-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"call-tool-handler.d.ts","sourceRoot":"","sources":["../../../../../../src/services/gateway/request-handlers/call-tool-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAezE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAgFhD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GACjC,IAAI,CA8FN"}
+{"version":3,"file":"call-tool-handler.d.ts","sourceRoot":"","sources":["../../../../../../src/services/gateway/request-handlers/call-tool-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA4FzE;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAwG/D"}

package/dist/server/src/services/gateway/request-handlers/call-tool-handler.js

@@ -3,14 +3,13 @@
  */
 import { CallToolRequestSchema, ListToolsRequestSchema, McpError } from '@modelcontextprotocol/sdk/types.js';
 import { logger, LOG_MODULES } from '../../../utils/index.js';
-import { stringifyForLogging } from '../../../utils/json-utils.js';
-import { mcpConnectionManager } from '../../mcp-connection-manager.js';
+import { hubToolsService } from '../../hub-tools.service.js';
 import { SystemToolHandler } from '../../system-tool-handler.js';
 import { ErrorHandler } from '../../../utils/error-handler.js';
 import { ToolArgsParser } from '../../../utils/tool-args-parser.js';
 import { SYSTEM_TOOL_NAMES, MCP_HUB_LITE_SERVER } from '../../../models/system-tools.constants.js';
 import { formatToolArgs, formatToolResponse } from '../log-formatter.js';
-import { generateGatewayToolsList } from '../tool-list-generator.js';
+import { getOrBuildGatewayToolMap, getOrBuildGatewayToolsList } from '../tool-list-generator.js';
 /**
  * Type guard to check if a result is a valid CallToolResult.
  *
@@ -37,7 +36,7 @@ async function executeSystemToolCall(toolName, toolArgs) {
             content: [
                 {
                     type: 'text',
-                    text: stringifyForLogging(result)
+                    text: JSON.stringify(result, null, 2)
                 }
             ]
         };
@@ -75,10 +74,10 @@ function getSystemToolName(toolName) {
  * @param server - MCP server instance to register handlers on
  * @param toolMap - Tool map for routing tool calls
  */
-export function registerCallToolHandler(server, toolMap) {
+export function registerCallToolHandler(server) {
     // Original list tools handler (for compatibility)
     server.server.setRequestHandler(ListToolsRequestSchema, async () => {
-        const gatewayTools = generateGatewayToolsList(toolMap);
+        const gatewayTools = getOrBuildGatewayToolsList();
         return {
             tools: gatewayTools
         };
@@ -88,26 +87,38 @@ export function registerCallToolHandler(server, toolMap) {
         const toolName = request.params.name;
         const toolArgs = request.params.arguments || {};
         const systemToolName = getSystemToolName(toolName);
+        const gwToolMap = getOrBuildGatewayToolMap();
         // Log incoming tool request with full context
         logger.info(`Tool call REQUEST received: toolName=${toolName}, args=${formatToolArgs(toolArgs)}`, LOG_MODULES.GATEWAY);
-        logger.debug(`Tool context: toolMap size=${toolMap.size}, available tools=${Array.from(toolMap.keys()).slice(0, 10).join(', ')}${toolMap.size > 10 ? '...' : ''}`, LOG_MODULES.GATEWAY);
+        logger.debug(`Tool context: toolMap size=${gwToolMap.size}, available tools=${Array.from(gwToolMap.keys()).slice(0, 10).join(', ')}${gwToolMap.size > 10 ? '...' : ''}`, LOG_MODULES.GATEWAY);
         // Handle system tools
         if (systemToolName) {
             logger.debug(`System tool called: ${systemToolName}, args=${formatToolArgs(toolArgs)}`, LOG_MODULES.GATEWAY);
             return await executeSystemToolCall(systemToolName, toolArgs);
         }
-        const target = toolMap.get(toolName);
+        const target = gwToolMap.get(toolName);
         logger.debug(`Tool lookup SUCCESS: toolName=${toolName} -> serverName=${target?.serverName}, serverIndex=${target?.serverIndex}, realToolName=${target?.realToolName}`, LOG_MODULES.GATEWAY);
         if (!target) {
-            logger.error(`Tool NOT FOUND: toolName=${toolName}, available tools=${Array.from(toolMap.keys()).join(', ')}`, LOG_MODULES.GATEWAY);
+            logger.error(`Tool NOT FOUND: toolName=${toolName}, available tools=${Array.from(gwToolMap.keys()).join(', ')}`, LOG_MODULES.GATEWAY);
             throw new McpError(-32801, `Tool ${toolName} not found`);
         }
+        // Extract wrapped arguments (LLM provides serverName/toolName per schema guidance)
+        const wrappedArgs = toolArgs;
+        const callServerName = wrappedArgs.serverName || target.serverName;
+        const callToolName = wrappedArgs.toolName || target.realToolName;
+        const callArgs = wrappedArgs.toolArgs || {};
+        const callOptions = wrappedArgs.requestOptions || {};
         const startTime = Date.now();
         try {
-            logger.debug(`Tool call EXECUTING: serverName=${target.serverName}, serverIndex=${target.serverIndex}, realToolName=${target.realToolName}, args=${formatToolArgs(toolArgs)}`, LOG_MODULES.GATEWAY);
-            const result = await mcpConnectionManager.callTool(target.serverName, target.serverIndex, target.realToolName, toolArgs);
+            logger.debug(`Tool call EXECUTING: serverName=${callServerName}, toolName=${callToolName}, args=${formatToolArgs(callArgs)}`, LOG_MODULES.GATEWAY);
+            const result = await hubToolsService.callTool({
+                serverName: callServerName,
+                toolName: callToolName,
+                toolArgs: callArgs,
+                requestOptions: callOptions
+            });
             const duration = Date.now() - startTime;
-            logger.info(`Tool call SUCCESS: serverName=${target.serverName}, serverIndex=${target.serverIndex}, realToolName=${target.realToolName}, duration=${duration}ms, response=${formatToolResponse(result)}`, LOG_MODULES.GATEWAY);
+            logger.info(`Tool call SUCCESS: serverName=${callServerName}, toolName=${callToolName}, duration=${duration}ms, response=${formatToolResponse(result)}`, LOG_MODULES.GATEWAY);
             // Wrap the result in a valid CallToolResult structure
             if (typeof result === 'object' && result !== null) {
                 return {
@@ -127,7 +138,7 @@ export function registerCallToolHandler(server, toolMap) {
             }
         }
         catch (error) {
-            ErrorHandler.handleToolCallError(`${target.serverName}-${target.serverIndex}`, target.realToolName, error);
+            ErrorHandler.handleToolCallError(callServerName, callToolName, error);
         }
     });
 }

package/dist/server/src/services/gateway/request-handlers/resources-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resources-handler.d.ts","sourceRoot":"","sources":["../../../../../../src/services/gateway/request-handlers/resources-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAMzE;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAwCjE"}
+{"version":3,"file":"resources-handler.d.ts","sourceRoot":"","sources":["../../../../../../src/services/gateway/request-handlers/resources-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAKzE;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAiDjE"}

package/dist/server/src/services/gateway/request-handlers/resources-handler.js

@@ -4,7 +4,6 @@
 import { ListResourcesRequestSchema, ReadResourceRequestSchema, McpError } from '@modelcontextprotocol/sdk/types.js';
 import { logger } from '../../../utils/index.js';
 import { LOG_MODULES } from '../../../utils/logger/log-modules.js';
-import { stringifyForLogging } from '../../../utils/json-utils.js';
 import { hubToolsService } from '../../hub-tools.service.js';
 /**
  * Register resources-related handlers on the MCP server.
@@ -32,13 +31,18 @@ export function registerResourcesHandlers(server) {
         try {
             const { uri } = request.params;
             const content = await hubToolsService.readResource(uri);
+            // Preserve original mimeType if content is already in MCP ReadResourceResult format
+            const mcpResult = content && typeof content === 'object' && 'contents' in content
+                ? content
+                : null;
+            const mimeType = mcpResult?.contents?.[0]?.mimeType || 'application/json';
             // Convert to official MCP format: contents array with required uri field
             return {
                 contents: [
                     {
                         uri,
-                        mimeType: 'application/json',
-                        text: typeof content === 'string' ? content : stringifyForLogging(content)
+                        mimeType,
+                        text: typeof content === 'string' ? content : JSON.stringify(content, null, 2)
                     }
                 ]
             };

package/dist/server/src/services/gateway/request-handlers/system-tools-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system-tools-handler.d.ts","sourceRoot":"","sources":["../../../../../../src/services/gateway/request-handlers/system-tools-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAazE;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAmNnE"}
+{"version":3,"file":"system-tools-handler.d.ts","sourceRoot":"","sources":["../../../../../../src/services/gateway/request-handlers/system-tools-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAczE;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA6OnE"}

package/dist/server/src/services/gateway/request-handlers/system-tools-handler.js

@@ -6,7 +6,7 @@ import { McpError } from '@modelcontextprotocol/sdk/types.js';
 import { logger } from '../../../utils/index.js';
 import { LOG_MODULES } from '../../../utils/logger/log-modules.js';
 import { hubToolsService } from '../../hub-tools.service.js';
-import { LIST_SERVERS_TOOL, LIST_TOOLS_TOOL, GET_TOOL_TOOL, CALL_TOOL_TOOL, UPDATE_SERVER_DESCRIPTION_TOOL, LIST_TAGS_TOOL } from '../../../models/system-tools.constants.js';
+import { LIST_SERVERS_TOOL, LIST_TOOLS_TOOL, GET_TOOL_TOOL, CALL_TOOL_TOOL, UPDATE_SERVER_DESCRIPTION_TOOL, LIST_TAGS_TOOL, SEARCH_TOOLS_TOOL } from '../../../models/system-tools.constants.js';
 /**
  * Register system tools handlers on the MCP server.
  *
@@ -219,4 +219,31 @@ export function registerSystemToolsHandlers(server) {
             }
         }
     });
+    // Search tools across all servers
+    const SearchToolsRequestSchema = z.object({
+        method: z.literal(SEARCH_TOOLS_TOOL),
+        params: z.object({
+            query: z.string()
+        }),
+        id: z.union([z.string(), z.number()]),
+        jsonrpc: z.literal('2.0')
+    });
+    server.server.setRequestHandler(SearchToolsRequestSchema, async (request) => {
+        try {
+            const result = await hubToolsService.searchTools(request.params.query);
+            return result;
+        }
+        catch (error) {
+            logger.error(`Search tools error:`, error, LOG_MODULES.SYSTEM_TOOLS_HANDLER);
+            if (error instanceof McpError) {
+                throw error;
+            }
+            else if (error instanceof Error) {
+                throw new McpError(-32802, error.message);
+            }
+            else {
+                throw new McpError(-32802, String(error));
+            }
+        }
+    });
 }

package/dist/server/src/services/gateway/tool-list-generator.d.ts

@@ -1,23 +1,18 @@
 /**
- * Gateway tool list generator with collision resolution.
+ * Gateway tool list generator with collision resolution and global caching.
  */
 import type { ToolMapEntry, GatewayTool } from './types.js';
-/**
- * Generates a unified list of gateway tools with proper naming and collision resolution.
- *
- * This method creates a comprehensive tool list that includes both system tools and
- * aggregated tools from all connected MCP servers. It implements sophisticated
- * naming collision resolution by:
- * - Adding server hash suffixes to non-unique tool names
- * - Handling conflicts with system tool names
- * - Ensuring names don't exceed 60 characters
- * - Providing final uniqueness guarantees through counter suffixes
- *
- * The method also populates the provided toolMap with mappings from gateway tool names
- * to actual server IDs and real tool names for efficient routing during tool execution.
- *
- * @param {Map<string, ToolMapEntry>} toolMap - Map to populate with gateway tool name to actual tool mappings
- * @returns {Array<GatewayTool>} Array of gateway tools with resolved names and descriptions
- */
-export declare function generateGatewayToolsList(toolMap: Map<string, ToolMapEntry>): Array<GatewayTool>;
+export declare function generateGatewayToolsList(toolMap: Map<string, ToolMapEntry>): GatewayTool[];
+/** Lazy get — first-request fallback when cache hasn't been built yet */
+export declare function getOrBuildGatewayToolMap(): Map<string, ToolMapEntry>;
+/** Lazy get — first-request fallback when cache hasn't been built yet */
+export declare function getOrBuildGatewayToolsList(): GatewayTool[];
+/** Lazy get — returns only aggregated external tools (excludes system tools) */
+export declare function getExternalGatewayTools(): GatewayTool[];
+/** Full rebuild from global state — used by TOOLS_UPDATED / SERVER_DISCONNECTED */
+export declare function rebuildFromScratch(): void;
+/** Incremental add — update raw data layer, re-resolve names only */
+export declare function addToCache(serverName: string, toolNames: string[]): void;
+/** Incremental remove — update raw data layer, re-resolve names only */
+export declare function removeFromCache(serverName: string, toolNames: string[]): void;
 //# sourceMappingURL=tool-list-generator.d.ts.map

package/dist/server/src/services/gateway/tool-list-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-list-generator.d.ts","sourceRoot":"","sources":["../../../../../src/services/gateway/tool-list-generator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,KAAK,CAAC,WAAW,CAAC,CAkI/F"}
+{"version":3,"file":"tool-list-generator.d.ts","sourceRoot":"","sources":["../../../../../src/services/gateway/tool-list-generator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAwM5D,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,WAAW,EAAE,CAG1F;AAID,yEAAyE;AACzE,wBAAgB,wBAAwB,IAAI,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAKpE;AAED,yEAAyE;AACzE,wBAAgB,0BAA0B,IAAI,WAAW,EAAE,CAK1D;AAED,gFAAgF;AAChF,wBAAgB,uBAAuB,IAAI,WAAW,EAAE,CAEvD;AAED,mFAAmF;AACnF,wBAAgB,kBAAkB,IAAI,IAAI,CASzC;AAED,qEAAqE;AACrE,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAoDxE;AAED,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAqC7E"}