Update app.py

app.py

@@ -1,109 +1,114 @@
 import os
 import json
 import re
-
 import gradio as gr
-import pandas as pd
+import requests
+import spaces
 
 from huggingface_hub import InferenceClient
 
 from prompt import SYSTEM_PROMPT
-
-from tools import (
-    execute_tool,
-    download_file
-)
-
-import requests
+from tools import execute_tool, download_file
 
 
 # ============================================================
 # CONFIG
 # ============================================================
 
-SCORING_API = (
-    "https://agents-course-unit4-scoring.hf.space"
-)
+SCORING_API = "https://agents-course-unit4-scoring.hf.space"
 
-MODEL_ID = os.getenv(
-    "TEXT_MODEL",
-    "Qwen/Qwen2.5-72B-Instruct"
-)
+MODEL_ID = "Qwen/Qwen2.5-72B-Instruct"
 
 HF_TOKEN = os.getenv("HF_TOKEN")
 
-MAX_STEPS = 10
-
-
 client = InferenceClient(
+    model=MODEL_ID,
     token=HF_TOKEN
 )
 
 
+# ============================================================
+# ZERO GPU STARTUP PROBE
+# ============================================================
+
+# ZeroGPU requires at least one @spaces.GPU function to exist
+# when the Space starts.
+#
+# We DO NOT call this function.
+# Therefore it consumes no GPU quota.
+
+@spaces.GPU(duration=1)
+def zerogpu_probe():
+    return "ok"
+
+
 # ============================================================
 # ANSWER CLEANING
 # ============================================================
 
 def clean_answer(answer):
+    if answer is None:
+        return ""
 
     answer = str(answer).strip()
 
-    # Remove markdown code fences.
-    answer = re.sub(
-        r"^```(?:text)?\s*",
-        "",
-        answer,
-        flags=re.IGNORECASE
-    )
+    answer = answer.replace("```", "")
+    answer = answer.replace("FINAL ANSWER:", "")
+    answer = answer.replace("Final Answer:", "")
+    answer = answer.replace("THE ANSWER IS:", "")
+    answer = answer.replace("The answer is:", "")
 
-    answer = re.sub(
-        r"\s*```$",
-        "",
-        answer
-    )
+    answer = answer.strip()
 
-    # Remove accidental prefixes.
-    answer = re.sub(
-        r"^\s*FINAL ANSWER\s*:?\s*",
-        "",
-        answer,
-        flags=re.IGNORECASE
-    )
+    return answer
 
-    answer = re.sub(
-        r"^\s*THE ANSWER IS\s*:?\s*",
-        "",
-        answer,
-        flags=re.IGNORECASE
-    )
 
-    return answer.strip()
+# ============================================================
+# JSON EXTRACTION
+# ============================================================
+
+def extract_json(text):
+
+    text = text.strip()
+
+    # Direct JSON
+    try:
+        return json.loads(text)
+    except:
+        pass
+
+    # Find JSON object inside model response
+    match = re.search(r"\{.*\}", text, re.DOTALL)
+
+    if match:
+        try:
+            return json.loads(match.group(0))
+        except:
+            pass
+
+    return None
 
 
 # ============================================================
 # MODEL CALL
 # ============================================================
 
-def call_model(messages):
+def ask_model(messages):
 
-    response = client.chat.completions.create(
-        model=MODEL_ID,
+    response = client.chat_completion(
         messages=messages,
         max_tokens=1200,
-        temperature=0
+        temperature=0.1
     )
 
     return response.choices[0].message.content
 
 
 # ============================================================
-# AGENT
+# SOLVE ONE GAIA QUESTION
 # ============================================================
 
-def solve_question(
-    task_id,
-    question
-):
+def solve_question(task_id, question):
 
     messages = [
         {
@@ -115,237 +120,195 @@ def solve_question(
             "content": (
                 f"GAIA TASK ID: {task_id}\n\n"
                 f"QUESTION:\n{question}\n\n"
-                "Solve this question."
+                "Solve this task completely. "
+                "Use tools whenever necessary."
             )
         }
     ]
 
-    # Cache downloaded attachment path if needed.
-    attachment_path = None
+    current_file = None
 
-    for step in range(MAX_STEPS):
-
-        print(
-            f"    Agent step {step + 1}/{MAX_STEPS}"
-        )
-
-        raw = call_model(messages)
-
-        print(
-            f"    Model: {raw[:500]}"
-        )
-
-        # ----------------------------------------------------
-        # Parse JSON
-        # ----------------------------------------------------
+    for step in range(12):
 
         try:
+            response = ask_model(messages)
 
-            decision = json.loads(
-                raw.strip()
-            )
+        except Exception as e:
+            return f"ERROR: model request failed: {e}"
 
-        except json.JSONDecodeError:
+        parsed = extract_json(response)
 
-            # Sometimes models put JSON inside markdown.
-            match = re.search(
-                r"\{.*\}",
-                raw,
-                re.DOTALL
-            )
+        if parsed is None:
 
-            if match:
+            # Give model another chance to follow JSON format
+            messages.append(
+                {
+                    "role": "assistant",
+                    "content": response
+                }
+            )
 
-                try:
-                    decision = json.loads(
-                        match.group(0)
+            messages.append(
+                {
+                    "role": "user",
+                    "content": (
+                        "Your previous response was not valid JSON. "
+                        "Respond ONLY with either:\n"
+                        '{"action":"tool","tool":"TOOL_NAME","input":"..."}\n'
+                        "or:\n"
+                        '{"action":"final","answer":"..."}'
                     )
-
-                except json.JSONDecodeError:
-                    decision = None
-
-            else:
-                decision = None
-
-        # ----------------------------------------------------
-        # Invalid model response
-        # ----------------------------------------------------
-
-        if not decision:
-
-            messages.append({
-                "role": "assistant",
-                "content": raw
-            })
-
-            messages.append({
-                "role": "user",
-                "content": (
-                    "Your response was not valid JSON.\n"
-                    "Return ONLY one of these formats:\n\n"
-                    '{"action":"tool","tool":"TOOL_NAME","input":"..."}\n'
-                    '{"action":"final","answer":"..."}'
-                )
-            })
+                }
+            )
 
             continue
 
+        action = parsed.get("action")
+
         # ----------------------------------------------------
         # FINAL ANSWER
         # ----------------------------------------------------
 
-        if decision.get("action") == "final":
+        if action == "final":
 
-            answer = decision.get(
-                "answer",
-                ""
-            )
+            answer = parsed.get("answer", "")
 
-            return clean_answer(
-                answer
-            )
+            return clean_answer(answer)
 
         # ----------------------------------------------------
         # TOOL CALL
         # ----------------------------------------------------
 
-        if decision.get("action") == "tool":
+        if action == "tool":
 
-            tool_name = decision.get(
-                "tool"
-            )
-
-            tool_input = decision.get(
-                "input",
-                ""
-            )
+            tool_name = parsed.get("tool")
+            tool_input = parsed.get("input", "")
 
-            # -----------------------------------------------
-            # Automatically download attachment
-            # -----------------------------------------------
-
-            if (
-                tool_name == "download_file"
-                and not attachment_path
-            ):
-
-                attachment_path = (
-                    download_file(task_id)
+            if not tool_name:
+                messages.append(
+                    {
+                        "role": "user",
+                        "content": "You must provide a tool name."
+                    }
                 )
+                continue
 
-                tool_result = (
-                    f"FILE_PATH:\n"
-                    f"{attachment_path}\n\n"
-                    f"The file has been downloaded."
-                )
+            try:
 
-            # -----------------------------------------------
-            # Inspect downloaded file
-            # -----------------------------------------------
+                # ------------------------------------------------
+                # Download file
+                # ------------------------------------------------
 
-            elif (
-                tool_name == "inspect_file"
-                and tool_input == "CURRENT_FILE"
-            ):
+                if tool_name == "download_file":
+
+                    file_path = download_file(
+                        task_id,
+                        tool_input
+                    )
 
-                if not attachment_path:
+                    current_file = file_path
 
-                    attachment_path = (
-                        download_file(task_id)
+                    result = (
+                        f"File downloaded successfully.\n"
+                        f"FILE_PATH: {file_path}"
                     )
 
-                tool_result = execute_tool(
+                # ------------------------------------------------
+                # File tools automatically use current file
+                # ------------------------------------------------
+
+                elif tool_name in [
                     "inspect_file",
-                    attachment_path,
-                    task_id,
-                    question
-                )
+                    "transcribe_audio"
+                ]:
 
-            # -----------------------------------------------
-            # Audio
-            # -----------------------------------------------
+                    if not current_file:
 
-            elif (
-                tool_name == "transcribe_audio"
-                and tool_input == "CURRENT_FILE"
-            ):
+                        result = (
+                            "No file has been downloaded yet. "
+                            "Use download_file first."
+                        )
 
-                if not attachment_path:
+                    else:
 
-                    attachment_path = (
-                        download_file(task_id)
-                    )
+                        result = execute_tool(
+                            tool_name,
+                            current_file
+                        )
 
-                tool_result = execute_tool(
-                    "transcribe_audio",
-                    attachment_path,
-                    task_id,
-                    question
-                )
+                elif tool_name == "analyze_image":
+
+                    if not current_file:
 
-            # -----------------------------------------------
-            # Image
-            # -----------------------------------------------
+                        result = (
+                            "No image has been downloaded yet. "
+                            "Use download_file first."
+                        )
 
-            elif (
-                tool_name == "analyze_image"
-                and tool_input == "CURRENT_FILE"
-            ):
+                    else:
 
-                if not attachment_path:
+                        result = execute_tool(
+                            tool_name,
+                            {
+                                "path": current_file,
+                                "question": tool_input
+                            }
+                        )
 
-                    attachment_path = (
-                        download_file(task_id)
+                else:
+
+                    result = execute_tool(
+                        tool_name,
+                        tool_input
                     )
 
-                tool_result = execute_tool(
-                    "analyze_image",
-                    attachment_path,
-                    task_id,
-                    question
-                )
+            except Exception as e:
 
-            # -----------------------------------------------
-            # Normal tool
-            # -----------------------------------------------
+                result = f"TOOL ERROR: {e}"
 
-            else:
+            # Give tool result back to model
+            messages.append(
+                {
+                    "role": "assistant",
+                    "content": json.dumps(parsed)
+                }
+            )
 
-                tool_result = execute_tool(
-                    tool_name,
-                    tool_input,
-                    task_id,
-                    question
-                )
+            messages.append(
+                {
+                    "role": "user",
+                    "content": (
+                        f"TOOL RESULT ({tool_name}):\n"
+                        f"{result}\n\n"
+                        "Continue solving the original question. "
+                        "Use another tool if necessary, otherwise return "
+                        "the final answer as JSON."
+                    )
+                }
+            )
 
-            # Don't let huge tool outputs destroy context.
-            tool_result = str(
-                tool_result
-            )[:40000]
+            continue
 
-            messages.append({
-                "role": "assistant",
-                "content": raw
-            })
+        # ----------------------------------------------------
+        # INVALID ACTION
+        # ----------------------------------------------------
 
-            messages.append({
+        messages.append(
+            {
                 "role": "user",
                 "content": (
-                    f"TOOL RESULT ({tool_name}):\n"
-                    f"{tool_result}\n\n"
-                    "Continue solving the original question. "
-                    "Use another tool if necessary, otherwise "
-                    "return the final JSON answer."
+                    "Invalid action. Use exactly one of:\n"
+                    '{"action":"tool","tool":"TOOL_NAME","input":"..."}\n'
+                    '{"action":"final","answer":"..."}'
                 )
-            })
-
-            continue
+            }
+        )
 
-    return "Unable to determine the answer."
+    return "ERROR: agent exceeded maximum reasoning steps."
 
 
 # ============================================================
-# FETCH QUESTIONS
+# GET QUESTIONS
 # ============================================================
 
 def get_questions():
@@ -357,21 +320,40 @@ def get_questions():
 
     response.raise_for_status()
 
-    return response.json()
+    data = response.json()
+
+    if isinstance(data, dict):
+
+        if "questions" in data:
+            return data["questions"]
+
+        if "data" in data:
+            return data["data"]
+
+    return data
 
 
 # ============================================================
-# SUBMIT
+# SUBMIT ANSWERS
 # ============================================================
 
-def submit(
-    username,
-    agent_code,
-    answers
-):
+def submit_answers(username, answers):
+
+    space_id = os.getenv("SPACE_ID")
+
+    if not space_id:
+
+        raise RuntimeError(
+            "SPACE_ID environment variable is missing."
+        )
+
+    agent_code = (
+        f"https://huggingface.co/spaces/"
+        f"{space_id}/tree/main"
+    )
 
     payload = {
-        "username": username,
+        "username": username.strip(),
         "agent_code": agent_code,
         "answers": answers
     }
@@ -379,7 +361,7 @@ def submit(
     response = requests.post(
         f"{SCORING_API}/submit",
         json=payload,
-        timeout=180
+        timeout=120
     )
 
     response.raise_for_status()
@@ -391,101 +373,46 @@ def submit(
 # MAIN EVALUATION
 # ============================================================
 
-def run_and_submit_all(
-    profile: gr.OAuthProfile | None
-):
+def run_agent(username):
 
-    if profile is None:
+    if not username or not username.strip():
 
         return (
-            "Please login to Hugging Face.",
-            None
+            "ERROR: Please enter your Hugging Face username.",
+            []
         )
 
-    username = profile.username
+    username = username.strip()
 
-    space_id = os.getenv(
-        "SPACE_ID"
-    )
-
-    if not space_id:
-
-        return (
-            "SPACE_ID was not found.",
-            None
-        )
-
-    agent_code = (
-        "https://huggingface.co/spaces/"
-        f"{space_id}/tree/main"
-    )
-
-    print("=" * 70)
+    print("\n========================================")
     print("GAIA UNIT 4 AGENT")
-    print("=" * 70)
-
-    print(
-        f"Username: {username}"
-    )
+    print("========================================")
 
-    print(
-        f"Agent code: {agent_code}"
-    )
-
-    # --------------------------------------------------------
-    # Fetch questions
-    # --------------------------------------------------------
-
-    try:
-
-        questions = get_questions()
-
-    except Exception as e:
-
-        return (
-            f"Could not fetch questions: {e}",
-            None
-        )
+    print(f"Username: {username}")
 
-    print(
-        f"Fetched {len(questions)} questions."
-    )
+    questions = get_questions()
 
-    answers = []
-    results = []
+    print(f"Questions received: {len(questions)}")
 
-    # --------------------------------------------------------
-    # Solve questions
-    # --------------------------------------------------------
+    answers_payload = []
+    display_rows = []
 
-    for index, item in enumerate(
+    for index, question_data in enumerate(
         questions,
         start=1
     ):
 
-        task_id = item.get(
-            "task_id"
-        )
-
-        question = item.get(
-            "question"
-        )
-
-        print("\n" + "=" * 70)
+        task_id = question_data.get("task_id")
 
-        print(
-            f"QUESTION {index}/{len(questions)}"
+        question = question_data.get(
+            "question",
+            question_data.get("prompt", "")
         )
 
-        print(
-            f"TASK ID: {task_id}"
-        )
-
-        print(
-            question[:500]
-        )
-
-        print("=" * 70)
+        print("\n----------------------------------------")
+        print(f"Question {index}/{len(questions)}")
+        print(f"Task ID: {task_id}")
+        print("----------------------------------------")
 
         try:
 
@@ -494,139 +421,125 @@ def run_and_submit_all(
                 question
             )
 
-            answer = clean_answer(
-                answer
-            )
-
-            print(
-                f"FINAL ANSWER: {answer}"
-            )
-
-            answers.append({
-                "task_id": task_id,
-                "submitted_answer": answer
-            })
-
-            results.append({
-                "Task ID": task_id,
-                "Submitted Answer": answer
-            })
-
         except Exception as e:
 
-            print(
-                f"ERROR: {e}"
-            )
+            answer = f"ERROR: {e}"
 
-            results.append({
-                "Task ID": task_id,
-                "Submitted Answer":
-                    f"ERROR: {e}"
-            })
+        answer = clean_answer(answer)
 
-    # --------------------------------------------------------
-    # Submit
-    # --------------------------------------------------------
+        print(f"ANSWER: {answer}")
 
-    if not answers:
+        answers_payload.append(
+            {
+                "task_id": task_id,
+                "submitted_answer": answer
+            }
+        )
 
-        return (
-            "No answers were generated.",
-            pd.DataFrame(results)
+        display_rows.append(
+            [
+                index,
+                task_id,
+                answer
+            ]
         )
 
-    print("\n" + "=" * 70)
+    print("\n========================================")
     print("SUBMITTING")
-    print("=" * 70)
+    print("========================================")
 
     try:
 
-        result = submit(
+        result = submit_answers(
             username,
-            agent_code,
-            answers
+            answers_payload
         )
 
+        print("Submission result:")
+        print(result)
+
         score = result.get(
             "score",
-            "N/A"
+            result.get("total_score", "N/A")
         )
 
         correct = result.get(
             "correct_count",
-            "?"
+            result.get("correct", "N/A")
         )
 
         total = result.get(
             "total_attempted",
-            "?"
-        )
-
-        message = result.get(
-            "message",
-            ""
+            len(answers_payload)
         )
 
         status = (
-            "Submission Successful!\n\n"
-            f"User: {username}\n"
-            f"Score: {score}%\n"
-            f"Correct: {correct}/{total}\n"
-            f"Message: {message}"
+            f"SUBMITTED\n"
+            f"Score: {score}\n"
+            f"Correct: {correct}/{total}"
         )
 
-        print(status)
-
-        return (
-            status,
-            pd.DataFrame(results)
-        )
+        return status, display_rows
 
     except Exception as e:
 
-        status = (
-            f"Submission failed: {e}"
-        )
-
-        print(status)
-
         return (
-            status,
-            pd.DataFrame(results)
+            f"SUBMISSION ERROR: {e}",
+            display_rows
         )
 
 
 # ============================================================
-# MINIMAL UI
+# SIMPLE UI
 # ============================================================
 
-with gr.Blocks() as demo:
+with gr.Blocks(
+    title="GAIA Unit 4 Agent"
+) as demo:
 
     gr.Markdown(
-        "# GAIA Unit 4 Agent"
-    )
+        """
+        # GAIA Unit 4 Agent
 
-    gr.Markdown(
-        "Login and click the button to run all GAIA questions."
+        Enter your Hugging Face username and run the agent.
+
+        The agent will solve the 20 validation questions and submit
+        the answers automatically.
+        """
     )
 
-    gr.LoginButton()
+    username = gr.Textbox(
+        label="Hugging Face Username",
+        placeholder="Your HF username"
+    )
 
     run_button = gr.Button(
-        "Run Evaluation & Submit"
+        "Run Agent & Submit",
+        variant="primary"
     )
 
     status = gr.Textbox(
-        label="Result",
-        lines=6
+        label="Status",
+        lines=5
     )
 
-    results = gr.DataFrame(
+    results = gr.Dataframe(
+        headers=[
+            "Question",
+            "Task ID",
+            "Submitted Answer"
+        ],
+        datatype=[
+            "number",
+            "str",
+            "str"
+        ],
         label="Answers"
     )
 
     run_button.click(
-        fn=run_and_submit_all,
+        fn=run_agent,
+        inputs=username,
         outputs=[
             status,
             results
@@ -634,9 +547,11 @@ with gr.Blocks() as demo:
     )
 
 
-if __name__ == "__main__":
+# IMPORTANT:
+# Disable Gradio SSR for better Spaces compatibility.
 
-    demo.launch(
-        debug=True,
-        share=False
-    )
+demo.launch(
+    debug=True,
+    share=False,
+    ssr_mode=False
+)