@loop_ouroboros/mcp-hub-lite 1.0.0

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

@@ -0,0 +1,200 @@
+/**
+ * Event Bus Service
+ *
+ * Centralized event management system for decoupled communication between different modules
+ * throughout the MCP Hub Lite application. This service implements the publish-subscribe
+ * pattern to enable loose coupling between components while maintaining efficient
+ * event-driven architecture.
+ *
+ * The event bus handles various types of events including server status changes,
+ * connection state updates, tool registry changes, log entries, configuration updates,
+ * and system health notifications. It provides thread-safe operations with error
+ * handling for listener callbacks to prevent cascading failures.
+ *
+ * Usage scenarios:
+ * - Server management modules publish server lifecycle events
+ * - Connection managers notify about connection state changes
+ * - UI components subscribe to relevant events for real-time updates
+ * - Logging services broadcast log entries to interested parties
+ * - Configuration services announce configuration changes
+ *
+ * All public methods are safe to call from any part of the application, and the service
+ * automatically manages memory by cleaning up empty event type entries when all listeners
+ * are unsubscribed.
+ */
+export class EventBusService {
+    listeners = new Map();
+    /**
+     * Publishes an event to all subscribed listeners for the specified event type.
+     *
+     * This method notifies all registered listeners for the given event type by
+     * invoking their callback functions with the provided event data. Each listener
+     * is executed in a try-catch block to prevent errors in one listener from
+     * affecting other listeners or the publisher.
+     *
+     * @param {string} eventType - The type of event to publish (e.g., EventTypes.SERVER_CONNECTED)
+     * @param {EventData} data - The event payload data to be passed to all listeners
+     * @throws {Error} - Never throws; errors in listeners are caught and logged to console.error
+     *
+     * @example
+     * ```typescript
+     * eventBus.publish(EventTypes.SERVER_CONNECTED, { serverId: 'server-1', timestamp: Date.now() });
+     * ```
+     */
+    publish(eventType, data) {
+        const listeners = this.listeners.get(eventType);
+        if (listeners) {
+            listeners.forEach((listener) => {
+                try {
+                    listener(data);
+                }
+                catch (error) {
+                    console.error(`Error in event listener for type ${eventType}:`, error);
+                }
+            });
+        }
+    }
+    /**
+     * Subscribes a listener function to receive events of the specified type.
+     *
+     * Registers the provided listener callback to be invoked whenever an event
+     * of the specified type is published. Returns an unsubscribe function that
+     * can be called to remove the listener registration.
+     *
+     * The service automatically creates a new listener set for the event type
+     * if it doesn't already exist, ensuring safe concurrent access.
+     *
+     * @param {string} eventType - The event type to subscribe to (e.g., EventTypes.TOOLS_UPDATED)
+     * @param {(data: EventData) => void} listener - The callback function to invoke when the event is published
+     * @returns {() => void} A function that, when called, unsubscribes the listener from the event type
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = eventBus.subscribe(EventTypes.SERVER_DISCONNECTED, (data) => {
+     *   console.log('Server disconnected:', data.serverId);
+     * });
+     * // Later, to unsubscribe:
+     * unsubscribe();
+     * ```
+     */
+    subscribe(eventType, listener) {
+        if (!this.listeners.has(eventType)) {
+            this.listeners.set(eventType, new Set());
+        }
+        this.listeners.get(eventType).add(listener);
+        // Return unsubscribe function
+        return () => this.unsubscribe(eventType, listener);
+    }
+    /**
+     * Unsubscribes a listener from receiving events of the specified type.
+     *
+     * Removes the specified listener from the registry for the given event type.
+     * If this was the last listener for the event type, the entire event type
+     * entry is removed from the registry to free memory.
+     *
+     * This method is private and should only be called internally by the
+     * unsubscribe function returned by the subscribe method.
+     *
+     * @param {string} eventType - The event type to unsubscribe from
+     * @param {(data: EventData) => void} listener - The listener function to remove
+     * @access private
+     */
+    unsubscribe(eventType, listener) {
+        const listeners = this.listeners.get(eventType);
+        if (listeners) {
+            listeners.delete(listener);
+            // If the listeners for this event type are empty, remove the event type entry
+            if (listeners.size === 0) {
+                this.listeners.delete(eventType);
+            }
+        }
+    }
+    /**
+     * Unsubscribes all listeners from all event types.
+     *
+     * Clears the entire listener registry, effectively removing all subscriptions
+     * across all event types. This is typically used during application shutdown
+     * or when a complete reset of the event system is required.
+     *
+     * @returns {void}
+     *
+     * @example
+     * ```typescript
+     * // Clean up all event subscriptions before application shutdown
+     * eventBus.unsubscribeAll();
+     * ```
+     */
+    unsubscribeAll() {
+        this.listeners.clear();
+    }
+    /**
+     * Retrieves all currently registered event types that have active listeners.
+     *
+     * Returns an array of event type strings that currently have at least one
+     * subscribed listener. This can be useful for debugging, monitoring, or
+     * introspection purposes.
+     *
+     * @returns {string[]} Array of event type strings with active listeners
+     *
+     * @example
+     * ```typescript
+     * const activeEventTypes = eventBus.getEventTypes();
+     * console.log('Active event types:', activeEventTypes);
+     * ```
+     */
+    getEventTypes() {
+        return Array.from(this.listeners.keys());
+    }
+    /**
+     * Gets the number of active listeners subscribed to a specific event type.
+     *
+     * Returns the count of listener functions currently registered for the
+     * specified event type. Returns 0 if no listeners are registered for
+     * the event type or if the event type doesn't exist.
+     *
+     * @param {string} eventType - The event type to check listener count for
+     * @returns {number} The number of active listeners for the event type (0 if none)
+     *
+     * @example
+     * ```typescript
+     * const listenerCount = eventBus.getListenerCount(EventTypes.LOG_ENTRY);
+     * console.log(`There are ${listenerCount} listeners for log entries`);
+     * ```
+     */
+    getListenerCount(eventType) {
+        const listeners = this.listeners.get(eventType);
+        return listeners ? listeners.size : 0;
+    }
+}
+// Event type constants
+export const EventTypes = {
+    // Server status related events
+    SERVER_STATUS_CHANGE: 'server-status',
+    SERVER_CONNECTED: 'server-connected',
+    SERVER_DISCONNECTED: 'server-disconnected',
+    // Server management events
+    SERVER_ADDED: 'server-added',
+    SERVER_UPDATED: 'server-updated',
+    SERVER_DELETED: 'server-deleted',
+    SERVER_INSTANCE_ADDED: 'server-instance-added',
+    SERVER_INSTANCE_UPDATED: 'server-instance-updated',
+    SERVER_INSTANCE_DELETED: 'server-instance-deleted',
+    // Tool related events
+    TOOLS_UPDATED: 'tools',
+    TOOL_CALL_STARTED: 'tool-call-started',
+    TOOL_CALL_COMPLETED: 'tool-call-completed',
+    TOOL_CALL_ERROR: 'tool-call-error',
+    // Resource related events
+    RESOURCES_UPDATED: 'resources',
+    // Log related events
+    LOG_ENTRY: 'log',
+    LOGS_CLEARED: 'logs-cleared',
+    // System related events
+    SYSTEM_HEALTH: 'system-health',
+    CONFIGURATION_UPDATED: 'configuration-updated',
+    // Client related events
+    CLIENT_CONNECTED: 'client-connected',
+    CLIENT_DISCONNECTED: 'client-disconnected'
+};
+// Create global event bus instance
+export const eventBus = new EventBusService();

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

