Update app.py

app.py

@@ -1,672 +1,66 @@
 import os
 import gradio as gr
 import requests
+import inspect
 import pandas as pd
-import re
-import json
-import time
-from urllib.parse import quote
-import wikipedia
-from bs4 import BeautifulSoup
-import random
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline
 
+# (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-class EnhancedAgent:
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+from transformers import pipeline
+
+class BasicAgent:
     def __init__(self):
-        print("Loading models and tools...")
-        # Load a stronger model
-        self.model_name = "google/flan-t5-xl"  # Stronger model than base
-        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-        
+        print("Loading flan-t5-base model...")
         self.pipeline = pipeline(
             "text2text-generation",
-            model=self.model_name,
-            max_new_tokens=256,
-            temperature=0.1,  # Lower temperature for more deterministic responses
+            model="google/flan-t5-base",
+            max_new_tokens=128,
+            temperature=0.3
+        )
+        print("Model loaded.")
+
+    def __call__(self, question: str) -> str:
+        print(f"Received question: {question[:60]}...")
+
+        few_shot_example = (
+            "Question: List just the vegetables from [milk, eggs, carrots, onions, cookies].\n"
+            "Answer: carrots, onions\n\n"
+        )
+
+        prompt = (
+            few_shot_example +
+            "Please solve the following step by step and return only the final answer:\n"
+            f"{question}"
         )
-        
-        # Set up Wikipedia API
-        wikipedia.set_lang("en")
-        print("Models and tools loaded.")
 
-    def __call__(self, question: str, task_id: str = None) -> str:
-        """Main entry point for handling questions"""
-        try:
-            print(f"\n==== Processing question: {question} ====")
-            # Preprocess question
-            question_lower = question.lower()
-            
-            # Detect question type and route to appropriate handler
-            if self.is_reverse_text_question(question_lower):
-                return self.handle_reverse_text(question)
-            elif self.is_wikipedia_question(question_lower):
-                return self.handle_wikipedia_question(question)
-            elif self.is_youtube_question(question_lower):
-                return self.handle_youtube_question(question)
-            elif self.is_file_processing_question(question_lower):
-                return self.handle_file_processing(question, task_id)
-            elif self.is_counting_question(question_lower):
-                return self.handle_counting_question(question)
-            elif self.is_math_question(question_lower):
-                return self.handle_math_question(question)
-            else:
-                # General reasoning for other questions
-                return self.handle_general_reasoning(question)
-        except Exception as e:
-            print(f"Error processing question: {str(e)}")
-            # Fall back to model-based answer on error
-            return self.simplified_model_response(question)
-    
-    def is_reverse_text_question(self, question_lower):
-        """Check if this is a text reversal question"""
-        reverse_patterns = [
-            "write the opposite", 
-            "reverse", 
-            "backwards",
-            ".rewsna",  # "answer." backwards
-            "etirw",    # "write" backwards
-            "esrever"   # "reverse" backwards
-        ]
-        return any(pattern in question_lower for pattern in reverse_patterns)
-    
-    def is_wikipedia_question(self, question_lower):
-        """Check if this is a Wikipedia-related question"""
-        return "wikipedia" in question_lower
-    
-    def is_youtube_question(self, question_lower):
-        """Check if this is a YouTube-related question"""
-        return "youtube" in question_lower or "video" in question_lower
-    
-    def is_file_processing_question(self, question_lower):
-        """Check if this question requires file processing"""
-        file_indicators = ["excel", "spreadsheet", "file", "csv", "attached"]
-        return any(indicator in question_lower for indicator in file_indicators)
-    
-    def is_counting_question(self, question_lower):
-        """Check if this is a counting question"""
-        counting_indicators = ["how many", "count", "number of"]
-        return any(indicator in question_lower for indicator in counting_indicators)
-    
-    def is_math_question(self, question_lower):
-        """Check if this is a math question"""
-        math_indicators = ["calculate", "sum", "multiply", "divide", "subtract", "add", "equals"]
-        return any(indicator in question_lower for indicator in math_indicators)
-    
-    def handle_reverse_text(self, question):
-        """Handle text reversal questions"""
-        # Check for backwards text first
-        if ".rewsna" in question.lower():
-            # The question itself is backwards, so we need to figure out what it's asking
-            reversed_query = question[::-1].strip()
-            print(f"Detected backwards question. Reversed: {reversed_query}")
-            
-            # Common pattern in GAIA: "If you understand this sentence, write the opposite of the word 'left' as the answer."
-            if "opposite" in reversed_query.lower() and "word" in reversed_query.lower():
-                match = re.search(r"opposite of the word ['\"](\w+)['\"]", reversed_query, re.IGNORECASE)
-                if match:
-                    word = match.group(1)
-                    opposites = {
-                        "left": "right",
-                        "right": "left",
-                        "up": "down",
-                        "down": "up",
-                        "yes": "no",
-                        "no": "yes",
-                        "true": "false",
-                        "false": "true",
-                        "hot": "cold",
-                        "cold": "hot",
-                        "open": "closed",
-                        "closed": "open",
-                        "on": "off",
-                        "off": "on"
-                    }
-                    return opposites.get(word.lower(), f"opposite of {word}")
-        
-        # For "write the opposite" type questions
-        if "write the opposite" in question.lower():
-            # Find the word to get the opposite of
-            match = re.search(r"opposite of (?:the word )?['\"](\w+)['\"]", question, re.IGNORECASE)
-            if match:
-                word = match.group(1)
-                opposites = {
-                    "left": "right",
-                    "right": "left",
-                    "up": "down",
-                    "down": "up",
-                    "yes": "no",
-                    "no": "yes",
-                    "true": "false",
-                    "false": "true",
-                    "hot": "cold",
-                    "cold": "hot",
-                    "open": "closed",
-                    "closed": "open",
-                    "on": "off",
-                    "off": "on"
-                }
-                return opposites.get(word.lower(), f"opposite of {word}")
-        
-        # Simple string reversal
-        if "reverse" in question.lower() and not "opposite" in question.lower():
-            # Extract potential text to reverse
-            text_to_reverse = re.sub(r'reverse the string |reverse |reverse this: ', '', question, flags=re.IGNORECASE).strip()
-            
-            # If the text contains instructions, try to isolate just the text to reverse
-            if len(text_to_reverse.split()) > 5:  # Heuristic: if too many words, look for quotes
-                quoted_text = re.search(r'[\'\"](.*?)[\'\"]', question)
-                if quoted_text:
-                    text_to_reverse = quoted_text.group(1)
-            
-            # Perform the reversal
-            return text_to_reverse[::-1].strip()
-        
-        # If we're unsure, use the LLM to help determine what to reverse
-        prompt = f"Extract the exact text that needs to be reversed from this instruction: {question}"
-        text_to_reverse = self.pipeline(prompt)[0]["generated_text"].strip()
-        return text_to_reverse[::-1].strip()
-    
-    def handle_wikipedia_question(self, question):
-        """Handle Wikipedia-related questions"""
-        # Extract query terms from question
-        query_terms = self.extract_wikipedia_query(question)
-        
-        try:
-            # Parse year range if present
-            year_range = self.extract_year_range(question)
-            
-            if "studio albums" in question.lower() and year_range:
-                # This is likely about counting albums in a date range
-                artist_name = self.extract_artist_name(question)
-                if artist_name:
-                    return self.count_albums_in_range(artist_name, year_range)
-            
-            # Search Wikipedia
-            print(f"Searching Wikipedia for: {query_terms}")
-            search_results = wikipedia.search(query_terms, results=3)
-            
-            if not search_results:
-                return "No Wikipedia results found."
-            
-            try:
-                # Get full page content
-                wiki_page = wikipedia.page(search_results[0], auto_suggest=False)
-                content = wiki_page.content
-                
-                # Process for specific question types
-                if "how many" in question.lower():
-                    return self.extract_count_from_wikipedia(question, content)
-                else:
-                    # For general info questions, summarize relevant information
-                    prompt = f"Based on this Wikipedia content about {search_results[0]}, answer the question: {question}\n\nWikipedia content: {content[:4000]}..."
-                    answer = self.pipeline(prompt)[0]["generated_text"].strip()
-                    
-                    # Clean up the answer to be concise
-                    if len(answer.split()) > 20:
-                        prompt = f"Provide a very concise answer (1-3 words if possible) to: {question}\nBased on: {answer}"
-                        answer = self.pipeline(prompt)[0]["generated_text"].strip()
-                    
-                    return answer
-            except wikipedia.exceptions.DisambiguationError as e:
-                # Handle disambiguation by picking the first option
-                try:
-                    wiki_page = wikipedia.page(e.options[0], auto_suggest=False)
-                    content = wiki_page.content
-                    prompt = f"Based on this Wikipedia content, answer the question: {question}\n\nWikipedia content: {content[:4000]}..."
-                    return self.pipeline(prompt)[0]["generated_text"].strip()
-                except:
-                    return "Could not resolve Wikipedia disambiguation."
-            
-        except Exception as e:
-            print(f"Wikipedia error: {str(e)}")
-            return self.simplified_model_response(question)
-    
-    def extract_artist_name(self, question):
-        """Extract artist name from studio albums question"""
-        # Try to identify artist name in album-related questions
-        artist_patterns = [
-            r"by ([A-Za-z\s]+) between",
-            r"were published by ([A-Za-z\s]+)",
-            r"albums (?:did|were) ([A-Za-z\s]+) (?:publish|release)"
-        ]
-        
-        for pattern in artist_patterns:
-            match = re.search(pattern, question)
-            if match:
-                return match.group(1).strip()
-        
-        # If no match, ask the model to extract
-        prompt = f"Extract only the artist name from this question: {question}"
-        return self.pipeline(prompt)[0]["generated_text"].strip()
-    
-    def count_albums_in_range(self, artist_name, year_range):
-        """Count studio albums in a year range for an artist"""
-        try:
-            start_year, end_year = year_range
-            
-            # Search for the artist
-            search_results = wikipedia.search(f"{artist_name} discography", results=3)
-            
-            # Try the first few search results
-            for result in search_results:
-                try:
-                    wiki_page = wikipedia.page(result, auto_suggest=False)
-                    content = wiki_page.content
-                    
-                    # Look for studio albums section
-                    sections = ["Studio albums", "Discography", "Albums"]
-                    relevant_content = content
-                    
-                    # Use regular expressions to find albums with years
-                    albums_pattern = r"(?:Album|album|Studio album).*?\((\d{4})\)"
-                    album_years = re.findall(albums_pattern, relevant_content)
-                    
-                    # Count albums in range
-                    count = 0
-                    for year_str in album_years:
-                        try:
-                            year = int(year_str)
-                            if start_year <= year <= end_year:
-                                count += 1
-                        except ValueError:
-                            continue
-                    
-                    if count > 0:
-                        return str(count)
-                    
-                except Exception as e:
-                    continue
-            
-            # If we couldn't find it in Wikipedia, try a model-based approach
-            prompt = f"How many studio albums did {artist_name} release between {start_year} and {end_year}, inclusive? Give only the number."
-            return self.pipeline(prompt)[0]["generated_text"].strip()
-            
-        except Exception as e:
-            print(f"Error counting albums: {str(e)}")
-            return "0"  # Default fallback
-    
-    def extract_wikipedia_query(self, question):
-        """Extract search terms for Wikipedia from the question"""
-        # Remove common phrases that wouldn't help the search
-        query = question.lower()
-        for phrase in ["according to wikipedia", "using wikipedia", "on wikipedia", "in wikipedia", "from wikipedia", "search wikipedia for", "look up on wikipedia"]:
-            query = query.replace(phrase, "")
-        
-        # Get the main entity or topic
-        prompt = f"Extract the main entity or topic to search on Wikipedia from this question: {query}"
-        result = self.pipeline(prompt)[0]["generated_text"].strip()
-        
-        return result
-    
-    def extract_year_range(self, question):
-        """Extract year range from question if present"""
-        # Look for patterns like "between 2000 and 2009" or "from 2000 to 2009"
-        range_patterns = [
-            r"between (\d{4}) and (\d{4})",
-            r"from (\d{4}) to (\d{4})",
-            r"(\d{4})-(\d{4})",
-            r"(\d{4}) to (\d{4})"
-        ]
-        
-        for pattern in range_patterns:
-            match = re.search(pattern, question)
-            if match:
-                start_year = int(match.group(1))
-                end_year = int(match.group(2))
-                return (start_year, end_year)
-        
-        return None
-    
-    def extract_count_from_wikipedia(self, question, content):
-        """Extract count information from Wikipedia content"""
-        # What are we counting?
-        count_object = re.search(r"how many ([^?]+)", question.lower())
-        if count_object:
-            object_type = count_object.group(1).strip()
-            
-            # Try to extract with the model
-            relevant_excerpt = content[:8000]  # Limit context size
-            prompt = f"Based on this Wikipedia content, answer the question: {question}\n\nWikipedia content: {relevant_excerpt}"
-            answer = self.pipeline(prompt)[0]["generated_text"].strip()
-            
-            # Try to extract just the number
-            number_match = re.search(r'\d+', answer)
-            if number_match:
-                return number_match.group(0)
-            else:
-                return answer
-        
-        return "Unable to determine count from Wikipedia."
-    
-    def handle_youtube_question(self, question):
-        """Handle YouTube-related questions"""
-        # Extract YouTube URL if present
-        youtube_url_match = re.search(r'(https?://(?:www\.)?youtube\.com/watch\?v=[a-zA-Z0-9_-]+)', question)
-        
-        if youtube_url_match:
-            youtube_url = youtube_url_match.group(1)
-            
-            # Based on the question, extract what we need to find in the video
-            if "highest number" in question.lower() and "bird" in question.lower():
-                # This is a specific GAIA question about counting birds in a video
-                # Since we can't actually watch the video, make an educated guess based on common patterns
-                print(f"YouTube video question about bird count: {youtube_url}")
-                return "4"  # A reasonable guess for bird count
-            
-            elif "title" in question.lower():
-                # Question about the video title
-                return self.get_youtube_title_estimation(youtube_url)
-            
-            else:
-                # Try to parse what the question is asking about the video
-                prompt = f"What specifically is this question asking about the YouTube video? Question: {question}"
-                aspect = self.pipeline(prompt)[0]["generated_text"].strip()
-                
-                if "duration" in aspect.lower() or "length" in aspect.lower():
-                    # Estimate a reasonable video length
-                    return "10:42"
-                elif "view" in aspect.lower():
-                    # Estimate view count
-                    return "2,547,931"
-                elif "upload" in aspect.lower() or "date" in aspect.lower():
-                    # Estimate upload date
-                    return "2019-05-15"
-                else:
-                    # Fallback - extract the most likely answer format from the question
-                    return self.extract_likely_format(question)
-        
-        return "Unable to process YouTube video information."
-    
-    def get_youtube_title_estimation(self, youtube_url):
-        """Estimate a YouTube video title based on URL"""
-        # Extract video ID
-        video_id_match = re.search(r'v=([a-zA-Z0-9_-]+)', youtube_url)
-        if not video_id_match:
-            return "Unable to determine video title"
-        
-        # Since we can't actually fetch the video, make a reasonable guess
-        video_id = video_id_match.group(1)
-        if "L1vXCYZAYYM" in video_id:  # The specific video ID from the example
-            return "Amazing Bird Feeder Compilation"
-        
-        # Generic response for other videos
-        return "Bird Watching - Amazing Compilation"
-    
-    def handle_file_processing(self, question, task_id):
-        """Handle file processing questions"""
-        if not task_id:
-            return "No file provided for processing."
-        
         try:
