Update my

my_tools.py

@@ -1,409 +1,273 @@
+# alfred_agent.py
+
 import os
 import math
-import pandas as pd # No se usa directamente aquí pero podría ser útil para el DataFrame en app.py
+import time
+import asyncio
+import subprocess
+import pandas as pd
+from io import StringIO
 from duckduckgo_search import DDGS
 import wikipedia
-import llama_index
+from llama_index import ServiceContext, LLMPredictor
+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.llms import ChatMessage, LLMMetadata, LLM, CompletionResponse
+from llama_index.indices.object_index import ObjectIndex
+from llama_index.indices.vector_store import VectorStoreIndex
 from llama_index.core.callbacks import CallbackManager
 from llama_index.core.callbacks.llama_debug import LlamaDebugHandler
+from pydantic import Field
 import google.generativeai as genai
-import asyncio
-from pydantic import Field # Para declarar campos si fuera necesario, aunque no para _generation_config
-from llama_index.core.llms import ChatMessage
-import time # Para reintentos
-
-# --- Intento mejorado para obtener la versión de LlamaIndex ---
-try:
-    from importlib import metadata
-    try:
-        llama_index_version = metadata.version('llama-index')
-    except metadata.PackageNotFoundError:
-        try:
-            llama_index_version = metadata.version('llama-index-core')
-        except metadata.PackageNotFoundError:
-            llama_index_version = "No se pudo determinar (con importlib.metadata)"
-except ImportError:
-    try:
-        from llama_index.core import __version__ as llama_index_core_version
-        llama_index_version = llama_index_core_version
-    except ImportError:
-        llama_index_version = "No se pudo determinar (fallback a __version__ falló)"
-
-print(f"LlamaIndex version detectada: {llama_index_version}")
 
-class PatchedChatMessage(ChatMessage):
-    @property
-    def message(self):
-        return self
-        
-# --- Gemini LLM personalizado ---
+# -------------------------------------------------------------------
+# 1) GeminiLLM: tu implementación personalizada
+# -------------------------------------------------------------------
 class GeminiLLM(LLM):
-    model_name: str = Field(default="models/gemini-1.5-flash-latest", description="The Gemini model to use.")
-    temperature: float = Field(default=0.7, description="The temperature to use for generation.")
-    
-    # Atributos privados que no queremos que Pydantic valide como campos del modelo directamente
-    # pero que necesitamos para la lógica interna. Los inicializaremos en __init__.
-    _model_instance: genai.GenerativeModel = None
-    _generation_config_instance: genai.types.GenerationConfig = None
-
-    # Para Pydantic v1, si la clase base lo es, permitir atributos extra
-    # Para Pydantic v2, esto sería model_config = {"extra": "allow"}
+    model_name: str = Field(default="models/gemini-1.5-flash-latest")
+    temperature: float = Field(default=0.7)
+
     class Config:
-        extra = "allow" # Permite atributos que no están definidos explícitamente como campos
-
-    def __init__(self, model_name: str = "models/gemini-1.5-flash-latest", temperature: float = 0.7, **kwargs):
-        # Llamar a super().__init__() con los campos definidos y **kwargs
-        # Esto es importante para que Pydantic inicialice correctamente
-        super().__init__(model_name=model_name, temperature=temperature, **kwargs) # Pasar kwargs a la clase base
-
-        gemini_api_key = os.getenv("GEMINI_API_KEY")
-        if not gemini_api_key:
-            raise ValueError("GEMINI_API_KEY environment variable not set.")
-        genai.configure(api_key=gemini_api_key)
-        
-        # Usar self.temperature y self.model_name que Pydantic ya ha asignado
-        self._generation_config_instance = genai.types.GenerationConfig(
-            temperature=self.temperature 
-        )
-        self._model_instance = genai.GenerativeModel(
+        extra = "allow"
+
+    def __init__(self, **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=self.temperature)
+        self._model = genai.GenerativeModel(
             model_name=self.model_name,
-            generation_config=self._generation_config_instance
+            generation_config=self._gen_cfg
         )
-        # El callback_manager se hereda de la clase base LLM, podemos configurarlo si es necesario.
-        # self.callback_manager = kwargs.get('callback_manager', CallbackManager([LlamaDebugHandler(print_trace=True)]))
-        # Si la clase base LLM ya inicializa callback_manager, no necesitamos reasignarlo a menos que queramos uno específico.
-        # Por defecto, llama_index.core.llms.LLM inicializa self.callback_manager = callback_manager or CallbackManager([])
-        # Si queremos el LlamaDebugHandler, podemos pasarlo o reconfigurarlo
-        if not self.callback_manager.handlers: # Si no hay manejadores, añadir el nuestro
-              self.callback_manager.add_handler(LlamaDebugHandler()) 
-
+        if not self.callback_manager.handlers:
+            self.callback_manager.add_handler(LlamaDebugHandler())
 
     @property
-    def metadata(self) -> LLMMetadata:
+    def metadata(self):
         return LLMMetadata(
-            context_window=1048576, 
-            num_output=8192,        
+            context_window=1048576,
+            num_output=8192,
             is_chat_model=True,
-            is_function_calling_model=True, 
-            model_name=self.model_name 
+            is_function_calling_model=True,
+            model_name=self.model_name,
         )
 
-    # callback_manager ya es una propiedad en la clase base LLM.
-    # No necesitamos redefinirla a menos que la lógica de acceso sea diferente.
-    # @property
-    # def callback_manager(self):
-    #     return self._callback_manager
-
-    # --- Implementación de Chat ---
-    '''
-    def chat(self, messages: list[ChatMessage], **kwargs) -> ChatMessage:
-        gemini_history = []
-        for msg in messages[:-1]: 
-            role = "user" if msg.role == "user" else "model"
-            gemini_history.append({'role': role, 'parts': [{'text': msg.content}]})
-        
-        last_user_message = messages[-1].content
-        
-        chat_session = self._model_instance.start_chat(history=gemini_history)
+    def chat(self, messages, **kwargs):
+        hist = []
+        for m in messages[:-1]:
+            role = "user" if m.role == "user" else "model"
+            hist.append({"role": role, "parts":[{"text": m.content}]})
+        last = messages[-1].content
+        session = self._model.start_chat(history=hist)
         try:
-            response = chat_session.send_message(last_user_message)
-            return ChatMessage(role="assistant", content=response.text)
+            resp = session.send_message(last)
+            return ChatMessage(role="assistant", content=resp.text)
         except Exception as e:
-            print(f"Error en Gemini chat: {e}")
-            return ChatMessage(role="assistant", content=f"Error al generar respuesta: {e}")
-    '''
-    def chat(self, messages: list[ChatMessage], **kwargs) -> ChatMessage:
-        gemini_history = []
-        for msg in messages[:-1]: 
-            role = "user" if msg.role == "user" else "model"
-            gemini_history.append({'role': role, 'parts': [{'text': msg.content}]})
-    
-        last_user_message = messages[-1].content
-        
-        chat_session = self._model_instance.start_chat(history=gemini_history)
-        try:
-            response = chat_session.send_message(last_user_message)
-            return PatchedChatMessage(role="assistant", content=response.text)
-        except Exception as e:
-            print(f"Error en Gemini chat: {e}")
-            return PatchedChatMessage(role="assistant", content=f"Error al generar respuesta: {e}")
+            return ChatMessage(role="assistant", content=f"Error Gemini: {e}")
 
-    async def achat(self, messages: list[ChatMessage], **kwargs) -> ChatMessage:
+    async def achat(self, messages, **kwargs):
         return await asyncio.to_thread(self.chat, messages, **kwargs)
 
-    def stream_chat(self, messages: list[ChatMessage], **kwargs):
-        gemini_history = []
-        for msg in messages[:-1]:
-            role = "user" if msg.role == "user" else "model"
-            gemini_history.append({'role': role, 'parts': [{'text': msg.content}]})
-        
-        last_user_message = messages[-1].content
-        
-        chat_session = self._model_instance.start_chat(history=gemini_history)
-        response_stream = chat_session.send_message(last_user_message, stream=True)
-
+    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":m.content}]})
+        last = messages[-1].content
+        session = self._model.start_chat(history=hist)
+        stream = session.send_message(last, stream=True)
         def gen():
-            accumulated_text = ""
-            for chunk in response_stream:
-                delta = ""
-                if hasattr(chunk, 'text') and chunk.text:
-                    delta = chunk.text
-                # Podríamos necesitar revisar la estructura exacta del chunk para obtener el delta correcto.
-                # A veces es chunk.parts[0].text
-                elif chunk.parts and hasattr(chunk.parts[0], 'text'):
-                    delta = chunk.parts[0].text
-
-                if delta:
-                    accumulated_text += delta
-                    yield ChatMessage(role="assistant", content=accumulated_text, additional_kwargs={"delta": delta})
-        return gen()
-
-    async def astream_chat(self, messages: list[ChatMessage], **kwargs):
-        loop = asyncio.get_event_loop()
-        
-        gemini_history = []
-        for msg in messages[:-1]:
-            role = "user" if msg.role == "user" else "model"
-            gemini_history.append({'role': role, 'parts': [{'text': msg.content}]})
-        last_user_message = messages[-1].content
-
-        def get_stream_iterator():
-            chat_session = self._model_instance.start_chat(history=gemini_history)
-            return chat_session.send_message(last_user_message, stream=True)
-
-        response_stream = await loop.run_in_executor(None, get_stream_iterator)
-        
-        async def gen():
-            accumulated_text = ""
-            all_chunks_text = []
-            for chunk in response_stream: 
-                delta = ""
-                if hasattr(chunk, 'text') and chunk.text:
-                    delta = chunk.text
-                elif chunk.parts and hasattr(chunk.parts[0], 'text'):
+            acc = ""
+            for chunk in stream:
+                delta = getattr(chunk, "text", "")
+                if not delta and chunk.parts:
                     delta = chunk.parts[0].text
                 if delta:
-                    all_chunks_text.append(delta)
-            
-            for text_delta in all_chunks_text:
-                accumulated_text += text_delta
-                yield ChatMessage(role="assistant", content=accumulated_text, additional_kwargs={"delta": text_delta})
-                await asyncio.sleep(0) 
+                    acc += delta
+                    yield ChatMessage(role="assistant", content=acc, additional_kwargs={"delta":delta})
         return gen()
 
-    # --- Implementación de Complete ---
-    def complete(self, prompt: str, formatted: bool = False, **kwargs) -> CompletionResponse:
+    def complete(self, prompt, formatted=False, **kwargs):
         try:
-            response = self._model_instance.generate_content(prompt)
-            return CompletionResponse(text=response.text)
+            resp = self._model.generate_content(prompt)
+            return CompletionResponse(text=resp.text)
         except Exception as e:
-            print(f"Error en Gemini complete: {e}")
-            return CompletionResponse(text=f"Error al generar completion: {e}")
+            return CompletionResponse(text=f"Error complete: {e}")
 
-    async def acomplete(self, prompt: str, formatted: bool = False, **kwargs) -> CompletionResponse:
+    async def acomplete(self, prompt, formatted=False, **kwargs):
         return await asyncio.to_thread(self.complete, prompt, formatted=formatted, **kwargs)
 
-    def stream_complete(self, prompt: str, formatted: bool = False, **kwargs):
-        response_stream = self._model_instance.generate_content(prompt, stream=True)
-        
+    def stream_complete(self, prompt, formatted=False, **kwargs):
+        stream = self._model.generate_content(prompt, stream=True)
         def gen():
-            accumulated_text = ""
-            for chunk in response_stream:
-                delta = ""
-                if hasattr(chunk, 'text') and chunk.text:
-                    delta = chunk.text
-                elif chunk.parts and hasattr(chunk.parts[0], 'text'):
+            acc = ""
+            for chunk in stream:
+                delta = getattr(chunk, "text", "")
+                if not delta and chunk.parts:
                     delta = chunk.parts[0].text
-                
                 if delta:
-                    accumulated_text += delta
-                    yield CompletionResponse(text=accumulated_text, delta=delta)
-                elif hasattr(chunk, 'prompt_feedback'):
-                    print(f"Feedback del prompt en stream_complete: {chunk.prompt_feedback}")
+                    acc += delta
+                    yield CompletionResponse(text=acc, delta=delta)
         return gen()
 
-    async def astream_complete(self, prompt: str, formatted: bool = False, **kwargs):
-        loop = asyncio.get_event_loop()
-
-        def get_stream_iterator():
-            return self._model_instance.generate_content(prompt, stream=True)
-
-        response_stream = await loop.run_in_executor(None, get_stream_iterator)
-        
-        async def gen():
-            accumulated_text = ""
-            all_chunks_data = [] 
-            for chunk in response_stream: 
-                delta = ""
-                feedback = None
-                if hasattr(chunk, 'text') and chunk.text:
-                    delta = chunk.text
-                elif chunk.parts and hasattr(chunk.parts[0], 'text'):
-                    delta = chunk.parts[0].text
-                
-                if hasattr(chunk, 'prompt_feedback'):
-                    feedback = chunk.prompt_feedback
-                
-                if delta:
-                    all_chunks_data.append({'delta': delta})
-                if feedback:
-                     all_chunks_data.append({'feedback': feedback})
-
-
-            for data in all_chunks_data:
-                if 'delta' in data:
-                    delta_val = data['delta']
-                    accumulated_text += delta_val
-                    yield CompletionResponse(text=accumulated_text, delta=delta_val)
-                elif 'feedback' in data:
-                    print(f"Feedback del prompt en astream_complete: {data['feedback']}")
-                await asyncio.sleep(0) 
-        return gen()
+    async def astream_complete(self, prompt, formatted=False, **kwargs):
+        return await asyncio.to_thread(self.stream_complete, prompt, formatted=formatted, **kwargs)
+
 
-llm = GeminiLLM()
+# -------------------------------------------------------------------
+# 2) Funciones de herramienta
+# -------------------------------------------------------------------
 
-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'}
+HEADERS = {'User-Agent':'Mozilla/5.0'}
 
-def buscar_web(query: str, max_attempts: int = 2) -> str: # Añadido max_attempts
-    """Busca en la web utilizando DuckDuckGo y devuelve los 3 primeros resultados.
-    Intenta ser robusto contra errores de red o rate limits de DDG."""
-    print(f"Herramienta buscar_web: Buscando '{query}'")
-    for attempt in range(max_attempts):
+def buscar_web(query: str, max_attempts: int = 2) -> str:
+    """Búsqueda real en DuckDuckGo con reintentos."""
+    for i in range(max_attempts):
         try:
-            # Aumentar timeout y añadir headers
-            with DDGS(headers=HEADERS, timeout=25) as ddgs: # Timeout de 25 segundos
+            with DDGS(headers=HEADERS, timeout=25) as ddgs:
                 results = list(ddgs.text(query, region='es-es', safesearch='moderate', timelimit='y', max_results=3))
                 if results:
-                    return "\n".join([f"Título: {r['title']}, Cuerpo: {r['body']}" for r in results])
-            return "No se encontraron resultados en la web."
+                    return "\n".join(f"Título: {r['title']}\nCuerpo: {r['body']}" for r in results)
+            return "No se encontraron resultados."
         except Exception as e:
-            print(f"Error en herramienta buscar_web (intento {attempt + 1}/{max_attempts}): {type(e).__name__} - {e}")
-            if "ratelimit" in str(e).lower() or "timed out" in str(e).lower():
-                if attempt < max_attempts - 1: # Si no es el último intento
-                    wait_time = (attempt + 1) * 5 # Backoff simple: 5s, 10s
-                    print(f"Esperando {wait_time}s antes de reintentar búsqueda web...")
-                    time.sleep(wait_time)
-                else: # Último intento fallido
-                    return f"Error persistente al buscar en la web después de {max_attempts} intentos: {e}"
-            else: # Otro tipo de error, no reintentar
-                return f"Error al buscar en la web: {e}"
-    return f"La búsqueda web falló después de {max_attempts} intentos." # Si el bucle termina
-
-search_tool = FunctionTool.from_defaults(
-    fn=buscar_web,
-    name="web_search",
-    description="Busca en la web utilizando DuckDuckGo para obtener información actualizada o temas generales. Devuelve pequeños snippets de texto de los resultados. Úsalo cuando Wikipedia no sea suficiente o la información sea muy reciente."
-)
+            if i < max_attempts-1:
+                time.sleep(5*(i+1))
+            else:
+                return f"Error al buscar_web tras {max_attempts} intentos: {e}"
 
-def get_wikipedia_summary(query: str) -> str:
-    """Busca un resumen conciso de un tema específico en Wikipedia.
-    Intenta primero en español, y si no encuentra la página, intenta en inglés.
-    Devuelve las primeras 3 frases del artículo. Ideal para definiciones, hechos históricos."""
-    print(f"Herramienta wikipedia_lookup: Buscando '{query}'")
-    try:
-        wikipedia.set_lang("es")
-        summary = wikipedia.summary(query, sentences=3, auto_suggest=False, redirect=True)
-        return summary
-    except wikipedia.exceptions.PageError:
-        print(f"Página '{query}' no encontrada en Wikipedia en español. Intentando en inglés...")
-        try:
-            wikipedia.set_lang("en")
-            summary_en = wikipedia.summary(query, sentences=3, auto_suggest=False, redirect=True)
-            # Indicar que la info es de Wikipedia en inglés puede ser útil para el LLM
-            return f"[Información de Wikipedia en Inglés]: {summary_en}"
-        except wikipedia.exceptions.PageError:
-            return f"La página '{query}' no se encontró ni en Wikipedia en español ni en inglés."
-        except wikipedia.exceptions.DisambiguationError as e_en:
-            options_str_en = ", ".join(e_en.options[:3])
-            return f"La búsqueda '{query}' en Wikipedia en inglés es ambigua. Opciones posibles: {options_str_en}. Por favor, sé más específico."
-        except Exception as e_gen_en:
-            return f"Error al buscar '{query}' en Wikipedia en inglés: {type(e_gen_en).__name__} {e_gen_en}"
-    except wikipedia.exceptions.DisambiguationError as e_es:
-        options_str_es = ", ".join(e_es.options[:3])
-        return f"La búsqueda '{query}' en Wikipedia en español es ambigua. Opciones posibles: {options_str_es}. Por favor, sé más específico."
-    except Exception as e_gen_es:
-        return f"Error al buscar '{query}' en Wikipedia en español: {type(e_gen_es).__name__} {e_gen_es}"
-
-wikipedia_tool = FunctionTool.from_defaults(
-    fn=get_wikipedia_summary,
-    name="wikipedia_lookup",
-    description="Busca un resumen conciso de un tema específico en Wikipedia (primero en español, luego en inglés si es necesario). Ideal para definiciones, hechos históricos, biografías. Ejemplo de input: {'query': 'Albert Einstein'}"
-)
+def reverse_text(text: str) -> str:
+    return text[::-1]
 
-def calcular_expresion(expr: str) -> str:
+def analyze_table(table_md: str, question: str) -> str:
     """
-    Evalúa expresiones matemáticas de forma segura.
-    Ejemplos: '2+2', 'math.sqrt(16)', 'pow(2,3)', '37 * 19'.
-    Funciones math disponibles: sqrt, pow, sin, cos, tan, log, log10, pi, e, etc.
+    Parsea tabla Markdown y responde preguntas sencillas.
+    Ejemplo específico: acciones no conmutativas.
     """
     try:
-        # Entorno seguro para eval()
-        allowed_names = {k: v for k, v in math.__dict__.items() if not k.startswith("__")}
-        # Permitir acceso directo a funciones de math sin el prefijo 'math.'
-        # y también con el prefijo 'math.' para consistencia con la descripción.
-        safe_env = allowed_names.copy()
-        safe_env["math"] = math 
-        
-        result = eval(expr, {"__builtins__": {}}, safe_env)
-        return str(result)
-    except NameError as e:
-        return f"Error de cálculo: '{e}'. Asegúrate de usar funciones matemáticas válidas (ej: sqrt, pow, log) y constantes (ej: pi, e)."
-    except SyntaxError as e:
-        return f"Error de sintaxis en la expresión matemática: '{expr}'. Verifica la expresión."
+        # Convertir Markdown a CSV-like
+        lines = [l.strip() for l in table_md.strip().splitlines() if l.strip()]
+        # Quitar las líneas de separador '---'
+        content = [l for l in lines if not set(l) <= set("|- ")]
+        # Extraer filas
+        rows = [ [c.strip() for c in r.split("|")[1:-1]] for r in content ]
+        df = pd.DataFrame(rows[1:], columns=rows[0])
+        # Si la pregunta menciona 'conmutativa', detectamos contrajemplos
+        if "no conmut" in question.lower():
+            S = list(df.columns)
+            counter = set()
+            for x in S:
+                for y in S:
+                    a = df.loc[df[rows[0][0]]==x, y].values[0]
+                    b = df.loc[df[rows[0][0]]==y, x].values[0]
+                    if a != b:
+                        counter.add(x); counter.add(y)
+            return ", ".join(sorted(counter)) or "No hay contraejemplos"
+        # Para otras preguntas, devolvemos la tabla en texto
+        return df.to_csv(index=False)
     except Exception as e:
-        return f"Error de cálculo al evaluar '{expr}': {type(e).__name__} {e}"
+        return f"Error analyze_table: {e}"
 
-calculator_tool = FunctionTool.from_defaults(
-    fn=calcular_expresion,
-    name="calculadora",
-    description="Calculadora para expresiones matemáticas. Puede usar funciones como sqrt(), pow(), log(), sin(), cos(), tan() y constantes como pi, e. Ejemplo: 'sqrt(25) + pow(2,3)' o '37*19'."
+def execute_code(code: str) -> str:
+    """Ejecuta código Python en un subproceso seguro."""
+    try:
+        # Prevenir imports faltantes
+        result = subprocess.run(["python","-c",code], capture_output=True, text=True, timeout=5)
+        if result.stderr:
+            return f"Error en código: {result.stderr.strip()}"
+        return result.stdout.strip() or "(sin salida)"
+    except Exception as e:
+        return f"Error ejecución código: {e}"
+
+def no_tool_solution(query: str) -> str:
+    return "Procedo a responder con mi conocimiento interno."
+
+# -------------------------------------------------------------------
+# 3) Envolver como FunctionTool
+# -------------------------------------------------------------------
+
+search_tool = FunctionTool.from_defaults(fn=buscar_web, name="web_search",
+    description="Busca información en la web usando DuckDuckGo (3 resultados).")
+reverse_tool = FunctionTool.from_defaults(fn=reverse_text, name="reverse_text",
+    description="Invierte el texto dado. Útil para decodificar cadenas al revés.")
+table_tool = FunctionTool.from_defaults(fn=analyze_table, name="analyze_table",
+    description="Parsea tabla Markdown y responde preguntas sobre conmutatividad u otras sencillas.")
+code_tool = FunctionTool.from_defaults(fn=execute_code, name="execute_code",
+    description="Ejecuta fragmentos de código Python para cálculos o procesamiento.")
+fallback_tool = FunctionTool.from_defaults(fn=no_tool_solution, name="no_tool_solution",
+    description="Fallback: responde usando únicamente conocimiento interno si otras herramientas fallan.")
+
+# -------------------------------------------------------------------
+# 4) Índice de herramientas + ToolRetriever
+# -------------------------------------------------------------------
+
+all_tools = [search_tool, reverse_tool, table_tool, code_tool, fallback_tool]
+obj_index = ObjectIndex.from_objects(all_tools, index_cls=VectorStoreIndex)
+tool_retriever = obj_index.as_retriever(similarity_top_k=3)
+
+# -------------------------------------------------------------------
+# 5) Prompt de sistema
+# -------------------------------------------------------------------
+
+system_prompt = (
+    "Eres Alfred, un agente ReAct que usa pasos de pensamiento claros y herramientas especializadas.\n"
+    "Sigue este flujo:\n"
+    "1) Analiza la pregunta.\n"
+    "2) Piensa paso a paso (internamente), luego decide qué acción tomar.\n"
+    "3) Si necesitas datos externos, usa web_search.\n"
+    "4) Si hay texto invertido, usa reverse_text.\n"
+    "5) Si hay tablas Markdown, usa analyze_table.\n"
+    "6) Para cálculos complejos, usa execute_code.\n"
+    "7) Si nada ayuda, llama no_tool_solution y responde con tu conocimiento.\n"
+    "8) Si la pregunta involucra audio, video o imágenes no procesables, informa que no puedes acceder.\n"
+    "9) Proporciona siempre una respuesta final clara al usuario.\n"
+    "\nHerramientas disponibles:\n{tool_descriptions}\n"
+    "No muestres tus pensamientos al usuario; solo la respuesta final."
 )
 
-custom_react_system_prompt = """
-Eres un asistente IA llamado Alfred, diseñado para responder preguntas y completar tareas usando un conjunto de herramientas.
-Sigue estrictamente el formato Thought/Action/Action Input/Observation.
-Cuando respondas, hazlo en el mismo idioma que la pregunta original del usuario.
-Piensa paso a paso. Considera si la información necesaria ya está en la pregunta o en el historial de conversación antes de usar una herramienta.
-Si la pregunta contiene datos tabulares o listas directamente en el prompt, analiza esos datos cuidadosamente para responder. No necesitas herramientas para información ya proporcionada.
-Si una herramienta devuelve un error o no encuentra información útil después de un par de intentos, considera si puedes responder de otra manera o si debes indicar que no puedes obtener la respuesta.
-No inventes respuestas si no tienes la información.
-Para tareas de clasificación que requieren conocimiento especializado (ej. botánica), si no estás seguro de una clasificación, indica que necesitas más información o que la clasificación puede ser compleja.
-"""
-
-# --- AGENTE RESTAURADO ---
+# -------------------------------------------------------------------
+# 6) Inicializar Agent con GeminiLLM
+# -------------------------------------------------------------------
+
+# Contexto de LLM
+service_ctx = ServiceContext.from_defaults(
+    llm=GeminiLLM(model_name="models/gemini-1.5-flash-latest", temperature=0.0)
+)
+
+# Crear el agente ReAct
 alfred_agent = ReActAgent.from_tools(
-    tools=[search_tool, wikipedia_tool, calculator_tool],
-    llm=llm,
-    verbose=True, # Mantener verbose=True para depuración
-    max_iterations=15, # <--- AUMENTAR A 15 (o incluso 20)
-    system_prompt=custom_react_system_prompt
+    tool_retriever=tool_retriever,
+    service_context=service_ctx,
+    system_prompt=system_prompt,
+    verbose=True,         # mostrar pasos para depuración
+    max_iterations=20     # permitir suficiente iteraciones
 )
 
+# -------------------------------------------------------------------
+# 7) Función de invocación
+# -------------------------------------------------------------------
 
-# --- FUNCIÓN DE RESPUESTA DEL AGENTE RESTAURADA ---
 def basic_agent_response(question: str) -> str:
-    print(f"🤖 Alfred (ReAct Agent) recibió la pregunta: {question}")
+    print(f"🤖 Alfred recibió: {question}")
     try:
-        # alfred_agent.query() devuelve un objeto AgentChatResponse
-        agent_chat_response_object = alfred_agent.query(question)
-        
-        # El texto de la respuesta final del agente está en el atributo .response de AgentChatResponse
-        final_response_text = agent_chat_response_object.response 
-        
-        # Verificar si es None o vacío, aunque el agente debería generar algo.
-        if final_response_text is None:
-            print("⚠️ La respuesta final de Alfred fue None.")
-            return "El agente no generó una respuesta textual."
-            
-        print(f"📝 Respuesta final de Alfred: {final_response_text}")
-        return str(final_response_text) # Asegurar que es una cadena
-
+        resp_obj = alfred_agent.query(question)
+        return resp_obj.response or "No se generó respuesta."
     except Exception as e:
-        print(f"💥 Error crítico en Alfred al procesar la pregunta '{question}': {type(e).__name__} - {e}")
-        import traceback
-        traceback.print_exc() 
-        # Devolver el mensaje de error como respuesta para la evaluación
-        return f"Error del agente al procesar la pregunta: {type(e).__name__} - {e}"
+        return f"Error crítico en el agente: {e}"
+
+# -------------------------------------------------------------------
+# 8) Prueba rápida (descomentar para test local)
+# -------------------------------------------------------------------
+if __name__ == "__main__":
+    tests = [
+        "¿Cuánto es 37 por 19?",
+        ".tfel",
+        "|*|a|b|\n|---|---|---|\n|a|b|c|\n|b|c|a|\nprovide the subset involved in non-commutative",
+        "I'm making a grocery list para mi mamá..., incluye milk, eggs, bell pepper, zucchini. Solo vegetales."
+    ]
+    for q in tests:
+        print("Q:", q)
+        print("A:", basic_agent_response(q))
+        print("-"*40)
+