/**
 * Core Routing Engine
 * Implements all routing strategies: percent-split, conditional, confidence-cascade,
 * cost-based, and ensemble routing with proper decision logic
 */
import type { RoutingPolicy, ModelConfig, ChatCompletionRequest, RoutingContext } from '../types.js';
import { RoutingStrategy } from '../types.js';
/**
 * Execution plan for model invocation
 */
export interface ExecutionPlan {
    id: string;
    strategy: RoutingStrategy;
    primary_models: Array<{
        model: ModelConfig;
        weight?: number;
        timeout_ms?: number;
        max_cost_usd?: number;
    }>;
    fallback_models: ModelConfig[];
    execution_mode: 'parallel' | 'sequential' | 'cascade';
    aggregation_strategy?: 'voting' | 'confidence_weighted' | 'ranker' | 'synthesizer' | 'first';
    synthesizer_model?: ModelConfig;
    estimated_cost_usd: number;
    estimated_latency_ms: number;
    budget_constraints: {
        max_cost_usd?: number;
        max_latency_ms?: number;
        max_tokens?: number;
    };
}
/**
 * Routing decision context
 */
export interface RoutingDecision {
    plan: ExecutionPlan;
    reason: string;
    filters_applied: string[];
    metadata: Record<string, unknown>;
}
/**
 * Route Engine - evaluates policies and produces execution plans
 */
export declare class RoutingEngine {
    private policies;
    private activeExperiments;
    /**
     * Register a routing policy
     */
    registerPolicy(policy: RoutingPolicy): void;
    /**
     * Get policy by ID
     */
    getPolicy(policyId: string): RoutingPolicy | undefined;
    /**
     * Remove a policy
     */
    removePolicy(policyId: string): boolean;
    /**
     * Main routing decision function
     * Evaluates request + context against policy and produces execution plan
     */
    route(request: ChatCompletionRequest, context: RoutingContext, policy: RoutingPolicy): Promise<RoutingDecision>;
    /**
     * Weighted/Percent-split routing
     * Distributes traffic based on model weights with optional sticky sessions
     */
    private routeWeighted;
    /**
     * Conditional routing based on request attributes
     */
    private routeConditional;
    /**
     * Confidence cascade routing
     * Try cheap model first, escalate to better model if confidence is low
     */
    private routeConfidenceCascade;
    /**
     * Cost-optimized routing
     * Select cheapest model that meets quality requirements
     */
    private routeCostOptimized;
    /**
     * Latency-optimized routing
     * Select fastest model
     */
    private routeLatencyOptimized;
    /**
     * Ensemble routing
     * Call multiple models in parallel and aggregate results
     */
    private routeEnsemble;
    /**
     * Round-robin routing
     * Distribute requests evenly across models
     */
    private routeRoundRobin;
    /**
     * Apply safety and content filters
     */
    private applyFilters;
    /**
     * Apply A/B experiments and traffic splits
     */
    private applyExperiments;
    /**
     * Extract features from request for conditional routing
     */
    private extractRequestFeatures;
    /**
     * Evaluate conditions against features
     */
    private evaluateConditions;
    /**
     * Estimate cost for a model call
     */
    private estimateModelCost;
    /**
     * Validate execution plan against budget constraints
     */
    private validateBudgets;
    /**
     * Hash session ID for sticky routing
     */
    private hashSession;
    /**
     * Simple string hash function
     */
    private hashString;
    /**
     * Check if user is in experiment
     */
    private isUserInExperiment;
    /**
     * Register an A/B experiment
     */
    registerExperiment(experiment: ExperimentConfig): void;
    /**
     * Remove an experiment
     */
    removeExperiment(experimentId: string): boolean;
}
/**
 * Experiment configuration for A/B testing
 */
export interface ExperimentConfig {
    id: string;
    name: string;
    traffic_percentage: number;
    variant_policy: RoutingPolicy;
    start_time: Date;
    end_time?: Date;
    metrics_to_track: string[];
}
//# sourceMappingURL=routing-engine.d.ts.map