mcp-smart/dist/SmartAdvisorServer.d.ts

MCP server providing multi-advisor AI consultations via OpenRouter API with advanced caching, rate limiting, and security features

declare enum CircuitBreakerState {
    CLOSED = "CLOSED",
    OPEN = "OPEN",
    HALF_OPEN = "HALF_OPEN"
}
interface CacheMetrics {
    hits: number;
    misses: number;
    evictions: number;
    totalRequests: number;
    hitRate: number;
}
interface CircuitBreakerMetrics {
    failures: number;
    successes: number;
    state: CircuitBreakerState;
    lastFailureTime: number;
    consecutiveFailures: number;
    totalRequests: number;
}
export declare class SmartAdvisorServer {
    private server;
    private config;
    private requestCache;
    private cacheMetrics;
    private logger;
    private rateLimitTracker;
    private startTime;
    private circuitBreakers;
    constructor();
    private initializeCircuitBreakers;
    private loadConfig;
    private validateInput;
    private sanitizeInput;
    private checkRateLimit;
    private setupToolHandlers;
    listTools(): Promise<{
        tools: {
            name: string;
            description: string;
            inputSchema: {
                type: string;
                properties: {
                    model: {
                        type: string;
                        enum: string[];
                        description: string;
                    };
                    task: {
                        type: string;
                        description: string;
                    };
                    context: {
                        type: string;
                        description: string;
                    };
                };
                required: string[];
            };
        }[];
    }>;
    callTool(name: string, args: any): Promise<{
        content: {
            type: string;
            text: string;
        }[];
    }>;
    private consultAllAdvisors;
    private getCachedResponse;
    private setCachedResponse;
    private evictLeastRecentlyUsed;
    private updateCacheHitRate;
    getCacheMetrics(): CacheMetrics;
    private routeToOptimalProvider;
    getHealthCheck(): {
        status: 'healthy' | 'degraded' | 'unhealthy';
        timestamp: string;
        uptime: number;
        cache: {
            size: number;
            hitRate: number;
            evictions: number;
        };
        rateLimit: {
            activeWindows: number;
        };
        circuitBreakers: Record<string, {
            state: CircuitBreakerState;
            failures: number;
            successRate: number;
        }>;
        version: string;
    };
    getCircuitBreakerMetrics(): Record<string, CircuitBreakerMetrics>;
    resetCircuitBreaker(provider: string): boolean;
    resetAllCircuitBreakers(): void;
    private callOpenRouterWithRetry;
    private getProviderFromModel;
    private attemptFallbackProvider;
    private callOpenRouterWithRetryFallback;
    private delay;
    private callOpenRouter;
    private formatMultiAdvisorResponse;
    run(): Promise<void>;
}
export {};