Update app.py

app.py

@@ -1,6 +1,9 @@
 import os
 import re
 import base64
+import ast
+import math
+import operator
 from io import BytesIO
 from pathlib import Path
 from zipfile import ZipFile
@@ -21,13 +24,93 @@ from smolagents import (
 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
+MAX_EXTRACTED_CHARS = 8_000
 WEBPAGE_CONNECT_TIMEOUT = 8
 WEBPAGE_READ_TIMEOUT = 20
-MAX_WEBPAGE_CHARS = 8_000
+MAX_WEBPAGE_CHARS = 6_000
 DEFAULT_MAIN_MODEL = "groq/qwen/qwen3.6-27b"
 DEFAULT_GROQ_REVIEW_MODEL = "groq/qwen/qwen3.6-27b"
 TASK_FILE_CACHE = {}
+ATTACHMENT_CACHE = {}
+WEBPAGE_CACHE = {}
+
+
+def compact_error(exc: Exception) -> str:
+    message = str(exc).strip()
+    return message or repr(exc)
+
+
+def focus_text(text: str, query: str, max_chars: int = 5_000) -> str:
+    """Selects high-signal passages locally, before text reaches the LLM."""
+    text = re.sub(r"\r\n?", "\n", str(text or ""))
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n{3,}", "\n\n", text).strip()
+    if not text or len(text) <= max_chars:
+        return text
+
+    stopwords = {
+        "about", "after", "again", "also", "article", "attached", "before",
+        "could", "find", "from", "have", "into", "just", "mentions", "please",
+        "provide", "question", "should", "that", "their", "there", "these",
+        "this", "under", "what", "when", "where", "which", "with", "work",
+        "would", "your",
+    }
+    terms = {
+        token.lower()
+        for token in re.findall(r"[A-Za-z0-9][A-Za-z0-9._-]{2,}", query or "")
+        if token.lower() not in stopwords
+    }
+    blocks = [
+        block.strip()
+        for block in re.split(r"\n\s*\n", text)
+        if block.strip()
+    ]
+    if not blocks:
+        return text[:max_chars]
+
+    scored = []
+    for index, block in enumerate(blocks):
+        lowered = block.lower()
+        hits = sum(lowered.count(term) for term in terms)
+        exact_bonus = 4 if query and query.lower() in lowered else 0
+        signal_bonus = 2 if re.search(
+            r"\b(acknowledg|award|grant|answer|result|total|page|pages)\b",
+            lowered,
+        ) else 0
+        scored.append((hits * 3 + exact_bonus + signal_bonus, index))
+
+    best_indices = [
+        index
+        for score, index in sorted(scored, reverse=True)
+        if score > 0
+    ][:10]
+    if not best_indices:
+        return (
+            text[: max_chars * 2 // 3]
+            + "\n\n[content omitted]\n\n"
+            + text[-max_chars // 3 :]
+        )
+
+    selected = {}
+    used = 0
+    for best_index in best_indices:
+        # Reserve space for the matching block before optional neighbors.
+        for index in (best_index, best_index - 1, best_index + 1):
+            if (
+                index in selected
+                or not 0 <= index < len(blocks)
+                or used >= max_chars
+            ):
+                continue
+            block = blocks[index]
+            if index != best_index and len(block) > 1_000:
+                block = block[:1_000]
+            remaining = max_chars - used
+            if remaining < 100:
+                break
+            selected[index] = block[:remaining]
+            used += len(selected[index]) + 2
+    return "\n\n".join(selected[index] for index in sorted(selected)).strip()
 
 
 def clean_filename(value: str) -> str:
@@ -70,10 +153,15 @@ def filename_from_response(response: requests.Response, task_id: str) -> str:
 def download_gaia_attachment(task_id: str) -> tuple[bytes, str]:
     """Baixa um anexo pela API do curso, com fallback para o dataset oficial."""
     task_id = str(task_id).strip()
+    if task_id in ATTACHMENT_CACHE:
+        return ATTACHMENT_CACHE[task_id]
+
     course_url = f"{DEFAULT_API_URL}/files/{task_id}"
     response = requests.get(course_url, timeout=HTTP_TIMEOUT)
     if response.ok:
-        return response.content, filename_from_response(response, task_id)
+        result = (response.content, filename_from_response(response, task_id))
+        ATTACHMENT_CACHE[task_id] = result
+        return result
     if response.status_code != 404:
         response.raise_for_status()
 
@@ -114,7 +202,9 @@ def download_gaia_attachment(task_id: str) -> tuple[bytes, str]:
                 filename=dataset_path,
                 token=token,
             )
-            return Path(local_path).read_bytes(), filename
+            result = (Path(local_path).read_bytes(), filename)
+            ATTACHMENT_CACHE[task_id] = result
+            return result
         except Exception as exc:
             errors.append(str(exc))
 
@@ -151,7 +241,9 @@ def get_task_file_name(task_id: str) -> str:
     return TASK_FILE_CACHE.get(task_id, "")
 
 
-def extract_attachment_text(data: bytes, filename: str) -> str:
+def extract_attachment_text(
+    data: bytes, filename: str, query: str = ""
+) -> str:
     """Extrai conteúdo legível dos formatos mais comuns do GAIA."""
     suffix = Path(filename).suffix.lower()
 
@@ -205,20 +297,10 @@ def extract_attachment_text(data: bytes, filename: str) -> str:
 
             text = BeautifulSoup(text, "html.parser").get_text("\n")
     elif suffix in {".mp3", ".wav", ".flac", ".m4a", ".ogg"}:
-        from huggingface_hub import InferenceClient
-
-        token = os.getenv("HF_TOKEN")
-        if not token:
-            text = "Audio transcription failed: HF_TOKEN is not configured."
-        else:
-            client = InferenceClient(api_key=token, provider="auto")
-            asr_model = os.getenv(
-                "GAIA_ASR_MODEL", "distil-whisper/distil-large-v3"
-            )
-            transcript = client.automatic_speech_recognition(
-                data, model=asr_model
-            )
-            text = f"Audio transcript:\n{transcript.text}"
+        text = (
+            "Audio attachment detected. Use transcribe_gaia_audio with the "
+            "task_id instead of inspect_gaia_attachment."
+        )
     elif suffix == ".zip":
         with ZipFile(BytesIO(data)) as archive:
             text = "Files inside ZIP:\n" + "\n".join(archive.namelist())
@@ -241,8 +323,16 @@ def extract_attachment_text(data: bytes, filename: str) -> str:
     text = text.strip()
     if not text:
         return f"The attachment {filename} was downloaded but contained no extractable text."
-    if len(text) > MAX_EXTRACTED_CHARS:
-        text = text[:MAX_EXTRACTED_CHARS] + "\n[content truncated]"
+    tabular = suffix in {".xlsx", ".xlsm", ".csv", ".tsv"}
+    if query and not tabular:
+        text = focus_text(text, query, MAX_EXTRACTED_CHARS)
+    elif len(text) > MAX_EXTRACTED_CHARS:
+        head_size = MAX_EXTRACTED_CHARS * 2 // 3
+        text = (
+            text[:head_size]
+            + "\n\n[attachment middle omitted]\n\n"
+            + text[-(MAX_EXTRACTED_CHARS - head_size) :]
+        )
     return text
 
 
@@ -259,16 +349,26 @@ class OpenWebPageTool(Tool):
         "url": {
             "type": "string",
             "description": "The complete HTTP or HTTPS URL to open.",
-        }
+        },
+        "query": {
+            "type": "string",
+            "description": (
+                "Short terms describing the exact fact to find on the page. "
+                "Do not repeat the full task."
+            ),
+        },
     }
     output_type = "string"
 
-    def forward(self, url: str) -> str:
+    def forward(self, url: str, query: str) -> str:
         from markdownify import markdownify
 
         url = str(url or "").strip()
+        query = str(query or "").strip()
         if not re.match(r"^https?://", url, flags=re.I):
             return "Invalid URL: visit_webpage requires a full HTTP/HTTPS URL."
+        if url in WEBPAGE_CACHE:
+            return focus_text(WEBPAGE_CACHE[url], query, MAX_WEBPAGE_CHARS)
 
         headers = {
             "User-Agent": (
@@ -358,47 +458,488 @@ class OpenWebPageTool(Tool):
                             + "\n".join(source_links[-25:])
                         )
                 text = re.sub(r"\n{3,}", "\n\n", text).strip()
-                if len(text) > MAX_WEBPAGE_CHARS:
-                    head_size = 5_000
-                    tail_size = MAX_WEBPAGE_CHARS - head_size
-                    text = (
-                        text[:head_size]
-                        + "\n\n[page middle omitted to conserve tokens]\n\n"
-                        + text[-tail_size:]
-                    )
-                return text or "The page was retrieved but contained no text."
+                if text:
+                    WEBPAGE_CACHE[url] = text[:50_000]
+                    return focus_text(text, query, MAX_WEBPAGE_CHARS)
+                return "The page was retrieved but contained no text."
             except Exception as exc:
-                errors.append(f"{target}: {exc}")
+                errors.append(f"{target}: {compact_error(exc)}")
 
         return "Error fetching the webpage: " + " | ".join(errors)
 
 
+class ReadDocumentUrlTool(Tool):
+    name = "read_document_url"
+    description = (
+        "Downloads and reads a PDF, DOCX, CSV, or text document from an exact "
+        "public URL, then returns only passages relevant to the supplied query. "
+        "Use it for linked papers and reports; use visit_webpage for HTML."
+    )
+    inputs = {
+        "url": {
+            "type": "string",
+            "description": "Direct public URL of the document.",
+        },
+        "query": {
+            "type": "string",
+            "description": "Short terms for the exact fact to find.",
+        },
+    }
+    output_type = "string"
+
+    def forward(self, url: str, query: str) -> str:
+        url = str(url or "").strip()
+        query = str(query or "").strip()
+        if not re.match(r"^https?://", url, flags=re.I):
+            return "Invalid document URL."
+
+        try:
+            response = requests.get(
+                url,
+                headers={"User-Agent": "GAIA-Course-Agent/1.0"},
+                timeout=(WEBPAGE_CONNECT_TIMEOUT, HTTP_TIMEOUT),
+                allow_redirects=True,
+            )
+            response.raise_for_status()
+            if len(response.content) > 25 * 1024 * 1024:
+                return "Document exceeds the 25 MB safety limit."
+
+            content_type = response.headers.get("content-type", "").lower()
+            if "text/html" in content_type:
+                return (
+                    "This URL returned HTML. Use visit_webpage with the same "
+                    "URL and a short query."
+                )
+            filename = filename_from_response(response, "web_document")
+            if not Path(filename).suffix:
+                from urllib.parse import urlparse
+
+                filename = Path(urlparse(response.url).path).name or filename
+            extracted = extract_attachment_text(
+                response.content, filename, query=query
+            )
+            return f"Document: {filename}\n\n{extracted}"
+        except Exception as exc:
+            return f"Could not read document URL: {compact_error(exc)}"
+
+
+class TranscribeGaiaAudioTool(Tool):
+    name = "transcribe_gaia_audio"
+    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."
+    )
+    inputs = {
+        "task_id": {
+            "type": "string",
+            "description": "Exact GAIA task_id associated with the audio.",
+        }
+    }
+    output_type = "string"
+
+    def forward(self, task_id: str) -> str:
+        task_id = str(task_id or "").strip()
+        try:
+            data, filename = download_gaia_attachment(task_id)
+            suffix = Path(filename).suffix.lower()
+            if suffix not in {
+                ".mp3", ".wav", ".flac", ".m4a", ".ogg", ".webm", ".mp4"
+            }:
+                return (
+                    f"Attachment {filename} is not an audio file. Use "
+                    "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)}"
+                    )
+
+            return "Audio transcription failed. " + " | ".join(errors)
+        except Exception as exc:
+            return (
+                f"Could not transcribe audio for task {task_id}: "
+                f"{compact_error(exc)}"
+            )
+
+
+class CalculatorTool(Tool):
+    name = "calculator"
+    description = (
+        "Evaluates arithmetic locally without an LLM. Supports +, -, *, /, //, "
+        "**, %, parentheses, pi, e, sqrt, log, exp, sin, cos, tan, abs, and round."
+    )
+    inputs = {
+        "expression": {
+            "type": "string",
+            "description": "Arithmetic expression to evaluate.",
+        }
+    }
+    output_type = "string"
+
+    def forward(self, expression: str) -> str:
+        binary_ops = {
+            ast.Add: operator.add,
+            ast.Sub: operator.sub,
+            ast.Mult: operator.mul,
+            ast.Div: operator.truediv,
+            ast.FloorDiv: operator.floordiv,
+            ast.Mod: operator.mod,
+            ast.Pow: operator.pow,
+        }
+        unary_ops = {ast.UAdd: operator.pos, ast.USub: operator.neg}
+        functions = {
+            "abs": abs,
+            "round": round,
+            "sqrt": math.sqrt,
+            "log": math.log,
+            "exp": math.exp,
+            "sin": math.sin,
+            "cos": math.cos,
+            "tan": math.tan,
+        }
+        constants = {"pi": math.pi, "e": math.e}
+
+        def evaluate(node):
+            if isinstance(node, ast.Expression):
+                return evaluate(node.body)
+            if isinstance(node, ast.Constant) and isinstance(
+                node.value, (int, float)
+            ):
+                return node.value
+            if isinstance(node, ast.BinOp) and type(node.op) in binary_ops:
+                return binary_ops[type(node.op)](
+                    evaluate(node.left), evaluate(node.right)
+                )
+            if isinstance(node, ast.UnaryOp) and type(node.op) in unary_ops:
+                return unary_ops[type(node.op)](evaluate(node.operand))
+            if isinstance(node, ast.Name) and node.id in constants:
+                return constants[node.id]
+            if (
+                isinstance(node, ast.Call)
+                and isinstance(node.func, ast.Name)
+                and node.func.id in functions
+                and not node.keywords
+            ):
+                return functions[node.func.id](
+                    *(evaluate(argument) for argument in node.args)
+                )
+            raise ValueError("Unsupported expression.")
+
+        try:
+            parsed = ast.parse(str(expression), mode="eval")
+            result = evaluate(parsed)
+            return str(result)
+        except Exception as exc:
+            return f"Calculation failed: {compact_error(exc)}"
+
+
+class QueryGaiaSpreadsheetTool(Tool):
+    name = "query_gaia_spreadsheet"
+    description = (
+        "Analyzes an attached XLSX, XLSM, CSV, or TSV locally. Use operation "
+        "'describe' first, then sum, mean, min, max, count, unique, or rows. "
+        "This avoids sending the entire spreadsheet to the language model."
+    )
+    inputs = {
+        "task_id": {
+            "type": "string",
+            "description": "Exact GAIA task_id for the spreadsheet.",
+        },
+        "operation": {
+            "type": "string",
+            "description": "describe, sum, mean, min, max, count, unique, or rows.",
+        },
+        "sheet": {
+            "type": "string",
+            "description": "Sheet name, or an empty string for the first sheet.",
+        },
+        "column": {
+            "type": "string",
+            "description": "Target column, or empty for describe/count rows.",
+        },
+        "filters": {
+            "type": "string",
+            "description": (
+                "Optional exact filters as column=value;column=value. "
+                "Use an empty string for no filter."
+            ),
+        },
+    }
+    output_type = "string"
+
+    def forward(
+        self,
+        task_id: str,
+        operation: str,
+        sheet: str,
+        column: str,
+        filters: str,
+    ) -> str:
+        try:
+            data, filename = download_gaia_attachment(str(task_id).strip())
+            suffix = Path(filename).suffix.lower()
+            if suffix in {".xlsx", ".xlsm"}:
+                tables = pd.read_excel(BytesIO(data), sheet_name=None)
+            elif suffix in {".csv", ".tsv"}:
+                separator = "\t" if suffix == ".tsv" else ","
+                tables = {
+                    "data": pd.read_csv(
+                        BytesIO(data),
+                        sep=separator,
+                        encoding_errors="replace",
+                    )
+                }
+            else:
+                return f"Attachment {filename} is not a supported spreadsheet."
+
+            requested_sheet = str(sheet or "").strip()
+            sheet_name = next(iter(tables))
+            if requested_sheet:
+                matching_sheet = next(
+                    (
+                        name
+                        for name in tables
+                        if str(name).lower() == requested_sheet.lower()
+                    ),
+                    None,
+                )
+                if matching_sheet is None:
+                    return (
+                        f"Unknown sheet {requested_sheet}. Available: "
+                        + ", ".join(map(str, tables))
+                    )
+                sheet_name = matching_sheet
+
+            frame = tables[sheet_name].copy()
+            frame.columns = [str(value).strip() for value in frame.columns]
+            requested_column = str(column or "").strip()
+
+            for filter_expression in str(filters or "").split(";"):
+                filter_expression = filter_expression.strip()
+                if not filter_expression:
+                    continue
+                if "=" not in filter_expression:
+                    return f"Invalid filter: {filter_expression}"
+                filter_column, filter_value = (
+                    part.strip() for part in filter_expression.split("=", 1)
+                )
+                actual_filter_column = next(
+                    (
+                        name
+                        for name in frame.columns
+                        if name.lower() == filter_column.lower()
+                    ),
+                    None,
+                )
+                if actual_filter_column is None:
+                    return (
+                        f"Unknown filter column {filter_column}. Columns: "
+                        + ", ".join(frame.columns)
+                    )
+                numeric_value = pd.to_numeric(
+                    pd.Series([filter_value]), errors="coerce"
+                ).iloc[0]
+                numeric_column = pd.to_numeric(
+                    frame[actual_filter_column], errors="coerce"
+                )
+                if pd.notna(numeric_value) and numeric_column.notna().any():
+                    frame = frame[numeric_column == numeric_value]
+                else:
+                    frame = frame[
+                        frame[actual_filter_column]
+                        .astype(str)
+                        .str.strip()
+                        .str.casefold()
+                        == filter_value.casefold()
+                    ]
+
+            operation = str(operation or "describe").strip().lower()
+            if operation == "describe":
+                preview = frame.head(5).to_csv(index=False)
+                return (
+                    f"Workbook: {filename}\n"
+                    f"Sheets: {', '.join(map(str, tables))}\n"
+                    f"Selected sheet: {sheet_name}\n"
+                    f"Rows: {len(frame)}; Columns: {len(frame.columns)}\n"
+                    f"Column names: {', '.join(frame.columns)}\n"
+                    f"First rows:\n{preview[:2_500]}"
+                )
+
+            if requested_column:
+                actual_column = next(
+                    (
+                        name
+                        for name in frame.columns
+                        if name.lower() == requested_column.lower()
+                    ),
+                    None,
+                )
+                if actual_column is None:
+                    return (
+                        f"Unknown target column {requested_column}. Columns: "
+                        + ", ".join(frame.columns)
+                    )
+            else:
+                actual_column = ""
+
+            if operation == "count":
+                result = (
+                    int(frame[actual_column].notna().sum())
+                    if actual_column
+                    else len(frame)
+                )
+            elif operation in {"sum", "mean", "min", "max"}:
+                if not actual_column:
+                    return f"Operation {operation} requires a target column."
+                series = pd.to_numeric(frame[actual_column], errors="coerce").dropna()
+                if series.empty:
+                    return f"Column {actual_column} has no numeric values."
+                result = getattr(series, operation)()
+            elif operation == "unique":
+                if not actual_column:
+                    return "Operation unique requires a target column."
+                values = frame[actual_column].dropna().astype(str).unique().tolist()
+                return ", ".join(values[:100])
+            elif operation == "rows":
+                columns = [actual_column] if actual_column else list(frame.columns)
+                return frame[columns].head(30).to_csv(index=False)[:4_000]
+            else:
+                return (
+                    "Unknown operation. Use describe, sum, mean, min, max, "
+                    "count, unique, or rows."
+                )
+
+            if hasattr(result, "item"):
+                result = result.item()
+            return (
+                f"Operation: {operation}; sheet: {sheet_name}; "
+                f"rows matched: {len(frame)}; result: {result}"
+            )
+        except Exception as exc:
+            return f"Spreadsheet analysis failed: {compact_error(exc)}"
+
+
 class InspectGaiaAttachmentTool(Tool):
     name = "inspect_gaia_attachment"
     description = (
         "Downloads and reads the official attachment associated with a GAIA "
-        "task. Use it when the question mentions an attached file, document, "
-        "spreadsheet, table, PDF, image, or other supplied material."
+        "task. Use it for PDF, DOCX, text, code, or ZIP files. Do not use it "
+        "for audio, images, or spreadsheets; those have specialized tools."
     )
     inputs = {
         "task_id": {
             "type": "string",
             "description": "The exact GAIA task_id supplied in the user task.",
-        }
+        },
+        "query": {
+            "type": "string",
+            "description": "Short terms for the exact fact to extract.",
+        },
     }
     output_type = "string"
 
-    def forward(self, task_id: str) -> str:
+    def forward(self, task_id: str, query: str) -> str:
         task_id = str(task_id).strip()
         if not task_id:
             return "No task_id was supplied."
 
         try:
             data, filename = download_gaia_attachment(task_id)
-            extracted = extract_attachment_text(data, filename)
+            suffix = Path(filename).suffix.lower()
+            if suffix in {
+                ".mp3", ".wav", ".flac", ".m4a", ".ogg", ".webm", ".mp4"
+            }:
+                return (
+                    f"Attachment {filename} is audio. Call "
+                    "transcribe_gaia_audio with this task_id."
+                )
+            if suffix in {".png", ".jpg", ".jpeg", ".webp", ".gif"}:
+                return (
+                    f"Attachment {filename} is an image. Call "
+                    "analyze_gaia_image with this task_id and question."
+                )
+            if suffix in {".xlsx", ".xlsm", ".csv", ".tsv"}:
+                return (
+                    f"Attachment {filename} is tabular. Call "
+                    "query_gaia_spreadsheet with operation='describe' first."
+                )
+            extracted = extract_attachment_text(
+                data, filename, query=str(query or "")
+            )
             return f"Attachment filename: {filename}\n\n{extracted}"
         except Exception as exc:
-            return f"Could not inspect attachment for task {task_id}: {exc}"
+            return (
+                f"Could not inspect attachment for task {task_id}: "
+                f"{compact_error(exc)}"
+            )
 
 
 class YouTubeTranscriptTool(Tool):
@@ -412,11 +953,15 @@ class YouTubeTranscriptTool(Tool):
         "url": {
             "type": "string",
             "description": "Full YouTube URL or the 11-character video ID.",
-        }
+        },
+        "query": {
+            "type": "string",
+            "description": "Short terms describing the spoken fact or quote.",
+        },
     }
     output_type = "string"
 
-    def forward(self, url: str) -> str:
+    def forward(self, url: str, query: str) -> str:
         from youtube_transcript_api import YouTubeTranscriptApi
 
         value = str(url or "").strip()
@@ -438,9 +983,16 @@ class YouTubeTranscriptTool(Tool):
                 if text:
                     lines.append(str(text))
             result = " ".join(lines).strip()
-            return result or "The video has no available transcript."
+            return (
+                focus_text(result, str(query or ""), 5_000)
+                if result
+                else "The video has no available transcript."
+            )
         except Exception as exc:
-            return f"Could not retrieve YouTube transcript: {exc}"
+            return (
+                "Could not retrieve YouTube transcript: "
+                f"{compact_error(exc)}"
+            )
 
 
 class AnalyzeGaiaImageTool(Tool):
@@ -499,8 +1051,9 @@ class AnalyzeGaiaImageTool(Tool):
                                     "type": "text",
                                     "text": (
                                         "Analyze the supplied image carefully and "
-                                        "answer this task. Explain visual evidence "
-                                        "briefly so another agent can verify it:\n"
+                                        "answer this task. Return the likely exact "
+                                        "answer plus at most one short evidence "
+                                        "sentence:\n"
                                         f"{question}"
                                     ),
                                 },
@@ -514,7 +1067,7 @@ class AnalyzeGaiaImageTool(Tool):
                         }
                     ],
                     "temperature": 0,
-                    "max_tokens": 600,
+                    "max_tokens": 300,
                 },
                 timeout=HTTP_TIMEOUT,
             )
@@ -522,7 +1075,10 @@ class AnalyzeGaiaImageTool(Tool):
             payload = response.json()
             return str(payload["choices"][0]["message"]["content"]).strip()
         except Exception as exc:
-            return f"Could not analyze the GAIA image: {exc}"
+            return (
+                "Could not analyze the GAIA image: "
+                f"{compact_error(exc)}"
+            )
 
 
 class BasicAgent:
@@ -559,7 +1115,7 @@ class BasicAgent:
         print(f"Modelo principal selecionado: {model_id}")
 
         web_search_tool = DuckDuckGoSearchTool(
-            max_results=8, rate_limit=1.0
+            max_results=5, rate_limit=1.0
         )
         web_search_tool.description = (
             "Searches the public web and returns result titles, URLs, and short "
@@ -581,10 +1137,14 @@ class BasicAgent:
         agent_tools = [
             web_search_tool,
             visit_page_tool,
+            ReadDocumentUrlTool(),
             wikipedia_tool,
             InspectGaiaAttachmentTool(),
+            QueryGaiaSpreadsheetTool(),
+            TranscribeGaiaAudioTool(),
             YouTubeTranscriptTool(),
             AnalyzeGaiaImageTool(),
+            CalculatorTool(),
         ]
 
         # Qwen returns native tool calls. ToolCallingAgent handles that
@@ -592,7 +1152,7 @@ class BasicAgent:
         self.agent = ToolCallingAgent(
             tools=agent_tools,
             model=self.model,
-            max_steps=10,
+            max_steps=7,
             planning_interval=None,
             description=(
                 "Agent designed to solve GAIA benchmark questions with "
@@ -605,22 +1165,25 @@ You are an expert AI assistant solving tasks from the GAIA benchmark.
 
 TOOL ROUTING POLICY:
 1. web_search discovers URLs and snippets. It does not read full pages.
-2. visit_webpage opens and reads one exact URL. Use it after web_search to
-   verify articles, tables, archives, papers, and linked primary sources.
-3. wikipedia_search searches English Wikipedia. Use it when Wikipedia is
-   explicitly mentioned or for encyclopedic facts. For revision-specific,
-   nomination, archive, or table details, verify the exact page.
-4. inspect_gaia_attachment reads the official file for the supplied task_id.
-   Call it first for attached PDFs, spreadsheets, documents, audio, or code.
-5. analyze_gaia_image reads image pixels. Use it for diagrams, screenshots,
-   chess positions, or questions that visually depend on an attached image.
-6. youtube_transcript retrieves spoken subtitles. Use it when asked what a
-   person said. It cannot answer purely visual video questions.
+2. visit_webpage reads focused passages from HTML; always provide short query
+   terms. read_document_url reads linked PDFs or documents by query.
+3. transcribe_gaia_audio is the only tool for attached audio. Call it first
+   for MP3, WAV, FLAC, M4A, OGG, WEBM, or MP4.
+4. inspect_gaia_attachment handles attached PDF, DOCX, text, code, or ZIP.
+   Pass short target terms. For XLSX/CSV use
+   query_gaia_spreadsheet instead: describe columns, then run one calculation.
+   Never send a whole table to the model.
+5. analyze_gaia_image handles attached images. youtube_transcript handles
+   spoken YouTube content. calculator evaluates arithmetic locally.
+6. wikipedia_search is for Wikipedia or encyclopedic facts. Verify historical,
+   nomination, revision, or archive details with an exact webpage.
 
 Research carefully, prefer primary or official sources, and cross-check
 uncertain facts. A search snippet alone is insufficient when the source page
 can be opened. Never invent a tool, use subprocess, or use shell commands.
-Do not repeat nearly identical searches; change the source or method.
+Do not repeat nearly identical searches. Stop as soon as primary evidence
+answers the exact question. Never pass an entire task as a webpage query; use
+only names, identifiers, and the target fact.
 
 FINAL RESPONSE POLICY:
 Call the final_answer tool with only the requested value. Never write the
@@ -647,15 +1210,36 @@ include reasoning, explanations, labels, Markdown, citations, or the words
 
         if task_id:
             attachment_name = get_task_file_name(task_id)
-            attachment_context = (
-                f"Official attachment: {attachment_name}. "
-                "Use the appropriate attachment tool."
-                if attachment_name
-                else (
-                    "Official attachment: NONE. Do not call "
-                    "inspect_gaia_attachment or analyze_gaia_image."
+            attachment_suffix = Path(attachment_name).suffix.lower()
+            if attachment_suffix in {
+                ".mp3", ".wav", ".flac", ".m4a", ".ogg", ".webm", ".mp4"
+            }:
+                attachment_context = (
+                    f"Official attachment: {attachment_name}. Call "
+                    "transcribe_gaia_audio first."
+                )
+            elif attachment_suffix in {
+                ".png", ".jpg", ".jpeg", ".webp", ".gif"
+            }:
+                attachment_context = (
+                    f"Official attachment: {attachment_name}. Call "
+                    "analyze_gaia_image with this task_id and question."
+                )
+            elif attachment_suffix in {".xlsx", ".xlsm", ".csv", ".tsv"}:
+                attachment_context = (
+                    f"Official attachment: {attachment_name}. Call "
+                    "query_gaia_spreadsheet with operation='describe' first."
+                )
+            elif attachment_name:
+                attachment_context = (
+                    f"Official attachment: {attachment_name}. Call "
+                    "inspect_gaia_attachment with this task_id and short target terms."
+                )
+            else:
+                attachment_context = (
+                    "Official attachment: NONE. Do not call any GAIA "
+                    "attachment tool."
                 )
-            )
             task_context = (
                 f"GAIA task_id: {task_id}\n"
                 f"{attachment_context}\n\nQuestion: {question}"
@@ -755,6 +1339,18 @@ include reasoning, explanations, labels, Markdown, citations, or the words
 
         text = cls.deterministic_answer_cleanup(text)
 
+        if "page numbers" in question_lower or "page number" in question_lower:
+            page_groups = re.findall(
+                r"\b(?:pages?|pp\.?)\s*(?:are|is|:|-)?\s*"
+                r"(\d+(?:(?:\s*,\s*(?:and\s+)?|\s+and\s+|-)\d+)*)",
+                text,
+                flags=re.I,
+            )
+            if page_groups:
+                pages = [int(value) for value in re.findall(r"\d+", page_groups[-1])]
+                if pages:
+                    return ", ".join(str(value) for value in sorted(set(pages)))
+
         quantity_question = (
             "how many" in question_lower
             or "numeric output" in question_lower
@@ -899,41 +1495,18 @@ include reasoning, explanations, labels, Markdown, citations, or the words
         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.
-
-Task ID: {task_id or "test"}
-Question:
-{question}
-
-Candidate answer:
-{candidate}
-
-Review the candidate for both likely correctness and exact requested format.
-Preserve it unless there is a clear factual, logical, ordering, spelling, or
-formatting error. Never add explanations to final_answer.
-
-Formatting rules:
-- If asked "how many", for a count, or for a numeric output: final_answer must
-  contain only the number, unless the question explicitly requests currency,
-  units, decimals, or another representation.
-- If asked for a first name, surname, city, country, or IOC code: return only
-  that requested value.
-- If asked for a list: return only the list, with the exact requested separator,
-  ordering, capitalization, and plurality.
-- If asked for a quote: return only the requested spoken words.
-- If asked for a chess move: return only algebraic notation.
-- Never include labels, Markdown, citations, rationale, or "FINAL ANSWER" inside
-  the final_answer value.
-
-Return exactly these two XML-style fields:
+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.
+Question: {question}
+Candidate: {candidate}
+Return:
 <final_answer>exact value to submit</final_answer>
-<review_note>brief reason, maximum 20 words</review_note>
-
-Do not return JSON. Do not wrap the fields in Markdown or a code block.
 """.strip()
 
         last_error = None
-        for attempt in range(2):
+        for attempt in range(1):
             try:
                 retry_instruction = (
                     ""
@@ -950,7 +1523,8 @@ Do not return JSON. Do not wrap the fields in Markdown or a code block.
                         }
                     ],
                     temperature=0,
-                    max_tokens=350,
+                    max_tokens=120,
+                    reasoning_effort="none",
                 )
                 content = str(response.choices[0].message.content).strip()
                 content = re.sub(