refactor: address batch-2 review feedback

Must-fix:
- Silent fallthrough when body.corpus was valid-per-Literal but not
in corpus_map (e.g. k8s removed from YAML but still in the
AskRequest Literal) is now a loud HTTPException(400) with the list
of available corpora in the detail. Mirrors the Task 2 AppConfig
validator for default_corpus but at request time.

Should-fix:
- Moved two_corpus_two_provider_app and _FakeOpenAI into
tests/conftest.py so test_corpus_routing.py, test_meta_corpus.py,
and test_prompt_template.py all consume a single source of truth
instead of cross-importing each other.
- Hoisted format_system_prompt import to the top of routes.py and
HTTPException / AppConfig alongside it.
- Fixed test_prompt_template.py ordering: imports at top, no more
bottom-of-file E402 noqa, no more `import pytest` inside a class
body.
- Removed `# noqa: F811` from test_meta_corpus.py fixture parameters
now that the fixture comes from conftest.

Security:
- AskRequest.provider is now a Literal constrained to
{openai, anthropic, selfhosted, mock}. Unknown providers fail
validation with 422 instead of silently falling back to
app.state.orchestrator.

Performance:
- format_system_prompt wrapped in @lru_cache(maxsize=32). The corpus
label set is tiny (a handful) and the function is called once per
/ask request; cache hit rate is effectively 100% post-warmup.
Includes a test that asserts identity-equality on repeated calls
so the cache can't silently regress.

Nice-to-haves:
- Direct unit tests for _resolve_orchestrator and
_resolve_system_prompt using a SimpleNamespace fake Request. Cover
happy path, provider fallback within corpus, legacy mode, and the
400-raise. Run in ~0.7s vs ~60s for HTTP-based coverage.
- Fixed `config: object` -> `config: AppConfig` in ask_stream.

Tests:
- 410 -> 421 (+11 new): 7 helper unit tests, 3 misconfiguration-400
tests, 1 lru_cache identity test. Ruff clean. Mypy clean on routes,
schemas, prompts.

agent_bench/core/prompts.py

@@ -7,6 +7,8 @@ prevents per-corpus drift when the prompt is tuned.
 
 from __future__ import annotations
 
+from functools import lru_cache
+
 SYSTEM_PROMPT_TEMPLATE = """\
 You are a technical documentation assistant for {corpus_label}. Answer \
 questions using ONLY the retrieved context from the {corpus_label} \
@@ -18,11 +20,13 @@ extrapolate, do not draw on general knowledge.\
 """
 
 
+@lru_cache(maxsize=32)
 def format_system_prompt(corpus_label: str) -> str:
     """Format the template with a corpus label.
 
-    Raises at call time if the caller forgets to pass a label, which is
-    louder than silently returning a prompt with an unresolved
+    Cached because the corpus label set is small (a handful of corpora)
+    and the prompt is requested once per /ask call. Raises on empty
+    label — louder than silently returning a prompt with an unresolved
     placeholder.
     """
     if not corpus_label:

agent_bench/serving/routes.py

@@ -4,11 +4,13 @@ from __future__ import annotations
 
 import time
 
-from fastapi import APIRouter, Request
+from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
 from starlette.responses import Response
 
 from agent_bench.agents.orchestrator import Orchestrator
