gmail-mcp-server/dist/utils/error-handling-resilience.d.ts

Gmail MCP Server with on-demand authentication for SIYA/Claude Desktop. Complete Gmail integration with multi-user support and OAuth2 security.

/**
 * Error Handling & Resilience System
 * Provides comprehensive error handling, retry mechanisms, circuit breakers, and graceful degradation
 */
export interface RetryConfig {
    maxAttempts: number;
    baseDelayMs: number;
    maxDelayMs: number;
    backoffMultiplier: number;
    jitterPercent: number;
}
export interface CircuitBreakerConfig {
    failureThreshold: number;
    recoveryTimeoutMs: number;
    monitoringWindowMs: number;
}
export interface TimeoutConfig {
    operationTimeoutMs: number;
    connectionTimeoutMs: number;
}
export interface ResilienceConfig {
    retry: RetryConfig;
    circuitBreaker: CircuitBreakerConfig;
    timeout: TimeoutConfig;
    enableGracefulDegradation: boolean;
}
export type ErrorType = 'RATE_LIMITED' | 'NETWORK_ERROR' | 'AUTHENTICATION_ERROR' | 'TIMEOUT_ERROR' | 'API_ERROR' | 'PARSING_ERROR' | 'UNKNOWN_ERROR';
export interface ErrorContext {
    operation: string;
    attempt: number;
    totalTime: number;
    errorType: ErrorType;
    retryable: boolean;
    metadata?: Record<string, any>;
}
export declare class ResilientError extends Error {
    readonly errorType: ErrorType;
    readonly retryable: boolean;
    readonly context?: ErrorContext | undefined;
    constructor(message: string, errorType: ErrorType, retryable?: boolean, context?: ErrorContext | undefined);
}
/**
 * Exponential Backoff Retry Manager
 */
export declare class RetryManager {
    private config;
    constructor(config?: Partial<RetryConfig>);
    executeWithRetry<T>(operation: () => Promise<T>, operationName: string, customConfig?: Partial<RetryConfig>): Promise<T>;
    private classifyError;
    private isRetryable;
    private calculateDelay;
    private sleep;
}
/**
 * Circuit Breaker Pattern Implementation
 */
export declare class CircuitBreaker {
    private state;
    private failureCount;
    private successCount;
    private lastFailureTime;
    private config;
    constructor(config?: Partial<CircuitBreakerConfig>);
    execute<T>(operation: () => Promise<T>, operationName: string): Promise<T>;
    private onSuccess;
    private onFailure;
    getState(): string;
    getStats(): {
        state: string;
        failureCount: number;
        successCount: number;
    };
}
/**
 * Rate Limiting Handler
 */
export declare class RateLimitHandler {
    private rateLimitedUntil;
    private requestCount;
    private windowStart;
    private readonly windowSizeMs;
    private readonly maxRequestsPerWindow;
    handleRateLimit(error: any): Promise<void>;
    checkRateLimit(): Promise<void>;
    private isRateLimited;
    private extractRetryAfter;
    private calculateBackoffTime;
    private sleep;
}
/**
 * Timeout Manager
 */
export declare class TimeoutManager {
    static withTimeout<T>(operation: () => Promise<T>, timeoutMs: number, operationName: string): Promise<T>;
}
/**
 * Graceful Degradation Manager
 */
export declare class GracefulDegradationManager {
    private enabledFeatures;
    private disabledFeatures;
    private featureErrors;
    constructor();
    isFeatureEnabled(feature: string): boolean;
    executeWithDegradation<T>(primaryOperation: () => Promise<T>, fallbackOperation: () => Promise<T>, featureName: string, operationName: string): Promise<T>;
    private recordSuccess;
    private recordFailure;
    getFeatureStatus(): Record<string, 'enabled' | 'disabled' | 'error'>;
}
/**
 * Resource Manager for proper cleanup
 */
export declare class ResourceManager {
    private resources;
    private cleanupTimeout;
    addResource(resource: {
        cleanup: () => Promise<void> | void;
    }): void;
    removeResource(resource: {
        cleanup: () => Promise<void> | void;
    }): void;
    cleanup(): Promise<void>;
    schedulePeriodicCleanup(intervalMs?: number): void;
    stopPeriodicCleanup(): void;
}
/**
 * Main Resilience Manager
 * Combines all resilience features
 */
export declare class ResilienceManager {
    private retryManager;
    private circuitBreakers;
    private rateLimitHandler;
    private degradationManager;
    private resourceManager;
    private config;
    constructor(config?: Partial<ResilienceConfig>);
    executeResilientOperation<T>(operation: () => Promise<T>, operationName: string, options?: {
        useCircuitBreaker?: boolean;
        feature?: string;
        fallback?: () => Promise<T>;
        timeout?: number;
        customRetryConfig?: Partial<RetryConfig>;
    }): Promise<T>;
    private getCircuitBreaker;
    getSystemStatus(): {
        features: Record<string, 'enabled' | 'disabled' | 'error'>;
        circuitBreakers: Record<string, {
            state: string;
            failureCount: number;
            successCount: number;
        }>;
        rateLimiting: {
            active: boolean;
        };
    };
    shutdown(): Promise<void>;
}
//# sourceMappingURL=error-handling-resilience.d.ts.map