@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

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 { getSessionCwd } 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 = getSessionCwd();
-            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

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

@@ -1 +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"}
+{"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,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,cAAc,2BAA2B,CAAC"}

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

@@ -2,7 +2,7 @@
  * 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';

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

@@ -1,7 +1,4 @@
-/**
- * Initialize and ping request handlers for Gateway service.
- */
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 /**
  * Register initialize and ping handlers on the MCP server.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"initialize-handler.d.ts","sourceRoot":"","sources":["../../../../../../src/services/gateway/request-handlers/initialize-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAOzE;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA8HlE"}
+{"version":3,"file":"initialize-handler.d.ts","sourceRoot":"","sources":["../../../../../../src/services/gateway/request-handlers/initialize-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAWpE;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA+DlE"}

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

@@ -1,76 +1,28 @@
-/**
- * Initialize and ping request handlers for Gateway service.
- */
-import { z } from 'zod';
-import { logger, LOG_MODULES } from '../../../utils/index.js';
-import { getSessionContext } from '../../../utils/request-context.js';
-import { sessionTrackerService } from '../../session-tracker.service.js';
+import { logger, LOG_MODULES } from '../../../utils/logger/index.js';
 import { MCP_HUB_LITE_SERVER } from '../../../models/system-tools.constants.js';
