Update app.py

app.py

@@ -7,221 +7,248 @@ import pandas as pd
 from google import genai
 from google.genai import types
 
-# --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 
+# ── Answer cleaner ────────────────────────────────────────────────────
 def clean_answer(text: str) -> str:
+    if not text:
+        return "N/A"
     text = text.strip()
-    text = re.sub(r"^```[a-zA-Z]*\n?", "", text)
-    text = re.sub(r"```$", "", text)
+    # Strip code fences
+    text = re.sub(r"^```[a-zA-Z]*\s*", "", text)
+    text = re.sub(r"\s*```$", "", text)
+    # Strip label prefixes
     for prefix in [
-        "Final Answer:", "Answer:", "FINAL ANSWER:", "ANSWER:",
-        "The answer is:", "The final answer is:",
+        "final answer:", "answer:", "the answer is:",
+        "the final answer is:", "result:",
     ]:
-        if text.lower().startswith(prefix.lower()):
+        if text.lower().startswith(prefix):
             text = text[len(prefix):].strip()
-    text = " ".join(text.split())
-    return text[:200]
-
+            break
+    return " ".join(text.split())[:200]
+
+
+def extract_text(response) -> str:
+    """
+    Pull the final answer text out of a GenerateContentResponse.
+    When google_search is used, Gemini emits:
+      [search_tool_use part] → [search_tool_result part] → [text part]
+    We want the LAST text part.
+    """
+    text_parts = []
+    try:
+        for candidate in response.candidates:
+            for part in candidate.content.parts:
+                if hasattr(part, "text") and part.text and part.text.strip():
+                    text_parts.append(part.text.strip())
+    except Exception as e:
+        print(f"  [extract_text error] {e}")
 
-class BasicAgent:
-    SYSTEM = """You are an expert AI assistant solving GAIA benchmark questions.
+    if text_parts:
+        return text_parts[-1]   # last text part = final answer after search
 
-RULES:
-1. Think step-by-step before answering.
-2. Use Google Search for any factual, date, or real-world questions.
-3. Use code execution for arithmetic, unit conversions, or data processing.
-4. Return ONLY the final answer — no explanation, no preamble.
-5. Numbers: no commas, correct decimals (42 not 42.0 if whole).
-6. Lists: comma-separated, alphabetical unless told otherwise.
-7. Yes/no questions: answer exactly "yes" or "no" (lowercase).
-8. Be as concise as possible while being complete and correct.
-"""
+    # Last resort: .text property
+    try:
+        return response.text.strip()
+    except Exception:
+        return ""
 
-    VERIFY = """Question: {question}
 
-Proposed answer: {answer}
+# ── Agent ─────────────────────────────────────────────────────────────
+class BasicAgent:
 
-Review:
-- Is it factually correct?
-- Is it in the exact requested format?
-- Is it as concise as possible?
+    SYSTEM = """You are an expert assistant solving GAIA benchmark questions.
 
-If correct, repeat it unchanged.
-If wrong or mis-formatted, return ONLY the corrected answer.
+STRICT OUTPUT FORMAT:
+- Return ONLY the final answer. No explanation. No preamble. No punctuation tail.
+- Numbers: digits only, no commas (e.g. 1234567 not 1,234,567). Omit trailing .0.
+- Lists: comma-separated, in the order the question requests (default: alphabetical).
+- Yes/no questions: exactly "yes" or "no" (lowercase).
+- Dates: use the format the question implies (e.g. "January 5, 1990" or "1990-01-05").
+- Names: full name unless the question asks for first/last only.
 
-Return ONLY the final answer — nothing else."""
+Use Google Search whenever you need facts, dates, counts, or external data.
+Think carefully step by step, then output ONLY the answer."""
 
     def __init__(self):
         api_key = os.getenv("GEMINI_API_KEY")
         if not api_key:
-            raise EnvironmentError("GEMINI_API_KEY environment variable is not set.")
+            raise EnvironmentError("GEMINI_API_KEY not set.")
 
-        self.client = genai.Client(api_key=api_key)
-        self.model_id = "gemini-2.5-flash-preview-04-17"
+        self.client   = genai.Client(api_key=api_key)
+        self.model_id = "gemini-2.0-flash"          # stable + has search grounding
 
-        self.tools = [
-            types.Tool(google_search=types.GoogleSearch()),
-            types.Tool(code_execution=types.ToolCodeExecution()),
-        ]
+        # Search-enabled config (separate from code-exec to avoid conflicts)
+        self.search_config = types.GenerateContentConfig(
+            system_instruction=self.SYSTEM,
+            tools=[types.Tool(google_search=types.GoogleSearch())],
+            temperature=0,      # deterministic
+        )
 
