Fix prompts and utils

agent.py

@@ -1,859 +1,74 @@
-# from __future__ import annotations
-
-# from dataclasses import dataclass
-# from typing import Optional
-
-# from prompts import build_solver_prompt
-# from tools import TaskFileTool
-# from utils import extract_final_answer, normalize_final_answer
-# from llm_client import HFLLMClient
-
-
-# @dataclass
-# class AgentConfig:
-#     api_base_url: str = "https://agents-course-unit4-scoring.hf.space"
-#     max_context_chars: int = 12000
-
-
-# class SubmissionAgent:
-#     """
-#     V1 agent for the Hugging Face Agents Course Unit 4 final project.
-
-#     Goals:
-#     - Accept a benchmark question and optional task_id
-#     - Load attached task-file context when available
-#     - Return ONLY the final answer string
-#     - Stay framework-agnostic for now so we can plug in any LLM later
-#     """
-#     def __init__(self, config: Optional[AgentConfig] = None, llm_client=None):
-#         self.config = config or AgentConfig()
-#         self.llm_client = llm_client or HFLLMClient()
-#         self.task_file_tool = TaskFileTool(api_base_url=self.config.api_base_url)
-
-#     def __call__(self, question: str, task_id: Optional[str] = None) -> str:
-#         """
-#         Main entry point used by app.py.
-#         """
-#         context = self._load_context(task_id=task_id)
-#         raw_output = self._solve(question=question, context=context)
-#         final_answer = extract_final_answer(raw_output)
-#         return normalize_final_answer(final_answer)
-
-#     def _load_context(self, task_id: Optional[str]) -> str:
-#         """
-#         Try to fetch and read any task-linked file.
-#         Safe fallback: empty context.
-#         """
-#         if not task_id:
-#             return ""
-
-#         try:
-#             file_text = self.task_file_tool.get_task_context(task_id=task_id)
-#             if not file_text:
-#                 return ""
-
-#             return file_text[: self.config.max_context_chars]
-#         except Exception:
-#             return ""
-
-#     def _solve(self, question: str, context: str) -> str:
-#         """
-#         Solve the question with either:
-#         1) a plugged-in LLM client, or
-#         2) a safe fallback so the app does not crash during setup.
-
-#         The LLM client is expected to expose a .generate(prompt: str) -> str method.
-#         We will wire the real model later.  
-#         """
-#         prompt = build_solver_prompt(question=question, context=context)
-
-#         try:
-#             return self.llm_client.generate(prompt)
-#         except Exception as e:
-#             print(f"LLM generation error: {e}")
-#             return ""
-
-# #2
-# from __future__ import annotations
-
-# import re
-# from dataclasses import dataclass
-# from pathlib import Path
-# from typing import Optional
-
-# from llm_client import HFLLMClient
-# from prompts import build_solver_prompt
-# from tools import (
-#     AudioTool,
-#     LogicTool,
-#     PythonExecutionTool,
-#     SpreadsheetTool,
-#     TaskFileTool,
-#     WebPageTool,
-#     WikipediaTool,
-# )
-# from utils import (
-#     extract_final_answer,
-#     extract_urls,
-#     get_file_extension,
-#     normalize_final_answer,
-# )
-
-
-# @dataclass
-# class AgentConfig:
-#     api_base_url: str = "https://agents-course-unit4-scoring.hf.space"
-#     max_context_chars: int = 12000
-#     enable_llm: bool = False
-
-
-# class SubmissionAgent:
-#     def __init__(self, config: Optional[AgentConfig] = None, llm_client=None):
-#         self.config = config or AgentConfig()
-#         self.llm_client = llm_client or HFLLMClient()
-#         self.task_file_tool = TaskFileTool(api_base_url=self.config.api_base_url)
-#         self.wikipedia_tool = WikipediaTool()
-#         self.web_tool = WebPageTool()
-#         self.audio_tool = AudioTool()
-#         self.sheet_tool = SpreadsheetTool()
-#         self.python_tool = PythonExecutionTool()
-#         self.logic_tool = LogicTool()
-
-#     def __call__(self, question: str, task_id: Optional[str] = None) -> str:
-#         file_path = ""
-#         if task_id:
-#             path_obj = self.task_file_tool.get_task_file_path(task_id)
-#             file_path = str(path_obj) if path_obj else ""
-
-#         # 1. hard deterministic solvers first
-#         answer = self._solve_deterministic(question, file_path)
-#         if answer:
-#             return normalize_final_answer(answer)
-
-#         # 2. evidence-based fallback
-#         answer = self._solve_with_evidence(question, file_path)
-#         return normalize_final_answer(answer)
-
-#     def _solve_deterministic(self, question: str, file_path: str) -> str:
-#         q = question.lower()
-
-#         # Reversed-text puzzle
-#         if 'tfel' in question and '.rewsna eht sa' in question:
-#             return "right"
-
-#         # Non-commutative table
-#         if "provide the subset of s involved in any possible counter-examples" in q:
-#             return self.logic_tool.solve_noncommutative_subset(question)
-
-#         # Grocery / botanical vegetables
-#         if "professor of botany" in q and "vegetables from my list" in q:
-#             return self._solve_botany_grocery(question)
-
-#         # Python file execution
-#         if file_path and Path(file_path).suffix.lower() == ".py":
-#             output = self.python_tool.run_python_file(file_path)
-#             return self._extract_last_number(output)
-
-#         # Spreadsheet total sales
-#         if file_path and Path(file_path).suffix.lower() in {".xlsx", ".xls", ".csv"}:
-#             if "total sales" in q and "food" in q:
-#                 return self.sheet_tool.total_food_sales(file_path)
-
-#         # Audio tasks
-#         if file_path and Path(file_path).suffix.lower() in {".mp3", ".wav", ".m4a", ".flac", ".ogg"}:
-#             transcript = self.audio_tool.transcribe(file_path)
-#             return self._solve_from_audio_transcript(question, transcript)
-
-#         # Mercedes Sosa counting from Wikipedia evidence
-#         if "mercedes sosa" in q and "studio albums" in q:
-#             return self._solve_mercedes_sosa()
-
-#         # Malko historical filtering
-#         if "malko competition" in q and "country that no longer exists" in q:
-#             return self._solve_malko()
-
-#         return ""
-
-#     def _solve_with_evidence(self, question: str, file_path: str) -> str:
-#         evidence_parts = []
-
-#         if file_path:
-#             ext = get_file_extension(file_path)
-#             if ext in {".txt", ".md", ".csv", ".json", ".html", ".xml"}:
-#                 try:
-#                     evidence_parts.append(self.task_file_tool.read_file_as_text(Path(file_path)))
-#                 except Exception:
-#                     pass
-
-#         urls = extract_urls(question)
-#         for url in urls[:2]:
-#             try:
-#                 evidence_parts.append(self.web_tool.fetch_text(url))
-#             except Exception:
-#                 pass
-
-#         q = question.lower()
-#         if "wikipedia" in q or "featured article" in q or "malko" in q or "olympics" in q:
-#             evidence_parts.append(self._gather_wikipedia_evidence(question))
-
-#         evidence = "\n\n".join(p for p in evidence_parts if p)[: self.config.max_context_chars]
-#         if not evidence:
-#             return ""
-
-#         # deterministic extraction first
-#         cheap = self._cheap_extract(question, evidence)
-#         if cheap:
-#             return cheap
-
-#         if not self.config.enable_llm:
-#             return ""
-
-#         try:
-#             prompt = build_solver_prompt(question=question, context=evidence)
-#             raw = self.llm_client.generate(prompt)
-#             return extract_final_answer(raw)
-#         except Exception as e:
-#             print(f"LLM generation error: {e}")
-#             return ""
-
-#     def _solve_botany_grocery(self, question: str) -> str:
-#         m = re.search(r"Here's the list I have so far:\s*(.*?)\s*I need to make headings", question, re.S)
-#         if not m:
-#             return ""
-
-#         items = [x.strip() for x in m.group(1).replace("\n", " ").split(",") if x.strip()]
-
-#         # Botanical vegetables only for this grocery context
-#         vegetables = {
-#             "broccoli",
-#             "celery",
-#             "fresh basil",
-#             "lettuce",
-#             "sweet potatoes",
-#         }
-
-#         selected = sorted([item for item in items if item.lower() in vegetables], key=str.lower)
-#         return ", ".join(selected)
-
-#     def _solve_from_audio_transcript(self, question: str, transcript: str) -> str:
-#         q = question.lower()
-#         t = transcript.strip()
-#         if not t:
-#             return ""
-
-#         if "page numbers" in q:
-#             nums = sorted({int(x) for x in re.findall(r"\b\d+\b", t)})
-#             return ", ".join(str(x) for x in nums)
-
-#         if "ingredients" in q and "filling" in q:
-#             # remove measurements, keep ingredient-like phrases
-#             parts = re.split(r"[.,;\n]", t)
-#             cleaned = []
-#             for p in parts:
-#                 s = p.strip().lower()
-#                 s = re.sub(r"\b(one|two|three|four|five|six|seven|eight|nine|ten)\b", "", s)
-#                 s = re.sub(r"\b\d+(/\d+)?\b", "", s)
-#                 s = re.sub(r"\b(cup|cups|tablespoon|tablespoons|teaspoon|teaspoons|pinch|ounces|ounce)\b", "", s)
-#                 s = re.sub(r"\s+", " ", s).strip(" ,.")
-#                 if s and len(s) < 40:
-#                     cleaned.append(s)
-
-#             cleaned = sorted(set(cleaned))
-#             return ", ".join(cleaned)
-
-#         return ""
-
-#     def _solve_mercedes_sosa(self) -> str:
-#         text = self.wikipedia_tool.get_page_text("Mercedes Sosa")
-#         if not text:
-#             return ""
-
-#         # Count years 2000..2009 appearing in studio-album discography style text
-#         years = re.findall(r"\b(200[0-9])\b", text)
-#         count = sum(1 for y in years if 2000 <= int(y) <= 2009)
-#         # This page contains many non-album years, so use discography-like patterns too
-#         line_hits = re.findall(r"(200[0-9]).{0,80}", text)
-#         filtered = [y for y in line_hits if 2000 <= int(y) <= 2009]
-#         if filtered:
-#             return str(len(filtered))
-#         return str(count) if count else ""
-
-#     def _solve_malko(self) -> str:
-#         text = self.wikipedia_tool.get_page_text("Malko Competition")
-#         if not text:
-#             return ""
-
-#         # Historical record-based heuristic
-#         # Looking for Claus Peter Flor / East Germany
-#         if "Claus Peter Flor" in text and "East Germany" in text:
-#             return "Claus"
-
-#         return ""
-
-#     def _gather_wikipedia_evidence(self, question: str) -> str:
-#         guesses = []
-#         q = question.lower()
-
-#         if "mercedes sosa" in q:
-#             guesses.append("Mercedes Sosa")
-#         if "malko" in q:
-#             guesses.append("Malko Competition")
-#         if "1928 summer olympics" in q:
-#             guesses.append("1928 Summer Olympics")
-#         if "featured article" in q and "dinosaur" in q:
-#             guesses.append("Wikipedia:Featured articles")
-
-#         texts = [self.wikipedia_tool.get_page_text(title) for title in guesses]
-#         return "\n\n".join(t for t in texts if t)
-
-#     def _cheap_extract(self, question: str, evidence: str) -> str:
-#         q = question.lower()
-#         ev = evidence.strip()
-
-#         if not ev:
-#             return ""
-
-#         if "how many" in q or "highest number" in q or "at bats" in q:
-#             nums = [int(x) for x in re.findall(r"\b\d+\b", ev)]
-#             if nums:
-#                 return str(max(nums))
-
-#         if "what is the first name" in q or "give only the first name" in q:
-#             m = re.search(r"\b([A-Z][a-z]+)\s+[A-Z][a-z]+\b", ev)
-#             if m:
-#                 return m.group(1)
-
-#         if "ioc country code" in q:
-#             m = re.search(r"\b[A-Z]{3}\b", ev)
-#             if m:
-#                 return m.group(0)
-
-#         if "award number" in q:
-#             m = re.search(r"\b[A-Z0-9-]{6,}\b", ev)
-#             if m:
-#                 return m.group(0)
-
-#         return ""
-
-#     def _extract_last_number(self, text: str) -> str:
-#         nums = re.findall(r"-?\d+(?:\.\d+)?", text or "")
-#         return nums[-1] if nums else ""
-
-# #2
-
-# from __future__ import annotations
-
-# from dataclasses import dataclass
-# from pathlib import Path
-# from typing import Optional
-
-# from smolagents import CodeAgent, tool
-
-# from llm_client import build_local_model
-# from tools import (
-#     AudioTool,
-#     LogicTool,
-#     PythonExecutionTool,
-#     SpreadsheetTool,
-#     TaskFileTool,
-#     WebPageTool,
-#     WikipediaTool,
-# )
-
-
-# @dataclass
-# class AgentConfig:
-#     api_base_url: str = "https://agents-course-unit4-scoring.hf.space"
-
-
-# class SubmissionAgent:
-#     def __init__(self, config: Optional[AgentConfig] = None):
-#         self.config = config or AgentConfig()
-#         self.task_file_tool = TaskFileTool(api_base_url=self.config.api_base_url)
-#         self.wikipedia_tool = WikipediaTool()
-#         self.web_tool = WebPageTool()
-#         self.audio_tool = AudioTool()
-#         self.sheet_tool = SpreadsheetTool()
-#         self.python_tool = PythonExecutionTool()
-#         self.logic_tool = LogicTool()
-
-#         @tool
-#         def get_task_file_path(task_id: str) -> str:
-#             """Return the local path of the attached file for a GAIA task_id, or empty string."""
-#             path_obj = self.task_file_tool.get_task_file_path(task_id)
-#             return str(path_obj) if path_obj else ""
-
-#         @tool
-#         def read_text_file(file_path: str) -> str:
-#             """Read a local text/csv/json/html/xml file and return its text content."""
-#             if not file_path:
-#                 return ""
-#             return self.task_file_tool.read_file_as_text(Path(file_path))
-
-#         @tool
-#         def transcribe_audio(file_path: str) -> str:
-#             """Transcribe a local audio file such as mp3/wav/m4a/flac/ogg."""
-#             if not file_path:
-#                 return ""
-#             return self.audio_tool.transcribe(file_path)
-
-#         @tool
-#         def run_python_file(file_path: str) -> str:
-#             """Run a local Python file and return stdout."""
-#             if not file_path:
-#                 return ""
-#             return self.python_tool.run_python_file(file_path)
-
-#         @tool
-#         def total_food_sales(file_path: str) -> str:
-#             """Compute total sales from food only, excluding drinks, from a spreadsheet file."""
-#             if not file_path:
-#                 return ""
-#             return self.sheet_tool.total_food_sales(file_path)
-
-#         @tool
-#         def get_wikipedia_page(title: str) -> str:
-#             """Fetch the text of an English Wikipedia page by title."""
-#             return self.wikipedia_tool.get_page_text(title)
-
-#         @tool
-#         def fetch_web_text(url: str) -> str:
-#             """Fetch readable text from a web page URL."""
-#             return self.web_tool.fetch_text(url)
-
-#         @tool
-#         def solve_noncommutative_subset(question_text: str) -> str:
-#             """Solve the specific operation-table non-commutativity question."""
-#             return self.logic_tool.solve_noncommutative_subset(question_text)
-
-#         @tool
-#         def solve_reverse_left(question_text: str) -> str:
-#             """Solve the reversed sentence asking for the opposite of 'left'."""
-#             if 'tfel' in question_text and '.rewsna eht sa' in question_text:
-#                 return "right"
-#             return ""
-
-#         @tool
-#         def solve_botany_grocery(question_text: str) -> str:
-#             """Return only botanical vegetables from the grocery-list question."""
-#             import re
-
-#             m = re.search(r"Here's the list I have so far:\s*(.*?)\s*I need to make headings", question_text, re.S)
-#             if not m:
-#                 return ""
-
-#             items = [x.strip() for x in m.group(1).replace("\n", " ").split(",") if x.strip()]
-#             vegetables = {"broccoli", "celery", "fresh basil", "lettuce", "sweet potatoes"}
-#             selected = sorted([item for item in items if item.lower() in vegetables], key=str.lower)
-#             return ", ".join(selected)
-
-#         @tool
-#         def solve_mercedes_sosa() -> str:
-#             """Count Mercedes Sosa studio albums between 2000 and 2009 using Wikipedia text."""
-#             import re
-
-#             text = self.wikipedia_tool.get_page_text("Mercedes Sosa")
-#             if not text:
-#                 return ""
-#             # conservative fallback
-#             line_hits = re.findall(r"(200[0-9]).{0,100}", text)
-#             filtered = [y for y in line_hits if 2000 <= int(y) <= 2009]
-#             return str(len(filtered)) if filtered else ""
-
-#         @tool
-#         def solve_malko() -> str:
-#             """Return the first name for the Malko winner with nationality on record from a non-existing country."""
-#             text = self.wikipedia_tool.get_page_text("Malko Competition")
-#             if "Claus Peter Flor" in text and "East Germany" in text:
-#                 return "Claus"
-#             return ""
-
-#         self.agent = CodeAgent(
-#             model=build_local_model(),
-#             tools=[
-#                 get_task_file_path,
-#                 read_text_file,
-#                 transcribe_audio,
-#                 run_python_file,
-#                 total_food_sales,
-#                 get_wikipedia_page,
-#                 fetch_web_text,
-#                 solve_noncommutative_subset,
-#                 solve_reverse_left,
-#                 solve_botany_grocery,
-#                 solve_mercedes_sosa,
-#                 solve_malko,
-#             ],
-#             additional_authorized_imports=["re", "json", "math", "statistics", "pathlib"],
-#             max_steps=6,
-#         )
-
-#     def __call__(self, question: str, task_id: Optional[str] = None) -> str:
-#         task_id = task_id or ""
-#         prompt = f"""
-# You are solving one GAIA benchmark task.
-
-# Rules:
-# - Return only the final answer.
-# - No explanation.
-# - No "FINAL ANSWER".
-# - Use tools when needed.
-# - Prefer deterministic tools over guessing.
-# - If there is an attached file, first call get_task_file_path("{task_id}").
-
-# Question:
-# {question}
-# """
-#         result = self.agent.run(prompt)
-#         return str(result).strip()
-
 from __future__ import annotations
 
 from dataclasses import dataclass
-from pathlib import Path
 from typing import Optional
 
-from smolagents import ToolCallingAgent, tool
-
-from llm_client import build_local_model
-from tools import (
-    AudioTool,
-    LogicTool,
-    PythonExecutionTool,
-    RetrieveCSVStorageTool,
-    SpreadsheetTool,
-    TaskFileTool,
-    WebPageTool,
-    WikiTool,
-    WikipediaTool,
-    fetch_text_content,
-    read_excel,
-)
-from utils import normalize_final_answer
+from prompts import build_solver_prompt
+from tools import TaskFileTool
+from utils import extract_final_answer, normalize_final_answer
+from llm_client import HFLLMClient
 
 
 @dataclass
 class AgentConfig:
     api_base_url: str = "https://agents-course-unit4-scoring.hf.space"
-    max_steps: int = 8
+    max_context_chars: int = 12000
 
 
 class SubmissionAgent:
-    def __init__(self, config: Optional[AgentConfig] = None):
+    """
+    V1 agent for the Hugging Face Agents Course Unit 4 final project.
+
+    Goals:
+    - Accept a benchmark question and optional task_id
+    - Load attached task-file context when available
+    - Return ONLY the final answer string
+    - Stay framework-agnostic for now so we can plug in any LLM later
+    """
+    def __init__(self, config: Optional[AgentConfig] = None, llm_client=None):
         self.config = config or AgentConfig()
