@tehreet/conduit/dist/lib/utils/router.d.ts

LLM API gateway with intelligent routing, robust process management, and health monitoring

import { SynapseContext } from './context-extractor';
import { DefaultPluginManager } from '../plugins';
import { ConduitConfig } from './config-presets';
export interface AdvancedRoutingRule {
    id: string;
    name: string;
    description?: string;
    priority: number;
    conditions: RoutingCondition[];
    model: string;
    confidence?: number;
    enabled: boolean;
    fallback?: string;
    metadata?: Record<string, any>;
}
export interface RoutingCondition {
    type: 'token_count' | 'model_request' | 'flags' | 'content' | 'context' | 'time' | 'custom';
    field?: string;
    operator: '=' | '!=' | '<' | '<=' | '>' | '>=' | 'includes' | 'excludes' | 'matches' | 'custom';
    value: any;
    negate?: boolean;
}
export interface RoutingDecision {
    selectedModel: string;
    confidence: number;
    reason: string;
    rule?: AdvancedRoutingRule;
    fallbackModel?: string;
    metadata?: Record<string, any>;
}
export interface RoutingEvaluationContext {
    request: any;
    tokenCount: number;
    config: ConduitConfig;
    env: NodeJS.ProcessEnv;
    synapseContext: SynapseContext;
    timestamp: Date;
    contentAnalysis?: {
        complexity: number;
        language: string;
        topics: string[];
        codeBlocks: number;
    };
}
/**
 * Enhanced routing engine with advanced rule evaluation
 */
export declare class AdvancedRoutingEngine {
    private rules;
    private customEvaluators;
    constructor();
    /**
     * Register a custom routing rule
     */
    registerRule(rule: AdvancedRoutingRule): void;
    /**
     * Remove a routing rule
     */
    removeRule(ruleId: string): void;
    /**
     * Get all routing rules
     */
    getRules(): AdvancedRoutingRule[];
    /**
     * Register custom condition evaluator
     */
    registerCustomEvaluator(name: string, evaluator: (condition: RoutingCondition, context: RoutingEvaluationContext) => boolean): void;
    /**
     * Evaluate routing rules and make routing decision
     */
    evaluate(context: RoutingEvaluationContext): Promise<RoutingDecision>;
    /**
     * Evaluate a single routing rule
     */
    private evaluateRule;
    /**
     * Evaluate a single condition
     */
    private evaluateCondition;
    /**
     * Evaluate token count condition
     */
    private evaluateTokenCountCondition;
    /**
     * Evaluate model request condition
     */
    private evaluateModelRequestCondition;
    /**
     * Evaluate flags condition
     */
    private evaluateFlagsCondition;
    /**
     * Evaluate content condition
     */
    private evaluateContentCondition;
    /**
     * Evaluate context condition (Synapse context)
     */
    private evaluateContextCondition;
    /**
     * Evaluate time condition
     */
    private evaluateTimeCondition;
    /**
     * Evaluate custom condition
     */
    private evaluateCustomCondition;
    /**
     * Compare values based on operator
     */
    private compareValues;
    /**
     * Evaluate array condition
     */
    private evaluateArrayCondition;
    /**
     * Enhance context with content analysis
     */
    private enhanceContext;
    /**
     * Analyze content for routing decisions
     */
    private analyzeContent;
    /**
     * Calculate content complexity
     */
    private calculateComplexity;
    /**
     * Detect content language
     */
    private detectLanguage;
    /**
     * Extract topics from content
     */
    private extractTopics;
    /**
     * Register default evaluators
     */
    private registerDefaultEvaluators;
}
export declare const getUseModel: (req: any, tokenCount: number, config: ConduitConfig, env?: NodeJS.ProcessEnv) => Promise<any>;
export declare const initializePlugins: (pluginDir?: string) => Promise<DefaultPluginManager>;
export declare const getAdvancedRoutingEngine: () => AdvancedRoutingEngine;
export declare const registerRoutingRule: (rule: AdvancedRoutingRule) => void;
export declare const removeRoutingRule: (ruleId: string) => void;
export declare const getAllRoutingRules: () => AdvancedRoutingRule[];
export declare const registerCustomEvaluator: (name: string, evaluator: (condition: RoutingCondition, context: RoutingEvaluationContext) => boolean) => void;
export declare const createCommonRoutingRules: () => AdvancedRoutingRule[];
export declare const router: (req: any, res: any, config: ConduitConfig) => Promise<void>;
//# sourceMappingURL=router.d.ts.map