Update app.py

app.py

@@ -1,506 +1,725 @@
 import os
-import gradio as gr
+import re
+import json
+import base64
+import subprocess
+import tempfile
 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
+# ── helpers ───────────────────────────────────────────────────────────────────
 
-        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."
+def _strip_html(html: str) -> str:
+    from html.parser import HTMLParser
 
-        ytt_api = YouTubeTranscriptApi()
-        fetched = ytt_api.fetch(video_id)
-        transcript_text = " ".join([t.text for t in fetched])
-        return transcript_text[:8000]
+    class _P(HTMLParser):
+        def __init__(self):
+            super().__init__()
+            self.parts = []
+            self._skip = False
+            self._skip_tags = {"script", "style", "nav", "footer", "head"}
 
-    except Exception as e:
-        # Fallback: try fetching via youtubetotranscript
-        try:
-            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:
-                video_id = video_url
+        def handle_starttag(self, tag, attrs):
+            if tag in self._skip_tags:
+                self._skip = True
 
-            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 Exception:
-            pass
-        return f"Transcript fetch failed: {e}"
+        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())
 
-@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)
+    p = _P()
+    p.feed(html)
+    return " ".join(p.parts)
 
-    headers = {
-        "User-Agent": "GaiaResearchBot/1.0 (huggingface educational project)"
-    }
 
-    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:
-        pass
-
-    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 web_search(query: str) -> str:
-    """Search the web using a query string. Returns search results as text.
-    Use this for general web searches. For Wikipedia, prefer wikipedia_fetch_page instead.
-    
-    Args:
-        query: The search query string. Be very specific, include full names to avoid ambiguity.
-    """
-    import time
+# ── agent ──────────────────────────────────────────────────────���──────────────
 
-    for attempt in range(3):
-        try:
-            from duckduckgo_search import DDGS
-            with DDGS() as ddgs:
-                results = list(ddgs.text(query, max_results=8))
-            if results:
-                return "\n\n".join(
-                    f"Title: {r['title']}\nURL: {r['href']}\nSnippet: {r['body']}"
-                    for r in results[:6]
-                )
-        except Exception as e:
-            if attempt < 2:
-                time.sleep(3)
-                continue
-            return f"Search unavailable after retries: {e}"
-
-    return "Search unavailable. Try wikipedia_fetch_page or visit_webpage instead."
-
-
-@tool
-def visit_webpage(url: str) -> str:
-    """Fetch the text content of a webpage. Use this to read full page content from a URL.
-    Tries direct fetch then Wayback Machine as fallback.
-    
-    Args:
-        url: The full URL of the webpage to fetch.
-    """
-    import re
-    import time
-
-    # For Wikipedia URLs, use the API instead
-    if "wikipedia.org/wiki/" in url:
-        page_title = url.split("/wiki/")[-1].replace("_", " ")
-        # Remove URL fragments
-        page_title = page_title.split("#")[0]
-        return wikipedia_fetch_page(page_title)
-
-    # Sites known to block scrapers — go straight to Wayback Machine
-    blocked = [
-        "genius.com", "rateyourmusic.com", "discogs.com",
-        "allmusic.com", "albumoftheyear.org", "famousfix.com",
-        "spotify.com", "apple.com/music"
-    ]
-    use_wayback = any(b in url for b in blocked)
+class BasicAgent:
+    def __init__(self):
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY missing.")
+        self.client = OpenAI(api_key=api_key)
+        self.api_url = DEFAULT_API_URL
+        print("✅ Agent initialised.")
 
-    headers = {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
-                      "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        "Accept-Language": "en-US,en;q=0.5",
-    }
+    # ── raw file fetch ────────────────────────────────────────────────────────
 
-    if not use_wayback:
+    def _fetch_file(self, task_id: str):
+        """Return (bytes, content_type) or (None, '')."""
         try:
-            resp = requests.get(url, headers=headers, timeout=20)
-            if resp.status_code == 200:
-                text = re.sub(r'<[^>]+>', ' ', resp.text)
-                text = re.sub(r'\s+', ' ', text).strip()
-                return text[:8000]
+            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 None, ""
+
+    # ── tools (called by the loop) ────────────────────────────────────────────
+
+    def tool_check_file(self, task_id: str) -> str:
+        """Tell the model whether a file exists and what type it is."""
+        fb, ct = self._fetch_file(task_id)
+        if not fb:
+            return "NO_FILE"
+        ct_clean = ct.split(";")[0].strip().lower()
+        return (
+            f"FILE_EXISTS type={ct_clean} size={len(fb)}_bytes. "
+            f"Use the appropriate tool to read it: "
+            f"image→analyse_image, python→run_python_file, "
+            f"excel/xlsx→read_excel_file, audio→transcribe_audio, "
+            f"text/pdf→read_text_file."
+        )
 
-    # Wayback Machine fallback
-    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)
-            snap_resp = requests.get(snapshot_url, headers=headers, timeout=20)
-            if snap_resp.status_code == 200:
-                text = re.sub(r'<[^>]+>', ' ', snap_resp.text)
-                text = re.sub(r'\s+', ' ', text).strip()
-                return f"[Via Wayback Machine]\n{text[:8000]}"
-    except Exception as e:
-        return f"Could not fetch {url}: {e}"
-
-    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.
-    Only use this for direct image URLs ending in .png, .jpg, .jpeg, .gif, .webp etc.
-    Do NOT use this for YouTube video URLs.
-    
-    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(
+    def tool_analyse_image(self, task_id: str, question: str) -> str:
+        """Pass the image to GPT-4o vision and return its answer."""
+        fb, ct = self._fetch_file(task_id)
+        if not fb:
+            return "No image found."
+        ct_clean = ct.split(";")[0].strip()
+        if "image" not in ct_clean:
+            return f"File is not an image (type={ct_clean})."
+        b64 = base64.b64encode(fb).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_clean};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.
-    ALWAYS call this first for every task. Returns 'NO_FILE_ATTACHED' if no file exists.
-    If it returns 'NO_FILE_ATTACHED', then use web_search or wikipedia_fetch_page instead.
-    
-    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"
-        resp.raise_for_status()
-
-        content_type = resp.headers.get("content-type", "").lower()
-        file_bytes = resp.content
-
-        # Image files
-        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.split(';')[0]};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=1000
-            )
-            return response.choices[0].message.content
-
-        # Text / CSV / JSON / HTML
-        elif any(x in content_type for x in ["text", "csv", "json", "html", "xml"]):
-            text_content = file_bytes.decode("utf-8", errors="ignore")[:12000]
-            response = client.chat.completions.create(
-                model="gpt-4o",
-                messages=[{"role": "user", "content": f"File content:\n{text_content}\n\nQuestion: {question}"}],
-                max_tokens=1000
-            )
-            return response.choices[0].message.content
-
-        # Audio files
-        elif any(x in content_type for x in ["audio", "mp3", "wav", "m4a", "ogg", "mpeg"]):
-            import tempfile
-            ext = content_type.split("/")[-1].split(";")[0]
-            if ext not in ["mp3", "wav", "m4a", "ogg", "webm", "flac"]:
-                ext = "mp3"
-            with tempfile.NamedTemporaryFile(suffix=f".{ext}", delete=False) as f:
-                f.write(file_bytes)
+        return resp.choices[0].message.content or "No response."
+
+    def tool_run_python_file(self, task_id: str) -> str:
+        """Download the Python file, execute it, return stdout/stderr."""
+        fb, ct = self._fetch_file(task_id)
+        if not fb:
+            return "No file found."
+        code = fb.decode("utf-8", errors="ignore")
+        try:
+            with tempfile.NamedTemporaryFile(suffix=".py", delete=False,
+                                             mode="w") as f:
+                f.write(code)
                 fname = f.name
-            with open(fname, "rb") as audio_file:
-                transcript = client.audio.transcriptions.create(
-                    model="whisper-1", file=audio_file
-                )
-            os.unlink(fname)
-            # Now answer the question using the transcript
-            response = client.chat.completions.create(
-                model="gpt-4o",
-                messages=[{"role": "user", "content": f"Audio transcript:\n{transcript.text}\n\nQuestion: {question}"}],
-                max_tokens=500
+            result = subprocess.run(
+                ["python3", fname],
+                capture_output=True, text=True, timeout=30
             )
-            return response.choices[0].message.content
+            out = result.stdout.strip()
+            err = result.stderr.strip()
+            if out:
+                return f"STDOUT:\n{out}"
+            if err:
+                return f"STDERR:\n{err}"
+            return "No output."
+        except Exception as e:
+            return f"Execution error: {e}"
 
-        # Excel / spreadsheet
-        elif any(x in content_type for x in ["excel", "spreadsheet", "xlsx", "xls",
-                                               "openxmlformats", "ms-excel"]):
-            import tempfile
+    def tool_read_excel_file(self, task_id: str, question: str) -> str:
+        """Download xlsx/csv, load with pandas, let GPT-4o answer about it."""
+        fb, ct = self._fetch_file(task_id)
+        if not fb:
+            return "No file found."
+        try:
             import io
-            with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as f:
-                f.write(file_bytes)
-                fname = f.name
-            try:
-                # Actually read the Excel file
-                xl = pd.read_excel(fname, sheet_name=None)
-                all_text = []
-                for sheet_name, df in xl.items():
-                    all_text.append(f"Sheet: {sheet_name}\n{df.to_string(index=False)}")
-                combined = "\n\n".join(all_text)[:12000]
-                os.unlink(fname)
-            except Exception as ex:
-                os.unlink(fname)
-                return f"Could not parse Excel file: {ex}"
-
-            response = client.chat.completions.create(
+            ct_clean = ct.split(";")[0].strip().lower()
+            if "csv" in ct_clean or "text" in ct_clean:
+                df = pd.read_csv(io.BytesIO(fb))
+            else:
+                df = pd.read_excel(io.BytesIO(fb))
+            preview = df.to_string(max_rows=60, max_cols=20)
+            # Ask GPT-4o to answer the question from the data
+            resp = self.client.chat.completions.create(
                 model="gpt-4o",
-                messages=[{"role": "user", "content": f"Spreadsheet data:\n{combined}\n\nQuestion: {question}"}],
-                max_tokens=1000
+                messages=[{
+                    "role": "user",
+                    "content": (
+                        f"Here is a spreadsheet (first 60 rows):\n\n{preview}\n\n"
+                        f"Question: {question}\n"
+                        f"Answer with ONLY the final value, no explanation."
+                    ),
+                }],
+                max_tokens=200,
+                temperature=0,
             )
-            return response.choices[0].message.content
+            return resp.choices[0].message.content or "No answer."
+        except Exception as e:
+            return f"Excel read error: {e}"
 
-        # PDF
-        elif "pdf" in content_type:
-            import tempfile
-            with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as f:
-                f.write(file_bytes)
+    def tool_transcribe_audio(self, task_id: str) -> str:
+        """Download audio and transcribe with Whisper."""
+        fb, ct = self._fetch_file(task_id)
+        if not fb:
+            return "No file found."
+        try:
+            # Guess extension
+            ct_clean = ct.split(";")[0].strip().lower()
+            ext_map = {
+                "audio/mpeg": ".mp3", "audio/mp3": ".mp3",
+                "audio/wav": ".wav", "audio/x-wav": ".wav",
+                "audio/ogg": ".ogg", "audio/flac": ".flac",
+                "audio/m4a": ".m4a", "audio/mp4": ".mp4",
+            }
+            ext = ext_map.get(ct_clean, ".mp3")
+            with tempfile.NamedTemporaryFile(suffix=ext, delete=False) as f:
+                f.write(fb)
                 fname = f.name
-            try:
-                import PyPDF2
-                with open(fname, "rb") as pdf_file:
-                    reader = PyPDF2.PdfReader(pdf_file)
-                    text = "\n".join(page.extract_text() or "" for page in reader.pages)
-                os.unlink(fname)
-            except Exception:
-                # Fallback: send as base64 image of first page
-                os.unlink(fname)
-                b64 = base64.b64encode(file_bytes).decode()
-                response = client.chat.completions.create(
-                    model="gpt-4o",
-                    messages=[{"role": "user", "content": f"I have a PDF file (base64, {len(b64)} chars). Question: {question}. Please note I cannot display the PDF directly."}],
-                    max_tokens=500
+            with open(fname, "rb") as audio_f:
+                transcript = self.client.audio.transcriptions.create(
+                    model="whisper-1", file=audio_f
                 )
-                return response.choices[0].message.content
-
-            response = client.chat.completions.create(
-                model="gpt-4o",
-                messages=[{"role": "user", "content": f"PDF content:\n{text[:12000]}\n\nQuestion: {question}"}],
-                max_tokens=1000
-            )
-            return response.choices[0].message.content
+            return transcript.text
+        except Exception as e:
+            return f"Transcription error: {e}"
 
-        else:
-            # Unknown type — try decoding as text
-            try:
-                text_content = file_bytes.decode("utf-8", errors="ignore")[:8000]
-                if text_content.strip():
-                    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
-            except Exception:
-                pass
-            return f"File downloaded ({len(file_bytes)} bytes, type: {content_type}) but format not supported."
-
-    except requests.exceptions.HTTPError as e:
-        if e.response is not None and e.response.status_code == 404:
-            return "NO_FILE_ATTACHED"
-        return "NO_FILE_ATTACHED"
-    except Exception as e:
-        return "NO_FILE_ATTACHED"
+    def tool_read_text_file(self, task_id: str) -> str:
+        """Read text/PDF file content."""
+        fb, ct = self._fetch_file(task_id)
+        if not fb:
+            return "No file found."
+        try:
+            ct_clean = ct.split(";")[0].strip().lower()
+            if "pdf" in ct_clean:
+                # Try pdfminer or just decode bytes
+                try:
+                    import pdfminer.high_level
+                    import io
+                    text = pdfminer.high_level.extract_text(io.BytesIO(fb))
+                    return text[:6000]
+                except ImportError:
+                    pass
+            return fb.decode("utf-8", errors="ignore")[:6000]
+        except Exception as e:
+            return f"Read error: {e}"
 
+    def tool_search_web(self, query: str) -> str:
+        """DuckDuckGo HTML search – stable from cloud IPs."""
+        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)
+                    if "result__snippet" in d.get("class", ""):
+                        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)
+            return "\n\n".join(p.results[:6]) or "No results."
+        except Exception as e:
+            return f"Search error: {e}"
 
-# --- Agent ---
+    def tool_fetch_webpage(self, url: str) -> str:
+        try:
+            hdrs = {"User-Agent": "Mozilla/5.0 Chrome/124.0"}
+            r = requests.get(url, headers=hdrs, timeout=18)
+            r.raise_for_status()
+            return _strip_html(r.text)[:8000]
+        except Exception as e:
+            return f"Fetch error: {e}"
 
-class BasicAgent:
-    def __init__(self):
-        api_key = os.getenv("OPENAI_API_KEY")
-        if not api_key:
-            raise ValueError("OPENAI_API_KEY is missing!")
+    def tool_fetch_wikipedia(self, title: str) -> str:
+        """Use Wikipedia REST API (no 403 issues)."""
+        try:
+            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:
+                data = r.json()
+                return data.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",
+                    "titles": title, "format": "json", "redirects": 1,
+                },
+                timeout=12,
+            )
+            pages = r2.json().get("query", {}).get("pages", {})
+            for page in pages.values():
+                text = _strip_html(page.get("extract", ""))
+                if text:
+                    return text[:7000]
+        except Exception as e:
+            return f"Wikipedia error: {e}"
+        return "Not found."
 
