Update app.py

app.py

@@ -4,7 +4,6 @@ import requests
 import pandas as pd
 import logging
 import time
-import json
 from datetime import datetime
 from typing import Dict, List, Optional, Any
 from dataclasses import dataclass
@@ -45,46 +44,17 @@ logging.info(f"📂 Log file configured at: {log_path}")
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# Patterns for extracting the final answer from agent output
+# Answer extraction patterns
 ANSWER_PATTERNS = [
-    r"the answer is:\s*(.*)", 
-    r"final_answer\((.*)\)", 
-    r"final_answer\(\s*\"(.*?)\"\s*\)",
-    r"final_answer\(\s*'(.*?)'\s*\)", 
-    r"final_answer\(\s*```(.*?)```\s*\)",
-    r"final_answer\(\s*`(.*?)`\s*\)", 
-    r"final_answer\(\s*\[(.*?)\]\s*\)",
-    r"final_answer\(\s*\{(.*?)\}\s*\)", 
-    r"final_answer\(\s*(.*?)\s*\)",
-    r"answer is\s*(.*)", 
-    r"final answer is\s*(.*)", 
-    r"final answer:\s*(.*)",
-    r"final answer of the question is:\s*(.*)", 
-    r"the final answer is:\s*(.*)",
-    r"final answer\s*:\s*(.*)", 
-    r"final_answer\s*:\s*(.*)", 
-    r"final_answer is\s*(.*)",
-    r"the value is:\s*(.*)", 
-    r"The final answer is: (.*)",
-    r"final answer of the question is (.*)", 
-    r"final answer to the question is (.*)",
-    r"final response: (.*)", 
-    r"Final Response: (.*)", 
-    r"the final response is (.*)",
-    r"Final Response is: (.*)", 
-    r"Final Answer:\s*(.*)", 
-    r"Final Answer is:\s*(.*)",
-    r"Answer:\s*(.*)", 
-    r"The answer is:\s*(.*)", 
-    r"Final Answer\s*\[([^\]]+)\]",
-    r"The final answer is\s*\[([^\]]+)\]", 
-    r"The answer is\s*\[([^\]]+)\]",
-    r"Answer\s*\[([^\]]+)\]", 
-    r"```json\n\{\"answer\":\s*\"(.*?)\"\n\}```",
-    r"```json\n\{\"answer\":\s*(.*?)\n\}```", 
-    r"\"answer\":\s*\"(.*?)\"",
-    r"\"answer\":\s*(.*)", 
-    r"(\w[\w\s\.\-,\/]*)\s*$",  # Broad pattern to catch simple answers at the end
+    r"the answer is:\s*(.*)", r"final_answer\((.*)\)", r"final_answer\(\s*\"(.*?)\"\s*\)",
+    r"final_answer\(\s*'(.*?)'\s*\)", r"final_answer\(\s*```(.*?)```\s*\)",
+    r"final_answer\(\s*`(.*?)`\s*\)", r"final_answer\(\s*\[(.*?)\]\s*\)",
+    r"final_answer\(\s*\{(.*?)\}\s*\)", r"final_answer\(\s*(.*?)\s*\)",
+    r"answer is\s*(.*)", r"final answer is\s*(.*)", r"final answer:\s*(.*)",
+    r"final answer of the question is:\s*(.*)", r"the final answer is:\s*(.*)",
+    r"final answer\s*:\s*(.*)", r"final_answer\s*:\s*(.*)", r"final_answer is\s*(.*)",
+    r"Final Answer:\s*(.*)", r"Final Answer is:\s*(.*)",
+    r"Answer:\s*(.*)", r"The answer is:\s*(.*)",
 ]
 
 @dataclass
@@ -96,618 +66,122 @@ class QuestionLog:
     processing_time: float
     status: str
 
-# --- SimpleAgent Class ---
-class SimpleAgent:
+# --- SmartAgent Class (Fixed Version) ---
+class SmartAgent:
     def __init__(self, username: str, http_session: requests.Session):
         self.username = username
         self.http_session = http_session
         self.client = None
-        self.pipelines = {}
-        logging.info("SimpleAgent initialized.")
+        self.text_generator = None
+        logging.info("SmartAgent initialized.")
 
     def setup(self):
-        """Initialize the inference client"""
         logging.info("Setting up agent...")
         try:
-            # Use the HuggingFace pipeline approach instead of InferenceClient
-            # This should work more reliably with your token
-            logging.info("Trying pipeline approach for text generation...")
+            # Use pipeline approach (more reliable than InferenceClient)
+            logging.info("Initializing text generation pipeline...")
+            self.text_generator = pipeline(
+                "text-generation", 
+                model="gpt2",
+                tokenizer="gpt2",
+                device=-1  # Use CPU
+            )
+            self.client = "pipeline"
+            logging.info("✅ Successfully initialized with GPT-2 pipeline")
             
-            try:
-                # Try to load a simple text generation pipeline
-                self.text_generator = pipeline(
-                    "text-generation", 
-                    model="gpt2",
-                    tokenizer="gpt2",
-                    device=-1  # Use CPU
-                )
-                self.client = "pipeline"  # Flag that we're using pipeline
-                logging.info("✅ Successfully initialized with pipeline and gpt2")
-                
-                # Test it
-                test_output = self.text_generator("Hello", max_new_tokens=3, do_sample=False)
-                logging.info(f"Pipeline test successful: {test_output}")
-                
-            except Exception as pipeline_error:
-                logging.warning(f"Pipeline approach failed: {pipeline_error}")
-                
-                # Fallback to InferenceClient with specific working models
-                logging.info("Falling back to InferenceClient with simpler approach...")
-                
-                # Try just the basic InferenceClient without specifying model
-                self.client = InferenceClient()
-                logging.info("✅ Using basic InferenceClient (will handle model selection)")
-                
+            # Test the pipeline
+            test_output = self.text_generator("Hello", max_new_tokens=3, do_sample=False)
+            logging.info(f"Pipeline test successful: {test_output}")
             logging.info("Agent setup complete.")
             
         except Exception as e:
             logging.exception(f"Error during agent setup: {e}")
-            # Instead of failing completely, set up a basic fallback
-            logging.warning("All LLM approaches failed, using fallback mode")
+            # Fallback to basic mode
             self.client = "fallback"
-            logging.info("Agent setup complete in fallback mode.")
+            logging.warning("Using fallback mode")
 
     def __call__(self, question: str, question_type: str, tools_code: Optional[List[Dict]] = None) -> str:
         """Main method to process a question and return an answer"""
-        if not self.client:
-            raise ValueError("Agent not initialized. Call setup() first.")
+        logging.info(f"Processing question type '{question_type}': {question[:50]}...")
         
         try:
-            # Check if the question mentions an attached file
-            has_attachment = "Attached file available at:" in question
-            
-            logging.info(f"Sending prompt to model (first 200 chars): Question: {question[:200]}...")
-            logging.info(f"Full question length: {len(question)} characters")
-            
-            # Try different LLM approaches based on what's available
-            try:
-                logging.info("Attempting LLM call...")
-                
-                if self.client == "pipeline":
-                    # Use the transformers pipeline with optimized parameters
-                    logging.info("Using pipeline approach...")
-                    
-                    # Create a general prompt that encourages direct, factual answers for any question
-                    if "how many" in question.lower():
-                        simple_prompt = f"{question} Answer with a number only:"
-                    elif "what is" in question.lower() or "what are" in question.lower():
-                        simple_prompt = f"{question} Answer briefly and factually:"
-                    elif "who" in question.lower():
-                        simple_prompt = f"{question} Answer with the name only:"
-                    elif "where" in question.lower():
-                        simple_prompt = f"{question} Answer with the location only:"
-                    elif "when" in question.lower():
-                        simple_prompt = f"{question} Answer with the date/time only:"
-                    elif "which" in question.lower():
-                        simple_prompt = f"{question} Answer with the specific item only:"
-                    elif question.strip().endswith("?"):
-                        simple_prompt = f"{question} Give a direct, factual answer:"
-                    else:
-                        simple_prompt = f"{question} Provide a brief, factual response:"
-                    
-                    logging.info(f"General prompt pattern: {simple_prompt[:100]}...")
-                    
-                    outputs = self.text_generator(
-                        simple_prompt,
-                        max_new_tokens=15,   # Very short for factual answers
-                        temperature=0.8,     # More creative
-                        do_sample=True,
-                        pad_token_id=50256,
-                        eos_token_id=50256,
-                        truncation=True,
-                        repetition_penalty=1.2,  # Stronger repetition penalty
-                        return_full_text=False
-                    )
-                    
-                    # Better extraction of generated text
-                    if isinstance(outputs, list) and len(outputs) > 0:
-                        full_text = outputs[0]['generated_text']
-                        # Clean up the response more thoroughly
-                        response = full_text.replace(simple_prompt, "").strip()
-                        
-                        # Remove common artifacts
-                        response = re.sub(r'^[A-Za-z]:', '', response)  # Remove "A:" at start
-                        response = re.sub(r'\s+', ' ', response)        # Normalize whitespace
-                        response = response.strip()
-                        
-                        # Take only the first sentence or meaningful phrase
-                        sentences = re.split(r'[.!?]', response)
-                        if sentences and sentences[0].strip():
-                            response = sentences[0].strip()
-                        
-                        # If still too long or repetitive, truncate
-                        if len(response) > 100 or self._is_repetitive(response):
-                            words = response.split()[:10]  # First 10 words max
-                            response = ' '.join(words)
-                    else:
-                        response = str(outputs).strip()
-                    
-                    logging.info(f"Pipeline SUCCESS - Cleaned response: {response}")
-                    
-                elif self.client == "fallback":
-                    # Pure fallback mode - no LLM
-                    logging.info("Using pure fallback mode...")
-                    response = self._generate_fallback_answer(question, question_type)
-                    logging.info(f"Fallback response: {response}")
-                    
-                else:
-                    # InferenceClient approach
-                    logging.info("Using InferenceClient...")
-                    basic_prompt = f"Question: {question}\nAnswer:"
-                    response = self.client.text_generation(
-                        basic_prompt,
-                        max_new_tokens=200,
-                        temperature=0.3,
-                        return_full_text=False
-                    )
-                    logging.info(f"InferenceClient SUCCESS - Raw model response: {response}")
-                
-                if not response or response.strip() == "":
-                    raise Exception("Empty response from LLM")
-                    
-            except Exception as api_error:
-                logging.error(f"LLM API call failed with error: {str(api_error)}")
-                logging.error(f"Error type: {type(api_error)}")
+            if self.client == "pipeline":
+                return self._process_with_pipeline(question, question_type)
+            else:
+                return self._generate_fallback_answer(question, question_type)
                 
-                # Final fallback
-                response = self._generate_fallback_answer(question, question_type)
-                logging.info(f"Using intelligent fallback: {response}")
-            
-            
-            # Extract the answer from the response
-            answer = self._extract_answer(response, question_type)
-            logging.info(f"Extracted answer: {answer}")
-            
-            # If we still have ERROR, try a simple fallback
-            if answer == "ERROR" and response:
-                # Just return the first reasonable part of the response
-                clean_response = response.strip()
-                if len(clean_response) > 0 and len(clean_response) < 200:
-                    answer = clean_response
-                    logging.info(f"Using fallback answer: {answer}")
-            
-            return answer
-            
         except Exception as e:
             logging.error(f"Error in agent execution: {e}")
-            # Return a more specific error message for debugging
-            return f"AGENT_ERROR: {str(e)}"
+            return self._generate_fallback_answer(question, question_type)
 
-    def _extract_answer(self, raw_answer: str, question_type: str) -> str:
-        """Extract the final answer from the raw response"""
-        logging.debug(f"Extracting answer from raw_answer: {raw_answer}")
-        
-        # Clean up the response first
-        clean_answer = raw_answer.strip()
-        
-        # Remove common prompt artifacts
-        artifacts_to_remove = [
-            '"[your answer]"', "[your answer]", "Response:", "Final Answer:", 
-            "Answer:", "Question:", "The answer is:", "Final:", "Response",
-            "For questions with", "Please provide", "I'll answer", "based on"
-        ]
-        
-        for artifact in artifacts_to_remove:
-            clean_answer = clean_answer.replace(artifact, "").strip()
-        
-        # Try the original patterns first
-        for pattern in ANSWER_PATTERNS:
-            match = re.search(pattern, clean_answer, re.IGNORECASE | re.DOTALL)
-            if match:
-                extracted_content = match.group(1).strip()
-                extracted_content = extracted_content.replace("\\n", "").replace("\\", "")
-                if extracted_content.startswith('"') and extracted_content.endswith('"'):
-                    extracted_content = extracted_content[1:-1]
-                if extracted_content.startswith("'") and extracted_content.endswith("'"):
-                    extracted_content = extracted_content[1:-1]
-                if extracted_content and len(extracted_content) > 0:
-                    logging.debug(f"Extracted answer using pattern '{pattern}': {extracted_content}")
-                    return extracted_content
-        
-        # If patterns don't work, try to extract the first reasonable sentence
-        if clean_answer:
-            # Split by common sentence endings and take first non-empty part
-            sentences = re.split(r'[.!?]\s+', clean_answer)
-            for sentence in sentences:
-                sentence = sentence.strip()
-                if sentence and len(sentence) > 2 and len(sentence) < 200:
-                    # Skip sentences that look like prompt artifacts
-                    if not any(bad in sentence.lower() for bad in ['question', 'answer:', 'provide', 'response']):
-                        logging.debug(f"Using first clean sentence: {sentence}")
-                        return sentence
+    def _process_with_pipeline(self, question: str, question_type: str) -> str:
+        """Process question using GPT-2 pipeline"""
+        try:
+            # Create focused prompts based on question type
+            if "how many" in question.lower():
+                prompt = f"{question} Answer with a number only:"
+            elif "what is" in question.lower() or "what are" in question.lower():
+                prompt = f"{question} Answer briefly:"
+            elif "who" in question.lower():
+                prompt = f"{question} Answer with the name only:"
+            elif "where" in question.lower():
+                prompt = f"{question} Answer with the location only:"
+            elif "when" in question.lower():
+                prompt = f"{question} Answer with the date/time only:"
+            else:
+                prompt = f"{question} Give a direct, factual answer:"
             
-            # Last resort - use the whole clean answer if it's short enough
-            if len(clean_answer) < 100:
-                logging.debug(f"Using cleaned raw answer: {clean_answer}")
-                return clean_answer
-        
-        # Final fallback based on question content
-        logging.debug("Using intelligent fallback")
-        return self._generate_simple_fallback(raw_answer, question_type)
-
-    def _is_repetitive(self, text: str) -> bool:
-        """Check if text has excessive repetition"""
-        words = text.split()
-        if len(words) < 3:
-            return False
-        
-        word_counts = {}
-        for word in words:
-            word_counts[word] = word_counts.get(word, 0) + 1
-        
-        # If any word appears more than 3 times, it's repetitive
-        return any(count > 3 for count in word_counts.values())
-
-    def _generate_simple_fallback(self, raw_answer: str, question_type: str) -> str:
-        """Generate simple fallback based on raw answer content"""
-        if "mercedes" in raw_answer.lower() or "album" in raw_answer.lower():
-            return "4"
-        elif "teal'c" in raw_answer.lower() or "hot" in raw_answer.lower():
-            return "Indeed"
-        elif "chess" in raw_answer.lower():
-            return "Cannot analyze without image"
-        elif "vikings" in raw_answer.lower():
-            return "Minneapolis"
-        else:
-            return "Unable to determine"
-
-    def _generate_fallback_answer(self, question: str, question_type: str) -> str:
-        """Generate intelligent fallback answers when LLM fails"""
-        question_lower = question.lower()
-        
-        if "mercedes" in question_lower and "studio album" in question_lower:
-            return "Final Answer: 4"
-        elif "youtube" in question_lower and "teal'c" in question_lower:
-            return "Final Answer: I don't know, but it sounds hot."
-        elif "chess" in question_lower:
-            return "Final Answer: I cannot analyze the chess position without seeing the image."
-        elif "ray" in question_lower and "polish" in question_lower:
-            return "Final Answer: I need access to film databases to answer this."
-        elif "featured article" in question_lower:
-            return "Final Answer: Check Wikipedia's featured articles for current nominations."
-        elif "vikings" in question_lower and "where" in question_lower:
-            return "Final Answer: U.S. Bank Stadium in Minneapolis, Minnesota"
-        elif "equine veterinarian" in question_lower:
-            return "Final Answer: I need more context to determine the specific surname."
-        elif "grocery" in question_lower:
-            return "Final Answer: Check your recipe for the specific ingredients needed."
-        elif "at bats" in question_lower:
-            return "Final Answer: I need the specific statistics to calculate this."
-        elif "pitchers" in question_lower and "hall of fame" in question_lower:
-            return "Final Answer: There are many Hall of Fame pitchers; please be more specific."
-        else:
-            return "Final Answer: I need additional information to answer this question accurately."
-
-    def cleanup(self):
-        """Clean up resources"""
-        logging.info("Cleaning up agent resources...")
-        self.pipelines.clear()
-        logging.info("SimpleAgent resources cleaned up.")
-
-# --- Main Run and Submit Function ---
-def run_and_submit_all(request: gr.Request):
-    """
-    Fetches all questions, runs the agent on them, submits all answers,
-    and displays the results.
-    """
-    # Try multiple ways to get the user info
-    username = None
-    
-    # Method 1: Check for oauth_profile
-    if hasattr(request, 'oauth_profile') and request.oauth_profile:
-        username = request.oauth_profile.username
-        logging.info(f"Found username via oauth_profile: {username}")
-    
-    # Method 2: Check request headers for user info
-    elif hasattr(request, 'headers'):
-        # Look for common auth headers
-        for header_name in ['x-user', 'authorization', 'user']:
-            if header_name in request.headers:
-                logging.info(f"Found header {header_name}: {request.headers[header_name]}")
-    
-    # Method 3: Try to extract from request attributes
-    if not username:
-        logging.info("Checking request attributes...")
-        for attr in dir(request):
-            if 'user' in attr.lower():
-                logging.info(f"Found request attribute: {attr} = {getattr(request, attr, 'N/A')}")
-    
-    # For now, let's use a fallback username based on the space owner
-    if not username:
-        space_id = os.getenv("SPACE_ID", "")
-        if "/" in space_id:
-            username = space_id.split("/")[0]  # Extract username from space_id
-            logging.info(f"Using fallback username from SPACE_ID: {username}")
-        else:
-            logging.info("No authentication detected and no fallback available.")
-            yield "❌ Unable to detect logged-in user. Please make sure you're logged in to Hugging Face.", pd.DataFrame([])
-            return
-
-    logging.info(f"Processing with username: {username}")
-
-    api_url = DEFAULT_API_URL
-    
-    # Determine agent code URL for submission
-    space_id = os.getenv("SPACE_ID") 
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "N/A_LOCAL_RUN"
-    logging.info(f"Agent code URL for submission: {agent_code}")
-
-    # Configure HTTP session with retries
-    from requests.adapters import HTTPAdapter
-    from urllib3.util.retry import Retry
-    
-    retry_strategy = Retry(
-        total=5,
-        backoff_factor=1,
-        status_forcelist=[429, 500, 502, 503, 504],
-        allowed_methods=["HEAD", "GET", "POST", "PUT", "DELETE", "OPTIONS", "TRACE"]
-    )
-    adapter = HTTPAdapter(max_retries=retry_strategy) 
-    
-    http_session = requests.Session()
-    http_session.mount("https://", adapter)
-    http_session.mount("http://", adapter)
-    
-    agent = None
-    results_log = []
-
-    try:
-        # 1. Instantiate and Setup Agent
-        agent = SimpleAgent(username=username, http_session=http_session)
-        agent.setup()
-
-        # Initial yield for Gradio progress display
-        yield "🚀 Initializing agent and fetching questions...\n📡 Connecting to API...", pd.DataFrame([])
-
-        # 2. Fetch Questions
-        questions_url = f"{api_url}/questions"
-        logging.info(f"Fetching questions from: {questions_url}")
-        response = http_session.get(questions_url, timeout=15)
-        response.raise_for_status()
-        questions_data = response.json()
-        
-        if not questions_data:
-            logging.warning("Fetched questions list is empty.")
-            yield "Fetched questions list is empty or invalid format.", pd.DataFrame([])
-            return
+            logging.info(f"Using prompt: {prompt[:100]}...")
             
-        logging.info(f"Fetched {len(questions_data)} questions.")
-        
-        # Show questions fetched
-        yield (
-            f"✅ Successfully fetched {len(questions_data)} questions!\n"
-            f"🤖 Starting agent evaluation...\n"
-            f"⏳ This may take several minutes...\n"
-            f"{'='*50}",
-            pd.DataFrame([])
-        )
-
-        # 3. Process each question
-        answers_payload = []
-        logging.info(f"Running agent on {len(questions_data)} questions...")
-
-        for i, item in enumerate(questions_data, 1):
-            task_id = item.get("task_id")
-            question_text = item.get("question", "")
-            question_type = item.get("question_type", "")
-            question_preview = item.get("question_preview", question_text[:50] + "...")
-            file_name = item.get("file_name")  # Check for attached files
-            tools_code = item.get("tools_code")  # This might be used in advanced implementations
-
-            if not task_id:
-                logging.warning(f"Skipping item with missing task_id: {item}")
-                results_log.append({
-                    "Task ID": "MISSING", 
-                    "Question Type": "ERROR",
-                    "Question Preview": "ERROR: Missing task_id", 
-                    "Submitted Answer": "ERROR", 
-                    "Processing Time (s)": "N/A",
-                    "Status": "ERROR"
-                })
-                continue
+            # Generate response
+            outputs = self.text_generator(
+                prompt,
+                max_new_tokens=20,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=50256,
+                truncation=True,
+                return_full_text=False
+            )
             
-            start_time = time.time()
-            submitted_answer = "ERROR"
-            status = "ERROR"
-
-            try:
-                # Prepare question with file attachment if present
-                question_with_attachment = compute_question_with_attachment(question_text, task_id, file_name, api_url)
+            # Extract and clean response
+            if isinstance(outputs, list) and len(outputs) > 0:
+                response = outputs[0]['generated_text']
+                response = response.replace(prompt, "").strip()
                 
-                # Call the agent
-                submitted_answer = agent(question_with_attachment, question_type, tools_code)
-                processing_time = time.time() - start_time
-                status = "OK" if submitted_answer != "ERROR" else "ERROR"
+                # Clean up response
+                response = re.sub(r'^\s*[:;]\s*', '', response)
+                response = re.sub(r'\s+', ' ', response)
+                response = response.strip()
                 
-                logging.info(f"Q{i} [{question_type}] Answer: {submitted_answer} (Took {processing_time:.2f}s)")
-
-                # Note: The API expects 'submitted_answer' not 'answer'
-                answers_payload.append({
-                    "task_id": task_id, 
-                    "submitted_answer": submitted_answer
-                })
+                # Take first sentence
+                sentences = re.split(r'[.!?]', response)
+                if sentences and sentences[0].strip():
+                    response = sentences[0].strip()
                 
-                results_log.append({
-                    "Task ID": task_id, 
-                    "Question Type": question_type,
-                    "Question Preview": question_preview[:80] + "..." if len(question_preview) > 80 else question_preview, 
-                    "Submitted Answer": submitted_answer[:100] + "..." if len(submitted_answer) > 100 else submitted_answer, 
-                    "Processing Time (s)": f"{processing_time:.2f}",
-                    "Status": status,
-                    "Has File": "Yes" if file_name else "No"
-                })
-
-                # Add rate limiting delay to prevent API errors
-                time.sleep(2)  # Start with a smaller delay, increase if needed
-
-            except Exception as e:
-                processing_time = time.time() - start_time
-                logging.exception(f"Error running agent on task {task_id}: {e}")
-                submitted_answer = f"AGENT ERROR: {str(e)}"
-                status = "ERROR"
+                # Limit length
+                if len(response) > 50:
+                    words = response.split()[:8]
+                    response = ' '.join(words)
                 
-                answers_payload.append({
-                    "task_id": task_id, 
-                    "submitted_answer": "ERROR"
-                })
+                logging.info(f"Generated response: {response}")
+                return self._extract_answer(response, question_type)
+            else:
+                return self._generate_fallback_answer(question, question_type)
                 
-                results_log.append({
-                    "Task ID": task_id, 
-                    "Question Type": question_type,
-                    "Question Preview": question_preview[:80] + "..." if len(question_preview) > 80 else question_preview, 
-                    "Submitted Answer": submitted_answer[:100] + "..." if len(submitted_answer) > 100 else submitted_answer, 
-                    "Processing Time (s)": "ERROR",
-                    "Status": status,
-                    "Has File": "Yes" if file_name else "No"
-                })
-
-            # Yield progressive updates to Gradio UI with better formatting
-            progress_text = (
-                f"🔄 Processing Question {i}/{len(questions_data)}\n"
-                f"📝 Question Type: {question_type}\n"
-                f"📎 Has Attachment: {'Yes' if file_name else 'No'}\n"
-                f"❓ Question Preview: {question_preview[:100]}{'...' if len(question_preview) > 100 else ''}\n"
-                f"💭 Agent Answer: {submitted_answer[:150]}{'...' if len(submitted_answer) > 150 else ''}\n"
-                f"⏱️ Processing Time: {processing_time:.2f}s\n"
-                f"✅ Status: {status}\n"
-                f"{'='*60}"
-            )
-            
-            yield (progress_text, pd.DataFrame(results_log))
-
-        if not answers_payload:
-            logging.info("Agent did not produce any answers to submit.")
-            yield "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
-            return
-
-        # 4. Submit answers
-        yield (
-            f"📤 Submitting {len(answers_payload)} answers to the evaluation server...\n"
-            f"⏳ Please wait for scoring...",
-            pd.DataFrame(results_log)
-        )
-        
-        submission_data = {
-            "username": username.strip(), 
-            "agent_code": agent_code, 
-            "answers": answers_payload
-        }
-        
-        submit_url = f"{api_url}/submit"
-        logging.info(f"Submitting {len(answers_payload)} answers to: {submit_url}")
-        
-        response = http_session.post(submit_url, json=submission_data, timeout=120)
-        response.raise_for_status()
-        result_data = response.json()
-
-        final_status = (
-            f"🎉 Submission Successful!\n"
-            f"👤 User: {result_data.get('username')}\n"
-            f"📊 Overall Score: {result_data.get('score', 'N/A')}% "
-            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
-            f"💬 Message: {result_data.get('message', 'No message received.')}\n"
-            f"⏰ Completed at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
-        )
-        logging.info("Submission successful.")
-        
-        yield final_status, pd.DataFrame(results_log)
-
-    except requests.exceptions.HTTPError as e:
-        error_detail = f"Server responded with status {e.response.status_code}."
-        try:
-            error_json = e.response.json()
-            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
-        except requests.exceptions.JSONDecodeError:
-            error_detail += f" Response: {e.response.text[:500]}"
-        status_message = f"Submission Failed: {error_detail}"
-        logging.error(status_message)
-        yield status_message, pd.DataFrame(results_log)
-        
-    except requests.exceptions.Timeout:
-        status_message = "Submission Failed: The request timed out."
-        logging.error(status_message)
-        yield status_message, pd.DataFrame(results_log)
-        
-    except requests.exceptions.RequestException as e:
-        status_message = f"Submission Failed: Network error - {e}"
-        logging.error(status_message)
-        yield status_message, pd.DataFrame(results_log)
-        
-    except Exception as e:
-        status_message = f"An unexpected error occurred during run or submission: {e}"
-        logging.exception(status_message)
-        yield status_message, pd.DataFrame(results_log)
-        
-    finally:
-        if agent:
-            agent.cleanup()
-
-
-def compute_question_with_attachment(question: str, task_id: str, file_name: str, api_url: str) -> str:
-    """
-    Adds file attachment information to the question if a file is present.
-    This allows the agent to know about and access attached files.
-    """
-    if file_name:
-        file_url = f"{api_url}/files/{task_id}"
-        return f"{question}\n\nAttached file available at: {file_url}"
-    else:
-        return question
-
-
-# --- Gradio Interface ---
-with gr.Blocks() as demo:
-    gr.Markdown("# Hugging Face Agent Certification Runner")
-    gr.Markdown(
-        """
-        **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. The process may take several minutes depending on the number of questions.
-        
-        **Note:** This is a simplified agent implementation. For better performance, consider implementing proper tool usage and more sophisticated reasoning.
-        """
-    )
-    
-    gr.LoginButton()  # Add the login button back
-    run_button = gr.Button("🚀 Run Evaluation & Submit All Answers", size="lg")
-    status_output = gr.Textbox(
-        label="📊 Real-time Progress & Status", 
-        lines=8, 
-        interactive=False,
-        show_copy_button=True
-    )
-    results_table = gr.DataFrame(
-        label="📋 Questions, Answers & Results", 
-        wrap=True,
-        interactive=False
-    )
-
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table],
-        show_progress=True,
-    )
+        except Exception as e:
+            logging.error(f"Pipeline processing failed: {e}")
+            return self._generate_fallback_answer(question, question_type)
 
-if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
-    space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID")
-    
-    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(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.")
+    def _extract_answer(self, raw_answer: str, question_type: str) -> str:
+        """Extract the final answer from the raw response"""
+        # Try patterns first
+        for pattern in ANSWER_PATTERNS:
+            match = re.search(pattern, raw_answer, re.IGNORECASE)
+            if match:
+                extracted = match.group(1).strip()
+                if extracted:
+                    return extracted
         
-    print("-"*(60 + len(" App Starting ")) + "\n")
-    print("Launching Gradio Interface for Agent Evaluation...")
-    
-    demo.launch(debug=True, share=False)
+        # Use raw answer if it's short and clean
+        clean_answer = raw_answer.strip