Update.

README.md

@@ -12,4 +12,24 @@ hf_oauth: true
 hf_oauth_expiration_minutes: 480
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+## Agent architecture
+
+- The manager uses `GROQ_MANAGER_MODEL` (default: `openai/gpt-oss-120b`).
+- Web research is one direct, bounded Tavily request; it does not start a
+  second LLM agent.
+- Document and media tasks keep dedicated agents because they may need to
+  download and inspect an attachment in multiple steps.
+- Calculations use `python_exec` or `calculator` directly.
+- Final answer formatting uses `GROQ_NORMALIZER_MODEL` (default:
+  `openai/gpt-oss-20b`).
+
+Required Space secrets are `GROQ_API_KEY` and `TAVILY_API_KEY`. Set
+`GROQ_VLM_MODEL` as well to enable image and video analysis.
+
+Run the offline web-search regression tests with:
+
+```bash
+python -m unittest -v test_web_search.py
+```

agents.py

@@ -10,6 +10,8 @@ def _make_llm(model: str = "openai/gpt-oss-120b", temperature: float = 0.1) -> C
         model=model,
         temperature=temperature,
         api_key=os.getenv("GROQ_API_KEY"),
+        timeout=60,
+        max_retries=2,
     )
 
 
@@ -19,29 +21,12 @@ def _make_llm(model: str = "openai/gpt-oss-120b", temperature: float = 0.1) -> C
 #   curl -s https://api.groq.com/openai/v1/models \
 #     -H "Authorization: Bearer $GROQ_API_KEY" | jq '.data[].id'
 _ROLE_MODELS = {
-    "web": os.getenv("GROQ_WEB_MODEL", "openai/gpt-oss-120b"),
-    "file": os.getenv("GROQ_FILE_MODEL", "openai/gpt-oss-120b"),
+    "file": os.getenv("GROQ_FILE_MODEL", "openai/gpt-oss-20b"),
     "media": os.getenv("GROQ_MEDIA_MODEL", "openai/gpt-oss-120b"),
-    "code": os.getenv("GROQ_CODE_MODEL", "openai/gpt-oss-120b"),
-    "normalizer": os.getenv("GROQ_NORMALIZER_MODEL", "openai/gpt-oss-120b"),
+    "normalizer": os.getenv("GROQ_NORMALIZER_MODEL", "openai/gpt-oss-20b"),
 }
 
 
-WEB_RESEARCH_PROMPT = """You are a web research specialist.
-
-For each question:
-1. Break it into sub-questions if needed.
-2. Use `search_tool` to find candidate sources. When a search snippet is
-   ambiguous or truncated, call `fetch_url` on the most relevant hit to
-   read the actual page.
-3. Cross-check facts across at least 2 independent sources before concluding
-   when the answer is not obvious.
-4. Return a concise, factual answer. If the question asks for a specific
-   value (number, name, date, list), give ONLY that value. Otherwise, keep
-   the answer under 3 sentences.
-5. Never guess. If you cannot verify, say "unknown"."""
-
-
 FILE_ANALYSIS_PROMPT = """You are a document analysis specialist.
 
 You handle questions that reference a task_id, URL, or file path pointing to
@@ -59,22 +44,6 @@ Workflow:
    verbatim when possible. Do not speculate."""
 
 
-CODE_AGENT_PROMPT = """You are a Python computation specialist.
-
-You answer questions that need arithmetic, list/string manipulation, date math,
-pandas transforms, unit conversions, or any calculation better *computed* than
-reasoned about.
-
-Workflow:
-1. Prefer `calculator` for a single closed-form math expression.
-2. Otherwise write a short Python snippet and run it via `python_exec`.
-   You MUST `print()` any value you want to see back — the tool returns stdout.
-3. If `python_exec` returns an error, read the traceback, fix the code, and
-   retry. Do not give up after one failure; iterate up to 3 times.
-4. Return ONLY the final computed value. No code in the final answer, no
-   explanation, no units unless asked."""
-
-
 MEDIA_ANALYSIS_PROMPT = """You are a media analysis specialist (image, audio, video).
 
 You handle questions that reference a task_id, URL, or file path pointing to
@@ -111,21 +80,6 @@ Never explain, never apologize, never quote the answer.
 Output ONLY the normalized answer, on a single line, nothing else."""
 
 
