@juspay/neurolink 4.1.1 → 4.2.0

package/dist/mcp/tool-registry.d.ts

@@ -20,23 +20,37 @@ export interface ToolExecutionOptions {
 }
 export declare class MCPToolRegistry extends MCPRegistry {
     private tools;
+    private toolImpls;
     private toolExecutionStats;
     /**
      * Register a server with its tools (updated signature)
      */
-    registerServer(serverId: string, serverConfig?: unknown, context?: ExecutionContext): Promise<void>;
+    registerServer(serverOrId: string | any, serverConfig?: unknown, context?: ExecutionContext): Promise<void>;
     /**
      * Execute a tool with enhanced context
      */
     executeTool<T = unknown>(toolName: string, args?: unknown, context?: ExecutionContext): Promise<T>;
     /**
-     * List all available tools (updated signature)
+     * List all available tools (updated signature with filtering)
      */
-    listTools(context?: ExecutionContext): Promise<ToolInfo[]>;
+    listTools(): Promise<ToolInfo[]>;
+    listTools(context: ExecutionContext): Promise<ToolInfo[]>;
+    listTools(filter: {
+        category?: string;
+        serverId?: string;
+        serverCategory?: string;
+        permissions?: string[];
+        context?: ExecutionContext;
+    }): Promise<ToolInfo[]>;
     /**
-     * Get tool information
+     * Get tool information with server details
      */
-    getToolInfo(toolName: string): ToolInfo | undefined;
+    getToolInfo(toolName: string): {
+        tool: ToolInfo;
+        server: {
+            id: string;
+        };
+    } | undefined;
     /**
      * Update execution statistics
      */
@@ -70,13 +84,19 @@ export declare class MCPToolRegistry extends MCPRegistry {
      */
     getToolCount(): number;
     /**
-     * Get statistics (alias for getExecutionStats)
+     * Get comprehensive statistics
      */
-    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;
+        }>;
+    };
     /**
      * Unregister a server
      */

package/dist/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/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/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
      */