-        self.model = OpenAIServerModel(
-            model_id="gpt-4o",
-            api_key=api_key
-        )
+    def tool_youtube_transcript(self, video_url: str) -> str:
+        try:
+            from youtube_transcript_api import YouTubeTranscriptApi
+            vid = re.search(r"v=([^&]+)", video_url)
+            if not vid:
+                return "Bad URL."
+            entries = YouTubeTranscriptApi.get_transcript(vid.group(1))
+            return " ".join(e["text"] for e in entries)[:6000]
+        except Exception as e:
+            err = str(e)
+            if any(k in err.lower() for k in
+                   ("blocked", "ip", "cloud", "requestblocked", "ipblocked")):
+                return (
+                    "BLOCKED: YouTube blocks cloud IPs. "
+                    "Use search_web to find transcript/description of this video. "
+                    "Search for the video title + key phrase from the question."
+                )
+            return f"Transcript error: {err}"
+
+    # ── tool dispatch ─────────────────────────────────────────────────────────
+
+    TOOLS = [
+        {
+            "type": "function",
+            "function": {
+                "name": "check_file",
+                "description": (
+                    "ALWAYS call this first. Checks if a file is attached to the task. "
+                    "Returns 'NO_FILE' or info about the file type and how to read it."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {"task_id": {"type": "string"}},
+                    "required": ["task_id"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "analyse_image",
+                "description": (
+                    "Analyse an image file attached to the task using GPT-4o vision. "
+                    "Use for chess boards, diagrams, photos, screenshots."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "task_id": {"type": "string"},
+                        "question": {"type": "string",
+                                     "description": "What to find/answer from the image."},
+                    },
+                    "required": ["task_id", "question"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "run_python_file",
+                "description": (
+                    "Execute the Python file attached to the task and return its output. "
+                    "Use when the task asks for the output of Python code."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {"task_id": {"type": "string"}},
+                    "required": ["task_id"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "read_excel_file",
+                "description": (
+                    "Read an Excel or CSV file attached to the task and answer "
+                    "a question about its data."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "task_id": {"type": "string"},
+                        "question": {"type": "string"},
+                    },
+                    "required": ["task_id", "question"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "transcribe_audio",
+                "description": (
+                    "Transcribe an audio file attached to the task using Whisper. "
+                    "Use for voice memos, recordings, audio questions."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {"task_id": {"type": "string"}},
+                    "required": ["task_id"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "read_text_file",
+                "description": "Read a text or PDF file attached to the task.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {"task_id": {"type": "string"}},
+                    "required": ["task_id"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "youtube_transcript",
+                "description": (
+                    "Fetch YouTube video transcript. If cloud-blocked, "
+                    "returns instructions to use search_web instead."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {"video_url": {"type": "string"}},
+                    "required": ["video_url"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "search_web",
+                "description": "Search the web via 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 content 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. "
+                    "Always use this instead of fetch_webpage for Wikipedia."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {"title": {"type": "string"}},
+                    "required": ["title"],
+                },
+            },
+        },
+    ]
 
-        self.agent = CodeAgent(
-            tools=[
-                web_search,
-                visit_webpage,
-                wikipedia_fetch_page,
-                analyze_image_from_url,
-                analyze_task_file,
-                get_youtube_transcript,
-            ],
-            model=self.model,
-            add_base_tools=True,
-            max_steps=15,
-        )
-        print("✅ OpenAI-powered Agent initialized.")
+    def _dispatch(self, fn: str, args: dict, task_id: str, question: str) -> str:
+        if fn == "check_file":
+            return self.tool_check_file(args.get("task_id", task_id))
+        if fn == "analyse_image":
+            return self.tool_analyse_image(
+                args.get("task_id", task_id), args.get("question", question))
+        if fn == "run_python_file":
+            return self.tool_run_python_file(args.get("task_id", task_id))
+        if fn == "read_excel_file":
+            return self.tool_read_excel_file(
+                args.get("task_id", task_id), args.get("question", question))
+        if fn == "transcribe_audio":
+            return self.tool_transcribe_audio(args.get("task_id", task_id))
+        if fn == "read_text_file":
+            return self.tool_read_text_file(args.get("task_id", task_id))
+        if fn == "youtube_transcript":
+            return self.tool_youtube_transcript(args.get("video_url", ""))
+        if fn == "search_web":
+            return self.tool_search_web(args.get("query", ""))
+        if fn == "fetch_webpage":
+            return self.tool_fetch_webpage(args.get("url", ""))
+        if fn == "fetch_wikipedia":
+            return self.tool_fetch_wikipedia(args.get("title", ""))
+        return "Unknown tool."
+
+    # ── system prompt ─────────────────────────────────────────────────────────
+
+    SYSTEM = """You are a precise research agent solving GAIA benchmark tasks.
+
+MANDATORY WORKFLOW — follow every step, no exceptions:
+
+STEP 1 — Always call check_file(task_id) first, regardless of the question.
+  • If NO_FILE → go to STEP 2.
+  • If FILE_EXISTS image → call analyse_image(task_id, full_question).
+  • If FILE_EXISTS python → call run_python_file(task_id). The output IS the answer.
+  • If FILE_EXISTS excel/xlsx/csv → call read_excel_file(task_id, question).
+  • If FILE_EXISTS audio → call transcribe_audio(task_id), then answer from transcript.
+  • If FILE_EXISTS text/pdf → call read_text_file(task_id), then answer from content.
+  CRITICAL: NEVER return "NO_FILE" or any tool status string as your final answer.
+
+STEP 2 — Gather information using tools.
+  • YouTube URL in question → call youtube_transcript(url) first.
+    If BLOCKED → use search_web("video title + key phrase") to find the answer.
+  • Wikipedia question → call fetch_wikipedia("Exact Article Title").
+    For discography → look at Studio albums table. Count ONLY solo studio albums.
+    Do NOT count: collaborations, live albums, compilations, EPs.
+  • LibreTexts 1.E Exercises → fetch_webpage with EXACT URL:
+    https://chem.libretexts.org/Bookshelves/Introductory_Chemistry/Introductory_Chemistry_(LibreTexts)/02%3A_Measurement_and_Problem_Solving/2.E%3A_Measurement_and_Problem_Solving_(Exercises)
+  • Wikipedia Featured Articles → fetch_webpage:
+    https://en.wikipedia.org/wiki/Wikipedia:Featured_articles_promoted_in_2016
+    Then search for the specific article's nomination page.
+  • Sports stats → search_web("player name stat year site:baseball-reference.com")
+    then fetch_webpage the result URL for exact numbers.
+  • For ANY other factual question → search_web, then fetch_webpage top result.
+
+STEP 3 — If first search fails, try different search terms. Try at least 2-3
+  different approaches before giving up. Never say "I was unable to find."
+
+STEP 4 — Answer format:
+  • Return ONLY the final value. No explanation. No "The answer is".
+  • Numbers: just the number (e.g. "3" not "3 albums").
+  • Names: just the name.
+  • Yes/No: just "yes" or "no".
+  • Lists: comma-separated values."""
+
+    # ── main call ─────────────────────────────────────────────────────────────
 
     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 before doing anything else.\n"
-            "  * If it returns a real answer (not 'NO_FILE_ATTACHED'), use that answer.\n"
-            "  * If it returns 'NO_FILE_ATTACHED', proceed with web_search or wikipedia_fetch_page.\n"
-            "- For Wikipedia lookups, ALWAYS use wikipedia_fetch_page with the EXACT article title.\n"
-            "  GOOD: wikipedia_fetch_page('Mercedes Sosa')\n"
-            "  GOOD: wikipedia_fetch_page('Giganotosaurus')\n"
-            "  BAD: web_search('Mercedes Sosa wikipedia')\n"
-            "- When web searching, use full specific names/phrases to avoid ambiguity.\n"
-            "- For YouTube video links, ALWAYS call get_youtube_transcript(video_url) FIRST.\n"
-            "  If transcript fetch fails, do web_search with the video ID or title.\n"
-            "- To read a full webpage, use visit_webpage(url).\n"
-            "- For chess positions in images, analyze_task_file will return the move directly.\n"
-            "- Provide ONLY the final direct answer. No explanations, no punctuation unless needed.\n"
-            "  Examples: '42', 'FunkMonk', 'right', 'Louvrier', 'b,e'\n"
-        )
+        print(f"▶ Task {task_id[:8]}: {question[:80]}")
+
+        # Pre-attach image to messages if task has an image file
+        fb, ct = self._fetch_file(task_id)
+        ct_clean = (ct or "").split(";")[0].strip().lower()
+
+        user_content = []
+        if fb and "image" in ct_clean:
+            b64 = base64.b64encode(fb).decode()
+            user_content.append({
+                "type": "image_url",
+                "image_url": {"url": f"data:{ct_clean};base64,{b64}",
+                              "detail": "high"},
+            })
+
+        user_content.append({
+            "type": "text",
+            "text": f"task_id: {task_id}\n\nTask: {question}",
+        })
+
+        messages = [
+            {"role": "system", "content": self.SYSTEM},
+            {"role": "user", "content": user_content},
+        ]
+
+        for _round in range(10):
+            try:
+                resp = self.client.chat.completions.create(
+                    model="gpt-4o",
+                    messages=messages,
+                    tools=self.TOOLS,
+                    tool_choice="auto",
+                    temperature=0,
+                    max_tokens=1500,
+                )
+            except Exception as e:
+                print(f"  OpenAI error: {e}")
+                return "Error."
+
+            msg = resp.choices[0].message
+
+            # No tool calls → we have the answer
+            if not msg.tool_calls:
+                answer = (msg.content or "").strip()
+                # Reject bad answers
+                bad = ("no_file", "file_exists", "i was unable",
+                       "i couldn't", "i can't access", "please provide",
+                       "you might want", "i'm unable")
+                if any(b in answer.lower() for b in bad):
+                    # Force a retry with a harder nudge
+                    messages.append({
+                        "role": "assistant",
+                        "content": answer,
+                    })
+                    messages.append({
+                        "role": "user",
+                        "content": (
+                            "That answer is not acceptable. "
+                            "Use your tools to find the real answer. "
+                            "Try search_web or fetch_wikipedia. "
+                            "Return ONLY the final value."
+                        ),
+                    })
+                    continue
+                return answer
+
+            # Append assistant turn
+            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
+                ],
+            })
+
+            # Execute tools
+            for tc in msg.tool_calls:
+                fn = tc.function.name
+                try:
+                    args = json.loads(tc.function.arguments)
+                except Exception:
+                    args = {}
+                result = self._dispatch(fn, args, task_id, question)
+                print(f"   {fn}({list(args.values())[:1]}) → {str(result)[:80]}")
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": tc.id,
+                    "content": result or "Empty result.",
+                })
+
+        # Force final answer
         try:
-            result = self.agent.run(prompt)
-            return str(result).strip()
-        except Exception as e:
-            print(f"❌ Error: {e}")
-            return "Error finding answer."
+            messages.append({
+                "role": "user",
+                "content": "Final answer only – just the value, no explanation.",
+            })
+            resp = self.client.chat.completions.create(
+                model="gpt-4o", messages=messages,
+                temperature=0, max_tokens=100,
+            )
+            return (resp.choices[0].message.content or "").strip()
+        except Exception:
+            return "Error."
 
 
-# --- 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"Init 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}"
+        print(f"  → Answer: {answer[:60]}")
 
-    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": f"https://huggingface.co/spaces/{space_id}/tree/main",
+                "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(
+        "Handles: images · Python execution · Excel · audio transcription · "
+        "Wikipedia · YouTube · web search"
+    )
     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")
-    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
+    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()