Update app.py

app.py

@@ -10,10 +10,10 @@ import pandas as pd
 import requests
 from litellm import completion
 from smolagents import (
-    CodeAgent,
     DuckDuckGoSearchTool,
     LiteLLMModel,
     Tool,
+    ToolCallingAgent,
     WikipediaSearchTool,
 )
 
@@ -22,7 +22,7 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 RESULT_COLUMNS = ["Task ID", "Question", "Submitted Answer"]
 HTTP_TIMEOUT = 45
 MAX_EXTRACTED_CHARS = 35_000
-DEFAULT_HF_MODEL = "huggingface/openai/gpt-oss-120b"
+DEFAULT_MAIN_MODEL = "groq/qwen/qwen3.6-27b"
 DEFAULT_GROQ_REVIEW_MODEL = "groq/qwen/qwen3.6-27b"
 TASK_FILE_CACHE = {}
 
@@ -210,7 +210,7 @@ def extract_attachment_text(data: bytes, filename: str) -> str:
         else:
             client = InferenceClient(api_key=token, provider="auto")
             asr_model = os.getenv(
-                "GAIA_ASR_MODEL", "openai/whisper-large-v3"
+                "GAIA_ASR_MODEL", "distil-whisper/distil-large-v3"
             )
             transcript = client.automatic_speech_recognition(
                 data, model=asr_model
@@ -401,8 +401,6 @@ class AnalyzeGaiaImageTool(Tool):
     output_type = "string"
 
     def forward(self, task_id: str, question: str) -> str:
-        from openai import OpenAI
-
         token = os.getenv("HF_TOKEN")
         if not token:
             return "Image analysis failed: HF_TOKEN is not configured."
@@ -419,41 +417,48 @@ class AnalyzeGaiaImageTool(Tool):
             }.get(suffix, "image/png")
             encoded = base64.b64encode(data).decode("ascii")
 
-            client = OpenAI(
-                base_url="https://router.huggingface.co/v1",
-                api_key=token,
-            )
             vision_model = os.getenv(
                 "GAIA_VISION_MODEL",
                 "Qwen/Qwen3-VL-235B-A22B-Instruct:cheapest",
             )
-            result = client.chat.completions.create(
-                model=vision_model,
-                messages=[
-                    {
-                        "role": "user",
-                        "content": [
-                            {
-                                "type": "text",
-                                "text": (
-                                    "Analyze the supplied image carefully and "
-                                    "answer this task. Explain visual evidence "
-                                    f"briefly so another agent can verify it:\n{question}"
-                                ),
-                            },
-                            {
-                                "type": "image_url",
-                                "image_url": {
-                                    "url": f"data:{mime};base64,{encoded}"
+            response = requests.post(
+                "https://router.huggingface.co/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {token}",
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "model": vision_model,
+                    "messages": [
+                        {
+                            "role": "user",
+                            "content": [
+                                {
+                                    "type": "text",
+                                    "text": (
+                                        "Analyze the supplied image carefully and "
+                                        "answer this task. Explain visual evidence "
+                                        "briefly so another agent can verify it:\n"
+                                        f"{question}"
+                                    ),
                                 },
-                            },
-                        ],
-                    }
-                ],
-                temperature=0,
-                max_tokens=600,
+                                {
+                                    "type": "image_url",
+                                    "image_url": {
+                                        "url": f"data:{mime};base64,{encoded}"
+                                    },
+                                },
+                            ],
+                        }
+                    ],
+                    "temperature": 0,
+                    "max_tokens": 600,
+                },
+                timeout=HTTP_TIMEOUT,
             )
-            return str(result.choices[0].message.content).strip()
+            response.raise_for_status()
+            payload = response.json()
+            return str(payload["choices"][0]["message"]["content"]).strip()
         except Exception as exc:
             return f"Could not analyze the GAIA image: {exc}"
 
@@ -463,18 +468,26 @@ class BasicAgent:
         print("Inicializando o agente GAIA...")
 
         hf_token = os.getenv("HF_TOKEN")
+        groq_api_key = os.getenv("GROQ_API_KEY")
         configured_model = os.getenv("GAIA_MODEL_ID")
 
-        model_id = configured_model or DEFAULT_HF_MODEL
-        if not hf_token:
+        model_id = configured_model or DEFAULT_MAIN_MODEL
+        if not model_id.lower().startswith("groq/qwen/"):
+            print(
+                "GAIA_MODEL_ID não apontava para um modelo Qwen no Groq "
+                "e foi ignorado. "
+                f"Usando {DEFAULT_MAIN_MODEL}."
+            )
+            model_id = DEFAULT_MAIN_MODEL
+        if not groq_api_key:
             raise RuntimeError(
-                "O secret HF_TOKEN não está configurado. "
+                "O secret GROQ_API_KEY não está configurado. "
                 "Adicione a chave em Settings > Variables and secrets > Secrets."
             )
 
         self.model = LiteLLMModel(
             model_id=model_id,
-            api_key=hf_token,
+            api_key=groq_api_key,
             temperature=0,
             max_tokens=2_000,
         )
@@ -511,21 +524,13 @@ class BasicAgent:
             AnalyzeGaiaImageTool(),
         ]
 
-        self.agent = CodeAgent(
+        # Qwen 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=10,
             planning_interval=None,
-            additional_authorized_imports=[
-                "collections",
-                "datetime",
-                "itertools",
-                "math",
-                "re",
-                "statistics",
-                "unicodedata",
-            ],
-            max_print_outputs_length=20_000,
             description=(
                 "Agent designed to solve GAIA benchmark questions with "
                 "exact-match answers."
@@ -555,16 +560,8 @@ can be opened. Never invent a tool, use subprocess, or use shell commands.
 Do not repeat nearly identical searches; change the source or method.
 
 FINAL RESPONSE POLICY:
-Call final_answer with only the requested value. The final action must always
-be valid executable code inside the required code tags, for example:
-<code>
-final_answer("Claus")
-</code>
-or:
-<code>
-final_answer(5)
-</code>
-Never write the answer as plain text outside a final_answer tool call. Never
+Call the final_answer tool with only the requested value. Never write the
+answer as plain text instead of calling final_answer. Never
 include reasoning, explanations, labels, Markdown, citations, or the words
 "FINAL ANSWER" inside the submitted value.
 - Quantity/count: return only the number, unless units or currency are requested.
@@ -617,7 +614,7 @@ include reasoning, explanations, labels, Markdown, citations, or the words
                     "Inference Providers."
                 ) from exc
             raise
-        candidate = self.format_exact_answer(question, str(result))
+        candidate = self.enforce_direct_answer(question, str(result))
         return self.review_answer_with_groq(
             question=question,
             candidate=candidate,
@@ -628,8 +625,20 @@ include reasoning, explanations, labels, Markdown, citations, or the words
     def deterministic_answer_cleanup(answer: str) -> str:
         """Remove embalagens comuns sem alterar o conteúdo da resposta."""
         text = str(answer or "").strip()
+        text = re.sub(r"</?code>", "", text, flags=re.I).strip()
         text = re.sub(r"^```(?:text|markdown)?\s*", "", text, flags=re.I)
         text = re.sub(r"\s*```$", "", text)
+        text = re.sub(r"^\s*#{1,6}\s*", "", text)
+        text = re.sub(r"^\s*[-*•]\s+", "", text)
+        text = re.sub(r"\[([^\]]+)\]\([^)]+\)", r"\1", text)
+
+        final_call = re.search(
+            r"final_answer\s*\(\s*([\"']?)(.*?)\1\s*\)\s*$",
+            text,
+            flags=re.I | re.S,
+        )
+        if final_call:
+            text = final_call.group(2).strip()
 
         marker_pattern = re.compile(
             r"(?:final\s+answer|answer|resposta\s+final|resposta)\s*:\s*",
@@ -647,6 +656,7 @@ include reasoning, explanations, labels, Markdown, citations, or the words
         for pattern in prefix_patterns:
             text = re.sub(pattern, "", text, flags=re.I).strip()
 
+        text = text.replace("**", "").replace("__", "").strip()
         if (
             len(text) >= 2
             and text[0] == text[-1]
@@ -656,6 +666,119 @@ include reasoning, explanations, labels, Markdown, citations, or the words
 
         return text.replace("FINAL ANSWER", "").strip()
 
+    @classmethod
+    def enforce_direct_answer(cls, question: str, answer: str) -> str:
+        """Impõe o formato exact-match sem pedir nova interpretação a uma LLM."""
+        original_text = str(answer or "")
+        bold_values = [
+            value.strip()
+            for value in re.findall(r"\*\*(.+?)\*\*", original_text, flags=re.S)
+            if value.strip()
+        ]
+        text = cls.deterministic_answer_cleanup(answer)
+        question_lower = str(question or "").lower()
+
+        lines = [line.strip() for line in text.splitlines() if line.strip()]
+        if len(lines) > 1:
+            # Para listas, privilegia a linha que realmente contém os itens.
+            if "comma" in question_lower or "vírgula" in question_lower:
+                comma_lines = [line for line in lines if "," in line]
+                if comma_lines:
+                    text = max(comma_lines, key=lambda value: value.count(","))
+                else:
+                    text = lines[-1]
+            else:
+                text = lines[-1]
+
+        text = cls.deterministic_answer_cleanup(text)
+
+        quantity_question = (
+            "how many" in question_lower
+            or "numeric output" in question_lower
+            or "quantos" in question_lower
+            or "quantas" in question_lower
+        )
+        if quantity_question:
+            numbers = re.findall(
+                r"(?<![\w.])-?\d+(?:,\d{3})*(?:\.\d+)?", text
+            )
+            if numbers:
+                return numbers[-1].replace(",", "")
+
+        requests_usd = (
+            "in usd" in question_lower
+            or "usd with" in question_lower
+            or "dollars" in question_lower
+        )
+        if requests_usd:
+            amounts = re.findall(
+                r"\$?\s*(-?\d+(?:,\d{3})*(?:\.\d+)?)", text
+            )
+            if amounts:
+                raw_amount = amounts[-1].replace(",", "")
+                try:
+                    return f"${float(raw_amount):,.2f}"
+                except ValueError:
+                    pass
+
+        person_question = (
+            question_lower.startswith("who ")
+            or " who " in f" {question_lower} "
+            or "first name" in question_lower
+            or "surname" in question_lower
+            or "username" in question_lower
+        )
+        if person_question:
+            # Explanatory answers often repeat the requested person in the
+            # final bold fragment. Prefer it before trying sentence patterns.
+            if bold_values:
+                emphasized = cls.deterministic_answer_cleanup(bold_values[-1])
+                if (
+                    emphasized
+                    and len(emphasized) <= 100
+                    and not re.search(r"[.!?]\s+\w", emphasized)
+                ):
+                    return emphasized.strip(" .,:;\"'")
+
+            person_patterns = [
+                r"\b(?:nominated|written|directed|created|founded|authored|performed)"
+                r"\s+by\s+([A-Z][\w'’-]*(?:\s+[A-Z][\w'’-]*){0,3})",
+                r"\b(?:username|first\s+name|surname|name)\s+(?:is|was)\s+"
+                r"([A-Z][\w'’-]*(?:\s+[A-Z][\w'’-]*){0,3})",
+            ]
+            matches = []
+            for pattern in person_patterns:
+                matches.extend(re.findall(pattern, text))
+            if matches:
+                return matches[-1].strip(" .,:;\"'")
+
+        # Remove frases introdutórias que ainda possam aparecer em uma linha.
+        text = re.sub(
+            r"^(?:therefore,\s*|thus,\s*|so,\s*)?"
+            r"(?:the\s+)?(?:correct\s+|final\s+)?answer\s+is\s+",
+            "",
+            text,
+            flags=re.I,
+        ).strip()
+        text = re.sub(
+            r"^(?:the\s+requested\s+)?"
+            r"(?:first\s+name|surname|city|country|ioc\s+code)\s+is\s+",
+            "",
+            text,
+            flags=re.I,
+        ).strip()
+
+        # Se ainda restar uma explicação seguida de dois-pontos, conserva o valor.
+        if ":" in text:
+            prefix, value = text.rsplit(":", 1)
+            if len(value.strip()) <= 250 and any(
+                cue in prefix.lower()
+                for cue in ("answer", "resposta", "result", "resultado")
+            ):
+                text = value.strip()
+
+        return cls.deterministic_answer_cleanup(text)
+
     def format_exact_answer(self, question: str, raw_answer: str) -> str:
         """Limpa o resultado mecanicamente, sem pedir a outro modelo para alterá-lo."""
         del question
@@ -692,7 +815,7 @@ include reasoning, explanations, labels, Markdown, citations, or the words
         """Solicita uma segunda opinião gratuita no Groq, com fallback local."""
         groq_api_key = os.getenv("GROQ_API_KEY")
         if not groq_api_key:
-            fallback = self.deterministic_answer_cleanup(candidate)
+            fallback = self.enforce_direct_answer(question, candidate)
             print("Groq review status: SKIPPED — GROQ_API_KEY is missing")
             print(f"Primary answer preserved: {fallback}")
             return fallback
@@ -700,6 +823,8 @@ include reasoning, explanations, labels, Markdown, citations, or the words
         reviewer_model = os.getenv(
             "GAIA_GROQ_REVIEW_MODEL", DEFAULT_GROQ_REVIEW_MODEL
         )
+        if not reviewer_model.lower().startswith("groq/qwen/"):
+            reviewer_model = DEFAULT_GROQ_REVIEW_MODEL
         review_prompt = f"""
 You are the mandatory final reviewer for a GAIA exact-match answer.
 
@@ -772,8 +897,8 @@ Do not return JSON. Do not wrap the fields in Markdown or a code block.
                     raise ValueError(
                         "Groq did not return the <final_answer> field."
                     )
-                final_answer = self.deterministic_answer_cleanup(
-                    answer_match.group(1)
+                final_answer = self.enforce_direct_answer(
+                    question, answer_match.group(1)
                 )
                 if not final_answer:
                     raise ValueError("Groq returned an empty final_answer.")
@@ -792,7 +917,7 @@ Do not return JSON. Do not wrap the fields in Markdown or a code block.
             except Exception as exc:
                 last_error = exc
 
-        fallback = self.deterministic_answer_cleanup(candidate)
+        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. "