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.

test: expand provider pipeline coverage

JerrettDavisce8a2f3cf814
diff --git a/tests/test_canonical_pipeline.py b/tests/test_canonical_pipeline.py
index cd34f4ba2..621e6b0b9 100644
--- a/tests/test_canonical_pipeline.py
+++ b/tests/test_canonical_pipeline.py
@@ -33,6 +33,22 @@ class MutatingExtension:
return event
+class ReplacingExtension:
+ def on_pipeline_event(self, event):
+ return type(event)(
+ stage=event.stage,
+ operation=event.operation,
+ model=event.model,
+ messages=[{"role": "user", "content": "replaced"}],
+ metadata={"replaced": True},
+ )
+
+
+class RaisingExtension:
+ def on_pipeline_event(self, event):
+ raise RuntimeError("boom")
+
+
class RecordingHooks(CompressionHooks):
def __init__(self) -> None:
self.stages: list[PipelineStage] = []
@@ -130,6 +146,77 @@ def test_pipeline_extension_manager_uses_canonical_stage_contract():
assert event.messages == [{"role": "user", "content": "mutated"}]
+def test_pipeline_extension_manager_replaces_events_and_ignores_failures(caplog):
+ recorder = RecordingExtension()
+ manager = PipelineExtensionManager(
+ extensions=[recorder, RaisingExtension(), ReplacingExtension(), object()],
+ discover=False,
+ )
+
+ with caplog.at_level("WARNING", logger="headroom.pipeline"):
+ event = manager.emit(
+ PipelineStage.PRE_SEND,
+ operation="test",
+ model="gpt-4o",
+ messages=[{"role": "user", "content": "hello"}],
+ )
+
+ assert manager.enabled is True
+ assert recorder.stages == [PipelineStage.PRE_SEND]
+ assert event.messages == [{"role": "user", "content": "replaced"}]
+ assert event.metadata == {"replaced": True}
+
+
+def test_discover_pipeline_extensions_handles_load_and_init_failures(monkeypatch):
+ pipeline_module = importlib.import_module("headroom.pipeline")
+
+ class Entry:
+ def __init__(self, name, loader):
+ self.name = name
+ self._loader = loader
+
+ def load(self):
+ return self._loader()
+
+ class ExtensionClass:
+ def on_pipeline_event(self, event):
+ return event
+
+ class FailingInit:
+ def __init__(self):
+ raise RuntimeError("init failed")
+
+ entries = [
+ Entry("instance", lambda: RecordingExtension()),
+ Entry("class", lambda: ExtensionClass),
+ Entry("load-fail", lambda: (_ for _ in ()).throw(RuntimeError("load failed"))),
+ Entry("init-fail", lambda: FailingInit),
+ ]
+
+ monkeypatch.setattr(
+ pipeline_module.importlib.metadata,
+ "entry_points",
+ lambda group: entries if group == pipeline_module.ENTRY_POINT_GROUP else [],
+ )
+
+ discovered = pipeline_module.discover_pipeline_extensions()
+
+ assert len(discovered) == 2
+ assert hasattr(discovered[0], "on_pipeline_event")
+ assert hasattr(discovered[1], "on_pipeline_event")
+
+
+def test_discover_pipeline_extensions_returns_empty_when_entrypoint_lookup_fails(monkeypatch):
+ pipeline_module = importlib.import_module("headroom.pipeline")
+ monkeypatch.setattr(
+ pipeline_module.importlib.metadata,
+ "entry_points",
+ lambda group: (_ for _ in ()).throw(RuntimeError("lookup failed")),
+ )
+
+ assert pipeline_module.discover_pipeline_extensions() == []
+
+
def test_compress_emits_canonical_pipeline_events(monkeypatch):
hooks = RecordingHooks()
compress_module = importlib.import_module("headroom.compress")
diff --git a/tests/test_provider_copilot_wrap.py b/tests/test_provider_copilot_wrap.py
new file mode 100644
index 000000000..04799fde0
--- /dev/null
+++ b/tests/test_provider_copilot_wrap.py
@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import io
+import json
+import urllib.error
+from unittest.mock import patch
+
+from headroom.providers.copilot.wrap import (
+ build_launch_env,
+ detect_running_proxy_backend,
+ model_configured,
+ provider_key_source,
+ query_proxy_config,
+ resolve_provider_type,
+ validate_configuration,
+)
+
+
+def test_query_proxy_config_handles_success_and_invalid_payload() -> None:
+ payload = io.BytesIO(json.dumps({"config": {"backend": "anyllm"}}).encode("utf-8"))
+ payload_missing = io.BytesIO(json.dumps({"status": "ok"}).encode("utf-8"))
+
+ with patch("urllib.request.urlopen", return_value=payload):
+ assert query_proxy_config(8787) == {"backend": "anyllm"}
+ with patch("urllib.request.urlopen", return_value=payload_missing):
+ assert query_proxy_config(8787) is None
+ with patch("urllib.request.urlopen", side_effect=urllib.error.URLError("down")):
+ assert query_proxy_config(8787) is None
+
+
+def test_detect_running_proxy_backend_requires_string_backend(monkeypatch) -> None:
+ monkeypatch.setattr(
+ "headroom.providers.copilot.wrap.query_proxy_config",
+ lambda port: {"backend": 123} if port == 8787 else None,
+ )
+
+ assert detect_running_proxy_backend(8787) is None
+ assert detect_running_proxy_backend(9999) is None
+
+
+def test_resolve_provider_type_prefers_explicit_and_env() -> None:
+ assert resolve_provider_type("anthropic", "openai") == "openai"
+ assert resolve_provider_type(None, "auto", {"HEADROOM_BACKEND": "anthropic"}) == "anthropic"
+ assert resolve_provider_type(None, "auto", {"HEADROOM_BACKEND": "anyllm"}) == "openai"
+
+
+def test_validate_configuration_accepts_supported_combinations() -> None:
+ validate_configuration(provider_type="openai", wire_api="responses", backend=None)
+ validate_configuration(provider_type="openai", wire_api="completions", backend="anyllm")
+
+
+def test_provider_key_source_and_build_launch_env_cover_anthropic_and_openai() -> None:
+ assert provider_key_source("anthropic") == "ANTHROPIC_API_KEY"
+ assert provider_key_source("openai") == "OPENAI_API_KEY"
+
+ anthropic_env, anthropic_lines = build_launch_env(
+ port=8787,
+ provider_type="anthropic",
+ wire_api="responses",
+ environ={
+ "ANTHROPIC_API_KEY": "sk-ant-test",
+ "COPILOT_PROVIDER_WIRE_API": "stale",
+ },
+ )
+ openai_env, openai_lines = build_launch_env(
+ port=8787,
+ provider_type="openai",
+ wire_api=None,
+ environ={"OPENAI_API_KEY": "sk-proj-test"},
+ )
+
+ assert anthropic_env["COPILOT_PROVIDER_TYPE"] == "anthropic"
+ assert anthropic_env["COPILOT_PROVIDER_BASE_URL"] == "http://127.0.0.1:8787"
+ assert anthropic_env["COPILOT_PROVIDER_API_KEY"] == "sk-ant-test"
+ assert "COPILOT_PROVIDER_WIRE_API" not in anthropic_env
+ assert anthropic_lines == [
+ "COPILOT_PROVIDER_TYPE=anthropic",
+ "COPILOT_PROVIDER_BASE_URL=http://127.0.0.1:8787",
+ ]
+
+ assert openai_env["COPILOT_PROVIDER_TYPE"] == "openai"
+ assert openai_env["COPILOT_PROVIDER_BASE_URL"] == "http://127.0.0.1:8787/v1"
+ assert openai_env["COPILOT_PROVIDER_WIRE_API"] == "completions"
+ assert openai_env["COPILOT_PROVIDER_API_KEY"] == "sk-proj-test"
+ assert openai_lines[-1] == "COPILOT_PROVIDER_WIRE_API=completions"
+
+
+def test_model_configured_detects_env_and_cli_variants() -> None:
+ assert model_configured((), {"COPILOT_MODEL": "gpt-4o"}) is True
+ assert model_configured(("--model", "gpt-4o"), {}) is True
+ assert model_configured(("--model=gpt-4o",), {}) is True
+ assert model_configured(("--other", "value"), {}) is False
diff --git a/tests/test_provider_proxy_routes.py b/tests/test_provider_proxy_routes.py
new file mode 100644
index 000000000..05d57b909
--- /dev/null
+++ b/tests/test_provider_proxy_routes.py
@@ -0,0 +1,283 @@
+from __future__ import annotations
+
+import importlib
+from typing import Any
+
+import httpx
+from fastapi.responses import JSONResponse
+from fastapi.testclient import TestClient
+
+from headroom.proxy.server import HeadroomProxy, ProxyConfig, create_app
+
+
+def _app() -> Any:
+ return create_app(
+ ProxyConfig(
+ optimize=False,
+ cache_enabled=False,
+ rate_limit_enabled=False,
+ anthropic_api_url="https://api.anthropic.test",
+ openai_api_url="https://api.openai.test",
+ gemini_api_url="https://api.gemini.test",
+ cloudcode_api_url="https://cloudcode.test",
+ )
+ )
+
+
+def test_provider_passthrough_routes_forward_expected_targets(monkeypatch) -> None:
+ calls: list[tuple[str, str, str, str]] = []
+
+ async def fake_passthrough(self, request, base_url, sub_path="", provider_name=""): # type: ignore[no-untyped-def]
+ calls.append((request.method, request.url.path, base_url, provider_name))
+ return JSONResponse(
+ {
+ "method": request.method,
+ "path": request.url.path,
+ "base_url": base_url,
+ "sub_path": sub_path,
+ "provider": provider_name,
+ }
+ )
+
+ monkeypatch.setattr(HeadroomProxy, "handle_passthrough", fake_passthrough)
+
+ with TestClient(_app()) as client:
+ assert client.post("/v1/messages/count_tokens").json()["base_url"] == (
+ "https://api.anthropic.test"
+ )
+ assert client.get("/v1/models", headers={"x-goog-api-key": "test"}).json()["base_url"] == (
+ "https://api.openai.test"
+ )
+ assert client.get("/v1/models/demo").json()["sub_path"] == "models"
+ assert (
+ client.get(
+ "/azure/models",
+ headers={
+ "api-key": "azure-key",
+ "x-headroom-base-url": "https://azure.example/openai/",
+ },
+ ).json()["base_url"]
+ == "https://azure.example/openai"
+ )
+ assert client.post("/v1/embeddings").json()["provider"] == "openai"
+ assert client.post("/v1/moderations").json()["sub_path"] == "moderations"
+ assert client.post("/v1/images/generations").json()["sub_path"] == "images/generations"
+ assert client.post("/v1/audio/transcriptions").json()["sub_path"] == "audio/transcriptions"
+ assert client.post("/v1/audio/speech").json()["sub_path"] == "audio/speech"
+ assert client.get("/v1beta/models").json()["provider"] == "gemini"
+ assert client.get("/v1beta/models/demo").json()["sub_path"] == "models"
+ assert client.post("/v1beta/models/demo:embedContent").json()["sub_path"] == "embedContent"
+ assert client.post("/v1beta/cachedContents").json()["sub_path"] == "cachedContents"
+ assert client.get("/v1beta/cachedContents").json()["sub_path"] == "cachedContents"
+ assert client.get("/v1beta/cachedContents/cache-1").json()["sub_path"] == "cachedContents"
+ assert client.delete("/v1beta/cachedContents/cache-1").json()["sub_path"] == (
+ "cachedContents"
+ )
+ assert (
+ client.get(
+ "/unhandled/path",
+ headers={"x-headroom-base-url": "https://custom.example/base/"},
+ ).json()["base_url"]
+ == "https://custom.example/base"
+ )
+ assert client.get("/another/path", headers={"x-goog-api-key": "test"}).json()[
+ "base_url"
+ ] == ("https://api.gemini.test")
+
+ assert len(calls) >= 16
+
+
+def test_proxy_route_helpers_prefer_legacy_targets_and_gemini_passthrough() -> None:
+ proxy_routes = importlib.import_module("headroom.providers.proxy_routes")
+ proxy = type(
+ "Proxy",
+ (),
+ {
+ "ANTHROPIC_API_URL": "https://legacy.anthropic.test",
+ "OPENAI_API_URL": "https://legacy.openai.test",
+ "GEMINI_API_URL": "https://legacy.gemini.test",
+ "provider_runtime": type(
+ "Runtime",
+ (),
+ {
+ "api_target": staticmethod(lambda provider: f"https://runtime.{provider}.test"),
+ "model_metadata_provider": staticmethod(lambda headers: "anthropic"),
+ },
+ )(),
+ },
+ )()
+
+ assert proxy_routes._api_target(proxy, "anthropic") == "https://legacy.anthropic.test"
+ assert proxy_routes._select_passthrough_base_url(proxy, {"x-goog-api-key": "test"}) == (
+ "https://legacy.gemini.test"
+ )
+ assert (
+ proxy_routes._select_passthrough_base_url(
+ proxy, {"api-key": "azure", "x-headroom-base-url": "https://azure.example/base/"}
+ )
+ == "https://azure.example/base"
+ )
+ assert proxy_routes._select_passthrough_base_url(proxy, {}) == "https://legacy.anthropic.test"
+
+
+def test_provider_specific_routes_delegate_to_expected_proxy_handlers(monkeypatch) -> None:
+ delegated: list[tuple[str, str, tuple[str, ...]]] = []
+
+ def install(name: str) -> None:
+ async def fake(self, request, *args): # type: ignore[no-untyped-def]
+ delegated.append((name, request.url.path, tuple(str(arg) for arg in args)))
+ return JSONResponse({"handler": name, "path": request.url.path, "args": list(args)})
+
+ monkeypatch.setattr(HeadroomProxy, name, fake)
+
+ for handler_name in (
+ "handle_anthropic_messages",
+ "handle_anthropic_batch_create",
+ "handle_anthropic_batch_passthrough",
+ "handle_anthropic_batch_results",
+ "handle_openai_chat",
+ "handle_openai_responses",
+ "handle_batch_create",
+ "handle_batch_list",
+ "handle_batch_get",
+ "handle_batch_cancel",
+ "handle_gemini_generate_content",
+ "handle_gemini_stream_generate_content",
+ "handle_gemini_count_tokens",
+ "handle_google_cloudcode_stream",
+ "handle_databricks_invocations",
+ "handle_google_batch_create",
+ "handle_google_batch_results",
+ "handle_google_batch_passthrough",
+ ):
+ install(handler_name)
+
+ with TestClient(_app()) as client:
+ assert client.post("/v1/messages").json()["handler"] == "handle_anthropic_messages"
+ assert (
+ client.post("/v1/messages/batches").json()["handler"] == "handle_anthropic_batch_create"
+ )
+ assert client.get("/v1/messages/batches").json()["handler"] == (
+ "handle_anthropic_batch_passthrough"
+ )
+ assert client.get("/v1/messages/batches/b1").json()["args"] == ["b1"]
+ assert client.get("/v1/messages/batches/b1/results").json()["handler"] == (
+ "handle_anthropic_batch_results"
+ )
+ assert client.post("/v1/messages/batches/b1/cancel").json()["handler"] == (
+ "handle_anthropic_batch_passthrough"
+ )
+ assert client.post("/v1/chat/completions").json()["handler"] == "handle_openai_chat"
+ assert client.post("/v1/responses").json()["handler"] == "handle_openai_responses"
+ assert client.post("/v1/codex/responses").json()["handler"] == "handle_openai_responses"
+ assert client.post("/backend-api/responses").json()["handler"] == "handle_openai_responses"
+ assert client.post("/backend-api/codex/responses").json()["handler"] == (
+ "handle_openai_responses"
+ )
+ assert client.post("/v1/batches").json()["handler"] == "handle_batch_create"
+ assert client.get("/v1/batches").json()["handler"] == "handle_batch_list"
+ assert client.get("/v1/batches/b1").json()["handler"] == "handle_batch_get"
+ assert client.post("/v1/batches/b1/cancel").json()["handler"] == "handle_batch_cancel"
+ assert client.post("/v1beta/models/demo:generateContent").json()["handler"] == (
+ "handle_gemini_generate_content"
+ )
+ assert client.post("/v1beta/models/demo:streamGenerateContent").json()["handler"] == (
+ "handle_gemini_stream_generate_content"
+ )
+ assert client.post("/v1beta/models/demo:countTokens").json()["handler"] == (
+ "handle_gemini_count_tokens"
+ )
+ assert client.post("/v1internal:streamGenerateContent").json()["handler"] == (
+ "handle_google_cloudcode_stream"
+ )
+ assert client.post("/v1/v1internal:streamGenerateContent").json()["handler"] == (
+ "handle_google_cloudcode_stream"
+ )
+ assert client.post("/serving-endpoints/demo/invocations").json()["handler"] == (
+ "handle_databricks_invocations"
+ )
+ assert client.post("/v1beta/models/demo:batchGenerateContent").json()["handler"] == (
+ "handle_google_batch_create"
+ )
+ assert client.get("/v1beta/batches/b1").json()["handler"] == "handle_google_batch_results"
+ assert client.post("/v1beta/batches/b1:cancel").json()["handler"] == (
+ "handle_google_batch_passthrough"
+ )
+ assert client.delete("/v1beta/batches/b1").json()["handler"] == (
+ "handle_google_batch_passthrough"
+ )
+
+ assert len(delegated) >= 24
+
+
+def test_openai_response_websocket_aliases_delegate_to_openai_ws_handler(monkeypatch) -> None:
+ seen_paths: list[str] = []
+
+ async def fake_ws(self, websocket): # type: ignore[no-untyped-def]
+ seen_paths.append(websocket.url.path)
+ await websocket.accept()
+ await websocket.send_json({"path": websocket.url.path})
+ await websocket.close()
+
+ monkeypatch.setattr(HeadroomProxy, "handle_openai_responses_ws", fake_ws)
+
+ with TestClient(_app()) as client:
+ for path in (
+ "/v1/responses",
+ "/v1/codex/responses",
+ "/backend-api/responses",
+ "/backend-api/codex/responses",
+ ):
+ with client.websocket_connect(path) as websocket:
+ assert websocket.receive_json() == {"path": path}
+
+ assert seen_paths == [
+ "/v1/responses",
+ "/v1/codex/responses",
+ "/backend-api/responses",
+ "/backend-api/codex/responses",
+ ]
+
+
+def test_openai_response_subpath_passthrough_returns_502_on_http_failure() -> None:
+ class FailingAsyncClient:
+ async def request(self, method, url, **kwargs): # type: ignore[no-untyped-def]
+ raise RuntimeError(f"boom: {method} {url}")
+
+ async def aclose(self) -> None:
+ return None
+
+ with TestClient(_app()) as client:
+ client.app.state.proxy.http_client = FailingAsyncClient()
+ response = client.post("/v1/responses/compact?trace=1", json={"model": "gpt-4o"})
+
+ assert response.status_code == 502
+ assert "boom: POST https://api.openai.test/v1/responses/compact?trace=1" in response.text
+
+
+def test_openai_response_subpath_passthrough_uses_openai_target() -> None:
+ class FakeAsyncClient:
+ def __init__(self) -> None:
+ self.calls: list[tuple[str, str, dict[str, str]]] = []
+
+ async def request(self, method, url, **kwargs): # type: ignore[no-untyped-def]
+ self.calls.append((method, url, dict(kwargs.get("headers", {}))))
+ return httpx.Response(200, json={"url": url})
+
+ async def aclose(self) -> None:
+ return None
+
+ with TestClient(_app()) as client:
+ fake = FakeAsyncClient()
+ client.app.state.proxy.http_client = fake
+ response = client.delete(
+ "/v1/responses/items/resp_123?trace=7",
+ headers={"Authorization": "Bearer sk-proj-test"},
+ )
+
+ assert response.status_code == 200
+ assert len(fake.calls) == 1
+ method, url, headers = fake.calls[0]
+ assert method == "DELETE"
+ assert url == "https://api.openai.test/v1/responses/items/resp_123?trace=7"
+ assert headers["authorization"] == "Bearer sk-proj-test"
diff --git a/tests/test_provider_registry_extended.py b/tests/test_provider_registry_extended.py
new file mode 100644
index 000000000..d584d9cae
--- /dev/null
+++ b/tests/test_provider_registry_extended.py
@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import logging
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+
+from headroom.providers.registry import (
+ ProviderApiTargets,
+ ProxyProviderRuntime,
+ call_client_transport,
+ create_proxy_backend,
+ format_backend_status,
+)
+
+
+class DummyStorage:
+ def __init__(self) -> None:
+ self.saved: list[Any] = []
+
+ def save(self, metrics: Any) -> None:
+ self.saved.append(metrics)
+
+
+class DummyClient:
+ def __init__(self) -> None:
+ self._storage = DummyStorage()
+ self._wrapped_stream: tuple[Any, Any] | None = None
+ self._original = SimpleNamespace(
+ chat=SimpleNamespace(completions=SimpleNamespace(create=self._openai_create)),
+ messages=SimpleNamespace(create=self._anthropic_create, stream=self._anthropic_stream),
+ )
+ self.openai_calls: list[dict[str, Any]] = []
+ self.anthropic_calls: list[dict[str, Any]] = []
+
+ def _openai_create(self, **kwargs: Any) -> Any:
+ self.openai_calls.append(kwargs)
+ if kwargs["stream"]:
+ return iter(["chunk-1", "chunk-2"])
+ return SimpleNamespace(
+ usage=SimpleNamespace(
+ completion_tokens=7,
+ prompt_tokens_details=SimpleNamespace(cached_tokens=3),
+ )
+ )
+
+ def _anthropic_create(self, **kwargs: Any) -> Any:
+ self.anthropic_calls.append(kwargs)
+ return SimpleNamespace(
+ usage=SimpleNamespace(
+ output_tokens=5,
+ cache_read_input_tokens=2,
+ )
+ )
+
+ def _anthropic_stream(self, **kwargs: Any) -> Any:
+ self.anthropic_calls.append(kwargs)
+ return "anthropic-stream"
+
+ def _wrap_stream(self, stream: Any, metrics: Any) -> Any:
+ self._wrapped_stream = (stream, metrics)
+ return ("wrapped", stream)
+
+
+def test_proxy_provider_runtime_selects_targets_and_providers() -> None:
+ runtime = ProxyProviderRuntime(
+ api_targets=ProviderApiTargets(
+ anthropic="https://anthropic.example",
+ openai="https://openai.example",
+ gemini="https://gemini.example",
+ cloudcode="https://cloudcode.example",
+ ),
+ pipeline_providers={
+ "anthropic": SimpleNamespace(name="anthropic"),
+ "openai": SimpleNamespace(name="openai"),
+ },
+ )
+
+ assert runtime.api_target("anthropic") == "https://anthropic.example"
+ assert runtime.pipeline_provider("openai").name == "openai"
+ assert runtime.model_metadata_provider({"Authorization": "Bearer sk-ant-api03-test"}) == (
+ "anthropic"
+ )
+ assert runtime.select_passthrough_base_url({"x-goog-api-key": "test"}) == (
+ "https://gemini.example"
+ )
+ assert (
+ runtime.select_passthrough_base_url(
+ {"api-key": "azure-key", "x-headroom-base-url": "https://azure.example/openai/"}
+ )
+ == "https://azure.example/openai"
+ )
+ assert runtime.select_passthrough_base_url({}) == "https://openai.example"
+
+
+def test_create_proxy_backend_uses_injected_backend_types() -> None:
+ logger = logging.getLogger("test")
+
+ anyllm = create_proxy_backend(
+ backend="anyllm",
+ anyllm_provider="groq",
+ bedrock_region=None,
+ logger=logger,
+ anyllm_backend_cls=lambda provider: {"kind": "anyllm", "provider": provider},
+ )
+ litellm = create_proxy_backend(
+ backend="bedrock",
+ anyllm_provider="ignored",
+ bedrock_region="us-east-1",
+ logger=logger,
+ litellm_backend_cls=lambda provider, region: {
+ "kind": "litellm",
+ "provider": provider,
+ "region": region,
+ },
+ )
+
+ assert anyllm == {"kind": "anyllm", "provider": "groq"}
+ assert litellm == {"kind": "litellm", "provider": "bedrock", "region": "us-east-1"}
+
+
+def test_create_proxy_backend_handles_missing_or_direct_backends(
+ caplog: pytest.LogCaptureFixture,
+) -> None:
+ logger = logging.getLogger("test")
+
+ direct = create_proxy_backend(
+ backend="anthropic",
+ anyllm_provider="ignored",
+ bedrock_region=None,
+ logger=logger,
+ )
+
+ with caplog.at_level(logging.WARNING):
+ missing = create_proxy_backend(
+ backend="anyllm",
+ anyllm_provider="groq",
+ bedrock_region=None,
+ logger=logger,
+ anyllm_backend_cls=lambda provider: (_ for _ in ()).throw(ImportError("missing")),
+ )
+
+ assert direct is None
+ assert missing is None
+ assert "any-llm backend not available" in caplog.text
+
+
+def test_format_backend_status_uses_litellm_provider_metadata(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ monkeypatch.setattr(
+ "headroom.backends.litellm.get_provider_config",
+ lambda provider: SimpleNamespace(
+ display_name=provider.upper(),
+ uses_region=(provider == "bedrock"),
+ ),
+ )
+
+ assert (
+ format_backend_status(
+ backend="litellm-bedrock",
+ anyllm_provider="ignored",
+ bedrock_region="us-west-2",
+ )
+ == "BEDROCK via LiteLLM (region=us-west-2)"
+ )
+ assert (
+ format_backend_status(
+ backend="litellm-openai",
+ anyllm_provider="ignored",
+ bedrock_region=None,
+ )
+ == "OPENAI via LiteLLM"
+ )
+
+
+def test_call_client_transport_covers_openai_and_anthropic_paths() -> None:
+ client = DummyClient()
+ openai_metrics = SimpleNamespace(tokens_output=0, cached_tokens=0)
+ anthropic_metrics = SimpleNamespace(tokens_output=0, cached_tokens=0)
+
+ openai_response = call_client_transport(
+ "openai",
+ client,
+ model="gpt-4o",
+ messages=[{"role": "user", "content": "hello"}],
+ stream=False,
+ metrics=openai_metrics,
+ temperature=0,
+ )
+ openai_stream = call_client_transport(
+ "openai",
+ client,
+ model="gpt-4o",
+ messages=[{"role": "user", "content": "hello"}],
+ stream=True,
+ metrics=openai_metrics,
+ )
+ anthropic_response = call_client_transport(
+ "anthropic",
+ client,
+ model="claude-sonnet",
+ messages=[{"role": "user", "content": "hello"}],
+ stream=False,
+ metrics=anthropic_metrics,
+ max_tokens=32,
+ )
+ anthropic_stream = call_client_transport(
+ "anthropic",
+ client,
+ model="claude-sonnet",
+ messages=[{"role": "user", "content": "hello"}],
+ stream=True,
+ metrics=anthropic_metrics,
+ max_tokens=32,
+ )
+
+ assert openai_response.usage.completion_tokens == 7
+ assert openai_metrics.tokens_output == 7
+ assert openai_metrics.cached_tokens == 3
+ assert openai_stream == ("wrapped", client._wrapped_stream[0])
+ assert anthropic_response.usage.output_tokens == 5
+ assert anthropic_metrics.tokens_output == 5
+ assert anthropic_metrics.cached_tokens == 2
+ assert anthropic_stream == "anthropic-stream"
+ assert len(client._storage.saved) == 3
+
+
+def test_call_client_transport_rejects_unknown_api_style() -> None:
+ with pytest.raises(ValueError, match="Unsupported api_style"):
+ call_client_transport(
+ "unknown",
+ DummyClient(),
+ model="gpt-4o",
+ messages=[],
+ stream=False,
+ metrics=SimpleNamespace(),
+ )