Update app.py

app.py

@@ -1,196 +1,264 @@
 import os
 import json
-import re
 import time
-
-import gradio as gr
 import requests
+import gradio as gr
 import spaces
 
 from groq import Groq
 
 from prompt import SYSTEM_PROMPT
-from tools import execute_tool, download_file
-
+from tools import (
+    web_search,
+    read_webpage,
+    download_file,
+    inspect_file,
+    run_python,
+    transcribe_audio,
+    analyze_image,
+)
 
-# ============================================================
-# CONFIG
-# ============================================================
 
 SCORING_API = "https://agents-course-unit4-scoring.hf.space"
-
 GROQ_API_KEY = os.getenv("GROQ_API_KEY")
 
-TEXT_MODEL = os.getenv(
-    "GROQ_TEXT_MODEL",
-    "openai/gpt-oss-120b"
-)
+TEXT_MODEL = os.getenv("GROQ_TEXT_MODEL", "openai/gpt-oss-120b")
 
 MAX_STEPS = 5
 
-client = Groq(
-    api_key=GROQ_API_KEY
-)
-
+client = Groq(api_key=GROQ_API_KEY)
 
-# ============================================================
-# ZERO GPU COMPATIBILITY
-# ============================================================
 
-# The Space is running on ZeroGPU.
-# Our actual agent does NOT need the GPU because Groq
-# performs the model inference remotely.
-#
-# This function exists so the Space is recognized as
-# ZeroGPU-compatible.
+# ---------------------------------------------------------
+# ZeroGPU compatibility
+# ---------------------------------------------------------
 
 @spaces.GPU(duration=1)
 def zerogpu_probe():
     return "ZeroGPU available"
 
 
-# ============================================================
-# JSON PARSING
-# ============================================================
-
-def extract_json(text):
-
-    if not text:
-        return None
-
-    text = text.strip()
-
-    try:
-        return json.loads(text)
-    except Exception:
-        pass
+# ---------------------------------------------------------
+# Real Groq function tools
+# ---------------------------------------------------------
+
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "web_search",
+            "description": "Search the web for factual information. Use this when the answer requires external research.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "A concise web search query."
+                    }
+                },
+                "required": ["query"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "read_webpage",
+            "description": "Read and extract useful text from a webpage URL.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {
+                        "type": "string",
+                        "description": "The webpage URL to read."
+                    }
+                },
+                "required": ["url"]
+            }
+        }
+    },
+    {
+        "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.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "task_id": {
+                        "type": "string",
+                        "description": "The GAIA task ID."
+                    }
+                },
+                "required": ["task_id"]
+            }
+        }
+    },
+    {
+        "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.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "task_id": {
+                        "type": "string",
+                        "description": "The GAIA task ID whose attachment should be inspected."
+                    }
+                },
+                "required": ["task_id"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "run_python",
+            "description": "Run Python code for calculations or analysis. Use this for numerical, tabular, or computational tasks.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "code": {
+                        "type": "string",
+                        "description": "Python code to execute."
+                    }
+                },
+                "required": ["code"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "transcribe_audio",
+            "description": "Transcribe an audio attachment from a GAIA task. The task attachment is automatically downloaded first.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "task_id": {
+                        "type": "string",
+                        "description": "The GAIA task ID."
+                    }
+                },
+                "required": ["task_id"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "analyze_image",
+            "description": "Analyze an image attachment from a GAIA task. The task attachment is automatically downloaded first.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "task_id": {
+                        "type": "string",
+                        "description": "The GAIA task ID."
+                    },
+                    "question": {
+                        "type": "string",
+                        "description": "What should be determined from the image?"
+                    }
+                },
+                "required": ["task_id", "question"]
+            }
+        }
+    }
+]
 
-    # Remove markdown code fences
-    cleaned = re.sub(
-        r"```(?:json)?",
-        "",
-        text,
-        flags=re.IGNORECASE
-    )
 
-    cleaned = cleaned.replace(
-        "```",
-        ""
-    ).strip()
+# ---------------------------------------------------------
+# Tool execution
+# ---------------------------------------------------------
 
+def execute_tool(name, args, task_id):
     try:
-        return json.loads(cleaned)
-    except Exception:
-        pass
 
-    # Find first JSON object
-    start = cleaned.find("{")
-    end = cleaned.rfind("}")
+        if name == "web_search":
+            return web_search(args["query"])
 
