anon-identity/dist/mcp/provider-registry.d.ts

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

/**
 * Provider Registry and Selection Logic for MCP
 *
 * Manages registration, discovery, and selection of LLM providers
 */
import { MCPProvider, ProviderConfig, LLMRequest, LLMCapabilities, LLMRequestType, ProviderStatus } from './types';
import { ProviderFactory } from './providers/base-provider';
/**
 * Provider selection criteria
 */
export interface ProviderSelectionCriteria {
    requestType: LLMRequestType;
    modelPreference?: string;
    capabilities?: string[];
    maxCost?: number;
    maxLatency?: number;
    preferredProviders?: string[];
    excludedProviders?: string[];
}
/**
 * Provider selection result
 */
export interface ProviderSelectionResult {
    provider: MCPProvider;
    confidence: number;
    reason: string;
    alternatives: Array<{
        provider: MCPProvider;
        confidence: number;
        reason: string;
    }>;
}
/**
 * Provider scoring weights
 */
interface ProviderScoringWeights {
    capability: number;
    cost: number;
    performance: number;
    reliability: number;
    preference: number;
}
/**
 * Provider Registry
 */
export declare class ProviderRegistry {
    private providers;
    private factories;
    private scoringWeights;
    constructor();
    /**
     * Register built-in provider factories
     */
    private registerBuiltInFactories;
    /**
     * Register a provider factory
     */
    registerProviderFactory(type: string, factory: ProviderFactory): void;
    /**
     * Create and register provider from config
     */
    createProvider(config: ProviderConfig): Promise<MCPProvider>;
    /**
     * Detect provider type from configuration
     */
    private detectProviderType;
    /**
     * Register an existing provider instance
     */
    registerProvider(provider: MCPProvider): void;
    /**
     * Unregister a provider
     */
    unregisterProvider(providerId: string): void;
    /**
     * Get provider by ID
     */
    getProvider(providerId: string): MCPProvider | undefined;
    /**
     * Get all registered providers
     */
    getAllProviders(): MCPProvider[];
    /**
     * Get available (enabled and healthy) providers
     */
    getAvailableProviders(): MCPProvider[];
    /**
     * Get providers by capability
     */
    getProvidersByCapability(capability: keyof LLMCapabilities): MCPProvider[];
    /**
     * Get providers supporting specific model
     */
    getProvidersByModel(modelId: string): MCPProvider[];
    /**
     * Select best provider for request
     */
    selectProvider(criteria: ProviderSelectionCriteria, request?: LLMRequest): ProviderSelectionResult;
    /**
     * Filter providers by basic requirements
     */
    private filterProviders;
    /**
     * Score a provider based on criteria
     */
    private scoreProvider;
    /**
     * Calculate capability score
     */
    private calculateCapabilityScore;
    /**
     * Check if provider has required capability for request type
     */
    private checkRequiredCapability;
    /**
     * Calculate cost score
     */
    private calculateCostScore;
    /**
     * Calculate performance score
     */
    private calculatePerformanceScore;
    /**
     * Calculate reliability score
     */
    private calculateReliabilityScore;
    /**
     * Calculate preference score
     */
    private calculatePreferenceScore;
    /**
     * Get selection reason for provider
     */
    private getSelectionReason;
    /**
     * Update scoring weights
     */
    updateScoringWeights(weights: Partial<ProviderScoringWeights>): void;
    /**
     * Get provider statistics
     */
    getProviderStats(): {
        total: number;
        available: number;
        byType: Record<string, number>;
        byStatus: Record<ProviderStatus, number>;
    };
    /**
     * Clear all providers
     */
    clear(): void;
}
export default ProviderRegistry;
//# sourceMappingURL=provider-registry.d.ts.map