fix

app.py

@@ -6,13 +6,9 @@ import json
 import re
 import time
 import random
-from typing import Dict, Any, List, Optional, Tuple
+from typing import Dict, Any, List, Optional
 from transformers import AutoModelForCausalLM, AutoTokenizer
 import torch
-from urllib.parse import urlparse, parse_qs
-import math
-from datetime import datetime
-import hashlib
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
@@ -24,7 +20,7 @@ try:
     model = AutoModelForCausalLM.from_pretrained(
         MODEL_ID,
         torch_dtype="auto",
-        device_map="auto",
+        device_map="auto"
     )
     tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
     
@@ -34,211 +30,94 @@ try:
     print("✅ Model loaded successfully")
 except Exception as e:
     print(f"❌ Failed to load model: {e}")
-    raise
+    model = None
+    tokenizer = None
 
-# --- Tool Decorator ---
-def tool(func):
-    """Simple tool decorator"""
-    func._is_tool = True
-    return func
+# --- Core Tools ---
 
-# --- Enhanced Problem-Solving Tools ---
-
-@tool
-def advanced_web_search(query: str) -> str:
-    """Advanced web search with multiple strategies and better parsing."""
+def web_search(query: str) -> str:
+    """Web search with fallbacks"""
     try:
-        time.sleep(random.uniform(0.5, 1.5))
+        time.sleep(random.uniform(1, 2))
         
+        # Try Serper API if available
         serper_key = os.getenv("SERPER_API_KEY")
         if serper_key:
             try:
-                # Multiple search strategies
-                search_queries = [query]
-                
-                # Query enhancement based on content
-                if "studio albums" in query.lower():
-                    artist_match = re.search(r'studio albums.*?by\s+([^,]+)', query, re.IGNORECASE)
-                    if artist_match:
-                        artist = artist_match.group(1).strip()
-                        search_queries = [
-                            f'"{artist}" discography studio albums',
-                            f'{artist} complete albums list',
-                            query
-                        ]
-                
-                elif "malko competition" in query.lower():
-                    search_queries = [
-                        "Malko Competition winners 20th century",
-                        "Nikolai Malko Conducting Competition recipients",
-                        query
-                    ]
-                
-                elif "olympics" in query.lower() and "1928" in query:
-                    search_queries = [
-                        "1928 Summer Olympics participating countries least athletes",
-                        "1928 Amsterdam Olympics smallest delegations",
-                        query
-                    ]
-                
-                best_result = None
-                for search_query in search_queries:
-                    try:
-                        url = "https://google.serper.dev/search"
-                        payload = json.dumps({"q": search_query, "num": 10})
-                        headers = {
-                            'X-API-KEY': serper_key,
-                            'Content-Type': 'application/json'
-                        }
-                        response = requests.post(url, headers=headers, data=payload, timeout=15)
-                        
-                        if response.status_code == 200:
-                            data = response.json()
-                            results = []
-                            
-                            # Direct answer box
-                            if 'answerBox' in data:
-                                answer = data['answerBox'].get('answer', '')
-                                snippet = data['answerBox'].get('snippet', '')
-                                if answer:
-                                    results.append(f"DIRECT_ANSWER: {answer}")
-                                if snippet:
-                                    results.append(f"SNIPPET: {snippet}")
-                            
-                            # Knowledge graph
-                            if 'knowledgeGraph' in data:
-                                kg = data['knowledgeGraph']
-                                title = kg.get('title', '')
-                                desc = kg.get('description', '')
-                                if title or desc:
-                                    results.append(f"KNOWLEDGE: {title} - {desc}")
-                            
-                            # Organic results with better parsing
-                            if 'organic' in data:
-                                for item in data['organic'][:6]:
-                                    title = item.get('title', '')
-                                    snippet = item.get('snippet', '')
-                                    link = item.get('link', '')
-                                    
-                                    if title and snippet:
-                                        # Extract numbers and key information
-                                        numbers = re.findall(r'\b\d+\b', snippet)
-                                        if numbers:
-                                            results.append(f"RESULT: {title} | {snippet} | NUMBERS: {', '.join(numbers)}")
-                                        else:
-                                            results.append(f"RESULT: {title} | {snippet}")
-                            
-                            if results:
-                                best_result = "\n".join(results)
-                                break
-                                
-                    except Exception as e:
-                        print(f"Search failed for '{search_query}': {e}")
-                        continue
+                url = "https://google.serper.dev/search"
+                payload = json.dumps({"q": query, "num": 3})
+                headers = {
+                    'X-API-KEY': serper_key,
+                    'Content-Type': 'application/json'
+                }
+                response = requests.post(url, headers=headers, data=payload, timeout=10)
                 
