Upload 4 files

agent.py

@@ -1,88 +1,101 @@
-"""
-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"]
+"""agent.py – GAIA benchmark agent using *smolagents*.
+
+This module exposes:
+
+* ``gaia_agent()`` – factory returning a ready‑to‑use agent instance.
+* ``GAIAAgent``  – subclass of ``smolagents.CodeAgent``.
+
+The LLM backend is chosen at runtime via the ``MODEL_PROVIDER``
+environment variable (``hf`` or ``openai``) exactly like *example.py*.
+"""
+
+import os
+from typing import Any, Sequence
+
+from dotenv import load_dotenv
+
+# SmolAgents Tools
+from smolagents import (
+    CodeAgent,
+    DuckDuckGoSearchTool,
+    Tool,
+)
+
+# Custom Tools
+from .tools import (PythonRunTool, ExcelLoaderTool, YouTubeTranscriptTool,
+                    AudioTranscriptionTool, SimpleOCRTool)
+
+# ---------------------------------------------------------------------------
+# Model selection helper
+# ---------------------------------------------------------------------------
+
+load_dotenv()  # Make sure we read credentials from .env when running locally
+
+
+def _select_model():
+    """Return a smolagents *model* as configured by the ``MODEL_PROVIDER`` env."""
+
+    provider = os.getenv("MODEL_PROVIDER", "hf").lower()
+
+    if provider == "hf":
+        from smolagents import InferenceClientModel
+        hf_model_id = os.getenv("HF_MODEL", "HuggingFaceH4/zephyr-7b-beta")
+        hf_token = os.getenv("HF_API_KEY")
+        return InferenceClientModel(model_id=hf_model_id, token=hf_token)
+
+    if provider == "openai":
+        from smolagents import OpenAIServerModel
+        openai_model_id = os.getenv("OPENAI_MODEL", "gpt-3.5-turbo")
+        openai_token = os.getenv("OPENAI_API_KEY")
+        return OpenAIServerModel(model_id=openai_model_id, api_key=openai_token)
+
+    raise ValueError(
+        f"Unsupported MODEL_PROVIDER: {provider!r}. "
+        "Use 'hf' (default) or 'openai'."
+    )
+
+# ---------------------------------------------------------------------------
+# Core Agent implementation
+# ---------------------------------------------------------------------------
+
+DEFAULT_TOOLS = [
+    DuckDuckGoSearchTool(),
+    PythonRunTool(),
+    ExcelLoaderTool(),
+    YouTubeTranscriptTool(),
+    AudioTranscriptionTool(),
+    SimpleOCRTool(),
+]
+
+class GAIAAgent(CodeAgent):
+    def __init__(self, tools=None):
+        super().__init__(tools=tools or DEFAULT_TOOLS, model=_select_model())
+
+    # Convenience so the object itself can be *called* directly
+    def __call__(self, question: str, **kwargs: Any) -> str:
+        steps = self.run(question, **kwargs)
+        last_step = None
+        for step in steps:
+            last_step = step
+        # If last_step is a FinalAnswerStep with .answer, return it
+        answer = getattr(last_step, "answer", None)
+        if answer is not None:
+            return str(answer)
+        return str(last_step)
+
+# ---------------------------------------------------------------------------
+# Factory helpers expected by app.py
+# ---------------------------------------------------------------------------
+
+def gaia_agent(*, extra_tools: Sequence[Tool] | None = None) -> GAIAAgent:
+    base_tools = [
+        DuckDuckGoSearchTool(),
+        CustomTool1(),
+        CustomTool2(),
+    ]
+    if extra_tools:
+        base_tools.extend(extra_tools)
+    return GAIAAgent(tools=base_tools)
+
+
+__all__ = ["GAIAAgent", "gaia_agent"]

app.py

@@ -1,11 +1,10 @@
 import os
 import gradio as gr
 import requests
-import inspect
 import pandas as pd
 
 # --- Our Agent ---
-from agent import my_agent
+from agent import gaia_agent
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -33,7 +32,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent (now using smolagents)
     try:
-        agent = my_agent()
+        agent = gaia_agent()
         print("SmolAgent instantiated successfully.")
     except Exception as e:
         print(f"Error instantiating agent: {e}")

requirements.txt

@@ -1,5 +1,8 @@
 gradio
 requests
 pandas
-smolagents
-duckduckgo-search
+smolagents[openai]
+duckduckgo-search
+youtube-transcript-api
+pytesseract
+pillow

tools.py

@@ -0,0 +1,104 @@
+# Custom tools for smolagents GAIA agent
+from __future__ import annotations
+import contextlib
+import io
+import os
+from typing import Any, Dict, List, Hashable
+
+from smolagents import Tool
+
+# ---- 1. PythonRunTool ------------------------------------------------------
+class PythonRunTool(Tool):
+    name = "python_run"
+    description = (
+        "Execute trusted Python code and return printed output "
+        "+ repr() of the last expression (or _result variable)."
+    )
+
+    def forward(self, code: str) -> str:  # type: ignore[override]
+        buf, ns = io.StringIO(), {}
+        last = None
+        try:
+            with contextlib.redirect_stdout(buf):
+                exec(compile(code, "<agent-python>", "exec"), {}, ns)
+            last = ns.get("_result", None)
+        except Exception as e:
+            raise RuntimeError(f"PythonRunTool error: {e}") from e
+        out = buf.getvalue()
+        return (out + (repr(last) if last is not None else "")).strip()
+
+# ---- 2. ExcelLoaderTool ----------------------------------------------------
+class ExcelLoaderTool(Tool):
+    name = "load_spreadsheet"
+    description = (
+        "Read .xlsx/.xls/.csv from disk and return "
+        "rows as a list of dictionaries with string keys."
+    )
+
+    def forward(self, path: str, sheet: str | int | None = None) -> List[Dict[str, Any]]:  # type: ignore[override]
+        import pandas as pd
+        if not os.path.isfile(path):
+            raise FileNotFoundError(path)
+        ext = os.path.splitext(path)[1].lower()
+        if ext == ".csv":
+            df = pd.read_csv(path)
+        else:
+            df = pd.read_excel(path, sheet_name=sheet)
+        # Ensure all keys are str for type safety
+        records = [{str(k): v for k, v in row.items()} for row in df.to_dict(orient="records")]
+        return records
+
+# ---- 3. YouTubeTranscriptTool ---------------------------------------------
+class YouTubeTranscriptTool(Tool):
+    name = "youtube_transcript"
+    description = "Return the subtitles of a YouTube URL using youtube-transcript-api."
+
+    def forward(self, url: str, lang: str = "en") -> str:  # type: ignore[override]
+        from urllib.parse import urlparse, parse_qs
+        # Per Pylance, import from private API
+        from youtube_transcript_api._api import YouTubeTranscriptApi
+        vid = parse_qs(urlparse(url).query).get("v", [None])[0] or url.split("/")[-1]
+        data = YouTubeTranscriptApi.get_transcript(vid, languages=[lang, "en", "en-US", "en-GB"])
+        return " ".join(d["text"] for d in data).strip()
+
+# ---- 4. AudioTranscriptionTool --------------------------------------------
+class AudioTranscriptionTool(Tool):
+    name = "transcribe_audio"
+    description = "Transcribe an audio file with OpenAI Whisper, returns plain text."
+
+    def forward(self, path: str, model: str = "whisper-1") -> str:  # type: ignore[override]
+        import openai
+        import os
+        if not os.path.isfile(path):
+            raise FileNotFoundError(path)
+        openai.api_key = os.getenv("OPENAI_API_KEY")
+        # Version/API guard for openai.Audio
+        if not hasattr(openai, "Audio"):
+            raise ImportError(
+                "Your OpenAI package does not support Audio. "
+                "Please upgrade it with: pip install --upgrade openai"
+            )
+        with open(path, "rb") as fp:
+            # type: ignore[attr-defined]
+            return openai.Audio.transcribe(model=model, file=fp)["text"].strip()
+
+# ---- 5. SimpleOCRTool ------------------------------------------------------
+class SimpleOCRTool(Tool):
+    name = "image_ocr"
+    description = "Return any text spotted in an image via pytesseract OCR."
+
+    def forward(self, path: str) -> str:  # type: ignore[override]
+        from PIL import Image
+        import pytesseract
+        if not os.path.isfile(path):
+            raise FileNotFoundError(path)
+        return pytesseract.image_to_string(Image.open(path)).strip()
+
+# ---------------------------------------------------------------------------
+__all__ = [
+    "PythonRunTool",
+    "ExcelLoaderTool",
+    "YouTubeTranscriptTool",
+    "AudioTranscriptionTool",
+    "SimpleOCRTool",
+]