Update app.py

app.py

@@ -3,102 +3,80 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-
-# (Keep Constants as is)
-# --- Constants ---
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-# --- LangGraph GPT-4.1 Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-import os
 import json
 from typing import Dict, Any, List, Literal, TypedDict, Annotated, Sequence, cast
 import operator
 from functools import partial
 
 # LangChain and LangGraph imports
-import langchain
 from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
 from langchain_core.output_parsers import StrOutputParser
-from langchain_core.pydantic_v1 import BaseModel, Field, validator
-from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
+from pydantic import BaseModel, Field, validator
 from langchain_openai import ChatOpenAI
-from langchain.tools import DuckDuckGoSearchRun
-from langchain.utilities import GoogleSearchAPIWrapper
+from langchain_community.tools import DuckDuckGoSearchRun
+from openai import OpenAI
 
-# LangGraph imports
+# LangGraph imports for latest version
 from langgraph.graph import END, StateGraph
-from langgraph.prebuilt import ToolInvocation, ToolNode
+from langgraph.graph.message import MessageGraph
 
-# Define our search tools
+# --- Constants ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+# --- Define our tool for web search ---
 class SearchTools:
     def __init__(self):
         self.search_tool = DuckDuckGoSearchRun()
         
     def web_search(self, query: str) -> str:
-        """Search the web for information about a topic."""
+        """Search the web for information."""
         try:
             result = self.search_tool.run(query)
             return result
         except Exception as e:
             return f"Error searching the web: {str(e)}"
 
+# --- Tool types and classes ---
+class ToolCall(BaseModel):
+    name: str
+    input: Dict[str, Any]
+
+class AgentState(TypedDict):
+    messages: List[Dict[str, Any]]
+    next: str
+
+# --- LangGraph Agent ---
 class LangGraphAgent:
     def __init__(self):
-        print("LangGraph GPT-4.1 Agent initializing...")
+        print("LangGraph GPT-4 Agent initializing...")
         # Get API key from environment variable
         self.api_key = os.getenv("OPENAI_API_KEY")
         if not self.api_key:
             print("WARNING: OPENAI_API_KEY environment variable not found.")
             print("Please set your OpenAI API key as an environment variable or in the space secrets.")
-            self.model = None
+            self.client = None
             return
             
-        # Initialize GPT-4.1 Turbo model
-        self.model = ChatOpenAI(
-            temperature=0, 
-            model="gpt-4-turbo", 
-            api_key=self.api_key,
-            max_tokens=1000
-        )
-        print("OpenAI GPT-4.1 model initialized successfully.")
+        # Initialize the OpenAI client
+        self.client = OpenAI(api_key=self.api_key)
+        print("OpenAI client initialized successfully.")
         
         # Initialize tools
         self.search_tools = SearchTools()
+        print("Search tools initialized.")
         
-        # Build the agent graph
-        self.agent_executor = self._build_agent_executor()
+        # Build the agent graph using the latest LangGraph version
+        self.graph = self._build_agent_graph()
         print("LangGraph agent initialized successfully.")
     
-    def _build_agent_executor(self):
-        """Build the LangGraph agent with tools"""
-        
-        # Define the available tools
-        tools = [
-            {
-                "type": "function",
-                "function": {
-                    "name": "web_search",
-                    "description": "Search the web for information about a topic",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {
-                            "query": {
-                                "type": "string",
-                                "description": "The search query to use"
-                            }
-                        },
-                        "required": ["query"]
-                    }
-                }
-            }
-        ]
+    def _build_agent_graph(self):
+        """Build a LangGraph agent that uses the OpenAI client directly."""
         
         # Define the system prompt for the agent
         system_prompt = """You are an intelligent agent designed to answer questions from the GAIA dataset.
 
-You have access to search tools to help you find information. Use them when needed to get accurate information.
+You have access to a web search tool to help you find accurate information when needed.
 
 IMPORTANT INSTRUCTIONS FOR FINAL ANSWERS:
 1. For your FINAL ANSWER, provide ONLY the exact answer - no explanations, no reasoning, no additional text.
@@ -110,86 +88,154 @@ IMPORTANT INSTRUCTIONS FOR FINAL ANSWERS:
 
 For your thought process, you can think step-by-step about the question, search for relevant information, and consider what would be the most accurate answer.
 """
