Upload 5 files

agent.py

@@ -1,36 +1,37 @@
-"""agent.py – GAIA benchmark agent using *smolagents*.
+"""GAIA benchmark agent using OpenAI Agents SDK.
 
 This module exposes:
 
 * ``gaia_agent()`` – factory returning a ready‑to‑use agent instance.
-* ``GAIAAgent``  – subclass of ``smolagents.CodeAgent``.
+* ``GAIAAgent``  – a class that wraps ``openai_agents.Agent``.
 
 The LLM backend is chosen at runtime via the ``MODEL_PROVIDER``
-environment variable (``hf`` or ``openai``) exactly like *example.py*.
+environment variable (``hf`` or ``openai``).
 """
 
 import os
-from typing import Any, Sequence
+import asyncio # Added for potential direct asyncio.run if needed, and for async def
+from typing import Any, Sequence, Callable, Union # Added Callable and Union
 
 from dotenv import load_dotenv
 
-# SmolAgents Tools
-from smolagents import (
-    CodeAgent,
-    DuckDuckGoSearchTool,
-    Tool
-)
+# OpenAI Agents SDK imports
+from openai_agents import Agent, Runner
+from openai_agents.models.openai_chat_completions import OpenAIChatCompletionsModel
+from openai_agents.extensions.models.litellm_model import LitellmModel
+# FunctionToolType could be imported if it's a public type, for now using Callable
+# from openai_agents import FunctionToolType # Example if such type exists
 
-# Custom Tools from tools.py
+# Custom Tools from tools.py (now functions)
 from tools import (
-    PythonRunTool,
-    ExcelLoaderTool,
-    YouTubeTranscriptTool,
-    AudioTranscriptionTool,
-    SimpleOCRTool,
+    python_run,
+    load_spreadsheet,
+    youtube_transcript,
+    transcribe_audio,
+    image_ocr,
+    duckduckgo_search, # Added the new tool
 )
 
- 
 # ---------------------------------------------------------------------------
 # Load the added system prompt from system_prompt.txt (located in the same directory)
 # ---------------------------------------------------------------------------
@@ -38,34 +39,38 @@ ADDED_PROMPT_PATH = os.path.join(os.path.dirname(__file__), "added_prompt.txt")
 with open(ADDED_PROMPT_PATH, "r", encoding="utf-8") as f:
     ADDED_PROMPT = f.read().strip()
 
-
 # ---------------------------------------------------------------------------
 # Model selection helper
 # ---------------------------------------------------------------------------
 
-load_dotenv()  # Make sure we read credentials from .env when running locally
+load_dotenv()  # Make sure we read credentials from .env
 
-def _select_model():
-    """Return a smolagents *model* as configured by the ``MODEL_PROVIDER`` env."""
+def _select_model() -> Union[OpenAIChatCompletionsModel, LitellmModel]:
+    """Return an OpenAI Agents SDK model instance as configured by env variables."""
 
     provider = os.getenv("MODEL_PROVIDER", "hf").lower()
+    # Ensure API keys are loaded if not directly passed to model constructors
+    # OpenAI API key is typically read by the library from OPENAI_API_KEY env var
+    # LiteLLM also often relies on environment variables for keys
 
     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
-        )
+        hf_model_id = os.getenv("HF_MODEL", "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO") # Example, ensure this is a valid LiteLLM model ID
+        # LiteLLM typically requires a prefix for HuggingFace models
+        if not hf_model_id.startswith("huggingface/"):
+            hf_model_id = f"huggingface/{hf_model_id}"
+        hf_token = os.getenv("HF_API_KEY") # LiteLLM might use this or HUGGINGFACE_API_KEY
+        # For LiteLLM, api_key parameter might be used for specific providers,
+        # but often it relies on env vars like HUGGINGFACE_API_KEY.
+        # Passing token explicitly if LitellmModel supports it, or ensuring env var is set.
+        return LitellmModel(model=hf_model_id, api_key=hf_token if hf_token else None)
+
 
     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
+        openai_token = os.getenv("OPENAI_API_KEY") # OpenAIChatCompletionsModel will use this by default if set in env
+        return OpenAIChatCompletionsModel(
+            model=openai_model_id,
+            api_key=openai_token # Explicitly passing, though often picked from env
         )
 
     raise ValueError(
@@ -77,50 +82,60 @@ def _select_model():
 # Core Agent implementation
 # ---------------------------------------------------------------------------
 
-DEFAULT_TOOLS = [
-    DuckDuckGoSearchTool(),
-    PythonRunTool(),
-    ExcelLoaderTool(),
-    YouTubeTranscriptTool(),
-    AudioTranscriptionTool(),
-    SimpleOCRTool(),
+DEFAULT_TOOLS: Sequence[Callable] = [
+    duckduckgo_search,
+    python_run,
+    load_spreadsheet,
+    youtube_transcript,
+    transcribe_audio,
+    image_ocr,
 ]
 
-class GAIAAgent(CodeAgent):
+class GAIAAgent:
     def __init__(
         self,
-        tools=None
+        tools: Sequence[Callable] | None = None
     ):
-        super().__init__(
-            tools=tools or DEFAULT_TOOLS,
-            model=_select_model()
+        self.model = _select_model()
+        self.tools = tools or DEFAULT_TOOLS
+        
+        base_system_prompt = "You are a helpful assistant designed to answer questions and complete tasks. You have access to a variety of tools to help you."
+        full_system_prompt = f"{base_system_prompt}\n\n{ADDED_PROMPT}"
+        
+        self.agent = Agent(
+            model=self.model,
+            tools=self.tools,
+            instructions=full_system_prompt,
+            name="GAIAAgent"
         )
-        # Append the additional prompt to the existing system prompt
-        self.prompt_templates["system_prompt"] += f"\n\n{ADDED_PROMPT}"
-
-    # Convenience so the object itself can be *called* directly
-    def __call__(self, question: str, **kwargs: Any) -> str:
-        steps = self.run(question, **kwargs)
-        # If steps is a primitive, just return it
-        if isinstance(steps, (int, float, str)):
-            return str(steps).strip()
-        last_step = None
-        for step in steps:
-            last_step = step
-        # Defensive: handle int/float/str directly
-        if isinstance(last_step, (int, float, str)):
-            return str(last_step).strip()
-        answer = getattr(last_step, "answer", None)
-        if answer is not None:
-            return str(answer).strip()
-        return str(last_step).strip()
+
+    async def __call__(self, question: str, **kwargs: Any) -> str:
+        """
+        Asynchronously processes a question using the agent and returns the final answer.
+        kwargs are passed to Runner.run if supported, currently ignored as per plan.
+        """
+        # As per plan, Runner.run(self.agent, question) is used.
+        # If session_id or other kwargs are needed by Runner.run, this might need adjustment.
+        response = await Runner.run(self.agent, question)
+        
+        # Extract the final output. Assuming response.final_output is the way.
+        # The type of final_output needs to be handled (e.g. if it's a message object or just text)
+        final_answer = response.final_output
+        if hasattr(final_answer, 'content'): # Example if final_output is a message object
+             final_answer_text = str(final_answer.content)
+        else:
+             final_answer_text = str(final_answer)
+             
+        return final_answer_text.strip()
 
 # ---------------------------------------------------------------------------
 # Factory helpers expected by app.py
 # ---------------------------------------------------------------------------
 
-def gaia_agent(*, extra_tools: Sequence[Tool] | None = None) -> GAIAAgent:
-    # Compose the toolset: always include all default tools, plus any extras
+def gaia_agent(*, extra_tools: Sequence[Callable] | None = None) -> GAIAAgent:
+    """
+    Factory function to create a GAIAAgent instance with default and optional extra tools.
+    """
     toolset = list(DEFAULT_TOOLS)
     if extra_tools:
         toolset.extend(extra_tools)

app.py

@@ -2,6 +2,7 @@ import os
 import gradio as gr
 import requests
 import pandas as pd
+import asyncio
 
 # --- Our Agent ---
 from agent import gaia_agent
@@ -13,10 +14,11 @@ DEBUG = os.getenv("DEBUG", "0") == "1"
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+# 2. Modified function definition to be async def
+async def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the BasicAgent on them, submits all answers,
-    and displays the results.
+    Fetches all questions, runs the GAIAAgent on them, submits all answers,
+    and displays the results. Now an async function.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
     space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
@@ -32,10 +34,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 (now using smolagents)
+    # 1. Instantiate Agent
     try:
         agent = gaia_agent()
-        print("SmolAgent instantiated successfully.")
+        print("GAIAAgent instantiated successfully.")
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -48,7 +50,9 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     import json
 
     try:
-        response = requests.get(questions_url, timeout=15)
+        # Using asyncio.to_thread to run synchronous requests.get in a separate thread
+        # to avoid blocking the asyncio event loop.
+        response = await asyncio.to_thread(requests.get, questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
@@ -57,7 +61,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         print(f"Fetched {len(questions_data)} questions.")
     except json.JSONDecodeError as e:
         print(f"Error decoding JSON response from questions endpoint: {e}")
-        print(f"Response text: {response.text[:500]}")
+        print(f"Response text: {response.text[:500]}") # type: ignore
         return f"Error decoding server response for questions: {e}", None
     except requests.exceptions.RequestException as e:
         print(f"Error fetching questions: {e}")
@@ -77,7 +81,8 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text)
+            # 3. Changed agent invocation to await agent call
+            submitted_answer = await agent(question_text)
             # --- DEBUG LOGGING ---
             if DEBUG:
                 print(f"[DEBUG] Task {task_id}: Answer type: {type(submitted_answer)}, Value: {repr(submitted_answer)}")
@@ -104,7 +109,8 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     # 5. Submit
     print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
+        # Using asyncio.to_thread for synchronous requests.post
+        response = await asyncio.to_thread(requests.post, submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
         result_data = response.json()
         final_status = (
@@ -122,7 +128,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         try:
             error_json = e.response.json()
             error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
-        except requests.exceptions.JSONDecodeError:
+        except requests.exceptions.JSONDecodeError: # Changed from requests.JSONDecodeError
             error_detail += f" Response: {e.response.text[:500]}"
         status_message = f"Submission Failed: {error_detail}"
         print(status_message)
@@ -170,6 +176,7 @@ with gr.Blocks() as demo:
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
+    # 5. Gradio's click call remains the same, it should handle async functions.
     run_button.click(
         fn=run_and_submit_all,
         outputs=[status_output, results_table]

requirements.txt

@@ -1,7 +1,7 @@
 gradio
 requests
 pandas
-smolagents[openai]
+openai-agents
 duckduckgo-search
 youtube-transcript-api
 pytesseract

tools.py

@@ -1,166 +1,131 @@
-# Custom tools for smolagents GAIA agent
+# Custom tools for OpenAI Agents
 from __future__ import annotations
+
 import contextlib
 import io
 import os
-from typing import Any, Dict, List
+from typing import Any, List, Union
+
+from openai_agents import function_tool # Using openai_agents
+import pandas as pd
+import openai
+from PIL import Image
+import pytesseract
+from duckduckgo_search import DDGS
+from urllib.parse import urlparse, parse_qs # For youtube_transcript
+from youtube_transcript_api import YouTubeTranscriptApi # For youtube_transcript, corrected import
 
-from smolagents import Tool
+# ---- 1. PythonRunTool -> python_run function ----------------------------------
+@function_tool
+def python_run(code: str) -> str:
+    """
+    Execute trusted Python code and return printed output + repr() of the last expression (or _result variable).
+
+    Args:
+        code (str): Python code to execute.
+    """
+    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()
+    # Always return a string
+    result = (out + (repr(last) if last is not None else "")).strip()
+    return str(result)
 
-# ---- 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).
+# ---- 2. ExcelLoaderTool -> load_spreadsheet function --------------------------
+@function_tool
+def load_spreadsheet(path: str, sheet: Union[str, int, None] = None) -> str:
     """
