Studio autoload: resolve dir-GGUF variants, match remembered kind, skip adapters

Review follow-ups, all verified against the backend inventory services:

- Directory-based local GGUFs (LM Studio, models dir, custom folders) are
  flagged requires_variant by the backend, so the fallback now resolves the
  smallest complete quant through the same variants API the picker card
  uses instead of dropping every directory row.
- A folder holding both GGUF and safetensors weights yields two rows with
  the same load target; remembered-model matching now requires the row
  format to agree with the remembered kind.
- Adapter rows are chat-capable but load by resolving their base model,
  which for a Hub-id base would start an implicit remote fetch; adapters
  are excluded from background auto-load.

Contract tests extended to pin all three behaviors.

Author: shimmyshimmer

studio/frontend/src/features/chat/api/chat-adapter.ts

@@ -1469,6 +1469,10 @@ function isAutoLoadableLocalRow(row: LocalModelInfo): boolean {
   if (!AUTO_LOAD_LOCAL_SOURCES.has(row.source)) return false;
   if (row.capabilities?.can_chat !== true) return false;
   if (row.partial) return false;
+  // Adapters are chat-capable but load by resolving their base model, which
+  // for a Hub-id base can trigger the implicit remote fetch a background
+  // auto-load must never start. Adapters stay interactive-only.
+  if (row.model_format === "adapter") return false;
   if (isHiddenModelId(row.model_id, row.id, row.path)) return false;
   if (
     row.model_format === "gguf" &&
@@ -1504,11 +1508,50 @@ function localRowToCandidate(
   };
 }
 
+/**
+ * Build a loadable candidate for a backend-indexed local row. Directory-based
+ * GGUFs (LM Studio, models dir, custom folders) are flagged requires_variant
+ * by the backend, so without a remembered quant the folder is scanned through
+ * the same variants API the picker card uses and the smallest complete,
+ * auto-loadable quant is chosen. Returns null when no quant can be resolved.
+ */
+async function resolveLocalRowCandidate(
+  row: LocalModelInfo,
+  rememberedVariant: string | null = null,
+): Promise<AutoLoadCandidate | null> {
+  const isGguf = row.model_format === "gguf";
+  if (row.capabilities?.requires_variant === true) {
+    // Only GGUF folders have an automatic quant resolution path.
+    if (!isGguf) return null;
+    if (!rememberedVariant) {
+      const variants = await listGgufVariants(row.model_id || row.id, undefined, {
+        preferLocalCache: true,
+        localPath: row.path,
+      });
+      const downloaded = variants.variants
+        .filter(
+          (entry) =>
+            entry.downloaded && !entry.partial && isAutoLoadableGgufVariant(entry),
+        )
+        .sort((a, b) => a.size_bytes - b.size_bytes);
+      if (downloaded.length === 0) return null;
+      return localRowToCandidate(row, downloaded[0].quant);
+    }
+  }
+  return localRowToCandidate(row, isGguf ? rememberedVariant : null);
+}
+
 /** Resolve a remembered local model against current backend inventory. */
 function matchesRememberedLocalRow(
   row: LocalModelInfo,
   remembered: LastLocalModelLoad,
 ): boolean {
+  // A folder holding both GGUF and safetensors weights yields two rows with
+  // the same path/load target, so the format must agree with the remembered
+  // kind before identifier matching can accept the row.
+  if ((row.model_format === "gguf") !== (remembered.kind === "gguf")) {
+    return false;
+  }
   if (
     remembered.inventoryId &&
     row.inventory_id &&
@@ -1911,17 +1954,19 @@ export async function autoLoadOnDeviceModel(): Promise<{
         if (row) {
           markSeen(row.load_id, row.id, row.path, row.model_id);
           try {
-            toast("Loading last used model…", {
-              id: toastId,
-              description: row.display_name || row.id,
-              duration: 5000,
-            });
-            if (
-              await loadAutoLoadCandidate(
-                localRowToCandidate(row, lastLoaded.ggufVariant),
-              )
-            ) {
-              return { loaded: true, blockedByTrustRemoteCode: false };
+            const rememberedCandidate = await resolveLocalRowCandidate(
+              row,
+              lastLoaded.ggufVariant,
+            );
+            if (rememberedCandidate) {
+              toast("Loading last used model…", {
+                id: toastId,
+                description: row.display_name || row.id,
+                duration: 5000,
+              });
+              if (await loadAutoLoadCandidate(rememberedCandidate)) {
+                return { loaded: true, blockedByTrustRemoteCode: false };
+              }
             }
           } catch {
             hadNonTrustFailure = true;
@@ -2030,9 +2075,12 @@ export async function autoLoadOnDeviceModel(): Promise<{
       bytes && bytes > 0 ? bytes : Number.MAX_SAFE_INTEGER;
     const bySizeAsc = (a: FallbackCandidate, b: FallbackCandidate): number =>
       a.sizeBytes - b.sizeBytes;
-    // Background loads cannot ask which quant/variant to use.
+    // Directory-based GGUF rows resolve a quant automatically below; only
+    // non-GGUF variant-requiring rows have no background resolution path.
     const cascadeLocalRows = localRows.filter(
-      (row) => row.capabilities?.requires_variant !== true,
+      (row) =>
+        row.model_format === "gguf" ||
+        row.capabilities?.requires_variant !== true,
     );
     const ggufGroup: FallbackCandidate[] = [
       ...ggufRepos.map((repo) => ({
@@ -2141,20 +2189,23 @@ export async function autoLoadOnDeviceModel(): Promise<{
       if (isSeen(row.load_id, row.id, row.path, row.model_id)) {
         continue;
       }
-      const localCandidate = localRowToCandidate(row);
-      if (
-        skippedAutoLoadCandidates.has(
-          autoLoadCandidateKey(
-            localCandidate.kind,
-            localCandidate.id,
-            localCandidate.ggufVariant,
-          ),
-        )
-      ) {
-        continue;
-      }
       markSeen(row.load_id, row.id, row.path, row.model_id);
       try {
+        const localCandidate = await resolveLocalRowCandidate(row);
+        if (!localCandidate) {
+          continue;
+        }
+        if (
+          skippedAutoLoadCandidates.has(
+            autoLoadCandidateKey(
+              localCandidate.kind,
+              localCandidate.id,
+              localCandidate.ggufVariant,
+            ),
+          )
+        ) {
+          continue;
+        }
         if (await loadAutoLoadCandidate(localCandidate)) {
           return { loaded: true, blockedByTrustRemoteCode: false };
         }

tests/studio/test_model_picker_contracts.py

@@ -520,6 +520,9 @@ def test_autoload_filters_match_picker_policy():
     local_fn = local_fn.split("\nfunction ", 1)[0]
     assert "row.capabilities?.can_chat !== true" in local_fn
     assert "row.partial" in local_fn
+    # Adapters resolve their base model on load; a Hub-id base would start
+    # the implicit remote fetch a background auto-load must never trigger.
+    assert 'row.model_format === "adapter"' in local_fn
     assert "isHiddenModelId(row.model_id, row.id, row.path)" in local_fn
     assert "hasBigEndianGgufMarker(row.path, row.format_variant)" in local_fn
     cached_fn = src.split("function isAutoLoadableCachedRepo", 1)[1]
@@ -552,7 +555,8 @@ def test_autoload_remembers_last_model_across_all_sources():
     auto_load = _autoload_section()
     assert "isManagedCacheSource(lastLoaded.source)" in auto_load
     assert "matchesRememberedLocalRow(candidateRow, lastLoaded)" in auto_load
-    assert "localRowToCandidate(row, lastLoaded.ggufVariant)" in auto_load
+    assert "await resolveLocalRowCandidate(" in auto_load
+    assert "lastLoaded.ggufVariant," in auto_load
     # Managed-cache candidates record their provenance for later resolution.
     assert auto_load.count('source: "hf_cache"') >= 4
 
@@ -612,3 +616,34 @@ def test_interactive_local_loads_are_remembered_without_lease_bypass():
     assert "!nativePathToken &&" in record_block
     assert "(indexedLocalSelection || !isLocalModelPath(modelId))" in record_block
     assert 'source: "local",' in record_block
+
+
+def test_remembered_local_row_match_requires_kind_agreement():
+    """A folder holding both GGUF and safetensors weights yields two inventory
+    rows with the same path/load target, so the remembered kind must gate the
+    identifier match or a remembered safetensors load can resolve to the GGUF
+    row (and vice versa)."""
+    src = _read("features/chat/api/chat-adapter.ts")
+    match_fn = src.split("function matchesRememberedLocalRow", 1)[1]
+    match_fn = match_fn.split("\nasync function ", 1)[0].split("\nfunction ", 1)[0]
+    assert '(row.model_format === "gguf") !== (remembered.kind === "gguf")' in match_fn
+
+
+def test_directory_gguf_rows_resolve_variant_like_picker():
+    """Directory-based local GGUFs (LM Studio, models dir, custom folders) are
+    flagged requires_variant by the backend, so the fallback must resolve a
+    quant through the variants API (as the picker card does) instead of
+    silently dropping every directory row; non-GGUF variant-requiring rows
+    have no background resolution and stay excluded."""
+    src = _read("features/chat/api/chat-adapter.ts")
+    resolve_fn = src.split("async function resolveLocalRowCandidate", 1)[1]
+    resolve_fn = resolve_fn.split("\nfunction ", 1)[0]
+    assert 'row.capabilities?.requires_variant === true' in resolve_fn
+    assert "if (!isGguf) return null;" in resolve_fn
+    assert "listGgufVariants(row.model_id || row.id" in resolve_fn
+    assert "localPath: row.path" in resolve_fn
+    assert "entry.downloaded && !entry.partial && isAutoLoadableGgufVariant(entry)" in resolve_fn
+    # The cascade must keep directory GGUF rows as candidates.
+    auto_load = src.split("async function autoLoadOnDeviceModel", 1)[1]
+    assert 'row.model_format === "gguf" ||' in auto_load
+    assert "await resolveLocalRowCandidate(row)" in auto_load