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.
Python agentaianthropicclaude-codecompressioncontext-engineeringcontext-windowcursorfastapilangchainllmmcpopenaiprompt-engineeringproxypythonragtoken-optimizationtokenstypescript
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.pyindex 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.pyindex 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._defaultprovider = 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.pynew file mode 100644index 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"