-    inputs = {
-        "code": {
-            "type": "string",
-            "description": "Python code to execute",
-            "required": True
-        }
-    }
-    output_type = "string"
+    Read .xlsx/.xls/.csv from disk and return rows as a list of dictionaries with string keys.
 
-    def forward(self, code: str) -> str:
-        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()
-        # Always return a string
-        result = (out + (repr(last) if last is not None else "")).strip()
-        return str(result)
+    Args:
+        path (str): Path to .csv/.xls/.xlsx file.
+        sheet (Union[str, int, None], optional): Sheet name or index (optional, required for Excel files only). Defaults to None.
+    """
+    if not os.path.isfile(path):
+        raise FileNotFoundError(path)
+    ext = os.path.splitext(path)[1].lower()
+    if sheet == "": # Treat empty string as None for sheet name
+        sheet = None
+    if ext == ".csv":
+        df = pd.read_csv(path)
+    else:
+        df = pd.read_excel(path, sheet_name=sheet)
+    records = [{str(k): v for k, v in row.items()} for row in df.to_dict(orient="records")]
+    # Always return a string
+    return str(records)
 
-# ---- 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.
+# ---- 3. YouTubeTranscriptTool -> youtube_transcript function ------------------
+@function_tool
+def youtube_transcript(url: str, lang: str = "en") -> str:
     """
