Create app.py

app.py

@@ -0,0 +1,689 @@
+import gradio as gr
+from transformers import pipeline, AutoModelForSeq2SeqLM, AutoTokenizer
+import torch
+import json
+import re
+import logging
+import sys
+from collections import defaultdict
+import time # Para pausas simuladas y feedback visual
+
+# --- Configuración Básica y Logging ---
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s - %(levelname)s - %(message)s',
+                    handlers=[logging.StreamHandler(sys.stdout)])
+logger = logging.getLogger(__name__)
+
+logger.info("SentientFlow: The Dynamic Cognition Engine - Iniciando app.py")
+
+# --- Carga de Modelos AI (Los "Órganos Cognitivos") ---
+# Definimos los modelos y sus propósitos. Intentamos usar modelos relativamente pequeños
+# que *tienen* que caber en un Space gratuito CPU/GPU básica.
+# Si hay OOM (Out Of Memory) errores, estos modelos deben ser reemplazados por versiones más pequeñas.
+
+MODEL_CONFIG = {
+    # Modelo para la "Cognición Dinámica" / Planificación Paso a Paso / Razonamiento
+    # Debe ser bueno entendiendo instrucciones, el estado actual y generando JSON/texto estructurado.
+    # Flan-T5 Base es un buen candidato, pero Small podría ser necesario por memoria. Probemos Base.
+    "dynamic_cognition_model": {"model_name": "google/flan-t5-base", "tokenizer_name": "google/flan-t5-base"},
+
+    # Modelos para "Procesos Cognitivos" (Las tareas a ejecutar) - Usamos Pipelines
+    "summarization_pipeline": {"pipeline_key": "summarization", "model_name": "sshleifer/distilbart-cnn-1-2"}, # Un BART pequeño para resumen
+    "translation_en_es_pipeline": {"pipeline_key": "translation_en_to_es", "model_name": "Helsinki-NLP/opus-mt-en-es"},
+    "sentiment_analysis_pipeline": {"pipeline_key": "sentiment-analysis", "model_name": "cardiffnlp/twitter-roberta-base-sentiment"}, # Modelo de sentimiento rápido
+    "ner_extraction_pipeline": {"pipeline_key": "ner", "model_name": "dslim/bert-base-NER"}, # BERT base para NER
+    # Modelo/Pipeline para tareas Text2Text más generales: Extracción de Info, Q&A, Síntesis Final
+    "text2text_pipeline": {"pipeline_key": "text2text-generation", "model_name": "google/flan-t5-small"}, # T5 Small para tareas flexibles
+    # Puedes añadir más modelos/procesos aquí (ej: zero-shot-classification con un modelo pequeño)
+}
+
+# Diccionarios para almacenar los modelos y pipelines cargados exitosamente
+loaded_models = {}
+loaded_pipelines = {}
+available_cognitive_processes = {} # Mapeo de nombre de proceso a función de ejecución
+
+
+def load_ai_models():
+    """Carga todos los modelos y pipelines definidos en MODEL_CONFIG."""
+    global loaded_models, loaded_pipelines, available_cognitive_processes
+    logger.info("🚀 Iniciando carga de modelos para SentientFlow...")
+
+    # Determinar el dispositivo
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    logger.info(f"Dispositivo de carga: {device}")
+    device_idx = 0 if device.type == 'cuda' else -1 # Para pipelines
+
+    for model_alias, config in MODEL_CONFIG.items():
+        model_name = config["model_name"]
+        tokenizer_name = config.get("tokenizer_name", model_name) # Tokenizer puede ser el mismo
+
+        try:
+            logger.info(f"Cargando modelo/pipeline: {model_alias} ({model_name})...")
+            if "pipeline_key" in config:
+                # Cargar como pipeline
+                pipeline_key = config["pipeline_key"]
+                # La función pipeline maneja la carga de modelo/tokenizer y mover a device
+                pipe = pipeline(pipeline_key, model=model_name, tokenizer=tokenizer_name, device=device_idx)
+                loaded_pipelines[model_alias] = pipe
+                logger.info(f"Pipeline '{model_alias}' cargado.")
+            else:
+                # Cargar solo tokenizer y modelo (para modelos usados directamente, como el planner)
+                tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)
+                model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
+                model.to(device) # Mover el modelo al dispositivo
+                loaded_models[model_alias] = {"model": model, "tokenizer": tokenizer, "device": device}
+                logger.info(f"Modelo '{model_alias}' cargado.")
+
+        except Exception as e:
+            logger.error(f"❌ Error cargando {model_alias} ({model_name}): {e}")
+            loaded_models[model_alias] = None
+            loaded_pipelines[model_alias] = None
+            logger.warning(f"{model_alias} no estará disponible.")
+
+    logger.info("✅ Carga de modelos de IA finalizada.")
+    # Limpiar caché de GPU tras carga si es necesario
+    if device.type == 'cuda':
+        torch.cuda.empty_cache()
+    logger.info("Memoria caché de GPU liberada después de la carga.")
+
+
+# --- Definición de Procesos Cognitivos Disponibles ---
+# Cada función representa un "acto cognitivo". Deben ser lo suficientemente flexibles
+# para tomar como input el texto principal Y los resultados acumulados.
+# Devuelven (resumen_legible_humano, resultado_estructurado_dict).
+
+class CognitiveProcesses:
+    """Implementaciones de los actos cognitivos."""
+
+    @staticmethod
+    def summarize(text_context, cumulative_results, params, objective):
+        """Resume el texto principal o una parte/resultado si params lo indica."""
+        pipe = loaded_pipelines.get("summarization_pipeline")
+        if not pipe: return "❌ Resumen: Modelo no disponible.", {"summary": None, "status": "error"}
+        try:
+            # Implementar lógica para resumir based_on params o cumulative_results si se desea en el futuro
+            # Por ahora, resume el texto principal (quizás truncado)
+            max_input_chars = 3000 # Ajustado para distilbart-cnn-1-2
+            text_to_summarize = text_context # default
+            if len(text_to_summarize) > max_input_chars:
+                 logger.warning(f"Resumen: Texto largo ({len(text_to_summarize)}), truncando.")
+                 text_to_summarize = text_to_summarize[:max_input_chars] + "..."
+
+            summary = pipe(text_to_summarize, max_length=150, min_length=40, do_sample=False)[0]['summary_text']
+            return f"✅ Resumen: {summary}", {"summary": summary, "from_text_length": len(text_context), "status": "success"}
+        except Exception as e:
+            logger.error(f"Error en resumen: {e}")
+            return f"❌ Error durante resumen: {e}", {"summary": None, "error": str(e), "status": "error"}
+
+    @staticmethod
+    def translate(text_context, cumulative_results, params, objective):
+        """Traduce el texto principal a un idioma (español o inglés)."""
+        target_lang = params.get('language', 'español').lower()
+        if target_lang == 'español':
+             pipe = loaded_pipelines.get("translation_en_es_pipeline")
+             pipe_key = "translation_en_es_pipeline"
+        elif target_lang == 'ingles':
+             pipe = loaded_pipelines.get("translation_es_en_pipeline") # Asumimos es_en si pide inglés
+             pipe_key = "translation_es_en_pipeline"
+        else:
+             return f"❌ Traducción: Idioma '{target_lang}' no soportado.", {"translation": None, "status": "error"}
+
+        if not pipe: return f"❌ Traducción a {target_lang}: Modelo no disponible.", {"translation": None, "status": "error"}
+
+        try:
+            max_input_chars = 1500 # Ajustado para Opus-MT
+            text_to_translate = text_context
+            if len(text_to_translate) > max_input_chars:
+                 logger.warning(f"Traducción a {target_lang}: Texto largo ({len(text_to_translate)}), truncando.")
+                 text_to_translate = text_to_translate[:max_input_chars] + "..."
+
+            translation = pipe(text_to_translate, max_length=512)[0]['translation_text']
+            return f"✅ Traducción a {target_lang}: {translation}", {"translation": translation, "language": target_lang, "status": "success"}
+        except Exception as e:
+            logger.error(f"Error en traducción a {target_lang}: {e}")
+            return f"❌ Error durante traducción a {target_lang}: {e}", {"translation": None, "error": str(e), "status": "error"}
+
+    @staticmethod
+    def analyze_sentiment(text_context, cumulative_results, params, objective):
+        """Analiza el sentimiento del texto principal."""
+        pipe = loaded_pipelines.get("sentiment_analysis_pipeline")
+        if not pipe: return "❌ Sentimiento: Modelo no disponible.", {"sentiment": None, "status": "error"}
+        try:
+            max_input_chars = 500 # Ajustado para modelos tipo BERT
+            text_to_analyze = text_context
+            if len(text_to_analyze) > max_input_chars:
+                 logger.warning(f"Sentimiento: Texto largo ({len(text_to_analyze)}), truncando.")
+                 text_to_analyze = text_to_analyze[:max_input_chars] + "..."
+
+            sentiment_result = pipe(text_to_analyze)[0]
+            # sentiment_result es un dict como {'label': '4 stars', 'score': 0.8}
+            return f"✅ Sentimiento: '{sentiment_result['label']}' ({sentiment_result['score']:.2f})", {"sentiment": sentiment_result, "status": "success"}
+        except Exception as e:
+            logger.error(f"Error en análisis de sentimiento: {e}")
+            return f"❌ Error durante análisis de sentimiento: {e}", {"sentiment": None, "error": str(e), "status": "error"}
+
+    @staticmethod
+    def extract_entities(text_context, cumulative_results, params, objective):
+        """Extrae entidades nombradas del texto principal."""
+        pipe = loaded_pipelines.get("ner_extraction_pipeline")
+        if not pipe: return "❌ Entidades: Modelo no disponible.", {"entities": [], "status": "error"}
+        try:
+            max_input_chars = 1000 # Ajustado para BERT base
+            text_to_extract = text_context
+            if len(text_to_extract) > max_input_chars:
+                 logger.warning(f"Entidades: Texto largo ({len(text_to_extract)}), truncando.")
+                 text_to_extract = text_to_extract[:max_input_chars] + "..."
+
+            entities = pipe(text_to_extract)
+            # Post-procesamiento para unir sub-palabras
+            processed_entities = []
+            current_entity = None
+            for entity in entities:
+                word = entity['word']
+                # Reemplazar espacios en sub-tokens si el modelo los introduce (ej: " _ ")
+                word = word.replace(" _ ", " ").strip()
+
+                # Heurística para unir entidades: si es continuation (##) O es el mismo tipo y la siguiente palabra
+                # Nota: Modelos BERT pueden tokenizar "New York" como ["New", "York"] o ["New", " York"]. ## indica sub-token,
+                # pero a veces modelos distintos usan otras heurísticas o no las usan.
+                # Una heurística más robusta podría implicar distancia entre tokens o tipos de entidades.
+                # Simplificamos: si empieza con ## o es un token adyacente del mismo tipo.
+                is_continuation = word.startswith("##") or (current_entity and entity['index'] == current_entity['end_index'] + 1 and entity['entity'].split('-')[-1] == current_entity['type'])
+
+                if current_entity is None or not is_continuation:
+                    if current_entity: # Guardar la entidad anterior si existe
+                        processed_entities.append({
+                            "word": "".join(current_entity["words"]).replace(" ##", "").replace(" ##", " ").strip(), # Unir y limpiar sub-tokens, manejar espacios
+                            "type": current_entity["type"],
+                            "score": current_entity["score"]
+                        })
+                    # Iniciar nueva entidad
+                    current_entity = {
+                        "words": [word],
+                        "type": entity['entity'].split('-')[-1],
+                        "score": entity['score'],
+                        "start_index": entity.get('start', -1), # Añadir índices si el pipeline los da
+                        "end_index": entity.get('end', -1)
+                    }
+                else: # Continuación de la entidad actual
+                    current_entity["words"].append(word)
+                    current_entity["score"] = max(current_entity["score"], entity['score']) # O promediar
+                    current_entity["end_index"] = entity.get('end', current_entity["end_index"])
+
+
+            # Añadir la última entidad si existe
+            if current_entity:
+                 processed_entities.append({
+                     "word": "".join(current_entity["words"]).replace(" ##", "").replace(" ##", " ").strip(),
+                     "type": current_entity["type"],
+                     "score": current_entity["score"]
+                 })
+
+            # Filtrar entidades con score bajo o tipos no deseados si es necesario
+            # processed_entities = [e for e in processed_entities if e['score'] > 0.9] # Ejemplo
+
+            summary_list = [f"{e['word']} ({e['type']})" for e in processed_entities[:10]] # Mostrar las primeras 10 en resumen
+            summary_str = "; ".join(summary_list) if summary_list else "ninguna detectada."
+
+            return f"✅ Entidades Extraídas: {summary_str}", {"entities": processed_entities, "status": "success"}
+        except Exception as e:
+            logger.error(f"Error en extracción de entidades: {e}")
+            return f"❌ Error durante extracción de entidades: {e}", {"entities": [], "error": str(e), "status": "error"}
+
+    @staticmethod
+    def extract_information(text_context, cumulative_results, params, objective):
+        """Extrae información específica usando un modelo text2text basado en una query."""
+        pipe = loaded_pipelines.get("text2text_pipeline")
+        if not pipe: return "❌ Extracción Info: Modelo no disponible.", {"extracted_info": None, "status": "error"}
+
+        # La query puede venir de params, del objetivo o ser una query genérica
+        query = params.get('query', objective if len(objective) < 100 else "información clave")
+
+        try:
+            max_input_chars = 1500 # Ajustado para Flan-T5 small
+            # Formato de prompt para T5: "question: ... context: ..."
+            prompt = f"question: {query}\ncontext: {text_context}"
+            if len(prompt) > max_input_chars:
+                 logger.warning(f"Extracción Info: Prompt largo ({len(prompt)}), truncando contexto.")
+                 # Truncamos el contexto si el prompt es muy largo
+                 prompt = f"question: {query}\ncontext: {text_context[:max_input_chars - len(f'question: {query}\ncontext: ')]}..."
+
+
+            extracted_info = pipe(prompt, max_length=150, do_sample=False)[0]['generated_text']
+
+            return f"✅ Información Extraída ('{query[:50]}...'): {extracted_info}", {"extracted_info": extracted_info, "query": query, "status": "success"}
+        except Exception as e:
+            logger.error(f"Error en extracción de info: {e}")
+            return f"❌ Error durante extracción de info: {e}", {"extracted_info": None, "error": str(e), "status": "error"}
+
+    @staticmethod
+    def synthesize_report(text_context, cumulative_results, params, objective):
+        """Genera un reporte final combinando texto original y resultados acumulados."""
+        pipe = loaded_pipelines.get("text2text_pipeline")
+        if not pipe: return "❌ Síntesis Final: Modelo no disponible.", {"final_report": "Modelo de síntesis no disponible.", "status": "error"}
+
+        try:
+            # Crear un prompt que incluya el objetivo, el texto original (parcial)
+            # y un resumen formateado de los resultados acumulados.
+            results_summary_str = "Resultados del análisis:\n"
+            if cumulative_results:
+                for key, result_data in cumulative_results.items():
+                    # Intentar formatear resultados comunes de forma legible para el modelo
+                    if result_data and isinstance(result_data, dict) and result_data.get("status") == "success":
+                        if "summary" in result_data: results_summary_str += f"- Resumen: {result_data['summary'][:200]}...\n"
+                        elif "translation" in result_data: results_summary_str += f"- Traducción ({result_data.get('language')}): {result_data['translation'][:200]}...\n"
+                        elif "sentiment" in result_data: results_summary_str += f"- Sentimiento: {result_data['sentiment'].get('label')} ({result_data['sentiment'].get('score'):.2f})\n"
+                        elif "entities" in result_data:
+                             entities_list = [f"{e['word']} ({e['type']})" for e in result_data['entities'][:5]]
+                             results_summary_str += f"- Entidades Clave: {'; '.join(entities_list)}...\n"
+                        elif "extracted_info" in result_data: results_summary_str += f"- Información Extraída: {result_data['extracted_info'][:200]}...\n"
+                        # Añadir manejo para otros tipos de resultados si se crean
+                if results_summary_str == "Resultados del análisis:\n":
+                     results_summary_str = "Resultados del análisis: No hay resultados exitosos para sintetizar."
+            else:
+                results_summary_str = "Resultados del análisis: No hay resultados parciales."
+
+
+            # Limitar el texto original para el prompt
+            original_text_preview = text_context[:2000] + "..." if len(text_context) > 2000 else text_context # Permitir un poco más de texto original
+
+            # Prompt para la síntesis final
+            prompt = f"""
+            Objective: {objective}
+            Original Text Summary: {original_text_preview[:1000]}...
+            ---
+            {results_summary_str[:1000]}... # Limitar también el resumen de resultados
+            ---
+            Based on the objective, the original text, and the analysis results provided, synthesize a comprehensive report. Make it insightful and directly address the objective.
+            Report:
+            """
+            max_input_chars = 2000 # Ajustado para el prompt combinado + texto
+
+            # Ensure the prompt length is within limits after combining parts
+            if len(prompt) > max_input_chars:
+                 logger.warning(f"Síntesis Final: Prompt muy largo ({len(prompt)}), truncando...")
+                 # Re-build prompt more aggressively truncated if needed
+                 prompt = f"""
+                Objective: {objective[:200]}...
+                Original Text Summary: {original_text_preview[:800]}...
+                ---
+                {results_summary_str[:800]}...
+                ---
+                Based on the objective, text, and analysis results, synthesize a comprehensive report.
+                Report:
+                """
+                 prompt = prompt[:max_input_chars] # Final truncation just in case
+
+
+            # Generar el reporte final
+            final_report_text = pipe(prompt, max_length=600, num_return_sequences=1, do_sample=True, temperature=0.8)[0]['generated_text']
+
+            return f"✅ Síntesis Final Generada.", {"final_report_text": final_report_text, "status": "success"}
+
+        except Exception as e:
+            logger.error(f"Error en síntesis final: {e}")
+            return f"❌ Error durante síntesis final: {e}", {"final_report_text": None, "error": str(e), "status": "error"}
+
+
+# Mapeo de nombres de procesos (usados por el modelo planificador) a las funciones de CognitiveProcesses
+# Se llena después de cargar los modelos para verificar disponibilidad
+PROCESS_FUNCTION_MAP = {
+    "summarize": CognitiveProcesses.summarize,
+    "translate": CognitiveProcesses.translate,
+    "analyze_sentiment": CognitiveProcesses.analyze_sentiment,
+    "extract_entities": CognitiveProcesses.extract_entities,
+    "extract_information": CognitiveProcesses.extract_information,
+    "synthesize_report": CognitiveProcesses.synthesize_report, # Este debería ser a menudo el último paso
+    # Añadir nuevos procesos aquí
+}
+
+# Lista de nombres de procesos disponibles para el prompt del modelo de cognición dinámica
+AVAILABLE_PROCESSES = ", ".join([f"`{name}`" for name in PROCESS_FUNCTION_MAP.keys()])
+
+
+# --- Motor de Cognición Dinámica (El "Sentient Core") ---
+
+def run_dynamic_cognition(objective, initial_text, max_cycles=7, progress=gr.Progress()):
+    """
+    Ejecuta ciclos cognitivos dinámicos para lograr el objetivo.
+    En cada ciclo, la IA decide el siguiente paso.
+    """
+    logger.info(f"🧠 SentientFlow: Iniciando proceso para objetivo: '{objective}'")
+    progress(0, desc="Iniciando SentientFlow...")
+
+    # Obtener modelo de cognición dinámica
+    cognition_model_info = loaded_models.get("dynamic_cognition_model")
+    if not cognition_model_info or not cognition_model_info["model"] or not cognition_model_info["tokenizer"]:
+         logger.error("❌ Modelo de cognición dinámica no cargado.")
+         return initial_text, {"status": "error", "message": "Modelo de cognición dinámica no disponible."}, "❌ Error: Modelo de cognición dinámica no cargado. La automatización dinámica es imposible."
+
+    cognition_model = cognition_model_info["model"]
+    cognition_tokenizer = cognition_model_info["tokenizer"]
+    cognition_device = cognition_model_info["device"]
+
+
+    current_text = initial_text # El texto principal sobre el que operan algunos procesos
+    cumulative_results = {} # Memoria de trabajo: acumula resultados estructurados
+    execution_log = ["--- Log de SentientFlow ---"]
+    history = [] # Para dar contexto al modelo de cognición (pasos anteriores)
+
+    execution_log.append(f"🎯 Objetivo: {objective}")
+    execution_log.append(f"📜 Texto Inicial (parcial): {initial_text[:500]}...")
+    execution_log.append("---")
+
+    # Asegurarse de que los procesos estén mapeados y disponibles
+    available_processes_in_map = {name: func for name, func in PROCESS_FUNCTION_MAP.items() if name in AVAILABLE_PROCESSES}
+    if not available_processes_in_map:
+        msg = "⚠️ Ningún proceso cognitivo disponible (modelos no cargados). La IA no puede hacer nada."
+        execution_log.append(msg)
+        logger.warning(msg)
+        # Intentar ejecutar solo síntesis final con texto original si está disponible
+        final_synthesis_result = CognitiveProcesses.synthesize_report(initial_text, {}, {"query": objective}, objective)
+        cumulative_results["final_synthesis"] = final_synthesis_result[1]
+        execution_log.append(f"\n--- Intentando Síntesis Final Directa ---")
+        execution_log.append(final_synthesis_result[0])
+        execution_log.append("--- Fin de Ejecución ---")
+        return final_synthesis_result[1].get("final_report_text", "Síntesis no generada."), cumulative_results, "\n".join(execution_log)
+
+
+    # --- Bucle de Ciclos Cognitivos ---
+    for cycle in range(max_cycles):
+        progress_percentage = (cycle + 1) / (max_cycles + 1) # +1 para incluir la síntesis final
+        progress(progress_percentage, desc=f"💭 Ciclo Cognitivo {cycle+1}/{max_cycles}")
+        execution_log.append(f"\n--- Ciclo Cognitivo {cycle+1} ---")
+        logger.info(f"--- Ciclo Cognitivo {cycle+1} ---")
+
+        # 1. La IA decide el siguiente paso
+        # Crear un prompt para el modelo de cognición dinámica
+        # Incluir el objetivo, el texto original (parcial), los resultados acumulados (resumido) y el historial
+        results_summary_for_prompt = "Current Results Summary:\n"
+        if cumulative_results:
+            for key, result_data in cumulative_results.items():
+                 if result_data and isinstance(result_data, dict) and result_data.get("status") == "success":
+                    if "summary" in result_data: results_summary_for_prompt += f"- {key}: Summary - {result_data['summary'][:100]}...\n"
+                    elif "translation" in result_data: results_summary_for_prompt += f"- {key}: Translation ({result_data.get('language')})\n"
+                    elif "sentiment" in result_data: results_summary_for_prompt += f"- {key}: Sentiment ({result_data['sentiment'].get('label')})\n"
+                    elif "entities" in result_data: results_summary_for_prompt += f"- {key}: Extracted {len(result_data['entities'])} entities\n"
+                    elif "extracted_info" in result_data: results_summary_for_prompt += f"- {key}: Info ('{result_data.get('query')[:50]}...')\n"
+                    elif "final_report_text" in result_data: results_summary_for_prompt += f"- {key}: Final Report (already generated)\n"
+                    else: results_summary_for_prompt += f"- {key}: Processed data\n"
+        else:
+            results_summary_for_prompt += "No results yet."
+
+        history_summary_for_prompt = "Previous steps:\n" + "\n".join([f"- {h['action']} ({h['status']})" for h in history[-3:]]) # Últimos 3 pasos
+
+
+        decision_prompt = f"""
+        You are the SentientFlow Dynamic Cognition Engine. Your goal is to analyze the user's OBJECTIVE and the provided TEXT, performing a series of cognitive processes using the AVAILABLE PROCESSES to achieve the objective.
+
+        You operate in cycles. In each cycle, you must decide the NEXT BEST PROCESS to run or if you are READY TO FINISH. You should consider the TEXT, the accumulated RESULTS, and the HISTORY of steps already taken.
+
+        Respond ONLY with a JSON object like this:
+        {{
+          "decision": "process" or "finish",
+          "process_name": "name_of_available_process" or null,
+          "parameters": {{...}}, // Parameters for the process, or empty dict. E.g., {{"language": "spanish"}} or {{"query": "key people"}}
+          "reasoning": "Your internal thought process explaining this decision."
+        }}
+
+        AVAILABLE PROCESSES: {", ".join(available_processes_in_map.keys())}
+
+        OBJECTIVE: {objective}
+        TEXT (first 500 chars): {initial_text[:500]}...
+        ---
+        {results_summary_for_prompt[:500]}...
+        ---
+        {history_summary_for_prompt}
+        ---
+        Based on the OBJECTIVE, TEXT, RESULTS, and HISTORY, decide the NEXT BEST PROCESS or if you are READY TO FINISH.
+        """
+        max_planner_input_chars = 1500 # Limit input length for the planner model
+        if len(decision_prompt) > max_planner_input_chars:
+            decision_prompt = decision_prompt[:max_planner_input_chars] + "..."
+            logger.warning(f"Planner prompt largo ({len(decision_prompt)}), truncando.")
+
+        logger.info(f"Prompt para modelo de cognición dinámica:\n---\n{decision_prompt}\n---")
+
+
+        # Mover modelo de cognición a device para inferencia
+        cognition_model.to(cognition_device)
+        input_ids = cognition_tokenizer(decision_prompt, return_tensors="pt").input_ids.to(cognition_device)
+
+
+        try:
+            # Generar la decisión (JSON)
+            decision_outputs = cognition_model.generate(input_ids, max_new_tokens=200, num_beams=3, early_stopping=True, no_repeat_ngram_size=2)
+            decision_text = cognition_tokenizer.decode(decision_outputs[0], skip_special_tokens=True)
+
+            # Mover modelo de vuelta a CPU si es necesario
+            if cognition_device.type == 'cuda':
+                 cognition_model.to("cpu")
+                 torch.cuda.empty_cache()
+                 logger.info("Modelo de cognición movido a CPU.")
+
+            logger.info(f"Respuesta cruda del modelo de cognición:\n---\n{decision_text}\n---")
+
+            # Intentar parsear la respuesta como JSON
+            decision_match = re.search(r"```json\n(.*?)\n```", decision_text, re.DOTALL)
+            if decision_match:
+                decision_json_str = decision_match.group(1).strip()
+            else:
+                decision_json_str = decision_text.strip() # Intentar parsear output completo si no hay ```json```
+
+            decision_data = json.loads(decision_json_str)
+
+            # Validar la estructura de la decisión
+            if not isinstance(decision_data, dict) or "decision" not in decision_data or "reasoning" not in decision_data:
+                 raise ValueError("Estructura de decisión JSON inválida.")
+
+            execution_log.append(f"💭 Pensamiento Interno: {decision_data.get('reasoning', 'No proporcionado.')}")
+            logger.info(f"Decisión del ciclo {cycle+1}: {decision_data.get('decision')}, Proceso: {decision_data.get('process_name')}")
+
+            if decision_data.get("decision") == "finish":
+                execution_log.append("✅ La IA decide que ha terminado el análisis.")
+                logger.info("AI decided to finish.")
+                break # Salir del bucle de ciclos cognitivos
+
+            # 2. Ejecutar el proceso decidido
+            process_name = decision_data.get("process_name")
+            process_params = decision_data.get("parameters", {})
+
+            if process_name and process_name in available_processes_in_map:
+                process_func = available_processes_in_map[process_name]
+                execution_log.append(f"⚙️ Ejecutando Proceso '{process_name}' con params: {process_params}...")
+                logger.info(f"Executing process: {process_name}")
+
+                # Ejecutar la función del proceso cognitivo
+                human_readable_result, structured_output = process_func(current_text, cumulative_results, process_params, objective)
+
+                # Añadir resultado a la memoria de trabajo (cumulative_results)
+                result_key = f"{process_name}_{len(history)+1}" # Clave única para el resultado
+                cumulative_results[result_key] = structured_output
+
+                execution_log.append(f"Resultado: {human_readable_result}")
+                # Mostrar una parte del resultado estructurado si no es solo error/None
+                if structured_output and structured_output.get("status") == "success":
+                     structured_output_preview = json.dumps(structured_output, indent=2)
+                     execution_log.append(f"Resultado Estructurado (parcial): {structured_output_preview[:500]}...")
+                elif structured_output and structured_output.get("error"):
+                     execution_log.append(f"Resultado Estructurado (error): {json.dumps(structured_output)[:200]}...")
+
+                # Actualizar history
+                history.append({"action": process_name, "status": structured_output.get("status", "unknown"), "key": result_key})
+
+                # Opcional: Actualizar current_text si el proceso es transformador (ej: resumen, traducción)
+                # Esto permite a los siguientes pasos operar sobre el texto transformado
+                # Heurística simple: Si el resultado contiene 'summary' o 'translation', actualizamos current_text
+                if structured_output and structured_output.get("status") == "success":
+                     if "summary" in structured_output and structured_output["summary"]:
+                          current_text = structured_output["summary"]
+                          logger.info("current_text actualizado a resumen.")
+                     elif "translation" in structured_output and structured_output["translation"]:
+                          current_text = structured_output["translation"]
+                          logger.info("current_text actualizado a traducción.")
+                     # Podrías añadir más reglas aquí
+
+            else:
+                msg = f"⚠️ La IA decidió un proceso no válido o no disponible: '{process_name}'. Deteniendo ciclos dinámicos."
+                execution_log.append(msg)
+                logger.warning(msg)
+                # Añadir error a resultados acumulados
+                cumulative_results[f"decision_error_{len(history)+1}"] = {"error": msg, "decision_data": decision_data, "status": "error"}
+                history.append({"action": process_name, "status": "invalid_decision", "key": f"decision_error_{len(history)+1}"})
+                break # Detener si la IA decide algo inválido
+
+        except json.JSONDecodeError as e:
+            msg = f"❌ Error al parsear JSON de decisión de la IA: {e}. Output crudo: {decision_text[:300]}..."
+            execution_log.append(msg)
+            logger.error(msg)
+            cumulative_results[f"json_error_{len(history)+1}"] = {"error": msg, "raw_output": decision_text, "status": "error"}
+            history.append({"action": "parse_error", "status": "error", "key": f"json_error_{len(history)+1}"})
+            break # Detener si falla el parsing de la decisión
+
+        except Exception as e:
+            msg = f"❌ Error inesperado durante el ciclo cognitivo: {e}"
+            execution_log.append(msg)
+            logger.error(msg)
+            cumulative_results[f"cycle_error_{len(history)+1}"] = {"error": msg, "status": "error"}
+            history.append({"action": "cycle_error", "status": "error", "key": f"cycle_error_{len(history)+1}"})
+            break # Detener en caso de excepción inesperada
+
+        # Pausa visual y para evitar saturar recursos rápidamente
+        time.sleep(0.5)
+
+
+    # --- Paso Final: Síntesis del Reporte ---
+    progress_percentage = (max_cycles + 1) / (max_cycles + 1) # 100%
+    progress(progress_percentage, desc="✨ Sintetizando Reporte Final...")
+    execution_log.append("\n--- Sintetizando Reporte Final ---")
+    logger.info("Running final synthesis.")
+
+    # El paso de síntesis toma el initial_text y todos los cumulative_results
+    final_synthesis_human_readable, final_synthesis_structured_output = CognitiveProcesses.synthesize_report(
+        initial_text, # Usar texto original para la síntesis final
+        cumulative_results,
+        {"query": objective}, # Pasar el objetivo como query/contexto para la síntesis
+        objective # Pasar el objetivo
+    )
+    cumulative_results["final_synthesis"] = final_synthesis_structured_output
+    execution_log.append(final_synthesis_human_readable)
+
+
+    execution_log.append("\n--- SentientFlow Completado ---")
+    logger.info("SentientFlow process completed.")
+
+    # Devolver el reporte final (texto), todos los resultados estructurados y el log completo
+    final_report_text = final_synthesis_structured_output.get("final_report_text", "Reporte final no generado.")
+    all_structured_results_str = json.dumps(cumulative_results, indent=2)
+
+
+    return final_report_text, all_structured_results_str, "\n".join(execution_log)
+
+
+# --- Cargar modelos y definir procesos disponibles al inicio de la app ---
+try:
+    load_ai_models()
+    # Mapear nombres de procesos a funciones SOLO SI EL MODELO NECESARIO FUE CARGADO
+    for name, func in PROCESS_FUNCTION_MAP.items():
+        # Esto requiere saber qué modelo/pipeline necesita cada función.
+        # HARDCODED MAPPING - THIS IS BRITTLE! Needs a better system in a real app.
+        required_model_alias = None
+        if func == CognitiveProcesses.summarize: required_model_alias = "summarization_pipeline"
+        elif func == CognitiveProcesses.translate: required_model_alias = "translation_en_es_pipeline" # Asumimos en_es como base
+        elif func == CognitiveProcesses.analyze_sentiment: required_model_alias = "sentiment_analysis_pipeline"
+        elif func == CognitiveProcesses.extract_entities: required_model_alias = "ner_extraction_pipeline"
+        elif func == CognitiveProcesses.extract_information or func == CognitiveProcesses.synthesize_report: required_model_alias = "text2text_pipeline"
+        # Añadir mapeos para nuevos procesos
+
+        if required_model_alias and loaded_pipelines.get(required_model_alias) is not None:
+             available_cognitive_processes[name] = func
+             logger.info(f"Proceso '{name}' DISPONIBLE.")
+        elif required_model_alias:
+             logger.warning(f"Proceso '{name}' NO DISPONIBLE: Modelo '{required_model_alias}' no cargado.")
+        else:
+             logger.warning(f"Proceso '{name}' NO MAPEADO a un modelo requerido. No disponible.")
+
+
+    # Actualizar la lista de procesos disponibles para el prompt del planner
+    AVAILABLE_PROCESSES = ", ".join([f"`{name}`" for name in available_cognitive_processes.keys()])
+    if "synthesize_report" in available_cognitive_processes:
+         # La síntesis final es un paso especial, la IA planificadora NO debe elegirla en ciclos intermedios.
+         # La removemos de la lista de procesos *elegibles* pero la mantenemos en el MAP.
+         # Esto es otra HEURÍSTICA. Un planner más inteligente sabría cuándo usarla.
+         eligible_processes_for_cycles = list(available_cognitive_processes.keys())
+         if "synthesize_report" in eligible_processes_for_cycles:
+             eligible_processes_for_cycles.remove("synthesize_report")
+         AVAILABLE_PROCESSES_FOR_PLANNER = ", ".join([f"`{name}`" for name in eligible_processes_for_cycles])
+    else:
+         AVAILABLE_PROCESSES_FOR_PLANNER = AVAILABLE_PROCESSES # Si no hay sintetizador, dejar todos los demás
+
+
+except Exception as e:
+    logger.error(f"Fallo crítico en setup de procesos/modelos: {e}")
+    # Si esto falla, la app no funcionará
+    available_cognitive_processes = {} # Asegurar que está vacío
+    AVAILABLE_PROCESSES_FOR_PLANNER = ""
+
+
+# --- Interfaz de Gradio ---
+
+# Mensaje sobre modelos disponibles para la UI
+available_tasks_list_str = ", ".join([f"**`{name}`**" for name in available_cognitive_processes.keys()])
+if "synthesize_report" in available_cognitive_processes:
+    available_tasks_list_str += ", **`synthesize_report`** (paso final automático)" # Añadir síntesis como paso final
+
+title = "✨ SentientFlow: The Dynamic Cognition Engine ✨"
+description = f"""
+**Automatización Cognitiva de Próximo Nivel: Describe un Objetivo, No Pasos.**
+
+SentientFlow no sigue un plan fijo. Le das un **objetivo general** sobre tu texto, y la IA usa su **cognición dinámica** para decidir paso a paso (en ciclos) qué análisis o transformación realizar, basándose en lo que ya ha descubierto.
+
+**Objetivo:** Describe **qué quieres lograr** (ej: "Entender las opiniones clave", "Extraer datos importantes y resumirlos").
+
+**Procesos Cognitivos Disponibles (Modelos Cargados):**
+{available_tasks_list_str if available_cognitive_processes else "**❌ Ningún proceso cognitivo disponible.** Revisa los logs de carga del Space. Los modelos de IA no pudieron cargarse."}
+
+*(La disponibilidad de los procesos depende de si los modelos de IA pudieron cargarse correctamente en este Hugging Face Space gratuito. Si un proceso no aparece aquí, su modelo no está disponible.)*
+
+**Ejemplos de Objetivos:**
+- `Analizar este artículo y extraer la información más importante, luego resumirlo`
+- `Entender el sentimiento general de estas opiniones y quiénes son los principales actores mencionados`
+- `Traducir este párrafo al español y luego generar preguntas sobre su contenido`
+- `Dame una síntesis completa de este documento, incluyendo sus puntos clave y el sentimiento`
+
+*SentientFlow realizará varios ciclos de análisis y síntesis para intentar cumplir tu objetivo. El proceso se detendrá después de un número fijo de ciclos o si la IA decide que ha terminado. Funciona 100% dentro del Space, sin acceso externo.*
+"""
+# Mensaje de advertencia si no hay modelos de IA cargados
+if not available_cognitive_processes:
+     description += "\n\n**🚨 ADVERTENCIA: Ningún modelo de IA se cargó correctamente. SentientFlow no podrá realizar ninguna tarea cognitiva.** Revisa la pestaña 'Logs' de tu Space para ver los errores de carga (posiblemente por falta de memoria)."
+     # Deshabilitar el botón si no hay modelos
+     interface_enabled = False
+else:
+     interface_enabled = True
+
+
+gr.Interface(
+    fn=run_dynamic_cognition,
+    inputs=[
+        gr.Textbox(label="Describe tu Objetivo Cognitivo:", placeholder="Ej: 'Analizar opiniones clave y sentimiento'", lines=3),
+        gr.Textbox(label="Texto de entrada:", placeholder="Pega el texto aquí...", lines=10)
+    ],
+    outputs=[
+        gr.Textbox(label="✨ Reporte Final Sintetizado por la IA:", interactive=False, lines=7),
+        gr.Textbox(label="🧠 Resultados Estructurados Acumulados:", interactive=False, lines=10, visible=True, render=True, show_copy_button=True), # Mostrar JSON, permitir copiar
+        gr.Textbox(label="📈 Log Detallado (Ciclos Cognitivos y Pensamientos IA):", interactive=False, lines=15)
+    ],
+    title=title,
+    description=description,
+    allow_flagging="never", # Disable flagging on Hugging Face Spaces
+    examples=[
+        ["Analizar este artículo y extraer la información más importante, luego resumirlo", "Artificial intelligence (AI) is a rapidly evolving field with applications in various industries, including healthcare, finance, and transportation. Leading research institutions like Stanford and MIT are at the forefront of AI development. Experts like Andrew Ng predict significant advancements in the coming decade. However, concerns about ethical implications and job displacement are also growing."],
+        ["Entender el sentimiento general de estas opiniones y quiénes son los principales actores mencionados", "Customer A: The new phone is great! Fast and good camera. Customer B: Software update broke everything, very frustrated. Customer C: The company's support team was useless."],
+        ["Traducir este párrafo al español y luego generar preguntas sobre su contenido", "Climate change is a global emergency that goes beyond national borders. It is an issue that requires coordinated solutions at all levels and international cooperation to help countries transition to a low-carbon economy."]
+    ],
+    # Deshabilitar el botón si no hay modelos cargados
+    submit_button="🚀 Iniciar Flujo Cognitivo" if interface_enabled else "Modelos IA No Disponibles",
+    # state=[available_cognitive_processes] # Podríamos pasar el estado de modelos disponibles si fuera necesario en fn
+).queue().launch()
+
+logger.info("Interfaz Gradio lanzada.")