@juspay/neurolink 6.1.0 → 6.2.1

package/dist/mcp/unified-mcp.js

@@ -1,251 +0,0 @@
-/**
- * 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);
-        // Calculate total tools from registry
-        const registryToolCount = this.registry.getToolCount
-            ? this.registry.getToolCount()
-            : 0;
-        const totalTools = internalToolCount + externalStatus.totalTools + registryToolCount;
-        return {
-            isInitialized: this.isInitialized,
-            internalServers: {
-                count: this.internalServers.length,
-                tools: internalToolCount,
-            },
-            externalServers: {
-                configured: externalStatus.totalServers,
-                connected: externalStatus.connected,
-                tools: externalStatus.totalTools,
-            },
-            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();
-}

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

@@ -1,165 +0,0 @@
-/**
- * Unified MCP Registry - Combines Multiple Registration Sources
- */
-import type { DiscoveredMCP, ExecutionContext } from "./contracts/mcp-contract.js";
-import type { JsonValue } from "../types/common.js";
-import type { DiscoveryOptions } from "./auto-discovery.js";
-interface MCPServerConfig {
-    name: string;
-    id?: string;
-    command: string;
-    args?: string[];
-    env?: Record<string, string>;
-    transport?: string;
-    [key: string]: JsonValue | undefined;
-}
-import { MCPToolRegistry, type ToolInfo } from "./tool-registry.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { ErrorManager } from "./error-manager.js";
-/**
- * Unified registry combining multiple sources
- */
-export declare class UnifiedMCPRegistry extends MCPToolRegistry {
-    private errorManager;
-    private autoDiscoveryEnabled;
-    private autoDiscoveredServers;
-    private manualServers;
-    private availableServers;
-    private transportManager;
-    private activeConnections;
-    constructor(errorManager?: ErrorManager);
-    /**
-     * Initialize with auto-discovery and manual config
-     */
-    initialize(options?: DiscoveryOptions): Promise<void>;
-    /**
-     * Load servers from .mcp-config.json
-     */
-    private loadManualConfig;
-    /**
-     * Connect to manually configured servers
-     */
-    private connectManualServers;
-    /**
-     * Enable or disable auto-discovery
-     */
-    setAutoDiscovery(enabled: boolean): void;
-    /**
-     * Refresh discovery
-     */
-    refresh(options?: DiscoveryOptions): Promise<void>;
-    /**
-     * Get total server count
-     */
-    getTotalServerCount(): number;
-    /**
-     * Get available server count
-     */
-    getAvailableServerCount(): number;
-    /**
-     * Get auto-discovered servers
-     */
-    getAutoDiscoveredServers(): DiscoveredMCP[];
-    /**
-     * Get manual servers
-     */
-    getManualServers(): Map<string, MCPServerConfig>;
-    /**
-     * List all tools from all registered plugins
-     */
-    listAllTools(): Promise<ToolInfo[]>;
-    /**
-     * 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
-     */
-    lazyActivateServer(serverId: string): Promise<boolean>;
-    /**
-     * Register a manual server
-     */
-    registerManualServer(id: string, server: MCPServerConfig): void;
-    /**
-     * Get registry statistics (override parent method)
-     */
-    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
-     */
-    getDetailedStats(): Promise<{
-        total: number;
-        bySource: Record<string, number>;
-        byType: Record<string, number>;
-        manual?: {
-            servers: number;
-        };
-        auto?: {
-            servers: number;
-        };
-        tools?: number;
-    }>;
-    /**
-     * Add external MCP server programmatically
-     *
-     * @param serverId - Unique server identifier
-     * @param config - Server configuration (stdio, sse, or http)
-     */
-    addExternalServer(serverId: string, config: {
-        type: "stdio" | "sse" | "http";
-        command?: string;
-        args?: string[];
-        env?: Record<string, string>;
-        cwd?: string;
-        url?: string;
-        headers?: Record<string, string>;
-        timeout?: number;
-    }): Promise<void>;
-    /**
-     * Get active connection for a server
-     */
-    getConnection(serverId: string): Client | undefined;
-    /**
-     * Check if server is actively connected
-     */
-    isConnected(serverId: string): boolean;
-    /**
-     * Clear all registries and active connections (synchronous, preserves base API contract)
-     */
-    /**
-     * Clear registries without closing connections (internal use)
-     */
-    private clearRegistriesOnly;
-    /**
-     * Clear all registries and initiate async connection cleanup
-     */
-    clear(): void;
-    /**
-     * Clear all registries and close active connections asynchronously
-     */
-    clearAsync(): Promise<void>;
-    /**
-     * Convert unknown arguments to JsonValue for CLI compatibility
-     * Attempts to serialize complex types to JSON-safe format
-     */
-    private toJsonValue;
-}
-/**
- * Default unified registry instance
- */
-export declare const unifiedRegistry: UnifiedMCPRegistry;
-export {};