-    inputs = {
-        "path": {
-            "type": "string",
-            "description": "Path to .csv/.xls/.xlsx file",
-            "required": True
-        },
-        "sheet": {
-            "type": "string",
-            "description": "Sheet name or index (optional, required for Excel files only)",
-            "required": False,
-            "default": "",
-            "nullable": True
-        }
-    }
-    output_type = "array"
+    Return the subtitles of a YouTube URL using youtube-transcript-api.
 
-    def forward(self, path: str, sheet: str | int | None = None) -> str:
-        import pandas as pd
-        if not os.path.isfile(path):
-            raise FileNotFoundError(path)
-        ext = os.path.splitext(path)[1].lower()
-        if sheet == "":
-            sheet = None
-        if ext == ".csv":
-            df = pd.read_csv(path)
-        else:
-            df = pd.read_excel(path, sheet_name=sheet)
-        records = [{str(k): v for k, v in row.items()} for row in df.to_dict(orient="records")]
-        # Always return a string
-        return str(records)
+    Args:
+        url (str): YouTube URL.
+        lang (str, optional): Transcript language. Defaults to "en".
+    """
+    vid = parse_qs(urlparse(url).query).get("v", [None])[0] or url.split("/")[-1]
+    # Corrected import: from youtube_transcript_api import YouTubeTranscriptApi
+    data = YouTubeTranscriptApi.get_transcript(vid, languages=[lang, "en", "en-US", "en-GB"])
+    text = " ".join(d["text"] for d in data).strip()
+    return str(text)
 
-# ---- 3. YouTubeTranscriptTool ---------------------------------------------
-class YouTubeTranscriptTool(Tool):
-    name = "youtube_transcript"
-    description = """
-        Return the subtitles of a YouTube URL using youtube-transcript-api.
+# ---- 4. AudioTranscriptionTool -> transcribe_audio function -------------------
+@function_tool
+def transcribe_audio(path: str, model: str = "whisper-1") -> str:
     """
-    inputs = {
-        "url": {
-            "type": "string",
-            "description": "YouTube URL",
-            "required": True
-        },
-        "lang": {
-            "type": "string",
-            "description": "Transcript language (default: en)",
-            "required": False,
-            "default": "en",
-            "nullable": True
-        }
-    }
-    output_type = "string"
+    Transcribe an audio file with OpenAI Whisper, returns plain text.
 
-    def forward(self, url: str, lang: str = "en") -> str:
-        from urllib.parse import urlparse, parse_qs
-        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"])
-        text = " ".join(d["text"] for d in data).strip()
-        return str(text)
+    Args:
+        path (str): Path to audio file.
+        model (str, optional): Model name for transcription. Defaults to "whisper-1".
+    """
+    if not os.path.isfile(path):
+        raise FileNotFoundError(path)
+    client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+    with open(path, "rb") as fp:
+        transcript_data = client.audio.transcriptions.create(model=model, file=fp) # Renamed to transcript_data
+    return str(transcript_data.text.strip())
 
