Update agent.py

agent.py

@@ -1,187 +1,239 @@
 import os
-import logging
-from typing import List, Dict, Any, Optional
+import openai
+import wikipedia
+from duckduckgo_search import DDGS
+import arxiv
+import json
+import re
 
-from smolagents import CodeAgent, tool, InferenceClientModel
+# Carica la chiave API di OpenAI dalla variabile d'ambiente
+# Per i test locali, puoi usare python-dotenv e un file .env
+# from dotenv import load_dotenv
+# load_dotenv()
+# openai.api_key = os.getenv("OPENAI_API_KEY") # La libreria OpenAI >1.0.0 lo gestisce automaticamente
 
-# Configurazione del logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger("GaiaAgent")
+# Se la chiave API non è impostata tramite variabile d'ambiente,
+# la libreria OpenAI cercherà di trovarla.
+# È buona pratica assicurarsi che sia disponibile.
+if not os.getenv("OPENAI_API_KEY"):
+    print("ATTENZIONE: La variabile d'ambiente OPENAI_API_KEY non è impostata.")
+    print("L'agente potrebbe non funzionare correttamente senza una chiave API OpenAI valida.")
+
+
+MAX_WIKIPEDIA_RESULTS = 3
+MAX_DDG_RESULTS = 4
+MAX_ARXIV_RESULTS = 3
+MAX_TOOL_ITERATIONS = 7 # Numero massimo di cicli di chiamata agli strumenti
 
 class GaiaAgent:
