Make DuckDuckGo rate-limit non-fatal so the agent can still answer

Before this change, a 202 Ratelimit from html.duckduckgo.com (common
when many HF Spaces share the same outbound IP) propagated all the way
up to run_ui and replaced the result with a raw "Error: ...
202 Ratelimit" string — no table, no answer, nothing.

Catch all exceptions in _run_search_single, retry once with a short
backoff to ride out transient 202s, and on persistent failure return a
structured tool error with an "answer from your own knowledge" hint so
the agent loop can still produce a final <answer> for questions the
model already knows (e.g. iPhone 15 vs 16 comparisons).

Made-with: Cursor

app.py

@@ -1,6 +1,7 @@
 import json
 import os
 import re
+import time
 from dataclasses import dataclass, field
 from datetime import date
 from pathlib import Path
@@ -950,26 +951,64 @@ def parse_tool_call(text: str) -> Tuple[Optional[str], Optional[Dict[str, Any]],
     return name, arguments, None
 
 
+_SEARCH_UNAVAILABLE_HINT = (
+    "The web-search backend is currently rate-limited or unreachable. "
+    "If this question can be answered confidently from your own training "
+    "knowledge (e.g. common product specs, historical facts, definitions), "
+    "please produce your best answer now inside <answer>...</answer>, and "
+    "mention any value that might be out of date. Only ask the user to "
+    "retry later if the question truly requires a fresh web lookup."
+)
+
+
 def _run_search_single(query: str, max_results: int) -> Dict[str, Any]:
+    """Run one DuckDuckGo query.
+
+    Returns a structured dict on both success and failure, never raises. If
+    the search backend rate-limits us (Space IPs share outbound NAT and
+    often trip DuckDuckGo's anti-scraping throttle), we return an
+    `ok: False` payload with a hint that lets the agent fall back to its
+    own knowledge instead of aborting the whole research run.
+    """
     if not query.strip():
         return {"ok": False, "error": "Search query cannot be empty."}
     cache_key = f"{query.strip().lower()}::{max_results}"
     if cache_key in SEARCH_CACHE:
         return {**SEARCH_CACHE[cache_key], "cached": True}
 
-    rows: List[Dict[str, str]] = []
-    with DDGS() as ddgs:
-        for item in ddgs.text(query, max_results=max_results):
-            rows.append(
-                {
-                    "title": item.get("title", ""),
-                    "href": item.get("href", ""),
-                    "body": item.get("body", ""),
-                }
-            )
-    payload = {"ok": True, "query": query, "results": rows, "cached": False}
-    SEARCH_CACHE[cache_key] = payload
-    return payload
+    last_exc: Optional[BaseException] = None
+    for attempt in range(2):
+        try:
+            rows: List[Dict[str, str]] = []
+            with DDGS() as ddgs:
+                for item in ddgs.text(query, max_results=max_results):
+                    rows.append(
+                        {
+                            "title": item.get("title", ""),
+                            "href": item.get("href", ""),
+                            "body": item.get("body", ""),
+                        }
+                    )
+            payload = {"ok": True, "query": query, "results": rows, "cached": False}
+            SEARCH_CACHE[cache_key] = payload
+            return payload
+        except Exception as exc:
+            last_exc = exc
+            # One retry with a small backoff covers most transient 202
+            # Ratelimit / transient network hiccups; on the second failure
+            # we give up and return a graceful error to the agent.
+            if attempt == 0:
+                time.sleep(1.5)
+                continue
+
+    err = f"{type(last_exc).__name__}: {last_exc}" if last_exc else "unknown error"
+    return {
+        "ok": False,
+        "query": query,
+        "error": f"Search backend unavailable ({err}).",
+        "results": [],
+        "hint": _SEARCH_UNAVAILABLE_HINT,
+    }
 
 
 def run_search(query: Union[str, List[str]], max_results: int = 5) -> Dict[str, Any]: