Update app.py

app.py

@@ -4,27 +4,19 @@ import time
 import requests
 import gradio as gr
 import spaces
-
 from groq import Groq
 
 from prompt import SYSTEM_PROMPT
-from tools import (
-    web_search,
-    read_webpage,
-    download_file,
-    inspect_file,
-    run_python,
-    transcribe_audio,
-    analyze_image,
-)
+from tools import execute_tool
 
 
 SCORING_API = "https://agents-course-unit4-scoring.hf.space"
-GROQ_API_KEY = os.getenv("GROQ_API_KEY")
 
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
 TEXT_MODEL = os.getenv("GROQ_TEXT_MODEL", "openai/gpt-oss-120b")
 
-MAX_STEPS = 5
+MAX_STEPS = 6
+MAX_TOOL_RESULT = 6000
 
 client = Groq(api_key=GROQ_API_KEY)
 
@@ -39,7 +31,7 @@ def zerogpu_probe():
 
 
 # ---------------------------------------------------------
-# Real Groq function tools
+# Native Groq tools
 # ---------------------------------------------------------
 
 TOOLS = [
@@ -47,75 +39,112 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "web_search",
-            "description": "Search the web for factual information. Use this when the answer requires external research.",
+            "description": (
+                "Search the public web for factual information. "
+                "Use this first for questions requiring current, historical, "
+                "Wikipedia, YouTube, NASA, IOC, news, or other web research."
+            ),
             "parameters": {
                 "type": "object",
                 "properties": {
                     "query": {
                         "type": "string",
-                        "description": "A concise web search query."
+                        "description": "The exact web search query."
                     }
                 },
-                "required": ["query"]
+                "required": ["query"],
+                "additionalProperties": False
             }
         }
     },
+
     {
         "type": "function",
         "function": {
             "name": "read_webpage",
-            "description": "Read and extract useful text from a webpage URL.",
+            "description": (
+                "Read a webpage returned by web_search. "
+                "Normally provide the full URL from a search result. "
+                "If you do not know the URL, you may provide cursor as the "
+                "zero-based search-result index and optionally pattern. "
+                "The application will resolve the URL from the most recent search."
+            ),
             "parameters": {
                 "type": "object",
                 "properties": {
                     "url": {
                         "type": "string",
-                        "description": "The webpage URL to read."
+                        "description": "Full webpage URL. Optional if cursor is provided."
+                    },
+                    "cursor": {
+                        "type": "integer",
+                        "description": "Zero-based index of the most recent web-search result."
+                    },
+                    "pattern": {
+                        "type": "string",
+                        "description": "Optional text/topic to focus on while reading."
                     }
                 },
-                "required": ["url"]
+                "required": [],
+                "additionalProperties": False
             }
         }
     },
+
     {
         "type": "function",
         "function": {
             "name": "download_file",
-            "description": "Download the attachment associated with a GAIA task. Must be used before inspecting, transcribing, or analyzing an attachment.",
+            "description": (
+                "Download the attachment associated with the current GAIA task. "
+                "Use this before inspecting an Excel, PDF, image, audio, or Python attachment."
+            ),
             "parameters": {
                 "type": "object",
                 "properties": {
                     "task_id": {
                         "type": "string",
-                        "description": "The GAIA task ID."
+                        "description": "The current GAIA task ID."
                     }
                 },
-                "required": ["task_id"]
+                "required": ["task_id"],
+                "additionalProperties": False
             }
         }
     },
+
     {
         "type": "function",
         "function": {
             "name": "inspect_file",
-            "description": "Inspect a downloaded attachment such as TXT, CSV, XLSX, PDF, PY, or other text/data files. The task_id is used to locate and download the attachment automatically.",
+            "description": (
+                "Inspect the current GAIA attachment. "
+                "Useful for Excel, CSV, PDF, TXT, Python, JSON and other files. "
+                "The application automatically downloads the task attachment."
+            ),
             "parameters": {
                 "type": "object",
                 "properties": {
                     "task_id": {
                         "type": "string",
-                        "description": "The GAIA task ID whose attachment should be inspected."
+                        "description": "The current GAIA task ID."
                     }
                 },
-                "required": ["task_id"]
+                "required": ["task_id"],
+                "additionalProperties": False
             }
         }
     },