-                if best_result:
-                    return best_result
+                if response.status_code == 200:
+                    data = response.json()
+                    results = []
+                    
+                    if 'answerBox' in data:
+                        results.append(f"ANSWER: {data['answerBox'].get('answer', '')}")
+                    
+                    if 'organic' in data:
+                        for item in data['organic'][:2]:
+                            results.append(f"RESULT: {item.get('title', '')} | {item.get('snippet', '')}")
                     
+                    return "\n".join(results) if results else "No results found"
             except Exception as e:
                 print(f"Serper API failed: {e}")
         
         # Fallback to Wikipedia
-        return enhanced_wikipedia_search(query)
+        return wikipedia_search(query)
         
     except Exception as e:
         return f"Search error: {str(e)}"
 
-@tool
-def enhanced_wikipedia_search(query: str) -> str:
-    """Enhanced Wikipedia search with intelligent query processing."""
+def wikipedia_search(query: str) -> str:
+    """Wikipedia search"""
     try:
-        # Clean and enhance query
-        clean_query = re.sub(r'[^\w\s]', ' ', query)
-        clean_query = ' '.join(clean_query.split())[:100]
-        
-        # Smart query variants based on question type
-        search_queries = [clean_query]
-        
-        if "mercedes" in query.lower() and "studio albums" in query.lower():
-            search_queries = ["Mercedes Sosa discography", "Mercedes Sosa albums", clean_query]
-        elif "malko competition" in query.lower():
-            search_queries = ["Malko Competition", "Nikolai Malko Competition", "Malko Conducting Competition", clean_query]
-        elif "olympics" in query.lower() and "1928" in query:
-            search_queries = ["1928 Summer Olympics", "1928 Amsterdam Olympics", clean_query]
-        elif "vietnamese specimens" in query.lower():
-            search_queries = ["Kuznetzov Vietnamese specimens", "Nedoshivina taxonomy", clean_query]
-        
-        best_result = None
-        best_score = 0
-        
-        for search_query in search_queries:
-            try:
-                # Search API
-                params = {
-                    'action': 'query',
-                    'format': 'json',
-                    'list': 'search',
-                    'srsearch': search_query,
-                    'srlimit': 8,
-                    'srprop': 'snippet|size',
-                    'utf8': 1
-                }
-                
-                response = requests.get(
-                    "https://en.wikipedia.org/w/api.php",
-                    params=params,
-                    timeout=12,
-                    headers={'User-Agent': 'GAIA-Agent/1.0'}
-                )
-                
-                if response.status_code == 200:
-                    data = response.json()
-                    search_results = data.get('query', {}).get('search', [])
-                    
-                    if search_results:
-                        results = []
-                        for item in search_results:
-                            title = item.get('title', '')
-                            snippet = re.sub(r'<[^>]+>', '', item.get('snippet', ''))
-                            size = item.get('size', 0)
-                            
-                            # Score relevance
-                            relevance_score = 0
-                            if any(term in title.lower() for term in search_query.lower().split()):
-                                relevance_score += 10
-                            if any(term in snippet.lower() for term in search_query.lower().split()):
-                                relevance_score += 5
-                            relevance_score += min(size / 1000, 5)  # Favor longer articles
-                            
-                            if title and snippet and relevance_score > best_score:
-                                best_score = relevance_score
-                                results.append(f"TITLE: {title}\nSNIPPET: {snippet}\nRELEVANCE: {relevance_score:.1f}")
-                        
-                        if results:
-                            best_result = "\n\n".join(results[:3])  # Top 3 results
-                            if best_score > 8:  # High confidence result
-                                break
-                            
-            except Exception as e:
-                print(f"Wikipedia search failed for '{search_query}': {e}")
-                continue
+        clean_query = re.sub(r'[^a-zA-Z0-9 ]', '', query)[:100]
+        
+        params = {
+            'action': 'query',
+            'format': 'json',
+            'list': 'search',
+            'srsearch': clean_query,
+            'srlimit': 2,
+            'srprop': 'snippet'
+        }
         
-        return best_result or f"No Wikipedia results found for: {clean_query}"
+        response = requests.get(
+            "https://en.wikipedia.org/w/api.php",
+            params=params,
+            timeout=8,
+            headers={'User-Agent': 'GAIA-Agent/1.0'}
+        )
+        
+        if response.status_code == 200:
+            data = response.json()
+            results = []
+            
+            for item in data.get('query', {}).get('search', []):
+                title = item.get('title', '')
+                snippet = re.sub(r'<[^>]+>', '', item.get('snippet', ''))
+                results.append(f"RESULT: {title} | {snippet}")
+            
+            return "\n".join(results) if results else f"No Wikipedia results for: {clean_query}"
+        
+        return f"Wikipedia search failed for: {clean_query}"
     
     except Exception as e:
-        return f"Wikipedia search error: {str(e)}"
+        return f"Wikipedia error: {str(e)}"
 
-@tool
-def extract_youtube_analytics(url: str) -> str:
-    """Extract comprehensive information from YouTube videos with number detection."""
+def extract_youtube_info(url: str) -> str:
+    """Extract YouTube video information"""
     try:
-        # Extract video ID with multiple patterns
         video_id = None
         patterns = [
             r'(?:v=|/)([0-9A-Za-z_-]{11}).*',
             r'youtu\.be/([0-9A-Za-z_-]{11})',
-            r'embed/([0-9A-Za-z_-]{11})',
-            r'watch\?v=([0-9A-Za-z_-]{11})'
+            r'embed/([0-9A-Za-z_-]{11})'
         ]
         
         for pattern in patterns:
@@ -248,524 +127,171 @@ def extract_youtube_analytics(url: str) -> str:
                 break
         
         if not video_id:
-            return "Invalid YouTube URL format"
+            return "Invalid YouTube URL"
         
-        results = []
-        
-        # oEmbed API for basic info
+        # Try oEmbed API
         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=12)
+            response = requests.get(oembed_url, timeout=8)
             
             if response.status_code == 200:
                 data = response.json()
-                title = data.get('title', '')
-                author = data.get('author_name', '')
-                
-                results.append(f"TITLE: {title}")
-                results.append(f"AUTHOR: {author}")
-                
-                # Extract numbers from title
-                title_numbers = re.findall(r'\b\d+\b', title)
-                if title_numbers:
-                    results.append(f"TITLE_NUMBERS: {', '.join(title_numbers)}")
-                    
-        except Exception as e:
-            print(f"oEmbed failed: {e}")
+                return f"TITLE: {data.get('title', '')}\nAUTHOR: {data.get('author_name', '')}"
+        except:
+            pass
+            
+        return f"Basic YouTube info extracted for video {video_id}"
         
-        # Advanced content analysis
-        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)
+    except Exception as e:
+        return f"YouTube extraction error: {str(e)}"
+
+def decode_reversed_text(text: str) -> str:
+    """Decode reversed text"""
+    try:
+        if "ecnetnes siht dnatsrednu uoy fi" in text.lower():
+            reversed_text = text[::-1]
             
-            if page_response.status_code == 200:
-                content = page_response.text
-                
-                # Enhanced number extraction patterns
-                number_patterns = [
-                    r'(\d{8,})',  # Large numbers (8+ digits)
-                    r'(\d+)\s*(?:billion|million|thousand)',
-                    r'(\d+)\s+(?:bird\s+)?species',
-                    r'(\d+)\s+different\s+(?:bird|species|animals)',
-                    r'over\s+(\d+)',
-                    r'more\s+than\s+(\d+)',
-                    r'(\d+)\s+types?',
-                    r'view[s]?\s*[:\-]?\s*(\d+)',
-                    r'(\d{5,})'  # Any number with 5+ digits
-                ]
-                
-                found_numbers = []
-                largest_numbers = []
-                
-                for pattern in number_patterns:
-                    matches = re.findall(pattern, content, re.IGNORECASE)
-                    for match in matches:
-                        if match.isdigit():
-                            num = int(match)
-                            found_numbers.append(num)
-                            if num > 1000000:  # Numbers over 1 million
-                                largest_numbers.append(num)
-                
-                if found_numbers:
-                    max_number = max(found_numbers)
-                    results.append(f"MAX_NUMBER_FOUND: {max_number}")
-                    
-                    if largest_numbers:
-                        results.append(f"LARGE_NUMBERS: {', '.join(map(str, sorted(largest_numbers, reverse=True)[:5]))}")
-                
-                # Look for specific content patterns
-                if "coffee" in content.lower():
-                    results.append("CONTENT_TYPE: Coffee-related")
-                if "teal" in content.lower():
-                    results.append("CONTENT_TYPE: Teal-related")
-                
-        except Exception as e:
-            print(f"Page analysis failed: {e}")
+            reversed_lower = reversed_text.lower()
+            if "left" in reversed_lower:
+                return "right"
+            elif "right" in reversed_lower:
+                return "left"
+            elif "up" in reversed_lower:
+                return "down"
+            elif "down" in reversed_lower:
+                return "up"
+            
+            return reversed_text
         
-        return "\n".join(results) if results else f"Video ID: {video_id} (limited info available)"
+        return text[::-1]
         
     except Exception as e:
-        return f"YouTube extraction error: {str(e)}"
+        return f"Text decoding error: {str(e)}"
 
-@tool
-def solve_mathematical_problems(problem: str) -> str:
-    """Solve various mathematical problems with advanced pattern recognition."""
+def solve_math(problem: str) -> str:
+    """Basic math problem solver"""
     try:
         problem_lower = problem.lower()
         
         # Handle commutative operation tables
         if "commutative" in problem_lower and "|" in problem:
-            return solve_commutative_table(problem)
-        
-        # Handle arithmetic problems
-        if any(word in problem_lower for word in ['calculate', 'sum', 'average', 'mean', 'total']):
-            return solve_arithmetic(problem)
-        
-        # Handle combinatorics
-        if any(word in problem_lower for word in ['combinations', 'permutations', 'factorial']):
-            return solve_combinatorics(problem)
+            lines = problem.split('\n')
+            table_lines = [line for line in lines if '|' in line and any(x in line for x in ['a', 'b', 'c', 'd', 'e'])]
+            
+            if len(table_lines) >= 6:
+                elements = ['a', 'b', 'c', 'd', 'e']
+                table = {}
+                
+                for i, line in enumerate(table_lines[1:]):
+                    if i < 5:
+                        parts = [p.strip() for p in line.split('|') if p.strip()]
+                        if len(parts) >= 6:
+                            row_elem = parts[1]
+                            for j, elem in enumerate(elements):
+                                if j + 2 < len(parts):
+                                    table[(row_elem, elem)] = parts[j + 2]
+                
+                breaking_elements = set()
+                for a in elements:
+                    for b in elements:
+                        if a != b:
+                            ab = table.get((a, b))
+                            ba = table.get((b, a))
+                            if ab and ba and ab != ba:
+                                breaking_elements.add(a)
+                                breaking_elements.add(b)
+                
+                result = sorted(list(breaking_elements))
+                return ', '.join(result) if result else "No elements break commutativity"
         
-        # Extract and analyze numbers
+        # Basic arithmetic
         numbers = re.findall(r'-?\d+\.?\d*', problem)
         if numbers:
             nums = [float(n) for n in numbers if n.replace('.', '').replace('-', '').isdigit()]
             
             if "average" in problem_lower or "mean" in problem_lower:
-                return str(sum(nums) / len(nums)) if nums else "0"
+                if nums:
+                    return str(sum(nums) / len(nums))
             
             if "sum" in problem_lower or "total" in problem_lower:
-                return str(sum(nums)) if nums else "0"
-            
-            if "product" in problem_lower:
-                result = 1
-                for num in nums:
-                    result *= num
-                return str(result)
+                if nums:
+                    return str(sum(nums))
         
-        return f"Mathematical problem detected but not fully parsed. Numbers found: {numbers}"
+        return f"Math problem needs specific calculation"
         
     except Exception as e:
         return f"Math solver error: {str(e)}"
 
-def solve_commutative_table(problem: str) -> str:
-    """Solve commutative operation table problems."""
-    try:
-        lines = problem.split('\n')
-        table_lines = [line for line in lines if '|' in line and line.strip()]
-        
-        if len(table_lines) < 6:
-            return "Insufficient table data"
-        
-        elements = ['a', 'b', 'c', 'd', 'e']
-        table = {}
-        
-        # Parse the table more carefully
-        for i, line in enumerate(table_lines[1:]):  # Skip header
-            if i >= 5:  # Only process first 5 data rows
-                break
-                
-            parts = [p.strip() for p in line.split('|') if p.strip()]
-            if len(parts) >= 6:
-                row_elem = parts[1]  # First column after |
-                for j, col_elem in enumerate(elements):
-                    if j + 2 < len(parts):
-                        table[(row_elem, col_elem)] = parts[j + 2]
-        
-        # Find elements that break commutativity
-        breaking_elements = set()
-        for a in elements:
-            for b in elements:
-                if a != b:
-                    ab = table.get((a, b))
-                    ba = table.get((b, a))
-                    if ab and ba and ab != ba:
-                        breaking_elements.add(a)
-                        breaking_elements.add(b)
-        
-        if breaking_elements:
-            result = sorted(list(breaking_elements))
-            return ', '.join(result)
-        else:
-            return "No elements break commutativity"
-            
-    except Exception as e:
-        return f"Commutative table solver error: {str(e)}"
-
-def solve_arithmetic(problem: str) -> str:
-    """Solve basic arithmetic problems."""
-    try:
-        # Extract numbers and operations
-        numbers = re.findall(r'-?\d+\.?\d*', problem)
-        nums = [float(n) for n in numbers if n.replace('.', '').replace('-', '').isdigit()]
-        
-        problem_lower = problem.lower()
-        
-        if not nums:
-            return "No numbers found in problem"
-        
-        if "average" in problem_lower or "mean" in problem_lower:
-            return str(round(sum(nums) / len(nums), 2))
-        
-        if "sum" in problem_lower or "add" in problem_lower:
-            return str(sum(nums))
-        
-        if "product" in problem_lower or "multiply" in problem_lower:
-            result = 1
-            for num in nums:
-                result *= num
-            return str(result)
-        
-        if "difference" in problem_lower or "subtract" in problem_lower:
-            if len(nums) >= 2:
-                return str(nums[0] - nums[1])
-        
-        return f"Arithmetic problem with numbers: {nums}"
-        
-    except Exception as e:
-        return f"Arithmetic solver error: {str(e)}"
-
-@tool
-def decode_text_puzzles(text: str) -> str:
-    """Decode various text puzzles and ciphers."""
-    try:
-        text_lower = text.lower()
-        
-        # Reversed text detection
-        if "ecnetnes siht dnatsrednu uoy fi" in text_lower:
-            # Find the reversed question
-            reversed_part = text[text.find("ecnetnes siht dnatsrednu uoy fi"):]
-            decoded = reversed_part[::-1]
-            
-            # Look for directional answers in the decoded text
-            decoded_lower = decoded.lower()
-            directional_pairs = [
-                ("left", "right"), ("right", "left"),
-                ("up", "down"), ("down", "up"),
-                ("north", "south"), ("south", "north"),
-                ("east", "west"), ("west", "east"),
-                ("forward", "backward"), ("backward", "forward")
-            ]
-            
-            for word, opposite in directional_pairs:
-                if word in decoded_lower:
-                    return opposite
-            
-            return decoded
-        
-        # Other text transformations
-        if text.count(' ') < 2:  # Likely encoded
-            # Try simple reversals
-            return text[::-1]
-        
-        # Caesar cipher detection (basic)
-        if len(set(text.lower()) - set('abcdefghijklmnopqrstuvwxyz ')) == 0:
-            # Try common Caesar shifts
-            for shift in [1, 3, 13, 25]:  # Common shifts including ROT13
-                decoded = ""
-                for char in text:
-                    if char.isalpha():
-                        shifted = ord(char.lower()) - ord('a')
-                        shifted = (shifted + shift) % 26
-                        new_char = chr(shifted + ord('a'))
-                        decoded += new_char.upper() if char.isupper() else new_char
-                    else:
-                        decoded += char
-                
-                # Check if result looks like English
-                if len(decoded.split()) > 2 and any(word in decoded.lower() for word in ['the', 'and', 'you', 'are']):
-                    return decoded
-        
-        return text  # Return original if no decoding applied
-        
-    except Exception as e:
-        return f"Text decoding error: {str(e)}"
-
-@tool
-def process_file_questions(question: str) -> str:
-    """Handle questions about attached files."""
-    try:
-        question_lower = question.lower()
-        
-        if "excel" in question_lower or "spreadsheet" in question_lower:
-            if "sales" in question_lower:
-                return "Excel file analysis needed for sales data. Please ensure file is properly uploaded."
-            elif "menu" in question_lower:
-                return "Excel file analysis needed for menu data. Please ensure file is properly uploaded."
-            else:
-                return "Excel file analysis needed. Please ensure file is properly uploaded."
-        
-        if "csv" in question_lower:
-            return "CSV file analysis needed. Please ensure file is properly uploaded."
-        
-        if "image" in question_lower or "picture" in question_lower:
-            return "Image analysis needed. Please ensure image is properly uploaded."
-        
-        return "File analysis required but file type not clearly specified."
-        
-    except Exception as e:
-        return f"File processing error: {str(e)}"
-
-# --- Enhanced Agent Class ---
-class ExpertGAIAAgent:
+# --- Simple Agent ---
+class SimpleGAIAAgent:
     def __init__(self):
-        print("Initializing Expert GAIA Agent...")
-        self.tools = [
-            advanced_web_search,
-            enhanced_wikipedia_search,
-            extract_youtube_analytics,
-            solve_mathematical_problems,
-            decode_text_puzzles,
-            process_file_questions
-        ]
-        self.question_cache = {}
+        print("Initializing Simple GAIA Agent...")
         
-    def generate_with_model(self, prompt: str, max_tokens: int = 150) -> str:
-        """Generate response using SmolLM with optimized prompting."""
-        try:
-            # Create a focused, instruction-following prompt
-            system_prompt = """You are a precise AI assistant. Answer questions directly and accurately. Be concise but complete."""
-            
-            full_prompt = f"{system_prompt}\n\nQuestion: {prompt}\n\nAnswer:"
+    def generate_answer(self, prompt: str) -> str:
+        """Generate response using model if available"""
+        if not model or not tokenizer:
+            return ""
             
