@juspay/neurolink 3.0.1 → 4.1.0

package/dist/mcp/transport-manager.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Transport Manager for MCP connections
+ * Supports stdio, SSE, and HTTP transports with reconnection logic
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { z } from "zod";
+import { ErrorManager } from "./error-manager.js";
+export declare const TransportConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"stdio">;
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: "stdio";
+    command: string;
+    args?: string[] | undefined;
+    cwd?: string | undefined;
+    env?: Record<string, string> | undefined;
+}, {
+    type: "stdio";
+    command: string;
+    args?: string[] | undefined;
+    cwd?: string | undefined;
+    env?: Record<string, string> | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"sse">;
+    url: z.ZodString;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    maxRetryTime: z.ZodDefault<z.ZodNumber>;
+    withCredentials: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "sse";
+    timeout: number;
+    url: string;
+    maxRetryTime: number;
+    withCredentials: boolean;
+    headers?: Record<string, string> | undefined;
+}, {
+    type: "sse";
+    url: string;
+    timeout?: number | undefined;
+    headers?: Record<string, string> | undefined;
+    maxRetryTime?: number | undefined;
+    withCredentials?: boolean | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"http">;
+    url: z.ZodString;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "http";
+    timeout: number;
+    url: string;
+    headers?: Record<string, string> | undefined;
+}, {
+    type: "http";
+    url: string;
+    timeout?: number | undefined;
+    headers?: Record<string, string> | undefined;
+}>]>;
+export type TransportConfig = z.infer<typeof TransportConfigSchema>;
+export interface TransportStatus {
+    connected: boolean;
+    type: "stdio" | "sse" | "http";
+    lastConnected?: Date;
+    lastError?: Error;
+    reconnectAttempts: number;
+}
+export interface TransportManagerOptions {
+    autoReconnect?: boolean;
+    maxReconnectAttempts?: number;
+    reconnectDelay?: number;
+    healthCheckInterval?: number;
+    jitterEnabled?: boolean;
+    maxJitter?: number;
+}
+/**
+ * Manages MCP transport connections with automatic reconnection and health monitoring
+ */
+export declare class TransportManager {
+    private errorManager;
+    private options;
+    private client?;
+    private config?;
+    private status;
+    private reconnectTimer?;
+    private healthCheckTimer?;
+    private reconnectPromise?;
+    constructor(errorManager: ErrorManager, options?: TransportManagerOptions);
+    /**
+     * Connect to MCP server using specified transport
+     */
+    connect(config: TransportConfig): Promise<Client>;
+    /**
+     * Create transport based on configuration
+     */
+    createTransport(config: TransportConfig): Promise<any>;
+    /**
+     * Create stdio transport
+     */
+    private createStdioTransport;
+    /**
+     * Create SSE transport with reconnection support
+     */
+    private createSSETransport;
+    /**
+     * Create HTTP transport
+     */
+    private createHTTPTransport;
+    /**
+     * Set up health monitoring
+     */
+    private setupHealthMonitoring;
+    /**
+     * Handle connection errors
+     */
+    private handleConnectionError;
+    /**
+     * Schedule reconnection attempt
+     */
+    private scheduleReconnect;
+    /**
+     * Calculate reconnect delay with exponential backoff
+     */
+    private calculateReconnectDelay;
+    /**
+     * Reconnect to server
+     */
+    reconnect(): Promise<void>;
+    private _reconnect;
+    /**
+     * Disconnect from server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get current transport status
+     */
+    getStatus(): TransportStatus;
+    /**
+     * Get connected client
+     */
+    getClient(): Client | undefined;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Reset reconnection attempts
+     */
+    resetReconnectAttempts(): void;
+}

package/dist/mcp/transport-manager.js

@@ -0,0 +1,331 @@
+/**
+ * Transport Manager for MCP connections
+ * Supports stdio, SSE, and HTTP transports with reconnection logic
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { z } from "zod";
+import { ErrorManager } from "./error-manager.js";
+import { ErrorCategory, ErrorSeverity } from "./error-manager.js";
+// Transport configuration schemas
+export const TransportConfigSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("stdio"),
+        command: z.string(),
+        args: z.array(z.string()).optional(),
+        cwd: z.string().optional(),
+        env: z.record(z.string()).optional(),
+    }),
+    z.object({
+        type: z.literal("sse"),
+        url: z.string().url(),
+        headers: z.record(z.string()).optional(),
+        timeout: z.number().min(5).default(30),
+        maxRetryTime: z.number().default(5000),
+        withCredentials: z.boolean().default(false),
+    }),
+    z.object({
+        type: z.literal("http"),
+        url: z.string().url(),
+        headers: z.record(z.string()).optional(),
+        timeout: z.number().min(5).default(30),
+    }),
+]);
+/**
+ * Manages MCP transport connections with automatic reconnection and health monitoring
+ */
+export class TransportManager {
+    errorManager;
+    options;
+    client;
+    config;
+    status;
+    reconnectTimer;
+    healthCheckTimer;
+    reconnectPromise;
+    constructor(errorManager, options = {}) {
+        this.errorManager = errorManager;
+        this.options = options;
+        // Initialize default options
+        this.options = {
+            jitterEnabled: true,
+            maxJitter: 1000,
+            ...this.options,
+        };
+        this.status = {
+            connected: false,
+            type: "stdio",
+            reconnectAttempts: 0,
+        };
+        // Apply defaults
+        this.options = {
+            autoReconnect: true,
+            maxReconnectAttempts: 5,
+            reconnectDelay: 1000,
+            healthCheckInterval: 30000,
+            ...options,
+        };
+    }
+    /**
+     * Connect to MCP server using specified transport
+     */
+    async connect(config) {
+        try {
+            // Validate configuration
+            const validatedConfig = TransportConfigSchema.parse(config);
+            this.config = validatedConfig;
+            this.status.type = validatedConfig.type;
+            // Disconnect existing client if any
+            if (this.client) {
+                await this.disconnect();
+            }
+            // Create transport based on type
+            const transport = await this.createTransport(validatedConfig);
+            // Create MCP client
+            this.client = new Client({
+                name: "neurolink-mcp-client",
+                version: "1.0.0",
+            }, {
+                capabilities: {},
+            });
+            // Connect client
+            await this.client.connect(transport);
+            // Update status
+            this.status.connected = true;
+            this.status.lastConnected = new Date();
+            this.status.reconnectAttempts = 0;
+            // Set up health monitoring if enabled
+            if (this.options.healthCheckInterval &&
+                this.options.healthCheckInterval > 0) {
+                this.setupHealthMonitoring();
+            }
+            return this.client;
+        }
+        catch (error) {
+            this.handleConnectionError(error);
+            throw error;
+        }
+    }
+    /**
+     * Create transport based on configuration
+     */
+    async createTransport(config) {
+        switch (config.type) {
+            case "stdio":
+                return this.createStdioTransport(config);
+            case "sse":
+                return this.createSSETransport(config);
+            case "http":
+                return this.createHTTPTransport(config);
+            default:
+                throw new Error(`Unsupported transport type: ${config.type}`);
+        }
+    }
+    /**
+     * Create stdio transport
+     */
+    createStdioTransport(config) {
+        // Filter out undefined values from process.env
+        const envWithoutUndefined = Object.fromEntries(Object.entries(process.env).filter(([_, value]) => value !== undefined));
+        // StdioClientTransport handles process creation internally
+        return new StdioClientTransport({
+            command: config.command,
+            args: config.args ?? [],
+            env: { ...envWithoutUndefined, ...config.env },
+            cwd: config.cwd,
+        });
+    }
+    /**
+     * Create SSE transport with reconnection support
+     */
+    async createSSETransport(config) {
+        // Dynamically import SSE transport
+        const { SSEClientTransport } = await import("@modelcontextprotocol/sdk/client/sse.js");
+        // Use ReconnectingEventSource for reliability
+        const ReconnectingEventSource = await import("reconnecting-eventsource").then((m) => m.default);
+        return new SSEClientTransport(new URL(config.url), {
+            requestInit: {
+                headers: config.headers,
+                ...(config.timeout && { timeout: config.timeout }),
+            },
+            eventSourceInit: {
+                eventSource: ReconnectingEventSource,
+                max_retry_time: config.maxRetryTime,
+                withCredentials: config.withCredentials,
+            },
+        });
+    }
+    /**
+     * Create HTTP transport
+     */
+    async createHTTPTransport(config) {
+        // Dynamically import HTTP transport
+        const httpModule = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+        const HTTPClientTransport = httpModule.default || httpModule.HTTPClientTransport;
+        return new HTTPClientTransport(new URL(config.url), {
+            requestInit: {
+                headers: config.headers,
+                timeout: config.timeout * 1000, // Convert seconds to milliseconds
+            },
+        });
+    }
+    /**
+     * Set up health monitoring
+     */
+    setupHealthMonitoring() {
+        if (!this.client) {
+            return;
+        }
+        // Clear any existing health check timer
+        if (this.healthCheckTimer) {
+            clearInterval(this.healthCheckTimer);
+        }
+        // Set up periodic health checks
+        this.healthCheckTimer = setInterval(async () => {
+            if (!this.client) {
+                return;
+            }
+            try {
+                // Simple health check - list tools
+                await this.client.request({ method: "tools/list" }, z.object({ tools: z.array(z.any()) }));
+            }
+            catch (error) {
+                // Health check failed, trigger reconnection if enabled
+                if (this.options.autoReconnect && this.config) {
+                    this.handleConnectionError(error);
+                }
+            }
+        }, this.options.healthCheckInterval);
+    }
+    /**
+     * Handle connection errors
+     */
+    handleConnectionError(error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.status.connected = false;
+        this.status.lastError = err;
+        // Record error
+        this.errorManager.recordError(err, {
+            category: ErrorCategory.CONNECTION_ERROR,
+            severity: ErrorSeverity.HIGH,
+            toolName: "transport-manager",
+            parameters: {
+                transport: this.status.type,
+                reconnectAttempts: this.status.reconnectAttempts,
+            },
+        });
+        // Attempt reconnection if enabled
+        if (this.options.autoReconnect &&
+            this.status.reconnectAttempts < this.options.maxReconnectAttempts) {
+            // Schedule reconnection attempt
+            this.scheduleReconnect();
+        }
+    }
+    /**
+     * Schedule reconnection attempt
+     */
+    scheduleReconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+        }
+        // Increment attempts BEFORE calculating delay (uses updated attempt count)
+        this.status.reconnectAttempts++;
+        const delay = this.calculateReconnectDelay();
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnect().catch((error) => {
+                console.error("Reconnection failed:", error);
+            });
+        }, delay);
+    }
+    /**
+     * Calculate reconnect delay with exponential backoff
+     */
+    calculateReconnectDelay() {
+        const baseDelay = this.options.reconnectDelay || 1000;
+        const maxDelay = 30000; // 30 seconds max
+        const delay = Math.min(baseDelay * Math.pow(2, this.status.reconnectAttempts), maxDelay);
+        // Add configurable jitter to prevent thundering herd
+        if (this.options.jitterEnabled === true) {
+            const maxJitter = this.options.maxJitter || 1000;
+            return delay + Math.random() * maxJitter;
+        }
+        return delay;
+    }
+    /**
+     * Reconnect to server
+     */
+    async reconnect() {
+        // Prevent concurrent reconnection attempts
+        if (this.reconnectPromise) {
+            return this.reconnectPromise;
+        }
+        this.reconnectPromise = this._reconnect();
+        try {
+            await this.reconnectPromise;
+        }
+        finally {
+            this.reconnectPromise = undefined;
+        }
+    }
+    async _reconnect() {
+        if (!this.config) {
+            throw new Error("No configuration available for reconnection");
+        }
+        try {
+            await this.connect(this.config);
+            console.log(`Reconnected successfully after ${this.status.reconnectAttempts} attempts`);
+        }
+        catch (error) {
+            if (this.status.reconnectAttempts >= this.options.maxReconnectAttempts) {
+                throw new Error(`Max reconnection attempts (${this.options.maxReconnectAttempts}) reached`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Disconnect from server
+     */
+    async disconnect() {
+        // Clear reconnection timer
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        // Stop health monitoring
+        if (this.healthCheckTimer) {
+            clearInterval(this.healthCheckTimer);
+            this.healthCheckTimer = undefined;
+        }
+        // Close client connection
+        if (this.client) {
+            await this.client.close();
+            this.client = undefined;
+        }
+        // Update status
+        this.status.connected = false;
+    }
+    /**
+     * Get current transport status
+     */
+    getStatus() {
+        return { ...this.status };
+    }
+    /**
+     * Get connected client
+     */
+    getClient() {
+        return this.client;
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.status.connected && this.client !== undefined;
+    }
+    /**
+     * Reset reconnection attempts
+     */
+    resetReconnectAttempts() {
+        this.status.reconnectAttempts = 0;
+    }
+}

package/dist/mcp/unified-mcp.js

@@ -139,6 +139,11 @@ export class UnifiedMCPSystem {
         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: {
@@ -150,7 +155,7 @@ export class UnifiedMCPSystem {
                 connected: externalStatus.connected,
                 tools: externalStatus.totalTools,
             },
-            totalTools: registryStats.totalTools,
+            totalTools,
             registryStats,
         };
     }

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

@@ -3,15 +3,21 @@
  */
 import type { DiscoveredMCP, ExecutionContext } from "./contracts/mcp-contract.js";
 import type { DiscoveryOptions } from "./auto-discovery.js";
-import { MCPToolRegistry, type ToolInfo, type ToolExecutionResult } from "./tool-registry.js";
+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
      */
@@ -47,7 +53,7 @@ export declare class UnifiedMCPRegistry extends MCPToolRegistry {
     /**
      * Execute a tool through the registry
      */
-    executeTool(toolName: string, args: any, context: ExecutionContext): Promise<ToolExecutionResult>;
+    executeTool<T = unknown>(toolName: string, args?: unknown, context?: ExecutionContext): Promise<T>;
     /**
      * Lazily activate a server by ID
      */
@@ -57,9 +63,17 @@ export declare class UnifiedMCPRegistry extends MCPToolRegistry {
      */
     registerManualServer(id: string, server: any): void;
     /**
-     * Get registry statistics
+     * Get registry statistics (override parent method)
      */
-    getStats(): Promise<{
+    getStats(): Record<string, {
+        count: number;
+        averageTime: number;
+        totalTime: number;
+    }>;
+    /**
+     * Get detailed registry statistics
+     */
+    getDetailedStats(): Promise<{
         total: number;
         bySource: Record<string, number>;
         byType: Record<string, number>;
@@ -72,9 +86,44 @@ export declare class UnifiedMCPRegistry extends MCPToolRegistry {
         tools?: number;
     }>;
     /**
-     * Clear all registries
+     * 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>;
 }
 /**
  * Default unified registry instance