Update app.py

app.py

@@ -1,6 +1,7 @@
 import os
 import re
 import json
+import time
 import tempfile
 from pathlib import Path
 
@@ -16,36 +17,36 @@ except ImportError:
     from smolagents import OpenAIModel as OpenAIServerModel
 
 
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 
 @tool
 def get_task_file_url(task_id: str) -> str:
     """
-    Returns the file URL for a GAIA task.
+    Build the file URL for a GAIA task.
 
     Args:
-        task_id: The task id.
+        task_id: The task identifier.
 
     Returns:
-        The download URL for the attached task file.
+        The download URL for the task file.
     """
-    return f"{DEFAULT_API_URL}/files/{task_id}"
+    return f"{API_URL}/files/{task_id}"
 
 
 @tool
 def download_file(url: str) -> str:
     """
-    Downloads a file from a URL and saves it to a temporary path.
+    Download a remote file to a temporary local path.
 
     Args:
-        url: The URL of the file.
+        url: The remote file URL.
 
     Returns:
         The local temporary file path.
     """
     suffix = ""
-    match = re.search(r"\.([a-zA-Z0-9]{1,6})(?:\?|$)", url)
+    match = re.search(r"\.([a-zA-Z0-9]{1,8})(?:\?|$)", url)
     if match:
         suffix = "." + match.group(1)
 
@@ -64,38 +65,40 @@ def download_file(url: str) -> str:
 @tool
 def inspect_local_text_file(path: str, max_chars: int = 12000) -> str:
     """
-    Reads a local text-like file and returns a preview.
+    Read a local text-like file and return a preview.
 
     Args:
         path: The local file path.
         max_chars: Maximum number of characters to return.
 
     Returns:
-        A text preview of the file contents.
+        A text preview.
     """
     p = Path(path)
     try:
         return p.read_text(encoding="utf-8", errors="ignore")[:max_chars]
     except Exception as e:
-        return f"Could not read text file: {e}"
+        return f"READ_ERROR: {e}"
 
 
 @tool
 def analyze_spreadsheet(path: str, instruction: str) -> str:
     """
-    Loads a spreadsheet and returns schema and preview information.
+    Load a spreadsheet and return a compact JSON summary.
 
     Args:
         path: The local spreadsheet path.
-        instruction: The analysis goal.
+        instruction: What the agent wants to determine.
 
     Returns:
-        A JSON string containing spreadsheet metadata and preview rows.
+        A JSON summary of the sheet.
     """
     p = Path(path)
-    if p.suffix.lower() in [".csv", ".tsv"]:
-        sep = "\t" if p.suffix.lower() == ".tsv" else ","
-        df = pd.read_csv(path, sep=sep)
+
+    if p.suffix.lower() == ".csv":
+        df = pd.read_csv(path)
+    elif p.suffix.lower() == ".tsv":
+        df = pd.read_csv(path, sep="\t")
     else:
         df = pd.read_excel(path)
 
@@ -104,7 +107,7 @@ def analyze_spreadsheet(path: str, instruction: str) -> str:
         "shape": list(df.shape),
         "columns": list(df.columns),
         "dtypes": {c: str(t) for c, t in df.dtypes.items()},
