fixing

app.py

@@ -1,307 +1,473 @@
 import os
 import gradio as gr
 import requests
+import inspect
+import pandas as pd
 import json
 import re
-import numexpr
-import pandas as pd
-from pdfminer.high_level import extract_text
-from bs4 import BeautifulSoup
-from typing import List, Dict, Optional, Tuple
-from dotenv import load_dotenv
-from transformers import AutoModelForCausalLM, AutoTokenizer
-import torch
-import time
-import gc
+from typing import Dict, List, Any, Optional
+import urllib.parse
+from datetime import datetime
+import math
 
-# --- Configuration ---
-load_dotenv()
-SERPER_API_KEY = os.getenv("SERPER_API_KEY")
-MODEL_NAME = "microsoft/Phi-3-mini-4k-instruct"
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+# Transformers and torch imports
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+import torch
 
 # --- Constants ---
-MAX_STEPS = 6
-MAX_TOKENS = 256
-TIMEOUT_PER_QUESTION = 45
-MAX_RESULT_LENGTH = 500
-MAX_ATTEMPTS = 2
-
-# --- Model Initialization ---
-print("Initializing model with fixed cache configuration...")
-start_time = time.time()
-
-model = AutoModelForCausalLM.from_pretrained(
-    MODEL_NAME,
-    trust_remote_code=True,
-    torch_dtype=torch.float32,
-    device_map="auto",
-    low_cpu_mem_usage=True
-)
-
-tokenizer = AutoTokenizer.from_pretrained(
-    MODEL_NAME,
-    use_fast=True,
-    trust_remote_code=True
-)
-
-if tokenizer.pad_token is None:
-    tokenizer.pad_token = tokenizer.eos_token
-
-print(f"Model loaded in {time.time() - start_time:.2f} seconds")
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Tool Implementations ---
-def web_search(query: str) -> str:
-    try:
-        if not SERPER_API_KEY:
-            return "Search API key not configured"
+class EnhancedGAIAAgent:
+    def __init__(self):
+        print("Initializing Enhanced GAIA Agent with Mistral-7B...")
+        
+        # Initialize Mistral model
+        try:
+            print("Loading Mistral-7B-Instruct model...")
+            self.tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")
+            self.model = AutoModelForCausalLM.from_pretrained(
+                "mistralai/Mistral-7B-Instruct-v0.3",
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                device_map="auto" if torch.cuda.is_available() else None
+            )
             
-        params = {'q': query, 'num': 3}
-        headers = {'X-API-KEY': SERPER_API_KEY}
-        response = requests.post(
-            'https://google.serper.dev/search',
-            headers=headers,
-            json=params,
-            timeout=10
-        )
-        response.raise_for_status()
-        results = response.json()
+            # Create pipeline for easier use
+            self.pipe = pipeline(
+                "text-generation",
+                model=self.model,
+                tokenizer=self.tokenizer,
+                max_new_tokens=512,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+            print("✅ Mistral model loaded successfully!")
+            
+        except Exception as e:
+            print(f"❌ Error loading Mistral model: {e}")
+            print("Falling back to basic responses...")
+            self.pipe = None
+            
+        # Tool functions for GAIA tasks
+        self.tools = {
+            "calculate": self._calculate,
+            "search_web": self._search_web,
+            "parse_data": self._parse_data,
+            "analyze_text": self._analyze_text,
+            "solve_math": self._solve_math
+        }
         
-        if 'organic' not in results or not results['organic']:
-            return "No relevant results found"
+    def _calculate(self, expression: str) -> str:
+        """Safe calculator for mathematical expressions"""
+        try:
+            # Clean and validate expression
+            expression = re.sub(r'[^0-9+\-*/().\s]', '', expression)
+            result = eval(expression)
+            return str(result)
+        except Exception as e:
+            return f"Calculation error: {e}"
+    
+    def _search_web(self, query: str) -> str:
+        """Simulate web search (placeholder - you'd integrate real search API)"""
+        # This is a placeholder - integrate with actual search API
+        return f"Search results for '{query}': [This would contain real search results]"
+    
+    def _parse_data(self, data: str) -> str:
+        """Parse and analyze structured data"""
+        try:
+            # Try to parse as JSON
+            if data.strip().startswith('{') or data.strip().startswith('['):
+                parsed = json.loads(data)
+                return f"Parsed data structure with {len(parsed) if isinstance(parsed, (list, dict)) else 1} elements"
+            else:
+                # Basic text analysis
+                lines = data.split('\n')
+                return f"Text data with {len(lines)} lines, {len(data.split())} words"
+        except Exception as e:
+            return f"Data parsing error: {e}"
+    
+    def _analyze_text(self, text: str) -> str:
+        """Analyze text content"""
+        words = text.split()
+        sentences = text.split('.')
+        return f"Text analysis: {len(words)} words, {len(sentences)} sentences"
+    
+    def _solve_math(self, problem: str) -> str:
+        """Enhanced math problem solver"""
+        try:
+            # Extract numbers and operations
+            numbers = re.findall(r'-?\d+\.?\d*', problem)
             
-        output = []
-        for r in results['organic'][:3]:
-            if 'title' in r and 'snippet' in r:
-                output.append(f"Title: {r['title']}\nSnippet: {r['snippet']}")
-        return "\n\n".join(output)[:MAX_RESULT_LENGTH]
-    except Exception as e:
-        return f"Search error: {str(e)}"
-
-def calculator(expression: str) -> str:
-    try:
-        expression = re.sub(r'[^\d+\-*/().^%,\s]', '', expression)
-        if not expression:
-            return "Invalid empty expression"
-        return str(numexpr.evaluate(expression))
-    except Exception as e:
-        return f"Calculation error: {str(e)}"
-
-def read_webpage(url: str) -> str:
-    try:
-        if not re.match(r'^https?://', url):
-            return "Invalid URL format"
+            # Handle common math patterns
+            if "percent" in problem.lower() or "%" in problem:
+                if len(numbers) >= 2:
+                    base = float(numbers[0])
+                    percent = float(numbers[1])
+                    result = base * (percent / 100)
+                    return str(result)
             
-        headers = {'User-Agent': 'Mozilla/5.0'}
-        response = requests.get(url, timeout=15, headers=headers)
-        response.raise_for_status()
+            if "average" in problem.lower() or "mean" in problem.lower():
+                if numbers:
+                    nums = [float(n) for n in numbers]
+                    return str(sum(nums) / len(nums))
+            
+            # Default calculation
+            return self._calculate(" ".join(numbers))
+            
+        except Exception as e:
+            return f"Math solving error: {e}"
+    
+    def _generate_response(self, prompt: str) -> str:
+        """Generate response using Mistral model"""
+        if not self.pipe:
+            return "Model not available - using fallback response."
         
-        soup = BeautifulSoup(response.text, 'html.parser')
-        for element in soup(['script', 'style', 'nav', 'footer', 'aside']):
-            element.decompose()
+        try:
+            messages = [
+                {"role": "user", "content": prompt}
+            ]
             
-        main_content = soup.find('main') or soup.find('article') or soup
-        text = main_content.get_text(separator='\n', strip=True)
-        text = re.sub(r'\n{3,}', '\n\n', text)
-        return text[:MAX_RESULT_LENGTH]
-    except Exception as e:
-        return f"Webpage error: {str(e)}"
-
-TOOLS = {
-    "web_search": web_search,
-    "calculator": calculator,
-    "read_webpage": read_webpage
-}
+            response = self.pipe(messages, max_new_tokens=512, temperature=0.7)
+            
+            # Extract the generated text
+            if response and len(response) > 0:
+                generated_text = response[0]['generated_text']
+                # Get only the assistant's response (after the user message)
+                if isinstance(generated_text, list):
+                    # Find the assistant's response
+                    for msg in generated_text:
+                        if msg.get('role') == 'assistant':
+                            return msg.get('content', '')
+                elif isinstance(generated_text, str):
+                    return generated_text
+                else:
+                    return str(generated_text)
+            
+            return "No response generated."
+            
+        except Exception as e:
+            print(f"Error generating response: {e}")
+            return f"Error in response generation: {e}"
+    
+    def _detect_task_type(self, question: str) -> str:
+        """Detect the type of task to apply appropriate strategy"""
+        question_lower = question.lower()
+        
+        if any(word in question_lower for word in ["calculate", "compute", "math", "+", "-", "*", "/", "="]):
+            return "calculation"
+        elif any(word in question_lower for word in ["search", "find", "lookup", "google"]):
+            return "search"
+        elif any(word in question_lower for word in ["data", "csv", "json", "table", "parse"]):
+            return "data_analysis"
+        elif any(word in question_lower for word in ["percent", "%", "average", "mean", "sum"]):
+            return "math_word_problem"
+        else:
+            return "general_reasoning"
+    
+    def __call__(self, question: str) -> str:
+        print(f"Agent processing question (first 100 chars): {question[:100]}...")
+        
+        # Detect task type
+        task_type = self._detect_task_type(question)
+        print(f"Detected task type: {task_type}")
+        
+        # Build enhanced prompt based on task type
+        if task_type == "calculation":
+            enhanced_prompt = f"""
+You are a precise mathematical assistant. Solve this step-by-step:
 
-# --- GAIA Agent Class ---
-class GAIA_Agent:
-    def __init__(self):
-        self.tools = TOOLS
-        self.system_prompt = """You are an advanced problem solver. Follow these steps:
-1. Analyze the question
-2. Select the best tool
-3. Execute with proper arguments
-4. Interpret results
-5. Provide final answer
+Question: {question}
 
-Tools:
-- web_search(query): For general knowledge
-- calculator(expression): For math
-- read_webpage(url): For web content
+Provide a clear, accurate answer. If calculation is needed, show your work.
+Answer:"""
+            
+        elif task_type == "math_word_problem":
+            enhanced_prompt = f"""
+You are solving a math word problem. Break it down step by step:
 
-Tool format: ```json
-{"tool": "tool_name", "args": {"arg": value}}```
+Question: {question}
 
-Always conclude with: Final Answer: [answer]"""
+Steps:
+1. Identify what is being asked
+2. Extract the relevant numbers
+3. Determine the operation needed
+4. Calculate the result
+5. Provide the final answer
 
-    def __call__(self, question: str) -> str:
-        start_time = time.time()
-        history = [f"Question: {question}"]
-        
-        try:
-            for step in range(MAX_STEPS):
-                if time.time() - start_time > TIMEOUT_PER_QUESTION:
-                    return "Timeout: Processing took too long"
-                
-                prompt = self._build_prompt(history)
-                response = self._call_model(prompt)
-                
-                if "Final Answer:" in response:
-                    return response.split("Final Answer:")[-1].strip()[:500]
-                
-                tool_call = self._parse_tool_call(response)
-                if tool_call:
-                    tool_name, args = tool_call
-                    observation = self._use_tool(tool_name, args)
-                    history.append(f"Tool: {tool_name}")
-                    history.append(f"Result: {observation[:300]}...")
-                else:
-                    history.append(f"Thought: {response}")
-                
-                gc.collect()
+Answer:"""
             
-            return "Maximum steps reached"
-        except Exception as e:
-            return f"Agent error: {str(e)}"
+        elif task_type == "data_analysis":
+            enhanced_prompt = f"""
+You are analyzing data. Approach this systematically:
 
-    def _build_prompt(self, history: List[str]) -> str:
-        return f"<|system|>\n{self.system_prompt}<|end|>\n<|user|>\n" + "\n".join(history) + "<|end|>\n<|assistant|>"
+Question: {question}
 
-    def _call_model(self, prompt: str) -> str:
-        for attempt in range(MAX_ATTEMPTS):
-            try:
-                inputs = tokenizer(
-                    prompt,
-                    return_tensors="pt",
-                    truncation=True,
-                    max_length=3072,
-                    padding=False
-                )
-                
-                outputs = model.generate(
-                    inputs.input_ids,
-                    max_new_tokens=MAX_TOKENS,
-                    temperature=0.3,
-                    top_p=0.9,
-                    do_sample=True,
-                    pad_token_id=tokenizer.pad_token_id,
-                    attention_mask=inputs.attention_mask
-                )
-                
-                return tokenizer.decode(outputs[0], skip_special_tokens=True).split("<|assistant|>")[-1].strip()
-            except Exception as e:
-                if attempt < MAX_ATTEMPTS - 1:
-                    time.sleep(0.5)
-                    continue
-                return f"Model error: {str(e)}"
+Consider:
+- What type of data is involved?
+- What analysis is needed?
+- What tools or methods should be used?
 
-    def _parse_tool_call(self, text: str) -> Optional[Tuple[str, Dict]]:
-        try:
-            json_match = re.search(r'```json\s*({.+?})\s*```', text, re.DOTALL)
-            if not json_match:
-                return None
-                
-            tool_call = json.loads(json_match.group(1))
-            if not isinstance(tool_call, dict):
-                return None
-            if "tool" not in tool_call or "args" not in tool_call:
-                return None
-            if not isinstance(tool_call["args"], dict):
-                return None
-                
-            return tool_call["tool"], tool_call["args"]
-        except:
-            return None
+Provide a clear, structured answer.
+Answer:"""
+            
+        else:
+            enhanced_prompt = f"""
+You are a helpful assistant that provides accurate, well-reasoned answers.
+
+Question: {question}
 
-    def _use_tool(self, tool_name: str, args: Dict) -> str:
-        if tool_name not in self.tools:
-            return f"Unknown tool: {tool_name}"
+Think through this step-by-step and provide a clear, comprehensive answer.
+Answer:"""
         
+        # Generate response using the model
         try:
-            if tool_name == "read_webpage" and "url" not in args:
-                url_match = re.search(r'https?://[^\s]+', str(args))
-                if url_match:
-                    args = {"url": url_match.group()}
-                else:
-                    return "Missing URL argument"
+            response = self._generate_response(enhanced_prompt)
+            
+            # Post-process response for specific task types
+            if task_type in ["calculation", "math_word_problem"]:
+                # Try to extract and verify any calculations
+                numbers_in_response = re.findall(r'-?\d+\.?\d*', response)
+                if numbers_in_response:
+                    # Attempt to verify calculation if simple enough
+                    pass
+            
+            print(f"Agent returning response (first 100 chars): {response[:100]}...")
+            return response.strip()
             
-            return str(self.tools[tool_name](**args))[:MAX_RESULT_LENGTH]
         except Exception as e:
-            return f"Tool error: {str(e)}"
-
-# --- Evaluation Function ---
-def run_evaluation(profile: gr.OAuthProfile | None):
-    if not profile:
-        return "Please login first", None
-    
-    agent = GAIA_Agent()
-    questions_url = f"{DEFAULT_API_URL}/questions"
-    submit_url = f"{DEFAULT_API_URL}/submit"
+            print(f"Error in agent processing: {e}")
+            fallback_response = self._handle_fallback(question, task_type)
+            return fallback_response
     
+    def _handle_fallback(self, question: str, task_type: str) -> str:
+        """Provide fallback responses when the main model fails"""
+        if task_type == "calculation":
+            # Try to extract and calculate simple expressions
+            try:
+                numbers = re.findall(r'-?\d+\.?\d*', question)
+                if len(numbers) >= 2:
+                    if "+" in question:
+                        result = sum(float(n) for n in numbers)
+                        return f"The sum is {result}"
+                    elif "*" in question or "multiply" in question.lower():
+                        result = 1
+                        for n in numbers:
+                            result *= float(n)
+                        return f"The product is {result}"
+            except:
+                pass
+        
+        return f"I understand you're asking about: {question}. This appears to be a {task_type} task. Let me provide my best analysis based on the available information."
+
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the EnhancedGAIAAgent on them, submits all answers,
+    and displays the results.
+    """
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID")
+
+    if profile:
+        username = f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
+
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
+    # 1. Instantiate Enhanced Agent
+    try:
+        print("Initializing Enhanced GAIA Agent...")
+        agent = EnhancedGAIAAgent()
+        print("✅ Agent initialized successfully!")
+    except Exception as e:
+        print(f"❌ Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(f"Agent code URL: {agent_code}")
+
+    # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
     try:
-        response = requests.get(questions_url, timeout=20)
+        response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-            return "No questions available", None
+            print("Fetched questions list is empty.")
+            return "Fetched questions list is empty or invalid format.", None
+        print(f"✅ Fetched {len(questions_data)} questions.")
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+        print(f"❌ Error decoding JSON response from questions endpoint: {e}")
+        return f"Error decoding server response for questions: {e}", None
     except Exception as e:
-        return f"Failed to get questions: {str(e)}", None
-    
-    results = []
-    answers = []
+        print(f"❌ An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+    # 3. Run Enhanced Agent
+    results_log = []
+    answers_payload = []
+    print(f"🚀 Running enhanced agent on {len(questions_data)} questions...")
     
-    for i, item in enumerate(questions_data):
+    for i, item in enumerate(questions_data, 1):
         task_id = item.get("task_id")
-        question = item.get("question")
+        question_text = item.get("question")
         
-        if not task_id or not question:
+        if not task_id or question_text is None:
+            print(f"⚠️  Skipping item with missing task_id or question: {item}")
             continue
             
-        print(f"Processing question {i+1}/{len(questions_data)}")
-        answer = agent(question)
+        print(f"📝 Processing question {i}/{len(questions_data)} (ID: {task_id})")
         
-        answers.append({"task_id": task_id, "submitted_answer": answer})
-        results.append({
-            "Task ID": task_id,
-            "Question": question[:100] + "..." if len(question) > 100 else question,
-            "Answer": answer[:100] + "..." if len(answer) > 100 else answer
-        })
-    
-    submission = {
-        "username": profile.username,
-        "agent_code": f"https://huggingface.co/spaces/{os.getenv('SPACE_ID')}",
-        "answers": answers
+        try:
+            submitted_answer = agent(question_text)
+            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": question_text[:200] + "..." if len(question_text) > 200 else question_text,
+                "Submitted Answer": submitted_answer[:300] + "..." if len(submitted_answer) > 300 else submitted_answer
+            })
+            print(f"✅ Completed question {i}")
+            
+        except Exception as e:
+            print(f"❌ Error running agent on task {task_id}: {e}")
+            error_response = f"AGENT ERROR: {e}"
+            answers_payload.append({"task_id": task_id, "submitted_answer": error_response})
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": question_text[:200] + "..." if len(question_text) > 200 else question_text,
+                "Submitted Answer": error_response
+            })
+
+    if not answers_payload:
+        print("❌ Agent did not produce any answers to submit.")
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    # 4. Prepare Submission
+    submission_data = {
+        "username": username.strip(), 
+        "agent_code": agent_code, 
+        "answers": answers_payload
     }
     
+    print(f"📤 Submitting {len(answers_payload)} answers for user '{username}'...")
+
+    # 5. Submit
     try:
-        response = requests.post(submit_url, json=submission, timeout=60)
+        response = requests.post(submit_url, json=submission_data, timeout=120)  # Increased timeout
         response.raise_for_status()
-        result = response.json()
-        status = (f"✅ Submission Successful!\n"
-                 f"Score: {result.get('score', 'N/A')}%\n"
-                 f"Correct: {result.get('correct_count', '?')}/{result.get('total_attempted', '?')}")
-        return status, pd.DataFrame(results)
+        result_data = response.json()
+        
+        final_status = (
+            f"🎉 Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Overall Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
+            f"Message: {result_data.get('message', 'No message received.')}"
+        )
+        
+        print("✅ Submission successful!")
+        results_df = pd.DataFrame(results_log)
+        return final_status, results_df
+        
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"Server responded with status {e.response.status_code}."
+        try:
+            error_json = e.response.json()
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+        except requests.exceptions.JSONDecodeError:
+            error_detail += f" Response: {e.response.text[:500]}"
+        status_message = f"❌ Submission Failed: {error_detail}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+        
     except Exception as e:
-        return f"❌ Submission failed: {str(e)}", pd.DataFrame(results)
+        status_message = f"❌ An unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+
+
+# --- Build Gradio Interface using Blocks ---
+with gr.Blocks(title="Enhanced GAIA Agent") as demo:
+    gr.Markdown("# 🚀 Enhanced GAIA Agent with Mistral-7B")
+    gr.Markdown(
+        """
+        **Enhanced Features:**
+        - 🧠 **Mistral-7B-Instruct** for advanced reasoning
+        - 🔧 **Tool Integration** for calculations and data processing  
+        - 📊 **Task Type Detection** for optimized responses
+        - 🎯 **GAIA-Optimized** prompting strategies
+        
+        **Instructions:**
+        1. Clone this space and ensure you have access to Mistral-7B-Instruct
+        2. Log in to your Hugging Face account using the button below
+        3. Click 'Run Enhanced Evaluation' to process all questions with the enhanced agent
+        
+        **Note:** The enhanced agent uses Mistral-7B which requires significant computational resources.
+        Processing may take several minutes depending on the number of questions.
+        """
+    )
 
-# --- Gradio Interface ---
-with gr.Blocks(title="Fixed GAIA Agent", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🚀 GAIA Agent Evaluation")
-    
     with gr.Row():
         gr.LoginButton()
-        run_btn = gr.Button("Run Evaluation", variant="primary")
-    
-    status_output = gr.Textbox(label="Status")
-    results_table = gr.DataFrame(label="Results")
+        
+    with gr.Row():
+        run_button = gr.Button("🚀 Run Enhanced Evaluation & Submit All Answers", variant="primary")
+
+    status_output = gr.Textbox(
+        label="📊 Run Status / Submission Result", 
+        lines=8, 
+        interactive=False
+    )
     
-    run_btn.click(
-        run_evaluation,
+    results_table = gr.DataFrame(
+        label="📝 Questions and Agent Answers", 
+        wrap=True,
+        height=400
+    )
+
+    run_button.click(
+        fn=run_and_submit_all,
         outputs=[status_output, results_table]
     )
 
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860
-    )
+    print("\n" + "="*50)
+    print("🚀 ENHANCED GAIA AGENT STARTING")
+    print("="*50)
+    
+    # Environment check
+    space_host = os.getenv("SPACE_HOST")
+    space_id = os.getenv("SPACE_ID")
+    
+    if space_host:
+        print(f"✅ SPACE_HOST: {space_host}")
+        print(f"🌐 Runtime URL: https://{space_host}.hf.space")
+    else:
+        print("ℹ️  Running locally - SPACE_HOST not found")
+
+    if space_id:
+        print(f"✅ SPACE_ID: {space_id}")
+        print(f"📁 Repo URL: https://huggingface.co/spaces/{space_id}")
+    else:
+        print("ℹ️  SPACE_ID not found")
+    
+    # GPU/CPU check
+    if torch.cuda.is_available():
+        print(f"🎮 GPU Available: {torch.cuda.get_device_name()}")
+        print(f"💾 GPU Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")
+    else:
+        print("💻 Running on CPU (GPU not available)")
+    
+    print("="*50)
+    print("🚀 Launching Enhanced GAIA Agent Interface...")
+    demo.launch(debug=True, share=False)