@loop_ouroboros/mcp-hub-lite 1.2.1 → 1.2.2

package/dist/server/src/services/connection/connection-manager.js

@@ -7,6 +7,7 @@ import { logStorage } from '../log-storage.service.js';
 import { eventBus, EventTypes } from '../event-bus.service.js';
 import { hubManager } from '../hub-manager.service.js';
 import { MCP_HUB_LITE_SERVER } from '../../models/system-tools.constants.js';
+import { configManager } from '../../config/config-manager.js';
 import { ToolCache } from './tool-cache.js';
 import { getCompositeKey } from '../../utils/composite-key.js';
 /**
@@ -94,212 +95,301 @@ export class McpConnectionManager {
      * ```
      */
     async connect(serverName, serverIndex, server) {
-        let serverInfo;
-        // Extract serverId at the very beginning for consistent usage in both try and catch blocks
         const serverId = server.id || 'unknown';
         const compositeKey = getCompositeKey(serverName, serverIndex);
-        try {
-            // Validate server configuration
-            if (!server.id) {
-                throw new Error('Server ID is required');
-            }
-            logger.info(`Connecting to server [${compositeKey}] (${serverId})...`, LOG_MODULES.CONNECTION_MANAGER);
-            // First set starting state (connected: false, no error)
-            this.serverStatus.set(compositeKey, {
-                connected: false,
-                lastCheck: Date.now(),
-                toolsCount: 0,
-                resourcesCount: 0
-            });
-            // Get server name from server instance ID (via hubManager.getServerById)
-            serverInfo = hubManager.getServerById(serverId);
-            if (!serverInfo) {
-                throw new Error(`Server not found for instance: ${serverId}`);
+        const { maxRetries, baseRetryDelay } = this.getRetryConfig();
+        // Retry loop for connection attempts
+        let lastError;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                // 1. Validate server configuration
+                this.validateServerConfig(server);
+                // 2. Log connection attempt
+                this.logConnectionAttempt(compositeKey, attempt, maxRetries);
+                // 3. Initialize starting status
+                this.initializeServerStatus(compositeKey);
+                // 4. Get server info
+                const serverInfo = this.getServerInfo(serverId);
+                // 5. Create transport and set up callbacks
+                const { transport, pid } = this.initializeTransport(server, serverInfo, compositeKey, serverName, serverIndex);
+                // 6. Establish client connection
+                const client = await this.establishClientConnection(transport);
+                // 7. Register connection
+                this.registerConnection(compositeKey, serverName, client, transport);
+                // 8. Update connected status
+                this.updateConnectedStatus(compositeKey, client, pid);
+                // 9. Publish connection events
+                this.publishConnectionEvents(serverName, serverIndex);
+                // 10. Refresh resources
+                await this.refreshServerResources(serverName, serverIndex, server.type);
+                return true;
             }
-            if (server.type === 'stdio' && (!server.command || server.command.trim() === '')) {
-                throw new Error('STDIO server requires a valid command');
+            catch (error) {
+                lastError = await this.handleConnectionError(error, compositeKey, attempt, maxRetries, baseRetryDelay);
             }
-            if ((server.type === 'sse' || server.type === 'streamable-http' || server.type === 'http') &&
-                (!server.url || server.url.trim() === '')) {
-                const displayType = server.type === 'http' ? 'streamable-http' : server.type;
-                throw new Error(`${displayType.toUpperCase()} server requires a valid URL`);
+        }
+        // All retries failed
+        this.handleFinalFailure(compositeKey, serverName, serverIndex, lastError);
+        return false;
+    }
+    /**
+     * Gets retry configuration from system settings.
+     */
+    getRetryConfig() {
+        const maxRetries = configManager.getConfig().system.startup?.maxConnectRetries ?? 3;
+        const baseRetryDelay = configManager.getConfig().system.startup?.connectRetryDelay ?? 5000;
+        return { maxRetries, baseRetryDelay };
+    }
+    /**
+     * Validates server configuration before connection.
+     */
+    validateServerConfig(server) {
+        if (!server.id) {
+            throw new Error('Server ID is required');
+        }
+        if (server.type === 'stdio' && (!server.command || server.command.trim() === '')) {
+            throw new Error('STDIO server requires a valid command');
+        }
+        if ((server.type === 'sse' || server.type === 'streamable-http' || server.type === 'http') &&
+            (!server.url || server.url.trim() === '')) {
+            const displayType = server.type === 'http' ? 'streamable-http' : server.type;
+            throw new Error(`${displayType.toUpperCase()} server requires a valid URL`);
+        }
+    }
+    /**
+     * Logs connection attempt information.
+     */
+    logConnectionAttempt(compositeKey, attempt, maxRetries) {
+        logger.info(`Connecting to server [${compositeKey}] (attempt ${attempt}/${maxRetries})...`, LOG_MODULES.CONNECTION_MANAGER);
+    }
+    /**
+     * Initializes server status to starting state.
+     */
+    initializeServerStatus(compositeKey) {
+        this.serverStatus.set(compositeKey, {
+            connected: false,
+            lastCheck: Date.now(),
+            toolsCount: 0,
+            resourcesCount: 0
+        });
+    }
+    /**
+     * Gets server info by ID from hub manager.
+     */
+    getServerInfo(serverId) {
+        const serverInfo = hubManager.getServerById(serverId);
+        if (!serverInfo) {
+            throw new Error(`Server not found for instance: ${serverId}`);
+        }
+        return serverInfo;
+    }
+    /**
+     * Creates transport and sets up all callbacks.
+     */
+    initializeTransport(server, serverInfo, compositeKey, serverName, serverIndex) {
+        const readyPatterns = server.type === 'stdio' ? (serverInfo.config.template.readyPatterns ?? []) : undefined;
+        const readyTimeout = configManager.getConfig().system.startup?.readyTimeout ?? 120000;
+        const transport = TransportFactory.createTransport({
+            ...server,
+            name: serverName
+        }, compositeKey, {
+            readyPatterns,
+            readyTimeout
+        });
+        // Set up message handler for notifications/message
+        transport.onmessage = (message) => {
+            if (getMcpCommDebugSetting()) {
+                const logMessage = formatMcpMessageForLogging(message);
+                logger.debug(`MCP message received: ${logMessage}`, LOG_MODULES.CONNECTION_MANAGER);
             }
-            // Create transport based on server type
-            const transport = TransportFactory.createTransport({
-                ...server,
-                name: serverName
-            }, compositeKey);
-            // Always set up message handler for notifications/message
-            transport.onmessage = (message) => {
-                // Communication debug logs: controlled by MCP_COMM_DEBUG environment variable
-                if (getMcpCommDebugSetting()) {
+            logNotificationMessage(message, serverName, compositeKey);
+        };
+        // Wrap send method for debug logging (if enabled)
+        if (getMcpCommDebugSetting()) {
+            const originalSend = transport.send;
+            transport.send = async (message, options) => {
+                try {
                     const logMessage = formatMcpMessageForLogging(message);
-                    logger.debug(`MCP message received: ${logMessage}`, LOG_MODULES.CONNECTION_MANAGER);
+                    logger.debug(`MCP message sent: ${logMessage}`, LOG_MODULES.CONNECTION_MANAGER);
                 }
-                // Log notifications/message to application logs (always enabled)
-                logNotificationMessage(message, serverName, compositeKey);
+                catch {
+                    logger.debug(`MCP message sent: [Error formatting response]`, LOG_MODULES.CONNECTION_MANAGER);
+                }
+                return await originalSend.call(transport, message, options);
             };
-            // Wrap send method for debug logging (if enabled)
-            if (getMcpCommDebugSetting()) {
-                const originalSend = transport.send;
-                transport.send = async (message, options) => {
-                    try {
-                        const logMessage = formatMcpMessageForLogging(message);
-                        logger.debug(`MCP message sent: ${logMessage}`, LOG_MODULES.CONNECTION_MANAGER);
-                    }
-                    catch {
-                        logger.debug(`MCP message sent: [Error formatting response]`, LOG_MODULES.CONNECTION_MANAGER);
-                    }
-                    // Call original send method
-                    return await originalSend.call(transport, message, options);
-                };
-            }
-            // Handle transport close events
-            if ('onclose' in transport) {
-                transport.onclose = () => {
-                    logger.info(`Transport closed for server [${compositeKey}]`, LOG_MODULES.CONNECTION_MANAGER);
-                    const currentStatus = this.serverStatus.get(compositeKey);
-                    // Only update status if it was previously connected or starting
-                    if (currentStatus && (currentStatus.connected || !currentStatus.error)) {
-                        this.serverStatus.set(compositeKey, {
-                            connected: false,
-                            lastCheck: Date.now(),
-                            toolsCount: 0,
-                            resourcesCount: 0,
-                            error: 'Connection closed unexpectedly'
-                        });
-                        // Publish server status change event
-                        eventBus.publish(EventTypes.SERVER_STATUS_CHANGE, {
-                            serverName,
-                            serverIndex,
-                            status: 'error',
-                            error: 'Connection closed unexpectedly',
-                            timestamp: Date.now()
-                        });
-                    }
-                };
-            }
-            // Add log listeners
-            if ('onstdout' in transport) {
-                transport.onstdout = (data) => {
-                    // Skip JSON-RPC communication to avoid log noise
-                    const trimmedData = data.trim();
-                    if (trimmedData) {
-                        // Check if it's a valid JSON-RPC message
-                        let isJsonRpc = false;
-                        if (trimmedData.startsWith('{')) {
-                            try {
-                                const parsed = JSON.parse(trimmedData);
-                                // Only consider it JSON-RPC if it has valid jsonrpc field
-                                isJsonRpc =
-                                    typeof parsed.jsonrpc === 'string' &&
-                                        (parsed.jsonrpc === '2.0' || parsed.jsonrpc === '1.0');
-                            }
-                            catch {
-                                // Not valid JSON, treat as log output
-                                isJsonRpc = false;
-                            }
+        }
+        // Handle transport close events
+        if ('onclose' in transport) {
+            transport.onclose = () => {
+                logger.info(`Transport closed for server [${compositeKey}]`, LOG_MODULES.CONNECTION_MANAGER);
+                const currentStatus = this.serverStatus.get(compositeKey);
+                if (currentStatus && (currentStatus.connected || !currentStatus.error)) {
+                    this.serverStatus.set(compositeKey, {
+                        connected: false,
+                        lastCheck: Date.now(),
+                        toolsCount: 0,
+                        resourcesCount: 0,
+                        error: 'Connection closed unexpectedly'
+                    });
+                    eventBus.publish(EventTypes.SERVER_STATUS_CHANGE, {
+                        serverName,
+                        serverIndex,
+                        status: 'error',
+                        error: 'Connection closed unexpectedly',
+                        timestamp: Date.now()
+                    });
+                }
+            };
+        }
+        // Add log listeners
+        if ('onstdout' in transport) {
+            transport.onstdout = (data) => {
+                const trimmedData = data.trim();
+                if (trimmedData) {
+                    let isJsonRpc = false;
+                    if (trimmedData.startsWith('{')) {
+                        try {
+                            const parsed = JSON.parse(trimmedData);
+                            isJsonRpc =
+                                typeof parsed.jsonrpc === 'string' &&
+                                    (parsed.jsonrpc === '2.0' || parsed.jsonrpc === '1.0');
                         }
-                        if (!isJsonRpc) {
-                            // Use composite key for log storage
-                            logStorage.append(compositeKey, 'info', `[${serverName}] [STDOUT] ${data}`);
+                        catch {
+                            isJsonRpc = false;
                         }
                     }
-                };
-            }
-            if ('onstderr' in transport) {
-                transport.onstderr = (data) => {
-                    // Use composite key for log storage
-                    logStorage.append(compositeKey, 'error', `[${serverName}] [STDERR] ${data}`);
-                };
-            }
-            const client = new Client({
-                name: MCP_HUB_LITE_SERVER,
-                version: getAppVersion()
-            }, {
-                capabilities: {}
-            });
-            await client.connect(transport);
-            this.clients.set(compositeKey, client);
-            this.transports.set(compositeKey, transport);
-            this._toolCache.setNameMapping(serverName, compositeKey);
-            // Register composite key for this server name
-            if (!this.serverNameToCompositeKeys.has(serverName)) {
-                this.serverNameToCompositeKeys.set(serverName, new Set());
-            }
-            this.serverNameToCompositeKeys.get(serverName).add(compositeKey);
-            // Get PID if available (only for stdio transport)
-            let pid;
-            if ('pid' in transport && typeof transport.pid === 'number') {
-                pid = transport.pid;
-            }
-            // Get server version
-            const clientServerInfo = client.getServerVersion();
-            const serverVersion = clientServerInfo?.version || clientServerInfo?.name;
-            this.serverStatus.set(compositeKey, {
-                connected: true,
-                lastCheck: Date.now(),
-                toolsCount: 0,
-                resourcesCount: 0,
-                pid: pid,
-                startTime: Date.now(),
-                version: serverVersion
-            });
-            logger.info(`Connected to server [${compositeKey}]`, LOG_MODULES.CONNECTION_MANAGER);
-            // Publish server connected event
-            eventBus.publish(EventTypes.SERVER_CONNECTED, {
-                serverName,
-                serverIndex,
-                status: 'online',
-                timestamp: Date.now()
-            });
-            // Publish server status change event
-            eventBus.publish(EventTypes.SERVER_STATUS_CHANGE, {
-                serverName,
-                serverIndex,
-                status: 'online',
-                timestamp: Date.now()
-            });
-            // Fetch tools and resources immediately (only for bidirectional transports)
-            if (server.type !== 'sse') {
-                const tools = await this.refreshTools(serverName, serverIndex);
-                const resources = await this.refreshResources(serverName, serverIndex);
-                // Publish tools and resources updated event
-                eventBus.publish(EventTypes.TOOLS_UPDATED, {
-                    serverName,
-                    serverIndex,
-                    tools
-                });
-                eventBus.publish(EventTypes.RESOURCES_UPDATED, {
-                    serverName,
-                    serverIndex,
-                    resources
-                });
-            }
-            else {
-                logger.info('SSE transport is unidirectional, skipping tool/resource refresh', LOG_MODULES.CONNECTION_MANAGER);
-            }
-            return true;
+                    if (!isJsonRpc) {
+                        logStorage.append(compositeKey, 'info', `[${serverName}] [STDOUT] ${data}`);
+                    }
+                }
+            };
         }
-        catch (error) {
-            logger.error(`Failed to connect to server ${compositeKey}:`, error, LOG_MODULES.CONNECTION_MANAGER);
-            this.serverStatus.set(compositeKey, {
-                connected: false,
-                error: error instanceof Error ? error.message : String(error),
-                lastCheck: Date.now(),
-                toolsCount: 0,
-                resourcesCount: 0
-            });
-            // Publish server status change event (error state)
-            eventBus.publish(EventTypes.SERVER_STATUS_CHANGE, {
-                serverName,
-                serverIndex,
-                status: 'error',
-                error: error instanceof Error ? error.message : String(error),
-                timestamp: Date.now()
-            });
-            return false;
+        if ('onstderr' in transport) {
+            transport.onstderr = (data) => {
+                logStorage.append(compositeKey, 'error', `[${serverName}] [STDERR] ${data}`);
+            };
+        }
+        // Get PID if available (only for stdio transport)
+        let pid;
+        if ('pid' in transport && typeof transport.pid === 'number') {
+            pid = transport.pid;
+        }
+        return { transport, pid };
+    }
+    /**
+     * Creates Client and connects to transport.
+     */
+    async establishClientConnection(transport) {
+        const client = new Client({
+            name: MCP_HUB_LITE_SERVER,
+            version: getAppVersion()
+        }, {
+            capabilities: {}
+        });
+        await client.connect(transport);
+        return client;
+    }
+    /**
+     * Registers client, transport, and updates name mappings.
+     */
+    registerConnection(compositeKey, serverName, client, transport) {
+        this.clients.set(compositeKey, client);
+        this.transports.set(compositeKey, transport);
+        this._toolCache.setNameMapping(serverName, compositeKey);
+        if (!this.serverNameToCompositeKeys.has(serverName)) {
+            this.serverNameToCompositeKeys.set(serverName, new Set());
+        }
+        this.serverNameToCompositeKeys.get(serverName).add(compositeKey);
+    }
+    /**
+     * Updates server status to connected state.
+     */
+    updateConnectedStatus(compositeKey, client, pid) {
+        const clientServerInfo = client.getServerVersion();
+        const serverVersion = clientServerInfo?.version || clientServerInfo?.name;
+        this.serverStatus.set(compositeKey, {
+            connected: true,
+            lastCheck: Date.now(),
+            toolsCount: 0,
+            resourcesCount: 0,
+            pid: pid,
+            startTime: Date.now(),
+            version: serverVersion
+        });
+        logger.info(`Connected to server [${compositeKey}]`, LOG_MODULES.CONNECTION_MANAGER);
+        return serverVersion;
+    }
+    /**
+     * Publishes connection events.
+     */
+    publishConnectionEvents(serverName, serverIndex) {
+        eventBus.publish(EventTypes.SERVER_CONNECTED, {
+            serverName,
+            serverIndex,
+            status: 'online',
+            timestamp: Date.now()
+        });
+        eventBus.publish(EventTypes.SERVER_STATUS_CHANGE, {
+            serverName,
+            serverIndex,
+            status: 'online',
+            timestamp: Date.now()
+        });
+    }
+    /**
+     * Refreshes server tools and resources (only for bidirectional transports).
+     */
+    async refreshServerResources(serverName, serverIndex, serverType) {
+        if (serverType === 'sse') {
+            logger.info('SSE transport is unidirectional, skipping tool/resource refresh', LOG_MODULES.CONNECTION_MANAGER);
+            return;
         }
+        const tools = await this.refreshTools(serverName, serverIndex);
+        const resources = await this.refreshResources(serverName, serverIndex);
+        eventBus.publish(EventTypes.TOOLS_UPDATED, {
+            serverName,
+            serverIndex,
+            tools
+        });
+        eventBus.publish(EventTypes.RESOURCES_UPDATED, {
+            serverName,
+            serverIndex,
+            resources
+        });
+    }
+    /**
+     * Handles connection error with logging and retry delay.
+     */
+    async handleConnectionError(error, compositeKey, attempt, maxRetries, baseRetryDelay) {
+        const lastError = error instanceof Error ? error : new Error(String(error));
+        logger.warn(`Connection attempt ${attempt}/${maxRetries} failed for ${compositeKey}: ${lastError.message}`, LOG_MODULES.CONNECTION_MANAGER);
+        if (attempt < maxRetries) {
+            const retryDelay = baseRetryDelay * Math.pow(2, attempt - 1);
+            logger.info(`Retrying connection to ${compositeKey} in ${retryDelay}ms...`, LOG_MODULES.CONNECTION_MANAGER);
+            await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        }
+        return lastError;
+    }
+    /**
+     * Handles final failure after all retries exhausted.
+     */
+    handleFinalFailure(compositeKey, serverName, serverIndex, lastError) {
+        const errorMessage = lastError?.message || 'Connection failed after all retries';
+        logger.error(`Failed to connect to server ${compositeKey} after retries:`, lastError, LOG_MODULES.CONNECTION_MANAGER);
+        this.serverStatus.set(compositeKey, {
+            connected: false,
+            error: errorMessage,
+            lastCheck: Date.now(),
+            toolsCount: 0,
+            resourcesCount: 0
+        });
+        eventBus.publish(EventTypes.SERVER_STATUS_CHANGE, {
+            serverName,
+            serverIndex,
+            status: 'error',
+            error: errorMessage,
+            timestamp: Date.now()
+        });
     }
     /**
      * Disconnects from an MCP server and cleans up all associated resources.

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;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;IAqBhC,OAAO,CAAC,gBAAgB;IAyCxB;;;;;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;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"}

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

@@ -20,6 +20,7 @@ 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 { 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';
@@ -34,7 +35,9 @@ export class GatewayService {
         this.server = this.createServerWithHandlers();
     }
     createServerWithHandlers() {
-        logger.debug('Creating new MCP server with handlers', LOG_MODULES.GATEWAY_SERVICE);
+        if (getGatewayDebugSetting()) {
+            logger.debug('Creating new MCP server with handlers', LOG_MODULES.GATEWAY_SERVICE);
+        }
         const server = new McpServer({
             name: MCP_HUB_LITE_SERVER,
             version: this.appVersion
@@ -44,19 +47,29 @@ export class GatewayService {
                 resources: {}
             }
         });
-        logger.debug('MCP server created successfully', LOG_MODULES.GATEWAY_SERVICE);
+        if (getGatewayDebugSetting()) {
+            logger.debug('MCP server created successfully', LOG_MODULES.GATEWAY_SERVICE);
+        }
         this.registerHandlers(server);
-        logger.debug('Handlers registered successfully on MCP server', LOG_MODULES.GATEWAY_SERVICE);
+        if (getGatewayDebugSetting()) {
+            logger.debug('Handlers registered successfully on MCP server', LOG_MODULES.GATEWAY_SERVICE);
+        }
         return server;
     }
     registerHandlers(server) {
-        logger.debug('Registering handlers on MCP server', LOG_MODULES.GATEWAY_SERVICE);
+        if (getGatewayDebugSetting()) {
+            logger.debug('Registering handlers on MCP server', LOG_MODULES.GATEWAY_SERVICE);
+        }
         // Local toolMap for this connection
         const toolMap = new Map();
-        logger.debug('Created local toolMap for connection', LOG_MODULES.GATEWAY_SERVICE);
+        if (getGatewayDebugSetting()) {
+            logger.debug('Created local toolMap for connection', LOG_MODULES.GATEWAY_SERVICE);
+        }
         try {
             registerInitializeHandlers(server);
-            logger.debug('Initialize handlers registered successfully', LOG_MODULES.GATEWAY_SERVICE);
+            if (getGatewayDebugSetting()) {
+                logger.debug('Initialize handlers registered successfully', LOG_MODULES.GATEWAY_SERVICE);
+            }
         }
         catch (error) {
             logger.error('Failed to register initialize handlers:', error, LOG_MODULES.GATEWAY_SERVICE);
@@ -64,7 +77,9 @@ export class GatewayService {
         }
         try {
             registerResourcesHandlers(server);
-            logger.debug('Resources handlers registered successfully', LOG_MODULES.GATEWAY_SERVICE);
+            if (getGatewayDebugSetting()) {
+                logger.debug('Resources handlers registered successfully', LOG_MODULES.GATEWAY_SERVICE);
+            }
         }
         catch (error) {
             logger.error('Failed to register resources handlers:', error, LOG_MODULES.GATEWAY_SERVICE);
@@ -72,7 +87,9 @@ export class GatewayService {
         }
         try {
             registerSystemToolsHandlers(server);
-            logger.debug('System tools handlers registered successfully', LOG_MODULES.GATEWAY_SERVICE);
+            if (getGatewayDebugSetting()) {
+                logger.debug('System tools handlers registered successfully', LOG_MODULES.GATEWAY_SERVICE);
+            }
         }
         catch (error) {
             logger.error('Failed to register system tools handlers:', error, LOG_MODULES.GATEWAY_SERVICE);
@@ -80,13 +97,17 @@ export class GatewayService {
         }
         try {
             registerCallToolHandler(server, toolMap);
-            logger.debug('Call tool handler registered successfully', LOG_MODULES.GATEWAY_SERVICE);
+            if (getGatewayDebugSetting()) {
+                logger.debug('Call tool handler registered successfully', LOG_MODULES.GATEWAY_SERVICE);
+            }
         }
         catch (error) {
             logger.error('Failed to register call tool handler:', error, LOG_MODULES.GATEWAY_SERVICE);
             throw error;
         }
-        logger.debug('All handlers registered successfully', LOG_MODULES.GATEWAY_SERVICE);
+        if (getGatewayDebugSetting()) {
+            logger.debug('All handlers registered successfully', LOG_MODULES.GATEWAY_SERVICE);
+        }
     }
     /**
      * Generates a unified list of gateway tools with proper naming and collision resolution.

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

@@ -1 +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;AAMnG;;;;;;GAMG;AACH,wBAAsB,sBAAsB;;;GA+D3C"}
+{"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;AAUnG;;;;;;GAMG;AACH,wBAAsB,sBAAsB;;;GAqE3C"}

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

@@ -7,7 +7,7 @@
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { gateway } from './gateway.service.js';
 import { logger, LOG_MODULES } from '../../utils/logger/index.js';
-import { stringifyForLogging, getMcpCommDebugSetting } from '../../utils/json-utils.js';
+import { stringifyForLogging, getMcpCommDebugSetting, getGatewayDebugSetting } from '../../utils/json-utils.js';
 import { formatMcpMessageForLogging, logNotificationMessage } from '../../utils/logger/log-output.js';
 /**
  * Creates a new MCP transport and server instance for a single request session.
@@ -21,14 +21,16 @@ export async function createSessionTransport() {
     const server = gateway.createConnectionServer();
     // Set up message logging (use empty string for sessionId in per-request mode)
     transport.onmessage = (message) => {
-        logger.debug(`Session transport onmessage called with: ${stringifyForLogging(message)}`, LOG_MODULES.GATEWAY);
         try {
             if (getMcpCommDebugSetting()) {
+                logger.debug(`Session transport onmessage called with: ${stringifyForLogging(message)}`, LOG_MODULES.COMMUNICATION);
                 const logMessage = formatMcpMessageForLogging(message);
                 logger.debug(`MCP message received: ${logMessage}`, LOG_MODULES.COMMUNICATION);
             }
             logNotificationMessage(message, ''); // Empty sessionId for per-request
-            logger.debug(`Session transport onmessage completed successfully`, LOG_MODULES.GATEWAY);
+            if (getGatewayDebugSetting()) {
+                logger.debug(`Session transport onmessage completed successfully`, LOG_MODULES.GATEWAY);
+            }
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -51,10 +53,14 @@ export async function createSessionTransport() {
         };
     }
     // Connect server to transport
-    logger.debug('About to connect session server to transport', LOG_MODULES.GATEWAY);
+    if (getGatewayDebugSetting()) {
+        logger.debug('About to connect session server to transport', LOG_MODULES.GATEWAY);
+    }
     try {
         await server.connect(transport);
-        logger.info('MCP session transport initialized (per-request mode)', LOG_MODULES.GATEWAY);
+        if (getGatewayDebugSetting()) {
+            logger.debug('MCP session transport initialized (per-request mode)', LOG_MODULES.GATEWAY);
+        }
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);