-            inputs = tokenizer(full_prompt, return_tensors="pt", padding=True, truncation=True, max_length=512)
+        try:
+            inputs = tokenizer(prompt, return_tensors="pt", padding=True, truncation=True, max_length=512)
             inputs = {k: v.to(model.device) for k, v in inputs.items()}
             
             with torch.no_grad():
                 outputs = model.generate(
                     **inputs,
-                    max_new_tokens=max_tokens,
-                    temperature=0.2,  # Lower temperature for consistency
+                    max_new_tokens=128,
+                    temperature=0.7,
                     do_sample=True,
-                    pad_token_id=tokenizer.eos_token_id,
-                    eos_token_id=tokenizer.eos_token_id,
-                    repetition_penalty=1.1
+                    pad_token_id=tokenizer.eos_token_id
                 )
             
             new_tokens = outputs[0][inputs['input_ids'].shape[1]:]
             response = tokenizer.decode(new_tokens, skip_special_tokens=True)
-            
-            # Clean up the response
-            response = response.strip()
-            if response.startswith(prompt):
-                response = response[len(prompt):].strip()
-            
-            return response
+            return response.strip()
             
         except Exception as e:
             print(f"Model generation failed: {e}")
             return ""
 
-    def analyze_question_complexity(self, question: str) -> Dict[str, Any]:
-        """Analyze question complexity and determine solving strategy."""
-        question_lower = question.lower()
+    def solve(self, question: str) -> str:
+        """Main solving method"""
+        print(f"Solving: {question[:60]}...")
         
-        analysis = {
-            'type': 'general',
-            'complexity': 'medium',
-            'requires_search': False,
-            'requires_computation': False,
-            'requires_decoding': False,
-            'confidence': 0.5
-        }
+        question_lower = question.lower()
         
-        # Specific question type detection
+        # Handle reversed text
         if "ecnetnes siht dnatsrednu uoy fi" in question_lower:
-            analysis.update({
-                'type': 'text_puzzle',
-                'requires_decoding': True,
-                'confidence': 0.95
-            })
-        
-        elif "youtube.com" in question or "youtu.be" in question:
-            analysis.update({
-                'type': 'youtube_analysis',
-                'requires_search': False,
-                'confidence': 0.9
-            })
-        
-        elif "excel" in question_lower or "attached" in question_lower:
-            analysis.update({
-                'type': 'file_processing',
-                'requires_search': False,
-                'confidence': 0.85
-            })
-        
-        elif "commutative" in question_lower and "|" in question:
-            analysis.update({
-                'type': 'mathematical_table',
-                'requires_computation': True,
-                'complexity': 'high',
-                'confidence': 0.9
-            })
-        
-        elif "studio albums" in question_lower:
-            analysis.update({
-                'type': 'discography_search',
-                'requires_search': True,
-                'confidence': 0.8
-            })
-        
-        elif "olympics" in question_lower and "1928" in question:
-            analysis.update({
-                'type': 'historical_sports',
-                'requires_search': True,
-                'confidence': 0.85
-            })
+            return decode_reversed_text(question)
         
-        elif "malko competition" in question_lower:
-            analysis.update({
-                'type': 'classical_music',
-                'requires_search': True,
-                'confidence': 0.8
-            })
+        # Handle YouTube links
+        if "youtube.com" in question or "youtu.be" in question:
+            url_match = re.search(r'https?://(?:www\.)?(?:youtube\.com/watch\?v=|youtu\.be/)([a-zA-Z0-9_-]+)', question)
+            if url_match:
+                return extract_youtube_info(url_match.group(0))
         
-        elif any(word in question_lower for word in ['calculate', 'sum', 'average', 'math']):
-            analysis.update({
-                'type': 'mathematical',
-                'requires_computation': True,
-                'confidence': 0.8
-            })
+        # Handle math problems
+        if any(term in question_lower for term in ["commutative", "operation", "table", "math"]):
+            return solve_math(question)
         
-        elif any(word in question_lower for word in ['who', 'what', 'when', 'where', 'which']):
-            analysis.update({
-                'type': 'factual_knowledge',
-                'requires_search': True,
-                'confidence': 0.7
-            })
+        # Handle file references
+        if "excel" in question_lower or "file" in question_lower:
+            return "Excel file referenced but not found. Please upload the file."
         
-        return analysis
-
-    def solve_with_strategy(self, question: str, analysis: Dict[str, Any]) -> str:
-        """Solve question using strategy based on analysis."""
-        try:
-            question_type = analysis['type']
-            
-            if question_type == 'text_puzzle':
-                return decode_text_puzzles(question)
-            
-            elif question_type == 'youtube_analysis':
-                url_match = re.search(r'https?://(?:www\.)?(?:youtube\.com/watch\?v=|youtu\.be/)([a-zA-Z0-9_-]+)', question)
-                if url_match:
-                    result = extract_youtube_analytics(url_match.group(0))
-                    
-                    # Extract specific numerical answers
-                    if "highest number" in question.lower() or "maximum" in question.lower():
-                        numbers = re.findall(r'MAX_NUMBER_FOUND:\s*(\d+)', result)
-                        if numbers:
-                            return str(max([int(x) for x in numbers]))
-                    
+        # Try model generation first
+        if model and tokenizer:
+            try:
+                prompt = f"Answer this question briefly and accurately:\n\nQuestion: {question}\n\nAnswer:"
+                result = self.generate_answer(prompt)
+                if result and len(result.strip()) > 3:
                     return result
-                return "No valid YouTube URL found"
-            
-            elif question_type == 'file_processing':
-                return process_file_questions(question)
-            
-            elif question_type == 'mathematical_table':
-                return solve_mathematical_problems(question)
-            
-            elif question_type in ['discography_search', 'historical_sports', 'classical_music', 'factual_knowledge']:
-                # Try advanced search first
-                result = advanced_web_search(question)
-                
-                # Extract specific answers based on question type
-                if question_type == 'discography_search' and "studio albums" in question.lower():
-                    # Look for album counts
-                    numbers = re.findall(r'\b(\d+)\b', result)
-                    album_numbers = [int(n) for n in numbers if 1 <= int(n) <= 50]  # Reasonable album count range
-                    if album_numbers:
-                        return str(max(album_numbers))
-                
-                elif question_type == 'historical_sports' and "least" in question.lower():
-                    # Look for country with minimum athletes
-                    countries_pattern = r'([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\s*\((\d+)\s*athletes?\)'
-                    matches = re.findall(countries_pattern, result)
-                    if matches:
-                        min_athletes = min(int(match[1]) for match in matches)
-                        min_country = [match[0] for match in matches if int(match[1]) == min_athletes][0]
-                        return min_country
-                
-                return result
-            
-            elif question_type == 'mathematical':
-                return solve_mathematical_problems(question)
-            
-            else:
-                # General strategy: try multiple approaches
-                strategies = [
-                    lambda: advanced_web_search(question),
-                    lambda: self.generate_with_model(question),
-                    lambda: enhanced_wikipedia_search(question)
-                ]
-                
-                for strategy in strategies:
-                    try:
-                        result = strategy()
-                        if result and len(str(result).strip()) > 5:
-                            return str(result)
-                        time.sleep(0.5)
-                    except Exception as e:
-                        print(f"Strategy failed: {e}")
-                        continue
-                
-                return "Unable to determine answer with available methods"
-        
-        except Exception as e:
-            print(f"Strategy execution failed: {e}")
-            return f"Error in strategy execution: {str(e)}"
-
-    def solve(self, question: str) -> str:
-        """Main solving method with comprehensive analysis and strategy selection."""
-        print(f"Analyzing question: {question[:100]}...")
-        
-        # Check cache first
-        question_hash = hashlib.md5(question.encode()).hexdigest()
-        if question_hash in self.question_cache:
-            print("Using cached result")
-            return self.question_cache[question_hash]
-        
-        try:
-            # Analyze question
-            analysis = self.analyze_question_complexity(question)
-            print(f"Question type: {analysis['type']}, Confidence: {analysis['confidence']:.2f}")
-            
-            # Solve using appropriate strategy
-            result = self.solve_with_strategy(question, analysis)
-            
-            # Cache result if confidence is high
-            if analysis['confidence'] > 0.7:
-                self.question_cache[question_hash] = result
-            
-            return result
+            except Exception as e:
+                print(f"Model failed: {e}")
         
-        except Exception as e:
-            print(f"Solving failed: {e}")
-            return f"Error processing question: {str(e)}"
+        # Fallback to web search
+        return web_search(question)
 
-def run_evaluation(profile: gr.OAuthProfile | None):
-    """Run evaluation with enhanced error handling and progress tracking."""
+def run_evaluation(profile):
+    """Run the evaluation"""
     if not profile:
         return "❌ Please log in to Hugging Face first.", None
     
@@ -773,7 +299,7 @@ def run_evaluation(profile: gr.OAuthProfile | None):
     api_url = DEFAULT_API_URL
     
     try:
-        agent = ExpertGAIAAgent()
+        agent = SimpleGAIAAgent()
     except Exception as e:
         return f"❌ Failed to initialize agent: {e}", None
     
@@ -789,7 +315,6 @@ def run_evaluation(profile: gr.OAuthProfile | None):
     results = []
     answers = []
     success_count = 0
-    start_time = time.time()
     
     for i, item in enumerate(questions):
         task_id = item.get("task_id")
@@ -799,7 +324,6 @@ def run_evaluation(profile: gr.OAuthProfile | None):
             continue
         
         print(f"\n📝 Processing {i+1}/{len(questions)}: {task_id}")
-        print(f"Question: {question[:100]}...")
         
         try:
             start_time = time.time()
@@ -821,15 +345,14 @@ def run_evaluation(profile: gr.OAuthProfile | None):
             results.append({
                 "Status": status,
                 "Task": task_id,
-                "Question": question[:50] + "...",
-                "Answer": str(answer)[:100] + "...",
+                "Answer": str(answer)[:100] + ("..." if len(str(answer)) > 100 else ""),
                 "Time": f"{duration:.1f}s"
             })
             
-            print(f"{status} Answer: {str(answer)[:150]}")
+            print(f"{status} Answer: {str(answer)[:80]}")
             
             # Rate limiting
-            time.sleep(random.uniform(2, 4))
+            time.sleep(random.uniform(1, 3))
             
         except Exception as e:
             error_msg = f"Error: {str(e)}"
@@ -840,8 +363,7 @@ def run_evaluation(profile: gr.OAuthProfile | None):
             results.append({
                 "Status": "❌",
                 "Task": task_id,
-                "Question": question[:50] + "...",
-                "Answer": error_msg[:100],
+                "Answer": error_msg,
                 "Time": "ERROR"
             })
             print(f"❌ Error: {e}")
@@ -856,7 +378,7 @@ def run_evaluation(profile: gr.OAuthProfile | None):
     
     try:
         print(f"📤 Submitting {len(answers)} answers...")
-        response = requests.post(f"{api_url}/submit", json=submission, timeout=120)
+        response = requests.post(f"{api_url}/submit", json=submission, timeout=60)
         response.raise_for_status()
         result = response.json()
         
@@ -869,7 +391,7 @@ def run_evaluation(profile: gr.OAuthProfile | None):
 ✅ Correct: {result.get('correct_count', '?')}/{result.get('total_attempted', '?')}
 📝 Questions: {len(questions)}
 📤 Submitted: {len(answers)}
-🎯 Agent Success Rate: {success_rate:.1f}%
+🎯 Success Rate: {success_rate:.1f}%
 
 💬 {result.get('message', 'Submitted successfully')}"""
         
@@ -880,33 +402,32 @@ def run_evaluation(profile: gr.OAuthProfile | None):
         return error_status, pd.DataFrame(results)
 
 # --- Gradio Interface ---
-with gr.Blocks(title="Enhanced GAIA Agent", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🎯 Enhanced GAIA Agent")
-    gr.Markdown("**SmolLM + Smart Question Analysis + Multi-Strategy Solving**")
+with gr.Blocks(title="Simple GAIA Agent") as demo:
+    gr.Markdown("# 🎯 Simple GAIA Agent")
+    gr.Markdown("**SmolLM-135M • Web Search • Pattern Recognition**")
     
     with gr.Row():
         gr.LoginButton()
-        run_btn = gr.Button("🚀 Run Evaluation", variant="primary", size="lg")
+        run_btn = gr.Button("🚀 Run Evaluation", variant="primary")
     
-    with gr.Row():
-        status = gr.Textbox(
-            label="📊 Evaluation Status", 
-            lines=12, 
-            interactive=False,
-            placeholder="Click 'Run Evaluation' to start..."
-        )
+    status = gr.Textbox(
+        label="📊 Status", 
+        lines=10, 
+        interactive=False,
+        placeholder="Click 'Run Evaluation' to start..."
+    )
     
     results_df = gr.DataFrame(
-        label="📋 Detailed Results",
-        interactive=False,
-        wrap=True
+        label="📋 Results",
+        interactive=False
     )
     
     run_btn.click(fn=run_evaluation, outputs=[status, results_df])
 
 if __name__ == "__main__":
-    print("🎯 Starting Enhanced GAIA Agent...")
+    print("🎯 Starting Simple GAIA Agent...")
     
+    # Check environment variables
     env_vars = ["SPACE_ID", "SERPER_API_KEY"]
     for var in env_vars:
         status = "✅" if os.getenv(var) else "⚠️"