Keep both Groq + HF models, remove rate-limited Groq models, unify model selection UI without backend labels

backend/app/groq_client.py

@@ -2,20 +2,47 @@ import json
 import os
 import random
 import math
+import httpx
 from groq import AsyncGroq
 from dotenv import load_dotenv
 
 load_dotenv()
 
 _GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
-_client = AsyncGroq(api_key=_GROQ_API_KEY) if _GROQ_API_KEY else None
+_HF_API_TOKEN = os.environ.get("HF_API_TOKEN")
+_groq_client = AsyncGroq(api_key=_GROQ_API_KEY) if _GROQ_API_KEY else None
+_HF_API_BASE = "https://api-inference.huggingface.co/models"
 
-DEFAULT_DECISION_MODEL = "llama-3.1-8b-instant"
 MAX_AGENT_SPEED = 80
 
+# Premium Groq models (high-token limits, no rate limits for these)
+GROQ_PREMIUM_MODELS = [
+    "mixtral-8x7b-32768",
+    "llama2-70b-4096",
+]
+
+# Open-source models available via HF Inference API (unlimited calls)
+HF_MODELS = [
+    "mistralai/Mistral-7B-Instruct-v0.2",
+    "NousResearch/Nous-Hermes-2-Mistral-7B-DPO",
+    "meta-llama/Llama-2-7b-chat-hf",
+    "google/flan-t5-large",
+]
+
 
 def is_ready():
-    return _client is not None
+    """Check if we have at least one backend available."""
+    return _groq_client is not None or _HF_API_TOKEN is not None
+
+
+def _is_groq_model(model_id: str) -> bool:
+    """Check if model is a Groq premium model."""
+    return model_id in GROQ_PREMIUM_MODELS
+
+
+def _is_hf_model(model_id: str) -> bool:
+    """Check if model is a HF model."""
+    return model_id in HF_MODELS
 
 
 def _build_fire_state_summary(agent, fire, all_agents) -> str:
@@ -47,10 +74,10 @@ def _build_fire_state_summary(agent, fire, all_agents) -> str:
 
 async def generate_fire_decision(agent, fire, water_sources, other_agents, bounds, recent_radio=None) -> dict:
     """
-    Fire scenario decision system.
+    Fire scenario decision system supporting both Groq and HF models.
     Actions: search_water, collect_water, extinguish_fire, escape, vote_for_leader
     """
-    if not _client:
+    if not is_ready():
         return _fallback_escape(agent, fire)
 
     dist_to_fire = math.dist((agent.x, agent.y), (fire.x, fire.y))
