Update app.py

app.py

@@ -3,10 +3,10 @@ import re
 import json
 import io
 import time
-import base64
 import traceback
 import contextlib
 import tempfile
+import mimetypes
 from urllib.parse import urlparse, parse_qs
 
 import gradio as gr
@@ -16,30 +16,15 @@ import pandas as pd
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# Free-tier Groq TPM limits (per minute):
-#   llama-3.1-8b-instant         -> 30,000 TPM (lots of headroom)
-#   llama-3.3-70b-versatile      ->  6,000 TPM (tight; one big tool result busts it)
-# Default order: 8b first to avoid 413s, fall back to 70b only when necessary.
-GROQ_MODELS = [
-    m.strip()
-    for m in os.getenv(
-        "GROQ_MODELS",
-        # 8b only end-to-end. 70b is too tight on free tier and breaks synthesis.
-        "llama-3.1-8b-instant",
-    ).split(",")
-    if m.strip()
-]
-# Smarter model used for the final synthesis pass. Tried first, falls back to 8b.
-GROQ_FINAL_MODEL = os.getenv("GROQ_FINAL_MODEL", "llama-3.3-70b-versatile")
-GROQ_VISION_MODEL = os.getenv("GROQ_VISION_MODEL", "meta-llama/llama-4-scout-17b-16e-instruct")
-GROQ_WHISPER_MODEL = os.getenv("GROQ_WHISPER_MODEL", "whisper-large-v3-turbo")
-
-MAX_TOOL_ITERATIONS = 7
-TOOL_RESULT_MAX_CHARS = 1500
-HISTORY_TRIM_AFTER = 6
+# 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
 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", "3"))
+INTER_QUESTION_SLEEP = float(os.getenv("INTER_QUESTION_SLEEP", "1"))
 
 # Track downloaded task files so vision/audio tools can re-use them by task_id.
 _TASK_FILE_CACHE: dict[str, dict] = {}
@@ -66,7 +51,7 @@ def tool_web_search(query: str, max_results: int = 5) -> str:
                 lines.append(f"Answer: {res['answer']}")
             for r in res.get("results", [])[:max_results]:
                 lines.append(
-                    f"- {r.get('title', '')}\n  {r.get('url', '')}\n  {r.get('content', '')[:300]}"
+                    f"- {r.get('title', '')}\n  {r.get('url', '')}\n  {r.get('content', '')[:400]}"
                 )
             if len(lines) > 1:
                 return "\n".join(lines)
@@ -81,7 +66,7 @@ def tool_web_search(query: str, max_results: int = 5) -> str:
         with DDGS() as ddgs:
             for r in ddgs.text(query, max_results=max_results):
                 results.append(
-                    f"- {r.get('title', '')}\n  {r.get('href', '')}\n  {r.get('body', '')[:300]}"
+                    f"- {r.get('title', '')}\n  {r.get('href', '')}\n  {r.get('body', '')[:400]}"
                 )
         if len(results) == 1:
             return "[provider: duckduckgo] No results."
@@ -90,7 +75,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 = 1800) -> str:
+def tool_fetch_url(url: str, max_chars: int = 4000) -> str:
     """Fetch a URL and return readable text (HTML stripped)."""
     try:
         from bs4 import BeautifulSoup
@@ -118,7 +103,7 @@ def tool_fetch_url(url: str, max_chars: int = 1800) -> str:
         return f"fetch_url error: {e}"
 
 
-def tool_wikipedia(query: str, sentences: int = 4) -> str:
+def tool_wikipedia(query: str, sentences: int = 6) -> str:
     """Look up a topic on Wikipedia and return a summary."""
     try:
         import wikipedia
@@ -147,7 +132,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)")[:1500]
+        return (out or "(no output)")[:3000]
     except Exception as e:
         return f"python error: {e}\n{traceback.format_exc(limit=2)}"
 
@@ -167,7 +152,7 @@ def _extract_youtube_id(url: str) -> str | None:
     return None
 
 
-def tool_youtube_transcript(url: str, max_chars: int = 2500) -> str:
+def tool_youtube_transcript(url: str, max_chars: int = 4000) -> str:
     """Fetch the transcript of a YouTube video by URL or ID."""
     try:
         from youtube_transcript_api import YouTubeTranscriptApi
@@ -187,77 +172,59 @@ def tool_youtube_transcript(url: str, max_chars: int = 2500) -> str:
         return f"youtube_transcript error: {e}"
 
 
-def tool_transcribe_audio(task_id: str) -> str:
-    """Transcribe an audio file attached to a GAIA task using Groq Whisper."""
+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 groq import Groq
-        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 "transcribe_audio error: no local file for task (file may not exist for this task_id)"
-
-        client = Groq(api_key=os.getenv("GROQ_API_KEY"))
-        with open(info["path"], "rb") as f:
-            tr = client.audio.transcriptions.create(
-                file=(os.path.basename(info["path"]), f.read()),
-                model=GROQ_WHISPER_MODEL,
-                response_format="text",
-            )
-        text = tr if isinstance(tr, str) else getattr(tr, "text", str(tr))
-        text = text.strip()
-        if len(text) > 3500:
-            text = text[:3500] + " ...[truncated]"
-        return text or "(empty transcript)"
-    except Exception as e:
-        return f"transcribe_audio error: {e}"
-
+        from google import genai
+        from google.genai import types
 
-def tool_view_image(task_id: str, question: str = "") -> str:
-    """Describe / answer a question about an image attached to a GAIA task using Groq vision."""
-    try:
-        from groq import Groq
         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 (file may not exist for this task_id)"
-
-        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}"
+            return "understand_media 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")
+
+        with open(path, "rb") as f:
+            data = f.read()
 
         prompt = (
             question.strip()
-            or "Describe this image in detail, including any text, numbers, or symbols visible."
+            or "Describe the contents of this file in full detail. Transcribe any audio. "
+               "Read any text in images. Identify all visible objects/people/numbers."
         )
 
-        client = Groq(api_key=os.getenv("GROQ_API_KEY"))
-        resp = client.chat.completions.create(
-            model=GROQ_VISION_MODEL,
-            messages=[
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": prompt},
-                        {"type": "image_url", "image_url": {"url": data_url}},
-                    ],
-                }
+        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,
             ],
-            temperature=0.0,
-            max_tokens=600,
         )
-        return (resp.choices[0].message.content or "").strip()
+        return (resp.text or "").strip() or "(no response)"
     except Exception as e:
-        return f"view_image error: {e}"
+        return f"understand_media error: {e}"
 
 
 def tool_get_task_file(task_id: str, api_url: str = DEFAULT_API_URL) -> str:
@@ -296,185 +263,152 @@ 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[:2500]
+            return info + "\n--- preview ---\n" + text[:3500]
 
         if suffix in {".xlsx", ".xls"}:
             try:
                 df = pd.read_excel(tmp.name)
-                # Show full table to allow exact summing.
                 csv = df.to_csv(index=False)
-                if len(csv) > 2500:
-                    csv = csv[:2500] + "\n...[truncated]"
+                if len(csv) > 3500:
+                    csv = csv[:3500] + "\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":
-            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)[:2500]
-            except Exception as e:
-                return info + f"\n(pdf parse error: {e})"
+            return info + "\nPDF file. Call understand_media(task_id, question='...') for full content."
 
         if suffix in {".mp3", ".wav", ".m4a", ".ogg", ".flac", ".webm"}:
-            return info + "\nThis is an audio file. Call transcribe_audio(task_id) to read it."
+            return info + "\nAudio file. Call understand_media(task_id, question='Transcribe this and answer: ...')."
 
         if suffix in {".png", ".jpg", ".jpeg", ".gif", ".webp"}:
-            return info + "\nThis is an image. Call view_image(task_id, question='...') to inspect it."
+            return info + "\nImage file. Call understand_media(task_id, question='...')."
 
-        return info + "\n(binary file; no preview)"
+        return info + "\n(binary file; call understand_media if it's media)"
     except Exception as e:
         return f"get_task_file error: {e}"
 
 
 # ---------------------------------------------------------------------------
-# Tool schema for Groq function calling
+# Tool schema for Gemini function calling
 # ---------------------------------------------------------------------------
-TOOLS_SPEC = [
-    {
-        "type": "function",
-        "function": {
-            "name": "web_search",
-            "description": "Search the web (Tavily preferred, DuckDuckGo fallback). Returns titles, URLs, snippets.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "query": {"type": "string"},
-                    "max_results": {"type": "integer", "default": 5},
-                },
-                "required": ["query"],
-            },
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "fetch_url",
-            "description": "Fetch a URL and return cleaned page text. Use after web_search to read a result.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "url": {"type": "string"},
-                    "max_chars": {"type": "integer", "default": 1800},
-                },
-                "required": ["url"],
-            },
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "wikipedia",
-            "description": "Get a Wikipedia summary for a topic.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "query": {"type": "string"},
-                    "sentences": {"type": "integer", "default": 4},
-                },
-                "required": ["query"],
-            },
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "python",
-            "description": "Execute a short Python snippet for math, dates, parsing CSV, list/string work, reversing text. 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. ONLY call when the question explicitly mentions an attached file/image/audio/Excel/PDF/code. Returns NO_FILE if none 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) for the given task_id.",
-            "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 for best results.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "task_id": {"type": "string"},
-                    "question": {"type": "string"},
-                },
-                "required": ["task_id"],
-            },
-        },
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "youtube_transcript",
-            "description": "Fetch the transcript text of a YouTube video given its URL or ID.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "url": {"type": "string"},
-                    "max_chars": {"type": "integer", "default": 2500},
-                },
-                "required": ["url"],
-            },
-        },
-    },
-]
+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"],
+                    ),
+                ),
+            ]
+        )
+    ]
+
 
 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", 1800))),
-    "wikipedia": lambda args: tool_wikipedia(args["query"], int(args.get("sentences", 4))),
+    "fetch_url": lambda args: tool_fetch_url(args["url"], int(args.get("max_chars", 4000))),
+    "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"]),
-    "transcribe_audio": lambda args: tool_transcribe_audio(args["task_id"]),
-    "view_image": lambda args: tool_view_image(args["task_id"], args.get("question", "")),
+    "understand_media": lambda args: tool_understand_media(args["task_id"], args.get("question", "")),
     "youtube_transcript": lambda args: tool_youtube_transcript(
-        args["url"], int(args.get("max_chars", 2500))
+        args["url"], int(args.get("max_chars", 4000))
     ),
 }
 
 
 SYSTEM_PROMPT = """You are a careful research agent answering GAIA benchmark questions.
 
-Tools: web_search, fetch_url, wikipedia, python, get_task_file, transcribe_audio, view_image, youtube_transcript.
+Tools: web_search, fetch_url, wikipedia, python, get_task_file, understand_media, youtube_transcript.
 
 Decision rules:
-- If the question literally references "attached file/image/audio/Excel/PDF/.mp3/.xlsx/.py/code/recording", call get_task_file FIRST. If it returns NO_FILE, do NOT call it again.
-- Audio file -> transcribe_audio(task_id).
-- Image file -> view_image(task_id, question="<focused question>").
-- YouTube URL -> youtube_transcript(url) directly (no get_task_file needed).
-- For factual lookups about people / places / artists / albums / animals / Wikipedia featured articles, START with wikipedia. Then fetch_url the relevant page if more detail needed.
-- For everything else research-y, web_search then fetch_url.
-- Use python for ALL arithmetic, sums (e.g. summing Excel rows), date math, sorting, alphabetizing, set/group operations, string reversal. Never compute by hand.
-- For Excel/CSV totals, after get_task_file shows you the data, ALWAYS use python to compute the sum precisely.
-
-You have 6 tool turns. Be decisive. Do not loop on the same query.
+- 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.
+- 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.
 
 ANSWER FORMATTING (the grader does an exact-match comparison; sentence answers ALWAYS lose):
 
@@ -483,10 +417,9 @@ Worked examples of correct GAIA format:
 - 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: "Just the city name without abbreviations" -> "Saint Petersburg"
-- Q: "Give only the first name" -> "Bartek"  (NOT "Bartlomiej" or "Bartek Kasprzykowski")
+- 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: "Final numeric output from the attached Python code" -> "0"  (just the number)
 - Q: opposite of "left" -> "right"  (one word)
 
 Strict rules:
@@ -494,22 +427,21 @@ Strict rules:
 - Do NOT include "FINAL ANSWER", "Answer:", or any label.
 - 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 (write "Saint" not "St."); digits as digits.
+- 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 formatting rules to each element. Sort if asked.
+- 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.
 """
 
 
 def _maybe_reverse_text(question: str) -> str:
-    """If the question text looks reversed, flip it. Returns possibly-modified question."""
-    # Heuristic: a normal English sentence has many word-frequencies like 'the', 'a', 'of'.
-    # A reversed one has 'eht', 'fo', 'sa', etc., and often starts with punctuation like '.'.
+    """If the question text looks reversed, flip it."""
     q = question.strip()
     if not q:
         return question
     starts_with_punct = q[0] in ".,;:!?"
     reversed_text = q[::-1]
-    # Look for common English words in the reversed version.
     common = (" the ", " of ", " and ", " to ", " is ", " a ", " in ", " for ")
     hits = sum(1 for w in common if w in (" " + reversed_text.lower() + " "))
     if starts_with_punct and hits >= 2:
@@ -520,94 +452,64 @@ def _maybe_reverse_text(question: str) -> str:
 # ---------------------------------------------------------------------------
 # Agent
 # ---------------------------------------------------------------------------
-class GroqAgent:
+class GeminiAgent:
     def __init__(self):
         try:
-            from groq import Groq
+            from google import genai
+            from google.genai import types
         except ImportError as e:
-            raise RuntimeError("groq package not installed") from e
+            raise RuntimeError("google-genai package not installed") from e
 
-        api_key = os.getenv("GROQ_API_KEY")
+        api_key = os.getenv("GEMINI_API_KEY")
         if not api_key:
             raise RuntimeError(
-                "GROQ_API_KEY is not set. Add it as a Secret in your HF Space settings."
+                "GEMINI_API_KEY is not set. Get one free at https://aistudio.google.com/apikey "
+                "and add it as a Secret in your HF Space settings."
             )
-        self.client = Groq(api_key=api_key)
-        self.models = list(GROQ_MODELS)
-        self.exhausted_models: set[str] = set()
-        print(f"GroqAgent initialized with models={self.models}")
-
-    def _chat(self, messages, use_tools: bool = True, max_tokens: int = 800, model: str | None = None):
-        """Try the configured models in order. Handles 429 (retry), 413 (trim & next), TPD (skip)."""
+        self.client = genai.Client(api_key=api_key)
+        self.types = types
+        self.tools = _build_tools_spec()
+        self.exhausted: set[str] = set()
+        print(f"GeminiAgent initialized with model={GEMINI_MODEL}, fallback={GEMINI_FALLBACK_MODEL}")
+
+    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]
         last_error: Exception | None = None
-        models = [model] if model else self.models
-        for m in models:
-            if m in self.exhausted_models:
+        for m in models_to_try:
+            if m in self.exhausted:
                 continue
             for attempt in range(3):
                 try:
-                    kwargs = dict(
-                        model=m,
-                        messages=messages,
+                    config = self.types.GenerateContentConfig(
                         temperature=0.0,
-                        max_tokens=max_tokens,
+                        tools=self.tools if use_tools else None,
+                    )
+                    return self.client.models.generate_content(
+                        model=m,
+                        contents=contents,
+                        config=config,
                     )
-                    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_429 = "429" in msg or "rate_limit" in msg.lower()
-                    is_413 = "413" in msg or "too large" in msg.lower()
-                    is_tpd = "per day" in msg.lower() or "tpd" in msg.lower()
-                    if is_413:
-                        print(f"[{m}] 413 too large; trying next model.")
-                        break
-                    if is_429 and is_tpd:
-                        print(f"[{m}] daily token limit exhausted; switching model.")
-                        self.exhausted_models.add(m)
+                    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()
+                    if is_rate and is_quota:
+                        print(f"[{m}] daily quota exhausted; switching model.")
+                        self.exhausted.add(m)
                         break
-                    if is_429:
-                        wait = self._parse_retry_seconds(msg)
-                        wait = min(max(wait, 2), 30)
-                        print(f"[{m}] 429; sleeping {wait}s (attempt {attempt + 1}/3)")
+                    if is_rate:
+                        wait = 5 * (attempt + 1)
+                        print(f"[{m}] rate-limited; sleeping {wait}s (attempt {attempt + 1}/3)")
                         time.sleep(wait)
                         continue
-                    print(f"[{m}] API error: {e}")
+                    print(f"[{m}] API error: {repr(e)[:300]}")
                     break
-        # Use repr() so empty exception messages still show useful info.
         err_str = repr(last_error) if last_error else "no error captured"
-        raise RuntimeError(f"All Groq models failed. {err_str}")
-
-    @staticmethod
-    def _parse_retry_seconds(error_msg: str) -> float:
-        m = re.search(r"in\s+(?:(\d+)m)?([\d.]+)s", error_msg)
-        if not m:
-            return 5.0
-        minutes = int(m.group(1)) if m.group(1) else 0
-        seconds = float(m.group(2)) if m.group(2) else 0.0
-        return minutes * 60 + seconds
-
-    @staticmethod
-    def _trim_messages(messages: list) -> list:
-        """Keep system + user(0) + last 4 turns. Older tool/assistant turns get summarized."""
-        if len(messages) <= HISTORY_TRIM_AFTER:
-            return messages
-        head = messages[:2]  # system + first user
-        tail = messages[-4:]
-        # Summarize what was dropped so model has continuity.
-        dropped = len(messages) - len(head) - len(tail)
-        summary = {
-            "role": "user",
-            "content": f"[Note: {dropped} earlier tool turns omitted to save tokens. Continue with the latest results.]",
-        }
-        return head + [summary] + tail
+        raise RuntimeError(f"All Gemini models failed. {err_str}")
 
     def __call__(self, question: str, task_id: str | None = None) -> str:
-        # Deterministic preprocess: detect & flip reversed-text trick questions.
-        original_q = question
         flipped = _maybe_reverse_text(question)
         if flipped != question:
             print("[reversed-text detected, flipping question]")
@@ -617,60 +519,57 @@ class GroqAgent:
         if task_id:
             user_content = f"task_id: {task_id}\n\nQuestion: {question}"
 
-        messages = [
-            {"role": "system", "content": SYSTEM_PROMPT},
-            {"role": "user", "content": user_content},
+        # 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)],
+            ),
         ]
 
-        # Track tool outputs to feed into the synthesis pass even if loop fails.
         collected_facts: list[str] = []
 
         for step in range(MAX_TOOL_ITERATIONS):
             try:
-                resp = self._chat(self._trim_messages(messages), use_tools=True, max_tokens=800)
+                resp = self._call_model(contents, use_tools=True)
             except Exception as e:
-                print(f"chat iteration {step} failed: {e} — trimming and retrying once.")
-                # Aggressive trim: keep only system + user + last 2 messages.
-                short_msgs = [messages[0], messages[1]]
-                if len(messages) > 2:
-                    short_msgs += messages[-2:]
-                try:
-                    resp = self._chat(short_msgs, use_tools=True, max_tokens=600)
-                except Exception as e2:
-                    print(f"retry also failed: {e2}; falling through to synthesis.")
-                    break
-
-            msg = resp.choices[0].message
-            tool_calls = getattr(msg, "tool_calls", None)
-
-            if not tool_calls:
-                answer = (msg.content or "").strip()
-                return self._finalize(answer, question, collected_facts)
-
-            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
-                    ],
-                }
-            )
+                print(f"call_model failed at step {step}: {e}")
+                break
 
-            for tc in tool_calls:
-                name = tc.function.name
-                try:
-                    args = json.loads(tc.function.arguments or "{}")
-                except json.JSONDecodeError:
-                    args = {}
+            # 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.
+                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:
@@ -680,134 +579,86 @@ class GroqAgent:
                         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]"
-
-                # Save to facts (cap each at 800 chars for synthesis pass).
-                collected_facts.append(f"[{name}] {result[:800]}")
-
-                messages.append(
-                    {
-                        "role": "tool",
-                        "tool_call_id": tc.id,
-                        "name": name,
-                        "content": result,
-                    }
+                collected_facts.append(f"[{name}] {result[:1200]}")
+                tool_response_parts.append(
+                    self.types.Part.from_function_response(
+                        name=name,
+                        response={"result": result},
+                    )
                 )
 
-        # Loop ended (either ran out of iterations OR chat repeatedly failed).
-        # Do a final synthesis pass on a SHORT context using the smarter model.
+            contents.append(self.types.Content(role="user", parts=tool_response_parts))
+
+        # 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. Tries smarter model first."""
-        # Keep total facts well under any TPM cap.
-        joined = "\n\n".join(facts[-6:])
-        if len(joined) > 2500:
-            joined = joined[-2500:]
-
-        synth_messages = [
-            {
-                "role": "system",
-                "content": (
-                    "You are a strict GAIA answer formatter. Read the question and the "
-                    "research notes below, 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 the notes are insufficient, give your single best guess based on "
-                    "general knowledge in the same strict format. Never refuse, never apologize, "
-                    "never reply with an empty string."
-                ),
-            },
-            {
-                "role": "user",
-                "content": (
-                    f"Question:\n{question}\n\n"
-                    f"Research notes:\n{joined or '(no notes)'}\n\n"
-                    f"Final answer:"
-                ),
-            },
-        ]
-        # Try the smarter final model first; fall back to the regular pool.
-        attempts = []
-        for model_choice in (GROQ_FINAL_MODEL, *self.models):
-            if model_choice in attempts:
-                continue
-            attempts.append(model_choice)
-            try:
-                resp = self._chat(synth_messages, use_tools=False, max_tokens=120, model=model_choice)
-                ans = (resp.choices[0].message.content or "").strip()
-                ans = self._postprocess_answer(ans, question)
-                if ans:
-                    return ans
-            except Exception as e:
-                print(f"synth with {model_choice} failed: {e}")
-                continue
-        # Last-resort: zero-shot guess with no notes, smallest possible prompt.
+        """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:"
+        )
         try:
-            resp = self._chat(
-                [
-                    {"role": "system", "content": "Answer in 1-5 words. No explanation."},
-                    {"role": "user", "content": question[:500]},
-                ],
+            resp = self._call_model(
+                [self.types.Content(role="user", parts=[self.types.Part.from_text(text=synth_prompt)])],
                 use_tools=False,
-                max_tokens=40,
-                model=self.models[0],
-            )
-            return self._postprocess_answer(
-                (resp.choices[0].message.content or "").strip(), question
             )
+            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"
         except Exception as e:
-            print(f"last-resort guess failed: {e}")
+            print(f"synthesis failed: {e}")
             return "unknown"
 
-    def _finalize(self, raw: str, question: str, facts: list[str] | None = None) -> str:
-        """Post-process and, if the answer still looks like a sentence, ask the model to reformat."""
+    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:
-            # Empty answer? Try synthesis from collected facts.
-            if facts:
-                return self._synthesize(question, facts)
-            return cleaned
-        # If the cleaned answer is suspiciously long or contains explanation-y patterns,
-        # do a single tiny reformat pass.
+            return self._synthesize(question, facts)
         looks_sentence = (
             len(cleaned.split()) > 12
             or re.search(
                 r"\b(because|received|grant|seems|unable|sorry|cannot|provides|indicating|"
-                r"web_search|youtube_transcript|fetch_url|task_id)\b",
+                r"web_search|youtube_transcript|fetch_url)\b",
                 cleaned,
                 re.IGNORECASE,
             )
         )
         if looks_sentence:
             try:
-                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:",
-                        },
-                    ],
+                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)])],
                     use_tools=False,
-                    max_tokens=80,
                 )
-                reformat = (resp.choices[0].message.content or "").strip()
-                reformat = self._postprocess_answer(reformat, question)
-                if reformat:
-                    return reformat
+                text = (resp.text or "").strip() if hasattr(resp, "text") and resp.text else ""
+                text = self._postprocess_answer(text, question)
+                if text:
+                    return text
             except Exception as e:
                 print(f"reformat pass failed: {e}")
         return cleaned
@@ -817,8 +668,6 @@ class GroqAgent:
         if not text:
             return ""
         text = text.strip()
-
-        # Drop common labels.
         text = re.sub(
             r"^(final\s*answer|answer|the\s*answer\s*is)\s*[:\-]?\s*",
             "",
@@ -838,7 +687,6 @@ class GroqAgent:
             if m:
                 text = m.group(0)
 
-        # Strip a single trailing period if the text is short / single token.
         if text.endswith(".") and " " not in text:
             text = text[:-1]
 
@@ -846,7 +694,7 @@ class GroqAgent:
 
 
 # ---------------------------------------------------------------------------
-# Answer cache
+# Cache
 # ---------------------------------------------------------------------------
 def _load_cache() -> dict:
     try:
@@ -881,7 +729,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     submit_url = f"{api_url}/submit"
 
     try:
-        agent = GroqAgent()
+        agent = GeminiAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None, None
@@ -916,7 +764,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             continue
         print(f"\n=== [{idx}/{len(questions_data)}] task_id={task_id} ===")
         cached = cache.get(task_id)
-        if cached and not str(cached).startswith("AGENT ERROR"):
+        if cached and not str(cached).startswith("AGENT ERROR") and cached not in {"", "unknown"}:
             submitted_answer = cached
             print(f"(cache hit) {submitted_answer[:80]}")
         else:
@@ -931,7 +779,6 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         results_log.append(
             {"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer}
         )
-        # Pace requests so per-minute Groq limits reset between questions.
         if INTER_QUESTION_SLEEP > 0 and idx < len(questions_data):
             time.sleep(INTER_QUESTION_SLEEP)
 
@@ -940,7 +787,6 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         df.to_csv(RESULTS_CSV_PATH, index=False)
         return "Agent did not produce any answers to submit.", df, RESULTS_CSV_PATH
 
-    # Save results CSV before submission so the user can download even if submit fails.
     df = pd.DataFrame(results_log)
     df.to_csv(RESULTS_CSV_PATH, index=False)
     print(f"Results CSV written to {RESULTS_CSV_PATH}")
@@ -991,8 +837,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             continue
 
     return (
-        f"Submission Failed after retries: {last_error}. Answers are cached at "
-        f"{ANSWER_CACHE_PATH} — re-run to retry without re-querying the model.",
+        f"Submission Failed after retries: {last_error}.",
         df,
         RESULTS_CSV_PATH,
     )
@@ -1000,20 +845,17 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
 # --- Gradio UI ---
 with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Agent (Groq) — Evaluation Runner")
+    gr.Markdown("# GAIA Agent (Gemini) — Evaluation Runner")
     gr.Markdown(
         """
         **Setup**
-        1. Add a Space secret named `GROQ_API_KEY` (free at console.groq.com).
-        2. *Optional but recommended:* `TAVILY_API_KEY` (free 1000/mo at tavily.com) for better search.
-        3. Optional env vars: `GROQ_MODELS`, `GROQ_VISION_MODEL`, `GROQ_WHISPER_MODEL`, `INTER_QUESTION_SLEEP`.
+        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**.
 
         Tools: `web_search`, `fetch_url`, `wikipedia`, `python`, `get_task_file`,
-        `transcribe_audio`, `view_image`, `youtube_transcript`.
-
-        Tip: if you get rate-limit errors, the answers cache lets you click Run again to
-        re-attempt only the failed questions without re-querying ones that already worked.
+        `understand_media` (handles images/audio/PDFs natively via Gemini), `youtube_transcript`.
         """
     )
 
@@ -1021,7 +863,7 @@ with gr.Blocks() as demo:
     run_button = gr.Button("Run Evaluation & Submit All Answers")
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
-    results_csv = gr.File(label="Download Results CSV (paste this back to me for tuning)")
+    results_csv = gr.File(label="Download Results CSV (paste back to me for tuning)")
 
     run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table, results_csv])
 
@@ -1042,8 +884,8 @@ if __name__ == "__main__":
     else:
         print("ℹ️  SPACE_ID not found (running locally?).")
 
-    if not os.getenv("GROQ_API_KEY"):
-        print("⚠️  GROQ_API_KEY is not set. Set it before running evaluation.")
+    if not os.getenv("GEMINI_API_KEY"):
+        print("⚠️  GEMINI_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).")