Files
headroom/tests/test_pricing_litellm_model_resolution.py
Tejas Chopra 0ad5e68ca5 fix(tests): ask litellm for a model it prices instead of naming a retired one (#3722)
## What broke

`litellm` downloads `model_prices_and_context_window.json` from GitHub
**at import time**, so `litellm.model_cost` is live third-party data we
do not control.

On 2026-09-23 BerriAI pruned retired Anthropic ids from that table.
`claude-sonnet-4-20250514` disappeared, and every test that priced it
started failing with `KeyError: 'input_cost_per_token'` — on every open
PR simultaneously, with no change on our side. `main` was green at
`5ff4ea1e` on 09-22 and the identical shards went red on #3720 and
#3721, which share that base and touch no pricing code.

## What this does

The model id in those tests is **incidental**. They assert that
Headroom's cost arithmetic agrees with litellm's numbers — not that any
particular model is priced correctly. So `tests/_pricing_models.py` asks
for *a* model carrying the fields a test needs, newest first, and raises
with an actionable message if litellm prices none of them.

```python
MODEL = anthropic_pricing_model(
    "input_cost_per_token_above_200k_tokens",
    "cache_creation_input_token_cost",
    "cache_read_input_token_cost",
)
```

Retiring one candidate is now a no-op until the list runs dry.

## Why not pin to the wheel's vendored copy

That was this PR's first attempt and **it was wrong** — I'm recording
why, because it looks like the obvious fix.

The live table and the copy vendored in the litellm wheel are
*complementary, not ordered*:

| | live | vendored |
|---|---|---|
| `claude-sonnet-4-20250514` | ✗ pruned | ✓ |
| `claude-sonnet-5` | ✓ | ✗ predates it |
| live-only entries | 1743 | — |
| vendored-only entries | — | 314 |

Pinning fixed the 25 `KeyError`s and **broke
`test_proxy_savings_history`**, which prices `claude-sonnet-5`. Taking
the union does not rescue it either: the vendored
`claude-sonnet-4-20250514` entry is an older schema that has no
`input_cost_per_token_above_200k_tokens` field at all, so
`test_cost_card_attribution` still fails against it.

## A second, separate breakage in the same data drop


`test_provider_prices_models_its_table_never_covered[groq/llama-3.3-70b-versatile]`
was failing for a different reason: litellm dropped that model too, so
`_get_pricing` fell through to the `$2.50/$10.00` GPT-4o default — which
that test's own comment names as the "unknown default" it exists to
catch. Repointed at `groq/llama-guard-3-8b`, which litellm still prices.

**The product-side problem is filed separately as #3732**: an
unresolvable model is silently billed at the GPT-4o tier, so cost
tracking and `check_budget` — a hard control that refuses requests — can
act on a fabricated number. For that groq model the default overstated
output cost by ~12x.

## Verification

Same six modules, same machine:

```
origin/main          25 failed, 82 passed
this branch                    107 passed
```

Ruff 0.16.7 `check` + `format --check` clean.

## Prior art

#3683 / #3684 was the same class of failure (litellm started billing
DeepSeek off-peak) and was patched narrowly at the assertion. This
removes the category for model *identity*; #3732 covers what happens in
production when identity goes missing.
2026-09-23 11:03:26 +02:00

130 lines
5.4 KiB
Python

