added agent, config, exception, web_search

agent.py

@@ -0,0 +1,88 @@
+"""
+agent.py – central coordinator for smolagents-powered agent.
+
+This file exposes a single helper function `my_agent()` that returns an
+object which is **callable** (i.e. implements `__call__(question:str) -> str`)
+so that `app.py` can stay unchanged apart from a single import.
+
+* Adding new tools
+------------------
+1. Drop the tool file inside the ``/tools`` package.
+2. Import the tool class in `my_agent` and append it to the ``tools`` list.
+   The rest of the application will automatically pick it up.
+"""
+
+from typing import List, Sequence
+
+try:
+    from smolagents import Agent, Tool  # type: ignore
+except ImportError as exc:  # pragma: no cover
+    raise ImportError(
+        "smolagents must be in requirements.txt. "
+        "Add `smolagents` to your dependencies."
+    ) from exc
+
+# Available tools
+from tools.web_search import DuckDuckGoSearchTool  # noqa: E402
+
+
+class SmolAgentWrapper:
+    """
+    Thin wrapper that makes a smolagents.Agent *callable*.
+
+    The evaluation harness in app.py expects an object that can be called
+    directly with a single question and that returns a string.  The underlying
+    smolagents agent is session-aware and can handle multi-turn conversations
+    but we keep the public interface single-turn for now.
+    """
+
+    def __init__(self, tools: Sequence["Tool"] | None = None) -> None:  # type: ignore[name-defined]
+        if tools is None:
+            tools = [DuckDuckGoSearchTool()]
+        self._agent = Agent(tools=list(tools))
+
+    # Allow the object itself to be called like a function
+    def __call__(self, question: str) -> str:  # noqa: D401  (simple summary ok)
+        """
+        Ask the underlying smolagents Agent a **single** question and return the answer.
+
+        Any exception is caught and surfaced as a readable string in order not
+        to crash the evaluation loop.
+        """
+        try:
+            response = self._agent.run(question)
+            # smolagents may return dicts or ToolOutput objects; normalise to str
+            if isinstance(response, str):
+                return response
+            return str(response)
+        except Exception as err:  # pragma: no cover
+            return f"ERROR: {type(err).__name__}: {err}"
+
+
+# --------------------------------------------------------------------------- #
+# Helper – this is what app.py will import
+# --------------------------------------------------------------------------- #
+
+def my_agent(extra_tools: Sequence["Tool"] | None = None) -> SmolAgentWrapper:  # type: ignore[name-defined]
+    """
+    Factory that returns a ready-to-go agent.
+
+    Parameters
+    ----------
+    extra_tools:
+        Optional sequence of additional smolagents Tool objects to extend the
+        agent's capabilities.  They are appended **after** the default search
+        tool so they can override it if they expose the same name.
+
+    Returns
+    -------
+    SmolAgentWrapper
+        A callable object compatible with the original BasicAgent.
+    """
+    tools: List["Tool"] = [DuckDuckGoSearchTool()]
+    if extra_tools:
+        tools.extend(extra_tools)
+    return SmolAgentWrapper(tools=tools)
+
+
+__all__ = ["my_agent", "SmolAgentWrapper"]

app.py

@@ -4,20 +4,13 @@ import requests
 import inspect
 import pandas as pd
 
+# --- Our Agent ---
+from agent import my_agent
+
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent initialized.")
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -38,9 +31,10 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent ( modify this part to create your agent)
+    # 1. Instantiate Agent (now using smolagents)
     try:
-        agent = BasicAgent()
+        agent = my_agent()
+        print("SmolAgent instantiated successfully.")
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -69,7 +63,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         print(f"An unexpected error occurred fetching questions: {e}")
         return f"An unexpected error occurred fetching questions: {e}", None
 
