car_inference/

adaptive_router.rs

//! Adaptive model routing — three-phase routing with learned performance profiles.
//!
//! Phase 1: **Filter** — hard constraints (capability, availability, memory, cost).
//! Phase 2: **Score** — blend quality, latency, and cost using observed profiles
//!          or schema defaults on cold start.
//! Phase 3: **Explore** — epsilon-greedy bandit to gather data on under-tested models.
//!
//! Replaces the hardcoded `ModelRouter` from `router.rs`.

use rand::Rng;
use serde::{Deserialize, Serialize};

use crate::hardware::HardwareInfo;
use crate::outcome::{InferenceTask, OutcomeTracker};
use crate::registry::UnifiedRegistry;
use crate::schema::{ModelCapability, ModelSchema};

/// Prompt complexity assessment (migrated from router.rs).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TaskComplexity {
    Simple,
    Medium,
    Code,
    Complex,
}

impl TaskComplexity {
    /// Assess complexity of a prompt string.
    ///
    /// Uses tree-sitter AST parsing (when the `ast` feature is enabled) for
    /// accurate code detection: if a code block parses successfully as any
    /// supported language, it's definitively code. Falls back to keyword
    /// heuristics for prompts that mention code without containing code blocks.
    pub fn assess(prompt: &str) -> Self {
        let lower = prompt.to_lowercase();
        let word_count = prompt.split_whitespace().count();
        let estimated_tokens = (word_count as f64 * 1.3) as usize;

        let has_code = Self::detect_code(prompt);

        let repair_markers = [
            "fix", "repair", "debug", "refactor", "broken",
            "failing", "error", "bug",
        ];
        let has_repair = repair_markers.iter().any(|m| lower.contains(m));

        let reasoning_markers = [
            "analyze", "compare", "explain why", "step by step",
            "think through", "evaluate", "trade-off", "tradeoff",
            "pros and cons", "architecture", "design", "strategy",
            "optimize", "comprehensive",
        ];
        let has_reasoning = reasoning_markers.iter().any(|m| lower.contains(m));

        let simple_patterns = [
            "what is", "who is", "when did", "where is",
            "how many", "yes or no", "true or false", "name the",
            "list the", "define ",
        ];
        let is_simple = simple_patterns.iter().any(|p| lower.contains(p));

        if has_code || has_repair {
            TaskComplexity::Code
        } else if has_reasoning || estimated_tokens > 500 {
            TaskComplexity::Complex
        } else if is_simple || estimated_tokens < 30 {
            TaskComplexity::Simple
        } else {
            TaskComplexity::Medium
        }
    }

    /// Detect whether a prompt contains code.
    ///
    /// With `ast` feature: extracts code blocks (``` delimited), attempts to
    /// parse each with tree-sitter. If any parses into symbols, it's real code.
    /// Without `ast` feature: falls back to keyword heuristics.
    fn detect_code(prompt: &str) -> bool {
        // First try AST-based detection on code blocks
        #[cfg(feature = "ast")]
        {
            if let Some(is_code) = Self::detect_code_ast(prompt) {
                return is_code;
            }
        }

        // Fallback: keyword heuristics
        let code_markers = [
            "```", "fn ", "def ", "class ", "import ", "require(",
            "async fn", "pub fn", "function ", "const ", "let ", "var ",
            "#include", "package ", "impl ",
        ];
        code_markers.iter().any(|m| prompt.contains(m))
    }

