Update app.py

app.py

@@ -3,6 +3,7 @@ import re
 import json
 import io
 import time
+import base64
 import traceback
 import contextlib
 import tempfile
@@ -15,16 +16,32 @@ import pandas as pd
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-# Gemini free-tier models. Flash is fast & smart; "lite" used as fallback only if needed.
-GEMINI_MODEL = os.getenv("GEMINI_MODEL", "gemini-2.5-flash")
-GEMINI_FALLBACK_MODEL = os.getenv("GEMINI_FALLBACK_MODEL", "gemini-2.0-flash")
-
-MAX_TOOL_ITERATIONS = 8
-TOOL_RESULT_MAX_CHARS = 4000
+OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
+
+# Fleet of free OpenRouter models. Tried in order. When one rate-limits or errors,
+# we fall through to the next one. Mix of strong reasoning + tool use.
+TEXT_MODELS = [
+    m.strip() for m in os.getenv(
+        "OPENROUTER_MODELS",
+        # Best free models for tool use as of 2025-2026.
+        "deepseek/deepseek-chat-v3-0324:free,"
+        "meta-llama/llama-3.3-70b-instruct:free,"
+        "mistralai/mistral-small-3.2-24b-instruct:free,"
+        "google/gemini-2.0-flash-exp:free,"
+        "qwen/qwen-2.5-72b-instruct:free,"
+        "deepseek/deepseek-r1:free"
+    ).split(",")
+    if m.strip()
+]
+# Vision-capable free model. Gemini Flash is multimodal and free on OpenRouter.
+VISION_MODEL = os.getenv("OPENROUTER_VISION_MODEL", "google/gemini-2.0-flash-exp:free")
+
+MAX_TOOL_ITERATIONS = 7
+TOOL_RESULT_MAX_CHARS = 3500
 ANSWER_CACHE_PATH = os.getenv("ANSWER_CACHE_PATH", "/tmp/answers_cache.json")
 RESULTS_CSV_PATH = "/tmp/gaia_results.csv"
-INTER_QUESTION_SLEEP = float(os.getenv("INTER_QUESTION_SLEEP", "1"))
+INTER_QUESTION_SLEEP = float(os.getenv("INTER_QUESTION_SLEEP", "2"))
+INTER_TOOL_SLEEP = float(os.getenv("INTER_TOOL_SLEEP", "0.5"))
 
 # Track downloaded task files so vision/audio tools can re-use them by task_id.
 _TASK_FILE_CACHE: dict[str, dict] = {}
@@ -34,7 +51,7 @@ _TASK_FILE_CACHE: dict[str, dict] = {}
 # Tool implementations
 # ---------------------------------------------------------------------------
 def tool_web_search(query: str, max_results: int = 5) -> str:
-    """Web search. Tries Tavily first (if TAVILY_API_KEY set), falls back to DuckDuckGo."""
+    """Web search. Tries Tavily first, falls back to DuckDuckGo."""
     tavily_key = os.getenv("TAVILY_API_KEY")
     if tavily_key:
         try:
@@ -75,7 +92,7 @@ def tool_web_search(query: str, max_results: int = 5) -> str:
         return f"web_search error: {e}"
 
 
-def tool_fetch_url(url: str, max_chars: int = 4000) -> str:
+def tool_fetch_url(url: str, max_chars: int = 3500) -> str:
     """Fetch a URL and return readable text (HTML stripped)."""
     try:
         from bs4 import BeautifulSoup
@@ -132,7 +149,7 @@ def tool_python(code: str) -> str:
         out = buf.getvalue().strip()
         if not out and "result" in local_ns:
             out = str(local_ns["result"])
-        return (out or "(no output)")[:3000]
+        return (out or "(no output)")[:2500]
     except Exception as e:
         return f"python error: {e}\n{traceback.format_exc(limit=2)}"
 
@@ -152,8 +169,8 @@ def _extract_youtube_id(url: str) -> str | None:
     return None
 
 
-def tool_youtube_transcript(url: str, max_chars: int = 4000) -> str:
-    """Fetch the transcript of a YouTube video by URL or ID."""
+def tool_youtube_transcript(url: str, max_chars: int = 3500) -> str:
+    """Fetch the spoken transcript of a YouTube video."""
     try:
         from youtube_transcript_api import YouTubeTranscriptApi
         vid = _extract_youtube_id(url) or url.strip()
@@ -172,59 +189,123 @@ def tool_youtube_transcript(url: str, max_chars: int = 4000) -> str:
         return f"youtube_transcript error: {e}"
 
 
-def tool_understand_media(task_id: str, question: str = "") -> str:
-    """Use Gemini's native multimodal understanding on an attached image, audio, video, or PDF."""
-    try:
-        from google import genai
-        from google.genai import types
+def _hf_inference(model: str, data: bytes, content_type: str) -> str:
+    """Call HF Inference API with raw bytes (used for Whisper audio transcription)."""
+    hf_token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+    headers = {"Content-Type": content_type}
+    if hf_token:
+        headers["Authorization"] = f"Bearer {hf_token}"
+    url = f"https://api-inference.huggingface.co/models/{model}"
+    # HF inference can be cold-started; retry a few times.
+    for attempt in range(3):
+        resp = requests.post(url, headers=headers, data=data, timeout=120)
+        if resp.status_code == 503:
+            # Model loading — wait per estimated_time.
+            try:
+                wait = float(resp.json().get("estimated_time", 10))
+            except Exception:
+                wait = 10
+            wait = min(max(wait, 3), 30)
+            print(f"HF model {model} loading; waiting {wait}s...")
+            time.sleep(wait)
+            continue
+        resp.raise_for_status()
+        return resp.text
+    raise RuntimeError(f"HF model {model} not ready after retries")
+
 
+def tool_transcribe_audio(task_id: str) -> str:
+    """Transcribe an attached audio file using HF Whisper Inference API."""
+    try:
         info = _TASK_FILE_CACHE.get(task_id)
         if not info:
             tool_get_task_file(task_id)
             info = _TASK_FILE_CACHE.get(task_id)
         if not info or not os.path.exists(info.get("path", "")):
-            return "understand_media error: no local file for task"
+            return "transcribe_audio error: no local file for task"
 
         path = info["path"]
-        mime = info.get("ctype") or mimetypes.guess_type(path)[0] or "application/octet-stream"
-        if not mime or mime == "application/octet-stream":
-            ext = os.path.splitext(path)[1].lower().lstrip(".")
-            mime_map = {
-                "mp3": "audio/mp3",
-                "wav": "audio/wav",
-                "m4a": "audio/mp4",
-                "ogg": "audio/ogg",
-                "flac": "audio/flac",
-                "png": "image/png",
-                "jpg": "image/jpeg",
-                "jpeg": "image/jpeg",
-                "gif": "image/gif",
-                "webp": "image/webp",
-                "pdf": "application/pdf",
-                "mp4": "video/mp4",
-            }
-            mime = mime_map.get(ext, "application/octet-stream")
+        ext = os.path.splitext(path)[1].lower().lstrip(".")
+        ctype_map = {
+            "mp3": "audio/mpeg", "wav": "audio/wav", "m4a": "audio/mp4",
+            "ogg": "audio/ogg", "flac": "audio/flac", "webm": "audio/webm",
+        }
+        ctype = ctype_map.get(ext, "audio/mpeg")
 
         with open(path, "rb") as f:
             data = f.read()
 
+        raw = _hf_inference("openai/whisper-large-v3", data, ctype)
+        try:
+            obj = json.loads(raw)
+            if isinstance(obj, dict) and "text" in obj:
+                text = obj["text"]
+            elif isinstance(obj, list) and obj and "text" in obj[0]:
+                text = obj[0]["text"]
+            else:
+                text = raw
+        except Exception:
+            text = raw
+        text = (text or "").strip()
+        if len(text) > 4000:
+            text = text[:4000] + " ...[truncated]"
+        return text or "(empty transcript)"
+    except Exception as e:
+        return f"transcribe_audio error: {e}"
+
+
+def tool_view_image(task_id: str, question: str = "") -> str:
+    """Inspect an image attached to a GAIA task using a vision-capable LLM via OpenRouter."""
+    try:
+        from openai import OpenAI
+
+        info = _TASK_FILE_CACHE.get(task_id)
+        if not info:
+            tool_get_task_file(task_id)
+            info = _TASK_FILE_CACHE.get(task_id)
+        if not info or not os.path.exists(info.get("path", "")):
+            return "view_image error: no local file for task"
+
+        suffix = os.path.splitext(info["path"])[1].lower().lstrip(".")
+        if suffix == "jpg":
+            suffix = "jpeg"
+        if suffix not in {"png", "jpeg", "gif", "webp"}:
+            return f"view_image error: unsupported image type .{suffix}"
+
+        with open(info["path"], "rb") as f:
+            b64 = base64.b64encode(f.read()).decode("ascii")
+        data_url = f"data:image/{suffix};base64,{b64}"
+
         prompt = (
             question.strip()
-            or "Describe the contents of this file in full detail. Transcribe any audio. "
-               "Read any text in images. Identify all visible objects/people/numbers."
+            or "Describe this image in detail, including any text, numbers, or symbols visible."
         )
 
-        client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
-        resp = client.models.generate_content(
-            model=GEMINI_MODEL,
-            contents=[
-                types.Part.from_bytes(data=data, mime_type=mime),
-                prompt,
+        client = OpenAI(
+            base_url=OPENROUTER_BASE_URL,
+            api_key=os.getenv("OPENROUTER_API_KEY"),
+        )
+        resp = client.chat.completions.create(
+            model=VISION_MODEL,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": prompt},
+                        {"type": "image_url", "image_url": {"url": data_url}},
+                    ],
+                }
             ],
+            temperature=0.0,
+            max_tokens=600,
+            extra_headers={
+                "HTTP-Referer": "https://huggingface.co/learn/agents-course",
+                "X-Title": "GAIA Agent",
+            },
         )
-        return (resp.text or "").strip() or "(no response)"
+        return (resp.choices[0].message.content or "").strip()
     except Exception as e:
-        return f"understand_media error: {e}"
+        return f"view_image error: {e}"
 
 
 def tool_get_task_file(task_id: str, api_url: str = DEFAULT_API_URL) -> str:
@@ -263,164 +344,198 @@ def tool_get_task_file(task_id: str, api_url: str = DEFAULT_API_URL) -> str:
                 text = resp.content.decode("utf-8", errors="replace")
             except Exception:
                 text = resp.text
-            return info + "\n--- preview ---\n" + text[:3500]
+            return info + "\n--- preview ---\n" + text[:3000]
 
         if suffix in {".xlsx", ".xls"}:
             try:
                 df = pd.read_excel(tmp.name)
                 csv = df.to_csv(index=False)
-                if len(csv) > 3500:
-                    csv = csv[:3500] + "\n...[truncated]"
+                if len(csv) > 3000:
+                    csv = csv[:3000] + "\n...[truncated]"
                 return info + "\n--- excel as csv ---\n" + csv
             except Exception as e:
                 return info + f"\n(excel parse error: {e})"
 
         if suffix == ".pdf":
-            return info + "\nPDF file. Call understand_media(task_id, question='...') for full content."
+            try:
+                from pypdf import PdfReader
+                reader = PdfReader(tmp.name)
+                pages = [p.extract_text() or "" for p in reader.pages[:6]]
+                return info + "\n--- pdf text ---\n" + "\n".join(pages)[:3000]
+            except Exception as e:
+                return info + f"\n(pdf parse error: {e})"
 
         if suffix in {".mp3", ".wav", ".m4a", ".ogg", ".flac", ".webm"}:
-            return info + "\nAudio file. Call understand_media(task_id, question='Transcribe this and answer: ...')."
+            return info + "\nAudio file. Call transcribe_audio(task_id) to read it."
 
         if suffix in {".png", ".jpg", ".jpeg", ".gif", ".webp"}:
-            return info + "\nImage file. Call understand_media(task_id, question='...')."
+            return info + "\nImage file. Call view_image(task_id, question='...')."
 
-        return info + "\n(binary file; call understand_media if it's media)"
+        return info + "\n(binary file; no preview)"
     except Exception as e:
         return f"get_task_file error: {e}"
 
 
 # ---------------------------------------------------------------------------
-# Tool schema for Gemini function calling
+# Tool schema (OpenAI-compatible)
 # ---------------------------------------------------------------------------
