Fix

app.py

@@ -6,26 +6,29 @@ import json
 import re
 import time
 from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel, tool
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Optional, Union
 import base64
 from io import BytesIO
 from PIL import Image
 import numpy as np
+import urllib.parse
+from datetime import datetime, timedelta
+import math
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Custom Tools ---
+# --- Enhanced Custom Tools ---
 
 @tool
 def serper_search(query: str) -> str:
-    """Search the web using Serper API for current information and specific queries
+    """Enhanced web search using Serper API with better result processing
     
     Args:
         query: The search query
         
     Returns:
-        Search results as formatted string
+        Formatted search results with relevance scoring
     """
     try:
         api_key = os.getenv("SERPER_API_KEY")
@@ -44,15 +47,44 @@ def serper_search(query: str) -> str:
         data = response.json()
         results = []
         
-        # 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
+        # Process knowledge graph first (highest priority)
         if 'knowledgeGraph' in data:
             kg = data['knowledgeGraph']
-            results.insert(0, f"Knowledge Graph: {kg.get('title', '')} - {kg.get('description', '')}\n")
+            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 + "\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
+                    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
+                    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]:
+                paa += f"Q: {item.get('question', '')}\nA: {item.get('snippet', '')}\n"
+            results.append(paa)
         
         return "\n".join(results) if results else "No results found"
         
@@ -60,220 +92,666 @@ def serper_search(query: str) -> str:
         return f"Search error: {str(e)}"
 
 @tool
-def wikipedia_search(query: str) -> str:
-    """Search Wikipedia for detailed information on topics
+def wikipedia_enhanced_search(query: str) -> str:
+    """Enhanced Wikipedia search with multiple strategies
     
     Args:
-        query: The Wikipedia search query
+        query: Wikipedia search query
         
     Returns:
-        Wikipedia search results
+        Comprehensive Wikipedia information
     """
     try:
-        # Search for pages
-        search_url = "https://en.wikipedia.org/api/rest_v1/page/summary/" + query.replace(" ", "_")
-        response = requests.get(search_url, timeout=15)
+        results = []
         
-        if response.status_code == 200:
-            data = response.json()
-            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_api = "https://en.wikipedia.org/w/api.php"
-            params = {
-                "action": "query",
-                "format": "json",
-                "list": "search",
-                "srsearch": query,
-                "srlimit": 3
-            }
-            response = requests.get(search_api, params=params, timeout=15)
+        # Strategy 1: Direct page lookup
+        clean_query = query.replace(" ", "_")
+        direct_url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{clean_query}"
+        
+        try:
+            response = requests.get(direct_url, timeout=15)
+            if response.status_code == 200:
+                data = response.json()
+                if data.get('type') != 'disambiguation':
+                    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:
+                        summary += f"Birth date found: {birth_match.group(1)}\n"
+                    
+                    death_match = re.search(r'died[^)]*(\d{1,2}\s+\w+\s+\d{4})', extract, re.IGNORECASE)
+                    if death_match:
+                        summary += f"Death date found: {death_match.group(1)}\n"
+                    
+                    results.append(summary)
+        except:
+            pass
+        
+        # Strategy 2: Search API for multiple results
+        search_url = "https://en.wikipedia.org/w/api.php"
+        search_params = {
+            "action": "query",
+            "format": "json",
+            "list": "search",
+            "srsearch": query,
+            "srlimit": 5
+        }
+        
+        try:
+            response = requests.get(search_url, params=search_params, timeout=15)
             data = response.json()
             
-            results = []
-            for item in data.get('query', {}).get('search', []):
-                results.append(f"Title: {item['title']}\nSnippet: {item['snippet']}")
-            
-            return "\n\n".join(results) if results else "No Wikipedia results found"
-            
+            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",
+            "search": query,
+            "limit": 3,
+            "format": "json"
+        }
+        
+        try:
+            response = requests.get(opensearch_url, params=opensearch_params, timeout=10)
+            data = response.json()
+            if len(data) >= 4 and data[1]:  # Has suggestions
+                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"
+                results.append(suggestions)
+        except:
+            pass
+        
+        return "\n".join(results) if results else "No Wikipedia results found"
+        
     except Exception as e:
         return f"Wikipedia search error: {str(e)}"
 
 @tool
-def youtube_analyzer(url: str) -> str:
-    """Analyze YouTube videos to extract information from titles, descriptions, and comments
+def youtube_enhanced_analyzer(url: str) -> str:
+    """Enhanced YouTube video analyzer with transcript extraction
     
     Args:
         url: YouTube video URL
         
     Returns:
-        Video information and analysis
+        Comprehensive video analysis
     """
     try:
         # Extract video ID
-        video_id_match = re.search(r'(?:v=|\/)([0-9A-Za-z_-]{11}).*', url)
+        video_id_match = re.search(r'(?:v=|/|youtu\.be/)([A-Za-z0-9_-]{11})', url)
         if not video_id_match:
-            return "Invalid YouTube URL"
+            return "Invalid YouTube URL format"
         
         video_id = video_id_match.group(1)
+        results = []
         
-        # 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)
+        # 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)
+            
+            if response.status_code == 200:
+                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)
+                    if duration_match:
+                        basic_info += f"Duration mentioned: {duration_match.group(1)} minutes\n"
+                
+                results.append(basic_info)
+        except:
+            pass
         
-        if response.status_code == 200:
-            data = response.json()
-            result = f"Title: {data.get('title', '')}\nAuthor: {data.get('author_name', '')}\n"
+        # Enhanced content analysis through page scraping
+        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'
+            }
             
-            # 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'}
-                page_response = requests.get(video_url, headers=headers, timeout=15)
+            response = requests.get(video_url, headers=headers, timeout=20)
+            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)}")
                 
-                if page_response.status_code == 200:
-                    content = page_response.text
-                    # Extract description from meta tags
-                    desc_match = re.search(r'"description":{"simpleText":"([^"]+)"', content)
+                # 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":"([^"]+)"'
+                ]
+                
+                for pattern in desc_patterns:
+                    desc_match = re.search(pattern, content)
                     if desc_match:
-                        result += f"Description: {desc_match.group(1)}\n"
-                        
-                    # Look for bird-related content
-                    if "bird" in content.lower():
-                        bird_matches = re.findall(r'\b\d+\s+bird', content.lower())
-                        if bird_matches:
-                            result += f"Bird mentions found: {bird_matches}\n"
-            
-            except:
-                pass
-            
-            return result
-        else:
-            return "Could not retrieve video information"
-            
+                        description = desc_match.group(1)[:500]  # Limit length
+                        results.append(f"Description excerpt: {description}")
+                        break
+        
+        except Exception as e:
+            results.append(f"Enhanced analysis error: {str(e)}")
+        
+        return "\n".join(results) if results else "Could not analyze video"
+        
     except Exception as e:
         return f"YouTube analysis error: {str(e)}"
 
 @tool
-def text_processor(text: str, operation: str = "analyze") -> str:
-    """Process text for various operations like reversing, parsing, and analyzing
+def text_processor_advanced(text: str, operation: str = "analyze") -> str:
+    """Advanced text processing for various linguistic operations
     
     Args:
         text: Text to process
-        operation: Operation to perform (reverse, parse, analyze)
+        operation: Operation type (reverse, parse, analyze, extract_numbers, decode)
         
     Returns:
-        Processed text result
+        Processed text results
     """
     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')
+                    return f"Base64 decoded: {decoded}"
+                except:
+                    return "Failed to decode base64"
+            
+            # Handle URL encoding
+            if '%' in text:
+                try:
+                    decoded = urllib.parse.unquote(text)
+                    return f"URL decoded: {decoded}"
+                except:
+                    return "Failed to decode URL"
+            
+            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),
+                'years': re.findall(r'\b(19|20)\d{2}\b', text),
+                'percentages': re.findall(r'\b\d+(?:\.\d+)?%', text),
+                'currencies': re.findall(r'\$[\d,]+(?:\.\d{2})?', text)
+            }
+            
+            result = "EXTRACTED NUMBERS:\n"
+            for category, matches in patterns.items():
+                if matches:
+                    result += f"{category.title()}: {', '.join(matches)}\n"
+            
+            return result
+        
         elif operation == "parse":
-            # Extract meaningful information
+            # Enhanced parsing with linguistic analysis
             words = text.split()