    /// AST-based code detection: parse code blocks with tree-sitter.
    /// Returns Some(true) if code found, Some(false) if blocks exist but
    /// don't parse, None if no code blocks found (fall through to heuristics).
    #[cfg(feature = "ast")]
    fn detect_code_ast(prompt: &str) -> Option<bool> {
        // Extract code blocks between ``` markers
        let mut blocks = Vec::new();
        let mut rest = prompt;
        while let Some(start) = rest.find("```") {
            let after_fence = &rest[start + 3..];
            // Skip optional language tag on the opening fence
            let code_start = after_fence.find('\n').map(|i| i + 1).unwrap_or(0);
            if let Some(end) = after_fence[code_start..].find("```") {
                blocks.push(&after_fence[code_start..code_start + end]);
                rest = &after_fence[code_start + end + 3..];
            } else {
                break;
            }
        }

        if blocks.is_empty() {
            return None; // No code blocks — let heuristics decide
        }

        // Try to parse each block with tree-sitter
        let languages = [
            car_ast::Language::Rust,
            car_ast::Language::Python,
            car_ast::Language::TypeScript,
            car_ast::Language::JavaScript,
            car_ast::Language::Go,
        ];

        for block in &blocks {
            let trimmed = block.trim();
            if trimmed.is_empty() { continue; }

            for lang in &languages {
                if let Some(parsed) = car_ast::parse(trimmed, *lang) {
                    // If it parsed into any symbols, it's definitely code
                    if !parsed.symbols.is_empty() {
                        return Some(true);
                    }
                }
            }
        }

        // Had code blocks but none parsed into symbols — could be
        // pseudocode, output, or unsupported language
        Some(false)
    }

    /// Map complexity to required capabilities.
    pub fn required_capabilities(&self) -> Vec<ModelCapability> {
        match self {
            TaskComplexity::Simple => vec![ModelCapability::Generate],
            TaskComplexity::Medium => vec![ModelCapability::Generate],
            TaskComplexity::Code => vec![ModelCapability::Code],
            TaskComplexity::Complex => vec![ModelCapability::Reasoning],
        }
    }

    /// Map complexity to the InferenceTask type.
    pub fn inference_task(&self) -> InferenceTask {
        match self {
            TaskComplexity::Simple | TaskComplexity::Medium => InferenceTask::Generate,
            TaskComplexity::Code => InferenceTask::Code,
            TaskComplexity::Complex => InferenceTask::Reasoning,
        }
    }
}

/// Configuration for routing behavior.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RoutingConfig {
    /// Exploration rate for epsilon-greedy bandit (0.0 = always exploit, 1.0 = always explore).
    pub exploration_rate: f64,
    /// Minimum observations before trusting a model's profile over schema defaults.
    pub min_observations: u64,
    /// Scoring weights (must sum to 1.0).
    pub quality_weight: f64,
    pub latency_weight: f64,
    pub cost_weight: f64,
    /// Hard constraint: maximum latency budget in ms.
    pub max_latency_ms: Option<u64>,
    /// Hard constraint: maximum cost per call in USD.
    pub max_cost_usd: Option<f64>,
    /// Prefer local models over remote (all else being equal).
    pub prefer_local: bool,
}

impl Default for RoutingConfig {
    fn default() -> Self {
        Self {
            exploration_rate: 0.1,
            min_observations: 5,
            quality_weight: 0.45,
            latency_weight: 0.4,
            cost_weight: 0.15,
            max_latency_ms: None,
            max_cost_usd: None,
            prefer_local: true,
        }
    }
}

/// How a model was selected.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RoutingStrategy {
    /// Using declared schema capabilities (no observed data).
    SchemaBased,
    /// Using observed performance profiles (exploitation).
    ProfileBased,
    /// Deliberately trying an under-tested model (exploration).
    Exploration,
    /// User explicitly specified the model.
    Explicit,
}

/// The result of adaptive routing.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdaptiveRoutingDecision {
    /// Selected model id.
    pub model_id: String,
    /// Selected model name (display).
    pub model_name: String,
    /// Task type.
    pub task: InferenceTask,
    /// Assessed complexity.
    pub complexity: TaskComplexity,
    /// Human-readable reason.
    pub reason: String,
    /// How the model was selected.
    pub strategy: RoutingStrategy,
    /// Predicted quality (0.0-1.0).
    pub predicted_quality: f64,
    /// Fallback chain (ordered list of alternative model ids).
    pub fallbacks: Vec<String>,
}

/// Adaptive router with three-phase model selection.
pub struct AdaptiveRouter {
    hw: HardwareInfo,
    config: RoutingConfig,
}

impl AdaptiveRouter {
    pub fn new(hw: HardwareInfo, config: RoutingConfig) -> Self {
        Self { hw, config }
    }

    pub fn with_default_config(hw: HardwareInfo) -> Self {
        Self::new(hw, RoutingConfig::default())
    }

