codecrucible-synth/dist/core/processing/request-processing-core-manager.d.ts

Production-Ready AI Development Platform with Multi-Voice Synthesis, Smithery MCP Integration, Enterprise Security, and Zero-Timeout Reliability

/**
 * Request Processing Core Manager - Centralizes request preparation, queuing, and processing logic
 * Extracted from UnifiedModelClient to provide focused request processing management
 */
import { EventEmitter } from 'events';
import { ModelRequest, ProjectContext } from '../types.js';
import { ActiveProcess } from '../performance/active-process-manager.js';
import { ProviderType } from '../providers/provider-repository.js';
export interface RequestMetrics {
    provider: string;
    model: string;
    startTime: number;
    endTime?: number;
    tokenCount?: number;
    success: boolean;
    error?: string;
}
export interface QueuedRequest {
    id: string;
    request: ModelRequest;
    resolve: (value: any) => void;
    reject: (reason?: Error) => void;
}
export interface ExecutionStrategy {
    mode: 'fast' | 'quality';
    provider: ProviderType;
    timeout: number;
    complexity: string;
}
export interface RequestProcessingConfig {
    maxConcurrentRequests: number;
    defaultTimeoutMs: number;
    memoryThresholds: {
        base: number;
        lengthMultiplier: number;
        complexityMultiplier: number;
    };
}
export interface IRequestProcessingCoreManager {
    /**
     * Estimate memory usage for a request
     */
    estimateMemoryUsage(request: ModelRequest): number;
    /**
     * Determine process type based on request content
     */
    getProcessType(request: ModelRequest): ActiveProcess['type'];
    /**
     * Determine request priority
     */
    getRequestPriority(request: ModelRequest): ActiveProcess['priority'];
    /**
     * Assess complexity quickly for timeout determination
     */
    assessComplexityFast(prompt: string): 'simple' | 'medium' | 'complex';
    /**
     * Determine execution strategy for a request
     */
    determineExecutionStrategy(request: ModelRequest, context?: ProjectContext, executionMode?: 'fast' | 'auto' | 'quality'): ExecutionStrategy;
    /**
     * Create timeout promise for request handling
     */
    createTimeoutPromise(timeoutMs: number): Promise<never>;
    /**
     * Queue request for processing when at capacity
     */
    queueRequest(request: ModelRequest, activeRequestsCount: number, processRequest: (req: ModelRequest, ctx?: ProjectContext) => Promise<any>, context?: ProjectContext): Promise<any>;
    /**
     * Process request queue
     */
    processQueue(activeRequestsCount: number, maxConcurrent: number, processRequest: (req: ModelRequest) => Promise<any>): Promise<void>;
    /**
     * Get current queue statistics
     */
    getQueueStats(): {
        queueLength: number;
        isProcessing: boolean;
        totalProcessed: number;
    };
    /**
     * Clear request queue (for shutdown)
     */
    clearQueue(): void;
    /**
     * Cleanup resources
     */
    cleanup(): Promise<void>;
}
export declare class RequestProcessingCoreManager extends EventEmitter implements IRequestProcessingCoreManager {
    private readonly config;
    private requestQueue;
    private isProcessingQueue;
    private totalProcessed;
    constructor(config?: Partial<RequestProcessingConfig>);
    /**
     * Estimate memory usage for a request
     */
    estimateMemoryUsage(request: ModelRequest): number;
    /**
     * Determine process type based on request content
     */
    getProcessType(request: ModelRequest): ActiveProcess['type'];
    /**
     * Determine request priority
     */
    getRequestPriority(request: ModelRequest): ActiveProcess['priority'];
    /**
     * OPTIMIZED: Fast complexity assessment for timeout determination
     */
    assessComplexityFast(prompt: string): 'simple' | 'medium' | 'complex';
    /**
     * Determine execution strategy for a request
     */
    determineExecutionStrategy(request: ModelRequest, context?: ProjectContext, executionMode?: 'fast' | 'auto' | 'quality'): ExecutionStrategy;
    /**
     * Create timeout promise for request handling
     */
    createTimeoutPromise(timeoutMs: number): Promise<never>;
    /**
     * Queue request for processing when at capacity
     */
    queueRequest(request: ModelRequest, activeRequestsCount: number, processRequest: (req: ModelRequest, ctx?: ProjectContext) => Promise<any>, context?: ProjectContext): Promise<any>;
    /**
     * Process request queue
     */
    processQueue(activeRequestsCount: number, maxConcurrent: number, processRequest: (req: ModelRequest) => Promise<any>): Promise<void>;
    /**
     * Get current queue statistics
     */
    getQueueStats(): {
        queueLength: number;
        isProcessing: boolean;
        totalProcessed: number;
    };
    /**
     * Clear request queue (for shutdown)
     */
    clearQueue(): void;
    /**
     * Cleanup resources
     */
    cleanup(): Promise<void>;
    /**
     * Generate unique request ID
     */
    private generateRequestId;
}
//# sourceMappingURL=request-processing-core-manager.d.ts.map