Upload 5 files

agent.py

@@ -1,144 +1,104 @@
-"""GAIA benchmark agent using OpenAI Agents SDK.
-
-This module exposes:
-
-* ``gaia_agent()`` – factory returning a ready‑to‑use agent instance.
-* ``GAIAAgent``  – a class that wraps ``openai_agents.Agent``.
-
-The LLM backend is chosen at runtime via the ``MODEL_PROVIDER``
-environment variable (``hf`` or ``openai``).
 """
+GAIA benchmark agent using the OpenAI Agents SDK.
+"""
+
+from __future__ import annotations
 
+import asyncio
 import os
-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 typing import Any, Sequence, Callable, List
 
 from dotenv import load_dotenv
+from agents import Agent, Runner, FunctionTool, 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 (now functions)
+# Import all function tools
 from tools import (
     python_run,
     load_spreadsheet,
     youtube_transcript,
     transcribe_audio,
     image_ocr,
-    duckduckgo_search, # Added the new tool
+    duckduckgo_search,
 )
 
 # ---------------------------------------------------------------------------
-# Load the added system prompt from system_prompt.txt (located in the same directory)
+# Load the added system prompt
 # ---------------------------------------------------------------------------
 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()
 
-load_dotenv()  # Make sure we read credentials from .env
-
-def _select_model() -> Union[OpenAIChatCompletionsModel, LitellmModel]:
-    """Return an OpenAI Agents SDK model instance as configured by env variables."""
 
+def _select_model() -> str:
+    """Return a model identifier appropriate for the Agents SDK based on environment settings."""
     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":
-        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":
-        openai_model_id = os.getenv("OPENAI_MODEL", "gpt-3.5-turbo")
-        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
-        )
+        model_name = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+        return f"openai/{model_name}"
+
+    if provider == "hf":
+        hf_model_id = os.getenv("HF_MODEL", "Qwen/Qwen2.5-Coder-32B-Instruct")
+        return f"litellm/huggingface/{hf_model_id}"
 
     raise ValueError(
-        f"Unsupported MODEL_PROVIDER: {provider!r}. "
-        "Use 'hf' (default) or 'openai'."
+        f"Unsupported MODEL_PROVIDER: {provider!r}. Expected 'openai' or 'hf'."
     )
 
-# ---------------------------------------------------------------------------
-# Core Agent implementation
-# ---------------------------------------------------------------------------
 
-DEFAULT_TOOLS: Sequence[Callable] = [
-    duckduckgo_search,
+DEFAULT_TOOLS: List[FunctionTool] = [
     python_run,
     load_spreadsheet,
     youtube_transcript,
     transcribe_audio,
     image_ocr,
+    duckduckgo_search,
 ]
 
+
+def _build_agent(extra_tools: Sequence[FunctionTool] | None = None) -> Agent:
+    """Construct the underlying Agents SDK `Agent` instance."""
+    instructions = (
+        "You are a helpful assistant tasked with answering questions using the available tools.\n\n"
+        + ADDED_PROMPT
+    )
+
+    tools: Sequence[Tool] = list(DEFAULT_TOOLS)
+    if extra_tools:
+        tools = list(tools) + list(extra_tools)
+
+    return Agent(
+        name="GAIA Agent",
+        instructions=instructions,
+        tools=tools,
+        model=_select_model(),
+    )
+
+
 class GAIAAgent:
-    def __init__(
-        self,
-        tools: Sequence[Callable] | None = None
-    ):
-        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"
-        )
-
-    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)
+    """Thin synchronous wrapper around an asynchronous Agents SDK agent."""
+
+    def __init__(self, *, extra_tools: Sequence[FunctionTool] | None = None):
+        self._agent = _build_agent(extra_tools=extra_tools)
+
+    async def _arun(self, question: str) -> str:
+        result = await Runner.run(self._agent, question)
+        return str(result.final_output).strip()
+
+    def __call__(self, question: str, **kwargs: Any) -> str:
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.run(self._arun(question))
         else:
-             final_answer_text = str(final_answer)
-             
-        return final_answer_text.strip()
+            return loop.run_until_complete(self._arun(question))
 
-# ---------------------------------------------------------------------------
-# Factory helpers expected by app.py
-# ---------------------------------------------------------------------------
 
-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)
-    return GAIAAgent(tools=toolset)
+def gaia_agent(*, extra_tools: Sequence[FunctionTool] | None = None) -> GAIAAgent:
+    """Factory returning a ready‑to‑use GAIAAgent instance."""
+    return GAIAAgent(extra_tools=extra_tools)
+
 
 __all__ = ["GAIAAgent", "gaia_agent"]

app.py

@@ -2,7 +2,6 @@ import os
 import gradio as gr
 import requests
 import pandas as pd
-import asyncio
 
 # --- Our Agent ---
 from agent import gaia_agent
@@ -14,11 +13,10 @@ DEBUG = os.getenv("DEBUG", "0") == "1"
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# 2. Modified function definition to be async def
-async def run_and_submit_all( profile: gr.OAuthProfile | None):
+def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the GAIAAgent on them, submits all answers,
-    and displays the results. Now an async function.
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    and displays the results.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
     space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
@@ -34,10 +32,10 @@ async def run_and_submit_all( profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent
+    # 1. Instantiate Agent (now using OpenAI Agents SDK)
     try:
         agent = gaia_agent()
-        print("GAIAAgent instantiated successfully.")
+        print("OpenAI Agent instantiated successfully.")
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -50,9 +48,7 @@ async def run_and_submit_all( profile: gr.OAuthProfile | None):
     import json
 
     try:
-        # 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 = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
@@ -61,7 +57,7 @@ async 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]}") # type: ignore
+        print(f"Response text: {response.text[:500]}")
         return f"Error decoding server response for questions: {e}", None
     except requests.exceptions.RequestException as e:
         print(f"Error fetching questions: {e}")
@@ -81,8 +77,7 @@ async def run_and_submit_all( profile: gr.OAuthProfile | None):
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            # 3. Changed agent invocation to await agent call
-            submitted_answer = await agent(question_text)
+            submitted_answer = agent(question_text)
             # --- DEBUG LOGGING ---
             if DEBUG:
                 print(f"[DEBUG] Task {task_id}: Answer type: {type(submitted_answer)}, Value: {repr(submitted_answer)}")
@@ -109,8 +104,7 @@ async def run_and_submit_all( profile: gr.OAuthProfile | None):
     # 5. Submit
     print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
-        # Using asyncio.to_thread for synchronous requests.post
-        response = await asyncio.to_thread(requests.post, submit_url, json=submission_data, timeout=60)
+        response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
         result_data = response.json()
         final_status = (
@@ -128,7 +122,7 @@ async 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: # Changed from requests.JSONDecodeError
+        except requests.exceptions.JSONDecodeError:
             error_detail += f" Response: {e.response.text[:500]}"
         status_message = f"Submission Failed: {error_detail}"
         print(status_message)
@@ -176,7 +170,6 @@ 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,8 +1,10 @@
 gradio
 requests
 pandas
-openai-agents
+openai-agents[litellm]
+openai>=1.3
 duckduckgo-search
 youtube-transcript-api
 pytesseract
-pillow
+pillow
+python-dotenv

tools.py

@@ -1,131 +1,142 @@
-# Custom tools for OpenAI Agents
+"""
+Custom function tools for OpenAI Agents SDK GAIA agent.
+"""
+
 from __future__ import annotations
 
 import contextlib
 import io
 import os
-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
-
-# ---- 1. PythonRunTool -> python_run function ----------------------------------
+from typing import List, Dict
+
+from agents import function_tool
+
+# 1. --------------------------------------------------------------------
 @function_tool
 def python_run(code: str) -> str:
-    """
-    Execute trusted Python code and return printed output + repr() of the last expression (or _result variable).
+    """Execute trusted Python code and return the captured stdout together with
+    the repr() of the last expression (or `_result` variable if set).
 
     Args:
-        code (str): Python code to execute.
+        code: Python code to execute.
     """