    /// Route a generation request to the best model.
    pub fn route(
        &self,
        prompt: &str,
        registry: &UnifiedRegistry,
        tracker: &OutcomeTracker,
    ) -> AdaptiveRoutingDecision {
        let complexity = TaskComplexity::assess(prompt);
        let task = complexity.inference_task();
        let required_caps = complexity.required_capabilities();

        // Phase 1: Filter candidates
        let candidates = self.filter_candidates(&required_caps, registry);

        if candidates.is_empty() {
            // Nothing available — return the schema-based default
            return self.cold_start_decision(complexity, task, registry);
        }

        // Phase 2: Score candidates
        let scored = self.score_candidates(&candidates, task, tracker);

        // Phase 3: Exploration vs exploitation
        let (selected_id, strategy) = self.select_with_exploration(&scored, tracker);

        // Build fallback chain
        let fallbacks: Vec<String> = scored.iter()
            .filter(|(id, _)| *id != selected_id)
            .map(|(id, _)| id.clone())
            .collect();

        let predicted_quality = scored.iter()
            .find(|(id, _)| *id == selected_id)
            .map(|(_, score)| *score)
            .unwrap_or(0.5);

        let model_name = registry.get(&selected_id)
            .or_else(|| registry.find_by_name(&selected_id))
            .map(|m| m.name.clone())
            .unwrap_or_else(|| selected_id.clone());

        let reason = format!(
            "{:?} task → {} via {:?} (quality: {:.2}, {} candidates)",
            complexity, model_name, strategy, predicted_quality, candidates.len()
        );

        AdaptiveRoutingDecision {
            model_id: selected_id,
            model_name,
            task,
            complexity,
            reason,
            strategy,
            predicted_quality,
            fallbacks,
        }
    }

    /// Route to the best embedding model.
    pub fn route_embedding(&self, registry: &UnifiedRegistry) -> String {
        let embed_models = registry.query_by_capability(ModelCapability::Embed);
        embed_models.first()
            .map(|m| m.name.clone())
            .unwrap_or_else(|| "Qwen3-Embedding-0.6B".to_string())
    }

    /// Route to the smallest available model (for classification).
    pub fn route_small(&self, registry: &UnifiedRegistry) -> String {
        let gen_models = registry.query_by_capability(ModelCapability::Generate);
        // Pick smallest by size
        gen_models.iter()
            .filter(|m| m.is_local())
            .min_by_key(|m| m.size_mb())
            .map(|m| m.name.clone())
            .unwrap_or_else(|| "Qwen3-0.6B".to_string())
    }

    // --- Internal phases ---

    // --- Scoring constants ---

    /// Latency ceiling: requests taking longer than this score 0.0.
    const LATENCY_CEILING_MS: f64 = 10000.0;
    /// TPS ceiling: models faster than this score 1.0.
    const TPS_CEILING: f64 = 150.0;
    /// MoE throughput penalty: naive expert routing on Metal/CPU runs at ~10% of declared TPS.
    const MOE_TPS_MULTIPLIER: f64 = 0.10;
    /// Cost ceiling: models costing more than this per 1K output tokens score 0.0.
    const COST_CEILING_PER_1K: f64 = 0.1;
    /// Local preference bonus added to the weighted score (before normalization).
    const LOCAL_BONUS: f64 = 0.15;

    // --- Internal phases ---

    /// Phase 1: Filter by hard constraints.
    fn filter_candidates(
        &self,
        required_caps: &[ModelCapability],
        registry: &UnifiedRegistry,
    ) -> Vec<ModelSchema> {
        registry.list().into_iter()
            .filter(|m| {
                // Must have all required capabilities
                if !required_caps.iter().all(|c| m.has_capability(*c)) {
                    return false;
                }
                // Must be available (downloaded for local, API key set for remote)
                if !m.available {
                    return false;
                }
                // Local models must fit in memory (strict: >= excludes models at the limit)
                if m.is_local() && m.size_mb() >= self.hw.max_model_mb {
                    return false;
                }
                // Hard latency constraint
                if let Some(max) = self.config.max_latency_ms {
                    if let Some(p50) = m.performance.latency_p50_ms {
                        if p50 > max {
                            return false;
                        }
                    }
                }
                // Hard cost constraint
                if let Some(max) = self.config.max_cost_usd {
                    if m.cost_per_1k_output() > max {
                        return false;
                    }
                }
                true
            })
            .cloned()
            .collect()
    }