-    # 3. Run your Agent
+    # 3. Run the Agent
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
@@ -142,7 +136,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown("# Agent Evaluation Runner")
     gr.Markdown(
         """
         **Instructions:**
@@ -192,5 +186,5 @@ if __name__ == "__main__":
 
     print("-"*(60 + len(" App Starting ")) + "\n")
 
-    print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    print("Launching Gradio Interface for Agent Evaluation…")
+    demo.launch(debug=True, share=False)

config.py

@@ -0,0 +1,7 @@
+# DuckDuckGo-specific settings
+DUCKDUCKGO_MAX_RESULTS = 10
+DUCKDUCKGO_TIMEOUT = 15  # seconds
+SEARCH_DEFAULT_ENGINE = 'duckduckgo'  # Make it easy to add others
+
+# Logging
+LOG_LEVEL = "INFO"

exceptions.py

@@ -0,0 +1,11 @@
+class SearchError(Exception):
+    """Base exception for search errors."""
+    pass
+
+class NoResultsFound(SearchError):
+    """Raised when no search results are returned."""
+    pass
+
+class SearchEngineUnavailable(SearchError):
+    """Raised when the search engine is down or unreachable."""
+    pass

requirements.txt

@@ -1,2 +1,5 @@
 gradio
-requests
+requests
+pandas
+smolagents
+duckduckgo-search

tools/web_search.py

@@ -0,0 +1,71 @@
+# search_tool.py
+
+from typing import List, Dict
+import logging
+
+from config import DUCKDUCKGO_MAX_RESULTS, DUCKDUCKGO_TIMEOUT, SEARCH_DEFAULT_ENGINE, LOG_LEVEL
+from exceptions import NoResultsFound, SearchEngineUnavailable
+
+try:
+    from duckduckgo_search import DDGS
+except ImportError as e:
+    raise ImportError("Missing dependency: install with `pip install duckduckgo-search`") from e
+
+logging.basicConfig(level=LOG_LEVEL)
+logger = logging.getLogger(__name__)
+
+
+class DuckDuckGoSearchTool:
+    """
+    Production-grade DuckDuckGo search tool.
+    Returns structured results and handles errors robustly.
+    """
+
+    def __init__(self, max_results: int = None, timeout: int = None):
+        self.max_results = max_results or DUCKDUCKGO_MAX_RESULTS
+        self.timeout = timeout or DUCKDUCKGO_TIMEOUT
+        try:
+            self.ddgs = DDGS(timeout=self.timeout)
+        except Exception as ex:
+            logger.critical("Failed to initialize DDGS: %s", ex)
+            raise SearchEngineUnavailable("Failed to initialize DuckDuckGo search engine.") from ex
+
+    def search(self, query: str) -> List[Dict]:
+        if not isinstance(query, str) or not query.strip():
+            logger.warning("Invalid search query provided: '%s'", query)
+            raise ValueError("Query must be a non-empty string.")
+        try:
+            results = self.ddgs.text(query, max_results=self.max_results)
+        except Exception as ex:
+            logger.error("Search failed: %s", ex)
+            raise SearchEngineUnavailable("DuckDuckGo search failed.") from ex
+
+        if not results:
+            logger.info("No results found for query: '%s'", query)
+            raise NoResultsFound(f"No results found for query: '{query}'")
+
+        safe_results = [self._sanitize_result(res) for res in results]
+        return safe_results
+
+    @staticmethod
+    def _sanitize_result(result: Dict) -> Dict:
+        """Sanitize user-facing fields to prevent markdown injection, etc."""
+        def escape_md(text: str) -> str:
+            # Very simple; improve as needed (real production code may need a markdown library)
+            return text.replace('[', '').replace(']', '').replace('(', '').replace(')', '')
+
+        return {
+            "title": escape_md(result.get("title", "")),
+            "link": result.get("href", ""),
+            "snippet": escape_md(result.get("body", "")),
+        }
+
+    @staticmethod
+    def format_markdown(results: List[Dict]) -> str:
+        """Format results as markdown. Keep presentation separate from core logic."""
+        if not results:
+            return "No results found."
+        lines = []
+        for res in results:
+            lines.append(f"- [{res['title']}]({res['link']})\n    {res['snippet']}")
+        return "## Search Results\n\n" + "\n\n".join(lines)