fix(gguf): actually lazy-pull via /api/pull, fail loudly on probe

Two bugs the charon bring-up exposed:

1. Ollama's /v1/chat/completions does NOT lazy-pull missing models
When charon's cache was empty for Q4_K_M and Q8_0 (only BF16 was
pre-pulled), the first chat request returned 404. The wrapper
caught it as a generic Exception and returned empty text, which
lighteval processed as '?' extracted answers, and we committed
32 garbage rows (16 per quant, both sides '?' and zero hits)
to lthn/lemer and the lthn/LEM-benchmarks aggregator before the
wrapper bug was spotted.

2. The probe was defensive-to-a-fault
_probe() swallowed exceptions with a warning and 'continuing
anyway — Ollama may lazy-pull on first real request'. Since we
just learned Ollama doesn't lazy-pull, that assumption was
wrong, and the probe was silently covering up the failure.

Fixes:

- _ensure_cached() uses Ollama's native /api/pull endpoint to
actually pull missing models into the cache. Calls /api/tags
first to see if it's already there (cheap no-op when cached).
Streams pull progress to stdout. Raises RuntimeError on any
pull error (network, 404 on HF, disk full, etc.).
- _probe() now RAISES on any failure instead of warning. Also
rejects empty responses as an indicator that chat template or
quant integrity is broken.
- greedy_until() unchanged — still catches per-sample errors and
substitutes empty text, because a single round can legitimately
fail (e.g. timeout) without tanking the whole 8-round batch.
But since __init__ now fails fast, we never reach greedy_until
for a broken model setup.

Cleanup: garbage Q4_K_M / Q8_0 canons from the initial charon loop
are being git rm'd from both lthn/lemer and lthn/LEM-benchmarks in
separate commits.

Co-Authored-By: Virgil <virgil@lethean.io>

gguf_wrapper.py

@@ -69,7 +69,15 @@ class GGUFOllamaModel(LightevalModel):
         self.config = config
         self.model_name = config.model_name
 
+        # The OpenAI-compat endpoint (chat/completions). Used for inference.
         self.base_url = os.environ.get("LEM_OLLAMA_URL", "http://localhost:11434/v1")
+        # The Ollama-native endpoint (/api/pull, /api/tags). Used to ensure
+        # the model is cached BEFORE we start inferring — Ollama's
+        # /v1/chat/completions endpoint does NOT lazy-pull, it just 404s.
+        self.ollama_native_url = os.environ.get(
+            "LEM_OLLAMA_NATIVE_URL",
+            self.base_url.replace("/v1", ""),
+        )
         self.api_key = os.environ.get("LEM_OLLAMA_API_KEY", "ollama")
 
         try:
@@ -80,29 +88,102 @@ class GGUFOllamaModel(LightevalModel):
                 "dependencies in eval.py or install with `uv pip install openai`."
             ) from e
 
-        print(f"[gguf_wrapper] Ollama endpoint: {self.base_url}")
+        print(f"[gguf_wrapper] Ollama OpenAI endpoint: {self.base_url}")
+        print(f"[gguf_wrapper] Ollama native endpoint: {self.ollama_native_url}")
         print(f"[gguf_wrapper] model: {self.model_name}")
         self._client = OpenAI(base_url=self.base_url, api_key=self.api_key)
 
-        # Force-probe: 1-token request to catch pull failures early rather
-        # than mid-eval after lighteval has already queued up work.
+        # Step 1: ensure the model is in Ollama's cache — pull via /api/pull
+        # if missing. Fails loudly if the pull itself errors (network, auth,
+        # repo/tag doesn't exist on HF, disk full, etc.).
+        self._ensure_cached()
+
+        # Step 2: 1-token probe via chat/completions to confirm the model
+        # actually serves. Raises on any failure — no more silent-empty.
         self._probe()
 
         self._cache = SampleCache(config)
 
+    def _ensure_cached(self) -> None:
+        """Make sure `self.model_name` is present in Ollama's local cache.
+
+        Ollama's /v1/chat/completions doesn't lazy-pull — it 404s on unknown
+        models. So we explicitly call /api/pull first. If the model is
+        already cached this is a no-op (Ollama responds immediately).
+        """
+        import urllib.request
+        import urllib.error
+        import json as _json
+
+        # Check cached models via /api/tags — cheap fast call.
+        try:
+            with urllib.request.urlopen(f"{self.ollama_native_url}/api/tags", timeout=10) as r:
+                tags = _json.loads(r.read().decode())
+                cached = {m.get("name") or m.get("model") for m in tags.get("models", [])}
+                if self.model_name in cached:
+                    print(f"[gguf_wrapper] already cached: {self.model_name}")
+                    return
+        except Exception as e:
+            print(f"[gguf_wrapper] /api/tags check failed ({type(e).__name__}: {e}), "
+                  f"attempting pull anyway", file=sys.stderr)
+
+        # Not cached — pull via /api/pull. This is a streaming endpoint;
+        # we read the chunks and watch for a final success/error.
+        print(f"[gguf_wrapper] pulling {self.model_name} (not cached)...")
+        req = urllib.request.Request(
+            f"{self.ollama_native_url}/api/pull",
+            data=_json.dumps({"name": self.model_name, "stream": True}).encode(),
+            headers={"Content-Type": "application/json"},
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=3600) as resp:
+                last_status = None
+                for line in resp:
+                    try:
+                        evt = _json.loads(line)
+                    except _json.JSONDecodeError:
+                        continue
+                    if "error" in evt:
+                        raise RuntimeError(
+                            f"Ollama pull failed: {evt['error']}"
+                        )
+                    status = evt.get("status")
+                    if status and status != last_status:
+                        print(f"[gguf_wrapper]   {status}")
+                        last_status = status
+        except urllib.error.HTTPError as e:
+            raise RuntimeError(
+                f"Ollama /api/pull returned HTTP {e.code}: {e.read().decode()[:200]}"
+            ) from e
+        print(f"[gguf_wrapper] pull complete: {self.model_name}")
+
     def _probe(self) -> None:
+        """1-token sanity check. Raises on any failure — no silent empty results.
+
+        If this wrapper is going to produce canon rows, the model MUST be
+        able to generate text. A failing probe means something upstream is
+        broken (Ollama down, model missing, chat template borked) and the
+        right response is to halt the run, not write empty ?-rows.
+        """
         try:
-            _ = self._client.chat.completions.create(
+            resp = self._client.chat.completions.create(
                 model=self.model_name,
                 messages=[{"role": "user", "content": "ping"}],
                 max_tokens=1,
                 temperature=0.0,
             )
-            print(f"[gguf_wrapper] probe OK")
         except Exception as e:
-            print(f"[gguf_wrapper] WARNING: probe failed ({type(e).__name__}: {e})", file=sys.stderr)
-            print(f"[gguf_wrapper] continuing anyway — Ollama may lazy-pull on first real request",
-                  file=sys.stderr)
+            raise RuntimeError(
+                f"[gguf_wrapper] probe FAILED for {self.model_name}: "
+                f"{type(e).__name__}: {e}"
+            ) from e
+        content = resp.choices[0].message.content or ""
+        if not content.strip():
+            raise RuntimeError(
+                f"[gguf_wrapper] probe returned empty content for {self.model_name} "
+                f"— model is reachable but not generating. Check chat template / quant integrity."
+            )
+        print(f"[gguf_wrapper] probe OK ({len(content)} chars returned)")
 
     @property
     def tokenizer(self):