@loop_ouroboros/mcp-hub-lite 1.2.9 → 1.3.0

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/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"}

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

@@ -1,35 +1,86 @@
 /**
- * Gateway tool list generator with collision resolution.
+ * Gateway tool list generator with collision resolution and global caching.
  */
-import { logger } from '../../utils/index.js';
-import { LOG_MODULES } from '../../utils/logger/log-modules.js';
-import { mcpConnectionManager } from '../mcp-connection-manager.js';
+import { logger, LOG_MODULES } from '../../utils/index.js';
+import { mcpConnectionManager } from '../connection/index.js';
 import { hubManager } from '../hub-manager.service.js';
-import { hubToolsService } from '../hub-tools.service.js';
+import { getSystemTools } from '../hub-tools/index.js';
 import { parseCompositeKey } from '../../utils/composite-key.js';
+// ── Double-layer cache ──────────────────────────────────────────
+/** Raw data layer: per-server aggregated tool snapshots */
+let rawToolData = null;
+/** Resolved name layer */
+let cachedToolMap = null;
+let cachedGatewayTools = null;
+// ── Phase 1: Data gathering ─────────────────────────────────────
 /**
- * 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
+ * Collects aggregated tool data from all connected servers.
+ * Iterates tool cache entries and applies the aggregatedTools filter.
  */