@@ -63,6 +90,7 @@ async def generate_fire_decision(agent, fire, water_sources, other_agents, bound
 
     coalition_leader = next((a.model_name for a in other_agents if a.is_leader), None)
     dist_to_water_display = f"{dist_to_water:.0f}px" if dist_to_water is not None else "unknown"
+    
     system_prompt = f"""You are {agent.model_name}, an AI model in a critical wildfire survival scenario.
 
 THE SCENARIO:
@@ -94,9 +122,6 @@ CHAT STYLE:
 - Keep it to one short sentence, playful or supportive, but still mission-focused.
 - Avoid repetitive template phrases.
 
-OUTPUT FORMAT - return ONLY valid JSON:
-{{"action": "<search_water|collect_water|extinguish_fire|escape|vote_for_leader>", "vote_for": "<model_name if voting, else null>", "message": "<full English sentence>", "reasoning": "<one sentence>"}}
-
 CURRENT STATE:
 Your position: ({agent.x}, {agent.y})
 Fire position: ({fire.x}, {fire.y})
@@ -113,20 +138,60 @@ RECENT RADIO CHAT:
 
 {state_summary}
 
-What do you do?"""
+Respond with ONLY valid JSON on a single line (no markdown, no code block):
+{{"action": "<search_water|collect_water|extinguish_fire|escape|vote_for_leader>", "vote_for": null, "message": "<sentence>", "reasoning": "<sentence>"}}"""
 
     try:
-        completion = await _client.chat.completions.create(
-            model=DEFAULT_DECISION_MODEL,
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": "Make your decision."}
-            ],
-            response_format={"type": "json_object"},
-            max_tokens=150,
-            timeout=3.0
-        )
-        decision = json.loads(completion.choices[0].message.content)
+        if _is_groq_model(agent.model_name) and _groq_client:
+            # Use Groq for premium models
+            completion = await _groq_client.chat.completions.create(
+                model=agent.model_name,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": "Make your decision."}
+                ],
+                response_format={"type": "json_object"},
+                max_tokens=150,
+                timeout=3.0
+            )
+            decision = json.loads(completion.choices[0].message.content)
+        elif _is_hf_model(agent.model_name) and _HF_API_TOKEN:
+            # Use HF Inference API for open-source models
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                response = await client.post(
+                    f"{_HF_API_BASE}/{agent.model_name}",
+                    headers={"Authorization": f"Bearer {_HF_API_TOKEN}"},
+                    json={
+                        "inputs": system_prompt,
+                        "parameters": {
+                            "max_new_tokens": 200,
+                            "temperature": 0.7,
+                            "top_p": 0.9,
+                        }
+                    }
+                )
+                response.raise_for_status()
+                data = response.json()
+                
+                if isinstance(data, list) and len(data) > 0:
+                    text = data[0].get("generated_text", "")
+                else:
+                    text = data.get("generated_text", "")
+                
+                text = text[len(system_prompt):].strip() if text.startswith(system_prompt) else text
+                
+                try:
+                    json_start = text.find('{')
+                    json_end = text.rfind('}') + 1
+                    if json_start >= 0 and json_end > json_start:
+                        json_str = text[json_start:json_end]
+                        decision = json.loads(json_str)
+                    else:
+                        decision = {}
+                except json.JSONDecodeError:
+                    decision = {}
+        else:
+            return _fallback_escape(agent, fire)
         
         action = decision.get("action", "escape")
         if action not in ["search_water", "collect_water", "extinguish_fire", "escape", "vote_for_leader"]:
@@ -144,7 +209,7 @@ What do you do?"""
             "reasoning": decision.get("reasoning", "Survival and teamwork.")
         }
     except Exception as e:
-        print(f"Error calling groq for {agent.model_name}: {e}")
+        print(f"Error calling inference for {agent.model_name}: {e}")
         return _fallback_escape(agent, fire)
 
 
@@ -159,3 +224,4 @@ def _fallback_escape(agent, fire) -> dict:
         "vote_for": None,
         "reasoning": "Fallback: survive."
     }
+

backend/app/hf_spaces.py

@@ -1,108 +1,65 @@
 """
-HuggingFace Spaces integration for discovering and querying open-source models.
+Model registry for unified inference API (Groq + HF Spaces).
+All models are returned without backend categorization.
 """
 import os
-import httpx
-from typing import Optional
+from . import groq_client
 
-HF_API_TOKEN = os.environ.get("HUGGINGFACE_API_TOKEN", "")
+HF_API_TOKEN = os.environ.get("HF_API_TOKEN", "")
 
-# Curated list of verified open-source models on HF Spaces that work reliably
-KNOWN_SPACES_MODELS = [
+# All available models from both backends (unified list)
+ALL_MODELS = [
+    # Premium Groq models (unlimited calls, high-quality)
     {
-        "id": "tiiuae/Falcon-7B",
-        "name": "Falcon-7B",
-        "space_url": "https://huggingface.co/spaces/tiiuae/falcon-chat",
-        "description": "7B parameter open model",
+        "id": "mixtral-8x7b-32768",
+        "name": "Mixtral 8x7B",
+        "description": "High-performance 8x7B mixture of experts model",
     },
     {
-        "id": "meta-llama/Llama-2-7b",
-        "name": "Llama-2-7B",
-        "space_url": "https://huggingface.co/spaces/meta-llama/Llama-2-7b-chat",
-        "description": "Meta's 7B model",
+        "id": "llama2-70b-4096",
+        "name": "Llama 2 70B",
+        "description": "Meta's large 70B instruction-tuned model",
     },
+    # Open-source HF models (unlimited calls, free)
     {
-        "id": "mistralai/Mistral-7B",
-        "name": "Mistral-7B",
-        "space_url": "https://huggingface.co/spaces/mistralai/Mistral-7B-Instruct-v0.1",
-        "description": "Mistral's 7B model",
+        "id": "mistralai/Mistral-7B-Instruct-v0.2",
+        "name": "Mistral 7B Instruct",
+        "description": "Fast, reliable 7B instruction-tuned model",
     },
     {
-        "id": "HuggingFaceH4/zephyr-7b",
-        "name": "Zephyr-7B",
-        "space_url": "https://huggingface.co/spaces/HuggingFaceH4/zephyr-7b-beta",
-        "description": "Zephyr 7B fine-tuned model",
+        "id": "NousResearch/Nous-Hermes-2-Mistral-7B-DPO",
+        "name": "Nous Hermes 2",
+        "description": "High-quality 7B with DPO training",
     },
     {
-        "id": "teknium/OpenHermes-2.5-Mistral-7B",
-        "name": "OpenHermes-7B",
-        "space_url": "https://huggingface.co/spaces/teknium/OpenHermes-2.5-Mistral-7B",
-        "description": "OpenHermes instruction-tuned 7B",
+        "id": "meta-llama/Llama-2-7b-chat-hf",
+        "name": "Llama 2 7B Chat",
+        "description": "Meta's Llama 2 7B chat variant",
+    },
+    {
+        "id": "google/flan-t5-large",
+        "name": "FLAN-T5 Large",
+        "description": "Google's instruction-tuned T5 model",
     },
-]
-
-# Groq models (built-in)
-GROQ_MODELS = [
-    {"id": "llama-3.1-8b-instant", "name": "Llama 3.1 8B", "backend": "groq"},
-    {"id": "llama-3.1-70b-versatile", "name": "Llama 3.1 70B", "backend": "groq"},
-    {"id": "mixtral-8x7b-32768", "name": "Mixtral 8x7B", "backend": "groq"},
-    {"id": "gemma-7b-it", "name": "Gemma 7B", "backend": "groq"},
 ]
 
 
 async def get_available_models() -> dict:
     """
-    Get list of available models from Groq and HF Spaces.
-    Returns both for frontend model selector.
+    Get unified list of all available models (Groq + HF).
+    Frontend receives models without backend categorization.
     """
     return {
-        "groq_models": GROQ_MODELS,
-        "hf_spaces_models": KNOWN_SPACES_MODELS,
-        "total": len(GROQ_MODELS) + len(KNOWN_SPACES_MODELS),
+        "models": ALL_MODELS,
+        "total": len(ALL_MODELS),
     }
 
 
-async def query_hf_space_model(model_id: str, prompt: str) -> Optional[str]:
-    """
-    Query a model on HuggingFace Spaces.
-    This is a fallback if we want to use HF spaces directly.
-    Note: HF spaces may have rate limits and require authentication.
-    """
-    if not HF_API_TOKEN:
-        return None
-
-    # Try to find the space URL for this model
-    space = next((m for m in KNOWN_SPACES_MODELS if m["id"] == model_id), None)
-    if not space:
-        return None
-
-    try:
-        # This would hit the HF inference API
-        # For now, we focus on Groq which is more reliable
-        async with httpx.AsyncClient(timeout=5.0) as client:
-            headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
-            response = await client.post(
-                "https://api-inference.huggingface.co/models/" + model_id,
-                json={"inputs": prompt},
-                headers=headers,
-            )
-            if response.status_code == 200:
-                result = response.json()
-                # Extract generated text from response
-                if isinstance(result, list) and len(result) > 0:
-                    return result[0].get("generated_text", "")
-    except Exception as e:
-        print(f"Error querying HF space {model_id}: {e}")
-
-    return None
-
-
 def get_model_display_name(model_id: str) -> str:
-    """Get a clean display name from model ID."""
-    # Try to find in known models
-    for model in GROQ_MODELS + KNOWN_SPACES_MODELS:
+    """Get clean display name from model ID."""
+    for model in ALL_MODELS:
         if model["id"] == model_id:
             return model["name"]
-
-    # Fallback: clean up the ID
+    # Fallback
     return model_id.split("/")[-1].split("-")[0].capitalize()
+

backend/requirements.txt

@@ -5,4 +5,3 @@ groq>=0.11.0
 httpx>=0.27.0
 python-dotenv>=1.0.0
 pydantic>=2.7.0
-

frontend/components/ModelSelector.tsx

@@ -6,8 +6,7 @@ import { getAvailableModels } from "../lib/api"
 interface Model {
   id: string
   name: string
-  backend?: string
-  tag?: string
+  description?: string
 }
 
 export default function ModelSelector({
@@ -28,30 +27,17 @@ export default function ModelSelector({
       try {
         const data = await getAvailableModels()
         
-        // Combine Groq and HF Spaces models
-        const combined: Model[] = [
-          ...(data.groq_models || []).map((m: any) => ({
-            id: m.id,
-            name: m.name,
-            backend: "groq",
-            tag: "groq"
-          })),
-          ...(data.hf_spaces_models || []).map((m: any) => ({
-            id: m.id,
-            name: m.name,
-            backend: "hf",
-            tag: "hf-spaces"
-          }))
-        ]
-        setAllModels(combined)
+        // Use unified model list (no backend categorization)
+        const modelList = data.models || data.hf_models || data.groq_models || []
+        setAllModels(modelList)
       } catch (err) {
         console.error("Failed to fetch models:", err)
-        // Fallback to default Groq models
+        // Fallback to default models
         setAllModels([
-          { id: "llama-3.1-8b-instant", name: "Llama 3.1 8B", backend: "groq", tag: "groq" },
-          { id: "llama-3.1-70b-versatile", name: "Llama 3.1 70B", backend: "groq", tag: "groq" },
-          { id: "mixtral-8x7b-32768", name: "Mixtral 8x7B", backend: "groq", tag: "groq" },
-          { id: "gemma-7b-it", name: "Gemma 7B", backend: "groq", tag: "groq" },
+          { id: "mixtral-8x7b-32768", name: "Mixtral 8x7B", description: "High-performance model" },
+          { id: "llama2-70b-4096", name: "Llama 2 70B", description: "Large instruction-tuned model" },
+          { id: "mistralai/Mistral-7B-Instruct-v0.2", name: "Mistral 7B", description: "Fast 7B model" },
+          { id: "NousResearch/Nous-Hermes-2-Mistral-7B-DPO", name: "Nous Hermes 2", description: "High-quality model" },
         ])
       } finally {
         setLoading(false)
@@ -71,74 +57,34 @@ export default function ModelSelector({
     )
   }
 
-  // Group models by backend
-  const groqModels = allModels.filter(m => m.backend === "groq")
-  const hfModels = allModels.filter(m => m.backend === "hf")
-
   return (
     <div className="px-4 py-6 space-y-6">
       <div>
         <h3 className="text-[10px] font-mono text-white/30 uppercase tracking-[0.2em] mb-4">
           Select Survivors ({models.length}/6)
         </h3>
-        <div className="space-y-4">
-          {/* Groq Models */}
-          {groqModels.length > 0 && (
-            <div>
-              <h4 className="text-[8px] font-mono text-white/40 uppercase tracking-[0.15em] mb-2">Groq API</h4>
-              <div className="grid grid-cols-1 gap-1.5">
-                {groqModels.map((m) => {
-                  const isSelected = models.includes(m.id)
-                  return (
-                    <button
-                      key={m.id}
-                      onClick={() => isSelected ? onRemove(m.id) : onAdd(m.id)}
-                      disabled={full && !isSelected}
-                      className={`flex items-center justify-between px-3 py-2 rounded-lg border transition-all duration-200 ${
-                        isSelected 
-                          ? 'bg-blue-500/10 border-blue-500/30' 
-                          : 'border-transparent hover:bg-white/5 opacity-60 hover:opacity-100'
-                      } ${full && !isSelected ? 'cursor-not-allowed opacity-20' : ''}`}
-                    >
-                      <span className="font-mono text-xs text-white/90">{m.name}</span>
-                      <span className="text-[8px] font-mono uppercase px-1.5 py-0.5 rounded bg-blue-500/20 text-blue-400">
-                        Groq
-                      </span>
-                    </button>
-                  )
-                })}
-              </div>
-            </div>
-          )}
-
-          {/* HF Spaces Models */}
-          {hfModels.length > 0 && (
-            <div>
-              <h4 className="text-[8px] font-mono text-white/40 uppercase tracking-[0.15em] mb-2">HuggingFace Spaces</h4>
-              <div className="grid grid-cols-1 gap-1.5">
-                {hfModels.map((m) => {
-                  const isSelected = models.includes(m.id)
-                  return (
-                    <button
-                      key={m.id}
-                      onClick={() => isSelected ? onRemove(m.id) : onAdd(m.id)}
-                      disabled={full && !isSelected}
-                      className={`flex items-center justify-between px-3 py-2 rounded-lg border transition-all duration-200 ${
-                        isSelected 
-                          ? 'bg-purple-500/10 border-purple-500/30' 
-                          : 'border-transparent hover:bg-white/5 opacity-60 hover:opacity-100'
-                      } ${full && !isSelected ? 'cursor-not-allowed opacity-20' : ''}`}
-                    >
-                      <span className="font-mono text-xs text-white/90">{m.name}</span>
-                      <span className="text-[8px] font-mono uppercase px-1.5 py-0.5 rounded bg-purple-500/20 text-purple-400">
-                        HF
-                      </span>
-                    </button>
-                  )
-                })}
-              </div>
-            </div>
-          )}
+        <div className="space-y-1.5">
+          {allModels.map((m) => {
+            const isSelected = models.includes(m.id)
+            return (
+              <button
+                key={m.id}
+                onClick={() => isSelected ? onRemove(m.id) : onAdd(m.id)}
+                disabled={full && !isSelected}
+                className={`w-full flex items-center justify-between px-3 py-2 rounded-lg border transition-all duration-200 ${
+                  isSelected 
+                    ? 'bg-white/10 border-white/20' 
+                    : 'border-transparent hover:bg-white/5 opacity-60 hover:opacity-100'
+                } ${full && !isSelected ? 'cursor-not-allowed opacity-20' : ''}`}
+                title={m.description}
+              >
+                <span className="font-mono text-xs text-white/90 text-left flex-1">{m.name}</span>
+                <span className={`text-[8px] font-mono ml-2 px-2 py-1 rounded ${isSelected ? 'bg-white/20 text-white' : 'text-white/30'}`}>
+                  {isSelected ? "✓" : "○"}
+                </span>
+              </button>
+            )
+          })}
         </div>
       </div>
       
@@ -150,7 +96,7 @@ export default function ModelSelector({
               return (
                 <div key={id} className="flex items-center gap-2 bg-white/5 px-2 py-1 rounded border border-white/10">
                   <span className="font-mono text-[10px] text-white/50">
-                    {model?.name || id}
+                    {model?.name || id.split("/").pop()}
                   </span>
                   <button onClick={() => onRemove(id)} className="text-white/20 hover:text-white">✕</button>
                 </div>
@@ -162,3 +108,4 @@ export default function ModelSelector({
     </div>
   )
 }
+