Update app.py

app.py

@@ -4,14 +4,14 @@ import json
 import requests
 import pandas as pd
 from pathlib import Path
-from typing import Optional, Union, Dict, Any, List
+from typing import Optional
 from dotenv import load_dotenv
 
-from langgraph.graph import StateGraph, MessagesState
 from langgraph.prebuilt import create_react_agent
-from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.messages import HumanMessage
 from langchain_core.tools import tool
 from langchain_openai import ChatOpenAI
+import inspect
 
 load_dotenv()
 
@@ -21,7 +21,6 @@ class OpenRouterLLM(ChatOpenAI):
     
     def __init__(self, model: str = "deepseek/deepseek-v3.1-terminus", **kwargs):
         api_key = os.getenv("OPENROUTER_API_KEY") or os.getenv("my_key")
-        
         super().__init__(
             model=model,
             openai_api_key=api_key,
@@ -30,34 +29,25 @@ class OpenRouterLLM(ChatOpenAI):
         )
 
 
+# ------------------ TOOLS ------------------
+
 @tool
 def search_web(query: str) -> str:
     """Search the web using DuckDuckGo for current information."""
     try:
-        # Simple web search using DuckDuckGo
         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()
-            
-            # Extract results
             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']}")
-            
-            if results:
-                return "\n".join(results)
-            else:
-                return f"Search performed for '{query}' but no specific results found."
-        else:
-            return f"Search failed with status code {response.status_code}"
-            
+            return "\n".join(results) if results else f"No results for '{query}'."
+        return f"Search failed with status code {response.status_code}"
     except Exception as e:
         return f"Search error: {str(e)}"
 
@@ -66,20 +56,13 @@ def search_web(query: str) -> str:
 def search_wikipedia(query: str) -> str:
     """Search Wikipedia for factual information."""
     try:
-        # Wikipedia API search
         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", "")
-            if extract:
-                return f"Wikipedia: {extract[:500]}..."
-            else:
-                return f"Wikipedia page found for '{query}' but no extract available."
-        else:
-            return f"Wikipedia search failed for '{query}'"
-            
+            return f"Wikipedia: {extract[:500]}..." if extract else f"No extract for '{query}'."
+        return f"Wikipedia search failed for '{query}'"
     except Exception as e:
         return f"Wikipedia search error: {str(e)}"
 
@@ -88,51 +71,27 @@ def search_wikipedia(query: str) -> str:
 def execute_python(code: str) -> str:
     """Execute Python code and return the result."""
     try:
-        # Create a safe execution environment
         safe_globals = {
             '__builtins__': {
-                'print': print,
-                'len': len,
-                'str': str,
-                'int': int,
-                'float': float,
-                'bool': bool,
-                'list': list,
-                'dict': dict,
-                'tuple': tuple,
-                'set': set,
-                'range': range,
-                'sum': sum,
-                'max': max,
-                'min': min,
-                'abs': abs,
-                'round': round,
-                'sorted': sorted,
-                'enumerate': enumerate,
-                'zip': zip,
+                'print': print, 'len': len, 'str': str, 'int': int, 'float': float,
+                'bool': bool, 'list': list, 'dict': dict, 'tuple': tuple, 'set': set,
+                'range': range, 'sum': sum, 'max': max, 'min': min, 'abs': abs,
+                'round': round, 'sorted': sorted, 'enumerate': enumerate, 'zip': zip,
             },
             'math': __import__('math'),
             'json': __import__('json'),
             'datetime': __import__('datetime'),
             'random': __import__('random'),
         }
-        
-        # Capture output
-        import io
-        import sys
-        
+        import io, sys
         old_stdout = sys.stdout
         sys.stdout = mystdout = io.StringIO()
-        
         try:
-            # Execute the code
             exec(code, safe_globals)
             output = mystdout.getvalue()
         finally:
             sys.stdout = old_stdout
-        
         return output if output else "Code executed successfully (no output)"
-        
     except Exception as e:
         return f"Python execution error: {str(e)}"
 
@@ -144,30 +103,20 @@ def read_excel_file(file_path: str, sheet_name: Optional[str] = None) -> str:
         file_path_obj = Path(file_path)
         if not file_path_obj.exists():
             return f"Error: File not found at {file_path}"
-        
-        # Try to read the Excel file
         if sheet_name and sheet_name.isdigit():
             sheet_name = int(sheet_name)
         elif sheet_name is None:
             sheet_name = 0
-            
         df = pd.read_excel(file_path, sheet_name=sheet_name)
-        
-        # Convert to string representation
         if len(df) > 20:
-            # Show first 10 and last 10 rows for large datasets
             result = f"Excel file with {len(df)} rows and {len(df.columns)} columns:\n\n"
-            result += "First 10 rows:\n"
-            result += df.head(10).to_string(index=False)
+            result += "First 10 rows:\n" + df.head(10).to_string(index=False)
             result += f"\n\n... ({len(df) - 20} rows omitted) ...\n\n"
-            result += "Last 10 rows:\n"
-            result += df.tail(10).to_string(index=False)
+            result += "Last 10 rows:\n" + df.tail(10).to_string(index=False)
         else:
             result = f"Excel file with {len(df)} rows and {len(df.columns)} columns:\n\n"
             result += df.to_string(index=False)
