feat: Update model routing and local provider to support multi-sponsor tiers and auto-class resolution

docs/adr/0033-local-inproc-transformers-backend.md

@@ -94,9 +94,11 @@ backend stays inactive and the deterministic stub owns the no-config demo path.
 - No new Python dependencies — `torch` and `transformers` are already transitive deps.
 - The parent-process cache means each ZeroGPU call after the first is weight-load-free
   within a session.
-- **Prize-lane impact:** keeps the **OpenBMB / MiniCPM** track (MiniCPM4.1-8B is in the
-  local catalogue), the **Tiny Titan** lane (Qwen2.5-3B-Instruct at the `tiny` tier is
-  ≤4B), and the **Community Choice** on-device-inference story for the HF Space demo.
+- **Prize-lane impact:** one sponsor family per tier, so a single in-process cast spans
+  four tracks at once — **NVIDIA Nemotron** (`tiny`, also the **Tiny Titan** ≤4B lane via
+  Nemotron-3-Nano-4B), **OpenBMB / MiniCPM** (`fast`), **Cohere / Aya** (`balanced`), and
+  **JetBrains / Mellum** (`strong`) — plus the **Community Choice** on-device-inference
+  story for the HF Space demo.
 
 **Negative / Risks:**
 - **Llama Champion badge is explicitly dropped.** No llama.cpp runtime in the cast means
@@ -117,9 +119,13 @@ backend stays inactive and the deterministic stub owns the no-config demo path.
 - `llamacpp_catalogue.py` and `llamacpp_server.py` are deleted; `app.py`'s
   `gpu_selftest` `@spaces.GPU` guard is retained — it detects ZeroGPU availability at
   startup and is unrelated to the inference path.
-- The single catalogue entry tagged as a tier default is `Qwen/Qwen2.5-3B-Instruct`
-  (`tiny`). Additional models (MiniCPM4.1-8B, Qwen2.5-7B-Instruct) are in the catalogue
-  but untagged; ZeroGPU quota pressure justifies keeping the default footprint minimal.
+- Each tier is tagged with a distinct sponsor model (NVIDIA Nemotron-3-Nano-4B-BF16 ·
+  OpenBMB MiniCPM4.1-8B · Cohere Aya-Expanse-8B · JetBrains Mellum2-12B-A2.5B-Instruct), so
+  a cross-sponsor cast runs on the Space's own GPU. This trades ZeroGPU quota/RAM headroom
+  (several multi-GB loads per show) for multi-track coverage; the `tiny` model is listed
+  first so any untagged fallback lands on the cheapest tier. Two deployment notes: Aya is a
+  **gated** repo (needs licence acceptance + `HF_TOKEN`), and Mellum loads via
+  `AutoModelForMultimodalLM` (a per-model `auto_class` on `LocalModel`).
 - Tests live in `tests/test_local_backend.py`. All 676 tests pass; the capability-gate
   logic is fully covered without a GPU or torch import in test processes.
 

docs/architecture/model-routing.md

@@ -106,19 +106,27 @@ Off ZeroGPU and without `LOCAL_INFERENCE=1`, `@spaces.GPU` is a no-op and the
 engine falls back to the deterministic stub — so the demo is always reproducible on
 CPU-only hosts. Pick "Local GPU" in the Lab's backend radio to opt in per run.
 
-Available models (all ≤32B; select via `local:<repo_id>`):
+Available models (all ≤32B; select via `local:<repo_id>`). One sponsor family per tier, so
+a single cast spans four sponsors at once (the multi-track strategy):
 
