Update app.py

app.py

@@ -8,163 +8,213 @@ import pandas as pd
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-# --- Try import smolagents components (fail gracefully with helpful error) ---
 _import_error_msgs = []
 try:
+    # Use CodeAgent (stable export), DuckDuckGoSearchTool, InferenceClientModel, and tool decorator
     from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel, tool
 except Exception as e:
-    # Keep placeholders to raise clearer errors only when instantiating
     CodeAgent = None
     DuckDuckGoSearchTool = None
     InferenceClientModel = None
     tool = None
-    _import_error_msgs.append(
-        "Failed to import smolagents components. Ensure 'smolagents' is installed in requirements.txt "
-        "and the environment has network access if needed. Import error: " + repr(e)
-    )
+    _import_error_msgs.append(repr(e))
+
 
-# --- Utility: clean agent output for exact-match grading ---
-def _clean_answer(raw: str) -> str:
+# --- Utilities ---
+def _clean_answer(raw: Any) -> str:
     """
-    Heuristic cleaning:
-      - strip surrounding whitespace and quotes
-      - drop lines before the final non-empty line
-      - remove common prefixes like 'Answer:', 'Final answer:', 'The answer is'
-      - return that single-line string
-    Note: this is intentionally conservative but helps avoid trivial format mismatches.
+    Heuristic cleaning to produce a single-line exact-match-friendly answer.
+
+    - Keep the last non-empty line of output.
+    - Remove common labels like "Answer:", "Final answer:".
+    - Strip surrounding quotes and whitespace.
+    - Collapse internal whitespace to single spaces.
+
+    Args:
+        raw (Any): Raw agent output to clean.
+
+    Returns:
+        str: Cleaned single-line answer string.
     """
     if raw is None:
         return ""
     text = str(raw)
 
-    # Normalize line endings, split, take last non-empty line
     lines = [ln.strip() for ln in text.replace("\r", "").split("\n") if ln.strip() != ""]
     if not lines:
         candidate = text.strip()
     else:
         candidate = lines[-1]
 
-    # Remove common labels
     candidate = re.sub(r'^(final answer[:\-\s]*)', '', candidate, flags=re.IGNORECASE)
     candidate = re.sub(r'^(answer[:\-\s]*)', '', candidate, flags=re.IGNORECASE)
     candidate = re.sub(r'^(the answer is[:\-\s]*)', '', candidate, flags=re.IGNORECASE)
 
-    # Strip surrounding quotes and whitespace
     candidate = candidate.strip().strip('\'"')
-
-    # Collapse internal multiple spaces to single space (helps formatting mismatches)
     candidate = re.sub(r'\s+', ' ', candidate)
-
     return candidate
 
-# --- Tool: GAIA file downloader ---
+
+# --- Safe small arithmetic evaluator tool ---
+def _safe_eval_arith(expr: str) -> str:
+    """
+    Safely evaluate simple arithmetic expressions using ast.
+
+    Supports: + - * / ** % unary ops and parentheses, numeric literals.
+    Rejects names, attribute access, calls, comprehensions, etc.
+    """
+    try:
+        node = ast.parse(expr, mode="eval")
+
+        # Define allowed node types
+        allowed_nodes = (
+            ast.Expression, ast.BinOp, ast.UnaryOp, ast.Num, ast.Constant,
+            ast.Add, ast.Sub, ast.Mult, ast.Div, ast.Pow, ast.Mod,
+            ast.UAdd, ast.USub, ast.Load, ast.Tuple, ast.List, ast.Expr,
+            ast.Subscript, ast.Index, ast.Slice, ast.Tuple
+        )
+
+        # Walk the AST and ensure nodes are permitted
+        for n in ast.walk(node):
+            if not isinstance(n, allowed_nodes):
+                # numeric constants in Python 3.8+ are ast.Constant
+                # allow parentheses (they are represented by grouping nodes)
+                raise ValueError(f"Disallowed expression element: {type(n).__name__}")
+
+        # Evaluate in a restricted namespace
+        result = eval(compile(node, filename="<ast>", mode="eval"), {"__builtins__": {}}, {})
+        return str(result)
+    except Exception as e:
+        return f"ERROR_EVAL: {e}"
+
+
+# --- Tools (must have good docstrings for smolagents) ---
 if tool is not None:
     @tool
     def download_gaia_file(task_id: str) -> str:
         """
-        Download the file associated with a GAIA task and return its text content.
+        Download the text content of the file associated with a GAIA task ID.
+
+        Args:
+            task_id (str): The task identifier for which the file should be downloaded. This
+                value comes from the GAIA questions endpoint and is used to fetch the file via
+                the /files/{task_id} route.
+
+        Returns:
+            str: The textual content of the downloaded file, or an error string beginning with
+                 'ERROR_DOWNLOADING_FILE:' in case of failure.
         """
         try:
             url = f"{DEFAULT_API_URL}/files/{task_id}"
             resp = requests.get(url, timeout=20)
             resp.raise_for_status()
