anon-identity/dist/mcp/providers/provider-selector.d.ts

Decentralized identity framework with DIDs, Verifiable Credentials, and privacy-preserving selective disclosure

/**
 * Provider Selection Engine for MCP
 *
 * Intelligent provider selection based on capabilities, performance, cost, and availability
 */
import { EventEmitter } from 'events';
import { LLMProvider, LLMRequest, LLMRequestType, RequestPriority } from '../types';
/**
 * Selection criteria for providers
 */
export interface SelectionCriteria {
    requestType: LLMRequestType;
    priority: RequestPriority;
    requirements: {
        streaming?: boolean;
        functionCalling?: boolean;
        maxTokens?: number;
        maxLatency?: number;
        minReliability?: number;
        costConstraint?: number;
        preferredModels?: string[];
    };
    context?: {
        agentDID: string;
        domain: string;
        sensitiveData: boolean;
        regulatoryRequirements?: string[];
    };
}
/**
 * Provider scoring weights
 */
export interface ScoringWeights {
    performance: number;
    reliability: number;
    capability: number;
    cost: number;
    availability: number;
    preference: number;
}
/**
 * Provider selection strategy
 */
export declare enum SelectionStrategy {
    PERFORMANCE = "performance",
    COST_OPTIMIZED = "cost_optimized",
    RELIABILITY = "reliability",
    CAPABILITY_MATCH = "capability_match",
    LOAD_BALANCED = "load_balanced",
    SMART_ADAPTIVE = "smart_adaptive"
}
/**
 * Selection result
 */
export interface SelectionResult {
    primaryProvider: LLMProvider;
    fallbackProviders: LLMProvider[];
    reasoning: string;
    score: number;
    estimatedCost: number;
    estimatedLatency: number;
    alternativeOptions: Array<{
        provider: LLMProvider;
        score: number;
        tradeoffs: string[];
    }>;
}
/**
 * Load balancing configuration
 */
export interface LoadBalancingConfig {
    strategy: 'round_robin' | 'weighted' | 'least_connections' | 'latency_based';
    weights?: Map<string, number>;
    stickySession: boolean;
    healthCheckInterval: number;
    failoverThreshold: number;
}
/**
 * Provider Selector
 */
export declare class ProviderSelector extends EventEmitter {
    private providers;
    private config;
    private providerMetrics;
    private providerHealth;
    private selectionHistory;
    private circuitBreakers;
    private loadBalancer;
    private adaptiveLearning;
    constructor(providers: Map<string, LLMProvider>, config?: {
        scoringWeights: ScoringWeights;
        loadBalancing: LoadBalancingConfig;
        circuitBreakerThreshold: number;
        circuitBreakerTimeout: number;
        adaptiveLearningEnabled: boolean;
        fallbackChainLength: number;
    });
    /**
     * Select optimal provider for request
     */
    selectProvider(request: LLMRequest, criteria: SelectionCriteria, strategy?: SelectionStrategy): Promise<SelectionResult>;
    /**
     * Get available providers based on criteria
     */
    private getAvailableProviders;
    /**
     * Score providers based on strategy
     */
    private scoreProviders;
    /**
     * Calculate individual provider score
     */
    private calculateProviderScore;
    /**
     * Aggregate scores based on strategy
     */
    private aggregateScore;
    /**
     * Check provider capabilities
     */
    private checkCapabilities;
    /**
     * Check regulatory compliance
     */
    private checkCompliance;
    /**
     * Calculate capability score
     */
    private calculateCapabilityScore;
    /**
     * Get model quality score
     */
    private getModelQualityScore;
    /**
     * Calculate preference score
     */
    private calculatePreferenceScore;
    /**
     * Estimate cost for request
     */
    private estimateCost;
    /**
     * Estimate latency
     */
    private estimateLatency;
    /**
     * Estimate token count
     */
    private estimateTokens;
    /**
     * Build reasoning for selection
     */
    private buildReasoning;
    /**
     * Calculate tradeoffs between providers
     */
    private calculateTradeoffs;
    /**
     * Record selection for learning
     */
    private recordSelection;
    /**
     * Record actual performance for learning
     */
    recordPerformance(requestId: string, providerId: string, performance: {
        latency: number;
        success: boolean;
        cost: number;
    }): Promise<void>;
    /**
     * Update provider metrics
     */
    private updateProviderMetrics;
    /**
     * Update circuit breaker
     */
    private updateCircuitBreaker;
    /**
     * Initialize provider health
     */
    private initializeProviderHealth;
    /**
     * Start health checks
     */
    private startHealthChecks;
    /**
     * Perform health checks
     */
    private performHealthChecks;
    /**
     * Perform individual health check
     */
    private performHealthCheck;
    /**
     * Get provider statistics
     */
    getStatistics(): {
        totalSelections: number;
        providerUsage: Record<string, number>;
        averageScore: number;
        failoverRate: number;
        costSavings: number;
    };
    /**
     * Shutdown
     */
    shutdown(): void;
}
export default ProviderSelector;
//# sourceMappingURL=provider-selector.d.ts.map