-export function generateGatewayToolsList(toolMap) {
-    const gatewayTools = [];
+function gatherRawToolData() {
+    const rawData = new Map();
+    for (const [compositeKey, tools] of mcpConnectionManager.getToolCacheEntries()) {
+        const parsed = parseCompositeKey(compositeKey);
+        const serverName = parsed ? parsed.serverName : compositeKey;
+        const serverIndex = parsed ? parsed.serverIndex : 0;
+        const serverConfig = hubManager.getServerByName(serverName);
+        if (!serverConfig)
+            continue;
+        const aggregatedTools = serverConfig.template?.aggregatedTools;
+        if (!aggregatedTools?.length)
+            continue;
+        const filteredTools = tools.filter((t) => aggregatedTools.includes(t.name));
+        if (filteredTools.length === 0)
+            continue;
+        const existing = rawData.get(serverName);
+        if (existing) {
+            // Merge tools from multiple instances — later tools overwrite earlier by name
+            const mergedTools = new Map();
+            for (const t of existing.tools)
+                mergedTools.set(t.name, t);
+            for (const t of filteredTools)
+                mergedTools.set(t.name, t);
+            // Update toolIndexes for tools from this instance
+            const mergedIndexes = new Map(existing.toolIndexes);
+            for (const t of filteredTools) {
+                mergedIndexes.set(t.name, serverIndex);
+            }
+            rawData.set(serverName, {
+                tools: Array.from(mergedTools.values()),
+                aggregated: aggregatedTools,
+                toolIndexes: mergedIndexes
+            });
+        }
+        else {
+            const toolIndexes = new Map();
+            for (const t of filteredTools) {
+                toolIndexes.set(t.name, serverIndex);
+            }
+            rawData.set(serverName, {
+                tools: filteredTools,
+                aggregated: aggregatedTools,
+                toolIndexes
+            });
+        }
+    }
+    let totalTools = 0;
+    for (const [, data] of rawData) {
+        totalTools += data.tools.length;
+    }
+    logger.debug(`Gateway tool cache: gathered ${totalTools} aggregated tools across ${rawData.size} servers`, LOG_MODULES.TOOL_LIST_GENERATOR);
+    return rawData;
+}
+// ── Phase 2: Name resolution ────────────────────────────────────
+/**
+ * Resolves final gateway tool names from raw data.
+ * Pure computation — no external calls.
+ */
+function resolveToolNames(rawData, toolMap) {
     toolMap.clear();
-    // Add system tools
-    const systemTools = hubToolsService.getSystemTools();
+    const gatewayTools = [];
     const usedNames = new Set();
+    // Add system tools
+    const systemTools = getSystemTools();
     for (const tool of systemTools) {
         gatewayTools.push({
             name: tool.name,
@@ -39,72 +90,31 @@ export function generateGatewayToolsList(toolMap) {
         });
         usedNames.add(tool.name);
     }
-    // First pass: Count tool name frequencies to determine uniqueness
+    // First pass: count tool name frequencies
     const toolNameCounts = new Map();
-    // Iterate through toolCache to get all tools - entries are keyed by compositeKey (serverName-serverIndex)
-    for (const [compositeKey, tools] of mcpConnectionManager.getToolCacheEntries()) {
-        for (const tool of tools) {
-            // Parse composite key to get serverName
-            const parsed = parseCompositeKey(compositeKey);
-            const serverName = parsed ? parsed.serverName : compositeKey;
-            const serverConfig = hubManager.getServerByName(serverName);
-            if (serverConfig) {
-                // Only include tools if server has aggregatedTools configured AND tool is in aggregatedTools
-                const aggregatedTools = serverConfig.template?.aggregatedTools;
-                const hasAggregatedTools = aggregatedTools && aggregatedTools.length > 0;
-                if (!hasAggregatedTools) {
-                    continue;
-                }
-                if (!Array.isArray(aggregatedTools) || !aggregatedTools.includes(tool.name)) {
-                    continue;
-                }
-            }
+    for (const [, data] of rawData) {
+        for (const tool of data.tools) {
             toolNameCounts.set(tool.name, (toolNameCounts.get(tool.name) || 0) + 1);
         }
     }
-    // Second pass: Generate gateway tools with proper naming
-    for (const [compositeKey, tools] of mcpConnectionManager.getToolCacheEntries()) {
-        // Parse composite key to get serverName
-        const parsed = parseCompositeKey(compositeKey);
-        const serverName = parsed ? parsed.serverName : compositeKey;
-        const serverIndex = parsed ? parsed.serverIndex : 0;
-        const serverConfig = hubManager.getServerByName(serverName);
-        // Skip if server configuration not found
-        if (!serverConfig) {
-            logger.warn(`Server configuration not found for serverName: ${serverName}, skipping tools`, LOG_MODULES.TOOL_LIST_GENERATOR);
-            continue;
-        }
-        // Only include tools if server has aggregatedTools configured
-        const aggregatedTools = serverConfig.template?.aggregatedTools;
-        const hasAggregatedTools = aggregatedTools && aggregatedTools.length > 0;
-        if (!hasAggregatedTools) {
-            continue;
-        }
-        // Get the instance ID for hash suffix (use compositeKey which contains serverName-serverIndex format)
-        const hashSuffix = compositeKey;
-        for (const tool of tools) {
-            if (!aggregatedTools.includes(tool.name)) {
-                continue;
-            }
+    // Second pass: generate gateway tools with collision resolution
+    for (const [serverName, data] of rawData) {
+        for (const tool of data.tools) {
             let gatewayToolName = tool.name;
             const isUnique = toolNameCounts.get(tool.name) === 1;
             const isSystemConflict = usedNames.has(tool.name);
-            // If tool name is not unique or conflicts with system tool, append server hash
             if (!isUnique || isSystemConflict) {
-                // Use hash suffix from compositeKey for uniqueness
-                const hash = hashSuffix.substring(0, 4);
+                const hash = serverName.substring(0, 4);
                 gatewayToolName = `${tool.name}_${hash}`;
             }
             // Ensure name doesn't exceed 60 chars
             if (gatewayToolName.length > 60) {
-                // Use hash suffix from compositeKey
-                const hash = hashSuffix.substring(0, 4);
-                // Reserve space for hash and separator
+                const hash = serverName.substring(0, 4);
                 const maxToolNameLen = 60 - hash.length - 1;
                 const truncatedToolName = tool.name.substring(0, maxToolNameLen);
                 gatewayToolName = `${truncatedToolName}_${hash}`;
             }
-            // Final uniqueness check (in case of hash collision or previous renaming conflict)
+            // Final uniqueness check
             let finalName = gatewayToolName;
             let counter = 1;
             while (usedNames.has(finalName)) {
@@ -118,19 +128,150 @@ export function generateGatewayToolsList(toolMap) {
                 }
                 counter++;
             }
-            gatewayToolName = finalName;
-            usedNames.add(gatewayToolName);
-            toolMap.set(gatewayToolName, {
+            usedNames.add(finalName);
+            toolMap.set(finalName, {
                 serverName,
-                serverIndex,
+                serverIndex: data.toolIndexes.get(tool.name) ?? 0,
                 realToolName: tool.name
             });
             gatewayTools.push({
-                name: gatewayToolName,
+                name: finalName,
                 description: `[From ${serverName}] ${tool.description || ''}`,
-                inputSchema: tool.inputSchema
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        serverName: {
+                            type: 'string',
+                            description: `Must be "${serverName}"`
+                        },
+                        toolName: {
+                            type: 'string',
+                            description: `Must be "${tool.name}"`
+                        },
+                        toolArgs: tool.inputSchema || { type: 'object', properties: {} },
+                        requestOptions: {
+                            type: 'object',
+                            description: 'Optional: instance selection options',
+                            properties: {
+                                sessionId: {
+                                    type: 'string',
+                                    description: 'Session ID for instance stickiness'
+                                },
+                                tags: {
+                                    type: 'object',
+                                    description: 'Tags for instance matching (e.g. {"env":"prod"})'
+                                }
+                            }
+                        }
+                    },
+                    required: ['serverName', 'toolName', 'toolArgs']
+                }
             });
         }
     }
     return gatewayTools;
 }
+// ── Composite: original function (backward compatible) ──────────
+export function generateGatewayToolsList(toolMap) {
+    const rawData = gatherRawToolData();
+    return resolveToolNames(rawData, toolMap);
+}
+// ── Cache API ────────────────────────────────────────────────────
+/** Lazy get — first-request fallback when cache hasn't been built yet */
+export function getOrBuildGatewayToolMap() {
+    if (!cachedToolMap) {
+        rebuildFromScratch();
+    }
+    return cachedToolMap;
+}
+/** Lazy get — first-request fallback when cache hasn't been built yet */
+export function getOrBuildGatewayToolsList() {
+    if (!cachedGatewayTools) {
+        rebuildFromScratch();
+    }
+    return cachedGatewayTools;
+}
+/** Lazy get — returns only aggregated external tools (excludes system tools) */
+export function getExternalGatewayTools() {
+    return getOrBuildGatewayToolsList().filter((t) => !t.description?.startsWith('[System]'));
+}
+/** Full rebuild from global state — used by TOOLS_UPDATED / SERVER_DISCONNECTED */
+export function rebuildFromScratch() {
+    const prevSize = cachedToolMap?.size ?? 0;
+    rawToolData = gatherRawToolData();
+    cachedToolMap = new Map();
+    cachedGatewayTools = resolveToolNames(rawToolData, cachedToolMap);
+    logger.info(`Gateway tool cache rebuilt: ${cachedToolMap.size} tools (was ${prevSize})`, LOG_MODULES.TOOL_LIST_GENERATOR);
+}
+/** Incremental add — update raw data layer, re-resolve names only */
+export function addToCache(serverName, toolNames) {
+    if (!rawToolData) {
+        logger.debug(`Gateway tool cache: raw data not initialized, falling back to full rebuild`, LOG_MODULES.TOOL_LIST_GENERATOR);
+        rebuildFromScratch();
+        return;
+    }
+    // Find tool definitions with instance info from tool cache entries
+    const toolDefs = new Map();
+    const toolIndexes = new Map();
+    for (const [compositeKey, tools] of mcpConnectionManager.getToolCacheEntries()) {
+        const parsed = parseCompositeKey(compositeKey);
+        if (!parsed || parsed.serverName !== serverName)
+            continue;
+        for (const t of tools) {
+            if (toolNames.includes(t.name)) {
+                toolDefs.set(t.name, t);
+                toolIndexes.set(t.name, parsed.serverIndex);
+            }
+        }
+    }
+    const newTools = Array.from(toolDefs.values());
+    const existing = rawToolData.get(serverName);
+    if (existing) {
+        const mergedTools = new Map();
+        for (const t of existing.tools)
+            mergedTools.set(t.name, t);
+        for (const t of newTools)
+            mergedTools.set(t.name, t);
+        const mergedIndexes = new Map(existing.toolIndexes);
+        for (const [name, idx] of toolIndexes) {
+            mergedIndexes.set(name, idx);
+        }
+        existing.tools = Array.from(mergedTools.values());
+        existing.aggregated = [...new Set([...existing.aggregated, ...toolNames])];
+        existing.toolIndexes = mergedIndexes;
+    }
+    else {
+        const serverConfig = hubManager.getServerByName(serverName);
+        rawToolData.set(serverName, {
+            tools: newTools,
+            aggregated: serverConfig?.template?.aggregatedTools ?? toolNames,
+            toolIndexes
+        });
+    }
+    cachedToolMap = new Map();
+    cachedGatewayTools = resolveToolNames(rawToolData, cachedToolMap);
+    logger.info(`Gateway tool cache: added ${toolNames.length} tool(s) from [${serverName}], total=${cachedToolMap.size}`, LOG_MODULES.TOOL_LIST_GENERATOR);
+}
+/** Incremental remove — update raw data layer, re-resolve names only */
+export function removeFromCache(serverName, toolNames) {
+    if (!rawToolData) {
+        logger.debug(`Gateway tool cache: raw data not initialized, falling back to full rebuild`, LOG_MODULES.TOOL_LIST_GENERATOR);
+        rebuildFromScratch();
+        return;
+    }
+    const existing = rawToolData.get(serverName);
+    if (!existing) {
+        logger.debug(`Gateway tool cache: no cached data for [${serverName}], skip remove`, LOG_MODULES.TOOL_LIST_GENERATOR);
+        return;
+    }
+    const removeSet = new Set(toolNames);
+    existing.tools = existing.tools.filter((t) => !removeSet.has(t.name));
+    existing.aggregated = existing.aggregated.filter((t) => !removeSet.has(t));
+    if (existing.aggregated.length === 0) {
+        rawToolData.delete(serverName);
+        logger.info(`Gateway tool cache: all aggregated tools removed from [${serverName}], server removed from cache`, LOG_MODULES.TOOL_LIST_GENERATOR);
+    }
+    cachedToolMap = new Map();
+    cachedGatewayTools = resolveToolNames(rawToolData, cachedToolMap);
+    logger.info(`Gateway tool cache: removed ${toolNames.length} tool(s) from [${serverName}], total=${cachedToolMap.size}`, LOG_MODULES.TOOL_LIST_GENERATOR);
+}

package/dist/server/src/services/hub-manager.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hub-manager.service.d.ts","sourceRoot":"","sources":["../../../../src/services/hub-manager.service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAEb,YAAY,EACZ,cAAc,EACd,cAAc,EACf,MAAM,2BAA2B,CAAC;AAEnC,OAAO,KAAK,EACV,mBAAmB,EACnB,yBAAyB,EAC1B,MAAM,gCAAgC,CAAC;AAKxC;;;;;;GAMG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,aAAa,CAAgB;gBAEzB,OAAO,GAAE,aAA6B;IAIlD;;OAEG;IACG,0BAA0B,CAC9B,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,CAAA;KAAE,CAAC,GAChE,OAAO,CAAC,IAAI,CAAC;IAUhB;;OAEG;IACG,gCAAgC,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAM5E;;OAEG;IACG,sBAAsB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA8BlE;;OAEG;IACH,aAAa,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAE,CAAC;IAI9D;;OAEG;IACH,aAAa,CACX,EAAE,EAAE,MAAM,GACT;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,QAAQ,EAAE,cAAc,CAAA;KAAE,GAAG,SAAS;IAe/E;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAIvD;;OAEG;IACH,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE;IAIxD;;OAEG;IACH,kBAAkB,IAAI,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC;IAStD;;OAEG;IACH,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI;IAQtF;;OAEG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IAOrF;;;;OAIG;IACG,iBAAiB,CACrB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,OAAO,CAAC,cAAc,CAAC,GAChC,OAAO,CAAC,cAAc,CAAC;IAQ1B;;OAEG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAkBhG;;OAEG;IACG,oBAAoB,CACxB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,GAC/B,OAAO,CAAC,IAAI,CAAC;IAShB;;OAEG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBlD;;OAEG;IACG,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBtE;;OAEG;IACG,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI7D;;OAEG;IACG,qCAAqC,CACzC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,yBAAyB,GAClC,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;CAwBhC;AAED,eAAO,MAAM,UAAU,mBAA0B,CAAC"}
+{"version":3,"file":"hub-manager.service.d.ts","sourceRoot":"","sources":["../../../../src/services/hub-manager.service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAEb,YAAY,EACZ,cAAc,EACd,cAAc,EACf,MAAM,2BAA2B,CAAC;AAEnC,OAAO,KAAK,EACV,mBAAmB,EACnB,yBAAyB,EAC1B,MAAM,gCAAgC,CAAC;AAKxC;;;;;;GAMG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,aAAa,CAAgB;gBAEzB,OAAO,GAAE,aAA6B;IAIlD;;OAEG;IACG,0BAA0B,CAC9B,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,CAAA;KAAE,CAAC,GAChE,OAAO,CAAC,IAAI,CAAC;IAUhB;;OAEG;IACG,gCAAgC,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAM5E;;OAEG;IACG,sBAAsB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA8BlE;;OAEG;IACH,aAAa,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAE,CAAC;IAI9D;;OAEG;IACH,aAAa,CACX,EAAE,EAAE,MAAM,GACT;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,QAAQ,EAAE,cAAc,CAAA;KAAE,GAAG,SAAS;IAe/E;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAIvD;;OAEG;IACH,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE;IAIxD;;OAEG;IACH,kBAAkB,IAAI,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC;IAStD;;OAEG;IACH,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI;IAQtF;;OAEG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IAOrF;;;;OAIG;IACG,iBAAiB,CACrB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,OAAO,CAAC,cAAc,CAAC,GAChC,OAAO,CAAC,cAAc,CAAC;IAQ1B;;OAEG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAkChG;;OAEG;IACG,oBAAoB,CACxB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,GAC/B,OAAO,CAAC,IAAI,CAAC;IAShB;;OAEG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBlD;;OAEG;IACG,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBtE;;OAEG;IACG,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI7D;;OAEG;IACG,qCAAqC,CACzC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,yBAAyB,GAClC,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;CAwBhC;AAED,eAAO,MAAM,UAAU,mBAA0B,CAAC"}

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

@@ -1,7 +1,7 @@
 import { configManager } from '../config/config-manager.js';
 import { resolveInstanceConfig } from '../config/config-migrator.js';
-import { logger, LOG_MODULES } from '../utils/logger.js';
-import { mcpConnectionManager } from './mcp-connection-manager.js';
+import { logger, LOG_MODULES } from '../utils/logger/index.js';
+import { mcpConnectionManager } from './connection/index.js';
 import { eventBus, EventTypes } from './event-bus.service.js';
 /**
  * Manages MCP server configurations and lifecycle operations through the configuration manager.
@@ -148,11 +148,24 @@ export class HubManagerService {
             logger.warn(`Attempted to update non-existent server: ${name}`, LOG_MODULES.HUB_MANAGER);
             return null;
         }
+        const oldAggregated = existing.template?.aggregatedTools ?? [];
         await this.configManager.updateServer(name, updates);
         logger.info(`Server updated: ${name}`, LOG_MODULES.HUB_MANAGER);
         const updatedServer = this.getServerByName(name) || null;
         if (updatedServer) {
             eventBus.publish(EventTypes.SERVER_UPDATED, { name, config: updatedServer });
+            if ('aggregatedTools' in updates) {
+                const newAggregated = (updates.aggregatedTools ?? []);
+                const oldSet = new Set(oldAggregated);
+                const newSet = new Set(newAggregated);
+                const added = newAggregated.filter((t) => !oldSet.has(t));
+                const removed = oldAggregated.filter((t) => !newSet.has(t));
+                eventBus.publish(EventTypes.AGGREGATED_TOOLS_CHANGED, {
+                    name,
+                    added,
+                    removed
+                });
+            }
         }
         return updatedServer;
     }

package/dist/server/src/services/hub-tools/instance-selector.js

@@ -1,5 +1,5 @@
 import { InstanceSelectionStrategy } from '../../models/server.model.js';
-import { mcpConnectionManager } from '../mcp-connection-manager.js';
+import { mcpConnectionManager } from '../connection/index.js';
 /**
  * Error thrown when tag-match-unique instance selection fails.
  * Passes raw data so the error class itself can format the message.

package/dist/server/src/services/hub-tools/resource-generator.d.ts

@@ -1,26 +1,5 @@
 import type { Resource } from '../../../shared/models/resource.model.js';
 import type { ServerStatus } from '../../../shared/types/common.types.js';
-/**
- * Clears the Hub to MCP URI mapping.
- * Should be called before regenerating resources.
- */
-export declare function clearHubToMcpUriMap(): void;
-/**
- * URI for the use guide resource.
- */
-export declare const USE_GUIDE_URI = "hub://use-guide";
-/**
- * Name of the use guide resource.
- */
-export declare const USE_GUIDE_NAME = "MCP Hub Lite Use Guide";
-/**
- * Description of the use guide resource.
- */
-export declare const USE_GUIDE_DESCRIPTION = "Comprehensive guide to using MCP Hub Lite gateway and its features";
-/**
- * MIME type for the use guide resource.
- */
-export declare const USE_GUIDE_MIME_TYPE = "text/markdown";
 /**
  * Server metadata resource content.
  */

package/dist/server/src/services/hub-tools/resource-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resource-generator.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/resource-generator.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAUlE;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AA6ID;;GAEG;AACH,eAAO,MAAM,aAAa,oBAAoB,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,cAAc,2BAA2B,CAAC;AAEvD;;GAEG;AACH,eAAO,MAAM,qBAAqB,uEACoC,CAAC;AAEvE;;GAEG;AACH,eAAO,MAAM,mBAAmB,kBAAkB,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,IAAI,QAAQ,EAAE,CAqErD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,cAAc,GAAG,QAAQ,EAAE,GAAG,MAAM,GAAG,OAAO,CAAC,CAyGzD"}
+{"version":3,"file":"resource-generator.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/resource-generator.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAiLlE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,IAAI,QAAQ,EAAE,CAqErD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,cAAc,GAAG,QAAQ,EAAE,GAAG,MAAM,GAAG,OAAO,CAAC,CAyGzD"}