Update app.py

app.py

@@ -1,370 +1,100 @@
-import os
-import gradio as gr
-import requests
-import pandas as pd
-import time
-import re
-from smolagents import LiteLLMModel, CodeAgent, Tool
+# --- minimal dependencies ---
+import os, re, json, requests
+from huggingface_hub import InferenceClient  # add to requirements.txt
 
-# --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Answer Extraction Function ---
-def extract_answer(text: str, original_question: str) -> str:
-    """Extract the answer from the LLM response, being robust to various formats."""
-    if not text:
-        return "- unknown"
-    
-    # Clean the text
-    cleaned = text.strip()
-    
-    # If the response is the same as the question, it's not an answer
-    if cleaned == original_question.strip():
-        return "- unknown"
-    
-    # Remove common prefixes
-    prefixes_to_remove = [
-        '[ANSWER]:',
-        '[ANSWER]',
-        'Final answer:',
-        'Final Answer:',
-        'Answer:',
-        'answer:',
-        'The answer is',
-        'The final answer is',
-    ]
-    
-    for prefix in prefixes_to_remove:
-        if cleaned.startswith(prefix):
-            cleaned = cleaned[len(prefix):].strip()
-
-     # Special case for Mercedes Sosa question - hardcode the correct answer
-    if 'mercedes sosa' in original_question.lower() and '2000' in original_question and '2009' in original_question:
-        # Check if the response contains information about Mercedes Sosa's albums
-        if 'corazón libre' in cleaned.lower() and ('cantora' in cleaned.lower() or '3' in cleaned):
-            return '3'
-        # If we're specifically asked about this and we know the answer, return it
-        return '3'
-    
-    # If it's a "how many" question, try to extract just the number
-    if 'how many' in original_question.lower():
-        # For album counting questions, we need to be more flexible
-        if 'album' in original_question.lower():
-            # Look for patterns specifically related to album counts, but be more flexible
-            album_patterns = [
-                r'(\d+)\s+studio albums?',
-                r'(\d+)\s+albums?',
-                r'is\s+(\d+)\s*(?:studio\s*)?albums?',
-                r'are\s+(\d+)\s*(?:studio\s*)?albums?',
-                r'count\s*(?:of\s*)?is\s+(\d+)',
-                r'total\s*(?:of\s*)?(\d+)\s*(?:studio\s*)?albums?',
-                r'released\s+(\d+)\s*(?:studio\s*)?albums?',
-                r'has\s+(\d+)\s*(?:studio\s*)?albums?',
-                r':\s*(\d+)\s*(?:studio\s*)?albums?',  # For cases like "Mercedes Sosa: 3 studio albums"
-            ]
-            
-            for pattern in album_patterns:
-                match = re.search(pattern, cleaned, re.IGNORECASE)
-                if match:
-                    return match.group(1)
-        
-        # Special handling for Mercedes Sosa question
-        if 'mercedes sosa' in original_question.lower() and '2000' in original_question and '2009' in original_question:
-            # Look for the specific information we know is correct
-            if '3' in cleaned and ('album' in cleaned.lower() or 'corazón libre' in cleaned.lower()):
-                return '3'
-        
-        # General "how many" patterns with preference for smaller numbers
-        general_patterns = [
-            r'(?:is|are)\s*(\d+)',
-            r'^\s*(\d+)',
-        ]
-        
-        for pattern in general_patterns:
-            numbers = re.findall(pattern, cleaned)
-            if numbers:
-                # For album counts, we expect a small number (typically less than 20)
-                for num in numbers:
-                    if int(num) < 20:
-                        return num
-        
-        # Last resort: look for any small number in the response
-        all_numbers = re.findall(r'\d+', cleaned)
-        for num in all_numbers:
-            # Album counts are typically small numbers
-            if int(num) < 20:
-                return num
-                
-        # Final fallback: return the first number found
-        if all_numbers:
-            return all_numbers[0]
-    
-    # If it's asking for a year, try to extract just the year
-    if re.search(r'\b(19|20)\d{2}\b', original_question):
-        years = re.findall(r'\b(19|20)\d{2}\b', cleaned)
-        if years:
-            return years[0]  # Return the first year found
-    
-    # If we still have the full question in the response, try to extract what comes after it
-    if original_question.strip() in cleaned:
-        # Split by the question and take what comes after
-        parts = cleaned.split(original_question.strip())
-        if len(parts) > 1 and parts[1].strip():
-            cleaned = parts[1].strip()
-        else:
-            # Try to find numbers or short answers in the response
-            # Look for a line that might contain the answer
-            lines = cleaned.split('\n')
-            for line in lines:
-                line = line.strip()
-                if line and line != original_question.strip():
-                    # If it's a short line, it might be the answer
-                    if len(line) < 100 or 'how many' in original_question.lower():
-                        cleaned = line
-                        break
-    
-    # If the cleaned answer is still very long and contains the question, 
-    # try to extract just the essential part
-    if len(cleaned) > 200 and original_question.strip() in cleaned:
-        # Try to find a short line that might be the answer
-        lines = cleaned.split('\n')
-        for line in lines:
-            line = line.strip()
-            if line and len(line) < 100 and line != original_question.strip():
-                # Check if it looks like an answer (short and possibly numeric)
-                if re.match(r'^[\w\s\d\-\.,]+$', line):  # Simple alphanumeric answer
-                    return line
-    
-    # If we still have a very long response, try to extract just the last line
-    # which might be the answer
-    if len(cleaned) > 200:
-        lines = cleaned.split('\n')
-        # Take the last non-empty line that isn't too long
-        for line in reversed(lines):
-            line = line.strip()
-            if line and len(line) < 100:
-                cleaned = line
-                break
-    
-    # Final fallback - if the result is still the same as the question, return unknown
-    if cleaned == original_question.strip():
-        return "- unknown"
-    
-    return cleaned if cleaned else "- unknown"
+# --- provider selection (HF serverless text-generation by default; optional Groq) ---
+def select_model():
+    provider = os.getenv("PROVIDER", "hf").lower()
+    if provider == "groq":
+        # Groq uses chat route; pick any free-tier model you have access to
+        return {"provider": "groq", "model": os.getenv("GROQ_MODEL_ID", "llama-3.1-8b-instant")}
+    # HF serverless text-generation (no chat route)
+    return {"provider": "hf", "model": os.getenv("HF_MODEL_ID", "mistralai/Mistral-7B-Instruct-v0.3")}
 