-    buf, ns = io.StringIO(), {}
+    buf = io.StringIO()
+    ns: dict = {}
     last = None
     try:
         with contextlib.redirect_stdout(buf):
             exec(compile(code, "<agent-python>", "exec"), {}, ns)
-        last = ns.get("_result", None)
+        last = ns.get("_result")
     except Exception as e:
-        raise RuntimeError(f"PythonRunTool error: {e}") from e
+        raise RuntimeError(f"python_run 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)
+    return (out + (repr(last) if last is not None else "")).strip()
+
 
-# ---- 2. ExcelLoaderTool -> load_spreadsheet function --------------------------
+# 2. --------------------------------------------------------------------
 @function_tool
-def load_spreadsheet(path: str, sheet: Union[str, int, None] = None) -> str:
-    """
-    Read .xlsx/.xls/.csv from disk and return rows as a list of dictionaries with string keys.
+def load_spreadsheet(path: str, sheet: str | int | None = None) -> list[Dict[str, str]]:
+    """Read .csv, .xls or .xlsx from disk and return rows as list of dictionaries.
 
     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.
+        path: Path to spreadsheet file.
+        sheet: Sheet name or index (for Excel files only).
     """
+    import pandas as pd
+
     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)
+        dfs = [df]
     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)
+        sheets = pd.read_excel(path, sheet_name=sheet if sheet not in ("", None) else None)
+        if isinstance(sheets, dict):
+            dfs = sheets.values()
+        else:
+            dfs = [sheets]
+    results = []
+    for df in dfs:
+        results.extend([{str(k): v for k, v in row.items()} for row in df.to_dict(orient="records")])
+    return results
+
 
-# ---- 3. YouTubeTranscriptTool -> youtube_transcript function ------------------
+# 3. --------------------------------------------------------------------
 @function_tool
 def youtube_transcript(url: str, lang: str = "en") -> str:
-    """
-    Return the subtitles of a YouTube URL using youtube-transcript-api.
+    """Fetch the subtitles of a YouTube video.
 
     Args:
-        url (str): YouTube URL.
-        lang (str, optional): Transcript language. Defaults to "en".
+        url: YouTube video URL.
+        lang: Preferred transcript language code (default "en").
     """
+    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]
-    # 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)
+    data = YouTubeTranscriptApi.get_transcript(
+        vid, languages=[lang, "en", "en-US", "en-GB"]
+    )
+    return " ".join(chunk["text"] for chunk in data).strip()
 
