@loop_ouroboros/mcp-hub-lite 1.0.0

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

@@ -0,0 +1,11 @@
+/**
+ * Initialize and ping request handlers for Gateway service.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register initialize and ping handlers on the MCP server.
+ *
+ * @param server - MCP server instance to register handlers on
+ */
+export declare function registerInitializeHandlers(server: McpServer): void;
+//# sourceMappingURL=initialize-handler.d.ts.map

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

@@ -0,0 +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;AAMzE;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA+ElE"}

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

@@ -0,0 +1,85 @@
+/**
+ * Initialize and ping request handlers for Gateway service.
+ */
+import { z } from 'zod';
+import { logger, LOG_MODULES } from '../../../utils/index.js';
+import { getClientContext } from '../../../utils/request-context.js';
+import { clientTrackerService } from '../../client-tracker.service.js';
+import { MCP_HUB_LITE_SERVER } from '../../../models/system-tools.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(),
+                experimental: z.record(z.string(), z.any()).optional()
+            })
+                .optional()
+        })
+            .optional(),
+        id: z.union([z.string(), z.number()]),
+        jsonrpc: z.literal('2.0')
+    });
+    server.server.setRequestHandler(InitializeRequestSchema, async (request) => {
+        // Capture client info
+        const context = getClientContext();
+        if (context && request.params?.clientInfo) {
+            const { name, version } = request.params.clientInfo;
+            logger.info(`Initialized client: ${name} v${version} (ID: ${context.sessionId})`, LOG_MODULES.GATEWAY);
+            // Update client info in tracker
+            clientTrackerService.updateClient({
+                ...context,
+                clientName: name
+            });
+        }
+        return {
+            protocolVersion: '2024-11-05',
+            serverInfo: {
+                name: MCP_HUB_LITE_SERVER,
+                version: '1.0.0',
+                mcpVersion: '2024-11-05'
+            },
+            capabilities: {
+                tools: {
+                    list: true,
+                    execute: true
+                },
+                resources: {
+                    list: true,
+                    read: true
+                },
+                experimental: {}
+            }
+        };
+    });
+    // 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
+    });
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Resources-related request handlers for Gateway service.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register resources-related handlers on the MCP server.
+ *
+ * @param server - MCP server instance to register handlers on
+ */
+export declare function registerResourcesHandlers(server: McpServer): void;
+//# sourceMappingURL=resources-handler.d.ts.map

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

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

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

@@ -0,0 +1,56 @@
+/**
+ * Resources-related request handlers for Gateway service.
+ */
+import { ListResourcesRequestSchema, ReadResourceRequestSchema, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { logger } from '../../../utils/index.js';
+import { stringifyForLogging } from '../../../utils/json-utils.js';
+import { hubToolsService } from '../../hub-tools.service.js';
+/**
+ * Register resources-related handlers on the MCP server.
+ *
+ * @param server - MCP server instance to register handlers on
+ */
+export function registerResourcesHandlers(server) {
+    server.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        try {
+            const resources = await hubToolsService.listResources();
+            return { resources };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logger.error(`List resources error:`, error);
+                throw new McpError(-32802, error.message);
+            }
+            else {
+                logger.error(`List resources error:`, error);
+                throw new McpError(-32802, String(error));
+            }
+        }
+    });
+    server.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        try {
+            const { uri } = request.params;
+            const content = await hubToolsService.readResource(uri);
+            // Convert to official MCP format: contents array with required uri field
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: 'application/json',
+                        text: typeof content === 'string' ? content : stringifyForLogging(content)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logger.error(`Read resource error:`, error);
+                throw new McpError(-32802, error.message);
+            }
+            else {
+                logger.error(`Read resource error:`, error);
+                throw new McpError(-32802, String(error));
+            }
+        }
+    });
+}

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

@@ -0,0 +1,11 @@
+/**
+ * System tools request handlers for Gateway service.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register system tools handlers on the MCP server.
+ *
+ * @param server - MCP server instance to register handlers on
+ */
+export declare function registerSystemToolsHandlers(server: McpServer): void;
+//# sourceMappingURL=system-tools-handler.d.ts.map

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

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

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

@@ -0,0 +1,228 @@
+/**
+ * System tools request handlers for Gateway service.
+ */
+import { z } from 'zod';
+import { McpError } from '@modelcontextprotocol/sdk/types.js';
+import { logger } from '../../../utils/index.js';
+import { getClientCwd } from '../../../utils/request-context.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';
+/**
+ * Register system tools handlers on the MCP server.
+ *
+ * @param server - MCP server instance to register handlers on
+ */
+export function registerSystemToolsHandlers(server) {
+    // List servers
+    const ListServersRequestSchema = z.object({
+        method: z.literal(LIST_SERVERS_TOOL),
+        params: z.object({}).optional(),
+        id: z.union([z.string(), z.number()]),
+        jsonrpc: z.literal('2.0')
+    });
+    server.server.setRequestHandler(ListServersRequestSchema, async () => {
+        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.string().optional(),
+                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),
+        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.string().optional(),
+                tags: z.record(z.string(), z.string()).optional()
+            })
+                .optional()
+        }),
+        id: z.union([z.string(), z.number()]),
+        jsonrpc: z.literal('2.0')
+    });
+    server.server.setRequestHandler(FindToolsInServerRequestSchema, async (request) => {
+        try {
+            const result = await hubToolsService.findToolsInServer(request.params);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logger.error(`Find tools in server error:`, error);
+                throw new McpError(-32802, error.message);
+            }
+            else {
+                logger.error(`Find tools in server error:`, error);
+                throw new McpError(-32802, String(error));
+            }
+        }
+    });
+    // Get tool
+    const GetToolRequestSchema = z.object({
+        method: z.literal(GET_TOOL_TOOL),
+        params: z.object({
+            serverName: z.string(),
+            toolName: z.string(),
+            requestOptions: z
+                .object({
+                sessionId: z.string().optional(),
+                tags: z.record(z.string(), z.string()).optional()
+            })
+                .optional()
+        }),
+        id: z.union([z.string(), z.number()]),
+        jsonrpc: z.literal('2.0')
+    });
+    server.server.setRequestHandler(GetToolRequestSchema, async (request) => {
+        try {
+            const tool = await hubToolsService.getTool(request.params);
+            if (!tool) {
+                throw new McpError(-32801, `Tool "${request.params.toolName}" not found on server "${request.params.serverName}"`);
+            }
+            return { tool };
+        }
+        catch (error) {
+            logger.error(`Get tool error:`, error);
+            if (error instanceof McpError) {
+                throw error;
+            }
+            else if (error instanceof Error) {
+                throw new McpError(-32802, error.message);
+            }
+            else {
+                throw new McpError(-32802, String(error));
+            }
+        }
+    });
+    // Call tool directly
+    const CallToolDirectRequestSchema = z.object({
+        method: z.literal(CALL_TOOL_TOOL),
+        params: z.object({
+            serverName: z.string(),
+            toolName: z.string(),
+            toolArgs: z.record(z.string(), z.unknown()),
+            requestOptions: z
+                .object({
+                sessionId: z.string().optional(),
+                tags: z.record(z.string(), z.string()).optional()
+            })
+                .optional()
+        }),
+        id: z.union([z.string(), z.number()]),
+        jsonrpc: z.literal('2.0')
+    });
+    server.server.setRequestHandler(CallToolDirectRequestSchema, async (request) => {
+        try {
+            const params = { ...request.params };
+            // Inject CWD if available and not present in args
+            const cwd = getClientCwd();
+            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) {
+                return {
+                    content: [],
+                    ...result
+                };
+            }
+            else {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: String(result)
+                        }
+                    ]
+                };
+            }
+        }
+        catch (error) {
+            logger.error(`Call tool error:`, error);
+            if (error instanceof McpError) {
+                throw error;
+            }
+            else if (error instanceof Error) {
+                throw new McpError(-32802, error.message);
+            }
+            else {
+                throw new McpError(-32802, String(error));
+            }
+        }
+    });
+    // List all tools from all servers
+    const ListAllToolsRequestSchema = z.object({
+        method: z.literal('list_all_tools'),
+        params: z.object({}).optional(),
+        id: z.union([z.string(), z.number()]),
+        jsonrpc: z.literal('2.0')
+    });
+    server.server.setRequestHandler(ListAllToolsRequestSchema, async () => {
+        const allTools = await hubToolsService.listAllTools();
+        return allTools;
+    });
+    // Find tools across all servers
+    const FindToolsRequestSchema = z.object({
+        method: z.literal(FIND_TOOLS_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(FindToolsRequestSchema, async (request) => {
+        const tools = await hubToolsService.findTools(request.params);
+        return tools;
+    });
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Tools-related request handlers for Gateway service.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register tools-related handlers on the MCP server.
+ *
+ * @param server - MCP server instance to register handlers on
+ */
+export declare function registerToolsHandlers(server: McpServer): void;
+//# sourceMappingURL=tools-handler.d.ts.map

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

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

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

@@ -0,0 +1,79 @@
+/**
+ * Tools-related request handlers for Gateway service.
+ */
+import { z } from 'zod';
+import { McpError } from '@modelcontextprotocol/sdk/types.js';
+import { logger } from '../../../utils/index.js';
+import { searchCoreService } from '../../search/search-core.service.js';
+import { hubManager } from '../../hub-manager.service.js';
+/**
+ * Register tools-related handlers on the MCP server.
+ *
+ * @param server - MCP server instance to register handlers on
+ */
+export function registerToolsHandlers(server) {
+    // Define search tool schema
+    const SearchToolsRequestSchema = z.object({
+        method: z.literal('tools/search'),
+        params: z
+            .object({
+            search: z.string().optional(),
+            filters: z
+                .object({
+                serverName: z.string().optional(),
+                tags: z.record(z.string(), z.string()).optional()
+            })
+                .optional(),
+            limit: z.number().int().positive().optional().default(50),
+            offset: z.number().int().nonnegative().optional().default(0)
+        })
+            .optional(),
+        id: z.union([z.string(), z.number()]),
+        jsonrpc: z.literal('2.0')
+    });
+    // Search tools handler
+    server.server.setRequestHandler(SearchToolsRequestSchema, async (request) => {
+        const { search = '', filters = {}, limit = 50, offset = 0 } = request.params || {};
+        try {
+            const searchOptions = {
+                mode: 'fuzzy',
+                limit,
+                offset,
+                filters: {}
+            };
+            if (filters.serverName) {
+                const serverInstances = hubManager.getServerInstanceByName(filters.serverName);
+                if (serverInstances.length > 0) {
+                    // Use the first instance's ID as filter condition
+                    searchOptions.filters.serverId = serverInstances[0].id;
+                }
+            }
+            if (filters.tags) {
+                searchOptions.filters.tags = filters.tags;
+            }
+            const results = await searchCoreService.search(search, searchOptions);
+            return {
+                results: results.map((r) => ({
+                    tool: r.tool,
+                    score: r.score
+                })),
+                pagination: {
+                    total: results.length,
+                    limit,
+                    offset,
+                    hasMore: results.length >= limit
+                }
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logger.error(`Search tools error:`, error);
+                throw new McpError(-32802, `Search failed: ${error.message}`);
+            }
+            else {
+                logger.error(`Search tools error:`, error);
+                throw new McpError(-32802, `Search failed: ${String(error)}`);
+            }
+        }
+    });
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Gateway tool list generator with collision resolution.
+ */
+import type { ToolMapEntry, GatewayTool } from './types.js';
+/**
+ * Generates a unified list of gateway tools with proper naming and collision resolution.
+ *
+ * This method creates a comprehensive tool list that includes both system tools and
+ * aggregated tools from all connected MCP servers. It implements sophisticated
+ * naming collision resolution by:
+ * - Adding server hash suffixes to non-unique tool names
+ * - Handling conflicts with system tool names
+ * - Ensuring names don't exceed 60 characters
+ * - Providing final uniqueness guarantees through counter suffixes
+ *
+ * The method also populates the provided toolMap with mappings from gateway tool names
+ * to actual server IDs and real tool names for efficient routing during tool execution.
+ *
+ * @param {Map<string, ToolMapEntry>} toolMap - Map to populate with gateway tool name to actual tool mappings
+ * @returns {Array<GatewayTool>} Array of gateway tools with resolved names and descriptions
+ */
+export declare function generateGatewayToolsList(toolMap: Map<string, ToolMapEntry>): Array<GatewayTool>;
+//# sourceMappingURL=tool-list-generator.d.ts.map

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

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

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

@@ -0,0 +1,115 @@
+/**
+ * Gateway tool list generator with collision resolution.
+ */
+import { logger } from '../../utils/index.js';
+import { mcpConnectionManager } from '../mcp-connection-manager.js';
+import { hubManager } from '../hub-manager.service.js';
+import { hubToolsService } from '../hub-tools.service.js';
+/**
+ * Generates a unified list of gateway tools with proper naming and collision resolution.
+ *
+ * This method creates a comprehensive tool list that includes both system tools and
+ * aggregated tools from all connected MCP servers. It implements sophisticated
+ * naming collision resolution by:
+ * - Adding server hash suffixes to non-unique tool names
+ * - Handling conflicts with system tool names
+ * - Ensuring names don't exceed 60 characters
+ * - Providing final uniqueness guarantees through counter suffixes
+ *
+ * The method also populates the provided toolMap with mappings from gateway tool names
+ * to actual server IDs and real tool names for efficient routing during tool execution.
+ *
+ * @param {Map<string, ToolMapEntry>} toolMap - Map to populate with gateway tool name to actual tool mappings
+ * @returns {Array<GatewayTool>} Array of gateway tools with resolved names and descriptions
+ */
+export function generateGatewayToolsList(toolMap) {
+    const gatewayTools = [];
+    toolMap.clear();
+    // Add system tools
+    const systemTools = hubToolsService.getSystemTools();
+    const usedNames = new Set();
+    for (const tool of systemTools) {
+        gatewayTools.push({
+            name: tool.name,
+            description: `[System] ${tool.description}`,
+            inputSchema: tool.inputSchema,
+            annotations: tool.annotations
+        });
+        usedNames.add(tool.name);
+    }
+    // First pass: Count tool name frequencies to determine uniqueness
+    const toolNameCounts = new Map();
+    // Iterate through toolCache to get all tools and their server IDs
+    for (const [serverId, tools] of mcpConnectionManager.toolCache.entries()) {
+        for (const tool of tools) {
+            const serverConfig = hubManager.getServerById(serverId);
+            if (serverConfig) {
+                if (serverConfig.config.allowedTools &&
+                    !serverConfig.config.allowedTools.includes(tool.name)) {
+                    continue;
+                }
+            }
+            toolNameCounts.set(tool.name, (toolNameCounts.get(tool.name) || 0) + 1);
+        }
+    }
+    // Second pass: Generate gateway tools with proper naming
+    for (const [serverId, tools] of mcpConnectionManager.toolCache.entries()) {
+        const serverConfig = hubManager.getServerById(serverId);
+        // Skip if server configuration not found
+        if (!serverConfig) {
+            logger.warn(`Server configuration not found for serverId: ${serverId}, skipping tools`);
+            continue;
+        }
+        for (const tool of tools) {
+            if (serverConfig.config.allowedTools &&
+                !serverConfig.config.allowedTools.includes(tool.name)) {
+                continue;
+            }
+            const serverName = serverConfig.name;
+            let gatewayToolName = tool.name;
+            const isUnique = toolNameCounts.get(tool.name) === 1;
+            const isSystemConflict = usedNames.has(tool.name);
+            // If tool name is not unique or conflicts with system tool, append server hash
+            if (!isUnique || isSystemConflict) {
+                // Get instance hash from serverConfig, use first 4 characters of serverId as default
+                const hash = serverConfig.instance?.hash || serverId.substring(0, 4);
+                gatewayToolName = `${tool.name}_${hash}`;
+            }
+            // Ensure name doesn't exceed 60 chars
+            if (gatewayToolName.length > 60) {
+                // Use first 4 characters of serverId as default hash
+                const hash = serverConfig.instance?.hash || serverId.substring(0, 4);
+                // Reserve space for hash and separator
+                const maxToolNameLen = 60 - hash.length - 1;
+                const truncatedToolName = tool.name.substring(0, maxToolNameLen);
+                gatewayToolName = `${truncatedToolName}_${hash}`;
+            }
+            // Final uniqueness check (in case of hash collision or previous renaming conflict)
+            let finalName = gatewayToolName;
+            let counter = 1;
+            while (usedNames.has(finalName)) {
+                const suffix = `_${counter}`;
+                if (gatewayToolName.length + suffix.length > 60) {
+                    const availableLen = 60 - suffix.length;
+                    finalName = gatewayToolName.substring(0, availableLen) + suffix;
+                }
+                else {
+                    finalName = gatewayToolName + suffix;
+                }
+                counter++;
+            }
+            gatewayToolName = finalName;
+            usedNames.add(gatewayToolName);
+            toolMap.set(gatewayToolName, {
+                serverId: serverId,
+                realToolName: tool.name
+            });
+            gatewayTools.push({
+                name: gatewayToolName,
+                description: `[From ${serverName}] ${tool.description || ''}`,
+                inputSchema: tool.inputSchema
+            });
+        }
+    }
+    return gatewayTools;
+}