@juspay/neurolink 1.10.0 → 1.11.0

package/dist/mcp/tool-registry.js

@@ -0,0 +1,160 @@
+/**
+ * MCP Tool Registry - Extended Registry with Tool Management
+ */
+import { MCPRegistry } from "./registry.js";
+import { registryLogger } from "./logging.js";
+export class MCPToolRegistry extends MCPRegistry {
+    tools = new Map();
+    toolExecutionStats = new Map();
+    /**
+     * Register a server with its tools
+     */
+    async registerServer(serverId, serverInfo) {
+        registryLogger.info(`Registering server: ${serverId}`);
+        // Extract tools from server info if available
+        if (serverInfo.tools) {
+            for (const [toolName, toolDef] of Object.entries(serverInfo.tools)) {
+                const toolId = `${serverId}.${toolName}`;
+                this.tools.set(toolId, {
+                    id: toolId,
+                    name: toolName,
+                    description: toolDef.description,
+                    inputSchema: toolDef.inputSchema,
+                    outputSchema: toolDef.outputSchema,
+                    serverId,
+                    server: serverId, // Backward compatibility alias
+                    source: "manual",
+                    isImplemented: true,
+                });
+            }
+        }
+    }
+    /**
+     * Unregister a server and its tools
+     */
+    async unregisterServer(serverId) {
+        registryLogger.info(`Unregistering server: ${serverId}`);
+        // Remove all tools for this server
+        for (const [toolId, toolInfo] of this.tools) {
+            if (toolInfo.serverId === serverId) {
+                this.tools.delete(toolId);
+                this.toolExecutionStats.delete(toolId);
+            }
+        }
+    }
+    /**
+     * Execute a tool
+     */
+    async executeTool(toolName, args, context) {
+        const startTime = Date.now();
+        try {
+            const toolInfo = this.getToolInfo(toolName);
+            if (!toolInfo) {
+                throw new Error(`Tool not found: ${toolName}`);
+            }
+            registryLogger.info(`Executing tool: ${toolName}`);
+            // Get the plugin that provides this tool
+            const plugin = this.get(toolInfo.serverId);
+            if (!plugin) {
+                throw new Error(`Plugin not found for tool: ${toolName}`);
+            }
+            // Execute through the plugin (stub implementation)
+            const result = {
+                success: true,
+                data: `Tool ${toolInfo.name} executed with args: ${JSON.stringify(args)}`,
+            };
+            const executionTime = Date.now() - startTime;
+            this.updateStats(toolName, executionTime);
+            return {
+                success: true,
+                data: result,
+                metadata: {
+                    toolName,
+                    executionTime,
+                    timestamp: Date.now(),
+                },
+            };
+        }
+        catch (error) {
+            registryLogger.error(`Tool execution failed: ${toolName}`, error);
+            return {
+                success: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+                metadata: {
+                    toolName,
+                    executionTime: Date.now() - startTime,
+                    timestamp: Date.now(),
+                },
+            };
+        }
+    }
+    /**
+     * List all available tools
+     */
+    async listTools() {
+        return Array.from(this.tools.values());
+    }
+    /**
+     * Get tool information
+     */
+    getToolInfo(toolName) {
+        return this.tools.get(toolName);
+    }
+    /**
+     * Update execution statistics
+     */
+    updateStats(toolName, executionTime) {
+        const stats = this.toolExecutionStats.get(toolName) || {
+            count: 0,
+            totalTime: 0,
+        };
+        stats.count++;
+        stats.totalTime += executionTime;
+        this.toolExecutionStats.set(toolName, stats);
+    }
+    /**
+     * Get tool execution statistics
+     */
+    getToolStats(toolName) {
+        if (toolName) {
+            const stats = this.toolExecutionStats.get(toolName);
+            return stats
+                ? {
+                    ...stats,
+                    averageTime: stats.totalTime / stats.count,
+                }
+                : null;
+        }
+        // Return all stats
+        const allStats = {};
+        for (const [tool, stats] of this.toolExecutionStats) {
+            allStats[tool] = {
+                ...stats,
+                averageTime: stats.totalTime / stats.count,
+            };
+        }
+        return allStats;
+    }
+    /**
+     * Get tool execution statistics
+     */
+    async getStats() {
+        const tools = await this.listTools();
+        return {
+            totalTools: tools.length,
+            totalExecutions: Array.from(this.toolExecutionStats.values()).reduce((acc, stats) => acc + stats.count, 0),
+        };
+    }
+    /**
+     * Clear all tools and stats
+     */
+    clear() {
+        super.clear();
+        this.tools.clear();
+        this.toolExecutionStats.clear();
+    }
+}
+// Export singleton instance
+export const toolRegistry = new MCPToolRegistry();
+// Additional exports for backward compatibility
+export const defaultToolRegistry = toolRegistry;

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