+
     {
         "type": "function",
         "function": {
             "name": "run_python",
-            "description": "Run Python code for calculations or analysis. Use this for numerical, tabular, or computational tasks.",
+            "description": (
+                "Run Python code for calculations, data processing, string operations, "
+                "statistics, or analyzing a downloaded attachment. "
+                "Do not use shell commands."
+            ),
             "parameters": {
                 "type": "object",
                 "properties": {
@@ -124,45 +153,56 @@ TOOLS = [
                         "description": "Python code to execute."
                     }
                 },
-                "required": ["code"]
+                "required": ["code"],
+                "additionalProperties": False
             }
         }
     },
+
     {
         "type": "function",
         "function": {
             "name": "transcribe_audio",
-            "description": "Transcribe an audio attachment from a GAIA task. The task attachment is automatically downloaded first.",
+            "description": (
+                "Transcribe the audio attachment for the current GAIA task. "
+                "Use when the question depends on spoken audio."
+            ),
             "parameters": {
                 "type": "object",
                 "properties": {
                     "task_id": {
                         "type": "string",
-                        "description": "The GAIA task ID."
+                        "description": "The current GAIA task ID."
                     }
                 },
-                "required": ["task_id"]
+                "required": ["task_id"],
+                "additionalProperties": False
             }
         }
     },
+
     {
         "type": "function",
         "function": {
             "name": "analyze_image",
-            "description": "Analyze an image attachment from a GAIA task. The task attachment is automatically downloaded first.",
+            "description": (
+                "Analyze the image attachment for the current GAIA task. "
+                "Use this for visual questions, diagrams, screenshots, chess boards, etc."
+            ),
             "parameters": {
                 "type": "object",
                 "properties": {
                     "task_id": {
                         "type": "string",
-                        "description": "The GAIA task ID."
+                        "description": "The current GAIA task ID."
                     },
                     "question": {
                         "type": "string",
-                        "description": "What should be determined from the image?"
+                        "description": "What specifically must be determined from the image."
                     }
                 },
-                "required": ["task_id", "question"]
+                "required": ["task_id", "question"],
+                "additionalProperties": False
             }
         }
     }
