fff

my_tools.py

@@ -1,3 +1,5 @@
+# my_tools.py
+
 import os
 import math
 import time
@@ -5,7 +7,7 @@ import asyncio
 import subprocess
 import requests
 import pandas as pd
-from io import StringIO, BytesIO
+from io import BytesIO
 from bs4 import BeautifulSoup
 from duckduckgo_search import DDGS
 import wikipedia
@@ -19,16 +21,17 @@ from llama_index.core.agent import ReActAgent
 from llama_index.core.callbacks.llama_debug import LlamaDebugHandler
 
 # -------------------------------------------------------------------
-# 1) GeminiLLM personalizado
+# 1) MONKEY-PATCH PARA ChatMessage (por requerimiento de LlamaIndex)
 # -------------------------------------------------------------------
-# Monkey-patch para exponer .message al objeto completo, tal como espera LlamaIndex
 ChatMessage.message = property(lambda self: self)
+
+# -------------------------------------------------------------------
+# 2) Clase GeminiLLM personalizada
+# -------------------------------------------------------------------
 class GeminiLLM(LLM):
     model_name: str = Field(default="models/gemini-1.5-flash-latest")
     temperature: float = Field(default=0.0)
 
-    # Atributos para el modelo y config de generación.
-    # Pydantic los ignorará si no son Fields y Config.extra = "allow" (lo cual tienes)
     _model: object = None
     _gen_cfg: object = None
 
@@ -36,78 +39,58 @@ class GeminiLLM(LLM):
         extra = "allow"
 
     def __init__(self, **kwargs):
-        super().__init__(**kwargs) # Pydantic procesa campos y kwargs
-
-        # --- INICIO DE LA CORRECCIÓN PARA FieldInfo ---
-        # Obtener el valor resuelto de model_name explícitamente
-        # Primero, intentar con el atributo de instancia (que Pydantic debería haber establecido)
-        actual_model_name = self.model_name 
-        
-        # Si sigue siendo un FieldInfo (o no es un string), obtener el valor default del campo
+        super().__init__(**kwargs)
+        # Resolver FieldInfo si es necesario
+        actual_model_name = self.model_name
         if not isinstance(actual_model_name, str):
-            # Acceder a la definición del campo de la clase para obtener su default
-            # self.__fields__ es un dict de los campos Pydantic de la clase
             model_field_definition = self.__fields__.get("model_name")
             if model_field_definition and hasattr(model_field_definition, 'default'):
                 actual_model_name = model_field_definition.default
-            
-            # Como última salvaguarda, si todo falla, usar un string literal (no ideal)
             if not isinstance(actual_model_name, str):
-                # print("ADVERTENCIA: model_name no se pudo resolver a un string, usando valor literal.")
-                actual_model_name = "models/gemini-1.5-flash-latest" 
-        
-        # Lo mismo para temperature, aunque es menos probable que sea un FieldInfo aquí
+                actual_model_name = "models/gemini-1.5-flash-latest"
+
         actual_temperature = self.temperature
         if not isinstance(actual_temperature, (float, int)):
             temp_field_definition = self.__fields__.get("temperature")
             if temp_field_definition and hasattr(temp_field_definition, 'default'):
                 actual_temperature = temp_field_definition.default
             if not isinstance(actual_temperature, (float, int)):
-                # print("ADVERTENCIA: temperature no se pudo resolver a un float, usando 0.0.")
                 actual_temperature = 0.0
-        # --- FIN DE LA CORRECCIÓN PARA FieldInfo ---
 
         key = os.getenv("GEMINI_API_KEY")
         if not key:
-            raise ValueError("GEMINI_API_KEY no configurada")
+            raise ValueError("GEMINI_API_KEY no configurada en variables de entorno")
         genai.configure(api_key=key)
-        
+
         self._gen_cfg = genai.types.GenerationConfig(temperature=actual_temperature)
         self._model = genai.GenerativeModel(
-            model_name=actual_model_name, # Usar el valor de string resuelto
+            model_name=actual_model_name,
             generation_config=self._gen_cfg
         )
-        
+
         if self.callback_manager is None:
             from llama_index.core.callbacks.base import CallbackManager
             self.callback_manager = CallbackManager([])
-            
         if not self.callback_manager.handlers:
             self.callback_manager.add_handler(LlamaDebugHandler())
 
     @property
     def metadata(self):
