Update app.py

app.py

@@ -4,196 +4,171 @@ import requests
 import pandas as pd
 import re
 from huggingface_hub import InferenceClient
+import time
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-
-# =========================
-# GAIA OPTIMIZED AGENT
-# =========================
-class GAIAAgent:
+# --- Free GAIA Agent Definition ---
+class EnhancedGAIAAgentFree:
     """
-    GAIA benchmark agent – chat-only, nscale-safe, exact answers.
+    GAIA Agent for free HuggingFace models.
+    Avoids PRO credits and multi-modal content.
     """
 
     def __init__(self):
-        print("🚀 GAIAAgent initializing...")
-
-        hf_token = (
-            os.getenv("HF_TOKEN")
-            or os.getenv("HUGGING_FACE_HUB_TOKEN")
-            or os.getenv("HF_API_TOKEN")
-        )
-
+        print("🚀 GAIAAgent initializing... (FREE version)")
+        
+        hf_token = os.getenv("HF_TOKEN") or os.getenv("HUGGING_FACE_HUB_TOKEN")
         if not hf_token:
-            raise RuntimeError("HF_TOKEN not found in Space secrets")
+            print("⚠️ HF_TOKEN not found! Add it to Space secrets.")
+            self.client = None
+            self.model = None
+            return
 
         self.client = InferenceClient(token=hf_token)
-
-        # ✅ SAFE MODELS (chat-only)
-        self.model = "meta-llama/Meta-Llama-3-8B-Instruct"
-        # Alternative:
-        # self.model = "Qwen/Qwen2.5-7B-Instruct"
-
+        self.model = "TheBloke/guanaco-7B-GPTQ"  # free HF model
         print(f"✅ Model loaded: {self.model}")
 
     def __call__(self, question: str) -> str:
-        print(f"\nQ: {question[:120]}")
+        """
+        Answer a question with free LLM.
+        """
+        print(f"\nQ: {question[:150]}...")
+        if not self.client or not self.model:
+            return "ERROR: HF_TOKEN not configured"
+
+        # Skip unsupported questions
+        if any(word in question.lower() for word in ["image", "video", "file", "attached", "excel", "code"]):
+            return "unknown"
 
         try:
-            answer = self._chat_answer(question)
-            print(f"A: {answer}")
+            answer = self._generate_answer(question)
+            print(f"A: {answer[:150]}...")
             return answer
         except Exception as e:
             print(f"❌ Agent error: {e}")
-            return "Unable to determine answer"
-
-    def _chat_answer(self, question: str) -> str:
-        messages = [
-            {
-                "role": "system",
-                "content": (
-                    "You are an expert GAIA benchmark solver.\n"
-                    "Answer EXACTLY what is asked.\n"
-                    "Return ONLY the final answer.\n"
-                    "No explanations, no prefixes, no formatting."
-                )
-            },
-            {
-                "role": "user",
-                "content": question
-            }
-        ]
-
-        response = self.client.chat_completion(
+            return "unknown"
+
+    def _generate_answer(self, question: str) -> str:
+        """
+        Free LLM answer generator with safe prompt.
+        """
+        prompt = f"""
+You are an expert for GAIA benchmark.
+Answer concisely. ONLY provide the final answer.
+If you cannot determine the answer, write "unknown".
+Question: {question}
+FINAL ANSWER:"""
+
+        response = self.client.text_generation(
             model=self.model,
-            messages=messages,
-            max_tokens=256,
-            temperature=0.0,
+            prompt=prompt,
+            max_new_tokens=128,
+            temperature=0.1,
+            do_sample=False,
+            return_full_text=False
         )
-
-        if not response or not response.choices:
-            return "Unable to determine answer"
-
-        raw = response.choices[0].message.content.strip()
-        return self._clean_answer(raw)
+        return self._clean_answer(response)
 
     def _clean_answer(self, text: str) -> str:
         """
-        GAIA-safe cleaning: minimal, no hallucinated trimming.
+        Keep only the final answer text.
         """
-        text = text.strip()
-
-        # Remove common junk if model disobeys
-        bad_prefixes = [
-            "answer:",
-            "final answer:",
-            "the answer is",
-            "result:"
-        ]
-
-        for p in bad_prefixes:
-            if text.lower().startswith(p):
-                text = text[len(p):].strip()
-
-        # If multi-line, keep first meaningful line
-        if "\n" in text:
-            text = text.split("\n")[0].strip()
-
-        # GAIA prefers concise
-        if len(text.split()) > 12:
-            # keep last sentence
-            parts = re.split(r"[.!?]", text)
-            text = parts[-2].strip() if len(parts) > 1 else parts[0].strip()
+        if not text:
+            return "unknown"
 
-        return text
+        # Remove prefixes
+        prefixes = ["Answer:", "The answer is", "A:", "FINAL ANSWER:", "Result:"]
+        for p in prefixes:
+            if text.lower().startswith(p.lower()):
+                text = text[len(p):].strip()
+        return text.strip() if text.strip() else "unknown"
 
 
-# =========================
-# RUN + SUBMIT
-# =========================
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-
-    if not profile:
-        return "Please login with Hugging Face.", None
-
-    username = profile.username
-    print(f"👤 User: {username}")
+    """
+    Run agent on all questions and submit results.
+    """
+    space_id = os.getenv("SPACE_ID")
+    if profile:
+        username = profile.username
+    else:
+        return "Please login to HuggingFace.", None
 
     questions_url = f"{DEFAULT_API_URL}/questions"
     submit_url = f"{DEFAULT_API_URL}/submit"
 
-    agent = GAIAAgent()
+    # Instantiate Agent
+    agent = EnhancedGAIAAgentFree()
+    if not agent.client or not agent.model:
+        return "⚠️ HF_TOKEN not found! Add it to Space secrets.", None
 
-    # Fetch questions
-    questions = requests.get(questions_url, timeout=15).json()
-
-    answers_payload = []
-    results_log = []
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
 
-    for idx, item in enumerate(questions):
-        task_id = item["task_id"]
-        question = item["question"]
+    # Fetch Questions
+    try:
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+    except Exception as e:
+        return f"Error fetching questions: {e}", None
 
-        print(f"\n[{idx+1}/{len(questions)}] {task_id}")
-        answer = agent(question)
+    results_log = []
+    answers_payload = []
 
-        answers_payload.append({
-            "task_id": task_id,
-            "submitted_answer": answer
-        })
+    for idx, item in enumerate(questions_data):
+        task_id = item.get("task_id")
+        question_text = item.get("question")
+        if not task_id or question_text is None:
+            continue
 
+        submitted_answer = agent(question_text)
+        answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
         results_log.append({
             "Task ID": task_id,
-            "Answer": answer
+            "Question": question_text[:80] + "..." if len(question_text) > 80 else question_text,
+            "Answer": submitted_answer[:80] + "..." if len(submitted_answer) > 80 else submitted_answer
         })
 
-    submission = {
-        "username": username,
-        "agent_code": f"https://huggingface.co/spaces/{os.getenv('SPACE_ID')}",
-        "answers": answers_payload
-    }
-
-    response = requests.post(submit_url, json=submission, timeout=60)
-    result = response.json()
-
-    status = (
-        f"🎉 Submission Successful\n\n"
-        f"Score: {result.get('score')}%\n"
-        f"Correct: {result.get('correct_count')}/{result.get('total_attempted')}"
-    )
-
-    return status, pd.DataFrame(results_log)
-
+    if not answers_payload:
+        return "No answers generated.", pd.DataFrame(results_log)
+
+    # Submit Results
+    submission_data = {"username": username, "agent_code": agent_code, "answers": answers_payload}
+    try:
+        response = requests.post(submit_url, json=submission_data, timeout=60)
+        response.raise_for_status()
+        result_data = response.json()
+        final_status = (
+            f"🎉 Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
+        )
+        return final_status, pd.DataFrame(results_log)
+    except Exception as e:
+        return f"Submission failed: {e}", pd.DataFrame(results_log)
 
-# =========================
-# GRADIO UI
-# =========================
-with gr.Blocks(title="GAIA Agent") as demo:
-    gr.Markdown("# 🤗 GAIA Benchmark Agent (Fixed)")
 
+# --- Gradio Interface ---
+with gr.Blocks(title="GAIA Agent Evaluation (Free)") as demo:
+    gr.Markdown("# 🤗 GAIA Benchmark Agent (Free)")
     gr.Markdown(
         """
-        ✅ Chat-only  
-        ✅ nscale-safe  
-        ✅ GAIA-optimized  
-        
-        **Steps**
-        1. Add `HF_TOKEN` to Space secrets  
-        2. Login with Hugging Face  
-        3. Click Run  
-        """
+**Setup Required:**
+1. Add HF_TOKEN to Space secrets (Settings → Variables and secrets)
+2. Get free token at: https://huggingface.co/settings/tokens (Read access)
+3. Login with HuggingFace, then click Run Evaluation.
+"""
     )
 
     gr.LoginButton()
-    run_btn = gr.Button("🚀 Run Evaluation", variant="primary")
-
-    status = gr.Textbox(label="Status", lines=6)
-    table = gr.DataFrame(label="Results")
-
-    run_btn.click(run_and_submit_all, outputs=[status, table])
+    run_button = gr.Button("🚀 Run Evaluation", variant="primary", size="lg")
+    status_output = gr.Textbox(label="Status", lines=8, interactive=False)
+    results_table = gr.DataFrame(label="Results", wrap=True)
 
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if __name__ == "__main__":
-    demo.launch(debug=True)
+    demo.launch(debug=True, share=False)