+from agent_bench.core.config import AppConfig
+from agent_bench.core.prompts import format_system_prompt
 from agent_bench.serving.middleware import MetricsCollector
 from agent_bench.serving.schemas import (
     AskRequest,
@@ -33,14 +35,34 @@ def _resolve_orchestrator(
     Legacy single-corpus mode: use the flat orchestrators dict keyed by
     provider name, then fall back to app.state.orchestrator.
 
+    Raises:
+        HTTPException(400): body.corpus is explicitly set in multi-corpus
+            mode but the named corpus is not wired on this server. Pydantic
+            Literal on AskRequest.corpus catches unknown names (422); this
+            catches "known per schema but not deployed" at 400. Mirrors
+            the AppConfig validator for default_corpus at request time.
+
     Returns the resolved orchestrator and the corpus name used (empty
     string in legacy mode when no default_corpus is configured).
     """
-    config = request.app.state.config
+    config: AppConfig = request.app.state.config
     corpus_map: dict = getattr(request.app.state, "corpus_map", {})
     default_corpus: str = getattr(config, "default_corpus", "") or ""
     provider_default: str = config.provider.default
 
+    # Fail loud if the request names a corpus that is not wired. Only
+    # fires when body.corpus is explicit — a None corpus always falls
+    # through to default_corpus (which the AppConfig validator guarantees
+    # is in corpus_map when corpora is non-empty).
+    if corpus_map and body.corpus is not None and body.corpus not in corpus_map:
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                f"Corpus {body.corpus!r} is not configured on this server. "
+                f"Available corpora: {sorted(corpus_map.keys())}"
+            ),
+        )
+
     corpus_name: str = body.corpus or default_corpus
 
     if corpus_map and corpus_name in corpus_map:
@@ -71,11 +93,9 @@ def _resolve_system_prompt(
     from the task config (app.state.system_prompt) is returned unchanged
     and corpus_label is empty.
     """
-    config = request.app.state.config
+    config: AppConfig = request.app.state.config
     corpora = getattr(config, "corpora", None) or {}
     if corpus_name and corpus_name in corpora:
-        from agent_bench.core.prompts import format_system_prompt
-
         label = corpora[corpus_name].label
         return format_system_prompt(label), label
     return request.app.state.system_prompt, ""
@@ -210,7 +230,7 @@ async def ask_stream(body: AskRequest, request: Request) -> StreamingResponse:
     system_prompt, corpus_label = _resolve_system_prompt(request, corpus_name)
     metrics: MetricsCollector = request.app.state.metrics
     request_id: str = getattr(request.state, "request_id", "unknown")
-    config: object = request.app.state.config
+    config: AppConfig = request.app.state.config
 
     # --- Meta event data (available before request starts) ---
     provider_name = getattr(config, "provider", None)

agent_bench/serving/schemas.py

@@ -15,9 +15,14 @@ class AskRequest(BaseModel):
     top_k: int = 5
     retrieval_strategy: Literal["semantic", "keyword", "hybrid"] = "hybrid"
     session_id: str | None = None  # None = stateless (V1 behavior)
-    provider: str | None = None  # None = use server default
+    # Per-request provider override. Constrained to the set of known
+    # provider names so unknown values are rejected at validation time
+    # with HTTP 422 instead of silently falling back.
+    provider: Literal["openai", "anthropic", "selfhosted", "mock"] | None = None
     # Per-request corpus selection. None = use default_corpus from config.
-    # Unknown values are rejected at validation time with HTTP 422.
+    # Unknown values rejected at validation time with HTTP 422. Names that
+    # pass validation but are not wired on the current server produce a
+    # 400 in the route handler (see _resolve_orchestrator).
     corpus: Literal["fastapi", "k8s"] | None = None
 
 

tests/conftest.py

@@ -110,3 +110,70 @@ def test_store(mock_embedder: Embedder, sample_chunks: list[Chunk]) -> HybridSto
 def test_retriever(mock_embedder: Embedder, test_store: HybridStore) -> Retriever:
     """Retriever wired to mock embedder + test store."""
     return Retriever(embedder=mock_embedder, store=test_store)
+
+
+# --- Multi-corpus test app (shared across routing / meta / prompt tests) ---
+
+
+class _FakeOpenAI(MockProvider):
+    """Distinct MockProvider subclass so tests can tell it apart from
+    the default mock when asserting which orchestrator actually ran."""
+
+
+@pytest.fixture
+def two_corpus_two_provider_app(tmp_path, monkeypatch):
+    """Two corpora (fastapi, k8s) × two providers (mock, openai-faked).
+
+    After building the app, each corpus × provider cell gets a *unique*
+    MockProvider instance tagged with `_tag`. create_app deliberately
+    shares one provider instance across corpora in production (providers
+    hold LLM clients and are expensive), but the test needs to distinguish
+    which cell ran a given request — so the fixture breaks the sharing
+    here and only here.
+    """
+    from agent_bench.core import provider as provider_mod
+    from agent_bench.core.config import (
+        AppConfig,
+        CorpusConfig,
+        EmbeddingConfig,
+        ProviderConfig,
+        RAGConfig,
+        SecurityConfig,
+    )
+    from agent_bench.serving.app import create_app
+
+    monkeypatch.setattr(provider_mod, "OpenAIProvider", lambda _cfg: _FakeOpenAI())
+    monkeypatch.setenv("OPENAI_API_KEY", "test-key")
+
+    config = AppConfig(
+        provider=ProviderConfig(default="mock"),
+        rag=RAGConfig(store_path=str(tmp_path / "store_default")),
+        embedding=EmbeddingConfig(cache_dir=str(tmp_path / "emb_cache")),
+        security=SecurityConfig(),
+        corpora={
+            "fastapi": CorpusConfig(
+                label="FastAPI Docs",
+                store_path=str(tmp_path / "store_fastapi"),
+                data_path="data/tech_docs",
+            ),
+            "k8s": CorpusConfig(
+                label="Kubernetes",
+                store_path=str(tmp_path / "store_k8s"),
+                data_path="data/k8s_docs",
+            ),
+        },
+        default_corpus="fastapi",
+    )
+    app = create_app(config)
+
+    # Stamp a unique provider into each cell so call_count is per-cell.
+    for c_name, inner in app.state.corpus_map.items():
+        for p_name, orch in inner.items():
+            unique = MockProvider()
+            unique._tag = f"{c_name}:{p_name}"  # type: ignore[attr-defined]
+            orch.provider = unique
+    # Keep the flat orchestrators dict and the singular orchestrator in
+    # sync with the per-cell instances for the default corpus.
+    app.state.orchestrators = dict(app.state.corpus_map[config.default_corpus])
+    app.state.orchestrator = app.state.orchestrators[config.provider.default]
+    return app

tests/test_corpus_routing.py

@@ -1,8 +1,9 @@
 """Tests for per-request corpus routing.
 
 Exercises the full corpus × provider matrix through /ask and /ask/stream.
-Uses create_app with a multi-corpus fixture and monkeypatches a second
-provider so both toggles can be tested without real API keys.
+The multi-corpus test-app fixture (`two_corpus_two_provider_app`) lives
+in tests/conftest.py and is shared with test_meta_corpus.py and
+test_prompt_template.py.
 """
 
 from __future__ import annotations
@@ -18,64 +19,9 @@ from agent_bench.core.config import (
     RAGConfig,
     SecurityConfig,
 )
-from agent_bench.core.provider import MockProvider
 from agent_bench.serving.app import create_app
 
 
-class _FakeOpenAI(MockProvider):
-    """Distinct MockProvider subclass so we can distinguish it from the
-    default mock when asserting which orchestrator actually ran."""
-
-
-@pytest.fixture
-def two_corpus_two_provider_app(tmp_path, monkeypatch):
-    """Two corpora (fastapi, k8s) × two providers (mock, openai-faked).
-
-    After building the app, each corpus×provider cell gets a *unique*
-    MockProvider instance stamped with a `_tag` attribute. create_app
-    deliberately shares one provider instance across corpora (it's an
-    expensive object), but the test needs to distinguish which cell ran
-    a given request, so we break the sharing here and only here.
-    """
-    from agent_bench.core import provider as provider_mod
-
-    monkeypatch.setattr(provider_mod, "OpenAIProvider", lambda _cfg: _FakeOpenAI())
-    monkeypatch.setenv("OPENAI_API_KEY", "test-key")
-
-    config = AppConfig(
-        provider=ProviderConfig(default="mock"),
-        rag=RAGConfig(store_path=str(tmp_path / "store_default")),
-        embedding=EmbeddingConfig(cache_dir=str(tmp_path / "emb_cache")),
-        security=SecurityConfig(),
-        corpora={
-            "fastapi": CorpusConfig(
-                label="FastAPI Docs",
-                store_path=str(tmp_path / "store_fastapi"),
-                data_path="data/tech_docs",
-            ),
-            "k8s": CorpusConfig(
-                label="Kubernetes",
-                store_path=str(tmp_path / "store_k8s"),
-                data_path="data/k8s_docs",
-            ),
-        },
-        default_corpus="fastapi",
-    )
-    app = create_app(config)
-
-    # Stamp a unique provider into each cell so call_count is per-cell.
-    for c_name, inner in app.state.corpus_map.items():
-        for p_name, orch in inner.items():
-            unique = MockProvider()
-            unique._tag = f"{c_name}:{p_name}"  # type: ignore[attr-defined]
-            orch.provider = unique
-    # Keep the flat orchestrators dict and the singular orchestrator in
-    # sync with the per-cell instances for the default corpus.
-    app.state.orchestrators = dict(app.state.corpus_map[config.default_corpus])
-    app.state.orchestrator = app.state.orchestrators[config.provider.default]
-    return app
-
-
 def _reset_call_counts(app):
     """Zero out provider.call_count on every orchestrator in corpus_map."""
     for inner in app.state.corpus_map.values():
@@ -196,3 +142,227 @@ class TestLegacyRouting:
                 "/ask", json={"question": "hi", "corpus": "fastapi"},
             )
         assert resp.status_code == 200
+
+
+class TestMisconfiguredCorpus:
+    """body.corpus valid-per-Literal but not in corpus_map should fail
+    loud at request time with 400 instead of silently falling through
+    to the legacy orchestrator."""
+
+    @pytest.fixture
+    def fastapi_only_app(self, tmp_path, monkeypatch):
+        """Multi-corpus mode with ONLY fastapi configured (k8s removed)."""
+        from agent_bench.core import provider as provider_mod
+        from agent_bench.core.provider import MockProvider
+
+        monkeypatch.setattr(
+            provider_mod, "OpenAIProvider", lambda _cfg: MockProvider(),
+        )
+        config = AppConfig(
+            provider=ProviderConfig(default="mock"),
+            rag=RAGConfig(store_path=str(tmp_path / "store_default")),
+            embedding=EmbeddingConfig(cache_dir=str(tmp_path / "emb_cache")),
+            security=SecurityConfig(),
+            corpora={
+                "fastapi": CorpusConfig(
+                    label="FastAPI Docs",
+                    store_path=str(tmp_path / "store_fastapi"),
+                    data_path="data/tech_docs",
+                ),
+            },
+            default_corpus="fastapi",
+        )
+        return create_app(config)
+
+    @pytest.mark.asyncio
+    async def test_unconfigured_corpus_returns_400(self, fastapi_only_app):
+        """k8s passes Literal but is not in corpus_map — expect 400."""
+        async with AsyncClient(
+            transport=ASGITransport(app=fastapi_only_app), base_url="http://test",
+        ) as client:
+            resp = await client.post(
+                "/ask", json={"question": "hi", "corpus": "k8s"},
+            )
+        assert resp.status_code == 400
+        detail = resp.json().get("detail", "")
+        assert "not configured" in detail.lower()
+        assert "k8s" in detail
+        assert "fastapi" in detail  # lists available corpora
+
+    @pytest.mark.asyncio
+    async def test_unconfigured_corpus_returns_400_stream(self, fastapi_only_app):
+        """Same guard on /ask/stream."""
+        async with AsyncClient(
+            transport=ASGITransport(app=fastapi_only_app), base_url="http://test",
+        ) as client:
+            resp = await client.post(
+                "/ask/stream", json={"question": "hi", "corpus": "k8s"},
+            )
+        assert resp.status_code == 400
+
+    @pytest.mark.asyncio
+    async def test_default_corpus_still_works(self, fastapi_only_app):
+        """fastapi (the only configured corpus) still routes fine."""
+        async with AsyncClient(
+            transport=ASGITransport(app=fastapi_only_app), base_url="http://test",
+        ) as client:
+            resp = await client.post(
+                "/ask", json={"question": "hi", "corpus": "fastapi"},
+            )
+        assert resp.status_code == 200
+
+
+class TestResolveOrchestratorDirect:
+    """Unit tests for _resolve_orchestrator without the HTTP stack.
+
+    Builds a fake Request object with just the app.state attributes the
+    helper reads. Catches edge cases that integration tests would miss
+    (unknown provider, explicit provider not in inner dict, etc.).
+    """
+
+    @pytest.fixture
+    def fake_request_builder(self):
+        """Return a factory that makes a fake Request with the given state."""
+        from types import SimpleNamespace
+
+        def build(
+            corpus_map,
+            default_corpus,
+            provider_default,
+            orchestrators=None,
+            orchestrator=None,
+            system_prompt="legacy prompt",
+        ):
+            state = SimpleNamespace(
+                config=SimpleNamespace(
+                    corpora={k: SimpleNamespace(label=k.title()) for k in corpus_map},
+                    default_corpus=default_corpus,
+                    provider=SimpleNamespace(default=provider_default),
+                ),
+                corpus_map=corpus_map,
+                orchestrators=orchestrators or {},
+                orchestrator=orchestrator,
+                system_prompt=system_prompt,
+            )
+            return SimpleNamespace(app=SimpleNamespace(state=state))
+
+        return build
+
+    def _make_body(self, corpus=None, provider=None):
+        from agent_bench.serving.schemas import AskRequest
+
+        return AskRequest(question="x", corpus=corpus, provider=provider)
+
+    def test_multi_corpus_happy_path(self, fake_request_builder):
+        from agent_bench.serving.routes import _resolve_orchestrator
+
+        sentinel = object()
+        req = fake_request_builder(
+            corpus_map={"fastapi": {"mock": sentinel}},
+            default_corpus="fastapi",
+            provider_default="mock",
+        )
+        orch, name = _resolve_orchestrator(req, self._make_body())
+        assert orch is sentinel
+        assert name == "fastapi"
+
+    def test_provider_fallback_to_corpus_default(self, fake_request_builder):
+        """body.provider=None uses corpus default; Literal accepts None."""
+        from agent_bench.serving.routes import _resolve_orchestrator
+
+        mock_sent = object()
+        oai_sent = object()
+        req = fake_request_builder(
+            corpus_map={"fastapi": {"mock": mock_sent, "openai": oai_sent}},
+            default_corpus="fastapi",
+            provider_default="mock",
+        )
+        orch, _ = _resolve_orchestrator(req, self._make_body(provider="openai"))
+        assert orch is oai_sent
+        orch, _ = _resolve_orchestrator(req, self._make_body())
+        assert orch is mock_sent
+
+    def test_explicit_unconfigured_corpus_raises_400(self, fake_request_builder):
+        from fastapi import HTTPException
+
+        from agent_bench.serving.routes import _resolve_orchestrator
+
+        req = fake_request_builder(
+            corpus_map={"fastapi": {"mock": object()}},
+            default_corpus="fastapi",
+            provider_default="mock",
+        )
+        with pytest.raises(HTTPException) as exc_info:
+            _resolve_orchestrator(req, self._make_body(corpus="k8s"))
+        assert exc_info.value.status_code == 400
+        assert "k8s" in exc_info.value.detail
+        assert "fastapi" in exc_info.value.detail
+
+    def test_legacy_mode_uses_flat_orchestrators(self, fake_request_builder):
+        from agent_bench.serving.routes import _resolve_orchestrator
+
+        legacy_orch = object()
+        flat_oai = object()
+        req = fake_request_builder(
+            corpus_map={},
+            default_corpus="",
+            provider_default="mock",
+            orchestrators={"openai": flat_oai},
+            orchestrator=legacy_orch,
+        )
+        # body.provider=openai finds it in flat dict
+        orch, _ = _resolve_orchestrator(req, self._make_body(provider="openai"))
+        assert orch is flat_oai
+        # No provider falls back to app.state.orchestrator
+        orch, _ = _resolve_orchestrator(req, self._make_body())
+        assert orch is legacy_orch
+
+
+class TestResolveSystemPromptDirect:
+    """Unit tests for _resolve_system_prompt."""
+
+    def _build_req(self, corpora, system_prompt="legacy"):
+        from types import SimpleNamespace
+
+        state = SimpleNamespace(
+            config=SimpleNamespace(corpora=corpora),
+            system_prompt=system_prompt,
+        )
+        return SimpleNamespace(app=SimpleNamespace(state=state))
+
+    def test_multi_corpus_formats_template(self):
+        from types import SimpleNamespace
+
+        from agent_bench.serving.routes import _resolve_system_prompt
+
+        req = self._build_req(
+            {"fastapi": SimpleNamespace(label="FastAPI Docs")},
+        )
+        prompt, label = _resolve_system_prompt(req, "fastapi")
+        assert label == "FastAPI Docs"
+        assert "FastAPI Docs" in prompt
+        assert "{corpus_label}" not in prompt
+        assert "refuse" in prompt.lower()
+
+    def test_legacy_returns_task_prompt(self):
+        from agent_bench.serving.routes import _resolve_system_prompt
+
+        req = self._build_req({}, system_prompt="legacy task prompt")
+        prompt, label = _resolve_system_prompt(req, "")
+        assert prompt == "legacy task prompt"
+        assert label == ""
+
+    def test_unknown_corpus_name_falls_to_legacy(self):
+        """If corpus_name isn't in corpora (shouldn't happen post-resolve
+        because of the 400 guard, but the helper should still be safe)."""
+        from types import SimpleNamespace
+
+        from agent_bench.serving.routes import _resolve_system_prompt
+
+        req = self._build_req(
+            {"fastapi": SimpleNamespace(label="FastAPI Docs")},
+            system_prompt="legacy",
+        )
+        prompt, label = _resolve_system_prompt(req, "nonexistent")
+        assert prompt == "legacy"
+        assert label == ""

tests/test_meta_corpus.py

@@ -1,4 +1,7 @@
-"""Tests for corpus + corpus_label fields in the SSE meta event."""
+"""Tests for corpus + corpus_label fields in the SSE meta event.
+
+The multi-corpus fixture is auto-loaded from tests/conftest.py.
+"""
 
 from __future__ import annotations
 
@@ -7,8 +10,6 @@ import json as json_mod
 import pytest
 from httpx import ASGITransport, AsyncClient
 
-from tests.test_corpus_routing import two_corpus_two_provider_app  # noqa: F401
-
 
 def _parse_sse(text: str) -> list[dict]:
     events = []
@@ -21,7 +22,7 @@ def _parse_sse(text: str) -> list[dict]:
 class TestMetaCorpus:
     @pytest.mark.asyncio
     async def test_meta_includes_corpus_and_label_default(
-        self, two_corpus_two_provider_app,  # noqa: F811
+        self, two_corpus_two_provider_app,
     ):
         app = two_corpus_two_provider_app
         async with AsyncClient(
@@ -35,7 +36,7 @@ class TestMetaCorpus:
 
     @pytest.mark.asyncio
     async def test_meta_reflects_explicit_corpus(
-        self, two_corpus_two_provider_app,  # noqa: F811
+        self, two_corpus_two_provider_app,
     ):
         app = two_corpus_two_provider_app
         async with AsyncClient(
@@ -51,7 +52,7 @@ class TestMetaCorpus:
 
     @pytest.mark.asyncio
     async def test_meta_provider_label_composes_with_corpus(
-        self, two_corpus_two_provider_app,  # noqa: F811
+        self, two_corpus_two_provider_app,
     ):
         """Provider field in meta still reflects the config default."""
         app = two_corpus_two_provider_app

tests/test_prompt_template.py

@@ -1,7 +1,14 @@
-"""Tests for the parameterized system prompt template."""
+"""Tests for the parameterized system prompt template.
+
+The integration tests rely on `two_corpus_two_provider_app` from
+tests/conftest.py.
+"""
 
 from __future__ import annotations
 
+import pytest
+from httpx import ASGITransport, AsyncClient
+
 from agent_bench.core.prompts import SYSTEM_PROMPT_TEMPLATE, format_system_prompt
 
 
@@ -47,25 +54,26 @@ def test_format_requires_citations():
 def test_format_rejects_empty_label():
     """Empty label is a caller bug — fail loud instead of producing a
     prompt with an unresolved placeholder."""
-    import pytest as _pytest
-
-    with _pytest.raises(ValueError, match="corpus_label"):
+    with pytest.raises(ValueError, match="corpus_label"):
         format_system_prompt("")
 
 
+def test_format_is_cached():
+    """@lru_cache on format_system_prompt — same input returns same object."""
+    a = format_system_prompt("FastAPI Docs")
+    b = format_system_prompt("FastAPI Docs")
+    assert a is b  # cached: same object identity, not just equal
+
+
 class TestRouteHandlerUsesFormattedPrompt:
     """In multi-corpus mode the orchestrator must receive a prompt
     formatted with the active corpus's label — not the legacy
     app.state.system_prompt."""
 
-    import pytest
-
     @pytest.mark.asyncio
     async def test_stream_passes_k8s_prompt_to_orchestrator(
-        self, two_corpus_two_provider_app,  # noqa: F811
+        self, two_corpus_two_provider_app,
     ):
-        from httpx import ASGITransport, AsyncClient
-
         app = two_corpus_two_provider_app
         # Record every system_prompt the orchestrator sees.
         captured: list[str] = []
@@ -96,10 +104,8 @@ class TestRouteHandlerUsesFormattedPrompt:
 
     @pytest.mark.asyncio
     async def test_fastapi_and_k8s_prompts_differ(
-        self, two_corpus_two_provider_app,  # noqa: F811
+        self, two_corpus_two_provider_app,
     ):
-        from httpx import ASGITransport, AsyncClient
-
         app = two_corpus_two_provider_app
         captured: dict[str, str] = {}
 
@@ -130,7 +136,3 @@ class TestRouteHandlerUsesFormattedPrompt:
         assert "FastAPI Docs" in captured["fastapi"]
         assert "Kubernetes" in captured["k8s"]
         assert captured["fastapi"] != captured["k8s"]
-
-
-# Re-export the multi-corpus fixture so the class above can use it
-from tests.test_corpus_routing import two_corpus_two_provider_app  # noqa: F401, E402