Update app.py

app.py

@@ -1,421 +1,526 @@
 import os
 import re
-import ast
 import json
+import io
+import traceback
+import contextlib
+import tempfile
+
+import gradio as gr
 import requests
 import pandas as pd
-import gradio as gr
-
-from groq import Groq
-from duckduckgo_search import DDGS
 
+# --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+GROQ_MODEL = os.getenv("GROQ_MODEL", "llama-3.3-70b-versatile")
+MAX_TOOL_ITERATIONS = 8
 
-# ---------------------------------------------------
-# SEARCH TOOL
-# ---------------------------------------------------
-class WebSearchTool:
 
-    def __init__(self):
-        self.ddgs = DDGS()
+# ---------------------------------------------------------------------------
+# Tool implementations
+# ---------------------------------------------------------------------------
+def tool_web_search(query: str, max_results: int = 5) -> str:
+    """DuckDuckGo text search. Returns a short list of titles + snippets + URLs."""
+    try:
+        from duckduckgo_search import DDGS
+        results = []
+        with DDGS() as ddgs:
+            for r in ddgs.text(query, max_results=max_results):
+                results.append(
+                    f"- {r.get('title', '')}\n  {r.get('href', '')}\n  {r.get('body', '')}"
+                )
+        if not results:
+            return "No results."
+        return "\n".join(results)
+    except Exception as e:
+        return f"web_search error: {e}"
 
-    def search(self, query, max_results=5):
 
-        try:
-
-            results = self.ddgs.text(
-                query,
-                max_results=max_results
+def tool_fetch_url(url: str, max_chars: int = 6000) -> str:
+    """Fetch a URL and return readable text (HTML stripped)."""
+    try:
+        from bs4 import BeautifulSoup
+        headers = {
+            "User-Agent": (
+                "Mozilla/5.0 (compatible; GAIA-Agent/1.0; "
+                "+https://huggingface.co/learn/agents-course)"
             )
+        }
+        resp = requests.get(url, headers=headers, timeout=20)
+        resp.raise_for_status()
+        ctype = resp.headers.get("Content-Type", "")
+        if "html" in ctype or url.endswith((".html", ".htm")) or "<html" in resp.text[:500].lower():
+            soup = BeautifulSoup(resp.text, "lxml")
+            for tag in soup(["script", "style", "noscript"]):
+                tag.decompose()
+            text = soup.get_text(separator="\n")
+        else:
+            text = resp.text
+        text = re.sub(r"\n\s*\n+", "\n\n", text).strip()
+        if len(text) > max_chars:
+            text = text[:max_chars] + "\n...[truncated]"
+        return text
+    except Exception as e:
+        return f"fetch_url error: {e}"
 
-            snippets = []
-
-            for r in results:
-
-                title = r.get("title", "")
-                body = r.get("body", "")
-
-                snippets.append(f"{title}: {body}")
 
-            return "\n".join(snippets[:max_results])
+def tool_wikipedia(query: str, sentences: int = 6) -> str:
+    """Look up a topic on Wikipedia and return a summary."""
+    try:
+        import wikipedia
+        wikipedia.set_lang("en")
+        try:
+            return wikipedia.summary(query, sentences=sentences, auto_suggest=True, redirect=True)
+        except wikipedia.DisambiguationError as de:
+            options = ", ".join(de.options[:8])
+            return f"Disambiguation. Options: {options}"
+        except wikipedia.PageError:
+            hits = wikipedia.search(query, results=5)
+            if not hits:
+                return "No Wikipedia page found."
+            return wikipedia.summary(hits[0], sentences=sentences, auto_suggest=False, redirect=True)
+    except Exception as e:
+        return f"wikipedia error: {e}"
 
-        except Exception as e:
 
-            print(f"Search error: {e}")
+def tool_python(code: str) -> str:
+    """Run a small Python snippet and return stdout (or the value of `result`)."""
+    buf = io.StringIO()
+    local_ns: dict = {}
+    try:
+        with contextlib.redirect_stdout(buf):
+            exec(code, {"__builtins__": __builtins__}, local_ns)
+        out = buf.getvalue().strip()
+        if not out and "result" in local_ns:
+            out = str(local_ns["result"])
+        return out or "(no output)"
+    except Exception as e:
+        return f"python error: {e}\n{traceback.format_exc(limit=2)}"
 
-            return ""
 
+def tool_get_task_file(task_id: str, api_url: str = DEFAULT_API_URL) -> str:
+    """Download the file attached to a task and return a text preview."""
+    try:
+        resp = requests.get(f"{api_url}/files/{task_id}", timeout=30)
+        resp.raise_for_status()
+        ctype = resp.headers.get("Content-Type", "")
+        cdisp = resp.headers.get("Content-Disposition", "")
+        fname_match = re.search(r'filename="?([^"]+)"?', cdisp)
+        fname = fname_match.group(1) if fname_match else f"{task_id}"
+        suffix = os.path.splitext(fname)[1].lower()
+
+        # Save to temp for tools that need a path
+        tmp = tempfile.NamedTemporaryFile(prefix=f"{task_id}_", suffix=suffix, delete=False)
+        tmp.write(resp.content)
+        tmp.close()
+
+        info = f"File: {fname}\nContent-Type: {ctype}\nSaved to: {tmp.name}\nSize: {len(resp.content)} bytes\n"
+
+        # Try to give a readable preview
+        if suffix in {".txt", ".md", ".csv", ".json", ".py", ".tsv", ".log", ".xml", ".html"}:
+            try:
+                text = resp.content.decode("utf-8", errors="replace")
+            except Exception:
+                text = resp.text
+            return info + "\n--- preview ---\n" + text[:6000]
+
+        if suffix in {".xlsx", ".xls"}:
+            try:
+                df = pd.read_excel(tmp.name)
+                return info + "\n--- preview (head 30) ---\n" + df.head(30).to_csv(index=False)
+            except Exception as e:
+                return info + f"\n(excel parse error: {e})"
+
+        if suffix == ".pdf":
+            try:
+                from pypdf import PdfReader
+                reader = PdfReader(tmp.name)
+                pages = [p.extract_text() or "" for p in reader.pages[:10]]
+                return info + "\n--- pdf text (first 10 pages) ---\n" + "\n".join(pages)[:6000]
+            except Exception as e:
+                return info + f"\n(pdf parse error: {e})"
+
+        if suffix in {".mp3", ".wav", ".m4a", ".ogg"}:
+            return info + "\n(audio file; no transcription tool available)"
+
+        if suffix in {".png", ".jpg", ".jpeg", ".gif", ".webp"}:
+            return info + "\n(image file; no vision tool available)"
+
+        return info + "\n(binary file; no preview)"
+    except Exception as e:
+        return f"get_task_file error: {e}"
+
+
+# ---------------------------------------------------------------------------
+# Tool schema for Groq function calling
+# ---------------------------------------------------------------------------
+TOOLS_SPEC = [
+    {
+        "type": "function",
+        "function": {
+            "name": "web_search",
+            "description": "Search the web with DuckDuckGo. Returns titles, URLs, and snippets.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string"},
+                    "max_results": {"type": "integer", "default": 5},
+                },
+                "required": ["query"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "fetch_url",
+            "description": "Fetch a URL and return cleaned page text. Use after web_search to read a result.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {"type": "string"},
+                    "max_chars": {"type": "integer", "default": 6000},
+                },
+                "required": ["url"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "wikipedia",
+            "description": "Get a Wikipedia summary for a topic.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string"},
+                    "sentences": {"type": "integer", "default": 6},
+                },
+                "required": ["query"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "python",
+            "description": "Execute a short Python snippet for math, string parsing, or data work. Use print() or assign to `result`.",
+            "parameters": {
+                "type": "object",
+                "properties": {"code": {"type": "string"}},
+                "required": ["code"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_task_file",
+            "description": "Download the file attached to a GAIA task by task_id and return a text preview.",
+            "parameters": {
+                "type": "object",
+                "properties": {"task_id": {"type": "string"}},
+                "required": ["task_id"],
+            },
+        },
+    },
+]
+
+TOOL_FUNCTIONS = {
+    "web_search": lambda args: tool_web_search(args["query"], int(args.get("max_results", 5))),
+    "fetch_url": lambda args: tool_fetch_url(args["url"], int(args.get("max_chars", 6000))),
+    "wikipedia": lambda args: tool_wikipedia(args["query"], int(args.get("sentences", 6))),
+    "python": lambda args: tool_python(args["code"]),
+    "get_task_file": lambda args: tool_get_task_file(args["task_id"]),
+}
+
+
+SYSTEM_PROMPT = """You are a careful research agent answering GAIA benchmark questions.
+
+You have tools: web_search, fetch_url, wikipedia, python, get_task_file.
+
+Workflow:
+- If the question references an attached file, image, audio, code, or table, call get_task_file with the task_id first.
+- Use web_search then fetch_url to verify facts from primary sources.
+- Use wikipedia for well-known entities or historical facts.
+- Use python for arithmetic, date math, string/list manipulation, or parsing CSV data.
+- Cross-check before answering. Avoid guessing.
+
+Answer formatting (critical, the grader does EXACT string match):
+- Reply with ONLY the answer. No preamble, no explanation, no quotes, no trailing period unless part of the answer.
+- Do NOT include the words "FINAL ANSWER" or any label.
+- Numbers: digits only, no commas, no units, no $ sign, unless the question asks for the unit.
+- Strings: no leading articles ("the", "a") unless required, no abbreviations, write digits as digits.
+- Lists: comma-separated, single space after each comma, applying the rules above to each element.
+- If the question asks for a name, give just the name. If it asks "how many", give just the number.
+"""
 
-# ---------------------------------------------------
-# AGENT
-# ---------------------------------------------------
-class BasicAgent:
 
+# ---------------------------------------------------------------------------
+# Agent
+# ---------------------------------------------------------------------------
+class GroqAgent:
     def __init__(self):
-
-        self.client = Groq(
-            api_key=os.getenv("GROQ_API_KEY")
-        )
-
-        self.search_tool = WebSearchTool()
-
-        print("Lightweight GAIA agent initialized.")
-
-    # ---------------------------------------------------
-    # CLEAN ANSWER
-    # ---------------------------------------------------
-    def clean_answer(self, text):
-
-        if text is None:
-            return ""
-
-        text = str(text)
-
-        bad_phrases = [
-            "FINAL ANSWER:",
-            "Answer:",
-            "answer:",
-            "```",
-            "`"
-        ]
-
-        for b in bad_phrases:
-            text = text.replace(b, "")
-
-        text = re.sub(r"\s+", " ", text)
-
-        text = text.strip()
-
-        # first line only
-        text = text.split("\n")[0]
-
-        return text[:300]
-
-    # ---------------------------------------------------
-    # REVERSE STRING TASK
-    # ---------------------------------------------------
-    def handle_reverse_text(self, question):
-
-        reversed_text = question[::-1]
-
-        return reversed_text[:300]
-
-    # ---------------------------------------------------
-    # DETECT SEARCH NEED
-    # ---------------------------------------------------
-    def needs_search(self, question):
-
-        q = question.lower()
-
-        keywords = [
-            "who",
-            "when",
-            "where",
-            "which",
-            "youtube",
-            "wikipedia",
-            "movie",
-            "actor",
-            "award",
-            "paper",
-            "country",
-            "city",
-            "population",
-            "published",
-            "album",
-            "song",
-            "species",
-            "nasa",
-            "video"
-        ]
-
-        return any(k in q for k in keywords)
-
-    # ---------------------------------------------------
-    # BUILD CONTEXT
-    # ---------------------------------------------------
-    def build_context(self, question):
-
-        q = question.lower()
-
-        context = []
-
-        # ---------------------------------------------------
-        # SEARCH
-        # ---------------------------------------------------
-        if self.needs_search(question):
-
-            print("\nRunning web search...")
-
-            web = self.search_tool.search(question)
-
-            context.append(
-                f"WEB SEARCH RESULTS:\n{web}"
-            )
-
-        # ---------------------------------------------------
-        # CHESS
-        # ---------------------------------------------------
-        if "chess" in q:
-
-            context.append(
-                "This is a chess puzzle. "
-                "Return the best move only."
-            )
-
-        # ---------------------------------------------------
-        # CODE
-        # ---------------------------------------------------
-        if "python code" in q:
-
-            context.append(
-                "Infer likely numeric output."
+        try:
+            from groq import Groq
+        except ImportError as e:
+            raise RuntimeError("groq package not installed") from e
+
+        api_key = os.getenv("GROQ_API_KEY")
+        if not api_key:
+            raise RuntimeError(
+                "GROQ_API_KEY is not set. Add it as a Secret in your HF Space settings."
             )
+        self.client = Groq(api_key=api_key)
+        self.model = GROQ_MODEL
+        print(f"GroqAgent initialized with model={self.model}")
+
+    def __call__(self, question: str, task_id: str | None = None) -> str:
+        user_content = question
+        if task_id:
+            user_content = f"task_id: {task_id}\n\nQuestion: {question}"
+
+        messages = [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_content},
+        ]
 
-        # ---------------------------------------------------
-        # YOUTUBE
-        # ---------------------------------------------------
-        if "youtube.com" in q or "youtu.be" in q:
-
-            context.append(
-                "Use search results and inference "
-                "to answer the YouTube question."
+        for step in range(MAX_TOOL_ITERATIONS):
+            try:
+                resp = self.client.chat.completions.create(
+                    model=self.model,
+                    messages=messages,
+                    tools=TOOLS_SPEC,
+                    tool_choice="auto",
+                    temperature=0.0,
+                    max_tokens=1024,
+                )
+            except Exception as e:
+                print(f"Groq API error: {e}")
+                return f"AGENT ERROR: {e}"
+
+            msg = resp.choices[0].message
+            tool_calls = getattr(msg, "tool_calls", None)
+
+            if not tool_calls:
+                answer = (msg.content or "").strip()
+                return self._postprocess_answer(answer)
+
+            # Append assistant message with the tool calls
+            messages.append(
+                {
+                    "role": "assistant",
+                    "content": msg.content or "",
+                    "tool_calls": [
+                        {
+                            "id": tc.id,
+                            "type": "function",
+                            "function": {
+                                "name": tc.function.name,
+                                "arguments": tc.function.arguments,
+                            },
+                        }
+                        for tc in tool_calls
+                    ],
+                }
             )
 
-        return "\n\n".join(context)
-
-    # ---------------------------------------------------
-    # MAIN CALL
-    # ---------------------------------------------------
-    def __call__(self, question: str) -> str:
-
-        try:
-
-            # ---------------------------------------------------
-            # REVERSE STRING
-            # ---------------------------------------------------
-            if question.strip().startswith("."):
-
-                print("Reverse text detected.")
-
-                return self.handle_reverse_text(question)
-
-            # ---------------------------------------------------
-            # CONTEXT
-            # ---------------------------------------------------
-            context = self.build_context(question)
-
-            # ---------------------------------------------------
-            # PROMPT
-            # ---------------------------------------------------
-            system_prompt = """
-You are a lightweight GAIA benchmark solving assistant.
-
-STRICT RULES:
-- Return ONLY the final answer.
-- No explanations.
-- No markdown.
-- No bullet points.
-- No reasoning traces.
-- Keep answers concise.
-- Use context carefully.
-"""
-
-            user_prompt = f"""
-QUESTION:
-{question}
-
-CONTEXT:
-{context}
-"""
-
-            # ---------------------------------------------------
-            # GROQ
-            # ---------------------------------------------------
-            completion = self.client.chat.completions.create(
-                model="llama-3.1-8b-instant",
-                messages=[
+            for tc in tool_calls:
+                name = tc.function.name
+                try:
+                    args = json.loads(tc.function.arguments or "{}")
+                except json.JSONDecodeError:
+                    args = {}
+                fn = TOOL_FUNCTIONS.get(name)
+                print(f"[tool] {name}({args})")
+                if fn is None:
+                    result = f"unknown tool: {name}"
+                else:
+                    try:
+                        result = fn(args)
+                    except Exception as e:
+                        result = f"{name} error: {e}"
+
+                if not isinstance(result, str):
+                    result = str(result)
+                if len(result) > 8000:
+                    result = result[:8000] + "\n...[truncated]"
+
+                messages.append(
                     {
-                        "role": "system",
-                        "content": system_prompt
-                    },
-                    {
-                        "role": "user",
-                        "content": user_prompt
+                        "role": "tool",
+                        "tool_call_id": tc.id,
+                        "name": name,
+                        "content": result,
                     }
-                ],
-                temperature=0,
-                max_tokens=96
+                )
+
+        # Out of iterations: ask for a final, no-tool answer
+        messages.append(
+            {
+                "role": "user",
+                "content": "Stop using tools. Reply with ONLY the final answer string per the formatting rules.",
+            }
+        )
+        try:
+            resp = self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                temperature=0.0,
+                max_tokens=256,
             )
-
-            answer = completion.choices[0].message.content
-
-            cleaned = self.clean_answer(answer)
-
-            print("\n======================")
-            print("QUESTION:")
-            print(question)
-            print("\nANSWER:")
-            print(cleaned)
-            print("======================\n")
-
-            return cleaned
-
+            return self._postprocess_answer((resp.choices[0].message.content or "").strip())
         except Exception as e:
+            return f"AGENT ERROR: {e}"
 
-            print(f"Agent error: {e}")
-
+    @staticmethod
+    def _postprocess_answer(text: str) -> str:
+        if not text:
             return ""
+        # Strip common prefixes the model may sneak in despite instructions.
+        text = text.strip()
+        text = re.sub(r"^(final answer|answer)\s*:\s*", "", text, flags=re.IGNORECASE)
+        # Remove surrounding quotes/backticks
+        if len(text) >= 2 and text[0] == text[-1] and text[0] in {'"', "'", "`"}:
+            text = text[1:-1].strip()
+        return text
 
 
-# ---------------------------------------------------
-# MAIN EVALUATION
-# ---------------------------------------------------
+# ---------------------------------------------------------------------------
+# Gradio submission flow
+# ---------------------------------------------------------------------------
 def run_and_submit_all(profile: gr.OAuthProfile | None):
+    space_id = os.getenv("SPACE_ID")
 
     if profile:
-        username = profile.username
+        username = f"{profile.username}"
+        print(f"User logged in: {username}")
     else:
-        return "Please login first.", None
+        return "Please Login to Hugging Face with the button.", None
 
-    questions_url = f"{DEFAULT_API_URL}/questions"
-    submit_url = f"{DEFAULT_API_URL}/submit"
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
 
-    # ---------------------------------------------------
-    # INIT AGENT
-    # ---------------------------------------------------
     try:
-
-        agent = BasicAgent()
-
+        agent = GroqAgent()
     except Exception as e:
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
 
-        return f"Agent init error: {e}", None
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(agent_code)
 
-    # ---------------------------------------------------
-    # FETCH QUESTIONS
-    # ---------------------------------------------------
+    print(f"Fetching questions from: {questions_url}")
     try:
-
-        response = requests.get(
-            questions_url,
-            timeout=30
-        )
-
+        response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
-
         questions_data = response.json()
-
+        if not questions_data:
+            return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
+    except requests.exceptions.RequestException as e:
+        return f"Error fetching questions: {e}", None
     except Exception as e:
+        return f"An unexpected error occurred fetching questions: {e}", None
 
-        return f"Question fetch error: {e}", None
-
-    answers_payload = []
     results_log = []
-
-    # ---------------------------------------------------
-    # RUN TASKS
-    # ---------------------------------------------------
-    for idx, item in enumerate(questions_data):
-
+    answers_payload = []
+    print(f"Running agent on {len(questions_data)} questions...")
+    for idx, item in enumerate(questions_data, 1):
         task_id = item.get("task_id")
-        question = item.get("question")
-
-        print(f"\nTASK {idx+1}")
-
+        question_text = item.get("question")
+        if not task_id or question_text is None:
+            print(f"Skipping item with missing task_id or question: {item}")
+            continue
+        print(f"\n=== [{idx}/{len(questions_data)}] task_id={task_id} ===")
         try:
-
-            answer = agent(question)
-
-            answers_payload.append({
-                "task_id": task_id,
-                "submitted_answer": answer
-            })
-
-            results_log.append({
-                "Task ID": task_id,
-                "Question": question,
-                "Answer": answer
-            })
-
+            submitted_answer = agent(question_text, task_id=task_id)
         except Exception as e:
-
-            results_log.append({
-                "Task ID": task_id,
-                "Question": question,
-                "Answer": f"ERROR: {e}"
-            })
-
-    # ---------------------------------------------------
-    # SUBMIT
-    # ---------------------------------------------------
-    try:
-
-        submission = {
-            "username": username,
-            "agent_code": "https://huggingface.co",
-            "answers": answers_payload
-        }
-
-        response = requests.post(
-            submit_url,
-            json=submission,
-            timeout=120
+            print(f"Error running agent on task {task_id}: {e}")
+            submitted_answer = f"AGENT ERROR: {e}"
+        answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
+        results_log.append(
+            {"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer}
         )
 
-        result = response.json()
+    if not answers_payload:
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
-        status = (
-            f"Score: {result.get('score')}%\n"
-            f"Correct: "
-            f"{result.get('correct_count')}/"
-            f"{result.get('total_attempted')}"
-        )
-
-        return status, pd.DataFrame(results_log)
+    submission_data = {
+        "username": username.strip(),
+        "agent_code": agent_code,
+        "answers": answers_payload,
+    }
+    print(f"Submitting {len(answers_payload)} answers for user '{username}'...")
 
+    try:
+        response = requests.post(submit_url, json=submission_data, timeout=120)
+        response.raise_for_status()
+        result_data = response.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', 'No message received.')}"
+        )
+        return final_status, pd.DataFrame(results_log)
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"Server responded with status {e.response.status_code}."
+        try:
+            error_detail += f" Detail: {e.response.json().get('detail', e.response.text)}"
+        except requests.exceptions.JSONDecodeError:
+            error_detail += f" Response: {e.response.text[:500]}"
+        return f"Submission Failed: {error_detail}", pd.DataFrame(results_log)
+    except requests.exceptions.Timeout:
+        return "Submission Failed: The request timed out.", pd.DataFrame(results_log)
+    except requests.exceptions.RequestException as e:
+        return f"Submission Failed: Network error - {e}", pd.DataFrame(results_log)
     except Exception as e:
-
-        return f"Submit error: {e}", pd.DataFrame(results_log)
+        return f"An unexpected error occurred during submission: {e}", pd.DataFrame(results_log)
 
 
-# ---------------------------------------------------
-# UI
-# ---------------------------------------------------
+# --- Gradio UI ---
 with gr.Blocks() as demo:
-
-    gr.Markdown("# Lightweight GAIA Agent")
-
-    gr.Markdown("""
-Enabled tools:
-- Groq Llama 3.1 8B Instant
-- DuckDuckGo Search
-- Reverse text handling
-- Lightweight reasoning
-""")
+    gr.Markdown("# GAIA Agent (Groq) — Evaluation Runner")
+    gr.Markdown(
+        """
+        **Setup**
+        1. Add a Space secret named `GROQ_API_KEY` with your Groq API key.
+        2. Optional: set `GROQ_MODEL` (default `llama-3.3-70b-versatile`).
+        3. Log in to Hugging Face below and click **Run Evaluation & Submit All Answers**.
+
+        Tools available to the agent: `web_search`, `fetch_url`, `wikipedia`, `python`, `get_task_file`.
+        """
+    )
 
     gr.LoginButton()
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
-    btn = gr.Button("Run Evaluation")
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
-    output = gr.Textbox(
-        label="Submission Result",
-        lines=6
-    )
-
-    table = gr.DataFrame()
 
-    btn.click(
-        fn=run_and_submit_all,
-        outputs=[output, table]
-    )
+if __name__ == "__main__":
+    print("\n" + "-" * 30 + " App Starting " + "-" * 30)
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID")
 
+    if space_host_startup:
+        print(f"✅ SPACE_HOST found: {space_host_startup}")
+    else:
+        print("ℹ️  SPACE_HOST not found (running locally?).")
 
-# ---------------------------------------------------
-# LAUNCH
-# ---------------------------------------------------
-if __name__ == "__main__":
+    if space_id_startup:
+        print(f"✅ SPACE_ID found: {space_id_startup}")
+        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+    else:
+        print("ℹ️  SPACE_ID not found (running locally?).")
 
-    print("Launching lightweight GAIA agent...")
+    if not os.getenv("GROQ_API_KEY"):
+        print("⚠️  GROQ_API_KEY is not set. Set it before running evaluation.")
 
-    demo.launch()
+    print("-" * (60 + len(" App Starting ")) + "\n")
+    demo.launch(debug=True, share=False)