-            # Get the file URL
-            file_url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
-            
-            # Determine what to do with the file based on the question
-            if "excel" in question.lower() or "spreadsheet" in question.lower():
-                # Process Excel file
-                return self.process_excel_file(file_url, question)
-            elif "csv" in question.lower():
-                # Process CSV file
-                return self.process_csv_file(file_url, question)
+            response = self.pipeline(prompt)[0]["generated_text"]
+            if "Answer:" in response:
+                answer = response.strip().split("Answer:")[-1].strip().split("\n")[0]
             else:
-                # Try to determine the file type from the question
-                return self.process_generic_file(file_url, question)
-        
+                answer = response.strip().split("\n")[0]
         except Exception as e:
-            print(f"File processing error: {str(e)}")
-            return f"Error processing file: {str(e)}"
-    
-    def process_excel_file(self, file_url, question):
-        """Process Excel file for analysis"""
-        try:
-            df = pd.read_excel(file_url)
-            
-            # Determine what analysis to perform based on the question
-            if "sales" in question.lower() and "food" in question.lower():
-                # Looking for food sales
-                food_sales = df[df["category"].str.lower() == "food"]["sales"].sum()
-                return f"${food_sales:.2f}"
-            
-            elif "sum" in question.lower() or "total" in question.lower():
-                # Summing a column
-                column_to_sum = self.determine_column_to_sum(question, df.columns)
-                if column_to_sum:
-                    total = df[column_to_sum].sum()
-                    return f"{total:.2f}"
-                
-            elif "average" in question.lower() or "mean" in question.lower():
-                # Computing an average
-                column_to_avg = self.determine_column_to_sum(question, df.columns)
-                if column_to_avg:
-                    avg = df[column_to_avg].mean()
-                    return f"{avg:.2f}"
-                
-            elif "count" in question.lower() or "how many" in question.lower():
-                # Counting records
-                filter_column = self.determine_filter_column(question, df.columns)
-                filter_value = self.determine_filter_value(question)
-                
-                if filter_column and filter_value:
-                    count = len(df[df[filter_column].astype(str).str.lower() == filter_value.lower()])
-                    return str(count)
-                else:
-                    # Just count all records
-                    return str(len(df))
-            
-            # If we couldn't determine the operation, try a general approach
-            prompt = f"Based on this Excel file data, answer the question: {question}\n\nExcel data (first 10 rows): {df.head(10).to_string()}"
-            return self.pipeline(prompt)[0]["generated_text"].strip()
-            
-        except Exception as e:
-            print(f"Excel processing error: {str(e)}")
-            return "Error processing Excel file."
-    
-    def determine_column_to_sum(self, question, columns):
-        """Determine which column to sum based on the question"""
-        # Check for column names in the question
-        for column in columns:
-            if column.lower() in question.lower():
-                return column
-        
-        # Common financial columns
-        financial_columns = ["sales", "revenue", "price", "cost", "amount", "value"]
-        for column in columns:
-            if any(fin_col in column.lower() for fin_col in financial_columns):
-                return column
-        
-        # First numeric column as a fallback
-        return columns[0]
-    
-    def determine_filter_column(self, question, columns):
-        """Determine which column to filter on based on the question"""
-        # Check for column names in the question
-        for column in columns:
-            if column.lower() in question.lower():
-                return column
-        
-        # Common categorical columns
-        category_columns = ["category", "type", "name", "product", "department"]
-        for column in columns:
-            if any(cat_col in column.lower() for cat_col in category_columns):
-                return column
-        
-        # First column as a fallback
-        return columns[0]
-    
-    def determine_filter_value(self, question):
-        """Determine what value to filter for based on the question"""
-        # Common categories in questions
-        categories = ["food", "electronics", "clothing", "books", "furniture"]
-        for category in categories:
-            if category.lower() in question.lower():
-                return category
-        
-        # Try to extract the value from the question
-        value_match = re.search(r'where (\w+) is (\w+)', question.lower())
-        if value_match:
-            return value_match.group(2)
-        
-        return None
-    
-    def process_csv_file(self, file_url, question):
-        """Process CSV file for analysis"""
-        # Very similar to Excel processing, but using read_csv
-        try:
-            df = pd.read_csv(file_url)
-            
-            # Use the same analysis logic as Excel
-            return self.process_excel_file(file_url, question)
-            
-        except Exception as e:
-            print(f"CSV processing error: {str(e)}")
-            return "Error processing CSV file."
-    
-    def process_generic_file(self, file_url, question):
-        """Process a file when the type isn't clear"""
-        try:
-            # Try Excel first
-            try:
-                return self.process_excel_file(file_url, question)
-            except:
-                # Then try CSV
-                try:
-                    return self.process_csv_file(file_url, question)
-                except:
-                    return "Unable to process the file - format not recognized."
-        except Exception as e:
-            print(f"Generic file processing error: {str(e)}")
-            return "Error processing file."
-    
-    def handle_counting_question(self, question):
-        """Handle counting questions"""
-        # Extract what needs to be counted
-        count_match = re.search(r'how many ([^?\.]+)', question.lower())
-        if count_match:
-            count_object = count_match.group(1).strip()
-            
-            # Special case for specific counting tasks
-            if "letters" in count_object:
-                # Count letters in a text
-                text_to_count = self.extract_text_to_count(question)
-                if text_to_count:
-                    # Count only alphabetic characters
-                    letter_count = sum(c.isalpha() for c in text_to_count)
-                    return str(letter_count)
-            
-            elif "words" in count_object:
-                # Count words in a text
-                text_to_count = self.extract_text_to_count(question)
-                if text_to_count:
-                    # Split by whitespace and count non-empty strings
-                    word_count = len([w for w in text_to_count.split() if w])
-                    return str(word_count)
-            
-            elif "vowels" in count_object:
-                # Count vowels in a text
-                text_to_count = self.extract_text_to_count(question)
-                if text_to_count:
-                    vowel_count = sum(c.lower() in 'aeiou' for c in text_to_count)
-                    return str(vowel_count)
-        
-        # Fall back to the model for answering
-        return self.simplified_model_response(question)
-    
-    def extract_text_to_count(self, question):
-        """Extract the text in which to count letters/words/etc."""
-        # Look for text in quotes
-        quoted_text = re.search(r'[\'\"](.*?)[\'\"]', question)
-        if quoted_text:
-            return quoted_text.group(1)
-        
-        # Look for "in the text" or "in the string" followed by the text
-        text_match = re.search(r'in the (?:text|string|sentence|phrase|word):?\s*([^?\.]+)', question, re.IGNORECASE)
-        if text_match:
-            return text_match.group(1).strip()
-        
-        # Look for text after "how many letters/words in"
-        following_text = re.search(r'how many (?:letters|words|characters|vowels) in\s*([^?\.]+)', question, re.IGNORECASE)
-        if following_text:
-            return following_text.group(1).strip()
-        
-        return None
-    
-    def handle_math_question(self, question):
-        """Handle mathematical questions"""
-        # Check if it's a simple calculation
-        calculation_match = re.search(r'(\d+)\s*([+\-*/])\s*(\d+)', question)
-        if calculation_match:
-            num1 = int(calculation_match.group(1))
-            operator = calculation_match.group(2)
-            num2 = int(calculation_match.group(3))
-            
-            if operator == '+':
-                return str(num1 + num2)
-            elif operator == '-':
-                return str(num1 - num2)
-            elif operator == '*':
-                return str(num1 * num2)
-            elif operator == '/':
-                if num2 == 0:
-                    return "Division by zero error"
-                return str(num1 / num2)
-        
-        # Extract numbers from the question for more complex calculations
-        numbers = re.findall(r'\d+', question)
-        if numbers and ("sum" in question.lower() or "add" in question.lower()):
-            total = sum(int(num) for num in numbers)
-            return str(total)
-        
-        # Fall back to the model
-        return self.simplified_model_response(question)
-    
-    def handle_general_reasoning(self, question):
-        """Handle general reasoning questions"""
-        # Use the model for general reasoning questions
-        return self.simplified_model_response(question)
-    
-    def simplified_model_response(self, question):
-        """Get a simplified response from the model"""
-        # Add instructions to keep it concise and direct
-        prompt = f"Answer this question with only the essential information. Be very concise and direct:\n{question}"
-        result = self.pipeline(prompt)[0]["generated_text"].strip()
-        
-        # Clean up the result
-        result = re.sub(r'^(Answer:|The answer is:|Answer is:)\s*', '', result)
-        
-        # If it's still verbose, try extracting just the key information
-        if len(result.split()) > 10:
-            # Try to extract just a few words
-            prompt = f"Extract just the direct answer in as few words as possible from: {result}"
-            result = self.pipeline(prompt)[0]["generated_text"].strip()
-        
-        return result.strip()
-    
-    def extract_likely_format(self, question):
-        """Try to extract the most likely format for the answer based on the question"""
-        if "date" in question.lower() or "when" in question.lower():
-            return "2023-09-15"
-        elif "percentage" in question.lower() or "percent" in question.lower():
-            return "42%"
-        elif "number" in question.lower() or "count" in question.lower() or "how many" in question.lower():
-            return "7"
-        elif "name" in question.lower() or "who" in question.lower():
-            return "John Smith"
-        else:
-            return "Unknown"
+            print(f"Model error: {e}")
+            answer = "[Error generating answer]"
 
+        print(f"Final answer: {answer}")
+        return answer
 
-def run_and_submit_all(profile: gr.OAuthProfile | None):
+
+def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the EnhancedAgent on them, submits all answers,
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
-    space_id = os.getenv("SPACE_ID")  # Get the SPACE_ID for sending link to the code
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
 
     if profile:
-        username = f"{profile.username}"
+        username= f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -676,13 +70,13 @@ 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 = EnhancedAgent()
+        agent = BasicAgent()
     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)
 
@@ -693,16 +87,16 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         response.raise_for_status()
         questions_data = response.json()
         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
@@ -718,7 +112,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text, task_id=task_id)
+            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, "Submitted Answer": submitted_answer})
         except Exception as e: