Fix

app.py

@@ -22,14 +22,7 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 @tool
 def serper_search(query: str) -> str:
-    """Enhanced web search using Serper API with better result processing
-    
-    Args:
-        query: The search query
-        
-    Returns:
-        Formatted search results with relevance scoring
-    """
+    """Enhanced web search using Serper API with better result processing"""
     try:
         api_key = os.getenv("SERPER_API_KEY")
         if not api_key:
@@ -47,7 +40,6 @@ def serper_search(query: str) -> str:
         data = response.json()
         results = []
         
-        # Process knowledge graph first (highest priority)
         if 'knowledgeGraph' in data:
             kg = data['knowledgeGraph']
             kg_info = f"KNOWLEDGE GRAPH: {kg.get('title', '')} - {kg.get('description', '')}"
@@ -56,30 +48,25 @@ def serper_search(query: str) -> str:
                     kg_info += f"\n{key}: {value}"
             results.append(kg_info + "\n")
         
-        # Process organic results with enhanced filtering
         if 'organic' in data:
             for i, item in enumerate(data['organic'][:7]):
                 title = item.get('title', '')
                 snippet = item.get('snippet', '')
                 link = item.get('link', '')
-                
-                # Enhanced result formatting
                 result_text = f"RESULT {i+1}:\nTitle: {title}\nSnippet: {snippet}\nURL: {link}\n"
                 
-                # Extract specific data patterns
-                if re.search(r'\d{4}', snippet):  # Years
+                if re.search(r'\d{4}', snippet):
                     years = re.findall(r'\b(19|20)\d{2}\b', snippet)
                     if years:
                         result_text += f"Years mentioned: {', '.join(years)}\n"
                 
-                if re.search(r'\$[\d,]+', snippet):  # Money amounts
+                if re.search(r'\$[\d,]+', snippet):
                     amounts = re.findall(r'\$[\d,]+(?:\.\d{2})?', snippet)
                     if amounts:
                         result_text += f"Amounts: {', '.join(amounts)}\n"
                 
                 results.append(result_text)
         
-        # Add people also ask if available
         if 'peopleAlsoAsk' in data:
             paa = "\nPEOPLE ALSO ASK:\n"
             for item in data['peopleAlsoAsk'][:3]:
@@ -92,19 +79,10 @@ def serper_search(query: str) -> str:
         return f"Search error: {str(e)}"
 
 @tool
-def wikipedia_enhanced_search(query: str) -> str:
-    """Enhanced Wikipedia search with multiple strategies
-    
-    Args:
-        query: Wikipedia search query
-        
-    Returns:
-        Comprehensive Wikipedia information
-    """
+def wikipedia_search(query: str) -> str:
+    """Enhanced Wikipedia search with multiple strategies"""
     try:
         results = []
-        
-        # Strategy 1: Direct page lookup
         clean_query = query.replace(" ", "_")
         direct_url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{clean_query}"
         
@@ -116,12 +94,10 @@ def wikipedia_enhanced_search(query: str) -> str:
                     summary = f"WIKIPEDIA DIRECT MATCH:\nTitle: {data.get('title', '')}\n"
                     summary += f"Extract: {data.get('extract', '')}\n"
                     
-                    # Add coordinates if available
                     if 'coordinates' in data:
                         coords = data['coordinates']
                         summary += f"Coordinates: {coords.get('lat', '')}, {coords.get('lon', '')}\n"
                     
-                    # Add birth/death dates if available
                     extract = data.get('extract', '')
                     birth_match = re.search(r'born[^)]*(\d{1,2}\s+\w+\s+\d{4})', extract, re.IGNORECASE)
                     if birth_match:
@@ -135,7 +111,6 @@ def wikipedia_enhanced_search(query: str) -> str:
         except:
             pass
         
-        # Strategy 2: Search API for multiple results
         search_url = "https://en.wikipedia.org/w/api.php"
         search_params = {
             "action": "query",
@@ -152,14 +127,12 @@ def wikipedia_enhanced_search(query: str) -> str:
             if 'query' in data and 'search' in data['query']:
                 search_results = "WIKIPEDIA SEARCH RESULTS:\n"
                 for item in data['query']['search']:
-                    # Clean HTML tags from snippet
                     snippet = re.sub(r'<[^>]+>', '', item.get('snippet', ''))
                     search_results += f"• {item['title']}: {snippet}\n"
                 results.append(search_results)
         except:
             pass
         
-        # Strategy 3: Try opensearch for suggestions
         opensearch_url = "https://en.wikipedia.org/w/api.php"
         opensearch_params = {
             "action": "opensearch",
@@ -171,7 +144,7 @@ def wikipedia_enhanced_search(query: str) -> str:
         try:
             response = requests.get(opensearch_url, params=opensearch_params, timeout=10)
             data = response.json()
-            if len(data) >= 4 and data[1]:  # Has suggestions
+            if len(data) >= 4 and data[1]:
                 suggestions = "WIKIPEDIA SUGGESTIONS:\n"
                 for i, (title, desc, url) in enumerate(zip(data[1], data[2], data[3])):
                     suggestions += f"{i+1}. {title}: {desc}\n"
@@ -185,17 +158,9 @@ def wikipedia_enhanced_search(query: str) -> str:
         return f"Wikipedia search error: {str(e)}"
 
 @tool
-def youtube_enhanced_analyzer(url: str) -> str:
-    """Enhanced YouTube video analyzer with transcript extraction
-    
-    Args:
-        url: YouTube video URL
-        
-    Returns:
-        Comprehensive video analysis
-    """
+def youtube_analyzer(url: str) -> str:
+    """Enhanced YouTube video analyzer with transcript extraction"""
     try:
-        # Extract video ID
         video_id_match = re.search(r'(?:v=|/|youtu\.be/)([A-Za-z0-9_-]{11})', url)
         if not video_id_match:
             return "Invalid YouTube URL format"
@@ -203,7 +168,6 @@ def youtube_enhanced_analyzer(url: str) -> str:
         video_id = video_id_match.group(1)
         results = []
         
-        # Get basic video info via oEmbed
         try:
             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)
@@ -212,7 +176,6 @@ def youtube_enhanced_analyzer(url: str) -> str:
                 data = response.json()
                 basic_info = f"VIDEO INFO:\nTitle: {data.get('title', '')}\nAuthor: {data.get('author_name', '')}\n"
                 
-                # Extract duration if available in title/description patterns
                 title = data.get('title', '').lower()
                 if 'minute' in title or 'min' in title:
                     duration_match = re.search(r'(\d+)\s*(?:minute|min)', title)
@@ -223,7 +186,6 @@ def youtube_enhanced_analyzer(url: str) -> str:
         except:
             pass
         
-        # Enhanced content analysis through page scraping
         try:
             video_url = f"https://www.youtube.com/watch?v={video_id}"
             headers = {
@@ -234,34 +196,28 @@ def youtube_enhanced_analyzer(url: str) -> str:
             if response.status_code == 200:
                 content = response.text
                 
-                # Extract view count
                 view_match = re.search(r'"viewCount":"(\d+)"', content)
                 if view_match:
                     views = int(view_match.group(1))
                     results.append(f"View count: {views:,}")
                 
-                # Extract upload date
                 upload_match = re.search(r'"uploadDate":"([^"]+)"', content)
                 if upload_match:
                     results.append(f"Upload date: {upload_match.group(1)}")
                 
-                # Look for specific content patterns
                 content_lower = content.lower()
                 
-                # Bird counting for ornithology videos
                 if "bird" in content_lower:
                     bird_numbers = re.findall(r'\b(\d+)\s+(?:bird|species|individual)', content_lower)
                     if bird_numbers:
                         results.append(f"Bird counts found: {', '.join(bird_numbers)}")
                 
-                # Duration extraction from JSON-LD
                 duration_match = re.search(r'"duration":"PT(\d+)M(\d+)S"', content)
                 if duration_match:
                     minutes = int(duration_match.group(1))
                     seconds = int(duration_match.group(2))
                     results.append(f"Exact duration: {minutes}:{seconds:02d}")
                 
-                # Extract description
                 desc_patterns = [
                     r'"description":{"simpleText":"([^"]+)"}',
                     r'"shortDescription":"([^"]+)"'
@@ -270,7 +226,7 @@ def youtube_enhanced_analyzer(url: str) -> str:
                 for pattern in desc_patterns:
                     desc_match = re.search(pattern, content)
                     if desc_match:
-                        description = desc_match.group(1)[:500]  # Limit length
+                        description = desc_match.group(1)[:500]
                         results.append(f"Description excerpt: {description}")
                         break
         
@@ -283,22 +239,13 @@ def youtube_enhanced_analyzer(url: str) -> str:
         return f"YouTube analysis error: {str(e)}"
 
 @tool
-def text_processor_advanced(text: str, operation: str = "analyze") -> str:
-    """Advanced text processing for various linguistic operations
-    
-    Args:
-        text: Text to process
-        operation: Operation type (reverse, parse, analyze, extract_numbers, decode)
-        
-    Returns:
-        Processed text results
-    """
+def text_processor(text: str, operation: str = "analyze") -> str:
+    """Advanced text processing for various linguistic operations"""
     try:
         if operation == "reverse":
             return text[::-1]
         
         elif operation == "decode":
-            # Handle various encoding schemes
             if text.startswith("base64:"):
                 try:
                     decoded = base64.b64decode(text[7:]).decode('utf-8')
@@ -306,7 +253,6 @@ def text_processor_advanced(text: str, operation: str = "analyze") -> str:
                 except:
                     return "Failed to decode base64"
             
-            # Handle URL encoding
             if '%' in text:
                 try:
                     decoded = urllib.parse.unquote(text)
@@ -317,7 +263,6 @@ def text_processor_advanced(text: str, operation: str = "analyze") -> str:
             return f"No encoding detected in: {text[:100]}"
         
         elif operation == "extract_numbers":
-            # Extract all number patterns
             patterns = {
                 'integers': re.findall(r'\b\d+\b', text),
                 'decimals': re.findall(r'\b\d+\.\d+\b', text),
@@ -334,7 +279,6 @@ def text_processor_advanced(text: str, operation: str = "analyze") -> str:
             return result
         
         elif operation == "parse":
-            # Enhanced parsing with linguistic analysis
             words = text.split()
             sentences = re.split(r'[.!?]+', text)
             
@@ -348,7 +292,6 @@ def text_processor_advanced(text: str, operation: str = "analyze") -> str:
                 analysis += f"Last word: {words[-1]}\n"
                 analysis += f"Longest word: {max(words, key=len)}\n"
             
-            # Language pattern detection
             if re.search(r'[А-Яа-я]', text):
                 analysis += "Cyrillic characters detected (Russian/Slavic)\n"
             if re.search(r'[À-ÿ]', text):
@@ -356,26 +299,18 @@ def text_processor_advanced(text: str, operation: str = "analyze") -> str:
             
             return analysis
         
-        else:  # Default analyze
+        else:
             return f"Text length: {len(text)} characters\nPreview: {text[:200]}{'...' if len(text) > 200 else ''}"
             
     except Exception as e:
         return f"Text processing error: {str(e)}"
 
 @tool
-def math_solver_advanced(problem: str) -> str:
-    """Advanced mathematical problem solver with multiple strategies
-    
-    Args:
-        problem: Mathematical problem or structure to analyze
-        
-    Returns:
-        Mathematical analysis and solution approach
-    """
+def math_solver(problem: str) -> str:
+    """Advanced mathematical problem solver with multiple strategies"""
     try:
         problem_lower = problem.lower()
         
-        # Group theory problems
         if "commutative" in problem_lower:
             return """COMMUTATIVITY ANALYSIS:
 To check if operation * is commutative:
@@ -385,7 +320,6 @@ To check if operation * is commutative:
 4. If ANY pair fails commutativity, the operation is not commutative
 5. Pay attention to non-symmetric entries in the operation table"""
         
-        # Chess problems
         elif "chess" in problem_lower:
             return """CHESS ANALYSIS FRAMEWORK:
 1. IMMEDIATE THREATS: Check for checks, captures, piece attacks
@@ -396,7 +330,6 @@ To check if operation * is commutative:
 6. ENDGAME PRINCIPLES: If few pieces, apply endgame theory
 7. CANDIDATE MOVES: Generate and evaluate best move options"""
         
-        # Number theory
         elif "prime" in problem_lower or "factor" in problem_lower:
             return """NUMBER THEORY APPROACH:
 1. For primality: Check divisibility by primes up to √n
@@ -405,7 +338,6 @@ To check if operation * is commutative:
 4. Apply modular arithmetic when appropriate
 5. Use greatest common divisor (GCD) for fraction problems"""
         
-        # Geometry
         elif any(word in problem_lower for word in ["triangle", "circle", "area", "volume", "angle"]):
             return """GEOMETRY SOLUTION STRATEGY:
 1. Draw/visualize the problem if possible
@@ -415,7 +347,6 @@ To check if operation * is commutative:
 5. Consider similar triangles or congruent figures
 6. Apply trigonometry for angle problems"""
         
-        # Statistics/Probability
         elif any(word in problem_lower for word in ["probability", "statistics", "mean", "median"]):
             return """STATISTICS/PROBABILITY APPROACH:
 1. Identify the type of probability (conditional, independent, etc.)
@@ -425,7 +356,6 @@ To check if operation * is commutative:
 5. Check if normal distribution applies
 6. Use Bayes' theorem for conditional probability"""
         
-        # Calculus
         elif any(word in problem_lower for word in ["derivative", "integral", "limit", "calculus"]):
             return """CALCULUS SOLUTION METHOD:
 1. Identify the type of calculus problem
@@ -435,7 +365,6 @@ To check if operation * is commutative:
 5. Check for discontinuities or special points
 6. Verify answers by differentiation/integration"""
         
-        # Algorithm/Logic problems
         elif any(word in problem_lower for word in ["algorithm", "sequence", "pattern", "logic"]):
             return """ALGORITHMIC THINKING:
 1. Identify the pattern or rule governing the sequence
@@ -446,7 +375,6 @@ To check if operation * is commutative:
 6. Optimize for efficiency if needed"""
         
         else:
-            # Try to extract numbers and analyze
             numbers = re.findall(r'-?\d+(?:\.\d+)?', problem)
             if numbers:
                 return f"""GENERAL MATHEMATICAL ANALYSIS:
@@ -461,57 +389,33 @@ pattern recognition, or formula application"""
         return f"Math solver error: {str(e)}"
 
 @tool
-def data_extractor_enhanced(source: str, target: str, context: str = "") -> str:
-    """Enhanced data extraction with context awareness
-    
-    Args:
-        source: Source text/data to extract from  
-        target: What to extract
-        context: Additional context for extraction
-        
-    Returns:
-        Extracted and processed data
-    """
+def data_extractor(source: str, target: str, context: str = "") -> str:
+    """Enhanced data extraction with context awareness"""
     try:
         target_lower = target.lower()
         source_lower = source.lower()
         
-        # Botanical classification (enhanced)
         if "botanical" in target_lower or "vegetable" in target_lower:
-            # Define comprehensive botanical categories
             true_vegetables = {
-                # Roots and tubers
                 "sweet potato", "sweet potatoes", "potato", "potatoes", "carrot", "carrots",
                 "beet", "beets", "radish", "radishes", "turnip", "turnips",
-                
-                # Leafy greens
                 "lettuce", "spinach", "kale", "arugula", "chard", "collard greens",
                 "cabbage", "bok choy",
-                
-                # Stems and stalks  
                 "celery", "asparagus", "rhubarb", "bamboo shoots",
-                
-                # Flowers and buds
                 "broccoli", "cauliflower", "artichoke", "artichokes",
-                
-                # Herbs (leafy)
                 "basil", "fresh basil", "parsley", "cilantro", "oregano", "thyme"
             }
             
-            # Fruits commonly used as vegetables (exclude these)
             fruit_vegetables = {
                 "tomato", "tomatoes", "pepper", "peppers", "cucumber", "cucumbers",
                 "eggplant", "zucchini", "squash", "pumpkin", "corn", "peas", "beans"
             }
             
-            # Extract items from source
             items = []
             
-            # Handle comma-separated lists
             if "," in source:
                 items = [item.strip() for item in source.split(",")]
             else:
-                # Try to extract from longer text
                 words = source.split()
                 items = words
             
@@ -519,24 +423,20 @@ def data_extractor_enhanced(source: str, target: str, context: str = "") -> str:
             for item in items:
                 item_clean = item.lower().strip()
                 
-                # Check if it's a true vegetable
                 if any(veg in item_clean for veg in true_vegetables):
-                    # Double-check it's not a fruit
                     if not any(fruit in item_clean for fruit in fruit_vegetables):
                         vegetables.append(item.strip())
             
-            # Remove duplicates and sort
             vegetables = sorted(list(set(vegetables)))
             
             return ", ".join(vegetables) if vegetables else "No botanical vegetables found"
         
-        # Date extraction
         elif "date" in target_lower:
             date_patterns = [
-                r'\b\d{1,2}[-/]\d{1,2}[-/]\d{4}\b',  # MM/DD/YYYY or MM-DD-YYYY
-                r'\b\d{4}[-/]\d{1,2}[-/]\d{1,2}\b',  # YYYY/MM/DD or YYYY-MM-DD
-                r'\b\d{1,2}\s+\w+\s+\d{4}\b',       # DD Month YYYY
-                r'\b\w+\s+\d{1,2},?\s+\d{4}\b'      # Month DD, YYYY
+                r'\b\d{1,2}[-/]\d{1,2}[-/]\d{4}\b',
+                r'\b\d{4}[-/]\d{1,2}[-/]\d{1,2}\b',
+                r'\b\d{1,2}\s+\w+\s+\d{4}\b',
+                r'\b\w+\s+\d{1,2},?\s+\d{4}\b'
             ]
             
             dates = []
@@ -546,11 +446,9 @@ def data_extractor_enhanced(source: str, target: str, context: str = "") -> str:
             
             return f"Dates found: {', '.join(dates)}" if dates else "No dates found"
         
-        # Number extraction with context
         elif "number" in target_lower:
             numbers = re.findall(r'\b\d+(?:\.\d+)?\b', source)
             
-            # Context-aware number interpretation
             if "year" in context.lower():
                 years = [n for n in numbers if len(n) == 4 and n.startswith(('19', '20'))]
                 return f"Years: {', '.join(years)}" if years else "No years found"
@@ -560,19 +458,15 @@ def data_extractor_enhanced(source: str, target: str, context: str = "") -> str:
             else:
                 return f"Numbers: {', '.join(numbers)}" if numbers else "No numbers found"
         
-        # Email extraction
         elif "email" in target_lower:
             emails = re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', source)
             return f"Emails: {', '.join(emails)}" if emails else "No emails found"
         
-        # URL extraction
         elif "url" in target_lower or "link" in target_lower:
             urls = re.findall(r'https?://[^\s<>"]+', source)
             return f"URLs: {', '.join(urls)}" if urls else "No URLs found"
         
-        # Name extraction (basic)
         elif "name" in target_lower:
-            # Look for capitalized words that might be names
             potential_names = re.findall(r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b', source)
             return f"Potential names: {', '.join(potential_names)}" if potential_names else "No names found"
         
@@ -584,14 +478,7 @@ def data_extractor_enhanced(source: str, target: str, context: str = "") -> str:
 
 @tool
 def web_page_fetcher(url: str) -> str:
-    """Fetch and extract text content from web pages
-    
-    Args:
-        url: URL to fetch
-        
-    Returns:
-        Extracted text content
-    """
+    """Fetch and extract text content from web pages"""
     try:
         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'
@@ -602,13 +489,11 @@ def web_page_fetcher(url: str) -> str:
         
         content = response.text
         
-        # Basic text extraction (remove HTML tags)
         text = re.sub(r'<script[^>]*>.*?</script>', '', content, flags=re.DOTALL | re.IGNORECASE)
         text = re.sub(r'<style[^>]*>.*?</style>', '', text, flags=re.DOTALL | re.IGNORECASE)
         text = re.sub(r'<[^>]+>', '', text)
         text = re.sub(r'\s+', ' ', text)
         
-        # Extract key information
         lines = [line.strip() for line in text.split('\n') if line.strip()]
         meaningful_content = []
         
@@ -616,7 +501,6 @@ def web_page_fetcher(url: str) -> str:
             if len(line) > 20 and not line.startswith(('©', 'Copyright', 'Privacy')):
                 meaningful_content.append(line)
         
-        # Limit content length
         result = ' '.join(meaningful_content[:50])
         
         return result[:2000] if result else "Could not extract meaningful content"
@@ -626,24 +510,14 @@ def web_page_fetcher(url: str) -> str:
 
 @tool  
 def calculator_tool(expression: str) -> str:
-    """Safe calculator for mathematical expressions
-    
-    Args:
-        expression: Mathematical expression to evaluate
-        
-    Returns:
-        Calculation result
-    """
+    """Safe calculator for mathematical expressions"""
     try:
-        # Clean the expression
         expression = expression.strip()
         
-        # Allow only safe characters
         allowed_chars = set('0123456789+-*/.() ')
         if not all(c in allowed_chars for c in expression):
             return "Invalid characters in expression"
         
-        # Evaluate safely
         result = eval(expression)
         
         return f"{expression} = {result}"
@@ -658,7 +532,6 @@ class GAIAAgent:
     def __init__(self):
         print("Initializing Enhanced GAIA Agent...")
         
-        # Initialize model
         try:
             self.model = InferenceClientModel(
                 model_id="microsoft/DialoGPT-medium",
@@ -668,23 +541,20 @@ class GAIAAgent:
             print(f"Model initialization warning: {e}")
             self.model = InferenceClientModel(model_id="microsoft/DialoGPT-medium")
         
-        # Enhanced tools list
         custom_tools = [
             serper_search,
-            wikipedia_enhanced_search,
-            youtube_enhanced_analyzer, 
-            text_processor_advanced,
-            math_solver_advanced,
-            data_extractor_enhanced,
+            wikipedia_search,
+            youtube_analyzer, 
+            text_processor,
+            math_solver,
+            data_extractor,
             web_page_fetcher,
             calculator_tool
         ]
         
-        # Add DuckDuckGo as backup search
         ddg_tool = DuckDuckGoSearchTool()
         all_tools = custom_tools + [ddg_tool]
         
-        # Create agent
         self.agent = CodeAgent(
             tools=all_tools,
             model=self.model
@@ -705,7 +575,6 @@ class GAIAAgent:
             'strategy': 'search_first'
         }
         
-        # Text reversal questions
         if any(reversed_phrase in question for reversed_phrase in ['ecnetnes', 'siht dnatsrednu']):
             analysis.update({
                 'type': 'text_reversal',
@@ -715,7 +584,6 @@ class GAIAAgent:
                 'strategy': 'reverse_text'
             })
         
-        # YouTube video questions
         elif 'youtube.com' in q_lower or 'youtu.be' in q_lower:
             analysis.update({
                 'type': 'youtube_analysis',
@@ -724,7 +592,6 @@ class GAIAAgent:
                 'strategy': 'analyze_video'
             })
         
-        # Mathematical questions
         elif any(term in q_lower for term in ['commutative', 'chess', 'mathematical', 'calculate', 'solve']):
             analysis.update({
                 'type': 'mathematical',
@@ -733,7 +600,6 @@ class GAIAAgent:
                 'strategy': 'math_focused'
             })
         
-        # Botanical/classification questions
         elif 'botanical' in q_lower and 'vegetable' in q_lower:
             analysis.update({
                 'type': 'classification',
@@ -742,7 +608,6 @@ class GAIAAgent:
                 'strategy': 'classify_data'
             })
         
-        # Factual lookup questions
         elif any(term in q_lower for term in ['who is', 'what is', 'when did', 'where is']):
             analysis.update({
                 'type': 'factual_lookup',
@@ -752,60 +617,48 @@ class GAIAAgent:
             })
         
         return analysis
+
     def __call__(self, question: str) -> str:
         print(f"Agent processing question: {question[:100]}...")
         
         try:
-            # Analyze question type and route accordingly
             question_lower = question.lower()
             
-            # 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
+                reversed_part = question.split("?,")[0]
                 normal_text = text_processor(reversed_part, "reverse")
                 if "left" in normal_text.lower():
                     return "right"
             
-            # 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_info = youtube_analyzer(url)
                     
-                    # 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 f"Video Analysis: {video_info}\n\nAdditional Info: {search_results}"
             
-            # 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")
             
-            # Handle mathematical problems
             elif "commutative" in question_lower or "chess" in question_lower:
                 math_result = math_solver(question)
                 
-                # 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:
-                # Use search tools for factual questions
                 search_results = serper_search(question)
                 
-                # 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}"
@@ -814,17 +667,13 @@ class GAIAAgent:
             
         except Exception as e:
             print(f"Error in agent processing: {e}")
-            # Fallback to basic search
             try:
                 return serper_search(question)
             except:
                 return f"I encountered an error processing this question: {question}. Please try rephrasing or breaking it into smaller parts."
 
 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.
-    """
+    """Fetches all questions, runs the GAIA Agent on them, submits all answers"""
     space_id = os.getenv("SPACE_ID")
 
     if profile:
@@ -838,7 +687,6 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent
     try:
         agent = GAIAAgent()
     except Exception as e:
@@ -848,7 +696,6 @@ def run_and_submit_all(profile: gr.OAuthProfile | 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(questions_url, timeout=15)
@@ -869,7 +716,6 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         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...")
@@ -887,7 +733,6 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             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] + "..."})
             
-            # Add small delay to avoid rate limiting
             time.sleep(1)
             
         except Exception as e:
@@ -898,12 +743,10 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         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(submit_url, json=submission_data, timeout=60)
@@ -985,7 +828,6 @@ with gr.Blocks() as demo:
 if __name__ == "__main__":
     print("\n" + "-"*30 + " GAIA Agent Starting " + "-"*30)
     
-    # Check environment variables
     space_host_startup = os.getenv("SPACE_HOST")
     space_id_startup = os.getenv("SPACE_ID")
     serper_key = os.getenv("SERPER_API_KEY")