Added HF environment model

app.py

@@ -4,20 +4,206 @@ import requests
 import inspect
 import pandas as pd
 
+# --------- AGENT IMPORTS ---------------
+# Read Data
+# Retriever Tool
+#from langchain_community.retrievers import BM25Retriever
+from langchain_core.tools import Tool
+# Web Search Tool
+from langchain_community.tools import DuckDuckGoSearchRun
+# Agent
+from typing import TypedDict, Annotated
+from langgraph.graph.message import add_messages
+from langchain_core.messages import AnyMessage, HumanMessage, AIMessage, SystemMessage
+from langgraph.prebuilt import ToolNode
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import tools_condition
+from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
+# Additional Libraries
+import re
+import requests
+from langchain_community.utilities import WikipediaAPIWrapper
+import subprocess
+# -------------------------------------------------------
+
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
+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."
+
 # --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+
+
+llm = HuggingFaceEndpoint(
+    repo_id="Qwen/Qwen2.5-7B-Instruct",
+    task="text-generation",
+    huggingfacehub_api_token=os.getenv("HF_TOKEN"),
+    temperature=0,
+    max_new_tokens=512,
+)
+
+def fetch_webpage(url: str) -> str:
+    """Fetch and read the text content of any webpage given its URL."""
+    try:
+        headers = {"User-Agent": "Mozilla/5.0 (compatible; GAIAAgent/1.0)"}
+        resp = requests.get(url.strip(), headers=headers, timeout=15)
+        resp.raise_for_status()
+
+        text = re.sub(r"<[^>]+>", " ", resp.text)
+        text = re.sub(r"\s+", " ", text).strip()
+
+        return text[:4000]
+
+    except Exception as e:
+        return f"Error fetching URL: {e}"
+
+
+def python_repl(code: str) -> str:
+    """Execute Python code for calculations, data parsing, or logic."""
+    try:
+        result = subprocess.run(
+            ["python3", "-c", code],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+
+        output = result.stdout.strip()
+        error = result.stderr.strip()
+
+        if error:
+            return f"stderr: {error}\nstdout: {output}"
+
+        return output if output else "(no output)"
+
+    except subprocess.TimeoutExpired:
+        return "Error: code execution timed out"
+
+    except Exception as e:
+        return f"Error running code: {e}"
+
+class AgentState(TypedDict):
+    messages: Annotated[list[AnyMessage], add_messages]
+
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
+
+        self.search_tool = DuckDuckGoSearchRun()
+
+        self.wikipedia = WikipediaAPIWrapper(
+            top_k_results=2,
+            doc_content_chars_max=3000,
+        )
+
+        self.fetch_webpage_tool = Tool(
+            name="fetch_webpage",
+            func=fetch_webpage,
+            description=(
+                "Fetch and read the text content of any webpage given its URL. "
+                "Use this when a question references a specific URL, or after "
+                "web search returns a URL you want to read in full. "
+                "Input: a full URL including https://."
+            ),
+        )
+
+        self.wikipedia_search_tool = Tool(
+            name="wikipedia_search",
+            func=self.wikipedia_search,
+            description=(
+                "Search Wikipedia for factual information about a topic. "
+                "Input: a topic or search query."
+            ),
+        )
+
+        self.python_repl_tool = Tool(
+            name="python_repl",
+            func=python_repl,
+            description=(
+                "Execute Python code for calculations, data parsing, or logic. "
+                "Use this for arithmetic, unit conversions, list operations, "
+                "or structured data processing. Input: valid Python code."
+            ),
+        )
+
+        self.tools = [
+            self.search_tool,
+            self.fetch_webpage_tool,
+            self.wikipedia_search_tool,
+            self.python_repl_tool,
+        ]
+
+        
+
+        self.chat = ChatHuggingFace(llm=llm)
+
+        self.chat_with_tools = self.chat.bind_tools(self.tools)
+
+        self.graph = self.build_graph()
+
+    def wikipedia_search(self, query: str) -> str:
+        try:
+            return self.wikipedia.run(query)
+        except Exception as e:
+            return f"Wikipedia search error: {e}"
+
+    def assistant(self, state: AgentState):
+        return {
+            "messages": [self.chat_with_tools.invoke(state["messages"])]
+        }
+
+    def build_graph(self):
+        builder = StateGraph(AgentState)
+
+        builder.add_node("assistant", self.assistant)
+        builder.add_node("tools", ToolNode(self.tools))
+
+        builder.add_edge(START, "assistant")
+
+        builder.add_conditional_edges(
+            "assistant",
+            tools_condition,
+        )
+
+        builder.add_edge("tools", "assistant")
+
+        return builder.compile()
+
+    def extract_final_answer(self, text: str) -> str:
+        match = re.search(
+            r"FINAL ANSWER:\s*(.*)",
+            text,
+            flags=re.IGNORECASE | re.DOTALL,
+        )
+
+        if match:
+            return match.group(1).strip()
+
+        return text.strip()
+
     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
+        print(f"Agent received question: {question[:100]}...")
+
+        messages = [
+            SystemMessage(content=SYSTEM_PROMPT),
+            HumanMessage(content=question),
+        ]
+
+        try:
+            response = self.graph.invoke({"messages": messages})
+            raw_answer = response["messages"][-1].content
+
+            final_answer = self.extract_final_answer(raw_answer)
+
+            print(f"Raw answer: {raw_answer}")
+            print(f"Submitted answer: {final_answer}")
+
+            return final_answer
+
+        except Exception as e:
+            print(f"Agent error: {e}")
+            return f"AGENT ERROR: {e}"
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """