@juspay/neurolink 1.6.0 → 1.10.0

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

@@ -0,0 +1,269 @@
+/**
+ * NeuroLink Unified MCP Registry System
+ * Combines manual configuration, auto-discovery, and default tool registry
+ * Provides intelligent server selection with configurable priorities
+ */
+import { type ToolSearchCriteria } from "./registry.js";
+import type { NeuroLinkMCPServer, NeuroLinkExecutionContext, ToolResult } from "./factory.js";
+/**
+ * MCP Server Configuration from manual .mcp-config.json
+ */
+export interface MCPServerConfig {
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    transport: "stdio" | "sse";
+    url?: string;
+}
+/**
+ * Enhanced MCP configuration with auto-discovery settings
+ */
+export interface EnhancedMCPConfig {
+    mcpServers: Record<string, MCPServerConfig>;
+    autoDiscovery?: {
+        enabled?: boolean;
+        sources?: string[];
+        autoRegister?: boolean;
+        excludeServers?: string[];
+        preferManualConfig?: boolean;
+    };
+    defaultRegistry?: {
+        enabled?: boolean;
+        includeBuiltInTools?: boolean;
+    };
+}
+/**
+ * Server source information
+ */
+export interface ServerSource {
+    type: "manual" | "auto" | "default";
+    priority: number;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Unified server entry
+ */
+export interface UnifiedServerEntry {
+    id: string;
+    config?: MCPServerConfig;
+    server?: NeuroLinkMCPServer;
+    source: ServerSource;
+    status: "available" | "unavailable" | "unknown" | "activated";
+}
+/**
+ * Unified execution options
+ */
+export interface UnifiedExecutionOptions {
+    preferredSource?: "manual" | "auto" | "default";
+    fallbackEnabled?: boolean;
+    validateBeforeExecution?: boolean;
+    timeoutMs?: number;
+}
+/**
+ * Unified MCP Registry that combines all sources
+ */
+export declare class UnifiedMCPRegistry {
+    private configPath;
+    private config;
+    private manualServers;
+    private autoServers;
+    private defaultServers;
+    private autoRegistryInstance;
+    private lastAutoDiscovery;
+    private autoDiscoveryCacheMs;
+    private _isInitialized;
+    constructor(configPath?: string);
+    /**
+     * Check if the registry has been initialized
+     */
+    get isInitialized(): boolean;
+    /**
+     * Load MCP configuration with defaults
+     */
+    private loadConfig;
+    /**
+     * Save configuration to file
+     */
+    private saveConfig;
+    /**
+     * Initialize the unified registry by loading all server sources
+     */
+    initialize(): Promise<void>;
+    /**
+     * Mark all discovered servers as available for lazy activation
+     */
+    private markServersAsAvailable;
+    /**
+     * Load manual servers from configuration
+     */
+    private loadManualServers;
+    /**
+     * Load auto-discovered servers
+     */
+    private loadAutoDiscoveredServers;
+    /**
+     * Load default registry tools
+     */
+    private loadDefaultRegistryTools;
+    /**
+     * Execute a tool using unified registry with fallback
+     */
+    executeTool(toolName: string, params: unknown, context: NeuroLinkExecutionContext, options?: UnifiedExecutionOptions): Promise<ToolResult>;
+    /**
+     * Execute tool from specific source
+     */
+    private executeFromSource;
+    /**
+     * Execute tool from manual configuration
+     */
+    private executeFromManualConfig;
+    /**
+     * Execute MCP tool using manual server configuration
+     */
+    private executeMCPTool;
+    /**
+     * Execute tool from auto-registered servers
+     */
+    private executeFromAutoRegistry;
+    /**
+     * Execute tool from default registry
+     */
+    private executeFromDefaultRegistry;
+    /**
+     * Get execution order based on preferences and tool type
+     */
+    private getExecutionOrder;
+    /**
+     * List all available tools from all sources
+     */
+    listAllTools(criteria?: ToolSearchCriteria & {
+        source?: "manual" | "auto" | "default";
+    }): Promise<Array<{
+        name: string;
+        server: string;
+        source: "manual" | "auto" | "default";
+        description?: string;
+        category?: string;
+        isImplemented?: boolean;
+    }>>;
+    /**
+     * List all servers from all sources
+     */
+    listAllServers(): UnifiedServerEntry[];
+    /**
+     * Get total server count across all sources
+     */
+    getTotalServerCount(): number;
+    /**
+     * Add a manual server configuration
+     */
+    addManualServer(serverId: string, config: MCPServerConfig): void;
+    /**
+     * Remove a manual server configuration
+     */
+    removeManualServer(serverId: string): boolean;
+    /**
+     * Update auto-discovery configuration
+     */
+    updateAutoDiscoveryConfig(config: Partial<EnhancedMCPConfig["autoDiscovery"]>): void;
+    /**
+     * Force refresh of auto-discovered servers
+     */
+    refreshAutoDiscovery(): Promise<void>;
+    /**
+     * Get current configuration
+     */
+    getConfig(): EnhancedMCPConfig;
+    /**
+     * Get registry statistics
+     */
+    getStats(): {
+        manual: {
+            servers: number;
+            tools: number;
+        };
+        auto: {
+            servers: number;
+            tools: number;
+        };
+        default: {
+            servers: number;
+            tools: number;
+        };
+        total: {
+            servers: number;
+            tools: number;
+        };
+    };
+    /**
+     * Get auto-discovered servers
+     */
+    getAutoDiscoveredServers(): Map<string, UnifiedServerEntry>;
+    /**
+     * Get manual servers
+     */
+    getManualServers(): Map<string, UnifiedServerEntry>;
+    /**
+     * Get server summary with counts and status
+     */
+    getServerSummary(): {
+        manual: {
+            servers: number;
+            tools: number;
+        };
+        auto: {
+            servers: number;
+            tools: number;
+        };
+        default: {
+            servers: number;
+            tools: number;
+        };
+        total: {
+            servers: number;
+            tools: number;
+        };
+    };
+    /**
+     * Activate discovered servers by testing connectivity and loading available tools
+     */
+    private activateDiscoveredServers;
+    /**
+     * Activate a single server by testing connectivity and loading tools
+     */
+    private activateServer;
+    /**
+     * Test server connectivity
+     */
+    private testServerConnectivity;
+    /**
+     * Load tools from a server
+     */
+    private loadServerTools;
+    /**
+     * Properly cleanup child process and its streams to prevent hanging
+     */
+    private cleanupChildProcess;
+    /**
+     * Create a server instance from config and tools
+     */
+    private createServerInstance;
+    /**
+     * Get count of activated servers
+     */
+    getAvailableServerCount(): number;
+    /**
+     * Get count of tools from activated servers
+     */
+    private getActivatedToolCount;
+    /**
+     * Activate a server on-demand when its tools are first requested
+     */
+    lazyActivateServer(serverId: string, entry: UnifiedServerEntry): Promise<boolean>;
+}
+/**
+ * Default unified registry instance
+ */
+export declare const defaultUnifiedRegistry: UnifiedMCPRegistry;