Make rate limiter token-aware; trim verbose tool outputs

Groq's 429s were a TPM (12k/min) limit, not RPM. RateLimiter now tracks actual token usage per step in a trailing 60s window; VisitWebpageTool and WikipediaSearchTool outputs trimmed to reduce per-call token volume.

app.py

@@ -1,6 +1,7 @@
 import os
 import tempfile
 import time
+from collections import deque
 import gradio as gr
 import requests
 import inspect
@@ -41,25 +42,45 @@ If you are asked for a comma separated list, apply the above rules to each eleme
 
 class RateLimiter:
     """
-    Enforces a minimum delay between successive agent LLM calls (one call per
-    step) as a step_callback, to stay under the model provider's
-    requests-per-minute limit. Groq's free tier for llama-3.3-70b-versatile
-    caps at 30 RPM, so the default here (2.5s) targets that with a small
-    margin; override via RATE_LIMIT_SECONDS_BETWEEN_CALLS for other tiers.
-    Note this only protects against per-minute limits - free tiers also
-    often cap total requests/day, which this can't work around.
+    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).
     """
-    def __init__(self, min_seconds_between_calls: float = 2.5):
+    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 __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:
-                print(f"Rate limiter: sleeping {wait:.1f}s to stay under the RPM limit")
                 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()
 
 
@@ -75,14 +96,21 @@ class BasicAgent:
         self.model = LiteLLMModel(model_id=model_id, api_key=api_key, temperature=0)
         self.agent = CodeAgent(
             model=self.model,
-            tools=[WebSearchTool(), VisitWebpageTool(), WikipediaSearchTool()],
+            tools=[
+                WebSearchTool(),
+                VisitWebpageTool(max_output_length=4000),  # 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
             additional_authorized_imports=[
                 "pandas", "numpy", "math", "re", "json", "itertools",
                 "collections", "statistics", "datetime", "io", "openpyxl", "PIL",
             ],
             max_steps=12,
-            step_callbacks=[RateLimiter(float(os.getenv("RATE_LIMIT_SECONDS_BETWEEN_CALLS", "2.5")))],
+            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")),
+            )],
         )
         print("BasicAgent initialized.")