adaptive-memory-multi-model-router 2.14.49 → 2.14.51

package/src/routing/advancedRouter.ts.bak

@@ -1,650 +0,0 @@
-/**
- * A3M Router - Generic Adaptive Routing (RouteLLM Style)
- *
- * Routes queries to the best available LLM based on:
- * - Query features (code, math, creative, etc.)
- * - Provider availability (checks API keys)
- * - Cost optimization
- * - Quality vs speed tradeoff
- *
- * All provider references are dynamically loaded from providerConfig.
- * Users can add/remove providers via environment variables or config files.
- */
-
-import { getAvailableProviders } from "../providers/providerConfig";
-import { estimateCost } from "../utils/tokenUtils";
-import { logScaleCostScore } from "../utils/costUtils";
-import { quickselectTopK, selectTop } from "../utils/sorting";
-
-// ============================================================
-// CACHE FOR MODEL PROFILES (avoids O(n*m) rebuild on every routeQuery)
-// ============================================================
-
-interface ModelProfile {
-  name: string;
-  provider: string;
-  providerName: string;
-  cost_per_1k_input: number;
-  cost_per_1k_output: number;
-  latency_ms: number;
-  quality_score: number;
-  strengths: string[];
-  context_window: number;
-  type: string;
-  priority: number;
-}
-
-let cachedProfiles: Record<string, ModelProfile> | null = null;
-let cacheTimestamp = 0;
-const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
-
-function buildModelProfiles(): Record<string, ModelProfile> {
-  const profiles: Record<string, ModelProfile> = {};
-  const available = getAvailableProviders();
-
-  for (const [providerId, provider] of Object.entries(available)) {
-    for (const model of provider.models) {
-      const modelKey = model.includes('/') ? model : providerId + '/' + model;
-      const costPerKInput = provider.costPerK ? provider.costPerK.input : 0;
-      const costPerKOutput = provider.costPerK ? provider.costPerK.output : 0;
-
-      // Assign strengths based on model characteristics
-      const strengths: string[] = [];
-      if (provider.type === 'cli') {
-        strengths.push('free', 'local');
-      }
-      if (costPerKInput < 0.3) {
-        strengths.push('budget', 'fast');
-      } else if (costPerKInput > 2) {
-        strengths.push('premium', 'reasoning');
-      }
-      if (provider.name === 'Mistral' || provider.name === 'Groq' || provider.name === 'Cerebras') {
-        strengths.push('fast', 'coding');
-      }
-      if (provider.name === 'CommandCode') {
-        strengths.push('code-aware', 'context-rich');
-      }
-      if (provider.name === 'OpenCode') {
-        strengths.push('free', 'multi-model');
-      }
-      if (provider.name === 'Google') {
-        strengths.push('multilingual', 'long-context');
-      }
-      if (provider.name === 'OpenAI') {
-        strengths.push('reasoning', 'coding', 'analysis');
-      }
-      if (provider.name === 'Anthropic') {
-        strengths.push('reasoning', 'creative', 'analysis');
-      }
-
-      profiles[modelKey] = {
-        name: modelKey,
-        provider: providerId,
-        providerName: provider.name,
-        cost_per_1k_input: costPerKInput,
-        cost_per_1k_output: costPerKOutput,
-        latency_ms: provider.type === 'cli' ? 5000 : (provider.priority * 200 + 300),
-        quality_score: (strengths.includes('premium') || strengths.includes('reasoning')) ? 0.94 :
-                       (strengths.includes('fast') && costPerKInput > 0.3) ? 0.85 :
-                       (strengths.includes('budget') || strengths.includes('free')) ? 0.72 : 0.80,
-        strengths,
-        context_window: provider.maxTokens || 8192,
-        type: provider.type,
-        priority: provider.priority,
-      };
-    }
-  }
-
-  return profiles;
-}
-
-// Lazy cache with TTL - replaces refreshModelProfiles()
-function getModelProfiles(): Record<string, ModelProfile> {
-  const now = Date.now();
-  if (!cachedProfiles || (now - cacheTimestamp) > CACHE_TTL_MS) {
-    cachedProfiles = buildModelProfiles();
-    cacheTimestamp = now;
-  }
-  return cachedProfiles;
-}
-
-// Manual cache invalidation (call if provider config changes)
-function invalidateProfileCache(): void {
-  cachedProfiles = null;
-  cacheTimestamp = 0;
-}
-
-export let MODEL_PROFILES: Record<string, ModelProfile> = {};
-try {
-  MODEL_PROFILES = buildModelProfiles();
-} catch (e) {
-  // Circular dependency at module load - will retry on first use
-  MODEL_PROFILES = {};
-}
-
-// ============================================================
-// FEATURE EXTRACTION (v3 - multi-signal complexity scorer)
-// ============================================================
-
-export interface QueryFeatures {
-  length: number;
-  wordCount: number;
-  complexity: number;
-  has_code: boolean;
-  has_math: boolean;  // Math detection (Calculate, integral, etc.)
-  requires_reasoning: boolean;
-  is_multilingual: boolean;
-  is_translation: boolean;
-  is_security: boolean;  // Security/penetration testing queries
-  is_creative: boolean;  // Creative writing, translation
-  is_devops: boolean;    // Infrastructure, databases, DevOps
-  is_multimodal: boolean; // Multi-modal queries
-  domain: string | null;
-  intent: string;
-  detected_language: string | null;
-}
-
-export function extractQueryFeatures(prompt: string): QueryFeatures {
-  const lower = prompt.toLowerCase();
-  const words = prompt.split(/\s+/);
-  const wordCount = words.length;
-
-  // === SIGNAL 1: Domain Detection ===
-  const domainSignals: Record<string, { keywords: string[]; weight: number }> = {
-    legal: {
-      keywords: ['legal', 'law', 'contract', 'liability', 'litigation', 'patent', 'copyright',
-                  'regulation', 'compliance', 'constitutional', 'statute', 'jurisdiction',
-                  'court', 'ruling', 'precedent', 'attorney', 'amicus', 'sec ', 'fda ',
-                  'gdpr', 'ccpa', 'cfpr', 'due diligence', 'merger', 'acquisition',
-                  '10-k', 'sec filing', 'forensic', 'embezzlement', 'infringement'],
-      weight: 0.35
-    },
-    medical: {
-      keywords: ['clinical', 'medical', 'pharmaceutical', 'oncology', 'drug', 'trial protocol',
-                  'diagnosis', 'treatment', 'epidemiolog', 'genome', 'cohort study',
-                  'biomarker', 'efficacy', 'pharmacoeconomic', 'biologic', 'vaccine',
-                  'sepsis', 'ehr ', 'surgical', 'patient safety', 'fda approval'],
-      weight: 0.35
-    },
-    finance: {
-      keywords: ['financial model', 'valuation', 'revenue', 'portfolio', 'derivative',
-                  'hedge fund', 'series a', 'series b', 'startup valuation', 'sensitivity analysis',
-                  'investment thesis', 'earnings', 'tax optimization', 'forensic accounting',
-                  'multinational', 'jurisdiction', 'risk assessment', 'monte carlo',
-                  'black-scholes', 'options pricing', 'credit risk'],
-      weight: 0.30
-    },
-    security: {
-      keywords: ['security audit', 'penetration', 'vulnerability', 'exploit', 'zero-trust',
-                  'threat model', 'incident response', 'malware', 'ransomware',
-                  'authentication flow', 'cryptograph', 'encryption', 'timing attack',
-                  'supply chain attack', 'owasp', 'compliance', 'risk assessment',
-                  'mfa', 'zero-day', 'firewall', 'intrusion'],
-      weight: 0.30
-    },
-    architecture: {
-      keywords: ['system design', 'microservice', 'distributed system', 'fault-tolerant',
-                  'event-sourced', 'cqrs', 'consensus algorithm', 'real-time pipeline',
-                  'high availability', 'multi-region', 'latency sla', 'kafka',
-                  'event-driven', 'data warehouse', 'etl', 'streaming', '1m events',
-                  'million events', 'scalab', 'infrastruct', 'deploy'],
-      weight: 0.25
-    },
-    data_science: {
-      keywords: ['machine learning', 'deep learning', 'neural network', 'transformer',
-                  'training data', 'model accuracy', 'hyperparameter', 'cross-validation',
-                  'feature engineering', 'data pipeline', 'pandas', 'numpy', 'scikit',
-                  'tensorflow', 'pytorch', 'regression', 'classification', 'clustering'],
-      weight: 0.30
-    },
-    ml_research: {
-      keywords: ['bert', 'gpt', 'super_glue', 'glue benchmark', 'benchmarks', 'performance comparison',
-                  'natural language processing', 'nlp', 'language model', 'transformer model',
-                  'fine.tuning', 'pre.training', 'few.shot', 'zero.shot', 'prompt engineering',
-                  'model comparison', 'accuracy', 'f1 score', 'bleu', 'rouge', 'perplexity'],
-      weight: 0.40
-    },
-  };
-
-  let detectedDomain: string | null = null;
-  let maxDomainScore = 0;
-  for (const [domain, signal] of Object.entries(domainSignals)) {
-    let domainScore = 0;
-    for (const kw of signal.keywords) {
-      if (lower.includes(kw)) {
-        domainScore += signal.weight;
-      }
-    }
-    if (domainScore > maxDomainScore) {
-      maxDomainScore = domainScore;
-      detectedDomain = domain;
-    }
-  }
-
-  // === SIGNAL 2: Code Detection ===
-  const codeSignals = [
-    'function ', 'def ', 'class ', 'import ', 'const ', 'let ', 'var ',
-    '=>', '->', 'async ', 'await ', 'return ', 'if (', 'for (', 'while (',
-    'public ', 'private ', 'protected ', 'static ', 'void ', 'int ', 'string ',
-    '#include', 'std::', 'cout', 'cin', 'printf(', 'println!',
-    'fn ', 'impl ', 'pub ', 'mut ', 'struct ', 'enum ',
-    '```', 'python', 'javascript', 'typescript', 'java', 'cpp', 'ruby',
-    'write a', 'create a', 'implement', 'algorithm'
-  ];
-  const hasCode = codeSignals.some(sig => lower.includes(sig));
-
-  // === SIGNAL 3: Reasoning Detection ===
-  // === SIGNAL 3: Reasoning Detection ===
-  const reasoningSignals = [
-    'why', 'how', 'explain', 'analyze', 'compare', 'contrast', 'evaluate',
-    'think about', 'reason', 'logic', 'proof', 'derive', '证明', '分析',
-    'reasoning', 'step by step', 'thinking', 'thought process'
-  ];
-
-  // Check if it's a simple factual "How" query (should NOT trigger reasoning boost)
-  const simpleHowPatterns = [
-    /^(what|how|who|which|when|where)\s+(is|are|was|were|do|does|did|can|has|have|named|called)/i,
-    /^how\s+(many|much|long|tall|old|far)/i,
-  ];
-  const isSimpleHowQuery = simpleHowPatterns.some(p => p.test(prompt.trim()));
-  const requiresReasoning = !isSimpleHowQuery && reasoningSignals.some(sig => lower.includes(sig));
-
-  // === SIGNAL 4: Language Detection ===
-  const languagePatterns: [RegExp, string][] = [
-    [/[\u4e00-\u9fff]/, 'zh'],
-    [/[\u0900-\u097f]/, 'hi'],
-    [/[\u0600-\u06ff]/, 'ar'],
-    [/[\u0400-\u04ff]/, 'ru'],
-    [/[\u0900-\u097f]/, 'hi-latn'],
-    [/বাংলা|করুন|হিন্দি|ভারত|ভারতীয়/, 'bn'],
-  ];
-
-  let detectedLanguage: string | null = null;
-  for (const [pattern, lang] of languagePatterns) {
-    if (pattern.test(prompt)) {
-      detectedLanguage = lang;
-      break;
-    }
-  }
-
-  // Translation detection
-  const translationSignals = ['translate', 'translation', 'into english', 'to english',
-    'traducir', 'traduction', 'traduzione', 'übersetzen'];
-  const isTranslation = translationSignals.some(sig => lower.includes(sig)) ||
-    /to (english|french|german|spanish|chinese|japanese|korean)/i.test(prompt);
-
-  const isMultilingual = detectedLanguage !== null || isTranslation;
-
-  // === SIGNAL 5: Intent Classification ===
-  let intent = 'general';
-  // Math takes priority over code for math-heavy queries
-  if (lower.includes('calculate') || lower.includes('compute') || lower.includes('integral') ||
-      lower.includes('derivative') || lower.includes('equation') || lower.includes('formula')) {
-    intent = 'math';
-  } else if (hasCode) {
-    intent = 'code';
-  } else if (isTranslation) {
-    intent = 'translation';
-  } else if (lower.includes('write') || lower.includes('create') || lower.includes('generate')) {
-    intent = 'creative';
-  } else if (lower.includes('explain') || lower.includes('what is') || lower.includes('how does')) {
-    intent = 'explanation';
-  }
-
-  // === COMPLEXITY SCORING ===
-  // Base complexity from length
-  let complexity = Math.min(wordCount / 100, 1.0);
-
-  // === RESEARCH-BACKED COMPLEXITY SIGNALS (from accuracy gap analysis) ===
-
-  // SIGNAL: Jargon Density (+15%) - professional terminology ratio
-  const professionalTerms = [
-    'liability', 'contract', 'clause', 'statute', 'jurisdiction', 'litigation', 'plaintiff', 'defendant', 'testimony', 'deposition', 'injunction', 'precedent',
-    'oncology', 'diagnosis', 'prognosis', 'pathology', 'pharmacology', 'etiology', 'symptomology', 'clinical',
-    'portfolio', 'equity', 'derivative', 'arbitrage', 'liquidity', 'amortization', 'collateral', 'fiduciary',
-    'architecture', 'protocol', 'schema', 'interface', 'abstraction', 'implementation', 'optimization', 'scalability',
-    'hypothesis', 'methodology', 'correlation', 'regression', 'variance', 'covariance', 'multivariate',
-    'quantitative', 'qualitative', 'peer-reviewed', 'meta-analysis', 'systematic review', 'empirical',
-  ];
-  const jargonCount = professionalTerms.filter(t => lower.includes(t)).length;
-  const jargonScore = (jargonCount / Math.max(wordCount, 1)) * 0.35;
-  complexity += jargonScore;
-
-  // SIGNAL: Task Formality (+10%) - formal professional task markers
-  const formalTasks = ['protocol', 'audit', 'brief', 'filing', 'submission', 'application', 'complaint', 'petition', 'motion', 'agreement', 'negotiation', 'mediation', 'arbitration', 'compliance', 'regulatory', 'certification', 'accreditation', 'assessment', 'evaluation', 'appraisal', 'due diligence', 'impact assessment', 'risk assessment', 'investigation', 'inquiry', 'examination'];
-  const formalityMatches = formalTasks.filter(t => lower.includes(t)).length;
-  if (formalityMatches > 0) complexity += 0.10 + (formalityMatches * 0.03);
-
-  // SIGNAL: Depth Markers (+8%) - comprehensive response requested
-  const depthTerms = ['comprehensive', 'detailed', 'thorough', 'in-depth', 'exhaustive', 'systematic', 'methodical', 'rigorous', 'extensive', 'elaborate', 'nuanced', 'multi-faceted', 'holistic', 'deep dive', 'full analysis', 'expert level', 'professional grade', 'end-to-end', 'literature review', 'research report', 'whitepaper', 'technical specification'];
-  const depthMatches = depthTerms.filter(t => lower.includes(t)).length;
-  if (depthMatches > 0) complexity += 0.08 + (depthMatches * 0.03);
-
-  // SIGNAL: Stakes Language (+5%) - high-stakes domain language
-  const highStakes = ['safety-critical', 'liability', 'regulatory', 'compliance', 'legal', 'patent', 'copyright', 'litigation', 'lawsuit', 'penalty', 'fraud', 'malpractice', 'negligence', 'confidential', 'proprietary', 'trade secret', 'intellectual property', 'patient safety', 'clinical trial', 'financial risk', 'market risk', 'operational risk'];
-  const stakesMatches = highStakes.filter(s => lower.includes(s)).length;
-  if (stakesMatches > 0) complexity += 0.08 + (stakesMatches * 0.02);
-
-  // SIGNAL: Multi-Step Structure (+5%) - sequential reasoning patterns
-  const multiStepPatterns = [/first\s+.+\s+then\s+.+\s+finally/i, /step\s+\d+\s*[,.:]\s*step\s+\d+/i, /phase\s*\d+\s*[-–]\s*phase\s*\d+/i, /stage\s*\d+\s*[-–]\s*stage\s*\d+/i, /before\s+.+\s+after\s+.+/i];
-  const multiStepMatches = multiStepPatterns.filter(p => p.test(prompt)).length;
-  if (multiStepMatches > 0) complexity += 0.07 + (multiStepMatches * 0.02);
-
-  // === MID-TIER SPECIFIC SIGNALS ===
-  const midTierJargon = [
-    'auth system', 'multi-tenant', 'ci/cd', 'pipeline', 'fraud detection', 'privacy-preserving',
-    'netflix-scale', 'sensor fusion', 'autonomous', 'distributed', 'consensus',
-    'load balancing', 'rate limiting', 'caching', 'sharding', 'replication',
-    'authentication', 'authorization', 'encryption', 'compression', 'serialization',
-  ];
-  const midJargonMatches = midTierJargon.filter(t => lower.includes(t)).length;
-  if (midJargonMatches > 0) complexity += 0.10 + (midJargonMatches * 0.02);
-
-  // Analysis/Design task boost
-  const analysisDesignPatterns = [
-    /analyze\s+.*\s+(impact|implications|consequences|effects)/i,
-    /compare\s+.*\s+and\s+.*\s+(vs|with|against)/i,
-    /design\s+(a|an)\s+(system|architecture|protocol|schema)/i,
-    /schema\s+for/i,
-    /pipeline\s+for/i,
-  ];
-  const analysisMatches = analysisDesignPatterns.filter(p => p.test(prompt)).length;
-  if (analysisMatches > 0) complexity += 0.12 + (analysisMatches * 0.03);
-
-  // Complex system analysis patterns
-  const complexSystemPatterns = [
-    /explain\s+(the\s+)?(difference|relationship|correlation)/i,
-    /how\s+does\s+.*\s+affect\s+.*\s+in\s+.*/i,
-  ];
-  const complexMatches = complexSystemPatterns.filter(p => p.test(prompt)).length;
-  if (complexMatches > 0) complexity += 0.08;
-
-  // === ORIGINAL SIGNALS (enhanced) ===
-  // Domain加成 (increased from 0.2 to 0.35)
-  if (detectedDomain) complexity += 0.35;
-
-  // Code加成
-  if (hasCode) complexity += 0.15;
-
-  // Reasoning加成 (increased from 0.15 to 0.20)
-  if (requiresReasoning) complexity += 0.20;
-
-  // Multilingual加成
-  if (isMultilingual) complexity += 0.1;
-
-  // Detect new feature flags
-  const isSecurity = /penetration testing|security audit|vulnerability|exploit|malware|ransomware|zero.trust|owasp|sql injection|xss|cross.site|csrf|brute.force|authentication bypass|cwe.\d+/i.test(lower);
-  const isCreative = /write a story|write a poem|creative|imagination|artistic/i.test(lower) || isTranslation;
-  const isDevops = /docker|kubernetes|terraform|ansible|ci.cd|pipeline|sql|nosql|database|sqlserver|mysql|postgres|deploy|container|orchestrat/i.test(lower);
-  const isMultimodal = /image|video|audio|generate.*picture|generate.*image|transcribe|voice/i.test(lower);
-
-  // Cap at 1.0
-  complexity = Math.min(complexity, 1.0);
-
-  return {
-    length: prompt.length,
-    wordCount,
-    complexity,
-    has_code: hasCode,
-    has_math: intent === 'math',  // Math detection
-    requires_reasoning: requiresReasoning,
-    is_multilingual: isMultilingual,
-    is_translation: isTranslation,
-    is_security: isSecurity,
-    is_creative: isCreative,
-    is_devops: isDevops,
-    is_multimodal: isMultimodal,
-    domain: detectedDomain,
-    intent,
-    detected_language: detectedLanguage,
-  };
-}
-
-function scoreModelFit(model: ModelProfile, features: QueryFeatures): number {
-  let score = model.quality_score * 0.6;
-
-  // Domain match (reduced for budget models)
-  // Premium models get +0.2 for domain match
-  // Budget/free models get only +0.05 (they lack capability for complex domains)
-  if (features.domain) {
-    const domainBonus: Record<string, string[]> = {
-      code: ['code-aware', 'coding', 'fast'],
-      medical: ['reasoning', 'analysis'],
-      legal: ['reasoning', 'analysis', 'context-rich'],
-      finance: ['analysis', 'reasoning'],
-      security: ['reasoning', 'analysis'],
-      architecture: ['context-rich', 'long-context'],
-      data_science: ['coding', 'fast', 'reasoning'],
-    };
-    const bonuses = domainBonus[features.domain] || [];
-    if (bonuses.some(b => model.strengths.includes(b))) {
-      const is_budget = model.strengths.includes('budget') || model.strengths.includes('free');
-      score += is_budget ? 0.05 : 0.25;  // Budget gets minimal boost
-    }
-  }
-
-  // For complex queries (complexity > 0.5), budget/free models get penalty
-  if (features.complexity > 0.5) {
-    if (model.strengths.includes('budget') || model.strengths.includes('free')) {
-      score *= 0.7;  // 30% penalty for budget models on complex queries
-    }
-  }
-
-  // Code bonus
-  if (features.has_code && model.strengths.includes('coding')) {
-    score += 0.15;
-  }
-
-  // Multilingual bonus
-  if (features.is_multilingual && model.strengths.includes('multilingual')) {
-    score += 0.15;
-  }
-
-  // Free tier preference for simple queries
-  if (features.complexity < 0.5 && model.strengths.includes('free')) {
-    score += 0.2;
-  }
-
-  // Fast provider for simple queries
-  if (features.complexity < 0.4 && model.strengths.includes('fast')) {
-    score += 0.15;
-  }
-
-  // Premium for complex queries
-  if (features.complexity > 0.6 && model.strengths.includes('premium')) {
-    score += 0.15;
-  }
-
-  return Math.min(score, 1.0);
-}
-
-function costEfficiency(model: ModelProfile, features: QueryFeatures): number {
-  // Use log-scale cost score for better mid-range differentiation
-  // Lower cost → higher score (thanks to logScaleCostScore inverse mapping)
-  const avg_cost = (model.cost_per_1k_input + model.cost_per_1k_output) / 2;
-  const cost_score = logScaleCostScore(avg_cost);
-
-  // Simple queries weigh cost more heavily (0.6)
-  // Complex queries weigh cost less (0.2) since quality matters more
-  const weight = features.complexity < 0.5 ? 0.6 : 0.2;
-  return cost_score * weight;
-}
-
-// ============================================================
-// ROUTING
-// ============================================================
-
-export interface RouteDecision {
-  primary_model: string | null;
-  fallback_models: string[];
-  confidence: number;
-  reasoning: string;
-  estimated_cost: number;
-  estimated_latency_ms: number;
-  features?: QueryFeatures;
-  provider_type?: string;
-}
-
-export function routeQuery(prompt: string, available_models?: string[], budget_multiplier: number = 1.0): RouteDecision {
-  // Use cached profiles instead of rebuilding every time (5-10ms savings)
-  const profiles = getModelProfiles();
-
-  const features = extractQueryFeatures(prompt);
-  const candidate_names = available_models || Object.keys(profiles);
-
-  // Filter to available models
-  const candidates = candidate_names
-    .filter(name => profiles[name])
-    .map(name => {
-      const profile = profiles[name];
-      const quality = scoreModelFit(profile, features);
-      const cost = costEfficiency(profile, features);
-      return {
-        name,
-        profile,
-        quality_score: quality,
-        cost_score: cost,
-        total_score: quality + cost
-      };
-    });
-
-  if (candidates.length === 0) {
-    return {
-      primary_model: null,
-      fallback_models: [],
-      confidence: 0,
-      reasoning: "No providers available - configure API keys in ~/.config/a3m-router/providers.json",
-      estimated_cost: 0,
-      estimated_latency_ms: 0,
-    };
-  }
-
-  // Sort by total score (quality vs cost tradeoff based on complexity)
-  const complexity_bias = features.complexity > 0.6 ? 0.7 : 0.3;
-  const scoreFn = (c: typeof candidates[0]) => c.quality_score * complexity_bias + c.cost_score * (1 - complexity_bias);
-
-  const topCandidates = quickselectTopK(candidates, 4, scoreFn);
-
-  const primary = topCandidates[0];
-  const secondary = topCandidates.slice(1, 3);
-
-  // Calculate confidence based on score gap
-  let confidence = 0.5;
-  if (candidates.length > 1) {
-    const gap = primary.total_score - candidates[1].total_score;
-    confidence = Math.min(0.95, 0.5 + gap * 2);
-  }
-
-  // Build reasoning
-  const reasons: string[] = [];
-  if (features.has_code) reasons.push("code detected");
-  if (features.requires_reasoning) reasons.push("reasoning needed");
-  if (features.complexity > 0.6) reasons.push("high complexity");
-  if (features.is_multilingual) reasons.push("multilingual");
-  if (features.is_translation) reasons.push("translation");
-  if (primary.profile.strengths.includes("free")) reasons.push("free tier");
-
-  const estimated_tokens = features.length * 1.5;
-  const estimated_cost = estimateCost(features.length, estimated_tokens, primary.name);
-
-  return {
-    primary_model: primary.name,
-    fallback_models: secondary.map(c => c.name),
-    confidence,
-    reasoning: `Selected ${primary.profile.providerName || primary.profile.provider}/${primary.name} for ${reasons.join(", ") || "general query"}`,
-    estimated_cost: estimated_cost * budget_multiplier,
-    estimated_latency_ms: primary.profile.latency_ms,
-    features,
-    provider_type: primary.profile.type,
-  };
-}
-
-// ============================================================
-// BATCH ROUTING
-// ============================================================
-
-export function routeBatch(prompts: string[], options: {
-  same_model?: boolean;
-  max_cost_per_prompt?: number;
-} = {}): RouteDecision[] {
-  const decisions = prompts.map(p => routeQuery(p));
-
-  if (options.same_model && decisions.length > 0) {
-    const primary_model = decisions[0].primary_model;
-    decisions.forEach(d => {
-      d.primary_model = primary_model;
-      d.fallback_models = decisions[0].fallback_models;
-    });
-  }
-
-  if (options.max_cost_per_prompt !== undefined) {
-    const profiles = getModelProfiles();
-    decisions.forEach(d => {
-      if (d.estimated_cost > options.max_cost_per_prompt!) {
-        const cheap = Object.entries(profiles)
-          .find(([name, p]) => p.cost_per_1k_input < 0.5);
-        if (cheap) {
-          d.primary_model = cheap[0];
-          d.reasoning = `Budget-limited routing to ${cheap[1].providerName || cheap[1].provider}`;
-        }
-      }
-    });
-  }
-
-  return decisions;
-}
-
-// ============================================================
-// TASK RECOMMENDATIONS
-// ============================================================
-
-export function recommendForTask(task: string) {
-  const features = extractQueryFeatures(task);
-  const decision = routeQuery(task);
-  return {
-    primary: decision.primary_model,
-    fallbacks: decision.fallback_models,
-    reason: decision.reasoning,
-    features,
-  };
-}
-
-// ============================================================
-// ONLINE LEARNING - Update model profiles from feedback
-// ============================================================
-
-export function updateModelProfile(model_name: string, actual_latency_ms: number, actual_cost: number, quality_rating: number): void {
-  const profiles = getModelProfiles();
-  const profile = profiles[model_name];
-  if (!profile) return;
-
-  const alpha = 0.2; // Learning rate
-  profile.latency_ms = profile.latency_ms * (1 - alpha) + actual_latency_ms * alpha;
-  profile.quality_score = profile.quality_score * (1 - alpha) + quality_rating * alpha;
-}
-
-// ============================================================
-// PROVIDER HEALTH CHECK
-// ============================================================
-
-export async function getProviderHealth() {
-  const { checkAllProviders } = require("../providers/providerConfig");
-  return checkAllProviders();
-}
-
-// ============================================================
-// Default export
-// ============================================================
-
-module.exports = {
-  extractQueryFeatures,
-  routeQuery,
-  routeBatch,
-  recommendForTask,
-  updateModelProfile,
-  getProviderHealth,
-  MODEL_PROFILES,
-  invalidateProfileCache,
-};
-
-module.exports.default = module.exports;