-        self.main_config = types.GenerateContentConfig(
+        # Code-execution config (for maths / data questions)
+        self.code_config = types.GenerateContentConfig(
             system_instruction=self.SYSTEM,
-            tools=self.tools,
+            tools=[types.Tool(code_execution=types.ToolCodeExecution())],
+            temperature=0,
         )
 
-        self.verify_config = types.GenerateContentConfig(
-            system_instruction="You are a precise answer validator. Return ONLY the final answer.",
+        # Plain config for the verify pass
+        self.plain_config = types.GenerateContentConfig(
+            system_instruction=(
+                "You are a strict answer formatter. "
+                "Return ONLY the final answer, no explanation."
+            ),
+            temperature=0,
         )
 
-        print("✅ BasicAgent (gemini-2.5-flash + Search + Code) initialised.")
+        print(f"✅ BasicAgent ready  (model={self.model_id})")
 
+    # ------------------------------------------------------------------
     def __call__(self, question: str) -> str:
         try:
             return self._run(question)
         except Exception as exc:
-            print(f"[AGENT ERROR] {exc}\n{traceback.format_exc()}")
+            print(f"  [FATAL] {exc}\n{traceback.format_exc()}")
             return "N/A"
 
     def _run(self, question: str) -> str:
-        resp1 = self.client.models.generate_content(
-            model=self.model_id,
-            contents=question,
-            config=self.main_config,
-        )
-        ans1 = clean_answer(self._extract_text(resp1))
-        print(f"  [Pass 1] {ans1!r}")
+        q_lower = question.lower()
 
-        if not ans1 or ans1 == "N/A":
-            return "N/A"
+        # Route to code-exec for pure maths / counting questions
+        needs_code = any(kw in q_lower for kw in [
+            "calculate", "compute", "how many", "sum of", "average",
+            "percentage", "multiply", "divide", "convert",
+        ])
+        config = self.code_config if needs_code else self.search_config
 
-        verify_prompt = self.VERIFY.format(question=question, answer=ans1)
-        resp2 = self.client.models.generate_content(
-            model=self.model_id,
-            contents=verify_prompt,
-            config=self.verify_config,
+        resp  = self.client.models.generate_content(
+            model=self.model_id, contents=question, config=config,
         )
-        ans2 = clean_answer(self._extract_text(resp2))
-        print(f"  [Pass 2] {ans2!r}")
-
-        return ans2 if ans2 else ans1
-
-    @staticmethod
-    def _extract_text(response) -> str:
-        try:
-            if response.text:
-                return response.text.strip()
-        except Exception:
-            pass
-        texts = []
-        for candidate in response.candidates:
-            for part in candidate.content.parts:
-                if hasattr(part, "text") and part.text:
-                    texts.append(part.text.strip())
-        return " ".join(texts).strip() or "N/A"
-
-
+        raw   = extract_text(resp)
+        ans   = clean_answer(raw)
+        print(f"  [raw]  {raw[:120]!r}")
+        print(f"  [ans]  {ans!r}")
+
+        if not ans or ans == "N/A":
+            # Fallback: try plain (no tools)
+            resp2 = self.client.models.generate_content(
+                model=self.model_id, contents=question, config=self.plain_config,
+            )
+            ans = clean_answer(extract_text(resp2))
+            print(f"  [fallback] {ans!r}")
+
+        return ans or "N/A"
+
+
+# ── Debug helper – fetch & show first N answers without submitting ────
+def debug_first_n(n: int = 3):
+    """Call this from __main__ to see raw vs cleaned answers."""
+    agent = BasicAgent()
+    resp  = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15)
+    questions = resp.json()[:n]
+    for item in questions:
+        print("\n" + "="*60)
+        print(f"Q: {item['question']}")
+        ans = agent(item["question"])
+        print(f"FINAL SUBMITTED: {ans!r}")
+
+
+# ── Gradio runner ─────────────────────────────────────────────────────
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    space_id = os.getenv("SPACE_ID")
-
     if not profile:
         return "Please log in to Hugging Face first.", None
 
-    username = profile.username
-    print(f"Logged in as: {username}")
-
-    questions_url = f"{DEFAULT_API_URL}/questions"
-    submit_url    = f"{DEFAULT_API_URL}/submit"
+    username  = profile.username
+    space_id  = os.getenv("SPACE_ID", "")
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
 
     try:
         agent = BasicAgent()
     except Exception as e:
         return f"Error initialising agent: {e}", None
 
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "unknown"
-
-    print(f"Fetching questions from {questions_url} …")
+    # Fetch questions
     try:
-        resp = requests.get(questions_url, timeout=15)
-        resp.raise_for_status()
-        questions_data = resp.json()
-        if not questions_data:
-            return "Question list is empty.", None
+        r = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15)
+        r.raise_for_status()
+        questions_data = r.json()
         print(f"Fetched {len(questions_data)} questions.")
     except Exception as e:
         return f"Error fetching questions: {e}", None
 
-    results_log     = []
-    answers_payload = []
+    results_log, answers_payload = [], []
 
     for item in questions_data:
-        task_id       = item.get("task_id")
-        question_text = item.get("question")
-        if not task_id or question_text is None:
+        task_id = item.get("task_id")
+        q_text  = item.get("question")
+        if not task_id or q_text is None:
             continue
 
-        print(f"\n[{task_id}] {question_text[:120]}")
+        print(f"\n── {task_id} ──")
+        print(f"Q: {q_text[:150]}")
         try:
-            answer = agent(question_text)
+            answer = agent(q_text)
         except Exception as e:
-            answer = f"AGENT ERROR: {e}"
+            answer = "N/A"
+            print(f"  ERROR: {e}")
 
-        print(f"  → {answer!r}")
         answers_payload.append({"task_id": task_id, "submitted_answer": answer})
-        results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": answer})
+        results_log.append({
+            "Task ID": task_id,
+            "Question": q_text[:120],
+            "Submitted Answer": answer,
+        })
 
     if not answers_payload:
-        return "Agent produced no answers.", pd.DataFrame(results_log)
-
-    submission_data = {
-        "username":   username.strip(),
-        "agent_code": agent_code,
-        "answers":    answers_payload,
-    }
-    print(f"\nSubmitting {len(answers_payload)} answers …")
+        return "No answers produced.", pd.DataFrame(results_log)
+
+    # Submit
     try:
-        resp = requests.post(submit_url, json=submission_data, timeout=120)
-        resp.raise_for_status()
-        result = resp.json()
-        final_status = (
+        r = requests.post(
+            f"{DEFAULT_API_URL}/submit",
+            json={"username": username, "agent_code": agent_code, "answers": answers_payload},
+            timeout=120,
+        )
+        r.raise_for_status()
+        res = r.json()
+        status = (
             f"✅ Submission successful!\n"
-            f"User:  {result.get('username')}\n"
-            f"Score: {result.get('score', 'N/A')}% "
-            f"({result.get('correct_count', '?')}/{result.get('total_attempted', '?')} correct)\n"
-            f"Msg:   {result.get('message', '')}"
+            f"User:  {res.get('username')}\n"
+            f"Score: {res.get('score', 'N/A')}% "
+            f"({res.get('correct_count', '?')}/{res.get('total_attempted', '?')} correct)\n"
+            f"Msg:   {res.get('message', '')}"
         )
     except requests.exceptions.HTTPError as e:
-        final_status = f"❌ HTTP {e.response.status_code}: {e.response.text[:500]}"
+        status = f"❌ HTTP {e.response.status_code}: {e.response.text[:300]}"
     except Exception as e:
-        final_status = f"❌ Submission error: {e}"
+        status = f"❌ Error: {e}"
 
-    print(final_status)
-    return final_status, pd.DataFrame(results_log)
+    print(status)
+    return status, pd.DataFrame(results_log)
 
 
+# ── UI ────────────────────────────────────────────────────────────────
 with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Agent Evaluation Runner")
+    gr.Markdown("# GAIA Agent — Gemini 2.0 Flash + Search")
     gr.Markdown(
-        """
-        **How to use:**
-        1. Set `GEMINI_API_KEY` in your Space secrets.
-        2. Log in with the button below.
-        3. Click **Run Evaluation** — the agent answers all questions and submits automatically.
-        """
+        "1. Set `GEMINI_API_KEY` in Space secrets.\n"
+        "2. Log in below.\n"
+        "3. Click **Run Evaluation**."
     )
     gr.LoginButton()
-    run_btn     = gr.Button("▶ Run Evaluation & Submit All Answers", variant="primary")
-    status_out  = gr.Textbox(label="Status / Result", lines=6, interactive=False)
-    results_tbl = gr.DataFrame(label="Questions & Agent Answers", wrap=True)
-
-    run_btn.click(fn=run_and_submit_all, outputs=[status_out, results_tbl])
+    btn     = gr.Button("▶ Run Evaluation & Submit All Answers", variant="primary")
+    status  = gr.Textbox(label="Status", lines=6, interactive=False)
+    table   = gr.DataFrame(label="Answers", wrap=True)
+    btn.click(fn=run_and_submit_all, outputs=[status, table])
 
 
 if __name__ == "__main__":
-    print("\n" + "─" * 50)
-    for var in ("SPACE_HOST", "SPACE_ID", "GEMINI_API_KEY"):
-        val = os.getenv(var)
-        print(f"{'✅' if val else '⚠️ '} {var}: {'set' if val else 'NOT SET'}")
-    print("─" * 50 + "\n")
+    print("\n── Env check ──")
+    for v in ("SPACE_HOST", "SPACE_ID", "GEMINI_API_KEY"):
+        print(f"  {v}: {'SET' if os.getenv(v) else 'MISSING'}")
+
+    # Uncomment to preview first 3 answers before submitting:
+    # debug_first_n(3)
+
     demo.launch(debug=True, share=False)