    /// Phase 2: Score candidates using profiles or schema defaults.
    fn score_candidates(
        &self,
        candidates: &[ModelSchema],
        task: InferenceTask,
        tracker: &OutcomeTracker,
    ) -> Vec<(String, f64)> {
        let mut scored: Vec<(String, f64)> = candidates.iter()
            .map(|m| {
                let score = self.score_model(m, task, tracker);
                (m.id.clone(), score)
            })
            .collect();

        scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
        scored
    }

    /// Score a single model. All sub-scores are in [0.0, 1.0].
    /// Final score = weighted sum + local_bonus, so range is [0.0, ~1.15].
    fn score_model(
        &self,
        model: &ModelSchema,
        task: InferenceTask,
        tracker: &OutcomeTracker,
    ) -> f64 {
        let profile = tracker.profile(&model.id);
        let schema_quality = self.schema_quality_estimate(model);
        let schema_latency = self.schema_latency_estimate(model);

        // Quality: blend schema estimate with observed data based on observation count.
        // Both cold start and warm start use consistent blending.
        let quality = match profile {
            Some(p) if p.total_calls >= self.config.min_observations => {
                p.task_stats(task).map(|ts| ts.ema_quality).unwrap_or(p.ema_quality)
            }
            Some(p) if p.total_calls > 0 => {
                let w = p.total_calls as f64 / self.config.min_observations as f64;
                schema_quality * (1.0 - w) + p.ema_quality * w
            }
            _ => schema_quality,
        };

        // Latency: same blending as quality — don't trust a single observation more
        // than schema estimates. This prevents routing oscillation on first few calls.
        let latency = match profile {
            Some(p) if p.total_calls >= self.config.min_observations => {
                let avg = p.avg_latency_ms();
                self.latency_ms_to_score(avg)
            }
            Some(p) if p.total_calls > 0 => {
                let observed = self.latency_ms_to_score(p.avg_latency_ms());
                let w = p.total_calls as f64 / self.config.min_observations as f64;
                schema_latency * (1.0 - w) + observed * w
            }
            _ => schema_latency,
        };

        // Cost score (lower is better → invert)
        let cost = if model.is_local() {
            1.0
        } else {
            (1.0 - (model.cost_per_1k_output() / Self::COST_CEILING_PER_1K)).clamp(0.0, 1.0)
        };

        let local_bonus = if self.config.prefer_local && model.is_local() {
            Self::LOCAL_BONUS
        } else {
            0.0
        };

        self.config.quality_weight * quality
            + self.config.latency_weight * latency
            + self.config.cost_weight * cost
            + local_bonus
    }

    /// Convert latency in ms to a [0, 1] score. Used by both schema and observed paths
    /// so the scales are consistent (fixes Linus review issue #2).
    fn latency_ms_to_score(&self, ms: f64) -> f64 {
        (1.0 - (ms / Self::LATENCY_CEILING_MS)).clamp(0.0, 1.0)
    }

    /// Convert TPS to estimated latency in ms (for a typical 200-token response).
    fn tps_to_latency_ms(tps: f64) -> f64 {
        if tps <= 0.0 { return Self::LATENCY_CEILING_MS; }
        // Assume ~200 tokens per response as baseline
        (200.0 / tps) * 1000.0
    }

    /// Schema-based quality estimate (cold start).
    ///
    /// Diminishing returns on model size — the jump from 4B to 8B matters,
    /// but 8B to 30B is marginal. Remote models get a conservative estimate.
    fn schema_quality_estimate(&self, model: &ModelSchema) -> f64 {
        match model.size_mb() {
            0 => 0.5,             // remote: unknown, conservative
            s if s < 1000 => 0.4, // 0.6B
            s if s < 2000 => 0.5, // 1.7B
            s if s < 3000 => 0.6, // 4B
            s if s < 6000 => 0.7, // 8B
            _ => 0.75,            // 30B+: diminishing returns
        }
    }

