Re-add token-aware pacing for llama-3.1-8b-instant's tight TPM

8b model's 6000 TPM cap is tighter in practice than 70b's - a single call already costs 2400-4000 tokens before any tool output. Native requests_per_minute can't account for token size. Re-add TokenPacer step_callback, drop redundant add_base_tools DuckDuckGo tool to shrink per-call overhead.

app.py

@@ -1,5 +1,7 @@
 import os
 import tempfile
+import time
+from collections import deque
 import gradio as gr
 import requests
 import inspect
@@ -39,6 +41,37 @@ If you are asked for a comma separated list, apply the above rules to each eleme
 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 TokenPacer:
+    """
+    Step_callback that tracks actual token usage per step in a trailing 60s
+    window and sleeps as needed to stay under a tokens-per-minute budget.
+    Necessary because a single call's fixed overhead (system prompt + tool
+    schemas + question, before any tool output) already runs 2,400-4,000
+    tokens on this agent - so llama-3.1-8b-instant's free-tier TPM cap (6000)
+    only fits ~1-2 calls per minute regardless of request frequency, which
+    smolagents' native requests_per_minute throttle can't account for since
+    it only paces call count, not size.
+    """
+    def __init__(self, tokens_per_minute_budget: int = 5000):
+        self.tokens_per_minute_budget = tokens_per_minute_budget
+        self._usage_window: deque[tuple[float, int]] = deque()
+
+    def __call__(self, memory_step: ActionStep, agent: CodeAgent) -> None:
+        now = time.monotonic()
+        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"Token pacer: {window_tokens} tokens in the last 60s (budget {self.tokens_per_minute_budget}), sleeping {wait:.1f}s")
+                time.sleep(wait)
+
+
 class MemoryTrimmer:
     """
     Step_callback that collapses old tool outputs in the agent's memory.
@@ -94,13 +127,18 @@ class BasicAgent:
                 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
+            # add_base_tools=True would add a duplicate DuckDuckGo search tool -
+            # every tool's schema is baked into the system prompt on every call,
+            # and that fixed overhead is what's blowing the 6000 TPM budget.
             additional_authorized_imports=[
                 "pandas", "numpy", "math", "re", "json", "itertools",
                 "collections", "statistics", "datetime", "io", "openpyxl", "PIL",
             ],
             max_steps=7,  # keep runs short: growing history otherwise blows the TPM budget by step ~6
-            step_callbacks=[MemoryTrimmer()],
+            step_callbacks=[
+                MemoryTrimmer(),
+                TokenPacer(tokens_per_minute_budget=int(os.getenv("RATE_LIMIT_TOKENS_PER_MINUTE", "5000"))),
+            ],
         )
         print("BasicAgent initialized.")