Update app.py

app.py

@@ -1,12 +1,13 @@
 import os
-import gradio as gr
+import re
+import json
 import requests
-import inspect
 import pandas as pd
-import re
 from pathlib import Path
 from typing import Optional
 from dotenv import load_dotenv
+import inspect
+import gradio as gr
 
 from langgraph.prebuilt import create_react_agent
 from langchain_core.messages import HumanMessage
@@ -15,13 +16,13 @@ from langchain_openai import ChatOpenAI
 
 load_dotenv()
 
-# ------------------ CUSTOM LLM ------------------
-
+# ------------------ LLM ------------------
 class OpenRouterLLM(ChatOpenAI):
     """Custom OpenRouter LLM wrapper for LangGraph"""
-    
     def __init__(self, model: str = "deepseek/deepseek-v3.1-terminus", **kwargs):
-        api_key = os.getenv("OPENROUTER_API_KEY") or os.getenv("my_key")
+        api_key = os.getenv("OPENROUTER_API_KEY")
+        if not api_key:
+            raise ValueError("OPENROUTER_API_KEY not set in environment variables.")
         super().__init__(
             model=model,
             openai_api_key=api_key,
@@ -31,43 +32,54 @@ class OpenRouterLLM(ChatOpenAI):
 
 # ------------------ TOOLS ------------------
 
+SERPAPI_KEY = os.getenv("SERPAPI_KEY")
+
 @tool
 def search_web(query: str) -> str:
-    """Search the web using DuckDuckGo and return current information."""
+    """Perform a reliable web search using SerpAPI."""
+    if not SERPAPI_KEY:
+        return "Error: SERPAPI_KEY not set."
+    search_url = "https://serpapi.com/search.json"
+    params = {"q": query, "api_key": SERPAPI_KEY, "num": 3}
     try:
-        search_url = f"https://api.duckduckgo.com/?q={query}&format=json&no_html=1&skip_disambig=1"
-        response = requests.get(search_url, timeout=10)
-        if response.status_code == 200:
-            data = response.json()
-            results = []
-            if data.get("AbstractText"):
-                results.append(f"Abstract: {data['AbstractText']}")
-            if data.get("RelatedTopics"):
-                for topic in data["RelatedTopics"][:3]:
-                    if isinstance(topic, dict) and topic.get("Text"):
-                        results.append(f"Related: {topic['Text']}")
-            return "\n".join(results) if results else f"No results for '{query}'."
-        return f"Search failed with status code {response.status_code}"
+        response = requests.get(search_url, params=params, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        results = []
+        for item in data.get("organic_results", []):
+            title = item.get("title", "")
+            snippet = item.get("snippet", "")
+            link = item.get("link", "")
+            results.append(f"{title}\n{snippet}\n{link}")
+        return "\n\n".join(results) if results else f"No results for '{query}'."
     except Exception as e:
-        return f"Search error: {str(e)}"
+        return f"Web search error: {str(e)}"
 
 @tool
 def search_wikipedia(query: str) -> str:
-    """Search Wikipedia for factual information and return a short summary."""
+    """Retrieve full Wikipedia article text."""
     try:
-        search_url = "https://en.wikipedia.org/api/rest_v1/page/summary/" + query.replace(" ", "_")
-        response = requests.get(search_url, timeout=10)
-        if response.status_code == 200:
-            data = response.json()
-            extract = data.get("extract", "")
-            return f"Wikipedia: {extract[:500]}..." if extract else f"No extract for '{query}'."
-        return f"Wikipedia search failed for '{query}'"
+        url = f"https://en.wikipedia.org/w/api.php"
+        params = {
+            "action": "query",
+            "format": "json",
+            "prop": "extracts",
+            "explaintext": True,
+            "titles": query
+        }
+        response = requests.get(url, params=params, timeout=10)
+        response.raise_for_status()
+        pages = response.json()["query"]["pages"]
+        text = next(iter(pages.values())).get("extract", "")
+        if not text:
+            return f"No Wikipedia content found for '{query}'."
+        return text[:2000]  # truncate if too long
     except Exception as e:
         return f"Wikipedia search error: {str(e)}"
 
 @tool
 def execute_python(code: str) -> str:
-    """Execute Python code safely and return the output or error message."""
+    """Execute Python code safely and return output."""
     try:
         safe_globals = {
             '__builtins__': {
@@ -95,7 +107,7 @@ def execute_python(code: str) -> str:
 
 @tool
 def read_excel_file(file_path: str, sheet_name: Optional[str] = None) -> str:
-    """Read an Excel file and return its contents as a formatted string."""
+    """Read an Excel file and return contents."""
     try:
         file_path_obj = Path(file_path)
         if not file_path_obj.exists():
@@ -119,7 +131,7 @@ def read_excel_file(file_path: str, sheet_name: Optional[str] = None) -> str:
 
 @tool
 def read_text_file(file_path: str) -> str:
-    """Read a text file and return its contents as a string."""
+    """Read a text file and return contents."""
     try:
         file_path_obj = Path(file_path)
         if not file_path_obj.exists():
@@ -128,7 +140,7 @@ def read_text_file(file_path: str) -> str:
         for encoding in encodings:
             try:
                 with open(file_path_obj, 'r', encoding=encoding) as f:
-                    return f"File content ({encoding} encoding):\n\n{f.read()}"
+                    return f.read()
             except UnicodeDecodeError:
                 continue
         return "Error: Could not decode file with any standard encoding"
@@ -136,12 +148,10 @@ def read_text_file(file_path: str) -> str:
         return f"Error reading file: {str(e)}"
 
 # ------------------ GAIA AGENT ------------------
-
 class GaiaAgent:
-    """LangGraph-based agent using OpenRouter DeepSeek"""
-    
+    """LangGraph-based agent with DeepSeek and enhanced tools."""
     def __init__(self):
-        print("Initializing GaiaAgent...")
+        print("Initializing GaiaAgent with LangGraph and OpenRouter DeepSeek...")
         self.llm = OpenRouterLLM(
             model="deepseek/deepseek-v3.1-terminus",
             temperature=0.1,
@@ -149,6 +159,8 @@ class GaiaAgent:
         )
         self.tools = [search_web, search_wikipedia, execute_python, read_excel_file, read_text_file]
         prompt_modifier = self._get_system_prompt()
+
+        # Detect correct kwarg for your LangGraph version
         sig = inspect.signature(create_react_agent)
         accepted = sig.parameters.keys()
         kwargs = {}
@@ -158,18 +170,24 @@ class GaiaAgent:
             kwargs["state_modifier"] = prompt_modifier
         elif "prompt" in accepted:
             kwargs["prompt"] = prompt_modifier
+
         self.agent = create_react_agent(self.llm, self.tools, **kwargs)
         print("GaiaAgent initialized successfully!")
 
     def _get_system_prompt(self) -> str:
-        return """You are an advanced AI agent designed to answer complex questions.
-Keep answers concise and factual where possible."""
+        return """You are an advanced AI agent designed to answer complex questions using all available tools, including web search, Wikipedia, Python execution, Excel and text file reading."""
 
-    def __call__(self, question: str) -> str:
+    def __call__(self, task_id: str, question: str) -> str:
         try:
-            messages = [HumanMessage(content=question)]
+            print(f"Processing task {task_id}: {question[:100]}...")
+            # Combine context from tools for better answers
+            wiki_text = search_wikipedia(question)
+            web_text = search_web(question)
+            combined_input = f"{wiki_text}\n\n{web_text}\n\nQuestion: {question}"
+            messages = [HumanMessage(content=combined_input)]
             result = self.agent.invoke({"messages": messages})
-            answer = result["messages"][-1].content
+            final_message = result["messages"][-1]
+            answer = final_message.content
             return self._clean_answer(answer)
         except Exception as e:
             return f"Agent error: {e}"
@@ -180,94 +198,25 @@ Keep answers concise and factual where possible."""
             parts = re.split(r'final answer:', answer, flags=re.IGNORECASE)
             if len(parts) > 1:
                 answer = parts[-1].strip()
-        prefixes = ["The answer is", "Answer:", "Result:", "Solution:"]
+        prefixes = ["The answer is", "Answer:", "Result:", "Solution:",
+                    "Based on", "Therefore", "In conclusion", "So the answer is"]
         for prefix in prefixes:
             if answer.lower().startswith(prefix.lower()):
                 answer = answer[len(prefix):].strip()
                 if answer.startswith(':'):
                     answer = answer[1:].strip()
                 break
+        if len(answer.split()) <= 3:
+            answer = answer.strip('"\'.')
         return answer
 
-# ------------------ RUN AND SUBMIT ------------------
-
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-def run_and_submit_all(profile: gr.OAuthProfile | None):
-    if profile:
-        username = profile.username
-    else:
-        return "Please login to Hugging Face first.", None
-
-    space_id = os.getenv("SPACE_ID") or "your_space_username/your_space_name"
-    api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
-
-    # Instantiate GaiaAgent
-    try:
-        agent = GaiaAgent()
-    except Exception as e:
-        return f"Error initializing GaiaAgent: {e}", None
-
-    # Fetch questions
-    try:
-        response = requests.get(questions_url, timeout=15)
-        response.raise_for_status()
-        questions_data = response.json()
-    except Exception as e:
-        return f"Error fetching questions: {e}", None
-
-    # Run agent on questions
-    answers_payload = []
-    results_log = []
-    for item in questions_data:
-        task_id = item.get("task_id")
-        question_text = item.get("question")
-        if not task_id or question_text is 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})
-        except Exception as e:
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
-
-    # Prepare submission
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    submission_data = {"username": username, "agent_code": agent_code, "answers": answers_payload}
-
-    # Submit answers
-    try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
-        response.raise_for_status()
-        result_data = response.json()
-        final_status = (
-            f"Submission Successful!\n"
-            f"User: {result_data.get('username')}\n"
-            f"Overall Score: {result_data.get('score', 'N/A')}% "
-            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
-            f"Message: {result_data.get('message', 'No message received.')}"
-        )
-        results_df = pd.DataFrame(results_log)
-        return final_status, results_df
-    except Exception as e:
-        results_df = pd.DataFrame(results_log)
-        return f"Submission failed: {e}", results_df
-
 # ------------------ GRADIO INTERFACE ------------------
+agent = GaiaAgent()
 
-with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Agent Evaluation Runner")
-    gr.LoginButton()
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+def run_agent(prompt: str) -> str:
+    return agent("gaia_task", prompt)
 
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table]
-    )
+demo = gr.Interface(fn=run_agent, inputs="text", outputs="text", title="GAIA Agent")
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)