@juspay/neurolink 6.1.0 → 6.2.1

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

@@ -1,154 +0,0 @@
-/**
- * Transport Manager for MCP connections
- * Supports stdio, SSE, and HTTP transports with reconnection logic
- */
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.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<Transport>;
-    /**
-     * 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

@@ -1,335 +0,0 @@
-/**
- * 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;
-        if (!HTTPClientTransport || typeof HTTPClientTransport !== "function") {
-            throw new Error("HTTPClientTransport constructor not found");
-        }
-        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.d.ts

@@ -1,133 +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 type { NeuroLinkExecutionContext, ToolResult } from "./factory.js";
-/**
- * Unified MCP System Options
- */
-export interface UnifiedMCPOptions {
-    configPath?: string;
-    enableExternalServers?: boolean;
-    enableInternalServers?: boolean;
-    autoInitialize?: boolean;
-    registry?: MCPToolRegistry;
-}
-/**
- * Unified MCP System Status
- */
-export interface UnifiedMCPStatus {
-    isInitialized: boolean;
-    internalServers: {
-        count: number;
-        tools: number;
-    };
-    externalServers: {
-        configured: number;
-        connected: number;
-        tools: number;
-    };
-    totalTools: number;
-    registryStats: unknown;
-}
-/**
- * Unified MCP System
- * Central hub for managing both internal and external MCP servers
- */
-export declare class UnifiedMCPSystem {
-    private registry;
-    private externalManager;
-    private internalServers;
-    private isInitialized;
-    private options;
-    constructor(options?: UnifiedMCPOptions);
-    /**
-     * Initialize the unified MCP system
-     */
-    initialize(): Promise<void>;
-    /**
-     * Initialize internal MCP servers
-     */
-    private initializeInternalServers;
-    /**
-     * Initialize external MCP servers
-     */
-    private initializeExternalServers;
-    /**
-     * Execute a tool from any registered server
-     */
-    executeTool(toolName: string, params: unknown, context: NeuroLinkExecutionContext): Promise<ToolResult>;
-    /**
-     * List all available tools
-     */
-    listTools(criteria?: unknown): Promise<import("./tool-registry.js").ToolInfo[]>;
-    /**
-     * Get tool information
-     */
-    getToolInfo(toolName: string): {
-        tool: import("./tool-registry.js").ToolInfo;
-        server: {
-            id: string;
-        };
-    } | undefined;
-    /**
-     * Get registry instance
-     */
-    getRegistry(): MCPToolRegistry;
-    /**
-     * Get external manager instance
-     */
-    getExternalManager(): ExternalMCPManager;
-    /**
-     * Get comprehensive status
-     */
-    getStatus(): Promise<UnifiedMCPStatus>;
-    /**
-     * Refresh external connections
-     */
-    refreshExternalServers(): Promise<void>;
-    /**
-     * Shutdown the unified MCP system
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Check if system is initialized
-     */
-    isSystemInitialized(): boolean;
-}
-/**
- * Default unified MCP system instance
- */
-export declare const defaultUnifiedMCP: UnifiedMCPSystem;
-/**
- * Initialize the default unified MCP system
- */
-export declare function initializeMCP(options?: UnifiedMCPOptions): Promise<UnifiedMCPSystem>;
-/**
- * Get the default unified MCP system
- */
-export declare function getMCPSystem(): UnifiedMCPSystem;
-/**
- * Execute a tool using the default system
- */
-export declare function executeMCPTool(toolName: string, params: unknown, context: NeuroLinkExecutionContext): Promise<ToolResult>;
-/**
- * List all available MCP tools
- */
-export declare function listMCPTools(criteria?: unknown): Promise<import("./tool-registry.js").ToolInfo[]>;
-/**
- * Get MCP tool information
- */
-export declare function getMCPToolInfo(toolName: string): {
-    tool: import("./tool-registry.js").ToolInfo;
-    server: {
-        id: string;
-    };
-} | undefined;
-/**
- * Get unified MCP system status
- */
-export declare function getMCPStatus(): Promise<UnifiedMCPStatus>;