-# ---- 4. AudioTranscriptionTool --------------------------------------------
-class AudioTranscriptionTool(Tool):
-    name = "transcribe_audio"
-    description = """
-        Transcribe an audio file with OpenAI Whisper, returns plain text."
+# ---- 5. SimpleOCRTool -> image_ocr function ------------------------------------
+@function_tool
+def image_ocr(path: str) -> str:
     """
-    inputs = {
-        "path": {
-            "type": "string",
-            "description": "Path to audio file",
-            "required": True
-        },
-        "model": {
-            "type": "string",
-            "description": "Model name for transcription (default: whisper-1)",
-            "required": False,
-            "default": "whisper-1",
-            "nullable": True
-        }
-    }
-    output_type = "string"
+    Return any text spotted in an image via pytesseract OCR.
 
-    def forward(self, path: str, model: str = "whisper-1") -> str:
-        import openai
-        if not os.path.isfile(path):
-            raise FileNotFoundError(path)
-        client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-        with open(path, "rb") as fp:
-            transcript = client.audio.transcriptions.create(model=model, file=fp)
-        return str(transcript.text.strip())
+    Args:
+        path (str): Path to image file.
+    """
+    if not os.path.isfile(path):
+        raise FileNotFoundError(path)
+    return str(pytesseract.image_to_string(Image.open(path)).strip())
 
-# ---- 5. SimpleOCRTool ------------------------------------------------------
-class SimpleOCRTool(Tool):
-    name = "image_ocr"
-    description = """
-        Return any text spotted in an image via pytesseract OCR.
+# ---- 6. New DuckDuckGo Search Tool ---------------------------------------------
+@function_tool
+def duckduckgo_search(query: str) -> str:
     """
-    inputs = {
-        "path": {
-            "type": "string",
-            "description": "Path to image file",
-            "required": True
-        }
-    }
-    output_type = "string"
+    Searches the web using DuckDuckGo and returns a summary of results.
 
-    def forward(self, path: str) -> str:
-        from PIL import Image
-        import pytesseract
-        if not os.path.isfile(path):
-            raise FileNotFoundError(path)
-        return str(pytesseract.image_to_string(Image.open(path)).strip())
+    Args:
+        query (str): The search query.
+    """
+    with DDGS() as ddgs:
+        results = ddgs.text(query, max_results=5) # Get top 5 results
+        summary = "\n".join([f"{r['title']}: {r['body']}" for r in results]) if results else "No results found."
+    return summary
 
 # ---------------------------------------------------------------------------
 __all__ = [
-    "PythonRunTool",
-    "ExcelLoaderTool",
-    "YouTubeTranscriptTool",
-    "AudioTranscriptionTool",
-    "SimpleOCRTool",
+    "python_run",
+    "load_spreadsheet",
+    "youtube_transcript",
+    "transcribe_audio",
+    "image_ocr",
+    "duckduckgo_search",
 ]