-class WebResearchAgent:
-    def __init__(self):
-        from tools import fetch_url, search_tool  # lazy: avoids circular import
-
-        self.graph = create_agent(
-            _make_llm(model=_ROLE_MODELS["web"]),
-            tools=[search_tool, fetch_url],
-            system_prompt=WEB_RESEARCH_PROMPT,
-        )
-
-    def __call__(self, question: str) -> str:
-        result = self.graph.invoke({"messages": [("user", question)]})
-        return result["messages"][-1].content
-
-
 class FileAnalysisAgent:
     def __init__(self):
         from tools import (
@@ -143,7 +97,10 @@ class FileAnalysisAgent:
         )
 
     def __call__(self, question: str) -> str:
-        result = self.graph.invoke({"messages": [("user", question)]})
+        result = self.graph.invoke(
+            {"messages": [("user", question)]},
+            config={"recursion_limit": 8},
+        )
         return result["messages"][-1].content
 
 
@@ -170,22 +127,10 @@ class MediaAgent:
         )
 
     def __call__(self, question: str) -> str:
-        result = self.graph.invoke({"messages": [("user", question)]})
-        return result["messages"][-1].content
-
-
-class CodeAgent:
-    def __init__(self):
-        from tools import calculator, python_exec  # lazy: avoids circular import
-
-        self.graph = create_agent(
-            _make_llm(model=_ROLE_MODELS["code"]),
-            tools=[python_exec, calculator],
-            system_prompt=CODE_AGENT_PROMPT,
+        result = self.graph.invoke(
+            {"messages": [("user", question)]},
+            config={"recursion_limit": 8},
         )
-
-    def __call__(self, question: str) -> str:
-        result = self.graph.invoke({"messages": [("user", question)]})
         return result["messages"][-1].content
 
 

app.py

@@ -17,23 +17,22 @@ from langgraph.prebuilt import ToolNode
 
 MANAGER_SYSTEM_PROMPT = """You are a QA agent for the GAIA benchmark.
 
-You have four specialist tools:
-- web_research(question): factual / current world knowledge (people, dates,
-  events, statistics).
+You have five tools:
+- web_research(question): one concise web search (maximum 25 words) returning
+  a short summary and three source excerpts.
 - file_analysis(question): question about an attached document
   (pdf / xlsx / csv / txt / json). Include the task_id or URL in your question.
 - media_analysis(question): question about an image, audio, or video (also
   YouTube URLs). Include the task_id or URL in your question.
-- compute(question): math, arithmetic, list ops, date math, string parsing,
-  unit conversions. State the computation in plain language with the inputs.
+- calculator(expression): one arithmetic expression.
+- python_exec(code): short Python computation; print the result.
 
 Rules:
-1. When a task has an attached file (mentioned by task_id), route to
-   file_analysis or media_analysis with the task_id embedded in the question.
-2. Ask each specialist ONE precise question at a time.
-3. Chain tools when needed (e.g. web_research to find numbers, then
-   compute to combine them).
-4. Final answer: give ONLY the value the question asks for. No preamble,
+1. Use the task_id only when the question refers to an attached file or media.
+2. For web research, search for one fact at a time. Never paste a long question
+   or previous search results into a new search query.
+3. Use no more than three tool rounds. Chain tools only when required.
+4. Final answer: give ONLY the requested value. No preamble,
    no explanation."""
 
 # (Keep Constants as is)
@@ -62,27 +61,29 @@ class BasicAgent:
         # Requires GROQ_API_KEY in the environment (set as a Space secret on HF).
         self.tools = ALL_TOOLS
         self.chat = ChatGroq(
-            model="openai/gpt-oss-120b",
+            model=os.getenv("GROQ_MANAGER_MODEL", "openai/gpt-oss-120b"),
             temperature=0.1,
             api_key=os.getenv("GROQ_API_KEY"),
+            timeout=60,
+            max_retries=2,
         )
         self.chat = self.chat.bind_tools(self.tools)
         self.agent = self.__init__agent__()
         self.normalizer = AnswerNormalizer()
 
-    def __call__(self, question: str) -> str:
-        return self.answer(question)
+    def __call__(self, question: str, task_id: str | None = None) -> str:
+        return self.answer(question, task_id=task_id)
 
     def __init__agent__(self):
         builder = StateGraph(AgentState)
-        builder.add_node("assistant", self.assitant)
+        builder.add_node("assistant", self.assistant)
         builder.add_node("tools", ToolNode(self.tools))
         builder.add_edge(START, "assistant")
         builder.add_conditional_edges("assistant", tools_condition)
         builder.add_edge("tools", "assistant")
         return builder.compile()
 
-    def assitant(self, state: AgentState):
+    def assistant(self, state: AgentState):
         messages = state["messages"]
         if not messages or not isinstance(messages[0], SystemMessage):
             messages = [SystemMessage(content=MANAGER_SYSTEM_PROMPT)] + list(messages)
@@ -90,9 +91,18 @@ class BasicAgent:
             "messages": [self.chat.invoke(messages)],
         }
 
-    def answer(self, question):
-        messages = [HumanMessage(content=question)]
-        response = self.agent.invoke({"messages": messages})
+    def answer(self, question: str, task_id: str | None = None) -> str:
+        user_content = f"QUESTION:\n{question}"
+        if task_id:
+            user_content += (
+                f"\n\nTASK_ID: {task_id}\n"
+                "Use this id only if the question requires an attached file."
+            )
+        messages = [HumanMessage(content=user_content)]
+        response = self.agent.invoke(
+            {"messages": messages},
+            config={"recursion_limit": 8},
+        )
         raw = response["messages"][-1].content
         return self.normalizer(question, raw)
 
@@ -158,7 +168,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text)
+            submitted_answer = agent(question_text, task_id=task_id)
             answers_payload.append(
                 {"task_id": task_id, "submitted_answer": submitted_answer}
             )

test_web_search.py

@@ -0,0 +1,99 @@
+"""Offline regression tests for the bounded web-search path."""
+
+import os
+import unittest
+from unittest.mock import patch
+
+import tools
+
+
+class FakeTavilyClient:
+    def __init__(self, response):
+        self.response = response
+        self.calls = []
+
+    def search(self, **kwargs):
+        self.calls.append(kwargs)
+        return self.response
+
+
+class WebSearchTests(unittest.TestCase):
+    def tearDown(self):
+        tools._tavily_client = None
+
+    def test_query_is_normalized_and_capped(self):
+        self.assertEqual(tools._compact_query("  a   short\nquery "), "a short query")
+
+        long_query = "word " * 200
+        compact = tools._compact_query(long_query)
+        self.assertLessEqual(len(compact), tools.WEB_QUERY_MAX_CHARS)
+        self.assertFalse(compact.endswith(" "))
+
+    def test_result_payload_has_hard_limits(self):
+        response = {
+            "answer": "a" * 3_000,
+            "results": [
+                {
+                    "title": f"Result {index}",
+                    "url": f"https://example.com/{index}",
+                    "content": "x" * 4_000,
+                }
+                for index in range(8)
+            ],
+        }
+
+        output = tools._format_search_results(response)
+
+        self.assertLessEqual(len(output), tools.WEB_OUTPUT_MAX_CHARS)
+        self.assertIn("Source 3", output)
+        self.assertNotIn("Source 4", output)
+        self.assertIn("[truncated]", output)
+
+    def test_web_research_is_one_direct_tavily_call(self):
+        fake = FakeTavilyClient(
+            {
+                "answer": "Paris",
+                "results": [
+                    {
+                        "title": "France",
+                        "url": "https://example.com/france",
+                        "content": "Paris is the capital of France.",
+                    }
+                ],
+            }
+        )
+        tools._tavily_client = fake
+
+        output = tools.web_research.invoke(
+            {"question": "  capital   of France "}
+        )
+
+        self.assertIn("Paris", output)
+        self.assertEqual(len(fake.calls), 1)
+        self.assertEqual(fake.calls[0]["query"], "capital of France")
+        self.assertEqual(fake.calls[0]["max_results"], tools.WEB_MAX_RESULTS)
+        self.assertTrue(fake.calls[0]["include_answer"])
+        self.assertFalse(fake.calls[0]["include_raw_content"])
+        self.assertFalse(fake.calls[0]["include_images"])
+
+    def test_missing_api_key_fails_only_when_search_is_used(self):
+        tools._tavily_client = None
+        with patch.dict(os.environ, {}, clear=True):
+            with self.assertRaisesRegex(RuntimeError, "TAVILY_API_KEY"):
+                tools._get_tavily_client()
+
+    def test_manager_exposes_only_five_bounded_tools(self):
+        self.assertEqual(
+            [tool.name for tool in tools.ALL_TOOLS],
+            [
+                "web_research",
+                "file_analysis",
+                "media_analysis",
+                "python_exec",
+                "calculator",
+            ],
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tools.py

@@ -11,13 +11,76 @@ import requests
 from langchain_core.messages import HumanMessage
 from langchain_core.tools import tool
 from langchain_groq import ChatGroq
-from tavily import TavilyClient
 
-from agents import CodeAgent, FileAnalysisAgent, MediaAgent, WebResearchAgent
+from agents import FileAnalysisAgent, MediaAgent
 
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
+WEB_QUERY_MAX_CHARS = 400
+WEB_RESULT_MAX_CHARS = 1_000
+WEB_ANSWER_MAX_CHARS = 1_200
+WEB_OUTPUT_MAX_CHARS = 5_000
+WEB_MAX_RESULTS = 3
+
+_tavily_client = None
+
+
+def _truncate(text: str, max_chars: int) -> str:
+    """Keep tool payloads bounded while making truncation visible."""
+    text = str(text or "").strip()
+    if len(text) <= max_chars:
+        return text
+    marker = "\n[truncated]"
+    if max_chars <= len(marker):
+        return text[:max_chars]
+    return f"{text[: max_chars - len(marker)].rstrip()}{marker}"
+
+
+def _compact_query(query: str) -> str:
+    """Normalize and cap a natural-language query before sending it to Tavily."""
+    compact = " ".join(str(query or "").split())
+    if not compact:
+        raise ValueError("The web search query is empty.")
+    if len(compact) <= WEB_QUERY_MAX_CHARS:
+        return compact
+
+    shortened = compact[:WEB_QUERY_MAX_CHARS]
+    if " " in shortened:
+        shortened = shortened.rsplit(" ", 1)[0]
+    return shortened
+
+
+def _get_tavily_client():
+    """Create the client only when web search is actually requested."""
+    global _tavily_client
+    if _tavily_client is None:
+        api_key = os.getenv("TAVILY_API_KEY")
+        if not api_key:
+            raise RuntimeError("TAVILY_API_KEY is not configured.")
+        from tavily import TavilyClient
+
+        _tavily_client = TavilyClient(api_key=api_key)
+    return _tavily_client
+
+
+def _format_search_results(response: dict) -> str:
+    """Return a small, predictable search payload for the manager model."""
+    blocks = []
+    answer = response.get("answer")
+    if answer:
+        blocks.append(f"Search summary: {_truncate(answer, WEB_ANSWER_MAX_CHARS)}")
+
+    for index, result in enumerate(response.get("results", [])[:WEB_MAX_RESULTS], 1):
+        title = _truncate(result.get("title", "Untitled"), 200)
+        url = str(result.get("url", "")).strip()
+        content = _truncate(result.get("content", ""), WEB_RESULT_MAX_CHARS)
+        blocks.append(
+            f"Source {index}\nTitle: {title}\nURL: {url}\nExcerpt: {content}"
+        )
+
+    if not blocks:
+        return "No web results found."
+    return _truncate("\n\n".join(blocks), WEB_OUTPUT_MAX_CHARS)
 
 
 @tool
@@ -28,16 +91,16 @@ def search_tool(query: str) -> str:
     Args:
         query: Search query.
     """
-    results = tavily_client.search(query=query, max_results=5, search_depth="basic")
-
-    output = []
-    for r in results["results"]:
-        output.append(f"""
-Title: {r['title']}
-URL: {r['url']}
-Content: {r['content']}
-""")
-    return "\n".join(output)
+    compact_query = _compact_query(query)
+    response = _get_tavily_client().search(
+        query=compact_query,
+        max_results=WEB_MAX_RESULTS,
+        search_depth="basic",
+        include_answer=True,
+        include_raw_content=False,
+        include_images=False,
+    )
+    return _format_search_results(response)
 
 
 @tool
@@ -391,25 +454,36 @@ def youtube_transcript(url_or_id: str) -> str:
     return " ".join(e["text"] for e in entries)
 
 
-_web_agent = WebResearchAgent()
-_file_agent = FileAnalysisAgent()
-_media_agent = MediaAgent()
-_code_agent = CodeAgent()
+_file_agent = None
+_media_agent = None
+
+
+def _get_file_agent() -> FileAnalysisAgent:
+    global _file_agent
+    if _file_agent is None:
+        _file_agent = FileAnalysisAgent()
+    return _file_agent
+
+
+def _get_media_agent() -> MediaAgent:
+    global _media_agent
+    if _media_agent is None:
+        _media_agent = MediaAgent()
+    return _media_agent
 
 
 @tool
 def web_research(question: str) -> str:
-    """Answer a factual question using web search and page reading.
+    """Search the web and return a compact summary with source excerpts.
 
-    Delegates to a specialist that searches (Tavily), visits pages when
-    snippets are insufficient, and cross-checks. Use for anything requiring
-    up-to-date or external world knowledge: people, dates, events, statistics,
-    biographies, current affairs.
+    This is deliberately a direct, bounded Tavily call rather than a nested
+    agent. Use a short query about one fact at a time. The query is capped at
+    400 characters and the result payload at 5,000 characters.
 
     Args:
-        question: Natural-language research question.
+        question: Concise natural-language search query.
     """
-    return _web_agent(question)
+    return search_tool.invoke({"query": question})
 
 
 @tool
@@ -425,7 +499,7 @@ def file_analysis(question: str) -> str:
     Args:
         question: Natural-language question mentioning the task_id / URL / path.
     """
-    return _file_agent(question)
+    return _get_file_agent()(question)
 
 
 @tool
@@ -442,27 +516,13 @@ def media_analysis(question: str) -> str:
     Args:
         question: Natural-language question mentioning the task_id / URL / path.
     """
-    return _media_agent(question)
-
-
-@tool
-def compute(question: str) -> str:
-    """Delegate math, arithmetic, data manipulation, or string parsing to a code specialist.
-
-    The specialist writes Python, runs it, iterates on errors, and returns the
-    computed value. Use for anything better *computed* than reasoned about:
-    sums / averages / dates / list ops / unit conversions / regex extraction.
-
-    Args:
-        question: What to compute, plainly stated. Include any input data or
-            values needed to perform the computation.
-    """
-    return _code_agent(question)
+    return _get_media_agent()(question)
 
 
 ALL_TOOLS = [
     web_research,
     file_analysis,
     media_analysis,
-    compute,
+    python_exec,
+    calculator,
 ]