-# ---- 4. AudioTranscriptionTool -> transcribe_audio function -------------------
+
+# 4. --------------------------------------------------------------------
 @function_tool
 def transcribe_audio(path: str, model: str = "whisper-1") -> str:
-    """
-    Transcribe an audio file with OpenAI Whisper, returns plain text.
+    """Transcribe an audio file using OpenAI Whisper.
 
     Args:
-        path (str): Path to audio file.
-        model (str, optional): Model name for transcription. Defaults to "whisper-1".
+        path: Path to audio file (wav / mp3 / m4a / etc.).
+        model: Whisper model name (default "whisper-1").
     """
+    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_data = client.audio.transcriptions.create(model=model, file=fp) # Renamed to transcript_data
-    return str(transcript_data.text.strip())
+        transcript = client.audio.transcriptions.create(model=model, file=fp)
+    return transcript.text.strip()
+
 
-# ---- 5. SimpleOCRTool -> image_ocr function ------------------------------------
+# 5. --------------------------------------------------------------------
 @function_tool
 def image_ocr(path: str) -> str:
-    """
-    Return any text spotted in an image via pytesseract OCR.
+    """Perform OCR on an image using Tesseract.
 
     Args:
-        path (str): Path to image file.
+        path: Path to image file.
     """
+    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())
+    return pytesseract.image_to_string(Image.open(path)).strip()
+
 
-# ---- 6. New DuckDuckGo Search Tool ---------------------------------------------
+# 6. --------------------------------------------------------------------
 @function_tool
-def duckduckgo_search(query: str) -> str:
-    """
-    Searches the web using DuckDuckGo and returns a summary of results.
+def duckduckgo_search(query: str, max_results: int = 5) -> List[Dict[str, str]]:
+    """Search DuckDuckGo and return a list of result dicts with title, href and body.
 
     Args:
-        query (str): The search query.
+        query: The search query.
+        max_results: Maximum results to return (default 5).
     """
+    from duckduckgo_search import DDGS
+
+    results = []
     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__ = [
-    "python_run",
-    "load_spreadsheet",
-    "youtube_transcript",
-    "transcribe_audio",
-    "image_ocr",
-    "duckduckgo_search",
-]
+        for r in ddgs.text(query, max_results=max_results):
+            results.append(
+                {
+                    "title": r.get("title", ""),
+                    "href": r.get("href", ""),
+                    "body": r.get("body", ""),
+                }
+            )
+    return results