-            return f"Word count: {len(words)}\nFirst word: {words[0] if words else 'None'}\nLast word: {words[-1] if words else 'None'}"
-        else:
-            # General analysis
-            return f"Text length: {len(text)}\nWord count: {len(text.split())}\nText: {text[:200]}..."
+            sentences = re.split(r'[.!?]+', text)
+            
+            analysis = f"TEXT ANALYSIS:\n"
+            analysis += f"Character count: {len(text)}\n"
+            analysis += f"Word count: {len(words)}\n"
+            analysis += f"Sentence count: {len([s for s in sentences if s.strip()])}\n"
+            
+            if words:
+                analysis += f"First word: {words[0]}\n"
+                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):
+                analysis += "Extended Latin characters detected\n"
+            
+            return analysis
+        
+        else:  # Default analyze
+            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(problem: str) -> str:
-    """Solve mathematical problems and analyze mathematical structures
+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
+        Mathematical analysis and solution approach
     """
     try:
-        # 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."
+        problem_lower = problem.lower()
+        
+        # Group theory problems
+        if "commutative" in problem_lower:
+            return """COMMUTATIVITY ANALYSIS:
+To check if operation * is commutative:
+1. Test if a*b = b*a for ALL elements in the set
+2. Look for counterexamples in the operation table
+3. Check systematically: compare (i,j) entry with (j,i) entry
+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
+2. TACTICAL MOTIFS: Look for pins, forks, skewers, discovered attacks
+3. KING SAFETY: Evaluate both kings' positions and escape squares
+4. PIECE ACTIVITY: Consider piece mobility and coordination
+5. MATERIAL BALANCE: Count material and positional advantages
+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
+2. For factorization: Use trial division, then advanced methods
+3. Look for patterns in sequences
+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
+2. Identify known values and what needs to be found
+3. Apply relevant formulas (area, volume, Pythagorean theorem)
+4. Use coordinate geometry if helpful
+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.)
+2. List all possible outcomes if finite
+3. Use appropriate formulas (combinations, permutations)
+4. For statistics: calculate mean, median, mode as needed
+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
+2. For derivatives: Apply appropriate rules (chain, product, quotient)
+3. For integrals: Try substitution, integration by parts
+4. For limits: Use L'Hôpital's rule if indeterminate form
+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
+2. Test the pattern with given examples
+3. Look for mathematical relationships (arithmetic, geometric)
+4. Consider recursive or iterative approaches
+5. Verify solution with edge cases
+6. Optimize for efficiency if needed"""
+        
         else:
-            return f"Mathematical analysis needed for: {problem[:100]}..."
+            # Try to extract numbers and analyze
+            numbers = re.findall(r'-?\d+(?:\.\d+)?', problem)
+            if numbers:
+                return f"""GENERAL MATHEMATICAL ANALYSIS:
+Numbers found: {', '.join(numbers)}
+Problem type analysis needed for: {problem[:100]}
+Consider: arithmetic operations, algebraic manipulation, 
+pattern recognition, or formula application"""
+            
+            return f"Mathematical analysis needed for: {problem[:150]}..."
+            
     except Exception as e:
         return f"Math solver error: {str(e)}"
 
 @tool
-def data_extractor(source: str, target: str) -> str:
-    """Extract structured data from various sources
+def data_extractor_enhanced(source: str, target: str, context: str = "") -> str:
+    """Enhanced data extraction with context awareness
     
     Args:
-        source: Data source or content to extract from
+        source: Source text/data to extract from  
         target: What to extract
+        context: Additional context for extraction
         
     Returns:
-        Extracted data
+        Extracted and processed data
     """
     try:
-        # Botanical classification helper
-        if "botanical" in target.lower() or "vegetable" in target.lower():
-            vegetables = []
+        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"
+            }
             
-            # Common botanical classifications - only true vegetables
-            items = [item.strip() for item in source.split(",")]
+            # 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
             
+            vegetables = []
             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)
+                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
+            ]
             
-            vegetables.sort()
-            return ", ".join(vegetables)
+            dates = []
+            for pattern in date_patterns:
+                matches = re.findall(pattern, source)
+                dates.extend(matches)
+            
+            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"
+            elif "count" in context.lower():
+                integers = [n for n in numbers if '.' not in n]
+                return f"Counts: {', '.join(integers)}" if integers else "No counts found"
+            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"
         
-        return f"Data extraction for {target} from {source[:100]}..."
+        # 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"
+        
+        else:
+            return f"Data extraction for '{target}' from: {source[:200]}..."
+            
     except Exception as e:
         return f"Data extraction error: {str(e)}"
 
-# --- Enhanced Agent Definition ---
+@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
+    """
+    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'
+        }
+        
+        response = requests.get(url, headers=headers, timeout=20)
+        response.raise_for_status()
+        
+        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 = []
+        
+        for line in lines:
+            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"
+        
+    except Exception as e:
+        return f"Web fetch error: {str(e)}"
+
+@tool  
+def calculator_tool(expression: str) -> str:
+    """Safe calculator for mathematical expressions
+    
+    Args:
+        expression: Mathematical expression to evaluate
+        
+    Returns:
+        Calculation result
+    """
+    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}"
+        
+    except ZeroDivisionError:
+        return "Error: Division by zero"
+    except Exception as e:
+        return f"Calculation error: {str(e)}"
+
+# --- Enhanced Agent Class ---
 class GAIAAgent:
     def __init__(self):
-        print("Initializing GAIA Agent...")
+        print("Initializing Enhanced GAIA Agent...")
         
-        # Initialize model with InferenceClientModel
+        # Initialize model
         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"Error initializing model: {e}")
-            # Fallback to a simpler approach if the model fails
-            self.model = InferenceClientModel(
-                model_id="microsoft/DialoGPT-medium"
-            )
+            print(f"Model initialization warning: {e}")
+            self.model = InferenceClientModel(model_id="microsoft/DialoGPT-medium")
         
-        # Custom tools list
+        # Enhanced tools list
         custom_tools = [
             serper_search,
-            wikipedia_search, 
-            youtube_analyzer,
-            text_processor,
-            math_solver,
-            data_extractor
+            wikipedia_enhanced_search,
+            youtube_enhanced_analyzer, 
+            text_processor_advanced,
+            math_solver_advanced,
+            data_extractor_enhanced,
+            web_page_fetcher,
+            calculator_tool
         ]
         
-        # Add DuckDuckGo search tool
+        # Add DuckDuckGo as backup search
         ddg_tool = DuckDuckGoSearchTool()
-        
-        # Create agent with all tools
         all_tools = custom_tools + [ddg_tool]
         
+        # Create agent
         self.agent = CodeAgent(
             tools=all_tools,
             model=self.model
         )
         
-        print("GAIA Agent initialized successfully.")
+        print("Enhanced GAIA Agent initialized successfully.")
 
+    def analyze_question_type(self, question: str) -> Dict[str, Any]:
+        """Analyze question to determine type and strategy"""
+        q_lower = question.lower()
+        
+        analysis = {
+            'type': 'general',
+            'needs_search': True,
+            'needs_calculation': False,
+            'needs_text_processing': False,
+            'confidence': 0.5,
+            'strategy': 'search_first'
+        }
+        
+        # Text reversal questions
+        if any(reversed_phrase in question for reversed_phrase in ['ecnetnes', 'siht dnatsrednu']):
+            analysis.update({
+                'type': 'text_reversal',
+                'needs_search': False,
+                'needs_text_processing': True,
+                'confidence': 0.9,
+                'strategy': 'reverse_text'
+            })
+        
+        # YouTube video questions
+        elif 'youtube.com' in q_lower or 'youtu.be' in q_lower:
+            analysis.update({
+                'type': 'youtube_analysis',
+                'needs_search': False,
+                'confidence': 0.8,
+                'strategy': 'analyze_video'
+            })
+        
+        # Mathematical questions
+        elif any(term in q_lower for term in ['commutative', 'chess', 'mathematical', 'calculate', 'solve']):
+            analysis.update({
+                'type': 'mathematical',
+                'needs_calculation': True,
+                'confidence': 0.8,
+                'strategy': 'math_focused'
+            })
+        
+        # Botanical/classification questions
+        elif 'botanical' in q_lower and 'vegetable' in q_lower:
+            analysis.update({
+                'type': 'classification',
+                'needs_search': False,
+                'confidence': 0.9,
+                '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',
+                'needs_search': True,
+                'confidence': 0.7,
+                'strategy': 'comprehensive_search'
+            })
+        
+        return analysis
     def __call__(self, question: str) -> str:
         print(f"Agent processing question: {question[:100]}...")