    /// Schema-based latency estimate (cold start).
    ///
    /// Converts declared TPS/p50 to the same ms-based score used by observed data,
    /// so there's no discontinuity when the first observation arrives.
    fn schema_latency_estimate(&self, model: &ModelSchema) -> f64 {
        let is_moe = model.tags.contains(&"moe".to_string());

        if model.is_local() {
            if let Some(tps) = model.performance.tokens_per_second {
                let effective_tps = if is_moe { tps * Self::MOE_TPS_MULTIPLIER } else { tps };
                let estimated_ms = Self::tps_to_latency_ms(effective_tps);
                return self.latency_ms_to_score(estimated_ms);
            }
            return 0.5; // local, no declared TPS
        }

        // Remote: use declared p50 latency
        if let Some(p50) = model.performance.latency_p50_ms {
            return self.latency_ms_to_score(p50 as f64);
        }
        0.3 // remote, no declared latency
    }

    /// Phase 3: Epsilon-greedy selection.
    fn select_with_exploration(
        &self,
        scored: &[(String, f64)],
        tracker: &OutcomeTracker,
    ) -> (String, RoutingStrategy) {
        if scored.is_empty() {
            return (String::new(), RoutingStrategy::SchemaBased);
        }

        let mut rng = rand::rng();

        // With probability epsilon, explore an under-tested model
        if rng.random::<f64>() < self.config.exploration_rate {
            // Find candidates with fewer than min_observations
            let under_tested: Vec<&str> = scored.iter()
                .filter(|(id, _)| {
                    tracker.profile(id)
                        .map(|p| p.total_calls < self.config.min_observations)
                        .unwrap_or(true) // never tested = definitely explore
                })
                .map(|(id, _)| id.as_str())
                .collect();

            if !under_tested.is_empty() {
                let idx = rng.random_range(0..under_tested.len());
                return (under_tested[idx].to_string(), RoutingStrategy::Exploration);
            }
        }

        // Exploit: pick the highest-scored model
        let best = &scored[0];
        let strategy = if tracker.profile(&best.0)
            .map(|p| p.total_calls >= self.config.min_observations)
            .unwrap_or(false)
        {
            RoutingStrategy::ProfileBased
        } else {
            RoutingStrategy::SchemaBased
        };

        (best.0.clone(), strategy)
    }

