def sweep_effort(tasks, model, levels=("low", "medium", "high", "xhigh", "max")):
    rows = []
    for level in levels:
        results = [run(model, t, effort=level) for t in tasks]
        ok = sum(r.success for r in results)
        cost = sum(r.cost_usd for r in results)
        rows.append({
            "effort": level,
            "success_rate": ok / len(tasks),
            "cost_per_success": cost / ok if ok else float("inf"),
        })
    return rows

def needs_model(ticket: Ticket) -> bool:
    if ticket.source == "billing_webhook":      # origem já determina o time
        return False
    if len(ticket.message) < 20:                # curto demais para julgar
        return False
    return True

import time
import uuid
from contextlib import contextmanager
from dataclasses import dataclass, field

# Preços por milhão de tokens. Snapshot datado, não constante do universo.
PRICING = {
    "gpt-6-luna": {"in": 0.10, "out": 0.50, "cached_in": 0.01},
    "gpt-6-sol":  {"in": 2.00, "out": 10.00, "cached_in": 0.20},
    "opus-5.5":   {"in": 4.00, "out": 20.00, "cached_in": 0.40},
}

@dataclass
class TaskCost:
    task_id: str
    model: str
    effort: str
    attempts: int = 0
    input_tokens: int = 0
    cached_tokens: int = 0
    output_tokens: int = 0
    success: bool = False
    tags: dict = field(default_factory=dict)

    @property
    def usd(self) -> float:
        p = PRICING[self.model]
        billable_in = self.input_tokens - self.cached_tokens
        return (
            billable_in * p["in"]
            + self.cached_tokens * p["cached_in"]
            + self.output_tokens * p["out"]
        ) / 1_000_000

@contextmanager
def measure(model: str, effort: str = "medium", **tags):
    task = TaskCost(task_id=str(uuid.uuid4()), model=model, effort=effort, tags=tags)
    started = time.monotonic()
    try:
        yield task
    finally:
        logger.bind(
            task_id=task.task_id,
            model=task.model,
            effort=task.effort,
            attempts=task.attempts,
            usd=round(task.usd, 6),
            success=task.success,
            latency_ms=round((time.monotonic() - started) * 1000, 1),
            **task.tags,
        ).info("llm_task")

with measure("gpt-6-luna", effort="medium", feature="ticket_triage") as task:
    for attempt in range(1, 4):
        task.attempts = attempt
        response = client.evaluate(state, questions)
        task.input_tokens += response.usage.input_tokens
        task.cached_tokens += response.usage.cached_input_tokens
        task.output_tokens += response.usage.output_tokens
        if validate(response):
            task.success = True
            break

SELECT
  feature,
  model,
  effort,
  COUNT(*)                                   AS tarefas,
  SUM(usd)                                   AS custo_total,
  AVG(success::int)                          AS taxa_sucesso,
  SUM(usd) / NULLIF(SUM(success::int), 0)    AS custo_por_sucesso,
  AVG(attempts)                              AS tentativas_medias
FROM llm_task
WHERE ts > now() - interval '7 days'
GROUP BY 1, 2, 3
ORDER BY custo_total DESC;

class BudgetExceeded(RuntimeError):
    pass

class Budget:
    """Teto diário por feature, com reserva otimista antes da chamada."""

    def __init__(self, store, daily_limit_usd: float):
        self.store = store
        self.limit = daily_limit_usd

    def reserve(self, feature: str, estimate_usd: float) -> None:
        spent = self.store.incr(f"budget:{feature}:{today()}", estimate_usd)
        if spent > self.limit:
            self.store.incr(f"budget:{feature}:{today()}", -estimate_usd)
            raise BudgetExceeded(f"{feature} excedeu US$ {self.limit:.2f} hoje")

    def settle(self, feature: str, estimate_usd: float, actual_usd: float) -> None:
        self.store.incr(f"budget:{feature}:{today()}", actual_usd - estimate_usd)