Update app.py

app.py

@@ -1,520 +1,555 @@
 import os
 import re
-import base64
-import gradio as gr
+import json
+import time
 import requests
+import tempfile
+import gradio as gr
 import pandas as pd
-from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
 
-# --- Constants ---
+# ─────────────────────────────────────────────
+# Constants
+# ─────────────────────────────────────────────
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+HF_API_URL      = "https://api-inference.huggingface.co/models"
+
+# ─────────────────────────────────────────────
+# HF Inference helpers
+# ─────────────────────────────────────────────
+
+def hf_token() -> str:
+    tok = os.getenv("HF_TOKEN", "")
+    if not tok:
+        raise EnvironmentError("HF_TOKEN environment variable is not set.")
+    return tok
+
+def hf_headers() -> dict:
+    return {"Authorization": f"Bearer {hf_token()}"}
 
-# ─────────────────────────────────────────────────────────────
-# LLM DIRECT — appel HTTP simple, pas de smolagents
-# ─────────────────────────────────────────────────────────────
-
-def call_llm(messages: list, max_tokens: int = 512) -> str:
-    """Appel direct à Qwen2.5-72B via HF Inference API."""
-    hf_token = os.getenv("HF_TOKEN", "")
-    models = [
-        "Qwen/Qwen2.5-72B-Instruct",
-        "Qwen/Qwen2.5-32B-Instruct",
-        "meta-llama/Llama-3.3-70B-Instruct",
-        "mistralai/Mistral-7B-Instruct-v0.3",
-    ]
-    for model_id in models:
+
+def chat_llm(messages: list[dict], model: str = "meta-llama/Llama-3.3-70B-Instruct",
+             max_tokens: int = 1024, temperature: float = 0.1) -> str:
+    """
+    Chat completion via HF Inference API (serverless).
+    messages = [{"role": "user"|"assistant"|"system", "content": "..."}]
+    """
+    url = f"https://api-inference.huggingface.co/models/{model}/v1/chat/completions"
+    payload = {
+        "model": model,
+        "messages": messages,
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+        "stream": False,
+    }
+    for attempt in range(3):
         try:
-            resp = requests.post(
-                f"https://api-inference.huggingface.co/models/{model_id}/v1/chat/completions",
-                headers={"Authorization": f"Bearer {hf_token}", "Content-Type": "application/json"},
-                json={"model": model_id, "messages": messages, "max_tokens": max_tokens, "temperature": 0.1},
-                timeout=60,
-            )
-            resp.raise_for_status()
-            content = resp.json()["choices"][0]["message"]["content"].strip()
-            print(f"  LLM ({model_id[:30]}): {content[:80]}")
-            return content
+            r = requests.post(url, headers=hf_headers(), json=payload, timeout=120)
+            if r.status_code == 503:          # model loading
+                wait = int(r.headers.get("X-Wait-Time", 20))
+                print(f"Model loading, waiting {wait}s …")
+                time.sleep(wait)
+                continue
+            r.raise_for_status()
+            data = r.json()
+            return data["choices"][0]["message"]["content"].strip()
         except Exception as e:
-            print(f"  LLM {model_id[:30]} failed: {e}")
-            continue
-    return "ERROR: all models failed"
-
-
-def call_vision(image_bytes: bytes, content_type: str, question: str) -> str:
-    """Appel Qwen2.5-VL-7B pour analyser une image."""
-    hf_token = os.getenv("HF_TOKEN", "")
-    ext = content_type.split("/")[-1].split(";")[0].strip()
-    if ext == "jpg":
-        ext = "jpeg"
-    media_type = f"image/{ext}"
-    b64 = base64.b64encode(image_bytes).decode("utf-8")
-    vision_models = ["Qwen/Qwen2.5-VL-7B-Instruct", "Qwen/Qwen2-VL-7B-Instruct"]
-    for model_id in vision_models:
+            print(f"chat_llm attempt {attempt+1} error: {e}")
+            time.sleep(5)
+    return ""
+
+
+def vision_llm(image_bytes: bytes, prompt: str,
+               model: str = "meta-llama/Llama-3.2-11B-Vision-Instruct") -> str:
+    """
+    Vision (image → text) via HF Inference API.
+    """
+    import base64
+    b64 = base64.b64encode(image_bytes).decode()
+    url = f"https://api-inference.huggingface.co/models/{model}/v1/chat/completions"
+    messages = [{
+        "role": "user",
+        "content": [
+            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}},
+            {"type": "text", "text": prompt},
+        ]
+    }]
+    payload = {"model": model, "messages": messages, "max_tokens": 512}
+    for attempt in range(3):
         try:
-            resp = requests.post(
-                f"https://api-inference.huggingface.co/models/{model_id}/v1/chat/completions",
-                headers={"Authorization": f"Bearer {hf_token}"},
-                json={
-                    "model": model_id,
-                    "messages": [{
-                        "role": "user",
-                        "content": [
-                            {"type": "image_url", "image_url": {"url": f"data:{media_type};base64,{b64}"}},
-                            {"type": "text", "text": f"{question}\nGive ONLY the exact answer, nothing else."}
-                        ]
-                    }],
-                    "max_tokens": 200,
-                    "temperature": 0.1,
-                },
-                timeout=60,
-            )
-            resp.raise_for_status()
-            answer = resp.json()["choices"][0]["message"]["content"].strip()
-            print(f"  Vision ({model_id[:30]}): {answer[:80]}")
-            return answer
+            r = requests.post(url, headers=hf_headers(), json=payload, timeout=120)
+            if r.status_code == 503:
+                time.sleep(int(r.headers.get("X-Wait-Time", 20)))
+                continue
+            r.raise_for_status()
+            return r.json()["choices"][0]["message"]["content"].strip()
         except Exception as e:
-            print(f"  Vision {model_id[:30]} failed: {e}")
-            continue
-    return "Unable to analyze image"
+            print(f"vision_llm attempt {attempt+1}: {e}")
+            time.sleep(5)
+    return ""
+
 
+def transcribe_audio(audio_bytes: bytes,
+                     model: str = "openai/whisper-large-v3") -> str:
+    """Transcribe audio bytes via HF Inference API."""
+    url = f"{HF_API_URL}/{model}"
+    for attempt in range(3):
+        try:
+            r = requests.post(url, headers=hf_headers(), data=audio_bytes, timeout=120)
+            if r.status_code == 503:
+                time.sleep(int(r.headers.get("X-Wait-Time", 20)))
+                continue
+            r.raise_for_status()
+            return r.json().get("text", "")
+        except Exception as e:
+            print(f"transcribe attempt {attempt+1}: {e}")
+            time.sleep(5)
+    return ""
 
-# ─────────────────────────────────────────────────────────────
-# TOOLS — fonctions Python pures
-# ─────────────────────────────────────────────────────────────
 
-def tool_search(query: str) -> str:
-    """Recherche DuckDuckGo."""
+# ─────────────────────────────────────────────
+# Tool: Web search (DuckDuckGo – no key needed)
+# ─────────────────────────────────────────────
+
+def web_search(query: str, max_results: int = 5) -> str:
+    """Search the web via DuckDuckGo Instant Answer API."""
     try:
-        headers = {"User-Agent": "Mozilla/5.0"}
-        resp = requests.get(
-            "https://api.duckduckgo.com/",
-            params={"q": query, "format": "json", "no_html": 1, "skip_disambig": 1},
-            headers=headers, timeout=10,
-        )
-        data = resp.json()
+        url = "https://api.duckduckgo.com/"
+        params = {"q": query, "format": "json", "no_html": 1, "skip_disambig": 1}
+        r = requests.get(url, params=params, timeout=15)
+        r.raise_for_status()
+        data = r.json()
         results = []
         if data.get("AbstractText"):
             results.append(data["AbstractText"])
-        for t in data.get("RelatedTopics", [])[:5]:
-            if isinstance(t, dict) and t.get("Text"):
-                results.append(t["Text"])
-        if results:
-            return "\n".join(results[:5])
-        # Fallback lite
-        resp2 = requests.get(
-            "https://lite.duckduckgo.com/lite/",
-            params={"q": query}, headers=headers, timeout=10,
-        )
-        clean = re.sub(r"<[^>]+>", " ", resp2.text)
-        clean = re.sub(r"\s+", " ", clean).strip()
-        return clean[:2000]
+        for topic in data.get("RelatedTopics", [])[:max_results]:
+            if isinstance(topic, dict) and topic.get("Text"):
+                results.append(topic["Text"])
+        return "\n".join(results) if results else "No results found."
     except Exception as e:
         return f"Search error: {e}"
 
 
-def tool_download_file(task_id: str) -> tuple:
-    """Télécharge le fichier associé à un task_id. Retourne (bytes, content_type)."""
+def web_fetch(url: str, max_chars: int = 4000) -> str:
+    """Fetch a webpage and return its text content."""
+    try:
+        headers = {"User-Agent": "Mozilla/5.0 (compatible; GAIAAgent/1.0)"}
+        r = requests.get(url, headers=headers, timeout=20)
+        r.raise_for_status()
+        # Simple HTML → text stripping
+        text = re.sub(r"<[^>]+>", " ", r.text)
+        text = re.sub(r"\s+", " ", text).strip()
+        return text[:max_chars]
+    except Exception as e:
+        return f"Fetch error: {e}"
+
+
+def wikipedia_search(query: str) -> str:
+    """Search Wikipedia for a query."""
     try:
-        url = f"{DEFAULT_API_URL}/files/{task_id}"
-        resp = requests.get(url, timeout=30)
-        if resp.status_code != 200:
-            return None, f"HTTP {resp.status_code}"
-        return resp.content, resp.headers.get("Content-Type", "")
+        url = "https://en.wikipedia.org/w/api.php"
+        params = {
+            "action": "query", "list": "search",
+            "srsearch": query, "format": "json", "srlimit": 3,
+        }
+        r = requests.get(url, params=params, timeout=15)
+        data = r.json()
+        snippets = []
+        for item in data["query"]["search"]:
+            snippets.append(f"**{item['title']}**: {re.sub('<[^>]+>','',item['snippet'])}")
+        if not snippets:
+            return "No Wikipedia results."
+        # Fetch first article intro
+        title = data["query"]["search"][0]["title"]
+        ex_url = "https://en.wikipedia.org/w/api.php"
+        ex_params = {
+            "action": "query", "prop": "extracts",
+            "exintro": True, "explaintext": True,
+            "titles": title, "format": "json",
+        }
+        er = requests.get(ex_url, params=ex_params, timeout=15)
+        pages = er.json()["query"]["pages"]
+        extract = next(iter(pages.values())).get("extract", "")[:3000]
+        return f"Search hits:\n" + "\n".join(snippets) + f"\n\nTop article ({title}):\n{extract}"
     except Exception as e:
-        return None, str(e)
+        return f"Wikipedia error: {e}"
+
 
+# ─────────────────────────────────────────────
+# Tool: File download from GAIA API
+# ─────────────────────────────────────────────
 
-def tool_parse_file(content: bytes, content_type: str) -> str:
-    """Parse le contenu d'un fichier en texte."""
+def download_task_file(task_id: str, api_url: str = DEFAULT_API_URL) -> bytes | None:
+    """Download a file associated with a task_id from the GAIA API."""
     try:
-        if any(t in content_type for t in ["text", "json", "csv"]):
-            return content.decode("utf-8", errors="replace")[:6000]
-        if "excel" in content_type or "spreadsheet" in content_type or "openxmlformats" in content_type:
-            import io, openpyxl
-            wb = openpyxl.load_workbook(io.BytesIO(content))
-            out = []
-            for sname in wb.sheetnames:
-                ws = wb[sname]
-                out.append(f"=== Sheet: {sname} ===")
-                for row in ws.iter_rows(values_only=True):
-                    out.append("\t".join("" if c is None else str(c) for c in row))
-            return "\n".join(out)[:8000]
-        if "pdf" in content_type:
-            import io, pypdf
-            reader = pypdf.PdfReader(io.BytesIO(content))
-            return "\n".join(p.extract_text() or "" for p in reader.pages[:15])[:6000]
-        return content.decode("utf-8", errors="replace")[:4000]
+        url = f"{api_url}/files/{task_id}"
+        r = requests.get(url, timeout=30)
+        if r.status_code == 200:
+            return r.content
+        return None
     except Exception as e:
-        return f"Parse error: {e}"
+        print(f"File download error: {e}")
+        return None
 
 
-def tool_python(code: str) -> str:
-    """Exécute du code Python."""
-    import io, sys, traceback
-    buf = io.StringIO()
-    old = sys.stdout; sys.stdout = buf
+def read_pdf_bytes(pdf_bytes: bytes) -> str:
+    """Extract text from PDF bytes using pypdf."""
     try:
-        exec(code, {"__builtins__": __builtins__, "pd": pd, "re": re})
-        return buf.getvalue() or "(no output)"
+        import io
+        from pypdf import PdfReader
+        reader = PdfReader(io.BytesIO(pdf_bytes))
+        text = "\n".join(page.extract_text() or "" for page in reader.pages)
+        return text[:6000]
+    except Exception as e:
+        return f"PDF read error: {e}"
+
+
+def read_excel_bytes(excel_bytes: bytes) -> str:
+    """Read Excel/CSV bytes and return a string summary."""
+    try:
+        import io
+        df = pd.read_excel(io.BytesIO(excel_bytes))
+        return df.to_string(index=False)[:4000]
     except Exception:
-        return traceback.format_exc()
-    finally:
-        sys.stdout = old
+        try:
+            import io
+            df = pd.read_csv(io.BytesIO(excel_bytes))
+            return df.to_string(index=False)[:4000]
+        except Exception as e:
+            return f"Excel read error: {e}"
+
 