+import { getAppVersion, getProtocolVersion } from '../../../utils/version.js';
+import { InitializedNotificationSchema, InitializeRequestSchema, PingRequestSchema } from './initialize.constants.js';
 /**
  * Register initialize and ping handlers on the MCP server.
  *
  * @param server - MCP server instance to register handlers on
  */
 export function registerInitializeHandlers(server) {
-    // MCP standard initialize handler
-    const InitializeRequestSchema = z.object({
-        method: z.literal('initialize'),
-        params: z
-            .object({
-            clientInfo: z
-                .object({
-                name: z.string(),
-                version: z.string(),
-                mcpVersion: z.string().optional()
-            })
-                .optional(),
-            capabilities: z
-                .object({
-                tools: z
-                    .object({
-                    list: z.boolean().optional(),
-                    execute: z.boolean().optional()
-                })
-                    .optional(),
-                roots: z
-                    .object({
-                    list: z.boolean().optional()
-                })
-                    .optional(),
-                experimental: z.record(z.string(), z.any()).optional()
-            })
-                .optional(),
-            protocolVersion: z.string().optional()
-        })
-            .optional(),
-        id: z.union([z.string(), z.number()]),
-        jsonrpc: z.literal('2.0')
-    });
     server.server.setRequestHandler(InitializeRequestSchema, async (request) => {
-        // Capture session info
-        const context = getSessionContext();
-        if (context && request.params?.clientInfo) {
+        if (request.params?.clientInfo) {
             const { name, version } = request.params.clientInfo;
+            const protocolVersion = request.params?.protocolVersion || getProtocolVersion();
             const clientCapabilities = request.params?.capabilities;
-            logger.info(`Initialized client: ${name} v${version} (ID: ${context.sessionId})`, LOG_MODULES.GATEWAY);
+            logger.debug(`Initialized client: Name=${name}, Version=${version}, ProtocolVersion=${protocolVersion}`, LOG_MODULES.GATEWAY);
             if (clientCapabilities?.roots) {
                 logger.debug(`Client ${name} supports roots capability`, LOG_MODULES.GATEWAY);
             }
-            // Update session info in tracker with capabilities
-            sessionTrackerService.updateSession({
-                ...context,
-                clientName: name,
-                clientVersion: version,
-                protocolVersion: request.params?.protocolVersion,
-                capabilities: clientCapabilities
-            });
         }
         return {
-            protocolVersion: '2024-11-05',
+            protocolVersion: getProtocolVersion(),
             serverInfo: {
                 name: MCP_HUB_LITE_SERVER,
-                version: '1.0.0',
-                mcpVersion: '2024-11-05'
+                version: getAppVersion()
             },
             capabilities: {
                 tools: {
@@ -85,33 +37,21 @@ export function registerInitializeHandlers(server) {
             }
         };
     });
-    // MCP standard ping handler
-    const PingRequestSchema = z.object({
-        method: z.literal('ping'),
-        params: z.object({}).optional(),
-        id: z.union([z.string(), z.number()]),
-        jsonrpc: z.literal('2.0')
-    });
     server.server.setRequestHandler(PingRequestSchema, async () => {
-        return { pong: true }; // Response format compliant with MCP specification
-    });
-    // MCP initialized notification handler
-    const InitializedNotificationSchema = z.object({
-        method: z.literal('notifications/initialized'),
-        params: z.any().optional(),
-        jsonrpc: z.literal('2.0')
+        return { pong: true };
     });
-    server.server.setNotificationHandler(InitializedNotificationSchema, async () => {
-        const context = getSessionContext();
-        if (!context) {
-            logger.warn('Received initialized notification but no session context available', LOG_MODULES.GATEWAY);
-            return;
+    server.server.setNotificationHandler(InitializedNotificationSchema, async (notification) => {
+        logger.debug('Received initialized notification from client', LOG_MODULES.GATEWAY);
+        logger.debug(`Initialized notification details: ${JSON.stringify(notification)}`, LOG_MODULES.GATEWAY);
+        try {
+            // Process the notification
+            logger.debug('Successfully processed initialized notification', LOG_MODULES.GATEWAY);
         }
-        const sessionInfo = sessionTrackerService.getSession(context.sessionId);
-        if (!sessionInfo) {
-            logger.warn(`Received initialized notification but no session info for session ${context.sessionId}`, LOG_MODULES.GATEWAY);
-            return;
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`Error processing initialized notification: ${errorMessage}`, LOG_MODULES.GATEWAY);
+            logger.error(`Notification that caused error: ${JSON.stringify(notification)}`, LOG_MODULES.GATEWAY);
+            throw error; // Re-throw to see if this is the source of the problem
         }
-        logger.debug(`Received initialized notification from client ${sessionInfo.clientName || 'unknown'} (${context.sessionId})`, LOG_MODULES.GATEWAY);
     });
 }

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

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+export declare const InitializeRequestSchema: z.ZodObject<{
+    method: z.ZodLiteral<"initialize">;
+    params: z.ZodOptional<z.ZodObject<{
+        clientInfo: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strip>>;
+        capabilities: z.ZodOptional<z.ZodObject<{
+            tools: z.ZodOptional<z.ZodObject<{
+                list: z.ZodOptional<z.ZodBoolean>;
+                execute: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            roots: z.ZodOptional<z.ZodObject<{
+                list: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            experimental: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$strip>>;
+        protocolVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+}, z.core.$strip>;
+export declare const PingRequestSchema: z.ZodObject<{
+    method: z.ZodLiteral<"ping">;
+    params: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+}, z.core.$strip>;
+export declare const InitializedNotificationSchema: z.ZodObject<{
+    method: z.ZodLiteral<"notifications/initialized">;
+    params: z.ZodOptional<z.ZodAny>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+}, z.core.$strip>;
+//# sourceMappingURL=initialize.constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"initialize.constants.d.ts","sourceRoot":"","sources":["../../../../../../src/services/gateway/request-handlers/initialize.constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;iBA+BlC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;iBAIxC,CAAC"}

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

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export const InitializeRequestSchema = z.object({
+    method: z.literal('initialize'),
+    params: z
+        .object({
+        clientInfo: z
+            .object({
+            name: z.string(),
+            version: z.string()
+        })
+            .optional(),
+        capabilities: z
+            .object({
+            tools: z
+                .object({
+                list: z.boolean().optional(),
+                execute: z.boolean().optional()
+            })
+                .optional(),
+            roots: z
+                .object({
+                list: z.boolean().optional()
+            })
+                .optional(),
+            experimental: z.record(z.string(), z.any()).optional()
+        })
+            .optional(),
+        protocolVersion: z.string().optional()
+    })
+        .optional(),
+    id: z.union([z.string(), z.number()]),
+    jsonrpc: z.literal('2.0')
+});
+export const PingRequestSchema = z.object({
+    method: z.literal('ping'),
+    params: z.object({}).optional(),
+    id: z.union([z.string(), z.number()]),
+    jsonrpc: z.literal('2.0')
+});
+export const InitializedNotificationSchema = z.object({
+    method: z.literal('notifications/initialized'),
+    params: z.any().optional(),
+    jsonrpc: z.literal('2.0')
+});

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

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

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

@@ -3,6 +3,7 @@
  */
 import { ListResourcesRequestSchema, ReadResourceRequestSchema, McpError } from '@modelcontextprotocol/sdk/types.js';
 import { logger } from '../../../utils/index.js';
+import { LOG_MODULES } from '../../../utils/logger/log-modules.js';
 import { stringifyForLogging } from '../../../utils/json-utils.js';
 import { hubToolsService } from '../../hub-tools.service.js';
 /**
@@ -18,11 +19,11 @@ export function registerResourcesHandlers(server) {
         }
         catch (error) {
             if (error instanceof Error) {
-                logger.error(`List resources error:`, error);
+                logger.error(`List resources error:`, error, LOG_MODULES.RESOURCES_HANDLER);
                 throw new McpError(-32802, error.message);
             }
             else {
-                logger.error(`List resources error:`, error);
+                logger.error(`List resources error:`, error, LOG_MODULES.RESOURCES_HANDLER);
                 throw new McpError(-32802, String(error));
             }
         }
@@ -44,11 +45,11 @@ export function registerResourcesHandlers(server) {
         }
         catch (error) {
             if (error instanceof Error) {
-                logger.error(`Read resource error:`, error);
+                logger.error(`Read resource error:`, error, LOG_MODULES.RESOURCES_HANDLER);
                 throw new McpError(-32802, error.message);
             }
             else {
-                logger.error(`Read resource error:`, error);
+                logger.error(`Read resource error:`, error, LOG_MODULES.RESOURCES_HANDLER);
                 throw new McpError(-32802, String(error));
             }
         }

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

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

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

@@ -4,9 +4,9 @@
 import { z } from 'zod';
 import { McpError } from '@modelcontextprotocol/sdk/types.js';
 import { logger } from '../../../utils/index.js';
-import { getSessionCwd } from '../../../utils/request-context.js';
+import { LOG_MODULES } from '../../../utils/logger/log-modules.js';
 import { hubToolsService } from '../../hub-tools.service.js';
-import { LIST_SERVERS_TOOL, FIND_SERVERS_TOOL, LIST_ALL_TOOLS_IN_SERVER_TOOL, FIND_TOOLS_IN_SERVER_TOOL, GET_TOOL_TOOL, CALL_TOOL_TOOL, FIND_TOOLS_TOOL } from '../../../models/system-tools.constants.js';
+import { LIST_SERVERS_TOOL, LIST_TOOLS_IN_SERVER_TOOL, GET_TOOL_TOOL, CALL_TOOL_TOOL, UPDATE_SERVER_DESCRIPTION_TOOL } from '../../../models/system-tools.constants.js';
 /**
  * Register system tools handlers on the MCP server.
  *
@@ -24,63 +24,11 @@ export function registerSystemToolsHandlers(server) {
         const servers = await hubToolsService.listServers();
         return { servers };
     });
-    // Find servers
-    const FindServersRequestSchema = z.object({
-        method: z.literal(FIND_SERVERS_TOOL),
-        params: z.object({
-            pattern: z.string(),
-            searchIn: z.enum(['name', 'description', 'both']).optional().default('both'),
-            caseSensitive: z.boolean().optional().default(false)
-        }),
-        id: z.union([z.string(), z.number()]),
-        jsonrpc: z.literal('2.0')
-    });
-    server.server.setRequestHandler(FindServersRequestSchema, async (request) => {
-        const servers = await hubToolsService.findServers(request.params);
-        return { servers };
-    });
     // List all tools in a specific server
-    const ListAllToolsInServerRequestSchema = z.object({
-        method: z.literal(LIST_ALL_TOOLS_IN_SERVER_TOOL),
-        params: z.object({
-            serverName: z.string(),
-            requestOptions: z
-                .object({
-                sessionId: z
-                    .union([z.string(), z.null()])
-                    .optional()
-                    .transform((val) => val ?? undefined),
-                tags: z.record(z.string(), z.string()).optional()
-            })
-                .optional()
-        }),
-        id: z.union([z.string(), z.number()]),
-        jsonrpc: z.literal('2.0')
-    });
-    server.server.setRequestHandler(ListAllToolsInServerRequestSchema, async (request) => {
-        try {
-            const result = await hubToolsService.listAllToolsInServer(request.params);
-            return result;
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                logger.error(`List tools in server error:`, error);
-                throw new McpError(-32802, error.message);
-            }
-            else {
-                logger.error(`List tools in server error:`, error);
-                throw new McpError(-32802, String(error));
-            }
-        }
-    });
-    // Find tools in a specific server
-    const FindToolsInServerRequestSchema = z.object({
-        method: z.literal(FIND_TOOLS_IN_SERVER_TOOL),
+    const ListToolsInServerRequestSchema = z.object({
+        method: z.literal(LIST_TOOLS_IN_SERVER_TOOL),
         params: z.object({
             serverName: z.string(),
-            pattern: z.string(),
-            searchIn: z.enum(['name', 'description', 'both']).optional().default('both'),
-            caseSensitive: z.boolean().optional().default(false),
             requestOptions: z
                 .object({
                 sessionId: z
@@ -94,18 +42,18 @@ export function registerSystemToolsHandlers(server) {
         id: z.union([z.string(), z.number()]),
         jsonrpc: z.literal('2.0')
     });
-    server.server.setRequestHandler(FindToolsInServerRequestSchema, async (request) => {
+    server.server.setRequestHandler(ListToolsInServerRequestSchema, async (request) => {
         try {
-            const result = await hubToolsService.findToolsInServer(request.params);
+            const result = await hubToolsService.listToolsInServer(request.params);
             return result;
         }
         catch (error) {
             if (error instanceof Error) {
-                logger.error(`Find tools in server error:`, error);
+                logger.error(`List tools in server error:`, error, LOG_MODULES.SYSTEM_TOOLS_HANDLER);
                 throw new McpError(-32802, error.message);
             }
             else {
-                logger.error(`Find tools in server error:`, error);
+                logger.error(`List tools in server error:`, error, LOG_MODULES.SYSTEM_TOOLS_HANDLER);
                 throw new McpError(-32802, String(error));
             }
         }
@@ -138,7 +86,7 @@ export function registerSystemToolsHandlers(server) {
             return { tool };
         }
         catch (error) {
-            logger.error(`Get tool error:`, error);
+            logger.error(`Get tool error:`, error, LOG_MODULES.SYSTEM_TOOLS_HANDLER);
             if (error instanceof McpError) {
                 throw error;
             }
@@ -173,12 +121,6 @@ export function registerSystemToolsHandlers(server) {
     server.server.setRequestHandler(CallToolDirectRequestSchema, async (request) => {
         try {
             const params = { ...request.params };
-            // Inject CWD if available and not present in args
-            const cwd = getSessionCwd();
-            if (cwd && !params.toolArgs.cwd) {
-                params.toolArgs.cwd = cwd;
-                logger.debug(`Injected CWD into direct tool call: ${cwd}`);
-            }
             const result = await hubToolsService.callTool(params);
             // Wrap the result in a valid CallToolResult structure
             if (typeof result === 'object' && result !== null) {
@@ -199,7 +141,7 @@ export function registerSystemToolsHandlers(server) {
             }
         }
         catch (error) {
-            logger.error(`Call tool error:`, error);
+            logger.error(`Call tool error:`, error, LOG_MODULES.SYSTEM_TOOLS_HANDLER);
             if (error instanceof McpError) {
                 throw error;
             }
@@ -222,19 +164,32 @@ export function registerSystemToolsHandlers(server) {
         const allTools = await hubToolsService.listAllTools();
         return allTools;
     });
-    // Find tools across all servers
-    const FindToolsRequestSchema = z.object({
-        method: z.literal(FIND_TOOLS_TOOL),
+    // Update server description
+    const UpdateServerDescriptionRequestSchema = z.object({
+        method: z.literal(UPDATE_SERVER_DESCRIPTION_TOOL),
         params: z.object({
-            pattern: z.string(),
-            searchIn: z.enum(['name', 'description', 'both']).optional().default('both'),
-            caseSensitive: z.boolean().optional().default(false)
+            serverName: z.string(),
+            description: z.string()
         }),
         id: z.union([z.string(), z.number()]),
         jsonrpc: z.literal('2.0')
     });
-    server.server.setRequestHandler(FindToolsRequestSchema, async (request) => {
-        const tools = await hubToolsService.findTools(request.params);
-        return tools;
+    server.server.setRequestHandler(UpdateServerDescriptionRequestSchema, async (request) => {
+        try {
+            const result = await hubToolsService.updateServerDescription(request.params);
+            return result;
+        }
+        catch (error) {
+            logger.error(`Update server description error:`, error, LOG_MODULES.SYSTEM_TOOLS_HANDLER);
+            if (error instanceof McpError) {
+                throw error;
+            }
+            else if (error instanceof Error) {
+                throw new McpError(-32802, error.message);
+            }
+            else {
+                throw new McpError(-32802, String(error));
+            }
+        }
     });
 }

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

@@ -1 +1 @@
-{"version":3,"file":"tool-list-generator.d.ts","sourceRoot":"","sources":["../../../../../src/services/gateway/tool-list-generator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,KAAK,CAAC,WAAW,CAAC,CA4G/F"}
+{"version":3,"file":"tool-list-generator.d.ts","sourceRoot":"","sources":["../../../../../src/services/gateway/tool-list-generator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,KAAK,CAAC,WAAW,CAAC,CAkI/F"}