-        # También asegurar que model_name es un string aquí
         actual_model_name_meta = self.model_name
         if not isinstance(actual_model_name_meta, str):
             model_field_def_meta = self.__fields__.get("model_name")
             if model_field_def_meta and hasattr(model_field_def_meta, 'default'):
                 actual_model_name_meta = model_field_def_meta.default
             if not isinstance(actual_model_name_meta, str):
-                 actual_model_name_meta = "models/gemini-1.5-flash-latest" # Fallback
-
+                actual_model_name_meta = "models/gemini-1.5-flash-latest"
         return LLMMetadata(
             context_window=1048576,
             num_output=8192,
             is_chat_model=True,
             is_function_calling_model=True,
-            model_name=actual_model_name_meta, # Usar el valor de string resuelto
+            model_name=actual_model_name_meta,
         )
 
-    # ... (todos los demás métodos: chat, achat, stream_complete, astream_complete, stream_chat, astream_chat, complete, acomplete)
-    # DEBEN ESTAR EXACTAMENTE COMO EN TU ÚLTIMA VERSIÓN FUNCIONAL DEL CÓDIGO QUE ME PEGASTE.
-    # Los copio de tu último fragmento para asegurar consistencia:
-
     def chat(self, messages: list[ChatMessage], **kwargs):
         hist = []
         for m in messages[:-1]:
@@ -180,20 +163,27 @@ class GeminiLLM(LLM):
     async def acomplete(self, prompt: str, formatted=False, **kwargs):
         return await asyncio.to_thread(self.complete, prompt, formatted=formatted, **kwargs)
 
-# --- Fin de la clase GeminiLLM ---
 # -------------------------------------------------------------------
-# 2) Herramientas
+# 3) HERRAMIENTAS PERSONALIZADAS
 # -------------------------------------------------------------------
 HEADERS = {'User-Agent': 'Mozilla/5.0'}
 
-# Web search tool
 def buscar_web(query: str, max_attempts: int = 2, num_results: int = 5) -> str:
+    """
+    Usa DuckDuckGo (vía duckduckgo_search) para devolver hasta 'num_results' resultados.
+    """
     for i in range(max_attempts):
         try:
             with DDGS(headers=HEADERS, timeout=25) as ddgs:
                 results = list(ddgs.text(query, region='es-es', safesearch='moderate', max_results=num_results))
                 if results:
-                    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))
+                    salida = []
+                    for idx, r in enumerate(results):
+                        titulo = r.get('title', 'Sin título')
+                        enlace = r.get('href', 'N/A')
+                        cuerpo = r.get('body', '')
+                        salida.append(f"Fuente {idx+1}: Título: {titulo}\nEnlace: {enlace}\nCuerpo: {cuerpo}")
+                    return "\n\n".join(salida)
             return "No se encontraron resultados relevantes."
         except Exception as e:
             if i < max_attempts - 1:
@@ -201,15 +191,19 @@ def buscar_web(query: str, max_attempts: int = 2, num_results: int = 5) -> str:
             else:
                 return f"Error buscar_web tras {max_attempts} intentos: {e}"
 
-# Reverse text tool
 def reverse_text(text: str) -> str:
+    """Invierte el orden de los caracteres en 'text'."""
     return text[::-1]
 
-# Analyze markdown table
 def analyze_table(table_md: str, question: str) -> str:
+    """
+    Recibe una tabla en Markdown (con pipes y separadores) y, si la pregunta menciona 'conmut',
+    verifica la conmutatividad de la matriz; en otro caso, devuelve el CSV equivalente.
+    """
     try:
+        # Quitar líneas de separación y vacías
         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 ]
+        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])
@@ -219,7 +213,7 @@ def analyze_table(table_md: str, question: str) -> str:
             for x in cols:
                 for y in cols:
                     try:
-                        if df.loc[df[rows[0][0]]==x, y].iat[0] != df.loc[df[rows[0][0]]==y, x].iat[0]:
+                        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
@@ -228,15 +222,18 @@ def analyze_table(table_md: str, question: str) -> str:
     except Exception as e:
         return f"Error analyze_table: {e}"
 
-# Execute code tool
 def execute_code(code: str) -> str:
+    """
+    Primero intenta evaluar con eval() en un entorno protegido; si falla, invoca un subproceso 'python -c'.
+    """
     try:
         allowed_globals = {'__builtins__': None, 'math': math}
         try:
             val = eval(code, allowed_globals, {})
             return str(val)
         except:
-            res = subprocess.run(["python", "-S", "-c", code], capture_output=True, text=True, timeout=10)
+            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)"
@@ -245,10 +242,13 @@ def execute_code(code: str) -> str:
     except Exception as e:
         return f"Error crítico: {e}"
 
-# Read Excel tool
 def read_excel_data(file_path: str, sheet_name=0) -> str:
+    """
+    Si file_path empieza con 'http', descarga el contenido y lee con pandas.
+    Si es una ruta local, lee directamente. Devuelve el CSV.
+    """
     try:
-        if file_path.startswith(('http://','https://')):
+        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)
@@ -262,21 +262,26 @@ def read_excel_data(file_path: str, sheet_name=0) -> str:
         return f"Error read_excel_data: {e}"
 
 def classify_botanical(items_list_str: str) -> str:
-    # Mapas de traducción para términos en inglés → español
+    """
+    Clasifica botánicamente una lista de alimentos (en inglés o español) en Verduras, Frutas u Otros.
+    """
+    # Mapeo inglés → español
     mapping = {
         "tomato": "tomate", "pepper": "pimiento", "bell pepper": "pimiento",
         "cucumber": "pepino", "eggplant": "berenjena", "zucchini": "calabacín",
         "avocado": "aguacate", "squash": "calabaza", "pea": "guisante", "corn": "maíz",
-        "bean": "judía", "green beans": "judía verde", "sweet potato": "batata",
+        "bean": "judía", "beans": "judía", "green beans": "judía verde", "sweet potato": "batata",
+        "whole bean coffee": "café", "rice": "arroz", "oregano": "orégano"
     }
-    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","apio","brócoli","lechuga"}
-    # Convertir todo a minúsculas y mapear sinónimos
+    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", "pepino", "pepino"}
+
     items = []
     for raw in items_list_str.split(','):
         itm = raw.strip().lower()
         itm_es = mapping.get(itm, itm)
         items.append(itm_es)
+
     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]
@@ -286,116 +291,170 @@ def classify_botanical(items_list_str: str) -> str:
         f"Otros: {', '.join(sorted(set(others)))}"
     )
 
-# Wikipedia table scraper
 def scrape_wikipedia_table(page_title: str, section: str, table_index: int = 0) -> str:
+    """
+    Busca una sección en una página de Wikipedia y extrae la tabla indicada (por índice).
+    Devuelve el CSV.
+    """
     try:
         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)
+        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)."
+            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]
-
-all_tools = [search_tool, scrape_tool, table_tool, code_tool, excel_tool, botanical_tool, reverse_tool, fallback_tool]
-
-# Construir descripciones de herramientas
-# CORRECCIÓN AQUÍ: Acceder a name y description a través de metadata
-#tool_descriptions = "\n".join([
-    #f"{t.metadata.name}: {t.metadata.description}"  # Cambiado t.name a t.metadata.name y t.tool_config.description a t.metadata.description
-    #for t in all_tools
-#])
+# -------------------------------------------------------------------
+# 4) ENVUELTORES DE HERRAMIENTAS (FunctionTool)
+# -------------------------------------------------------------------
+search_tool = FunctionTool.from_defaults(
+    fn=buscar_web,
+    name="web_search",
+    description="Búsqueda DuckDuckGo (máximo 5 resultados)."
+)
+reverse_tool = FunctionTool.from_defaults(
+    fn=reverse_text,
+    name="reverse_text",
+    description="Invierte el texto recibido."
+)
+table_tool = FunctionTool.from_defaults(
+    fn=analyze_table,
+    name="analyze_markdown_table",
+    description="Procesa tabla Markdown y verifica conmutatividad si se menciona 'conmut'."
+)
+code_tool = FunctionTool.from_defaults(
+    fn=execute_code,
+    name="execute_code",
+    description="Ejecuta código Python de forma segura."
+)
+excel_tool = FunctionTool.from_defaults(
+    fn=read_excel_data,
+    name="read_excel_data",
+    description="Lee un archivo Excel (local o URL) y devuelve CSV."
+)
+botanical_tool = FunctionTool.from_defaults(
+    fn=classify_botanical,
+    name="classify_botanical_foods",
+    description="Clasifica botánicamente una lista de alimentos."
+)
+scrape_tool = FunctionTool.from_defaults(
+    fn=scrape_wikipedia_table,
+    name="scrape_wiki_table",
+    description="Extrae tabla de sección específica de Wikipedia."
+)
+fallback_tool = FunctionTool.from_defaults(
+    fn=lambda q: "Procedo con conocimiento interno.",
+    name="no_tool_solution",
+    description="Respuesta genérica por conocimiento interno si todo lo demás falla."
+)
+
+all_tools = [
+    search_tool,
+    scrape_tool,
+    table_tool,
+    code_tool,
+    excel_tool,
+    botanical_tool,
+    reverse_tool,
+    fallback_tool
+]
+
+# -------------------------------------------------------------------
+# 5) DESCRIPCIONES DE HERRAMIENTAS (con ejemplos)
+# -------------------------------------------------------------------
 tool_descriptions = "\n".join([
     f"{t.metadata.name}: {t.metadata.description} "
     + {
-        "classify_botanical_foods": "(Ejemplo: classify_botanical_foods('zanahoria, manzana, tomate'))",
-        "read_excel_data": "(Ejemplo: read_excel_data('ventas.xlsx', sheet_name=0))",
-        "analyze_markdown_table": "(Ejemplo: analyze_markdown_table('| A | B |\\n|---|---|\\n|1|2|', '¿Es conmut?'))",
-        "web_search": "(Ejemplo: web_search('¿Quién ganó el Clásico 2025?'))",
-        "scrape_wiki_table": "(Ejemplo: scrape_wiki_table('Lionel Messi', 'Carrera', 0))",
-        "reverse_text": "(Ejemplo: reverse_text('hola'))",
-        "execute_code": "(Ejemplo: execute_code('2+2'))",
+        "classify_botanical_foods": "(Ej: classify_botanical_foods('zanahoria, pepino, tomate'))",
+        "read_excel_data": "(Ej: read_excel_data('ventas.xlsx', sheet_name=0))",
+        "analyze_markdown_table": "(Ej: analyze_markdown_table('| A | B |\\n|---|---|\\n|1|2|', '¿Es conmut?'))",
+        "web_search": "(Ej: web_search('¿Quién ganó la Champions 2025?'))",
+        "scrape_wiki_table": "(Ej: scrape_wiki_table('Lionel Messi', 'Carrera', 0))",
+        "reverse_text": "(Ej: reverse_text('Hola'))",
+        "execute_code": "(Ej: execute_code('5*7'))",
     }.get(t.metadata.name, "")
     for t in all_tools
 ])
 
-# Prompt de sistema 
+# -------------------------------------------------------------------
+# 6) PROMPT DE SISTEMA MEJORADO
+# -------------------------------------------------------------------
 system_prompt = f"""
 Eres Alfred, un agente ReAct eficiente y preciso. Tu objetivo es responder correctamente usando las herramientas disponibles.
-Sigue este flujo para cada pregunta:
-1. LEE la pregunta y analiza palabras clave.
-   - Si ves “lista” de “alimentos” o “categorizar” cosas botánicamente, usa classify_botanical_foods(items_coma_sep).
-   - Si ves referencia a un “archivo Excel” o “attached Excel file”, usa read_excel_data(ruta_o_URL).
-   - Si ves una “tabla Markdown” (columnas/filas con pipes), usa analyze_markdown_table(tabla_md, pregunta).
-   - Si necesitas buscar información en la web, usa web_search(query).
-   - Si hay que raspar una tabla en Wikipedia, usa scrape_wiki_table(título_página, sección, índice_tabla).
-   - Si debes invertir texto, usa reverse_text(texto).
-   - Si debes ejecutar código Python directamente, usa execute_code(código_python).
-
-2. Selecciona la HERRAMIENTA adecuada y construye el input:
-   Ejemplos:
-     - Pregunta: “Por favor, clasifica esta lista de verduras y frutas: tomate, zanahoria, manzana,…”
-       → TOOL CALL: classify_botanical_foods("tomate, zanahoria, manzana,…")
-     - Pregunta: “Adjunto un Excel con ventas, ¿cuál fue la suma de las ventas de comida sin bebidas?”
-       → TOOL CALL: read_excel_data("ruta/o/URL/al/archivo.xlsx")
-
+Sigue este flujo en cada pregunta:
+1. LEE la pregunta y analiza palabras clave:
+   - Si menciona “lista” de “alimentos” o “categorizar” botánicamente, llama:
+        classify_botanical_foods(<lista_coma_sep>).
+   - Si menciona “archivo Excel” o “Excel adjunto”, llama:
+        read_excel_data(<ruta_o_URL>).
+   - Si ves una “tabla Markdown”, llama:
+        analyze_markdown_table(<tabla_md>, <pregunta>).
+   - Si necesitas información general de la web, llama:
+        web_search(<consulta>).
+   - Si necesitas raspar tablas de Wikipedia, llama:
+        scrape_wiki_table(<título>, <sección>, <índice_tabla>).
+   - Si hay que invertir texto, llama:
+        reverse_text(<texto>).
+   - Si hay que ejecutar código Python, llama:
+        execute_code(<código>).
+2. GENERA el “TOOL CALL” con la entrada correcta.
 3. EJECUTA la herramienta y observa el resultado.
-4. VERIFICA que la salida tenga sentido con la pregunta (si algo falla, vuelve a intentarlo).
-5. RESPONDE de forma clara y concisa usando la salida de la herramienta.
+4. VERIFICA que el resultado responda bien la pregunta. Si no, intenta otro paso.
+5. RESPONDE de forma clara y concisa usando la salida obtenida.
 
-Herramientas disponibles (úsa solo estos nombres exactos):
+Herramientas disponibles (USAR EXÁCTAMENTE estos nombres):
 {tool_descriptions}
 """
 
-# Inicializar agente
-llm = GeminiLLM() # LlamaDebugHandler se añade dentro de GeminiLLM si no hay handlers
+# -------------------------------------------------------------------
+# 7) INICIALIZAR EL AGENTE ReActAgent
+# -------------------------------------------------------------------
+llm = GeminiLLM()
 alfred_agent = ReActAgent.from_tools(
     tools=all_tools,
     llm=llm,
     system_prompt=system_prompt,
     verbose=True,
-    max_iterations=25,
-    callback_manager=llm.callback_manager, # Asegura que el agente usa el callback manager del LLM
-    handle_parsing_errors=True,  # que reintente si el LLM genera JSON malformado
+    max_iterations=25,            # Más iteraciones para razonamiento multi-paso
+    callback_manager=llm.callback_manager,
+    handle_parsing_errors=True     # Para que reintente si la llamada a herramienta sale malformada
 )
 
 def basic_agent_response(question: str) -> str:
+    """
+    Si detecta “Excel adjunto”, asume que SAIA inyecta el path y fuerza read_excel_data.
+    De lo contrario, usa ReActAgent.query().
+    """
     try:
-
-        # Si detectamos “Excel” en el texto, extraemos la ruta (SAIA suele anotar algo como “attached Excel file”)
-        if "attached Excel" in question.lower() or "archivo excel" in question.lower():
-            # Supongamos que SAIA añade algo como “see attached Excel file” sin ruta en la pregunta.
-            # Podemos devolver un mensaje especial que indique al usuario que suba la ruta.
-            # Pero en la práctica, SAIA pasa el path en un campo aparte; aquí solo forzamos a usar read_excel_data:
-            # (En muchos casos, SAIA evalúa que invoques la herramienta correctamente)
-            # Podemos invocar read_excel_data sin parámetros y devolver un placeholder:
+        # Forzar uso de read_excel_data si aparece Excel en la pregunta
+        if "attached excel" in question.lower() or "archivo excel" in question.lower():
+            # En el entorno SAIA normalmente inyectan la ruta real; aquí usamos un placeholder.
             return read_excel_data("data/attached.xlsx")
-        
         resp = alfred_agent.query(question)
         if hasattr(resp, 'response') and resp.response is not None:
             return str(resp.response)
         elif resp is not None:
             return str(resp)
-        return "No se generó una respuesta válida."
+        else:
+            return "No se generó una respuesta válida."
     except Exception as e:
         return f"Error crítico del agente: {e}"
 
+# --- FIN DE my_tools.py ---
+
+