fix(llm): single multi-model llm.chat so sponsor backends are reachable

Registry keys local caps by (node,name,version); registering one llm.chat per backend overwrote earlier ones, so HF (registered last) hid Nemotron/Modal/MiniCPM even with NVIDIA_API_KEY set. Now LlmService registers one llm.chat/llm.complete advertising the full model catalogue in params.models and dispatches each call to the owning backend via _resolve_backend. _model_matches and registry _remote_params_compatible honour the catalogue for cross-node routing.

hearthnet/bus/registry.py

@@ -52,11 +52,20 @@ class Registry:
         # Use a general params-compatibility check for remote entries so that
         # corpus/model/lang routing works across the mesh without needing to
         # transfer Python callables over the wire.
-        offered_params = dict(descriptor.params)
-
         def _remote_params_compatible(offered: dict, requested: dict) -> bool:
             for key, value in requested.items():
-                if value is not None and key in offered and offered[key] != value:
+                if value is None:
+                    continue
+                if key == "model":
+                    # A capability may advertise a catalogue of models it serves
+                    # ("models") in addition to its primary ("model").
+                    catalogue = offered.get("models")
+                    if catalogue and value in catalogue:
+                        continue
+                    if offered.get("model") == value:
+                        continue
+                    return False
+                if key in offered and offered[key] != value:
                     return False
             return True
 

hearthnet/services/llm/service.py

@@ -47,90 +47,102 @@ class LlmService:
                 self._backends = [_UnavailableBackend()]
 
     def capabilities(self) -> list[tuple]:
-        result = []
-        for backend in self._backends:
-            for bm in backend.models:
-                descriptor = CapabilityDescriptor(
-                    name="llm.chat",
-                    version=(1, 0),
-                    stability="stable",
-                    params={"model": bm.name, "requires_internet": bm.requires_internet},
-                    max_concurrent=2,
-                    trust_required="member",
-                    timeout_seconds=120,
-                    idempotent=False,
-                )
-                result.append(
-                    (descriptor, self._make_chat_handler(backend, bm.name), _model_matches)
-                )
-                descriptor_complete = CapabilityDescriptor(
-                    name="llm.complete",
-                    version=(1, 0),
-                    stability="stable",
-                    params={"model": bm.name, "requires_internet": bm.requires_internet},
-                    max_concurrent=2,
-                    trust_required="member",
-                    timeout_seconds=120,
-                    idempotent=False,
-                )
-                result.append(
-                    (
-                        descriptor_complete,
-                        self._make_complete_handler(backend, bm.name),
-                        _model_matches,
-                    )
-                )
-        return result
-
-    def _make_chat_handler(self, backend: LlmBackend, model_name: str):
-        async def handle_chat(req: RouteRequest) -> dict:
-            inp = req.body.get("input", {})
-            messages = inp.get("messages", [])
-            params = req.body.get("params", {})
-            temperature = float(params.get("temperature", 0.7))
-            max_tokens = int(params.get("max_tokens", 1024))
-            try:
-                result = await backend.chat(
-                    messages,
-                    model=model_name,
-                    stream=False,
-                    temperature=temperature,
-                    max_tokens=max_tokens,
-                )
-                return {
-                    "output": {"message": {"role": "assistant", "content": result.text}},
-                    "meta": {
-                        "model": result.model,
-                        "tokens_in": result.tokens_in,
-                        "tokens_out": result.tokens_out,
-                        "ms": result.ms,
-                    },
-                }
-            except Exception as exc:
-                return {"error": "internal_error", "message": str(exc)}
-
-        return handle_chat
-
-    def _make_complete_handler(self, backend: LlmBackend, model_name: str):
-        async def handle_complete(req: RouteRequest) -> dict:
-            inp = req.body.get("input", {})
-            prompt = inp.get("prompt", "")
-            params = req.body.get("params", {})
-            try:
-                result = await backend.complete(prompt, model=model_name, stream=False)
-                return {
-                    "output": {"text": result.text},
-                    "meta": {
-                        "model": result.model,
-                        "tokens_in": result.tokens_in,
-                        "tokens_out": result.tokens_out,
-                        "ms": result.ms,
-                    },
-                }
-            except Exception as exc:
-                return {"error": "internal_error", "message": str(exc)}
-
-        return handle_complete
+        # Collect every (backend, model) pair across all configured backends.
+        # The registry keys local capabilities by (node, name, version), so a
+        # separate llm.chat per model would collide and only the last would
+        # survive — making additional backends (e.g. sponsor clouds) unreachable.
+        # Instead we register ONE llm.chat / llm.complete that advertises the
+        # full model catalogue and dispatches to the owning backend by model.
+        model_entries = [(backend, bm) for backend in self._backends for bm in backend.models]
+        if not model_entries:
+            return []
+        _primary_backend, primary_bm = model_entries[0]
+        model_names = [bm.name for _, bm in model_entries]
+        params = {
+            "model": primary_bm.name,
+            "models": model_names,
+            "requires_internet": primary_bm.requires_internet,
+        }
+        chat_descriptor = CapabilityDescriptor(
+            name="llm.chat",
+            version=(1, 0),
+            stability="stable",
+            params=dict(params),
+            max_concurrent=2,
+            trust_required="member",
+            timeout_seconds=120,
+            idempotent=False,
+        )
+        complete_descriptor = CapabilityDescriptor(
+            name="llm.complete",
+            version=(1, 0),
+            stability="stable",
+            params=dict(params),
+            max_concurrent=2,
+            trust_required="member",
+            timeout_seconds=120,
+            idempotent=False,
+        )
+        return [
+            (chat_descriptor, self._handle_chat, _model_matches),
+            (complete_descriptor, self._handle_complete, _model_matches),
+        ]
+
+    def _resolve_backend(self, model_name: str) -> tuple[LlmBackend, str]:
+        """Pick the backend that serves ``model_name``; fall back to primary."""
+        if model_name:
+            for backend in self._backends:
+                for bm in backend.models:
+                    if bm.name == model_name:
+                        return backend, model_name
+        backend = self._backends[0]
+        return backend, backend.models[0].name
+
+    async def _handle_chat(self, req: RouteRequest) -> dict:
+        inp = req.body.get("input", {})
+        messages = inp.get("messages", [])
+        params = req.body.get("params", {})
+        backend, model_name = self._resolve_backend(str(params.get("model") or ""))
+        temperature = float(params.get("temperature", 0.7))
+        max_tokens = int(params.get("max_tokens", 1024))
+        try:
+            result = await backend.chat(
+                messages,
+                model=model_name,
+                stream=False,
+                temperature=temperature,
+                max_tokens=max_tokens,
+            )
+            return {
+                "output": {"message": {"role": "assistant", "content": result.text}},
+                "meta": {
+                    "model": result.model,
+                    "tokens_in": result.tokens_in,
+                    "tokens_out": result.tokens_out,
+                    "ms": result.ms,
+                },
+            }
+        except Exception as exc:
+            return {"error": "internal_error", "message": str(exc)}
+
+    async def _handle_complete(self, req: RouteRequest) -> dict:
+        inp = req.body.get("input", {})
+        prompt = inp.get("prompt", "")
+        params = req.body.get("params", {})
+        backend, model_name = self._resolve_backend(str(params.get("model") or ""))
+        try:
+            result = await backend.complete(prompt, model=model_name, stream=False)
+            return {
+                "output": {"text": result.text},
+                "meta": {
+                    "model": result.model,
+                    "tokens_in": result.tokens_in,
+                    "tokens_out": result.tokens_out,
+                    "ms": result.ms,
+                },
+            }
+        except Exception as exc:
+            return {"error": "internal_error", "message": str(exc)}
 
 
 class _UnavailableBackend:
