Harden agent: survive Groq tool_use_failed, enforce per-question timeout

research node retries malformed tool calls then bails to evidence; agent wrapper bounds each question with QUESTION_TIMEOUT via a per-call executor; judge retries cut to 1 to reduce Groq rate-limit stalls; add progress logging.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

gaia_agent/agent.py

@@ -2,6 +2,10 @@
 
 from __future__ import annotations
 
+import time
+from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import TimeoutError as FutureTimeout
+
 from gaia_agent.config import get_settings
 from gaia_agent.graph import graph
 
@@ -18,15 +22,33 @@ class GaiaAgent:
         self._settings = get_settings()
         print("GaiaAgent initialised (LangGraph + Groq).")
 
+    def _run(self, question: str, task_id: str) -> str:
+        result = self._graph.invoke(
+            {"question": question, "task_id": task_id},
+            config={"recursion_limit": self._settings.recursion_limit},
+        )
+        return (result.get("final_answer") or "").strip()
+
     def __call__(self, question: str, task_id: str = "") -> str:
-        """Run the graph on one question and return the bare answer string."""
+        """Run the graph on one question, bounded by QUESTION_TIMEOUT seconds.
+
+        A fresh single-worker executor per call means a timed-out question's thread
+        is abandoned (daemon) rather than blocking the next question.
+        """
+        start = time.time()
+        print(f"[GaiaAgent] task {task_id}: {question[:70]}...")
+        pool = ThreadPoolExecutor(max_workers=1)
+        future = pool.submit(self._run, question, task_id)
         try:
-            result = self._graph.invoke(
-                {"question": question, "task_id": task_id},
-                config={"recursion_limit": self._settings.recursion_limit},
-            )
-            answer = (result.get("final_answer") or "").strip()
-            return answer or "Unable to determine an answer."
+            answer = future.result(timeout=self._settings.question_timeout)
+        except FutureTimeout:
+            print(f"[GaiaAgent] task {task_id} timed out after "
+                  f"{self._settings.question_timeout}s; returning best-effort.")
+            answer = ""
         except Exception as exc:  # noqa: BLE001
-            print(f"GaiaAgent error on task {task_id}: {exc}")
-            return "Unable to determine an answer."
+            print(f"[GaiaAgent] task {task_id} error: {exc}")
+            answer = ""
+        finally:
+            pool.shutdown(wait=False)
+        print(f"[GaiaAgent] task {task_id} done in {time.time() - start:.0f}s -> {answer!r}")
+        return answer or "Unable to determine an answer."

gaia_agent/config.py

@@ -29,7 +29,7 @@ class Settings(BaseSettings):
 
     # --- API + control knobs ---
     gaia_api_url: str = "https://agents-course-unit4-scoring.hf.space"
-    max_judge_retries: int = 2
+    max_judge_retries: int = 1
     recursion_limit: int = 40
     question_timeout: int = 180
 

gaia_agent/nodes.py

@@ -6,7 +6,7 @@ Flow: planner -> [ingest_file] -> research <-> tools -> evidence -> solver
 
 from __future__ import annotations
 
-from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
 
 from gaia_agent.config import get_settings
 from gaia_agent.llm import get_text_llm
@@ -99,6 +99,28 @@ def ingest_file(state: GraphState) -> dict:
 # --------------------------------------------------------------------------- #
 
 
+def _invoke_with_tools(llm, msgs: list):
+    """Invoke a tool-bound LLM, tolerating Groq's occasional malformed tool calls.
+
+    Groq's llama models sometimes emit ``<function=name{...}>`` text instead of a
+    proper tool call, which the API rejects with a 400 ``tool_use_failed``. We retry
+    once with a corrective nudge, then fall back to a tool-less AIMessage so the graph
+    proceeds to the evidence step instead of failing the whole question.
+    """
+    try:
+        return llm.invoke(msgs)
+    except Exception:  # noqa: BLE001
+        nudge = SystemMessage(
+            "Call tools ONLY via the native function-calling interface. Never write "
+            "<function=...> tags or tool calls inside message content. If you do not "
+            "need a tool, answer in plain text."
+        )
+        try:
+            return llm.invoke(msgs + [nudge])
+        except Exception:  # noqa: BLE001
+            return AIMessage(content="(tool calling unavailable; proceeding with context)")
+
+
 def research(state: GraphState) -> dict:
     """Run one step of the research tool-calling loop."""
     llm = get_text_llm().bind_tools(RESEARCH_TOOLS)
@@ -115,9 +137,9 @@ def research(state: GraphState) -> dict:
                 "needed to answer precisely. Call tools as needed; stop when confident."
             ),
         ]
-        ai = llm.invoke(seed)
+        ai = _invoke_with_tools(llm, seed)
         return {"messages": seed + [ai]}
-    ai = llm.invoke(state["messages"])
+    ai = _invoke_with_tools(llm, state["messages"])
     return {"messages": [ai]}