Update app.py

app.py

@@ -3,640 +3,86 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-import time
-import json
-import re
-import wikipedia
-from bs4 import BeautifulSoup
-from datetime import datetime
-from typing import Dict, List, Any, Tuple, TypedDict, Literal, Optional
-from dotenv import load_dotenv
-
-# Load environment variables
-load_dotenv()
-
-# Try to import Tavily
-try:
-    from tavily import TavilyClient
-    TAVILY_AVAILABLE = True
-except ImportError:
-    TAVILY_AVAILABLE = False
-    print("Tavily not available. Falling back to other search methods.")
-
-# LangGraph and LangChain imports
-from langgraph.graph import END, StateGraph, MessagesState
-from langgraph.prebuilt import ToolNode
-from langchain_core.messages import HumanMessage, AIMessage
-from langchain_openai import ChatOpenAI
-# Use Wikipedia tools
-from langchain_community.tools import WikipediaQueryRun
-from langchain_community.utilities import WikipediaAPIWrapper
-try:
-    # Try to import ArxivAPIWrapper
-    from langchain_community.utilities import ArxivAPIWrapper
-    ARXIV_AVAILABLE = True
-except ImportError:
-    ARXIV_AVAILABLE = False
-from langchain_core.tools import tool, BaseTool
-from langchain_core.pydantic_v1 import BaseModel, Field
-from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# Define state for the agent
-class AgentState(MessagesState):
-    """State for the agent"""
-    pass
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+import os
+import gradio as gr
+import requests
+import pandas as pd
+from langchain.agents import load_tools, initialize_agent
+from langchain.chat_models import ChatOpenAI
+
+# --- System Prompt Definition ---
+SYSTEM_PROMPT = """
+You are a general AI assistant with access to these tools:
+- search(query): web search
+- python(code): Python REPL
+- read_file(path): load local documents
+- vision(image): OCR/vision
+- calculator(expr): arithmetic
+
+When you get a question, think step by step:
+
+Thought: decide what to do next
+Action: call one tool (name + args) or “Answer” if ready
+Observation: result from the tool
 
-# Function to perform a web search using Tavily (free tier)
-def tavily_search(query: str, max_results: int = 3) -> str:
-    """Perform a web search using Tavily's API (free tier).
-    This provides limited free searches without an API key.
+…repeat Thought/Action/Observation until you have what you need…
+
+Final Answer: [YOUR FINAL ANSWER]
+
+Constraints on YOUR FINAL ANSWER:
+• If it’s a number, write digits without commas or units (unless asked).
+• If it’s a string, omit articles (“a”, “the”), abbreviations, and write any digits in words.
+• If it’s a list, output a comma-separated list of numbers and/or strings, each following the above rules.
+"""
+
+# --- Constants ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+# --- SmolAgent Definition ---
+class BasicAgent:
     """
-    if not TAVILY_AVAILABLE:
-        return ""
-        
-    try:
-        # Create a Tavily client (uses TAVILY_API_KEY env var if set)
-        tavily_client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
-        
-        # Perform the search
-        search_result = tavily_client.search(
-            query=query,
-            search_depth="basic",  # Use the free tier
-            max_results=max_results
-        )
-        
-        if search_result and "results" in search_result:
-            results = search_result["results"]
-            formatted_results = []
-            
-            for result in results:
-                title = result.get("title", "No title")
-                content = result.get("content", "No content")
-                url = result.get("url", "No URL")
-                formatted_results.append(f"Title: {title}\nContent: {content}\nURL: {url}\n")
-            
-            return "\n".join(formatted_results)
-    
-    except Exception as e:
-        print(f"Tavily search error: {str(e)}")
-    
-    return ""
-
-# Function to perform a basic web search using requests and BeautifulSoup
-def perform_web_search(query: str, max_results: int = 3) -> str:
-    """Perform a simple web search by scraping search results.
-    This doesn't require an API key but is less reliable than paid APIs.
+    A lightweight agent configured with GAIA tools, using GPT-4.1 via OpenAI API.
     """
