Fall back to another repo's GGUF header; hide non-llama.cpp GGUFs

app/detail.py

@@ -158,17 +158,27 @@ def read_header(repo: str, path: str, client: httpx.Client):
     raise NeedMoreBytes
 
 
-def header_candidate(repos: list[RepoFiles], params: float | None = None) -> tuple[str, QuantFile] | None:
-    """The smallest real quant of the most downloaded repo: every quant shares the geometry,
-    and a small single file keeps the tensor table in the part we read. Files too small to be
-    the model (drafts, heads, encoders) are skipped."""
+def header_candidates(repos: list[RepoFiles], params: float | None = None, limit: int = 3) -> list[tuple[str, QuantFile]]:
+    """The smallest real quant of each repo, most downloaded repo first: every quant shares the
+    geometry, and a small single file keeps the tensor table in the part we read. Files too small
+    to be the model (drafts, heads, encoders) are skipped. Later repos are fallbacks for a first
+    file that isn't a llama.cpp GGUF (a ComfyUI export, another engine's own format)."""
     floor = min_model_bytes(params)
+    out = []
     for rf in repos:
         real = [q for q in rf.quants if (q.size or 0) >= floor]
         singles = [q for q in real if len(q.files) == 1] or real
         if singles:
-            return rf.repo, min(singles, key=lambda q: q.size or 0)
-    return None
+            out.append((rf.repo, min(singles, key=lambda q: q.size or 0)))
+        if len(out) >= limit:
+            break
+    return out
+
+
+def llama_cpp_header(h) -> bool:
+    """llama.cpp names tensors blk.N.* and keys <arch>.block_count; ComfyUI and some engines'
+    GGUFs keep Hugging Face names (model.layers.N.*) that llama.cpp can't load."""
+    return bool(h.arch_key("block_count")) and not any(k.startswith("comfy.") for k in h.metadata)
 
 
 def plausible_geometry(d: dict) -> bool:
@@ -187,6 +197,8 @@ class DetailCache:
         self._inflight: dict[str, threading.Event] = {}
         self.repo_files: dict[str, RepoFiles] = {}
         self.geometries: dict[str, dict] = {}
+        self.geometry_failed: dict[str, float] = {}  # group key -> when its headers couldn't be planned
+        self.not_llama_cpp: set[str] = set()  # every file read is a format llama.cpp can't load (ComfyUI, ...)
         self.fetch = fetch
         self.pool = ThreadPoolExecutor(max_workers=6, thread_name_prefix="detail")
         for path in (snapshot, self._geo_file):
@@ -229,7 +241,8 @@ class DetailCache:
     def get(self, group: Group, timeout: float = 20.0, with_geometry: bool = True,
             repos: int = REPOS_PER_MODEL) -> ModelDetail:
         wanted = [r.id for r in group.repos[:repos] if self._stale(r.id)]
-        need_geo = with_geometry and group.key not in self.geometries
+        need_geo = (with_geometry and group.key not in self.geometries
+                    and time.time() - self.geometry_failed.get(group.key, 0) > FILES_TTL)
         if self.fetch and (wanted or need_geo):
             with self._lock:
                 ev = self._inflight.get(group.key)
@@ -257,25 +270,39 @@ class DetailCache:
                 if need_geo:
                     ordered = [self.repo_files[r.id] for r in group.repos if r.id in self.repo_files]
                     params = next((r.params for r in group.repos if r.params), None)
-                    cand = header_candidate(ordered, params)
-                    if cand:
-                        repo, q = cand
+                    readable = foreign = 0
+                    candidates = header_candidates(ordered, params)
+                    for repo, q in candidates:
                         try:
                             if not BUDGET.acquire():
                                 raise TimeoutError("hub budget")
                             h = read_header(repo, q.first_file, client)
-                            g = from_header(h, q.size)
-                            vocab = h.metadata.get("tokenizer.ggml.tokens")
-                            n_vocab = vocab.get("array_len") if isinstance(vocab, dict) else None
-                            g.params = g.params or params  # the header's own weight count when it lists every tensor
-                            record = {**geometry_to_json(g, n_vocab), "_from": f"{repo}/{q.first_file}"}
-                            if plausible_geometry(record):
-                                self.geometries[group.key] = record
-                                self._save_geometries()
-                            else:
-                                log.info("implausible geometry for %s from %s", group.key, q.first_file)
                         except Exception as e:
-                            log.info("header read failed for %s: %s", group.key, type(e).__name__)
+                            log.info("header read failed for %s from %s: %s", group.key, q.first_file, type(e).__name__)
+                            continue
+                        readable += 1
+                        if not llama_cpp_header(h):
+                            foreign += 1
+                            log.info("not a llama.cpp GGUF: %s/%s", repo, q.first_file)
+                            continue
+                        g = from_header(h, q.size)
+                        vocab = h.metadata.get("tokenizer.ggml.tokens")
+                        n_vocab = vocab.get("array_len") if isinstance(vocab, dict) else None
+                        g.params = g.params or params  # the header's own weight count when it lists every tensor
+                        record = {**geometry_to_json(g, n_vocab), "_from": f"{repo}/{q.first_file}"}
+                        if plausible_geometry(record):
+                            self.geometries[group.key] = record
+                            self.geometry_failed.pop(group.key, None)
+                            self.not_llama_cpp.discard(group.key)
+                            self._save_geometries()
+                            break
+                        log.info("implausible geometry for %s from %s", group.key, q.first_file)
+                    else:
+                        if candidates and readable == len(candidates):
+                            # every file was read and none could be planned: don't re-read on every visit
+                            if foreign == readable:
+                                self.not_llama_cpp.add(group.key)
+                            self.geometry_failed[group.key] = time.time()
         finally:
             done.set()
             with self._lock:

app/main.py

@@ -144,6 +144,10 @@ class State:
         self.stats.invalidate()
 
 
+def _hidden(s, details) -> bool:
+    return _only_auxiliary(s) or s.group.key in details.not_llama_cpp
+
+
 def _only_auxiliary(s) -> bool:
     """Every file we could read is too small to be the model (a repo of draft models or
     speculative-decoding heads, which nobody runs on their own), or below the chosen bit level."""
@@ -226,7 +230,7 @@ def create_app(state: State | None = None) -> FastAPI:
         groups = st.catalogue.matching(req.family or None, req.size or None, req.search, req.moe_only, req.vision_only)
         community = st.stats.community()
         cached = {g.key: d for g in groups if (d := st.details.peek(g))}
-        prelim = [s for s in st.engine.score(groups, q, cached, community) if not _only_auxiliary(s)]
+        prelim = [s for s in st.engine.score(groups, q, cached, community) if not _hidden(s, st.details)]
         if (req.fits_only or q.vram_only) and q.hardware:
             prelim = [s for s in prelim if s.best and s.best.fit and s.best.fit.tier not in ("no", "no_vram")]
         prelim = sort_results(prelim, req.sort, community)
@@ -244,7 +248,7 @@ def create_app(state: State | None = None) -> FastAPI:
             fresh = {g.key: d for g in missing if (d := st.details.peek(g))}
             rescored = {s.group.key: s for s in st.engine.score([s.group for s in window], q, {**cached, **fresh}, community)}
             prelim = [rescored.get(s.group.key, s) for s in prelim]
-            prelim = [s for s in prelim if not _only_auxiliary(s)]
+            prelim = [s for s in prelim if not _hidden(s, st.details)]
             if (req.fits_only or q.vram_only) and q.hardware:
                 prelim = [s for s in prelim if s.best and s.best.fit and s.best.fit.tier not in ("no", "no_vram")]
             prelim = sort_results(prelim, req.sort, community)
@@ -252,7 +256,8 @@ def create_app(state: State | None = None) -> FastAPI:
         notices = []
         if st.catalogue.degraded:
             notices.append("Showing a cached copy of the model list.")
-        est = sum(1 for s in page if s.best and s.best.estimated)
+        # Only models whose files are still to be read; a model whose GGUFs can't be planned stays marked (est.)
+        est = sum(1 for s in page if s.best and s.best.estimated and s.group.key not in st.details.geometry_failed)
         if est:
             notices.append(f"{est} result(s) are estimated from the parameter count until their files are read.")
         return {"total": len(prelim), "offset": req.offset, "results": [s.to_dict(q) for s in page],