ffff

my_tools.py

@@ -1,5 +1,3 @@
-# my_tools.py
-
 import os
 import math
 import time
@@ -7,14 +5,7 @@ import asyncio
 import subprocess
 import requests
 import pandas as pd
-from io import StringIO, BytesIO #acc = ""
-            for chunk in stream:
-                delta = getattr(chunk, "text", "")
-                if not delta and hasattr(chunk, 'parts') and chunk.parts:
-                    delta = chunk.parts[0].text
-                if delta:
-                    acc += delta
-                    yield CompletionResponse(text=acc, delta BytesIO para leer Excel de contenido web si fuera necesario
+from io import StringIO, BytesIO
 from bs4 import BeautifulSoup
 from duckduckgo_search import DDGS
 import wikipedia
@@ -22,156 +13,64 @@ from pydantic import Field
 import google.generativeai as genai
 
 # LlamaIndex imports
-from llama_index.core.llms import ChatMessage, LLMMetadata, LLM, CompletionResponse=delta)
-        return gen()
-
-    async def astream_complete(self, prompt, formatted=False, **kwargs):
-        return await asyncio.to_thread(self.stream_complete, prompt, formatted=formatted, **kwargs)
-
-    def astream_chat(self, messages: list[ChatMessage], **kwargs):
-ChatMessage.message = property(lambda self: self)
+from llama_index.core.llms import ChatMessage, LLMMetadata, LLM, CompletionResponse
 from llama_index.core.tools import FunctionTool
 from llama_index.core.agent import ReActAgent
-from llama_index.core.callbacks.llama_debug import
-        return self.stream_chat(messages, **kwargs)
+from llama_index.core.callbacks.llama_debug import LlamaDebugHandler
 
 # -------------------------------------------------------------------
-# 2) Herramientas (con nuevas herramientas y mejoras)
-# -------------------------------------------------------------------
-HEADERS = {'User- LlamaDebugHandler
-
-# -------------------------------------------------------------------
-# 1) GeminiLLM personalizado (SIN CAMBIOS - Asumimos que está bien)
+# 1) GeminiLLM personalizado
 # -------------------------------------------------------------------
+ChatMessage.message = property(lambda self: self.content)
 class GeminiLLM(LLM):
-    Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/model_name: str = Field(default="models/gemini-1.5-flash-latest")
-537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'}
-
-def buscar_web(query: str, max_attempts: int    temperature: float = Field(default=0.0) # Mantenemos 0.0 para consistencia
+    model_name: str = Field(default="models/gemini-1.5-flash-latest")
+    temperature: float = Field(default=0.0)
 
     class Config:
         extra = "allow"
 
     def __init__(self, **kwargs):
-        super().__ = 2, num_results: int = 5) -> str: # MEJORA: num_results aumentado
-    for i in range(max_attempts):
-        try:
-            with DDGS(headers=HEADERSinit__(**kwargs)
+        super().__init__(**kwargs)
         key = os.getenv("GEMINI_API_KEY")
         if not key:
             raise ValueError("GEMINI_API_KEY no configurada")
         genai.configure(api_key=key)
-        self._gen_cfg = genai.types.GenerationConfig(temperature=, timeout=25) as ddgs:
-                # MEJORA: 'y' (año) puede ser demasiado restrictivo, quitamos timelimit por defecto.
-                # El LLM puede especificarlo en la query si es necesario ("self.temperature)
+        self._gen_cfg = genai.types.GenerationConfig(temperature=self.temperature)
         self._model = genai.GenerativeModel(
             model_name=self.model_name,
             generation_config=self._gen_cfg
         )
-        # Asegurar que LlamaDebugHandler senoticias recientes de X")
-                results = list(ddgs.text(query, region='es-es', safesearch='moderate', max_results=num_results))
-                if results:
-                    return "\n". añade si no hay otros handlers
-        # Lo quitamos de aquí porque es mejor añadirlo explícitamente aljoin(f"Título: {r['title']}\nCuerpo: {r['body']}\nFuente crear el agente o el LLM si se desea
-        # if not self.callback_manager.handlers:
-        #: {r['href']}" for r in results)
-            return "No se encontraron resultados para la búsqueda web."
-        except Exception as e:
-            if i < max_attempts - 1:
-                time.     self.callback_manager.add_handler(LlamaDebugHandler())
+        if not self.callback_manager.handlers:
+            self.callback_manager.add_handler(LlamaDebugHandler())
 
     @property
     def metadata(self):
         return LLMMetadata(
-            context_window=1048576sleep(3 * (i + 1)) # Reducido ligeramente el sleep
-            else:
-                return f, # Gemini 1.5 Flash tiene 1M de tokens
+            context_window=1048576,
             num_output=8192,
-"Error buscar_web tras {max_attempts} intentos: {e}"
-
-def reverse_text(text: str)            is_chat_model=True,
-            is_function_calling_model=True, # Gemini es -> str:
-    return text[::-1]
-
-def analyze_table(table_md: str, question: str) -> bueno en esto
+            is_chat_model=True,
+            is_function_calling_model=True,
             model_name=self.model_name,
         )
 
-    def chat(self, messages, str:
-    try:
-        lines = [l for l in table_md.splitlines() if l **kwargs):
+    def chat(self, messages, **kwargs):
         hist = []
         for m in messages[:-1]:
-            role = "user".strip()]
-        lines = [l for l in lines if not l.strip().startswith('|') or '---' not in l]
-        rows = []
-        for l in lines:
-            parts = [c if m.role == "user" else "model"
-            # Asegurar que content es string
-            content_str = str(m.content) if m.content is not None else ""
-            hist.append({"role.strip() for c in l.strip().strip('|').split('|')]
-            rows.append(parts)
-        if not rows or len(rows) < 1: # Comprobación de tabla vacía o solo cabecera
-             ": role, "parts":[{"text": content_str}]})
-        
-        last_content_str = str(messages[-1].content) if messages[-1].content is not None else ""
+            role = "user" if m.role == "user" else "model"
+            hist.append({"role": role, "parts": [{"text": str(m.content)}]})
+        last = str(messages[-1].content)
         session = self._model.start_chat(history=hist)
         try:
-            resp = session.send_message(last_content_str)
+            resp = session.send_message(last)
             return ChatMessage(role="assistant", content=resp.text)
-        except Exceptionreturn "Error analyze_table: La tabla Markdown parece estar vacía o mal formateada después de la limpieza."
-        df = pd.DataFrame(rows[1:], columns=rows[0])
-        
-        if 'conmut' in question.lower():
-            S = rows[0][1:]
-            counter = set()
-            for x_label in S:
-                for y_label in S:
-                    # Asegurarse de que los as e:
-            # print(f"DEBUG Gemini chat error: {e}") # Para depuración local
-            # print(f"DEBUG History: {hist}")
-            # print(f"DEBUG Last message: {last_content_str}")
+        except Exception as e:
             return ChatMessage(role="assistant", content=f"Error Gemini: {e}")
 
     async def achat(self, messages, **kwargs):
         return await asyncio.to_thread(self.chat, messages, **kwargs)
 
-    # stream_chat, complete, acomplete, stream_complete, astream_ índices de las columnas existan
-                    if x_label not in df.columns or y_label not in df.columns:
-                        continue # Saltar si alguna columna no existe (podría pasar con tablas mal formadas)
-                    
-                    # Localizar valores, asegurándose de que las filas (indexadas por la primera columna) existan
-                    x_row = df[df[rows[0][0]] == x_label]
-                    y_row = df[df[rows[0][0]] == y_label]
-
-                    if x_row.empty or y_rowcomplete, astream_chat (SIN CAMBIOS)
-    # ... (mantener el código de estos métodos igual que en el original) ...
-    def stream_chat(self, messages, **kwargs):
-        hist = []
-        for m in messages[:-1]:
-            role = "user" if m.role=="user" else "model"
-            content_str = str(m.content) if m.content is not None else ""
-            hist.append({"role": role, "parts":[{"text":content_str}]})
-        last_content_str = str(messages[-1].content) if messages[-1].content is not None else ""
-        session = self._model.start_chat(history=hist)
-        stream = session.send_message(last.empty:
-                        continue # Saltar si no se encuentra la fila para x_label o y_label
-                        
-                    val_a_series = x_row[y_label]
-                    val_b_series = y_row[x_label]
-
-                    if val_a_series.empty or val_b_series.empty:
-                        continue # Saltar si la celda específica está vacía o no se encuentra
-
-                    a = val_a_series.iat[0]
-                    b = val_b_series.iat[0]
-                    
-                    if a != b:
-                        counter.update([x_label, y_label])
-            return ', '.join(sorted(list(counter))) or 'La operación es conmutativa (no hay contraejemplos).'
-        return df.to_csv(index=False)
-    except IndexError as e:
-        return f"Error analyze_table_content_str, stream=True)
+    def stream_complete(self, prompt, formatted=False, **kwargs):
+        stream = self._model.generate_content(str(prompt), stream=True)
         def gen():
             acc = ""
             for chunk in stream:
@@ -180,32 +79,20 @@ def analyze_table(table_md: str, question: str) -> bueno en esto
                     delta = chunk.parts[0].text
                 if delta:
                     acc += delta
-                    yield ChatMessage(role="assistant", content=acc, additional_kwargs={"delta":delta})
+                    yield CompletionResponse(text=acc, delta=delta)
         return gen()
 
-    def complete(self, prompt, formatted=False, **kwargs):
-        try:
-            resp = self._model.generate_content(str(prompt)) # Asegurar que prompt es string
-            return CompletionResponse(text=resp.text)
-        except Exception as e:
-            return CompletionResponse(text=f"Error complete: {e}")
-
-    async def acomplete(self, prompt, formatted=False, **kwargs):
-        return await asyncio.to_thread(self.complete, str(prompt), formatted=formatted, ** (IndexError): {e}. Verifique que la tabla tiene cabeceras y datos y la pregunta es adecuada."
-    except KeyError as e:
-        return f"Error analyze_table (KeyError): {e}. Alguna columna o etiqueta no se encontró en la tabla."
-    except Exception as e:
-        return f"Error analyze_table: {e}"
-
-def execute_code(code: str) -> str:
-    try:
-        # Try eval for simple expressions
-        try:
-            # MEJORA: Un entorno un poco más seguro y con más utilidades matemáticas comunes
-            allowed_globals = {'__builtins__': None, 'math': math, 'pdkwargs) # Asegurar que prompt es string
+    async def astream_complete(self, prompt, formatted=False, **kwargs):
+        return await asyncio.to_thread(self.stream_complete, prompt, formatted=formatted, **kwargs)
 
-    def stream_complete(self, prompt, formatted=False, **kwargs):
-        stream = self._model.generate_content(str(prompt), stream=True) # Asegurar que prompt es string
+    def stream_chat(self, messages, **kwargs):
+        hist = []
+        for m in messages[:-1]:
+            role = "user" if m.role == "user" else "model"
+            hist.append({"role": role, "parts": [{"text": str(m.content)}]})
+        last = str(messages[-1].content)
+        session = self._model.start_chat(history=hist)
+        stream = session.send_message(last, stream=True)
         def gen():
             acc = ""
             for chunk in stream:
@@ -214,463 +101,142 @@ def execute_code(code: str) -> str:
                     delta = chunk.parts[0].text
                 if delta:
                     acc += delta
-                    yield CompletionResponse(text=acc, delta=delta)
+                    yield ChatMessage(role="assistant", content=acc, additional_kwargs={"delta": delta})
         return gen()
 
-    async def astream_complete(self, prompt, formatted=False, **kwargs):
-        # This needs to be a': pd, 'np': __import__('numpy')} # Ejemplo, añadir según necesidad
-            allowed_locals = {name: getattr(math, name) for name in dir(math) if not name.startswith("__")}
-            val = eval(code, allowed_globals, allowed_locals)
-            return str(val)
-        except (SyntaxError, Name coroutine that returns an async generator
-        # For simplicity, we'll call the synchronous version in a thread
-        # and then adapt its generator. However, a true async implementation
-        # would use an async http client for genai.
-        sync_gen = await asyncio.to_thread(self.stream_complete, str(prompt), formatted=formatted, **kwargs)
-        async def async_gen_wrapper():
-            for item in sync_gen:
-                yieldError): # Errores comunes de eval que pueden ser código más complejo
-            pass # Intentar con subprocess
-        except Exception as e_eval: # Otros errores de eval
-            return f"Error eval en código: {e_eval}"
-
-        # Fallback to subprocess
-        res = subprocess.run(
-            ["python", "-c", code], capture_output=True, text=True, timeout=10 # MEJORA: timeout aumentado
-        )
-        if res.stderr:
-            return f"Error código (subprocess): {res.stderr.strip()}"
-        return res.stdout.strip() or "(sin salida de Python)"
-    except subprocess.TimeoutExpired:
-        return "Error ejecutar item
-        return async_gen_wrapper()
-
-
-    async def astream_chat(self, messages: list[ChatMessage], **kwargs):
-        # Similar to astream_complete, wrap the sync generator
-        sync_gen = await asyncio.to_thread(self.stream_chat, messages, **kwargs)
-        async def async_gen_wrapper():
-            for item in sync_gen:
-                yield item
-        return async_gen_wrapper código: El código tardó demasiado en ejecutarse (timeout)."
-    except Exception as e:
-        return f"Error crítico al ejecutar código: {e}"
+    def complete(self, prompt, formatted=False, **kwargs):
+        try:
+            resp = self._model.generate_content(str(prompt))
+            return CompletionResponse(text=resp.text)
+        except Exception as e:
+            return CompletionResponse(text=f"Error complete: {e}")
 
-def no_tool_solution(query: str) -> str:
-    # MEJORA: La respuesta debería ser manejada por el LLM. Esta herramienta solo indica que se usará conocimiento interno.
-    return "Respuesta basada en conocimiento interno. El LLM procederá a responder directamente."
+    async def acomplete(self, prompt, formatted=False, **kwargs):
+        return await asyncio.to_thread(self.complete, prompt, formatted=formatted, **kwargs)
 
-def scrape_wikipedia_table()
 # -------------------------------------------------------------------
-# 2) Herramientas (MODIFICADAS Y NUEVAS)
+# 2) Herramientas
 # -------------------------------------------------------------------
-HEADERS = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'} #(query: str, section_title: str, table_index: int = 0) -> str:
-    """
-    Busca una página de Wikipedia y extrae la tabla HTML (wikitable) bajo la sección dada.
-    Devuelve CSV de la tabla. Elige la N-ésima tabla si hay varias.
-    """
-    try Agente de usuario más común
+HEADERS = {'User-Agent': 'Mozilla/5.0'}
 
-def buscar_web(query: str, max_attempts: int = 2) -> str:
-    """Busca en la web usando DuckDuckGo. Intenta hasta max_attempts veces."""
+# Web search tool
+def buscar_web(query: str, max_attempts: int = 2, num_results: int = 5) -> str:
     for i in range(max_attempts):
         try:
-            # Aumentamos max_results para dar:
-        wikipedia.set_lang("es") # Asegurar idioma español
-        page = wikipedia.page(query, auto_suggest=True, redirect=True) # MEJORA: auto_suggest y redirect
-        html más contexto al LLM
             with DDGS(headers=HEADERS, timeout=25) as ddgs:
-                results = list(ddgs.text(query, region='es-es', safesearch='moderate', timelimit_content = page.html()
-        soup = BeautifulSoup(html_content, 'html.parser')
-        
-        target_section = None
-        # Buscar encabezados h2 o h3 que contengan el título de la sección
-='y', max_results=5)) # Aumentado a 5
+                results = list(ddgs.text(query, region='es-es', safesearch='moderate', max_results=num_results))
                 if results:
-                    return "\n".join(f"Fuente {idx+1}:\nTítulo: {r['title']}\nEnlace: {r        for header_tag in soup.find_all(['h2', 'h3']):
-            if header_tag.['href']}\nCuerpo: {r['body']}" for idx, r in enumerate(results))
-            return "No se encontraron resultados relevantes en la web para esta consulta."
+                    return "\n".join(f"Fuente {idx+1}: Título: {r['title']}\nEnlace: {r.get('href','N/A')}\nCuerpo: {r['body']}" for idx, r in enumerate(results))
+            return "No se encontraron resultados relevantes."
         except Exception as e:
-            ifspan and section_title.lower() in header_tag.span.get_text(strip=True).lower():
-                target_section = header_tag
-                break
-        
-        if not target_section:
-            # Intento más permisivo si no se encontró con span exacto
-            for header_tag in soup.find_all(['h2', 'h3']):
-                if section_title.lower() in header_tag.get_ i < max_attempts - 1:
-                time.sleep(2 * (i + 1)) # Reducido el tiempo de espera base
+            if i < max_attempts - 1:
+                time.sleep(2 * (i + 1))
             else:
-                return f"Error en buscar_web tras {max_attempts} intentos: {e}. Prueba una consulta diferente o simplificada."
+                return f"Error buscar_web tras {max_attempts} intentos: {e}"
 
+# Reverse text tool
 def reverse_text(text: str) -> str:
-    """Invierte una cadena de texto."""
     return text[::-1]
 
+# Analyze markdown table
 def analyze_table(table_md: str, question: str) -> str:
-    """
-    Procesa una tabla entext(strip=True).lower():
-                    target_section = header_tag
-                    break
-            if not target_section:
-                return f"Sección '{section_title}' no encontrada en la página de Wikipedia '{query}'."
-
-        # Encontrar todas las tablas wikitable DESPUÉS del encabezado de la sección
-        # y ANTES del siguiente encabezado del mismo nivel o superior
-        tables_after_section = []
-        for sibling in target_section.find_next_siblings():
-            if sibling.name in ['h2', 'h3'] and sibling.name <= target_section.name: # <= para h2 vs h2, o h2 vs h3
-                break # Hemos llegado a la siguiente sección del mismo nivel o superior
-            if sibling.name == 'table' and 'wikitable' in formato Markdown. Si la pregunta incluye 'conmutatividad',
-    verifica esta propiedad. De lo contrario, devuelve la tabla en formato CSV.
-    """
-    try:
-        lines = [l for l in table_md.splitlines() if l.strip() and not l.strip().startswith('|--')]
-        if not lines:
-            return "Error analyze_table: La tabla Markdown parece estar vacía o mal formateada."
-
-        rows = []
-        header_skipped = False
-        for l in lines:
-            # Skip initial divider lines if any
-            if '---' in l and not header_skipped :
-                if not rows: # if there's no header yet, this is the divider after header
-                    header_skipped = True
-                    continue
-            
-            parts = [c.strip() for c in l.strip().strip('|').split('|')]
-            if not any(parts): # Skip empty sibling.get('class', []):
-                tables_after_section.append(sibling)
-        
-        if not tables_after_section:
-            return f"No se encontró ninguna tabla 'wikitable' después de la sección '{section_title}'."
-        
-        if table_index >= len(tables_after_section):
-            return f"Índice de tabla {table_index} fuera de rango. Se encontraron {len(tables_after_section)} tablas después de la sección."
-            
-        selected_table = tables_after_section[table_index]
-        
-        # Usar pandas para leer la tabla HTML directamente
-        dfs = pd.read_html(StringIO(str(selected_table)), flavor='bs4') # StringIO necesario para read_html con string
-        if not dfs:
-            return "Pandas no pudo parsear la tabla HTML encontrada."
-        
-        df = dfs[0] # Usualmente la primera tabla parseada es la correcta
-        # Limpieza básica: eliminar filas/columnas completamente vacías
-        df.dropna(axis=0, how='all', inplace=True)
-        df.dropna(axis=1, how='all', inplace=True)
-        return df.to_csv(index=False lines that might result from split
-                continue
-            rows.append(parts)
-        
-        if not rows or len(rows) < 1: # Need at least a header
-             return "Error analyze_table: No se pudo extraer ninguna fila válida de la tabla Markdown."
-
-        df = pd.DataFrame(rows[1:], columns=rows[0]) # Asume que la primera fila es el encabezado
-
-        if 'conmutatividad' in question.lower() or 'conmut' in question.lower():
-            if len(df.columns) < 2 or len(df) < 1:
-                return "Error analyze_table: La tabla es demasiado pequeña para verificar la conmutatividad."
-            
-            first_col_name = df.columns[0]
-            S = df[first_col_name].tolist() # Elementos para verificar, usualmente de la primera columna/fila
-            # Asumimos que las cabeceras de las columnas (después de la primera) son los mismos elementos que en la primera columna
-            # Esto es típico para tablas de Cayley. Si no, esta lógica necesita ajuste.
-            elements_for_op = df.columns[1:].tolist() 
-
-            # Check if elements_for_op are a subset of S, or if S matches elements_for_op
-            # For simplicity, let's assume the)
-    except wikipedia.exceptions.PageError:
-        return f"Error scrape_wikipedia_table: Página de Wikipedia '{query}' no encontrada."
-    except wikipedia.exceptions.DisambiguationError as e:
-        return f"Error scrape_wikipedia_table: '{query}' es ambiguo. Posibles opciones: {e.options[:5]}"
-    except Exception as e:
-        return f"Error scrape_wikipedia_table: {e}"
-
-# --- NUEVAS HERRAMIENTAS ---
-def read_excel_data(file_url_or_path: str, sheet_name: Any = 0) -> str:
-    """
-    Lee datos de un archivo Excel (desde URL o ruta local) y los devuelve como CSV.
-    El argumento sheet_name puede ser el nombre de la hoja o el índice (0 por defecto).
-    """
     try:
-        # Intentar detectar si es una URL square part of the table for operation uses elements from the first column
-            # as both row and column headers for the operation.
-            
-            counter_examples = set()
-            valid_elements_for_lookup = df.columns.tolist()
-
-            for x_val in S:
-                for y_val in S:
-                    if x_val not in valid_elements_for_lookup or y_val not in valid_elements_for_lookup:
-                        # This check is if S contains elements not in column headers,
-                        # or y_val is not a column header. This logic might need refinement
-                        # based on actual table structures encountered.
-                        continue
-
+        lines = [l for l in table_md.splitlines() if l.strip() and '---' not in l]
+        rows = [ [c.strip() for c in l.strip().strip('|').split('|')] for l in lines ]
+        if len(rows) < 2:
+            return "Tabla Markdown mal formateada o vacía."
+        df = pd.DataFrame(rows[1:], columns=rows[0])
+        if 'conmut' in question.lower():
+            cols = df.columns.tolist()[1:]
+            counter = set()
+            for x in cols:
+                for y in cols:
                     try:
-                        # df.loc[df[first_col_name]==x_val, y_val] da una Serie
-                        # .iat[0] accede al primer elemento de esa Serie
-                        a = df.loc[df[first_col_name] == x_val, y_val].iat[0]
-                        b = df.loc[df[first_col_name] == y_val, x_val].iat[0]
-                        if a != b:
-                            counter_examples.update([x_val, y_val])
-                    except (IndexError, KeyError) as e_lookup:
-                        # Esto puede pasar si y_val no es una columna, o x_val no es una fila
-                        # O si la tabla no es "cuadrada" en el sentido esperado para la operación
-
-        if file_url_or_path.startswith(('http://', 'https://')):
-            response = requests.get(file_url_or_path, headers=HEADERS, timeout=30)
-            response.raise_for_status() # Lanza error si la descarga falla
-            excel_content = BytesIO(response.content)
-            df = pd.read_excel(excel_content, sheet_name=sheet_name)
-        else: # Asumir que es una ruta local (aunque en GAIA es improbable que se use)
-            if not os.path.exists(file_url_or_path):
-                return f"Error read_excel_data: Archivo local no encontrado en '{file_url_or_path}'."
-            df = pd.read_excel(file_url_or_path, sheet_name=sheet_name)
-        
-        # Limpieza básica: eliminar filas/columnas completamente vacías
-        df.dropna(axis=0, how='all', inplace=True)
-        df.dropna(axis=1, how='all', inplace=True)
+                        if df.loc[df[rows[0][0]]==x, y].iat[0] != df.loc[df[rows[0][0]]==y, x].iat[0]:
+                            counter.update([x, y])
+                    except:
+                        continue
+            return ', '.join(sorted(counter)) or 'Conmutativa'
         return df.to_csv(index=False)
-    except requests.exceptions.RequestException as e:
-        return f"Error read_excel_data: No se pudo descargar el archivo desde la URL. {e}"
-    except FileNotFoundError: # Específico para rutas locales
-        return f"Error read_excel_data: Archivo local no encontrado en '{file_url_or_path}'."
-    except pd.errors.EmptyDataError:
-        return "Error read_excel_data: El archivo Excel o la hoja especificada está vacía."
-    except ValueError as e: # Puede ser por sheet_name inválido
-        return f"Error read_excel_data: Error al procesar el Excel (posiblemente hoja no encontrada o formato incorrecto). {e}"
     except Exception as e:
-        return f"Error read_excel_data: {e}"
-
-def classify_botanical(items_list_str: str) -> str:
-    """
-    Clasifica una lista de alimentos (separados por comas) en frutas y verduras botánicas.
-    Utiliza un conocimiento base y puede indicar ítems no reconocidos.
-    """
-    items = [item.strip().lower() for item in items_list_str.split(',')]
-    if not items or (len(items) == 1 and not items[0]):
-        return "Error classify_botanical                        # print(f"Debug: Error al buscar {x_val}, {y_val}: {e_lookup}")
-                        continue # Saltar este par si no se puede encontrar
-
-            if counter_examples:
-                return f"La operación no es conmutativa. Contraejemplos (elementos involucrados): {', '.join(sorted(list(counter_examples)))}"
-            else:
-                return "La operación parece ser conmutativa para los elementos y valores dados."
-        
-        return f"Tabla procesada en formato CSV:\n{df.to_csv(index=False)}"
-    except Exception as e:
-        return f"Error crítico en analyze_table: {e}. Asegúrate de que la tabla Markdown esté bien formateada."
-
+        return f"Error analyze_table: {e}"
 
+# Execute code tool
 def execute_code(code: str) -> str:
-    """Ejecuta código Python de forma segura para cálculos o manipulación de datos simple.
-    Evita operaciones de sistema o red.
-    """
     try:
-        # Intenta eval para expresiones matemáticas/lógicas simples y seguras
-        # Proporciona un entorno limitado para eval
-        allowed_globals = {"math": math, "__builtins__": {"abs": abs, "min": min, "max": max, "sum": sum, "len": len, "round": round, "str": str, "int": int, "float": float, "list": list, "dict": dict, "tuple": tuple, "True": True, "False": False, "None": None}}
-        # math.__dict__ es demasiado permisivo. Seamos más explícitos si es necesario.
-        # Por ahora, el usuario debe usar math.sqrt, etc.
-        
-        # Validar el código contra operaciones peligrosas antes de eval o exec
-        # Esto es una lista negra simple, no exhaustiva. Para un sandbox real se necesita más.
-        disallowed_keywords = ["import ", "os.", "sys.", "subprocess.", "open(", "eval(", "exec(", "compile(", "socket", "requests", "urllib", "shutil", "glob", "eval\\(", "exec\\("]
-        if any(keyword in code for keyword in disallowed_keywords):
-            # También chequear si `code` intenta llamar a `__import__` o acceder a `: La lista de ítems está vacía."
-
-    # Conocimiento botánico base (simplificado, ampliar según sea necesario)
-    # Fuentes: Conocimiento general botánico. Fruta = desarrolla del ovario de una flor y contiene semillas.
-    botanical_fruits = {
-        "tomate", "pepino", "calabacín", "berenjena", "pimiento", "aguacate",
-        "calabaza", "guisante", "judía verde", "maíz", "aceituna", "manzana", "pera",
-        "plátano", "naranja", "limón", "uva", "fresa", "frambuesa", "mora", "sandía",
-        "melón", "kiwi", "mango", "piña", "cereza", "ciruela", "melocotón", "albaricoque",
-        "higo", "granada", "papaya", "chile", "zapallo", "zapallito", "ají", "pimentón",
-        "sweet potatoes", "plums", "green beans", "corn", "bell pepper", "acorns", "peanuts", "oreos" # Oreos es claramente NO fruta ni verdura
-    }
-    # Verduras culinarias que son botánicamente frutas ya están arriba.
-    # Estas son partes de plantas como raíces, tallos, hojas.
-    botanical_vegetables = {
-        "zanahoria", "patata", "batata", "cebolla", "ajo", "puerro", "apio",
-        "lechuga", "espinaca", "acelga", "col", "brócoli", "coliflor", "espárrago",
-        "rábano", "nabo", "remolacha", "alcachofa", "hinojo",
-        "fresh basil", "broccoli", "celery", "lettuce", "sweet potatoes" # Sweet potatoes (batata) es raíz, verdura
-    }
-    # Algunos ítems de la lista original:
-    # milk, eggs, flour, whole bean coffee, Oreos, rice, whole allspice
-    non_botanical_produce = { # Ni fruta ni verdura en el sentido de "produce" fresco
-        "milk", "eggs", "flour", "whole bean coffee", "oreos", "rice", "whole allspice",
-        "leche", "huevos", "harina", "café en grano", "arroz", "pimienta de jamaica"
-    }
-
-    fruits_found = []
-    vegetables_found = []
-    unrecognized_items = []
-    other_items = []
-
-    for item_singular in items:
-        # Intentar una forma singular simple (esto es rudimentario)
-        item_processed = item_singular
-        if item_singular.endswith('s') and not item_singular.endswith('ss'): # ej. "apples" -> "apple"
-            if item_singular[:-1] in botanical_fruits or__builtins__` de forma peligrosa
-            if "__" in code: # Simplificación: si hay doble guion bajo, sospechar.
-                 return "Error código: El código parece intentar acceder a funcionalidades restringidas o peligrosas (ej. dunder methods/attrs)."
-            return "Error código: El código contiene palabras clave o patrones no permitidos (ej. import, os, subprocess, file access)."
-
+        allowed_globals = {'__builtins__': None, 'math': math}
         try:
-            # Si es una sola expresión, eval puede ser suficiente
-            val = eval(code, allowed_globals, {}) # No locals
-            return f"Resultado de la expresión: {str(val)}"
-        except (SyntaxError, NameError): # Si no es una expresión simple, o necesita definiciones
-            # Fallback a subprocess si eval falla o para scripts más complejos (pero aún simples)
-            # El timeout es crucial.
-            # Usar python -S para deshabilitar la importación de site-specific paths (más seguro)
-            # Para mayor seguridad, se podría ejecutar en un contenedor Docker o con `nsjail`.
-            # Por ahora, confiamos en el timeout y la validación de palabras clave.
-            # Si se necesita pandas o numpy en el código, esta herramienta tendría que ser más sofisticada
-            # o el LLM tendría que generar código que no dependa de imports no disponibles en el sandbox.
-            
-            # Re-validar para subprocess, ya que el contexto es diferente
-            if any(keyword in code for keyword in ["import os", "import sys", "subprocess", " open("]): # lista más restrictiva para subprocess
-                 return "Error código: El código para subprocess contiene palabras clave no permitidas."
-
-            # Si el código es multilinea o define funciones, eval no sirve, se necesitaría exec.
-            # Pero exec es más peligroso. Subprocess es un sandbox mejor si se configura bien.
-            # Por ahora, si eval falla, intentamos subprocess con el código tal cual.
-            # Esto asume que el código es un script simple que imprime a stdout.
-            
-            # Prepend common safe imports if the LLM is instructed to use them without explicit import
-            # For example, if we want 'math' to be available implicitly.
-            # safe_prelude = "import math\n"
-            # full_code = safe_prelude + code
-            
-            res = subprocess.run(
-                ["python", "-S", "-c", code], capture_output=True, text=True, timeout=10 # Aumentado timeout un poco
-            )
-            if res.returncode != 0: # Chequear returncode además de stderr
-                error_message = res.stderr.strip() if res.stderr else "El código falló sin un mensaje de error específico." item_singular[:-1] in botanical_vegetables:
-                 item_processed = item_singular[:-1]
-        
-        # Para el ejemplo específico del prompt, algunos están en inglés y otros no.
-        # La lista de la compra del prompt original:
-        # milk, eggs, flour, whole bean coffee, Oreos, sweet potatoes, fresh basil, plums, green beans, 
-        # rice, corn, bell pepper, whole allspice, acorns, broccoli, celery, zucchini, lettuce, peanuts
+            val = eval(code, allowed_globals, {})
+            return str(val)
+        except:
+            res = subprocess.run(["python", "-S", "-c", code], capture_output=True, text=True, timeout=10)
+            if res.returncode != 0:
+                return f"Error código: {res.stderr.strip()}"
+            return res.stdout.strip() or "(sin salida)"
+    except subprocess.TimeoutExpired:
+        return "Error ejecutar código: timeout"
+    except Exception as e:
+        return f"Error crítico: {e}"
 
-        if item_processed in botanical_fruits:
-            fruits_found.append(item_singular) # Devolver el original
-        elif item_processed in botanical_vegetables:
-            vegetables_found.append(item_singular)
-        elif item_processed in non_botanical_produce:
-            other_items.append(item_singular)
+# Read Excel tool
+def read_excel_data(file_path: str, sheet_name=0) -> str:
+    try:
+        if file_path.startswith(('http://','https://')):
+            resp = requests.get(file_path, headers=HEADERS, timeout=30)
+            resp.raise_for_status()
+            df = pd.read_excel(BytesIO(resp.content), sheet_name=sheet_name)
         else:
-            # Consulta web simple si no está en las listas (podría ser costoso para muchos ítems)
-            # print(f"DEBUG: Item '{item_singular}' no reconocido, podría buscar en web.")
-            # search_result = buscar_web(f"¿{item_singular} es fruta o verdura botánica?", num_results=1)
-            # Aquí se necesitaría un LLM para interpretar el resultado de la búsqueda.
-            # Por ahora, lo marcamos como no reconocido por la herramienta.
-            unrecognized_items.append(item_singular)
-            
-    result = []
-    if fruits_found:
-        result.append(f"Frutas botánicas: {', '.join(sorted(list(set(fruits_found))))}")
-    if vegetables_found:
-        result.append(f"Verduras botánicas: {', '.join(sorted(list(set(vegetables_found))))}")
-    if other_items:
-        result.append(f"Otros ítems (ni fruta ni verdura botánica): {', '.join(sorted(list(set(other_items))))}")
-    if unrecognized_items:
-        result.append(f"Ítems no reconocidos por esta herramienta (requieren investigación adicional o son ambiguos): {', '.join(sorted(list(set(unrecognized_items))))}")
-
-    return "\n".join(result) if result else "No se pudieron clasificar los ítems o la lista estaba vacía."
-
-
-# Encapsular herramientas
-search_tool   = FunctionTool.from_defaults(fn=buscar_web,           name="web_search",           description="Búsqueda web general (DuckDuckGo, 5 resultados). Útil para información actual, definiciones, hechos, o cuando otras herramientas no aplican. Especifica bien tu consulta.")
-reverse_tool  = FunctionTool.from_defaults(fn=reverse_text,         name="reverse_text",        description="Invierte una cadena de texto.")
-table_tool    = FunctionTool.from_defaults(fn=analyze_table,        name="analyze_table",       description="Procesa tablas en formato Markdown. Puede verificar conmutatividad si se le pide o devolver la tabla como CSV. Asegúrate de que la tabla esté bien formada.")
-code_tool     = FunctionTool.from_defaults(fn=execute_code,         name="execute_code",        description="Ejecuta código Python para cálculos matemáticos, manipulación de datos simple (si se proveen como strings o listas), u otras tareas algorítmicas. No puede acceder a internet ni a archivos externos.")
-fallback_tool = FunctionTool.from_defaults(fn=no_tool_solution,     name="no_tool_solution",     description="Úsalo como ÚLTIMO RECURSO si estás seguro de que puedes responder la pregunta con tu conocimiento interno y ninguna otra herramienta es adecuada o ha funcionado. Expl
-                return f"Error código (código de salida {res.returncode}): {error_message}"
-            return res.stdout.strip() or "(El código se ejecutó sin salida a stdout)"
-        except Exception as e_eval: # Captura errores de eval si no fueron SyntaxError o NameError
-             return f"Error código (eval): {e_eval}"
-
-    except Exception as e_general:
-        return f"Error crítico al intentar ejecutar código: {e_general}"
-
-def no_tool_solution(query_context: str) -> str: # Cambiado el parámetro para reflejar su uso
-    """
-    Se utiliza cuando ninguna otra herramienta es adecuada o cuando la pregunta requiere
-    conocimiento general, razonamiento o procesamiento de información ya disponible en la conversación.
-    Explica brevemente por qué se usa esta opción.
-    """
-    return f"Procedo con conocimiento interno y razonamiento. Contexto/Razón: {query_context}"
+            if not os.path.exists(file_path):
+                return f"Error read_excel_data: archivo '{file_path}' no encontrado"
+            df = pd.read_excel(file_path, sheet_name=sheet_name)
+        df = df.fillna('')
+        return df.to_csv(index=False)
+    except Exception as e:
+        return f"Error read_excel_data: {e}"
 
-def scrape_wikipedia_table(page_title: str, section_heading_substring: str, table_index: int = 0) -> str:
-    """
-    Busca una página de Wikipedia por su título exacto y extrae una tabla HTML
-    bajo una sección que contenga el 'section_heading_substring'.
-    Devuelve la tabla como CSV. Se puede especificar table_index (0 por defecto) si hay varias tablas en la sección.
-    """
+# Botanical classification tool
+def classify_botanical(items_list_str: str) -> str:
+    fruits = {"tomate","pepino","calabacín","berenjena","pimiento","aguacate","calabaza","guisante","judía verde","maíz"}
+    vegetables = {"zanahoria","patata","batata","cebolla","ajo","puerro","apio","lechuga","espinaca","brócoli"}
+    items = [i.strip().lower() for i in items_list_str.split(',')] if items_list_str else []
+    vegs = [i for i in items if i in vegetables]
+    fruits_found = [i for i in items if i in fruits]
+    others = [i for i in items if i not in fruits and i not in vegetables]
+    return f"Verduras: {', '.join(sorted(set(vegs)))}\nFrutas: {', '.join(sorted(set(fruits_found)))}\nOtros: {', '.join(sorted(set(others)))}"
+
+# Wikipedia table scraper
+def scrape_wikipedia_table(page_title: str, section: str, table_index: int = 0) -> str:
     try:
-        wikipedia.set_lang("es") # Asegurar que busca en Wikipedia en español si es relevante
-        page = wikipedia.page(page_title, auto_suggest=False) # Evitar auto_suggest si el título debe ser exacto
-        html = page.html()
-        soup = BeautifulSoup(html, 'html.parser')
-        
-        target_section_element = None
-        # Buscar encabezados (h1, h2, h3, h4) que contengan el texto de la sección
-        for header_level in ['h1', 'h2', 'h3', 'h4']:
-            headers = soup.find_all(header_level)
-            for header in headers:
-                if section_heading_substring.lower() in header.get_text(strip=True).lower():
-                    span_headline = header.find('span', class_='mw-headline')
-                    if span_headline and section_heading_substring.lower() in span_headline.get_text(strip=True).lower():
-                        target_section_element = header
-                        break
-            if target_section_element:
-                break
-        
-        if not target_section_element:
-            return f"Sección que contenga '{section_heading_substring}' no encontrada en la página de Wikipedia '{page_title}'. Intenta con un título de sección diferente o verifica el título de la página."
-
-        # Buscar todas las tablas wikitable *después* del encabezado de la sección encontrada
-        # y dentro del mismo "nivel" (antes del siguiente encabezado del mismo o mayor nivel)
-        tables_in_section = []
-        for sibling in target_section_element.find_next_siblings():
-            # Detener la búsqueda si encontramos otro encabezado del mismo nivel o superior
-            if sibling.name in ['h1', 'h2', 'h3', 'h4'] and sibling.name <= target_section_element.name:
-                break
-            if sibling.name == 'table' and ('wikitable' in sibling.get('class', [])):
-                tables_in_section.append(sibling)
-        
-        if not tables_in_section:
-            return f"No se encontró ninguna tabla 'wikitable' después de la sección '{section_heading_substring}'."
-        
-        if table_index >= len(tables_in_section):
-            return f"Índice de tabla {table_index} fuera de rango. Se encontraron {len(tables_in_section)} tablas en la sección."
-            
-        # Convertir la tabla seleccionada a DataFrame y luego a CSV
-        # Usar pd.read_htmlica tu razonamiento.")
-scrape_tool   = FunctionTool.from_defaults(fn=scrape_wikipedia_table,name="scrape_wiki_table",   description="Extrae una tabla específica (wikitable) de una página de Wikipedia dada una sección y el índice de la tabla (0 por defecto). Útil para datos estructurados en Wikipedia.")
-# NUEVAS
-excel_reader_tool = FunctionTool.from_defaults(fn=read_excel_data, name="read_excel_data", description="Lee datos de un archivo Excel accesible por URL (o ruta local, menos común aquí). Devuelve los datos como CSV. Necesita la URL del archivo y opcionalmente el nombre/índice de la hoja.")
-botanical_tool = FunctionTool.from_defaults(fn=classify_botanical, name="classify_botanical_foods", description="Clasifica una lista de alimentos (texto separado por comas) en frutas botánicas y verduras botánicas según un conocimiento base. Indica ítems no reconocidos. Útil para listas de la compra o categorización de alimentos.")
-
-
-all_tools = [
-    search_tool, 
-    scrape_tool, # scrape_tool antes de table_tool si se espera obtener la tabla de la web primero
-    table_tool,  
-    code_tool, 
-    excel_reader_tool,
-    botanical_tool,
-    # reverse_tool, # Menos probable que sea útil en GAIA, pero lo dejamos
-    fallback_tool # Fallback siempre al final
-]
-
+        wikipedia.set_lang("es")
+        page = wikipedia.page(page_title, auto_suggest=False)
+        soup = BeautifulSoup(page.html(), 'html.parser')
+        header = next((h for h in soup.find_all(['h2','h3']) if section.lower() in h.get_text(strip=True).lower()), None)
+        if not header:
+            return f"Sección '{section}' no encontrada en '{page_title}'"
+        tables = []
+        for sib in header.find_next_siblings():
+            if sib.name in ['h2','h3']: break
+            if sib.name=='table' and 'wikitable' in sib.get('class',[]): tables.append(sib)
+        if table_index>=len(tables): return f"Tabla índice {table_index} fuera de rango (solo {len(tables)} tablas)."
+        df = pd.read_html(str(tables[table_index]))[0]
+        return df.to_csv(index=False)
+    except Exception as e:
+        return f"Error scrape_wiki_table: {e}"
+
+# Wrap tools
+search_tool = FunctionTool.from_defaults(fn=buscar_web, name="web_search", description="Búsqueda DuckDuckGo.")
+reverse_tool = FunctionTool.from_defaults(fn=reverse_text, name="reverse_text", description="Invierte texto.")
+table_tool   = FunctionTool.from_defaults(fn=analyze_table, name="analyze_markdown_table", description="Procesa tabla Markdown.")
+code_tool    = FunctionTool.from_defaults(fn=execute_code, name="execute_code", description="Ejecuta Python.")
+excel_tool   = FunctionTool.from_defaults(fn=read_excel_data, name="read_excel_data", description="Lee Excel.")
+botanical_tool = FunctionTool.from_defaults(fn=classify_botanical, name="classify_botanical_foods", description="Clasifica botánicamente alimentos.")
+scrape_tool  = FunctionTool.from_defaults(fn=scrape_wikipedia_table, name="scrape_wiki_table", description="Scrapea tabla Wikipedia.")
+fallback_tool= FunctionTool.from_defaults(fn=lambda q: "Procedo con conocimiento interno.", name="no_tool_solution", description="Fallback.")
+all_tools = [search_tool, scrape_tool, table_tool, code_tool, excel_tool, botanical_tool, reverse_tool, fallback_tool]
+
+# System prompt
+tool_descriptions = "\n".join([t.description for t in all_tools])
+#system_prompt = f"Eres Alfred...\nHerramientas:\n{tool_desc}" 
 # Prompt de sistema REFINADO
 system_prompt = (
     "Eres Alfred, un agente ReAct eficiente y preciso. Tu objetivo es responder preguntas de forma correcta.\n"
@@ -689,131 +255,14 @@ system_prompt = (
     "Herramientas disponibles (usa SOLO estas y con los nombres exactos):\n{tool_descriptions}"
 )
 
-# Inicializar agente
-llm = GeminiLLM(model_name="models/gemini-1.5-flash-latest", temperature=0.0) # Temperatura ya estaba en 0.0
-
-alfred_agent = ReActAgent.from_tools(
-    tools=all_tools,
-    llm=llm,
-    system_prompt=system_prompt,
-    verbose=True,
-    max_iterations=15, # MEJORA: Reducido de 20 a 15. Ajustar según sea necesario.
-    # MEJORA: Añadir el callback manager al agente para que use los handlers definidos en el LLM
-    callback_manager=llm.callback_manager 
-)
+# Agent init
+llm = GeminiLLM()
+alfred_agent = ReActAgent.from_tools(tools=all_tools, llm=llm, system_prompt=system_prompt, verbose=True, max_iterations=15, callback_manager=llm.callback_manager)
 
-# Función pública (sin cambios)
 def basic_agent_response(question: str) -> str:
-    # Limpiar el estado del handler de métricas para cada nueva pregunta
-    # metrics_handler.tool_usage_counts.clear()
-    # metrics_handler.tool_errors.clear()
-    # metrics_handler.tool_timings.clear()
-    # metrics_handler._tool_starts.clear() # No que puede manejar HTML complejo, pero darle el string de la tabla
-        # io.StringIO es necesario porque read_html espera un buffer de archivo o una URL
-        dfs = pd.read_html(StringIO(str(tables_in_section[table_index])), flavor='bs4')
-        if not dfs:
-            return "Error scrape_wikipedia_table: pandas no pudo parsear la tabla encontrada."
-        
-        df = dfs[0] # Asumimos que la primera tabla parseada es la correcta
-        return f"Tabla de Wikipedia (sección '{section_heading_substring}', índice {table_index}) en formato CSV:\n{df.to_csv(index=False)}"
-    except wikipedia.exceptions.PageError:
-        return f"Error scrape_wikipedia_table: Página de Wikipedia '{page_title}' no encontrada. Verifica el título."
-    except wikipedia.exceptions.DisambiguationError as e:
-        return f"Error scrape_wikipedia_table: Título ambiguo '{page_title}'. Posibles opciones: {e.options}. Por favor, proporciona un título más específico."
-    except IndexError:
-        return f"Error scrape_wikipedia_table: No se pudo encontrar la tabla con índice {table_index} en la sección especificada."
-    except Exception as e:
-        return f"Error inesperado en scrape_wikipedia_table: {e}"
-
-# NUEVA HERRAMIENTA: Lector de Excel
-def read_excel_data(file_path: str, sheet_name=0) -> str:
-    """
-    Lee un archivo Excel (.xls o .xlsx) desde una ruta de archivo local (file_path)
-    y una hoja específica (sheet_name, por defecto la primera, índice 0).
-    Devuelve los datos de la tabla como una cadena en formato CSV.
-    Esta herramienta SÓLO funciona si el archivo Excel está accesible en el sistema de archivos local
-    donde se ejecuta el agente y se proporciona la ruta correcta.
-    No puede acceder a archivos adjuntos de correos o subidos a chats directamente.
-    """
-    try:
-        # Para archivos remotos, necesitaríamos requests y pasar BytesIO(response.content)
-        # if file_path.startswith('http://') or file_path.startswith('https://'):
-        #     response = requests.get(file_path)
-        #     response.raise_for_status() # Asegura que la descarga fue exitosa
-        #     excel_content = BytesIO(response.content)
-        #     df = pd.read_excel(excel_content, sheet_name=sheet_name)
-        # else:
-        #     df = pd.read_excel(file_path, sheet_name=sheet_name)
-        
-        # Simplificamos: solo rutas locales por ahora, como es más probable en el entorno de prueba.
-        if not os.path.exists(file_path):
-             return f"Error read_excel_data: El archivo local '{file_path}' no fue encontrado."
-
-        df = pd.read_excel(file_path, sheet_name=sheet_name)
-        
-        # Limpiar NaNs que pueden causar problemas al convertir a CSV o ser interpretados por el LLM
-        df_cleaned = df.fillna('') # Reemplazar NaN con string vacío
-
-        csv_output = df_cleaned.to_csv(index=False)
-        if not csv_output.strip(): # Si el CSV está vacío (solo cabeceras vacías o nada)
-            return "El archivo Excel o la hoja especificada parece estar vacía o no contiene datos procesables."
-
-        return f"Contenido del archivo Excel '{os.path.basename(file_path)}' (hoja '{sheet_name}') en formato CSV:\n{csv_output}"
-    except FileNotFoundError: # Esto es redundante si usamos os.path.exists, pero por si acaso.
-        return f"Error read_excel_data: El archivo local '{file_path}' no fue encontrado."
-    except ValueError as ve: # Errores comunes de pandas al leer formatos incorrectos
-        if "Excel file format cannot be determined" in str(ve) or "File is not a zip file" in str(ve):
-            return f"Error read_excel_data: El archivo '{file_path}' no parece ser un archivo Excel válido (.xls, .xlsx)."
-        return f"Error read_excel_data: Problema al leer el archivo Excel (ValueError): {ve}"
-    except Exception as e:
-        return f"Error crítico en read_excel_data al procesar '{file_path}': {e}"
-
-
-# Encapsular herramientas
-search_tool         = FunctionTool.from_defaults(fn=buscar_web,                name="web_search",              description="Realiza una búsqueda en la web (DuckDuckGo) con una consulta y devuelve un resumen de los principales resultados (título, enlace, cuerpo). Útil para encontrar información general, noticias, o datos específicos que no estén en Wikipedia.")
-reverse_tool        = FunctionTool.from_defaults(fn=reverse_text,              name="reverse_text",            description="Invierte una cadena de texto. Útil para manipulaciones simples de strings o tareas específicas que lo requieran.")
-table_tool          = FunctionTool.from_defaults(fn=analyze_table,             name="analyze_markdown_table",  description="Procesa una tabla que YA ESTÁ en es ideal modificar atributos privados, pero para un reinicio simple...
-    # Mejor aún: crear una nueva instancia o un método reset() en el handler.
-    # Por simplicidad, y dado que el callback manager del LLM es compartido, esto es complicado.
-    # Una mejor práctica sería pasar un nuevo callback manager o handlers reseteados por pregunta si es necesario.
-    # Para GAIA, donde se evalúa pregunta por pregunta, el estado acumulado de las métricas puede ser útil al final.
-    # Si se quiere métricas por pregunta, el handler necesitaría ser instanciado/reseteado por llamada.
-    
     try:
         resp = alfred_agent.query(question)
-        # Imprimir métricas después de cada respuesta (opcional, para depuración)
-        # print("--- Métricas de Herramientas para esta pregunta ---")
-        # print(metrics_handler.get_metrics())
-        # print("-------------------------------------------------")
-        return resp.response or "No se generó respuesta."
+        return resp.response or "No response."
     except Exception as e:
-        return f"Error crítico del agente: {e}"
-
-if __name__ == "__main__":
-    # Ejemplo de cómo obtener las métricas acumuladas al final de una sesión
-    # Esto es solo un ejemplo, en tu `app.py` lo harías después del bucle de preguntas.
-    
-    # Simulación de algunas preguntas
-    print("Ejecutando prueba de agente (botánica)...")
-    # Pregunta original de la lista de la compra
-    q_botanica = "I'm making a grocery list for my mom, but she's a professor of botany and she's a real stickler when it comes to categorizing things. I need to add different foods to different categories on the grocery list, but if I make a mistake, she won't buy anything inserted in the wrong category. Here's the list I have so far: milk, eggs, flour, whole bean coffee, Oreos, sweet potatoes, fresh basil, plums, green beans, rice, corn, bell pepper, whole allspice, acorns, broccoli, celery, zucchini, lettuce, peanuts I need to make headings for the fruits and vegetables. Could you please create a list of just the vegetables from my list? If you could do that, then I can figure out how to categorize the rest of the list into the appropriate categories. But remember that my mom is a real stickler, so make sure that no botanical fruits end up on the vegetable list, or she won't get them when she's at the store. Please alphabetize the list of vegetables, and place each item in a comma separated list."
-    response_botanica = basic_agent_response(q_botanica)
-    print(f"Pregunta Botánica: {q_botanica}")
-    print(f"Respuesta del Agente: {response_botanica}\n")
-
-    print("Ejecutando prueba de agente (Excel)...")
-    # OJO: Esta URL es un ejemplo, DEBE ser un enlace directo a un archivo .xlsx o .xls
-    # Github raw links a veces no funcionan directamente con requests si no son el archivo real.
-    # Necesitarías una URL pública directa a un archivo Excel.
-    # Ejemplo (ficticio, necesitas una URL real): "https://example.com/test_sales.xlsx"
-    # Para probar sin una URL real, puedes comentar esta prueba o usar una ruta local si ejecutas esto localmente.
-    q_excel = "Por favor, lee el archivo Excel en 'https://github.com/datasciencedojo/datasets/raw/master/Sales%20Data/Sales%20Examples.xlsx' y dime el total de 'Total Revenue' de la primera hoja."
-    # Este enlace anterior SÍ es un Excel real y público
-    response_excel = basic_agent_response(q_excel)
-    print(f"Pregunta Excel: {q_excel}")
-    print(f"Respuesta del Agente: {response_excel}\n")
+        return f"Error crítico: {e}"
 
-    # Al final de todas las ejecuciones, puedes imprimir las métricas acumuladas:
-    print("\n--- Métricas Acumuladas de Herramientas (Ejemplo Final) ---")
-    print(metrics_handler.get_metrics())
-    print("----------------------------------------------------------")