Update app.py

app.py

@@ -16,6 +16,13 @@ from typing import Optional, Tuple, List, Dict, Any
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 GROQ_API = "https://api.groq.com/openai/v1/chat/completions"
 
+# Models to try in order of preference
+GROQ_MODELS = [
+    "llama-3.3-70b-versatile",
+    "llama-3.1-70b-versatile", 
+    "mixtral-8x7b-32768",
+]
+
 # ==========================================
 # TOOLS
 # ==========================================
@@ -355,41 +362,62 @@ def search_wikipedia(query: str) -> str:
 # GROQ LLM
 # ==========================================
 
-def ask_groq(messages: List[Dict], groq_key: str, max_tokens: int = 400, temperature: float = 0.1) -> str:
-    """Send request to Groq API with retries."""
-    for attempt in range(3):
-        try:
-            resp = requests.post(
-                GROQ_API,
-                headers={
-                    "Authorization": f"Bearer {groq_key}",
-                    "Content-Type": "application/json"
-                },
-                json={
-                    "model": "llama-3.3-70b-versatile",
-                    "messages": messages,
-                    "temperature": temperature,
-                    "max_tokens": max_tokens,
-                },
-                timeout=30,
-            )
-            
-            if resp.status_code == 200:
-                return resp.json()["choices"][0]["message"]["content"].strip()
-            elif resp.status_code == 429:
-                wait_time = 5 * (attempt + 1)
-                print(f"    ⏳ Rate limited, waiting {wait_time}s...")
-                time.sleep(wait_time)
-            else:
-                print(f"    ⚠️ Groq API error: {resp.status_code} - {resp.text[:200]}")
-                time.sleep(2)
-        except requests.exceptions.Timeout:
-            print(f"    ⚠️ Groq timeout (attempt {attempt + 1})")
-            time.sleep(3)
-        except Exception as e:
-            print(f"    ⚠️ Groq error: {e}")
-            time.sleep(2)
+def ask_groq(messages: List[Dict], groq_key: str, max_tokens: int = 400, temperature: float = 0.1, model: str = None) -> str:
+    """Send request to Groq API with retries and model fallback."""
+    if not groq_key:
+        print("    ❌ GROQ_API_KEY is empty!")
+        return ""
     
+    # Use specified model or try all models in order
+    models_to_try = [model] if model else GROQ_MODELS
+    
+    for model_name in models_to_try:
+        for attempt in range(2):  # 2 attempts per model
+            try:
+                resp = requests.post(
+                    GROQ_API,
+                    headers={
+                        "Authorization": f"Bearer {groq_key}",
+                        "Content-Type": "application/json"
+                    },
+                    json={
+                        "model": model_name,
+                        "messages": messages,
+                        "temperature": temperature,
+                        "max_tokens": max_tokens,
+                    },
+                    timeout=60,
+                )
+                
+                if resp.status_code == 200:
+                    result = resp.json()
+                    content = result.get("choices", [{}])[0].get("message", {}).get("content", "")
+                    if content:
+                        print(f"    📝 [{model_name}] Response: {content[:80]}...")
+                        return content.strip()
+                    else:
+                        print(f"    ⚠️ [{model_name}] Empty content")
+                elif resp.status_code == 429:
+                    wait_time = 10 * (attempt + 1)
+                    print(f"    ⏳ [{model_name}] Rate limited, waiting {wait_time}s...")
+                    time.sleep(wait_time)
+                elif resp.status_code == 401:
+                    print(f"    ❌ Groq API key invalid!")
+                    return ""
+                elif resp.status_code == 404:
+                    print(f"    ⚠️ Model {model_name} not found, trying next...")
+                    break  # Try next model
+                else:
+                    print(f"    ⚠️ [{model_name}] HTTP {resp.status_code}: {resp.text[:200]}")
+                    time.sleep(3)
+            except requests.exceptions.Timeout:
+                print(f"    ⚠️ [{model_name}] Timeout (attempt {attempt + 1}/2)")
+                time.sleep(5)
+            except Exception as e:
+                print(f"    ⚠️ [{model_name}] Error: {type(e).__name__}: {e}")
+                time.sleep(3)
+    
+    print("    ❌ All Groq attempts failed")
     return ""
 
 
@@ -637,7 +665,9 @@ def solve_question(question: str, task_id: str, groq_key: str) -> str:
         ]
     
     answer_raw = ask_groq(messages, groq_key, max_tokens=400, temperature=0.1)
-    answer = clean_answer(answer_raw)
+    answer = clean_answer(answer_raw) if answer_raw else ""
+    
+    print(f"    📤 Raw: '{answer_raw[:100] if answer_raw else '[empty]'}' -> Clean: '{answer}'")
     
     # If answer isn't valid, try again with different approach
     if not is_valid_answer(answer):
@@ -649,13 +679,22 @@ def solve_question(question: str, task_id: str, groq_key: str) -> str:
             {"role": "user", "content": f"Using your knowledge, answer this question with ONLY the final answer:\n\n{processed_q}"}
         ]
         answer_raw = ask_groq(retry_messages, groq_key, max_tokens=400, temperature=0.2)
-        answer = clean_answer(answer_raw)
-    
-    # Final validation
-    if not is_valid_answer(answer):
+        answer = clean_answer(answer_raw) if answer_raw else ""
+        print(f"    📤 Retry raw: '{answer_raw[:100] if answer_raw else '[empty]'}' -> Clean: '{answer}'")
+    
+    # If still no valid answer but we have some text, use it anyway
+    if not answer or len(answer.strip()) == 0:
+        # If we got something from Groq, try to extract any content
+        if answer_raw and len(answer_raw.strip()) > 0:
+            answer = answer_raw.strip().split('\n')[0].strip()
+            print(f"    🔄 Using raw first line: '{answer}'")
+    
+    # Final validation - only return "I don't know" as absolute last resort
+    if not answer or len(answer.strip()) == 0:
         answer = "I don't know"
+        print(f"    ❌ No answer found, defaulting to 'I don't know'")
     
-    print(f"    ✅ Answer: {answer}")
+    print(f"    ✅ Final Answer: {answer}")
     return answer
 
 
@@ -679,8 +718,19 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     print(f"\n{'='*60}")
     print(f"👤 User: {username}")
     print(f"🤖 Agent: GAIA Agent v4")
+    print(f"🔑 API Key: {groq_key[:8]}...{groq_key[-4:]}")
     print(f"{'='*60}")
     
+    # Test Groq API connectivity first
+    print("\n🔍 Testing Groq API connectivity...")
+    test_response = ask_groq(
+        [{"role": "user", "content": "Say 'OK' and nothing else."}],
+        groq_key, max_tokens=10, temperature=0.0
+    )
+    if not test_response:
+        return "❌ Groq API test failed! Check your API key and try again.", None
+    print(f"✅ Groq API test passed: '{test_response}'")
+    
     # Fetch questions
     try:
         resp = requests.get(f"{DEFAULT_API_URL}/questions", timeout=20)
@@ -723,8 +773,8 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             "Answer": answer
         })
         
-        # Rate limit protection
-        time.sleep(1.5)
+        # Rate limit protection - increase delay between questions
+        time.sleep(2.5)
     
     if not answers:
         return "❌ Nessuna risposta generata.", pd.DataFrame(results)