losing my mind

app.py

@@ -1,272 +1,431 @@
 import os
-import google.generativeai as genai
-from dotenv import load_dotenv
-from excel_parser import ExcelParser
-import re
-import time
+import gradio as gr
+import requests
+import inspect
+import pandas as pd
 import asyncio
+import aiohttp
+import time
+import random
+import json
+import boto3
+from smolagents import FinalAnswerTool, Tool, tool, OpenAIServerModel, DuckDuckGoSearchTool, CodeAgent, VisitWebpageTool
+from nova_agent import NovaProAgent
+from gemini_agent import GeminiAgent
+
+from dotenv import load_dotenv
 
 load_dotenv()
+# (Keep Constants as is)
+# --- Constants ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
 
-class GeminiAgent:
+OPENAI_TOKEN = os.getenv("OPENAI_API_KEY")
+
+# --- Custom Tools ---
+class KnowledgeBaseTool(Tool):
+    name = "knowledge_base"
+    description = "Access structured knowledge for common topics"
+    inputs = {"topic": {"type": "string", "description": "The topic to look up"}}
+    output_type = "string"
+    
     def __init__(self):
-        print("GeminiAgent initialized.")
-        
-        # Get Google API key from environment variables
-        api_key = os.getenv('GOOGLE_API_KEY')
-        genai.configure(api_key=api_key)
+        super().__init__()
+        self.is_initialized = True
+        # Common knowledge base
+        self.knowledge = {
+            "olympics": "Olympic Games data: Countries, athletes, years, sports",
+            "countries": "Country codes: ISO, IOC, FIFA codes and country information",
+            "sports": "Sports history, rules, famous athletes and events",
+            "science": "Scientific facts, formulas, discoveries, and researchers",
+            "history": "Historical events, dates, people, and places",
+            "geography": "Countries, capitals, populations, and geographical features"
+        }
+    
+    def forward(self, topic: str) -> str:
+        topic_lower = topic.lower()
+        for key, info in self.knowledge.items():
+            if key in topic_lower:
+                return f"Knowledge base: {info}. Use this context to answer questions about {topic}."
+        return f"No specific knowledge base entry for '{topic}'. Use general reasoning."
+
+class WikipediaSearchTool(Tool):
+    name = "wikipedia_search"
+    description = "Search Wikipedia for information"
+    inputs = {"query": {"type": "string", "description": "The search query for Wikipedia"}}
+    output_type = "string"
+    
+    def __init__(self):
+        super().__init__()
+        self.is_initialized = True
         
-        self.model = genai.GenerativeModel('gemini-2.0-flash-exp')
-        self.last_request_time = 0
-        self.min_request_interval = 6.0  # 6 seconds between requests (10 per minute limit)
+    def forward(self, query: str) -> str:
+        """Search Wikipedia with simple fallback."""
+        try:
+            import requests
+            wiki_url = "https://en.wikipedia.org/api/rest_v1/page/summary/" + query.replace(" ", "_")
+            response = requests.get(wiki_url, timeout=2)
+            if response.status_code == 200:
+                data = response.json()
+                if 'extract' in data and data['extract']:
+                    return f"Wikipedia: {data['extract'][:500]}"  # Limit length
+        except Exception as e:
+            print(f"Wikipedia search failed: {e}")
         
-        # Initialize parsers
-        self.excel_parser = ExcelParser()
+        return f"Wikipedia search unavailable for '{query}'. Use your knowledge to answer."
+
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+class SlpMultiAgent:
+    def __init__(self):
+        print("BasicAgent initialized.")
         
     async def __call__(self, question: str) -> str:
-        print(f"GeminiAgent received question (first 50 chars): {question}...")
-        
-        try:
-            # Check if question involves video analysis
-            if 'youtube.com' in question or 'video' in question.lower():
-                return await self._handle_video_question(question)
-            
-            # Check if question involves Excel files
-            if '.xlsx' in question or '.xls' in question or 'excel' in question.lower():
-                return await self._handle_excel_question(question)
-            
-            # Regular text-based question
-            return await self._handle_text_question(question)
-            
-        except Exception as e:
-            print(f"Error processing question: {e}")
-            return "Unable to process request."
-    
-    async def _handle_video_question(self, question: str) -> str:
-        """Handle questions that require video analysis"""
-        # Extract YouTube URL
-        youtube_url = re.search(r'https://www\.youtube\.com/watch\?v=[\w-]+', question)
-        if not youtube_url:
-            return "No valid YouTube URL found in question."
+        print(f"Agent received question (first 50 chars): {question}...")
+        fixed_answer = "This is a default answer."
+        print(f"Agent returning fixed answer: {fixed_answer}")
         
-        url = youtube_url.group()
+        # Truncate question to avoid exceeding model context length
+        MAX_QUESTION_LENGTH = 1000
+        short_question = question  # [:MAX_QUESTION_LENGTH]
         
-        # Extract video ID for reference
-        video_id = re.search(r'v=([\w-]+)', url).group(1)
+        # Use cheaper, faster model
+        model = OpenAIServerModel(
+            model_id="gpt-3.5-turbo", 
+            temperature=0.0,  # Deterministic for consistency
+            max_tokens=400    # Reduced tokens for cost efficiency
+        )
         
-        # Extract video information from the question to provide relevant answers
-        # without hardcoding specific IDs
+        # Create only essential agents with reduced complexity
+        research_agent = CodeAgent(
+            tools=[KnowledgeBaseTool()],  # Remove Wikipedia to avoid timeouts
+            model=model,
+            additional_authorized_imports=["re", "datetime"],
+            max_steps=2,  # Reduced steps for cost
+            name="ResearchAgent",
+            verbosity_level=0,
+            description="Quick factual research and knowledge lookup."
+        )
         
-        # Enhanced video prompt for better accuracy
-        video_prompt = f"""You need to answer this question about YouTube video {url}:
-
-{question}
+        solver_agent = CodeAgent(
+            tools=[],
+            model=model,
+            additional_authorized_imports=["math", "re", "collections", "itertools"],
+            max_steps=2,  # Reduced steps
+            name="SolverAgent",
+            verbosity_level=0,
+            description="Problem solving, calculations, and logical reasoning."
+        )
 
-Provide only the direct answer. If it's a quote, give just the quoted text. If it's a number, give just the number. If it's about bird species count, analyze carefully and give the exact count. If it's about dialogue, provide the exact words spoken."""
-        
-        try:
-            await self._rate_limit()
-            response = self.model.generate_content(
-                video_prompt,
-                generation_config=genai.types.GenerationConfig(
-                    max_output_tokens=50,
-                    temperature=0.0
-                )
-            )
-            answer = response.text.strip()
-            
-            # Clean up video responses to be more concise
-            if len(answer) > 100:
-                # Extract key information
-                if '"' in answer:
-                    # Extract quoted text
-                    quotes = re.findall(r'"([^"]+)"', answer)
-                    if quotes:
-                        return quotes[0]
-                # Extract numbers if it's a counting question
-                if 'how many' in question.lower() or 'number' in question.lower():
-                    numbers = re.findall(r'\b\d+\b', answer)
-                    if numbers:
-                        return numbers[0]
-                # Take first sentence
-                sentences = answer.split('. ')
-                answer = sentences[0]
-            
-            return answer
-            
-        except Exception as e:
-            print(f"Video analysis failed: {str(e)}")
-            # Generate answer based on question content
-            return await self._generate_video_answer_from_question(question, video_id)
-    
-    async def _handle_excel_question(self, question: str) -> str:
-        """Handle questions that require Excel file analysis"""
-        # Extract file path from question if present
-        file_patterns = [r'([A-Za-z]:\\[^\s]+\.xlsx?)', r'([^\s]+\.xlsx?)']
-        file_path = None
+        manager_agent = CodeAgent(
+            model=OpenAIServerModel(
+                model_id="gpt-3.5-turbo",
+                temperature=0.0,
+                max_tokens=500
+            ),
+            tools=[KnowledgeBaseTool()],  # Remove Wikipedia to avoid timeouts
+            managed_agents=[research_agent, solver_agent],  # Only 2 agents
+            name="ManagerAgent",
+            description="Efficient manager for quick problem solving.",
+            additional_authorized_imports=["re", "math"],
+            planning_interval=1,  # Faster planning
+            verbosity_level=0,  # Reduce verbosity
+            max_steps=3,  # Further reduced steps to avoid timeouts
+            final_answer_checks=[check_reasoning]
+        )
         
-        for pattern in file_patterns:
-            match = re.search(pattern, question)
-            if match:
-                file_path = match.group(1)
-                break
+        # Create a task for the agent run with retry mechanism for rate limits
+        max_retries = 3
+        result = None
         
-        # If we have a file path, try to process it
-        if file_path:
+        for attempt in range(max_retries):
             try:
-                if 'sales' in question.lower() and 'food' in question.lower():
-                    results = self.excel_parser.analyze_sales_data(file_path)
-                    return results.get('total_food_sales', 'No sales data found')
-                else:
-                    df = self.excel_parser.read_excel_file(file_path)
-                    return f"Excel file loaded with {len(df)} rows and {len(df.columns)} columns."
+                loop = asyncio.get_event_loop()
+                result = await loop.run_in_executor(
+                    None,
+                    lambda: manager_agent.run(f"""
+                    Question: {short_question}
+                    
+                    You have knowledge_base() tool and two agents:
+                    - ResearchAgent: For factual questions
+                    - SolverAgent: For calculations and logic
+                    
+                    IMPORTANT: Always end with exactly this format:
+                    <code>
+                    final_answer("your direct answer")
+                    </code>
+                    
+                    Be concise and direct.
+                    """)
+                )
+                break  # Success, exit retry loop
             except Exception as e:
-                print(f"Excel analysis failed: {str(e)}")
-                # Fall through to Nova Pro search
+                print(f"Attempt {attempt+1}/{max_retries} failed: {e}")
+                if "rate limit" in str(e).lower() and attempt < max_retries - 1:
+                    # Add jitter to avoid synchronized retries
+                    wait_time = (attempt + 1) * 10 + random.uniform(0, 5)  
+                    print(f"Rate limit hit. Waiting {wait_time:.2f} seconds before retry...")
+                    await asyncio.sleep(wait_time)
+                elif attempt < max_retries - 1:
+                    await asyncio.sleep(5)  # Wait before general retry
+                else:
+                    print(f"All attempts failed. Returning default answer.")
+                    return "I apologize, but I'm currently experiencing technical difficulties. Please try again later."
         
-        # Use Nova Pro to search for information about the Excel file
-        excel_prompt = f"""I need to analyze an Excel file mentioned in this question, but I don't have direct access to it. 
-        Based on your knowledge, provide the most accurate answer possible:
-
-        {question}
-
-        If you don't have specific information about this Excel file, provide a reasonable estimate based on similar data."""
+        # If we couldn't get a result after all retries
+        if result is None:
+            return "I apologize, but I'm currently experiencing technical difficulties. Please try again later."
         
-        try:
-            await self._rate_limit()
-            response = self.model.generate_content(
-                excel_prompt,
-                generation_config=genai.types.GenerationConfig(
-                    max_output_tokens=150,
-                    temperature=0.0
-                )
-            )
-            answer = response.text.strip()
+        
+        # Extract clean answer from result
+        if result and isinstance(result, str):
+            # Look for final_answer pattern
+            import re
+            final_answer_match = re.search(r'final_answer\(["\']([^"\']*)["\'\)]', result)  # Fixed regex
+            if final_answer_match:
+                clean_answer = final_answer_match.group(1)
+                return clean_answer
             
-            # Check if the answer contains a dollar amount
-            dollar_match = re.search(r'\$[\d,]+\.\d{2}', answer)
-            if dollar_match:
-                return dollar_match.group(0)
-            else:
-                return answer
-                
-        except Exception as e:
-            print(f"Gemini search failed: {str(e)}")
-            return "Unable to analyze Excel data. Please provide the file directly."
+            # If no final_answer found, try to extract the last meaningful line
+            lines = result.strip().split('\n')
+            for line in reversed(lines):
+                line = line.strip()
+                if line and not line.startswith('#') and not line.startswith('###') and len(line) < 200:
+                    return line
+        
+        # Return the result from the agent
+        return result if result else "Unable to determine answer."
     
-    async def _handle_text_question(self, question: str) -> str:
-        """Handle regular text-based questions"""
-        prompt = ""
-        # Handle attached file questions with enhanced prompts
-        if 'attached' in question.lower():
-            if 'python code' in question.lower():
-                prompt = f"""This question refers to attached Python code. Based on typical code execution patterns, provide the most likely numeric output:\n\n{question}\n\nAnswer:"""
-            elif '.mp3' in question.lower():
-                prompt = f"""This question refers to an attached audio file. Provide the most likely answer based on the context:\n\n{question}\n\nAnswer:"""
-            else:
-                prompt = f"""This question refers to an attached file. Provide the most likely answer:\n\n{question}\n\nAnswer:"""
-        # Handle chess position question
-        elif 'chess position' in question.lower() and 'image' in question.lower():
-            prompt = f"""This is a chess question with an attached image. Provide the best chess move in algebraic notation:\n\n{question}\n\nAnswer:"""
-        # Handle list extraction and formatting
-        elif (
-            'alphabetize' in question.lower() or 
-            'comma separated' in question.lower() or 
-            'list' in question.lower() or 
-            'ingredients' in question.lower() or 
-            'page numbers' in question.lower() or 
-            'vegetables' in question.lower()
-        ):
-            # Add domain definition for botanical vegetables
-            if 'vegetable' in question.lower() and ('botany' in question.lower() or 'botanical' in question.lower()):
-                definition = ("In botany, a vegetable is any edible part of a plant that is not a fruit or seed. "
-                              "Fruits contain seeds and develop from the ovary of a flower. Use this definition.")
-                prompt = f"{definition}\n\n{question}\n\nList only the requested items, alphabetized, comma separated, and do not include any explanations or extra words."
-            else:
-                prompt = f"{question}\n\nList only the requested items, alphabetized, comma separated, and do not include any explanations or extra words."
-        # Create enhanced prompt based on question type
-        elif 'how many' in question.lower() or 'what is the' in question.lower():
-            prompt = f"""Provide only the exact answer to this question. No explanations, just the specific number, name, or fact requested:\n\n{question}\n\nAnswer:"""
-        elif 'who' in question.lower():
-            prompt = f"""Provide only the name requested. No explanations or additional context:\n\n{question}\n\nAnswer:"""
-        elif 'where' in question.lower():
-            prompt = f"""Provide only the location requested. No explanations:\n\n{question}\n\nAnswer:"""
+def check_reasoning(final_answer, agent_memory):
+    # Skip expensive validation to save costs
+    return True
+
+
+async def run_and_submit_all(profile):
+    """
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    and displays the results asynchronously.
+    """
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+
+    # Handle different profile types
+    if profile:
+        if hasattr(profile, 'username'):
+            # It's an OAuthProfile object
+            username = profile.username
         else:
-            prompt = f"""Answer this question with only the essential information requested:\n\n{question}\n\nAnswer:"""
-        
-        # Use the constructed prompt for all cases
-        await self._rate_limit()
-        response = self.model.generate_content(
-            prompt,
-            generation_config=genai.types.GenerationConfig(
-                max_output_tokens=100,
-                temperature=0.0
-            )
-        )
-        answer = response.text.strip()
-        
-        # Extract the core answer
-        if ':' in answer:
-            answer = answer.split(':')[-1].strip()
-        
-        # Remove common prefixes
-        prefixes = ['The answer is', 'Based on', 'According to']
-        for prefix in prefixes:
-            if answer.lower().startswith(prefix.lower()):
-                answer = answer[len(prefix):].strip()
-                if answer.startswith(','):
-                    answer = answer[1:].strip()
-        
-        # Limit length
-        if len(answer) > 200:
-            sentences = answer.split('. ')
-            answer = sentences[0] + '.'
-        
-        # If the question expects a single value, extract it
-        if any(kw in question.lower() for kw in ["how many", "what is the", "who", "where", "give only", "provide only"]):
-            # Extract the first number, word, or phrase (tweak regex as needed)
-            match = re.search(r'^[A-Za-z0-9 ,+-]+', answer)
-            if match:
-                answer = match.group(0).strip()
-        
-        return answer
+            # It's a string or other type
+            username = str(profile)
+        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 Agent ( modify this part to create your agent)
+    try:
+        agent = GeminiAgent()
+    except Exception as e:
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+    # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(agent_code)
+
+    # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(questions_url, timeout=15) as response:
+                response.raise_for_status()
+                questions_data = await response.json()
+                if not questions_data:
+                    print("Fetched questions list is empty.")
+                    return "Fetched questions list is empty or invalid format.", None
+                print(f"Fetched {len(questions_data)} questions.")
+    except aiohttp.ClientError as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+    except ValueError as e:  # JSON decode error
+        print(f"Error decoding JSON response from questions endpoint: {e}")
+        return f"Error decoding server response for questions: {e}", None
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+    # 3. Run your Agent
+    results_log = []
+    answers_payload = []
+    print(f"Running agent on {len(questions_data)} questions...")
     
-    async def _generate_video_answer_from_question(self, question: str, video_id: str) -> str:
-        """Generate an answer for a video question based on the question content"""
-        # Create a prompt that asks Nova Pro to analyze the question and generate a likely answer
-        prompt = f"""Based on this question about YouTube video ID {video_id}, 
-        what would be the most likely accurate answer? The question is:
-        
-        {question}
-        
-        Provide only the direct answer without explanation."""
+    # Process questions one at a time to avoid rate limits
+    semaphore = asyncio.Semaphore(1)  # Process 1 question at a time
+    
+    async def process_question(item):
+        task_id = item.get("task_id")
+        question_text = item.get("question")
+        if not task_id or question_text is None:
+            print(f"Skipping item with missing task_id or question: {item}")
+            return None
         
-        try:
-            await self._rate_limit()
-            response = self.model.generate_content(
-                prompt,
-                generation_config=genai.types.GenerationConfig(
-                    max_output_tokens=100,
-                    temperature=0.0
+        async with semaphore:
+            max_retries = 3
+            for attempt in range(max_retries):
+                try:
+                    print(f"Processing task {task_id}, attempt {attempt+1}/{max_retries}")
+                    submitted_answer = await agent(question_text)
+                    return {"task_id": task_id, "submitted_answer": submitted_answer, 
+                            "log": {"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer}}
+                except Exception as e:
+                    print(f"Error running agent on task {task_id}, attempt {attempt+1}: {e}")
+                    if "rate limit" in str(e).lower() and attempt < max_retries - 1:
+                        # Exponential backoff with jitter
+                        wait_time = (2 ** attempt) * 5 + random.uniform(0, 3)
+                        print(f"Rate limit hit. Waiting {wait_time:.2f} seconds before retry...")
+                        await asyncio.sleep(wait_time)
+                    elif attempt < max_retries - 1:
+                        await asyncio.sleep(5)  # Reduced wait time
+                    else:
+                        # All retries failed, return default answer
+                        default_answer = "This is a default answer."
+                        return {"task_id": task_id, "submitted_answer": default_answer, 
+                                "log": {"Task ID": task_id, "Question": question_text, "Submitted Answer": default_answer}}
+    
+    # Create tasks for all questions
+    tasks = [process_question(item) for item in questions_data]
+    results = await asyncio.gather(*tasks)
+    
+    # Process results
+    for result in results:
+        if result is not None:
+            answers_payload.append({"task_id": result["task_id"], "submitted_answer": result["submitted_answer"]})
+            results_log.append(result["log"])
+
+    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": str(username).strip(), "agent_code": agent_code, "answers": answers_payload}
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
+
+    # 5. Submit
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(submit_url, json=submission_data, timeout=60) as response:
+                response.raise_for_status()
+                result_data = await 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.')}"
                 )
-            )
-            answer = response.text.strip()
-            
-            # Clean up the answer to make it concise
-            if len(answer) > 100:
-                sentences = answer.split('. ')
-                answer = sentences[0]
-            
-            return answer
-            
+                print("Submission successful.")
+                results_df = pd.DataFrame(results_log)
+                return final_status, results_df
+    except aiohttp.ClientResponseError as e:
+        error_detail = f"Server responded with status {e.status}."
+        try:
+            error_text = await e.response.text()
+            try:
+                error_json = await e.response.json()
+                error_detail += f" Detail: {error_json.get('detail', error_text)}"
+            except ValueError:
+                error_detail += f" Response: {error_text[:500]}"
+        except:
+            pass
+        status_message = f"Submission Failed: {error_detail}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except asyncio.TimeoutError:
+        status_message = "Submission Failed: The request timed out."
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except aiohttp.ClientError as e:
+        status_message = f"Submission Failed: Network error - {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except Exception as e:
+        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() as demo:
+    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        **Instructions:**
+        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
+        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
+        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
+        ---
+        **Disclaimers:**
+        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
+        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
+        """
+    )
+
+    login_button = gr.LoginButton()
+
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
+
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    # Removed max_rows=10 from DataFrame constructor
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+    
+    def sync_wrapper(profile):
+        # This wrapper ensures we have access to the profile
+        if not profile:
+            print("No profile available in sync_wrapper")
+            return "Please Login to Hugging Face with the button.", None
+        print(f"Profile type in wrapper: {type(profile)}")
+        try:
+            return asyncio.run(run_and_submit_all(profile))
         except Exception as e:
-            print(f"Failed to generate video answer: {str(e)}")
-            return "Video analysis unavailable."
+            print(f"Error in sync_wrapper: {e}")
+            return f"Error processing request: {e}", None
     
-    async def _rate_limit(self):
-        """Ensure minimum time between API requests"""
-        current_time = time.time()
-        time_since_last = current_time - self.last_request_time
-        if time_since_last < self.min_request_interval:
-            await asyncio.sleep(self.min_request_interval - time_since_last)
-        self.last_request_time = time.time()
+    run_button.click(
+        fn=sync_wrapper,
+        inputs=login_button,
+        outputs=[status_output, results_table]
+    )
+
+if __name__ == "__main__":
+    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    # Check for SPACE_HOST and SPACE_ID at startup for information
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+
+    if space_host_startup:
+        print(f"✅ SPACE_HOST found: {space_host_startup}")
+        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+    else:
+        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
+
+    if space_id_startup: # Print repo URLs if SPACE_ID is found
+        print(f"✅ SPACE_ID found: {space_id_startup}")
+        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
+        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+    else:
+        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+
+    print("-"*(60 + len(" App Starting ")) + "\n")
+
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=False)