-            # If content-type is binary, this might return bytes; convert to text defensively
+            # Return text, decoding bytes defensively
             if isinstance(resp.content, (bytes, bytearray)):
-                try:
-                    return resp.content.decode(resp.encoding or "utf-8", errors="replace")
-                except Exception:
-                    return resp.text
+                return resp.content.decode(resp.encoding or "utf-8", errors="replace")
             return resp.text
         except Exception as e:
-            # Return a short diagnostic string as tool observation (agent can handle)
             return f"ERROR_DOWNLOADING_FILE: {e}"
+
+    @tool
+    def web_search(query: str) -> str:
+        """
+        Execute a web search using DuckDuckGoSearchTool (wrapped) and return the combined results.
+
+        Args:
+            query (str): A natural-language query describing the information to find.
+
+        Returns:
+            str: Search results or a short error string beginning with 'ERROR_SEARCH:'.
+        """
+        try:
+            # Construct a minimal wrapper call to DuckDuckGoSearchTool
+            # The actual DuckDuckGoSearchTool object will be created in agent init
+            return DuckDuckGoSearchTool()(query)
+        except Exception as e:
+            return f"ERROR_SEARCH: {e}"
+
+    @tool
+    def simple_calc(expression: str) -> str:
+        """
+        Compute a simple arithmetic expression safely.
+
+        Args:
+            expression (str): A mathematical expression like '2 + 3 * (4 - 1)'.
+
+        Returns:
+            str: The numeric result as a string, or an error string beginning with 'ERROR_EVAL:'.
+        """
+        return _safe_eval_arith(expression)
 else:
-    # Placeholder to fail fast with clear message if tool decorator missing
+    # If smolagents.tool not available, define fallback functions that raise helpful errors
     def download_gaia_file(task_id: str) -> str:
-        raise RuntimeError("smolagents.tool is not available; check smolagents installation. "
-                           "Original import error(s): " + "; ".join(_import_error_msgs))
+        raise RuntimeError("smolagents.tool decorator unavailable. Install smolagents and redeploy. Import errors: " + "; ".join(_import_error_msgs))
+    def web_search(query: str) -> str:
+        raise RuntimeError("smolagents.tool decorator unavailable. Install smolagents and redeploy. Import errors: " + "; ".join(_import_error_msgs))
+    def simple_calc(expression: str) -> str:
+        raise RuntimeError("smolagents.tool decorator unavailable. Install smolagents and redeploy. Import errors: " + "; ".join(_import_error_msgs))
 
 
-# --- Leaderboard-grade Agent (uses CodeAgent under smolagents) ---
+# --- Leaderboard-grade Agent (CodeAgent) ---
 class BasicAgent:
     def __init__(self):
         if CodeAgent is None or InferenceClientModel is None or DuckDuckGoSearchTool is None:
-            # Raise a clear runtime error with the original import messages
             raise RuntimeError(
-                "smolagents components are not available in this environment. "
-                "Please ensure 'smolagents' is installed and included in requirements.txt. "
+                "smolagents imports failed. Ensure 'smolagents' is in requirements.txt and redeploy. "
                 "Import details: " + "; ".join(_import_error_msgs)
             )
 
         print("Initializing GAIA leaderboard-grade agent (CodeAgent)...")
 
-        # Model selection: allow overriding via env var HF_MODEL_ID
         model_id = os.getenv("HF_MODEL_ID", "Qwen/Qwen2.5-72B-Instruct")
-        # Temperature explicitly 0 for determinism
         try:
             self.model = InferenceClientModel(
                 model_id=model_id,
                 temperature=0.0
             )
         except Exception as e:
-            # Provide a friendly message if model instantiation fails
-            raise RuntimeError(f"Failed to initialize InferenceClientModel for '{model_id}': {e}")
+            raise RuntimeError(f"Failed to init InferenceClientModel({model_id}): {e}")
 
-        # Tools: search + file download
+        # Instantiate the real search tool object and put our tools in list
         try:
-            self.tools = [
-                DuckDuckGoSearchTool(),
-                download_gaia_file
-            ]
+            ddg = DuckDuckGoSearchTool()
+            self.tools = [ddg, download_gaia_file, simple_calc]
         except Exception as e:
-            raise RuntimeError(f"Failed to initialize tools: {e}")
+            raise RuntimeError(f"Failed to init tools: {e}")
 
-        # A concise system prompt guiding strict outputs. CodeAgent may accept prompts via run input;
-        # we will supply a short instruction prefix when calling agent.run below.
+        # Instructions to bias towards exact final-answer-only outputs
         self.system_instructions = (
-            "You are solving GAIA benchmark questions. "
-            "Rules: use tools when needed. If a file is available, read it. "
-            "Do NOT output reasoning. The final output MUST be exactly the answer only—no extra words, "
-            "no 'FINAL ANSWER', no explanations. Keep output to a single line if possible."
+            "You are solving GAIA benchmark questions. Use available tools when needed. "
+            "If a file is referenced, download and read it. Do NOT reveal your chain-of-thought or reasoning. "
+            "The final output MUST be exactly the answer only (one short line). No extra commentary, no 'FINAL ANSWER'."
         )
 
-        # Initialize CodeAgent
+        # Initialize CodeAgent; argument signatures may vary across versions, handle common cases
         try:
-            # CodeAgent signature and options may vary by smolagents version; keep minimal.
             self.agent = CodeAgent(
                 tools=self.tools,
                 model=self.model
             )
         except TypeError:
-            # Try alternate ordering if smolagents version expects different arguments
             self.agent = CodeAgent(self.model, self.tools)
 
     def __call__(self, question: str) -> str:
         """
-        Run the agent on the given question and return a cleaned answer string.
-        We prefix the question with system instructions to bias towards exact-match outputs.
+        Run the CodeAgent on the provided question and return a cleaned single-line answer.
         """
         try:
             prompt = f"{self.system_instructions}\n\nQUESTION:\n{question}\n\nAnswer:"
-            print("Running agent on question (preview):", (question[:200] + "...") if len(question) > 200 else question)
-            # Many smolagents agent.run implementations accept either a string or a dict; support both.
+            # Some smolagents versions accept dict input; try string then dict
             try:
-                raw_result = self.agent.run(prompt)
+                raw = self.agent.run(prompt)
             except TypeError:
-                # fallback if run signature is different
-                raw_result = self.agent.run({"input": prompt})
-            # Convert to string and clean
-            cleaned = _clean_answer(raw_result)
-            print("Raw result preview:", str(raw_result)[:300])
-            print("Cleaned final answer:", cleaned)
+                raw = self.agent.run({"input": prompt})
+            cleaned = _clean_answer(raw)
             return cleaned
         except Exception as e:
             tb = traceback.format_exc()
             print("Agent runtime error:", e, tb)
-            # Return a short sentinel so submission still proceeds (tooling will show errors per-item)
-            return f"AGENT_ERROR: {str(e)}"
+            return f"AGENT_ERROR: {e}"