-| Key | Model | Notes |
-|---|---|---|
-| `local:Qwen/Qwen2.5-3B-Instruct` | Qwen 2.5 3B | **tiny default** — latency + quota guardrail |
-| `local:openbmb/MiniCPM4.1-8B` | MiniCPM 4.1 8B | alternate; OpenBMB prize lane |
-| `local:Qwen/Qwen2.5-7B-Instruct` | Qwen 2.5 7B | alternate |
+| Key | Model | Tier | Notes |
+|---|---|---|---|
+| `local:nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16` | Nemotron Nano 4B | **tiny** | NVIDIA lane; Tiny-Titan ≤4B band; `trust_remote_code`; Mamba-2 hybrid (BF16, not GGUF) |
+| `local:openbmb/MiniCPM4.1-8B` | MiniCPM 4.1 8B | fast | OpenBMB lane; `trust_remote_code` |
+| `local:CohereLabs/aya-expanse-8b` | Aya Expanse 8B | balanced | Cohere lane; **gated repo** — needs licence acceptance + `HF_TOKEN` |
+| `local:JetBrains/Mellum2-12B-A2.5B-Instruct` | Mellum 2 (12B MoE, ~2.5B active) | strong | JetBrains lane; loads via `AutoModelForMultimodalLM` |
+
+Each tier is tagged, so a cast's `fast`/`balanced`/`strong` seats route to different sponsor
+models. That cross-sponsor cast loads several multi-GB models per show — heavy on the free
+ZeroGPU ~5-min/day budget and host RAM; on a dedicated GPU there is no cap. For a
+quota-light demo, pin the whole cast to the tiny default. The tiny model is listed first, so
+any untagged fallback also lands on the cheapest tier.
 
 Bind a tier to a local model with a qualified key:
 
 ```yaml
 profiles:
-  tiny: { endpoint: "local:Qwen/Qwen2.5-3B-Instruct", temperature: 0.7, max_tokens: 192 }
+  tiny: { endpoint: "local:nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16", temperature: 0.7, max_tokens: 192 }
 ```
 
 ### Real cost → Governor

src/models/__init__.py

@@ -1,2 +1 @@
 """Model provider adapters."""
-

src/models/local_catalogue.py

@@ -31,12 +31,12 @@ append one :class:`LocalModel`. Every model stays within the ≤32B "small minds
 the ``tiny`` default honours the Tiny-Titan ≤4B band.
 
 **Quota note (ZeroGPU only).** Free ZeroGPU grants ~5 minutes of GPU/day (2 for anonymous
-visitors), billed per ``@spaces.GPU`` call. A full multi-agent show makes many sequential
-calls, so the catalogue deliberately tags **one tiny model** as the only tier default:
-with no per-tier override the whole cast routes to it (see ``lab._default_model_key``),
-keeping a live show inside the daily budget. On a dedicated GPU there is no such cap, but
-the tiny default still keeps first-token latency low. Larger alternates are listed
-untagged — a cast can pin them, but they are never the silent default.
+visitors), billed per ``@spaces.GPU`` call. Each tier maps to a *different* sponsor model
+(see ``LOCAL_MODELS``), so a cross-sponsor cast loads several multi-GB models per show —
+heavy on that daily budget and on host RAM. A dedicated-GPU Space has no such cap; for a
+quota-light demo, pin the whole cast to the tiny default in the Lab (one model, low
+latency). The tiny model is listed first, so any untagged fallback (see
+``lab._default_model_key``) also lands on the cheapest tier.
 """
 
 from __future__ import annotations
@@ -65,7 +65,10 @@ class LocalModel:
     ``transformers``). ``profile`` is the tier this model is the default casting for, or
     None for an alternate the cast can still pin explicitly. ``source`` is a friendly
     family/org label for the picker. ``trust_remote_code`` is forwarded to
-    ``from_pretrained`` for repos that ship custom modelling code (e.g. MiniCPM).
+    ``from_pretrained`` for repos that ship custom modelling code (e.g. MiniCPM, Nemotron).
+    ``auto_class`` is the ``transformers`` auto-class the provider loads the repo with —
+    ``AutoModelForCausalLM`` for an ordinary LM, overridden where a model card calls for a
+    different one (e.g. JetBrains Mellum loads with ``AutoModelForMultimodalLM``).
     """
 
     repo_id: str
@@ -73,6 +76,7 @@ class LocalModel:
     params_b: float | None = None
     source: str = "Hugging Face"
     trust_remote_code: bool = False
+    auto_class: str = "AutoModelForCausalLM"
 
     @property
     def key(self) -> str:
@@ -84,36 +88,57 @@ class LocalModel:
         return self.repo_id
 
 
-# --- The catalogue: small transformers instruct models -------------------------------
-# One tiny model is tagged as the cast-wide default (low latency + ZeroGPU-quota-friendly,
-# see the module docstring); the rest are untagged alternates a cast can pin. Plain data:
-# swapping the default or adding a sponsor family is a one-line edit.
+# --- The catalogue: one sponsor model per tier ---------------------------------------
+# Each tier is tagged with a distinct sponsor family, so a single cast legitimately spans
+# four sponsors at once (NVIDIA · OpenBMB · Cohere · JetBrains) — the multi-track prize
+# strategy run on the Space's own GPU, no endpoint to deploy. Every model honours the ≤32B
+# "small minds" rule and the tiny default keeps the Tiny-Titan ≤4B band. Plain data:
+# swapping a tier's model is a one-line edit.
+#
+# ZeroGPU cost: a cross-sponsor cast loads several multi-GB models per show (a download on
+# first use, then a host→device copy per turn), which is heavy on the free ~5-min/day GPU
+# quota and on host RAM. A dedicated-GPU Space has no such cap; for a quota-light demo, pin
+# the whole cast to the tiny default in the Lab. The first entry is the tiny default, so any
+# untagged fallback also lands on the cheapest model.
 
 LOCAL_MODELS: tuple[LocalModel, ...] = (
-    # Tiny tier (≤4B, Tiny-Titan band) — the cast-wide default. Small, fast, and a
-    # reliable chat template, so a full show stays low-latency (and well inside the free
-    # ZeroGPU GPU/day budget).
+    # Tiny tier (≤4B, Tiny-Titan band) — the cast-wide fallback default. NVIDIA Nemotron
+    # Nano is a Mamba-2/Transformer hybrid; load the BF16 (safetensors) sibling, not the
+    # GGUF, since the in-process path runs transformers. Ships custom modelling code, so
+    # trust_remote_code is required.
     LocalModel(
-        repo_id="Qwen/Qwen2.5-3B-Instruct",
+        repo_id="nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16",
         profile="tiny",
-        params_b=3.0,
-        source="Qwen",
+        params_b=4.0,
+        source="NVIDIA Nemotron",
+        trust_remote_code=True,
     ),
-    # OpenBMB MiniCPM 4.1 8B (fast tier) — keeps the OpenBMB lane on the in-process path.
-    # Ships custom modelling code, so trust_remote_code is required. An alternate, not the
-    # default: a cast can pin it, but the tiny model above drives a show by default.
+    # Fast tier — OpenBMB MiniCPM 4.1 8B. Ships custom modelling code (trust_remote_code).
     LocalModel(
         repo_id="openbmb/MiniCPM4.1-8B",
+        profile="fast",
         params_b=8.0,
         source="OpenBMB MiniCPM",
         trust_remote_code=True,
     ),
-    # Qwen 7B (fast tier) — a slightly larger alternate for a single specialist seat (e.g.
-    # the Judge) when the hardware/quota allows. Untagged, so never the silent default.
+    # Balanced tier — Cohere Labs Aya Expanse 8B (Command family, native transformers arch).
+    # NOTE: this repo is *gated* — the Space's HF account must accept its licence and an
+    # HF_TOKEN must be present for the weights to download.
+    LocalModel(
+        repo_id="CohereLabs/aya-expanse-8b",
+        profile="balanced",
+        params_b=8.0,
+        source="Cohere Labs Aya",
+    ),
+    # Strong tier — JetBrains Mellum 2 (12B MoE, ~2.5B active). The Instruct variant (a
+    # post-trained assistant with a chat template), not the Base completion model. Its card
+    # loads it with AutoModelForMultimodalLM, so we pin that auto-class.
     LocalModel(
-        repo_id="Qwen/Qwen2.5-7B-Instruct",
-        params_b=7.0,
-        source="Qwen",
+        repo_id="JetBrains/Mellum2-12B-A2.5B-Instruct",
+        profile="strong",
+        params_b=12.0,
+        source="JetBrains Mellum",
+        auto_class="AutoModelForMultimodalLM",
     ),
 )
 

src/models/local_provider.py

@@ -50,7 +50,7 @@ from src.models.provider import ModelProvider, estimate_tokens, model_error
 _LOADED: dict[str, tuple] = {}
 
 
-def _ensure_loaded(repo_id: str, trust_remote_code: bool) -> tuple:
+def _ensure_loaded(repo_id: str, trust_remote_code: bool, auto_class: str = "AutoModelForCausalLM") -> tuple:
     """Load (once, cached) the tokenizer + model for *repo_id* **on CPU**.
 
     Called from :meth:`LocalTransformersProvider.complete` in the parent process to warm
@@ -75,15 +75,19 @@ def _ensure_loaded(repo_id: str, trust_remote_code: bool) -> tuple:
     """
     if repo_id in _LOADED:
         return _LOADED[repo_id]
-    from transformers import AutoModelForCausalLM, AutoTokenizer
+    import transformers
+    from transformers import AutoTokenizer
 
+    # The auto-class is per-model (most are AutoModelForCausalLM; some cards call for another,
+    # e.g. Mellum's AutoModelForMultimodalLM) — resolve it by name off the transformers module.
+    model_cls = getattr(transformers, auto_class)
     tokenizer = AutoTokenizer.from_pretrained(repo_id, trust_remote_code=trust_remote_code)
     try:
-        model = AutoModelForCausalLM.from_pretrained(
+        model = model_cls.from_pretrained(
             repo_id, dtype="auto", low_cpu_mem_usage=False, trust_remote_code=trust_remote_code
         )
     except TypeError:  # pragma: no cover - older transformers use the torch_dtype kwarg name
-        model = AutoModelForCausalLM.from_pretrained(
+        model = model_cls.from_pretrained(
             repo_id, torch_dtype="auto", low_cpu_mem_usage=False, trust_remote_code=trust_remote_code
         )
     # Re-tie the output head to the (materialized) input embeddings so no parameter is left
@@ -94,7 +98,7 @@ def _ensure_loaded(repo_id: str, trust_remote_code: bool) -> tuple:
     return _LOADED[repo_id]
 
 
-def _gpu_duration(repo_id, trust_remote_code, system, prompt, max_new_tokens, temperature, top_p) -> int:
+def _gpu_duration(repo_id, trust_remote_code, auto_class, system, prompt, max_new_tokens, temperature, top_p) -> int:
     """Dynamic ``@spaces.GPU`` duration (seconds) for one generation.
 
     Scales with the token budget and stays short so the Space keeps high queue priority on
@@ -105,7 +109,7 @@ def _gpu_duration(repo_id, trust_remote_code, system, prompt, max_new_tokens, te
 
 
 @spaces.GPU(duration=_gpu_duration)
-def _generate(repo_id, trust_remote_code, system, prompt, max_new_tokens, temperature, top_p):
+def _generate(repo_id, trust_remote_code, auto_class, system, prompt, max_new_tokens, temperature, top_p):
     """Run one chat completion on the GPU; return ``(text, prompt_tokens, completion_tokens)``.
 
     Module-level and decorated so ZeroGPU registers it and grants a GPU for the call. The
@@ -118,7 +122,7 @@ def _generate(repo_id, trust_remote_code, system, prompt, max_new_tokens, temper
     """
     import torch
 
-    tokenizer, model = _ensure_loaded(repo_id, trust_remote_code)
+    tokenizer, model = _ensure_loaded(repo_id, trust_remote_code, auto_class)
     if torch.cuda.is_available():
         model = model.to("cuda")
     device = next(model.parameters()).device
@@ -151,7 +155,7 @@ def _generate(repo_id, trust_remote_code, system, prompt, max_new_tokens, temper
 class LocalTransformersProvider(ModelProvider):
     """Serve one logical profile by running a ``transformers`` model on the host GPU.
 
-    ``model`` is the bare ``transformers`` repo id (e.g. ``"Qwen/Qwen2.5-3B-Instruct"``) —
+    ``model`` is the bare ``transformers`` repo id (e.g. ``"openbmb/MiniCPM4.1-8B"``) —
     the same string :func:`src.models.local_catalogue.binding_for` returns. Decoding
     (``temperature`` / ``top_p`` / ``max_tokens``) comes from the router's per-profile
     spec. ``trust_remote_code`` is resolved from the catalogue for the repo (default
@@ -177,11 +181,12 @@ class LocalTransformersProvider(ModelProvider):
                 # Warm the weights in the PARENT first so the forked @spaces.GPU call
                 # inherits them (see module docstring); this is a cache hit after the
                 # first use of this model in the process.
-                _ensure_loaded(self.model, self._trust_remote_code())
+                _ensure_loaded(self.model, self._trust_remote_code(), self._auto_class())
                 system = OpenAICompatProvider._system_for_role(role)
                 text, prompt_tokens, completion_tokens = _generate(
                     self.model,
                     self._trust_remote_code(),
+                    self._auto_class(),
                     system,
                     prompt,
                     self.max_tokens,
@@ -209,6 +214,18 @@ class LocalTransformersProvider(ModelProvider):
         entry = local_catalogue.model_by_key(self.model)
         return bool(entry.trust_remote_code) if entry is not None else False
 
+    def _auto_class(self) -> str:
+        """The ``transformers`` auto-class to load this repo with (from the catalogue).
+
+        Most models load with ``AutoModelForCausalLM``; a few cards call for another (e.g.
+        JetBrains Mellum → ``AutoModelForMultimodalLM``). An off-catalogue id defaults to
+        ``AutoModelForCausalLM`` — the ordinary case for a hand-pinned chat model.
+        """
+        from src.models import local_catalogue
+
+        entry = local_catalogue.model_by_key(self.model)
+        return entry.auto_class if entry is not None else "AutoModelForCausalLM"
+
     def _record_usage(self, prompt_tokens: int, completion_tokens: int, prompt: str, text: str) -> None:
         # Generation returns exact token counts; fall back to an estimate only if a count
         # came back as zero (e.g. an empty decode), so the Governor always sees a budget hit.

tests/test_local_backend.py

@@ -24,34 +24,46 @@ from src.models.router import ModelRouter
 # ── catalogue ─────────────────────────────────────────────────────────────────────
 
 
-def test_only_tiny_is_a_tier_default_and_sizes_stay_small():
-    # Exactly one tier default (tiny) so the whole cast routes to it unless a seat is
-    # pinned — the latency/ZeroGPU-quota guardrail. Every model honours the ≤32B rule.
-    tagged = [m for m in local_catalogue.LOCAL_MODELS if m.profile is not None]
-    assert [m.profile for m in tagged] == ["tiny"]
+def test_one_sponsor_model_per_tier_and_sizes_stay_small():
+    # Each tier maps to a *distinct* sponsor model (the multi-track cast), so one show spans
+    # NVIDIA · OpenBMB · Cohere · JetBrains. Every model honours the ≤32B rule and the tiny
+    # default keeps the Tiny-Titan ≤4B band.
+    tagged = {m.profile: m for m in local_catalogue.LOCAL_MODELS if m.profile is not None}
+    assert set(tagged) == {"tiny", "fast", "balanced", "strong"}
     assert all(m.params_b is None or m.params_b <= 32 for m in local_catalogue.LOCAL_MODELS)
-    tiny = local_catalogue.model_by_key(local_catalogue.default_key_for_profile("tiny"))
-    assert tiny is not None and tiny.params_b <= 4  # Tiny-Titan band
+    assert tagged["tiny"].params_b <= 4  # Tiny-Titan band
+    assert len({m.source for m in tagged.values()}) == 4  # four sponsor families
 
 
-def test_only_tiny_has_a_default_other_tiers_fall_through():
-    assert local_catalogue.default_key_for_profile("tiny") is not None
-    for tier in ("fast", "balanced", "strong"):
-        assert local_catalogue.default_key_for_profile(tier) is None
+def test_every_tier_resolves_to_its_sponsor_model():
+    assert local_catalogue.default_key_for_profile("tiny") == "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"
+    assert local_catalogue.default_key_for_profile("fast") == "openbmb/MiniCPM4.1-8B"
+    assert local_catalogue.default_key_for_profile("balanced") == "CohereLabs/aya-expanse-8b"
+    assert local_catalogue.default_key_for_profile("strong") == "JetBrains/Mellum2-12B-A2.5B-Instruct"
+    # the tiny model is listed first, so an untagged/unknown tier falls back to the cheapest.
+    assert local_catalogue.LOCAL_MODELS[0].profile == "tiny"
 
 
 def test_model_by_key_carries_trust_remote_code():
-    # MiniCPM ships custom modelling code; Qwen does not; an off-catalogue id is unknown.
+    # Nemotron + MiniCPM ship custom modelling code; Aya (native Command arch) does not; an
+    # off-catalogue id is unknown.
+    assert local_catalogue.model_by_key("nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16").trust_remote_code is True
     assert local_catalogue.model_by_key("openbmb/MiniCPM4.1-8B").trust_remote_code is True
-    assert local_catalogue.model_by_key("Qwen/Qwen2.5-3B-Instruct").trust_remote_code is False
+    assert local_catalogue.model_by_key("CohereLabs/aya-expanse-8b").trust_remote_code is False
     assert local_catalogue.model_by_key("does/not-exist") is None
 
 
+def test_model_by_key_carries_auto_class():
+    # Mellum's card loads it with AutoModelForMultimodalLM; the rest use the default class.
+    assert local_catalogue.model_by_key("JetBrains/Mellum2-12B-A2.5B-Instruct").auto_class == "AutoModelForMultimodalLM"
+    assert local_catalogue.model_by_key("openbmb/MiniCPM4.1-8B").auto_class == "AutoModelForCausalLM"
+
+
 def test_binding_is_a_bare_repo_id_with_no_endpoint():
     # In-process: the binding carries the raw transformers repo id (no openai/ prefix) and
     # neither a base_url nor an api_key — the router builds the in-process provider from it.
-    binding = local_catalogue.binding_for("Qwen/Qwen2.5-3B-Instruct")
-    assert binding["model"] == "Qwen/Qwen2.5-3B-Instruct"
+    binding = local_catalogue.binding_for("nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16")
+    assert binding["model"] == "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"
     assert binding["base_url"] == ""
     assert binding["api_key"] == ""
 
@@ -103,9 +115,9 @@ def test_local_backend_is_registered_and_qualified():
 
 def test_registry_default_and_binding_round_trip():
     key = inference.default_key_for_profile("tiny", "local")
-    assert key == "local:Qwen/Qwen2.5-3B-Instruct"
+    assert key == "local:nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"
     binding = inference.binding_for(key)
-    assert binding["model"] == "Qwen/Qwen2.5-3B-Instruct"
+    assert binding["model"] == "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"
     assert binding["base_url"] == ""
 
 
@@ -124,15 +136,15 @@ def test_router_dispatches_local_key_to_in_process_provider():
     # A live router resolving a local: key must build the in-process provider (not LiteLLM),
     # bound to the bare repo id. Construction only — no GPU is touched.
     router = ModelRouter(offline=False)
-    provider = router.for_profile("local:Qwen/Qwen2.5-3B-Instruct")
+    provider = router.for_profile("local:nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16")
     assert isinstance(provider, LocalTransformersProvider)
-    assert provider.model == "Qwen/Qwen2.5-3B-Instruct"
-    assert provider.model_id == "Qwen/Qwen2.5-3B-Instruct"
+    assert provider.model == "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"
+    assert provider.model_id == "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"
 
 
 def test_catalogue_spec_tags_local_kind_and_others_litellm():
     router = ModelRouter(offline=False)
-    local_spec = router._catalogue_spec("local:Qwen/Qwen2.5-3B-Instruct")
+    local_spec = router._catalogue_spec("local:nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16")
     assert local_spec is not None and local_spec.kind == "local"
     # An HF key resolves through the same path but stays on the HTTP transport.
     hf_spec = router._catalogue_spec("hf:katanemo/Arch-Router-1.5B")
@@ -143,8 +155,8 @@ def test_catalogue_spec_tags_local_kind_and_others_litellm():
 
 
 def test_provider_reports_model_id_and_zeroed_usage_before_any_call():
-    provider = LocalTransformersProvider(model="Qwen/Qwen2.5-3B-Instruct")
-    assert provider.model_id == "Qwen/Qwen2.5-3B-Instruct"
+    provider = LocalTransformersProvider(model="nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16")
+    assert provider.model_id == "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"
     assert provider.last_usage == {}  # no call yet — matches the sibling providers
     provider._zero_usage()
     assert provider.last_usage == {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
@@ -152,11 +164,21 @@ def test_provider_reports_model_id_and_zeroed_usage_before_any_call():
 
 def test_provider_resolves_trust_remote_code_from_catalogue():
     assert LocalTransformersProvider(model="openbmb/MiniCPM4.1-8B")._trust_remote_code() is True
-    assert LocalTransformersProvider(model="Qwen/Qwen2.5-3B-Instruct")._trust_remote_code() is False
+    assert LocalTransformersProvider(model="CohereLabs/aya-expanse-8b")._trust_remote_code() is False
     # An off-catalogue repo defaults to the safe choice.
     assert LocalTransformersProvider(model="some/random-repo")._trust_remote_code() is False
 
 
+def test_provider_resolves_auto_class_from_catalogue():
+    # Mellum loads with a non-default auto-class; ordinary and off-catalogue repos use CausalLM.
+    assert (
+        LocalTransformersProvider(model="JetBrains/Mellum2-12B-A2.5B-Instruct")._auto_class()
+        == "AutoModelForMultimodalLM"
+    )
+    assert LocalTransformersProvider(model="openbmb/MiniCPM4.1-8B")._auto_class() == "AutoModelForCausalLM"
+    assert LocalTransformersProvider(model="some/random-repo")._auto_class() == "AutoModelForCausalLM"
+
+
 # ── ZeroGPU contract: CUDA only inside @spaces.GPU, never in the parent ───────────────
 # Regression guard for the production crash "Low-level CUDA init (torch._C._cuda_init)
 # reached … ZeroGPU's emulation did not intercept": the parent process gets no GPU, so any