-def _build_tools_spec():
-    """Build google.genai Tool objects."""
-    from google.genai import types
-
-    return [
-        types.Tool(
-            function_declarations=[
-                types.FunctionDeclaration(
-                    name="web_search",
-                    description="Search the web (Tavily preferred, DuckDuckGo fallback). Returns titles, URLs, snippets, and Tavily's synthesized answer.",
-                    parameters=types.Schema(
-                        type="OBJECT",
-                        properties={
-                            "query": types.Schema(type="STRING"),
-                            "max_results": types.Schema(type="INTEGER"),
-                        },
-                        required=["query"],
-                    ),
-                ),
-                types.FunctionDeclaration(
-                    name="fetch_url",
-                    description="Fetch a URL and return cleaned page text. Use after web_search to read a result page.",
-                    parameters=types.Schema(
-                        type="OBJECT",
-                        properties={
-                            "url": types.Schema(type="STRING"),
-                            "max_chars": types.Schema(type="INTEGER"),
-                        },
-                        required=["url"],
-                    ),
-                ),
-                types.FunctionDeclaration(
-                    name="wikipedia",
-                    description="Get a Wikipedia summary for a person, place, work, or topic. Use FIRST for biographical or list questions.",
-                    parameters=types.Schema(
-                        type="OBJECT",
-                        properties={
-                            "query": types.Schema(type="STRING"),
-                            "sentences": types.Schema(type="INTEGER"),
-                        },
-                        required=["query"],
-                    ),
-                ),
-                types.FunctionDeclaration(
-                    name="python",
-                    description="Execute a Python snippet for math, sums, dates, sorting, alphabetizing, parsing, string reversal, set logic. Use print() or assign to `result`.",
-                    parameters=types.Schema(
-                        type="OBJECT",
-                        properties={"code": types.Schema(type="STRING")},
-                        required=["code"],
-                    ),
-                ),
-                types.FunctionDeclaration(
-                    name="get_task_file",
-                    description="Download the file attached to a GAIA task by task_id. Returns a text preview for text/CSV/Excel/JSON. Returns NO_FILE if no file exists.",
-                    parameters=types.Schema(
-                        type="OBJECT",
-                        properties={"task_id": types.Schema(type="STRING")},
-                        required=["task_id"],
-                    ),
-                ),
-                types.FunctionDeclaration(
-                    name="understand_media",
-                    description="Analyze an attached image, audio, video, or PDF using multimodal AI. Pass a focused question. Use for chess images, audio recordings, photos, etc.",
-                    parameters=types.Schema(
-                        type="OBJECT",
-                        properties={
-                            "task_id": types.Schema(type="STRING"),
-                            "question": types.Schema(type="STRING"),
-                        },
-                        required=["task_id"],
-                    ),
-                ),
-                types.FunctionDeclaration(
-                    name="youtube_transcript",
-                    description="Fetch the spoken transcript of a YouTube video given its URL or ID. NOTE: only captures speech, not visual content.",
-                    parameters=types.Schema(
-                        type="OBJECT",
-                        properties={
-                            "url": types.Schema(type="STRING"),
-                            "max_chars": types.Schema(type="INTEGER"),
-                        },
-                        required=["url"],
-                    ),
-                ),
-            ]
-        )
-    ]
-
+TOOLS_SPEC = [
+    {
+        "type": "function",
+        "function": {
+            "name": "web_search",
+            "description": "Search the web (Tavily preferred, DuckDuckGo fallback). Returns titles, URLs, snippets, and Tavily's synthesized answer.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string"},
+                    "max_results": {"type": "integer"},
+                },
+                "required": ["query"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "fetch_url",
+            "description": "Fetch a URL and return cleaned page text. Use after web_search to read a result page.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {"type": "string"},
+                    "max_chars": {"type": "integer"},
+                },
+                "required": ["url"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "wikipedia",
+            "description": "Get a Wikipedia summary for a person, place, work, or topic. Use FIRST for biographical or list questions.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string"},
+                    "sentences": {"type": "integer"},
+                },
+                "required": ["query"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "python",
+            "description": "Execute a Python snippet for math, sums, dates, sorting, alphabetizing, parsing, string reversal, set logic. Use print() or assign to `result`.",
+            "parameters": {
+                "type": "object",
+                "properties": {"code": {"type": "string"}},
+                "required": ["code"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_task_file",
+            "description": "Download the file attached to a GAIA task by task_id. Returns NO_FILE if no file exists.",
+            "parameters": {
+                "type": "object",
+                "properties": {"task_id": {"type": "string"}},
+                "required": ["task_id"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "transcribe_audio",
+            "description": "Transcribe an attached audio file (.mp3/.wav/.m4a/.ogg/.flac) using Whisper.",
+            "parameters": {
+                "type": "object",
+                "properties": {"task_id": {"type": "string"}},
+                "required": ["task_id"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "view_image",
+            "description": "Inspect an attached image (.png/.jpg/.gif/.webp) using a vision model. Pass a focused question.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "task_id": {"type": "string"},
+                    "question": {"type": "string"},
+                },
+                "required": ["task_id"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "youtube_transcript",
+            "description": "Fetch the spoken transcript of a YouTube video given its URL. Only captures speech, not visual content.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {"type": "string"},
+                    "max_chars": {"type": "integer"},
+                },
+                "required": ["url"],
+            },
+        },
+    },
+]
 
 TOOL_FUNCTIONS = {
     "web_search": lambda args: tool_web_search(args["query"], int(args.get("max_results", 5))),
-    "fetch_url": lambda args: tool_fetch_url(args["url"], int(args.get("max_chars", 4000))),
+    "fetch_url": lambda args: tool_fetch_url(args["url"], int(args.get("max_chars", 3500))),
     "wikipedia": lambda args: tool_wikipedia(args["query"], int(args.get("sentences", 6))),
     "python": lambda args: tool_python(args["code"]),
     "get_task_file": lambda args: tool_get_task_file(args["task_id"]),
-    "understand_media": lambda args: tool_understand_media(args["task_id"], args.get("question", "")),
+    "transcribe_audio": lambda args: tool_transcribe_audio(args["task_id"]),
+    "view_image": lambda args: tool_view_image(args["task_id"], args.get("question", "")),
     "youtube_transcript": lambda args: tool_youtube_transcript(
-        args["url"], int(args.get("max_chars", 4000))
+        args["url"], int(args.get("max_chars", 3500))
     ),
 }
 
 
 SYSTEM_PROMPT = """You are a careful research agent answering GAIA benchmark questions.
 
-Tools: web_search, fetch_url, wikipedia, python, get_task_file, understand_media, youtube_transcript.
+Tools: web_search, fetch_url, wikipedia, python, get_task_file, transcribe_audio, view_image, youtube_transcript.
 
 Decision rules:
-- If the question references "attached file/image/audio/Excel/PDF/.mp3/.xlsx/.py/recording/image/photo", call get_task_file FIRST.
-  - For audio (.mp3, .wav, etc.) or images (.png, .jpg, etc.) or PDF or video, after get_task_file, call understand_media(task_id, question="<focused question>") to read the content.
-  - For Excel/CSV/text, the get_task_file preview is enough; use python to compute on it.
-- For YouTube URLs, use understand_media is NOT applicable (we don't download videos). Use youtube_transcript(url) for audio captions only.
-  - If a YouTube question requires VISUAL info (e.g. counting birds on screen), the transcript won't help; make your best estimate from research and the transcript.
+- If the question references "attached file/image/audio/Excel/PDF/.mp3/.xlsx/.py/recording/photo/image", call get_task_file FIRST.
+  - Audio (.mp3, .wav, etc.) -> transcribe_audio(task_id) after get_task_file.
+  - Image (.png, .jpg, etc.) -> view_image(task_id, question="<focused question>") after get_task_file.
+  - Excel/CSV/text/PDF — the get_task_file preview is enough; use python to compute on it.
+  - If get_task_file returns NO_FILE, do NOT call it again.
+- For YouTube URLs, use youtube_transcript(url) directly. (No get_task_file needed.) The transcript is speech only — for visual questions, give your best estimate.
 - For factual lookups about people, places, artists, albums, animals, Wikipedia featured articles: START with wikipedia.
 - For everything else research-y: web_search then fetch_url the most relevant URL.
 - Use python for ALL arithmetic, sums, date math, sorting, alphabetizing, set/group operations, string reversal. Never compute by hand.
 - For Excel/CSV totals, after get_task_file shows the data, ALWAYS use python to compute the sum precisely.
 
+Be decisive — don't repeat the same tool with the same args. You have 7 tool turns.
+
 ANSWER FORMATTING (the grader does an exact-match comparison; sentence answers ALWAYS lose):
 
 Worked examples of correct GAIA format:
 - Q: "How many albums..." -> "3"   (NOT "3 albums" or "There were 3 albums")
-- Q: "Express your answer in USD with two decimal places" -> "89706.00"  (NOT "$89,706" or "89706")
-- Q: "Give the IOC country code" -> "MLT"  (NOT "Malta" or "Malta (MLT)")
+- Q: "Express your answer in USD with two decimal places" -> "89706.00"
+- Q: "Give the IOC country code" -> "MLT"
 - Q: "Just the city name without abbreviations" -> "Saint Petersburg"
 - Q: "Give only the first name" -> "Bartek"
 - Q: "Comma separated list ... in alphabetical order" -> "broccoli, celery, fresh basil, lettuce, sweet potatoes, zucchini"
-- Q: "Under what NASA award number..." -> "80NSSC21K1130"  (just the code, NO surrounding sentence)
-- Q: opposite of "left" -> "right"  (one word)
+- Q: "Under what NASA award number..." -> "80NSSC21K1130"
+- Q: opposite of "left" -> "right"
 
 Strict rules:
 - Reply with ONLY the answer. No preamble. No explanation. No quotes. No trailing period.
@@ -428,10 +543,8 @@ Strict rules:
 - Numbers: digits only, no commas, no units, no $ — UNLESS the question asks for the unit.
 - Currency "two decimal places": e.g. "89706.00".
 - Strings: no leading articles ("the", "a") unless required; no abbreviations ("Saint" not "St."); digits as digits.
-- Names: read the question carefully. "First name only" / "last name only" / "surname" / "full name". Match exactly.
-- Lists: comma-separated, ONE space after each comma. Apply rules to each element. Sort if asked.
-
-You have 8 tool turns. Be decisive — don't loop on the same query.
+- Names: read the question carefully ("first name only" / "last name only" / "surname" / "full name").
+- Lists: comma-separated, ONE space after each comma. Sort if asked.
 """
 
 
@@ -452,62 +565,66 @@ def _maybe_reverse_text(question: str) -> str:
 # ---------------------------------------------------------------------------
 # Agent
 # ---------------------------------------------------------------------------
-class GeminiAgent:
+class OpenRouterAgent:
     def __init__(self):
         try:
-            from google import genai
-            from google.genai import types
+            from openai import OpenAI
         except ImportError as e:
-            raise RuntimeError("google-genai package not installed") from e
+            raise RuntimeError("openai package not installed") from e
 
-        api_key = os.getenv("GEMINI_API_KEY")
+        api_key = os.getenv("OPENROUTER_API_KEY")
         if not api_key:
             raise RuntimeError(
-                "GEMINI_API_KEY is not set. Get one free at https://aistudio.google.com/apikey "
+                "OPENROUTER_API_KEY is not set. Get one free at https://openrouter.ai/keys "
                 "and add it as a Secret in your HF Space settings."
             )
-        self.client = genai.Client(api_key=api_key)
-        self.types = types
-        self.tools = _build_tools_spec()
+        self.client = OpenAI(base_url=OPENROUTER_BASE_URL, api_key=api_key)
+        self.models = list(TEXT_MODELS)
         self.exhausted: set[str] = set()
-        print(f"GeminiAgent initialized with model={GEMINI_MODEL}, fallback={GEMINI_FALLBACK_MODEL}")
+        self.extra_headers = {
+            "HTTP-Referer": "https://huggingface.co/learn/agents-course",
+            "X-Title": "GAIA Agent",
+        }
+        print(f"OpenRouterAgent initialized with model fleet: {self.models}")
 
-    def _call_model(self, contents, model: str | None = None, use_tools: bool = True):
-        """One call to Gemini with retry & fallback. Returns response object."""
-        models_to_try = [model] if model else [GEMINI_MODEL, GEMINI_FALLBACK_MODEL]
+    def _chat(self, messages, use_tools: bool = True, max_tokens: int = 800):
+        """Try each model in the fleet. Falls through on rate limit / error."""
         last_error: Exception | None = None
-        for m in models_to_try:
+        for m in self.models:
             if m in self.exhausted:
                 continue
-            for attempt in range(3):
+            for attempt in range(2):
                 try:
-                    config = self.types.GenerateContentConfig(
-                        temperature=0.0,
-                        tools=self.tools if use_tools else None,
-                    )
-                    return self.client.models.generate_content(
+                    kwargs = dict(
                         model=m,
-                        contents=contents,
-                        config=config,
+                        messages=messages,
+                        temperature=0.0,
+                        max_tokens=max_tokens,
+                        extra_headers=self.extra_headers,
                     )
+                    if use_tools:
+                        kwargs["tools"] = TOOLS_SPEC
+                        kwargs["tool_choice"] = "auto"
+                    return self.client.chat.completions.create(**kwargs)
                 except Exception as e:
                     msg = str(e)
                     last_error = e
-                    is_rate = "429" in msg or "RESOURCE_EXHAUSTED" in msg or "rate" in msg.lower()
-                    is_quota = "quota" in msg.lower() or "exhausted" in msg.lower()
+                    is_rate = "429" in msg or "rate" in msg.lower() or "limit" in msg.lower()
+                    is_quota = ("daily" in msg.lower() or "quota" in msg.lower()
+                                or "exhausted" in msg.lower())
                     if is_rate and is_quota:
                         print(f"[{m}] daily quota exhausted; switching model.")
                         self.exhausted.add(m)
                         break
                     if is_rate:
-                        wait = 5 * (attempt + 1)
-                        print(f"[{m}] rate-limited; sleeping {wait}s (attempt {attempt + 1}/3)")
+                        wait = 4 * (attempt + 1)
+                        print(f"[{m}] rate-limited; sleeping {wait}s (attempt {attempt + 1}/2)")
                         time.sleep(wait)
                         continue
-                    print(f"[{m}] API error: {repr(e)[:300]}")
+                    print(f"[{m}] API error: {repr(e)[:240]} — trying next model.")
                     break
         err_str = repr(last_error) if last_error else "no error captured"
-        raise RuntimeError(f"All Gemini models failed. {err_str}")
+        raise RuntimeError(f"All OpenRouter models failed. {err_str}")
 
     def __call__(self, question: str, task_id: str | None = None) -> str:
         flipped = _maybe_reverse_text(question)
@@ -519,118 +636,142 @@ class GeminiAgent:
         if task_id:
             user_content = f"task_id: {task_id}\n\nQuestion: {question}"
 
-        # Gemini uses a Content list with role/parts. System instruction is separate but
-        # we'll prepend it as the first user message for simplicity / model compatibility.
-        contents = [
-            self.types.Content(
-                role="user",
-                parts=[self.types.Part.from_text(text=SYSTEM_PROMPT + "\n\n---\n\n" + user_content)],
-            ),
+        messages = [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_content},
         ]
 
         collected_facts: list[str] = []
+        seen_calls: set[str] = set()
 
         for step in range(MAX_TOOL_ITERATIONS):
             try:
-                resp = self._call_model(contents, use_tools=True)
+                resp = self._chat(messages, use_tools=True, max_tokens=800)
             except Exception as e:
-                print(f"call_model failed at step {step}: {e}")
+                print(f"chat at step {step} failed: {e}")
                 break
 
-            # Check for function calls.
-            fcs = []
-            try:
-                if resp.candidates and resp.candidates[0].content and resp.candidates[0].content.parts:
-                    for part in resp.candidates[0].content.parts:
-                        if getattr(part, "function_call", None):
-                            fcs.append(part.function_call)
-            except Exception as e:
-                print(f"parse error: {e}")
-
-            if not fcs:
-                # Final text answer.
-                text = (resp.text or "").strip() if hasattr(resp, "text") else ""
-                if not text and resp.candidates:
-                    # Pull text parts manually.
-                    parts_text = []
-                    for p in resp.candidates[0].content.parts or []:
-                        if getattr(p, "text", None):
-                            parts_text.append(p.text)
-                    text = "".join(parts_text).strip()
-                if text:
-                    return self._finalize(text, question, collected_facts)
-                # No text and no function call: fall through to synthesis.
+            msg = resp.choices[0].message
+            tool_calls = getattr(msg, "tool_calls", None)
+
+            if not tool_calls:
+                answer = (msg.content or "").strip()
+                if answer:
+                    return self._finalize(answer, question, collected_facts)
                 break
 
-            # Append assistant turn (model's function_call response).
-            contents.append(resp.candidates[0].content)
-
-            # Execute each function call and append a function response part.
-            tool_response_parts = []
-            for fc in fcs:
-                name = fc.name
-                args = dict(fc.args or {})
-                fn = TOOL_FUNCTIONS.get(name)
-                print(f"[tool] {name}({str(args)[:200]})")
-                if fn is None:
-                    result = f"unknown tool: {name}"
+            messages.append(
+                {
+                    "role": "assistant",
+                    "content": msg.content or "",
+                    "tool_calls": [
+                        {
+                            "id": tc.id,
+                            "type": "function",
+                            "function": {
+                                "name": tc.function.name,
+                                "arguments": tc.function.arguments,
+                            },
+                        }
+                        for tc in tool_calls
+                    ],
+                }
+            )
+
+            for tc in tool_calls:
+                name = tc.function.name
+                try:
+                    args = json.loads(tc.function.arguments or "{}")
+                except json.JSONDecodeError:
+                    args = {}
+
+                call_key = f"{name}|{json.dumps(args, sort_keys=True, default=str)[:300]}"
+                if call_key in seen_calls:
+                    print(f"[tool] {name}({str(args)[:120]}) [DUPLICATE — skipping]")
+                    result = "DUPLICATE_CALL: you already called this with the same args. Try a different query, a different tool, or give your final answer."
                 else:
-                    try:
-                        result = fn(args)
-                    except Exception as e:
-                        result = f"{name} error: {e}"
+                    seen_calls.add(call_key)
+                    fn = TOOL_FUNCTIONS.get(name)
+                    print(f"[tool] {name}({str(args)[:200]})")
+                    if fn is None:
+                        result = f"unknown tool: {name}"
+                    else:
+                        try:
+                            result = fn(args)
+                        except Exception as e:
+                            result = f"{name} error: {e}"
+
                 if not isinstance(result, str):
                     result = str(result)
                 if len(result) > TOOL_RESULT_MAX_CHARS:
                     result = result[:TOOL_RESULT_MAX_CHARS] + "\n...[truncated]"
+
                 collected_facts.append(f"[{name}] {result[:1200]}")
-                tool_response_parts.append(
-                    self.types.Part.from_function_response(
-                        name=name,
-                        response={"result": result},
-                    )
+
+                messages.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": tc.id,
+                        "name": name,
+                        "content": result,
+                    }
                 )
 
-            contents.append(self.types.Content(role="user", parts=tool_response_parts))
+            if INTER_TOOL_SLEEP > 0:
+                time.sleep(INTER_TOOL_SLEEP)
 
-        # Out of iterations or model gave up: synthesize from collected facts.
         return self._synthesize(question, collected_facts)
 
     def _synthesize(self, question: str, facts: list[str]) -> str:
         """Final answer pass on a short context. No tools."""
         joined = "\n\n".join(facts[-8:])
-        if len(joined) > 6000:
-            joined = joined[-6000:]
-
-        synth_prompt = (
-            "You are a strict GAIA answer formatter. Read the question and the research notes, "
-            "then output ONLY the final answer string. No preamble, no labels, no explanation, "
-            "no quotes, no trailing period. Match the question's required format exactly "
-            "(number-only / IOC code / first name only / surname only / two-decimal currency / "
-            "comma-space list). If notes are insufficient, give your single best guess based on "
-            "general knowledge. Never refuse, never apologize, never reply with empty string.\n\n"
-            f"Question:\n{question}\n\nResearch notes:\n{joined or '(no notes)'}\n\nFinal answer:"
-        )
+        if len(joined) > 5000:
+            joined = joined[-5000:]
+
+        synth_messages = [
+            {
+                "role": "system",
+                "content": (
+                    "You are a strict GAIA answer formatter. Read the question and the research "
+                    "notes, then output ONLY the final answer string. No preamble, no labels, no "
+                    "explanation, no quotes, no trailing period. Match the question's required "
+                    "format exactly. If notes are insufficient, give your single best guess based "
+                    "on general knowledge. Never refuse, never apologize, never reply with empty."
+                ),
+            },
+            {
+                "role": "user",
+                "content": (
+                    f"Question:\n{question}\n\n"
+                    f"Research notes:\n{joined or '(no notes)'}\n\nFinal answer:"
+                ),
+            },
+        ]
         try:
-            resp = self._call_model(
-                [self.types.Content(role="user", parts=[self.types.Part.from_text(text=synth_prompt)])],
-                use_tools=False,
-            )
-            text = ""
-            if hasattr(resp, "text") and resp.text:
-                text = resp.text.strip()
-            elif resp.candidates:
-                for p in resp.candidates[0].content.parts or []:
-                    if getattr(p, "text", None):
-                        text += p.text
-                text = text.strip()
-            return self._postprocess_answer(text, question) or "unknown"
+            resp = self._chat(synth_messages, use_tools=False, max_tokens=120)
+            return self._postprocess_answer(
+                (resp.choices[0].message.content or "").strip(), question
+            ) or "unknown"
         except Exception as e:
             print(f"synthesis failed: {e}")
-            return "unknown"
+            # Last-resort: tiny zero-shot guess
+            try:
+                resp = self._chat(
+                    [
+                        {"role": "system", "content": "Answer in 1-5 words. No explanation."},
+                        {"role": "user", "content": question[:500]},
+                    ],
+                    use_tools=False,
+                    max_tokens=40,
+                )
+                return self._postprocess_answer(
+                    (resp.choices[0].message.content or "").strip(), question
+                ) or "unknown"
+            except Exception as e2:
+                print(f"last-resort guess failed: {e2}")
+                return "unknown"
 
     def _finalize(self, raw: str, question: str, facts: list[str]) -> str:
-        """Post-process; reformat if it still looks like a sentence."""
         cleaned = self._postprocess_answer(raw, question)
         if not cleaned:
             return self._synthesize(question, facts)
@@ -645,20 +786,28 @@ class GeminiAgent:
         )
         if looks_sentence:
             try:
-                prompt = (
-                    "Extract ONLY the final answer from the assistant text below, matching the "
-                    "question's required format exactly. No preamble, no explanation, no quotes, "
-                    "no trailing period, no labels.\n\n"
-                    f"Question: {question}\n\nAssistant text: {cleaned}\n\nFinal answer:"
-                )
-                resp = self._call_model(
-                    [self.types.Content(role="user", parts=[self.types.Part.from_text(text=prompt)])],
+                resp = self._chat(
+                    [
+                        {
+                            "role": "system",
+                            "content": (
+                                "Extract ONLY the final answer from the assistant text below, "
+                                "matching the question's required format exactly. No preamble, "
+                                "no explanation, no quotes, no trailing period, no labels."
+                            ),
+                        },
+                        {
+                            "role": "user",
+                            "content": f"Question: {question}\n\nAssistant text: {cleaned}\n\nFinal answer:",
+                        },
+                    ],
                     use_tools=False,
+                    max_tokens=80,
                 )
-                text = (resp.text or "").strip() if hasattr(resp, "text") and resp.text else ""
-                text = self._postprocess_answer(text, question)
-                if text:
-                    return text
+                reformat = (resp.choices[0].message.content or "").strip()
+                reformat = self._postprocess_answer(reformat, question)
+                if reformat:
+                    return reformat
             except Exception as e:
                 print(f"reformat pass failed: {e}")
         return cleaned
@@ -729,7 +878,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     submit_url = f"{api_url}/submit"
 
     try:
-        agent = GeminiAgent()
+        agent = OpenRouterAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None, None
@@ -845,17 +994,20 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
 # --- Gradio UI ---
 with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Agent (Gemini) — Evaluation Runner")
+    gr.Markdown("# GAIA Agent (OpenRouter) — Evaluation Runner")
     gr.Markdown(
         """
         **Setup**
-        1. Add a Space secret named `GEMINI_API_KEY` (free at [aistudio.google.com/apikey](https://aistudio.google.com/apikey)).
-        2. *Optional but recommended:* `TAVILY_API_KEY` (free tier at tavily.com) for better search.
-        3. Optional env vars: `GEMINI_MODEL` (default `gemini-2.5-flash`), `GEMINI_FALLBACK_MODEL`.
-        4. Log in to Hugging Face below and click **Run Evaluation & Submit All Answers**.
+        1. Add a Space secret named `OPENROUTER_API_KEY` (free at [openrouter.ai/keys](https://openrouter.ai/keys)).
+        2. *Optional but recommended:* `TAVILY_API_KEY` for better search.
+        3. Optional: `HF_TOKEN` for Whisper audio transcription via HF Inference API.
+        4. Optional env vars: `OPENROUTER_MODELS` (comma-separated fleet), `OPENROUTER_VISION_MODEL`.
+        5. Log in to Hugging Face below and click **Run Evaluation & Submit All Answers**.
 
         Tools: `web_search`, `fetch_url`, `wikipedia`, `python`, `get_task_file`,
-        `understand_media` (handles images/audio/PDFs natively via Gemini), `youtube_transcript`.
+        `transcribe_audio` (HF Whisper), `view_image` (Gemini Flash via OpenRouter), `youtube_transcript`.
+
+        Model fleet falls through automatically when one rate-limits.
         """
     )
 
@@ -884,10 +1036,12 @@ if __name__ == "__main__":
     else:
         print("ℹ️  SPACE_ID not found (running locally?).")
 
-    if not os.getenv("GEMINI_API_KEY"):
-        print("⚠️  GEMINI_API_KEY is not set. Set it before running evaluation.")
+    if not os.getenv("OPENROUTER_API_KEY"):
+        print("⚠️  OPENROUTER_API_KEY is not set. Set it before running evaluation.")
     if not os.getenv("TAVILY_API_KEY"):
         print("ℹ️  TAVILY_API_KEY not set — search will use DuckDuckGo (less reliable).")
+    if not os.getenv("HF_TOKEN"):
+        print("ℹ️  HF_TOKEN not set — audio transcription may rate-limit on cold starts.")
 
     print("-" * (60 + len(" App Starting ")) + "\n")
     demo.launch(debug=True, share=False)