Use smolagents' native RPM/retry controls, cap steps, trim memory

Custom step_callback throttling couldn't see smolagents' own internal retries on rate-limit errors. Switch to LiteLLMModel's native requests_per_minute=25 and retry=False. Cap max_steps=7 and add MemoryTrimmer to stop unbounded context growth (the real driver of TPM failures). Prioritizes speed - a failed question is skipped, not retried.

app.py

@@ -1,7 +1,5 @@
 import os
 import tempfile
-import time
-from collections import deque
 import gradio as gr
 import requests
 import inspect
@@ -38,50 +36,30 @@ Your final answer should be a number OR as few words as possible OR a comma sepa
 If you are asked for a number, don't use commas to write it, and don't use units such as $ or % unless specified otherwise.
 If you are asked for a string, don't use articles or abbreviations (e.g. for cities), and write digits in plain text unless specified otherwise.
 If you are asked for a comma separated list, apply the above rules to each element depending on whether it's a number or a string.
+Work efficiently: if a search or lookup doesn't find what you need after 1-2 tries, try a meaningfully different approach rather than repeating similar queries, and give your best-guess final_answer rather than exhausting all steps.
 """
 
-class RateLimiter:
+class MemoryTrimmer:
     """
-    Step_callback that throttles both request frequency (RPM) and actual
-    token volume (TPM) against the model provider's free-tier limits. Groq's
-    free tier for llama-3.3-70b-versatile caps at 30 RPM and 12,000 TPM - and
-    TPM is the tighter constraint here, since a CodeAgent's context (tool
-    outputs, growing conversation history) can easily run several thousand
-    tokens per call. Tracks actual usage reported per step in a trailing
-    60s window and sleeps as needed to stay under a token budget (with
-    margin below the real cap).
+    Step_callback that collapses old tool outputs in the agent's memory.
+    CodeAgent re-sends the *entire* step history on every call, so input
+    tokens grow every single step (2k -> 5k -> 8k -> ... -> 20k+ by step 6),
+    which both wrecks the TPM budget and slows every later step far more
+    than it needs to. Keeps the most recent `keep_recent` steps' tool
+    outputs intact (the agent still needs that detail) and truncates older
+    ones to a short placeholder, keeping per-call token cost roughly flat
+    across a run instead of growing unbounded.
     """
-    def __init__(self, min_seconds_between_calls: float = 2.5, tokens_per_minute_budget: int = 9000):
-        self.min_seconds_between_calls = min_seconds_between_calls
-        self.tokens_per_minute_budget = tokens_per_minute_budget
-        self._last_call_at: float | None = None
-        self._usage_window: deque[tuple[float, int]] = deque()
+    def __init__(self, keep_recent: int = 2, max_old_observation_chars: int = 300):
+        self.keep_recent = keep_recent
+        self.max_old_observation_chars = max_old_observation_chars
 
     def __call__(self, memory_step: ActionStep, agent: CodeAgent) -> None:
-        now = time.monotonic()
-
-        # RPM guard
-        if self._last_call_at is not None:
-            wait = self.min_seconds_between_calls - (now - self._last_call_at)
-            if wait > 0:
-                time.sleep(wait)
-                now = time.monotonic()
-
-        # TPM guard, based on actual usage from the step that just completed
-        usage = getattr(memory_step, "token_usage", None)
-        tokens = (usage.input_tokens + usage.output_tokens) if usage else 0
-        self._usage_window.append((now, tokens))
-        cutoff = now - 60
-        while self._usage_window and self._usage_window[0][0] < cutoff:
-            self._usage_window.popleft()
-        window_tokens = sum(t for _, t in self._usage_window)
-        if window_tokens > self.tokens_per_minute_budget and self._usage_window:
-            wait = 60 - (now - self._usage_window[0][0]) + 0.5
-            if wait > 0:
-                print(f"Rate limiter: {window_tokens} tokens in the last 60s (budget {self.tokens_per_minute_budget}), sleeping {wait:.1f}s")
-                time.sleep(wait)
-
-        self._last_call_at = time.monotonic()
+        action_steps = [step for step in agent.memory.steps if isinstance(step, ActionStep)]
+        for step in action_steps[:-self.keep_recent]:
+            observations = getattr(step, "observations", None)
+            if observations and len(observations) > self.max_old_observation_chars:
+                step.observations = observations[:self.max_old_observation_chars] + " [...older output truncated to save context]"
 
 
 # --- Basic Agent Definition ---
@@ -93,12 +71,27 @@ class BasicAgent:
         if not api_key:
             print("Warning: GROQ_API_KEY is not set - the agent will fail to call the model.")
 
-        self.model = LiteLLMModel(model_id=model_id, api_key=api_key, temperature=0)
+        # requests_per_minute: smolagents' own ApiModel throttles calls at this
+        # rate before ever hitting the API (a bit under Groq's 30 RPM cap).
+        # retry=False: smolagents' default retries a failed call several
+        # times internally (invisible to us - confirmed via Groq's dashboard,
+        # 429s with sub-second gaps between requests). Only ~30% of GAIA
+        # questions need to succeed here, so a call that still gets rate
+        # limited (e.g. on tokens/minute, which this doesn't track) should
+        # just fail fast - the per-question try/except below skips it and
+        # moves on, which is much cheaper than retry-storming.
+        self.model = LiteLLMModel(
+            model_id=model_id,
+            api_key=api_key,
+            temperature=0,
+            requests_per_minute=float(os.getenv("RATE_LIMIT_RPM", "25")),
+            retry=False,
+        )
         self.agent = CodeAgent(
             model=self.model,
             tools=[
                 WebSearchTool(),
-                VisitWebpageTool(max_output_length=4000),  # default 40000 chars blows the TPM budget in one call
+                VisitWebpageTool(max_output_length=3000),  # default 40000 chars blows the TPM budget in one call
                 WikipediaSearchTool(content_type="summary"),  # "text" (default) returns the full article
             ],
             add_base_tools=True,  # adds DuckDuckGo search + Whisper audio transcriber
@@ -106,11 +99,8 @@ class BasicAgent:
                 "pandas", "numpy", "math", "re", "json", "itertools",
                 "collections", "statistics", "datetime", "io", "openpyxl", "PIL",
             ],
-            max_steps=12,
-            step_callbacks=[RateLimiter(
-                min_seconds_between_calls=float(os.getenv("RATE_LIMIT_SECONDS_BETWEEN_CALLS", "2.5")),
-                tokens_per_minute_budget=int(os.getenv("RATE_LIMIT_TOKENS_PER_MINUTE", "9000")),
-            )],
+            max_steps=7,  # keep runs short: growing history otherwise blows the TPM budget by step ~6
+            step_callbacks=[MemoryTrimmer()],
         )
         print("BasicAgent initialized.")