@juspay/neurolink 6.1.0 → 6.2.1

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

@@ -1,308 +0,0 @@
-/**
- * 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 {
-            if (!serverInfo.client) {
-                throw new Error("Client is not available");
-            }
-            if (!serverInfo.server) {
-                throw new Error("Server is not available");
-            }
-            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: null,
-                server: null,
-            };
-        }
-        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/function-calling.d.ts

@@ -1,65 +0,0 @@
-/**
- * MCP Function-Calling Integration
- * Converts MCP tools to AI SDK function definitions and handles function calls
- * Enables true AI function calling with discovered MCP tools
- */
-import type { Tool } from "ai";
-import type { NeuroLinkMCPTool, ToolResult, NeuroLinkExecutionContext } from "./factory.js";
-import type { UnknownRecord } from "../types/common.js";
-/**
- * Convert MCP tool to AI SDK function definition
- */
-export declare function mcpToolToAISDKTool(tool: NeuroLinkMCPTool, serverId: string): Tool;
-/**
- * Get all available MCP tools as AI SDK function definitions
- */
-export declare function getAvailableFunctionTools(): Promise<{
-    tools: Tool[];
-    toolsObject: Record<string, Tool>;
-    toolMap: Map<string, {
-        serverId: string;
-        toolName: string;
-    }>;
-}>;
-/**
- * Execute MCP tool from AI function call
- */
-export declare function executeFunctionCall(functionName: string, parameters: Record<string, unknown>, context?: NeuroLinkExecutionContext): Promise<ToolResult>;
-/**
- * Handle multiple function calls and format results for AI
- */
-export declare function handleFunctionCalls(functionCalls: Array<{
-    name: string;
-    parameters: Record<string, unknown>;
-    id?: string;
-}>, context?: NeuroLinkExecutionContext): Promise<Array<{
-    id?: string;
-    result: ToolResult;
-    formattedForAI: string;
-}>>;
-/**
- * Create a subset of tools for specific categories or capabilities
- */
-export declare function getFunctionToolsForCategory(category?: string, maxTools?: number): Promise<{
-    tools: Tool[];
-    toolMap: Map<string, {
-        serverId: string;
-        toolName: string;
-    }>;
-}>;
-/**
- * Check if function calling is available
- */
-export declare function isFunctionCallingAvailable(): Promise<boolean>;
-/**
- * Utility function to create a named tool object for debugging
- */
-export declare function createNamedTool(name: string, toolDef: Tool): Tool & {
-    name: string;
-};
-/**
- * Get tools with proper name properties for debugging
- */
-export declare function getToolsWithNames(): Promise<Record<string, UnknownRecord & {
-    name: string;
-}>>;