-        "head": df.head(8).to_dict(orient="records"),
+        "head": df.head(10).to_dict(orient="records"),
         "numeric_column_sums": {
             c: float(df[c].sum())
             for c in df.select_dtypes(include="number").columns
@@ -116,10 +119,10 @@ def analyze_spreadsheet(path: str, instruction: str) -> str:
 @tool
 def python_compute(code: str) -> str:
     """
-    Executes short Python code for local calculations.
+    Execute short Python code for local calculations.
 
     Args:
-        code: Python code that must assign the final output to a variable named result.
+        code: Python code that must assign the final value to a variable named result.
 
     Returns:
         The string form of result.
@@ -135,36 +138,57 @@ def python_compute(code: str) -> str:
     exec(code, global_vars, local_vars)
 
     if "result" not in local_vars:
-        return "ERROR: code did not define variable `result`"
+        return "ERROR_NO_RESULT"
     return str(local_vars["result"])
 
 
-def clean_final_answer(text: str) -> str:
+def clean_final_answer(text) -> str:
     if text is None:
         return ""
 
     answer = str(text).strip()
-    answer = re.sub(r"^```.*?\n", "", answer, flags=re.DOTALL)
     answer = answer.replace("```", "").strip()
-    answer = re.sub(r"^(FINAL ANSWER\s*:\s*)", "", answer, flags=re.IGNORECASE)
-    answer = re.sub(r"^(Answer\s*:\s*)", "", answer, flags=re.IGNORECASE)
+    answer = re.sub(r"^FINAL ANSWER\s*:\s*", "", answer, flags=re.IGNORECASE)
+    answer = re.sub(r"^Answer\s*:\s*", "", answer, flags=re.IGNORECASE)
     answer = re.sub(r"[ \t]+", " ", answer).strip()
-    return answer
+
+    if answer.startswith('"') and answer.endswith('"') and len(answer) >= 2:
+        answer = answer[1:-1].strip()
+
+    bad_markers = [
+        "incorrect api key",
+        "openai_api_key",
+        "error in generating model output",
+        "traceback",
+        "exception",
+        "401",
+        "403",
+        "429",
+    ]
+    lowered = answer.lower()
+    if any(marker in lowered for marker in bad_markers):
+        return ""
+
+    lines = [line.strip() for line in answer.splitlines() if line.strip()]
+    if len(lines) > 1:
+        answer = lines[-1]
+
+    return answer.strip()
 
 
 SYSTEM_PROMPT = """
 You are solving GAIA-style benchmark tasks.
 
 Rules:
-- You may use tools.
-- If the task includes a file, use the file tools.
-- If the task asks for a web fact, search and verify.
-- For spreadsheet/math/data tasks, compute carefully.
-- For exact-match scoring, your final output must be ONLY the answer and nothing else.
-- Do not include explanations in your final answer.
-- Do not include the words FINAL ANSWER.
-- When a question requests a format, obey that exact format.
-- If the answer is numeric and the prompt requests decimals, format correctly.
+- Return only the final answer, with no explanation.
+- Respect the exact format requested in the question.
+- If a file is needed, use get_task_file_url(task_id), then download_file(url).
+- If the file is text-like, inspect it.
+- If it is a spreadsheet, analyze it.
+- Use web search when needed.
+- Double-check dates, numbers, names, and formatting.
+- Never output tool errors or debugging text as the final answer.
+- If you are uncertain, reason carefully and still output one best final answer only.
 """
 
 
@@ -172,7 +196,7 @@ class GaiaAgent:
     def __init__(self):
         api_key = os.environ.get("OPENAI_API_KEY")
         if not api_key:
-            raise ValueError("Missing OPENAI_API_KEY secret.")
+            raise ValueError("OPENAI_API_KEY is missing")
 
         model_id = os.environ.get("OPENAI_MODEL", "gpt-4o-mini")
 
@@ -180,8 +204,6 @@ class GaiaAgent:
             model_id=model_id,
             api_base="https://api.openai.com/v1",
             api_key=api_key,
-            temperature=0.1,
-            max_tokens=1200,
         )
 
         try:
@@ -197,7 +219,7 @@ class GaiaAgent:
                     python_compute,
                 ],
                 add_base_tools=False,
-                max_steps=10,
+                max_steps=12,
                 instructions=SYSTEM_PROMPT,
             )
         except TypeError:
@@ -213,118 +235,122 @@ class GaiaAgent:
                     python_compute,
                 ],
                 add_base_tools=False,
-                max_steps=10,
+                max_steps=12,
             )
 
-    def __call__(self, question: str, task_id: str) -> str:
-        full_prompt = f"""
+    def answer_task(self, question: str, task_id: str, retries: int = 2) -> str:
+        prompt = f"""
 Task ID: {task_id}
 
 Question:
 {question}
 
 Important:
-- If there is an attached file, its URL can be obtained using get_task_file_url(task_id).
 - Return only the final answer.
+- If a file is required, use get_task_file_url(task_id).
 """
-        raw = self.agent.run(full_prompt)
-        return clean_final_answer(raw)
 
+        last_error = None
 
-def run_and_submit_all(profile: gr.OAuthProfile | None):
-    space_id = os.getenv("SPACE_ID")
+        for attempt in range(retries + 1):
+            try:
+                raw = self.agent.run(prompt)
+                cleaned = clean_final_answer(raw)
+                if cleaned:
+                    return cleaned
+            except Exception as e:
+                last_error = str(e)
+
+            if attempt < retries:
+                time.sleep(1.5)
+
+        if last_error:
+            print(f"Task {task_id} failed: {last_error}")
+        return ""
 
-    if not profile:
-        return "Please Login to Hugging Face first.", None
 
-    username = profile.username
-    api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
+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
 
     try:
         agent = GaiaAgent()
     except Exception as e:
         return f"Error initializing agent: {e}", None
 
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-
     try:
-        r = requests.get(questions_url, timeout=30)
+        r = requests.get(f"{API_URL}/questions", timeout=30)
         r.raise_for_status()
-        questions_data = r.json()
+        questions = r.json()
     except Exception as e:
         return f"Error fetching questions: {e}", None
 
-    results_log = []
-    answers_payload = []
+    answers = []
+    rows = []
 
-    for item in questions_data:
-        task_id = item.get("task_id")
-        question_text = item.get("question")
+    for item in questions:
+        task_id = item.get("task_id", "")
+        question = item.get("question", "")
 
-        if not task_id or not question_text:
+        if not task_id or not question:
             continue
 
-        try:
-            submitted_answer = agent(question_text, task_id)
-        except Exception as e:
-            submitted_answer = f"ERROR: {e}"
+        answer = agent.answer_task(question, task_id, retries=2)
 
-        answers_payload.append(
+        answers.append(
             {
                 "task_id": task_id,
-                "submitted_answer": submitted_answer,
+                "submitted_answer": answer,
             }
         )
 
-        results_log.append(
+        rows.append(
             {
                 "Task ID": task_id,
-                "Question": question_text,
-                "Submitted Answer": submitted_answer,
+                "Question": question,
+                "Submitted Answer": answer,
             }
         )
 
-    submission_data = {
-        "username": username.strip(),
-        "agent_code": agent_code,
-        "answers": answers_payload,
+    payload = {
+        "username": profile.username.strip(),
+        "agent_code": f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "",
+        "answers": answers,
     }
 
     try:
-        r = requests.post(submit_url, json=submission_data, timeout=120)
+        r = requests.post(f"{API_URL}/submit", json=payload, timeout=180)
         r.raise_for_status()
-        result_data = r.json()
-
-        final_status = (
-            f"Submission Successful!\n"
-            f"User: {result_data.get('username')}\n"
-            f"Overall Score: {result_data.get('score', 'N/A')}% "
-            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
-            f"Message: {result_data.get('message', '')}"
+        result = r.json()
+
+        status = (
+            f"Submission successful.\n"
+            f"User: {result.get('username')}\n"
+            f"Score: {result.get('score', 'N/A')}%\n"
+            f"Correct: {result.get('correct_count', '?')}/{result.get('total_attempted', '?')}\n"
+            f"Message: {result.get('message', '')}"
         )
-        return final_status, pd.DataFrame(results_log)
-
+        return status, pd.DataFrame(rows)
     except Exception as e:
-        return f"Submission Failed: {e}", pd.DataFrame(results_log)
+        return f"Submission failed: {e}", pd.DataFrame(rows)
 
 
 with gr.Blocks() as demo:
     gr.Markdown("# Unit 4 GAIA Agent")
     gr.Markdown(
         """
-1. Add your API key as a Space Secret: `OPENAI_API_KEY`
-2. Optional: set `OPENAI_MODEL`
-3. Login with Hugging Face
-4. Click run
+1. Add `OPENAI_API_KEY` as a Space secret
+2. Optionally add `OPENAI_MODEL`
+3. Log in with Hugging Face
+4. Run evaluation
 """
     )
 
     gr.LoginButton()
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=6, interactive=False)
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+    run_button = gr.Button("Run Evaluation and Submit")
+    status_output = gr.Textbox(label="Status", lines=8, interactive=False)
+    results_table = gr.DataFrame(label="Task Results", wrap=True)
 
     run_button.click(
         fn=run_and_submit_all,