@loop_ouroboros/mcp-hub-lite 1.0.1 → 1.1.0

package/dist/server/src/services/connection/tool-cache.d.ts

@@ -1,63 +1,64 @@
 import type { Tool } from '../../../shared/models/tool.model.js';
 /**
- * Manages tool caching for MCP connections at both server ID and server name levels.
+ * Manages tool caching for MCP connections at both composite key and server name levels.
  *
- * This class encapsulates all tool cache operations, providing both server ID-level
+ * This class encapsulates all tool cache operations, providing both composite key-level
  * and server name-level caching for efficient tool lookup while maintaining data
  * consistency across multiple instances of the same server.
  */
 export declare class ToolCache {
     private toolCache;
     private serverNameToolCache;
-    private nameToIdMap;
+    private nameToCompositeKeyMap;
     /**
-     * Sets the name-to-ID mapping for server name resolution.
+     * Sets the name-to-composite-key mapping for server name resolution.
      *
      * @param serverName - The server name
-     * @param serverId - The corresponding server instance ID
+     * @param compositeKey - The corresponding composite key
      */
-    setNameMapping(serverName: string, serverId: string): void;
+    setNameMapping(serverName: string, compositeKey: string): void;
     /**
-     * Removes the name-to-ID mapping for a server.
+     * Removes the name-to-composite-key mapping for a server.
      *
      * @param serverName - The server name to remove
      */
     removeNameMapping(serverName: string): void;
     /**
-     * Removes name mapping by server ID.
+     * Removes name mapping by composite key.
      *
-     * @param serverId - The server ID to remove
+     * @param compositeKey - The composite key to remove
      */
-    removeNameMappingById(serverId: string): void;
+    removeNameMappingById(compositeKey: string): void;
     /**
-     * Gets the server ID for a given server name.
+     * Gets the composite key for a given server name.
      *
      * @param name - The server name
-     * @returns The server ID or undefined if not found
+     * @returns The composite key or undefined if not found
      */
-    getServerIdByName(name: string): string | undefined;
+    getCompositeKeyByName(name: string): string | undefined;
     /**
-     * Gets the server name for a given server ID.
+     * Gets the server name for a given composite key.
      *
-     * @param serverId - The server ID
+     * @param compositeKey - The composite key
      * @returns The server name or 'unknown' if not found
      */
-    getServerNameById(serverId: string): string;
+    getServerNameById(compositeKey: string): string;
     /**
      * Sets tools for a specific server instance and updates both caches.
      *
-     * @param serverId - The server instance ID
+     * @param serverName - The server name
+     * @param serverIndex - The instance index
      * @param tools - The tools to cache
-     * @param serverName - Optional server name for name-level cache update
      */
-    setTools(serverId: string, tools: Tool[], serverName?: string): void;
+    setTools(serverName: string, serverIndex: number, tools: Tool[]): void;
     /**
      * Gets tools for a specific server instance.
      *
-     * @param serverId - The server instance ID
+     * @param serverName - The server name
+     * @param serverIndex - The instance index
      * @returns Array of tools, empty if none
      */
-    getTools(serverId: string): Tool[];
+    getTools(serverName: string, serverIndex: number): Tool[];
     /**
      * Gets tools by server name from the server name-level cache.
      *
@@ -88,23 +89,24 @@ export declare class ToolCache {
     /**
      * Gets all tool cache entries.
      *
-     * @returns Array of [serverId, tools] tuples
+     * @returns Array of [compositeKey, tools] tuples
      */
     getToolCacheEntries(): [string, Tool[]][];
     /**
      * Returns an iterator over the tool cache entries for backward compatibility.
      * This mimics the Map.entries() method signature.
      *
-     * @returns Iterator of [serverId, tools] tuples
+     * @returns Iterator of [compositeKey, tools] tuples
      * @deprecated Use getToolCacheEntries() instead
      */
     entries(): IterableIterator<[string, Tool[]]>;
     /**
      * Clears tools for a specific server and updates both caches.
      *
-     * @param serverId - The server instance ID
+     * @param serverName - The server name
+     * @param serverIndex - The instance index
      */
-    clearTools(serverId: string): void;
+    clearTools(serverName: string, serverIndex: number): void;
     /**
      * Updates the server name-level cache for a specific server.
      * This aggregates tools from all instances of the same server name.

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

@@ -1 +1 @@
-{"version":3,"file":"tool-cache.d.ts","sourceRoot":"","sources":["../../../../../src/services/connection/tool-cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AAEzD;;;;;;GAMG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,SAAS,CAAkC;IACnD,OAAO,CAAC,mBAAmB,CAAkC;IAC7D,OAAO,CAAC,WAAW,CAAkC;IAErD;;;;;OAKG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAI1D;;;;OAIG;IACH,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAI3C;;;;OAIG;IACH,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAS7C;;;;;OAKG;IACH,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAInD;;;;;OAKG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAS3C;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI;IAkBpE;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE;IAUlC;;;;;OAKG;IACH,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,EAAE;IAIhD;;;;;;OAMG;IACH,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS;IAK/D;;;;OAIG;IACH,WAAW,IAAI,IAAI,EAAE;IAQrB;;;;OAIG;IACH,uBAAuB,IAAI,IAAI,EAAE;IAQjC;;;;OAIG;IACH,mBAAmB,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE;IAIzC;;;;;;OAMG;IACH,OAAO,IAAI,gBAAgB,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IAI7C;;;;OAIG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAclC;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAiB7B;;;;OAIG;IACH,IAAI,iBAAiB,IAAI,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAE3C;CACF"}
+{"version":3,"file":"tool-cache.d.ts","sourceRoot":"","sources":["../../../../../src/services/connection/tool-cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AAGzD;;;;;;GAMG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,SAAS,CAAkC;IACnD,OAAO,CAAC,mBAAmB,CAAkC;IAC7D,OAAO,CAAC,qBAAqB,CAAkC;IAE/D;;;;;OAKG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAI9D;;;;OAIG;IACH,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAI3C;;;;OAIG;IACH,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IASjD;;;;;OAKG;IACH,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIvD;;;;;OAKG;IACH,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;IAS/C;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAWtE;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,EAAE;IAWzD;;;;;OAKG;IACH,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,EAAE;IAIhD;;;;;;OAMG;IACH,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS;IAK/D;;;;OAIG;IACH,WAAW,IAAI,IAAI,EAAE;IAQrB;;;;OAIG;IACH,uBAAuB,IAAI,IAAI,EAAE;IAQjC;;;;OAIG;IACH,mBAAmB,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE;IAIzC;;;;;;OAMG;IACH,OAAO,IAAI,gBAAgB,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IAI7C;;;;;OAKG;IACH,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAWzD;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAiB7B;;;;OAIG;IACH,IAAI,iBAAiB,IAAI,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAE3C;CACF"}

package/dist/server/src/services/connection/tool-cache.js

@@ -1,63 +1,64 @@
 import { logger, LOG_MODULES } from '../../utils/logger.js';
+import { getCompositeKey } from '../../utils/composite-key.js';
 /**
- * Manages tool caching for MCP connections at both server ID and server name levels.
+ * Manages tool caching for MCP connections at both composite key and server name levels.
  *
- * This class encapsulates all tool cache operations, providing both server ID-level
+ * This class encapsulates all tool cache operations, providing both composite key-level
  * and server name-level caching for efficient tool lookup while maintaining data
  * consistency across multiple instances of the same server.
  */
 export class ToolCache {
     toolCache = new Map();
     serverNameToolCache = new Map();
-    nameToIdMap = new Map();
+    nameToCompositeKeyMap = new Map();
     /**
-     * Sets the name-to-ID mapping for server name resolution.
+     * Sets the name-to-composite-key mapping for server name resolution.
      *
      * @param serverName - The server name
-     * @param serverId - The corresponding server instance ID
+     * @param compositeKey - The corresponding composite key
      */
-    setNameMapping(serverName, serverId) {
-        this.nameToIdMap.set(serverName, serverId);
+    setNameMapping(serverName, compositeKey) {
+        this.nameToCompositeKeyMap.set(serverName, compositeKey);
     }
     /**
-     * Removes the name-to-ID mapping for a server.
+     * Removes the name-to-composite-key mapping for a server.
      *
      * @param serverName - The server name to remove
      */
     removeNameMapping(serverName) {
-        this.nameToIdMap.delete(serverName);
+        this.nameToCompositeKeyMap.delete(serverName);
     }
     /**
-     * Removes name mapping by server ID.
+     * Removes name mapping by composite key.
      *
-     * @param serverId - The server ID to remove
+     * @param compositeKey - The composite key to remove
      */
-    removeNameMappingById(serverId) {
-        for (const [name, id] of this.nameToIdMap.entries()) {
-            if (id === serverId) {
-                this.nameToIdMap.delete(name);
+    removeNameMappingById(compositeKey) {
+        for (const [name, key] of this.nameToCompositeKeyMap.entries()) {
+            if (key === compositeKey) {
+                this.nameToCompositeKeyMap.delete(name);
                 break;
             }
         }
     }
     /**
-     * Gets the server ID for a given server name.
+     * Gets the composite key for a given server name.
      *
      * @param name - The server name
-     * @returns The server ID or undefined if not found
+     * @returns The composite key or undefined if not found
      */
-    getServerIdByName(name) {
-        return this.nameToIdMap.get(name);
+    getCompositeKeyByName(name) {
+        return this.nameToCompositeKeyMap.get(name);
     }
     /**
-     * Gets the server name for a given server ID.
+     * Gets the server name for a given composite key.
      *
-     * @param serverId - The server ID
+     * @param compositeKey - The composite key
      * @returns The server name or 'unknown' if not found
      */
-    getServerNameById(serverId) {
-        for (const [name, id] of this.nameToIdMap.entries()) {
-            if (id === serverId) {
+    getServerNameById(compositeKey) {
+        for (const [name, key] of this.nameToCompositeKeyMap.entries()) {
+            if (key === compositeKey) {
                 return name;
             }
         }
@@ -66,33 +67,28 @@ export class ToolCache {
     /**
      * Sets tools for a specific server instance and updates both caches.
      *
-     * @param serverId - The server instance ID
+     * @param serverName - The server name
+     * @param serverIndex - The instance index
      * @param tools - The tools to cache
-     * @param serverName - Optional server name for name-level cache update
      */
-    setTools(serverId, tools, serverName) {
-        this.toolCache.set(serverId, tools);
-        if (serverName) {
-            this.updateServerNameCache(serverName);
-        }
-        else {
-            const resolvedName = this.getServerNameById(serverId);
-            if (resolvedName !== 'unknown') {
-                this.updateServerNameCache(resolvedName);
-            }
-        }
-        logger.debug(`ToolCache: Set ${tools.length} tools for server [${serverId}]`, LOG_MODULES.CONNECTION_MANAGER);
+    setTools(serverName, serverIndex, tools) {
+        const compositeKey = getCompositeKey(serverName, serverIndex);
+        this.toolCache.set(compositeKey, tools);
+        this.updateServerNameCache(serverName);
+        logger.debug(`ToolCache: Set ${tools.length} tools for server [${compositeKey}]`, LOG_MODULES.CONNECTION_MANAGER);
     }
     /**
      * Gets tools for a specific server instance.
      *
-     * @param serverId - The server instance ID
+     * @param serverName - The server name
+     * @param serverIndex - The instance index
      * @returns Array of tools, empty if none
      */
-    getTools(serverId) {
-        const tools = this.toolCache.get(serverId) || [];
-        const fromCache = this.toolCache.has(serverId);
-        logger.debug(`ToolCache: getTools for [${serverId}]: returned ${tools.length} tools (${fromCache ? 'from cache' : 'no cache'})`, LOG_MODULES.CONNECTION_MANAGER);
+    getTools(serverName, serverIndex) {
+        const compositeKey = getCompositeKey(serverName, serverIndex);
+        const tools = this.toolCache.get(compositeKey) || [];
+        const fromCache = this.toolCache.has(compositeKey);
+        logger.debug(`ToolCache: getTools for [${compositeKey}]: returned ${tools.length} tools (${fromCache ? 'from cache' : 'no cache'})`, LOG_MODULES.CONNECTION_MANAGER);
         return tools;
     }
     /**
@@ -142,7 +138,7 @@ export class ToolCache {
     /**
      * Gets all tool cache entries.
      *
-     * @returns Array of [serverId, tools] tuples
+     * @returns Array of [compositeKey, tools] tuples
      */
     getToolCacheEntries() {
         return Array.from(this.toolCache.entries());
@@ -151,7 +147,7 @@ export class ToolCache {
      * Returns an iterator over the tool cache entries for backward compatibility.
      * This mimics the Map.entries() method signature.
      *
-     * @returns Iterator of [serverId, tools] tuples
+     * @returns Iterator of [compositeKey, tools] tuples
      * @deprecated Use getToolCacheEntries() instead
      */
     entries() {
@@ -160,15 +156,14 @@ export class ToolCache {
     /**
      * Clears tools for a specific server and updates both caches.
      *
-     * @param serverId - The server instance ID
+     * @param serverName - The server name
+     * @param serverIndex - The instance index
      */
-    clearTools(serverId) {
-        const serverName = this.getServerNameById(serverId);
-        this.toolCache.delete(serverId);
-        if (serverName !== 'unknown') {
-            this.updateServerNameCache(serverName);
-        }
-        logger.debug(`ToolCache: Cleared tools for server [${serverId}]`, LOG_MODULES.CONNECTION_MANAGER);
+    clearTools(serverName, serverIndex) {
+        const compositeKey = getCompositeKey(serverName, serverIndex);
+        this.toolCache.delete(compositeKey);
+        this.updateServerNameCache(serverName);
+        logger.debug(`ToolCache: Cleared tools for server [${compositeKey}]`, LOG_MODULES.CONNECTION_MANAGER);
     }
     /**
      * Updates the server name-level cache for a specific server.
@@ -178,8 +173,8 @@ export class ToolCache {
      */
     updateServerNameCache(serverName) {
         const allToolsForServer = [];
-        for (const [id, cachedTools] of this.toolCache.entries()) {
-            const instanceServerName = this.getServerNameById(id);
+        for (const [compositeKey, cachedTools] of this.toolCache.entries()) {
+            const instanceServerName = this.getServerNameById(compositeKey);
             if (instanceServerName === serverName) {
                 allToolsForServer.push(...cachedTools);
             }

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

@@ -21,7 +21,9 @@ import type { ToolMapEntry, GatewayTool } from './types.js';
 export declare class GatewayService {
     private server;
     private transport;
+    private readonly appVersion;
     constructor();
+    private createServerWithHandlers;
     private registerHandlers;
     /**
      * Generates a unified list of gateway tools with proper naming and collision resolution.

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;AAapE,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE5D,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,SAAS,CAAqC;;IAoBtD,OAAO,CAAC,gBAAgB;IAWxB;;;;;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;IAmB1C;;;;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;AAcpE,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;IAkBhC,OAAO,CAAC,gBAAgB;IAUxB;;;;;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

@@ -19,31 +19,37 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { logger } from '../../utils/index.js';
+import { LOG_MODULES } from '../../utils/logger/log-modules.js';
 import { MCP_HUB_LITE_SERVER } from '../../models/system-tools.constants.js';
-import { registerInitializeHandlers, registerToolsHandlers, registerResourcesHandlers, registerSystemToolsHandlers, registerCallToolHandler } from './request-handlers/index.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 { formatToolArgs, formatToolResponse } from './log-formatter.js';
 export class GatewayService {
     server;
     transport = null;
+    appVersion;
     constructor() {
-        this.server = new McpServer({
+        this.appVersion = getAppVersion();
+        this.server = this.createServerWithHandlers();
+    }
+    createServerWithHandlers() {
+        const server = new McpServer({
             name: MCP_HUB_LITE_SERVER,
-            version: '1.0.0'
+            version: this.appVersion
         }, {
             capabilities: {
                 tools: {},
-                resources: {} // Add resource capability support
+                resources: {}
             }
         });
-        // Call registerHandlers directly in constructor
-        this.registerHandlers(this.server);
+        this.registerHandlers(server);
+        return server;
     }
     registerHandlers(server) {
         // Local toolMap for this connection
         const toolMap = new Map();
         registerInitializeHandlers(server);
-        registerToolsHandlers(server);
         registerResourcesHandlers(server);
         registerSystemToolsHandlers(server);
         registerCallToolHandler(server, toolMap);
@@ -81,17 +87,7 @@ export class GatewayService {
      * @returns {McpServer} New MCP server instance with all handlers registered
      */
     createConnectionServer() {
-        const server = new McpServer({
-            name: MCP_HUB_LITE_SERVER,
-            version: '1.0.0'
-        }, {
-            capabilities: {
-                tools: {},
-                resources: {} // Add resource capability support
-            }
-        });
-        this.registerHandlers(server);
-        return server;
+        return this.createServerWithHandlers();
     }
     /**
      * Starts the MCP gateway service on stdio transport.
@@ -101,7 +97,7 @@ export class GatewayService {
     async start() {
         this.transport = new StdioServerTransport();
         await this.server.connect(this.transport);
-        logger.info('MCP Gateway started on stdio');
+        logger.info('MCP Gateway started on stdio', LOG_MODULES.GATEWAY_SERVICE);
     }
 }
 export const gateway = new GatewayService();

package/dist/server/src/services/gateway/global-transport.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Global stateless MCP transport and server.
+ *
+ * This module provides a shared, stateless MCP transport and server instance
+ * that can be used across all requests without session isolation.
+ */
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+export declare const globalTransport: StreamableHTTPServerTransport;
+export declare const globalServer: import("@modelcontextprotocol/sdk/server/mcp.js").McpServer;
+//# sourceMappingURL=global-transport.d.ts.map

package/dist/server/src/services/gateway/global-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-transport.d.ts","sourceRoot":"","sources":["../../../../../src/services/gateway/global-transport.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,6BAA6B,EAAE,MAAM,oDAAoD,CAAC;AAwCnG,eAAO,MAAM,eAAe,+BAAY,CAAC;AACzC,eAAO,MAAM,YAAY,6DAAS,CAAC"}

package/dist/server/src/services/gateway/global-transport.js

@@ -0,0 +1,42 @@
+/**
+ * Global stateless MCP transport and server.
+ *
+ * This module provides a shared, stateless MCP transport and server instance
+ * that can be used across all requests without session isolation.
+ */
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { gateway } from './gateway.service.js';
+import { logger, LOG_MODULES } from '../../utils/logger/index.js';
+import { getMcpCommDebugSetting } from '../../utils/json-utils.js';
+import { formatMcpMessageForLogging, logNotificationMessage } from '../../utils/logger/log-output.js';
+// Create shared transport in STATELESS MODE - NO PARAMETERS NEEDED!
+const transport = new StreamableHTTPServerTransport();
+// Create shared server
+const server = gateway.createConnectionServer();
+// Set up message logging (use empty string for sessionId in stateless mode)
+transport.onmessage = (message) => {
+    if (getMcpCommDebugSetting()) {
+        const logMessage = formatMcpMessageForLogging(message);
+        logger.debug(`MCP message received: ${logMessage}`, LOG_MODULES.COMMUNICATION);
+    }
+    logNotificationMessage(message, ''); // Empty sessionId for stateless
+};
+// Wrap send method for debug logging
+if (getMcpCommDebugSetting()) {
+    const originalSend = transport.send;
+    transport.send = async (message, options) => {
+        try {
+            const logMessage = formatMcpMessageForLogging(message);
+            logger.debug(`MCP message sent: ${logMessage}`, LOG_MODULES.COMMUNICATION);
+        }
+        catch {
+            logger.debug(`MCP message sent: [Error formatting response]`, LOG_MODULES.COMMUNICATION);
+        }
+        return await originalSend.call(transport, message, options);
+    };
+}
+// Connect server to transport
+await server.connect(transport);
+logger.info('Global MCP transport initialized (stateless mode)', LOG_MODULES.GATEWAY);
+export const globalTransport = transport;
+export const globalServer = server;

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;AAEhD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GACjC,IAAI,CAwKN"}
+{"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"}

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

@@ -4,7 +4,6 @@
 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 { getClientCwd } from '../../../utils/request-context.js';
 import { mcpConnectionManager } from '../../mcp-connection-manager.js';
 import { SystemToolHandler } from '../../system-tool-handler.js';
 import { ErrorHandler } from '../../../utils/error-handler.js';
@@ -12,6 +11,64 @@ 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';
+/**
+ * Type guard to check if a result is a valid CallToolResult.
+ *
+ * @param result - The result to check
+ * @returns True if result has the expected CallToolResult structure
+ */
+function isCallToolResult(result) {
+    return (!!result && typeof result === 'object' && 'content' in result && Array.isArray(result.content));
+}
+/**
+ * Executes a system tool call via the SystemToolHandler.
+ *
+ * @param toolName - Name of the system tool to call
+ * @param toolArgs - Arguments to pass to the tool
+ * @returns CallToolResult with the tool execution result
+ */
+async function executeSystemToolCall(toolName, toolArgs) {
+    try {
+        const result = await SystemToolHandler.handleSystemToolCall(toolName, toolArgs);
+        if (isCallToolResult(result)) {
+            return result;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: stringifyForLogging(result)
+                }
+            ]
+        };
+    }
+    catch (error) {
+        ErrorHandler.handleSystemToolError(toolName, error);
+    }
+}
+/**
+ * Parses a tool name to check if it refers to a system tool.
+ * Handles both direct system tool names (e.g., "list_servers") and
+ * prefixed names (e.g., "mcp__mcp-hub-lite__list_servers").
+ *
+ * @param toolName - The tool name to parse
+ * @returns The system tool name if it's a system tool, null otherwise
+ */
+function getSystemToolName(toolName) {
+    const parsedTool = ToolArgsParser.parsePrefixedToolName(toolName);
+    if (parsedTool) {
+        logger.debug(`Parsed prefixed tool name: "${toolName}" → server="${parsedTool.serverName}", tool="${parsedTool.toolName}"`, LOG_MODULES.GATEWAY);
+        if (parsedTool.serverName === MCP_HUB_LITE_SERVER &&
+            SYSTEM_TOOL_NAMES.includes(parsedTool.toolName)) {
+            logger.info(`System tool called via prefixed name: ${parsedTool.toolName}`, LOG_MODULES.GATEWAY);
+            return parsedTool.toolName;
+        }
+    }
+    if (SYSTEM_TOOL_NAMES.includes(toolName)) {
+        return toolName;
+    }
+    return null;
+}
 /**
  * Register call tool handler on the MCP server.
  *
@@ -30,82 +87,27 @@ export function registerCallToolHandler(server, toolMap) {
     server.server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const toolName = request.params.name;
         const toolArgs = request.params.arguments || {};
-        // Parse prefixed tool names (like mcp__mcp-hub-lite__xxx) if applicable
-        // This handles Claude Code style tool names with server prefix
-        const parsedTool = ToolArgsParser.parsePrefixedToolName(toolName);
-        if (parsedTool) {
-            logger.debug(`Parsed prefixed tool name: "${toolName}" → server="${parsedTool.serverName}", tool="${parsedTool.toolName}"`, LOG_MODULES.GATEWAY);
-            // Check if it's a system tool call
-            if (parsedTool.serverName === MCP_HUB_LITE_SERVER &&
-                SYSTEM_TOOL_NAMES.includes(parsedTool.toolName)) {
-                logger.info(`System tool called via prefixed name: ${parsedTool.toolName}`, LOG_MODULES.GATEWAY);
-                try {
-                    const result = await SystemToolHandler.handleSystemToolCall(parsedTool.toolName, toolArgs);
-                    if (result &&
-                        typeof result === 'object' &&
-                        'content' in result &&
-                        Array.isArray(result.content)) {
-                        return result;
-                    }
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: stringifyForLogging(result)
-                            }
-                        ]
-                    };
-                }
-                catch (error) {
-                    ErrorHandler.handleSystemToolError(parsedTool.toolName, error);
-                }
-            }
-        }
+        const systemToolName = getSystemToolName(toolName);
         // 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);
         // Handle system tools
-        if (typeof toolName === 'string' && SYSTEM_TOOL_NAMES.includes(toolName)) {
-            logger.debug(`System tool called: ${toolName}, args=${formatToolArgs(toolArgs)}`, LOG_MODULES.GATEWAY);
-            try {
-                const result = await SystemToolHandler.handleSystemToolCall(toolName, toolArgs);
-                if (result &&
-                    typeof result === 'object' &&
-                    'content' in result &&
-                    Array.isArray(result.content)) {
-                    return result;
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: stringifyForLogging(result)
-                        }
-                    ]
-                };
-            }
-            catch (error) {
-                ErrorHandler.handleSystemToolError(toolName, error);
-            }
+        if (systemToolName) {
+            logger.debug(`System tool called: ${systemToolName}, args=${formatToolArgs(toolArgs)}`, LOG_MODULES.GATEWAY);
+            return await executeSystemToolCall(systemToolName, toolArgs);
         }
         const target = toolMap.get(toolName);
-        logger.debug(`Tool lookup SUCCESS: toolName=${toolName} -> serverId=${target?.serverId}, realToolName=${target?.realToolName}`, LOG_MODULES.GATEWAY);
+        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);
             throw new McpError(-32801, `Tool ${toolName} not found`);
         }
         const startTime = Date.now();
         try {
-            // Inject CWD if available and not present in args
-            const cwd = getClientCwd();
-            if (cwd && !toolArgs.cwd) {
-                toolArgs.cwd = cwd;
-                logger.debug(`Injected CWD into tool call ${toolName}: ${cwd}`, LOG_MODULES.dynamic(toolName));
-            }
-            logger.debug(`Tool call EXECUTING: serverId=${target.serverId}, realToolName=${target.realToolName}, args=${formatToolArgs(toolArgs)}`, LOG_MODULES.GATEWAY);
-            const result = await mcpConnectionManager.callTool(target.serverId, target.realToolName, toolArgs);
+            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);
             const duration = Date.now() - startTime;
-            logger.info(`Tool call SUCCESS: serverId=${target.serverId}, realToolName=${target.realToolName}, duration=${duration}ms, response=${formatToolResponse(result)}`, LOG_MODULES.GATEWAY);
+            logger.info(`Tool call SUCCESS: serverName=${target.serverName}, serverIndex=${target.serverIndex}, realToolName=${target.realToolName}, duration=${duration}ms, response=${formatToolResponse(result)}`, LOG_MODULES.GATEWAY);
             // Wrap the result in a valid CallToolResult structure
             if (typeof result === 'object' && result !== null) {
                 return {
@@ -125,7 +127,7 @@ export function registerCallToolHandler(server, toolMap) {
             }
         }
         catch (error) {
-            ErrorHandler.handleToolCallError(target.serverId, target.realToolName, error);
+            ErrorHandler.handleToolCallError(`${target.serverName}-${target.serverIndex}`, target.realToolName, error);
         }
     });
 }

package/dist/server/src/services/gateway/request-handlers/index.d.ts

@@ -2,8 +2,8 @@
  * Gateway request handlers index.
  */
 export { registerInitializeHandlers } from './initialize-handler.js';
-export { registerToolsHandlers } from './tools-handler.js';
 export { registerResourcesHandlers } from './resources-handler.js';
 export { registerSystemToolsHandlers } from './system-tools-handler.js';
 export { registerCallToolHandler } from './call-tool-handler.js';
+export * from './initialize.constants.js';
 //# sourceMappingURL=index.d.ts.map