    /// Fallback decision when no candidates pass filtering.
    fn cold_start_decision(
        &self,
        complexity: TaskComplexity,
        task: InferenceTask,
        registry: &UnifiedRegistry,
    ) -> AdaptiveRoutingDecision {
        // Fall back to the old complexity-based defaults
        let model_name = match complexity {
            TaskComplexity::Simple => "Qwen3-0.6B",
            TaskComplexity::Medium => "Qwen3-1.7B",
            TaskComplexity::Code => "Qwen3-4B",
            TaskComplexity::Complex => &self.hw.recommended_model,
        };

        let model_id = registry.find_by_name(model_name)
            .map(|m| m.id.clone())
            .unwrap_or_else(|| model_name.to_string());

        AdaptiveRoutingDecision {
            model_id,
            model_name: model_name.to_string(),
            task,
            complexity,
            reason: format!("{:?} task → {} (cold start, no candidates)", complexity, model_name),
            strategy: RoutingStrategy::SchemaBased,
            predicted_quality: 0.5,
            fallbacks: vec![],
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::outcome::InferredOutcome;

    fn test_hw() -> HardwareInfo {
        HardwareInfo {
            os: "macos".into(),
            arch: "aarch64".into(),
            cpu_cores: 10,
            total_ram_mb: 32768,
            gpu_backend: crate::hardware::GpuBackend::Metal,
            gpu_memory_mb: Some(28672),
            recommended_model: "Qwen3-8B".into(),
            recommended_context: 8192,
            max_model_mb: 18000, // headroom above 30B-A3B's 17000MB
        }
    }

    fn test_registry() -> UnifiedRegistry {
        let tmp = std::path::PathBuf::from("/tmp/car-test-adaptive-router");
        // Create fake model dirs so the registry marks them as available
        for name in &["Qwen3-0.6B", "Qwen3-1.7B", "Qwen3-4B", "Qwen3-8B", "Qwen3-Embedding-0.6B"] {
            let dir = tmp.join(name);
            let _ = std::fs::create_dir_all(&dir);
            let _ = std::fs::write(dir.join("model.gguf"), b"fake");
            let _ = std::fs::write(dir.join("tokenizer.json"), b"{}");
        }
        UnifiedRegistry::new(tmp)
    }

    #[test]
    fn routes_simple_to_balanced_local() {
        let router = AdaptiveRouter::new(test_hw(), RoutingConfig {
            exploration_rate: 0.0,
            ..Default::default()
        });
        let reg = test_registry();
        let tracker = OutcomeTracker::new();

        let decision = router.route("What is 2+2?", &reg, &tracker);
        assert_eq!(decision.complexity, TaskComplexity::Simple);
        assert_eq!(decision.strategy, RoutingStrategy::SchemaBased);
        // On cold start, the router balances quality vs latency.
        // The selected model should be local (not remote).
        let schema = reg.find_by_name(&decision.model_name);
        assert!(schema.is_some(), "selected model should exist in registry");
        assert!(schema.unwrap().is_local(), "simple task should route to local model");
    }

    #[test]
    fn routes_code_to_code_capable_local() {
        let router = AdaptiveRouter::new(test_hw(), RoutingConfig {
            exploration_rate: 0.0,
            ..Default::default()
        });
        let reg = test_registry();
        let tracker = OutcomeTracker::new();

        let decision = router.route("Fix this function:\n```rust\nfn main() {}\n```", &reg, &tracker);
        assert_eq!(decision.complexity, TaskComplexity::Code);
        assert_eq!(decision.task, InferenceTask::Code);
        // 0.6B has no Code capability, so smallest code-capable model wins
        assert_eq!(decision.model_name, "Qwen3-1.7B");
    }

    #[test]
    fn profile_based_routing_selects_proven_model() {
        let router = AdaptiveRouter::new(test_hw(), RoutingConfig {
            exploration_rate: 0.0,
            min_observations: 3,
            ..Default::default()
        });
        let reg = test_registry();
        let mut tracker = OutcomeTracker::new();

        // Build a strong profile for Qwen3-8B on code tasks (fast + high quality)
        let qwen_8b_id = "qwen/qwen3-8b:q4_k_m";
        for _ in 0..5 {
            let trace = tracker.record_start(qwen_8b_id, InferenceTask::Code, "test");
            tracker.record_complete(&trace, 500, 100, 50); // 500ms avg
            tracker.record_inferred_outcome(&trace, InferredOutcome::Accepted { confidence: 0.95 });
        }

        let decision = router.route("Fix this bug in the parser", &reg, &tracker);
        assert_eq!(decision.complexity, TaskComplexity::Code);
        // With strong observed data (quality ~0.95, latency 500ms), 8B should beat
        // the 1.7B's cold-start schema score
        assert_eq!(decision.model_name, "Qwen3-8B");
        assert_eq!(decision.strategy, RoutingStrategy::ProfileBased);
    }

    #[test]
    fn fallback_chain_has_alternatives() {
        let router = AdaptiveRouter::new(test_hw(), RoutingConfig {
            exploration_rate: 0.0,
            ..Default::default()
        });
        let reg = test_registry();
        let tracker = OutcomeTracker::new();

        let decision = router.route("Analyze the architecture trade-offs", &reg, &tracker);
        assert!(!decision.fallbacks.is_empty());
        // Primary should not appear in fallbacks
        assert!(!decision.fallbacks.contains(&decision.model_id));
    }

    #[test]
    fn latency_scoring_is_consistent() {
        // Verify that schema and observed latency produce comparable scores
        let router = AdaptiveRouter::with_default_config(test_hw());

        // A model at 25 TPS → ~200/25*1000 = 8000ms → score = 1 - 8000/10000 = 0.2
        let schema_score = router.latency_ms_to_score(AdaptiveRouter::tps_to_latency_ms(25.0));
        // Same model observed at 8000ms → same formula
        let observed_score = router.latency_ms_to_score(8000.0);
        assert!((schema_score - observed_score).abs() < 0.01,
            "schema ({schema_score}) and observed ({observed_score}) should match");
    }

    #[test]
    fn complexity_assessment() {
        assert_eq!(TaskComplexity::assess("What is the capital of France?"), TaskComplexity::Simple);
        assert_eq!(TaskComplexity::assess("Fix this broken test"), TaskComplexity::Code);
        assert_eq!(TaskComplexity::assess("Analyze the trade-offs between A and B"), TaskComplexity::Complex);
    }
}