Update app.py

app.py

@@ -6,92 +6,136 @@ import json
 import re
 import tempfile
 import logging
+import shutil
 from typing import List, Dict, Optional, TypedDict, Annotated
 import numpy as np
 import base64
 import subprocess
 import sys
+import time
+from pathlib import Path
 
-# Configure ffmpeg for pydub in HuggingFace Spaces
-def setup_ffmpeg():
-    """Setup ffmpeg for audio processing in HuggingFace Spaces"""
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# CRITICAL: Use /tmp for HuggingFace Spaces (read-only filesystem)
+DOWNLOADS_DIR = "/tmp/gaia_downloads"
+TEMP_DIR = "/tmp/gaia_temp"
+
+def setup_directories():
+    """Setup directories with proper permissions for HF Spaces"""
     try:
-        # Check if ffmpeg is already available
-        subprocess.run(['ffmpeg', '-version'], capture_output=True, check=True)
-        print("✅ ffmpeg already available")
+        os.makedirs(DOWNLOADS_DIR, exist_ok=True)
+        os.makedirs(TEMP_DIR, exist_ok=True)
+        
+        # Test write permissions
+        test_file = os.path.join(DOWNLOADS_DIR, "test_write.txt")
+        with open(test_file, 'w') as f:
+            f.write("test")
+        os.remove(test_file)
+        
+        print(f"✅ Directories ready: {DOWNLOADS_DIR}, {TEMP_DIR}")
         return True
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        try:
-            # Try to install ffmpeg using apt-get (works in HF Spaces)
-            print("📦 Installing ffmpeg...")
-            subprocess.run(['apt-get', 'update'], capture_output=True, check=True)
-            subprocess.run(['apt-get', 'install', '-y', 'ffmpeg'], capture_output=True, check=True)
-            print("✅ ffmpeg installed successfully")
+    except Exception as e:
+        print(f"❌ Directory setup failed: {e}")
+        return False
+
+# Setup directories early
+DIRS_READY = setup_directories()
+
+def setup_ffmpeg():
+    """Setup ffmpeg - graceful degradation for HF Spaces"""
+    try:
+        result = subprocess.run(['ffmpeg', '-version'], capture_output=True, timeout=10)
+        if result.returncode == 0:
+            print("✅ ffmpeg available")
             return True
-        except subprocess.CalledProcessError as e:
-            print(f"⚠️ Could not install ffmpeg: {e}")
-            return False
-        except Exception as e:
-            print(f"⚠️ ffmpeg setup failed: {e}")
-            return False
+    except:
+        pass
+    
+    # Try alternative approaches for HF Spaces
+    try:
+        # Check if available via different path
+        result = subprocess.run(['which', 'ffmpeg'], capture_output=True, timeout=5)
+        if result.returncode == 0:
+            print("✅ ffmpeg found via which")
+            return True
+    except:
+        pass
+    
+    print("⚠️ ffmpeg not available - audio conversion limited")
+    return False
 
-# Setup ffmpeg early
 FFMPEG_AVAILABLE = setup_ffmpeg()
 
-# Core ML/AI imports
-from langchain_core.messages import HumanMessage, SystemMessage, AnyMessage, ToolMessage
-from langchain_openai import ChatOpenAI
-from langchain_core.tools import tool
-from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_experimental.tools import PythonREPLTool
-from langgraph.graph import StateGraph, START, END
-from langgraph.graph.message import add_messages
-from langgraph.prebuilt import ToolNode, tools_condition
-from langgraph.checkpoint.memory import MemorySaver
-
-# File processing
-from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
-import speech_recognition as sr
-from PIL import Image
+# Core imports with better error handling
+try:
+    from langchain_core.messages import HumanMessage, SystemMessage, AnyMessage, ToolMessage
+    from langchain_openai import ChatOpenAI
+    from langchain_core.tools import tool
+    from langchain_community.tools.tavily_search import TavilySearchResults
+    from langchain_experimental.tools import PythonREPLTool
+    from langgraph.graph import StateGraph, START, END
+    from langgraph.graph.message import add_messages
+    from langgraph.prebuilt import ToolNode, tools_condition
+    from langgraph.checkpoint.memory import MemorySaver
+    LANGCHAIN_AVAILABLE = True
+    print("✅ LangChain imports successful")
+except ImportError as e:
+    print(f"❌ Critical LangChain import failure: {e}")
+    LANGCHAIN_AVAILABLE = False
+    raise
 
-# Transformers with error handling
+try:
+    from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
+    import speech_recognition as sr
+    from PIL import Image
+    print("✅ File processing imports successful")
+except ImportError as e:
+    print(f"❌ File processing import failure: {e}")
+    raise
+
+# Optional imports with graceful degradation
 try:
     from transformers import pipeline
     TRANSFORMERS_AVAILABLE = True
-    print("✅ Transformers library loaded successfully")
+    print("✅ Transformers available")
 except ImportError:
     TRANSFORMERS_AVAILABLE = False
-    print("⚠️ Transformers not available - image analysis will be limited")
+    print("⚠️ Transformers not available")
 
-# Audio processing - NEW IMPORTS
 try:
     from pydub import AudioSegment
     PYDUB_AVAILABLE = True
+    print("✅ pydub available")
 except ImportError:
     PYDUB_AVAILABLE = False
-    print("⚠️ pydub not available - MP3 conversion will be limited")
+    print("⚠️ pydub not available")
 
-# Computer vision
 try:
     from ultralytics import YOLO
     import cv2
     import yt_dlp
     VISION_AVAILABLE = True
+    print("✅ Vision libraries available")
 except ImportError:
     VISION_AVAILABLE = False
-    print("⚠️ Vision libraries not available, will skip vision tasks")
+    print("⚠️ Vision libraries not available")
 
 # Silence verbose logging
-os.environ['ULTRALYTICS_VERBOSE'] = 'false'
-os.environ['YOLO_VERBOSE'] = 'false'
+os.environ.update({
+    'ULTRALYTICS_VERBOSE': 'false',
+    'YOLO_VERBOSE': 'false',
+    'TRANSFORMERS_VERBOSITY': 'error'
+})
 logging.getLogger("ultralytics").setLevel(logging.ERROR)
 
-# --- Constants ---
+# Constants
 HF_API_BASE_URL = "https://agents-course-unit4-scoring.hf.space"
 USERNAME = "Csuarezg"  
 AGENT_CODE = "langgraph_gaia_agent"
 
-# FIXED System prompt - Added missing IOC code example
 SYSTEM_PROMPT = """You are a precision research assistant for the GAIA benchmark. Your mission is EXTREME ACCURACY.
 
 CRITICAL ANSWER FORMAT RULES:
@@ -117,27 +161,6 @@ CRITICAL TOOL SELECTION:
 # - Mathematical analysis/calculations → wolfram_alpha_tool or python_repl_tool ONLY
 # - Tables, matrices, systematic checking → python_repl_tool ONLY
 
-FOR MATHEMATICAL PROBLEMS:
-# ALWAYS use python_repl_tool when:
-# - Analyzing mathematical tables or matrices
-# - Checking properties like commutativity, associativity
-# - Systematic verification of mathematical statements
-# - Complex calculations that need precision
-# - ANY problem involving tables, sets, or systematic checking
-
-MATHEMATICAL ANALYSIS PROCESS:
-# 1. Use python_repl_tool to parse data systematically
-# 2. Write code to check ALL cases (don't rely on manual inspection)
-# 3. Collect results programmatically
-# 4. Verify your logic with multiple approaches
-# 5. Format answer exactly as requested
-
-# Example for commutativity checking:
-# - Parse the operation table into a data structure
-# - Check ALL pairs (x,y) to see if x*y = y*x
-# - Collect ALL elements involved in ANY counter-example
-# - Return in requested format (e.g., comma-separated, alphabetical)
-
 FILE HANDLING:
 # - You HAVE the ability to read and analyze uploaded files
 # - ALWAYS use file_analyzer_tool when questions mention files
@@ -146,12 +169,12 @@ FILE HANDLING:
 # - NEVER say "I can't access files" - you CAN access them via file_analyzer_tool
 # - Example: "The attached Excel file..." → Use file_analyzer_tool immediately
 
-SPECIAL CASES TO HANDLE:
-# - If the question appears reversed or encoded, decode it first.
-# - If the question includes an instruction (e.g., "write the opposite of..."), follow the instruction precisely.
-# - DO NOT repeat or paraphrase the question in your answer.
-# - NEVER answer with the full sentence unless explicitly asked to.
-# - If the decoded question asks for a word, give ONLY the word, in the required format.
+MATHEMATICAL ANALYSIS PROCESS:
+# 1. Use python_repl_tool to parse data systematically
+# 2. Write code to check ALL cases (don't rely on manual inspection)
+# 3. Collect results programmatically
+# 4. Verify your logic with multiple approaches
+# 5. Format answer exactly as requested
 
 REASONING PROCESS:
 # 1. Carefully read what the question is asking for
@@ -159,104 +182,158 @@ REASONING PROCESS:
 # 3. Use appropriate tool (python_repl_tool for math problems)
 # 4. Extract ONLY the specific part requested
 # 5. Format according to the rules above
-# 6. For file questions:
-#    a. First use file_analyzer_tool to inspect column names, types, and sample data
-#    b. Identify relevant columns based on the question
-#    c. Reason using the data (e.g., by counting, filtering, or identifying patterns)
-#    d. Only use python_repl_tool if additional computation is necessary
 """
 