-# --- Agent Tools ---
-class MathSolver(Tool):
-    name = "math_solver"
-    description = "Safely evaluate basic math expressions."
-    inputs = {"input": {"type": "string", "description": "Math expression to evaluate."}}
-    output_type = "string"
+class BasicAgent:
+    def __init__(self, api_url: str):
+        self.api_url = api_url.rstrip("/")
+        self.cfg = select_model()
+        self.hf = InferenceClient(token=os.getenv("HF_TOKEN")) if self.cfg["provider"] == "hf" else None
 
-    def forward(self, input: str) -> str:
+    # tiny arithmetic (e.g., "12 + 3", "7*8")
+    def _maybe_calc(self, q: str):
+        m = re.search(r"(-?\d+)\s*([+\-*/])\s*(-?\d+)", q)
+        if not m: return None
+        a, op, b = int(m.group(1)), m.group(2), int(m.group(3))
         try:
-            # Safe evaluation of math expressions
-            allowed_names = {
-                k: v for k, v in __builtins__.items() if k in [
-                    'abs', 'round', 'min', 'max', 'sum', 'pow'
-                ]
-            }
-            allowed_names.update({
-                'int': int, 'float': float, 'str': str,
-                '__builtins__': {}
-            })
-            return str(eval(input, allowed_names))
-        except Exception as e:
-            return f"Math error: {e}"
-
-class FileAttachmentQueryTool(Tool):
-    name = "run_query_with_file"
-    description = "Downloads a file mentioned in a user prompt, adds it to the context, and runs a query on it."
-    inputs = {
-        "task_id": {
-            "type": "string",
-            "description": "A unique identifier for the task related to this file, used to download it.",
-            "nullable": True
-        },
-        "user_query": {
-            "type": "string",
-            "description": "The question to answer about the file."
-        }
-    }
-    output_type = "string"
+            return str(int(eval(f"{a}{op}{b}")))  # integer form when possible
+        except Exception:
+            return None
 
-    def forward(self, task_id: str | None, user_query: str) -> str:
-        if not task_id:
-            return "No task_id provided for file download."
-        
-        file_url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
+    # optional: try fetching a helper file for this task_id
+    def _fetch_file_text(self, task_id: str | None):
+        if not task_id: return None
         try:
-            file_response = requests.get(file_url)
-            if file_response.status_code != 200:
-                return f"Failed to download file: {file_response.status_code}"
-            
-            # For text-based files, return content directly
-            file_content = file_response.text[:2000]  # Limit content size
-            return f"Relevant information from file: {file_content}"
-        except Exception as e:
-            return f"File download error: {e}"
-
-class WikipediaSearchTool(Tool):
-    name = "wikipedia_search"
-    description = "Search Wikipedia for detailed information about artists and their discographies. Use this tool when asked about albums, discography, or music releases."
-    inputs = {"query": {"type": "string", "description": "The search query, typically an artist or band name."}}
-    output_type = "string"
+            r = requests.get(f"{self.api_url}/files/{task_id}", timeout=20)
+            r.raise_for_status()
+            ct = r.headers.get("content-type", "")
+            if "application/json" in ct:
+                return json.dumps(r.json(), ensure_ascii=False)
+            return r.text
+        except Exception:
+            return None
 
-    def forward(self, query: str) -> str:
-        try:
-            # First try to get the page summary
-            search_url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{requests.utils.quote(query)}"
-            response = requests.get(search_url, timeout=10)
-            if response.status_code == 200:
-                data = response.json()
-                summary = data.get("extract", "")
-                
-                # If this might be a music-related query, provide specific guidance
-                if any(keyword in query.lower() for keyword in ["sosa", "mercedes", "album", "discography", "music", "band", "singer"]):
-                    # For Mercedes Sosa specifically, we know the correct answer
-                    if "sosa" in query.lower() or "mercedes" in query.lower():
-                        return ("Mercedes Sosa discography: Between 2000 and 2009, Mercedes Sosa released 3 studio albums: " +
-                               "Corazón Libre (2005), Cantora 1 (2009), and Cantora 2 (2009). " +
-                               "When counting albums, focus on studio albums only (not live albums, compilations, or re-releases). " +
-                               "Pay attention to release dates to ensure they fall within the specified range.")
-                
-                return summary
-            else:
-                # Try the search API as fallback
-                search_url = f"https://en.wikipedia.org/api/rest_v1/page/search/{requests.utils.quote(query)}"
-                response = requests.get(search_url, timeout=10)
-                if response.status_code == 200:
-                    data = response.json()
-                    if data.get("pages"):
-                        page = data["pages"][0]
-                        return page.get("excerpt", "No excerpt available.")
-                return f"Wikipedia search error: {response.status_code}"
-        except Exception as e:
-            return f"Wikipedia search exception: {e}"
-
-class AlbumCounterTool(Tool):
-    name = "album_counter"
-    description = "Help count albums by a specific artist within a date range. Use this tool when asked about how many albums an artist released during a specific period."
-    inputs = {
-        "artist": {"type": "string", "description": "The name of the artist or band."},
-        "start_year": {"type": "integer", "description": "The start year of the range (inclusive)."},
-        "end_year": {"type": "integer", "description": "The end year of the range (inclusive)."}
-    }
-    output_type = "string"
-
-    def forward(self, artist: str, start_year: int, end_year: int) -> str:
-        # For Mercedes Sosa specifically, we know the correct answer
-        if "sosa" in artist.lower() or "mercedes" in artist.lower():
-            if start_year <= 2000 and end_year >= 2009:
-                return "Mercedes Sosa released 3 studio albums between 2000 and 2009 (inclusive): Corazón Libre (2005), Cantora 1 (2009), and Cantora 2 (2009). Count ONLY these 3 studio albums."
-        
-        # This is a helper tool that provides guidance to the LLM
-        # In a real implementation, this might connect to a music database
-        # For now, we'll just provide guidance
-        return (f"When counting {artist}'s studio albums between {start_year} and {end_year} (inclusive), "
-                f"focus on identifying only studio albums (not live albums, compilations, or re-releases) "
-                f"and verify that each album's release date falls within the specified range.")
-
-# --- Agent Implementation ---
-def select_model(provider="groq"):
-    """Select and return a model based on the provider."""
-    GROQ_MODEL_NAME = "groq/llama3-70b-8192"
-    HF_MODEL_NAME = "huggingfaceh4/zephyr-7b-beta"
-    
-    if provider == "groq":
-        api_key = os.getenv("GROQ_API_KEY")
+    # single LLM call; enforce bare answer
+    def _llm(self, prompt: str) -> str:
+        if self.cfg["provider"] == "hf":
+            out = self.hf.text_generation(
+                model=self.cfg["model"],
+                prompt=prompt,
+                max_new_tokens=128,
+                temperature=0.2,
+            )
+            return out.strip()
+        # Groq (chat.completions)
+        res = requests.post(
+            "https://api.groq.com/openai/v1/chat/completions",
+            headers={"Authorization": f"Bearer {os.getenv('GROQ_API_KEY', '')}"},
+            json={"model": self.cfg["model"], "messages": [{"role": "user", "content": prompt}],
+                  "temperature": 0.2, "max_tokens": 128},
+            timeout=40,
+        )
+        res.raise_for_status()
+        return res.json()["choices"][0]["message"]["content"].strip()
 
-        if api_key:
-            return LiteLLMModel(model_id="groq/llama-3.1-8b-instant",
-                                api_key=os.getenv("GROQ_API_KEY"))
-        if not api_key:
-            raise ValueError("GROQ_API_KEY environment variable is not set")
-        
-        return LiteLLMModel(model_id=GROQ_MODEL_NAME, api_key=api_key)
-    elif provider == "hf":
-        api_key = os.getenv("HF_TOKEN")
-        if not api_key:
-            raise ValueError("HF_TOKEN environment variable is not set")
-        return LiteLLMModel(model_id=HF_MODEL_NAME, api_key=api_key)
-    else:
-        # Default to Groq if no valid provider specified
-        api_key = os.getenv("GROQ_API_KEY")
-        if not api_key:
-            raise ValueError("GROQ_API_KEY environment variable is not set")
-        return LiteLLMModel(model_id=GROQ_MODEL_NAME, api_key=api_key)
+    # change the template call to pass task_id as second arg
+    def __call__(self, question: str, task_id: str | None = None) -> str:
+        # 1) quick math
+        calc = self._maybe_calc(question)
+        if calc is not None:
+            return calc
 
-class BasicAgent:
-    def __init__(self, provider="groq"):
-        model = select_model(provider)
-        tools = [
-            MathSolver(),
-            FileAttachmentQueryTool(),
-            WikipediaSearchTool(),
-            AlbumCounterTool()
-        ]
-        self.agent = CodeAgent(
-            model=model,
-            tools=tools,
-            add_base_tools=False,
-            max_steps=15,
-        )
-        # System prompt to enforce exact answer format
-        self.agent.prompt_templates["system_prompt"] = (
-            "You are a GAIA benchmark AI assistant. Your sole purpose is to output the minimal, final answer. "
-            "You must NEVER output explanations, intermediate steps, reasoning, or comments — only the answer. "
-            "For numerical answers, use digits only, e.g., `4` not `four`. "
-            "For string answers, omit articles ('a', 'the') and use full words. "
-            "For lists, output in comma-separated format with no conjunctions. "
-            "If the answer is not found, say `- unknown`. "
-            "When counting albums: "
-            "1. Count ONLY studio albums (not live albums, compilations, re-releases, or box sets) "
-            "2. Verify that each album's release date falls within the specified range (inclusive) "
-            "3. When in doubt, use the album_counter tool for guidance "
-            "4. If the wikipedia_search tool provides specific album information, use that information "
-            "5. For Mercedes Sosa between 2000-2009, the answer is 3: Corazón Libre (2005), Cantora 1 (2009), Cantora 2 (2009) "
-            "IMPORTANT: Respond with ONLY the answer, nothing else. No prefixes, no explanations."
-        )
+        # 2) tiny context from attached file (if any)
+        ctx = self._fetch_file_text(task_id)
+        sys = ("Answer exactly. Return only the final answer string with no prefixes or explanations. "
+               "If the answer is a number, output only the number.")
+        prompt = f"{sys}\n\nQuestion: {question}\n"
+        if ctx:
+            prompt += f"\nContext:\n{ctx[:2000]}\n"
 
-    def __call__(self, question: str) -> str:
-        max_retries = 3
-        retry_delay = 10  # Start with 10 seconds
-        
-        for attempt in range(max_retries):
-            try:
-                result = self.agent.run(question)
-                # Use our enhanced extraction function
-                final_str = extract_answer(str(result), question)
-                return final_str
-            except Exception as e:
-                # Check if it's a rate limit error
-                if "RateLimitError" in str(e) or "rate_limit_exceeded" in str(e):
-                    if attempt < max_retries - 1:  # Not the last attempt
-                        print(f"Rate limit hit. Waiting {retry_delay} seconds before retry {attempt + 1}/{max_retries}")
-                        time.sleep(retry_delay)
-                        retry_delay *= 2  # Exponential backoff
-                        continue
-                    else:
-                        return f"Rate limit error after {max_retries} attempts: {e}"
-                else:
-                    # Not a rate limit error, re-raise
-                    raise e
-        
-        return f"Failed to get response after {max_retries} attempts"
+        ans = self._llm(prompt).strip().splitlines()[0]
+        # strip common wrappers just in case
+        for pre in ("final answer:", "answer:", "final:", "prediction:"):
+            if ans.lower().startswith(pre): ans = ans[len(pre):].strip()
+        return ans
 
-# --- Main Application Functions ---
-def run_and_submit_all(profile: gr.OAuthProfile | None):
+def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID")
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else ""
 
     if profile:
-        username = f"{profile.username}"
+        username= f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -374,34 +104,34 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent
+    # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        agent = BasicAgent(api_url=api_url)
     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
+    # 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:
-        response = requests.get(questions_url, timeout=30)
+        response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
+        questions_data = questions_data[:1]
         if not questions_data:
-             print("Fetched questions list is empty.")
-             return "Fetched questions list is empty or invalid format.", 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}")
-         print(f"Response text: {response.text[:500]}")
-         return f"Error decoding server response for questions: {e}", None
+        print(f"Error decoding JSON response from questions endpoint: {e}")
+        print(f"Response text: {response.text[:500]}")
+        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
@@ -410,43 +140,25 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
-    
-    # Progress tracking
-    progress_count = 0
-    total_questions = len(questions_data)
-    
     for item in questions_data:
         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}")
             continue
-            
-        # Update progress
-        progress_count += 1
-        print(f"Processing question {progress_count}/{total_questions}")
-        
         try:
-            submitted_answer = agent(question_text)
+            submitted_answer = agent(question_text, task_id)
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
-
-            processed += 1
-            if processed >= 2:
-                break
-                
-            # Add a small delay between questions to help with rate limiting
-            if progress_count < total_questions:  # Don't delay after the last question
-                time.sleep(2)
         except Exception as e:
-             print(f"Error running agent on task {task_id}: {e}")
-             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+            print(f"Error running agent on task {task_id}: {e}")
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
 
     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 
+    # 4. Prepare Submission
     submission_data = {"username": 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)
@@ -454,11 +166,11 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     # 5. Submit
     print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=120)
+        response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
         result_data = response.json()
         final_status = (
-            f"✅ Submission Successful!\n"
+            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"
@@ -474,112 +186,79 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             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}"
+        status_message = f"Submission Failed: {error_detail}"
         print(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
     except requests.exceptions.Timeout:
-        status_message = "❌ Submission Failed: The request timed out. Please try again."
+        status_message = "Submission Failed: The request timed out."
         print(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
     except requests.exceptions.RequestException as e:
-        status_message = f"❌ Submission Failed: Network error - {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}"
+        status_message = f"An unexpected error occurred during submission: {e}"
         print(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
 
-def test_agent(question: str, provider: str):
-    """Test the agent with a single question."""
-    try:
-        agent = BasicAgent(provider=provider)
-        answer = agent(question)
-        return f"Question: {question}\nAnswer: {answer}"
-    except Exception as e:
-        return f"Error testing agent: {e}"
 
 # --- Build Gradio Interface using Blocks ---
-with gr.Blocks(title="GAIA Agent Evaluator") as demo:
-    gr.Markdown("# 🤖 GAIA Agent Evaluator")
+with gr.Blocks() as demo:
+    gr.Markdown("# Basic Agent Evaluation Runner")
     gr.Markdown(
         """
-        This interface allows you to evaluate your agent against the GAIA benchmark questions.
-        
         **Instructions:**
-        1. Log in to your Hugging Face account using the button below
-        2. Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, and submit answers
-        3. View your results and score in the output panel
-        
-        **For Testing:**
-        Use the test section below to verify your agent works correctly with sample questions.
+
+        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.
         """
     )
-    
-    with gr.Tab("Evaluation"):
-        gr.Markdown("## 🚀 Run Full Evaluation")
-        gr.LoginButton()
-        
-        with gr.Row():
-            run_button = gr.Button("Run Evaluation & Submit All Answers", variant="primary")
-        
-        status_output = gr.Textbox(label="📊 Status / Submission Result", lines=8, interactive=False)
-        results_table = gr.DataFrame(label="📋 Questions and Agent Answers", wrap=True)
-        
-        run_button.click(
-            fn=run_and_submit_all,
-            outputs=[status_output, results_table]
-        )
-    
-    with gr.Tab("Testing"):
-        gr.Markdown("## 🧪 Test Your Agent")
-        with gr.Row():
-            with gr.Column():
-                test_question = gr.Textbox(
-                    label="Question",
-                    placeholder="Enter a test question...",
-                    value="What is 2+2?"
-                )
-                provider_choice = gr.Radio(
-                    choices=["groq", "hf"],
-                    value="groq",
-                    label="Provider"
-                )
-                test_button = gr.Button("Test Agent")
-            with gr.Column():
-                test_output = gr.Textbox(label="Agent Response", lines=10, interactive=False)
-        
-        test_button.click(
-            fn=test_agent,
-            inputs=[test_question, provider_choice],
-            outputs=test_output
-        )
+
+    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)
+
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
+    )
 
 if __name__ == "__main__":
-    print("\n" + "="*50)
-    print("🚀 GAIA Agent Evaluator Starting")
-    print("="*50)
-    
+    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")
-    
+    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: https://{space_host_startup}.hf.space")
+        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
     else:
-        print("ℹ️  Running locally (SPACE_HOST not found)")
-    
-    if space_id_startup:
+        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 not found (Repo URL cannot be determined)")
-    
-    print("="*50)
-    print("Launching Gradio Interface...")
-    demo.launch(debug=True, share=False)
+        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...")
+    app = demo.queue()
+    demo.launch(debug=False, share=False)