@@ -170,86 +210,77 @@ TOOLS = [
 
 
 # ---------------------------------------------------------
-# Tool execution
+# Groq call
 # ---------------------------------------------------------
 
-def execute_tool(name, args, task_id):
-    try:
-
-        if name == "web_search":
-            return web_search(args["query"])
-
-        if name == "read_webpage":
-            return read_webpage(args["url"])
-
-        if name == "download_file":
-            path = download_file(task_id)
-            return f"Attachment downloaded successfully.\nPath: {path}"
+def call_groq(messages, use_tools=True):
+    last_error = None
 
-        if name == "inspect_file":
-            path = download_file(task_id)
-            return inspect_file(path)
+    for attempt in range(3):
+        try:
+            kwargs = {
+                "model": TEXT_MODEL,
+                "messages": messages,
+                "temperature": 0,
+                "max_completion_tokens": 2500,
+            }
 
-        if name == "run_python":
-            return run_python(args["code"])
+            if use_tools:
+                kwargs["tools"] = TOOLS
+                kwargs["tool_choice"] = "auto"
+            else:
+                # No tools on final answer call.
+                kwargs["tool_choice"] = "none"
 
-        if name == "transcribe_audio":
-            path = download_file(task_id)
-            return transcribe_audio(path)
+            response = client.chat.completions.create(**kwargs)
+            return response.choices[0].message
 
-        if name == "analyze_image":
-            path = download_file(task_id)
-            return analyze_image(
-                path,
-                args.get("question", "")
-            )
+        except Exception as e:
+            last_error = e
+            print(f"Groq error (attempt {attempt + 1}/3): {type(e).__name__}: {e}")
 
-        return f"Unknown tool: {name}"
+            if attempt < 2:
+                time.sleep(2 ** attempt)
 
-    except Exception as e:
-        return f"Tool error: {type(e).__name__}: {str(e)}"
+    raise RuntimeError(
+        f"Groq request failed after 3 attempts: {last_error}"
+    )
 
 
 # ---------------------------------------------------------
-# Groq call
+# Answer cleanup
 # ---------------------------------------------------------
 
-def call_groq(messages, use_tools=True):
+def clean_answer(answer):
+    if answer is None:
+        return ""
 
-    kwargs = {
-        "model": TEXT_MODEL,
-        "messages": messages,
-        "temperature": 0.1,
-        "max_completion_tokens": 1200,
-    }
+    answer = str(answer).strip()
 
-    if use_tools:
-        kwargs["tools"] = TOOLS
-        kwargs["tool_choice"] = "auto"
-    else:
-        # Important:
-        # After receiving tool results, explicitly prevent another
-        # tool call and force a final textual answer.
-        kwargs["tools"] = TOOLS
-        kwargs["tool_choice"] = "none"
+    if answer.startswith("```"):
+        lines = answer.splitlines()
 
-    for attempt in range(3):
+        if lines and lines[0].startswith("```"):
+            lines = lines[1:]
 
-        try:
-            response = client.chat.completions.create(**kwargs)
-            return response.choices[0].message
+        if lines and lines[-1].strip() == "```":
+            lines = lines[:-1]
 
-        except Exception as e:
+        answer = "\n".join(lines).strip()
 
-            print(
-                f"Groq error (attempt {attempt + 1}/3): "
-                f"{type(e).__name__}: {e}"
-            )
+    if answer.upper().startswith("FINAL ANSWER:"):
+        answer = answer[len("FINAL ANSWER:"):].strip()
 
-            if attempt < 2:
-                time.sleep(2 ** attempt)
+    # Handle accidental JSON final response
+    try:
+        obj = json.loads(answer)
+
+        if isinstance(obj, dict) and "answer" in obj:
+            answer = str(obj["answer"]).strip()
+    except Exception:
+        pass
 
-    raise RuntimeError("Groq request failed after 3 attempts.")
+    return answer
 
 
 # ---------------------------------------------------------
@@ -258,7 +289,10 @@ def call_groq(messages, use_tools=True):
 
 def solve_question(task_id, question):
 
-    print(f"\n  Agent solving task {task_id}")
+    print()
+    print("=" * 60)
+    print(f"Agent solving task {task_id}")
+    print("=" * 60)
 
     messages = [
         {
@@ -270,128 +304,90 @@ def solve_question(task_id, question):
             "content": (
                 f"GAIA TASK ID: {task_id}\n\n"
                 f"QUESTION:\n{question}\n\n"
-                "Solve this question. Use tools when necessary. "
-                "Return only the exact final answer when finished."
+                "Solve this task and return only the exact answer when finished."
             )
         }
     ]
 
     for step in range(1, MAX_STEPS + 1):
 
-        print(f"  Agent step {step}/{MAX_STEPS}")
+        print(f"Agent step {step}/{MAX_STEPS}")
+
+        try:
+            message = call_groq(messages, use_tools=True)
+        except Exception as e:
+            return f"ERROR: {e}"
 
-        message = call_groq(messages, use_tools=True)
+        tool_calls = message.tool_calls or []
 
-        # -------------------------------------------------
-        # Model requested tools
-        # -------------------------------------------------
+        if not tool_calls:
+            answer = clean_answer(message.content)
+            print(f"FINAL ANSWER: {answer}")
+            return answer
 
-        if message.tool_calls:
+        print(
+            "Tool calls:",
+            [call.function.name for call in tool_calls]
+        )
 
-            print(
-                "  Tool calls:",
-                [x.function.name for x in message.tool_calls]
-            )
+        # Important: append the assistant tool-call message exactly as returned.
+        messages.append(message)
 
-            # Add assistant message containing the tool calls
-            messages.append(message)
+        for tool_call in tool_calls:
 
-            for tool_call in message.tool_calls:
+            name = tool_call.function.name
 
-                name = tool_call.function.name
+            try:
+                args = json.loads(tool_call.function.arguments or "{}")
+            except Exception:
+                args = {}
 
-                try:
-                    args = json.loads(tool_call.function.arguments)
-                except Exception:
-                    args = {}
+            print(f"Executing: {name}")
+            print(f"Arguments: {args}")
 
-                print(f"  Executing: {name}")
+            # Force current task ID into task-dependent tools.
+            if name in {
+                "download_file",
+                "inspect_file",
+                "transcribe_audio",
+                "analyze_image"
+            }:
+                args["task_id"] = task_id
 
+            try:
                 result = execute_tool(
-                    name,
-                    args,
-                    task_id
+                    name=name,
+                    args=args,
+                    task_id=task_id
                 )
 
-                # Keep context manageable.
-                if result is None:
-                    result = ""
+            except Exception as e:
+                result = f"Tool error: {type(e).__name__}: {e}"
 
-                result = str(result)
+            result = str(result)
 
-                if len(result) > 9000:
-                    result = result[:9000] + "\n[OUTPUT TRUNCATED]"
-
-                print(
-                    f"  Tool result: {len(result)} characters"
-                )
-
-                messages.append(
-                    {
-                        "role": "tool",
-                        "tool_call_id": tool_call.id,
-                        "name": name,
-                        "content": result
-                    }
+            if len(result) > MAX_TOOL_RESULT:
+                result = (
+                    result[:MAX_TOOL_RESULT]
+                    + "\n[TOOL OUTPUT TRUNCATED]"
                 )
 
-            # Continue agent loop.
-            continue
-
-        # -------------------------------------------------
-        # No tool call = model has an answer
-        # -------------------------------------------------
-
-        content = message.content or ""
-
-        print("  Model:", content[:1000])
-
-        if content.strip():
-            return clean_answer(content)
-
-    return "ERROR: maximum reasoning steps reached."
-
-
-# ---------------------------------------------------------
-# Clean final answer
-# ---------------------------------------------------------
-
-def clean_answer(text):
-
-    text = text.strip()
-
-    # Sometimes the model still wraps the final answer in JSON.
-    try:
-        obj = json.loads(text)
-
-        if isinstance(obj, dict):
-
-            if "answer" in obj:
-                return str(obj["answer"]).strip()
-
-            if "final_answer" in obj:
-                return str(obj["final_answer"]).strip()
-
-    except Exception:
-        pass
-
-    # Remove accidental prefixes.
-    prefixes = [
-        "FINAL ANSWER:",
-        "Final answer:",
-        "final answer:",
-    ]
-
-    for prefix in prefixes:
+            print(f"Tool result: {len(result)} characters")
 
-        if text.startswith(prefix):
-            text = text[len(prefix):].strip()
+            messages.append(
+                {
+                    "role": "tool",
+                    "tool_call_id": tool_call.id,
+                    "name": name,
+                    "content": result
+                }
+            )
 
-    return text
+    return "ERROR: Maximum reasoning steps reached."
 
 
 # ---------------------------------------------------------
-# Get GAIA questions
+# Fetch questions
 # ---------------------------------------------------------
 
 def get_questions():
@@ -405,27 +401,28 @@ def get_questions():
 
     data = response.json()
 
+    if isinstance(data, list):
+        return data
+
     if isinstance(data, dict):
         if "questions" in data:
             return data["questions"]
 
-    return data
+    raise RuntimeError("Unexpected /questions response format.")
 
 
 # ---------------------------------------------------------
-# Submit answers
+# Submit
 # ---------------------------------------------------------
 
 def submit_answers(username, answers):
 
-    agent_code = (
-        f"https://huggingface.co/spaces/"
-        f"{username}/Final_Assignment_Template/tree/main"
-    )
-
     payload = {
         "username": username,
-        "agent_code": agent_code,
+        "agent_code": (
+            "https://huggingface.co/spaces/"
+            f"{username}/Final_Assignment_Template/tree/main"
+        ),
         "answers": answers
     }
 
@@ -435,57 +432,48 @@ def submit_answers(username, answers):
         timeout=60
     )
 
-    print("\nSUBMISSION RESPONSE:")
-    print(response.text)
+    response.raise_for_status()
 
-    return response.text
+    return response.json()
 
 
 # ---------------------------------------------------------
-# Main run
+# Run all questions
 # ---------------------------------------------------------
 
 def run_agent(username):
 
-    print("\n" + "=" * 60)
-    print("GAIA UNIT 4 AGENT")
-    print("=" * 60)
+    if not GROQ_API_KEY:
+        return "ERROR: GROQ_API_KEY is not configured in Space Secrets."
 
-    print(f"Username: {username}")
-    print(f"Model: {TEXT_MODEL}")
+    username = username.strip()
+
+    if not username:
+        return "ERROR: Enter your Hugging Face username."
+
+    print("\nFetching GAIA questions...")
 
     questions = get_questions()
 
-    print(f"Questions: {len(questions)}")
-    print("=" * 60)
+    print(f"Found {len(questions)} questions.")
 
     answers = []
 
-    for index, item in enumerate(questions, 1):
+    for i, item in enumerate(questions, start=1):
 
-        task_id = item.get("task_id")
+        task_id = item.get("task_id") or item.get("id")
         question = item.get("question")
 
-        print("\n")
+        print()
         print("=" * 60)
-        print(f"QUESTION {index}/{len(questions)}")
+        print(f"QUESTION {i}/{len(questions)}")
         print(f"TASK ID: {task_id}")
         print("=" * 60)
 
-        try:
-
-            answer = solve_question(
-                task_id,
-                question
-            )
-
-        except Exception as e:
-
-            answer = (
-                f"ERROR: {type(e).__name__}: {str(e)}"
-            )
-
-        print("FINAL ANSWER:", answer)
+        answer = solve_question(
+            task_id=task_id,
+            question=question
+        )
 
         answers.append(
             {
@@ -494,35 +482,32 @@ def run_agent(username):
             }
         )
 
-        # Small pause between questions.
+        # Small delay between questions.
         time.sleep(0.5)
 
-    print("\n")
-    print("=" * 60)
-    print("SUBMITTING ALL ANSWERS")
-    print("=" * 60)
+    print("\nSubmitting answers...")
 
     result = submit_answers(
-        username,
-        answers
+        username=username,
+        answers=answers
     )
 
-    return result
+    print("\nSUBMISSION RESULT:")
+    print(result)
+
+    return json.dumps(
+        result,
+        indent=2
+    )
 
 
 # ---------------------------------------------------------
-# Gradio UI
+# Simple UI
 # ---------------------------------------------------------
 
-with gr.Blocks(title="GAIA Unit 4 Agent") as demo:
-
-    gr.Markdown(
-        """
-# GAIA Unit 4 Agent
+with gr.Blocks(title="GAIA Agent") as demo:
 
-Enter your Hugging Face username and run the 20-question GAIA validation.
-"""
-    )
+    gr.Markdown("# GAIA Unit 4 Agent")
 
     username = gr.Textbox(
         label="Hugging Face Username",
@@ -530,13 +515,12 @@ Enter your Hugging Face username and run the 20-question GAIA validation.
     )
 
     run_button = gr.Button(
-        "Run GAIA Agent",
-        variant="primary"
+        "Run Agent"
     )
 
     output = gr.Textbox(
         label="Result",
-        lines=10
+        lines=15
     )
 
     run_button.click(
@@ -546,8 +530,9 @@ Enter your Hugging Face username and run the 20-question GAIA validation.
     )
 
 
-demo.launch(
-    debug=True,
-    share=False,
-    ssr_mode=False
-)
+if __name__ == "__main__":
+    demo.launch(
+        debug=True,
+        share=False,
+        ssr_mode=False
+    )