Update app.py

app.py

@@ -1,420 +1,534 @@
 import os
-import gradio as gr
+import re
+import json
+import base64
 import requests
 import pandas as pd
-from smolagents import CodeAgent, OpenAIServerModel, tool
+import gradio as gr
 from openai import OpenAI
-import base64
 
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Custom Tools ---
-@tool
-def get_youtube_transcript(video_url: str) -> str:
-    """Fetch the transcript/captions of a YouTube video.
-    
-    Args:
-        video_url: The full YouTube video URL e.g. https://www.youtube.com/watch?v=XXXXX
-    """
-    try:
-        from youtube_transcript_api import YouTubeTranscriptApi
-        
-        if "v=" in video_url:
-            video_id = video_url.split("v=")[-1].split("&")[0]
-        elif "youtu.be/" in video_url:
-            video_id = video_url.split("youtu.be/")[-1].split("?")[0]
-        else:
-            return "Could not extract video ID."
-        
-        # New API style (v0.6.0+)
-        ytt_api = YouTubeTranscriptApi()
-        fetched = ytt_api.fetch(video_id)
-        transcript_text = " ".join([t.text for t in fetched])
-        return transcript_text[:8000]
-        
-    except Exception as e:
-        # Fallback: try fetching via youtubetotranscript API
+# ── helpers ──────────────────────────────────────────────────────────────────
+
+def _strip_html(html: str) -> str:
+    from html.parser import HTMLParser
+
+    class _P(HTMLParser):
+        def __init__(self):
+            super().__init__()
+            self.parts = []
+            self._skip = False
+            self._skip_tags = {"script", "style", "nav", "footer", "head"}
+
+        def handle_starttag(self, tag, attrs):
+            if tag in self._skip_tags:
+                self._skip = True
+
+        def handle_endtag(self, tag):
+            if tag in self._skip_tags:
+                self._skip = False
+
+        def handle_data(self, data):
+            if not self._skip and data.strip():
+                self.parts.append(data.strip())
+
+    p = _P()
+    p.feed(html)
+    return " ".join(p.parts)
+
+
+# ── agent ─────────────────────────────────────────────────────────────────────
+
+class BasicAgent:
+    def __init__(self):
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY missing – add it to Space Secrets.")
+        self.client = OpenAI(api_key=api_key)
+        self.api_url = DEFAULT_API_URL
+        print("✅ Agent initialised.")
+
+    # ── tool implementations ──────────────────────────────────────────────────
+
+    def fetch_task_file(self, task_id: str):
         try:
-            resp = requests.get(
-                f"https://youtubetotranscript.com/transcript?v={video_id}",
-                headers={"User-Agent": "Mozilla/5.0"},
-                timeout=15
-            )
-            if resp.status_code == 200:
-                import re
-                text = re.sub(r'<[^>]+>', ' ', resp.text)
-                text = re.sub(r'\s+', ' ', text).strip()
-                return text[:6000]
-        except:
+            r = requests.get(f"{self.api_url}/files/{task_id}", timeout=15)
+            if r.status_code == 200 and r.content:
+                return r.content, r.headers.get("Content-Type", "")
+        except Exception:
             pass
-        return f"Transcript fetch failed: {e}"
-
-@tool
-def wikipedia_fetch_page(page_title: str) -> str:
-    """Fetch the full content of a specific Wikipedia page by its exact title.
-    
-    Args:
-        page_title: The exact Wikipedia page title, e.g. 'Mercedes Sosa' or 'Mercedes Sosa discography'.
-    """
-    import time
-    time.sleep(1)  # avoid rate limiting
-    
-    headers = {
-        "User-Agent": "GaiaResearchBot/1.0 (huggingface educational project)"
-    }
-    
-    # Try action API with full extract
-    try:
-        params = {
-            "action": "query",
-            "titles": page_title,
-            "prop": "extracts",
-            "explaintext": True,
-            "exsectionformat": "plain",
-            "format": "json",
-            "redirects": 1,
-        }
-        resp = requests.get(
-            "https://en.wikipedia.org/w/api.php",
-            params=params,
-            headers=headers,
-            timeout=20
-        )
-        resp.raise_for_status()
-        data = resp.json()
-        pages = data.get("query", {}).get("pages", {})
-        for pid, page in pages.items():
-            if pid == "-1":
-                return f"Page '{page_title}' not found on Wikipedia."
-            return page.get("extract", "No content.")[:10000]
-    except Exception as e:
-        pass
-    
-    # Fallback: try wikimedia API
-    try:
-        url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{page_title.replace(' ', '_')}"
-        resp = requests.get(url, headers=headers, timeout=15)
-        data = resp.json()
-        return data.get("extract", "No summary found.")
-    except Exception as e:
-        return f"Failed to fetch Wikipedia page: {e}"
-
-
-@tool
-def search_web(query: str) -> str:
-    """Search the web using a query string. Returns search results as text.
-    
-    Args:
-        query: The search query string. Be very specific, include full names to avoid ambiguity.
-    """
-    import time
-    
-    # Try DuckDuckGo with retries
-    for attempt in range(3):
+        return None, ""
+
+    def search_web(self, query: str) -> str:
+        try:
+            hdrs = {
+                "User-Agent": (
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                    "AppleWebKit/537.36 (KHTML, like Gecko) "
+                    "Chrome/124.0 Safari/537.36"
+                )
+            }
+            r = requests.get(
+                "https://html.duckduckgo.com/html/",
+                params={"q": query},
+                headers=hdrs,
+                timeout=12,
+            )
+            from html.parser import HTMLParser
+
+            class _DDG(HTMLParser):
+                def __init__(self):
+                    super().__init__()
+                    self.results = []
+                    self._in = False
+                    self._cur = ""
+
+                def handle_starttag(self, tag, attrs):
+                    d = dict(attrs)
+                    cls = d.get("class", "")
+                    if tag in ("a", "span") and "result__snippet" in cls:
+                        self._in = True
+                        self._cur = ""
+
+                def handle_data(self, data):
+                    if self._in:
+                        self._cur += data
+
+                def handle_endtag(self, tag):
+                    if self._in:
+                        t = self._cur.strip()
+                        if t:
+                            self.results.append(t)
+                        self._in = False
+
+            p = _DDG()
+            p.feed(r.text)
+            snippets = p.results[:6]
+            if snippets:
+                return "\n\n".join(snippets)
+        except Exception as e:
+            return f"Search error: {e}"
+        return "No results."
+
+    def fetch_webpage(self, url: str) -> str:
         try:
-            from duckduckgo_search import DDGS
-            with DDGS() as ddgs:
-                results = list(ddgs.text(query, max_results=6))
-            if results:
-                # Filter out obviously irrelevant results
-                filtered = [r for r in results if query.split()[0].lower() in 
-                           (r['title'] + r['body']).lower()]
-                use_results = filtered if filtered else results
-                return "\n\n".join(
-                    f"Title: {r['title']}\nURL: {r['href']}\nSnippet: {r['body']}"
-                    for r in use_results[:5]
+            hdrs = {
+                "User-Agent": (
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                    "AppleWebKit/537.36 (KHTML, like Gecko) "
+                    "Chrome/124.0 Safari/537.36"
                 )
+            }
+            r = requests.get(url, headers=hdrs, timeout=18)
+            r.raise_for_status()
+            return _strip_html(r.text)[:8000]
         except Exception as e:
-            time.sleep(2)
-            continue
-    
-    return "Search unavailable. Try wikipedia_fetch_page or visit_url instead."
-
-
-@tool
-def visit_url(url: str) -> str:
-    """Fetch the text content of a webpage. Tries direct fetch then Wayback Machine.
-    
-    Args:
-        url: The full URL of the webpage to fetch.
-    """
-    import re, time
-    
-    # Don't even try sites known to block bots
-    blocked = ["genius.com", "rateyourmusic.com", "discogs.com", 
-               "allmusic.com", "albumoftheyear.org", "famousfix.com"]
-    if any(b in url for b in blocked):
-        # Go straight to Wayback Machine for these
+            return f"Error fetching {url}: {e}"
+
+    def fetch_wikipedia(self, title: str) -> str:
         try:
-            wb_api = f"https://archive.org/wayback/available?url={url}&timestamp=20221201"
-            wb_resp = requests.get(wb_api, timeout=10)
-            snapshot = wb_resp.json().get("archived_snapshots", {}).get("closest", {})
-            snapshot_url = snapshot.get("url")
-            if snapshot_url:
-                time.sleep(1)
-                headers = {"User-Agent": "Mozilla/5.0"}
-                snap_resp = requests.get(snapshot_url, headers=headers, timeout=20)
-                text = re.sub(r'<[^>]+>', ' ', snap_resp.text)
-                text = re.sub(r'\s+', ' ', text).strip()
-                return f"[Via Wayback Machine]\n{text[:6000]}"
+            slug = requests.utils.quote(title.replace(" ", "_"))
+            r = requests.get(
+                f"https://en.wikipedia.org/api/rest_v1/page/summary/{slug}",
+                timeout=12,
+            )
+            if r.status_code == 200:
+                return r.json().get("extract", "Not found.")
+            # fallback: full extract via w/api.php
+            r2 = requests.get(
+                "https://en.wikipedia.org/w/api.php",
+                params={
+                    "action": "query",
+                    "prop": "extracts",
+                    "exintro": True,
+                    "titles": title,
+                    "format": "json",
+                },
+                timeout=12,
+            )
+            pages = r2.json().get("query", {}).get("pages", {})
+            for page in pages.values():
+                extract = _strip_html(page.get("extract", ""))
+                if extract:
+                    return extract[:6000]
         except Exception as e:
-            return f"Wayback Machine fetch failed for {url}: {e}"
-    
-    # For Wikipedia, use the API instead
-    if "wikipedia.org/wiki/" in url:
-        page_title = url.split("/wiki/")[-1].replace("_", " ")
-        return wikipedia_fetch_page(page_title)
-    
-    headers = {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-    }
-    
-    try:
-        resp = requests.get(url, headers=headers, timeout=15)
-        if resp.status_code == 200:
-            text = re.sub(r'<[^>]+>', ' ', resp.text)
-            text = re.sub(r'\s+', ' ', text).strip()
+            return f"Wikipedia error: {e}"
+        return "Not found."
+
+    def fetch_youtube_transcript(self, video_url: str) -> str:
+        try:
+            from youtube_transcript_api import YouTubeTranscriptApi
+            vid_id = re.search(r"v=([^&]+)", video_url)
+            if not vid_id:
+                return "Could not parse video ID."
+            entries = YouTubeTranscriptApi.get_transcript(vid_id.group(1))
+            text = " ".join(e["text"] for e in entries)
             return text[:6000]
-    except Exception:
-        pass
-    
-    # Fallback: Wayback Machine
-    try:
-        wb_api = f"https://archive.org/wayback/available?url={url}&timestamp=20221201"
-        wb_resp = requests.get(wb_api, timeout=10)
-        snapshot_url = wb_resp.json().get("archived_snapshots", {}).get("closest", {}).get("url")
-        if snapshot_url:
-            snap_resp = requests.get(snapshot_url, headers=headers, timeout=20)
-            text = re.sub(r'<[^>]+>', ' ', snap_resp.text)
-            text = re.sub(r'\s+', ' ', text).strip()
-            return f"[Via Wayback Machine]\n{text[:6000]}"
-    except Exception as e:
-        pass
-    
-    return f"Could not fetch {url}"
-
-@tool
-def analyze_image_from_url(image_url: str, question: str) -> str:
-    """Analyze an image from a URL using GPT-4o vision and answer a question about it.
-    
-    Args:
-        image_url: The direct URL to the image file to analyze.
-        question: The question to answer about the image content.
-    """
-    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-    try:
-        response = client.chat.completions.create(
+        except Exception as e:
+            err = str(e)
+            if any(k in err.lower() for k in ("blocked", "ip", "cloud", "requestblocked")):
+                return (
+                    "TRANSCRIPT_UNAVAILABLE: cloud IP blocked by YouTube. "
+                    "Use search_web to find the video title, description, or "
+                    "third-party pages that describe its content."
+                )
+            return f"Transcript error: {err}"
+
+    # ── image analysis ────────────────────────────────────────────────────────
+
+    def _analyse_image(self, task_id: str, question: str) -> str:
+        file_bytes, content_type = self.fetch_task_file(task_id)
+        if not file_bytes or "image" not in (content_type or ""):
+            return "No image found for this task."
+        ct = content_type.split(";")[0].strip()
+        b64 = base64.b64encode(file_bytes).decode()
+        resp = self.client.chat.completions.create(
             model="gpt-4o",
             messages=[{
                 "role": "user",
                 "content": [
-                    {"type": "image_url", "image_url": {"url": image_url}},
-                    {"type": "text", "text": question}
-                ]
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:{ct};base64,{b64}",
+                            "detail": "high",
+                        },
+                    },
+                    {"type": "text", "text": question},
+                ],
             }],
-            max_tokens=500
+            max_tokens=800,
+            temperature=0,
         )
-        return response.choices[0].message.content
-    except Exception as e:
-        return f"Image analysis failed: {e}"
-
-@tool
-def analyze_task_file(task_id: str, question: str) -> str:
-    """Download and analyze a file attached to a GAIA task.
-    
-    Args:
-        task_id: The GAIA task ID used to fetch the associated file.
-        question: The question to answer based on the file content.
-    """
-    api_url = DEFAULT_API_URL
-    file_url = f"{api_url}/files/{task_id}"
-    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-
-    try:
-        resp = requests.get(file_url, timeout=30)
-        if resp.status_code == 404:
-            return "NO_FILE_ATTACHED"  # Signal to agent to use other tools
-        resp.raise_for_status()
-
-        content_type = resp.headers.get("content-type", "")
-        file_bytes = resp.content
-
-        if any(x in content_type for x in ["image", "png", "jpeg", "jpg", "gif", "webp"]):
-            b64 = base64.b64encode(file_bytes).decode()
-            data_url = f"data:{content_type};base64,{b64}"
-            response = client.chat.completions.create(
-                model="gpt-4o",
-                messages=[{"role": "user", "content": [
-                    {"type": "image_url", "image_url": {"url": data_url}},
-                    {"type": "text", "text": question}
-                ]}],
-                max_tokens=500
-            )
-            return response.choices[0].message.content
-
-        elif any(x in content_type for x in ["text", "csv", "json", "html"]):
-            text_content = file_bytes.decode("utf-8", errors="ignore")[:8000]
-            response = client.chat.completions.create(
-                model="gpt-4o",
-                messages=[{"role": "user", "content": f"File content:\n{text_content}\n\nQuestion: {question}"}],
-                max_tokens=500
-            )
-            return response.choices[0].message.content
-
-        elif any(x in content_type for x in ["audio", "mp3", "wav", "m4a", "ogg", "mpeg"]):
-            import tempfile
-            suffix = "." + content_type.split("/")[-1].split(";")[0]
-            with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as f:
-                f.write(file_bytes)
-                fname = f.name
-            with open(fname, "rb") as audio_file:
-                transcript = client.audio.transcriptions.create(
-                    model="whisper-1", file=audio_file
-                )
-            return f"Audio transcript: {transcript.text}"
-
-        elif any(x in content_type for x in ["excel", "spreadsheet", "xlsx", "xls"]):
-            import tempfile, subprocess
-            with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as f:
-                f.write(file_bytes)
-                fname = f.name
-            response = client.chat.completions.create(
-                model="gpt-4o",
-                messages=[{"role": "user", "content": f"I have an Excel file. {question}. The file is at {fname}. Please note I cannot execute code - give me your best analysis based on context."}],
-                max_tokens=500
-            )
-            return response.choices[0].message.content
-
-        else:
-            return f"File downloaded ({len(file_bytes)} bytes, type: {content_type}) but format not yet supported."
-
-    except Exception as e:
-        return f"NO_FILE_ATTACHED"
-
-
-# --- Agent ---
-
-class BasicAgent:
-    def __init__(self):
-        api_key = os.getenv("OPENAI_API_KEY")
-        if not api_key:
-            raise ValueError("OPENAI_API_KEY is missing!")
-
-        self.model = OpenAIServerModel(
-            model_id="gpt-4o",
-            api_key=api_key
+        return resp.choices[0].message.content or "No description."
+
+    # ── messages ──────────────────────────────────────────────────────────────
+
+    def _build_messages(self, question: str, task_id: str) -> list:
+        system = (
+            "You are an expert research agent solving GAIA benchmark tasks.\n\n"
+            "STRICT RULES:\n"
+            "1. Call get_task_file(task_id) FIRST for every task.\n"
+            "   - If it returns 'NO_FILE', proceed with other tools.\n"
+            "   - If it says a file is attached AND the task involves an image "
+            "(chess board, diagram, photo), call analyse_image_file(task_id, question) "
+            "to get a vision description. Then reason from that description.\n"
+            "   - NEVER return 'NO_FILE' or any tool result directly as your final answer.\n\n"
+            "2. YouTube tasks: call get_youtube_transcript(url) first.\n"
+            "   If blocked, use search_web to find what the video says "
+            "(search for the exact video title + key phrase from the question).\n\n"
+            "3. Wikipedia tasks: use fetch_wikipedia(exact_title).\n"
+            "   For discography tasks, fetch the artist's Wikipedia page and look "
+            "at the Studio albums table. Count ONLY the artist's SOLO studio albums. "
+            "Do NOT count collaborative albums, live albums, or compilations.\n\n"
+            "4. LibreTexts 1.E Exercises: fetch this EXACT URL for the Introductory "
+            "Chemistry bookshelf version (not campus remixes):\n"
+            "https://chem.libretexts.org/Bookshelves/Introductory_Chemistry/"
+            "Introductory_Chemistry_(LibreTexts)/02%3A_Measurement_and_Problem_Solving/"
+            "2.E%3A_Measurement_and_Problem_Solving_(Exercises)\n\n"
+            "5. Final answer: ONLY the value – no explanation, no 'The answer is'."
         )
 
-        self.agent = CodeAgent(
-            tools=[
-                search_web,
-                visit_url,
-                wikipedia_fetch_page,
-                analyze_image_from_url,
-                analyze_task_file,
-                get_youtube_transcript
-            ],
-            model=self.model,
-            add_base_tools=True,
-            max_steps=12,
-        )
-        print("✅ OpenAI-powered Agent initialized.")
+        file_bytes, content_type = self.fetch_task_file(task_id)
+        user_parts = []
+
+        if file_bytes and content_type:
+            ct = content_type.split(";")[0].strip()
+            if "image" in ct:
+                b64 = base64.b64encode(file_bytes).decode()
+                user_parts.append({
+                    "type": "image_url",
+                    "image_url": {"url": f"data:{ct};base64,{b64}", "detail": "high"},
+                })
+                user_parts.append({
+                    "type": "text",
+                    "text": f"The image above is attached to this task.\n\nTask: {question}",
+                })
+            else:
+                try:
+                    text = file_bytes.decode("utf-8", errors="ignore")[:6000]
+                except Exception:
+                    text = "(binary file)"
+                user_parts.append({
+                    "type": "text",
+                    "text": f"Attached file:\n{text}\n\nTask: {question}",
+                })
+        else:
+            user_parts.append({"type": "text", "text": f"Task: {question}"})
+
+        return [
+            {"role": "system", "content": system},
+            {"role": "user", "content": user_parts},
+        ]
+
+    # ── tool specs ────────────────────────────────────────────────────────────
+
+    TOOLS = [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_task_file",
+                "description": (
+                    "Check if a file is attached to this GAIA task. "
+                    "Returns 'NO_FILE' or a description of the file. "
+                    "ALWAYS call this first."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {"task_id": {"type": "string"}},
+                    "required": ["task_id"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "analyse_image_file",
+                "description": (
+                    "Use GPT-4o vision to analyse the image attached to a task. "
+                    "Call this after get_task_file confirms an image file exists "
+                    "and the task requires visual reasoning (chess, diagrams, photos)."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "task_id": {"type": "string"},
+                        "question": {
+                            "type": "string",
+                            "description": "What to look for / answer from the image.",
+                        },
+                    },
+                    "required": ["task_id", "question"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "get_youtube_transcript",
+                "description": (
+                    "Fetch the transcript of a YouTube video. "
+                    "Returns 'TRANSCRIPT_UNAVAILABLE' if cloud-blocked – "
+                    "in that case use search_web to find info about the video."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {"video_url": {"type": "string"}},
+                    "required": ["video_url"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "search_web",
+                "description": "Search the web using DuckDuckGo. Returns top snippets.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {"query": {"type": "string"}},
+                    "required": ["query"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "fetch_webpage",
+                "description": "Fetch and read the full text of any URL.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {"url": {"type": "string"}},
+                    "required": ["url"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "fetch_wikipedia",
+                "description": (
+                    "Fetch a Wikipedia article by exact title via the REST API "
+                    "(avoids 403 errors). Use for all Wikipedia lookups."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {"title": {"type": "string"}},
+                    "required": ["title"],
+                },
+            },
+        },
+    ]
+
+    # ── main ──────────────────────────────────────────────────────────────────
 
     def __call__(self, question: str, task_id: str = "") -> str:
-        print(f"DEBUG: Agent received question: {question[:100]}...")
-
-        prompt = (
-            f"You are a precise research agent solving GAIA benchmark tasks.\n"
-            f"Task ID: {task_id}\n"
-            f"Task: {question}\n\n"
-            "Instructions:\n"
-            "- ALWAYS call analyze_task_file first for every task. If it returns 'NO_FILE_ATTACHED', proceed with web search.\n"
-            "- For Wikipedia lookups, use wikipedia_fetch_page with the EXACT article title.\n"
-            "  Example: wikipedia_fetch_page('Mercedes Sosa') NOT web_search('Mercedes Sosa')\n"
-            "- When searching, use FULL specific names to avoid ambiguity.\n"
-            "  BAD: 'Mercedes Sosa albums 2000 to 2009' (confuses with Mercedes-Benz)\n"
-            "  GOOD: wikipedia_fetch_page('Mercedes Sosa discography')\n"
-            "- If a Wikipedia page 404s, try the parent page e.g. 'Mercedes Sosa' instead.\n"
-            "- For YouTube links, ALWAYS call get_youtube_transcript(video_url) FIRST before any web search.\n"
-            "- Provide ONLY the final direct answer. No explanations, just the value.\n"
-        )
+        print(f"▶ Task {task_id[:8]}: {question[:80]}")
+        messages = self._build_messages(question, task_id)
+
+        for _ in range(8):
+            try:
+                resp = self.client.chat.completions.create(
+                    model="gpt-4o",
+                    messages=messages,
+                    tools=self.TOOLS,
+                    tool_choice="auto",
+                    temperature=0,
+                    max_tokens=1200,
+                )
+            except Exception as e:
+                print(f"  OpenAI error: {e}")
+                return "Error finding answer."
+
+            msg = resp.choices[0].message
+
+            if not msg.tool_calls:
+                return (msg.content or "").strip()
+
+            messages.append({
+                "role": "assistant",
+                "content": msg.content,
+                "tool_calls": [
+                    {
+                        "id": tc.id,
+                        "type": "function",
+                        "function": {
+                            "name": tc.function.name,
+                            "arguments": tc.function.arguments,
+                        },
+                    }
+                    for tc in msg.tool_calls
+                ],
+            })
+
+            for tc in msg.tool_calls:
+                fn = tc.function.name
+                try:
+                    args = json.loads(tc.function.arguments)
+                except Exception:
+                    args = {}
+
+                if fn == "get_task_file":
+                    fb, ct = self.fetch_task_file(args.get("task_id", task_id))
+                    result = (
+                        f"File attached – content_type: {ct}, size: {len(fb)} bytes."
+                        if fb else "NO_FILE"
+                    )
+                elif fn == "analyse_image_file":
+                    result = self._analyse_image(
+                        args.get("task_id", task_id),
+                        args.get("question", question),
+                    )
+                elif fn == "get_youtube_transcript":
+                    result = self.fetch_youtube_transcript(args.get("video_url", ""))
+                elif fn == "search_web":
+                    result = self.search_web(args.get("query", ""))
+                elif fn == "fetch_webpage":
+                    result = self.fetch_webpage(args.get("url", ""))
+                elif fn == "fetch_wikipedia":
+                    result = self.fetch_wikipedia(args.get("title", ""))
+                else:
+                    result = "Unknown tool."
+
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": tc.id,
+                    "content": result or "Empty result.",
+                })
+
+        # Force final answer after max rounds
         try:
-            result = self.agent.run(prompt)
-            return str(result).strip()
-        except Exception as e:
-            print(f"❌ Error: {e}")
+            messages.append({
+                "role": "user",
+                "content": "Give your best final answer now – value only, no explanation.",
+            })
+            resp = self.client.chat.completions.create(
+                model="gpt-4o",
+                messages=messages,
+                temperature=0,
+                max_tokens=200,
+            )
+            return (resp.choices[0].message.content or "").strip()
+        except Exception:
             return "Error finding answer."
 
 
-# --- Gradio + Submission ---
+# ── Gradio UI ─────────────────────────────────────────────────────────────────
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    if profile:
-        username = f"{profile.username}"
-        print(f"Logged in as: {username}")
-    else:
-        return "Please Login to Hugging Face first.", None
+    if not profile:
+        return "Please login to Hugging Face first.", None
 
-    space_id = os.getenv("SPACE_ID")
+    username = profile.username
+    space_id = os.getenv("SPACE_ID", "")
     api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
 
     try:
         agent = BasicAgent()
     except Exception as e:
-        return f"Initialization Failed: {e}", None
+        return f"Initialisation failed: {e}", None
 
     try:
-        response = requests.get(questions_url, timeout=15)
-        response.raise_for_status()
-        questions_data = response.json()
+        qs = requests.get(f"{api_url}/questions", timeout=15)
+        qs.raise_for_status()
+        questions_data = qs.json()
     except Exception as e:
         return f"Error fetching questions: {e}", None
 
-    results_log = []
-    answers_payload = []
+    results_log, answers_payload = [], []
 
     for item in questions_data:
         task_id = item.get("task_id", "")
         question_text = item.get("question", "")
         try:
-            submitted_answer = agent(question_text, task_id=task_id)
-            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            results_log.append({"Task ID": task_id, "Question": question_text[:80], "Answer": submitted_answer})
+            answer = agent(question_text, task_id=task_id)
         except Exception as e:
-            results_log.append({"Task ID": task_id, "Question": question_text[:80], "Answer": f"Error: {e}"})
+            answer = f"Error: {e}"
 
-    submission_data = {
-        "username": username.strip(),
-        "agent_code": agent_code,
-        "answers": answers_payload
-    }
+        answers_payload.append({"task_id": task_id, "submitted_answer": answer})
+        results_log.append({
+            "Task ID": task_id,
+            "Question": question_text[:120],
+            "Answer": answer,
+        })
 
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
-        response.raise_for_status()
-        res = response.json()
+        r = requests.post(
+            f"{api_url}/submit",
+            json={
+                "username": username.strip(),
+                "agent_code": agent_code,
+                "answers": answers_payload,
+            },
+            timeout=60,
+        )
+        r.raise_for_status()
+        res = r.json()
         status = (
-            f"Submission Successful!\n"
-            f"Score: {res.get('score')}% ({res.get('correct_count')}/{res.get('total_attempted')})\n"
+            f"✅ Submitted!\n"
+            f"Score: {res.get('score')}% "
+            f"({res.get('correct_count')}/{res.get('total_attempted')})\n"
             f"Message: {res.get('message')}"
         )
-        return status, pd.DataFrame(results_log)
     except Exception as e:
-        return f"Submission Failed: {e}", pd.DataFrame(results_log)
+        status = f"Submission failed: {e}"
+
+    return status, pd.DataFrame(results_log)
 
 
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 🤖 GAIA Agent Evaluation")
-    gr.Markdown("Click Login, then Run to evaluate your agent on the GAIA dataset.")
+    gr.Markdown(
+        "Fixes applied: chess image via GPT-4o vision · YouTube IP-block fallback · "
+        "correct LibreTexts canonical URL · solo-only discography counting · "
+        "stable DDG HTML scrape."
+    )
     gr.LoginButton()
     run_button = gr.Button("🚀 Run Evaluation & Submit", variant="primary")
-    status_output = gr.Textbox(label="Status", lines=4)
-    results_table = gr.DataFrame(label="Agent Performance Log")
+    status_output = gr.Textbox(label="Status", lines=5)
+    results_table = gr.DataFrame(label="Results")
     run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if __name__ == "__main__":
-    demo.launch(ssr_mode=False)
+    demo.launch()