-    if start != -1 and end != -1 and end > start:
+        if name == "read_webpage":
+            return read_webpage(args["url"])
 
-        candidate = cleaned[start:end + 1]
+        if name == "download_file":
+            path = download_file(task_id)
+            return f"Attachment downloaded successfully.\nPath: {path}"
 
-        try:
-            return json.loads(candidate)
-        except Exception:
-            pass
+        if name == "inspect_file":
+            path = download_file(task_id)
+            return inspect_file(path)
 
-    return None
+        if name == "run_python":
+            return run_python(args["code"])
 
+        if name == "transcribe_audio":
+            path = download_file(task_id)
+            return transcribe_audio(path)
 
-# ============================================================
-# ANSWER CLEANING
-# ============================================================
-
-def clean_answer(answer):
-
-    if answer is None:
-        return ""
-
-    answer = str(answer).strip()
-
-    answer = re.sub(
-        r"^```(?:text|json)?\s*",
-        "",
-        answer,
-        flags=re.IGNORECASE
-    )
-
-    answer = re.sub(
-        r"\s*```$",
-        "",
-        answer
-    )
-
-    prefixes = [
-        "FINAL ANSWER:",
-        "Final Answer:",
-        "THE ANSWER IS:",
-        "The answer is:",
-        "ANSWER:"
-    ]
-
-    for prefix in prefixes:
+        if name == "analyze_image":
+            path = download_file(task_id)
+            return analyze_image(
+                path,
+                args.get("question", "")
+            )
 
-        if answer.startswith(prefix):
+        return f"Unknown tool: {name}"
 
-            answer = answer[
-                len(prefix):
-            ].strip()
+    except Exception as e:
+        return f"Tool error: {type(e).__name__}: {str(e)}"
 
-    return answer.strip()
 
+# ---------------------------------------------------------
+# Groq call
+# ---------------------------------------------------------
 
-# ============================================================
-# GROQ CALL
-# ============================================================
+def call_groq(messages, use_tools=True):
 
-def call_groq(messages):
+    kwargs = {
+        "model": TEXT_MODEL,
+        "messages": messages,
+        "temperature": 0.1,
+        "max_completion_tokens": 1200,
+    }
 
-    last_error = None
+    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"
 
     for attempt in range(3):
 
         try:
-
-            response = client.chat.completions.create(
-                model=TEXT_MODEL,
-                messages=messages,
-                temperature=0.1,
-                max_tokens=1200
-            )
-
-            return response.choices[0].message.content
+            response = client.chat.completions.create(**kwargs)
+            return response.choices[0].message
 
         except Exception as e:
 
-            last_error = e
-
             print(
-                f"Groq error "
-                f"(attempt {attempt + 1}/3): {e}"
+                f"Groq error (attempt {attempt + 1}/3): "
+                f"{type(e).__name__}: {e}"
             )
 
-            # Backoff for rate limits
             if attempt < 2:
-                time.sleep(
-                    2 ** attempt
-                )
+                time.sleep(2 ** attempt)
+
+    raise RuntimeError("Groq request failed after 3 attempts.")
 
-    raise RuntimeError(
-        f"Groq request failed: {last_error}"
-    )
 
+# ---------------------------------------------------------
+# Solve one GAIA question
+# ---------------------------------------------------------
 
-# ============================================================
-# SOLVE ONE QUESTION
-# ============================================================
+def solve_question(task_id, question):
 
