Update app.py

app.py

@@ -1,157 +1,235 @@
-import os
-import gradio as gr
-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"
 
-# --- Free GAIA Agent Definition ---
-class EnhancedGAIAAgentFree:
+
+# =========================
+# GAIA OPTIMIZED AGENT
+# =========================
+class GAIAAgent:
     """
-    GAIA Agent for free HuggingFace models.
-    Returns 'unknown' for images, videos, code, Excel, or unsupported questions.
+    GAIA benchmark agent – chat-only, nscale-safe, exact answers.
+
     """
 
     def __init__(self):
-        print("🚀 GAIAAgent initializing... (FREE version)")
-        hf_token = os.getenv("HF_TOKEN") or os.getenv("HUGGING_FACE_HUB_TOKEN")
+        print("🚀 GAIAAgent initializing...")
+
+        hf_token = (
+            os.getenv("HF_TOKEN")
+            or os.getenv("HUGGING_FACE_HUB_TOKEN")
+            or os.getenv("HF_API_TOKEN")
+        )
+
         if not hf_token:
-            print("⚠️ HF_TOKEN not found! Add it to Space secrets.")
-            self.client = None
-            self.model = None
-            return
+            raise RuntimeError("HF_TOKEN not found in Space secrets")
+
+
+
 
         self.client = InferenceClient(token=hf_token)
-        self.model = "TheBloke/guanaco-7B-GPTQ"  # free model
+
+        # ✅ SAFE MODELS (chat-only)
+        self.model = "meta-llama/Meta-Llama-3-8B-Instruct"
+        # Alternative:
+        # self.model = "Qwen/Qwen2.5-7B-Instruct"
+
         print(f"✅ Model loaded: {self.model}")
 
     def __call__(self, question: str) -> str:
-        """
-        Answer a question or return 'unknown' for unsupported content.
-        """
+        print(f"\nQ: {question[:120]}")
+
+
+
+
+
+
+
+
+
+
         try:
-            # Filter unsupported content
-            unsupported = ["image", "video", "file", "attached", "excel", "python code", "chart", "csv"]
-            if any(word in question.lower() for word in unsupported):
-                return "unknown"
-
-            # Very short or empty questions
-            if not question.strip() or len(question.strip()) < 5:
-                return "unknown"
-
-            # Free text generation for supported questions
-            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,
-                prompt=prompt,
-                max_new_tokens=128,
-                temperature=0.1,
-                do_sample=False,
-                return_full_text=False
-            )
-
-            # Clean response
-            answer = response.strip() if response else "unknown"
+            answer = self._chat_answer(question)
+            print(f"A: {answer}")
             return answer
-
         except Exception as e:
             print(f"❌ Agent error: {e}")
-            return "unknown"
+            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(
+            model=self.model,
+            messages=messages,
+            max_tokens=256,
+            temperature=0.0,
+
+
+        )
+
+        if not response or not response.choices:
+            return "Unable to determine answer"
+
+        raw = response.choices[0].message.content.strip()
+        return self._clean_answer(raw)
+
+    def _clean_answer(self, text: str) -> str:
+        """
+        GAIA-safe cleaning: minimal, no hallucinated trimming.
+        """
+        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()
+
+        return text
+
+
 
 
+
+
+
+# =========================
+# RUN + SUBMIT
+# =========================
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """
-    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
+
+    if not profile:
+        return "Please login with Hugging Face.", None
+
+    username = profile.username
+    print(f"👤 User: {username}")
+
+
 
     questions_url = f"{DEFAULT_API_URL}/questions"
     submit_url = f"{DEFAULT_API_URL}/submit"
 
-    # Instantiate Agent
-    agent = EnhancedGAIAAgentFree()
-    if not agent.client or not agent.model:
-        return "⚠️ HF_TOKEN not found! Add it to Space secrets.", None
+    agent = GAIAAgent()
 
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
 
-    # 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
 
-    results_log = []
+
+    # Fetch questions
+    questions = requests.get(questions_url, timeout=15).json()
+
     answers_payload = []
+    results_log = []
+
+    for idx, item in enumerate(questions):
+        task_id = item["task_id"]
+        question = item["question"]
+
+
+
+
+
+        print(f"\n[{idx+1}/{len(questions)}] {task_id}")
+        answer = agent(question)
+
+        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,
-            "Question": question_text[:80] + "..." if len(question_text) > 80 else question_text,
-            "Answer": submitted_answer[:80] + "..." if len(submitted_answer) > 80 else submitted_answer
+            "Answer": answer
+
         })
 
-    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)
+    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)
+
+
+
+# =========================
+# 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(
         """
-**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.
-"""
+        ✅ Chat-only  
+        ✅ nscale-safe  
+        ✅ GAIA-optimized  
+        
+        **Steps**
+        1. Add `HF_TOKEN` to Space secrets  
+        2. Login with Hugging Face  
+        3. Click Run  
+        """
     )
 
     gr.LoginButton()
-    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_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.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if __name__ == "__main__":
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True)