anon-identity/dist/mcp/routing/message-router.d.ts

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

/**
 * Secure Message Router for MCP
 *
 * Routes messages between agents and LLM providers with security, monitoring, and reliability
 */
import { EventEmitter } from 'events';
import { LLMRequest, LLMResponse, LLMResponseChunk, MCPError, RequestPriority, ConnectionStatus } from '../types';
import { MCPClient } from '../client';
import { AuthManager } from '../security/auth-manager';
import { AuditLogger } from '../security/audit-logger';
import { RateLimiterManager } from '../security/rate-limiter';
import { CredentialManager } from '../security/credential-manager';
/**
 * Message routing configuration
 */
export interface RoutingConfig {
    maxRetries: number;
    retryDelay: number;
    timeout: number;
    circuitBreaker: {
        enabled: boolean;
        threshold: number;
        resetTimeout: number;
    };
    loadBalancing: {
        enabled: boolean;
        strategy: 'round-robin' | 'least-connections' | 'weighted' | 'latency-based';
    };
    encryption: {
        enabled: boolean;
        algorithm: string;
    };
}
/**
 * Routed message
 */
export interface RoutedMessage {
    id: string;
    originalRequest: LLMRequest;
    routedTo: string;
    timestamp: Date;
    attempts: number;
    status: 'pending' | 'success' | 'failed' | 'timeout';
    response?: LLMResponse;
    error?: MCPError;
    metrics: {
        queueTime: number;
        routingTime: number;
        responseTime: number;
        totalTime: number;
    };
}
/**
 * Provider health metrics
 */
interface ProviderHealth {
    providerId: string;
    status: ConnectionStatus;
    successRate: number;
    averageLatency: number;
    errorCount: number;
    lastError?: string;
    lastSuccess?: Date;
    circuitBreakerOpen: boolean;
}
/**
 * Secure Message Router
 */
export declare class MessageRouter extends EventEmitter {
    private mcpClient;
    private authManager;
    private auditLogger;
    private rateLimiter;
    private credentialManager;
    private config;
    private messageQueue;
    private activeRequests;
    private providerHealth;
    private circuitBreakers;
    private loadBalancer;
    private encryptionKey?;
    private isShuttingDown;
    constructor(mcpClient: MCPClient, authManager: AuthManager, auditLogger: AuditLogger, rateLimiter: RateLimiterManager, credentialManager: CredentialManager, config?: RoutingConfig);
    /**
     * Route message to LLM provider
     */
    routeMessage(request: LLMRequest): Promise<LLMResponse>;
    /**
     * Stream message to LLM provider
     */
    streamMessage(request: LLMRequest): AsyncIterable<LLMResponseChunk>;
    /**
     * Perform security checks
     */
    private performSecurityChecks;
    /**
     * Detect suspicious activity
     */
    private detectSuspiciousActivity;
    /**
     * Select provider based on strategy
     */
    private selectProvider;
    /**
     * Get available providers
     */
    private getAvailableProviders;
    /**
     * Calculate provider score
     */
    private calculateProviderScore;
    /**
     * Process message immediately
     */
    private processMessageImmediately;
    /**
     * Queue message for processing
     */
    private queueMessage;
    /**
     * Send request to provider
     */
    private sendToProvider;
    /**
     * Initialize queues
     */
    private initializeQueues;
    /**
     * Start queue processor
     */
    private startQueueProcessor;
    /**
     * Process message queues
     */
    private processQueues;
    /**
     * Update provider health metrics
     */
    private updateProviderHealth;
    /**
     * Open circuit breaker for provider
     */
    private openCircuitBreaker;
    /**
     * Setup health monitoring
     */
    private setupHealthMonitoring;
    /**
     * Initialize encryption
     */
    private initializeEncryption;
    /**
     * Encrypt request
     */
    private encryptRequest;
    /**
     * Encrypt content
     */
    private encryptContent;
    /**
     * Decrypt content
     */
    private decryptContent;
    /**
     * Check if provider supports request
     */
    private supportsRequest;
    /**
     * Get routing statistics
     */
    getStatistics(): {
        activeRequests: number;
        queuedRequests: Record<RequestPriority, number>;
        providerHealth: ProviderHealth[];
        circuitBreakers: Array<{
            providerId: string;
            open: boolean;
            resetTime?: Date;
        }>;
        successRate: number;
        averageLatency: number;
    };
    /**
     * Route streaming message
     */
    routeStreamingMessage(request: LLMRequest): Promise<AsyncIterable<LLMResponseChunk> & {
        providerId?: string;
        model?: string;
    }>;
    /**
     * Shutdown router
     */
    shutdown(): Promise<void>;
}
export default MessageRouter;
//# sourceMappingURL=message-router.d.ts.map