codecrucible-synth/dist/core/interfaces/routing-interfaces.d.ts

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

/**
 * Routing Interface Abstractions
 * Breaking circular dependencies in hybrid routing system
 *
 * Living Spiral Council Applied:
 * - Architect: Clean routing abstraction without client coupling
 * - Maintainer: Stable routing contracts for different strategies
 * - Security Guardian: Controlled routing decisions and validation
 * - Performance Engineer: Efficient routing with performance metrics
 */
export interface TaskComplexityMetrics {
    linesOfCode?: number;
    fileCount?: number;
    hasMultipleFiles?: boolean;
    requiresDeepAnalysis?: boolean;
    isTemplateGeneration?: boolean;
    hasSecurityImplications?: boolean;
    estimatedProcessingTime?: number;
}
export interface RoutingDecision {
    selectedLLM: 'lm-studio' | 'ollama' | 'hybrid';
    confidence: number;
    reasoning: string;
    fallbackStrategy: string;
    estimatedResponseTime: number;
    escalationThreshold?: number;
}
export interface HybridConfig {
    lmStudio: {
        endpoint: string;
        enabled: boolean;
        models: string[];
        maxConcurrent: number;
        strengths: string[];
    };
    ollama: {
        endpoint: string;
        enabled: boolean;
        models: string[];
        maxConcurrent: number;
        strengths: string[];
    };
    routing: {
        defaultProvider: 'auto' | 'lm-studio' | 'ollama';
        escalationThreshold: number;
        confidenceScoring: boolean;
        learningEnabled: boolean;
    };
}
export interface IModelRouter {
    routeTask(taskType: string, prompt: string, metrics?: TaskComplexityMetrics): Promise<RoutingDecision>;
    [key: string]: any;
}
export interface IRoutingStrategy {
    evaluateTask(taskType: string, prompt: string, metrics?: TaskComplexityMetrics): Promise<RoutingDecision>;
    getName(): string;
    getConfidence(): number;
}
export interface ITaskAnalyzer {
    analyzeComplexity(prompt: string): TaskComplexityMetrics;
    classifyTask(prompt: string): string;
    estimateResourceRequirements(prompt: string): any;
}
export interface ILoadBalancer {
    getCurrentLoads(): {
        lmStudio: number;
        ollama: number;
    };
    adjustForLoad(decision: RoutingDecision): RoutingDecision;
    reportCompletion(provider: string): void;
}
export interface IPerformancePredictor {
    predictResponseTime(provider: string, taskType: string): number;
    predictQuality(provider: string, taskType: string): number;
    updatePredictions(provider: string, actual: any): void;
}
export interface RoutingEvents {
    routingDecisionMade: {
        taskId: string;
        decision: RoutingDecision;
        taskType: string;
    };
    routingCompleted: {
        taskId: string;
        actualPerformance: any;
        success: boolean;
    };
    routingFailed: {
        taskId: string;
        error: Error;
        fallbackUsed: boolean;
    };
    configUpdated: {
        config: HybridConfig;
    };
}
export interface IRouterFactory {
    createHybridRouter(config: HybridConfig): IModelRouter;
    createSimpleRouter(defaultProvider: string): IModelRouter;
    createLoadBalancedRouter(config: any): IModelRouter;
}
export interface RoutingContext {
    user?: any;
    session?: any;
    priority?: 'low' | 'normal' | 'high' | 'urgent';
    budget?: any;
    qualityRequirements?: any;
    deadlines?: any;
}
export interface IAdvancedRouter extends IModelRouter {
    routeWithContext(taskType: string, prompt: string, context: RoutingContext, metrics?: TaskComplexityMetrics): Promise<RoutingDecision>;
    setRoutingPolicies(policies: any[]): void;
    addRoutingMiddleware(middleware: any): void;
}
//# sourceMappingURL=routing-interfaces.d.ts.map