anon-identity/dist/mcp/streaming/stream-manager.d.ts

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

/**
 * Stream Manager for MCP
 *
 * Manages streaming responses for real-time LLM interactions
 */
import { EventEmitter } from 'events';
import { LLMRequest, LLMResponse, LLMResponseChunk, StreamingConfig, MCPError } from '../types';
import { MessageRouter } from '../routing/message-router';
import { AuthManager } from '../security/auth-manager';
import { AuditLogger } from '../security/audit-logger';
/**
 * Stream session
 */
export interface StreamSession {
    id: string;
    agentDID: string;
    requestId: string;
    providerId: string;
    status: 'active' | 'paused' | 'completed' | 'error' | 'cancelled';
    startedAt: Date;
    lastChunkAt?: Date;
    completedAt?: Date;
    totalChunks: number;
    totalTokens: number;
    metadata: {
        purpose: string;
        priority: 'low' | 'medium' | 'high' | 'critical';
        maxDuration?: number;
        bufferSize?: number;
    };
}
/**
 * Stream chunk with metadata
 */
export interface EnhancedStreamChunk extends LLMResponseChunk {
    sessionId: string;
    chunkIndex: number;
    bufferStatus: {
        size: number;
        flushed: boolean;
    };
    latency: number;
    timestamp: Date;
}
/**
 * Stream buffer configuration
 */
export interface StreamBufferConfig {
    maxSize: number;
    flushInterval: number;
    flushOnComplete: boolean;
    adaptiveBuffering: boolean;
}
/**
 * Real-time processing configuration
 */
export interface RealTimeConfig {
    enableInterruption: boolean;
    priorityPreemption: boolean;
    multiplexing: boolean;
    backpressureHandling: 'drop' | 'buffer' | 'throttle';
    qualityOfService: {
        targetLatency: number;
        maxJitter: number;
        adaptiveQuality: boolean;
    };
}
/**
 * Stream Manager
 */
export declare class StreamManager extends EventEmitter {
    private messageRouter;
    private authManager;
    private auditLogger;
    private config;
    private activeSessions;
    private sessionBuffers;
    private sessionTimers;
    private priorityQueue;
    private realTimeProcessor;
    constructor(messageRouter: MessageRouter, authManager: AuthManager, auditLogger: AuditLogger, config?: {
        streaming: StreamingConfig;
        buffer: StreamBufferConfig;
        realTime: RealTimeConfig;
        maxConcurrentStreams: number;
        sessionTimeout: number;
    });
    /**
     * Start streaming session
     */
    startStream(request: LLMRequest, options?: {
        bufferConfig?: Partial<StreamBufferConfig>;
        priority?: 'low' | 'medium' | 'high' | 'critical';
        maxDuration?: number;
        onChunk?: (chunk: EnhancedStreamChunk) => void;
        onComplete?: (response: LLMResponse) => void;
        onError?: (error: MCPError) => void;
    }): Promise<StreamSession>;
    /**
     * Process streaming request
     */
    private processStreamRequest;
    /**
     * Process individual chunk
     */
    private processChunk;
    /**
     * Check if natural breakpoint
     */
    private isNaturalBreakpoint;
    /**
     * Flush buffer
     */
    private flushBuffer;
    /**
     * Check if backpressure should be applied
     */
    private shouldApplyBackpressure;
    /**
     * Apply backpressure
     */
    private applyBackpressure;
    /**
     * Monitor quality of service
     */
    private monitorQualityOfService;
    /**
     * Adapt stream quality
     */
    private adaptStreamQuality;
    /**
     * Pause stream
     */
    pauseStream(sessionId: string): Promise<void>;
    /**
     * Resume stream
     */
    resumeStream(sessionId: string): Promise<void>;
    /**
     * Cancel stream
     */
    cancelStream(sessionId: string): Promise<void>;
    /**
     * Handle stream error
     */
    private handleStreamError;
    /**
     * Timeout session
     */
    private timeoutSession;
    /**
     * Preempt lowest priority stream
     */
    private preemptLowestPriorityStream;
    /**
     * Get priority score
     */
    private getPriorityScore;
    /**
     * Cleanup session
     */
    private cleanupSession;
    /**
     * Setup event handlers
     */
    private setupEventHandlers;
    /**
     * Get active sessions
     */
    getActiveSessions(): StreamSession[];
    /**
     * Get session statistics
     */
    getSessionStatistics(sessionId: string): {
        duration: number;
        chunksPerSecond: number;
        tokensPerSecond: number;
        averageLatency: number;
        bufferUtilization: number;
    } | null;
    /**
     * Shutdown
     */
    shutdown(): void;
}
export default StreamManager;
//# sourceMappingURL=stream-manager.d.ts.map