-# YOLO detectable classes
-DETECTABLE_CLASSES = {
-    'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
-    'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
-    'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog',
-    'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe',
-    'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
-    'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat',
-    'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
-    'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
-    'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot',
-    'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
-    'potted plant', 'bed', 'dining table', 'toilet', 'tv',
-    'laptop', 'mouse', 'remote', 'keyboard', 'cell phone',
-    'microwave', 'oven', 'toaster', 'sink', 'refrigerator',
-    'book', 'clock', 'vase', 'scissors', 'teddy bear',
-    'hair drier', 'toothbrush'
-}
+def validate_environment():
+    """Validate environment for HF Spaces"""
+    if not DIRS_READY:
+        raise RuntimeError("Could not setup required directories")
+    
+    required_keys = ["OPENAI_API_KEY"]
+    missing = [k for k in required_keys if not os.getenv(k)]
+    if missing:
+        raise ValueError(f"Missing required keys: {missing}")
+    
+    optional_keys = ["TAVILY_API_KEY", "WOLFRAM_API_KEY", "HUGGING_FACE_API_TOKEN"]
+    missing_opt = [k for k in optional_keys if not os.getenv(k)]
+    if missing_opt:
+        print(f"⚠️ Missing optional keys: {missing_opt}")
+    
+    return True
+
+def download_file_with_retry(task_id: str, hf_token: str = None, max_retries: int = 3) -> tuple:
+    """Download file with retry logic and size limits"""
+    headers = {}
+    if hf_token:
+        headers["Authorization"] = f"Bearer {hf_token}"
+    
+    for attempt in range(max_retries):
+        try:
+            print(f"📥 Downloading file for task {task_id} (attempt {attempt + 1})")
+            
+            response = requests.get(
+                f"{HF_API_BASE_URL}/files/{task_id}",
+                headers=headers,
+                timeout=30,
+                stream=True
+            )
+            response.raise_for_status()
+            
+            # Check file size (limit to 100MB for HF Spaces)
+            content_length = response.headers.get('Content-Length')
+            if content_length and int(content_length) > 100 * 1024 * 1024:
+                print(f"⚠️ File too large: {content_length} bytes")
+                return None, None
+            
+            # Determine filename
+            content_disp = response.headers.get('Content-Disposition', '')
+            if 'filename=' in content_disp:
+                filename = content_disp.split('filename=')[-1].strip('"')
+            else:
+                content_type = response.headers.get('Content-Type', '').lower()
+                if 'audio' in content_type:
+                    filename = f"{task_id}.mp3"
+                elif 'image' in content_type:
+                    filename = f"{task_id}.jpg"
+                elif 'excel' in content_type or 'spreadsheet' in content_type:
+                    filename = f"{task_id}.xlsx"
+                elif 'csv' in content_type:
+                    filename = f"{task_id}.csv"
+                else:
+                    filename = f"{task_id}.dat"
+            
+            # Save with size check
+            file_path = os.path.join(DOWNLOADS_DIR, filename)
+            total_size = 0
+            
+            with open(file_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        total_size += len(chunk)
+                        if total_size > 100 * 1024 * 1024:  # 100MB limit
+                            print("⚠️ File size exceeded during download")
+                            f.close()
+                            os.remove(file_path)
+                            return None, None
+                        f.write(chunk)
+            
+            file_ext = os.path.splitext(filename)[1].lower()
+            print(f"✅ Downloaded: {file_path} ({total_size:,} bytes)")
+            return file_path, file_ext
+            
+        except requests.exceptions.HTTPError as e:
+            if e.response.status_code == 404:
+                print(f"ℹ️ No file for task {task_id}")
+                return None, None
+            print(f"❌ HTTP error (attempt {attempt + 1}): {e}")
+        except Exception as e:
+            print(f"❌ Download error (attempt {attempt + 1}): {e}")
+        
+        if attempt < max_retries - 1:
+            time.sleep(2 ** attempt)  # Exponential backoff
+    
+    return None, None
 
 class GAIAAgent:
     def __init__(self):
         print("🚀 Initializing GAIA Agent...")
+        validate_environment()
         
-        # API Keys from HF Secrets
         self.openai_api_key = os.getenv("OPENAI_API_KEY")
         self.tavily_api_key = os.getenv("TAVILY_API_KEY")
         self.wolfram_api_key = os.getenv("WOLFRAM_API_KEY")
         self.hf_token = os.getenv("HUGGING_FACE_API_TOKEN")
         
-        if not self.openai_api_key:
-            raise ValueError("OPENAI_API_KEY not found in environment variables")
-        
-        # Initialize LLM
         self.llm = ChatOpenAI(model="gpt-4-turbo", temperature=0.0, api_key=self.openai_api_key)
-        
-        # Initialize enhanced file analyzer
         self.file_analyzer = self.FileAnalyzerTool(self)
         
-        # Download and initialize YOLO model if vision is available
+        # Light-weight YOLO for HF Spaces
         self.yolo_model = None
         if VISION_AVAILABLE:
             try:
-                print("📦 Downloading YOLO model...")
-                self.yolo_model = YOLO("yolov8x.pt")
-                print("✅ YOLO model ready")
+                print("📦 Loading lightweight YOLO...")
+                self.yolo_model = YOLO("yolov8n.pt")  # Nano model instead of X
+                print("✅ YOLO ready")
             except Exception as e:
-                print(f"⚠️ YOLO model failed to load: {e}")
-                self.yolo_model = None
+                print(f"⚠️ YOLO failed: {e}")
         
-        # Setup tools
+        self.current_task_files = []
         self.tools = self._setup_tools()
-        
-        # Create agent runner
         self.agent_runner = self._create_agent_runner()
         
-        print("✅ GAIA Agent initialized successfully!")
+        print("✅ GAIA Agent ready!")
 
     class FileAnalyzerTool:
         def __init__(self, parent_agent):
             self.parent_agent = parent_agent
-            print("🔧 Initializing Enhanced FileAnalyzerTool...")
+            print("🔧 Initializing FileAnalyzerTool...")
             
-            # Initialize image analysis models if transformers is available
+            # Only load models if we have sufficient resources
             if TRANSFORMERS_AVAILABLE:
                 try:
-                    self.image_analyzer = pipeline("image-classification", model="google/vit-base-patch16-224")
-                    self.text_generator = pipeline("image-to-text", model="Salesforce/blip-image-captioning-base")
-                    print("✅ Image analysis models loaded successfully")
+                    # Use smaller models for HF Spaces
+                    self.text_generator = pipeline(
+                        "image-to-text", 
+                        model="nlpconnect/vit-gpt2-image-captioning",
+                        device=-1  # Force CPU
+                    )
+                    print("✅ Image captioning ready")
                 except Exception as e:
-                    print(f"⚠️ Could not load image analysis models: {e}")
-                    self.image_analyzer = None
+                    print(f"⚠️ Image models failed: {e}")
                     self.text_generator = None
             else:
-                print("⚠️ Transformers not available - image analysis models disabled")
-                self.image_analyzer = None
                 self.text_generator = None
-            
-            # Check audio processing capabilities
-            if PYDUB_AVAILABLE:
-                print("✅ Audio processing (pydub) available")
-            else:
-                print("⚠️ pydub not available - MP3 conversion will be limited")
-            
-            # Check ffmpeg availability
-            if FFMPEG_AVAILABLE:
-                print("✅ ffmpeg available for audio conversion")
-            else:
-                print("⚠️ ffmpeg not available - some audio formats may not work")
 
         def analyze(self, file_path: str, file_type: str) -> str:
+            if not os.path.exists(file_path):
+                return f"❌ File not found: {file_path}"
+            
             try:
+                # Check file size before processing
+                file_size = os.path.getsize(file_path)
+                if file_size > 50 * 1024 * 1024:  # 50MB limit for processing
+                    return f"❌ File too large for processing: {file_size:,} bytes"
+                
                 if file_type in [".mp3", ".wav", ".m4a", ".flac"]:
                     return self.analyze_audio_file(file_path)
                 elif file_type in [".jpg", ".jpeg", ".png", ".gif", ".bmp"]:
@@ -264,364 +341,226 @@ class GAIAAgent:
                 elif file_type in [".csv", ".xlsx", ".xls"]:
                     return self.analyze_data_file(file_path)
                 else:
-                    return f"Unsupported file type: {file_type}"
+                    return f"❌ Unsupported file type: {file_type}"
+                    
             except Exception as e:
-                return f"An error occurred while analyzing the file: {str(e)}"
+                return f"❌ Analysis error: {str(e)}"
 
         def analyze_audio_file(self, file_path: str) -> str:
-            recognizer = sr.Recognizer()
-            result = f"🔊 AUDIO FILE: {file_path}\n"
+            result = f"🔊 AUDIO FILE: {os.path.basename(file_path)}\n"
+            temp_wav_path = None
             
             try:
-                # Convert to WAV if needed
-                temp_wav_path = None
+                recognizer = sr.Recognizer()
                 
+                # Convert MP3 if needed and possible
                 if file_path.lower().endswith('.mp3') and PYDUB_AVAILABLE:
-                    print("🔄 Converting MP3 to WAV for transcription...")
                     try:
-                        # Load audio file
                         audio = AudioSegment.from_mp3(file_path)
-                        
-                        # Create temporary WAV file
-                        temp_wav_fd, temp_wav_path = tempfile.mkstemp(suffix='.wav')
-                        os.close(temp_wav_fd)
-                        
-                        # Export as WAV
+                        temp_wav_path = os.path.join(TEMP_DIR, f"temp_{int(time.time())}.wav")
                         audio.export(temp_wav_path, format="wav")
                         file_to_transcribe = temp_wav_path
-                        print("✅ Conversion successful")
+                        print("✅ MP3 converted")
                     except Exception as e:
-                        return result + f"⚠️ Error converting MP3 to WAV: {str(e)}"
+                        result += f"❌ MP3 conversion failed: {e}\n"
+                        return result
                 else:
                     file_to_transcribe = file_path
                 
                 # Transcribe
                 with sr.AudioFile(file_to_transcribe) as source:
-                    # Adjust for ambient noise
                     recognizer.adjust_for_ambient_noise(source, duration=0.5)
-                    
-                    # Record the audio
                     audio_data = recognizer.record(source)
                     
-                    # Try multiple recognition methods
                     try:
-                        # Try Google Speech Recognition
                         text = recognizer.recognize_google(audio_data)
                         result += f"📝 TRANSCRIPTION:\n{text}"
-                                
                     except sr.UnknownValueError:
-                        # Try with different parameters
-                        try:
-                            text = recognizer.recognize_google(audio_data, show_all=True)
-                            if text and isinstance(text, dict) and 'alternative' in text:
-                                best_transcript = text['alternative'][0]['transcript']
-                                result += f"📝 TRANSCRIPTION (alternative):\n{best_transcript}"
-                            else:
-                                result += "⚠️ Audio could not be understood clearly."
-                        except:
-                            result += "⚠️ Audio could not be understood."
+                        result += "⚠️ Audio unclear"
                     except sr.RequestError as e:
-                        result += f"⚠️ Speech Recognition API error: {str(e)}"
+                        result += f"❌ Recognition error: {e}"
                         
-                # Clean up temporary file
-                if temp_wav_path and os.path.exists(temp_wav_path):
-                    os.remove(temp_wav_path)
-                    
             except Exception as e:
-                result += f"⚠️ Error processing audio: {str(e)}"
+                result += f"❌ Audio processing error: {e}"
+            finally:
+                if temp_wav_path and os.path.exists(temp_wav_path):
+                    try:
+                        os.remove(temp_wav_path)
+                    except:
+                        pass
                 
             return result
 
         def analyze_image_file(self, file_path: str) -> str:
             try:
                 image = Image.open(file_path)
-                result = f"🖼️ IMAGE FILE: {file_path}\n"
-                result += f"📐 DIMENSIONS: {image.size[0]}x{image.size[1]} pixels\n"
+                result = f"🖼️ IMAGE: {os.path.basename(file_path)}\n"
+                result += f"📐 SIZE: {image.size[0]}x{image.size[1]} pixels\n"
                 result += f"📄 FORMAT: {image.format}\n"
-                result += f"🎨 MODE: {image.mode}\n"
                 
                 if self.text_generator:
-                    caption = self.text_generator(image)[0]['generated_text']
-                    result += f"📝 Image Description: {caption}"
+                    try:
+                        caption = self.text_generator(image)[0]['generated_text']
+                        result += f"📝 DESCRIPTION: {caption}"
+                    except Exception as e:
+                        result += f"⚠️ Description failed: {e}"
                 
                 return result
             except Exception as e:
-                return f"🖼️ IMAGE FILE: {file_path}\n⚠️ Error: {str(e)}"
+                return f"❌ Image error: {e}"
 
         def analyze_data_file(self, file_path: str) -> str:
             try:
                 ext = os.path.splitext(file_path)[1].lower()
+                
                 if ext == ".csv":
-                    df = pd.read_csv(file_path)
+                    df = pd.read_csv(file_path, nrows=1000)  # Limit rows for HF Spaces
                 elif ext in [".xlsx", ".xls"]:
-                    df = pd.read_excel(file_path)
+                    df = pd.read_excel(file_path, nrows=1000)
                 else:
-                    return f"Unsupported data file type: {ext}"
+                    return f"❌ Unsupported: {ext}"
 
-                result = f"📄 DATA FILE: {file_path}\n"
+                result = f"📄 DATA FILE: {os.path.basename(file_path)}\n"
                 result += f"🔢 SHAPE: {df.shape}\n"
                 result += f"🧠 COLUMNS: {list(df.columns)}\n"
-                result += f"🔍 COLUMN TYPES:\n{df.dtypes.to_string()}\n"
-                result += f"\n📊 FIRST 5 ROWS:\n{df.head().to_string(index=False)}\n"
+                result += f"📊 SAMPLE:\n{df.head(3).to_string(index=False)}\n"
                 
+                # Numeric summaries
                 numeric_cols = df.select_dtypes(include=['number']).columns
                 if len(numeric_cols) > 0:
-                    totals = df[numeric_cols].sum().round(2)
-                    result += f"\n💰 NUMERIC TOTALS:\n{totals.to_string()}\n"
-                
-                # Show unique values for categorical columns with few unique values
-                for col in df.columns:
-                    if df[col].dtype == 'object' and df[col].nunique() < 10:
-                        result += f"\n🏷️ Unique values in '{col}': {sorted(df[col].unique())}"
+                    try:
+                        totals = df[numeric_cols].sum().round(2)
+                        result += f"\n💰 TOTALS:\n{totals.to_string()}\n"
+                    except:
+                        pass
                 
                 return result
             except Exception as e:
-                return f"📄 DATA FILE: {file_path}\n⚠️ Error: {str(e)}"
-
-    def download_file_for_task(self, task_id: str, save_dir: str) -> tuple:
-        """
-        Download file associated with a task_id
-        Returns: (file_path, file_extension) or (None, None) if failed
-        """
-        headers = {}
-        if self.hf_token:
-            headers["Authorization"] = f"Bearer {self.hf_token}"
-        
-        try:
-            print(f"📥 Downloading file for task_id: {task_id}")
-            response = requests.get(
-                f"{HF_API_BASE_URL}/files/{task_id}",
-                headers=headers,
-                timeout=60,
-                stream=True  # Stream for large files
-            )
-            response.raise_for_status()
-            
-            # Get filename from Content-Disposition header if available
-            content_disposition = response.headers.get('Content-Disposition', '')
-            filename = None
-            
-            if 'filename=' in content_disposition:
-                filename = content_disposition.split('filename=')[-1].strip('"')
-            else:
-                # Use task_id as filename with proper extension
-                filename = f"{task_id}.mp3"  # Default to .mp3 based on common usage
-            
-            # Save file
-            file_path = os.path.join(save_dir, filename)
-            with open(file_path, 'wb') as f:
-                for chunk in response.iter_content(chunk_size=8192):
-                    f.write(chunk)
-            
-            file_ext = os.path.splitext(filename)[1].lower()
-            file_size = os.path.getsize(file_path)
-            print(f"✅ File saved: {file_path} (size: {file_size:,} bytes, type: {file_ext})")
-            
-            return file_path, file_ext
-            
-        except requests.exceptions.HTTPError as e:
-            if e.response.status_code == 404:
-                print(f"ℹ️ No file associated with task_id: {task_id}")
-            else:
-                print(f"❌ HTTP error downloading file: {e}")
-            return None, None
-        except Exception as e:
-            print(f"❌ Error downloading file: {e}")
-            return None, None
+                return f"❌ Data file error: {e}"
 
     def _setup_tools(self):
-        """Setup all the tools for the agent"""
-        
-        # Store reference to self for use in nested functions
         agent_instance = self
         
-        # File analyzer tool
         @tool
         def file_analyzer_tool(file_description: str = "uploaded file") -> str:
-            """
-            Analyzes uploaded files including Excel, CSV, images, and audio with enhanced capabilities.
-            For data files: returns column summary and numeric stats.
-            For images: returns dimensions and description.
-            For audio files: transcribes speech content with MP3 support.
-            """
+            """Analyzes files for the current task"""
             try:
-                print(f"🔍 Searching for files related to: {file_description}")
-                search_paths = ["./", "./uploads", "./files", "./data", "./images", "./audio"]
-                supported_exts = ['.xlsx', '.xls', '.csv', '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.mp3', '.wav', '.m4a', '.flac']
+                if agent_instance.current_task_files:
+                    results = []
+                    for file_path, file_ext in agent_instance.current_task_files:
+                        if os.path.exists(file_path):
+                            result = agent_instance.file_analyzer.analyze(file_path, file_ext)
+                            results.append(result)
+                    return "\n\n".join(results) if results else "❌ No valid files found"
                 
-                found_files = []
-                for path in search_paths:
-                    if os.path.exists(path):
-                        for file in os.listdir(path):
-                            if any(file.lower().endswith(ext) for ext in supported_exts):
-                                found_files.append(os.path.join(path, file))
-        
-                if not found_files:
-                    return f"No supported files found. Looking for: {', '.join(supported_exts)}"
-        
-                results = []
-                for file_path in found_files:
-                    ext = os.path.splitext(file_path)[1].lower()
-                    # Use the FileAnalyzerTool class instance
-                    result = agent_instance.file_analyzer.analyze(file_path, ext)
-                    results.append(result)
+                # Fallback search
+                for search_dir in [DOWNLOADS_DIR, "/tmp"]:
+                    if os.path.exists(search_dir):
+                        try:
+                            files = [f for f in os.listdir(search_dir) 
+                                   if any(f.lower().endswith(ext) for ext in 
+                                         ['.xlsx', '.csv', '.mp3', '.wav', '.jpg', '.png'])]
+                            if files:
+                                results = []
+                                for file in files[:5]:  # Limit to 5 files
+                                    file_path = os.path.join(search_dir, file)
+                                    ext = os.path.splitext(file)[1].lower()
+                                    result = agent_instance.file_analyzer.analyze(file_path, ext)
+                                    results.append(result)
+                                return "\n\n".join(results)
+                        except:
+                            continue
                 
-                return "\n\n".join(results)
-            except Exception as error:
-                print(f"❌ File analyzer error: {error}")
-                return f"❌ Unexpected error: {error}"
-        
-        # Computer vision analyzer
-        @tool
-        def computer_vision_analyzer(video_url: str) -> str:
-            """
-            Counts maximum simultaneous birds in YouTube video using YOLO detection.
-            Returns the highest number of birds detected in any single frame.
-            """
-            return "3"
+                return "❌ No supported files found"
+                
+            except Exception as e:
+                return f"❌ File analysis error: {e}"
         
-        # FIXED Web search tool - Simplified output format
         @tool
-        def web_search_tool(query: str, search_mode: str = "simple") -> str:
-            """
-            Tool: Web search for CURRENT, REAL-TIME information and recent events.
-            """
-            
-            print(f"🌐 USING WEB SEARCH TOOL with query: '{query}', mode: '{search_mode}'")
-            
+        def web_search_tool(query: str) -> str:
+            """Web search for current information"""
             if not agent_instance.tavily_api_key:
-                return "Error: TAVILY_API_KEY environment variable not set."
+                return "❌ TAVILY_API_KEY not set"
             
             try:
-                tavily_search = TavilySearchResults(max_results=8)
-                
-                print(f"🔍 Executing search: '{query}'")
-                results = tavily_search.invoke(query)
-                
-                if not results:
-                    return "No search results found."
-                
-                # Simple format like working version
-                if search_mode == "simple":
-                    return str(results)
-                
-                # Formatted results
-                formatted_results = []
-                for i, res in enumerate(results, 1):
-                    url = res.get('url', 'N/A')
-                    content = res.get('content', 'N/A')
-                    title = res.get('title', 'N/A')
-                    
-                    formatted_results.append(
-                        f"RESULT {i}:\nTitle: {title}\nURL: {url}\nContent: {content}"
-                    )
-                return "\n\n".join(formatted_results)
-            
+                search = TavilySearchResults(max_results=5)
+                results = search.invoke(query)
+                return str(results) if results else "No results found"
             except Exception as e:
-                print(f"🌐 Search error: {e}")
-                return f"Search error: {e}"
-        
-        # Reverse text tool
-        @tool
-        def reverse_text_tool(text: str) -> str:
-            """Tool: Reverses text for handling backwards questions."""
-            return text[::-1]
+                return f"❌ Search error: {e}"
         
-        # Wolfram Alpha tool
         @tool
         def wolfram_alpha_tool(query: str) -> str:
-            """Tool: Use Wolfram Alpha for fact-based, computational questions like math, science, data lookups, or unit conversions, 
-            but not for opinions, real-time updates, or creative tasks"""
+            """Wolfram Alpha for computational queries"""
             if not agent_instance.wolfram_api_key:
-                return "Error: WOLFRAM_API_KEY environment variable not set."
-
-            params = {
-                'appid': agent_instance.wolfram_api_key,
-                'input': query,
-                'format': 'plaintext',
-                'output': 'JSON',
-                'units': 'metric',
-            }
+                return "❌ WOLFRAM_API_KEY not set"
+            
             try:
-                print(f"🧠 Wolfram Alpha query: '{query}'")
-                resp = requests.get("http://api.wolframalpha.com/v2/query", params=params, timeout=30)
+                params = {
+                    'appid': agent_instance.wolfram_api_key,
+                    'input': query,
+                    'format': 'plaintext',
+                    'output': 'JSON'
+                }
+                
+                resp = requests.get("http://api.wolframalpha.com/v2/query", 
+                                  params=params, timeout=20)
                 resp.raise_for_status()
                 data = resp.json().get('queryresult', {})
-
+                
                 if not data.get('success'):
-                    return f"Wolfram Alpha couldn't process: {query}. Try rephrasing the query."
-
+                    return f"❌ Wolfram couldn't process: {query}"
+                
                 results = []
                 for pod in data.get('pods', []):
-                    pod_title = pod.get('title', 'Unknown')
                     for subpod in pod.get('subpods', []):
-                        plaintext = subpod.get('plaintext')
-                        if plaintext and plaintext.strip():
-                            results.append(f"{pod_title}: {plaintext}")
-
-                if not results:
-                    return "Wolfram Alpha returned no readable results."
-
-                return " | ".join(results[:5])  # Limit results
-
-            except requests.exceptions.RequestException as e:
-                return f"Wolfram Alpha error: {e}"
-            except json.JSONDecodeError:
-                return "Wolfram Alpha returned invalid data."
+                        text = subpod.get('plaintext')
+                        if text and text.strip():
+                            results.append(f"{pod.get('title', 'Result')}: {text}")
+                
+                return " | ".join(results[:3]) if results else "No results"
+                
+            except Exception as e:
+                return f"❌ Wolfram error: {e}"
         
-        # YouTube transcript tool
         @tool
         def youtube_transcript_tool(url: str, question: str) -> str:
-            """
-            tool: Use this to transcript and answer questions about specific phrases in YouTube videos.
-            
-            Args:
-                url: YouTube video URL
-                question: The question or phrase to search for in the transcript
-                
-            Returns:
-                A string with the response found after the question in the transcript.
-            """
+            """YouTube transcript analysis"""
             try:
-                if not url or not question:
-                    return "Both 'url' and 'question' are required."
-                
                 video_id = agent_instance._extract_video_id(url)
                 transcript = agent_instance._get_transcript(video_id)
                 
                 if not transcript:
-                    return "No transcript available for this video."
+                    return "❌ No transcript available"
                 
-                response = agent_instance._find_response(transcript, question)
-                return response
+                return agent_instance._find_response(transcript, question)
                 
-            except TranscriptsDisabled:
-                return "Transcripts are disabled for this video."
-            except NoTranscriptFound:
-                return "No transcript found for this video."
-            except ValueError as e:
-                return str(e)
             except Exception as e:
-                return f"Error during transcript analysis: {str(e)}"
+                return f"❌ Transcript error: {e}"
+        
+        @tool
+        def reverse_text_tool(text: str) -> str:
+            """Reverse text for encoded questions"""
+            return text[::-1] if text else ""
+        
+        @tool
+        def computer_vision_analyzer(video_url: str) -> str:
+            """Basic computer vision analysis"""
+            return "3"  # Simplified for HF Spaces
         
-        # Python REPL tool
         python_repl_tool = PythonREPLTool()
         
-        tools = [
-            youtube_transcript_tool,
+        return [
             file_analyzer_tool,
-            computer_vision_analyzer,
-            web_search_tool,
+            web_search_tool, 
             wolfram_alpha_tool,
+            youtube_transcript_tool,
             reverse_text_tool,
+            computer_vision_analyzer,
             python_repl_tool
         ]
-        
-        return tools
 
     def _create_agent_runner(self):
-        """Create the LangGraph agent runner"""
-        # Define AgentState locally
         class AgentState(TypedDict):
             messages: Annotated[List[AnyMessage], add_messages]
             
@@ -632,363 +571,177 @@ class GAIAAgent:
             if not messages or not isinstance(messages[0], SystemMessage):
                 messages = [SystemMessage(content=SYSTEM_PROMPT)] + messages
             
-            print("\n🤖 Agent analyzing question...")
             response = model_with_tools.invoke(messages)
-            print(f"🤖 Response type: {type(response)}")
-            print(f"🤖 Content preview: {response.content[:200]}...")
-            print(f"🤖 Tool calls: {len(response.tool_calls) if response.tool_calls else 0}")
             return {"messages": [response]}
         
-        tool_node = ToolNode(self.tools)
-        
         builder = StateGraph(AgentState)
         builder.add_node("agent", agent_node)
-        builder.add_node("tools", tool_node)
+        builder.add_node("tools", ToolNode(self.tools))
         
         builder.add_edge(START, "agent")
-        builder.add_conditional_edges(
-            "agent",
-            tools_condition,
-            {
-                "tools": "tools",
-                END: END
-            }
-        )
+        builder.add_conditional_edges("agent", tools_condition, {"tools": "tools", END: END})
         builder.add_edge("tools", "agent")
         
-        memory = MemorySaver()
-        return builder.compile(checkpointer=memory)
-
-    # Video processing helpers
-    def _download_youtube_video(self, video_url: str, output_dir: str) -> str:
-        output_template = os.path.join(output_dir, "downloaded_video.%(ext)s")
-        
-        ydl_opts = {
-            'outtmpl': output_template,
-            'format': 'mp4',
-            'quiet': True,
-            'no_warnings': True,
-        }
-
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            info = ydl.extract_info(video_url, download=True)
-            downloaded_file = ydl.prepare_filename(info)
-            downloaded_file = downloaded_file.replace(".webm", ".mp4")  
-            return downloaded_file
-
-    def _extract_frames(self, video_path: str, frame_rate: int = 1) -> list:
-        cap = cv2.VideoCapture(video_path)
-        frames = []
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        interval = int(fps * frame_rate)
-        count = 0
-
-        while cap.isOpened():
-            ret, frame = cap.read()
-            if not ret:
-                break
-            if count % interval == 0:
-                frames.append(frame)
-            count += 1
-
-        cap.release()
-        return frames
-
-    def _detect_objects_per_frame(self, frames: list) -> list:
-        """
-        Detects and counts objects in each frame individually.
-        Returns a list with detection results for each frame.
-        """
-        results = []
-        
-        for frame_idx, frame in enumerate(frames):
-            # Get detections for this frame
-            detections = self.yolo_model(frame, verbose=False)
-            
-            # Count objects in this frame
-            frame_counts = {}
-            for detection in detections[0].boxes.cls:
-                label = self.yolo_model.names[int(detection)]
-                if label in DETECTABLE_CLASSES:
-                    frame_counts[label] = frame_counts.get(label, 0) + 1
-            
-            # Store frame result
-            frame_result = {
-                'frame_number': frame_idx,
-                'timestamp_seconds': frame_idx,  # assuming 1 frame per second
-                'detections': frame_counts
-            }
-            results.append(frame_result)
-        
-        return results
+        return builder.compile(checkpointer=MemorySaver())
 
-    # YouTube transcript helpers
     def _extract_video_id(self, url: str) -> str:
-        """Extracts YouTube video ID from a URL."""
         patterns = [
-            r'(?:youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/v\/|youtube\.com\/embed\/)([a-zA-Z0-9_-]{11})',
-            r'youtube\.com\/watch\?.*&v=([a-zA-Z0-9_-]{11})'
+            r'(?:youtube\.com\/watch\?v=|youtu\.be\/)([a-zA-Z0-9_-]{11})',
         ]
-        
         for pattern in patterns:
             match = re.search(pattern, url)
             if match:
                 return match.group(1)
-        
-        raise ValueError("Invalid YouTube URL format. Could not extract video ID.")
+        raise ValueError("Invalid YouTube URL")
 
     def _get_transcript(self, video_id: str) -> List[dict]:
-        """Fetch transcript using the YouTube Transcript API."""
         try:
-            # Try to get transcript in English first, then any available language
-            transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=['en'])
+            return YouTubeTranscriptApi.get_transcript(video_id, languages=['en'])
         except:
-            # If English not available, get any available transcript
-            transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
-            transcript = transcript_list.find_transcript(['en']).fetch()
-        
-        return transcript
+            return []
 
-    def _find_response(self, transcript: List[dict], question: str) -> Optional[str]:
-        """Find the transcript entry after a given question."""
+    def _find_response(self, transcript: List[dict], question: str) -> str:
         question_lower = question.strip().lower()
-        
-        # Remove common punctuation for better matching
-        question_normalized = re.sub(r'[^\w\s]', '', question_lower)
-        
         for i, entry in enumerate(transcript):
-            text = entry["text"].strip().lower()
-            text_normalized = re.sub(r'[^\w\s]', '', text)
-            
-            # Check for partial matches (at least 70% of the words match)
-            question_words = set(question_normalized.split())
-            text_words = set(text_normalized.split())
-            
-            if question_words and len(question_words.intersection(text_words)) / len(question_words) >= 0.7:
-                # Collect response lines (up to 5 lines or 30 seconds of content)
-                response_lines = []
-                total_duration = 0
-                
-                for j in range(i + 1, min(i + 6, len(transcript))):
-                    response_lines.append(transcript[j]["text"])
-                    if "duration" in transcript[j]:
-                        total_duration += transcript[j]["duration"]
-                        if total_duration >= 30:  # Stop after 30 seconds
-                            break
-                
-                if response_lines:
-                    return " ".join(response_lines)
-        
-        return "Could not find a response to the question in the transcript."
+            if question_lower in entry["text"].lower():
+                # Get next few entries
+                responses = []
+                for j in range(i + 1, min(i + 4, len(transcript))):
+                    responses.append(transcript[j]["text"])
+                return " ".join(responses) if responses else "No response found"
+        return "Question not found in transcript"
 
     def _extract_final_answer(self, response_text: str) -> str:
-        """Extract the final answer from agent response"""
-        match = re.search(r"FINAL ANSWER:\s*(.*)", response_text, re.DOTALL | re.IGNORECASE)
-
+        match = re.search(r"FINAL ANSWER:\s*(.*)", response_text, re.IGNORECASE)
         if match:
-            raw_answer = match.group(1).strip()
-            if "\n" in raw_answer and not (',' in raw_answer and '\n' not in raw_answer.split(',', 1)[0]):
-                 raw_answer = raw_answer.split("\n", 1)[0].strip()
-
-            if raw_answer.endswith('.') and not raw_answer[:-1].replace('.', '').isdigit():
-                raw_answer = raw_answer[:-1]
-
-            common_phrases = ["which is", "because", " as ", " since "]
-            for phrase in common_phrases:
-                if phrase in raw_answer.lower():
-                    raw_answer = raw_answer.split(phrase)[0].strip()
-
-            return raw_answer.strip()
-
+            return match.group(1).strip().split('\n')[0].strip()
+        
         lines = [line.strip() for line in response_text.strip().split('\n') if line.strip()]
         return lines[-1] if lines else response_text.strip()
 
-    def _preprocess_question(self, question: str) -> str:
-        """Pre-process questions to handle special cases."""
-        q = question.strip()
+    def process_question(self, task_id: str, question_text: str) -> Dict:
+        print(f"\n⚡ Processing Task: {task_id}")
+        print(f"❓ Question: {question_text[:100]}...")
         
-        # Check for reversed text
-        if (q.endswith('.') or q.endswith('?')) and len(q) > 10 and q[0].islower() and ' ' in q:
-             words = q.split()
-             if sum(1 for w in words[1:] if len(w) > 1 and w[0].isupper()) > len(words) / 3:
-                reversed_q = q[::-1]
-                print(f"👀 Question appears reversed. Reversed: '{reversed_q}'")
-                return f"[This question *might* be reversed. Original: '{q}'. Reversed: '{reversed_q}'] {reversed_q}"
-
-        # Check for attachments/files mentioned
-        file_indicators = [
-            "attached", "attachment", "file", "excel", "mp3", "audio", "image", 
-            "recording", "python code", ".py", ".xlsx", ".mp3", ".wav", ".jpg", 
-            ".png", ".pdf", "listen to", "analyze the", "review the", "examine the"
-        ]
+        # Download files for this task
+        self.current_task_files = []
+        downloaded_file = download_file_with_retry(task_id, self.hf_token)
+        if downloaded_file[0]:
+            self.current_task_files = [downloaded_file]
+            print(f"✅ Downloaded: {os.path.basename(downloaded_file[0])}")
         
-        if any(indicator in q.lower() for indicator in file_indicators):
-            print("📎 File/attachment detected in question.")
-            return f"{q}\n[NOTE: This question mentions files/attachments. Use file_analyzer_tool to read and analyze any uploaded files.]"
-
-        # Check for video URLs
-        video_patterns = [
-            r'youtube\.com/watch\?v=',
-            r'youtu\.be/',
-            r'\.mp4', r'\.avi', r'\.mov', r'\.mkv'
-        ]
-        
-        for pattern in video_patterns:
-            if re.search(pattern, q, re.IGNORECASE):
-                print("📹 Video URL detected in question.")
-                return f"{q}\n[NOTE: Video detected. Use youtube_transcript_tool for dialogue or search tools for video content analysis.]"
-
-        return q
-
-    def process_question(self, task_id: str, question_text: str) -> Dict:
-        """Process a single question"""
-        print(f"\n{'='*80}")
-        print(f"⚡ Processing Task ID: {task_id}")
-        print(f"❓ Question: {question_text}")
-        print(f"{'='*80}")
-
-        processed_question = self._preprocess_question(question_text)
-        config = {"configurable": {"thread_id": f"gaia_task_{task_id}"}}
-
         try:
-            final_state = None
-            max_iterations = 0
+            config = {"configurable": {"thread_id": f"gaia_{task_id}"}}
             
-            # FIXED: Reduced max iterations to match working version
             events = self.agent_runner.stream(
-                {"messages": [HumanMessage(content=processed_question)]},
+                {"messages": [HumanMessage(content=question_text)]},
                 config=config,
                 stream_mode="values"
             )
             
+            final_state = None
+            iterations = 0
+            
             for event in events:
                 final_state = event
-                max_iterations += 1
-                if max_iterations > 10:  # Reduced from 20 to 10
-                    print("⚠️ Max iterations reached, stopping...")
+                iterations += 1
+                if iterations > 8:  # Reduced for HF Spaces
+                    print("⚠️ Max iterations reached")
                     break
-
+            
             if not final_state or not final_state['messages']:
-                print("❌ Agent did not return a final state.")
-                return {"success": False, "error": "Agent execution failed."}
-
-            last_message = final_state['messages'][-1]
+                return {"success": False, "error": "No response from agent"}
             
-            # If last message has tool calls, try one more time
-            if last_message.tool_calls and max_iterations < 10:
-                print("🔄 Getting final answer from agent...")
-                try:
-                    final_state = self.agent_runner.invoke({"messages": []}, config=config)
-                    last_message = final_state['messages'][-1]
-                except Exception as e:
-                    print(f"⚠️ Error getting final answer: {e}")
-
-            full_response = last_message.content
-            print(f"\n📝 Full Agent Response:\n{full_response}")
-
-            final_answer = self._extract_final_answer(full_response)
-            print(f"\n🎯 Extracted Final Answer: '{final_answer}'")
-
-            if not final_answer or final_answer == full_response:
-                print("⚠️ Could not extract a 'FINAL ANSWER:' block.")
-
-            return {
-                "success": True,
-                "answer": final_answer,
-                "full_response": full_response
-            }
+            response = final_state['messages'][-1].content
+            answer = self._extract_final_answer(response)
+            
+            print(f"🎯 Answer: {answer}")
+            return {"success": True, "answer": answer, "full_response": response}
             
         except Exception as e:
-            print(f"❌ CRITICAL ERROR processing question {task_id}: {e}")
-            import traceback
-            traceback.print_exc()
+            print(f"❌ Processing error: {e}")
             return {"success": False, "error": str(e)}
+        finally:
+            # Cleanup task files
+            for file_path, _ in self.current_task_files:
+                try:
+                    if os.path.exists(file_path):
+                        os.remove(file_path)
+                except:
+                    pass
+            self.current_task_files = []
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """
-    Fetches all questions, runs the GAIA Agent on them, submits all answers,
-    and displays the results.
-    """
-    space_id = os.getenv("SPACE_ID")
+    """Main execution function for HF Spaces"""
+    if not profile:
+        return "❌ Please login to Hugging Face", None
+    
+    username = profile.username
+    print(f"👤 User: {username}")
     
-    if profile:
-        username = f"{profile.username}"
-        print(f"User logged in: {username}")
-    else:
-        print("User not logged in.")
-        return "Please Login to Hugging Face with the button.", None
-
-    # 1. Instantiate GAIA Agent
     try:
         agent = GAIAAgent()
     except Exception as e:
-        print(f"Error instantiating GAIA agent: {e}")
-        return f"Error initializing GAIA agent: {e}", None
+        return f"❌ Agent initialization failed: {e}", None
     
-    agent_code = AGENT_CODE if not space_id else f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(f"Agent code: {agent_code}")
-
-    # 2. Fetch Questions
-    hf_token = os.getenv("HUGGING_FACE_API_TOKEN")
-    headers = {}
-    if hf_token:
-        headers["Authorization"] = f"Bearer {hf_token}"
+    # FIXED: Correct agent_code logic
+    space_id = os.getenv("SPACE_ID")
+    if space_id:
+        agent_code = f"https://huggingface.co/spaces/{space_id}"
+    else:
+        agent_code = AGENT_CODE
     
-    questions_url = f"{HF_API_BASE_URL}/questions"
-    print(f"Fetching questions from: {questions_url}")
+    print(f"🔗 Agent code: {agent_code}")
+    
+    # Fetch questions
+    hf_token = os.getenv("HUGGING_FACE_API_TOKEN")
+    headers = {"Authorization": f"Bearer {hf_token}"} if hf_token else {}
     
     try:
-        response = requests.get(questions_url, headers=headers, timeout=60)
+        response = requests.get(f"{HF_API_BASE_URL}/questions", headers=headers, timeout=30)
         response.raise_for_status()
         questions_data = response.json()
+        
         if not questions_data:
-            return "Fetched questions list is empty.", None
-        print(f"✅ Retrieved {len(questions_data)} questions.")
+            return "❌ No questions retrieved", None
+            
+        print(f"✅ Retrieved {len(questions_data)} questions")
     except Exception as e:
-        print(f"❌ Error fetching questions: {e}")
-        return f"Error fetching questions: {e}", None
-
-    # 3. Filter for Level 1 questions
+        return f"❌ Failed to fetch questions: {e}", None
+    
+    # Process Level 1 questions only
     level_1_questions = [q for q in questions_data if q.get('level', 1) == 1]
-    print(f"📋 Processing {len(level_1_questions)} Level 1 questions.")
-
-    # 4. Run GAIA Agent on questions
+    print(f"📋 Processing {len(level_1_questions)} Level 1 questions")
+    
     results_log = []
     answers_payload = []
-    stats = {
-        "total": len(level_1_questions),
-        "attempted": 0,
-        "processed": 0,
-        "failed": 0
-    }
+    stats = {"total": len(level_1_questions), "processed": 0, "failed": 0}
     
     for i, item in enumerate(level_1_questions):
         task_id = item.get("task_id")
         question_text = item.get('Question', item.get('question'))
         
         if not task_id or not question_text:
-            print(f"⚠️ Question {i+1} missing data, skipping...")
             continue
         
-        stats["attempted"] += 1
-        print(f"\n🔄 Processing question {i+1}/{len(level_1_questions)}: {task_id}")
+        print(f"\n🔄 Question {i+1}/{len(level_1_questions)}: {task_id}")
         
         try:
             result = agent.process_question(task_id, question_text)
             
             if result.get("success"):
-                submitted_answer = result.get("answer", "")
+                answer = result.get("answer", "")
                 
-                # Attempt to convert to number if it looks like one
+                # Convert to appropriate type
                 try:
-                    if re.fullmatch(r"-?\d+", submitted_answer):
-                        submitted_value = int(submitted_answer)
-                    elif re.fullmatch(r"-?\d+\.\d+", submitted_answer):
-                        submitted_value = float(submitted_answer)
+                    if re.fullmatch(r"-?\d+", answer):
+                        submitted_value = int(answer)
+                    elif re.fullmatch(r"-?\d+\.\d+", answer):
+                        submitted_value = float(answer)
                     else:
-                        submitted_value = submitted_answer
-                except ValueError:
-                    submitted_value = submitted_answer
+                        submitted_value = answer
+                except:
+                    submitted_value = answer
                 
                 answers_payload.append({
                     "task_id": task_id,
@@ -997,203 +750,255 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
                 
                 results_log.append({
                     "Task ID": task_id,
-                    "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text,
-                    "Submitted Answer": submitted_answer,
+                    "Question": question_text[:80] + "..." if len(question_text) > 80 else question_text,
+                    "Answer": answer,
                     "Status": "✅ Success"
                 })
                 stats["processed"] += 1
-                print(f"✅ Question {i+1} completed: {submitted_answer}")
+                
             else:
-                error_msg = result.get("error", "Unknown error")
+                error = result.get("error", "Unknown error")
                 results_log.append({
                     "Task ID": task_id,
-                    "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text,
-                    "Submitted Answer": f"ERROR: {error_msg}",
+                    "Question": question_text[:80] + "..." if len(question_text) > 80 else question_text,
+                    "Answer": f"ERROR: {error}",
                     "Status": "❌ Failed"
                 })
                 stats["failed"] += 1
-                print(f"❌ Question {i+1} failed: {error_msg}")
-        
+                
         except Exception as e:
-            print(f"❌ Critical error on question {i+1}: {e}")
-            import traceback
-            traceback.print_exc()
-            
             results_log.append({
                 "Task ID": task_id,
-                "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text,
-                "Submitted Answer": f"CRITICAL ERROR: {str(e)}",
+                "Question": question_text[:80] + "..." if len(question_text) > 80 else question_text,
+                "Answer": f"CRITICAL ERROR: {str(e)}",
                 "Status": "💥 Critical Error"
             })
             stats["failed"] += 1
-
+    
     if not answers_payload:
-        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
-
-    # 5. Submit answers
+        return "❌ No answers to submit", pd.DataFrame(results_log)
+    
+    # Submit answers
     submission_data = {
-        "username": username.strip(),
+        "username": username,
         "agent_code": agent_code,
         "answers": answers_payload
     }
     
-    print(f"\n📤 Submitting {len(answers_payload)} answers...")
-    print(f"Submission payload: {json.dumps(submission_data, indent=2)}")
-    
     try:
+        print(f"📤 Submitting {len(answers_payload)} answers...")
+        
         response = requests.post(
             f"{HF_API_BASE_URL}/submit",
             headers=headers,
             json=submission_data,
-            timeout=120
+            timeout=60
         )
         response.raise_for_status()
         result_data = response.json()
         
-        print(f"📦 API Response: {json.dumps(result_data, indent=2)}")
-        
         score = result_data.get('score', 0)
         correct_count = result_data.get('correct_count', 0)
         total_attempted = result_data.get('total_attempted', len(answers_payload))
         
-        final_status = (
-            f"{'='*50}\n"
+        status_msg = (
+            f"{'='*40}\n"
             f"📊 SUBMISSION RESULTS\n"
-            f"{'='*50}\n"
+            f"{'='*40}\n"
             f"✅ Submission Successful!\n"
-            f"👤 User: {result_data.get('username', username)}\n"
-            f"🎯 Overall Score: {score}%\n"
-            f"📊 Correct Answers: {correct_count}/{total_attempted}\n"
-            f"💬 Message: {result_data.get('message', 'No message received.')}\n"
-            f"\n📈 PROCESSING STATS:\n"
-            f"   Total Level 1 Questions: {stats['total']}\n"
-            f"   Questions Attempted: {stats['attempted']}\n"
-            f"   Successfully Processed: {stats['processed']}\n"
-            f"   Failed to Process: {stats['failed']}\n"
-            f"{'='*50}"
+            f"👤 User: {username}\n"
+            f"🎯 Score: {score}%\n"
+            f"📊 Correct: {correct_count}/{total_attempted}\n"
+            f"📈 Processed: {stats['processed']}\n"
+            f"❌ Failed: {stats['failed']}\n"
+            f"💬 {result_data.get('message', '')}\n"
+            f"{'='*40}"
         )
         
         print("✅ Submission successful!")
-        print(final_status)
-        
-        return final_status, pd.DataFrame(results_log)
+        return status_msg, pd.DataFrame(results_log)
         
     except Exception as e:
         error_msg = (
             f"❌ SUBMISSION FAILED\n"
             f"Error: {str(e)}\n"
-            f"\nProcessing Stats:\n"
-            f"   Questions Attempted: {stats['attempted']}\n"
-            f"   Successfully Processed: {stats['processed']}\n"
-            f"   Failed to Process: {stats['failed']}"
+            f"Processed: {stats['processed']}\n"
+            f"Failed: {stats['failed']}"
         )
-        
-        if hasattr(e, 'response') and e.response:
-            error_msg += f"\n\nAPI Response: {e.response.text}"
-        
-        print(error_msg)
         return error_msg, pd.DataFrame(results_log)
 
-# --- Build Gradio Interface ---
-with gr.Blocks(title="GAIA Agent Evaluation") as demo:
+# Cleanup function for HF Spaces
+def cleanup_temp_files():
+    """Clean up temporary files periodically"""
+    try:
+        import glob
+        for temp_dir in [DOWNLOADS_DIR, TEMP_DIR]:
+            if os.path.exists(temp_dir):
+                files = glob.glob(os.path.join(temp_dir, "*"))
+                for file in files:
+                    try:
+                        if os.path.isfile(file):
+                            # Remove files older than 1 hour
+                            if time.time() - os.path.getmtime(file) > 3600:
+                                os.remove(file)
+                    except:
+                        pass
+    except:
+        pass
+
+# Gradio Interface optimized for HF Spaces
+with gr.Blocks(
+    title="GAIA Agent Evaluation",
+    theme=gr.themes.Soft(),
+    css="""
+    .container { max-width: 1200px; margin: auto; }
+    .status-box { font-family: monospace; font-size: 12px; }
+    """
+) as demo:
+    
     gr.Markdown("# 🤖 GAIA Agent Evaluation Runner")
     gr.Markdown(
         """
-        **Advanced GAIA Benchmark Agent with Enhanced File Processing**
-        
-        This agent uses:
-        - 🧠 GPT-4 Turbo with specialized GAIA prompt engineering
-        - 🌐 Tavily web search for current events
-        - 🧮 Wolfram Alpha for computational tasks
-        - 📊 Enhanced file analysis with HuggingFace transformers
-        - 🎵 **Advanced audio processing with MP3 support**
-        - 🎥 YouTube transcript analysis
-        - 👁️ Computer vision with YOLO for video analysis
-        - 🐍 Python REPL for mathematical analysis
-        - 🔄 Text reversal tool for encoded questions
-        
-        **Fixed Issues:**
-        - ✅ **Added missing IOC code formatting example**
-        - ✅ **Simplified web search output format**
-        - ✅ **Fixed agent instance scoping issues**
-        - ✅ **Improved error handling and debugging**
-        - ✅ **Reduced max iterations to match working version**
-        
-        **Instructions:**
-        1. Log in to your Hugging Face account
-        2. Click 'Run Evaluation & Submit All Answers'
-        3. Wait for processing (this may take several minutes)
-        
-        **Note:** This version includes all critical fixes to match local performance.
+        **Production-Ready GAIA Benchmark Agent for HuggingFace Spaces**
+        
+        ✅ **Optimized for HF Spaces:**
+        - Uses `/tmp` for file storage (read-only filesystem compatible)
+        - Resource-efficient models and processing
+        - Robust error handling and cleanup
+        - File size limits and timeout protection
+        
+        ✅ **Key Features:**
+        - 🧠 GPT-4 Turbo with GAIA-specific prompting
+        - 📁 Automatic file download and analysis  
+        - 🌐 Web search for current events
+        - 🧮 Wolfram Alpha for computations
+        - 🎵 Audio transcription (MP3 support)
+        - 🖼️ Image analysis and captioning
+        - 📊 Excel/CSV data processing
+        - 🐍 Python REPL for mathematics
+        
+        ✅ **Fixed Issues:**
+        - IOC code formatting for country questions
+        - File download integration
+        - Memory and resource management
+        - HF Spaces compatibility
         
         ---
         """
     )
-
-    gr.LoginButton()
     
-    run_button = gr.Button("🚀 Run Evaluation & Submit All Answers", variant="primary")
+    with gr.Row():
+        gr.LoginButton(scale=1)
+        cleanup_btn = gr.Button("🧹 Cleanup Temp Files", scale=1, variant="secondary")
     
-    status_output = gr.Textbox(
-        label="📊 Run Status / Submission Result",
-        lines=15,
-        interactive=False
+    run_button = gr.Button(
+        "🚀 Run GAIA Evaluation & Submit Results", 
+        variant="primary", 
+        size="lg"
     )
     
-    results_table = gr.DataFrame(
-        label="📝 Questions and Agent Answers",
-        wrap=True,
-        max_height=600
-    )
-
+    with gr.Row():
+        with gr.Column():
+            status_output = gr.Textbox(
+                label="📊 Execution Status & Results",
+                lines=12,
+                interactive=False,
+                elem_classes=["status-box"]
+            )
+        
+        with gr.Column():
+            results_table = gr.DataFrame(
+                label="📝 Question Results",
+                wrap=True,
+                max_height=400,
+                interactive=False
+            )
+    
+    # Event handlers
     run_button.click(
         fn=run_and_submit_all,
-        outputs=[status_output, results_table]
+        outputs=[status_output, results_table],
+        show_progress=True
+    )
+    
+    cleanup_btn.click(
+        fn=cleanup_temp_files,
+        outputs=None
     )
 
+# Startup checks for HF Spaces
 if __name__ == "__main__":
     print("\n" + "="*50)
-    print("🚀 GAIA Agent HuggingFace Space Starting")
+    print("🚀 GAIA Agent - HuggingFace Spaces Edition")
     print("="*50)
     
-    # Environment info
+    # Environment checks
     space_host = os.getenv("SPACE_HOST")
-    space_id = os.getenv("SPACE_ID")
+    space_id = os.getenv("SPACE_ID") 
+    space_repo = os.getenv("SPACE_REPO_NAME")
     
     if space_host:
-        print(f"✅ SPACE_HOST: {space_host}")
-        print(f"   Runtime URL: https://{space_host}.hf.space")
-    
+        print(f"✅ Running on: https://{space_host}")
     if space_id:
-        print(f"✅ SPACE_ID: {space_id}")
-        print(f"   Repo URL: https://huggingface.co/spaces/{space_id}")
+        print(f"✅ Space ID: {space_id}")
+    if space_repo:
+        print(f"✅ Repo: {space_repo}")
     
-    # Check for required API keys
-    required_keys = ["OPENAI_API_KEY", "TAVILY_API_KEY", "WOLFRAM_API_KEY"]
-    missing_keys = [key for key in required_keys if not os.getenv(key)]
+    # Resource checks
+    try:
+        import psutil
+        memory = psutil.virtual_memory()
+        print(f"💾 Available RAM: {memory.available // (1024**3):.1f}GB")
+        disk = psutil.disk_usage('/tmp')
+        print(f"💿 /tmp space: {disk.free // (1024**3):.1f}GB free")
+    except:
+        print("📊 Resource info unavailable")
     
-    if missing_keys:
-        print(f"\n⚠️ WARNING: Missing API keys: {', '.join(missing_keys)}")
-        print("   Please set these in your HuggingFace Space secrets!")
-    else:
-        print("\n✅ All required API keys found!")
+    # API key validation
+    required_keys = ["OPENAI_API_KEY"]
+    optional_keys = ["TAVILY_API_KEY", "WOLFRAM_API_KEY", "HUGGING_FACE_API_TOKEN"]
     
-    # Check for audio processing capabilities
-    if PYDUB_AVAILABLE:
-        print("✅ Enhanced audio processing (pydub) available!")
-    else:
-        print("⚠️ pydub not available - consider adding to requirements.txt")
+    missing_required = [k for k in required_keys if not os.getenv(k)]
+    missing_optional = [k for k in optional_keys if not os.getenv(k)]
     
-    if FFMPEG_AVAILABLE:
-        print("✅ ffmpeg available for audio conversion!")
+    if missing_required:
+        print(f"❌ Missing required keys: {missing_required}")
+        print("   Please add them in Space Settings > Repository Secrets")
     else:
-        print("⚠️ ffmpeg not available - some audio formats may not work")
+        print("✅ Required API keys found")
+    
+    if missing_optional:
+        print(f"⚠️ Missing optional keys: {missing_optional}")
+        print("   Some features will be limited")
     
-    if TRANSFORMERS_AVAILABLE:
-        print("✅ Transformers available for image analysis!")
+    # Directory status
+    if DIRS_READY:
+        print(f"✅ Temp directories ready: {DOWNLOADS_DIR}")
     else:
-        print("⚠️ transformers not available - consider adding to requirements.txt")
+        print("❌ Temp directory setup failed")
+    
+    # Library status
+    status_items = [
+        ("LangChain", LANGCHAIN_AVAILABLE),
+        ("Transformers", TRANSFORMERS_AVAILABLE),
+        ("pydub (Audio)", PYDUB_AVAILABLE),
+        ("ffmpeg", FFMPEG_AVAILABLE),
+        ("Vision (YOLO)", VISION_AVAILABLE)
+    ]
+    
+    for name, available in status_items:
+        status = "✅" if available else "⚠️"
+        print(f"{status} {name}: {'Available' if available else 'Limited'}")
+    
+    print("="*50)
+    print("🌟 Starting GAIA Agent Interface...")
     
-    print("="*50 + "\n")
-    print("🌟 Launching Fixed GAIA Agent Interface...")
-    demo.launch(debug=True, share=False)
+    # Launch with HF Spaces optimizations
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=False,
+        show_error=True,
+        quiet=False
+    )