@@ -0,0 +1,61 @@
+/**
+ * MCP Gateway service that aggregates tools from multiple MCP servers and provides a unified interface.
+ *
+ * This service acts as the central hub for MCP (Model Context Protocol) communication,
+ * exposing both system tools and aggregated tools from connected MCP servers through
+ * a single stdio transport endpoint.
+ *
+ * This is a thin wrapper around modular handlers for better maintainability.
+ *
+ * @example
+ * ```typescript
+ * const gateway = new GatewayService();
+ * await gateway.start(); // Start on stdio transport
+ *
+ * // Or create connection server for HTTP transport
+ * const server = gateway.createConnectionServer();
+ * ```
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ToolMapEntry, GatewayTool } from './types.js';
+export declare class GatewayService {
+    private server;
+    private transport;
+    constructor();
+    private registerHandlers;
+    /**
+     * Generates a unified list of gateway tools with proper naming and collision resolution.
+     *
+     * @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
+     */
+    generateGatewayToolsList(toolMap: Map<string, ToolMapEntry>): Array<GatewayTool>;
+    /**
+     * Safely formats tool arguments for logging with circular reference handling and size limits.
+     *
+     * @param {unknown} args - Tool arguments to format
+     * @returns {string} Safe formatted string representation of the arguments
+     */
+    formatToolArgs(args: unknown): string;
+    /**
+     * Safely formats tool responses for logging with size limits.
+     *
+     * @param {unknown} response - Tool response to format
+     * @returns {string} Safe formatted string representation of the response
+     */
+    formatToolResponse(response: unknown): string;
+    /**
+     * Creates a new MCP server instance with all handlers registered for connection-based transports.
+     *
+     * @returns {McpServer} New MCP server instance with all handlers registered
+     */
+    createConnectionServer(): McpServer;
+    /**
+     * Starts the MCP gateway service on stdio transport.
+     *
+     * @returns {Promise<void>} Resolves when the gateway is successfully started on stdio
+     */
+    start(): Promise<void>;
+}
+export declare const gateway: GatewayService;
+//# sourceMappingURL=gateway.service.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,107 @@
+/**
+ * MCP Gateway service that aggregates tools from multiple MCP servers and provides a unified interface.
+ *
+ * This service acts as the central hub for MCP (Model Context Protocol) communication,
+ * exposing both system tools and aggregated tools from connected MCP servers through
+ * a single stdio transport endpoint.
+ *
+ * This is a thin wrapper around modular handlers for better maintainability.
+ *
+ * @example
+ * ```typescript
+ * const gateway = new GatewayService();
+ * await gateway.start(); // Start on stdio transport
+ *
+ * // Or create connection server for HTTP transport
+ * const server = gateway.createConnectionServer();
+ * ```
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { logger } from '../../utils/index.js';
+import { MCP_HUB_LITE_SERVER } from '../../models/system-tools.constants.js';
+import { registerInitializeHandlers, registerToolsHandlers, registerResourcesHandlers, registerSystemToolsHandlers, registerCallToolHandler } from './request-handlers/index.js';
+import { generateGatewayToolsList } from './tool-list-generator.js';
+import { formatToolArgs, formatToolResponse } from './log-formatter.js';
+export class GatewayService {
+    server;
+    transport = null;
+    constructor() {
+        this.server = new McpServer({
+            name: MCP_HUB_LITE_SERVER,
+            version: '1.0.0'
+        }, {
+            capabilities: {
+                tools: {},
+                resources: {} // Add resource capability support
+            }
+        });
+        // Call registerHandlers directly in constructor
+        this.registerHandlers(this.server);
+    }
+    registerHandlers(server) {
+        // Local toolMap for this connection
+        const toolMap = new Map();
+        registerInitializeHandlers(server);
+        registerToolsHandlers(server);
+        registerResourcesHandlers(server);
+        registerSystemToolsHandlers(server);
+        registerCallToolHandler(server, toolMap);
+    }
+    /**
+     * Generates a unified list of gateway tools with proper naming and collision resolution.
+     *
+     * @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
+     */
+    generateGatewayToolsList(toolMap) {
+        return generateGatewayToolsList(toolMap);
+    }
+    /**
+     * Safely formats tool arguments for logging with circular reference handling and size limits.
+     *
+     * @param {unknown} args - Tool arguments to format
+     * @returns {string} Safe formatted string representation of the arguments
+     */
+    formatToolArgs(args) {
+        return formatToolArgs(args);
+    }
+    /**
+     * Safely formats tool responses for logging with size limits.
+     *
+     * @param {unknown} response - Tool response to format
+     * @returns {string} Safe formatted string representation of the response
+     */
+    formatToolResponse(response) {
+        return formatToolResponse(response);
+    }
+    /**
+     * Creates a new MCP server instance with all handlers registered for connection-based transports.
+     *
+     * @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;
+    }
+    /**
+     * Starts the MCP gateway service on stdio transport.
+     *
+     * @returns {Promise<void>} Resolves when the gateway is successfully started on stdio
+     */
+    async start() {
+        this.transport = new StdioServerTransport();
+        await this.server.connect(this.transport);
+        logger.info('MCP Gateway started on stdio');
+    }
+}
+export const gateway = new GatewayService();

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

@@ -0,0 +1,8 @@
+/**
+ * Gateway service module index.
+ */
+export { GatewayService, gateway } from './gateway.service.js';
+export type { ToolMapEntry, GatewayTool } from './types.js';
+export { generateGatewayToolsList } from './tool-list-generator.js';
+export { formatToolArgs, formatToolResponse } from './log-formatter.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/gateway/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/D,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}

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

@@ -0,0 +1,6 @@
+/**
+ * Gateway service module index.
+ */
+export { GatewayService, gateway } from './gateway.service.js';
+export { generateGatewayToolsList } from './tool-list-generator.js';
+export { formatToolArgs, formatToolResponse } from './log-formatter.js';

package/dist/server/src/services/gateway/log-formatter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Log formatting utilities for Gateway service.
+ */
+/**
+ * Safely formats tool arguments for logging with circular reference handling and size limits.
+ *
+ * This method provides safe JSON serialization of tool arguments for logging purposes,
+ * handling circular references by replacing them with '[Circular Reference]' and
+ * truncating large strings and outputs to prevent log noise and performance issues.
+ *
+ * @param {unknown} args - Tool arguments to format
+ * @returns {string} Safe formatted string representation of the arguments
+ */
+export declare function formatToolArgs(args: unknown): string;
+/**
+ * Safely formats tool responses for logging with size limits.
+ *
+ * This method provides safe JSON serialization of tool responses for logging purposes,
+ * truncating large outputs to prevent log noise and performance issues while maintaining
+ * readability through pretty-printed JSON formatting.
+ *
+ * @param {unknown} response - Tool response to format
+ * @returns {string} Safe formatted string representation of the response
+ */
+export declare function formatToolResponse(response: unknown): string;
+//# sourceMappingURL=log-formatter.d.ts.map

