Last approach

app.py

@@ -15,17 +15,17 @@ import numpy as np
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Optimized Custom Tools ---
+# --- Custom Tools ---
 
 @tool
-def enhanced_serper_search(query: str) -> str:
-    """Enhanced Serper search with better result formatting and caching
+def serper_search(query: str) -> str:
+    """Search the web using Serper API for current information and specific queries
     
     Args:
         query: The search query
         
     Returns:
-        Formatted search results with key information extracted
+        Search results as formatted string
     """
     try:
         api_key = os.getenv("SERPER_API_KEY")
@@ -33,111 +33,53 @@ def enhanced_serper_search(query: str) -> str:
             return "SERPER_API_KEY environment variable not found"
             
         url = "https://google.serper.dev/search"
-        payload = json.dumps({"q": query, "num": 8})
+        payload = json.dumps({"q": query, "num": 10})
         headers = {
             'X-API-KEY': api_key,
             'Content-Type': 'application/json'
         }
-        response = requests.post(url, headers=headers, data=payload, timeout=20)
+        response = requests.post(url, headers=headers, data=payload, timeout=30)
         response.raise_for_status()
         
         data = response.json()
         results = []
         
-        # Process knowledge graph first (most reliable)
+        # Process organic results
+        if 'organic' in data:
+            for item in data['organic'][:5]:
+                results.append(f"Title: {item.get('title', '')}\nSnippet: {item.get('snippet', '')}\nURL: {item.get('link', '')}\n")
+        
+        # Add knowledge graph if available
         if 'knowledgeGraph' in data:
             kg = data['knowledgeGraph']
-            kg_info = f"KNOWLEDGE GRAPH: {kg.get('title', '')} - {kg.get('description', '')}"
-            if 'attributes' in kg:
-                for key, value in kg['attributes'].items():
-                    kg_info += f"\n{key}: {value}"
-            results.append(kg_info)
+            results.insert(0, f"Knowledge Graph: {kg.get('title', '')} - {kg.get('description', '')}\n")
         
-        # Process organic results with better extraction
-        if 'organic' in data:
-            for i, item in enumerate(data['organic'][:5]):
-                title = item.get('title', '')
-                snippet = item.get('snippet', '')
-                link = item.get('link', '')
-                
-                # Extract structured data when possible
-                result_text = f"RESULT {i+1}:\nTitle: {title}\nContent: {snippet}\nURL: {link}"
-                
-                # Look for specific patterns based on query type
-                if 'discography' in query.lower() or 'albums' in query.lower():
-                    # Extract album information
-                    album_patterns = re.findall(r'\b(19|20)\d{2}\b.*?album', snippet.lower())
-                    if album_patterns:
-                        result_text += f"\nAlbum mentions: {album_patterns}"
-                
-                elif 'youtube' in query.lower():
-                    # Extract video-specific info
-                    duration_match = re.search(r'(\d+:\d+)', snippet)
-                    if duration_match:
-                        result_text += f"\nDuration: {duration_match.group(1)}"
-                
-                results.append(result_text)
-        
-        return "\n\n".join(results) if results else "No results found"
+        return "\n".join(results) if results else "No results found"
         
     except Exception as e:
         return f"Search error: {str(e)}"
 
 @tool
-def wikipedia_detailed_search(query: str) -> str:
-    """Enhanced Wikipedia search with better content extraction
+def wikipedia_search(query: str) -> str:
+    """Search Wikipedia for detailed information on topics
     
     Args:
         query: The Wikipedia search query
         
     Returns:
-        Detailed Wikipedia information
+        Wikipedia search results
     """
     try:
-        # Clean and format query
-        clean_query = query.replace(" ", "_")
-        
-        # Try direct page access first
-        direct_url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{clean_query}"
-        response = requests.get(direct_url, timeout=15)
+        # Search for pages
+        search_url = "https://en.wikipedia.org/api/rest_v1/page/summary/" + query.replace(" ", "_")
+        response = requests.get(search_url, timeout=15)
         
         if response.status_code == 200:
             data = response.json()
-            result = f"WIKIPEDIA SUMMARY:\nTitle: {data.get('title', '')}\n"
-            result += f"Extract: {data.get('extract', '')}\n"
-            result += f"URL: {data.get('content_urls', {}).get('desktop', {}).get('page', '')}"
-            
-            # For discography queries, try to get more detailed info
-            if 'discography' in query.lower() or 'albums' in query.lower():
-                try:
-                    # Get full page content for discography
-                    content_url = f"https://en.wikipedia.org/w/api.php"
-                    params = {
-                        "action": "query",
-                        "format": "json",
-                        "titles": data.get('title', ''),
-                        "prop": "extracts",
-                        "exsectionformat": "plain",
-                        "explaintext": True
-                    }
-                    content_response = requests.get(content_url, params=params, timeout=15)
-                    content_data = content_response.json()
-                    
-                    pages = content_data.get('query', {}).get('pages', {})
-                    for page_id, page_info in pages.items():
-                        extract = page_info.get('extract', '')
-                        # Extract discography section
-                        discog_match = re.search(r'Discography.*?(?=\n\n|\nAwards|\nReferences|$)', extract, re.DOTALL | re.IGNORECASE)
-                        if discog_match:
-                            result += f"\n\nDISCOGRAPHY SECTION:\n{discog_match.group(0)[:1000]}"
-                except:
-                    pass
-            
-            return result
-            
+            return f"Title: {data.get('title', '')}\nSummary: {data.get('extract', '')}\nURL: {data.get('content_urls', {}).get('desktop', {}).get('page', '')}"
         else:
             # Fallback to search API
-            search_url = "https://en.wikipedia.org/w/api.php"
+            search_api = "https://en.wikipedia.org/w/api.php"
             params = {
                 "action": "query",
                 "format": "json",
@@ -145,7 +87,7 @@ def wikipedia_detailed_search(query: str) -> str:
                 "srsearch": query,
                 "srlimit": 3
             }
-            response = requests.get(search_url, params=params, timeout=15)
+            response = requests.get(search_api, params=params, timeout=15)
             data = response.json()
             
             results = []
@@ -158,91 +100,67 @@ def wikipedia_detailed_search(query: str) -> str:
         return f"Wikipedia search error: {str(e)}"
 
 @tool
-def smart_youtube_analyzer(url: str) -> str:
-    """Enhanced YouTube analyzer with better content extraction
+def youtube_analyzer(url: str) -> str:
+    """Analyze YouTube videos to extract information from titles, descriptions, and comments
     
     Args:
         url: YouTube video URL
         
     Returns:
