@juspay/neurolink 1.10.0 → 1.11.1

package/dist/lib/mcp/external-manager.js

@@ -0,0 +1,302 @@
+/**
+ * NeuroLink External MCP Manager
+ * Manages external MCP servers and bridges them into the NeuroLink factory ecosystem
+ * Reads .mcp-config.json and spawns external clients
+ */
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { createExternalMCPClient, } from "./external-client.js";
+import { createMCPServer } from "./factory.js";
+import { MCPToolRegistry } from "./tool-registry.js";
+import { mcpLogger as logger } from "./logging.js";
+/**
+ * External MCP Manager
+ * Bridges external MCP servers into NeuroLink's factory pattern ecosystem
+ */
+export class ExternalMCPManager {
+    servers = new Map();
+    registry;
+    configPath;
+    config = null;
+    isInitialized = false;
+    constructor(configPath, registry) {
+        this.configPath = configPath || ".mcp-config.json";
+        this.registry = registry || new MCPToolRegistry();
+    }
+    /**
+     * Initialize the external MCP manager
+     * Reads config and connects to all external servers
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            logger.debug("[External MCP Manager] Already initialized");
+            return;
+        }
+        try {
+            logger.info("[External MCP Manager] Initializing...");
+            // Load configuration
+            await this.loadConfig();
+            if (!this.config?.mcpServers) {
+                logger.warn("[External MCP Manager] No MCP servers configured");
+                this.isInitialized = true;
+                return;
+            }
+            // Connect to all configured servers
+            const serverNames = Object.keys(this.config.mcpServers);
+            logger.info(`[External MCP Manager] Connecting to ${serverNames.length} external servers: ${serverNames.join(", ")}`);
+            const connectionPromises = serverNames.map((serverName) => this.connectToServer(serverName).catch((error) => {
+                logger.error(`[External MCP Manager] Failed to connect to ${serverName}:`, error);
+                return null;
+            }));
+            const results = await Promise.allSettled(connectionPromises);
+            const connected = results.filter((r) => r.status === "fulfilled" && r.value !== null).length;
+            logger.info(`[External MCP Manager] Connected to ${connected}/${serverNames.length} external servers`);
+            this.isInitialized = true;
+        }
+        catch (error) {
+            logger.error("[External MCP Manager] Initialization failed:", error);
+            throw error;
+        }
+    }
+    /**
+     * Load MCP configuration from file
+     */
+    async loadConfig() {
+        try {
+            const configFile = resolve(this.configPath);
+            const configData = await readFile(configFile, "utf-8");
+            this.config = JSON.parse(configData);
+            logger.debug("[External MCP Manager] Config loaded:", {
+                serversCount: Object.keys(this.config?.mcpServers || {}).length,
+                autoDiscovery: this.config?.autoDiscovery?.enabled,
+            });
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                logger.warn(`[External MCP Manager] Config file not found: ${this.configPath}`);
+                this.config = { mcpServers: {} };
+            }
+            else {
+                logger.error("[External MCP Manager] Failed to load config:", error);
+                throw error;
+            }
+        }
+    }
+    /**
+     * Connect to a specific external server
+     */
+    async connectToServer(serverName) {
+        if (!this.config?.mcpServers[serverName]) {
+            throw new Error(`Server configuration not found: ${serverName}`);
+        }
+        const serverConfig = this.config.mcpServers[serverName];
+        try {
+            logger.info(`[External MCP Manager] Connecting to server: ${serverName}`);
+            // Create external client
+            const client = createExternalMCPClient({
+                name: serverName,
+                command: serverConfig.command,
+                args: serverConfig.args,
+                transport: serverConfig.transport,
+                env: serverConfig.env,
+            });
+            // Create server info
+            const serverInfo = {
+                name: serverName,
+                client,
+                server: createMCPServer({
+                    id: `external-${serverName}`,
+                    title: `External ${serverConfig.name || serverName}`,
+                    description: `External MCP server: ${serverName}`,
+                    category: "integrations",
+                    visibility: "private",
+                    metadata: {
+                        external: true,
+                        transport: "stdio",
+                        command: serverConfig.command,
+                        args: serverConfig.args,
+                    },
+                }),
+                status: "connecting",
+                toolCount: 0,
+                retryCount: 0,
+            };
+            // Setup event handlers
+            client.on("connected", () => {
+                logger.info(`[External MCP Manager] Connected to ${serverName}`);
+                serverInfo.status = "connected";
+                this.registerServerTools(serverInfo);
+            });
+            client.on("disconnected", () => {
+                logger.warn(`[External MCP Manager] Disconnected from ${serverName}`);
+                serverInfo.status = "disconnected";
+                // TODO: Implement reconnection logic
+            });
+            client.on("error", (error) => {
+                logger.error(`[External MCP Manager] Error from ${serverName}:`, error);
+                serverInfo.status = "error";
+                serverInfo.lastError = error.message;
+            });
+            // Store server info
+            this.servers.set(serverName, serverInfo);
+            // Connect to the server
+            await client.connect();
+            return serverInfo;
+        }
+        catch (error) {
+            logger.error(`[External MCP Manager] Failed to connect to ${serverName}:`, error);
+            const serverInfo = {
+                name: serverName,
+                client: null,
+                server: null,
+                status: "error",
+                lastError: error instanceof Error ? error.message : String(error),
+                toolCount: 0,
+                retryCount: 0,
+            };
+            this.servers.set(serverName, serverInfo);
+            return null;
+        }
+    }
+    /**
+     * Register tools from an external server with the NeuroLink registry
+     */
+    async registerServerTools(serverInfo) {
+        try {
+            const tools = serverInfo.client.getNeuroLinkTools();
+            // Register each tool with the server
+            for (const [toolName, tool] of Object.entries(tools)) {
+                serverInfo.server.registerTool(tool);
+            }
+            serverInfo.toolCount = Object.keys(tools).length;
+            // Register the server with the registry
+            await this.registry.registerServer(serverInfo.name, serverInfo);
+            logger.info(`[External MCP Manager] Registered ${serverInfo.toolCount} tools from ${serverInfo.name}`);
+        }
+        catch (error) {
+            logger.error(`[External MCP Manager] Failed to register tools from ${serverInfo.name}:`, error);
+        }
+    }
+    /**
+     * Get all connected external servers
+     */
+    getConnectedServers() {
+        return Array.from(this.servers.values()).filter((s) => s.status === "connected");
+    }
+    /**
+     * Get server status
+     */
+    getServerStatus(serverName) {
+        return this.servers.get(serverName);
+    }
+    /**
+     * Get all server statuses
+     */
+    getAllServerStatuses() {
+        const statuses = {};
+        for (const [name, info] of this.servers) {
+            statuses[name] = {
+                ...info,
+                // Don't include the actual client/server objects in status
+                client: undefined,
+                server: undefined,
+            };
+        }
+        return statuses;
+    }
+    /**
+     * Execute a tool on any connected server
+     */
+    async executeTool(toolName, params, context) {
+        // Use the registry to execute the tool
+        return this.registry.executeTool(toolName, params, context);
+    }
+    /**
+     * List all available tools from external servers
+     */
+    listExternalTools() {
+        return this.registry.listTools();
+    }
+    /**
+     * Get registry instance
+     */
+    getRegistry() {
+        return this.registry;
+    }
+    /**
+     * Disconnect from a specific server
+     */
+    async disconnectServer(serverName) {
+        const serverInfo = this.servers.get(serverName);
+        if (!serverInfo || !serverInfo.client) {
+            return false;
+        }
+        try {
+            await serverInfo.client.disconnect();
+            this.registry.unregisterServer(`external-${serverName}`);
+            this.servers.delete(serverName);
+            logger.info(`[External MCP Manager] Disconnected from ${serverName}`);
+            return true;
+        }
+        catch (error) {
+            logger.error(`[External MCP Manager] Failed to disconnect from ${serverName}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Disconnect from all servers
+     */
+    async disconnectAll() {
+        logger.info("[External MCP Manager] Disconnecting from all external servers");
+        const disconnectPromises = Array.from(this.servers.keys()).map((serverName) => this.disconnectServer(serverName));
+        await Promise.allSettled(disconnectPromises);
+        this.servers.clear();
+        this.isInitialized = false;
+    }
+    /**
+     * Refresh connections - reload config and reconnect
+     */
+    async refresh() {
+        logger.info("[External MCP Manager] Refreshing connections");
+        await this.disconnectAll();
+        await this.initialize();
+    }
+    /**
+     * Get comprehensive status
+     */
+    getStatus() {
+        const servers = Array.from(this.servers.values());
+        return {
+            isInitialized: this.isInitialized,
+            configPath: this.configPath,
+            totalServers: servers.length,
+            connected: servers.filter((s) => s.status === "connected").length,
+            connecting: servers.filter((s) => s.status === "connecting").length,
+            disconnected: servers.filter((s) => s.status === "disconnected").length,
+            errors: servers.filter((s) => s.status === "error").length,
+            totalTools: servers.reduce((sum, s) => sum + s.toolCount, 0),
+            servers: this.getAllServerStatuses(),
+        };
+    }
+}
+/**
+ * Default external MCP manager instance
+ */
+export const defaultExternalMCPManager = new ExternalMCPManager();
+/**
+ * Initialize external MCP servers with default manager
+ */
+export async function initializeExternalMCP(configPath) {
+    if (configPath) {
+        const manager = new ExternalMCPManager(configPath);
+        await manager.initialize();
+        return;
+    }
+    await defaultExternalMCPManager.initialize();
+}
+/**
+ * Get the default external MCP manager
+ */
+export function getExternalMCPManager() {
+    return defaultExternalMCPManager;
+}

package/dist/lib/mcp/factory.d.ts

@@ -4,6 +4,7 @@
  * Compatible with Lighthouse MCP patterns for seamless migration
  */
 import { z } from "zod";
+import type { ExecutionContext } from "./contracts/mcp-contract.js";
 /**
  * MCP Server Categories for organization and discovery
  */
@@ -11,10 +12,9 @@ export type MCPServerCategory = "ai-providers" | "frameworks" | "development" |
 /**
  * Tool execution context - Rich context passed to every tool execution
  * Following Lighthouse's pattern for rich tool context
+ * Extends ExecutionContext for compatibility
  */
-export interface NeuroLinkExecutionContext {
-    sessionId: string;
-    userId?: string;
+export interface NeuroLinkExecutionContext extends ExecutionContext {
     aiProvider?: string;
     modelId?: string;
     temperature?: number;
@@ -51,7 +51,7 @@ export interface NeuroLinkExecutionContext {
 export interface ToolResult {
     success: boolean;
     data?: any;
-    error?: string;
+    error?: string | Error;
     usage?: {
         tokens?: number;
         cost?: number;

package/dist/lib/mcp/function-calling.js

@@ -5,7 +5,7 @@
  */
 import { tool } from "ai";
 import { z } from "zod";
-import { defaultUnifiedRegistry } from "./unified-registry.js";
+import { unifiedRegistry } from "./unified-registry.js";
 import { createExecutionContext } from "./context-manager.js";
 import { mcpLogger } from "./logging.js";
 /**
@@ -74,18 +74,21 @@ export async function getAvailableFunctionTools() {
                 const { initializeNeuroLinkMCP } = await import("./initialize.js");
                 await initializeNeuroLinkMCP();
                 // Ensure unified registry is initialized
-                await defaultUnifiedRegistry.initialize();
+                await unifiedRegistry.initialize();
                 // Try to activate important servers like filesystem
                 mcpLogger.debug(`[${functionTag}] Attempting to activate important servers...`);
                 try {
                     // Get auto-discovered servers
-                    const autoServers = defaultUnifiedRegistry.getAutoDiscoveredServers();
+                    const autoServers = unifiedRegistry.getAutoDiscoveredServers();
                     // Try to activate filesystem server specifically
-                    for (const [serverId, entry] of autoServers) {
-                        if (serverId.includes("filesystem") &&
-                            entry.status !== "activated") {
-                            mcpLogger.debug(`[${functionTag}] Activating filesystem server: ${serverId}`);
-                            await defaultUnifiedRegistry.lazyActivateServer(serverId, entry);
+                    for (const server of autoServers) {
+                        if (server.metadata.name.includes("filesystem")) {
+                            mcpLogger.debug(`[${functionTag}] Activating filesystem server: ${server.metadata.name}`);
+                            const serverName = server.metadata.name;
+                            if (typeof serverName === "string" && serverName.length > 0) {
+                                // @ts-ignore - serverName is verified as string with length > 0 above
+                                await unifiedRegistry.lazyActivateServer(serverName);
+                            }
                         }
                     }
                 }
@@ -93,7 +96,7 @@ export async function getAvailableFunctionTools() {
                     mcpLogger.debug(`[${functionTag}] Error activating servers: ${error}`);
                 }
                 // Get all tools from unified registry directly
-                const allTools = await defaultUnifiedRegistry.listAllTools();
+                const allTools = await unifiedRegistry.listAllTools();
                 mcpLogger.debug(`[${functionTag}] Found ${allTools.length} total tools`);
                 // Try to activate servers that have "-tools" entries to get real tools
                 const serversToActivate = allTools
@@ -101,18 +104,19 @@ export async function getAvailableFunctionTools() {
                     .map((tool) => tool.server);
                 mcpLogger.debug(`[${functionTag}] Attempting to activate ${serversToActivate.length} servers for real tool discovery`);
                 // Activate servers to convert placeholders to real tools
-                for (const serverId of [...new Set(serversToActivate)]) {
+                for (const serverId of [...new Set(serversToActivate)].filter((id) => typeof id === "string" && id !== "unknown")) {
                     try {
                         mcpLogger.debug(`[${functionTag}] Activating server: ${serverId}`);
                         // Get the server entry from auto-discovered or manual servers
-                        const autoServers = defaultUnifiedRegistry.getAutoDiscoveredServers();
-                        const manualServers = defaultUnifiedRegistry.getManualServers();
-                        const serverEntry = autoServers.get(serverId) || manualServers.get(serverId);
-                        if (serverEntry) {
-                            await defaultUnifiedRegistry.lazyActivateServer(serverId, serverEntry);
+                        const autoServers = unifiedRegistry.getAutoDiscoveredServers();
+                        const manualServers = unifiedRegistry.getManualServers();
+                        const serverEntry = autoServers.find((s) => s.metadata.name === serverId) ||
+                            manualServers.get(serverId);
+                        if (serverEntry && serverId.length > 0) {
+                            await unifiedRegistry.lazyActivateServer(serverId);
                         }
                         else {
-                            mcpLogger.debug(`[${functionTag}] Server entry not found for: ${serverId}`);
+                            mcpLogger.debug(`[${functionTag}] Server entry not found for: ${serverId || "undefined"}`);
                         }
                     }
                     catch (error) {
@@ -120,7 +124,7 @@ export async function getAvailableFunctionTools() {
                     }
                 }
                 // Get tools again after activation
-                const activatedTools = await defaultUnifiedRegistry.listAllTools();
+                const activatedTools = await unifiedRegistry.listAllTools();
                 mcpLogger.debug(`[${functionTag}] Found ${activatedTools.length} total tools after activation`);
                 // Filter to get real, individual tools (not placeholder or grouped tools)
                 const realTools = activatedTools.filter((toolInfo) => {
@@ -152,7 +156,7 @@ export async function getAvailableFunctionTools() {
                         let functionName;
                         let originalFunctionName;
                         // Convert server name to underscore format to check if it's embedded in tool name
-                        const sanitizedServerCheck = toolInfo.server.replace(/[^a-zA-Z0-9_]/g, "_");
+                        const sanitizedServerCheck = (toolInfo.server || "unknown").replace(/[^a-zA-Z0-9_]/g, "_");
                         if (toolInfo.name.includes(sanitizedServerCheck) ||
                             toolInfo.name.endsWith("-tools") ||
                             toolInfo.name.startsWith("github_com_") ||
@@ -202,7 +206,7 @@ export async function getAvailableFunctionTools() {
                         }
                         else {
                             // Tool name doesn't include server info, create compound name
-                            const sanitizedServerName = toolInfo.server.replace(/[^a-zA-Z0-9_]/g, "_");
+                            const sanitizedServerName = (toolInfo.server || "unknown").replace(/[^a-zA-Z0-9_]/g, "_");
                             const sanitizedToolName = toolInfo.name.replace(/[^a-zA-Z0-9_]/g, "_");
                             // Check if it's a filesystem tool from MCP
                             if (sanitizedServerName.includes("modelcontextprotocol") &&
@@ -235,7 +239,7 @@ export async function getAvailableFunctionTools() {
                                     }
                                 }
                             }
-                            originalFunctionName = `${toolInfo.server}.${toolInfo.name}`;
+                            originalFunctionName = `${toolInfo.server || "unknown"}.${toolInfo.name}`;
                         }
                         // Create AI SDK tool using the proper tool() helper
                         const aiTool = tool({
@@ -273,7 +277,7 @@ export async function getAvailableFunctionTools() {
                         tools.push(aiTool);
                         // Store mapping for execution - CRITICAL: Use sanitized functionName as key
                         toolMap.set(functionName, {
-                            serverId: toolInfo.server,
+                            serverId: toolInfo.server || "unknown",
                             toolName: toolInfo.name,
                         });
                         mcpLogger.debug(`[${functionTag}] Converted tool: ${functionName} (original: ${originalFunctionName})`);
@@ -312,7 +316,17 @@ export async function getAvailableFunctionTools() {
 export async function executeFunctionCall(functionName, parameters, context) {
     const functionTag = "executeFunctionCall";
     try {
-        mcpLogger.debug(`[${functionTag}] Executing function call: ${functionName}`, { parameters });
+        // CRITICAL FIX: Unwrap 'input' parameter if it exists
+        // AI function calling wraps parameters in { input: { actualParams } }
+        // but MCP tools expect direct parameters
+        let actualParameters = parameters;
+        if (parameters.input &&
+            typeof parameters.input === "object" &&
+            parameters.input !== null) {
+            actualParameters = parameters.input;
+            mcpLogger.debug(`[${functionTag}] Unwrapped input parameter for ${functionName}`, { original: parameters, unwrapped: actualParameters });
+        }
+        mcpLogger.debug(`[${functionTag}] Executing function call: ${functionName}`, { parameters: actualParameters });
         // Create context if not provided
         let finalContext = context;
         if (!finalContext) {
@@ -325,23 +339,34 @@ export async function executeFunctionCall(functionName, parameters, context) {
         // Parse server and tool name from function name
         // First try underscore format (sanitized), then fallback to dot format
         let parts = functionName.split("_");
-        let serverId;
-        let toolName;
+        let serverId = "unknown";
+        let toolName = functionName;
         if (parts.length >= 2) {
             // Handle underscore format (sanitized names)
-            serverId = parts[0];
+            const firstPart = parts[0];
+            if (firstPart && typeof firstPart === "string" && firstPart.length > 0) {
+                serverId = firstPart;
+            }
+            else {
+                serverId = "unknown";
+            }
             toolName = parts.slice(1).join("_"); // Rejoin in case tool name had underscores
         }
         else {
             // Fallback to dot format for backward compatibility
             parts = functionName.split(".");
             if (parts.length === 2) {
-                [serverId, toolName] = parts;
+                const parsedServerId = parts[0];
+                const parsedToolName = parts[1];
+                if (parsedServerId && parsedToolName) {
+                    serverId = parsedServerId;
+                    toolName = parsedToolName;
+                }
             }
             else {
                 // Can't parse - try executing as-is through unified registry
                 mcpLogger.debug(`[${functionTag}] Cannot parse function name format: ${functionName}, trying unified registry`);
-                const result = await defaultUnifiedRegistry.executeTool(functionName, parameters, finalContext);
+                const result = await unifiedRegistry.executeTool(functionName, actualParameters, finalContext);
                 return result;
             }
         }
@@ -352,15 +377,15 @@ export async function executeFunctionCall(functionName, parameters, context) {
             serverId === "neurolink_ai_core") {
             mcpLogger.debug(`[${functionTag}] Executing built-in tool: ${toolName} from ${serverId}`);
             // Import and execute from default registry
-            const { defaultToolRegistry } = await import("./registry.js");
-            return await defaultToolRegistry.executeTool(toolName, parameters, finalContext);
+            const { defaultToolRegistry } = await import("./tool-registry.js");
+            return await defaultToolRegistry.executeTool(toolName, actualParameters, finalContext);
         }
         // Handle filesystem server with special activation logic
         if (serverId === "filesystem") {
             mcpLogger.debug(`[${functionTag}] Executing filesystem tool: ${toolName}`);
             try {
                 // First, try to execute through unified registry
-                const result = await defaultUnifiedRegistry.executeTool(functionName, parameters, finalContext);
+                const result = await unifiedRegistry.executeTool(functionName, actualParameters, finalContext);
                 if (result.success) {
                     return result;
                 }
@@ -372,7 +397,7 @@ export async function executeFunctionCall(functionName, parameters, context) {
             try {
                 // Force activation by attempting to activate the filesystem server directly
                 // This should convert placeholders to real tools
-                await defaultUnifiedRegistry.initialize();
+                await unifiedRegistry.initialize();
                 // Try a few common activation patterns
                 const activationAttempts = [
                     `${serverId}.list_directory`,
@@ -381,7 +406,7 @@ export async function executeFunctionCall(functionName, parameters, context) {
                 ];
                 for (const attempt of activationAttempts) {
                     try {
-                        const result = await defaultUnifiedRegistry.executeTool(attempt, parameters, finalContext);
+                        const result = await unifiedRegistry.executeTool(attempt, actualParameters, finalContext);
                         if (result.success) {
                             mcpLogger.debug(`[${functionTag}] Filesystem tool executed successfully with: ${attempt}`);
                             return result;
@@ -394,7 +419,7 @@ export async function executeFunctionCall(functionName, parameters, context) {
                 // If all attempts fail, return a helpful error
                 return {
                     success: false,
-                    error: `Filesystem tool '${toolName}' could not be activated. Available parameters: ${JSON.stringify(parameters)}`,
+                    error: `Filesystem tool '${toolName}' could not be activated. Available parameters: ${JSON.stringify(actualParameters)}`,
                     metadata: {
                         functionName,
                         timestamp: Date.now(),
@@ -417,7 +442,7 @@ export async function executeFunctionCall(functionName, parameters, context) {
         }
         // For other tools, use unified registry
         mcpLogger.debug(`[${functionTag}] Executing through unified registry: ${functionName}`);
-        const result = await defaultUnifiedRegistry.executeTool(functionName, parameters, finalContext);
+        const result = await unifiedRegistry.executeTool(functionName, actualParameters, finalContext);
         mcpLogger.debug(`[${functionTag}] Function call completed: ${functionName}`, {
             success: result.success,
             hasData: !!result.data,