package/dist/server/src/services/gateway/log-formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-formatter.d.ts","sourceRoot":"","sources":["../../../../../src/services/gateway/log-formatter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CA4BpD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,CAe5D"}

package/dist/server/src/services/gateway/log-formatter.js

@@ -0,0 +1,66 @@
+/**
+ * Log formatting utilities for Gateway service.
+ */
+import { stringifyForLogging, stringifyForLoggingWithReplacer } from '../../utils/json-utils.js';
+/**
+ * Safely formats tool arguments for logging with circular reference handling and size limits.
+ *
+ * This method provides safe JSON serialization of tool arguments for logging purposes,
+ * handling circular references by replacing them with '[Circular Reference]' and
+ * truncating large strings and outputs to prevent log noise and performance issues.
+ *
+ * @param {unknown} args - Tool arguments to format
+ * @returns {string} Safe formatted string representation of the arguments
+ */
+export function formatToolArgs(args) {
+    try {
+        const seen = new WeakSet();
+        const replacer = (_key, value) => {
+            if (typeof value === 'object' && value !== null) {
+                if (seen.has(value)) {
+                    return '[Circular Reference]';
+                }
+                seen.add(value);
+            }
+            // Limit string length and truncate large objects
+            if (typeof value === 'string' && value.length > 500) {
+                return value.substring(0, 500) + '... [truncated]';
+            }
+            return value;
+        };
+        const formatted = stringifyForLoggingWithReplacer(args, replacer);
+        // Limit total output length
+        if (formatted.length > 2000) {
+            return formatted.substring(0, 2000) + '... [truncated]';
+        }
+        return formatted;
+    }
+    catch (error) {
+        return ('[Error formatting args: ' + (error instanceof Error ? error.message : String(error)) + ']');
+    }
+}
+/**
+ * Safely formats tool responses for logging with size limits.
+ *
+ * This method provides safe JSON serialization of tool responses for logging purposes,
+ * truncating large outputs to prevent log noise and performance issues while maintaining
+ * readability through pretty-printed JSON formatting.
+ *
+ * @param {unknown} response - Tool response to format
+ * @returns {string} Safe formatted string representation of the response
+ */
+export function formatToolResponse(response) {
+    try {
+        const formatted = stringifyForLogging(response);
+        // Limit total output length
+        if (formatted.length > 2000) {
+            return formatted.substring(0, 2000) + '... [truncated]';
+        }
+        return formatted;
+    }
+    catch (error) {
+        return ('[Error formatting response: ' +
+            (error instanceof Error ? error.message : String(error)) +
+            ']');
+    }
+}

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

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

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

@@ -0,0 +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"}

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

@@ -0,0 +1,131 @@
+/**
+ * Call tool request handler for Gateway service.
+ */
+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';
+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';
+/**
+ * Register call tool handler on the MCP server.
+ *
+ * @param server - MCP server instance to register handlers on
+ * @param toolMap - Tool map for routing tool calls
+ */
+export function registerCallToolHandler(server, toolMap) {
+    // Original list tools handler (for compatibility)
+    server.server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const gatewayTools = generateGatewayToolsList(toolMap);
+        return {
+            tools: gatewayTools
+        };
+    });
+    // Original call tool handler (for compatibility)
+    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);
+                }
+            }
+        }
+        // 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);
+            }
+        }
+        const target = toolMap.get(toolName);
+        logger.debug(`Tool lookup SUCCESS: toolName=${toolName} -> serverId=${target?.serverId}, 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);
+            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);
+            // Wrap the result in a valid CallToolResult structure
+            if (typeof result === 'object' && result !== null) {
+                return {
+                    content: [],
+                    ...result
+                };
+            }
+            else {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: String(result)
+                        }
+                    ]
+                };
+            }
+        }
+        catch (error) {
+            ErrorHandler.handleToolCallError(target.serverId, target.realToolName, error);
+        }
+    });
+}

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

@@ -0,0 +1,9 @@
+/**
+ * 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';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/services/gateway/request-handlers/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC"}

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

@@ -0,0 +1,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';