@juspay/neurolink 6.1.0 → 6.2.0

package/dist/mcp/error-recovery.js

@@ -1,405 +0,0 @@
-/**
- * NeuroLink Error Recovery System
- * Implements circuit breaker, retry strategies, and pattern detection
- * Based on resilience patterns from reference implementations
- */
-/**
- * Circuit breaker states
- */
-export var CircuitState;
-(function (CircuitState) {
-    CircuitState["CLOSED"] = "CLOSED";
-    CircuitState["OPEN"] = "OPEN";
-    CircuitState["HALF_OPEN"] = "HALF_OPEN";
-})(CircuitState || (CircuitState = {}));
-/**
- * Circuit breaker instance
- */
-class CircuitBreaker {
-    config;
-    state = CircuitState.CLOSED;
-    failures = 0;
-    successes = 0;
-    lastFailureTime = 0;
-    nextAttemptTime = 0;
-    constructor(config) {
-        this.config = config;
-    }
-    /**
-     * Check if request should be allowed
-     */
-    canExecute() {
-        const now = Date.now();
-        switch (this.state) {
-            case CircuitState.CLOSED:
-                return true;
-            case CircuitState.OPEN:
-                if (now >= this.nextAttemptTime) {
-                    this.state = CircuitState.HALF_OPEN;
-                    this.successes = 0;
-                    return true;
-                }
-                return false;
-            case CircuitState.HALF_OPEN:
-                return true;
-            default:
-                return false;
-        }
-    }
-    /**
-     * Record success
-     */
-    recordSuccess() {
-        this.failures = 0;
-        if (this.state === CircuitState.HALF_OPEN) {
-            this.successes++;
-            if (this.successes >= this.config.successThreshold) {
-                this.state = CircuitState.CLOSED;
-            }
-        }
-    }
-    /**
-     * Record failure
-     */
-    recordFailure() {
-        const now = Date.now();
-        // Reset failure count if outside monitoring period
-        if (now - this.lastFailureTime > this.config.monitoringPeriod) {
-            this.failures = 0;
-        }
-        this.failures++;
-        this.lastFailureTime = now;
-        if (this.state === CircuitState.HALF_OPEN) {
-            this.state = CircuitState.OPEN;
-            this.nextAttemptTime = now + this.config.resetTimeout;
-        }
-        else if (this.failures >= this.config.failureThreshold) {
-            this.state = CircuitState.OPEN;
-            this.nextAttemptTime = now + this.config.resetTimeout;
-        }
-    }
-    /**
-     * Get current state
-     */
-    getState() {
-        return this.state;
-    }
-}
-/**
- * Error Recovery Manager
- */
-export class ErrorRecovery {
-    circuitBreakers = new Map();
-    errorPatterns = [];
-    recoveryHistory = new Map();
-    defaultRetryConfig = {
-        maxAttempts: 3,
-        initialDelay: 1000,
-        maxDelay: 30000,
-        backoffMultiplier: 2,
-        jitter: true,
-    };
-    defaultCircuitConfig = {
-        failureThreshold: 5,
-        resetTimeout: 60000,
-        successThreshold: 2,
-        monitoringPeriod: 60000,
-    };
-    constructor() {
-        this.initializeDefaultPatterns();
-    }
-    /**
-     * Initialize default error patterns
-     */
-    initializeDefaultPatterns() {
-        // Network timeout pattern
-        this.addPattern({
-            id: "network-timeout",
-            name: "Network Timeout Pattern",
-            description: "Repeated network timeouts indicating connectivity issues",
-            matcher: (errors) => {
-                const recentErrors = errors.slice(-5);
-                return (recentErrors.length >= 3 &&
-                    recentErrors.every((e) => e.category === "TIMEOUT_ERROR"));
-            },
-            severity: "HIGH",
-            recoveryStrategy: {
-                type: "retry",
-                config: {
-                    maxAttempts: 5,
-                    initialDelay: 2000,
-                    maxDelay: 60000,
-                    backoffMultiplier: 3,
-                    jitter: true,
-                },
-            },
-        });
-        // Rate limit pattern
-        this.addPattern({
-            id: "rate-limit",
-            name: "Rate Limit Pattern",
-            description: "API rate limit errors",
-            matcher: (errors) => {
-                const lastError = errors[errors.length - 1];
-                return (lastError &&
-                    (lastError.error.message.includes("429") ||
-                        lastError.error.message.toLowerCase().includes("rate limit")));
-            },
-            severity: "MEDIUM",
-            recoveryStrategy: {
-                type: "circuit-breaker",
-                config: {
-                    failureThreshold: 3,
-                    resetTimeout: 120000, // 2 minutes
-                    successThreshold: 1,
-                    monitoringPeriod: 60000,
-                },
-            },
-        });
-        // Configuration error pattern
-        this.addPattern({
-            id: "config-error",
-            name: "Configuration Error Pattern",
-            description: "Missing or invalid configuration",
-            matcher: (errors) => {
-                const lastError = errors[errors.length - 1];
-                return lastError?.category === "CONFIGURATION_ERROR";
-            },
-            severity: "CRITICAL",
-            recoveryStrategy: {
-                type: "manual",
-                action: async (context) => ({
-                    success: false,
-                    message: "Configuration error requires manual intervention. Check environment variables and config files.",
-                }),
-            },
-        });
-    }
-    /**
-     * Add error pattern
-     */
-    addPattern(pattern) {
-        this.errorPatterns.push(pattern);
-    }
-    /**
-     * Detect patterns in error history
-     */
-    detectPatterns(errors) {
-        return this.errorPatterns.filter((pattern) => pattern.matcher(errors));
-    }
-    /**
-     * Get circuit breaker for resource
-     */
-    getCircuitBreaker(resourceId, config) {
-        if (!this.circuitBreakers.has(resourceId)) {
-            this.circuitBreakers.set(resourceId, new CircuitBreaker(config || this.defaultCircuitConfig));
-        }
-        return this.circuitBreakers.get(resourceId);
-    }
-    /**
-     * Calculate retry delay with exponential backoff
-     */
-    calculateRetryDelay(attemptNumber, config) {
-        const exponentialDelay = config.initialDelay *
-            Math.pow(config.backoffMultiplier, attemptNumber - 1);
-        const delay = Math.min(exponentialDelay, config.maxDelay);
-        if (config.jitter) {
-            // Add random jitter (±25%)
-            const jitter = delay * 0.25 * (Math.random() * 2 - 1);
-            return Math.floor(delay + jitter);
-        }
-        return delay;
-    }
-    /**
-     * Attempt recovery for an error
-     */
-    async attemptRecovery(error, context) {
-        // Detect patterns
-        const patterns = this.detectPatterns([error]);
-        const pattern = patterns[0]; // Use first matching pattern
-        // Get recovery history
-        const historyKey = `${error.context.toolName || "unknown"}-${error.category}`;
-        const history = this.recoveryHistory.get(historyKey) || [];
-        // Build recovery context
-        const recoveryContext = {
-            error,
-            pattern,
-            attemptNumber: history.length + 1,
-            totalAttempts: 0,
-            previousAttempts: history,
-            executionContext: context,
-        };
-        // Determine recovery strategy
-        const strategy = pattern?.recoveryStrategy || this.getDefaultStrategy(error);
-        // Execute recovery
-        const startTime = Date.now();
-        let result;
-        try {
-            switch (strategy.type) {
-                case "retry":
-                    result = await this.executeRetryStrategy(recoveryContext, strategy.config);
-                    break;
-                case "circuit-breaker":
-                    result = await this.executeCircuitBreakerStrategy(recoveryContext, strategy.config);
-                    break;
-                case "fallback":
-                    result = await this.executeFallbackStrategy(recoveryContext, strategy.config);
-                    break;
-                case "manual":
-                    result = strategy.action
-                        ? await strategy.action(recoveryContext)
-                        : { success: false, message: "Manual intervention required" };
-                    break;
-                default:
-                    result = {
-                        success: false,
-                        message: "No recovery strategy available",
-                    };
-            }
-        }
-        catch (recoveryError) {
-            result = {
-                success: false,
-                message: `Recovery failed: ${recoveryError instanceof Error ? recoveryError.message : "Unknown error"}`,
-            };
-        }
-        // Record attempt
-        const attempt = {
-            timestamp: Date.now(),
-            strategy: strategy.type,
-            successful: result.success,
-            duration: Date.now() - startTime,
-            error: result.success
-                ? undefined
-                : new Error(result.message || "Recovery failed"),
-        };
-        history.push(attempt);
-        this.recoveryHistory.set(historyKey, history.slice(-10)); // Keep last 10 attempts
-        return result;
-    }
-    /**
-     * Execute retry strategy
-     */
-    async executeRetryStrategy(context, config) {
-        const retryConfig = config || this.defaultRetryConfig;
-        if (context.attemptNumber > retryConfig.maxAttempts) {
-            return {
-                success: false,
-                message: `Maximum retry attempts (${retryConfig.maxAttempts}) exceeded`,
-            };
-        }
-        const delay = this.calculateRetryDelay(context.attemptNumber, retryConfig);
-        return {
-            success: true,
-            nextAction: "retry",
-            delay,
-            message: `Retry attempt ${context.attemptNumber}/${retryConfig.maxAttempts} after ${delay}ms`,
-        };
-    }
-    /**
-     * Execute circuit breaker strategy
-     */
-    async executeCircuitBreakerStrategy(context, config) {
-        const resourceId = context.error.context.toolName || "default";
-        const circuitBreaker = this.getCircuitBreaker(resourceId, config);
-        if (!circuitBreaker.canExecute()) {
-            return {
-                success: false,
-                message: `Circuit breaker OPEN for ${resourceId}. Service temporarily unavailable.`,
-            };
-        }
-        // Record the failure for circuit breaker
-        circuitBreaker.recordFailure();
-        return {
-            success: true,
-            nextAction: circuitBreaker.getState() === CircuitState.OPEN ? "fail" : "retry",
-            message: `Circuit breaker state: ${circuitBreaker.getState()}`,
-        };
-    }
-    /**
-     * Execute fallback strategy
-     */
-    async executeFallbackStrategy(context, config) {
-        // In a real implementation, this would execute fallback logic
-        // For now, just indicate fallback should be used
-        return {
-            success: true,
-            fallbackUsed: true,
-            message: "Fallback strategy activated",
-        };
-    }
-    /**
-     * Get default recovery strategy based on error
-     */
-    getDefaultStrategy(error) {
-        switch (error.category) {
-            case "NETWORK_ERROR":
-            case "TIMEOUT_ERROR":
-                return {
-                    type: "retry",
-                    config: this.defaultRetryConfig,
-                };
-            case "CONFIGURATION_ERROR":
-            case "PERMISSION_ERROR":
-                return {
-                    type: "manual",
-                };
-            default:
-                return {
-                    type: "retry",
-                    config: {
-                        ...this.defaultRetryConfig,
-                        maxAttempts: 2,
-                    },
-                };
-        }
-    }
-    /**
-     * Get recovery statistics
-     */
-    getRecoveryStats() {
-        let totalAttempts = 0;
-        let successfulRecoveries = 0;
-        let failedRecoveries = 0;
-        // Calculate from history
-        for (const attempts of this.recoveryHistory.values()) {
-            for (const attempt of attempts) {
-                totalAttempts++;
-                if (attempt.successful) {
-                    successfulRecoveries++;
-                }
-                else {
-                    failedRecoveries++;
-                }
-            }
-        }
-        // Get circuit breaker states
-        const circuitBreakerStates = {};
-        for (const [id, breaker] of this.circuitBreakers) {
-            circuitBreakerStates[id] = breaker.getState();
-        }
-        return {
-            totalAttempts,
-            successfulRecoveries,
-            failedRecoveries,
-            circuitBreakerStates,
-            patternMatches: {}, // TODO: Track pattern matches
-        };
-    }
-    /**
-     * Reset circuit breaker
-     */
-    resetCircuitBreaker(resourceId) {
-        this.circuitBreakers.delete(resourceId);
-    }
-    /**
-     * Clear recovery history
-     */
-    clearHistory() {
-        this.recoveryHistory.clear();
-    }
-}
-/**
- * Default error recovery instance
- */
-export const defaultErrorRecovery = new ErrorRecovery();

package/dist/mcp/external-client.d.ts

@@ -1,88 +0,0 @@
-/**
- * NeuroLink External MCP Client
- * Connects to external MCP servers via stdio transport following MCP specification
- * Bridges external tools into NeuroLink's factory pattern ecosystem
- */
-import { EventEmitter } from "events";
-import type { NeuroLinkMCPTool, NeuroLinkExecutionContext, ToolResult } from "./factory.js";
-/**
- * External MCP Server Configuration
- */
-export interface ExternalMCPServerConfig {
-    name: string;
-    command: string;
-    args: string[];
-    transport: "stdio";
-    env?: Record<string, string>;
-    timeout?: number;
-    retryAttempts?: number;
-}
-/**
- * External MCP Client for stdio transport
- */
-export declare class ExternalMCPClient extends EventEmitter {
-    private config;
-    private process;
-    private isConnected;
-    private messageId;
-    private pendingRequests;
-    private tools;
-    private buffer;
-    constructor(config: ExternalMCPServerConfig);
-    /**
-     * Connect to the external MCP server
-     */
-    connect(): Promise<void>;
-    /**
-     * Initialize MCP session
-     */
-    private initialize;
-    /**
-     * Discover available tools from the server
-     */
-    private discoverTools;
-    /**
-     * Execute a tool on the external server
-     */
-    executeTool(toolName: string, params: unknown, context: NeuroLinkExecutionContext): Promise<ToolResult>;
-    /**
-     * Get available tools as NeuroLink MCP tools
-     */
-    getNeuroLinkTools(): Record<string, NeuroLinkMCPTool>;
-    /**
-     * Send a request to the MCP server
-     */
-    private sendRequest;
-    /**
-     * Handle incoming messages from the server
-     */
-    private handleMessage;
-    /**
-     * Process a parsed MCP message
-     */
-    private processMessage;
-    /**
-     * Disconnect from the server
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Check if connected
-     */
-    isConnectedToServer(): boolean;
-    /**
-     * Get server information
-     */
-    getServerInfo(): {
-        name: string;
-        command: string;
-        args: string[];
-        transport: "stdio";
-        isConnected: boolean;
-        toolCount: number;
-        tools: string[];
-    };
-}
-/**
- * Create an external MCP client
- */
-export declare function createExternalMCPClient(config: ExternalMCPServerConfig): ExternalMCPClient;