Function classify

uncommon_route/router/classifier.py:314–376

(
    prompt: str,
    system_prompt: str | None = None,
    config: ScoringConfig | None = None,
    context_features: dict[str, float] | None = None,
)

# ─── Main Entry ───

def classify(
    prompt: str,
    system_prompt: str | None = None,
    config: ScoringConfig | None = None,
    context_features: dict[str, float] | None = None,
) -> ScoringResult:
    if config is None:
        config = ScoringConfig()

    feature_text = _merge_feature_text(prompt, system_prompt)
    estimated_tokens = estimate_tokens(feature_text)
    _ensure_model_loaded()

    trivial = _check_trivial(feature_text, estimated_tokens)
    if trivial is not None:
        trivial_complexity = 0.0 if trivial is Tier.SIMPLE else 0.90
        return ScoringResult(
            tier=trivial, confidence=0.95,
            signals=(f"trivial:{trivial.value}",),
            complexity=trivial_complexity,
        )

    all_features = _extract_all_features(
        prompt,
        system_prompt=system_prompt,
        context_features=context_features,
    )

    if _model is not None:
        complexity, tier_str, confidence = _model.predict_complexity(all_features)
        normalized_tier = "COMPLEX" if tier_str == "REASONING" else tier_str
        tier = Tier(normalized_tier)
        tier = _soften_short_code_question(prompt, estimated_tokens, tier)
        tier = _soften_low_structure_question(prompt, estimated_tokens, tier, all_features)
        normalized_tier = tier.value
        if tier is Tier.MEDIUM and complexity > 0.40:
            complexity = 0.40
        signals = (f"model:{normalized_tier}({confidence:.2f})", f"complexity:{complexity:.2f}")
        return ScoringResult(
            tier=tier, confidence=confidence,
            signals=signals, complexity=complexity,
        )

    tier, confidence = _rule_based_classify(all_features, config)
    _TIER_TO_COMPLEXITY = {Tier.SIMPLE: 0.0, Tier.MEDIUM: 0.40, Tier.COMPLEX: 0.90}
    complexity = _TIER_TO_COMPLEXITY.get(tier, 0.33)
    struct_dims = extract_structural_features(prompt)
    signals = [d.signal for d in struct_dims if d.signal is not None]
    signals.append("rule-fallback")
    signals.append(f"complexity:{complexity:.2f}")

    if confidence < config.confidence_threshold:
        return ScoringResult(
            tier=None, confidence=confidence,
            signals=tuple(signals), dimensions=tuple(struct_dims),
            complexity=complexity,
        )