Discover a model's vendor from LiteLLM instead of its name

Route selection sniffed model names: anything starting "claude-" or
"anthropic/" took the vendor-native passthrough, everything else took the
normalized route. That works only while an alias names its vendor. A
semantic role alias like "remote-architecture" is meant to point at
Anthropic today and somewhere else tomorrow, and the name says nothing
either way -- so it would have taken the normalized route regardless of
what was behind it, silently losing the fidelity A13 wants for delegations.

LiteLLM already knows the answer. /model/info reports each alias's backing
model, provider, and declared tool support, so the agent asks at startup and
routes on the provider it discovers. That keeps vendor knowledge where A5
already put it -- in the proxy -- rather than duplicating it as name patterns
here.

There is deliberately no name-based fallback: PASSTHROUGH_PREFIXES and
has_native_adapter are gone, and select_client now requires a catalog. A
second heuristic could only ever disagree with the proxy. An unknown model
raises instead of guessing a route.

Misconfiguration is therefore loud and early. build_agent validates every
role against the catalog before it clones anything, naming all the bad ones
at once. Discovery is per key -- /model/info returns only what the presented
token may use -- so the same check catches a role pointed at a real model
this key cannot reach. An unreachable proxy is reported separately, since an
outage and a typo call for different responses from the operator.

Two things now get recorded rather than inferred: the resolved model is
pinned alongside the role mapping at task start, for the reason A11 already
pins roles, and DelegationStarted carries backing_model so A16 eval history
is not averaged across whatever an alias happened to point at.

A model LiteLLM declares tool-less warns at startup rather than refusing;
A15 expects weak local models to be accommodated, and they are observed
driving tool loops anyway.

Verified live: all four aliases the production key can see route correctly
through discovery, and each chosen route works.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

nisse-dev/tests/test_agent_build.py

@@ -11,9 +11,28 @@ import httpx
 import pytest
 from test_config import COMPLETE
 
-from nisse_dev.agent import build_agent, prepare_workspace
+from nisse_dev.agent import build_agent, discover_models, prepare_workspace
+from nisse_dev.catalog import ModelCatalog, UnknownModel
 from nisse_dev.config import AgentConfig
 from nisse_dev.git import GitRepo
+from nisse_dev.oplog import OpLog
+
+# What the test roles resolve to, as LiteLLM would report them.
+TEST_CATALOG = ModelCatalog.from_payload(
+    {
+        "data": [
+            {
+                "model_name": alias,
+                "litellm_params": {"model": f"anthropic/{alias}"},
+                "model_info": {
+                    "litellm_provider": "anthropic",
+                    "supports_function_calling": True,
+                },
+            }
+            for alias in ("claude-opus-5", "claude-haiku-4-5")
+        ]
+    }
+)
 
 
 def config_for(tmp_path: Path, **overrides: str) -> AgentConfig:
@@ -94,6 +113,10 @@ def build_offline(tmp_path: Path, origin: Path, monkeypatch: Any) -> Any:
     monkeypatch.setattr(
         "nisse_dev.agent.GiteaClient.whoami", lambda self: "nisse-dev-testing"
     )
+    monkeypatch.setattr(
+        "nisse_dev.agent.ModelCatalog.discover",
+        classmethod(lambda cls, *a, **kw: TEST_CATALOG),
+    )
     monkeypatch.setattr("nisse_dev.agent.MatrixTransport", lambda cfg: FakeTransport())
     monkeypatch.setattr(
         "nisse_dev.agent.authenticated_url",
@@ -177,3 +200,90 @@ def test_httpx_clients_are_not_shared_between_routes(
     assert isinstance(normalized, httpx.Client)
     assert normalized is not passthrough  # different base URLs and headers
     agent.stop()
+
+
+# --- startup model discovery (A5/A11) ------------------------------------
+
+
+def test_a_typod_role_refuses_to_boot(tmp_path: Path, monkeypatch) -> None:
+    # Misconfiguration should cost a second at startup, not be discovered ten
+    # minutes into a milestone.
+    config = config_for(tmp_path, NISSE_ROLE_PLANNER="clause-opus-5")
+    monkeypatch.setattr(
+        "nisse_dev.agent.ModelCatalog.discover",
+        classmethod(lambda cls, *a, **kw: TEST_CATALOG),
+    )
+    with pytest.raises(UnknownModel, match="planner='clause-opus-5'"):
+        discover_models(config, OpLog("test"))
+
+
+def test_a_role_this_key_cannot_reach_refuses_to_boot(
+    tmp_path: Path, monkeypatch
+) -> None:
+    # /model/info is scoped per key, so the same check catches a role pointed
+    # at a real model that this token has no access to.
+    config = config_for(tmp_path, NISSE_ROLE_EXECUTOR="local-fast")
+    monkeypatch.setattr(
+        "nisse_dev.agent.ModelCatalog.discover",
+        classmethod(lambda cls, *a, **kw: TEST_CATALOG),
+    )
+    with pytest.raises(UnknownModel, match="executor='local-fast'"):
+        discover_models(config, OpLog("test"))
+
+
+def test_a_tool_less_model_warns_but_still_boots(tmp_path: Path, monkeypatch) -> None:
+    # A15 expects weak local models to be accommodated, and models LiteLLM
+    # declares tool-less are observed driving tool loops anyway.
+    import io
+
+    tool_less = ModelCatalog.from_payload(
+        {
+            "data": [
+                {
+                    "model_name": alias,
+                    "litellm_params": {"model": "openai/qwen3-8b-awq"},
+                    "model_info": {
+                        "litellm_provider": "openai",
+                        "supports_function_calling": False,
+                    },
+                }
+                for alias in ("claude-opus-5", "claude-haiku-4-5")
+            ]
+        }
+    )
+    monkeypatch.setattr(
+        "nisse_dev.agent.ModelCatalog.discover",
+        classmethod(lambda cls, *a, **kw: tool_less),
+    )
+    stream = io.StringIO()
+    discover_models(config_for(tmp_path), OpLog("test", stream))
+
+    logged = stream.getvalue()
+    assert "model_tools_unsupported" in logged
+    assert '"role": "executor"' in logged
+    assert '"role": "consultant"' not in logged  # ask_expert drives no tools
+
+
+def test_the_resolved_model_is_pinned_at_task_start(
+    tmp_path: Path, origin: Path, monkeypatch
+) -> None:
+    agent = build_offline(tmp_path, origin, monkeypatch)
+    agent.orchestrator._begin_project("greet")
+
+    pinned = agent.orchestrator._data["models"]
+    assert pinned["planner"] == {
+        "alias": "claude-opus-5",
+        "backing": "anthropic/claude-opus-5",
+        "provider": "anthropic",
+    }
+    agent.stop()
+
+
+def test_delegation_records_what_the_alias_resolved_to(
+    tmp_path: Path, origin: Path, monkeypatch
+) -> None:
+    # A16 eval history keyed on an alias alone would average across whatever
+    # that alias pointed at over time.
+    agent = build_offline(tmp_path, origin, monkeypatch)
+    assert agent.orchestrator._delegate._backing_model == "anthropic/claude-opus-5"
+    agent.stop()