-def solve_question(
-    task_id,
-    question
-):
+    print(f"\n  Agent solving task {task_id}")
 
     messages = [
         {
@@ -200,236 +268,131 @@ def solve_question(
         {
             "role": "user",
             "content": (
-                f"GAIA TASK ID:\n{task_id}\n\n"
+                f"GAIA TASK ID: {task_id}\n\n"
                 f"QUESTION:\n{question}\n\n"
-                "Solve this question. "
-                "Use tools only when necessary. "
-                "Return the exact requested answer."
+                "Solve this question. Use tools when necessary. "
+                "Return only the exact final answer when finished."
             )
         }
     ]
 
-    current_file = None
-
-    for step in range(MAX_STEPS):
-
-        print(
-            f"  Agent step "
-            f"{step + 1}/{MAX_STEPS}"
-        )
-
-        try:
-
-            response = call_groq(
-                messages
-            )
-
-        except Exception as e:
-
-            return (
-                f"ERROR: model request failed: {e}"
-            )
-
-        print(
-            f"  Model: {response[:500]}"
-        )
-
-        parsed = extract_json(
-            response
-        )
-
-        # ----------------------------------------------------
-        # Model failed JSON formatting
-        # ----------------------------------------------------
-
-        if parsed is None:
+    for step in range(1, MAX_STEPS + 1):
 
-            messages.append(
-                {
-                    "role": "assistant",
-                    "content": response
-                }
-            )
-
-            messages.append(
-                {
-                    "role": "user",
-                    "content": (
-                        "Invalid format. "
-                        "Respond ONLY with valid JSON.\n\n"
-                        "For a tool:\n"
-                        '{"action":"tool","tool":"TOOL_NAME","input":"..."}\n\n'
-                        "For the final answer:\n"
-                        '{"action":"final","answer":"..."}'
-                    )
-                }
-            )
+        print(f"  Agent step {step}/{MAX_STEPS}")
 
-            continue
-
-        action = parsed.get(
-            "action"
-        )
+        message = call_groq(messages, use_tools=True)
 
-        # ----------------------------------------------------
-        # FINAL
-        # ----------------------------------------------------
+        # -------------------------------------------------
+        # Model requested tools
+        # -------------------------------------------------
 
-        if action == "final":
+        if message.tool_calls:
 
-            answer = parsed.get(
-                "answer",
-                ""
+            print(
+                "  Tool calls:",
+                [x.function.name for x in message.tool_calls]
             )
 
-            return clean_answer(
-                answer
-            )
+            # Add assistant message containing the tool calls
+            messages.append(message)
 
-        # ----------------------------------------------------
-        # TOOL
-        # ----------------------------------------------------
+            for tool_call in message.tool_calls:
 
-        if action == "tool":
+                name = tool_call.function.name
 
-            tool_name = parsed.get(
-                "tool"
-            )
+                try:
+                    args = json.loads(tool_call.function.arguments)
+                except Exception:
+                    args = {}
 
-            tool_input = parsed.get(
-                "input",
-                ""
-            )
+                print(f"  Executing: {name}")
 
-            print(
-                f"  Tool: {tool_name}"
-            )
-
-            try:
-
-                # Downloading a GAIA attachment
-                if tool_name == "download_file":
-
-                    current_file = download_file(
-                        task_id
-                    )
+                result = execute_tool(
+                    name,
+                    args,
+                    task_id
+                )
 
-                    result = (
-                        "File downloaded successfully.\n"
-                        f"FILE_PATH: {current_file}"
-                    )
+                # Keep context manageable.
+                if result is None:
+                    result = ""
 
-                # Tools that require current file
-                elif tool_name in [
-                    "inspect_file",
-                    "transcribe_audio"
-                ]:
+                result = str(result)
 
-                    if not current_file:
+                if len(result) > 9000:
+                    result = result[:9000] + "\n[OUTPUT TRUNCATED]"
 
-                        result = (
-                            "No attachment has been downloaded. "
-                            "Call download_file first."
-                        )
+                print(
+                    f"  Tool result: {len(result)} characters"
+                )
 
-                    else:
+                messages.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "name": name,
+                        "content": result
+                    }
+                )
 
-                        result = execute_tool(
-                            tool_name,
-                            current_file
-                        )
+            # Continue agent loop.
+            continue
 
-                elif tool_name == "analyze_image":
+        # -------------------------------------------------
+        # No tool call = model has an answer
+        # -------------------------------------------------
 
-                    if not current_file:
+        content = message.content or ""
 
-                        result = (
-                            "No image has been downloaded. "
-                            "Call download_file first."
-                        )
+        print("  Model:", content[:1000])
 
-                    else:
+        if content.strip():
+            return clean_answer(content)
 
-                        result = execute_tool(
-                            tool_name,
-                            {
-                                "path": current_file,
-                                "question": tool_input
-                            }
-                        )
+    return "ERROR: maximum reasoning steps reached."
 
-                else:
 
-                    result = execute_tool(
-                        tool_name,
-                        tool_input
-                    )
+# ---------------------------------------------------------
+# Clean final answer
+# ---------------------------------------------------------
 
-            except Exception as e:
+def clean_answer(text):
 
-                result = (
-                    f"TOOL ERROR: {e}"
-                )
+    text = text.strip()
 
-            # Add the tool call and result
-            # to the conversation.
-            messages.append(
-                {
-                    "role": "assistant",
-                    "content": json.dumps(
-                        parsed
-                    )
-                }
-            )
+    # Sometimes the model still wraps the final answer in JSON.
+    try:
+        obj = json.loads(text)
 
-            # Keep tool output reasonably short.
-            result = str(result)
+        if isinstance(obj, dict):
 
-            if len(result) > 18000:
+            if "answer" in obj:
+                return str(obj["answer"]).strip()
 
-                result = (
-                    result[:18000]
-                    + "\n[TOOL OUTPUT TRUNCATED]"
-                )
+            if "final_answer" in obj:
+                return str(obj["final_answer"]).strip()
 
-            messages.append(
-                {
-                    "role": "user",
-                    "content": (
-                        f"TOOL RESULT:\n{result}\n\n"
-                        "Continue solving the original "
-                        "question. If you now know the "
-                        "answer, return the final JSON."
-                    )
-                }
-            )
+    except Exception:
+        pass
 
-            continue
+    # Remove accidental prefixes.
+    prefixes = [
+        "FINAL ANSWER:",
+        "Final answer:",
+        "final answer:",
+    ]
 
-        # ----------------------------------------------------
-        # INVALID ACTION
-        # ----------------------------------------------------
+    for prefix in prefixes:
 
-        messages.append(
-            {
-                "role": "user",
-                "content": (
-                    "Invalid action. Use exactly:\n"
-                    '{"action":"tool","tool":"TOOL_NAME","input":"..."}\n'
-                    "or\n"
-                    '{"action":"final","answer":"..."}'
-                )
-            }
-        )
+        if text.startswith(prefix):
+            text = text[len(prefix):].strip()
 
-    return (
-        "ERROR: maximum reasoning steps reached."
-    )
+    return text
 
 
-# ============================================================
-# GET GAIA QUESTIONS
-# ============================================================
+# ---------------------------------------------------------
+# Get GAIA questions
+# ---------------------------------------------------------
 
 def get_questions():
 
@@ -443,152 +406,70 @@ def get_questions():
     data = response.json()
 
     if isinstance(data, dict):
-
         if "questions" in data:
             return data["questions"]
 
-        if "data" in data:
-            return data["data"]
-
     return data
 
 
-# ============================================================
-# SUBMIT
-# ============================================================
-
-def submit_answers(
-    username,
-    answers
-):
+# ---------------------------------------------------------
+# Submit answers
+# ---------------------------------------------------------
 
-    space_id = os.getenv(
-        "SPACE_ID"
-    )
-
-    if not space_id:
-
-        raise RuntimeError(
-            "SPACE_ID is missing."
-        )
+def submit_answers(username, answers):
 
     agent_code = (
         f"https://huggingface.co/spaces/"
-        f"{space_id}/tree/main"
+        f"{username}/Final_Assignment_Template/tree/main"
     )
 
     payload = {
-        "username": username.strip(),
+        "username": username,
         "agent_code": agent_code,
         "answers": answers
     }
 
-    print(
-        "\nAgent code:"
-    )
-
-    print(
-        agent_code
-    )
-
     response = requests.post(
         f"{SCORING_API}/submit",
         json=payload,
-        timeout=120
+        timeout=60
     )
 
-    response.raise_for_status()
+    print("\nSUBMISSION RESPONSE:")
+    print(response.text)
 
-    return response.json()
+    return response.text
 
 
-# ============================================================
-# RUN ALL 20
-# ============================================================
+# ---------------------------------------------------------
+# Main run
+# ---------------------------------------------------------
 
 def run_agent(username):
 
-    if not GROQ_API_KEY:
-
-        return (
-            "ERROR: GROQ_API_KEY is not configured.",
-            []
-        )
-
-    if not username:
-
-        return (
-            "ERROR: Enter your Hugging Face username.",
-            []
-        )
-
-    username = username.strip()
-
-    print("\n")
-    print("=" * 60)
+    print("\n" + "=" * 60)
     print("GAIA UNIT 4 AGENT")
     print("=" * 60)
 
-    print(
-        f"Username: {username}"
-    )
-
-    print(
-        f"Model: {TEXT_MODEL}"
-    )
-
-    # --------------------------------------------------------
-    # Get questions
-    # --------------------------------------------------------
-
-    try:
+    print(f"Username: {username}")
+    print(f"Model: {TEXT_MODEL}")
 
-        questions = get_questions()
+    questions = get_questions()
 
-    except Exception as e:
-
-        return (
-            f"ERROR getting questions: {e}",
-            []
-        )
-
-    print(
-        f"Questions: {len(questions)}"
-    )
-
-    answers_payload = []
-
-    display_rows = []
-
-    # --------------------------------------------------------
-    # Sequential processing
-    # --------------------------------------------------------
+    print(f"Questions: {len(questions)}")
+    print("=" * 60)
 
-    for index, item in enumerate(
-        questions,
-        start=1
-    ):
+    answers = []
 
-        task_id = item.get(
-            "task_id"
-        )
+    for index, item in enumerate(questions, 1):
 
-        question = item.get(
-            "question",
-            item.get(
-                "prompt",
-                ""
-            )
-        )
+        task_id = item.get("task_id")
+        question = item.get("question")
 
         print("\n")
         print("=" * 60)
-        print(
-            f"QUESTION {index}/{len(questions)}"
-        )
-        print(
-            f"TASK ID: {task_id}"
-        )
+        print(f"QUESTION {index}/{len(questions)}")
+        print(f"TASK ID: {task_id}")
         print("=" * 60)
 
         try:
@@ -601,160 +482,70 @@ def run_agent(username):
         except Exception as e:
 
             answer = (
-                f"ERROR: {e}"
+                f"ERROR: {type(e).__name__}: {str(e)}"
             )
 
-        answer = clean_answer(
-            answer
-        )
-
-        print(
-            f"FINAL ANSWER: {answer}"
-        )
+        print("FINAL ANSWER:", answer)
 
-        answers_payload.append(
+        answers.append(
             {
                 "task_id": task_id,
                 "submitted_answer": answer
             }
         )
 
-        display_rows.append(
-            [
-                index,
-                task_id,
-                answer
-            ]
-        )
-
         # Small pause between questions.
         time.sleep(0.5)
 
-    # --------------------------------------------------------
-    # Submit once
-    # --------------------------------------------------------
-
     print("\n")
     print("=" * 60)
     print("SUBMITTING ALL ANSWERS")
     print("=" * 60)
 
-    try:
-
-        result = submit_answers(
-            username,
-            answers_payload
-        )
-
-    except Exception as e:
-
-        return (
-            f"SUBMISSION ERROR: {e}",
-            display_rows
-        )
-
-    print(
-        "SUBMISSION RESULT:"
+    result = submit_answers(
+        username,
+        answers
     )
 
-    print(
-        result
-    )
+    return result
 
-    score = result.get(
-        "score",
-        result.get(
-            "total_score",
-            "N/A"
-        )
-    )
 
-    correct = result.get(
-        "correct_count",
-        result.get(
-            "correct",
-            "N/A"
-        )
-    )
+# ---------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------
 
-    total = result.get(
-        "total_attempted",
-        len(answers_payload)
-    )
-
-    status = (
-        "SUBMITTED\n"
-        f"Score: {score}\n"
-        f"Correct: {correct}/{total}"
-    )
-
-    return (
-        status,
-        display_rows
-    )
-
-
-# ============================================================
-# GRADIO UI
-# ============================================================
-
-with gr.Blocks(
-    title="GAIA Unit 4 Agent"
-) as demo:
+with gr.Blocks(title="GAIA Unit 4 Agent") as demo:
 
     gr.Markdown(
         """
 # GAIA Unit 4 Agent
 
-Groq-powered autonomous agent for the GAIA Unit 4 final assignment.
-
-Enter your Hugging Face username and run the evaluation.
+Enter your Hugging Face username and run the 20-question GAIA validation.
 """
     )
 
     username = gr.Textbox(
         label="Hugging Face Username",
-        placeholder="e.g. Viske"
+        value="Viske"
     )
 
     run_button = gr.Button(
-        "Run 20 Questions & Submit",
+        "Run GAIA Agent",
         variant="primary"
     )
 
-    status = gr.Textbox(
-        label="Status",
-        lines=5
-    )
-
-    results = gr.Dataframe(
-        headers=[
-            "Question",
-            "Task ID",
-            "Submitted Answer"
-        ],
-        datatype=[
-            "number",
-            "str",
-            "str"
-        ],
-        label="Answers"
+    output = gr.Textbox(
+        label="Result",
+        lines=10
     )
 
     run_button.click(
         fn=run_agent,
         inputs=username,
-        outputs=[
-            status,
-            results
-        ]
+        outputs=output
     )
 
 
-# ============================================================
-# LAUNCH
-# ============================================================
-
 demo.launch(
     debug=True,
     share=False,