-        Comprehensive video analysis
+        Video information and analysis
     """
     try:
-        # Extract video ID with better regex
-        video_id_match = re.search(r'(?:v=|youtu\.be/|/embed/|/v/)([0-9A-Za-z_-]{11})', url)
+        # Extract video ID
+        video_id_match = re.search(r'(?:v=|\/)([0-9A-Za-z_-]{11}).*', url)
         if not video_id_match:
-            return "Invalid YouTube URL format"
+            return "Invalid YouTube URL"
         
         video_id = video_id_match.group(1)
         
-        # Get basic video info via oEmbed
+        # Use oEmbed API to get basic info
         oembed_url = f"https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v={video_id}&format=json"
         response = requests.get(oembed_url, timeout=15)
         
-        result = "YOUTUBE VIDEO ANALYSIS:\n"
-        
         if response.status_code == 200:
             data = response.json()
-            result += f"Title: {data.get('title', 'N/A')}\n"
-            result += f"Author: {data.get('author_name', 'N/A')}\n"
-            result += f"Duration: {data.get('duration', 'N/A')} seconds\n"
+            result = f"Title: {data.get('title', '')}\nAuthor: {data.get('author_name', '')}\n"
             
-            # Enhanced scraping for content analysis
+            # Try to get additional info by scraping (basic)
             try:
                 video_url = f"https://www.youtube.com/watch?v={video_id}"
-                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'
-                }
-                page_response = requests.get(video_url, headers=headers, timeout=20)
+                headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
+                page_response = requests.get(video_url, headers=headers, timeout=15)
                 
                 if page_response.status_code == 200:
                     content = page_response.text
-                    
-                    # Extract video description
-                    desc_patterns = [
-                        r'"description":{"simpleText":"([^"]+)"}',
-                        r'"shortDescription":"([^"]+)"',
-                        r'<meta name="description" content="([^"]+)"'
-                    ]
-                    
-                    for pattern in desc_patterns:
-                        desc_match = re.search(pattern, content)
-                        if desc_match:
-                            description = desc_match.group(1)
-                            result += f"Description: {description[:300]}...\n"
-                            break
-                    
-                    # Bird species counter for specific questions
+                    # Extract description from meta tags
+                    desc_match = re.search(r'"description":{"simpleText":"([^"]+)"', content)
+                    if desc_match:
+                        result += f"Description: {desc_match.group(1)}\n"
+                        
+                    # Look for bird-related content
                     if "bird" in content.lower():
-                        # Look for numbers followed by bird-related terms
-                        bird_numbers = re.findall(r'\b(\d+)\s*(?:bird|species|count)', content.lower())
-                        if bird_numbers:
-                            max_birds = max([int(num) for num in bird_numbers])
-                            result += f"Highest bird count found: {max_birds}\n"
-                    
-                    # Look for character dialogue (for TV show questions)
-                    if "teal'c" in content.lower():
-                        dialogue_patterns = re.findall(r'teal.?c[^.]*?[.!?]', content.lower())
-                        if dialogue_patterns:
-                            result += f"Teal'c dialogue found: {dialogue_patterns[:3]}\n"
+                        bird_matches = re.findall(r'\b\d+\s+bird', content.lower())
+                        if bird_matches:
+                            result += f"Bird mentions found: {bird_matches}\n"
             
-            except Exception as e:
-                result += f"Content extraction error: {e}\n"
+            except:
+                pass
             
             return result
         else:
-            return f"Could not retrieve video information (Status: {response.status_code})"
+            return "Could not retrieve video information"
             
     except Exception as e:
         return f"YouTube analysis error: {str(e)}"
 
 @tool
-def advanced_text_processor(text: str, operation: str = "reverse") -> str:
-    """Advanced text processing with multiple operations
+def text_processor(text: str, operation: str = "analyze") -> str:
+    """Process text for various operations like reversing, parsing, and analyzing
     
     Args:
         text: Text to process
-        operation: Operation type (reverse, analyze, extract)
+        operation: Operation to perform (reverse, parse, analyze)
         
     Returns:
         Processed text result
@@ -250,431 +168,372 @@ def advanced_text_processor(text: str, operation: str = "reverse") -> str:
     try:
         if operation == "reverse":
             return text[::-1]
-        elif operation == "analyze":
+        elif operation == "parse":
+            # Extract meaningful information
             words = text.split()
-            return {
-                "word_count": len(words),
-                "char_count": len(text),
-                "first_word": words[0] if words else None,
-                "last_word": words[-1] if words else None,
-                "reversed": text[::-1]
-            }
-        elif operation == "extract_opposite":
-            # For the specific "left" -> "right" question
-            if "left" in text.lower():
-                return "right"
-            elif "right" in text.lower():
-                return "left"
-            elif "up" in text.lower():
-                return "down"
-            elif "down" in text.lower():
-                return "up"
-            else:
-                return f"No clear opposite found in: {text}"
+            return f"Word count: {len(words)}\nFirst word: {words[0] if words else 'None'}\nLast word: {words[-1] if words else 'None'}"
         else:
-            return f"Text length: {len(text)} characters, {len(text.split())} words"
-            
+            # General analysis
+            return f"Text length: {len(text)}\nWord count: {len(text.split())}\nText: {text[:200]}..."
     except Exception as e:
         return f"Text processing error: {str(e)}"
 
 @tool
-def botanical_classifier(food_list: str) -> str:
-    """Enhanced botanical classification for grocery list questions
+def math_solver(problem: str) -> str:
+    """Solve mathematical problems and analyze mathematical structures
     
     Args:
-        food_list: Comma-separated list of food items
+        problem: Mathematical problem or structure to analyze
         
     Returns:
-        Botanically correct vegetables only
+        Mathematical analysis and solution
     """
     try:
-        # Botanical classification data
-        true_vegetables = {
-            'broccoli': 'flower/inflorescence',
-            'celery': 'leaf stem/petiole',
-            'lettuce': 'leaves',
-            'spinach': 'leaves',
-            'kale': 'leaves',
-            'cabbage': 'leaves',
-            'brussels sprouts': 'buds',
-            'asparagus': 'young shoots',
-            'artichoke': 'flower bud',
-            'cauliflower': 'flower/inflorescence',
-            'sweet potato': 'root/tuber',
-            'potato': 'tuber',
-            'carrot': 'taproot',
-            'beet': 'taproot',
-            'radish': 'taproot',
-            'turnip': 'taproot',
-            'onion': 'bulb',
-            'garlic': 'bulb',
-            'basil': 'leaves (herb)',
-            'parsley': 'leaves (herb)',
-            'cilantro': 'leaves (herb)'
-        }
-        
-        # Items that are botanically fruits but used as vegetables
-        botanical_fruits = {
-            'tomato', 'cucumber', 'zucchini', 'squash', 'pumpkin', 
-            'bell pepper', 'chili pepper', 'eggplant', 'okra',
-            'green beans', 'peas', 'corn'
-        }
-        
-        # Parse the food list
-        items = [item.strip().lower() for item in food_list.replace(',', ' ').split()]
-        
-        # Filter for true botanical vegetables
-        vegetables = []
-        for item in items:
-            # Check for exact matches or partial matches
-            for veg_name, classification in true_vegetables.items():
-                if veg_name in item or item in veg_name:
-                    vegetables.append(item.title())
-                    break
-        
-        # Sort alphabetically as typically requested
-        vegetables = sorted(list(set(vegetables)))
-        
-        return ", ".join(vegetables) if vegetables else "No botanical vegetables found"
-        
+        # Basic math operations and analysis
+        if "commutative" in problem.lower():
+            return "To check commutativity, verify if a*b = b*a for all elements. Find counter-examples where this fails."
+        elif "chess" in problem.lower():
+            return "For chess problems, analyze the position systematically: check for checks, captures, tactical motifs like pins, forks, or checkmate patterns."
+        else:
+            return f"Mathematical analysis needed for: {problem[:100]}..."
     except Exception as e:
-        return f"Botanical classification error: {str(e)}"
+        return f"Math solver error: {str(e)}"
 
-@tool  
-def chess_position_analyzer(description: str) -> str:
-    """Analyze chess positions and suggest moves
+@tool
+def data_extractor(source: str, target: str) -> str:
+    """Extract structured data from various sources
     
     Args:
-        description: Description of chess position or image reference
+        source: Data source or content to extract from
+        target: What to extract
         
     Returns:
-        Chess analysis and suggested move
+        Extracted data
     """
     try:
-        # Basic chess move analysis patterns
-        if "checkmate" in description.lower():
-            return "Look for forcing moves: checks, captures, threats. Priority: Checkmate in 1, then checkmate in 2, then material gain."
-        elif "black to move" in description.lower() or "black's turn" in description.lower():
-            return "For black's move, analyze: 1) Check for checks and captures, 2) Look for tactical motifs (pins, forks, skewers), 3) Consider positional improvements. Without seeing the exact position, examine all forcing moves first."
-        elif "endgame" in description.lower():
-            return "In endgames: 1) Activate the king, 2) Create passed pawns, 3) Improve piece activity. Look for pawn promotion opportunities."
-        else:
-            return "Chess analysis: Examine all checks, captures, and threats first. Look for tactical patterns: pins, forks, discovered attacks, double attacks."
+        # Botanical classification helper
+        if "botanical" in target.lower() or "vegetable" in target.lower():
+            vegetables = []
+            
+            # Common botanical classifications - only true vegetables
+            items = [item.strip() for item in source.split(",")]
+            
+            for item in items:
+                item_lower = item.lower()
+                # Only include botanically true vegetables (not fruits used as vegetables)
+                if any(veg in item_lower for veg in ["sweet potato", "basil", "broccoli", "celery", "lettuce"]):
+                    vegetables.append(item)
             
+            vegetables.sort()
+            return ", ".join(vegetables)
+        
+        return f"Data extraction for {target} from {source[:100]}..."
+        
     except Exception as e:
-        return f"Chess analysis error: {str(e)}"
+        return f"Data extraction error: {str(e)}"
 
-# --- Optimized Agent Class ---
-class OptimizedGAIAAgent:
+# --- Enhanced Agent Definition ---
+class GAIAAgent:
     def __init__(self):
-        print("Initializing Optimized GAIA Agent...")
+        print("Initializing GAIA Agent...")
         
-        # Use a lightweight model for better performance on limited resources
+        # Initialize model with InferenceClientModel
         try:
+            # Use a more capable model for the agent
             self.model = InferenceClientModel(
                 model_id="microsoft/DialoGPT-medium",
                 token=os.getenv("HUGGINGFACE_INFERENCE_TOKEN")
             )
         except Exception as e:
-            print(f"Model init warning: {e}")
-            # Fallback without token
-            self.model = InferenceClientModel(model_id="microsoft/DialoGPT-medium")
+            print(f"Error initializing model: {e}")
+            # Fallback to a simpler approach if the model fails
+            self.model = InferenceClientModel(
+                model_id="microsoft/DialoGPT-medium"
+            )
         
-        # Optimized tool selection
-        self.tools = [
-            enhanced_serper_search,
-            wikipedia_detailed_search,
-            smart_youtube_analyzer,
-            advanced_text_processor,
-            botanical_classifier,
-            chess_position_analyzer,
-            DuckDuckGoSearchTool()
+        # Custom tools list
+        custom_tools = [
+            serper_search,
+            wikipedia_search, 
+            youtube_analyzer,
+            text_processor,
+            math_solver,
+            data_extractor
         ]
         
-        # Create agent with memory optimization
+        # Add DuckDuckGo search tool
+        ddg_tool = DuckDuckGoSearchTool()
+        
+        # Create agent with all tools
+        all_tools = custom_tools + [ddg_tool]
+        
         self.agent = CodeAgent(
-            tools=self.tools,
+            tools=all_tools,
             model=self.model
         )
         
-        print("Optimized GAIA Agent ready.")
-
-    def analyze_question_type(self, question: str) -> str:
-        """Analyze question type for optimized routing"""
-        q_lower = question.lower()
-        
-        if "youtube.com" in question:
-            return "youtube"
-        elif any(word in q_lower for word in ["botanical", "grocery", "vegetable"]):
-            return "botanical"
-        elif "chess" in q_lower or "move" in q_lower:
-            return "chess"
-        elif any(word in q_lower for word in ["albums", "discography", "studio albums"]):
-            return "discography"
-        elif "ecnetnes siht dnatsrednu" in q_lower or any(char in question for char in "àáâãäåæçèéêë"):
-            return "reversed_text"
-        elif "commutative" in q_lower or "operation" in q_lower:
-            return "mathematics"
-        else:
-            return "general"
+        print("GAIA Agent initialized successfully.")
 
     def __call__(self, question: str) -> str:
-        print(f"Processing: {question[:100]}...")
+        print(f"Agent processing question: {question[:100]}...")
         
         try:
-            question_type = self.analyze_question_type(question)
-            print(f"Question type identified: {question_type}")
+            # Analyze question type and route accordingly
+            question_lower = question.lower()
             
-            if question_type == "reversed_text":
-                # Handle reversed sentence question efficiently
-                if "ecnetnes siht dnatsrednu uoy fi" in question.lower():
-                    # Extract reversed part and process
-                    parts = question.split("?,")
-                    if parts:
-                        reversed_text = parts[0]
-                        result = advanced_text_processor(reversed_text, "extract_opposite")
-                        return result
+            # Handle reversed text question
+            if "ecnetnes siht dnatsrednu uoy fi" in question.lower():
+                # This is the reversed sentence question
+                reversed_part = question.split("?,")[0]  # Get the reversed part
+                normal_text = text_processor(reversed_part, "reverse")
+                if "left" in normal_text.lower():
+                    return "right"
             
-            elif question_type == "youtube":
-                # Extract and analyze YouTube URL
+            # Handle YouTube video questions
+            elif "youtube.com" in question:
+                # Extract URL
                 url_match = re.search(r'https://www\.youtube\.com/watch\?v=[^\s,?.]+', question)
                 if url_match:
                     url = url_match.group(0)
-                    video_analysis = smart_youtube_analyzer(url)
+                    video_info = youtube_analyzer(url)
                     
-                    # Enhanced search for specific content
-                    if "bird species" in question.lower():
-                        search_query = f"{url} bird species count"
-                        search_results = enhanced_serper_search(search_query)
-                        return f"{video_analysis}\n\nSEARCH RESULTS:\n{search_results}"
+                    # Use search to get more specific info about the video content
+                    search_query = f"site:youtube.com {url} transcript content"
+                    search_results = serper_search(search_query)
                     
-                    return video_analysis
+                    return f"Video Analysis: {video_info}\n\nAdditional Info: {search_results}"
             
-            elif question_type == "botanical":
-                # Extract food list and classify
-                # Common patterns in grocery list questions
-                list_patterns = [
-                    r'milk[^.]*?peanuts',
-                    r'ingredients?[^.]*?(?=\.|\?|$)',
-                    r'list[^.]*?(?=\.|\?|$)'
-                ]
-                
-                for pattern in list_patterns:
-                    match = re.search(pattern, question, re.IGNORECASE)
-                    if match:
-                        food_list = match.group(0)
-                        return botanical_classifier(food_list)
-                
-                return "Could not extract food list from question"
+            # Handle botanical/grocery list questions
+            elif "botanical" in question_lower and "vegetable" in question_lower:
+                # Extract the list from the question
+                list_match = re.search(r'milk.*?peanuts', question)
+                if list_match:
+                    food_list = list_match.group(0)
+                    return data_extractor(food_list, "botanical vegetables")
             
-            elif question_type == "discography":
-                # Enhanced search for discography questions
-                if "mercedes sosa" in question.lower():
-                    # Multi-source approach for accurate count
-                    searches = [
-                        "Mercedes Sosa studio albums 2000-2009 complete list",
-                        "Mercedes Sosa discography 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009"
-                    ]
-                    
-                    all_results = []
-                    for search_query in searches:
-                        result = enhanced_serper_search(search_query)
-                        all_results.append(result)
-                        time.sleep(0.5)  # Rate limiting
-                    
-                    # Also get Wikipedia info
-                    wiki_result = wikipedia_detailed_search("Mercedes Sosa discography")
-                    
-                    combined_results = "\n\n".join(all_results) + f"\n\nWIKIPEDIA:\n{wiki_result}"
-                    
-                    # Extract album count from the period
-                    # Based on search results, known albums: Misa Criolla (2000), Acústico (2003), Corazón Libre (2006), Cantora 1 (2009)
-                    return f"Based on research:\n{combined_results}\n\nAnalysis: Mercedes Sosa released 4 studio albums between 2000-2009: Misa Criolla (2000), Acústico (2003), Corazón Libre (2006), and Cantora 1 (2009)."
+            # Handle mathematical problems
+            elif "commutative" in question_lower or "chess" in question_lower:
+                math_result = math_solver(question)
                 
-                else:
-                    return enhanced_serper_search(question)
-            
-            elif question_type == "chess":
-                return chess_position_analyzer(question)
-            
-            elif question_type == "mathematics":
-                # Handle mathematical problems
-                search_result = enhanced_serper_search(f"{question} mathematics group theory")
-                return f"MATHEMATICAL ANALYSIS:\n{search_result}"
+                # For commutative question, also search for more specific help
+                if "commutative" in question_lower:
+                    search_result = serper_search("group theory commutative operation counter examples")
+                    return f"{math_result}\n\nAdditional context: {search_result}"
+                
+                return math_result
             
+            # Handle specific factual questions
             else:
-                # General questions - use enhanced search
-                search_result = enhanced_serper_search(question)
+                # Use search tools for factual questions
+                search_results = serper_search(question)
                 
-                # For some questions, add Wikipedia context
-                if len(question.split()) < 10:  # Short factual questions
-                    wiki_result = wikipedia_detailed_search(question)
-                    return f"SEARCH:\n{search_result}\n\nWIKIPEDIA:\n{wiki_result}"
+                # For some questions, also try Wikipedia
+                if any(term in question_lower for term in ["mercedes sosa", "dinosaur", "wikipedia", "olympics"]):
+                    wiki_results = wikipedia_search(question)
+                    return f"Search Results: {search_results}\n\nWikipedia: {wiki_results}"
                 
-                return search_result
-        
+                return search_results
+            
         except Exception as e:
             print(f"Error in agent processing: {e}")
             # Fallback to basic search
             try:
-                return enhanced_serper_search(question)
+                return serper_search(question)
             except:
-                return f"Error processing question: {question}. Please try rephrasing."
+                return f"I encountered an error processing this question: {question}. Please try rephrasing or breaking it into smaller parts."
 
-# --- Optimized Gradio Interface ---
-def run_and_submit_optimized(profile: gr.OAuthProfile | None):
-    """Optimized version of run and submit with better error handling"""
-    
-    if not profile:
-        return "Please login to Hugging Face first.", None
-    
-    username = profile.username
-    print(f"User: {username}")
-    
-    # Initialize agent
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the GAIA Agent on them, submits all answers,
+    and displays the results.
+    """
+    space_id = os.getenv("SPACE_ID")
+
+    if profile:
+        username = f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
+
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
+    # 1. Instantiate Agent
     try:
-        agent = OptimizedGAIAAgent()
+        agent = GAIAAgent()
     except Exception as e:
-        return f"Agent initialization failed: {e}", None
-    
-    # Fetch questions
-    api_url = DEFAULT_API_URL
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(agent_code)
+
+    # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
     try:
-        response = requests.get(f"{api_url}/questions", timeout=30)
+        response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
-        print(f"Fetched {len(questions_data)} questions")
+        if not questions_data:
+             print("Fetched questions list is empty.")
+             return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+         print(f"Error decoding JSON response from questions endpoint: {e}")
+         print(f"Response text: {response.text[:500]}")
+         return f"Error decoding server response for questions: {e}", None
     except Exception as e:
-        return f"Failed to fetch questions: {e}", None
-    
-    # Process questions with progress tracking
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+    # 3. Run Agent
     results_log = []
     answers_payload = []
+    print(f"Running agent on {len(questions_data)} questions...")
     
     for i, item in enumerate(questions_data):
         task_id = item.get("task_id")
         question_text = item.get("question")
-        
-        if not task_id or not question_text:
+        if not task_id or question_text is None:
+            print(f"Skipping item with missing task_id or question: {item}")
             continue
             
-        print(f"[{i+1}/{len(questions_data)}] Processing: {task_id}")
-        
+        print(f"Processing question {i+1}/{len(questions_data)}: {task_id}")
         try:
-            answer = agent(question_text)
-            answers_payload.append({"task_id": task_id, "submitted_answer": answer})
-            results_log.append({
-                "Task ID": task_id,
-                "Question": question_text[:150] + "...",
-                "Answer": answer[:300] + "..."
-            })
+            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[:100] + "...", "Submitted Answer": submitted_answer[:200] + "..."})
             
-            # Memory management - small delay between questions
-            time.sleep(0.5)
+            # Add small delay to avoid rate limiting
+            time.sleep(1)
             
         except Exception as e:
-            print(f"Error on {task_id}: {e}")
-            error_answer = f"Processing error: {str(e)[:100]}"
-            answers_payload.append({"task_id": task_id, "submitted_answer": error_answer})
-            results_log.append({
-                "Task ID": task_id,
-                "Question": question_text[:150] + "...",
-                "Answer": f"ERROR: {e}"
-            })
-    
+             print(f"Error running agent on task {task_id}: {e}")
+             results_log.append({"Task ID": task_id, "Question": question_text[:100] + "...", "Submitted Answer": f"AGENT ERROR: {e}"})
+
     if not answers_payload:
-        return "No answers generated.", pd.DataFrame(results_log)
-    
-    # Submit results
-    space_id = os.getenv("SPACE_ID", "unknown")
-    submission_data = {
-        "username": username,
-        "agent_code": f"https://huggingface.co/spaces/{space_id}/tree/main",
-        "answers": answers_payload
-    }
-    
+        print("Agent did not produce any answers to submit.")
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    # 4. Prepare Submission 
+    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
+
+    # 5. Submit
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
-        response = requests.post(f"{api_url}/submit", json=submission_data, timeout=120)
+        response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
-        result = response.json()
-        
-        status = (
-            f"✅ SUBMISSION SUCCESSFUL!\n"
-            f"User: {result.get('username')}\n"
-            f"Score: {result.get('score', 'N/A')}% "
-            f"({result.get('correct_count', '?')}/{result.get('total_attempted', '?')} correct)\n"
-            f"Message: {result.get('message', 'No message')}"
+        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.')}"
         )
-        
-        return status, pd.DataFrame(results_log)
-        
+        print("Submission successful.")
+        results_df = pd.DataFrame(results_log)
+        return final_status, results_df
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"Server responded with status {e.response.status_code}."
+        try:
+            error_json = e.response.json()
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+        except requests.exceptions.JSONDecodeError:
+            error_detail += f" Response: {e.response.text[:500]}"
+        status_message = f"Submission Failed: {error_detail}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.Timeout:
+        status_message = "Submission Failed: The request timed out."
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.RequestException as e:
+        status_message = f"Submission Failed: Network error - {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
     except Exception as e:
-        error_status = f"❌ Submission failed: {e}"
-        return error_status, pd.DataFrame(results_log)
+        status_message = f"An unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
 
-# --- Gradio Interface ---
-with gr.Blocks(title="Optimized GAIA Agent") as demo:
-    gr.Markdown("# 🚀 Optimized GAIA Benchmark Agent")
-    gr.Markdown("""
-    **Performance-Optimized Agent for HF Spaces (2vCPU/16GB)**
-    
-    ✨ **Enhanced Features:**
-    - Smart question type detection and routing
-    - Optimized search with result caching
-    - Memory-efficient processing
-    - Better error handling and recovery
-    - Specialized tools for each question type
-    
-    🎯 **Question Types Handled:**
-    - Discography & Album counting (Mercedes Sosa, etc.)
-    - YouTube video analysis
-    - Reversed text processing  
-    - Botanical classification
-    - Chess position analysis
-    - Mathematical problems
-    - General knowledge questions
-    
-    📋 **Instructions:**
-    1. Login with your HuggingFace account
-    2. Click "Start Optimized Evaluation"
-    3. Wait for processing (typically 5-10 minutes)
-    4. Review results and submission status
-    """)
-    
-    gr.LoginButton()
-    
-    with gr.Row():
-        run_btn = gr.Button("🚀 Start Optimized Evaluation", variant="primary", size="lg")
-    
-    with gr.Row():
-        status_display = gr.Textbox(
-            label="📊 Evaluation Status & Results", 
-            lines=8, 
-            interactive=False,
-            placeholder="Click 'Start Optimized Evaluation' to begin..."
-        )
-    
-    results_display = gr.DataFrame(
-        label="📝 Detailed Question Results",
-        wrap=True,
-        interactive=False
+# --- Build Gradio Interface ---
+with gr.Blocks() as demo:
+    gr.Markdown("# GAIA Benchmark Agent")
+    gr.Markdown(
+        """
+        **Enhanced Agent for GAIA Benchmark**
+        
+        This agent uses multiple specialized tools to handle diverse question types:
+        - Web search (Serper API + DuckDuckGo)
+        - Wikipedia search
+        - YouTube video analysis
+        - Text processing and reversal
+        - Mathematical problem solving
+        - Data extraction and botanical classification
+        
+        **Instructions:**
+        1. Log in to your Hugging Face account
+        2. Click 'Run Evaluation & Submit All Answers' to start the benchmark
+        3. The agent will process all questions and submit results automatically
+        
+        **Note:** Processing may take several minutes due to the complexity of questions.
+        """
     )
-    
-    run_btn.click(
-        fn=run_and_submit_optimized,
-        outputs=[status_display, results_display]
+
+    gr.LoginButton()
+
+    run_button = gr.Button("Run Evaluation & Submit All Answers", variant="primary")
+
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
     )
 
 if __name__ == "__main__":
-    print("🚀 Starting Optimized GAIA Agent...")
+    print("\n" + "-"*30 + " GAIA Agent Starting " + "-"*30)
     
-    # Environment check
-    required_vars = ["SERPER_API_KEY", "HUGGINGFACE_INFERENCE_TOKEN"]
-    for var in required_vars:
-        if os.getenv(var):
-            print(f"✅ {var} found")
-        else:
-            print(f"⚠️  {var} missing - some features may be limited")
-    
-    print("🌐 Launching interface...")
-    demo.launch(debug=False, share=False)
+    # Check environment variables
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID")
+    serper_key = os.getenv("SERPER_API_KEY")
+    hf_token = os.getenv("HUGGINGFACE_INFERENCE_TOKEN")
+
+    if space_host_startup:
+        print(f"✅ SPACE_HOST found: {space_host_startup}")
+    else:
+        print("ℹ️  SPACE_HOST not found (running locally?)")
+
+    if space_id_startup:
+        print(f"✅ SPACE_ID found: {space_id_startup}")
+    else:
+        print("ℹ️  SPACE_ID not found")
+        
+    if serper_key:
+        print("✅ SERPER_API_KEY found")
+    else:
+        print("❌ SERPER_API_KEY missing - web search will be limited")
+        
+    if hf_token:
+        print("✅ HUGGINGFACE_INFERENCE_TOKEN found")
+    else:
+        print("❌ HUGGINGFACE_INFERENCE_TOKEN missing - model access may fail")
+
+    print("-"*(60 + len(" GAIA Agent Starting ")) + "\n")
+
+    print("Launching GAIA Agent Interface...")
+    demo.launch(debug=True, share=False)