@@ -251,4 +263,9 @@ class _EchoBackend:
 
 
 def _model_matches(offered: dict, requested: dict) -> bool:
-    return not requested.get("model") or requested.get("model") == offered.get("model")
+    req = requested.get("model")
+    if not req:
+        return True
+    if req == offered.get("model"):
+        return True
+    return req in (offered.get("models") or [])

tests/test_components_real.py

@@ -291,7 +291,7 @@ class TestBusRouting:
     def test_unknown_capability_raises(self, mesh):
         """Calling a capability no node provides raises, not silently fails."""
         alice, _ = mesh
-        with pytest.raises(Exception, match="not_found|not_implemented|partition"):  # BusError
+        with pytest.raises(Exception, match="not_found|not_implemented|partition|no provider"):  # BusError
             _run(alice.bus.call(
                 "nonexistent.capability", (1, 0), {},
             ))

tests/test_sponsor_backends.py

@@ -0,0 +1,56 @@
+"""Sponsor LLM backends are wired when their env vars are set (prize tracks)."""
+
+from __future__ import annotations
+
+from hearthnet.node import HearthNode
+
+
+def _llm_models(node: HearthNode) -> set[str]:
+    """Collect every model name served by registered llm.chat capabilities.
+
+    LlmService registers a single llm.chat that advertises its full model
+    catalogue in params["models"], dispatching to the owning backend by model.
+    """
+    models: set[str] = set()
+    for e in node.bus.registry.all_local():
+        if e.descriptor.name != "llm.chat":
+            continue
+        primary = e.descriptor.params.get("model")
+        if primary:
+            models.add(str(primary))
+        models.update(str(m) for m in e.descriptor.params.get("models", []))
+    return models
+
+
+def _nemotron_models() -> set[str]:
+    from hearthnet.services.llm.backends.nemotron import NemotronBackend
+
+    backend = NemotronBackend(api_key_env="NVIDIA_API_KEY")
+    return {bm.name for bm in backend.models}
+
+
+def test_nemotron_wired_when_key_set(monkeypatch) -> None:
+    monkeypatch.setenv("NVIDIA_API_KEY", "test-key-not-real")
+    monkeypatch.delenv("MODAL_ENDPOINT", raising=False)
+    node = HearthNode("ed25519:nv", "NV", "ed25519:test-community")
+    node.install_services(corpus="t")
+    # At least one of Nemotron's models must now be served via llm.chat.
+    assert _llm_models(node) & _nemotron_models()
+
+
+def test_no_sponsor_backend_without_env(monkeypatch) -> None:
+    monkeypatch.delenv("NVIDIA_API_KEY", raising=False)
+    monkeypatch.delenv("NEMOTRON_URL", raising=False)
+    monkeypatch.delenv("MODAL_ENDPOINT", raising=False)
+    monkeypatch.delenv("MINICPM_URL", raising=False)
+    node = HearthNode("ed25519:none", "None", "ed25519:test-community")
+    node.install_services(corpus="t")
+    # Without the key, none of Nemotron's models should be registered.
+    assert not (_llm_models(node) & _nemotron_models())
+
+
+def test_nemotron_backend_constructs() -> None:
+    from hearthnet.services.llm.backends.nemotron import NemotronBackend
+
+    backend = NemotronBackend(api_key_env="NVIDIA_API_KEY")
+    assert backend.name == "nemotron"