from __future__ import annotations
from headroom.pricing.litellm_model_resolution import (
MODEL_ALIASES,
LiteLLMModelPrefixRule,
_strip_vertex_version_suffix,
pricing_lookup_candidates,
resolution_candidates,
resolve_litellm_model_name,
)
def test_prefix_rule_matches_case_insensitively() -> None:
rule = LiteLLMModelPrefixRule("minimax-", "minimax/")
assert rule.candidate_for("MiniMax-M3") == "minimax/MiniMax-M3"
assert rule.candidate_for("gpt-4o") is None
def test_resolution_candidates_try_bare_then_matching_prefix_then_alias() -> None:
assert resolution_candidates("gpt-4o") == ("gpt-4o", "openai/gpt-4o")
assert resolution_candidates("MiniMax-M3") == ("MiniMax-M3", "minimax/MiniMax-M3")
retired = "claude-3-5-sonnet-20241022"
candidates = resolution_candidates(retired)
assert candidates[0] == retired
assert f"anthropic/{retired}" in candidates
assert f"vertex_ai/{retired}" not in candidates # no @YYYYMMDD suffix = not Vertex
assert MODEL_ALIASES[retired] in candidates
def test_pricing_lookup_candidates_include_provider_prefixes_and_aliases() -> None:
candidates = pricing_lookup_candidates("claude-3-5-sonnet-20241022")
assert candidates[0] == "claude-3-5-sonnet-20241022"
assert "anthropic/claude-3-5-sonnet-20241022" in candidates
assert "minimax/claude-3-5-sonnet-20241022" in candidates
assert candidates[-1] == MODEL_ALIASES["claude-3-5-sonnet-20241022"]
def test_retired_claude_3_sonnet_aliases_to_sonnet_tier_not_haiku() -> None:
"""Retired claude-3-sonnet must map to a Sonnet-tier price, not Haiku.
claude-3-sonnet-20240229 was a $3/$15-per-1M model; aliasing it to
claude-3-haiku-20240307 ($0.25/$1.25) underpriced its cost/savings ~12x.
"""
alias = MODEL_ALIASES["claude-3-sonnet-20240229"]
assert "haiku" not in alias
assert "sonnet" in alias
# Same-tier target as the other retired-Sonnet aliases.
assert alias == MODEL_ALIASES["claude-3-5-sonnet-20241022"]
# Deliberately not a specific release: this asserted
# "claude-sonnet-4-20250514" until litellm pruned that id, at which point
# the alias had to move and this test broke for naming the target rather
# than the property it cares about. That the target is *priced*, and priced
# at Sonnet rates rather than the unknown-model default, is asserted in
# tests/test_model_alias_targets_are_priced.py.
def test_resolve_litellm_model_name_returns_first_known_candidate() -> None:
known = {"openai/gpt-4o"}
assert resolve_litellm_model_name("gpt-4o", known.__contains__) == "openai/gpt-4o"
def test_resolve_litellm_model_name_returns_original_when_unknown() -> None:
assert resolve_litellm_model_name("mystery-model", lambda _: False) == "mystery-model"
def test_strip_vertex_version_suffix() -> None:
assert _strip_vertex_version_suffix("claude-haiku-4-5@20251001") == "claude-haiku-4-5"
assert _strip_vertex_version_suffix("claude-opus-4@20250514") == "claude-opus-4"
assert _strip_vertex_version_suffix("claude-sonnet-4-6") == "claude-sonnet-4-6"
assert _strip_vertex_version_suffix("claude-sonnet-4-20250514") == "claude-sonnet-4-20250514"
def test_resolution_candidates_vertex_versioned_models() -> None:
# Vertex appends @YYYYMMDD — bare name and vertex_ai/ must be candidates
candidates = resolution_candidates("claude-haiku-4-5@20251001")
assert "claude-haiku-4-5" in candidates
assert "anthropic/claude-haiku-4-5" in candidates
assert "vertex_ai/claude-haiku-4-5" in candidates # vertex_ai/ only for versioned
candidates = resolution_candidates("claude-opus-4@20250514")
assert "claude-opus-4" in candidates
assert "anthropic/claude-opus-4" in candidates
assert "vertex_ai/claude-opus-4" in candidates
# Non-versioned names should NOT get vertex_ai/ candidates
candidates = resolution_candidates("claude-sonnet-4-6")
assert candidates[0] == "claude-sonnet-4-6"
assert "vertex_ai/claude-sonnet-4-6" not in candidates
assert "anthropic/claude-sonnet-4-6" in candidates
def test_pricing_lookup_candidates_vertex_versioned_models() -> None:
candidates = pricing_lookup_candidates("claude-haiku-4-5@20251001")
# Bare name and vertex_ai/ prefix must both be candidates
assert "claude-haiku-4-5" in candidates
assert "vertex_ai/claude-haiku-4-5" in candidates
assert "anthropic/claude-haiku-4-5" in candidates
candidates = pricing_lookup_candidates("claude-opus-4@20250514")
assert "claude-opus-4" in candidates
assert "vertex_ai/claude-opus-4" in candidates
# Non-versioned names should NOT get vertex_ai/ pricing candidates
candidates = pricing_lookup_candidates("claude-sonnet-4-6")
assert "vertex_ai/claude-sonnet-4-6" not in candidates
assert "anthropic/claude-sonnet-4-6" in candidates
def test_vertex_versioned_model_resolves_to_known_key() -> None:
# Simulate LiteLLM knowing the bare model name (not the versioned one)
known = {"claude-haiku-4-5", "anthropic/claude-sonnet-4-6"}
assert (
resolve_litellm_model_name("claude-haiku-4-5@20251001", known.__contains__)
== "claude-haiku-4-5"
)
assert (
resolve_litellm_model_name("claude-sonnet-4-6", known.__contains__)
== "anthropic/claude-sonnet-4-6"
)
# Unknown versioned model falls back to original
assert (
resolve_litellm_model_name("claude-unknown@20251001", lambda _: False)
== "claude-unknown@20251001"
)