-
+        self.llm_client = llm_client or HFLLMClient()
         self.task_file_tool = TaskFileTool(api_base_url=self.config.api_base_url)
-        self.wikipedia_tool = WikipediaTool()
-        self.web_tool = WebPageTool()
-        self.audio_tool = AudioTool()
-        self.sheet_tool = SpreadsheetTool()
-        self.python_tool = PythonExecutionTool()
-        self.logic_tool = LogicTool()
-
-        self.wiki_storage_tool = RetrieveCSVStorageTool(
-            table_name="wiki",
-            init_storage=True,
-            storage_path="./storage",
-        )
-
-        @tool
-        def get_task_file_path(task_id: str) -> str:
-            """
-            Get the local cached path for a GAIA task attachment.
-
-            Args:
-                task_id: The GAIA task identifier.
-
-            Returns:
-                The local file path if a file exists, otherwise an empty string.
-            """
-            path_obj = self.task_file_tool.get_task_file_path(task_id)
-            return str(path_obj) if path_obj else ""
-
-        @tool
-        def inspect_file(file_path: str) -> str:
-            """
-            Inspect a local file and return basic metadata.
-
-            Args:
-                file_path: The local file path.
-
-            Returns:
-                A short description with file name, suffix, and existence status.
-            """
-            if not file_path:
-                return "No file path provided."
-            p = Path(file_path)
-            return f"name={p.name}, suffix={p.suffix.lower()}, exists={p.exists()}"
-
-        @tool
-        def read_local_text_file(file_path: str) -> str:
-            """
-            Read a local text-like file.
-
-            Args:
-                file_path: The local file path.
-
-            Returns:
-                The file contents as text, or an empty string if unavailable.
-            """
-            if not file_path:
-                return ""
-            return self.task_file_tool.read_file_as_text(Path(file_path))
-
-        @tool
-        def transcribe_local_audio(file_path: str) -> str:
-            """
-            Transcribe a local audio file into text.
-
-            Args:
-                file_path: The local audio file path.
-
-            Returns:
-                The transcription text, or an empty string if transcription fails.
-            """
-            if not file_path:
-                return ""
-            return self.audio_tool.transcribe(file_path)
-
-        @tool
-        def run_local_python(file_path: str) -> str:
-            """
-            Execute a local Python file and capture stdout.
-
-            Args:
-                file_path: The local Python file path.
-
-            Returns:
-                The stdout output of the script, or an empty string if execution fails.
-            """
-            if not file_path:
-                return ""
-            return self.python_tool.run_python_file(file_path)
-
-        @tool
-        def read_local_spreadsheet(file_path: str) -> str:
-            """
-            Read a local spreadsheet and return all sheets as CSV-like text.
-
-            Args:
-                file_path: The local spreadsheet file path.
-
-            Returns:
-                A combined text representation of spreadsheet contents.
-            """
-            if not file_path:
-                return ""
-
-            sheets = self.sheet_tool.read(file_path)
-            if not sheets:
-                return ""
-
-            parts = []
-            for sheet_name, df in sheets.items():
-                parts.append(f"Sheet: {sheet_name}")
-                try:
-                    parts.append(df.to_csv(index=False))
-                except Exception:
-                    parts.append(str(df))
-            return "\n\n".join(parts)
-
-        @tool
-        def compute_total_food_sales(file_path: str) -> str:
-            """
-            Compute total food sales excluding drinks from a spreadsheet.
-
-            Args:
-                file_path: The local spreadsheet file path.
-
-            Returns:
-                The total food sales with two decimal places.
-            """
-            if not file_path:
-                return ""
-            return self.sheet_tool.total_food_sales(file_path)
-
-        @tool
-        def get_wikipedia_page(title: str) -> str:
-            """
-            Fetch the text of an English Wikipedia page by title.
-
-            Args:
-                title: The Wikipedia page title.
-
-            Returns:
-                The page text, or an empty string if not found.
-            """
-            return self.wikipedia_tool.get_page_text(title)
-
-        @tool
-        def fetch_web_text(url: str) -> str:
-            """
-            Fetch readable text from a web page URL.
-
-            Args:
-                url: The web page URL.
-
-            Returns:
-                The readable text content, or an empty string if fetch fails.
-            """
-            try:
-                return self.web_tool.fetch_text(url)
-            except Exception:
-                return ""
-
-        @tool
-        def fetch_wiki_content(query: str, language: str | None = None) -> str:
-            """
-            Fetch Wikipedia page content and store any extracted tables.
-
-            Args:
-                query: The Wikipedia page title.
-                language: The Wikipedia language code, such as en.
-
-            Returns:
-                The Wikipedia page text plus any stored table keys.
-            """
-            language = language or "en"
-            wiki_tool = WikiTool(storage=self.wiki_storage_tool.get_storage())
-            return wiki_tool.forward(query=query, language=language)
-
-        @tool
-        def retrieve_stored_table(key: str) -> str:
-            """
-            Retrieve a stored Wikipedia table by key.
-
-            Args:
-                key: The stored table key, such as table_1.
-
-            Returns:
-                The table as CSV-like text, or an error message.
-            """
-            return self.wiki_storage_tool.forward(key)
-
-        @tool
-        def solve_noncommutative_table(question_text: str) -> str:
-            """
-            Solve an operation-table commutativity question.
-
-            Args:
-                question_text: The full question text including the table.
-
-            Returns:
-                A comma-separated list of the elements involved in counterexamples.
-            """
-            return self.logic_tool.solve_noncommutative_subset(question_text)
-
-        @tool
-        def extract_last_number(text: str) -> str:
-            """
-            Extract the last numeric value from text.
-
-            Args:
-                text: Input text.
-
-            Returns:
-                The last numeric value, or an empty string if none is found.
-            """
-            import re
-
-            nums = re.findall(r"-?\d+(?:\.\d+)?", text or "")
-            return nums[-1] if nums else ""
-
-        @tool
-        def extract_page_numbers(text: str) -> str:
-            """
-            Extract unique page numbers from text and return them in ascending order.
-
-            Args:
-                text: Input text.
-
-            Returns:
-                A comma-separated list of ascending page numbers.
-            """
-            import re
-
-            nums = sorted({int(x) for x in re.findall(r"\b\d+\b", text or "")})
-            return ", ".join(str(x) for x in nums)
-
-        @tool
-        def extract_first_name(text: str) -> str:
-            """
-            Extract a likely first name from a full name in text.
-
-            Args:
-                text: Input text.
-
-            Returns:
-                The first name, or an empty string if not found.
-            """
-            import re
-
-            m = re.search(r"\b([A-Z][a-z]+)\s+[A-Z][A-Za-z'’-]+\b", text or "")
-            return m.group(1) if m else ""
-
-        @tool
-        def extract_code_like_token(text: str) -> str:
-            """
-            Extract a likely alphanumeric code token from text.
-
-            Args:
-                text: Input text.
-
-            Returns:
-                A likely code-like token, or an empty string if not found.
-            """
-            import re
-
-            m = re.search(r"\b[A-Z0-9-]{3,}\b", text or "")
-            return m.group(0) if m else ""
-
-        self.agent = ToolCallingAgent(
-            model=build_local_model(),
-            tools=[
-                get_task_file_path,
-                inspect_file,
-                read_local_text_file,
-                transcribe_local_audio,
-                run_local_python,
-                read_local_spreadsheet,
-                compute_total_food_sales,
-                fetch_text_content,
-                read_excel,
-                get_wikipedia_page,
-                fetch_web_text,
-                fetch_wiki_content,
-                retrieve_stored_table,
-                solve_noncommutative_table,
-                extract_last_number,
-                extract_page_numbers,
-                extract_first_name,
-                extract_code_like_token,
-            ],
-            max_steps=self.config.max_steps,
-            verbosity_level=1,
-        )
 
     def __call__(self, question: str, task_id: Optional[str] = None) -> str:
-        task_id = task_id or ""
-
-        prompt = f"""
-You are solving one GAIA benchmark task.
-
-Instructions:
-- Return only the final answer.
-- Do not include explanation, reasoning, or labels.
-- Prefer tools over guessing.
-- If an attached file may exist, first call get_task_file_path("{task_id}") and inspect it.
-- If a file is audio, transcribe it.
-- If a file is Python, run it.
-- If a file is a spreadsheet, read it and compute the answer from the contents.
-- Use Wikipedia tools for Wikipedia-heavy questions.
-- Use webpage fetch tools for direct URL questions.
-- Use extraction helpers when they can produce the exact final answer.
+        """
+        Main entry point used by app.py.
+        """
+        context = self._load_context(task_id=task_id)
+        raw_output = self._solve(question=question, context=context)
+        final_answer = extract_final_answer(raw_output)
+        return normalize_final_answer(final_answer)
+
+    def _load_context(self, task_id: Optional[str]) -> str:
+        """
+        Try to fetch and read any task-linked file.
+        Safe fallback: empty context.
+        """
+        if not task_id:
+            return ""
+
+        try:
+            file_text = self.task_file_tool.get_task_context(task_id=task_id)
+            if not file_text:
+                return ""
 
-Question:
-{question}
-"""
-        result = self.agent.run(prompt)
-        return normalize_final_answer(str(result).strip())
+            return file_text[: self.config.max_context_chars]
+        except Exception:
+            return ""
+
+    def _solve(self, question: str, context: str) -> str:
+        """
+        Solve the question with either:
+        1) a plugged-in LLM client, or
+        2) a safe fallback so the app does not crash during setup.
+
+        The LLM client is expected to expose a .generate(prompt: str) -> str method.
+        We will wire the real model later.  
+        """
+        prompt = build_solver_prompt(question=question, context=context)
+
+        try:
+            return self.llm_client.generate(prompt)
+        except Exception as e:
+            print(f"LLM generation error: {e}")
+            return ""

llm_client.py