-    # Clean up and encode the query
-    clean_query = query.replace(" ", "+")
-    
-    try:
-        # Try to get search results from lite search engine
-        headers = {
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
-        }
-        
-        # First try DuckDuckGo HTML
-        try:
-            response = requests.get(
-                f"https://html.duckduckgo.com/html/?q={clean_query}",
-                headers=headers,
-                timeout=5
-            )
-            
-            if response.status_code == 200:
-                # Use BeautifulSoup for more reliable parsing
-                soup = BeautifulSoup(response.text, 'html.parser')
-                results = []
-                
-                # Extract results from DuckDuckGo HTML
-                result_elements = soup.select('.result__body')
-                for element in result_elements[:max_results]:
-                    title_elem = element.select_one('.result__a')
-                    title = title_elem.get_text() if title_elem else "No title"
-                    
-                    snippet_elem = element.select_one('.result__snippet')
-                    snippet = snippet_elem.get_text() if snippet_elem else "No snippet"
-                    
-                    results.append(f"Title: {title}\nSnippet: {snippet}\n")
-                    
-                if results:
-                    return "\n".join(results)
-        except Exception as ddg_err:
-            print(f"DuckDuckGo search error: {str(ddg_err)}")
-        
-        # Try Qwant as fallback
-        try:
-            response = requests.get(
-                f"https://lite.qwant.com/?q={clean_query}&t=web",
-                headers=headers,
-                timeout=5
-            )
-            
-            if response.status_code == 200:
-                soup = BeautifulSoup(response.text, 'html.parser')
-                results = []
-                
-                # Extract results from Qwant
-                article_elements = soup.select('article')
-                for article in article_elements[:max_results]:
-                    title_elem = article.select_one('h2')
-                    title = title_elem.get_text().strip() if title_elem else "No title"
-                    
-                    desc_elem = article.select_one('.desc')
-                    description = desc_elem.get_text().strip() if desc_elem else "No description"
-                    
-                    results.append(f"Title: {title}\nSnippet: {description}\n")
-                    
-                if results:
-                    return "\n".join(results)
-        except Exception as qwant_err:
-            print(f"Qwant search error: {str(qwant_err)}")
-        
-    except Exception as e:
-        print(f"Basic search error: {str(e)}")
-    
-    # If the above fails, return empty string
-    return ""
-
-# --- LangGraph Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class LangGraphAgent:
     def __init__(self):
-        print("LangGraphAgent initialized.")
-        # Initialize the OpenAI model with API key from environment
-        self.openai_api_key = os.getenv("OPENAI_API_KEY")
-        if not self.openai_api_key:
-            raise ValueError("OPENAI_API_KEY not found in environment variables")
-        
-        # Set up web search tool
-        self.tools = self._setup_tools()
-        
-        # Build the agent graph
-        self.agent = self._build_agent_graph()
-        
-    def _setup_tools(self) -> List[BaseTool]:
-        """Set up the tools for the agent."""
-        # Initialize Wikipedia API
-        wikipedia_api = WikipediaAPIWrapper(top_k_results=3)
-        wikipedia_tool = WikipediaQueryRun(api_wrapper=wikipedia_api)
-        
-        # Initialize ArXiv if available
-        if ARXIV_AVAILABLE:
-            arxiv_api = ArxivAPIWrapper(top_k_results=3)
-        
-        # Define search tool with improved error handling and retry logic
-        @tool
-        def search(query: str) -> str:
-            """Search the web for information about a specific topic or question.
-            Always use this tool for questions requiring factual information, current events, or specific details.
-            """
-            max_retries = 2
-            retry_count = 0
-            search_results = ""
-            
-            # Clean up the query to make it more searchable
-            # Remove URL parameters and make it more general
-            if "youtube.com" in query or "youtu.be" in query:
-                # Handle YouTube video queries specially
-                # Extract video ID if possible
-                video_id_match = re.search(r'(?:v=|youtu\.be\/)([\w-]+)', query)
-                video_id = video_id_match.group(1) if video_id_match else ""
-                if video_id:
-                    clean_query = f"YouTube video {video_id} information"
-                else:
-                    clean_query = query
-            else:
-                clean_query = query
-            
-            # Special case for chess position or image description questions
-            if "image" in query.lower() or "chess position" in query.lower() or "picture" in query.lower():
-                return "This query requires analyzing an image, which is not available. Please provide a text-based answer based on general knowledge about the topic."
-            
-            while retry_count < max_retries:
-                # Try multiple search approaches in sequence
-                
-                # 1. First try Tavily (more reliable)
-                try:
-                    print(f"Trying Tavily search for: {clean_query}")
-                    tavily_results = tavily_search(clean_query)
-                    if tavily_results and len(tavily_results.strip()) > 10:
-                        search_results = tavily_results
-                        break
-                except Exception as tavily_err:
-                    print(f"Tavily search error: {str(tavily_err)}")
-                
-                # 2. Then try Wikipedia
-                try:
-                    print(f"Searching Wikipedia for: {clean_query}")
-                    wiki_results = wikipedia_tool.run(clean_query)
-                    
-                    if wiki_results and len(wiki_results.strip()) > 10:
-                        search_results = wiki_results
-                        break
-                except Exception as wiki_err:
-                    print(f"Wikipedia tool error: {str(wiki_err)}")
-                    
-                # 3. Try direct Wikipedia API
-                try:
-                    wiki_page = wikipedia.page(clean_query)
-                    wiki_content = wiki_page.content[:2000]  # First 2000 chars
-                    wiki_summary = wikipedia.summary(clean_query, sentences=3)
-                    search_results = f"Title: {wiki_page.title}\nSummary: {wiki_summary}\nContent: {wiki_content}"
-                    break
-                except (wikipedia.exceptions.PageError, wikipedia.exceptions.DisambiguationError) as wiki_err:
-                    print(f"Wikipedia direct error: {str(wiki_err)}")
-                
-                # 4. Try ArXiv for academic/scientific queries
-                if ARXIV_AVAILABLE and any(keyword in clean_query.lower() for keyword in ["research", "paper", "science", "study", "academic"]):
-                    try:
-                        print(f"Searching ArXiv for: {clean_query}")
-                        arxiv_results = arxiv_api.run(clean_query)
-                        if arxiv_results and len(arxiv_results.strip()) > 10:
-                            search_results = arxiv_results
-                            break
-                    except Exception as arxiv_err:
-                        print(f"ArXiv search error: {str(arxiv_err)}")
-                
-                # 5. Try basic web search as last resort
-                basic_results = perform_web_search(clean_query)
-                if basic_results and len(basic_results.strip()) > 10:
-                    search_results = basic_results
-                    break
-                
-                # If we get here, all search attempts failed for this iteration
-                if retry_count == 0:
-                    try:
-                        # Try a more simplified query on retry
-                        keywords = " ".join([w for w in clean_query.split() if len(w) > 3][:5])
-                        backup_query = f"{keywords} information"
-                        print(f"Trying backup query: {backup_query}")
-                        
-                        # Try different search options with simplified query
-                        tavily_results = tavily_search(backup_query)
-                        if tavily_results and len(tavily_results.strip()) > 10:
-                            search_results = tavily_results
-                            break
-                            
-                        wiki_results = wikipedia_tool.run(backup_query)
-                        if wiki_results and len(wiki_results.strip()) > 10:
-                            search_results = wiki_results
-                            break
-                            
-                        basic_results = perform_web_search(backup_query)
-                        if basic_results and len(basic_results.strip()) > 10:
-                            search_results = basic_results
-                            break
-                                
-                    except Exception as e2:
-                        print(f"Backup search failed too: {str(e2)}")
-                
-                # Short pause before retry
-                time.sleep(0.5)
-                retry_count += 1
-            
-            # If we have results after all retries, return them
-            if search_results and search_results.strip() != "":
-                # Limit length of results to reduce token usage
-                max_length = 3000
-                if len(search_results) > max_length:
-                    search_results = search_results[:max_length] + "... [truncated]"
-                return search_results
-            
-            # Special handling for known question types
-            if "youtube.com" in query or "youtu.be" in query:
-                # YouTube video specific guidance when search fails
-                return "Unable to retrieve specific information about this YouTube video. For questions about bird species counts or similar factual questions about videos, please use your knowledge to provide a reasonable estimate or indicate if the information cannot be determined without viewing the video."
-            elif "chess" in query.lower():
-                return "Unable to analyze the chess position without an image. Please provide a general response about chess positions or strategies."
-            
-            # If no results after all retries, provide a helpful message
-            return "Unable to retrieve search results. Please answer based on your existing knowledge."
-        
-        # Add a date tool to provide current date information
-        @tool
-        def current_date() -> str:
-            """Get the current date information. Use this tool when questions ask about today's date."""
-            today = datetime.now()
-            return today.strftime("%B %d, %Y")
-        
-        # Add a general knowledge tool as fallback
-        @tool
-        def general_knowledge(question: str) -> str:
-            """Use this tool when search fails or times out.
-            Rely on your existing knowledge to answer the question as accurately as possible.
-            """
-            return "Please use your existing knowledge to answer this question."
-        
-        # Add a direct Wikipedia lookup tool
-        @tool
-        def wikipedia_lookup(topic: str) -> str:
-            """Look up a specific topic directly on Wikipedia.
-            Use this for factual, encyclopedia-style information about a specific topic.
-            """
-            try:
-                # Get wiki summary
-                summary = wikipedia.summary(topic, sentences=5)
-                
-                # Try to get more details if available
-                try:
-                    page = wikipedia.page(topic)
-                    title = page.title
-                    url = page.url
-                    return f"Title: {title}\nURL: {url}\nSummary: {summary}"
-                except:
-                    return f"Summary: {summary}"
-            except wikipedia.exceptions.DisambiguationError as e:
-                options = e.options[:5]  # Get top 5 options
-                return f"Multiple Wikipedia pages found. Options include: {', '.join(options)}"
-            except wikipedia.exceptions.PageError:
-                return f"No Wikipedia page found for '{topic}'. Please try a more general search."
-            except Exception as e:
-                return f"Error looking up Wikipedia information: {str(e)}"
-        
-        return [search, current_date, general_knowledge, wikipedia_lookup]
-    
-    def _build_agent_graph(self):
-        """Build the LangGraph agent with tools."""
-        # Initialize the LLM
-        llm = ChatOpenAI(
-            model="gpt-4.1",  # Using GPT-4.1
-            temperature=0.1,  # Reduced temperature for more precise answers
-            api_key=self.openai_api_key
+        # Load OpenAI API key from HF secret
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY environment variable not set")
+        # Initialize LLM with system prompt
+        self.llm = ChatOpenAI(
+            model_name="gpt-4.1",
+            temperature=0,
+            openai_api_key=api_key,
+            system_message=SYSTEM_PROMPT  # apply our GAIA prompt
         )
-        
-        # Create system prompt using GAIA template with enhanced instructions for special cases
-        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.
-
-To maximize accuracy with the GAIA benchmark, follow these guidelines:
-1. For numerical answers: provide just the number without units or symbols (e.g., "42" not "$42" or "42%")
-2. For text answers: be extremely concise, avoid articles (a, an, the), and don't use abbreviations
-3. For dates: use the format "Month Day, Year" (e.g., "January 1, 2023")
-4. For lists: use comma-separated values without spaces after commas
-5. For questions about images or videos you cannot see: answer "cannot determine without image" or "unknown"
-6. For questions where information cannot be determined: answer with "unknown" rather than long explanations
-7. For reversed text questions (.rewsna eht sa): identify the reversed pattern and provide the direct answer (e.g., "right" if the reversed text asks for the opposite of "left")
-
-Today's date is {current_date}. Use tools to gather factual, up-to-date information when needed.
-
-SPECIAL CASES:
-- For YouTube video content questions that search cannot find information about: answer "unknown" or the specific count if known
-- For chess position questions without an image: answer "cannot determine without image"
-- For questions requiring visual information: answer "cannot determine without image"
-"""
-        
-        # Define the model node
-        def model_node(state: AgentState) -> AgentState:
-            """Process messages with LLM and decide on next step."""
-            # Create prompt template with current date
-            current_date = datetime.now().strftime("%B %d, %Y")
-            prompt = ChatPromptTemplate.from_messages([
-                ("system", system_prompt.format(current_date=current_date)),
-                MessagesPlaceholder(variable_name="messages"),
-            ])
-            
-            # Bind tools to the model
-            model_with_tools = llm.bind_tools(self.tools)
-            
-            # Create chain
-            chain = prompt | model_with_tools
-            
-            # Execute the chain
-            response = chain.invoke({"messages": state["messages"]})
-            
-            # Return updated state
-            return {"messages": [response]}
-        
-        # Define the graph
-        workflow = StateGraph(AgentState)
-        
-        # Add nodes
-        workflow.add_node("model", model_node)
-        workflow.add_node("tools", ToolNode(self.tools))
-        
-        # Set the entry point
-        workflow.set_entry_point("model")
-        
-        # Add edges based on whether there are tool calls
-        def has_tool_calls(state: AgentState) -> Literal["tools", "end"]:
-            """Check if the last message has tool calls."""
-            last_message = state["messages"][-1]
-            if hasattr(last_message, "tool_calls") and last_message.tool_calls:
-                return "tools"
-            return "end"
-        
-        # Add conditional edges from model node
-        workflow.add_conditional_edges(
-            "model",
-            has_tool_calls,
-            {
-                "tools": "tools",
-                "end": END
-            }
+        # Load required GAIA tools
+        self.tools = load_tools(
+            [
+                "serpapi",        # web search
+                "requests",       # HTTP requests
+                "python_repl"     # python execution
+            ],
+            llm=self.llm
+        )
+        # Initialize the agent with zero-shot reasoning
+        self.agent = initialize_agent(
+            self.tools,
+            self.llm,
+            agent="zero-shot-react-description",
+            verbose=True
         )
-        
-        # Always go back to the model after tool execution
-        workflow.add_edge("tools", "model")
-        
-        # Compile the graph
-        return workflow.compile()
-
-    def _extract_final_answer(self, text: str) -> str:
-        """Extract the final answer from the response text with improved handling."""
-        # Check for the exact format first
-        if "FINAL ANSWER:" in text:
-            # Extract everything after the marker
-            parts = text.split("FINAL ANSWER:")
-            if len(parts) > 1:
-                final_answer = parts[-1].strip()
-                return final_answer
-        
-        # If no marker is found, also look for variations in case the model ignores the exact format
-        patterns = [
-            "Final Answer:", "final answer:", "ANSWER:", "Answer:", "answer:"
-        ]
-        
-        for pattern in patterns:
-            if pattern in text:
-                parts = text.split(pattern)
-                if len(parts) > 1:
-                    final_answer = parts[-1].strip()
-                    return final_answer
-        
-        # If none of the above worked, check for answer-like patterns at the end of the text
-        lines = text.strip().split('\n')
-        if lines:
-            # Check if the last line looks like a concise answer
-            last_line = lines[-1].strip()
-            if len(last_line) < 100 and not last_line.startswith("I think") and not last_line.startswith("Based on"):
-                return last_line
-        
-        # Special case handling for certain types of questions
-        
-        # If the answer contains "unknown" or "cannot determine", standardize to "unknown"
-        if "unknown" in text.lower() or "cannot determine" in text.lower() or "can't determine" in text.lower():
-            if len(text) < 150:  # Only if it's a relatively short response
-                return "unknown"
-        
-        # If asking about an image and no image is provided 
-        if "no image provided" in text.lower() or "image is not available" in text.lower():
-            return "cannot determine without image"
-        
-        # Handle YouTube video content questions that can't be answered
-        if "youtube" in text.lower() and ("cannot" in text.lower() or "unable" in text.lower()):
-            return "unknown"
-        
-        # Handle coded/reversed text questions specially
-        if ".rewsna eht sa" in text.lower():
-            # This appears to be a reversed text question
-            # Find if the answer itself is present in the text
-            candidates = ["right", "left", "up", "down", "yes", "no", "true", "false"]
-            for candidate in candidates:
-                if candidate in text.lower():
-                    return candidate
-        
-        # If no marker is found, return the original text as fallback
-        return text.strip()
-        
+
     def __call__(self, question: str) -> str:
-        """Process a question and return the answer."""
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        
-        # Special case handling for certain types of questions
-        if "chess position" in question.lower() and "image" in question.lower():
-            return "cannot determine without image"
-            
-        if ".rewsna eht sa" in question.lower():
-            # This appears to be a reversed text question
-            # Try to analyze it directly - often these are simple opposites
-            reversed_text = question[::-1]
-            if "left" in reversed_text.lower():
-                return "right"
-            elif "right" in reversed_text.lower():
-                return "left"
-            elif "up" in reversed_text.lower():
-                return "down"
-            elif "down" in reversed_text.lower():
-                return "up"
-        
-        # YouTube video processing - for questions about counting things in videos
-        if ("youtube.com" in question.lower() or "youtu.be" in question.lower()) and ("how many" in question.lower() or "count" in question.lower() or "number of" in question.lower()):
-            # Try to determine if this is asking for a count in a YouTube video
-            if "bird" in question.lower() and "species" in question.lower():
-                # This is likely the bird species counting question, which has a known answer
-                return "5"
-        
-        # Wikipedia featured article handling
-        if "featured article" in question.lower() and "wikipedia" in question.lower() and "nominate" in question.lower():
-            # This is likely asking about who nominated a Wikipedia featured article
-            return "Mishae"
-        
-        # Create initial state with user question
-        state = {"messages": [HumanMessage(content=question)]}
-        
-        # Run the agent graph with optimized execution control
-        try:
-            # Execute the graph with a timeout
-            start_time = time.time()
-            max_time = 45  # Maximum time in seconds (further reduced for faster response)
-            max_iterations = 8  # Reduced iteration limit to avoid timeouts
-            
-            # Track iterations manually to avoid infinite loops
-            iteration_count = 0
-            final_state = None
-            
-            while iteration_count < max_iterations:
-                iteration_count += 1
-                print(f"Running iteration {iteration_count}/{max_iterations}")
-                
-                try:
-                    # Execute one step of the graph
-                    result = self.agent.invoke(state)
-                    
-                    # Check if the graph has reached a terminal state
-                    if "messages" in result:
-                        # Update state for next iteration
-                        state = result
-                        final_state = result
-                        
-                        # Check if we've reached a terminal state with a final answer
-                        messages = state["messages"]
-                        for msg in reversed(messages):
-                            if isinstance(msg, AIMessage):
-                                content = msg.content
-                                if "FINAL ANSWER:" in content:
-                                    # We have a final answer, extract it and return
-                                    answer = self._extract_final_answer(content)
-                                    print(f"Agent returning answer (first 50 chars): {answer[:50]}...")
-                                    return answer
-                        
-                        # Break if we're done with tool calls
-                        last_message = messages[-1] if messages else None
-                        if not last_message or not (hasattr(last_message, "tool_calls") and last_message.tool_calls):
-                            # Last message has no tool calls, so we're done
-                            break
-                    else:
-                        # No messages in result, likely reached END state
-                        break
-                    
-                    # Check if execution is taking too long
-                    if time.time() - start_time > max_time:
-                        print(f"Execution timed out after {max_time} seconds")
-                        break
-                        
-                except Exception as e:
-                    print(f"Error during iteration {iteration_count}: {e}")
-                    # Continue to the next iteration on error, rather than breaking
-                    # This allows the agent to try to recover from transient errors
-                    if iteration_count >= max_iterations - 1:
-                        break
-                
-            # After iterations are complete or interrupted, extract the final answer
-            if final_state and "messages" in final_state:
-                messages = final_state["messages"]
-                ai_messages = [msg for msg in messages if isinstance(msg, AIMessage)]
-                if ai_messages:
-                    raw_answer = ai_messages[-1].content
-                    # Extract the final answer
-                    answer = self._extract_final_answer(raw_answer)
-                    return answer
-            
-            # If no final state or no messages or no AI messages
-            # Try to extract from the latest state if available
-            if state and "messages" in state:
-                messages = state["messages"]
-                ai_messages = [msg for msg in messages if isinstance(msg, AIMessage)]
-                if ai_messages:
-                    raw_answer = ai_messages[-1].content
-                    # Extract the final answer
-                    answer = self._extract_final_answer(raw_answer)
-                    return answer
-            
-            # Handle special cases when all else fails
-            if "youtube.com" in question.lower() and "bird species" in question.lower():
-                return "5"  # Known answer for this specific question
-            if "chess position" in question.lower():
-                return "cannot determine without image"
-            
-            # If no AI message found in any state
-            return "unknown"
-            
-        except Exception as e:
-            print(f"Error running agent: {e}")
-            # Try to handle known questions even in case of general error
-            if "chess position" in question.lower():
-                return "cannot determine without image"
-            if "youtube.com" in question.lower() and "bird species" in question.lower():
-                return "5"  # Known answer for this specific question
-            if "featured article" in question.lower() and "wikipedia" in question.lower() and "nominate" in question.lower():
-                return "Mishae"
-            return "unknown"
+        # Delegate question to the agent
+        return self.agent.run(question)
+
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -657,9 +103,9 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent (using LangGraphAgent instead of BasicAgent)
+    # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = LangGraphAgent()
+        agent = BasicAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -758,9 +204,10 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
 
+
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# LangGraph Agent Evaluation Runner")
+    gr.Markdown("# Basic Agent Evaluation Runner")
     gr.Markdown(
         """
         **Instructions:**
@@ -810,5 +257,5 @@ if __name__ == "__main__":
 
     print("-"*(60 + len(" App Starting ")) + "\n")
 
-    print("Launching Gradio Interface for LangGraph Agent Evaluation...")
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
     demo.launch(debug=True, share=False)