-    """
-    Agente AI per superare il test GAIA livello 1.
-    Utilizza smolagents con capacità di ricerca Wikipedia, DuckDuckGo, arXiv e code execution.
-    """
-    
-    def __init__(self):
-        logger.info("Inizializzazione GaiaAgent")
-        
-        # Verifica della chiave API
-        api_key = os.environ.get("OPENAI_API_KEY")
-        if not api_key:
-            logger.error("OPENAI_API_KEY non trovata nelle variabili d'ambiente")
-            raise ValueError("OPENAI_API_KEY non trovata. Configura il secret in Hugging Face.")
-        
-        # Configurazione del modello LLM
-        self.model = InferenceClientModel(
-            model="gpt-4.1",
-            api_key=api_key
+    def __init__(self, model_name="gpt-4o"):
+        self.model_name = model_name
+        self.client = openai.OpenAI() # Inizializza il client OpenAI qui
+        print(f"GaiaAgent initialized with model: {self.model_name}")
+        if not self.client.api_key: # Verifica se la chiave è stata caricata dal client
+             print("WARNING: OpenAI API key not found by the client. Ensure OPENAI_API_KEY is set.")
+
+    def _call_openai_api(self, messages, tools=None, tool_choice=None):
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=messages,
+                tools=tools,
+                tool_choice=tool_choice,
+                temperature=0.1, # Bassa temperatura per risposte più deterministiche e fattuali
+            )
+            return response
+        except openai.APIError as e:
+            print(f"Errore API OpenAI: {e}")
+            # Potresti voler restituire un messaggio di errore specifico o sollevare l'eccezione
+            return f"Errore durante la chiamata all'API OpenAI: {str(e)}"
+        except Exception as e:
+            print(f"Errore imprevisto durante la chiamata OpenAI API: {e}")
+            return f"Errore imprevisto durante la chiamata OpenAI API: {str(e)}"
+
+
+    def _execute_python_code(self, code_string: str) -> str:
+        """Esegue codice Python e restituisce l'output o un errore."""
+        print(f"Esecuzione codice Python (primi 200 caratteri): {code_string[:200]}...")
+        try:
+            # Rimuovi i backtick e 'python' se presenti (comune nell'output LLM)
+            code_string = re.sub(r"^```python\n", "", code_string)
+            code_string = re.sub(r"\n```$", "", code_string)
+            code_string = code_string.strip()
+
+            # Prepara un ambiente per l'esecuzione del codice
+            # Reindirizza stdout per catturare i print
+            import io
+            from contextlib import redirect_stdout
+            f = io.StringIO()
+            with redirect_stdout(f):
+                exec(code_string, {}) # Usa un dizionario vuoto per globals per un minimo di isolamento
+            s = f.getvalue()
+
+            # Se non c'è output esplicito da print(), indica che l'esecuzione è avvenuta
+            if not s:
+                s = "Codice eseguito con successo, nessun output esplicito (print)."
+            print(f"Esecuzione codice riuscita. Output (primi 200 caratteri): {s[:200]}")
+            return s
+        except Exception as e:
+            print(f"Errore durante l'esecuzione del codice Python: {e}")
+            return f"Errore nell'esecuzione del codice: {str(e)}"
+
+    def _search_wikipedia(self, query: str) -> str:
+        print(f"Ricerca Wikipedia per: {query}")
+        try:
+            wikipedia.set_lang("en") # Le domande GAIA sono in inglese
+            results = wikipedia.search(query, results=MAX_WIKIPEDIA_RESULTS)
+            if not results:
+                return "Nessun risultato trovato su Wikipedia."
+            summaries = []
+            for res_title in results:
+                try:
+                    page = wikipedia.page(res_title, auto_suggest=False, preload=True)
+                    summary_text = page.summary.replace("\n", " ")[:700]
+                    summaries.append(f"Title: {page.title}\nSummary: {summary_text}...")
+                except wikipedia.exceptions.DisambiguationError as e:
+                    options = ", ".join(e.options[:3])
+                    summaries.append(f"Pagina di disambiguazione per '{res_title}': Le opzioni includono {options}. Prova una query più specifica.")
+                except wikipedia.exceptions.PageError:
+                    summaries.append(f"Pagina '{res_title}' non trovata su Wikipedia.")
+                except Exception as e_page:
+                    summaries.append(f"Errore nel recuperare la pagina '{res_title}': {str(e_page)}")
+            return "\n\n".join(summaries) if summaries else "Nessun sommario trovato per i risultati di Wikipedia."
+        except Exception as e:
+            return f"Errore durante la ricerca su Wikipedia: {str(e)}"
+
+    def _search_duckduckgo(self, query: str) -> str:
+        print(f"Ricerca DuckDuckGo per: {query}")
+        try:
+            with DDGS() as ddgs:
+                # Usare ddgs.text per risultati testuali, o ddgs.answers per risposte più dirette se disponibili
+                results = list(ddgs.text(query, max_results=MAX_DDG_RESULTS))
+            if not results:
+                return "Nessun risultato trovato su DuckDuckGo."
+            return "\n\n".join([f"Title: {r['title']}\nSnippet: {r['body'][:500]}...\nURL: {r['href']}" for r in results])
+        except Exception as e:
+            return f"Errore durante la ricerca su DuckDuckGo: {str(e)}"
+
+    def _search_arxiv(self, query: str) -> str:
+        print(f"Ricerca Arxiv per: {query}")
+        try:
+            search = arxiv.Search(
+                query=query,
+                max_results=MAX_ARXIV_RESULTS,
+                sort_by=arxiv.SortCriterion.Relevance
+            )
+            client = arxiv.Client()
+            results_data = []
+            for r in client.results(search):
+                authors = ", ".join([str(a) for a in r.authors])
+                results_data.append(f"Title: {r.title}\nAuthors: {authors}\nPublished: {r.published.date()}\nSummary: {r.summary.replace_summary_newline_chars_with_spaces()[:700]}...\nLink: {r.pdf_url}")
+            return "\n\n".join(results_data) if results_data else "Nessun risultato trovato su Arxiv."
+        except Exception as e:
+            return f"Errore durante la ricerca su Arxiv: {str(e)}"
+
+    def __call__(self, question: str) -> str:
+        print(f"GaiaAgent ha ricevuto la domanda (primi 100 caratteri): {question[:100]}...")
+        if not self.client.api_key:
+            return "Errore: OPENAI_API_KEY non configurata o non valida per l'agente."
+
+        tools = [
+            {"type": "function", "function": {
+                "name": "search_wikipedia",
+                "description": "Cerca informazioni su Wikipedia. Utile per conoscenza generale, fatti, definizioni, storia.",
+                "parameters": {"type": "object", "properties": {"query": {"type": "string", "description": "La query di ricerca per Wikipedia."}}, "required": ["query"]}}},
+            {"type": "function", "function": {
+                "name": "search_duckduckgo",
+                "description": "Cerca sul web usando DuckDuckGo. Utile per eventi attuali, siti specifici, o quando Wikipedia non è sufficiente.",
+                "parameters": {"type": "object", "properties": {"query": {"type": "string", "description": "La query di ricerca per DuckDuckGo."}}, "required": ["query"]}}},
+            {"type": "function", "function": {
+                "name": "search_arxiv",
+                "description": "Cerca su Arxiv articoli scientifici e preprint (fisica, matematica, informatica, ecc.).",
+                "parameters": {"type": "object", "properties": {"query": {"type": "string", "description": "La query di ricerca per Arxiv (es. autore, titolo, parole chiave)."}}, "required": ["query"]}}},
+            {"type": "function", "function": {
+                "name": "execute_python_code",
+                "description": "Esegue una stringa di codice Python e restituisce il suo output. Usare per calcoli, manipolazione dati o qualsiasi task che richieda esecuzione di codice. Assicurarsi che il codice stampi il risultato su stdout. Il codice viene eseguito in un ambiente stateless. NON usare per installare pacchetti o interagire con file system.",
+                "parameters": {"type": "object", "properties": {"code_string": {"type": "string", "description": "Il codice Python da eseguire. Deve essere uno script Python valido. Esempio: 'print(sum([i for i in range(101)]))'"}}, "required": ["code_string"]}}}
+        ]
+
+        system_prompt = (
+            "Sei GaiaAgent, un assistente AI progettato per rispondere a domande in modo accurato e completo, specialmente per task complessi come quelli di GAIA. "
+            "Hai accesso ai seguenti strumenti: ricerca Wikipedia, ricerca web DuckDuckGo, ricerca Arxiv e un interprete di codice Python. "
+            "Segui questi passaggi per rispondere alla domanda dell'utente:\n"
+            "1. **Analizza la Domanda**: Comprendi a fondo cosa viene chiesto. Se la domanda è complessa, scomponila in sotto-problemi.\n"
+            "2. **Pianifica l'Uso degli Strumenti**: Decidi quali strumenti sono più appropriati e in quale ordine. Puoi usare più strumenti in sequenza.\n"
+            "   - `search_wikipedia`: per conoscenza generale consolidata.\n"
+            "   - `search_duckduckgo`: per informazioni recenti, argomenti di nicchia, o per confermare/trovare URL specifici.\n"
+            "   - `search_arxiv`: per ricerca scientifica e tecnica.\n"
+            "   - `execute_python_code`: per calcoli, elaborazione di dati testuali/numerici, o simulazioni. Il codice deve stampare esplicitamente i risultati.\n"
+            "3. **Esegui e Itera**: Usa gli strumenti. Se uno strumento non fornisce l'informazione necessaria, valuta se riformulare la query, provare un altro strumento, o concludere che l'informazione non è reperibile con gli strumenti attuali.\n"
+            "4. **Sintetizza e Rispondi**: Combina le informazioni raccolte e la tua conoscenza interna per formulare una risposta finale chiara, concisa e che risponda direttamente alla domanda originale. Se non riesci a trovare una risposta definitiva, indicalo chiaramente.\n"
+            "Limita il numero di chiamate agli strumenti a un massimo di {} iterazioni per domanda. ".format(MAX_TOOL_ITERATIONS) +
+            "Fornisci solo la risposta finale senza commentare il processo di ragionamento o l'uso degli strumenti, a meno che non sia esplicitamente richiesto o necessario per chiarire la provenienza di un'informazione cruciale."
         )
-        
-        # Definizione dei tools necessari
-        @tool
-        def search_wikipedia(query: str) -> str:
-            """
-            Cerca informazioni su Wikipedia.
-            
-            Args:
-                query: La query di ricerca
-                
-            Returns:
-                I risultati della ricerca
-            """
-            import wikipedia
-            try:
-                return wikipedia.summary(query, sentences=5)
-            except Exception as e:
-                return f"Errore nella ricerca su Wikipedia: {str(e)}"
-        
-        @tool
-        def search_web(query: str) -> str:
-            """
-            Cerca informazioni sul web usando DuckDuckGo.
-            
-            Args:
-                query: La query di ricerca
-                
-            Returns:
-                I risultati della ricerca
-            """
-            from duckduckgo_search import DDGS
-            try:
-                with DDGS() as ddgs:
-                    results = list(ddgs.text(query, max_results=5))
-                return str(results)
-            except Exception as e:
-                return f"Errore nella ricerca web: {str(e)}"
-        
-        @tool
-        def search_arxiv(query: str) -> str:
-            """
-            Cerca articoli scientifici su arXiv.
-            
-            Args:
-                query: La query di ricerca
-                
-            Returns:
-                I risultati della ricerca
-            """
-            import arxiv
-            try:
-                search = arxiv.Search(query=query, max_results=5)
-                results = []
-                for result in search.results():
-                    results.append({
-                        "title": result.title,
-                        "authors": ", ".join(author.name for author in result.authors),
-                        "summary": result.summary[:200] + "..." if len(result.summary) > 200 else result.summary
-                    })
-                return str(results)
-            except Exception as e:
-                return f"Errore nella ricerca su arXiv: {str(e)}"
-        
-        @tool
-        def execute_code(code: str) -> str:
-            """
-            Esegue codice Python.
+
+        messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": question}]
+
+        for iteration in range(MAX_TOOL_ITERATIONS):
+            print(f"Agente: Chiamata OpenAI. Iterazione {iteration + 1}. Ultimo messaggio: {messages[-1]['role']}")
             
-            Args:
-                code: Il codice da eseguire
+            api_response_or_error = self._call_openai_api(messages, tools=tools, tool_choice="auto")
+
+            if isinstance(api_response_or_error, str): # Errore gestito da _call_openai_api
+                return api_response_or_error # Restituisce il messaggio di errore
+
+            response_message = api_response_or_error.choices[0].message
+
+            if response_message.tool_calls:
+                print(f"OpenAI suggerisce chiamate a strumenti: {[tc.function.name for tc in response_message.tool_calls]}")
+                messages.append(response_message) # Aggiungi la risposta dell'assistente con le richieste di tool
                 
-            Returns:
-                Il risultato dell'esecuzione
-            """
-            import sys
-            from io import StringIO
-            import traceback
-            
-            old_stdout = sys.stdout
-            redirected_output = sys.stdout = StringIO()
-            
-            try:
-                exec(code)
-                sys.stdout = old_stdout
-                return redirected_output.getvalue()
-            except Exception as e:
-                sys.stdout = old_stdout
-                return f"Errore nell'esecuzione del codice: {str(e)}\n{traceback.format_exc()}"
-        
-        # Lista dei tools
-        tools = [search_wikipedia, search_web, search_arxiv, execute_code]
-        
-        # Istruzioni specifiche per il formato delle risposte
-        system_prompt = """You are a helpful assistant tasked with answering questions using a set of tools.
-Your final answer should be a number OR as few words as possible OR a comma separated list of numbers and/or strings.
-If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise.
-If you are asked for a string, don't use articles, neither abbreviations, and write digits in plain text unless specified otherwise.
-Return ONLY the final answer line."""
-        
-        # Creazione dell'agente
-        self.agent = CodeAgent(
-            model=self.model,
-            tools=tools,
-            system_prompt=system_prompt,
-            verbose=True  # Per logging essenziale
-        )
-        
-        logger.info("GaiaAgent inizializzato con successo")
-    
-    def __call__(self, question: str) -> str:
-        """
-        Processa una domanda e restituisce la risposta.
-        
-        Args:
-            question: La domanda da processare
-            
-        Returns:
-            La risposta alla domanda
-        """
-        logger.info(f"Elaborazione domanda: {question[:50]}...")
-        
-        try:
-            # Esecuzione dell'agente sulla domanda
-            response = self.agent.run(question)
-            
-            # Estrazione della risposta finale
-            answer = self._extract_final_answer(response)
-            
-            logger.info(f"Risposta generata: {answer[:50]}...")
-            return answer
-            
-        except Exception as e:
-            logger.error(f"Errore durante l'elaborazione della domanda: {str(e)}")
-            return f"Errore: {str(e)}"
-    
-    def _extract_final_answer(self, response: Dict[str, Any]) -> str:
-        """
-        Estrae la risposta finale dal risultato dell'agente.
-        
-        Args:
-            response: Il risultato completo dell'agente
+                for tool_call in response_message.tool_calls:
+                    function_name = tool_call.function.name
+                    try:
+                        function_args = json.loads(tool_call.function.arguments)
+                    except json.JSONDecodeError as e:
+                        print(f"Errore nel decodificare gli argomenti JSON per {function_name}: {e}")
+                        tool_output = f"Errore: argomenti JSON invalidi per {function_name}."
+                        messages.append({"tool_call_id": tool_call.id, "role": "tool", "name": function_name, "content": tool_output})
+                        continue # Salta al prossimo tool_call o iterazione
+
+                    print(f"Esecuzione strumento: {function_name} con argomenti: {function_args}")
+                    tool_output = ""
+                    if function_name == "search_wikipedia":
+                        tool_output = self._search_wikipedia(query=function_args.get("query",""))
+                    elif function_name == "search_duckduckgo":
+                        tool_output = self._search_duckduckgo(query=function_args.get("query",""))
+                    elif function_name == "search_arxiv":
+                        tool_output = self._search_arxiv(query=function_args.get("query",""))
+                    elif function_name == "execute_python_code":
+                        tool_output = self._execute_python_code(code_string=function_args.get("code_string",""))
+                    else:
+                        tool_output = f"Strumento sconosciuto: {function_name}"
+                    
+                    print(f"Output strumento {function_name} (primi 100 caratteri): {str(tool_output)[:100]}")
+                    messages.append({"tool_call_id": tool_call.id, "role": "tool", "name": function_name, "content": str(tool_output)})
             
-        Returns:
-            La risposta finale estratta
-        """
-        # Estrazione della risposta finale dal risultato dell'agente
-        if isinstance(response, dict) and "output" in response:
-            return response["output"].strip()
-        elif isinstance(response, str):
-            return response.strip()
-        else:
-            logger.warning(f"Formato di risposta inatteso: {type(response)}")
-            # Tentativo di conversione a stringa
-            return str(response).strip()
+            else: # Nessuna chiamata a strumento, l'LLM dovrebbe aver fornito una risposta finale
+                final_answer = response_message.content
+                if final_answer:
+                    print(f"Agente restituisce risposta finale (primi 200 caratteri): {final_answer[:200]}")
+                    return final_answer
+                else: # Risposta vuota, prova a forzare una risposta basata sulla cronologia
+                    print("L'LLM non ha chiamato strumenti e non ha fornito contenuto. Tento di forzare una risposta.")
+                    messages.append({"role": "user", "content": "Per favore, fornisci la migliore risposta possibile basata sulle informazioni raccolte finora, senza usare altri strumenti."})
+                    final_attempt_response = self._call_openai_api(messages) # No tools this time
+                    if isinstance(final_attempt_response, str): return final_attempt_response # Errore
+                    if final_attempt_response and final_attempt_response.choices[0].message.content:
+                        return final_attempt_response.choices[0].message.content
+                    return "L'agente ha ricevuto una risposta finale vuota e non è riuscito a generarne una alternativa."
+
+
+        print("L'agente ha raggiunto il numero massimo di iterazioni degli strumenti.")
+        # Tenta un'ultima chiamata per sintetizzare
+        messages.append({"role": "user", "content": "Hai raggiunto il limite di utilizzo degli strumenti. Per favore, fornisci la migliore risposta possibile basata sulle informazioni raccolte finora."})
+        final_summary_response = self._call_openai_api(messages) # No tools
+        if isinstance(final_summary_response, str): return final_summary_response # Errore
+        if final_summary_response and final_summary_response.choices[0].message.content:
+            return final_summary_response.choices[0].message.content
+        return "L'agente ha raggiunto il numero massimo di iterazioni e non è riuscito a formulare una risposta finale."