Skip to content

Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.

fix(route_advice): per-inbound-protocol native providers (enable OpenAI-in → Claude-out) (#3585)

Tejas Chopradc28413fd9ab
diff --git a/headroom/proxy/handlers/openai.py b/headroom/proxy/handlers/openai.py
index 463963e35..9d49650e5 100644
--- a/headroom/proxy/handlers/openai.py
+++ b/headroom/proxy/handlers/openai.py
@@ -4481,7 +4481,10 @@ class OpenAIHandlerMixin:
_normalize_openai_max_tokens(
body,
- backend_owns_translation=resolver_for(self).for_request(request) is not None,
+ backend_owns_translation=resolver_for(self).for_request(
+ request, native_providers=("openai",)
+ )
+ is not None,
)
# Output shaping (opt-in via HEADROOM_OUTPUT_SHAPER): verbosity steering
@@ -4550,9 +4553,13 @@ class OpenAIHandlerMixin:
# Route through LiteLLM/any-llm backend if configured -- or through a
# per-request one an extension asked for (see proxy/route_advice.py).
- # No advice resolves to `self.anthropic_backend`, so this is the same
- # condition it has always been.
- request_backend = resolver_for(self).for_request(request, body=body)
+ # anthropic is NOT native to this OpenAI-shape handler, so cross-family
+ # advice (e.g. Codex routed to a Claude model) resolves to a translating
+ # litellm backend; same-family (openai) advice still resolves to
+ # `self.anthropic_backend`, unchanged.
+ request_backend = resolver_for(self).for_request(
+ request, body=body, native_providers=("openai",)
+ )
if request_backend is not None:
try:
if stream:
diff --git a/headroom/proxy/route_advice.py b/headroom/proxy/route_advice.py
index 84ad31e21..aceb31c33 100644
--- a/headroom/proxy/route_advice.py
+++ b/headroom/proxy/route_advice.py
@@ -102,14 +102,31 @@ class BackendResolver:
def default(self) -> Any:
return self._default
- def for_request(self, request: Any, *, body: dict | None = None) -> Any:
- """The backend to serve this request. Falls back to the default."""
+ def for_request(
+ self,
+ request: Any,
+ *,
+ body: dict | None = None,
+ native_providers: tuple[str, ...] = _NATIVE,
+ ) -> Any:
+ """The backend to serve this request. Falls back to the default.
+
+ ``native_providers`` names the provider(s) whose wire format the caller
+ already holds, so no translating backend is needed. It defaults to
+ ``_NATIVE`` (``anthropic``) for the Anthropic handler, whose body is
+ Anthropic-shaped. The OpenAI handler passes ``("openai",)``: for an
+ OpenAI-shape request, *anthropic* is NOT native — it needs the litellm
+ openai->anthropic translation — so a Claude target must not be
+ short-circuited to the default backend. One proxy instance serves both
+ wires from a single shared resolver, so native-ness cannot live on the
+ resolver; it must be supplied per dispatch site.
+ """
advice = advice_from(request)
if advice is None:
return self._default
provider = advice.provider or _provider_of(advice.model)
- if not provider or provider in _NATIVE:
+ if not provider or provider in native_providers:
# Same protocol the proxy already speaks -- a `body["model"]`
# rewrite is enough and the extension has already done it. Nothing
# to switch.
diff --git a/tests/test_route_advice_native_providers.py b/tests/test_route_advice_native_providers.py
new file mode 100644
index 000000000..762c89edb
--- /dev/null
+++ b/tests/test_route_advice_native_providers.py
@@ -0,0 +1,81 @@
+"""BackendResolver.for_request native-provider gating.
+
+One proxy instance serves both the Anthropic and OpenAI wire from a single
+shared resolver, so "which provider needs no translation" cannot be a global
+constant — it depends on the inbound protocol. `native_providers` supplies it
+per dispatch site. Regression for the `_NATIVE = ("anthropic",)` hardcode that
+made an OpenAI-in request to a Claude model short-circuit to the OpenAI backend
+(never translating, never rewriting the model).
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+from headroom.proxy.route_advice import BackendResolver, RouteAdvice
+
+
+class _Sentinel:
+ """Stands in for a translating backend built by the resolver."""
+
+
+def _request(model: str, provider: str):
+ state = SimpleNamespace(headroom_route=RouteAdvice(model=model, provider=provider))
+ return SimpleNamespace(state=state)
+
+
+def _resolver() -> BackendResolver:
+ resolver = BackendResolver(default="DEFAULT_BACKEND")
+ # Avoid constructing a real litellm backend; prove routing, not litellm.
+ resolver._build = lambda provider: _Sentinel() # type: ignore[method-assign]
+ return resolver
+
+
+def test_no_advice_returns_default() -> None:
+ resolver = _resolver()
+ assert resolver.for_request(SimpleNamespace(state=SimpleNamespace())) == "DEFAULT_BACKEND"
+
+
+def test_anthropic_target_is_native_for_anthropic_handler() -> None:
+ # Default native set = anthropic (the Anthropic handler). A Claude target
+ # needs no translation: the body is already Anthropic-shaped.
+ resolver = _resolver()
+ result = resolver.for_request(_request("claude-opus-5", "anthropic"))
+ assert result == "DEFAULT_BACKEND"
+
+
+def test_anthropic_target_is_foreign_for_openai_handler() -> None:
+ # THE FIX: for an OpenAI-shape request, anthropic is NOT native — it must be
+ # translated. A Claude target now resolves to a built backend, not default.
+ resolver = _resolver()
+ body: dict = {"model": "gpt-4o"}
+ result = resolver.for_request(
+ _request("claude-opus-5", "anthropic"), body=body, native_providers=("openai",)
+ )
+ assert isinstance(result, _Sentinel)
+ assert body["model"] == "claude-opus-5", "body model must be rewritten to the advised model"
+
+
+def test_openai_target_is_native_for_openai_handler() -> None:
+ resolver = _resolver()
+ result = resolver.for_request(_request("gpt-4o", "openai"), native_providers=("openai",))
+ assert result == "DEFAULT_BACKEND"
+
+
+def test_openai_target_is_foreign_for_anthropic_handler() -> None:
+ # The already-working forward direction (Anthropic-in -> OpenAI-out).
+ resolver = _resolver()
+ body: dict = {"model": "claude-opus-5"}
+ result = resolver.for_request(_request("gpt-4o", "openai"), body=body)
+ assert isinstance(result, _Sentinel)
+ assert body["model"] == "gpt-4o"
+
+
+def test_failed_provider_falls_back_to_default() -> None:
+ resolver = BackendResolver(default="DEFAULT_BACKEND")
+ resolver._build = lambda provider: (_ for _ in ()).throw(RuntimeError("boom")) # type: ignore[method-assign]
+ # First call fails to build -> default; provider remembered as failed.
+ r1 = resolver.for_request(_request("claude-opus-5", "anthropic"), native_providers=("openai",))
+ assert r1 == "DEFAULT_BACKEND"
+ r2 = resolver.for_request(_request("claude-opus-5", "anthropic"), native_providers=("openai",))
+ assert r2 == "DEFAULT_BACKEND"