Update app.py

app.py

@@ -15,23 +15,27 @@ import pandas as pd
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-# Primary model first, then fallbacks used when rate-limited.
+
+# 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",
-        "llama-3.3-70b-versatile,llama-3.1-8b-instant",
+        "llama-3.1-8b-instant,llama-3.3-70b-versatile",
     ).split(",")
     if m.strip()
 ]
-# Vision-capable Groq model (free tier).
 GROQ_VISION_MODEL = os.getenv("GROQ_VISION_MODEL", "meta-llama/llama-4-scout-17b-16e-instruct")
-# Groq Whisper model for audio.
 GROQ_WHISPER_MODEL = os.getenv("GROQ_WHISPER_MODEL", "whisper-large-v3-turbo")
 
-MAX_TOOL_ITERATIONS = 8
-TOOL_RESULT_MAX_CHARS = 3500
+MAX_TOOL_ITERATIONS = 5
+TOOL_RESULT_MAX_CHARS = 1800       # smaller -> stays under 6K TPM for 70b fallback
+HISTORY_TRIM_AFTER = 6             # trim old tool turns once we have this many messages
 ANSWER_CACHE_PATH = os.getenv("ANSWER_CACHE_PATH", "answers_cache.json")
+INTER_QUESTION_SLEEP = float(os.getenv("INTER_QUESTION_SLEEP", "2"))
 
 # Track downloaded task files so vision/audio tools can re-use them by task_id.
 _TASK_FILE_CACHE: dict[str, dict] = {}
@@ -58,21 +62,20 @@ 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', '')[:400]}"
+                    f"- {r.get('title', '')}\n  {r.get('url', '')}\n  {r.get('content', '')[:300]}"
                 )
             if lines:
                 return "\n".join(lines)
         except Exception as e:
             print(f"tavily search failed, falling back to DDG: {e}")
 
-    # Fallback: DuckDuckGo
     try:
         from duckduckgo_search import DDGS
         results = []
         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', '')}"
+                    f"- {r.get('title', '')}\n  {r.get('href', '')}\n  {r.get('body', '')[:300]}"
                 )
         if not results:
             return "No results."
@@ -81,7 +84,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 = 3500) -> str:
+def tool_fetch_url(url: str, max_chars: int = 1800) -> str:
     """Fetch a URL and return readable text (HTML stripped)."""
     try:
         from bs4 import BeautifulSoup
@@ -138,7 +141,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)"
+        return (out or "(no output)")[:1500]
     except Exception as e:
         return f"python error: {e}\n{traceback.format_exc(limit=2)}"
 
@@ -158,7 +161,7 @@ def _extract_youtube_id(url: str) -> str | None:
     return None
 
 
-def tool_youtube_transcript(url: str, max_chars: int = 3500) -> str:
+def tool_youtube_transcript(url: str, max_chars: int = 2500) -> str:
     """Fetch the transcript of a YouTube video by URL or ID."""
     try:
         from youtube_transcript_api import YouTubeTranscriptApi
@@ -166,7 +169,6 @@ def tool_youtube_transcript(url: str, max_chars: int = 3500) -> str:
         try:
             data = YouTubeTranscriptApi.get_transcript(vid, languages=["en", "en-US", "en-GB"])
         except Exception:
-            # Try any available language
             tlist = YouTubeTranscriptApi.list_transcripts(vid)
             t = next(iter(tlist), None)
             data = t.fetch() if t else []
@@ -183,13 +185,12 @@ def tool_transcribe_audio(task_id: str) -> str:
     """Transcribe an audio file attached to a GAIA task using Groq Whisper."""
     try:
         from groq import Groq
-        # Make sure the file is downloaded.
         info = _TASK_FILE_CACHE.get(task_id)
         if not info:
-            tool_get_task_file(task_id)  # populates cache
+            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"
+            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:
@@ -200,8 +201,8 @@ def tool_transcribe_audio(task_id: str) -> str:
             )
         text = tr if isinstance(tr, str) else getattr(tr, "text", str(tr))
         text = text.strip()
-        if len(text) > 4000:
-            text = text[:4000] + " ...[truncated]"
+        if len(text) > 3500:
+            text = text[:3500] + " ...[truncated]"
         return text or "(empty transcript)"
     except Exception as e:
         return f"transcribe_audio error: {e}"
@@ -216,7 +217,7 @@ def tool_view_image(task_id: str, question: str = "") -> str:
             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"
+            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":
@@ -246,7 +247,7 @@ def tool_view_image(task_id: str, question: str = "") -> str:
                 }
             ],
             temperature=0.0,
-            max_tokens=800,
+            max_tokens=600,
         )
         return (resp.choices[0].message.content or "").strip()
     except Exception as e:
@@ -257,6 +258,11 @@ def tool_get_task_file(task_id: str, api_url: str = DEFAULT_API_URL) -> str:
     """Download the file attached to a task and return a text preview."""
     try:
         resp = requests.get(f"{api_url}/files/{task_id}", timeout=30)
+        if resp.status_code == 404:
+            return (
+                "NO_FILE: This task has no attached file. Do not call get_task_file again. "
+                "Answer using web_search / wikipedia / python / your own knowledge."
+            )
         resp.raise_for_status()
         ctype = resp.headers.get("Content-Type", "")
         cdisp = resp.headers.get("Content-Disposition", "")
@@ -264,7 +270,6 @@ def tool_get_task_file(task_id: str, api_url: str = DEFAULT_API_URL) -> str:
         fname = fname_match.group(1) if fname_match else f"{task_id}"
         suffix = os.path.splitext(fname)[1].lower()
 
-        # Save to temp for tools that need a path
         tmp = tempfile.NamedTemporaryFile(prefix=f"{task_id}_", suffix=suffix, delete=False)
         tmp.write(resp.content)
         tmp.close()
@@ -277,22 +282,24 @@ def tool_get_task_file(task_id: str, api_url: str = DEFAULT_API_URL) -> str:
         }
 
         info = (
-            f"File: {fname}\nContent-Type: {ctype}\nSaved to: {tmp.name}\n"
-            f"Size: {len(resp.content)} bytes\n"
+            f"File: {fname}\nContent-Type: {ctype}\nSize: {len(resp.content)} bytes\n"
         )
 
-        # Try to give a readable preview
         if suffix in {".txt", ".md", ".csv", ".json", ".py", ".tsv", ".log", ".xml", ".html"}:
             try:
                 text = resp.content.decode("utf-8", errors="replace")
             except Exception:
                 text = resp.text
-            return info + "\n--- preview ---\n" + text[:3000]
+            return info + "\n--- preview ---\n" + text[:2500]
 
         if suffix in {".xlsx", ".xls"}:
             try:
                 df = pd.read_excel(tmp.name)
-                return info + "\n--- preview (head 30) ---\n" + df.head(30).to_csv(index=False)
+                # Show full table to allow exact summing.
+                csv = df.to_csv(index=False)
+                if len(csv) > 2500:
+                    csv = csv[:2500] + "\n...[truncated]"
+                return info + "\n--- excel as csv ---\n" + csv
             except Exception as e:
                 return info + f"\n(excel parse error: {e})"
 
@@ -300,16 +307,16 @@ def tool_get_task_file(task_id: str, api_url: str = DEFAULT_API_URL) -> str:
             try:
                 from pypdf import PdfReader
                 reader = PdfReader(tmp.name)
-                pages = [p.extract_text() or "" for p in reader.pages[:8]]
-                return info + "\n--- pdf text (first 8 pages) ---\n" + "\n".join(pages)[:3000]
+                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})"
 
         if suffix in {".mp3", ".wav", ".m4a", ".ogg", ".flac", ".webm"}:
-            return info + "\nThis is an audio file. Call transcribe_audio to read it."
+            return info + "\nThis is an audio file. Call transcribe_audio(task_id) to read it."
 
         if suffix in {".png", ".jpg", ".jpeg", ".gif", ".webp"}:
-            return info + "\nThis is an image. Call view_image to inspect it."
+            return info + "\nThis is an image. Call view_image(task_id, question='...') to inspect it."
 
         return info + "\n(binary file; no preview)"
     except Exception as e:
@@ -344,7 +351,7 @@ TOOLS_SPEC = [
                 "type": "object",
                 "properties": {
                     "url": {"type": "string"},
-                    "max_chars": {"type": "integer", "default": 3500},
+                    "max_chars": {"type": "integer", "default": 1800},
                 },
                 "required": ["url"],
             },
@@ -369,7 +376,7 @@ TOOLS_SPEC = [
         "type": "function",
         "function": {
             "name": "python",
-            "description": "Execute a short Python snippet for math, dates, parsing CSV, list/string work. Use print() or assign to `result`.",
+            "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"}},
@@ -381,7 +388,7 @@ TOOLS_SPEC = [
         "type": "function",
         "function": {
             "name": "get_task_file",
-            "description": "Download the file attached to a GAIA task by task_id and return a text preview. Always call this first if the question references an attached 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"}},
@@ -425,7 +432,7 @@ TOOLS_SPEC = [
                 "type": "object",
                 "properties": {
                     "url": {"type": "string"},
-                    "max_chars": {"type": "integer", "default": 3500},
+                    "max_chars": {"type": "integer", "default": 2500},
                 },
                 "required": ["url"],
             },
@@ -435,14 +442,14 @@ TOOLS_SPEC = [
 
 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", 3500))),
+    "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))),
     "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", "")),
     "youtube_transcript": lambda args: tool_youtube_transcript(
-        args["url"], int(args.get("max_chars", 3500))
+        args["url"], int(args.get("max_chars", 2500))
     ),
 }
 
@@ -451,24 +458,27 @@ SYSTEM_PROMPT = """You are a careful research agent answering GAIA benchmark que
 
 Tools: web_search, fetch_url, wikipedia, python, get_task_file, transcribe_audio, view_image, youtube_transcript.
 
-Workflow:
-- If the question references an attached file/image/audio/code/table, call get_task_file(task_id) first.
-  - For audio (mp3/wav/m4a/ogg), then call transcribe_audio(task_id).
-  - For images (png/jpg/gif/webp), then call view_image(task_id, question="...").
-- If the question references a YouTube link, call youtube_transcript(url).
-- Use web_search then fetch_url to verify facts from primary sources. Prefer official sites and Wikipedia.
-- Use wikipedia for well-known entities, places, and historical facts.
-- Use python for arithmetic, date math, sorting, set operations, parsing strings/CSV. Do NOT eyeball math.
-- Cross-check before answering. Don't guess. If two sources disagree, prefer the most authoritative.
-
-Answer formatting (CRITICAL — grader does an exact-match-style comparison):
-- Reply with ONLY the answer. No preamble, no explanation, no quotes, no trailing period.
+Decide tools by reading the question carefully:
+- ONLY call get_task_file if the question literally says "attached file", "attached image", ".mp3", ".xlsx", ".pdf", ".py", "the file", "the image", "the audio", "the recording", or similar. If get_task_file returns NO_FILE, do NOT call it again — answer from web research.
+- If the question references an audio file/recording, call get_task_file then transcribe_audio.
+- If it references an image, call get_task_file then view_image with a focused question.
+- If it contains a YouTube URL, call youtube_transcript(url) directly. (No need for get_task_file.)
+- If the question text looks reversed (e.g. starts with strange punctuation like ".rewsna" or seems like backwards English), use python to reverse it: `result = "<text>"[::-1]` then answer that reversed question.
+- For factual lookups, prefer wikipedia first for entities/people/places, web_search + fetch_url for everything else.
+- Use python for ALL arithmetic, sums, date math, sorting, alphabetizing. Never compute by hand.
+
+Be concise with tool calls — you have at most 5 tool turns, so plan well.
+
+Answer formatting (CRITICAL — grader does an exact-match comparison):
+- Reply with ONLY the answer. No preamble, no explanation, no quotes, no trailing period, no markdown.
 - Do NOT include the words "FINAL ANSWER", "Answer:", or any label.
 - Numbers: digits only, no commas, no units, no $ sign — UNLESS the question asks for the unit.
+- Currency with "two decimal places": e.g. "89706.00" not "$89,706" not "89706".
 - Strings: no leading articles ("the", "a") unless required; spell out, no abbreviations; write digits as digits.
+- For names: just the requested form (first name only / last name only / full name) — read the question carefully.
 - Lists: comma-separated, single space after each comma, applying the rules above to each element.
-- If the question asks for a name, give just the name. If it asks "how many", give just the number.
-- If the question asks for a list in alphabetical order, sort it.
+- For "alphabetical order" lists, sort them.
+- For "ascending order" numeric lists, sort numerically.
 """
 
 
@@ -489,12 +499,10 @@ class GroqAgent:
             )
         self.client = Groq(api_key=api_key)
         self.models = list(GROQ_MODELS)
-        # Track models that hit a daily-token cap; skip them for the rest of the run.
         self.exhausted_models: set[str] = set()
         print(f"GroqAgent initialized with models={self.models}")
 
-    # ---- Groq call with model fallback + 429 handling -------------------
-    def _chat(self, messages, use_tools: bool = True, max_tokens: int = 1024):
+    def _chat(self, messages, use_tools: bool = True, max_tokens: int = 800):
         last_error: Exception | None = None
         for model in self.models:
             if model in self.exhausted_models:
@@ -515,7 +523,14 @@ class GroqAgent:
                     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:
+                        # Request is too big for this model's TPM bucket.
+                        # Trim history aggressively and try the next model.
+                        print(f"[{model}] 413 too large; will trim and try next model.")
+                        last_error = e
+                        break
                     if is_429 and is_tpd:
                         print(f"[{model}] daily token limit exhausted; switching model.")
                         self.exhausted_models.add(model)
@@ -523,7 +538,7 @@ class GroqAgent:
                     if is_429:
                         wait = self._parse_retry_seconds(msg)
                         wait = min(max(wait, 2), 30)
-                        print(f"[{model}] 429 rate limit; sleeping {wait}s (attempt {attempt + 1}/3)")
+                        print(f"[{model}] 429; sleeping {wait}s (attempt {attempt + 1}/3)")
                         time.sleep(wait)
                         continue
                     print(f"[{model}] API error: {e}")
@@ -539,7 +554,21 @@ class GroqAgent:
         seconds = float(m.group(2)) if m.group(2) else 0.0
         return minutes * 60 + seconds
 
-    # ---- Main entrypoint ------------------------------------------------
+    @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
+
     def __call__(self, question: str, task_id: str | None = None) -> str:
         user_content = question
         if task_id:
@@ -552,9 +581,18 @@ class GroqAgent:
 
         for step in range(MAX_TOOL_ITERATIONS):
             try:
-                resp = self._chat(messages, use_tools=True, max_tokens=1024)
+                resp = self._chat(self._trim_messages(messages), use_tools=True, max_tokens=800)
             except Exception as e:
-                return f"AGENT ERROR: {e}"
+                # Try one more time with no tools, heavily trimmed, to at least get a guess.
+                print(f"chat failed: {e} — trying no-tool fallback.")
+                try:
+                    resp = self._chat(
+                        [messages[0], messages[1]],
+                        use_tools=False,
+                        max_tokens=200,
+                    )
+                except Exception as e2:
+                    return f"AGENT ERROR: {e2}"
 
             msg = resp.choices[0].message
             tool_calls = getattr(msg, "tool_calls", None)
@@ -619,7 +657,7 @@ class GroqAgent:
             }
         )
         try:
-            resp = self._chat(messages, use_tools=False, max_tokens=256)
+            resp = self._chat(self._trim_messages(messages), use_tools=False, max_tokens=200)
             return self._postprocess_answer(
                 (resp.choices[0].message.content or "").strip(), question
             )
@@ -639,13 +677,10 @@ class GroqAgent:
             text,
             flags=re.IGNORECASE,
         )
-        # If model wrapped answer in code fence or quotes.
         text = text.strip("`")
         if len(text) >= 2 and text[0] == text[-1] and text[0] in {'"', "'"}:
             text = text[1:-1].strip()
 
-        # If the question is "how many" / numeric and the model returned a sentence,
-        # try to extract a single number.
         q_lower = question.lower()
         wants_number = bool(
             re.search(r"\bhow many\b|\bhow much\b|\bwhat number\b|\bcount\b", q_lower)
@@ -655,15 +690,15 @@ class GroqAgent:
             if m:
                 text = m.group(0)
 
-        # Strip a single trailing period if the text isn't a list/sentence with internal periods.
-        if text.endswith(".") and text.count(".") == 1 and " " not in text[-3:]:
+        # Strip a single trailing period if the text is short / single token.
+        if text.endswith(".") and " " not in text:
             text = text[:-1]
 
         return text.strip()
 
 
 # ---------------------------------------------------------------------------
-# Answer cache so a failed run doesn't waste tokens
+# Answer cache
 # ---------------------------------------------------------------------------
 def _load_cache() -> dict:
     try:
@@ -748,6 +783,9 @@ 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)
 
     if not answers_payload:
         return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
@@ -810,14 +848,16 @@ with gr.Blocks() as demo:
     gr.Markdown(
         """
         **Setup**
-        1. Add a Space secret named `GROQ_API_KEY` with your Groq API key (free at console.groq.com).
-        2. *Optional but recommended:* add `TAVILY_API_KEY` (free tier at tavily.com) for better search.
-        3. Optional env vars: `GROQ_MODELS`, `GROQ_VISION_MODEL`, `GROQ_WHISPER_MODEL`.
+        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`.
         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`.
-        Answers are cached locally so a failed submission can be retried without re-running the agent.
+
+        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.
         """
     )