Route easy → cheap, hard → premium.

import os
import json
from openai import OpenAI

client = OpenAI(base_url="https://api.anoman.io/v1", api_key=os.environ["ANOMAN_API_KEY"])

# Tiny, cheap classifier. ~$0.000_05 per call.
CLASSIFIER_MODEL = "qwen-2.5-7b"

# Heavy model for hard requests.
HEAVY_MODEL = "claude-sonnet-4-6"
# Cheap model for easy requests.
LIGHT_MODEL = "gpt-4o-mini"

CLASSIFIER_SYSTEM = """
Classify the difficulty of the user's question as one of:
  easy      — Factual lookup, simple instruction, short formatting task
  medium    — Multi-step reasoning, document summarization, code generation
  hard      — Algorithm design, math proof, multi-turn planning, long context

Respond with ONLY the single word. No explanation.
""".strip()

def classify(question: str) -> str:
    response = client.chat.completions.create(
        model=CLASSIFIER_MODEL,
        messages=[
            {"role": "system", "content": CLASSIFIER_SYSTEM},
            {"role": "user",   "content": question},
        ],
        max_tokens=10,
        temperature=0,
    )
    return response.choices[0].message.content.strip().lower()

def ask(question: str) -> str:
    difficulty = classify(question)
    model = {
        "easy":   LIGHT_MODEL,
        "medium": LIGHT_MODEL,
        "hard":   HEAVY_MODEL,
    }.get(difficulty, HEAVY_MODEL)  # safe default: escalate

    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": question}],
        # Track which path took for monitoring
        metadata={"routed_via": "classifier", "difficulty": difficulty},
    )
    return response.choices[0].message.content

print(ask("Capital of Indonesia?"))                            # easy → cheap
print(ask("Prove that the halting problem is undecidable."))   # hard → premium

# Combine both: the classifier picks a candidate model, the candidate
# can still escalate on low confidence. Catches mis-classifications.

def smart_ask(question: str) -> dict:
    difficulty = classify(question)

    if difficulty == "hard":
        # Skip cheap layer entirely.
        return {"answer": ask_heavy(question), "model": HEAVY, "path": "direct"}

    answer, model_used = ask_with_escalation(question)
    return {
        "answer": answer,
        "model": model_used,
        "path": "escalated" if model_used == HEAVY else "cheap",
    }