@juspay/neurolink/dist/lib/mcp/mcpCircuitBreaker.d.ts

Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and

/**
 * MCP Circuit Breaker
 * Implements circuit breaker pattern for external MCP operations
 * Provides fault tolerance and prevents cascading failures
 */
import { EventEmitter } from "events";
/**
 * Circuit breaker states
 */
export type CircuitBreakerState = "closed" | "open" | "half-open";
/**
 * Circuit breaker configuration
 */
export interface CircuitBreakerConfig {
    /** Number of failures before opening the circuit */
    failureThreshold: number;
    /** Time to wait before attempting reset (milliseconds) */
    resetTimeout: number;
    /** Maximum calls allowed in half-open state */
    halfOpenMaxCalls: number;
    /** Timeout for individual operations (milliseconds) */
    operationTimeout: number;
    /** Minimum number of calls before calculating failure rate */
    minimumCallsBeforeCalculation: number;
    /** Window size for calculating failure rate (milliseconds) */
    statisticsWindowSize: number;
}
/**
 * Circuit breaker statistics
 */
export interface CircuitBreakerStats {
    /** Current state */
    state: CircuitBreakerState;
    /** Total number of calls */
    totalCalls: number;
    /** Number of successful calls */
    successfulCalls: number;
    /** Number of failed calls */
    failedCalls: number;
    /** Current failure rate (0-1) */
    failureRate: number;
    /** Calls in current time window */
    windowCalls: number;
    /** Last state change timestamp */
    lastStateChange: Date;
    /** Next retry time (for open state) */
    nextRetryTime?: Date;
    /** Half-open call count */
    halfOpenCalls: number;
}
/**
 * Circuit breaker events
 */
export interface CircuitBreakerEvents {
    stateChange: {
        oldState: CircuitBreakerState;
        newState: CircuitBreakerState;
        reason: string;
        timestamp: Date;
    };
    callSuccess: {
        duration: number;
        timestamp: Date;
    };
    callFailure: {
        error: string;
        duration: number;
        timestamp: Date;
    };
    circuitOpen: {
        failureRate: number;
        totalCalls: number;
        timestamp: Date;
    };
    circuitHalfOpen: {
        timestamp: Date;
    };
    circuitClosed: {
        timestamp: Date;
    };
}
/**
 * MCPCircuitBreaker
 * Implements circuit breaker pattern for fault tolerance
 */
export declare class MCPCircuitBreaker extends EventEmitter {
    private name;
    private state;
    private config;
    private callHistory;
    private lastFailureTime;
    private halfOpenCalls;
    private lastStateChange;
    private cleanupTimer?;
    constructor(name: string, config?: Partial<CircuitBreakerConfig>);
    /**
     * Execute an operation with circuit breaker protection
     */
    execute<T>(operation: () => Promise<T>): Promise<T>;
    /**
     * Record a call in the history
     */
    private recordCall;
    /**
     * Check if failure threshold is exceeded
     */
    private checkFailureThreshold;
    /**
     * Change circuit breaker state
     */
    private changeState;
    /**
     * Create a timeout promise
     */
    private timeoutPromise;
    /**
     * Clean up old call records
     */
    private cleanupCallHistory;
    /**
     * Get current statistics
     */
    getStats(): CircuitBreakerStats;
    /**
     * Manually reset the circuit breaker
     */
    reset(): void;
    /**
     * Force open the circuit breaker
     */
    forceOpen(reason?: string): void;
    /**
     * Get circuit breaker name
     */
    getName(): string;
    /**
     * Check if circuit is open
     */
    isOpen(): boolean;
    /**
     * Check if circuit is closed
     */
    isClosed(): boolean;
    /**
     * Check if circuit is half-open
     */
    isHalfOpen(): boolean;
    /**
     * Destroy the circuit breaker and clean up resources
     * This method should be called when the circuit breaker is no longer needed
     * to prevent memory leaks from the cleanup timer
     */
    destroy(): void;
}
/**
 * Circuit breaker manager for multiple circuit breakers
 */
export declare class CircuitBreakerManager {
    private breakers;
    /**
     * Get or create a circuit breaker
     */
    getBreaker(name: string, config?: Partial<CircuitBreakerConfig>): MCPCircuitBreaker;
    /**
     * Remove a circuit breaker and clean up its resources
     */
    removeBreaker(name: string): boolean;
    /**
     * Get all circuit breaker names
     */
    getBreakerNames(): string[];
    /**
     * Get statistics for all circuit breakers
     */
    getAllStats(): Record<string, CircuitBreakerStats>;
    /**
     * Reset all circuit breakers
     */
    resetAll(): void;
    /**
     * Get health summary
     */
    getHealthSummary(): {
        totalBreakers: number;
        closedBreakers: number;
        openBreakers: number;
        halfOpenBreakers: number;
        unhealthyBreakers: string[];
    };
    /**
     * Destroy all circuit breakers and clean up their resources
     * This should be called during application shutdown to prevent memory leaks
     */
    destroyAll(): void;
}
export declare const globalCircuitBreakerManager: CircuitBreakerManager;