+def read_python_bytes(code_bytes: bytes) -> str:
+    """Return Python code as string."""
+    return code_bytes.decode("utf-8", errors="replace")[:4000]
 
-# ─────────────────────────────────────────────────────────────
-# AGENT — boucle ReAct simple et robuste
-# ─────────────────────────────────────────────────────────────
 
-SYSTEM_PROMPT = """You are a precise AI assistant solving GAIA benchmark questions.
+# ─────────────────────────────────────────────
+# Tool: Python code execution (safe sandbox)
+# ─────────────────────────────────────────────
 
-You can use tools by writing exactly:
-SEARCH: <your search query>
-CODE: <python code using print() to show results>
-FILE: already provided in context
+def run_python(code: str) -> str:
+    """Execute Python code and return stdout/result."""
+    import subprocess, sys
+    try:
+        result = subprocess.run(
+            [sys.executable, "-c", code],
+            capture_output=True, text=True, timeout=30,
+        )
+        out = result.stdout.strip()
+        err = result.stderr.strip()
+        if out:
+            return out
+        if err:
+            return f"STDERR: {err}"
+        return "(no output)"
+    except subprocess.TimeoutExpired:
+        return "Code execution timed out."
+    except Exception as e:
+        return f"Execution error: {e}"
+
+
+# ─────────────────────────────────────────────
+# Core Agent
+# ─────────────────────────────────────────────
+
+SYSTEM_PROMPT = """You are an expert research agent solving questions from the GAIA benchmark.
+You reason carefully and use tools when needed.
+
+TOOLS available (call them by writing a JSON block):
+- web_search(query) – search the web
+- wikipedia_search(query) – search Wikipedia
+- web_fetch(url) – fetch a webpage
+- run_python(code) – execute Python code and get result
+- read_file_summary – (provided automatically when a file is attached)
 
 RULES:
 1. Think step by step before answering.
-2. Use SEARCH for Wikipedia facts, historical data, people, places.
-3. Use CODE for calculations, data analysis, string manipulation.
-4. Final answer must be on its own line starting with: ANSWER: <value>
-5. Answer must be SHORT and EXACT: a number, name, short phrase, or comma-separated list.
-6. NO explanation after ANSWER:
-7. For reversed text like ".rewsna" → decode it first then answer.
-8. For botanical vegetables → exclude bell pepper, corn, zucchini, green beans (they are botanical fruits).
-9. Never write "I don't know" — always give best answer.
-
-Example:
-Question: What is the capital of France?
-ANSWER: Paris
-
-Question: How many albums did X release between 2000-2009?
-SEARCH: X discography Wikipedia
-[results show 3 albums]
-ANSWER: 3
+2. For factual questions, search Wikipedia or the web.
+3. For math/logic, write and run Python code.
+4. Your FINAL answer must be on the LAST line starting with ANSWER: 
+   followed by ONLY the answer (no extra explanation).
+5. Keep answers as short as possible – exact match is required.
+6. Never include "FINAL ANSWER" text in your response.
+
+TOOL CALL FORMAT (use when needed):
+{"tool": "web_search", "args": {"query": "..."}}
+{"tool": "wikipedia_search", "args": {"query": "..."}}
+{"tool": "web_fetch", "args": {"url": "..."}}
+{"tool": "run_python", "args": {"code": "..."}}
 """
 
 
-def run_react_agent(question: str, task_id: str = None, max_steps: int = 5) -> str:
-    """Boucle ReAct : pense → agit → observe → répond."""
-    print(f"\n{'='*50}\nQ: {question[:80]}")
-
-    # Contexte initial
-    file_text = ""
-    file_bytes = None
-    file_ctype = ""
-    is_image = False
-
-    # Télécharger le fichier si task_id disponible
-    if task_id:
-        file_bytes, file_ctype = tool_download_file(task_id)
-        if file_bytes:
-            if any(t in file_ctype for t in ["image", "png", "jpg", "jpeg", "gif", "webp"]):
-                is_image = True
-                print(f"  → Image file detected")
-            else:
-                file_text = tool_parse_file(file_bytes, file_ctype)
-                print(f"  → File parsed ({len(file_text)} chars)")
-
-    # Route directe pour les images
-    if is_image and file_bytes:
-        answer = call_vision(file_bytes, file_ctype, question)
-        return clean_answer(answer)
-
-    # Construction du contexte
-    context = f"Question: {question}\n"
-    if file_text:
-        context += f"\n[ATTACHED FILE CONTENT]:\n{file_text[:4000]}\n"
-
-    messages = [
-        {"role": "system", "content": SYSTEM_PROMPT},
-        {"role": "user", "content": context + "\nThink step by step, use tools if needed, then give ANSWER:"},
-    ]
-
-    for step in range(max_steps):
-        response = call_llm(messages, max_tokens=600)
-
-        # Chercher ANSWER: dans la réponse
-        answer_match = re.search(r"ANSWER:\s*(.+?)(?:\n|$)", response, re.IGNORECASE)
-
-        # Chercher des tool calls
-        search_match = re.search(r"SEARCH:\s*(.+?)(?:\n|$)", response, re.IGNORECASE)
-        code_match = re.search(r"CODE:\s*```?python?\n?(.*?)```?(?:\n|$)", response, re.IGNORECASE | re.DOTALL)
-        if not code_match:
-            code_match = re.search(r"CODE:\s*(.+?)(?=SEARCH:|ANSWER:|$)", response, re.IGNORECASE | re.DOTALL)
-
-        # Si on a une réponse finale ET pas de tool calls → on s'arrête
-        if answer_match and not search_match and not code_match:
-            return clean_answer(answer_match.group(1).strip())
-
-        # Exécuter les tools
-        tool_results = []
-
-        if search_match:
-            query = search_match.group(1).strip()
-            print(f"  SEARCH: {query[:60]}")
-            result = tool_search(query)
-            tool_results.append(f"[Search '{query}']:\n{result[:1500]}")
-
-        if code_match:
-            code = code_match.group(1).strip()
-            print(f"  CODE: {code[:60]}")
-            result = tool_python(code)
-            tool_results.append(f"[Code output]:\n{result[:1000]}")
-
-        if tool_results:
-            # Ajouter les résultats et relancer
+def call_tool(tool_name: str, args: dict) -> str:
+    if tool_name == "web_search":
+        return web_search(args.get("query", ""))
+    elif tool_name == "wikipedia_search":
+        return wikipedia_search(args.get("query", ""))
+    elif tool_name == "web_fetch":
+        return web_fetch(args.get("url", ""))
+    elif tool_name == "run_python":
+        return run_python(args.get("code", ""))
+    return f"Unknown tool: {tool_name}"
+
+
+def extract_tool_call(text: str) -> tuple[str, dict] | None:
+    """Extract a tool call JSON from the model output."""
+    pattern = r'\{[^{}]*"tool"\s*:\s*"([^"]+)"[^{}]*"args"\s*:\s*(\{[^{}]*\})[^{}]*\}'
+    match = re.search(pattern, text, re.DOTALL)
+    if match:
+        tool_name = match.group(1)
+        try:
+            args = json.loads(match.group(2))
+            return tool_name, args
+        except json.JSONDecodeError:
+            pass
+    return None
+
+
+def extract_answer(text: str) -> str:
+    """Extract the final answer from the model's response."""
+    # Look for ANSWER: on a line
+    for line in reversed(text.split("\n")):
+        line = line.strip()
+        if line.upper().startswith("ANSWER:"):
+            answer = line[7:].strip()
+            return answer
+    # Fallback: last non-empty line
+    lines = [l.strip() for l in text.split("\n") if l.strip()]
+    return lines[-1] if lines else text.strip()
+
+
+class GAIAAgent:
+    def __init__(self, api_url: str = DEFAULT_API_URL, max_turns: int = 8):
+        self.api_url = api_url
+        self.max_turns = max_turns
+        print("GAIAAgent initialized.")
+
+    def __call__(self, question: str, task_id: str = "") -> str:
+        print(f"\n{'='*60}")
+        print(f"Task: {task_id}")
+        print(f"Question: {question[:120]}...")
+
+        # Check for attached file
+        file_context = ""
+        if task_id:
+            file_bytes = download_task_file(task_id, self.api_url)
+            if file_bytes:
+                # Detect file type by magic bytes or try different parsers
+                if file_bytes[:4] == b"%PDF":
+                    content = read_pdf_bytes(file_bytes)
+                    file_context = f"\n[ATTACHED FILE - PDF]\n{content}\n[END FILE]\n"
+                elif file_bytes[:2] in (b"PK", b"\xd0\xcf"):  # ZIP/XLSX or OLE/XLS
+                    content = read_excel_bytes(file_bytes)
+                    file_context = f"\n[ATTACHED FILE - SPREADSHEET]\n{content}\n[END FILE]\n"
+                elif file_bytes[:3] in (b"ID3", b"\xff\xfb", b"\xff\xf3"):  # MP3
+                    content = transcribe_audio(file_bytes)
+                    file_context = f"\n[ATTACHED FILE - AUDIO TRANSCRIPTION]\n{content}\n[END FILE]\n"
+                else:
+                    # Try as text/code
+                    try:
+                        content = file_bytes.decode("utf-8", errors="replace")[:4000]
+                        file_context = f"\n[ATTACHED FILE - TEXT/CODE]\n{content}\n[END FILE]\n"
+                    except Exception:
+                        file_context = "\n[ATTACHED FILE - binary, unreadable]\n"
+                print(f"File loaded: {len(file_bytes)} bytes")
+
+        # Detect YouTube URL in question
+        yt_match = re.search(r'https?://(?:www\.)?youtube\.com/watch\?v=([A-Za-z0-9_-]+)|https?://youtu\.be/([A-Za-z0-9_-]+)', question)
+        yt_context = ""
+        if yt_match:
+            vid_id = yt_match.group(1) or yt_match.group(2)
+            # Fetch YouTube transcript via a public endpoint
+            yt_context = self._get_youtube_transcript(vid_id)
+
+        user_content = question
+        if file_context:
+            user_content += "\n" + file_context
+        if yt_context:
+            user_content += "\n" + yt_context
+
+        messages = [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_content},
+        ]
+
+        for turn in range(self.max_turns):
+            response = chat_llm(messages)
+            print(f"\n[Turn {turn+1}] Model response:\n{response[:400]}...")
+
+            if not response:
+                break
+
             messages.append({"role": "assistant", "content": response})
