@juspay/neurolink 6.1.0 → 6.2.0

package/dist/mcp/error-manager.js

@@ -1,501 +0,0 @@
-/**
- * NeuroLink MCP Enhanced Error Handling System
- * Provides comprehensive error tracking, categorization, and debugging capabilities
- * Based on error accumulation patterns from Cline
- */
-import { ErrorRecovery, defaultErrorRecovery, } from "./error-recovery.js";
-/**
- * Error categories for classification
- */
-export var ErrorCategory;
-(function (ErrorCategory) {
-    ErrorCategory["TOOL_ERROR"] = "TOOL_ERROR";
-    ErrorCategory["NETWORK_ERROR"] = "NETWORK_ERROR";
-    ErrorCategory["VALIDATION_ERROR"] = "VALIDATION_ERROR";
-    ErrorCategory["TIMEOUT_ERROR"] = "TIMEOUT_ERROR";
-    ErrorCategory["PERMISSION_ERROR"] = "PERMISSION_ERROR";
-    ErrorCategory["CONFIGURATION_ERROR"] = "CONFIGURATION_ERROR";
-    ErrorCategory["CONNECTION_ERROR"] = "CONNECTION_ERROR";
-    ErrorCategory["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-})(ErrorCategory || (ErrorCategory = {}));
-/**
- * Error severity levels
- */
-export var ErrorSeverity;
-(function (ErrorSeverity) {
-    ErrorSeverity["LOW"] = "LOW";
-    ErrorSeverity["MEDIUM"] = "MEDIUM";
-    ErrorSeverity["HIGH"] = "HIGH";
-    ErrorSeverity["CRITICAL"] = "CRITICAL";
-})(ErrorSeverity || (ErrorSeverity = {}));
-/**
- * Enhanced Error Manager with accumulation and analysis capabilities
- */
-export class ErrorManager {
-    errorHistory = [];
-    maxHistorySize;
-    enableStackTrace;
-    autoRecovery;
-    errorRateWindow;
-    errorCounter = 0;
-    errorFrequency = new Map();
-    categoryCounts;
-    severityCounts;
-    errorRecovery;
-    constructor(options = {}) {
-        this.maxHistorySize = options.maxHistorySize || 1000;
-        this.enableStackTrace = options.enableStackTrace ?? true;
-        this.autoRecovery = options.autoRecovery ?? false;
-        this.errorRateWindow = options.errorRateWindow || 60000; // 1 minute default
-        // Initialize counters
-        this.categoryCounts = Object.values(ErrorCategory).reduce((acc, category) => ({ ...acc, [category]: 0 }), {});
-        this.severityCounts = Object.values(ErrorSeverity).reduce((acc, severity) => ({ ...acc, [severity]: 0 }), {});
-        // Initialize error recovery system
-        this.errorRecovery = defaultErrorRecovery;
-    }
-    /**
-     * Record an error with context
-     *
-     * @param error The error to record
-     * @param context Additional context about the error
-     * @returns The created error entry
-     */
-    async recordError(error, context = {}) {
-        // Ensure we have an Error object
-        let errorObj;
-        if (error instanceof Error) {
-            errorObj = error;
-        }
-        else if (error && typeof error === "object" && "message" in error) {
-            // Handle objects with message property
-            errorObj = new Error(String(error.message));
-        }
-        else if (error === null || error === undefined) {
-            errorObj = new Error("Unknown error");
-        }
-        else {
-            // Convert other types to string
-            errorObj = new Error(String(error));
-        }
-        // Determine category and severity
-        const category = context.category || this.categorizeError(errorObj);
-        const severity = context.severity || this.determineSeverity(errorObj, category);
-        // Create error entry
-        const entry = {
-            id: this.generateErrorId(),
-            timestamp: Date.now(),
-            category,
-            severity,
-            error: errorObj,
-            context: {
-                sessionId: context.sessionId,
-                toolName: context.toolName,
-                parameters: context.parameters,
-                executionContext: context.executionContext,
-            },
-        };
-        // Add stack trace if enabled
-        if (this.enableStackTrace && errorObj.stack) {
-            entry.stackTrace = errorObj.stack;
-        }
-        // Attempt recovery if enabled
-        if (this.autoRecovery) {
-            entry.recovery = await this.attemptRecovery(entry);
-        }
-        // Add to history (circular buffer)
-        this.addToHistory(entry);
-        // Update statistics
-        this.updateStatistics(entry);
-        // Log if debug mode
-        if (process.env.NEUROLINK_DEBUG === "true") {
-            console.error(`[ErrorManager] ${category} - ${severity}: ${errorObj.message}`, context);
-        }
-        return entry;
-    }
-    /**
-     * Get error history
-     *
-     * @param filter Optional filter criteria
-     * @returns Filtered error history
-     */
-    getErrorHistory(filter) {
-        let filtered = [...this.errorHistory];
-        if (filter) {
-            if (filter.category) {
-                filtered = filtered.filter((e) => e.category === filter.category);
-            }
-            if (filter.severity) {
-                filtered = filtered.filter((e) => e.severity === filter.severity);
-            }
-            if (filter.sessionId) {
-                filtered = filtered.filter((e) => e.context.sessionId === filter.sessionId);
-            }
-            if (filter.toolName) {
-                filtered = filtered.filter((e) => e.context.toolName === filter.toolName);
-            }
-            if (filter.since) {
-                filtered = filtered.filter((e) => e.timestamp >= filter.since);
-            }
-            if (filter.limit) {
-                filtered = filtered.slice(-filter.limit);
-            }
-        }
-        return filtered;
-    }
-    /**
-     * Get error statistics
-     *
-     * @returns Current error statistics
-     */
-    getStats() {
-        const recentErrors = this.getErrorHistory({
-            since: Date.now() - this.errorRateWindow,
-        });
-        const errorRate = (recentErrors.length / this.errorRateWindow) * 60000; // Per minute
-        // Find most frequent error
-        let mostFrequentError;
-        if (this.errorFrequency.size > 0) {
-            const [message, count] = Array.from(this.errorFrequency.entries()).sort((a, b) => b[1] - a[1])[0];
-            const category = this.errorHistory.find((e) => e.error.message === message)?.category ||
-                ErrorCategory.UNKNOWN_ERROR;
-            mostFrequentError = { message, count, category };
-        }
-        return {
-            totalErrors: this.errorCounter,
-            errorsByCategory: { ...this.categoryCounts },
-            errorsBySeverity: { ...this.severityCounts },
-            errorRate,
-            lastError: this.errorHistory[this.errorHistory.length - 1],
-            mostFrequentError,
-        };
-    }
-    /**
-     * Clear error history
-     */
-    clearHistory() {
-        this.errorHistory = [];
-        this.errorFrequency.clear();
-        if (process.env.NEUROLINK_DEBUG === "true") {
-            console.log("[ErrorManager] Error history cleared");
-        }
-    }
-    /**
-     * Get recovery suggestions for an error
-     *
-     * @param error The error entry
-     * @returns Recovery suggestion
-     */
-    getRecoverySuggestion(error) {
-        switch (error.category) {
-            case ErrorCategory.NETWORK_ERROR:
-                return "Check network connectivity and retry the operation";
-            case ErrorCategory.TIMEOUT_ERROR:
-                return "Increase timeout settings or optimize the operation";
-            case ErrorCategory.PERMISSION_ERROR:
-                return "Verify API keys and access permissions";
-            case ErrorCategory.VALIDATION_ERROR:
-                return "Check input parameters and data formats";
-            case ErrorCategory.CONFIGURATION_ERROR:
-                return "Review configuration settings and environment variables";
-            case ErrorCategory.TOOL_ERROR:
-                return "Check tool availability and dependencies";
-            default:
-                return "Review error details and contact support if issue persists";
-        }
-    }
-    /**
-     * Categorize error based on message and type
-     *
-     * @private
-     */
-    categorizeError(error) {
-        const message = error.message.toLowerCase();
-        const name = error.name?.toLowerCase() || "";
-        if (message.includes("network") ||
-            message.includes("fetch") ||
-            message.includes("connection") ||
-            name.includes("network")) {
-            return ErrorCategory.NETWORK_ERROR;
-        }
-        if (message.includes("timeout") ||
-            message.includes("timed out") ||
-            name.includes("timeout")) {
-            return ErrorCategory.TIMEOUT_ERROR;
-        }
-        if (message.includes("permission") ||
-            message.includes("unauthorized") ||
-            message.includes("forbidden") ||
-            message.includes("401") ||
-            message.includes("403")) {
-            return ErrorCategory.PERMISSION_ERROR;
-        }
-        if (message.includes("validation") ||
-            message.includes("invalid") ||
-            message.includes("required") ||
-            name.includes("validation")) {
-            return ErrorCategory.VALIDATION_ERROR;
-        }
-        if (message.includes("config") ||
-            message.includes("configuration") ||
-            message.includes("environment")) {
-            return ErrorCategory.CONFIGURATION_ERROR;
-        }
-        if (message.includes("tool") || message.includes("execution")) {
-            return ErrorCategory.TOOL_ERROR;
-        }
-        return ErrorCategory.UNKNOWN_ERROR;
-    }
-    /**
-     * Determine error severity
-     *
-     * @private
-     */
-    determineSeverity(error, category) {
-        // Critical errors
-        if (category === ErrorCategory.PERMISSION_ERROR ||
-            category === ErrorCategory.CONFIGURATION_ERROR) {
-            return ErrorSeverity.CRITICAL;
-        }
-        // High severity
-        if (category === ErrorCategory.NETWORK_ERROR ||
-            error.message.includes("fatal") ||
-            error.message.includes("critical")) {
-            return ErrorSeverity.HIGH;
-        }
-        // Medium severity
-        if (category === ErrorCategory.TIMEOUT_ERROR ||
-            category === ErrorCategory.TOOL_ERROR) {
-            return ErrorSeverity.MEDIUM;
-        }
-        // Low severity
-        return ErrorSeverity.LOW;
-    }
-    /**
-     * Add error to circular buffer
-     *
-     * @private
-     */
-    addToHistory(entry) {
-        this.errorHistory.push(entry);
-        // Maintain circular buffer size
-        if (this.errorHistory.length > this.maxHistorySize) {
-            this.errorHistory.shift();
-        }
-    }
-    /**
-     * Update error statistics
-     *
-     * @private
-     */
-    updateStatistics(entry) {
-        this.errorCounter++;
-        this.categoryCounts[entry.category]++;
-        this.severityCounts[entry.severity]++;
-        // Update frequency map
-        const message = entry.error.message;
-        this.errorFrequency.set(message, (this.errorFrequency.get(message) || 0) + 1);
-    }
-    /**
-     * Attempt automatic recovery
-     *
-     * @private
-     */
-    async attemptRecovery(entry) {
-        // Use the enhanced error recovery system
-        const recoveryResult = await this.errorRecovery.attemptRecovery(entry, entry.context.executionContext);
-        return {
-            attempted: true,
-            successful: recoveryResult.success,
-            recovered: recoveryResult.recovered,
-            fallbackUsed: recoveryResult.fallbackUsed,
-            nextAction: recoveryResult.nextAction,
-            delay: recoveryResult.delay,
-            suggestion: recoveryResult.message || this.getRecoverySuggestion(entry),
-        };
-    }
-    /**
-     * Generate unique error ID
-     *
-     * @private
-     */
-    generateErrorId() {
-        return `err-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-    }
-    /**
-     * Detect error patterns in recent history
-     *
-     * @param timeWindow Time window to analyze (ms)
-     * @returns Detected patterns with counts and severity
-     */
-    detectPatterns(timeWindow = 300000) {
-        const now = Date.now();
-        const recentErrors = this.errorHistory.filter((e) => now - e.timestamp <= timeWindow);
-        // Detect patterns
-        const patterns = this.errorRecovery.detectPatterns(recentErrors);
-        const patternResults = patterns.map((pattern) => {
-            const matchingErrors = recentErrors.filter((e) => pattern.matcher([e]));
-            return {
-                pattern: pattern.name,
-                count: matchingErrors.length,
-                errors: matchingErrors,
-                severity: pattern.severity,
-                recommendation: pattern.description,
-            };
-        });
-        // Detect correlations
-        const correlations = this.detectCorrelations(recentErrors);
-        return { patterns: patternResults, correlations };
-    }
-    /**
-     * Detect correlations between errors
-     *
-     * @private
-     */
-    detectCorrelations(errors) {
-        const correlations = [];
-        // Group errors by message
-        const errorGroups = new Map();
-        for (const error of errors) {
-            const key = error.error.message;
-            if (!errorGroups.has(key)) {
-                errorGroups.set(key, []);
-            }
-            errorGroups.get(key).push(error);
-        }
-        // Find correlations based on temporal proximity
-        const keys = Array.from(errorGroups.keys());
-        for (let i = 0; i < keys.length; i++) {
-            for (let j = i + 1; j < keys.length; j++) {
-                const errors1 = errorGroups.get(keys[i]);
-                const errors2 = errorGroups.get(keys[j]);
-                // Calculate correlation based on time proximity
-                let proximityCount = 0;
-                for (const e1 of errors1) {
-                    for (const e2 of errors2) {
-                        const timeDiff = Math.abs(e1.timestamp - e2.timestamp);
-                        if (timeDiff < 60000) {
-                            // Within 1 minute
-                            proximityCount++;
-                        }
-                    }
-                }
-                const correlation = proximityCount / Math.max(errors1.length, errors2.length);
-                if (correlation > 0.5) {
-                    correlations.push({
-                        error1: keys[i],
-                        error2: keys[j],
-                        correlation,
-                    });
-                }
-            }
-        }
-        return correlations;
-    }
-    /**
-     * Get error trends over time
-     *
-     * @param bucketSize Time bucket size in ms (default: 1 minute)
-     * @param timeWindow Total time window to analyze
-     * @returns Error counts per time bucket
-     */
-    getErrorTrends(bucketSize = 60000, timeWindow = 3600000) {
-        const now = Date.now();
-        const startTime = now - timeWindow;
-        const buckets = [];
-        // Initialize buckets
-        for (let time = startTime; time < now; time += bucketSize) {
-            buckets.push({
-                timestamp: time,
-                count: 0,
-                categories: Object.values(ErrorCategory).reduce((acc, cat) => ({ ...acc, [cat]: 0 }), {}),
-            });
-        }
-        // Fill buckets with error counts
-        for (const error of this.errorHistory) {
-            if (error.timestamp >= startTime && error.timestamp < now) {
-                const bucketIndex = Math.floor((error.timestamp - startTime) / bucketSize);
-                if (bucketIndex >= 0 && bucketIndex < buckets.length) {
-                    buckets[bucketIndex].count++;
-                    buckets[bucketIndex].categories[error.category]++;
-                }
-            }
-        }
-        return buckets;
-    }
-    /**
-     * Get recovery statistics
-     *
-     * @returns Recovery statistics from error recovery system
-     */
-    getRecoveryStats() {
-        return this.errorRecovery.getRecoveryStats();
-    }
-    /**
-     * Reset circuit breaker for specific resource
-     *
-     * @param resourceId Resource identifier (usually tool name)
-     */
-    resetCircuitBreaker(resourceId) {
-        this.errorRecovery.resetCircuitBreaker(resourceId);
-    }
-    /**
-     * Get error insights and recommendations
-     *
-     * @returns Insights based on error analysis
-     */
-    getInsights() {
-        const stats = this.getStats();
-        const patterns = this.detectPatterns();
-        const recoveryStats = this.getRecoveryStats();
-        const criticalIssues = [];
-        const recommendations = [];
-        // Check error rate
-        if (stats.errorRate > 10) {
-            criticalIssues.push(`High error rate: ${stats.errorRate.toFixed(1)} errors/minute`);
-            recommendations.push("Consider implementing rate limiting or increasing resources");
-        }
-        // Check critical errors
-        const criticalCount = stats.errorsBySeverity[ErrorSeverity.CRITICAL] || 0;
-        if (criticalCount > 0) {
-            criticalIssues.push(`${criticalCount} critical errors detected`);
-            recommendations.push("Review and address critical errors immediately");
-        }
-        // Check circuit breakers
-        const openBreakers = Object.entries(recoveryStats.circuitBreakerStates).filter(([_, state]) => state === "OPEN");
-        if (openBreakers.length > 0) {
-            criticalIssues.push(`${openBreakers.length} circuit breakers are OPEN`);
-            recommendations.push(`Services unavailable: ${openBreakers.map(([id]) => id).join(", ")}`);
-        }
-        // Check patterns
-        for (const pattern of patterns.patterns) {
-            if (pattern.count > 5 && pattern.severity === ErrorSeverity.HIGH) {
-                recommendations.push(pattern.recommendation);
-            }
-        }
-        // Calculate health score (0-100)
-        let healthScore = 100;
-        healthScore -= Math.min(stats.errorRate * 2, 30); // Up to -30 for error rate
-        healthScore -= criticalCount * 10; // -10 per critical error
-        healthScore -= openBreakers.length * 15; // -15 per open circuit breaker
-        healthScore = Math.max(0, healthScore);
-        return {
-            criticalIssues,
-            recommendations: [...new Set(recommendations)], // Remove duplicates
-            healthScore,
-        };
-    }
-}
-/**
- * Default error manager instance
- */
-export const defaultErrorManager = new ErrorManager();
-/**
- * Utility function to record error with default manager
- *
- * @param error Error to record
- * @param context Error context
- * @returns Error entry
- */
-export async function recordError(error, context) {
-    return defaultErrorManager.recordError(error, context);
-}

package/dist/mcp/error-recovery.d.ts

@@ -1,159 +0,0 @@
-/**
- * NeuroLink Error Recovery System
- * Implements circuit breaker, retry strategies, and pattern detection
- * Based on resilience patterns from reference implementations
- */
-import type { ErrorEntry, ErrorSeverity } from "./error-manager.js";
-import type { NeuroLinkExecutionContext } from "./factory.js";
-import type { UnknownRecord } from "../types/common.js";
-/**
- * Circuit breaker states
- */
-export declare enum CircuitState {
-    CLOSED = "CLOSED",// Normal operation
-    OPEN = "OPEN",// Failing, reject requests
-    HALF_OPEN = "HALF_OPEN"
-}
-/**
- * Retry strategy configuration
- */
-export interface RetryConfig extends UnknownRecord {
-    maxAttempts: number;
-    initialDelay: number;
-    maxDelay: number;
-    backoffMultiplier: number;
-    jitter: boolean;
-}
-/**
- * Circuit breaker configuration
- */
-export interface CircuitBreakerConfig extends UnknownRecord {
-    failureThreshold: number;
-    resetTimeout: number;
-    successThreshold: number;
-    monitoringPeriod: number;
-}
-/**
- * Error pattern for detection
- */
-export interface ErrorPattern {
-    id: string;
-    name: string;
-    description: string;
-    matcher: (errors: ErrorEntry[]) => boolean;
-    severity: ErrorSeverity;
-    recoveryStrategy: RecoveryStrategy;
-}
-/**
- * Recovery strategy
- */
-export interface RecoveryStrategy {
-    type: "retry" | "circuit-breaker" | "fallback" | "manual";
-    config?: UnknownRecord;
-    action?: (context: RecoveryContext) => Promise<RecoveryResult>;
-}
-/**
- * Recovery context
- */
-export interface RecoveryContext {
-    error: ErrorEntry;
-    pattern?: ErrorPattern;
-    attemptNumber: number;
-    totalAttempts: number;
-    previousAttempts: RecoveryAttempt[];
-    executionContext?: NeuroLinkExecutionContext;
-}
-/**
- * Recovery attempt record
- */
-export interface RecoveryAttempt {
-    timestamp: number;
-    strategy: string;
-    successful: boolean;
-    duration: number;
-    error?: Error;
-}
-/**
- * Recovery result
- */
-export interface RecoveryResult {
-    success: boolean;
-    recovered?: boolean;
-    fallbackUsed?: boolean;
-    nextAction?: "retry" | "fail" | "fallback";
-    delay?: number;
-    message?: string;
-}
-/**
- * Error Recovery Manager
- */
-export declare class ErrorRecovery {
-    private circuitBreakers;
-    private errorPatterns;
-    private recoveryHistory;
-    private defaultRetryConfig;
-    private defaultCircuitConfig;
-    constructor();
-    /**
-     * Initialize default error patterns
-     */
-    private initializeDefaultPatterns;
-    /**
-     * Add error pattern
-     */
-    addPattern(pattern: ErrorPattern): void;
-    /**
-     * Detect patterns in error history
-     */
-    detectPatterns(errors: ErrorEntry[]): ErrorPattern[];
-    /**
-     * Get circuit breaker for resource
-     */
-    private getCircuitBreaker;
-    /**
-     * Calculate retry delay with exponential backoff
-     */
-    private calculateRetryDelay;
-    /**
-     * Attempt recovery for an error
-     */
-    attemptRecovery(error: ErrorEntry, context?: NeuroLinkExecutionContext): Promise<RecoveryResult>;
-    /**
-     * Execute retry strategy
-     */
-    private executeRetryStrategy;
-    /**
-     * Execute circuit breaker strategy
-     */
-    private executeCircuitBreakerStrategy;
-    /**
-     * Execute fallback strategy
-     */
-    private executeFallbackStrategy;
-    /**
-     * Get default recovery strategy based on error
-     */
-    private getDefaultStrategy;
-    /**
-     * Get recovery statistics
-     */
-    getRecoveryStats(): {
-        totalAttempts: number;
-        successfulRecoveries: number;
-        failedRecoveries: number;
-        circuitBreakerStates: Record<string, CircuitState>;
-        patternMatches: Record<string, number>;
-    };
-    /**
-     * Reset circuit breaker
-     */
-    resetCircuitBreaker(resourceId: string): void;
-    /**
-     * Clear recovery history
-     */
-    clearHistory(): void;
-}
-/**
- * Default error recovery instance
- */
-export declare const defaultErrorRecovery: ErrorRecovery;