Dépôts Hugging Face verrouillés : dit lesquels, et pourquoi le 401

Un dépôt « gated » (orcarouter/Qwen3.8-27B-Uncensored-GGUF, vécu) laisse lire
son arborescence sans rien : Loki listait donc ses seize quantifications avec
leur verdict mémoire, puis échouait sur « HTTP 401 depuis la source » au
premier octet. Le message ne disait ni que le dépôt était verrouillé, ni qu'il
fallait accepter ses conditions, ni où poser un jeton.

- Le refus est maintenant traduit à partir de X-Error-Code (GatedRepo,
  RepoNotFound, EntryNotFound…) et nomme le dépôt, l'action à faire et l'état
  du jeton : absent (il en faut un) ou présent mais sans accès. 404, 416, 429
  et les pannes de la source y gagnent aussi une phrase utile.
- Le verrou se voit AVANT de choisir une quantification : la recherche demande
  `expand[]=gated` et la fiche du dépôt est lue à l'ouverture, d'où une
  pastille « accès restreint » dans la liste et un avertissement en toutes
  lettres au-dessus des fichiers.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Hz1QWmvZqW3t53YC5SJBKC

internal/loki/backend_hf.go

@@ -67,6 +67,11 @@ type hfRepo struct {
 	ID        string `json:"id"`
 	Downloads int    `json:"downloads"`
 	Likes     int    `json:"likes"`
+	// Gated : le dépôt exige d'avoir accepté ses conditions ET un jeton. Il se
+	// LIT pourtant sans rien (arborescence en 200), et ne refuse qu'au moment du
+	// transfert : sans cette pastille, l'interface propose des quants avec leur
+	// verdict mémoire et le téléchargement échoue en 401 sans prévenir.
+	Gated bool `json:"gated"`
 }
 
 // hfEntry — un .gguf installable. Shards > 1 signale une famille de tranches :
@@ -85,6 +90,7 @@ type hfEntry struct {
 // hfListing — le contenu utile d'un dépôt, trié.
 type hfListing struct {
 	Repo       string    `json:"repo"`
+	Gated      bool      `json:"gated"`
 	Models     []hfEntry `json:"models"`
 	Projectors []hfEntry `json:"projectors"`
 	Drafts     []hfEntry `json:"drafts"`
@@ -172,29 +178,94 @@ func hfSearch(ctx context.Context, q string) ([]hfRepo, error) {
 	if len(q) > hfMaxQuery {
 		q = q[:hfMaxQuery]
 	}
+	// `expand[]` remplace les champs par défaut de la réponse : `gated` s'y
+	// ajoute, mais downloads et likes doivent alors être redemandés
+	// explicitement, sinon ils disparaissent et la liste perd son classement
+	// lisible.
 	endpoint := hfHost + "/api/models?" + url.Values{
 		"search":    {q},
 		"filter":    {"gguf"},
 		"limit":     {fmt.Sprint(hfMaxRepos)},
 		"sort":      {"downloads"},
 		"direction": {"-1"},
+		"expand[]":  {"gated", "downloads", "likes"},
 	}.Encode()
 
 	var raw []struct {
 		ID        string `json:"id"`
 		Downloads int    `json:"downloads"`
 		Likes     int    `json:"likes"`
+		Gated     any    `json:"gated"`
 	}
 	if err := hfGetJSON(ctx, endpoint, hfSearchTTL, &raw); err != nil {
 		return nil, err
 	}
 	out := make([]hfRepo, 0, len(raw))
 	for _, r := range raw {
-		out = append(out, hfRepo{ID: r.ID, Downloads: r.Downloads, Likes: r.Likes})
+		out = append(out, hfRepo{ID: r.ID, Downloads: r.Downloads, Likes: r.Likes, Gated: hfGatedFlag(r.Gated)})
 	}
 	return out, nil
 }
 
+// hfGatedFlag lit le champ `gated` de l'API, qui n'est PAS un booléen : il vaut
+// false, "auto" (accepter les conditions suffit) ou "manual" (l'auteur valide
+// chaque demande). Les deux dernières valeurs verrouillent le téléchargement de
+// la même façon ; seule la présence d'un verrou nous intéresse ici.
+func hfGatedFlag(v any) bool {
+	switch g := v.(type) {
+	case bool:
+		return g
+	case string:
+		switch strings.ToLower(strings.TrimSpace(g)) {
+		case "", "false", "none", "no":
+			return false
+		}
+		return true
+	}
+	return false
+}
+
+// hfRepoGated dit si un dépôt est verrouillé. L'arborescence (hfFiles) ne porte
+// pas l'information : elle se lit sur la fiche du dépôt, en un appel séparé et
+// mis en cache comme elle. Une erreur ici ne doit RIEN casser — au pire on
+// n'affiche pas l'avertissement, et le téléchargement dira lui-même pourquoi il
+// a été refusé.
+func hfRepoGated(ctx context.Context, repo string) bool {
+	var info struct {
+		Gated any `json:"gated"`
+	}
+	endpoint := hfHost + "/api/models/" + repo + "?" + url.Values{"expand[]": {"gated"}}.Encode()
+	if err := hfGetJSON(ctx, endpoint, hfFilesTTL, &info); err != nil {
+		return false
+	}
+	return hfGatedFlag(info.Gated)
+}
+
+// hfTokenSet dit si un jeton est configuré, pour que l'interface distingue
+// « il faut en poser un » de « celui qui est posé ne suffit pas ».
+func hfTokenSet() bool {
+	return strings.TrimSpace(os.Getenv("HF_TOKEN")) != ""
+}
+
+// hfRepoFromURL retrouve « auteur/dépôt » dans un lien de téléchargement
+// Hugging Face, pour pouvoir le nommer dans un message d'erreur. Renvoie "" si
+// le lien pointe ailleurs.
+func hfRepoFromURL(raw string) string {
+	u, err := url.Parse(raw)
+	if err != nil || !strings.Contains(u.Host, "huggingface.co") {
+		return ""
+	}
+	segs := strings.Split(strings.Trim(u.Path, "/"), "/")
+	if len(segs) < 4 || (segs[2] != "resolve" && segs[2] != "blob") {
+		return ""
+	}
+	repo := segs[0] + "/" + segs[1]
+	if !hfRepoRe.MatchString(repo) {
+		return ""
+	}
+	return repo
+}
+
 // hfFiles liste les .gguf d'un dépôt et les range par famille.
 //
 // `recursive=1` n'est pas un confort : les quants volumineux vivent dans des
@@ -229,7 +300,9 @@ func hfFiles(ctx context.Context, repo string) (hfListing, error) {
 		}
 		files = append(files, hfFile{Path: f.Path, Size: n})
 	}
-	return hfClassify(repo, files), nil
+	out := hfClassify(repo, files)
+	out.Gated = hfRepoGated(ctx, repo)
+	return out, nil
 }
 
 // hfFile — une entrée d'arborescence, réduite à ce dont le classement a besoin.