@@ -0,0 +1,123 @@
+/**
+ * NeuroLink Unified MCP System
+ * Combines internal MCP servers with external MCP server integration
+ * Single initialization point for the complete MCP ecosystem
+ */
+import { MCPToolRegistry } from "./tool-registry.js";
+import { ExternalMCPManager } from "./external-manager.js";
+import type { NeuroLinkExecutionContext, ToolResult } from "./factory.js";
+/**
+ * Unified MCP System Options
+ */
+export interface UnifiedMCPOptions {
+    configPath?: string;
+    enableExternalServers?: boolean;
+    enableInternalServers?: boolean;
+    autoInitialize?: boolean;
+    registry?: MCPToolRegistry;
+}
+/**
+ * Unified MCP System Status
+ */
+export interface UnifiedMCPStatus {
+    isInitialized: boolean;
+    internalServers: {
+        count: number;
+        tools: number;
+    };
+    externalServers: {
+        configured: number;
+        connected: number;
+        tools: number;
+    };
+    totalTools: number;
+    registryStats: any;
+}
+/**
+ * Unified MCP System
+ * Central hub for managing both internal and external MCP servers
+ */
+export declare class UnifiedMCPSystem {
+    private registry;
+    private externalManager;
+    private internalServers;
+    private isInitialized;
+    private options;
+    constructor(options?: UnifiedMCPOptions);
+    /**
+     * Initialize the unified MCP system
+     */
+    initialize(): Promise<void>;
+    /**
+     * Initialize internal MCP servers
+     */
+    private initializeInternalServers;
+    /**
+     * Initialize external MCP servers
+     */
+    private initializeExternalServers;
+    /**
+     * Execute a tool from any registered server
+     */
+    executeTool(toolName: string, params: any, context: NeuroLinkExecutionContext): Promise<ToolResult>;
+    /**
+     * List all available tools
+     */
+    listTools(criteria?: any): Promise<import("./tool-registry.js").ToolInfo[]>;
+    /**
+     * Get tool information
+     */
+    getToolInfo(toolName: string): import("./tool-registry.js").ToolInfo | undefined;
+    /**
+     * Get registry instance
+     */
+    getRegistry(): MCPToolRegistry;
+    /**
+     * Get external manager instance
+     */
+    getExternalManager(): ExternalMCPManager;
+    /**
+     * Get comprehensive status
+     */
+    getStatus(): Promise<UnifiedMCPStatus>;
+    /**
+     * Refresh external connections
+     */
+    refreshExternalServers(): Promise<void>;
+    /**
+     * Shutdown the unified MCP system
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Check if system is initialized
+     */
+    isSystemInitialized(): boolean;
+}
+/**
+ * Default unified MCP system instance
+ */
+export declare const defaultUnifiedMCP: UnifiedMCPSystem;
+/**
+ * Initialize the default unified MCP system
+ */
+export declare function initializeMCP(options?: UnifiedMCPOptions): Promise<UnifiedMCPSystem>;
+/**
+ * Get the default unified MCP system
+ */
+export declare function getMCPSystem(): UnifiedMCPSystem;
+/**
+ * Execute a tool using the default system
+ */
+export declare function executeMCPTool(toolName: string, params: any, context: NeuroLinkExecutionContext): Promise<ToolResult>;
+/**
+ * List all available MCP tools
+ */
+export declare function listMCPTools(criteria?: any): Promise<import("./tool-registry.js").ToolInfo[]>;
+/**
+ * Get MCP tool information
+ */
+export declare function getMCPToolInfo(toolName: string): import("./tool-registry.js").ToolInfo | undefined;
+/**
+ * Get unified MCP system status
+ */
+export declare function getMCPStatus(): Promise<UnifiedMCPStatus>;

package/dist/mcp/unified-mcp.js

@@ -0,0 +1,246 @@
+/**
+ * NeuroLink Unified MCP System
+ * Combines internal MCP servers with external MCP server integration
+ * Single initialization point for the complete MCP ecosystem
+ */
+import { MCPToolRegistry } from "./tool-registry.js";
+import { ExternalMCPManager } from "./external-manager.js";
+import { aiCoreServer } from "./servers/ai-providers/ai-core-server.js";
+import { mcpLogger as logger } from "./logging.js";
+/**
+ * Unified MCP System
+ * Central hub for managing both internal and external MCP servers
+ */
+export class UnifiedMCPSystem {
+    registry;
+    externalManager;
+    internalServers = [];
+    isInitialized = false;
+    options;
+    constructor(options = {}) {
+        this.options = {
+            configPath: ".mcp-config.json",
+            enableExternalServers: true,
+            enableInternalServers: true,
+            autoInitialize: false,
+            registry: new MCPToolRegistry(),
+            ...options,
+        };
+        this.registry = this.options.registry;
+        this.externalManager = new ExternalMCPManager(this.options.configPath, this.registry);
+    }
+    /**
+     * Initialize the unified MCP system
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            logger.debug("[Unified MCP] Already initialized");
+            return;
+        }
+        try {
+            logger.info("[Unified MCP] Initializing unified MCP system...");
+            const startTime = Date.now();
+            // Initialize internal servers first
+            if (this.options.enableInternalServers) {
+                await this.initializeInternalServers();
+            }
+            // Initialize external servers
+            if (this.options.enableExternalServers) {
+                await this.initializeExternalServers();
+            }
+            this.isInitialized = true;
+            const initTime = Date.now() - startTime;
+            const status = this.getStatus();
+            const currentStatus = await this.getStatus();
+            logger.info(`[Unified MCP] Initialization complete in ${initTime}ms`, {
+                totalTools: currentStatus.totalTools,
+                internalServers: currentStatus.internalServers.count,
+                externalServers: currentStatus.externalServers.connected,
+            });
+        }
+        catch (error) {
+            logger.error("[Unified MCP] Initialization failed:", error);
+            throw error;
+        }
+    }
+    /**
+     * Initialize internal MCP servers
+     */
+    async initializeInternalServers() {
+        try {
+            logger.info("[Unified MCP] Initializing internal servers...");
+            // Register AI Core Server (with 10 tools)
+            await this.registry.registerServer("ai-core", aiCoreServer);
+            this.internalServers.push(aiCoreServer);
+            // TODO: Add other internal servers here as they are created
+            // await this.registry.registerServer(utilityServer);
+            // this.internalServers.push(utilityServer);
+            const totalInternalTools = this.internalServers.reduce((sum, server) => sum + Object.keys(server.tools).length, 0);
+            logger.info(`[Unified MCP] Registered ${this.internalServers.length} internal servers with ${totalInternalTools} tools`);
+        }
+        catch (error) {
+            logger.error("[Unified MCP] Failed to initialize internal servers:", error);
+            throw error;
+        }
+    }
+    /**
+     * Initialize external MCP servers
+     */
+    async initializeExternalServers() {
+        try {
+            logger.info("[Unified MCP] Initializing external servers...");
+            await this.externalManager.initialize();
+            const connectedServers = this.externalManager.getConnectedServers();
+            const totalExternalTools = connectedServers.reduce((sum, server) => sum + server.toolCount, 0);
+            logger.info(`[Unified MCP] Connected to ${connectedServers.length} external servers with ${totalExternalTools} tools`);
+        }
+        catch (error) {
+            logger.warn("[Unified MCP] External server initialization failed (continuing without external servers):", error);
+            // Don't throw here - external servers are optional
+        }
+    }
+    /**
+     * Execute a tool from any registered server
+     */
+    async executeTool(toolName, params, context) {
+        if (!this.isInitialized) {
+            throw new Error("Unified MCP system not initialized. Call initialize() first.");
+        }
+        return this.registry.executeTool(toolName, params, context);
+    }
+    /**
+     * List all available tools
+     */
+    listTools(criteria) {
+        return this.registry.listTools();
+    }
+    /**
+     * Get tool information
+     */
+    getToolInfo(toolName) {
+        return this.registry.getToolInfo(toolName);
+    }
+    /**
+     * Get registry instance
+     */
+    getRegistry() {
+        return this.registry;
+    }
+    /**
+     * Get external manager instance
+     */
+    getExternalManager() {
+        return this.externalManager;
+    }
+    /**
+     * Get comprehensive status
+     */
+    async getStatus() {
+        const registryStats = await this.registry.getStats();
+        const externalStatus = this.externalManager.getStatus();
+        const internalToolCount = this.internalServers.reduce((sum, server) => sum + Object.keys(server.tools).length, 0);
+        return {
+            isInitialized: this.isInitialized,
+            internalServers: {
+                count: this.internalServers.length,
+                tools: internalToolCount,
+            },
+            externalServers: {
+                configured: externalStatus.totalServers,
+                connected: externalStatus.connected,
+                tools: externalStatus.totalTools,
+            },
+            totalTools: registryStats.totalTools,
+            registryStats,
+        };
+    }
+    /**
+     * Refresh external connections
+     */
+    async refreshExternalServers() {
+        if (!this.options.enableExternalServers) {
+            return;
+        }
+        logger.info("[Unified MCP] Refreshing external servers...");
+        await this.externalManager.refresh();
+    }
+    /**
+     * Shutdown the unified MCP system
+     */
+    async shutdown() {
+        if (!this.isInitialized) {
+            return;
+        }
+        logger.info("[Unified MCP] Shutting down unified MCP system...");
+        try {
+            // Disconnect external servers
+            await this.externalManager.disconnectAll();
+            // Clear registry
+            this.registry.clear();
+            // Clear internal servers
+            this.internalServers = [];
+            this.isInitialized = false;
+            logger.info("[Unified MCP] Shutdown complete");
+        }
+        catch (error) {
+            logger.error("[Unified MCP] Shutdown failed:", error);
+            throw error;
+        }
+    }
+    /**
+     * Check if system is initialized
+     */
+    isSystemInitialized() {
+        return this.isInitialized;
+    }
+}
+/**
+ * Default unified MCP system instance
+ */
+export const defaultUnifiedMCP = new UnifiedMCPSystem({
+    autoInitialize: false,
+});
+/**
+ * Initialize the default unified MCP system
+ */
+export async function initializeMCP(options) {
+    if (options) {
+        const customSystem = new UnifiedMCPSystem(options);
+        await customSystem.initialize();
+        return customSystem;
+    }
+    if (!defaultUnifiedMCP.isSystemInitialized()) {
+        await defaultUnifiedMCP.initialize();
+    }
+    return defaultUnifiedMCP;
+}
+/**
+ * Get the default unified MCP system
+ */
+export function getMCPSystem() {
+    return defaultUnifiedMCP;
+}
+/**
+ * Execute a tool using the default system
+ */
+export async function executeMCPTool(toolName, params, context) {
+    return defaultUnifiedMCP.executeTool(toolName, params, context);
+}
+/**
+ * List all available MCP tools
+ */
+export function listMCPTools(criteria) {
+    return defaultUnifiedMCP.listTools(criteria);
+}
+/**
+ * Get MCP tool information
+ */
+export function getMCPToolInfo(toolName) {
+    return defaultUnifiedMCP.getToolInfo(toolName);
+}
+/**
+ * Get unified MCP system status
+ */
+export async function getMCPStatus() {
+    return await defaultUnifiedMCP.getStatus();
+}