+
+            # Check for tool call
+            tool_call = extract_tool_call(response)
+            if tool_call:
+                tool_name, args = tool_call
+                print(f"  → Calling tool: {tool_name}({args})")
+                tool_result = call_tool(tool_name, args)
+                print(f"  → Tool result: {tool_result[:200]}...")
+                messages.append({
+                    "role": "user",
+                    "content": f"Tool result for {tool_name}:\n{tool_result}\n\nContinue reasoning and provide your final answer with ANSWER: on the last line."
+                })
+                continue
+
+            # Check if we have a final answer
+            if "ANSWER:" in response.upper():
+                answer = extract_answer(response)
+                print(f"  → Final answer: {answer}")
+                return answer
+
+            # If no tool call and no answer, prompt for conclusion
             messages.append({
                 "role": "user",
-                "content": "\n\n".join(tool_results) + "\n\nBased on these results, give your final ANSWER: (short, exact, nothing else after it)"
+                "content": "Please provide your final answer now. Write ANSWER: followed by just the answer on the last line."
             })
-        elif answer_match:
-            # On a une réponse même avec des tool calls → l'utiliser
-            return clean_answer(answer_match.group(1).strip())
-        else:
-            # Pas de tool calls, pas de réponse → forcer
-            messages.append({"role": "assistant", "content": response})
-            messages.append({"role": "user", "content": "Give your final ANSWER: now. Just the answer, nothing else."})
-
-    # Dernier essai
-    final = call_llm(messages, max_tokens=100)
-    m = re.search(r"ANSWER:\s*(.+?)(?:\n|$)", final, re.IGNORECASE)
-    if m:
-        return clean_answer(m.group(1).strip())
-
-    # Réponse directe sans structure
-    direct = call_llm([
-        {"role": "system", "content": "Answer with ONLY the exact answer. No explanation. No preamble."},
-        {"role": "user", "content": f"Question: {question}\nAnswer:"}
-    ], max_tokens=150)
-    return clean_answer(direct)
-
-
-def clean_answer(answer: str) -> str:
-    """Nettoie les préfixes verbeux."""
-    answer = answer.strip()
-    prefixes = [
-        "final answer:", "answer:", "the answer is", "result:",
-        "the final answer is", "based on", "according to",
-        "therefore,", "thus,", "so the answer is",
-    ]
-    low = answer.lower()
-    for p in prefixes:
-        if low.startswith(p):
-            answer = answer[len(p):].strip()
-            low = answer.lower()
-    # Si trop long, prendre dernière ligne courte
-    if len(answer) > 250:
-        lines = [l.strip() for l in answer.splitlines() if l.strip()]
-        for line in reversed(lines):
-            if 0 < len(line) < 200:
-                return line
-    return answer
-
-
-# ─────────────────────────────────────────────────────────────
-# CLASSE AGENT (interface compatible avec le template)
-# ─────────────────────────────────────────────────────────────
 
-class GAIAAgent:
-    def __init__(self):
-        hf_token = os.getenv("HF_TOKEN", "")
-        if not hf_token:
-            raise ValueError("HF_TOKEN not set! Add it in Space Settings → Secrets.")
-        print("GAIAAgent initialized (direct HTTP ReAct loop, no smolagents).")
+        # Last attempt to extract answer
+        if messages and messages[-1]["role"] == "assistant":
+            return extract_answer(messages[-1]["content"])
 
-    def __call__(self, question: str) -> str:
-        # Extraire task_id
-        m = re.match(r"\[task_id=([^\]]+)\]\s*", question)
-        task_id = m.group(1) if m else None
-        clean_q = re.sub(r"^\[task_id=[^\]]+\]\s*", "", question).strip()
-        return run_react_agent(clean_q, task_id=task_id, max_steps=5)
+        return "Unable to determine answer."
 
+    def _get_youtube_transcript(self, video_id: str) -> str:
+        """Try to get YouTube transcript/captions."""
+        try:
+            # Try youtube-transcript-api style endpoint
+            url = f"https://www.youtube.com/watch?v={video_id}"
+            page = web_fetch(url, max_chars=8000)
+            # Look for caption data in the page
+            if "captionTracks" in page:
+                cap_match = re.search(r'"captionTracks":\[.*?"baseUrl":"([^"]+)"', page)
+                if cap_match:
+                    cap_url = cap_match.group(1).replace("\\u0026", "&")
+                    cap_text = web_fetch(cap_url, max_chars=5000)
+                    # Strip XML tags
+                    cap_text = re.sub(r"<[^>]+>", " ", cap_text)
+                    cap_text = re.sub(r"\s+", " ", cap_text).strip()
+                    return f"\n[YOUTUBE TRANSCRIPT]\n{cap_text}\n[END TRANSCRIPT]\n"
+            # Fallback: return page description
+            desc_match = re.search(r'"description":.*?"simpleText":"([^"]{20,})"', page)
+            if desc_match:
+                return f"\n[YOUTUBE VIDEO DESCRIPTION]\n{desc_match.group(1)[:1000]}\n"
+            return f"\n[YOUTUBE PAGE (partial)]\n{page[:2000]}\n"
+        except Exception as e:
+            return f"\n[Could not fetch YouTube content: {e}]\n"
 
-# ─────────────────────────────────────────────────────────────
-# run_and_submit_all
-# ─────────────────────────────────────────────────────────────
+
+# ─────────────────────────────────────────────
+# Gradio UI
+# ─────────────────────────────────────────────
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """
-    Fetches all questions, runs the GAIAAgent on them, submits all answers,
-    and displays the results.
-    """
     space_id = os.getenv("SPACE_ID")
 
     if profile:
-        username = f"{profile.username}"
+        username = profile.username
         print(f"User logged in: {username}")
     else:
-        print("User not logged in.")
-        return "Please Login to Hugging Face with the button.", None
+        return "Please login to Hugging Face first.", None
 
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
+    submit_url    = f"{api_url}/submit"
 
-    # 1. Instantiate Agent
+    # Instantiate agent
     try:
-        agent = GAIAAgent()
+        agent = GAIAAgent(api_url=api_url)
     except Exception as e:
-        print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
 
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(agent_code)
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "local"
 
-    # 2. Fetch Questions
-    print(f"Fetching questions from: {questions_url}")
+    # Fetch questions
     try:
-        response = requests.get(questions_url, timeout=15)
-        response.raise_for_status()
-        questions_data = response.json()
+        r = requests.get(questions_url, timeout=15)
+        r.raise_for_status()
+        questions_data = r.json()
         if not questions_data:
-            print("Fetched questions list is empty.")
-            return "Fetched questions list is empty or invalid format.", None
+            return "No questions returned.", None
         print(f"Fetched {len(questions_data)} questions.")
-    except requests.exceptions.RequestException as e:
-        print(f"Error fetching questions: {e}")
-        return f"Error fetching questions: {e}", None
-    except requests.exceptions.JSONDecodeError as e:
-        print(f"Error decoding JSON response from questions endpoint: {e}")
-        print(f"Response text: {response.text[:500]}")
-        return f"Error decoding server response for questions: {e}", None
     except Exception as e:
-        print(f"An unexpected error occurred fetching questions: {e}")
-        return f"An unexpected error occurred fetching questions: {e}", None
+        return f"Error fetching questions: {e}", None
 
-    # 3. Run Agent — PARALLÈLE avec timeout par question
-    results_log = []
+    # Run agent
+    results_log    = []
     answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions (4 threads)...")
 
-    def process_one(item):
-        task_id = item.get("task_id")
+    for item in questions_data:
+        task_id       = item.get("task_id")
         question_text = item.get("question")
         if not task_id or question_text is None:
-            return None
+            continue
         try:
-            question_with_id = f"[task_id={task_id}] {question_text}"
-            submitted_answer = agent(question_with_id)
-            print(f"✅ [{task_id[:8]}] {submitted_answer[:60]}")
-            return {"task_id": task_id, "question_text": question_text, "answer": submitted_answer}
+            answer = agent(question_text, task_id=task_id)
         except Exception as e:
-            print(f"❌ [{task_id[:8]}] {e}")
-            return {"task_id": task_id, "question_text": question_text, "answer": "I don't know"}
-
-    with ThreadPoolExecutor(max_workers=4) as executor:
-        futures = {executor.submit(process_one, item): item for item in questions_data}
-        for future in as_completed(futures):
-            try:
-                result = future.result(timeout=120)
-            except Exception as e:
-                print(f"Future error: {e}")
-                continue
-            if result is None:
-                continue
-            answers_payload.append({"task_id": result["task_id"], "submitted_answer": result["answer"]})
-            results_log.append({"Task ID": result["task_id"], "Question": result["question_text"], "Submitted Answer": result["answer"]})
+            print(f"Agent error on {task_id}: {e}")
+            answer = f"AGENT ERROR: {e}"
+
+        answers_payload.append({"task_id": task_id, "submitted_answer": answer})
+        results_log.append({
+            "Task ID": task_id,
+            "Question": question_text[:80],
+            "Submitted Answer": answer,
+        })
+        # Be polite to the API
+        time.sleep(1)
 
     if not answers_payload:
-        print("Agent did not produce any answers to submit.")
-        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
-
-    # 4. Prepare Submission
-    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
-    print(status_update)
-
-    # 5. Submit
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+        return "No answers produced.", pd.DataFrame(results_log)
+
+    # Submit
+    submission_data = {
+        "username":   username.strip(),
+        "agent_code": agent_code,
+        "answers":    answers_payload,
+    }
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
-        response.raise_for_status()
-        result_data = response.json()
-        final_status = (
+        r = requests.post(submit_url, json=submission_data, timeout=120)
+        r.raise_for_status()
+        result = r.json()
+        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.')}"
+            f"User: {result.get('username')}\n"
+            f"Score: {result.get('score', 'N/A')}% "
+            f"({result.get('correct_count', '?')}/{result.get('total_attempted', '?')} correct)\n"
+            f"Message: {result.get('message', '')}"
         )
-        print("Submission successful.")
-        results_df = pd.DataFrame(results_log)
-        return final_status, results_df
-    except requests.exceptions.HTTPError as e:
-        error_detail = f"Server responded with status {e.response.status_code}."
-        try:
-            error_json = e.response.json()
-            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
-        except requests.exceptions.JSONDecodeError:
-            error_detail += f" Response: {e.response.text[:500]}"
-        status_message = f"Submission Failed: {error_detail}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.Timeout:
-        status_message = "Submission Failed: The request timed out."
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.RequestException as e:
-        status_message = f"Submission Failed: Network error - {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
     except Exception as e:
-        status_message = f"An unexpected error occurred during submission: {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        status = f"Submission error: {e}"
 
+    return status, pd.DataFrame(results_log)
+
+
+# ─────────────────────────────────────────────
+# Build Gradio app
+# ─────────────────────────────────────────────
 
-# --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner")
-    gr.Markdown(
-        """
-        **Instructions:**
-
-        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
-        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
-        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
-
-        ---
-        **Disclaimers:**
-        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
-        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
-        """
-    )
+    gr.Markdown("# 🤖 GAIA Agent – HF Inference Powered")
+    gr.Markdown("""
+**How it works:**
+- Uses `meta-llama/Llama-3.3-70B-Instruct` for reasoning
+- Uses `meta-llama/Llama-3.2-11B-Vision-Instruct` for images  
+- Uses `openai/whisper-large-v3` for audio transcription
+- Has web search, Wikipedia search, webpage fetching, and Python execution tools
+- Automatically downloads and reads attached task files (PDF, Excel, audio, code)
+
+**Setup:** Set the `HF_TOKEN` environment variable in your Space secrets.
+    """)
 
     gr.LoginButton()
 
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
+    run_btn = gr.Button("🚀 Run Evaluation & Submit All Answers", variant="primary")
+    status_out = gr.Textbox(label="Status / Score", lines=6, interactive=False)
+    results_tbl = gr.DataFrame(label="Questions & Answers", wrap=True)
 
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+    run_btn.click(fn=run_and_submit_all, outputs=[status_out, results_tbl])
 
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_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}")
-        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
-    else:
-        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
-    if space_id_startup:
-        print(f"✅ SPACE_ID found: {space_id_startup}")
-        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
-        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
-    else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
-    print("-"*(60 + len(" App Starting ")) + "\n")
-    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    print("Starting GAIA Agent …")
     demo.launch(debug=True, share=False)