Update app.py

app.py

@@ -2,8 +2,10 @@ import os
 import re
 import base64
 import ast
+import json
 import math
 import operator
+import threading
 from io import BytesIO
 from pathlib import Path
 from zipfile import ZipFile
@@ -11,9 +13,7 @@ from zipfile import ZipFile
 import gradio as gr
 import pandas as pd
 import requests
-from litellm import completion
 from smolagents import (
-    DuckDuckGoSearchTool,
     LiteLLMModel,
     Tool,
     ToolCallingAgent,
@@ -28,11 +28,13 @@ MAX_EXTRACTED_CHARS = 8_000
 WEBPAGE_CONNECT_TIMEOUT = 8
 WEBPAGE_READ_TIMEOUT = 20
 MAX_WEBPAGE_CHARS = 6_000
-DEFAULT_MAIN_MODEL = "groq/qwen/qwen3.6-27b"
-DEFAULT_GROQ_REVIEW_MODEL = "groq/qwen/qwen3.6-27b"
+DEFAULT_MAIN_MODEL = "cerebras/zai-glm-4.7"
+DEFAULT_GEMINI_REVIEW_MODEL = "gemini-3.5-flash"
 TASK_FILE_CACHE = {}
 ATTACHMENT_CACHE = {}
 WEBPAGE_CACHE = {}
+SEARCH_CACHE = {}
+SEARCH_LOCK = threading.Lock()
 
 
 def compact_error(exc: Exception) -> str:
@@ -336,6 +338,56 @@ def extract_attachment_text(
     return text
 
 
+class ConciseWebSearchTool(Tool):
+    name = "web_search"
+    description = (
+        "Searches the public web without an API key. Returns at most five "
+        "compact results. Use one precise query, then open the best source. "
+        "Identical repeated searches are skipped automatically."
+    )
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "One concise web search query.",
+        }
+    }
+    output_type = "string"
+
+    def forward(self, query: str) -> str:
+        from ddgs import DDGS
+
+        query = " ".join(str(query or "").split())
+        if not query:
+            return "Search query is empty."
+        cache_key = query.casefold()
+
+        # The lock also prevents parallel duplicate searches from both sending
+        # the same network request and duplicating a large observation.
+        with SEARCH_LOCK:
+            if cache_key in SEARCH_CACHE:
+                return (
+                    "Duplicate search skipped; the identical results are "
+                    "already present in this run. Open one of those URLs."
+                )
+            try:
+                raw_results = list(DDGS().text(query, max_results=5))
+                lines = []
+                for index, result in enumerate(raw_results[:5], start=1):
+                    title = " ".join(str(result.get("title") or "").split())
+                    url = str(result.get("href") or result.get("url") or "").strip()
+                    snippet = " ".join(str(result.get("body") or "").split())
+                    lines.append(
+                        f"{index}. {title[:180]}\n"
+                        f"URL: {url}\n"
+                        f"Snippet: {snippet[:320]}"
+                    )
+                output = "\n\n".join(lines) or "No search results found."
+                SEARCH_CACHE[cache_key] = output
+                return output
+            except Exception as exc:
+                return f"Web search failed: {compact_error(exc)}"
+
+
 class OpenWebPageTool(Tool):
     name = "visit_webpage"
     description = (
@@ -528,7 +580,7 @@ class TranscribeGaiaAudioTool(Tool):
     description = (
         "Downloads and transcribes the official GAIA audio attachment. Use it "
         "first whenever the attachment is MP3, WAV, FLAC, M4A, OGG, or WEBM. "
-        "Speech transcription uses the separate audio quota, not chat tokens."
+        "It uses Hugging Face speech recognition, not the chat model."
     )
     inputs = {
         "task_id": {
@@ -551,78 +603,33 @@ class TranscribeGaiaAudioTool(Tool):
                     "inspect_gaia_attachment."
                 )
 
-            errors = []
-            groq_api_key = os.getenv("GROQ_API_KEY")
-            if groq_api_key:
-                mime_types = {
-                    ".mp3": "audio/mpeg",
-                    ".wav": "audio/wav",
-                    ".flac": "audio/flac",
-                    ".m4a": "audio/mp4",
-                    ".ogg": "audio/ogg",
-                    ".webm": "audio/webm",
-                    ".mp4": "video/mp4",
-                }
-                try:
-                    response = requests.post(
-                        "https://api.groq.com/openai/v1/audio/transcriptions",
-                        headers={"Authorization": f"Bearer {groq_api_key}"},
-                        files={
-                            "file": (
-                                filename,
-                                data,
-                                mime_types.get(suffix, "application/octet-stream"),
-                            )
-                        },
-                        data={
-                            "model": "whisper-large-v3-turbo",
-                            "response_format": "json",
-                            "temperature": "0",
-                            "language": "en",
-                        },
-                        timeout=(WEBPAGE_CONNECT_TIMEOUT, 90),
-                    )
-                    response.raise_for_status()
-                    transcript = str(response.json().get("text") or "").strip()
-                    if transcript:
-                        return (
-                            f"Audio transcript ({filename}):\n"
-                            f"{transcript[:6_000]}"
-                        )
-                    errors.append("Groq returned an empty transcript.")
-                except Exception as exc:
-                    detail = compact_error(exc)
-                    if "response" in locals() and response is not None:
-                        detail += f" Response: {response.text[:500]}"
-                    errors.append(f"Groq speech-to-text: {detail}")
-
             hf_token = os.getenv("HF_TOKEN")
-            if hf_token:
-                try:
-                    from huggingface_hub import InferenceClient
-
-                    client = InferenceClient(api_key=hf_token, provider="auto")
-                    transcript_result = client.automatic_speech_recognition(
-                        data,
-                        model=os.getenv(
-                            "GAIA_ASR_MODEL", "openai/whisper-large-v3"
-                        ),
-                    )
-                    transcript = str(
-                        getattr(transcript_result, "text", transcript_result)
-                    ).strip()
-                    if transcript:
-                        return (
-                            f"Audio transcript ({filename}):\n"
-                            f"{transcript[:6_000]}"
-                        )
-                    errors.append("Hugging Face returned an empty transcript.")
-                except Exception as exc:
-                    errors.append(
-                        f"Hugging Face speech-to-text: {compact_error(exc)}"
-                    )
+            if not hf_token:
+                return "Audio transcription failed: HF_TOKEN is not configured."
+            try:
+                from huggingface_hub import InferenceClient
 
-            return "Audio transcription failed. " + " | ".join(errors)
+                client = InferenceClient(api_key=hf_token, provider="auto")
+                transcript_result = client.automatic_speech_recognition(
+                    data,
+                    model=os.getenv(
+                        "GAIA_ASR_MODEL", "openai/whisper-large-v3"
+                    ),
+                )
+                transcript = str(
+                    getattr(transcript_result, "text", transcript_result)
+                ).strip()
+                if not transcript:
+                    return "Hugging Face returned an empty audio transcript."
+                return (
+                    f"Audio transcript ({filename}):\n"
+                    f"{transcript[:6_000]}"
+                )
+            except Exception as exc:
+                return (
+                    "Hugging Face speech-to-text failed: "
+                    f"{compact_error(exc)}"
+                )
         except Exception as exc:
             return (
                 f"Could not transcribe audio for task {task_id}: "
@@ -1086,42 +1093,36 @@ class BasicAgent:
         print("Inicializando o agente GAIA...")
 
         hf_token = os.getenv("HF_TOKEN")
-        groq_api_key = os.getenv("GROQ_API_KEY")
+        cerebras_api_key = os.getenv("CEREBRAS_API_KEY")
         configured_model = os.getenv("GAIA_MODEL_ID")
 
         model_id = configured_model or DEFAULT_MAIN_MODEL
-        if not model_id.lower().startswith("groq/qwen/"):
+        if not model_id.lower().startswith("cerebras/"):
             print(
-                "GAIA_MODEL_ID não apontava para um modelo Qwen no Groq "
+                "GAIA_MODEL_ID não apontava para um modelo Cerebras "
                 "e foi ignorado. "
                 f"Usando {DEFAULT_MAIN_MODEL}."
             )
             model_id = DEFAULT_MAIN_MODEL
-        if not groq_api_key:
+        if not cerebras_api_key:
             raise RuntimeError(
-                "O secret GROQ_API_KEY não está configurado. "
+                "O secret CEREBRAS_API_KEY não está configurado. "
                 "Adicione a chave em Settings > Variables and secrets > Secrets."
             )
 
         self.model = LiteLLMModel(
             model_id=model_id,
-            api_key=groq_api_key,
+            api_key=cerebras_api_key,
             temperature=0,
-            max_tokens=1_200,
-            requests_per_minute=2,
+            max_tokens=1_000,
+            requests_per_minute=8,
+            parallel_tool_calls=False,
         )
         self.hf_token = hf_token
         self.model_id = model_id
         print(f"Modelo principal selecionado: {model_id}")
 
-        web_search_tool = DuckDuckGoSearchTool(
-            max_results=5, rate_limit=1.0
-        )
-        web_search_tool.description = (
-            "Searches the public web and returns result titles, URLs, and short "
-            "snippets. Use it to discover candidate sources. It does NOT open "
-            "or read the full pages; call visit_webpage on a returned URL."
-        )
+        web_search_tool = ConciseWebSearchTool()
         visit_page_tool = OpenWebPageTool()
         wikipedia_tool = WikipediaSearchTool(
             user_agent="GAIA-Course-Agent/1.0 (educational project)",
@@ -1147,12 +1148,13 @@ class BasicAgent:
             CalculatorTool(),
         ]
 
-        # Qwen returns native tool calls. ToolCallingAgent handles that
+        # GLM returns native tool calls. ToolCallingAgent handles that
         # structured format without parsing generated Python code.
         self.agent = ToolCallingAgent(
             tools=agent_tools,
             model=self.model,
-            max_steps=7,
+            max_steps=4,
+            max_tool_threads=1,
             planning_interval=None,
             description=(
                 "Agent designed to solve GAIA benchmark questions with "
@@ -1207,6 +1209,7 @@ include reasoning, explanations, labels, Markdown, citations, or the words
         question = (question or "").strip()
         if not question:
             raise ValueError("Digite uma pergunta para testar o agente.")
+        SEARCH_CACHE.clear()
 
         if task_id:
             attachment_name = get_task_file_name(task_id)
@@ -1262,7 +1265,7 @@ include reasoning, explanations, labels, Markdown, citations, or the words
                 ) from exc
             raise
         candidate = self.enforce_direct_answer(question, str(result))
-        return self.review_answer_with_groq(
+        return self.review_answer_with_gemini(
             question=question,
             candidate=candidate,
             task_id=task_id,
@@ -1390,7 +1393,39 @@ include reasoning, explanations, labels, Markdown, citations, or the words
             if identifiers:
                 return identifiers[-1].strip(" .,:;\"'")
 
-        person_question = (
+        list_question = (
+            "comma" in question_lower
+            or "list" in question_lower
+            or "separated" in question_lower
+            or "delimited" in question_lower
+        )
+        if (
+            list_question
+            and "last name" in question_lower
+            and "before" in question_lower
+            and "after" in question_lower
+        ):
+            emphasized_names = [
+                cls.deterministic_answer_cleanup(value).strip(" .,:;\"'")
+                for value in bold_values
+            ]
+            emphasized_names = [
+                value
+                for value in emphasized_names
+                if value and len(value) <= 60 and " " not in value
+            ]
+            if len(emphasized_names) >= 2:
+                return ", ".join(emphasized_names[-2:])
+
+            name_pair = re.search(
+                r"\b(?:are|were)\s+([A-Z][A-Za-z'’-]+)\s*"
+                r"(?:,|and)\s*([A-Z][A-Za-z'’-]+)",
+                text,
+            )
+            if name_pair:
+                return f"{name_pair.group(1)}, {name_pair.group(2)}"
+
+        person_question = not list_question and (
             question_lower.startswith("who ")
             or " who " in f" {question_lower} "
             or "first name" in question_lower
@@ -1478,103 +1513,99 @@ include reasoning, explanations, labels, Markdown, citations, or the words
 
         return self.deterministic_answer_cleanup(cleaned)
 
-    def review_answer_with_groq(
+    def review_answer_with_gemini(
         self, question: str, candidate: str, task_id: str | None = None
     ) -> str:
-        """Solicita uma segunda opinião gratuita no Groq, com fallback local."""
-        groq_api_key = os.getenv("GROQ_API_KEY")
-        if not groq_api_key:
+        """Revisa com Gemini e sempre preserva a resposta primária se falhar."""
+        gemini_api_key = os.getenv("GEMINI_API_KEY")
+        if not gemini_api_key:
             fallback = self.enforce_direct_answer(question, candidate)
-            print("Groq review status: SKIPPED — GROQ_API_KEY is missing")
+            print("Gemini review status: SKIPPED — GEMINI_API_KEY is missing")
             print(f"Primary answer preserved: {fallback}")
             return fallback
 
         reviewer_model = os.getenv(
-            "GAIA_GROQ_REVIEW_MODEL", DEFAULT_GROQ_REVIEW_MODEL
+            "GAIA_GEMINI_REVIEW_MODEL", DEFAULT_GEMINI_REVIEW_MODEL
         )
-        if not reviewer_model.lower().startswith("groq/qwen/"):
-            reviewer_model = DEFAULT_GROQ_REVIEW_MODEL
+        if not reviewer_model.lower().startswith("gemini-"):
+            reviewer_model = DEFAULT_GEMINI_REVIEW_MODEL
         review_prompt = f"""
-Review this GAIA exact-match candidate. Preserve it unless clearly wrong.
-Return only the requested value: no explanation, label, Markdown, or citation.
-Respect requested number, currency, name, list separator/order, quote, or chess
-notation format.
+Review this GAIA exact-match candidate. Preserve it unless a correction is
+clearly necessary. The final_answer must contain only the requested value,
+without explanation, label, Markdown, or citation. Respect requested numeric,
+currency, name, list separator/order, quote, or chess notation formats.
+Task ID: {task_id or "test"}
 Question: {question}
 Candidate: {candidate}
-Return:
-<final_answer>exact value to submit</final_answer>
 """.strip()
 
-        last_error = None
-        for attempt in range(1):
-            try:
-                retry_instruction = (
-                    ""
-                    if attempt == 0
-                    else "\nIMPORTANT: Return both XML fields exactly as specified."
-                )
-                response = completion(
-                    model=reviewer_model,
-                    api_key=groq_api_key,
-                    messages=[
+        try:
+            response = requests.post(
+                (
+                    "https://generativelanguage.googleapis.com/v1beta/models/"
+                    f"{reviewer_model}:generateContent"
+                ),
+                headers={
+                    "x-goog-api-key": gemini_api_key,
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "contents": [
                         {
                             "role": "user",
-                            "content": review_prompt + retry_instruction,
+                            "parts": [{"text": review_prompt}],
                         }
                     ],
-                    temperature=0,
-                    max_tokens=120,
-                    reasoning_effort="none",
-                )
-                content = str(response.choices[0].message.content).strip()
-                content = re.sub(
-                    r"^```(?:xml|text)?\s*|\s*```$", "", content, flags=re.I
-                )
-                answer_match = re.search(
-                    r"<final_answer>\s*(.*?)\s*</final_answer>",
-                    content,
-                    flags=re.I | re.S,
-                )
-                note_match = re.search(
-                    r"<review_note>\s*(.*?)\s*</review_note>",
-                    content,
-                    flags=re.I | re.S,
-                )
-                if not answer_match:
-                    raise ValueError(
-                        "Groq did not return the <final_answer> field."
-                    )
-                final_answer = self.enforce_direct_answer(
-                    question, answer_match.group(1)
-                )
-                if not final_answer:
-                    raise ValueError("Groq returned an empty final_answer.")
-
-                changed = final_answer != candidate
-                note = (
-                    note_match.group(1).strip()
-                    if note_match
-                    else "Review completed without a note."
-                )
-                print(f"Candidate answer: {candidate}")
-                print(f"Groq reviewed answer: {final_answer}")
-                print(f"Groq changed answer: {changed}")
-                print(f"Groq review note: {note}")
-                return final_answer
-            except Exception as exc:
-                last_error = exc
-
-        fallback = self.enforce_direct_answer(question, candidate)
-        if not fallback:
-            raise RuntimeError(
-                "A revisão do Groq falhou e a resposta primária estava vazia. "
-                f"Detalhe: {last_error}"
+                    "generationConfig": {
+                        "temperature": 0,
+                        "maxOutputTokens": 120,
+                        "responseMimeType": "application/json",
+                        "responseJsonSchema": {
+                            "type": "object",
+                            "properties": {
+                                "final_answer": {"type": "string"},
+                                "review_note": {"type": "string"},
+                            },
+                            "required": ["final_answer", "review_note"],
+                            "additionalProperties": False,
+                        },
+                    },
+                },
+                timeout=(WEBPAGE_CONNECT_TIMEOUT, 45),
             )
-
-        print(f"Candidate answer: {fallback}")
-        print("Groq review status: FAILED — primary answer preserved")
-        print(f"Groq review error: {last_error}")
-        return fallback
+            response.raise_for_status()
+            payload = response.json()
+            parts = payload["candidates"][0]["content"]["parts"]
+            content = "".join(
+                str(part.get("text") or "") for part in parts
+            ).strip()
+            review_data = json.loads(content)
+            final_answer = self.enforce_direct_answer(
+                question, str(review_data.get("final_answer") or "")
+            )
+            if not final_answer:
+                raise ValueError("Gemini returned an empty final_answer.")
+
+            note = str(review_data.get("review_note") or "").strip()
+            print(f"Candidate answer: {candidate}")
+            print(f"Gemini reviewed answer: {final_answer}")
+            print(f"Gemini changed answer: {final_answer != candidate}")
+            print(f"Gemini review note: {note}")
+            return final_answer
+        except Exception as exc:
+            fallback = self.enforce_direct_answer(question, candidate)
+            if not fallback:
+                raise RuntimeError(
+                    "Gemini review failed and the primary answer was empty. "
+                    f"Detail: {compact_error(exc)}"
+                ) from exc
+            detail = compact_error(exc)
+            if "response" in locals() and response is not None:
+                detail += f" Response: {response.text[:500]}"
+            print(f"Candidate answer: {fallback}")
+            print("Gemini review status: FAILED — primary answer preserved")
+            print(f"Gemini review error: {detail}")
+            return fallback
 
 
 def empty_results() -> pd.DataFrame: