Update app.py

app.py

@@ -1,300 +1,231 @@
 """
-Improved GAIA Agent with LLM Integration for Hugging Face Course
+Улучшенный GAIA Agent с поддержкой кэширования ответов и исправленным полем agent_code
 """
 
 import os
-import gradio as gr
-import requests
-import pandas as pd
 import json
-import re
 import time
-from typing import List, Dict, Any, Optional, Callable, Union
-from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+import torch
+import requests
+import gradio as gr
+import pandas as pd
+from huggingface_hub import login
+from typing import List, Dict, Any, Optional, Union, Callable
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 
-# --- Constants ---
+# Константы
+CACHE_FILE = "gaia_answers_cache.json"
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-DEFAULT_MODEL = "google/flan-t5-small"  # Smaller model for faster loading
-MAX_RETRIES = 3  # Maximum number of submission retries
-RETRY_DELAY = 5  # Seconds to wait between retries
+MAX_RETRIES = 3  # Максимальное количество попыток отправки
+RETRY_DELAY = 5  # Секунды ожидания между попытками
 
-class LLMGAIAAgent:
+class EnhancedGAIAAgent:
     """
-    An improved GAIA agent that uses a language model to generate responses
-    instead of template-based answers.
+    Улучшенный агент для Hugging Face GAIA с поддержкой кэширования ответов
     """
     
-    def __init__(self, model_name=DEFAULT_MODEL ):
-        """Initialize the agent with a language model."""
-        print(f"Initializing LLMGAIAAgent with model: {model_name}")
-        try:
-            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-            self.model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
-            self.model_name = model_name
-            print(f"Successfully loaded model: {model_name}")
-        except Exception as e:
-            print(f"Error loading model: {e}")
-            print("Falling back to template-based responses")
-            self.model = None
-            self.tokenizer = None
-            self.model_name = None
-    
-    def __call__(self, question: str, task_id: str = None) -> str:
-        """Process a question and return an answer using the language model."""
-        print(f"Processing question: {question}")
+    def __init__(self, model_name="google/flan-t5-small", use_cache=True):
+        """
+        Инициализация агента с моделью и кэшем
         
-        # Check if model is available
-        if self.model is None or self.tokenizer is None:
-            return self._fallback_response(question)
+        Args:
+            model_name: Название модели для загрузки
+            use_cache: Использовать ли кэширование ответов
+        """
+        print(f"Initializing EnhancedGAIAAgent with model: {model_name}")
+        self.model_name = model_name
+        self.use_cache = use_cache
+        self.cache = self._load_cache() if use_cache else {}
         
-        try:
-            # Prepare prompt based on question type
-            prompt = self._prepare_prompt(question)
-            
-            # Generate response using the model
-            inputs = self.tokenizer(prompt, return_tensors="pt", max_length=512, truncation=True)
-            outputs = self.model.generate(
-                inputs["input_ids"],
-                max_length=150,
-                min_length=20,
-                temperature=0.7,
-                top_p=0.9,
-                do_sample=True,
-                num_return_sequences=1
-            )
-            
-            # Decode the response
-            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-            
-            # Clean up the response if needed
-            response = self._clean_response(response)
-            
-            # Return JSON with final_answer key
-            return json.dumps({"final_answer": response})
-        except Exception as e:
-            print(f"Error generating response: {e}")
-            return json.dumps({"final_answer": self._fallback_response(question)})
+        # Загружаем модель и токенизатор
+        print("Loading tokenizer...")
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        print("Loading model...")
+        self.model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
+        print("Model and tokenizer loaded successfully")
     
-    def _prepare_prompt(self, question: str) -> str:
-        """Prepare an appropriate prompt based on the question type."""
-        question_lower = question.lower()
-        
-        # Check for calculation questions
-        if any(keyword in question_lower for keyword in [
-            "calculate", "compute", "sum", "difference", 
-            "product", "divide", "plus", "minus", "times"
-        ]):
-            return f"Solve this math problem step by step: {question}"
-        
-        # Check for image analysis questions
-        elif any(keyword in question_lower for keyword in [
-            "image", "picture", "photo", "graph", "chart", "diagram"
-        ]):
-            return f"Describe what might be seen in an image related to this question: {question}"
-        
-        # Check for factual questions
-        elif any(keyword in question_lower for keyword in [
-            "who", "what", "where", "when", "why", "how"
-        ]):
-            return f"Answer this factual question concisely and accurately: {question}"
+    def _load_cache(self) -> Dict[str, str]:
+        """
+        Загружает кэш ответов из файла
         
-        # Default prompt for general knowledge
+        Returns:
+            Dict[str, str]: Словарь с кэшированными ответами
+        """
+        if os.path.exists(CACHE_FILE):
+            try:
+                with open(CACHE_FILE, 'r', encoding='utf-8') as f:
+                    print(f"Loading cache from {CACHE_FILE}")
+                    return json.load(f)
+            except Exception as e:
+                print(f"Error loading cache: {e}")
+                return {}
         else:
-            return f"Provide a concise, informative answer to this question: {question}"
-    
-    def _clean_response(self, response: str) -> str:
-        """Clean up the model's response if needed."""
-        # Remove any prefixes like "Answer:" or "Response:"
-        for prefix in ["Answer:", "Response:", "A:"]:
-            if response.startswith(prefix):
-                response = response[len(prefix):].strip()
-        
-        # Ensure the response is not too short
-        if len(response) < 10:
-            return self._fallback_response("general")
-        
-        return response
-    
-    def _fallback_response(self, question: str) -> str:
-        """Provide a fallback response if the model fails."""
-        question_lower = question.lower() if isinstance(question, str) else ""
-        
-        # Map question words to appropriate responses (similar to original GAIAAgent)
-        if "who" in question_lower:
-            return "The person involved is a notable figure in this field with significant contributions and achievements."
-        elif "when" in question_lower:
-            return "This occurred during a significant historical period, specifically in the early part of the relevant era."
-        elif "where" in question_lower:
-            return "The location is in a region known for its historical and cultural significance."
-        elif "what" in question_lower:
-            return "This refers to an important concept or entity that has several key characteristics and functions."
-        elif "why" in question_lower:
-            return "This happened due to a combination of factors including historical context, individual decisions, and broader societal trends."
-        elif "how" in question_lower:
-            return "The process involves several key steps that must be followed in sequence to achieve the desired outcome."
-        
-        # Fallback for other question types
-        return "Based on my analysis, the answer to your question involves several important factors. First, we need to consider the context and specific details mentioned."
-
-
-class GAIAAgent:
-    """
-    A pattern-matching agent designed to pass the GAIA evaluation by recognizing
-    question types and providing appropriate formatted responses.
-    """
+            print(f"Cache file {CACHE_FILE} not found, creating new cache")
+            return {}
     
-    def __init__(self):
-        """Initialize the agent with handlers for different question types."""
-        self.handlers = {
-            'calculation': self._handle_calculation,
-            'image': self._handle_image_analysis,
-            'factual': self._handle_factual_question,
-            'general': self._handle_general_knowledge
-        }
-        print("GAIAAgent initialized with specialized question handlers.")
+    def _save_cache(self) -> None:
+        """
+        Сохраняет кэш ответов в файл
+        """
+        try:
+            with open(CACHE_FILE, 'w', encoding='utf-8') as f:
+                json.dump(self.cache, f, ensure_ascii=False, indent=2)
+                print(f"Cache saved to {CACHE_FILE}")
+        except Exception as e:
+            print(f"Error saving cache: {e}")
     
-    def __call__(self, question: str, task_id: str = None) -> str:
-        """Process a question and return an appropriate answer."""
-        print(f"Processing question: {question}")
-        
-        # Determine question type
-        question_type = self._classify_question(question)
+    def _classify_question(self, question: str) -> str:
+        """
+        Классифицирует вопрос по типу для лучшего форматирования ответа
         
-        # Use the appropriate handler
-        answer = self.handlers[question_type](question)
+        Args:
+            question: Текст вопроса
+            
+        Returns:
+            str: Тип вопроса (factual, calculation, list, date_time, etc.)
+        """
+        # Простая эвристическая классификация
+        question_lower = question.lower()
         
-        # Return JSON with final_answer key
-        return json.dumps({"final_answer": answer})
+        if any(word in question_lower for word in ["calculate", "sum", "product", "divide", "multiply", "add", "subtract", "how many"]):
+            return "calculation"
+        elif any(word in question_lower for word in ["list", "enumerate", "items", "elements"]):
+            return "list"
+        elif any(word in question_lower for word in ["date", "time", "day", "month", "year", "when"]):
+            return "date_time"
+        else:
+            return "factual"
     
-    def _classify_question(self, question: str) -> str:
-        """Classify the question into one of the supported types."""
-        question_lower = question.lower()
+    def _format_answer(self, raw_answer: str, question_type: str) -> str:
+        """
+        Форматирует ответ в соответствии с типом вопроса
         
-        # Check for calculation questions
-        if any(keyword in question_lower for keyword in [
-            "calculate", "compute", "sum", "difference", 
-            "product", "divide", "plus", "minus", "times"
-        ]):
-            return 'calculation'
+        Args:
+            raw_answer: Необработанный ответ от модели
+            question_type: Тип вопроса
+            
+        Returns:
+            str: Отформатированный ответ
+        """
+        # Удаляем лишние пробелы и переносы строк
+        answer = raw_answer.strip()
         
-        # Check for image analysis questions
-        elif any(keyword in question_lower for keyword in [
-            "image", "picture", "photo", "graph", "chart", "diagram"
-        ]):
-            return 'image'
+        # Удаляем префиксы, которые часто добавляет модель
+        prefixes = ["Answer:", "The answer is:", "I think", "I believe", "According to", "Based on"]
+        for prefix in prefixes:
+            if answer.startswith(prefix):
+                answer = answer[len(prefix):].strip()
         
-        # Check for factual questions (who, what, where, etc.)
-        elif any(keyword in question_lower for keyword in [
-            "who", "what", "where", "when", "why", "how"
-        ]):
-            return 'factual'
+        # Специфическое форматирование в зависимости от типа вопроса
+        if question_type == "calculation":
+            # Для числовых ответов удаляем лишний текст
+            # Оставляем только числа, если они есть
+            import re
+            numbers = re.findall(r'-?\d+\.?\d*', answer)
+            if numbers:
+                answer = numbers[0]
+        elif question_type == "list":
+            # Для списков убеждаемся, что элементы разделены запятыми
+            if "," not in answer and " " in answer:
+                items = [item.strip() for item in answer.split() if item.strip()]
+                answer = ", ".join(items)
         
-        # Default to general knowledge
-        else:
-            return 'general'
+        return answer
     
-    def _handle_calculation(self, question: str) -> str:
-        """Handle mathematical calculation questions."""
-        question_lower = question.lower()
-        
-        # Extract numbers from the question
-        numbers = re.findall(r'\d+', question)
+    def __call__(self, question: str, task_id: Optional[str] = None) -> str:
+        """
+        Обрабатывает вопрос и возвращает ответ
         
-        if len(numbers) >= 2:
-            # Determine operation type
-            if any(op in question_lower for op in ["sum", "add", "plus", "+"]):
-                result = sum(int(num) for num in numbers)
-                return f"{result}"
-                
-            elif any(op in question_lower for op in ["difference", "subtract", "minus", "-"]):
-                result = int(numbers[0]) - int(numbers[1])
-                return f"{result}"
-                
-            elif any(op in question_lower for op in ["product", "multiply", "times", "*"]):
-                result = int(numbers[0]) * int(numbers[1])
-                return f"{result}"
-                
-            elif any(op in question_lower for op in ["divide", "division", "/"]):
-                if int(numbers[1]) != 0:
-                    result = int(numbers[0]) / int(numbers[1])
-                    return f"{result}"
-                else:
-                    return "Cannot divide by zero"
+        Args:
+            question: Текст вопроса
+            task_id: Идентификатор задачи (опционально)
+            
+        Returns:
+            str: Ответ в формате JSON с ключом final_answer
+        """
+        # Создаем ключ для кэша (используем task_id, если доступен)
+        cache_key = task_id if task_id else question
         
-        # If we couldn't parse the calculation specifically
-        return "I'll calculate this for you: " + question
-    
-    def _handle_image_analysis(self, question: str) -> str:
-        """Handle questions about images or visual content."""
-        return "Based on the image, I can see several key elements that help answer your question. The main subject appears to be [description] which indicates [answer]."
-    
-    def _handle_factual_question(self, question: str) -> str:
-        """Handle factual questions (who, what, where, when, why, how)."""
-        question_lower = question.lower()
+        # Проверяем наличие ответа в кэше
+        if self.use_cache and cache_key in self.cache:
+            print(f"Cache hit for question: {question[:50]}...")
+            return self.cache[cache_key]
         
-        # Map question words to appropriate responses
-        if "who" in question_lower:
-            return "The person involved is a notable figure in this field with significant contributions and achievements."
-        elif "when" in question_lower:
-            return "This occurred during a significant historical period, specifically in the early part of the relevant era."
-        elif "where" in question_lower:
-            return "The location is in a region known for its historical and cultural significance."
-        elif "what" in question_lower:
-            return "This refers to an important concept or entity that has several key characteristics and functions."
-        elif "why" in question_lower:
-            return "This happened due to a combination of factors including historical context, individual decisions, and broader societal trends."
-        elif "how" in question_lower:
-            return "The process involves several key steps that must be followed in sequence to achieve the desired outcome."
+        # Классифицируем вопрос
+        question_type = self._classify_question(question)
+        print(f"Processing question: {question[:100]}...")
+        print(f"Classified as: {question_type}")
         
-        # Fallback for other question types
-        return "The answer to this factual question involves several important considerations and contextual factors."
-    
-    def _handle_general_knowledge(self, question: str) -> str:
-        """Handle general knowledge questions that don't fit other categories."""
-        return "Based on my analysis, the answer to your question involves several important factors. First, we need to consider the context and specific details mentioned. Taking all available information into account, the most accurate response would be a comprehensive explanation that addresses all aspects of your query."
+        try:
+            # Генерируем ответ с помощью модели
+            inputs = self.tokenizer(question, return_tensors="pt")
+            outputs = self.model.generate(**inputs, max_length=100)
+            raw_answer = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            # Форматируем ответ
+            formatted_answer = self._format_answer(raw_answer, question_type)
+            
+            # Формируем JSON-ответ
+            result = {"final_answer": formatted_answer}
+            json_response = json.dumps(result)
+            
+            # Сохраняем в кэш
+            if self.use_cache:
+                self.cache[cache_key] = json_response
+                self._save_cache()
+            
+            return json_response
+            
+        except Exception as e:
+            error_msg = f"Error generating answer: {e}"
+            print(error_msg)
+            return json.dumps({"final_answer": f"AGENT ERROR: {e}"})
 
 
 class EvaluationRunner:
     """
-    Handles the evaluation process: fetching questions, running the agent,
-    and submitting answers to the evaluation server.
+    Обрабатывает процесс оценки: получение вопросов, запуск агента,
+    и отправку ответов на сервер оценки.
     """
     
-    def __init__(self, api_url: str = DEFAULT_API_URL):
-        """Initialize with API endpoints."""
+    def __init__(self, api_url=DEFAULT_API_URL):
+        """Инициализация с API endpoints."""
         self.api_url = api_url
         self.questions_url = f"{api_url}/questions"
         self.submit_url = f"{api_url}/submit"
+        self.results_url = f"{api_url}/results"
+        self.correct_answers = 0
+        self.total_questions = 0
     
     def run_evaluation(self, 
                       agent: Callable[[str], str], 
                       username: str, 
                       agent_code_url: str) -> tuple[str, pd.DataFrame]:
         """
-        Run the full evaluation process:
-        1. Fetch questions
-        2. Run agent on all questions
-        3. Submit answers
-        4. Return results
+        Запускает полный процесс оценки:
+        1. Получает вопросы
+        2. Запускает агента на всех вопросах
+        3. Отправляет ответы
+        4. Возвращает результаты
         """
-        # Fetch questions
+        # Получаем вопросы
         questions_data = self._fetch_questions()
-        if isinstance(questions_data, str):  # Error message
+        if isinstance(questions_data, str):  # Сообщение об ошибке
             return questions_data, None
         
-        # Run agent on all questions
+        # Запускаем агента на всех вопросах
         results_log, answers_payload = self._run_agent_on_questions(agent, questions_data)
         if not answers_payload:
             return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
         
-        # Submit answers with retry logic
-        submission_result = self._submit_answers_with_retry(username, agent_code_url, answers_payload)
+        # Отправляем ответы с логикой повторных попыток
+        submission_result = self._submit_answers(username, agent_code_url, answers_payload)
         
-        # Return results
+        # Возвращаем результаты
         return submission_result, pd.DataFrame(results_log)
     
     def _fetch_questions(self) -> Union[List[Dict[str, Any]], str]:
-        """Fetch questions from the evaluation server."""
+        """Получает вопросы с сервера оценки."""
         print(f"Fetching questions from: {self.questions_url}")
         try:
             response = requests.get(self.questions_url, timeout=15)
@@ -306,7 +237,8 @@ class EvaluationRunner:
                 print(error_msg)
                 return error_msg
             
-            print(f"Successfully fetched {len(questions_data)} questions.")
+            self.total_questions = len(questions_data)
+            print(f"Successfully fetched {self.total_questions} questions.")
             return questions_data
             
         except requests.exceptions.RequestException as e:
@@ -326,9 +258,9 @@ class EvaluationRunner:
             return error_msg
     
     def _run_agent_on_questions(self, 
-                               agent: Callable[[str], str], 
+                               agent: Any, 
                                questions_data: List[Dict[str, Any]]) -> tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
-        """Run the agent on all questions and collect results."""
+        """Запускает агента на всех вопросах и собирает результаты."""
         results_log = []
         answers_payload = []
         
@@ -342,22 +274,20 @@ class EvaluationRunner:
                 continue
             
             try:
-                # Call agent with task_id parameter if supported
-                if hasattr(agent, '__code__') and 'task_id' in agent.__code__.co_varnames:
-                    json_response = agent(question_text, task_id)
-                else:
-                    json_response = agent(question_text)
+                # Вызываем агента с task_id для правильного форматирования
+                json_response = agent(question_text, task_id)
                 
-                # Parse the JSON response
+                # Парсим JSON-ответ
                 response_obj = json.loads(json_response)
                 
-                # Extract the final_answer for submission
+                # Извлекаем final_answer для отправки
                 submitted_answer = response_obj.get("final_answer", "")
                 
                 answers_payload.append({
                     "task_id": task_id, 
                     "submitted_answer": submitted_answer
                 })
+                
                 results_log.append({
                     "Task ID": task_id, 
                     "Question": question_text, 
@@ -374,156 +304,202 @@ class EvaluationRunner:
         
         return results_log, answers_payload
     
-    def _submit_answers_with_retry(self, 
-                                  username: str, 
-                                  agent_code_url: str, 
-                                  answers_payload: List[Dict[str, Any]]) -> str:
-        """Submit answers to the evaluation server with retry logic."""
+    def _submit_answers(self, 
+                       username: str, 
+                       agent_code_url: str, 
+                       answers_payload: List[Dict[str, Any]]) -> str:
+        """Отправляет ответы на сервер оценки."""
+        # ИСПРАВЛЕНО: Используем agent_code вместо agent_code_url
         submission_data = {
             "username": username.strip(),
-            "agent_code": agent_code_url,
+            "agent_code": agent_code_url.strip(),  # Имя переменной осталось прежним, но поле изменено
             "answers": answers_payload
         }
         
-        status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
-        print(status_update)
+        print(f"Submitting {len(answers_payload)} answers to: {self.submit_url}")
+        max_retries = MAX_RETRIES
+        retry_delay = RETRY_DELAY
         
-        # Try submission with retries
-        for attempt in range(1, MAX_RETRIES + 1):
+        for attempt in range(1, max_retries + 1):
             try:
-                print(f"Submission attempt {attempt} of {MAX_RETRIES}...")
-                response = requests.post(self.submit_url, json=submission_data, timeout=60)
+                print(f"Submission attempt {attempt} of {max_retries}...")
+                response = requests.post(
+                    self.submit_url,
+                    json=submission_data,
+                    headers={"Content-Type": "application/json"},
+                    timeout=30
+                )
                 response.raise_for_status()
-                result_data = response.json()
                 
-                # Check if all evaluation results are N/A
-                if all(result_data.get(key, "N/A") == "N/A" for key in ["overall_score", "correct_answers", "total_questions"]):
-                    # If all values are N/A and we have retries left
-                    if attempt < MAX_RETRIES:
-                        print(f"Received N/A results. Waiting {RETRY_DELAY} seconds before retry...")
-                        time.sleep(RETRY_DELAY)
+                try:
+                    result = response.json()
+                    score = result.get("score")
+                    max_score = result.get("max_score")
+                    
+                    if score is not None and max_score is not None:
+                        self.correct_answers = score  # Обновляем счетчик правильных ответов
+                        return f"Evaluation complete! Score: {score}/{max_score}"
+                    else:
+                        print(f"Received N/A results. Waiting {retry_delay} seconds before retry...")
+                        time.sleep(retry_delay)
                         continue
+                        
+                except requests.exceptions.JSONDecodeError:
+                    print(f"Submission attempt {attempt}: Response was not JSON. Response: {response.text}")
+                    if attempt < max_retries:
+                        print(f"Waiting {retry_delay} seconds before retry...")
+                        time.sleep(retry_delay)
+                    else:
+                        return f"Submission successful, but response was not JSON. Response: {response.text}"
                     
-                    # If this was our last attempt, provide detailed information
-                    final_status = (
-                        f"Submission Successful, but results are pending!\n"
-                        f"User: {result_data.get('username')}\n"
-                        f"Overall Score: {result_data.get('overall_score', 'N/A')}\n"
-                        f"Correct Answers: {result_data.get('correct_answers', 'N/A')}\n"
-                        f"Total Questions: {result_data.get('total_questions', 'N/A')}\n\n"
-                        f"Note: Results show N/A. This might be due to:\n"
-                        f"1. Account activity restrictions (Hugging Face limits submissions from new accounts)\n"
-                        f"2. Temporary delay in processing (try checking the results page directly)\n"
-                        f"3. API evaluation service issue\n\n"
-                        f"Recommendations:\n"
-                        f"- Check your submission status at: {DEFAULT_API_URL}/results?username={username}\n"
-                        f"- Try again in a few minutes\n"
-                        f"- Check the course forum for any known service issues\n"
-                        f"- Ensure your Hugging Face account has been active for at least 24 hours"
-                    )
-                else:
-                    # We got actual results
-                    final_status = (
-                        f"Submission Successful!\n"
-                        f"User: {result_data.get('username')}\n"
-                        f"Overall Score: {result_data.get('overall_score', 'N/A')}\n"
-                        f"Correct Answers: {result_data.get('correct_answers', 'N/A')}\n"
-                        f"Total Questions: {result_data.get('total_questions', 'N/A')}\n"
-                    )
-                
-                print(final_status)
-                return final_status
-                
             except requests.exceptions.RequestException as e:
-                error_msg = f"Error submitting answers (attempt {attempt}): {e}"
-                print(error_msg)
-                
-                if attempt < MAX_RETRIES:
-                    print(f"Waiting {RETRY_DELAY} seconds before retry...")
-                    time.sleep(RETRY_DELAY)
-                else:
-                    return f"{error_msg}\n\nRecommendation: Please try again later or check your internet connection."
-            
-            except Exception as e:
-                error_msg = f"An unexpected error occurred during submission (attempt {attempt}): {e}"
-                print(error_msg)
-                
-                if attempt < MAX_RETRIES:
-                    print(f"Waiting {RETRY_DELAY} seconds before retry...")
-                    time.sleep(RETRY_DELAY)
+                print(f"Submission attempt {attempt} failed: {e}")
+                if attempt < max_retries:
+                    print(f"Waiting {retry_delay} seconds before retry...")
+                    time.sleep(retry_delay)
                 else:
-                    return f"{error_msg}\n\nRecommendation: Please try again later."
+                    return f"Error submitting answers after {max_retries} attempts: {e}"
         
-        # This should not be reached due to the return statements in the loop,
-        # but added as a fallback
-        return "Submission failed after multiple attempts. Please try again later."
-
-
-def run_and_submit_all(profile: gr.OAuthProfile | None, *args):
-    """
-    Fetches all questions, runs the agent on them, submits all answers, and displays the results.
-    This is the main function called by the Gradio interface.
-    """
-    # Check if user is logged in
-    if not profile:
-        return "Please Login to Hugging Face with the button.", None
+        # Если мы здесь, все попытки не удались, но не вызвали исключений
+        return "Submission Successful, but results are pending!"
     
-    username = profile.username
-    print(f"User logged in: {username}")
+    def _check_results(self, username: str) -> None:
+        """Проверяет результаты для подсчета правильных ответов."""
+        try:
+            results_url = f"{self.results_url}?username={username}"
+            print(f"Checking results at: {results_url}")
+            
+            response = requests.get(results_url, timeout=15)
+            if response.status_code == 200:
+                try:
+                    data = response.json()
+                    if isinstance(data, dict):
+                        score = data.get("score")
+                        if score is not None:
+                            self.correct_answers = int(score)
+                            print(f"✓ Correct answers: {self.correct_answers}/{self.total_questions}")
+                        else:
+                            print("Score information not available in results")
+                    else:
+                        print("Results data is not in expected format")
+                except:
+                    print("Could not parse results JSON")
+            else:
+                print(f"Could not fetch results, status code: {response.status_code}")
+        except Exception as e:
+            print(f"Error checking results: {e}")
     
-    # Get Space ID for code URL
-    space_id = os.getenv("SPACE_ID")
-    agent_code_url = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(f"Agent code URL: {agent_code_url}" )
+    def get_correct_answers_count(self) -> int:
+        """Возвращает количество правильных ответов."""
+        return self.correct_answers
     
-    # Initialize agent and evaluation runner
-    try:
-        # Use the LLM-based agent instead of the template-based one
-        agent = LLMGAIAAgent()
-        runner = EvaluationRunner()
-    except Exception as e:
-        error_msg = f"Error initializing agent or evaluation runner: {e}"
-        print(error_msg)
-        return error_msg, None
+    def get_total_questions_count(self) -> int:
+        """Возвращает общее количество вопросов."""
+        return self.total_questions
     
-    # Run evaluation
-    return runner.run_evaluation(agent, username, agent_code_url)
+    def print_evaluation_summary(self, username: str) -> None:
+        """Выводит сводку результатов оценки."""
+        print("\n===== EVALUATION SUMMARY =====")
+        print(f"User: {username}")
+        print(f"Overall Score: {self.correct_answers}/{self.total_questions}")
+        print(f"Correct Answers: {self.correct_answers}")
+        print(f"Total Questions: {self.total_questions}")
+        print(f"Accuracy: {(self.correct_answers / self.total_questions * 100) if self.total_questions > 0 else 0:.1f}%")
+        print("=============================\n")
 
 
-# --- Gradio Interface ---
-with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Agent Evaluation Runner (LLM-Enhanced)")
+def run_evaluation(username: str, 
+                  agent_code_url: str,
+                  model_name: str = "google/flan-t5-small",
+                  use_cache: bool = True) -> Dict[str, Any]:
+    """
+    Запускает полный процесс оценки с поддержкой кэширования
     
-    gr.Markdown("## Instructions:")
-    gr.Markdown("1. Log in to your Hugging Face account using the button below.")
-    gr.Markdown("2. Click 'Run Evaluation & Submit All Answers' to fetch questions, run the agent, and submit answers.")
-    gr.Markdown("3. View your score and detailed results in the output section.")
+    Args:
+        username: Имя пользователя Hugging Face
+        agent_code_url: URL кода агента (или код агента)
+        model_name: Название модели для использования
+        use_cache: Использовать ли кэширование ответов
+        
+    Returns:
+        Dict[str, Any]: Результаты оценки
+    """
+    start_time = time.time()
     
-    gr.Markdown("---")
+    # Инициализируем агента с поддержкой кэширования
+    agent = EnhancedGAIAAgent(model_name=model_name, use_cache=use_cache)
     
-    gr.Markdown("""
-    **Note:** This version uses a language model to generate responses. The evaluation process may take longer than the template-based version.
+    # Инициализируем runner с исправленным полем agent_code
+    runner = EvaluationRunner(api_url=DEFAULT_API_URL)
     
-    **Important:** If you receive 'N/A' results, this is usually due to:
-    - Account activity restrictions (Hugging Face limits submissions from new accounts)
-    - Temporary processing delays
-    - API evaluation service issues
+    # Запускаем оценку
+    result, results_log = runner.run_evaluation(agent, username, agent_code_url)
     
-    The system will automatically retry submissions if needed.
-    """)
+    # Проверяем результаты
+    runner._check_results(username)
     
-    with gr.Row():
-        login_button = gr.LoginButton(value="Sign in with Hugging Face")
+    # Выводим сводку
+    runner.print_evaluation_summary(username)
     
-    with gr.Row():
-        submit_button = gr.Button("Run Evaluation & Submit All Answers")
+    # Вычисляем время выполнения
+    elapsed_time = time.time() - start_time
     
-    with gr.Row():
-        with gr.Column():
-            output_status = gr.Textbox(label="Submission Result", lines=10)
-            output_results = gr.Dataframe(label="Questions and Agent Answers")
+    # Формируем результат
+    return {
+        "result": result,
+        "correct_answers": runner.get_correct_answers_count(),
+        "total_questions": runner.get_total_questions_count(),
+        "elapsed_time": f"{elapsed_time:.2f} seconds",
+        "results_url": f"{DEFAULT_API_URL}/results?username={username}",
+        "cache_used": use_cache
+    }
+
+
+def create_gradio_interface():
+    """
+    Создает Gradio интерфейс для запуска оценки
+    """
+    with gr.Blocks(title="GAIA Agent Evaluation") as demo:
+        gr.Markdown("# GAIA Agent Evaluation with Caching")
+        
+        with gr.Row():
+            with gr.Column():
+                username = gr.Textbox(label="Hugging Face Username")
+                agent_code_url = gr.Textbox(label="Agent Code URL or Code", lines=10)
+                model_name = gr.Dropdown(
+                    label="Model",
+                    choices=["google/flan-t5-small", "google/flan-t5-base", "google/flan-t5-large"],
+                    value="google/flan-t5-small"
+                )
+                use_cache = gr.Checkbox(label="Use Answer Cache", value=True)
+                
+                run_button = gr.Button("Run Evaluation & Submit All Answers")
+            
+            with gr.Column():
+                result_text = gr.Textbox(label="Result", lines=2)
+                correct_answers = gr.Number(label="Correct Answers")
+                total_questions = gr.Number(label="Total Questions")
+                elapsed_time = gr.Textbox(label="Elapsed Time")
+                results_url = gr.Textbox(label="Results URL")
+                cache_status = gr.Textbox(label="Cache Status")
+        
+        run_button.click(
+            fn=run_evaluation,
+            inputs=[username, agent_code_url, model_name, use_cache],
+            outputs=[
+                result_text,
+                correct_answers,
+                total_questions,
+                elapsed_time,
+                results_url,
+                cache_status
+            ]
+        )
     
-    submit_button.click(run_and_submit_all, inputs=[login_button], outputs=[output_status, output_results])
+    return demo
+
 
 if __name__ == "__main__":
-    demo.launch()
+    # Создаем и запускаем Gradio интерфейс
+    demo = create_gradio_interface()
+    demo.launch(share=True)