-
-        # Create prompt with tool instructions included
-        prompt = ChatPromptTemplate.from_messages(
-            [
-                ("system", system_prompt),
-                MessagesPlaceholder(variable_name="messages"),
-                MessagesPlaceholder(variable_name="agent_scratchpad"),
-            ]
-        )
-        
-        # Create the ChatOpenAI model with function calling
-        tool_model = self.model.bind_functions(functions=tools)
         
-        # Define the agent state
-        class AgentState(TypedDict):
-            messages: list
-            agent_scratchpad: list
-
-        # Define the agent runner        
-        def run_agent(state: AgentState):
+        # Define the agent function using direct OpenAI API calls
+        def agent(state: AgentState) -> Dict:
+            # Extract the messages from the state
             messages = state["messages"]
-            agent_scratchpad = state["agent_scratchpad"]
-            response = tool_model.invoke({
-                "messages": messages,
-                "agent_scratchpad": agent_scratchpad,
-            })
-            return {"messages": messages + [response], "agent_scratchpad": agent_scratchpad + [response]}
-        
-        # Define the tool execution node for the web search
-        def run_tool(state: AgentState, tool_invocation: ToolInvocation):
-            messages = state["messages"]
-            agent_scratchpad = state["agent_scratchpad"]
-            if tool_invocation.name == "web_search":
-                tool_result = self.search_tools.web_search(tool_invocation.arguments["query"])
-                return {"messages": messages, "agent_scratchpad": agent_scratchpad + [AIMessage(content=tool_result)]}
-            else:
-                return {"messages": messages, "agent_scratchpad": agent_scratchpad + [AIMessage(content="Tool not found")]}
             
-        # Define should_continue function to determine if we should continue or provide the final answer
-        def should_continue(state: AgentState) -> Literal["agent", "tool", "end"]:
-            """Determine if we should continue with the agent or end."""
+            # Prepare messages for OpenAI API
+            formatted_messages = []
+            formatted_messages.append({"role": "system", "content": system_prompt})
+            
+            for message in messages:
+                if message.get("role") == "user":
+                    formatted_messages.append({"role": "user", "content": message.get("content", "")})
+                elif message.get("role") == "assistant":
+                    # Handle assistant messages
+                    if message.get("tool_calls") and len(message.get("tool_calls", [])) > 0:
+                        # Format the tool calls for OpenAI
+                        formatted_messages.append({
+                            "role": "assistant", 
+                            "content": message.get("content", ""),
+                            "tool_calls": message.get("tool_calls", [])
+                        })
+                    else:
+                        formatted_messages.append({
+                            "role": "assistant", 
+                            "content": message.get("content", "")
+                        })
+                elif message.get("role") == "tool":
+                    # Handle tool results
+                    formatted_messages.append({
+                        "role": "tool", 
+                        "content": message.get("content", ""),
+                        "tool_call_id": message.get("tool_call_id", "")
+                    })
+            
+            # Define the available tools
+            tools = [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "web_search",
+                        "description": "Search the web for information about a topic",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "query": {
+                                    "type": "string",
+                                    "description": "The search query to use"
+                                }
+                            },
+                            "required": ["query"]
+                        }
+                    }
+                }
+            ]
+            
+            # Call the OpenAI API
+            response = self.client.chat.completions.create(
+                model="gpt-4-turbo",
+                messages=formatted_messages,
+                tools=tools,
+                tool_choice="auto",
+                temperature=0
+            )
+            
+            # Get the response message
+            response_message = response.choices[0].message
+            
+            # Create a standardized message structure
+            new_message = {
+                "role": "assistant",
+                "content": response_message.content or ""
+            }
+            
+            # Check if there are tool calls
+            if response_message.tool_calls:
+                new_message["tool_calls"] = []
+                
+                for tool_call in response_message.tool_calls:
+                    new_message["tool_calls"].append({
+                        "id": tool_call.id,
+                        "name": tool_call.function.name,
+                        "arguments": tool_call.function.arguments
+                    })
+                
+                # If we have tool calls, the next node should be 'action'
+                return {"messages": messages + [new_message], "next": "action"}
+            
+            # If no tool calls, this is our final answer, so end the graph
+            return {"messages": messages + [new_message], "next": "end"}
+            
+        # Define the action function for executing tools
+        def action(state: AgentState) -> Dict:
+            # Get the messages and find the last assistant message with tool calls
             messages = state["messages"]
-            if not messages:
-                return "agent"
+            assistant_messages = [m for m in messages if m.get("role") == "assistant" and m.get("tool_calls")]
             
-            last_message = messages[-1]
+            if not assistant_messages:
+                # No tool calls found, just continue
+                return {"messages": messages, "next": "agent"}
+                
+            # Get the last assistant message with tool calls
+            last_assistant_message = assistant_messages[-1]
+            tool_calls = last_assistant_message.get("tool_calls", [])
             
-            # Check if the message has a function call
-            if hasattr(last_message, "function_call") and last_message.function_call:
-                return "tool"
+            # Process each tool call
+            tool_results = []
+            for tool_call in tool_calls:
+                tool_name = tool_call.get("name")
+                arguments = json.loads(tool_call.get("arguments", "{}"))
+                
+                # Execute the appropriate tool
+                if tool_name == "web_search":
+                    query = arguments.get("query", "")
+                    result = self.search_tools.web_search(query)
+                else:
+                    result = f"Error: Unknown tool {tool_name}"
+                
+                # Add the result as a tool message
+                tool_results.append({
+                    "role": "tool",
+                    "tool_call_id": tool_call.get("id"),
+                    "content": result
+                })
             
-            # If no function call and it's an AI message, we're done
-            if isinstance(last_message, AIMessage):
-                return "end"
+            # Add all tool results to messages
+            return {"messages": messages + tool_results, "next": "agent"}
             
-            # Continue with the agent
-            return "agent"
-        
         # Create the graph
         workflow = StateGraph(AgentState)
         
         # Add nodes
-        workflow.add_node("agent", run_agent)
-        workflow.add_node("tool", partial(ToolNode(), run_tool))
+        workflow.add_node("agent", agent)
+        workflow.add_node("action", action)
         
-        # Add conditional edges
+        # Add edges
         workflow.add_conditional_edges(
             "agent",
-            should_continue,
+            lambda x: x["next"],
             {
-                "tool": "tool",
-                "end": END,
-                "agent": "agent",
-            },
+                "action": "action",
+                "end": END
+            }
         )
         
-        # Connect tool back to agent
-        workflow.add_edge("tool", "agent")
+        workflow.add_edge("action", "agent")
         
-        # Set entry point
+        # Set the entry point
         workflow.set_entry_point("agent")
         
         # Compile the graph
@@ -198,31 +244,31 @@ For your thought process, you can think step-by-step about the question, search
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
         
-        if not self.model or not self.agent_executor:
+        if not self.client or not self.graph:
             return "OpenAI API key not set. Please set the OPENAI_API_KEY as a secret in your space settings."
             
         try:
             # Initial state with the question
             initial_state = {
-                "messages": [HumanMessage(content=question)],
-                "agent_scratchpad": []
+                "messages": [{"role": "user", "content": question}],
+                "next": "agent"
             }
             
-            # Execute the agent
-            result = self.agent_executor.invoke(initial_state)
+            # Run the graph
+            result = self.graph.invoke(initial_state)
             
-            # Get the final message from the result
-            messages = result.get("messages", [])
+            # Extract the final answer from the result
+            messages = result["messages"]
             if not messages:
                 return "No response generated."
                 
-            # Extract the final answer from the last AI message
-            final_messages = [m for m in messages if isinstance(m, AIMessage)]
+            # Find all assistant messages without tool calls (these are response messages)
+            final_messages = [m for m in messages if m.get("role") == "assistant" and not m.get("tool_calls")]
             if not final_messages:
-                return "No AI response found."
+                return "No final answer found."
                 
-            last_ai_message = final_messages[-1]
-            raw_answer = last_ai_message.content
+            # Get the content from the last assistant message
+            raw_answer = final_messages[-1].get("content", "")
             
             # Clean up the answer
             answer = raw_answer.strip()
@@ -250,9 +296,9 @@ For your thought process, you can think step-by-step about the question, search
             print(f"Error while processing question: {e}")
             return f"Error processing question: {str(e)}"
 
-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,
+    Fetches all questions, runs the Agent on them, submits all answers,
     and displays the results.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
@@ -269,13 +315,13 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent ( modify this part to create your agent)
+    # 1. Instantiate Agent
     try:
         agent = LangGraphAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
-    # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
+    # In the case of an app running as a hugging Face space, this link points toward your codebase
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
     print(agent_code)
 
@@ -394,7 +440,6 @@ 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)
-    # Removed max_rows=10 from DataFrame constructor
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
     run_button.click(