fix: preserve HuggingFace provider details in model response

- Store raw HuggingFace models in cache to preserve provider information
- Export getCachedRawHuggingFaceModels to retrieve full model data
- Update huggingface-models.ts to return cached raw models when available
- Include provider name in model descriptions
- Always add provider-specific variants to show all available providers
- Remove console.log statements from fetcher

Author: daniel-lxs

src/api/huggingface-models.ts

@@ -1,5 +1,10 @@
-import { getHuggingFaceModels as fetchModels, type HuggingFaceModel } from "./providers/fetchers/huggingface"
-import type { ModelRecord } from "../shared/api"
+import {
+	getHuggingFaceModels as fetchModels,
+	getCachedRawHuggingFaceModels,
+	type HuggingFaceModel,
+} from "./providers/fetchers/huggingface"
+import axios from "axios"
+import { HUGGINGFACE_API_URL } from "@roo-code/types"
 
 export interface HuggingFaceModelsResponse {
 	models: HuggingFaceModel[]
@@ -8,35 +13,49 @@ export interface HuggingFaceModelsResponse {
 }
 
 export async function getHuggingFaceModels(): Promise<HuggingFaceModelsResponse> {
-	// Fetch models as ModelRecord
-	const modelRecord = await fetchModels()
+	try {
+		// First, trigger the fetch to populate cache
+		await fetchModels()
 
-	// Convert ModelRecord to array of HuggingFaceModel for backward compatibility
-	// Note: This is a temporary solution to maintain API compatibility
-	const models: HuggingFaceModel[] = Object.entries(modelRecord).map(([id, info]) => ({
-		id,
-		object: "model" as const,
-		created: Date.now(),
-		owned_by: "huggingface",
-		providers: [
-			{
-				provider: "auto",
-				status: "live" as const,
-				context_length: info.contextWindow,
-				pricing:
-					info.inputPrice && info.outputPrice
-						? {
-								input: info.inputPrice,
-								output: info.outputPrice,
-							}
-						: undefined,
+		// Get the raw models from cache
+		const cachedRawModels = getCachedRawHuggingFaceModels()
+
+		if (cachedRawModels) {
+			return {
+				models: cachedRawModels,
+				cached: true,
+				timestamp: Date.now(),
+			}
+		}
+
+		// If no cached raw models, fetch directly from API
+		const response = await axios.get(HUGGINGFACE_API_URL, {
+			headers: {
+				"Upgrade-Insecure-Requests": "1",
+				"Sec-Fetch-Dest": "document",
+				"Sec-Fetch-Mode": "navigate",
+				"Sec-Fetch-Site": "none",
+				"Sec-Fetch-User": "?1",
+				Priority: "u=0, i",
+				Pragma: "no-cache",
+				"Cache-Control": "no-cache",
 			},
-		],
-	}))
+			timeout: 10000,
+		})
+
+		const models = response.data?.data || []
 
-	return {
-		models,
-		cached: false,
-		timestamp: Date.now(),
+		return {
+			models,
+			cached: false,
+			timestamp: Date.now(),
+		}
+	} catch (error) {
+		console.error("Failed to get HuggingFace models:", error)
+		return {
+			models: [],
+			cached: false,
+			timestamp: Date.now(),
+		}
 	}
 }

src/api/providers/fetchers/huggingface.ts

@@ -80,6 +80,7 @@ type HuggingFaceApiResponse = z.infer<typeof huggingFaceApiResponseSchema>
  */
 interface CacheEntry {
 	data: ModelRecord
+	rawModels?: HuggingFaceModel[]
 	timestamp: number
 }
 
@@ -100,6 +101,9 @@ function parseHuggingFaceModel(model: HuggingFaceModel, provider?: HuggingFacePr
 
 	const pricing = provider?.pricing || model.providers.find((p) => p.pricing)?.pricing
 
+	// Include provider name in description if specific provider is given
+	const description = provider ? `${model.id} via ${provider.provider}` : `${model.id} via HuggingFace`
+
 	return {
 		maxTokens: Math.min(contextLength, HUGGINGFACE_DEFAULT_MAX_TOKENS),
 		contextWindow: contextLength,
@@ -108,7 +112,7 @@ function parseHuggingFaceModel(model: HuggingFaceModel, provider?: HuggingFacePr
 		supportsComputerUse: false,
 		inputPrice: pricing?.input,
 		outputPrice: pricing?.output,
-		description: `${model.id} via HuggingFace`,
+		description,
 	}
 }
 
@@ -123,15 +127,12 @@ export async function getHuggingFaceModels(): Promise<ModelRecord> {
 
 	// Check cache
 	if (cache && now - cache.timestamp < HUGGINGFACE_CACHE_DURATION) {
-		console.log("Using cached HuggingFace models")
 		return cache.data
 	}
 
 	const models: ModelRecord = {}
 
 	try {
-		console.log("Fetching HuggingFace models from API...")
-
 		const response = await axios.get<HuggingFaceApiResponse>(HUGGINGFACE_API_URL, {
 			headers: {
 				"Upgrade-Insecure-Requests": "1",
@@ -159,34 +160,31 @@ export async function getHuggingFaceModels(): Promise<ModelRecord> {
 			// Add the base model
 			models[model.id] = parseHuggingFaceModel(model)
 
-			// Add provider-specific variants if they have different capabilities
+			// Add provider-specific variants for all live providers
 			for (const provider of model.providers) {
 				if (provider.status === "live") {
 					const providerKey = `${model.id}:${provider.provider}`
 					const providerModel = parseHuggingFaceModel(model, provider)
 
-					// Only add provider variant if it differs from base model
-					if (JSON.stringify(models[model.id]) !== JSON.stringify(providerModel)) {
-						models[providerKey] = providerModel
-					}
+					// Always add provider variants to show all available providers
+					models[providerKey] = providerModel
 				}
 			}
 		}
 
 		// Update cache
 		cache = {
 			data: models,
+			rawModels: validModels,
 			timestamp: now,
 		}
 
-		console.log(`Fetched ${Object.keys(models).length} HuggingFace models`)
 		return models
 	} catch (error) {
 		console.error("Error fetching HuggingFace models:", error)
 
 		// Return cached data if available
 		if (cache) {
-			console.log("Using stale cached data due to fetch error")
 			return cache.data
 		}
 
@@ -216,6 +214,13 @@ export function getCachedHuggingFaceModels(): ModelRecord | null {
 	return cache?.data || null
 }
 
+/**
+ * Get cached raw models for UI display
+ */
+export function getCachedRawHuggingFaceModels(): HuggingFaceModel[] | null {
+	return cache?.rawModels || null
+}
+
 /**
  * Clear the cache
  */