-            
         return result
-        
     except Exception as e:
         return f"Error reading Excel file: {str(e)}"
 
@@ -179,153 +128,92 @@ def read_text_file(file_path: str) -> str:
         file_path_obj = Path(file_path)
         if not file_path_obj.exists():
             return f"Error: File not found at {file_path}"
-        
-        # Try different encodings
         encodings = ['utf-8', 'utf-16', 'iso-8859-1', 'cp1252']
-        
         for encoding in encodings:
             try:
                 with open(file_path_obj, 'r', encoding=encoding) as f:
-                    content = f.read()
-                return f"File content ({encoding} encoding):\n\n{content}"
+                    return f"File content ({encoding} encoding):\n\n{f.read()}"
             except UnicodeDecodeError:
                 continue
-        
-        return f"Error: Could not decode file with any standard encoding"
-        
+        return "Error: Could not decode file with any standard encoding"
     except Exception as e:
         return f"Error reading file: {str(e)}"
 
 
+# ------------------ GAIA AGENT ------------------
+
 class GaiaAgent:
     """LangGraph-based agent for GAIA tasks using OpenRouter DeepSeek"""
     
     def __init__(self):
         print("Initializing GaiaAgent with LangGraph and OpenRouter DeepSeek...")
-        
-        # Initialize the LLM
         self.llm = OpenRouterLLM(
             model="deepseek/deepseek-v3.1-terminus",
             temperature=0.1,
             max_tokens=2000
         )
-        
-        # Define available tools
-        self.tools = [
-            search_web,
-            search_wikipedia,
-            execute_python,
-            read_excel_file,
-            read_text_file,
-        ]
-        
-        # Create the agent
-        self.agent = create_react_agent(
-            self.llm,
-            self.tools,
-            state_modifier=self._get_system_prompt()
-        )
-        
+        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 = {}
+        if "messages_modifier" in accepted:
+            kwargs["messages_modifier"] = prompt_modifier
+        elif "state_modifier" in accepted:
+            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:
-        """Get the system prompt for the agent"""
-        return """You are an advanced AI agent designed to answer complex questions that may require:
 
-1. Web searches for current information
-2. Mathematical calculations using Python
-3. File analysis (Excel, text files)  
-4. Multi-step reasoning and problem solving
-
-For GAIA evaluation:
-- Provide EXACT, DIRECT answers
-- Use tools when necessary to gather information or perform calculations
-- For math problems, show your calculation but end with just the number
-- For yes/no questions, answer just "Yes" or "No"
-- For factual questions, provide just the fact
-
-When you encounter files:
-- Use read_excel_file for .xlsx, .xls files
-- Use read_text_file for text-based files
-- Analyze the file content to answer the question
-
-Be thorough in your analysis but concise in your final answer."""
+    def _get_system_prompt(self) -> str:
+        return """You are an advanced AI agent designed to answer complex questions...
+(keep your original system prompt here)"""
 
     def __call__(self, task_id: str, question: str) -> str:
-        """Process a question and return the answer"""
         try:
             print(f"Processing task {task_id}: {question[:100]}...")
-            
-            # Create the input state
             messages = [HumanMessage(content=question)]
-            
-            # Run the agent
             result = self.agent.invoke({"messages": messages})
-            
-            # Extract the final answer
             final_message = result["messages"][-1]
             answer = final_message.content
-            
-            # Clean up the answer for GAIA evaluation
-            clean_answer = self._clean_answer(answer)
-            
-            print(f"Agent answer for {task_id}: {clean_answer}")
-            return clean_answer
-            
+            return self._clean_answer(answer)
         except Exception as e:
-            error_msg = f"Agent error: {str(e)}"
-            print(f"Error processing task {task_id}: {error_msg}")
-            return error_msg
-    
+            return f"Agent error: {e}"
+
     def _clean_answer(self, answer: str) -> str:
-        """Clean the answer to extract the final result"""
+        # same cleaning code as before
         answer = answer.strip()
-        
-        # Look for "Final Answer:" pattern
         if "final answer:" in answer.lower():
             parts = re.split(r'final answer:', answer, flags=re.IGNORECASE)
             if len(parts) > 1:
                 answer = parts[-1].strip()
-        
-        # Remove common prefixes
-        prefixes = [
-            "The answer is", "Answer:", "Result:", "Solution:",
-            "Based on", "Therefore", "In conclusion", "So the answer is"
-        ]
-        
+        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
-        
-        # Remove quotes and periods from short answers
         if len(answer.split()) <= 3:
             answer = answer.strip('"\'.')
-        
         return answer
 
 
+# ------------------ ENTRYPOINT ------------------
+
 import gradio as gr
 
-# Create a single global agent instance
 agent = GaiaAgent()
 
 def run_agent(prompt: str) -> str:
-    """
-    Simple wrapper so GAIA and Hugging Face Spaces can call the agent.
-    GAIA usually passes only a prompt (not task_id), so we use a dummy ID.
-    """
     return agent("gaia_task", prompt)
 
-# Expose via Gradio
-demo = gr.Interface(
-    fn=run_agent,
-    inputs="text",
-    outputs="text",
-    title="GAIA Agent"
-)
+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)
+    demo.launch(server_name="0.0.0.0", server_port=7860)