Studio: redesign Select model dropdown to match Hub design

studio/backend/models/models.py

@@ -154,6 +154,10 @@ class GgufVariantsResponse(BaseModel):
     default_variant: Optional[str] = Field(
         None, description = "Recommended default quantization variant"
     )
+    context_length: Optional[int] = Field(
+        None,
+        description = "Native max context from GGUF metadata; set once a variant is downloaded",
+    )
 
 
 class LocalModelInfo(BaseModel):
@@ -170,6 +174,11 @@ class LocalModelInfo(BaseModel):
         None,
         description = "HF repo id for cached models, e.g. org/model",
     )
+    model_format: Optional[str] = Field(
+        None,
+        description = "Detected weights format ('gguf' when known). Lets the UI "
+        "classify scanned folders whose name lacks a -GGUF suffix.",
+    )
     updated_at: Optional[float] = Field(
         None,
         description = "Unix timestamp of latest observed update",

studio/backend/tests/test_cached_gguf_routes.py

@@ -82,6 +82,7 @@ def test_list_cached_gguf_includes_non_suffix_repo_when_cache_contains_gguf(monk
             "repo_id": "HauhauCS/Gemma-4-E4B-Uncensored-HauhauCS-Aggressive",
             "size_bytes": 5_000,
             "cache_path": str(repo.repo_path),
+            "has_vision": False,
         }
     ]
 
@@ -103,6 +104,7 @@ def test_list_cached_gguf_matches_extension_case_insensitively(monkeypatch, tmp_
             "repo_id": "Org/Model-Without-Suffix",
             "size_bytes": 7_000,
             "cache_path": str(repo.repo_path),
+            "has_vision": False,
         }
     ]
 
@@ -197,6 +199,7 @@ def test_list_cached_gguf_keeps_largest_duplicate_repo_across_scans(monkeypatch,
             "repo_id": "org/dupe",
             "size_bytes": 6_000,
             "cache_path": str(larger.repo_path),
+            "has_vision": False,
         }
     ]
 
@@ -226,6 +229,7 @@ def test_list_cached_gguf_dedupes_shared_blobs_across_revisions(monkeypatch, tmp
             "repo_id": "Org/SharedBlobRepo",
             "size_bytes": 5_000,
             "cache_path": str(repo.repo_path),
+            "has_vision": False,
         }
     ]
 
@@ -275,6 +279,7 @@ def test_list_cached_gguf_includes_mixed_repo_with_gguf_and_safetensors(monkeypa
             "repo_id": "Org/MixedRepo",
             "size_bytes": 5_000,
             "cache_path": str(mixed.repo_path),
+            "has_vision": False,
         }
     ]
 
@@ -301,6 +306,7 @@ def test_list_cached_gguf_handles_none_size_on_disk(monkeypatch, tmp_path):
             "repo_id": "Org/PartialDownload",
             "size_bytes": 5_000,
             "cache_path": str(partial.repo_path),
+            "has_vision": False,
         }
     ]
 
@@ -336,6 +342,7 @@ def revisions(self):
             "repo_id": "Org/Healthy",
             "size_bytes": 5_000,
             "cache_path": str(healthy.repo_path),
+            "has_vision": False,
         }
     ]
 
@@ -411,6 +418,7 @@ def test_list_cached_gguf_includes_vision_repo_with_main_gguf_and_mmproj(monkeyp
             "repo_id": "Org/VisionGguf",
             "size_bytes": 5_000,
             "cache_path": str(vision_repo.repo_path),
+            "has_vision": True,
         }
     ]
 
@@ -464,6 +472,7 @@ def resolve(self):
             "repo_id": "Org/Active",
             "size_bytes": 5_000,
             "cache_path": str(tmp_path / "active"),
+            "has_vision": False,
         }
     ]
 

studio/backend/tests/test_local_model_format.py

@@ -0,0 +1,117 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Tests for local GGUF ``model_format`` classification (PR #6364 follow-up).
+
+Suffixless GGUF folders (custom folders / LM Studio) carry no ``-GGUF`` name
+hint, so the scanners must surface ``model_format = "gguf"`` for the UI to route
+them through the GGUF load path. The rule, shared by ``_dir_model_format`` and
+``_scan_models_dir``: a directory is GGUF-format when it holds ``.gguf`` files
+and no non-GGUF weights (``.safetensors`` / ``.bin``); a stray ``config.json``
+must not disqualify it.
+
+No GPU/network: only file names and sizes are inspected.
+"""
+
+from __future__ import annotations
+
+import sys
+import types
+from pathlib import Path
+
+# Keep runnable without optional logging deps (mirrors the sibling tests).
+if "structlog" not in sys.modules:
+
+    class _DummyLogger:
+        def __getattr__(self, _name):
+            return lambda *args, **kwargs: None
+
+    sys.modules["structlog"] = types.SimpleNamespace(
+        BoundLogger = _DummyLogger,
+        get_logger = lambda *args, **kwargs: _DummyLogger(),
+    )
+
+import routes.models as models_route
+
+
+def _touch(path: Path) -> Path:
+    path.parent.mkdir(parents = True, exist_ok = True)
+    path.write_bytes(b"\0")
+    return path
+
+
+def test_dir_model_format_gguf_only(tmp_path):
+    d = tmp_path / "model"
+    _touch(d / "model-Q4_K_M.gguf")
+    assert models_route._dir_model_format(d) == "gguf"
+
+
+def test_dir_model_format_gguf_with_config_is_still_gguf(tmp_path):
+    # A config.json alongside the .gguf must not flip it to non-GGUF.
+    d = tmp_path / "model"
+    _touch(d / "config.json")
+    _touch(d / "model-Q4_K_M.gguf")
+    assert models_route._dir_model_format(d) == "gguf"
+
+
+def test_dir_model_format_mixed_weights_is_not_gguf(tmp_path):
+    # Real safetensors weights present -> not a GGUF folder.
+    d = tmp_path / "model"
+    _touch(d / "model.safetensors")
+    _touch(d / "model-Q4_K_M.gguf")
+    assert models_route._dir_model_format(d) is None
+
+
+def test_dir_model_format_no_gguf(tmp_path):
+    d = tmp_path / "model"
+    _touch(d / "config.json")
+    _touch(d / "model.safetensors")
+    assert models_route._dir_model_format(d) is None
+
+
+def test_dir_model_format_ignores_tokenizer_bin(tmp_path):
+    # A companion tokenizer.bin is not a weight file, so a GGUF folder shipping
+    # one is still GGUF (not misread as a plain .bin checkpoint).
+    d = tmp_path / "model"
+    _touch(d / "tokenizer.bin")
+    _touch(d / "model-Q4_K_M.gguf")
+    assert models_route._dir_model_format(d) == "gguf"
+
+
+def test_dir_model_format_weight_bin_is_not_gguf(tmp_path):
+    # A real PyTorch weight .bin alongside a .gguf means mixed weights -> None.
+    d = tmp_path / "model"
+    _touch(d / "pytorch_model.bin")
+    _touch(d / "model-Q4_K_M.gguf")
+    assert models_route._dir_model_format(d) is None
+
+
+def test_scan_models_dir_classifies_gguf_with_config(tmp_path):
+    root = tmp_path / "models"
+    # GGUF repo that also ships a config.json (the regression case).
+    _touch(root / "gguf_repo" / "config.json")
+    _touch(root / "gguf_repo" / "model-Q4_K_M.gguf")
+    # A plain safetensors checkpoint stays non-GGUF.
+    _touch(root / "st_repo" / "config.json")
+    _touch(root / "st_repo" / "model.safetensors")
+    # A standalone .gguf file is GGUF.
+    _touch(root / "loose.gguf")
+
+    fmt = {Path(m.path).name: m.model_format for m in models_route._scan_models_dir(root)}
+
+    assert fmt["gguf_repo"] == "gguf"
+    assert fmt["st_repo"] is None
+    assert fmt["loose.gguf"] == "gguf"
+
+
+def test_scan_models_dir_classifies_root_gguf_with_config(tmp_path):
+    # Custom scan folders can point directly at a GGUF repo, not only at a
+    # parent directory that contains model repos.
+    root = tmp_path / "SuffixlessRepo"
+    _touch(root / "config.json")
+    _touch(root / "model-Q4_K_M.gguf")
+
+    [row] = models_route._scan_models_dir(root)
+
+    assert row.path == str(root)
+    assert row.model_format == "gguf"

studio/backend/tests/test_recommended_folders_has_model.py

@@ -0,0 +1,166 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""
+Regression test for /recommended-folders suggesting empty scaffolds.
+
+The endpoint used to surface any well-known dir that merely existed, so a
+freshly installed LM Studio or Ollama (empty ``models`` dir) showed up as a
+"Recommended" chip with no models behind it. ``_dir_has_downloaded_model``
+now gates each candidate on real weights: a GGUF/safetensors file anywhere in
+the tree, or a non-empty Ollama ``manifests/`` beside ``blobs/``.
+
+``routes.models`` pulls the full backend dep tree, so we extract the real
+helper (and its ``_safe_is_dir`` dependency) from the source via AST and run
+the shipped code in isolation, mirroring
+``test_recommended_folders_permission.py``.
+
+Run:
+    python -m pytest studio/backend/tests/test_recommended_folders_has_model.py -v
+"""
+
+import ast
+import json
+import os
+from pathlib import Path
+
+_backend_root = Path(__file__).resolve().parent.parent
+_models_src = _backend_root / "routes" / "models.py"
+
+
+def _load_has_downloaded_model():
+    """Return the real ``_dir_has_downloaded_model`` (plus its ``_safe_is_dir``
+    and ``_is_weight_bin`` deps, and the ``_WEIGHT_BIN_PREFIXES`` constant the
+    latter reads) without importing the heavy module."""
+    tree = ast.parse(_models_src.read_text())
+    wanted = {"_safe_is_dir", "_dir_has_downloaded_model", "_is_weight_bin"}
+    body = []
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef) and node.name in wanted:
+            body.append(node)
+        elif isinstance(node, ast.Assign) and any(
+            isinstance(t, ast.Name) and t.id == "_WEIGHT_BIN_PREFIXES" for t in node.targets
+        ):
+            body.append(node)
+    got = {n.name for n in body if isinstance(n, ast.FunctionDef)}
+    assert got == wanted, f"helpers missing from source: {wanted - got}"
+    module = ast.Module(body = body, type_ignores = [])
+    ns: dict = {"Path": Path, "os": os, "json": json}
+    exec(compile(module, f"<extracted {_models_src}>", "exec"), ns)
+    return ns["_dir_has_downloaded_model"]
+
+
+has_downloaded_model = _load_has_downloaded_model()
+
+
+def test_empty_scaffold_is_false(tmp_path):
+    empty = tmp_path / "lmstudio" / "models"
+    empty.mkdir(parents = True)
+    assert has_downloaded_model(empty) is False
+
+
+def test_lmstudio_gguf_is_true(tmp_path):
+    # models/publisher/repo/file.gguf (LM Studio's nested layout).
+    repo = tmp_path / "models" / "bartowski" / "Qwen3-4B-GGUF"
+    repo.mkdir(parents = True)
+    (repo / "q4.gguf").write_bytes(b"x")
+    assert has_downloaded_model(tmp_path / "models") is True
+
+
+def test_safetensors_is_true(tmp_path):
+    repo = tmp_path / "models" / "repo"
+    repo.mkdir(parents = True)
+    (repo / "model.safetensors").write_bytes(b"x")
+    assert has_downloaded_model(tmp_path / "models") is True
+
+
+def test_ollama_empty_scaffold_is_false(tmp_path):
+    models = tmp_path / "ollama" / "models"
+    (models / "manifests").mkdir(parents = True)
+    (models / "blobs").mkdir()
+    assert has_downloaded_model(models) is False
+
+
+def test_ollama_with_manifest_is_true(tmp_path):
+    models = tmp_path / "ollama" / "models"
+    manifest = models / "manifests" / "registry.ollama.ai" / "library" / "llama3"
+    manifest.mkdir(parents = True)
+    # A real manifest references its weights via an image.model layer; the
+    # referenced blob must exist on disk for the model to be loadable.
+    (manifest / "latest").write_text(
+        json.dumps(
+            {
+                "layers": [
+                    {
+                        "mediaType": "application/vnd.ollama.image.model",
+                        "digest": "sha256:abc",
+                    }
+                ]
+            }
+        )
+    )
+    (models / "blobs").mkdir()
+    (models / "blobs" / "sha256-abc").write_bytes(b"x")
+    assert has_downloaded_model(models) is True
+
+
+def test_ollama_manifest_without_blob_is_false(tmp_path):
+    # A failed/pruned pull leaves the manifest behind but its model blob is
+    # gone: the chip must not lead to an empty picker.
+    models = tmp_path / "ollama" / "models"
+    manifest = models / "manifests" / "registry.ollama.ai" / "library" / "llama3"
+    manifest.mkdir(parents = True)
+    (manifest / "latest").write_text(
+        json.dumps(
+            {
+                "layers": [
+                    {
+                        "mediaType": "application/vnd.ollama.image.model",
+                        "digest": "sha256:missing",
+                    }
+                ]
+            }
+        )
+    )
+    (models / "blobs").mkdir()  # empty: the referenced blob never landed
+    assert has_downloaded_model(models) is False
+
+
+def test_non_model_files_is_false(tmp_path):
+    junk = tmp_path / "junk"
+    junk.mkdir()
+    (junk / "readme.txt").write_text("hi")
+    assert has_downloaded_model(junk) is False
+
+
+def test_pytorch_bin_weights_are_true(tmp_path):
+    # A folder whose only weights are PyTorch .bin checkpoints (which the local
+    # scanner accepts) should still earn a Recommended chip.
+    repo = tmp_path / "models" / "repo"
+    repo.mkdir(parents = True)
+    (repo / "config.json").write_text("{}")
+    (repo / "pytorch_model.bin").write_bytes(b"x")
+    assert has_downloaded_model(tmp_path / "models") is True
+
+
+def test_non_weight_bin_is_false(tmp_path):
+    # A stray .bin that is not a weight file (e.g. tokenizer.bin) must not count.
+    repo = tmp_path / "models" / "repo"
+    repo.mkdir(parents = True)
+    (repo / "tokenizer.bin").write_bytes(b"x")
+    assert has_downloaded_model(tmp_path / "models") is False
+
+
+def test_hidden_subtree_does_not_starve_the_budget(tmp_path):
+    # A real model dir that also holds a huge hidden subtree (e.g. a .git or
+    # .cache). The hidden entries must not exhaust max_entries before the walk
+    # reaches the actual weights, which would falsely report "no model".
+    models = tmp_path / "models"
+    git = models / ".git" / "objects"
+    git.mkdir(parents = True)
+    for i in range(50):
+        (git / f"obj{i}").write_bytes(b"x")
+    repo = models / "repo"
+    repo.mkdir()
+    (repo / "model.safetensors").write_bytes(b"x")
+    assert has_downloaded_model(models, max_entries = 10) is True