Implement LangGraphAgent and enhance BasicAgent functionality; update requirements and add .env configuration

.env

@@ -0,0 +1,2 @@
+OPENROUTER_API_KEY=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
+OPENROUTER_API_URL=https://openrouter.ai/api/v1

agent.py

@@ -0,0 +1,111 @@
+import os
+from typing import Optional
+
+from langgraph.graph import StateGraph, START, END, MessagesState
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+from langgraph.prebuilt import ToolNode  # add
+
+# Try to import tools from tools.py
+try:
+    from .tools import get_tools as _get_tools  # package-style
+except Exception:
+    try:
+        from tools import get_tools as _get_tools  # script-style
+    except Exception:
+        def _get_tools(): return []  # fallback
+
+try:
+    # Optional, used when OPENAI_API_KEY is available
+    from langchain_openai import ChatOpenAI
+except Exception:  # pragma: no cover - optional dependency resolution
+    ChatOpenAI = None  # type: ignore
+
+
+class _EchoModel:
+    """Simple stub model used when no API key / model is configured."""
+
+    def __init__(self, prefix: str = "[stub]"):
+        self.prefix = prefix
+
+    def invoke(self, messages):
+        last = messages[-1]
+        content = getattr(last, "content", str(last))
+        # Ensure the contract: always emit FINAL ANSWER:
+        return AIMessage(content=f"{self.prefix} FINAL ANSWER: You asked: {content}")
+
+
+class LangGraphAgent:
+    """
+    Minimal LangGraph agent template.
+
+    Usage:
+        agent = LangGraphAgent()
+        answer = agent("What is the capital of France?")
+    """
+
+    def __init__(self, *, model: Optional[object] = None, system_prompt: Optional[str] = None):
+        # Guide the model to use tools and to output a clear final answer.
+        base_prompt = system_prompt or "You are a helpful assistant. Keep answers concise."
+        self.system_prompt = (
+            base_prompt
+            + "\n\nGuidelines:\n"
+              "- Use tools when they can verify facts or fetch fresh data.\n"
+              "- Think privately; do not reveal chain-of-thought.\n"
+              "- Provide the final user-facing result prefixed exactly with 'FINAL ANSWER:'."
+        )
+
+        # Choose an LLM if not provided
+        if model is None:
+            if ChatOpenAI is not None:
+                model = ChatOpenAI(
+                    api_key=os.getenv("OPENROUTER_API_KEY"),
+                    base_url=os.getenv("OPENROUTER_BASE_URL"),
+                    model="openai/gpt-oss-20b:free",
+                )
+            else:
+                model = _EchoModel()
+        self.model = model
+
+        # Load tools and bind to the model if supported
+        self.tools = _get_tools()
+        self.llm = getattr(self.model, "bind_tools",
+                           lambda _: self.model)(self.tools)
+
+        # Build a tool-using LangGraph: agent -> (maybe) tools -> agent -> ... -> END
+        def call_agent(state: MessagesState):
+            msgs = [SystemMessage(content=self.system_prompt)
+                    ] + list(state["messages"])
+            ai = self.llm.invoke(msgs)
+            return {"messages": [ai]}
+
+        def should_call_tools(state: MessagesState):
+            # If the last AI message includes tool calls, route to tools; else end.
+            last = state["messages"][-1]
+            if isinstance(last, AIMessage) and getattr(last, "tool_calls", None):
+                return "tools"
+            return "end"
+
+        builder = StateGraph(MessagesState)
+        builder.add_node("agent", call_agent)
+        builder.add_node("tools", ToolNode(self.tools))
+        builder.add_edge(START, "agent")
+        builder.add_edge("tools", "agent")
+        builder.add_conditional_edges("agent", should_call_tools, {
+                                      "tools": "tools", "end": END})
+        self.graph = builder.compile()
+
+    @staticmethod
+    def _extract_final_answer(text: str) -> str:
+        key = "FINAL ANSWER:"
+        idx = text.rfind(key)
+        return text[idx + len(key):].strip() if idx != -1 else text.strip()
+
+    def __call__(self, question: str) -> str:
+        state = {"messages": [HumanMessage(content=question)]}
+        result = self.graph.invoke(state)
+        messages = result.get("messages", [])
+        # Return only the content after "FINAL ANSWER:"
+        for msg in reversed(messages):
+            if isinstance(msg, AIMessage):
+                return self._extract_final_answer(msg.content)
+        return self._extract_final_answer(messages[-1].content) if messages else ""

app.py

@@ -10,25 +10,37 @@ 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.")
+        from agent import LangGraphAgent
+        print("BasicAgent initialized (LangGraph).")
+        # Create a minimal LangGraph agent; will use OPENAI_API_KEY if set, else a stub echo
+        self._agent = LangGraphAgent()
+
     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
+        try:
+            answer = self._agent(question)
+        except Exception as e:
+            print(f"LangGraph agent error: {e}")
+            answer = "Sorry, the agent hit a snag."
+        print(f"Agent returning answer (first 80 chars): {answer[:80]}...")
+        return answer
+
 
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     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
+    # Get the SPACE_ID for sending link to the code
+    space_id = os.getenv("SPACE_ID")
 
     if profile:
-        username= f"{profile.username}"
+        username = f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -55,16 +67,16 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-             print("Fetched questions list is empty.")
-             return "Fetched questions list is empty or invalid format.", None
+            print("Fetched questions list is empty.")
+            return "Fetched questions list is empty or invalid format.", None
         print(f"Fetched {len(questions_data)} questions.")
     except requests.exceptions.RequestException as e:
         print(f"Error fetching questions: {e}")
         return f"Error fetching questions: {e}", None
     except requests.exceptions.JSONDecodeError as e:
-         print(f"Error decoding JSON response from questions endpoint: {e}")
-         print(f"Response text: {response.text[:500]}")
-         return f"Error decoding server response for questions: {e}", None
+        print(f"Error decoding JSON response from questions endpoint: {e}")
+        print(f"Response text: {response.text[:500]}")
+        return f"Error decoding server response for questions: {e}", None
     except Exception as e:
         print(f"An unexpected error occurred fetching questions: {e}")
         return f"An unexpected error occurred fetching questions: {e}", None
@@ -81,18 +93,22 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             continue
         try:
             submitted_answer = agent(question_text)
-            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
+            answers_payload.append(
+                {"task_id": task_id, "submitted_answer": submitted_answer})
+            results_log.append(
+                {"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
         except Exception as e:
-             print(f"Error running agent on task {task_id}: {e}")
-             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+            print(f"Error running agent on task {task_id}: {e}")
+            results_log.append(
+                {"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
 
     if not answers_payload:
         print("Agent did not produce any answers to submit.")
         return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
-    # 4. Prepare Submission 
-    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    # 4. Prepare Submission
+    submission_data = {"username": username.strip(
+    ), "agent_code": agent_code, "answers": answers_payload}
     status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
     print(status_update)
 
@@ -162,9 +178,11 @@ with gr.Blocks() as demo:
 
     run_button = gr.Button("Run Evaluation & Submit All Answers")
 
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    status_output = gr.Textbox(
+        label="Run Status / Submission Result", lines=5, interactive=False)
     # Removed max_rows=10 from DataFrame constructor
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+    results_table = gr.DataFrame(
+        label="Questions and Agent Answers", wrap=True)
 
     run_button.click(
         fn=run_and_submit_all,
@@ -175,22 +193,24 @@ if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)
     # Check for SPACE_HOST and SPACE_ID at startup for information
     space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+    space_id_startup = os.getenv("SPACE_ID")  # Get SPACE_ID at startup
 
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
-        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+        print(
+            f"   Runtime URL should be: https://{space_host_startup}.hf.space")
     else:
         print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    if space_id_startup: # Print repo URLs if SPACE_ID is found
+    if space_id_startup:  # Print repo URLs if SPACE_ID is found
         print(f"✅ SPACE_ID found: {space_id_startup}")
         print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
-        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+        print(
+            f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
     else:
         print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
 
     print("-"*(60 + len(" App Starting ")) + "\n")
 
     print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=False)

prompt.py

@@ -0,0 +1,9 @@
+# GAIA system prompt
+system_prompt = """\
+You are a general AI assistant.
+I will ask you a question. Report your thoughts, and finish your answer with the following template: FINAL ANSWER: [YOUR FINAL ANSWER]. 
+YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings.
+If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise.
+If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise.
+If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
+"""

requirements.txt

@@ -1,2 +1,7 @@
 gradio
-requests
+requests
+pandas
+langgraph
+langchain-core
+langchain-openai
+openai

tools.py

@@ -0,0 +1,273 @@
+import os
+from langchain_community.tools import Tool, BraveSearch, YouTubeSearchTool, ExtractTextTool
+from langchain_community.tools import DuckDuckGoSearchResults, GoogleSearchResults
+from langchain_community.tools import WikipediaQueryRun
+from langchain_community.tools import WolframAlphaQueryRun
+from typing import Any, Dict, List, Optional
+import json
+import re
+from datetime import datetime, timedelta
+
+# Structured tools
+try:
+    from langchain_core.tools import tool
+except Exception:
+    def tool(*args, **kwargs):
+        def _wrap(fn): return fn
+        return _wrap
+
+# Optional deps
+try:
+    from youtube_transcript_api import (
+        YouTubeTranscriptApi,
+        TranscriptsDisabled,
+        NoTranscriptFound,
+    )
+except Exception:
+    YouTubeTranscriptApi = None  # type: ignore
+    TranscriptsDisabled = Exception  # type: ignore
+    NoTranscriptFound = Exception  # type: ignore
+
+try:
+    from dateutil import parser as date_parser
+    from dateutil.relativedelta import relativedelta
+except Exception:
+    date_parser = None  # type: ignore
+    relativedelta = None  # type: ignore
+
+try:
+    from zoneinfo import ZoneInfo  # py>=3.9
+except Exception:
+    ZoneInfo = None  # type: ignore
+
+
+def _parse_video_id(url_or_id: str) -> Optional[str]:
+    s = (url_or_id or "").strip()
+    if re.fullmatch(r"[0-9A-Za-z_-]{11}", s):
+        return s
+    try:
+        from urllib.parse import urlparse, parse_qs
+        u = urlparse(s)
+        if u.netloc.endswith(("youtube.com", "m.youtube.com", "music.youtube.com")):
+            qs = parse_qs(u.query)
+            v = (qs.get("v") or [""])[0]
+            if re.fullmatch(r"[0-9A-Za-z_-]{11}", v):
+                return v
+        if u.netloc.endswith("youtu.be"):
+            vid = u.path.lstrip("/").split("/")[0]
+            if re.fullmatch(r"[0-9A-Za-z_-]{11}", vid):
+                return vid
+    except Exception:
+        pass
+    return None
+
+
+def _to_dt(value: str, tz: Optional[str] = None) -> datetime:
+    if date_parser is not None:
+        dt = date_parser.parse(value)
+    else:
+        try:
+            dt = datetime.fromisoformat(value)
+        except Exception:
+            dt = datetime.strptime(value, "%Y-%m-%d")
+    if tz and ZoneInfo is not None:
+        try:
+            z = ZoneInfo(tz)
+            dt = dt.replace(
+                tzinfo=z) if dt.tzinfo is None else dt.astimezone(z)
+        except Exception:
+            pass
+    return dt
+
+
+@tool("youtube_transcript", return_direct=False)
+def youtube_transcript(video: str, languages: Optional[List[str]] = None, max_chars: int = 8000) -> Dict[str, Any]:
+    """
+    Get YouTube transcript for a video URL or ID.
+    Params:
+      - video: URL or 11-char video ID
+      - languages: preferred languages, e.g. ["vi","en"]
+      - max_chars: truncate long transcripts
+    """
+    if YouTubeTranscriptApi is None:
+        return {"ok": False, "error": "youtube-transcript-api not installed. pip install youtube-transcript-api"}
+    vid = _parse_video_id(video)
+    if not vid:
+        return {"ok": False, "error": "Invalid YouTube video id/url."}
+    langs = languages or ["vi", "en"]
+    try:
+        segs = None
+        try:
+            segs = YouTubeTranscriptApi.get_transcript(vid, languages=langs)
+        except NoTranscriptFound:
+            try:
+                segs = YouTubeTranscriptApi.get_transcript(
+                    vid, languages=["en"])
+            except Exception:
+                pass
+        if not segs:
+            try:
+                tx = YouTubeTranscriptApi.list_transcripts(vid)
+                for tr in tx:
+                    if tr.is_translatable and "en" in langs:
+                        segs = tr.translate("en").fetch()
+                        break
+            except Exception:
+                pass
+        if not segs:
+            return {"ok": False, "error": "No transcript available."}
+        text = " ".join(s.get("text", "") for s in segs).strip()
+        if max_chars and len(text) > max_chars:
+            text = text[:max_chars] + " ...[truncated]..."
+        return {"ok": True, "data": {"video_id": vid, "text": text, "segments": segs}}
+    except TranscriptsDisabled:
+        return {"ok": False, "error": "Transcripts are disabled for this video."}
+    except Exception as e:
+        return {"ok": False, "error": f"Transcript fetch failed: {e}"}
+
+
+@tool("date_today", return_direct=False)
+def date_today(tz: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Return today's datetime fields.
+    """
+    now = datetime.now(
+        ZoneInfo(tz)) if tz and ZoneInfo is not None else datetime.now()
+    return {"ok": True, "data": {"iso": now.isoformat(), "date": now.date().isoformat(), "time": now.time().isoformat(timespec="seconds")}}
+
+
+@tool("date_parse", return_direct=False)
+def date_parse(date_str: str, tz: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Parse a date/time string into ISO fields.
+    """
+    try:
+        dt = _to_dt(date_str, tz)
+        return {"ok": True, "data": {"iso": dt.isoformat(), "date": dt.date().isoformat(), "time": dt.time().isoformat(timespec="seconds")}}
+    except Exception as e:
+        return {"ok": False, "error": f"Parse failed: {e}"}
+
+
+@tool("date_add", return_direct=False)
+def date_add(date_str: str, days: int = 0, months: int = 0, years: int = 0, tz: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Add/subtract days/months/years to a date/time.
+    """
+    try:
+        dt = _to_dt(date_str, tz)
+        if relativedelta is not None:
+            dt2 = dt + relativedelta(days=days, months=months, years=years)
+        else:
+            if months or years:
+                return {"ok": False, "error": "Month/year arithmetic needs python-dateutil. pip install python-dateutil"}
+            dt2 = dt + timedelta(days=days)
+        return {"ok": True, "data": {"iso": dt2.isoformat(), "date": dt2.date().isoformat(), "time": dt2.time().isoformat(timespec="seconds")}}
+    except Exception as e:
+        return {"ok": False, "error": f"Add failed: {e}"}
+
+
+@tool("date_diff", return_direct=False)
+def date_diff(start: str, end: str, unit: str = "days", tz: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Difference between two date/times. unit: days|hours|minutes|seconds.
+    """
+    try:
+        d1 = _to_dt(start, tz)
+        d2 = _to_dt(end, tz)
+        seconds = (d2 - d1).total_seconds()
+        unit = (unit or "days").lower()
+        if unit == "seconds":
+            value = seconds
+        elif unit == "minutes":
+            value = seconds / 60
+        elif unit == "hours":
+            value = seconds / 3600
+        else:
+            unit = "days"
+            value = seconds / 86400
+        return {"ok": True, "data": {"value": value, "unit": unit}}
+    except Exception as e:
+        return {"ok": False, "error": f"Diff failed: {e}"}
+
+
+@tool("next_weekday", return_direct=False)
+def next_weekday(date_str: str, weekday: int, include_today: bool = False, tz: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Next date matching weekday (0=Mon..6=Sun).
+    """
+    try:
+        base = _to_dt(date_str, tz).date()
+        wd = int(weekday) % 7
+        delta = (wd - base.weekday()) % 7
+        if delta == 0 and not include_today:
+            delta = 7
+        target = base + timedelta(days=delta)
+        return {"ok": True, "data": {"date": target.isoformat(), "weekday": wd}}
+    except Exception as e:
+        return {"ok": False, "error": f"next_weekday failed: {e}"}
+
+
+@tool("date_format", return_direct=False)
+def date_format(date_str: str, fmt: str = "%Y-%m-%d %H:%M:%S", tz: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Format a date/time string with strftime.
+    """
+    try:
+        dt = _to_dt(date_str, tz)
+        return {"ok": True, "data": {"formatted": dt.strftime(fmt)}}
+    except Exception as e:
+        return {"ok": False, "error": f"Format failed: {e}"}
+
+
+def get_tools():
+    """
+    Returns a list of tools that can be used by the agent.
+    """
+    tools = [
+        Tool(
+            name="BraveSearch",
+            func=BraveSearch().run,
+            description="Search the web using Brave Search."
+        ),
+        Tool(
+            name="YouTubeSearch",
+            func=YouTubeSearchTool().run,
+            description="Search YouTube for videos."
+        ),
+        Tool(
+            name="ExtractText",
+            func=ExtractTextTool().run,
+            description="Extract text from a given URL."
+        ),
+        Tool(
+            name="DuckDuckGoSearch",
+            func=DuckDuckGoSearchResults().run,
+            description="Search the web using DuckDuckGo."
+        ),
+        Tool(
+            name="GoogleSearch",
+            func=GoogleSearchResults().run,
+            description="Search the web using Google."
+        ),
+        Tool(
+            name="WikipediaQuery",
+            func=WikipediaQueryRun().run,
+            description="Query Wikipedia for information."
+        ),
+        Tool(
+            name="WolframAlphaQuery",
+            func=WolframAlphaQueryRun().run,
+            description="Query Wolfram Alpha for computational knowledge."
+        )
+    ]
+    # Add structured tools (LangChain @tool)
+    tools.extend([
+        youtube_transcript,
+        date_today,
+        date_parse,
+        date_add,
+        date_diff,
+        next_weekday,
+        date_format,
+    ])
+    return tools