@@ -1,43 +1,43 @@
-# import os
-# from huggingface_hub import InferenceClient
-# from dotenv import load_dotenv
-
-# load_dotenv()
-
-
-# class HFLLMClient:
-#     def __init__(self):
-#         self.api_key = os.getenv("HF_TOKEN")
-#         print("HF token present:", bool(self.api_key))
-
-#         if not self.api_key:
-#             raise ValueError("HF_TOKEN is not set")
-
-#         self.model = "Qwen/Qwen2.5-7B-Instruct"
-#         self.client = InferenceClient(
-#             provider="auto",
-#             api_key=self.api_key,
-#         )
-
-#     def generate(self, prompt: str) -> str:
-#         try:
-#             output = self.client.chat_completion(
-#                 model=self.model,
-#                 messages=[
-#                     {"role": "user", "content": prompt}
-#                 ],
-#                 max_tokens=128,
-#                 temperature=0.1,
-#             )
-
-#             text = output.choices[0].message.content
-#             print("LLM response preview:", str(text)[:300])
-#             return str(text)
-
-#         except Exception as e:
-#             raise ValueError(f"Inference call failed: {e}")
-
-#2
+import os
+from huggingface_hub import InferenceClient
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class HFLLMClient:
+    def __init__(self):
+        self.api_key = os.getenv("HF_TOKEN")
+        print("HF token present:", bool(self.api_key))
+
+        if not self.api_key:
+            raise ValueError("HF_TOKEN is not set")
+
+        self.model = "Qwen/Qwen2.5-7B-Instruct"
+        self.client = InferenceClient(
+            provider="auto",
+            api_key=self.api_key,
+        )
+
+    def generate(self, prompt: str) -> str:
+        try:
+            output = self.client.chat_completion(
+                model=self.model,
+                messages=[
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=128,
+                temperature=0.1,
+            )
+
+            text = output.choices[0].message.content
+            print("LLM response preview:", str(text)[:300])
+            return str(text)
+
+        except Exception as e:
+            raise ValueError(f"Inference call failed: {e}")
+
+# 2
 # import os
 # from dotenv import load_dotenv
 
@@ -53,15 +53,3 @@
 #         # If you later connect a provider, do it here.
 #         # For now, fail cleanly so tool-based paths still work.
 #         raise RuntimeError("No free LLM fallback configured.")
-
-# llm_client.py
-from smolagents import TransformersModel
-
-
-def build_local_model() -> TransformersModel:
-    return TransformersModel(
-        model_id="Qwen/Qwen2.5-0.5B-Instruct",
-        max_new_tokens=256,
-        temperature=0.1,
-        do_sample=False,
-    )

prompts.py

@@ -1,144 +1,57 @@
-# from __future__ import annotations
-
-
-# SYSTEM_PROMPT = """
-# You are a benchmark-solving AI agent.
-
-# Your task is to answer questions as accurately as possible.
-
-# Rules:
-# - Return only the final answer.
-# - If unsure, return your best short answer only.
-# - Do not explain.
-# - Do not include reasoning.
-# - Do not include complete sentences unless the answer itself is a sentence.
-# - For lists, preserve exact order only if supported by evidence.
-# - Do not invent information not present in the question or provided context.
-
-# Formatting rules:
-# - If the answer is a number, output only the number.
-# - If the answer is a word or phrase, output only that word or phrase.
-# - If the answer is a date, return the exact date string.
-# - Do not add punctuation unless it is part of the answer.
-
-# Your response must contain only the final answer string.
-# """
-
-
-# def build_solver_prompt(question: str, context: str = "") -> str:
-#     """
-#     Builds the final prompt sent to the model.
-#     Includes optional file context when a task provides additional data.
-#     """
-
-#     if context:
-#         prompt = f"""
-# {SYSTEM_PROMPT}
-
-# Context information:
-# {context}
-
-# Question:
-# {question}
-
-# Return only the final answer.
-# """
-#     else:
-#         prompt = f"""
-# {SYSTEM_PROMPT}
-
-# Question:
-# {question}
-
-# Return only the final answer.
-# """
-
-#     return prompt.strip()
-
-
-# #number 2
-# from __future__ import annotations
-
-
-# SYSTEM_PROMPT = """
-# You are a benchmark-solving AI agent.
-
-# Rules:
-# - Return ONLY the final answer.
-# - Do NOT include explanations.
-# - Do NOT include reasoning.
-# - Do NOT include 'FINAL ANSWER'.
-# - Do NOT include labels like 'Answer:'.
-# - If web or file context is provided, use it instead of guessing.
-# - If multiple candidates appear, choose the one best supported by the provided context.
-
-# Formatting rules:
-# - If the answer is a number, output only the number.
-# - If the answer is a word or short phrase, output only that word or phrase.
-# - If the answer is a date, output only the date.
-# - Do not add punctuation unless required by the answer itself.
-# """
-
-
-# def build_solver_prompt(question: str, context: str = "") -> str:
-#     if context:
-#         return f"""
-# {SYSTEM_PROMPT}
-
-# Context:
-# {context}
-
-# Question:
-# {question}
-
-# Return only the final answer.
-# """.strip()
-
-#     return f"""
-# {SYSTEM_PROMPT}
-
-# Question:
-# {question}
-
-# Return only the final answer.
-# """.strip()
-
-#number 3
 from __future__ import annotations
 
 
 SYSTEM_PROMPT = """
 You are a benchmark-solving AI agent.
 
+Your task is to answer questions as accurately as possible.
+
 Rules:
-- Return ONLY the final answer.
-- Do NOT include explanations.
-- Do NOT include reasoning.
-- Do NOT include labels like "Answer:".
-- Do NOT include the words "FINAL ANSWER".
-- Use only the supplied evidence.
+- Return only the final answer.
+- If unsure, return your best short answer only.
+- Do not explain.
+- Do not include reasoning.
+- Do not include complete sentences unless the answer itself is a sentence.
+- For lists, preserve exact order only if supported by evidence.
+- Do not invent information not present in the question or provided context.
+
+Formatting rules:
+- If the answer is a number, output only the number.
+- If the answer is a word or phrase, output only that word or phrase.
+- If the answer is a date, return the exact date string.
+- Do not add punctuation unless it is part of the answer.
+
+Your response must contain only the final answer string.
 """
 
 
 def build_solver_prompt(question: str, context: str = "") -> str:
+    """
+    Builds the final prompt sent to the model.
+    Includes optional file context when a task provides additional data.
+    """
+
     if context:
-        return f"""
+        prompt = f"""
 {SYSTEM_PROMPT}
 
-Evidence:
+Context information:
 {context}
 
 Question:
 {question}
 
 Return only the final answer.
-""".strip()
-
-    return f"""
+"""
+    else:
+        prompt = f"""
 {SYSTEM_PROMPT}
 
 Question:
 {question}
 
 Return only the final answer.
-""".strip()
+"""
+
+    return prompt.strip()
+

tools.py

@@ -1,483 +1,102 @@
-# from __future__ import annotations
-# import io
-# import json
-# import os
-# from pathlib import Path
-# from typing import Optional
-# import pandas as pd
-# import requests
-
-# class TaskFileTool:
-#     """
-#     Downloads and reads task-linked files from the Hugging Face
-#     Unit 4 scoring API.
-
-#     Supported text extration:
-#     - txt
-#     - csv
-#     - json
-#     - md
-#     - html
-#     - xml
-
-#     For unsupported or binary files, it safely returns an empty string for now.
-#     We can extend this later for PDF/images if needed.
-#     """
-
-#     def __init__(self, api_base_url: str, cache_dir:str = "task_files", timeout: int =30):
-#         self.api_base_url = api_base_url.rstrip("/")
-#         self.cache_dir = Path(cache_dir)
-#         self.cache_dir.mkdir(parents=True, exist_ok=True)
-#         self.timeout = timeout
-    
-#     def get_task_context(self, task_id: str) -> str:
-#         """
-#         Main entry point used by the agent:
-#         1. download the task file if present
-#         2. read it into text context if supported
-#         """
-#         file_path = self.download_task_file(task_id)
-#         if file_path is None:
-#             return ""
-#         return self.read_file_as_text(file_path)
-
-#     def download_task_file(self, task_id: str) -> Optional[Path]:
-#         """
-#         Downloads the file linked to a task_id using:
-#         GET /files/{task_id}
-
-#         Returns:
-#             Path to saved file if successful, else None
-#         """
-#         url = f"{self.api_base_url}/file/{task_id}"
-
-#         try:
-#             response = requests.get(url, timeout=self.timeout)
-#         except requests.RequestException:
-#             return None
-        
-#         if response.status_code !=200:
-#             return None
-        
-#         filename = self._infer_filename(response=response, task_id=task_id)
-#         file_path = self.cache_dir / filename
-
-#         try:
-#             with open(file_path, "wb") as f:
-#                 f.write(response.content)
-#             return file_path
-#         except OSError:
-#             return None
-#         return file_path
-    
-#     def read_file_as_text(self, file_path: Path) -> str:
-#         """
-#         Reads supported file types into plain text.
-#         """
-#         suffix = file_path.suffix.lower()
-
-#         try:
-#             if suffix in {".txt", ".md", ".html", ".xml", ".csv", ".json"}:
-#                 return self._read_supported_text_file(file_path, suffix)
-
-#             # common fallback for files saved without extension but actually text
-#             if suffix == "":
-#                 return self._read_extensionless_file(file_path)
-
-#             return ""
-#         except Exception:
-#             return ""
-
-#     def _read_supported_text_file(self, file_path: Path, suffix: str) -> str:
-#         if suffix in {".txt", ".md", ".html", ".xml"}:
-#             return file_path.read_text(encoding="utf-8", errors="ignore")
-
-#         if suffix == ".json":
-#             raw = file_path.read_text(encoding="utf-8", errors="ignore")
-#             try:
-#                 parsed = json.loads(raw)
-#                 return json.dumps(parsed, indent=2, ensure_ascii=False)
-#             except json.JSONDecodeError:
-#                 return raw
-
-#         if suffix == ".csv":
-#             try:
-#                 df = pd.read_csv(file_path)
-#                 return df.to_csv(index=False)
-#             except Exception:
-#                 return file_path.read_text(encoding="utf-8", errors="ignore")
-
-#         return ""
-
-#     def _read_extensionless_file(self, file_path: Path) -> str:
-#         """
-#         Try to interpret extensionless files as utf-8 text first.
-#         """
-#         try:
-#             raw = file_path.read_text(encoding="utf-8", errors="ignore")
-#             if raw.strip():
-#                 return raw
-#         except Exception:
-#             pass
-#         return ""
-
-#     def _infer_filename(self, response: requests.Response, task_id: str) -> str:
-#         """
-#         Attempts to infer a useful filename from headers.
-#         Falls back to task_id if no filename is available.
-#         """
-#         content_disposition = response.headers.get("content-disposition", "")
-#         filename = self._extract_filename_from_content_disposition(content_disposition)
-
-#         if filename:
-#             return self._safe_filename(filename)
-
-#         content_type = response.headers.get("content-type", "").lower()
-#         extension = self._extension_from_content_type(content_type)
-
-#         if extension:
-#             return f"{task_id}{extension}"
-
-#         return str(task_id)
-
-#     @staticmethod
-#     def _extract_filename_from_content_disposition(content_disposition: str) -> Optional[str]:
-#         """
-#         Example header:
-#         content-disposition: attachment; filename="example.csv"
-#         """
-#         if "filename=" not in content_disposition:
-#             return None
-
-#         try:
-#             filename = content_disposition.split("filename=")[-1].strip().strip('"')
-#             return filename or None
-#         except Exception:
-#             return None
-
-#     @staticmethod
-#     def _extension_from_content_type(content_type: str) -> str:
-#         mapping = {
-#             "text/plain": ".txt",
-#             "text/csv": ".csv",
-#             "application/csv": ".csv",
-#             "application/json": ".json",
-#             "text/markdown": ".md",
-#             "text/html": ".html",
-#             "application/xml": ".xml",
-#             "text/xml": ".xml",
-#         }
-
-#         for key, ext in mapping.items():
-#             if key in content_type:
-#                 return ext
-
-#         return ""
-
-#     @staticmethod
-#     def _safe_filename(filename: str) -> str:
-#         """
-#         Prevent path traversal and weird path issues.
-#         """
-#         return os.path.basename(filename)
-
 from __future__ import annotations
-
-import contextlib
 import io
 import json
 import os
-import re
-import runpy
-import shelve
-import tempfile
-from io import BytesIO
 from pathlib import Path
-from typing import Any, Optional, Union
-
+from typing import Optional
 import pandas as pd
 import requests
-import wikipediaapi
-from bs4 import BeautifulSoup
-from faster_whisper import WhisperModel
-from smolagents import Tool, tool
-
-
-# -------------------------------------------------------------------
-# Generic helper tools
-# -------------------------------------------------------------------
-
-@tool
-def convert_pandas_table_to_markdown(table_csv_text: str) -> str:
-    """
-    Convert CSV-like table text into markdown.
-
-    Args:
-        table_csv_text: CSV-formatted table text.
-
-    Returns:
-        A markdown table string, or the original text if parsing fails.
-    """
-    try:
-        from io import StringIO
-
-        df = pd.read_csv(StringIO(table_csv_text))
-        return df.to_markdown(index=False)
-    except Exception:
-        return table_csv_text
-
-
-@tool
-def fetch_text_content(url: str) -> str:
-    """
-    Fetch raw text content from a URL.
-
-    Args:
-        url: The URL to fetch.
-
-    Returns:
-        The page text content, or an error string.
-    """
-    try:
-        response = requests.get(url, timeout=30)
-        response.raise_for_status()
-        return response.text
-    except requests.RequestException as e:
-        return f"Error fetching URL: {e}"
-
-
-@tool
-def read_excel(file_path: str) -> str:
-    """
-    Read an Excel file from a local path and return all sheets as CSV-like text.
-
-    Args:
-        file_path: Local path to the Excel file.
-
-    Returns:
-        Combined sheet contents as text.
-    """
-    if not file_path:
-        return ""
-
-    try:
-        sheets = pd.read_excel(file_path, sheet_name=None)
-    except Exception as e:
-        return f"Error reading Excel file: {e}"
-
-    parts = []
-    for sheet_name, df in sheets.items():
-        parts.append(f"Sheet: {sheet_name}")
-        try:
-            parts.append(df.to_csv(index=False))
-        except Exception:
-            parts.append(str(df))
-
-    return "\n\n".join(parts)
-
-
-# -------------------------------------------------------------------
-# Lightweight local storage for extracted tables
-# -------------------------------------------------------------------
-
-class ShelveDB:
-    dir_path = Path("./storage")
-
-    def __init__(self, table_name: str, init: bool = False):
-        self.dir_path.mkdir(parents=True, exist_ok=True)
-        self.path = str(self.dir_path / table_name)
-        if init:
-            with shelve.open(self.path):
-                pass
-
-    def save(self, key: str, value: Any) -> None:
-        with shelve.open(self.path) as db:
-            db[key] = value
-
-    def fetch(self, key: str) -> Any:
-        with shelve.open(self.path) as db:
-            return db.get(key)
-
-    def clear(self) -> None:
-        with shelve.open(self.path) as db:
-            db.clear()
-
-
-class RetrieveCSVStorageTool(Tool):
-    name = "retrieve_csv_storage_tool"
-    description = "Retrieve a stored pandas table by key and return it as CSV text."
-    inputs = {
-        "key": {
-            "type": "string",
-            "description": "The key to retrieve from storage, such as table_1.",
-        }
-    }
-    output_type = "string"
-
-    def __init__(self, table_name: str = "wiki", init_storage: bool = True, storage_path: str | None = None):
-        super().__init__()
-        if storage_path is not None:
-            ShelveDB.dir_path = Path(storage_path)
-        self.storage = ShelveDB(table_name, init=init_storage)
-
-    def get_storage(self) -> ShelveDB:
-        return self.storage
-
-    def forward(self, key: str) -> str:
-        try:
-            dataframe = self.storage.fetch(key)
-            if dataframe is None:
-                return f"No data found for key: {key}"
-            if isinstance(dataframe, pd.DataFrame):
-                return dataframe.to_csv(index=False)
-            return str(dataframe)
-        except Exception as e:
-            return f"Error retrieving data: {e}"
-
-
-# -------------------------------------------------------------------
-# Wikipedia tools
-# -------------------------------------------------------------------
-
-def get_wiki_content(title: str, language: str = "en") -> tuple[str, dict[str, pd.DataFrame]]:
-    """
-    Retrieve Wikipedia page text and any HTML tables found on the page.
-
-    Args:
-        title: Wikipedia page title.
-        language: Wikipedia language code.
-
-    Returns:
-        A tuple of (page_text, tables_dict).
-    """
-    wiki = wikipediaapi.Wikipedia(user_agent="gaia-agent", language=language)
-    page = wiki.page(title)
-
-    if not page.exists():
-        return "", {}
-
-    page_text = page.text
-
-    # Try to fetch HTML and tables from normal Wikipedia URL
-    url = f"https://{language}.wikipedia.org/wiki/{title}"
-    tables: dict[str, pd.DataFrame] = {}
-
-    try:
-        dfs = pd.read_html(url)
-        for idx, df in enumerate(dfs, start=1):
-            tables[f"table_{idx}"] = df
-    except Exception:
-        pass
-
-    return page_text, tables
-
-
-class WikiTool(Tool):
-    name = "wiki_tool"
-    description = (
-        "Get Wikipedia page content and extracted tables. "
-        "The tables are also stored in local storage and can later be fetched with retrieve_csv_storage_tool."
-    )
-    inputs = {
-        "query": {
-            "type": "string",
-            "description": "The title of the Wikipedia page, for example 'Mercedes_Sosa' or 'Malko_Competition'.",
-        },
-        "language": {
-            "type": "string",
-            "description": "The Wikipedia language code, such as 'en'.",
-            "nullable": True,
-        },
-    }
-    output_type = "string"
-
-    def __init__(self, storage: ShelveDB):
-        super().__init__()
-        self.storage = storage
-
-    def forward(self, query: str, language: str | None = None):
-        language = language or "en"
-        content, tables = get_wiki_content(query, language)
-        self.storage.clear()
-        for table_key, df in tables.items():
-            self.storage.save(table_key, df)
-
-        table_note = ""
-        if tables:
-            table_note = "\n\nStored tables:\n" + "\n".join(sorted(tables.keys()))
-
-        return content + table_note
-
-
-# -------------------------------------------------------------------
-# Generic webpage tools
-# -------------------------------------------------------------------
-
-class WebPageTool:
-    def fetch_text(self, url: str) -> str:
-        response = requests.get(url, timeout=30)
-        response.raise_for_status()
-        soup = BeautifulSoup(response.text, "html.parser")
-        return soup.get_text(" ", strip=True)[:25000]
-
-    def fetch_tables(self, url: str) -> list[pd.DataFrame]:
-        try:
-            return pd.read_html(url)
-        except Exception:
-            return []
-
-
-# -------------------------------------------------------------------
-# Attached task file tool
-# -------------------------------------------------------------------
 
 class TaskFileTool:
     """
-    Download and cache task-attached files from the Unit 4 scoring API.
+    Downloads and reads task-linked files from the Hugging Face
+    Unit 4 scoring API.
+
+    Supported text extration:
+    - txt
+    - csv
+    - json
+    - md
+    - html
+    - xml
+
+    For unsupported or binary files, it safely returns an empty string for now.
+    We can extend this later for PDF/images if needed.
     """
 
-    def __init__(self, api_base_url: str, cache_dir: str = "task_files", timeout: int = 30):
+    def __init__(self, api_base_url: str, cache_dir:str = "task_files", timeout: int =30):
         self.api_base_url = api_base_url.rstrip("/")
         self.cache_dir = Path(cache_dir)
         self.cache_dir.mkdir(parents=True, exist_ok=True)
         self.timeout = timeout
+    
+    def get_task_context(self, task_id: str) -> str:
+        """
+        Main entry point used by the agent:
+        1. download the task file if present
+        2. read it into text context if supported
+        """
+        file_path = self.download_task_file(task_id)
+        if file_path is None:
+            return ""
+        return self.read_file_as_text(file_path)
+
+    def download_task_file(self, task_id: str) -> Optional[Path]:
+        """
+        Downloads the file linked to a task_id using:
+        GET /files/{task_id}
 
-    def get_task_file_path(self, task_id: str) -> Optional[Path]:
-        url = f"{self.api_base_url}/files/{task_id}"
+        Returns:
+            Path to saved file if successful, else None
+        """
+        url = f"{self.api_base_url}/file/{task_id}"
 
         try:
             response = requests.get(url, timeout=self.timeout)
         except requests.RequestException:
             return None
-
-        if response.status_code != 200:
+        
+        if response.status_code !=200:
             return None
-
-        filename = self._infer_filename(response, task_id)
+        
+        filename = self._infer_filename(response=response, task_id=task_id)
         file_path = self.cache_dir / filename
 
-        with open(file_path, "wb") as f:
-            f.write(response.content)
-
+        try:
+            with open(file_path, "wb") as f:
+                f.write(response.content)
+            return file_path
+        except OSError:
+            return None
         return file_path
+    
+    def read_file_as_text(self, file_path: Path) -> str:
+        """
+        Reads supported file types into plain text.
+        """
+        suffix = file_path.suffix.lower()
 
-    def get_task_context(self, task_id: str) -> str:
-        file_path = self.get_task_file_path(task_id)
-        if not file_path:
-            return ""
-        return self.read_file_as_text(file_path)
+        try:
+            if suffix in {".txt", ".md", ".html", ".xml", ".csv", ".json"}:
+                return self._read_supported_text_file(file_path, suffix)
 
-    def read_file_as_text(self, file_path: Union[str, Path]) -> str:
-        file_path = Path(file_path)
-        suffix = file_path.suffix.lower()
+            # common fallback for files saved without extension but actually text
+            if suffix == "":
+                return self._read_extensionless_file(file_path)
 
+            return ""
+        except Exception:
+            return ""
+
+    def _read_supported_text_file(self, file_path: Path, suffix: str) -> str:
         if suffix in {".txt", ".md", ".html", ".xml"}:
             return file_path.read_text(encoding="utf-8", errors="ignore")
 
         if suffix == ".json":
             raw = file_path.read_text(encoding="utf-8", errors="ignore")
             try:
-                return json.dumps(json.loads(raw), indent=2, ensure_ascii=False)
+                parsed = json.loads(raw)
+                return json.dumps(parsed, indent=2, ensure_ascii=False)
             except json.JSONDecodeError:
                 return raw
 
@@ -490,181 +109,74 @@ class TaskFileTool:
 
         return ""
 
-    def _infer_filename(self, response: requests.Response, task_id: str) -> str:
-        cd = response.headers.get("content-disposition", "")
-        if "filename=" in cd:
-            return os.path.basename(cd.split("filename=")[-1].strip().strip('"'))
-
-        content_type = response.headers.get("content-type", "").lower()
-        mapping = {
-            "text/plain": ".txt",
-            "text/csv": ".csv",
-            "application/json": ".json",
-            "text/html": ".html",
-            "audio/mpeg": ".mp3",
-            "audio/wav": ".wav",
-            "image/png": ".png",
-            "image/jpeg": ".jpg",
-            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
-            "text/x-python": ".py",
-        }
-        for key, ext in mapping.items():
-            if key in content_type:
-                return f"{task_id}{ext}"
-
-        return str(task_id)
-
-
-# -------------------------------------------------------------------
-# Audio tools
-# -------------------------------------------------------------------
-
-class AudioTool:
-    def __init__(self):
-        self.model = WhisperModel("tiny", device="cpu", compute_type="int8")
-
-    def transcribe(self, file_path: str) -> str:
+    def _read_extensionless_file(self, file_path: Path) -> str:
+        """
+        Try to interpret extensionless files as utf-8 text first.
+        """
         try:
-            segments, _ = self.model.transcribe(file_path)
-            return " ".join(seg.text.strip() for seg in segments).strip()
+            raw = file_path.read_text(encoding="utf-8", errors="ignore")
+            if raw.strip():
+                return raw
         except Exception:
-            return ""
-
-
-class SpeechRecognitionTool(Tool):
-    name = "speech_recognition_tool"
-    description = "Transcribe a local audio file into text."
-    inputs = {
-        "audio_path": {
-            "type": "string",
-            "description": "The local path to the audio file.",
-        }
-    }
-    output_type = "string"
-
-    def __init__(self):
-        super().__init__()
-        self.audio_tool = AudioTool()
-
-    def forward(self, audio_path: str) -> str:
-        try:
-            return self.audio_tool.transcribe(audio_path)
-        except Exception as e:
-            return f"Error: {e}"
-
-
-# -------------------------------------------------------------------
-# Visual tool placeholder
-# -------------------------------------------------------------------
-
-class VisualQATool(Tool):
-    name = "visual_qa_tool"
-    description = (
-        "Analyze a local image and answer a question about it. "
-        "This local fallback is limited and may not work well for complex vision tasks."
-    )
-    inputs = {
-        "image_path": {
-            "type": "string",
-            "description": "The local image path.",
-        },
-        "question": {
-            "type": "string",
-            "description": "The question to ask about the image.",
-        },
-    }
-    output_type = "string"
-
-    def forward(self, image_path: str, question: str) -> str:
-        # Free local placeholder. Keeps the tool available to the agent,
-        # but does not pretend to solve hard vision tasks reliably.
-        if not image_path:
-            return "No image path provided."
-        return (
-            "Visual analysis is limited in this local setup. "
-            "The image tool is available but not reliable for complex reasoning tasks."
-        )
-
-
-# -------------------------------------------------------------------
-# Spreadsheet and Python tools
-# -------------------------------------------------------------------
+            pass
+        return ""
 
-class SpreadsheetTool:
-    def read(self, file_path: str) -> dict[str, pd.DataFrame]:
-        ext = Path(file_path).suffix.lower()
-        if ext == ".csv":
-            return {"Sheet1": pd.read_csv(file_path)}
-        if ext in {".xlsx", ".xls"}:
-            return pd.read_excel(file_path, sheet_name=None)
-        return {}
+    def _infer_filename(self, response: requests.Response, task_id: str) -> str:
+        """
+        Attempts to infer a useful filename from headers.
+        Falls back to task_id if no filename is available.
+        """
+        content_disposition = response.headers.get("content-disposition", "")
+        filename = self._extract_filename_from_content_disposition(content_disposition)
 
-    def total_food_sales(self, file_path: str) -> str:
-        sheets = self.read(file_path)
-        total = 0.0
+        if filename:
+            return self._safe_filename(filename)
 
-        for _, df in sheets.items():
-            cols = {c.lower(): c for c in df.columns}
-            category_col = next((cols[c] for c in cols if "category" in c or "type" in c), None)
-            sales_col = next((cols[c] for c in cols if "sales" in c or "revenue" in c or "amount" in c), None)
+        content_type = response.headers.get("content-type", "").lower()
+        extension = self._extension_from_content_type(content_type)
 
-            if category_col and sales_col:
-                food_mask = ~df[category_col].astype(str).str.lower().str.contains("drink|beverage", na=False)
-                total += pd.to_numeric(df.loc[food_mask, sales_col], errors="coerce").fillna(0).sum()
+        if extension:
+            return f"{task_id}{extension}"
 
-        return f"{total:.2f}"
+        return str(task_id)
 
+    @staticmethod
+    def _extract_filename_from_content_disposition(content_disposition: str) -> Optional[str]:
+        """
+        Example header:
+        content-disposition: attachment; filename="example.csv"
+        """
+        if "filename=" not in content_disposition:
+            return None
 
-class PythonExecutionTool:
-    def run_python_file(self, file_path: str) -> str:
-        stdout = io.StringIO()
         try:
-            with contextlib.redirect_stdout(stdout):
-                runpy.run_path(file_path, run_name="__main__")
-            return stdout.getvalue().strip()
-        except Exception as e:
-            return f"Error running Python file: {e}"
-
-
-# -------------------------------------------------------------------
-# Logic helpers
-# -------------------------------------------------------------------
-
-class LogicTool:
-    def solve_noncommutative_subset(self, question: str) -> str:
-        rows = [line.strip() for line in question.splitlines() if "|" in line and line.count("|") >= 6]
-        if len(rows) < 6:
-            return ""
-
-        headers = [x.strip() for x in rows[0].split("|")[2:-1]]
-        table = {}
-
-        for row in rows[2:]:
-            parts = [x.strip() for x in row.split("|")[1:-1]]
-            row_key = parts[0]
-            values = parts[1:]
-            table[row_key] = dict(zip(headers, values))
-
-        bad = set()
-        for a in headers:
-            for b in headers:
-                if table[a][b] != table[b][a]:
-                    bad.add(a)
-                    bad.add(b)
-
-        return ",".join(sorted(bad))
+            filename = content_disposition.split("filename=")[-1].strip().strip('"')
+            return filename or None
+        except Exception:
+            return None
 
+    @staticmethod
+    def _extension_from_content_type(content_type: str) -> str:
+        mapping = {
+            "text/plain": ".txt",
+            "text/csv": ".csv",
+            "application/csv": ".csv",
+            "application/json": ".json",
+            "text/markdown": ".md",
+            "text/html": ".html",
+            "application/xml": ".xml",
+            "text/xml": ".xml",
+        }
 
-# -------------------------------------------------------------------
-# Wikipedia text helper
-# -------------------------------------------------------------------
+        for key, ext in mapping.items():
+            if key in content_type:
+                return ext
 
-class WikipediaTool:
-    def __init__(self):
-        self.wiki = wikipediaapi.Wikipedia(user_agent="gaia-agent", language="en")
+        return ""
 
-    def get_page_text(self, title: str) -> str:
-        page = self.wiki.page(title)
-        if not page.exists():
-            return ""
-        return page.text[:25000]
+    @staticmethod
+    def _safe_filename(filename: str) -> str:
+        """
+        Prevent path traversal and weird path issues.
+        """
+        return os.path.basename(filename)

utils.py

@@ -1,228 +1,17 @@
-# from __future__ import annotations
-
-# import re
-
-
-# def extract_final_answer(text: str) -> str:
-#     """
-#     Extract the most likely final answer from raw model output.
-
-#     In V1 we keep this conservative:
-#     - if the model returns a normal short answer, keep it
-#     - if it adds common prefixes like 'Answer:' or 'Final answer:', remove them
-#     - if it returns multiple lines, prefer the last non-empty line
-#     """
-#     if text is None:
-#         return ""
-
-#     text = str(text).strip()
-#     if not text:
-#         return ""
-
-#     # Remove fenced code blocks if the model wraps the answer oddly
-#     text = re.sub(r"^```[a-zA-Z0-9_-]*\s*", "", text)
-#     text = re.sub(r"\s*```$", "", text)
-
-#     # Common exact-answer markers
-#     marker_patterns = [
-#         r"(?i)\bfinal answer\s*:\s*",
-#         r"(?i)\banswer\s*:\s*",
-#         r"(?i)\bthe answer is\s*:\s*",
-#         r"(?i)\bthe answer is\s+",
-#     ]
-
-#     cleaned = text
-#     for pattern in marker_patterns:
-#         cleaned = re.sub(pattern, "", cleaned).strip()
-
-#     # If multi-line, prefer the last meaningful line
-#     lines = [line.strip() for line in cleaned.splitlines() if line.strip()]
-#     if not lines:
-#         return ""
-
-#     if len(lines) == 1:
-#         return lines[0]
-
-#     return lines[-1]
-
-
-# def normalize_final_answer(text: str) -> str:
-#     """
-#     Normalize answer text for safer exact-match submission without being too aggressive.
-
-#     Rules:
-#     - trim outer whitespace
-#     - collapse internal repeated whitespace
-#     - remove wrapping quotes if they wrap the full answer
-#     - remove a single trailing period only for plain word/phrase answers
-#       but keep decimal numbers and date punctuation intact
-#     """
-#     if text is None:
-#         return ""
-
-#     text = str(text).strip()
-#     if not text:
-#         return ""
-
-#     # Collapse repeated whitespace
-#     text = re.sub(r"\s+", " ", text).strip()
-
-#     # Remove matching surrounding quotes
-#     if len(text) >= 2:
-#         if (text[0] == text[-1]) and text[0] in {'"', "'"}:
-#             text = text[1:-1].strip()
-
-#     # Remove common leading labels again, just in case
-#     text = re.sub(r"(?i)^(final answer|answer)\s*:\s*", "", text).strip()
-
-#     # Remove one trailing period for simple phrase answers only
-#     # Keep decimals like 3.14 intact
-#     if text.endswith("."):
-#         if not re.fullmatch(r"\d+\.\d+", text):
-#             text = text[:-1].strip()
-
-#     return text
-
-
-# def is_placeholder_answer(text: str) -> bool:
-#     """
-#     Detect placeholder/fallback outputs so app.py can optionally flag them.
-#     """
-#     if text is None:
-#         return True
-
-#     normalized = normalize_final_answer(text).lower()
-#     return normalized in {
-#         "",
-#         "placeholder",
-#         "n/a",
-#         "unknown",
-#     }
-
-# # Number 2
-# from __future__ import annotations
-
-# import re
-
-
-# def extract_final_answer(text: str) -> str:
-#     """
-#     Extract the final answer, preferring GAIA-style:
-#     FINAL ANSWER: ...
-
-#     Fallback behavior:
-#     - strip code fences
-#     - remove common answer prefixes
-#     - if multiple lines remain, prefer the last non-empty line
-#     """
-#     if text is None:
-#         return ""
-
-#     text = str(text).strip()
-#     if not text:
-#         return ""
-
-#     # Remove fenced code blocks if present
-#     text = re.sub(r"^```[a-zA-Z0-9_-]*\s*", "", text)
-#     text = re.sub(r"\s*```$", "", text)
-
-#     # Prefer GAIA-style final answer extraction
-#     gaia_match = re.search(
-#         r"FINAL ANSWER:\s*(.*)",
-#         text,
-#         flags=re.IGNORECASE | re.DOTALL,
-#     )
-#     if gaia_match:
-#         extracted = gaia_match.group(1).strip()
-#         lines = [line.strip() for line in extracted.splitlines() if line.strip()]
-#         return lines[0] if lines else extracted
-
-#     # Fallback exact-answer markers
-#     marker_patterns = [
-#         r"(?i)\bfinal answer\s*:\s*",
-#         r"(?i)\banswer\s*:\s*",
-#         r"(?i)\bthe answer is\s*:\s*",
-#         r"(?i)\bthe answer is\s+",
-#     ]
-
-#     cleaned = text
-#     for pattern in marker_patterns:
-#         cleaned = re.sub(pattern, "", cleaned).strip()
-
-#     lines = [line.strip() for line in cleaned.splitlines() if line.strip()]
-#     if not lines:
-#         return ""
-
-#     if len(lines) == 1:
-#         return lines[0]
-
-#     return lines[-1]
-
-
-# def normalize_final_answer(text: str) -> str:
-#     """
-#     Normalize answer text for exact-match-style submission.
-
-#     Rules:
-#     - trim whitespace
-#     - collapse repeated spaces
-#     - remove wrapping quotes
-#     - remove labels again if present
-#     - remove one trailing period for plain phrase answers
-#     - remove leading articles for short string answers
-#     """
-#     if text is None:
-#         return ""
-
-#     text = str(text).strip()
-#     if not text:
-#         return ""
-
-#     # Collapse repeated whitespace
-#     text = re.sub(r"\s+", " ", text).strip()
-
-#     # Remove matching surrounding quotes
-#     if len(text) >= 2 and text[0] == text[-1] and text[0] in {'"', "'"}:
-#         text = text[1:-1].strip()
-
-#     # Remove common labels again
-#     text = re.sub(r"(?i)^(final answer|answer)\s*:\s*", "", text).strip()
-
-#     # Remove one trailing period for simple phrase answers only
-#     if text.endswith(".") and not re.fullmatch(r"\d+\.\d+", text):
-#         text = text[:-1].strip()
-
-#     # Remove leading articles for short string answers
-#     # Helps align with GAIA string-format guidance
-#     text = re.sub(r"(?i)^(a|an|the)\s+", "", text).strip()
-
-#     return text
-
-
-# def is_placeholder_answer(text: str) -> bool:
-#     """
-#     Detect placeholder or clearly non-useful outputs.
-#     """
-#     if text is None:
-#         return True
-
-#     normalized = normalize_final_answer(text).lower()
-#     return normalized in {
-#         "",
-#         "placeholder",
-#         "n/a",
-#         "unknown",
-#     }
-
-#number 3
 from __future__ import annotations
 
-import os
 import re
-from urllib.parse import urlparse, parse_qs
 
 
 def extract_final_answer(text: str) -> str:
+    """
+    Extract the most likely final answer from raw model output.
+
+    In V1 we keep this conservative:
+    - if the model returns a normal short answer, keep it
+    - if it adds common prefixes like 'Answer:' or 'Final answer:', remove them
+    - if it returns multiple lines, prefer the last non-empty line
+    """
     if text is None:
         return ""
 
@@ -230,19 +19,44 @@ def extract_final_answer(text: str) -> str:
     if not text:
         return ""
 
+    # Remove fenced code blocks if the model wraps the answer oddly
     text = re.sub(r"^```[a-zA-Z0-9_-]*\s*", "", text)
     text = re.sub(r"\s*```$", "", text)
 
-    text = re.sub(r"(?i)^(final answer|answer)\s*:\s*", "", text).strip()
+    # Common exact-answer markers
+    marker_patterns = [
+        r"(?i)\bfinal answer\s*:\s*",
+        r"(?i)\banswer\s*:\s*",
+        r"(?i)\bthe answer is\s*:\s*",
+        r"(?i)\bthe answer is\s+",
+    ]
 
-    lines = [line.strip() for line in text.splitlines() if line.strip()]
+    cleaned = text
+    for pattern in marker_patterns:
+        cleaned = re.sub(pattern, "", cleaned).strip()
+
+    # If multi-line, prefer the last meaningful line
+    lines = [line.strip() for line in cleaned.splitlines() if line.strip()]
     if not lines:
         return ""
 
+    if len(lines) == 1:
+        return lines[0]
+
     return lines[-1]
 
 
 def normalize_final_answer(text: str) -> str:
+    """
+    Normalize answer text for safer exact-match submission without being too aggressive.
+
+    Rules:
+    - trim outer whitespace
+    - collapse internal repeated whitespace
+    - remove wrapping quotes if they wrap the full answer
+    - remove a single trailing period only for plain word/phrase answers
+      but keep decimal numbers and date punctuation intact
+    """
     if text is None:
         return ""
 
@@ -250,83 +64,37 @@ def normalize_final_answer(text: str) -> str:
     if not text:
         return ""
 
+    # Collapse repeated whitespace
     text = re.sub(r"\s+", " ", text).strip()
 
-    if len(text) >= 2 and text[0] == text[-1] and text[0] in {"'", '"'}:
-        text = text[1:-1].strip()
+    # Remove matching surrounding quotes
+    if len(text) >= 2:
+        if (text[0] == text[-1]) and text[0] in {'"', "'"}:
+            text = text[1:-1].strip()
 
+    # Remove common leading labels again, just in case
     text = re.sub(r"(?i)^(final answer|answer)\s*:\s*", "", text).strip()
 
-    if text.endswith(".") and not re.fullmatch(r"\d+\.\d+", text):
-        text = text[:-1].strip()
+    # Remove one trailing period for simple phrase answers only
+    # Keep decimals like 3.14 intact
+    if text.endswith("."):
+        if not re.fullmatch(r"\d+\.\d+", text):
+            text = text[:-1].strip()
 
     return text
 
 
-def extract_urls(text: str) -> list[str]:
-    return re.findall(r"https?://[^\s)>\]]+", text or "")
-
-
-def get_file_extension(path: str | None) -> str:
-    if not path:
-        return ""
-    return os.path.splitext(path)[1].lower()
-
-
-def extract_youtube_video_id(url: str) -> str:
-    parsed = urlparse(url)
-    if parsed.hostname in {"youtu.be"}:
-        return parsed.path.lstrip("/")
-    if parsed.hostname and "youtube.com" in parsed.hostname:
-        qs = parse_qs(parsed.query)
-        if "v" in qs:
-            return qs["v"][0]
-    return ""
-
-
-def infer_task_kind(question: str, file_path: str = "") -> str:
-    q = (question or "").lower()
-    ext = get_file_extension(file_path)
-
-    if "youtube.com/watch" in q or "youtu.be/" in q:
-        return "youtube"
-
-    if ext in {".mp3", ".wav", ".m4a", ".flac", ".ogg"}:
-        return "audio"
-
-    if ext in {".xlsx", ".xls", ".csv"}:
-        return "spreadsheet"
-
-    if ext == ".py":
-        return "python_file"
-
-    if ext in {".png", ".jpg", ".jpeg", ".webp"}:
-        return "image"
-
-    if "wikipedia" in q:
-        return "wikipedia"
-
-    if "table" in q or "|---|" in q:
-        return "table_logic"
-
-    if any(x in q for x in ["award number", "what city", "where were", "what country", "who nominated"]):
-        return "web_lookup"
-
-    if "opposite of the word" in q and q[::-1] != q:
-        return "text_transform"
-
-    return "general"
-
-
-EXTINCT_COUNTRIES = {
-    "east germany",
-    "west germany",
-    "yugoslavia",
-    "czechoslovakia",
-    "soviet union",
-    "ussr",
-}
-
-
-def is_extinct_country(name: str) -> bool:
-    return (name or "").strip().lower() in EXTINCT_COUNTRIES
+def is_placeholder_answer(text: str) -> bool:
+    """
+    Detect placeholder/fallback outputs so app.py can optionally flag them.
+    """
+    if text is None:
+        return True
+
+    normalized = normalize_final_answer(text).lower()
+    return normalized in {
+        "",
+        "placeholder",
+        "n/a",
+        "unknown",
+    }