Update app.py

app.py

@@ -10,15 +10,190 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent initialized.")
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
 
+class GAIAAgent:
+    def __init__(self):
+        self.setup_models()
+        self.setup_agent()
+    
+    def setup_models(self):
+        """Configura i modelli necessari"""
+        # Gemini per capacità multimodali
+        genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+        self.gemini_model = genai.GenerativeModel('gemini-2.0-flash-exp')
+        
+        # Pipeline per trascrizione audio
+        self.whisper_pipeline = pipeline(
+            "automatic-speech-recognition",
+            model="openai/whisper-large-v3",
+            device_map="auto"
+        )
+    
+    def setup_agent(self):
+        """Configura l'agente con tools ottimizzati"""
+        self.agent = CodeAgent(
+            tools=[
+                self.analyze_image,
+                self.transcribe_audio,
+                self.extract_text_from_file,
+                self.web_search,
+                self.calculate_precise
+            ],
+            model="microsoft/DialoGPT-medium",
+            max_iterations=10,
+            verbosity=2
+        )
+    
+    @tool
+    def analyze_image(self, image_path: str, question: str) -> str:
+        """Analizza immagini usando Gemini Vision per domande GAIA"""
+        try:
+            import PIL.Image
+            image = PIL.Image.open(image_path)
+            
+            prompt = f"""
+            Analizza questa immagine per rispondere alla domanda: {question}
+            
+            Fornisci una risposta precisa e dettagliata. Se la domanda richiede:
+            - Conteggio di oggetti: conta accuratamente
+            - Identificazione di testo: trascrivi esattamente
+            - Descrizione di elementi: sii specifico e ordinato
+            - Posizioni relative: usa riferimenti chiari (orario, coordinate)
+            
+            Risposta:
+            """
+            
+            response = self.gemini_model.generate_content([prompt, image])
+            return response.text
+        except Exception as e:
+            return f"Errore nell'analisi dell'immagine: {str(e)}"
+    
+    @tool
+    def transcribe_audio(self, audio_path: str) -> str:
+        """Trascrizione audio ad alta precisione"""
+        try:
+            result = self.whisper_pipeline(audio_path)
+            return result["text"]
+        except Exception as e:
+            return f"Errore nella trascrizione: {str(e)}"
+    
+    @tool
+    def extract_text_from_file(self, file_path: str) -> str:
+        """Estrae testo da vari formati di file"""
+        try:
+            if file_path.endswith('.txt'):
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    return f.read()
+            elif file_path.endswith('.csv'):
+                import pandas as pd
+                df = pd.read_csv(file_path)
+                return df.to_string()
+            elif file_path.endswith(('.xlsx', '.xls')):
+                import pandas as pd
+                df = pd.read_excel(file_path)
+                return df.to_string()
+            else:
+                return "Formato file non supportato"
+        except Exception as e:
+            return f"Errore nella lettura del file: {str(e)}"
+    
+    @tool
+    def web_search(self, query: str) -> str:
+        """Ricerca web per informazioni aggiornate"""
+        try:
+            # Implementa ricerca web usando API disponibili
+            # Per semplicità, qui usiamo un placeholder
+            return f"Risultati ricerca per: {query}"
+        except Exception as e:
+            return f"Errore nella ricerca: {str(e)}"
+    
+    @tool
+    def calculate_precise(self, expression: str) -> str:
+        """Calcoli matematici precisi"""
+        try:
+            # Sanitizza l'espressione per sicurezza
+            safe_expr = re.sub(r'[^0-9+\-*/().\s]', '', expression)
+            result = eval(safe_expr)
+            return str(result)
+        except Exception as e:
+            return f"Errore nel calcolo: {str(e)}"
+    
+    def solve_question(self, question: str, file_path: Optional[str] = None) -> str:
+        """Risolve una domanda GAIA con approccio ottimizzato"""
+        
+        # Prompt engineering ottimizzato per GAIA Level 1[3][8]
+        system_prompt = f"""
+        Sei un agente AI specializzato nel risolvere domande del benchmark GAIA Level 1.
+        
+        OBIETTIVO: Fornire risposte ESATTE che corrispondano perfettamente al formato richiesto.
+        
+        REGOLE CRITICHE:
+        1. Leggi attentamente la domanda e identifica il formato di risposta richiesto
+        2. Se c'è un file allegato, analizzalo completamente prima di rispondere
+        3. Per domande numeriche: fornisci solo il numero (es. "42", non "La risposta è 42")
+        4. Per liste: usa il formato esatto richiesto (virgole, punti, etc.)
+        5. Per date: usa il formato specificato nella domanda
+        6. NON aggiungere prefissi come "Risposta:", "Il risultato è:", etc.
+        
+        STRATEGIA DI RISOLUZIONE:
+        1. Analizza la domanda per identificare il tipo di task
+        2. Pianifica i passaggi necessari
+        3. Usa gli strumenti appropriati
+        4. Verifica la risposta prima di fornirla
+        5. Formatta la risposta nel modo ESATTO richiesto
+        
+        DOMANDA: {question}
+        {f"FILE ALLEGATO: {file_path}" if file_path else ""}
+        
+        Risolvi step-by-step e fornisci SOLO la risposta finale nel formato richiesto.
+        """
+        
+        try:
+            # Esegui l'agente con il prompt ottimizzato
+            response = self.agent.run(system_prompt)
+            
+            # Post-processing per garantire formato corretto
+            answer = self.clean_answer(response, question)
+            
+            return answer
+            
+        except Exception as e:
+            return f"Errore nella risoluzione: {str(e)}"
+    
+    def clean_answer(self, raw_answer: str, question: str) -> str:
+        """Pulisce e formatta la risposta per EXACT MATCH"""
+        
+        # Rimuovi prefissi comuni
+        prefixes_to_remove = [
+            "Final Answer:", "Risposta:", "Answer:", "Il risultato è:",
+            "La risposta è:", "Risposta finale:", "ANSWER:", "RISPOSTA:"
+        ]
+        
+        cleaned = raw_answer.strip()
+        for prefix in prefixes_to_remove:
+            if cleaned.startswith(prefix):
+                cleaned = cleaned[len(prefix):].strip()
+        
+        # Gestione formati specifici basati sulla domanda
+        if "comma-separated" in question.lower():
+            # Assicura formato lista separata da virgole
+            cleaned = re.sub(r'\s*,\s*', ', ', cleaned)
+        
+        if "number" in question.lower() or "how many" in question.lower():
+            # Estrai solo numeri per domande numeriche
+            numbers = re.findall(r'\d+(?:\.\d+)?', cleaned)
+            if numbers:
+                cleaned = numbers[0]
+        
+        if "yes" in question.lower() and "no" in question.lower():
+            # Domande yes/no
+            if "yes" in cleaned.lower():
+                cleaned = "Yes"
+            elif "no" in cleaned.lower():
+                cleaned = "No"
+        
+        return cleaned.strip()
+        
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,