@juspay/neurolink 4.1.1 → 4.2.0

package/dist/lib/mcp/tool-registry.js

@@ -4,43 +4,72 @@
  */
 import { MCPRegistry } from "./registry.js";
 import { registryLogger } from "./logging.js";
+import { randomUUID } from "crypto";
 export class MCPToolRegistry extends MCPRegistry {
     tools = new Map();
+    toolImpls = new Map(); // Store actual tool implementations
     toolExecutionStats = new Map();
     /**
      * Register a server with its tools (updated signature)
      */
-    async registerServer(serverId, serverConfig, context) {
-        registryLogger.info(`Registering server: ${serverId}`);
-        // Convert to DiscoveredMcp format for compatibility
-        const plugin = {
-            metadata: {
-                name: serverId,
-                description: typeof serverConfig === "object" && serverConfig
-                    ? serverConfig.description || "No description"
-                    : "No description",
-            },
-            tools: typeof serverConfig === "object" && serverConfig
-                ? serverConfig.tools
-                : {},
-            configuration: typeof serverConfig === "object" && serverConfig
-                ? serverConfig
-                : {},
-        };
+    async registerServer(serverOrId, serverConfig, context) {
+        let serverId;
+        let plugin;
+        if (typeof serverOrId === "string") {
+            // Original behavior: register by ID and config
+            serverId = serverOrId;
+            registryLogger.info(`Registering server by ID: ${serverId}`);
+            plugin = {
+                metadata: {
+                    name: serverId,
+                    description: typeof serverConfig === "object" && serverConfig
+                        ? serverConfig.description || "No description"
+                        : "No description",
+                },
+                tools: typeof serverConfig === "object" && serverConfig
+                    ? serverConfig.tools
+                    : {},
+                configuration: typeof serverConfig === "object" && serverConfig
+                    ? serverConfig
+                    : {},
+            };
+        }
+        else {
+            // New behavior: register server object
+            const server = serverOrId;
+            serverId = server.id || server.serverId || "unknown-server";
+            registryLogger.info(`Registering server object: ${serverId}`);
+            plugin = {
+                metadata: {
+                    name: serverId,
+                    description: server.description || server.title || "No description",
+                    category: server.category,
+                },
+                tools: server.tools || {},
+                configuration: server.configuration || {},
+            };
+        }
         // Call the parent register method
         this.register(plugin);
         // Extract tools from server info if available
         const tools = plugin.tools || {};
+        registryLogger.debug(`Registering ${Object.keys(tools).length} tools for server ${serverId}:`, Object.keys(tools));
         for (const [toolName, toolDef] of Object.entries(tools)) {
             const toolId = `${serverId}.${toolName}`;
-            this.tools.set(toolId, {
+            const toolInfo = {
                 name: toolName,
                 description: toolDef?.description,
                 inputSchema: toolDef?.inputSchema,
                 outputSchema: toolDef?.outputSchema,
                 serverId,
                 category: toolDef?.category || "general",
-            });
+                permissions: toolDef?.permissions || [],
+            };
+            // Register only with fully-qualified toolId to avoid collisions
+            this.tools.set(toolId, toolInfo);
+            // Store the actual tool implementation for execution using toolId as key
+            this.toolImpls.set(toolId, toolDef);
+            registryLogger.debug(`Registered tool '${toolName}' with execute function:`, typeof toolDef?.execute);
         }
     }
     /**
@@ -50,39 +79,148 @@ export class MCPToolRegistry extends MCPRegistry {
         const startTime = Date.now();
         try {
             registryLogger.info(`Executing tool: ${toolName}`);
+            // Try to find the tool by fully-qualified name first
+            let tool = this.tools.get(toolName);
+            // If not found, search for tool by name across all entries (for backward compatibility)
+            let toolId = toolName;
+            if (!tool) {
+                for (const [candidateToolId, toolInfo] of this.tools.entries()) {
+                    if (toolInfo.name === toolName) {
+                        tool = toolInfo;
+                        toolId = candidateToolId;
+                        break;
+                    }
+                }
+            }
+            if (!tool) {
+                throw new Error(`Tool '${toolName}' not found in registry`);
+            }
             // Create execution context if not provided
             const execContext = {
-                sessionId: context?.sessionId || crypto.randomUUID(),
+                sessionId: context?.sessionId || randomUUID(),
                 userId: context?.userId,
                 ...context,
             };
-            // Mock execution for now
+            // Get the tool implementation using the resolved toolId
+            const toolImpl = this.toolImpls.get(toolId);
+            registryLogger.debug(`Looking for tool '${toolName}' (toolId: '${toolId}'), found: ${!!toolImpl}, type: ${typeof toolImpl?.execute}`);
+            registryLogger.debug(`Available tools:`, Array.from(this.toolImpls.keys()));
+            if (!toolImpl || typeof toolImpl?.execute !== "function") {
+                throw new Error(`Tool '${toolName}' implementation not found or not executable`);
+            }
+            // Execute the actual tool
+            registryLogger.debug(`Executing tool '${toolName}' with args:`, args);
+            const toolResult = await toolImpl.execute(args, execContext);
+            // Add metadata to the tool result (don't double-wrap)
             const result = {
-                result: `Mock execution of ${toolName}`,
-                args,
-                context: execContext,
+                ...toolResult,
+                usage: {
+                    ...toolResult.usage,
+                    executionTime: Date.now() - startTime,
+                },
+                metadata: {
+                    ...toolResult.metadata,
+                    toolName,
+                    serverId: tool.serverId,
+                    sessionId: execContext.sessionId,
+                    executionTime: Date.now() - startTime,
+                },
             };
             // Update statistics
             const duration = Date.now() - startTime;
             this.updateStats(toolName, duration);
+            registryLogger.debug(`Tool '${toolName}' executed successfully in ${duration}ms`);
             return result;
         }
         catch (error) {
             registryLogger.error(`Tool execution failed: ${toolName}`, error);
-            throw error;
+            // Return error in ToolResult format
+            const errorResult = {
+                success: false,
+                data: null,
+                error: error instanceof Error ? error.message : String(error),
+                usage: {
+                    executionTime: Date.now() - startTime,
+                },
+                metadata: {
+                    toolName,
+                    sessionId: context?.sessionId,
+                },
+            };
+            return errorResult;
         }
     }
-    /**
-     * List all available tools (updated signature)
-     */
-    async listTools(context) {
-        return Array.from(this.tools.values());
+    async listTools(filterOrContext) {
+        // FIXED: Return unique tools (avoid duplicates from dual registration)
+        const uniqueTools = new Map();
+        for (const tool of this.tools.values()) {
+            const key = `${tool.serverId || "unknown"}.${tool.name}`;
+            if (!uniqueTools.has(key)) {
+                uniqueTools.set(key, tool);
+            }
+        }
+        let result = Array.from(uniqueTools.values());
+        // Determine if parameter is a filter object or just context
+        let filter;
+        if (filterOrContext) {
+            // Check if it's a filter object (has filter-specific properties) or just context
+            if ("sessionId" in filterOrContext || "userId" in filterOrContext) {
+                // It's an ExecutionContext, treat as no filter
+                filter = undefined;
+            }
+            else {
+                // It's a filter object
+                filter = filterOrContext;
+            }
+        }
+        // Apply filters if provided
+        if (filter) {
+            if (filter.category) {
+                result = result.filter((tool) => tool.category === filter.category);
+            }
+            if (filter.serverId) {
+                result = result.filter((tool) => tool.serverId === filter.serverId);
+            }
+            if (filter.serverCategory) {
+                result = result.filter((tool) => {
+                    const server = this.get(tool.serverId || "");
+                    return server?.metadata?.category === filter.serverCategory;
+                });
+            }
+            if (filter.permissions && filter.permissions.length > 0) {
+                result = result.filter((tool) => {
+                    const toolPermissions = tool.permissions || [];
+                    return filter.permissions.some((perm) => toolPermissions.includes(perm));
+                });
+            }
+        }
+        registryLogger.debug(`Listed ${result.length} unique tools (${filter ? "filtered" : "unfiltered"})`);
+        return result;
     }
     /**
-     * Get tool information
+     * Get tool information with server details
      */
     getToolInfo(toolName) {
-        return this.tools.get(toolName);
+        // Try to find the tool by fully-qualified name first
+        let tool = this.tools.get(toolName);
+        // If not found, search for tool by name across all entries (for backward compatibility)
+        if (!tool) {
+            for (const toolInfo of this.tools.values()) {
+                if (toolInfo.name === toolName) {
+                    tool = toolInfo;
+                    break;
+                }
+            }
+        }
+        if (!tool) {
+            return undefined;
+        }
+        return {
+            tool,
+            server: {
+                id: tool.serverId || "unknown-server",
+            },
+        };
     }
     /**
      * Update execution statistics
@@ -120,22 +258,52 @@ export class MCPToolRegistry extends MCPRegistry {
      * Get tools by category
      */
     getToolsByCategory(category) {
-        return Array.from(this.tools.values()).filter((tool) => tool.category === category);
+        // Return unique tools by fully-qualified toolId
+        const uniqueTools = new Map();
+        for (const [toolId, tool] of this.tools.entries()) {
+            if (tool.category === category && !uniqueTools.has(toolId)) {
+                uniqueTools.set(toolId, tool);
+            }
+        }
+        return Array.from(uniqueTools.values());
     }
     /**
      * Check if tool exists
      */
     hasTool(toolName) {
-        return this.tools.has(toolName);
+        // Check by fully-qualified name first, then fallback to any matching tool name
+        if (this.tools.has(toolName)) {
+            return true;
+        }
+        for (const tool of this.tools.values()) {
+            if (tool.name === toolName) {
+                return true;
+            }
+        }
+        return false;
     }
     /**
      * Remove a tool
      */
     removeTool(toolName) {
-        const removed = this.tools.delete(toolName);
-        if (removed) {
+        // Remove by fully-qualified name first, then fallback to any matching tool name
+        let removed = false;
+        if (this.tools.has(toolName)) {
+            this.tools.delete(toolName);
             this.toolExecutionStats.delete(toolName);
             registryLogger.info(`Removed tool: ${toolName}`);
+            removed = true;
+        }
+        else {
+            // Remove all tools with matching name
+            for (const [toolId, tool] of Array.from(this.tools.entries())) {
+                if (tool.name === toolName) {
+                    this.tools.delete(toolId);
+                    this.toolExecutionStats.delete(toolId);
+                    registryLogger.info(`Removed tool: ${toolId}`);
+                    removed = true;
+                }
+            }
         }
         return removed;
     }
@@ -146,10 +314,30 @@ export class MCPToolRegistry extends MCPRegistry {
         return this.tools.size;
     }
     /**
-     * Get statistics (alias for getExecutionStats)
+     * Get comprehensive statistics
      */
     getStats() {
-        return this.getExecutionStats();
+        const servers = this.list(); // Get all registered servers
+        const allTools = Array.from(this.tools.values());
+        // Count servers by category
+        const serversByCategory = {};
+        for (const server of servers) {
+            const category = server.metadata?.category || "uncategorized";
+            serversByCategory[category] = (serversByCategory[category] || 0) + 1;
+        }
+        // Count tools by category
+        const toolsByCategory = {};
+        for (const tool of allTools) {
+            const category = tool.category || "uncategorized";
+            toolsByCategory[category] = (toolsByCategory[category] || 0) + 1;
+        }
+        return {
+            totalServers: servers.length,
+            totalTools: allTools.length,
+            serversByCategory,
+            toolsByCategory,
+            executionStats: this.getExecutionStats(),
+        };
     }
     /**
      * Unregister a server

package/dist/lib/mcp/unified-mcp.d.ts

@@ -67,7 +67,12 @@ export declare class UnifiedMCPSystem {
     /**
      * Get tool information
      */
-    getToolInfo(toolName: string): import("./tool-registry.js").ToolInfo | undefined;
+    getToolInfo(toolName: string): {
+        tool: import("./tool-registry.js").ToolInfo;
+        server: {
+            id: string;
+        };
+    } | undefined;
     /**
      * Get registry instance
      */
@@ -116,7 +121,12 @@ export declare function listMCPTools(criteria?: any): Promise<import("./tool-reg
 /**
  * Get MCP tool information
  */
-export declare function getMCPToolInfo(toolName: string): import("./tool-registry.js").ToolInfo | undefined;
+export declare function getMCPToolInfo(toolName: string): {
+    tool: import("./tool-registry.js").ToolInfo;
+    server: {
+        id: string;
+    };
+} | undefined;
 /**
  * Get unified MCP system status
  */

package/dist/lib/mcp/unified-registry.d.ts

@@ -19,9 +19,13 @@ export declare class UnifiedMCPRegistry extends MCPToolRegistry {
     private activeConnections;
     constructor(errorManager?: ErrorManager);
     /**
-     * Initialize with auto-discovery
+     * Initialize with auto-discovery and manual config
      */
     initialize(options?: DiscoveryOptions): Promise<void>;
+    /**
+     * Load servers from .mcp-config.json
+     */
+    private loadManualConfig;
     /**
      * Enable or disable auto-discovery
      */
@@ -51,9 +55,13 @@ export declare class UnifiedMCPRegistry extends MCPToolRegistry {
      */
     listAllTools(): Promise<ToolInfo[]>;
     /**
-     * Execute a tool through the registry
+     * Execute a tool through the registry with fallback to direct MCP execution
      */
     executeTool<T = unknown>(toolName: string, args?: unknown, context?: ExecutionContext): Promise<T>;
+    /**
+     * Execute tool via direct MCP server connection (fallback)
+     */
+    private executeToolViaMCPServer;
     /**
      * Lazily activate a server by ID
      */
@@ -65,11 +73,17 @@ export declare class UnifiedMCPRegistry extends MCPToolRegistry {
     /**
      * Get registry statistics (override parent method)
      */
-    getStats(): Record<string, {
-        count: number;
-        averageTime: number;
-        totalTime: number;
-    }>;
+    getStats(): {
+        totalServers: number;
+        totalTools: number;
+        serversByCategory: Record<string, number>;
+        toolsByCategory: Record<string, number>;
+        executionStats: Record<string, {
+            count: number;
+            averageTime: number;
+            totalTime: number;
+        }>;
+    };
     /**
      * Get detailed registry statistics
      */

package/dist/lib/mcp/unified-registry.js

@@ -7,6 +7,8 @@ import { MCPToolRegistry, } from "./tool-registry.js";
 import { TransportManager, TransportConfigSchema, } from "./transport-manager.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { ErrorManager } from "./error-manager.js";
+import * as fs from "fs";
+import * as path from "path";
 /**
  * Unified registry combining multiple sources
  */
@@ -24,10 +26,12 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
         this.transportManager = new TransportManager(this.errorManager);
     }
     /**
-     * Initialize with auto-discovery
+     * Initialize with auto-discovery and manual config
      */
     async initialize(options = {}) {
         unifiedRegistryLogger.info("Initializing unified MCP registry...");
+        // Load manual configuration first
+        await this.loadManualConfig();
         if (this.autoDiscoveryEnabled) {
             const result = await autoRegisterMCPServers(options);
             unifiedRegistryLogger.info(`Auto-discovery complete: ${result.registered} registered, ${result.failed} failed`);
@@ -39,6 +43,58 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
             }
         }
     }
+    /**
+     * Load servers from .mcp-config.json
+     */
+    async loadManualConfig() {
+        const configPath = path.join(process.cwd(), ".mcp-config.json");
+        try {
+            await fs.promises.access(configPath, fs.constants.F_OK);
+        }
+        catch {
+            unifiedRegistryLogger.debug("No .mcp-config.json found");
+            return;
+        }
+        try {
+            const configContent = await fs.promises.readFile(configPath, "utf-8");
+            const config = JSON.parse(configContent);
+            if (!config.mcpServers) {
+                unifiedRegistryLogger.debug("No mcpServers section in config");
+                return;
+            }
+            unifiedRegistryLogger.info(`Loading ${Object.keys(config.mcpServers).length} servers from .mcp-config.json`);
+            for (const [serverId, serverConfig] of Object.entries(config.mcpServers)) {
+                try {
+                    // Convert server config to DiscoveredMCP format
+                    const discoveredMcp = {
+                        metadata: {
+                            name: serverId,
+                            version: "1.0.0",
+                            main: "index.js",
+                            engine: { neurolink: ">=4.0.0" },
+                            description: `MCP server: ${serverId}`,
+                            permissions: ["filesystem", "network"],
+                        },
+                        entryPath: serverConfig.command || "npx",
+                        source: "project",
+                        constructor: undefined,
+                    };
+                    // Register the server
+                    this.register(discoveredMcp);
+                    this.manualServers.set(serverId, serverConfig);
+                    this.availableServers.add(serverId);
+                    unifiedRegistryLogger.debug(`Registered manual server: ${serverId}`);
+                }
+                catch (error) {
+                    unifiedRegistryLogger.error(`Failed to register server ${serverId}:`, error instanceof Error ? error.message : String(error));
+                }
+            }
+            unifiedRegistryLogger.info(`Manual config loaded: ${this.manualServers.size} servers registered`);
+        }
+        catch (error) {
+            unifiedRegistryLogger.error("Failed to load manual config:", error instanceof Error ? error.message : String(error));
+        }
+    }
     /**
      * Enable or disable auto-discovery
      */
@@ -84,30 +140,136 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
      */
     async listAllTools() {
         const allTools = [];
-        const plugins = this.list();
+        try {
+            // FIXED: Get built-in tools from base registry
+            const builtInTools = await super.listTools();
+            allTools.push(...builtInTools.map((tool) => ({
+                ...tool,
+                id: tool.name,
+                serverId: tool.serverId || "built-in",
+                source: "built-in",
+                isExternal: false,
+            })));
+            unifiedRegistryLogger.debug(`Found ${builtInTools.length} built-in tools`);
+        }
+        catch (error) {
+            unifiedRegistryLogger.warn("Failed to get built-in tools:", error);
+        }
+        // FIXED: Get tools from external servers with proper error handling
+        // Use the internal plugin registry for accurate server listing
+        const plugins = Array.from(this.plugins.values());
+        const externalToolPromises = [];
         for (const plugin of plugins) {
-            try {
-                // Get tools from plugin metadata if available
-                const tools = await this.listTools();
-                allTools.push(...tools.map((tool) => ({
-                    ...tool,
-                    id: tool.name,
-                    serverId: tool.serverId || plugin.metadata.name,
-                    source: "unified",
-                })));
-            }
-            catch (error) {
-                unifiedRegistryLogger.warn(`Failed to get tools from ${plugin.metadata.name}:`, error);
+            if (plugin.metadata?.name &&
+                this.availableServers.has(plugin.metadata.name)) {
+                const connection = this.activeConnections.get(plugin.metadata.name);
+                if (connection) {
+                    externalToolPromises.push(connection
+                        .listTools()
+                        .then((response) => {
+                        const serverTools = response.tools || [];
+                        allTools.push(...serverTools.map((tool) => ({
+                            name: tool.name,
+                            description: tool.description,
+                            inputSchema: tool.inputSchema,
+                            serverId: plugin.metadata.name,
+                            id: `${plugin.metadata.name}.${tool.name}`,
+                            source: "external",
+                            isExternal: true,
+                        })));
+                        unifiedRegistryLogger.debug(`Found ${serverTools.length} tools from ${plugin.metadata.name}`);
+                    })
+                        .catch((error) => {
+                        unifiedRegistryLogger.warn(`Failed to get tools from ${plugin.metadata.name}:`, error);
+                    }));
+                }
             }
         }
+        await Promise.all(externalToolPromises);
+        unifiedRegistryLogger.info(`Total tools available: ${allTools.length}`);
         return allTools;
     }
     /**
-     * Execute a tool through the registry
+     * Execute a tool through the registry with fallback to direct MCP execution
      */
     async executeTool(toolName, args, context) {
         unifiedRegistryLogger.info(`Executing tool: ${toolName}`);
-        return super.executeTool(toolName, args, context);
+        // STEP 1: Try built-in tools first
+        try {
+            const result = await super.executeTool(toolName, args, context);
+            unifiedRegistryLogger.info(`Tool ${toolName} executed successfully via built-in registry`);
+            return result;
+        }
+        catch (builtInError) {
+            unifiedRegistryLogger.debug(`Built-in tool execution failed: ${builtInError.message}`);
+        }
+        // STEP 2: Try external MCP servers
+        try {
+            const result = await this.executeToolViaMCPServer(toolName, args, context);
+            unifiedRegistryLogger.info(`Tool ${toolName} executed successfully via external MCP server`);
+            return result;
+        }
+        catch (externalError) {
+            unifiedRegistryLogger.debug(`External MCP execution failed: ${externalError.message}`);
+        }
+        // STEP 3: Comprehensive error with available tools
+        const availableTools = await this.listAllTools();
+        const toolNames = availableTools.map((t) => t.name).join(", ");
+        const builtInTools = availableTools
+            .filter((t) => !t.isExternal)
+            .map((t) => t.name)
+            .join(", ");
+        const externalTools = availableTools
+            .filter((t) => t.isExternal)
+            .map((t) => `${t.serverId}.${t.name}`)
+            .join(", ");
+        const errorMessage = [
+            `Tool '${toolName}' not found in any registry.`,
+            `Available built-in tools: ${builtInTools || "none"}`,
+            `Available external tools: ${externalTools || "none"}`,
+            `Connected servers: ${Array.from(this.availableServers).join(", ") || "none"}`,
+        ].join("\n");
+        throw new Error(errorMessage);
+    }
+    /**
+     * Execute tool via direct MCP server connection (fallback)
+     */
+    async executeToolViaMCPServer(toolName, args, context) {
+        const configPath = path.join(process.cwd(), ".mcp-config.json");
+        if (!fs.existsSync(configPath)) {
+            throw new Error(`Tool '${toolName}' not found and no .mcp-config.json for fallback`);
+        }
+        const configContent = fs.readFileSync(configPath, "utf-8");
+        const config = JSON.parse(configContent);
+        if (!config.mcpServers) {
+            throw new Error(`Tool '${toolName}' not found and no servers configured`);
+        }
+        // Try each configured server
+        const errors = [];
+        for (const [serverId, serverConfig] of Object.entries(config.mcpServers)) {
+            try {
+                unifiedRegistryLogger.debug(`Trying tool ${toolName} on server ${serverId}`);
+                // Import the executeMCPTool function
+                const { executeMCPTool } = await import("../../cli/commands/mcp.js");
+                const result = await executeMCPTool(serverConfig, toolName, args || {});
+                // Convert to ToolResult format
+                const toolResult = {
+                    success: true,
+                    data: result,
+                    metadata: { toolName, serverId, sessionId: context?.sessionId },
+                };
+                unifiedRegistryLogger.info(`Tool ${toolName} executed successfully via server ${serverId}`);
+                return toolResult;
+            }
+            catch (serverError) {
+                const errorMsg = serverError instanceof Error
+                    ? serverError.message
+                    : String(serverError);
+                errors.push(`${serverId}: ${errorMsg}`);
+                unifiedRegistryLogger.debug(`Tool ${toolName} failed on server ${serverId}: ${errorMsg}`);
+            }
+        }
+        throw new Error(`Tool '${toolName}' not found on any configured MCP server. Errors: ${errors.join("; ")}`);
     }
     /**
      * Lazily activate a server by ID
@@ -143,7 +305,7 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
      * Get registry statistics (override parent method)
      */
     getStats() {
-        // Return execution stats in the expected format
+        // Return full stats interface as expected by MCPOrchestrator
         return super.getStats();
     }
     /**