@innvisor/conny-ai 9.7.0

package/conny_config.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+"""
+conny_config.py — All constants, templates and string literals from conny.py
+Extracted for Phase 3 split.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Dict, List, Set, Tuple
+
+_CONNY_HOME = os.getenv("CONNY_HOME", str(Path.home() / ".conny"))
+
+
+class Config:
+    """Configuración centralizada con validación."""
+
+    TELEGRAM_TOKEN     = os.getenv("TELEGRAM_TOKEN", "")
+    GROQ_API_KEY       = os.getenv("GROQ_API_KEY", "")
+    GEMINI_API_KEY     = os.getenv("GEMINI_API_KEY",   "")
+    GEMINI_API_KEY_2   = os.getenv("GEMINI_API_KEY_2", "")
+    GEMINI_API_KEY_3   = os.getenv("GEMINI_API_KEY_3", "")
+    GEMINI_API_KEY_4   = os.getenv("GEMINI_API_KEY_4", "")
+    GEMINI_API_KEY_5   = os.getenv("GEMINI_API_KEY_5", "")
+    GEMINI_API_KEY_6   = os.getenv("GEMINI_API_KEY_6", "")
+    OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
+    OPENAI_API_KEY     = os.getenv("OPENAI_API_KEY", "")
+    ANTHROPIC_API_KEY  = os.getenv("ANTHROPIC_API_KEY",  "")
+    BRAVE_API_KEY      = os.getenv("BRAVE_API_KEY",      "")
+    APIFY_API_KEY      = os.getenv("APIFY_API_KEY",      "")
+    SERP_API_KEY       = os.getenv("SERP_API_KEY",        "")
+    CALENDLY_LINK      = os.getenv("CALENDLY_LINK",       "")
+    GCAL_ACCESS_TOKEN  = os.getenv("GCAL_ACCESS_TOKEN",    "")
+    GCAL_REFRESH_TOKEN = os.getenv("GCAL_REFRESH_TOKEN",   "")
+    GCAL_CLIENT_ID     = os.getenv("GCAL_CLIENT_ID",      "")
+    GCAL_CLIENT_SECRET = os.getenv("GCAL_CLIENT_SECRET",  "")
+    GCAL_CALENDAR_ID   = os.getenv("GCAL_CALENDAR_ID",    "primary")
+    META_APP_ID        = os.getenv("META_APP_ID",          "")
+    META_APP_SECRET    = os.getenv("META_APP_SECRET",     "")
+    NOVA_URL           = os.getenv("NOVA_URL", "http://localhost:9003")
+    NOVA_TOKEN         = os.getenv("NOVA_TOKEN",   "")
+    NOVA_API_KEY       = os.getenv("NOVA_API_KEY", "")
+    NOVA_ENABLED       = os.getenv("NOVA_ENABLED", "false").lower() == "true"
+    WEBHOOK_SECRET     = os.getenv("WEBHOOK_SECRET", "conny_ultra_5")
+    BASE_URL           = os.getenv("BASE_URL",           "")
+    TELEGRAM_SHARED     = os.getenv("TELEGRAM_SHARED", "false").lower() == "true"
+    TELEGRAM_SHARED_ROUTER = os.getenv("TELEGRAM_SHARED_ROUTER", "false").lower() == "true"
+    TELEGRAM_SHARED_SECRET = os.getenv("TELEGRAM_SHARED_SECRET", "conny_shared_telegram")
+    TELEGRAM_DEFAULT_INSTANCE = os.getenv("TELEGRAM_DEFAULT_INSTANCE", "").strip()
+    TELEGRAM_SHARED_ROUTES_PATH = os.getenv(
+        "TELEGRAM_SHARED_ROUTES_PATH",
+        str(Path(_CONNY_HOME) / "shared_telegram_routes.json"),
+    )
+    TELEGRAM_SHARED_INSTANCES_DIR = os.getenv(
+        "TELEGRAM_SHARED_INSTANCES_DIR",
+        str(Path(_CONNY_HOME) / "instances"),
+    )
+    PLATFORM           = os.getenv("PLATFORM", "telegram")
+    WHATSAPP_BRIDGE_URL = os.getenv("WHATSAPP_BRIDGE_URL", "http://localhost:3000")
+    SECTOR             = os.getenv("SECTOR", "otro")
+    WA_PHONE_ID        = os.getenv("WA_PHONE_ID", "")
+    WA_ACCESS_TOKEN    = os.getenv("WA_ACCESS_TOKEN", "")
+    WA_VERIFY_TOKEN    = os.getenv("WA_VERIFY_TOKEN", "")
+    EVOLUTION_URL      = os.getenv("EVOLUTION_URL",       "")
+    EVOLUTION_API_KEY  = os.getenv("EVOLUTION_API_KEY",   "")
+    EVOLUTION_INSTANCE = os.getenv("EVOLUTION_INSTANCE",  "conny")
+    MASTER_API_KEY     = os.getenv("MASTER_API_KEY",     "")
+    N8N_WEBHOOK_URL   = os.getenv("N8N_WEBHOOK_URL",     "")
+    TOKEN_EXPIRY_HOURS = int(os.getenv("TOKEN_EXPIRY_HOURS", "72"))
+    DEMO_MODE          = os.getenv("DEMO_MODE", "false").lower() == "true"
+    DEMO_BUSINESS_NAME = os.getenv("DEMO_BUSINESS_NAME", "tu negocio")
+    DEMO_SECTOR        = os.getenv("DEMO_SECTOR", "estetica")
+    DEMO_SESSION_TTL   = int(os.getenv("DEMO_SESSION_TTL", "1800"))
+    GREETING_ONLY_IDLE_SECONDS = int(os.getenv("GREETING_ONLY_IDLE_SECONDS", "300"))
+    V8_ACTIVE_MODEL_REASONING = os.getenv("V8_ACTIVE_MODEL_REASONING", "")
+    V8_ACTIVE_MODEL_FAST      = os.getenv("V8_ACTIVE_MODEL_FAST",      "")
+    V8_ACTIVE_MODEL_LITE      = os.getenv("V8_ACTIVE_MODEL_LITE",      "")
+    V8_QUALITY_THRESHOLD  = float(os.getenv("V8_QUALITY_THRESHOLD", "0.72"))
+    V8_MAX_RETRIES        = int(os.getenv("V8_MAX_RETRIES", "3"))
+    CONNY_COMPACT_PROMPT = os.getenv("CONNY_COMPACT_PROMPT", "true").lower() in ("1", "true", "yes", "on")
+    CONNY_CONTEXT_RECENT_MESSAGES = int(os.getenv("CONNY_CONTEXT_RECENT_MESSAGES", "12"))
+    CONNY_CORE_ENABLED = os.getenv("CONNY_CORE_ENABLED", "true").lower() in ("1", "true", "yes", "on")
+    CONNY_CORE_PERSONAS_DIR = os.getenv(
+        "CONNY_CORE_PERSONAS_DIR",
+        str(Path(__file__).resolve().parent / "personas" / "conny" / "base"),
+    )
+    V8_FILTER_LEVEL       = int(os.getenv("V8_FILTER_LEVEL", "2"))
+    DB_PATH            = os.getenv("DB_PATH", "/home/ubuntu/conny/conny_ultra.db")
+    VECTOR_DB_PATH     = os.getenv("VECTOR_DB_PATH", "/home/ubuntu/conny/vectors.db")
+    LLM_MODELS = {
+        "reasoning": os.getenv("LLM_REASONING", "google/gemini-2.5-pro"),
+        "fast": os.getenv("LLM_FAST", "google/gemini-2.5-flash"),
+        "lite": os.getenv("LLM_LITE", "google/gemini-2.5-flash-lite"),
+        "embedding": os.getenv("LLM_EMBEDDING", "openai/text-embedding-3-small"),
+    }
+    WHISPER_MODEL = os.getenv("WHISPER_MODEL", "openai/whisper-large-v3")
+    BUFFER_WAIT_MIN    = int(os.getenv("BUFFER_WAIT_MIN", "25"))
+    BUFFER_WAIT_MAX    = int(os.getenv("BUFFER_WAIT_MAX", "45"))
+    BUBBLE_PAUSE_MIN   = float(os.getenv("BUBBLE_PAUSE_MIN", "1.2"))
+    BUBBLE_PAUSE_MAX   = float(os.getenv("BUBBLE_PAUSE_MAX", "3.0"))
+    BRAND_ASSETS_BASE_DIR = os.getenv(
+        "BRAND_ASSETS_BASE_DIR",
+        "/home/ubuntu/conny/brand-assets",
+    )
+    SELF_IMPROVE_INTERVAL = int(os.getenv("SELF_IMPROVE_INTERVAL", "3600"))
+    LEARNING_RATE         = float(os.getenv("LEARNING_RATE", "0.1"))
+    MAX_CONTEXT_MESSAGES = int(os.getenv("MAX_CONTEXT", "50"))
+    MAX_MEMORY_ITEMS     = int(os.getenv("MAX_MEMORY", "1000"))
+
+    @classmethod
+    def validate(cls) -> List[str]:
+        errors = []
+        if not cls.TELEGRAM_TOKEN:
+            errors.append("TELEGRAM_TOKEN requerido")
+        if not cls.OPENROUTER_API_KEY and not cls.GEMINI_API_KEY:
+            errors.append("Se requiere al menos OPENROUTER_API_KEY o GEMINI_API_KEY")
+        return errors
+
+
+DEMO_COMMANDS: Dict[str, str] = {
+    "/formal":"/formal", "/amigable":"/amigable", "/luxury":"/luxury",
+    "/directa":"/directa", "/energica":"/energica", "/empatica":"/empatica",
+    "/experta":"/experta", "/juvenil":"/juvenil",
+    "/objecion":"/objecion", "/cita":"/cita", "/stats":"/stats",
+    "/prueba":"/prueba", "/cierre":"/cierre", "/bot":"/bot",
+    "/memoria":"/memoria", "/2am":"/2am", "/competencia":"/competencia",
+    "/precio":"/precio", "/siguiente":"/siguiente",
+}
+
+DEMO_TRICKS_ORDER: List[Tuple[str, str]] = [
+    ("/objecion",   "ver cómo manejo objeciones en vivo"),
+    ("/cita",       "ver cómo agendo una cita completa"),
+    ("/luxury",     "activar personalidad premium"),
+    ("/empatica",   "cambiar a modo empático y de escucha"),
+    ("/stats",      "ver el impacto en números reales"),
+    ("/prueba",     "lanzarme el mensaje más difícil que tengas"),
+    ("/cierre",     "ver cómo cierro una venta"),
+    ("/directa",    "activar modo al grano sin rodeos"),
+    ("/menu",       "ver modo bot con emojis y menú numerado"),
+    ("/2am",        "verme responder a las 2 de la madrugada"),
+    ("/memoria",    "ver qué recuerdo de esta conversación"),
+    ("/experta",    "cambiar a modo técnico y preciso"),
+    ("/modelo",     "cambiar el modelo de IA que me impulsa"),
+]
+
+DEMO_CMD_ALIASES: Dict[str, str] = {
+    "formal":"formal","amigable":"amigable","luxury":"luxury","lujo":"luxury",
+    "directa":"directa","energica":"energica","enérgica":"energica",
+    "empatica":"empatica","empática":"empatica","experta":"experta",
+    "juvenil":"juvenil","joven":"juvenil","profesional":"formal","objecion":"objecion","objeción":"objecion",
+    "cita":"cita","agendar":"cita","stats":"stats","estadisticas":"stats",
+    "prueba":"prueba","reto":"prueba","cierre":"cierre","bot":"bot",
+    "memoria":"memoria","recuerdas":"memoria","2am":"2am","de noche":"2am",
+    "competencia":"competencia","precio":"precio","caro":"precio",
+    "siguiente":"siguiente","que mas":"siguiente","qué más":"siguiente",
+    "menu":"menu_bot","menú":"menu_bot","modo bot":"menu_bot","bot menu":"menu_bot",
+    "list":"list","lista":"list","comandos":"list","ayuda":"list","help":"list",
+    "qué puedes hacer":"list","que puedes hacer":"list",
+    "emojis":"emojis_on","con emojis":"emojis_on","activa emojis":"emojis_on",
+    "sin emojis":"emojis_off","quita emojis":"emojis_off","desactiva emojis":"emojis_off",
+    "modelo":"modelo","model":"modelo","cambiar modelo":"modelo",
+}
+
+MODEL_CATALOG: Dict[str, Tuple[str, str, str]] = {
+    "claude-opus":   ("anthropic/claude-opus-4",          "reasoning", "Más inteligente. Más caro."),
+    "claude-sonnet": ("anthropic/claude-sonnet-4",        "reasoning", "Balance inteligencia/costo."),
+    "claude-haiku":  ("anthropic/claude-haiku-3-5",       "fast",      "Rapidísimo y económico."),
+    "gemini-pro":    ("google/gemini-2.5-pro",            "reasoning", "Google Pro."),
+    "gemini-flash":  ("google/gemini-2.5-flash",          "fast",      "Velocidad + calidad."),
+    "gemini-lite":   ("google/gemini-2.5-flash-lite",     "lite",      "El más económico."),
+    "llama-70b":     ("meta-llama/llama-3.3-70b-instruct","fast",      "Open source, excelente español."),
+    "llama-8b":      ("meta-llama/llama-3.1-8b-instruct", "lite",      "Ultrarrápido, básico."),
+    "gpt4o":         ("openai/gpt-4o",                    "reasoning", "OpenAI flagship."),
+    "gpt4o-mini":   ("openai/gpt-4o-mini",               "fast",      "OpenAI económico."),
+    "mistral-large": ("mistralai/mistral-large",          "reasoning", "Europeo, buen español."),
+    "mistral-small": ("mistralai/mistral-small",          "fast",      "Rápido y asequible."),
+}
+
+INTERNAL_PHRASES_TO_BLOCK: List[str] = [
+    "todavía no tengo este chat enlazado",
+    "ya recibí tu mensaje",
+    "no tengo este chat",
+    "[error",
+    "[internal",
+    "{",
+]
+
+AUDIO_ERROR_MSG = "Recibí tu audio pero no lo pude procesar. ¿Puedes escribirlo?"
+JSON_ERROR_MSG = "Entendido, déjame verificar eso."
+UNKNOWN_CMD_MSG = "Comando no reconocido. Escribe /help para ver los disponibles."
+
+DEMO_HELP_FULL = (
+    "esto es lo que puedo mostrarte 👇\n\n"
+    "🎭 Personalidades: /formal · /amigable · /luxury · /directa · /empatica · /experta · /juvenil\n\n"
+    "💬 Situaciones reales:\n"
+    "objecion — cliente difícil\n"
+    "cita — agendamiento completo\n"
+    "cierre — técnica de cierre\n"
+    "competencia — ya fui a otro lado\n"
+    "precio — está muy caro\n"
+    "prueba — mándame el más difícil\n"
+    "bot — soy un bot?\n"
+    "2am — respuesta a las 2am\n\n"
+    "📊 Demo y datos:\n"
+    "stats — impacto en números\n"
+    "memoria — qué recuerdo de ti\n"
+    "menu — modo bot con emojis\n\n"
+    "⚙️ Ajustes:\n"
+    "usa emojis / sin emojis\n"
+    "siguiente — próximo truco\n"
+    "/modelo — cambiar el modelo\n"
+    "reset — empezar de nuevo\n\n"
+    "escribe sin slash para activar"
+)

package/conny_core/__init__.py

@@ -0,0 +1,3 @@
+from .conversation_engine import ConversationEngine, ConversationTurnResult
+from .persona_registry import PersonaProfile, PersonaRegistry
+

package/conny_core/conversation_engine.py

@@ -0,0 +1,446 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from .persona_registry import PersonaProfile, PersonaRegistry
+
+
+@dataclass
+class ConversationTurnResult:
+    handled: bool
+    bubbles: List[str]
+    reason: str = ""
+    persona_key: str = "default"
+
+
+class ConversationEngine:
+    def __init__(self, registry: PersonaRegistry):
+        self.registry = registry
+
+    def handle(
+        self,
+        *,
+        clinic: Dict[str, Any],
+        user_msg: str,
+        history: Optional[List[Dict[str, Any]]] = None,
+        is_admin: bool = False,
+        channel: str = "",
+    ) -> ConversationTurnResult:
+        history = history or []
+        persona = self.registry.resolve_for_clinic(clinic)
+        first_turn = not any(msg.get("role") == "assistant" for msg in history)
+        normalized = self._normalize(user_msg)
+
+        if is_admin:
+            return ConversationTurnResult(False, [], reason="admin_route", persona_key=persona.key)
+
+        if self._is_identity_probe(normalized):
+            return ConversationTurnResult(
+                True,
+                self._build_identity_probe(persona, clinic, normalized, history, first_turn=first_turn),
+                reason="identity_probe",
+                persona_key=persona.key,
+            )
+
+        if self._is_meta_followup_probe(normalized):
+            return ConversationTurnResult(
+                True,
+                self._build_meta_followup(persona, clinic, normalized),
+                reason="meta_followup",
+                persona_key=persona.key,
+            )
+
+        if self._is_greeting_only(normalized):
+            return ConversationTurnResult(False, [], reason="llm_greeting", persona_key=persona.key)
+
+        if first_turn and self._looks_like_contextual_first_turn(persona, clinic, normalized):
+            return ConversationTurnResult(
+                True,
+                self._build_first_contextual_followup(persona, clinic, normalized),
+                reason="first_turn_contextual",
+                persona_key=persona.key,
+            )
+
+        return ConversationTurnResult(False, [], reason="not_handled", persona_key=persona.key)
+
+    def _normalize(self, text: str) -> str:
+        return (text or "").strip().lower()
+
+    def _is_greeting_only(self, normalized: str) -> bool:
+        cleaned = normalized.replace("0", "o")
+        cleaned = cleaned.replace("!", "").replace("?", "").replace("¡", "").replace("¿", "").strip()
+        cleaned = cleaned.replace(",", " ").replace(".", " ")
+        cleaned = " ".join(cleaned.split())
+        return cleaned in {
+            "hola",
+            "hola que tal",
+            "hola como vas",
+            "hola como estas",
+            "hola que mas",
+            "hola buenas",
+            "buenas",
+            "buenas tardes",
+            "buenos dias",
+            "buenos días",
+            "buenas noches",
+            "hey",
+            "holi",
+            "como vas",
+            "como estas",
+            "todo bien",
+            "que mas",
+            "qué más",
+            "que tal",
+        }
+
+    def _is_identity_probe(self, normalized: str) -> bool:
+        probes = (
+            "que eres",
+            "qué eres",
+            "quien eres",
+            "quién eres",
+            "eres una ia",
+            "eres ia",
+            "eres un bot",
+            "eres bot",
+            "como funcionas",
+            "cómo funcionas",
+            "que haces",
+            "qué haces",
+            "quiero probarte",
+            "me gustaria probarte",
+            "me gustaría probarte",
+            "tengo un negocio",
+            "tengo una empresa",
+            "quiero una demo",
+            "quiero demo",
+            "soy curioso",
+            "quiero saber quien eres",
+            "quiero saber quién eres",
+        )
+        return any(marker in normalized for marker in probes)
+
+    def _is_meta_followup_probe(self, normalized: str) -> bool:
+        probes = (
+            "como trabajas aqui",
+            "cómo trabajas aquí",
+            "como trabajas por aqui",
+            "cómo trabajas por aquí",
+            "lo llevas tu sola",
+            "lo llevas tú sola",
+            "atiendes como secretaria",
+            "atiendes como asesora",
+            "si te pregunto por un procedimiento",
+            "si te pregunto por precio",
+            "quiero entender si recuerdas",
+            "recuerdas lo que te digo",
+            "como recuerdas",
+            "cómo recuerdas",
+        )
+        return any(marker in normalized for marker in probes)
+
+    def _looks_like_first_contact_request(self, normalized: str) -> bool:
+        signals = (
+            "hola",
+            "buenas",
+            "quiero probarte",
+            "me gustaria probarte",
+            "me gustaría probarte",
+            "tengo un negocio",
+            "tengo una empresa",
+        )
+        return any(sig in normalized for sig in signals)
+
+    def _looks_like_contextual_first_turn(
+        self,
+        persona: PersonaProfile,
+        clinic: Dict[str, Any],
+        normalized: str,
+    ) -> bool:
+        if self._looks_like_first_contact_request(normalized):
+            return True
+        if self._extract_topic(persona, clinic, normalized):
+            return True
+        return any(token in normalized for token in ("precio", "cuanto", "cuánto", "horario", "agenda", "cita", "disponibilidad"))
+
+    def _build_first_turn(self, persona: PersonaProfile, clinic: Dict[str, Any]) -> List[str]:
+        clinic_name = str(clinic.get("name") or "").strip()
+        intro_template = self._choose(
+            persona.first_turn_variants
+            or [f"Hola, soy {persona.identity}, la asesora virtual{f' de {clinic_name}' if clinic_name else ''}"],
+            clinic_name or persona.identity,
+        )
+        intro = self._render_persona_line(intro_template, persona, clinic_name)
+
+        if persona.capabilities:
+            if clinic.get("sector") == "estetica":
+                capabilities = (
+                    f"Te ayudo con {', '.join(persona.capabilities[:3])}. "
+                    "Si quieres, cuéntame qué te interesa o qué tratamiento estás mirando."
+                )
+            else:
+                capabilities = (
+                    f"Te ayudo con {', '.join(persona.capabilities[:3])}. "
+                    "Cuéntame qué te gustaría revisar."
+                )
+        else:
+            capabilities = "Te ayudo con información, valoración y disponibilidad"
+
+        return [intro, capabilities]
+
+    def _build_returning_greeting(
+        self,
+        persona: PersonaProfile,
+        clinic: Dict[str, Any],
+        history: Optional[List[Dict[str, Any]]],
+        normalized: str,
+    ) -> List[str]:
+        history = history or []
+        gap_hours = self._hours_since_last_turn(history)
+        recent_topic = self._extract_recent_topic_from_history(persona, clinic, history)
+
+        if any(marker in normalized for marker in ("como estas", "cómo estás", "como vas", "cómo vas", "que tal", "qué tal")):
+            if gap_hours is not None and gap_hours >= 24:
+                intro = "Hola. Todo bien por acá."
+            else:
+                intro = "Hola. Todo bien por acá, gracias por preguntar."
+        else:
+            intro = "Hola."
+
+        if recent_topic:
+            followup = f"Si sigues con lo de {recent_topic}, dime y lo vemos."
+        else:
+            followup = "Cuéntame qué quieres revisar y lo vemos."
+
+        return [intro, followup]
+
+    def _build_identity_probe(
+        self,
+        persona: PersonaProfile,
+        clinic: Dict[str, Any],
+        normalized: str,
+        history: Optional[List[Dict[str, Any]]] = None,
+        first_turn: bool = True,
+    ) -> List[str]:
+        clinic_name = str(clinic.get("name") or "").strip()
+        history = history or []
+        if not first_turn and any(marker in normalized for marker in (
+            "eres una ia",
+            "eres ia",
+            "eres una persona",
+            "persona real",
+            "eres un bot",
+            "eres bot",
+        )):
+            return [
+                f"Soy Conny, la asesora virtual{f' de {clinic_name}' if clinic_name else ''}",
+                "Soy una IA hecha para orientar, responder y ayudarte a avanzar sin sonar acartonada",
+            ]
+        prior_identity = any(
+            any(marker in self._normalize(str(msg.get("content") or "")) for marker in (
+                "recepcionista virtual",
+                "asesora virtual",
+                "soy conny",
+                "trabaja por tu negocio",
+                "disponible por aqui",
+                "disponible por aquí",
+            ))
+            for msg in history
+            if msg.get("role") == "assistant"
+        )
+        if prior_identity:
+            return [
+                f"Sigo siendo Conny, la asesora virtual{f' de {clinic_name}' if clinic_name else ''}",
+                "Sigo siendo una IA hecha para orientarte bien, sostener la conversación y ayudarte sin respuestas de plantilla",
+            ]
+
+        intro = self._choose(
+            persona.identity_probe_variants or [
+                f"Soy {persona.identity}, la asesora virtual{f' de {clinic_name}' if clinic_name else ''}. También soy la IA que sostiene este chat para orientarte bien",
+                f"Soy {persona.identity}, la asesora virtual{f' de {clinic_name}' if clinic_name else ''}. Soy una IA hecha para resolver dudas y ayudarte a avanzar sin enredos",
+                f"Soy {persona.identity}, la asesora virtual{f' de {clinic_name}' if clinic_name else ''}. Soy una IA pensada para que este chat se sienta claro, útil y bien llevado",
+            ],
+            normalized,
+        )
+        intro = self._render_persona_line(intro, persona, clinic_name)
+        if persona.capabilities:
+            capabilities = (
+                "Te puedo ayudar con "
+                + ", ".join(persona.capabilities[:3])
+            )
+        else:
+            capabilities = "Te puedo ayudar con información, horarios, disponibilidad, valoración y orientación inicial"
+
+        if clinic_name:
+            cta = "Si quieres, cuéntame qué te gustaría revisar y lo vemos desde ahí"
+        else:
+            cta = "Cuéntame qué te gustaría revisar y te ubico"
+        return [intro, capabilities, cta]
+
+    def _render_persona_line(self, template: str, persona: PersonaProfile, clinic_name: str) -> str:
+        raw = str(template or "").strip()
+        if not raw:
+            return f"Soy {persona.identity}, la asesora virtual{f' de {clinic_name}' if clinic_name else ''}"
+        clinic_label = clinic_name.strip() if clinic_name else ""
+        if "{clinic_name}" in raw and not clinic_label:
+            clinic_label = "la clínica"
+        try:
+            rendered = raw.format(clinic_name=clinic_label, identity=persona.identity).strip()
+        except Exception:
+            rendered = raw
+        rendered = rendered.replace("de .", "de la clínica")
+        rendered = " ".join(rendered.split())
+        return rendered
+
+    def _build_meta_followup(
+        self,
+        persona: PersonaProfile,
+        clinic: Dict[str, Any],
+        normalized: str,
+    ) -> List[str]:
+        if any(marker in normalized for marker in (
+            "lo llevas tu sola",
+            "lo llevas tú sola",
+        )):
+            return [
+                "Yo sostengo este canal y el hilo de la conversación, pero no me pongo a improvisar donde toca confirmación real.",
+                "Si algo depende de una valoración o de validar un dato del negocio, te lo digo directo y lo aterrizo sin humo.",
+            ]
+
+        if any(marker in normalized for marker in (
+            "como trabajas aqui",
+            "cómo trabajas aquí",
+            "como trabajas por aqui",
+            "cómo trabajas por aquí",
+        )):
+            return [
+                "Trabajo llevando la conversación, entendiendo qué necesitas y guiándote hacia lo útil, no soltando respuestas al azar.",
+                "Y si algo toca confirmarlo con el negocio, te lo digo claro en vez de inventártelo.",
+            ]
+
+        if any(marker in normalized for marker in ("atiendes como secretaria", "atiendes como asesora")):
+            return [
+                "Un poco de las dos, pero bien hecho: recibo, oriento y también ayudo a mover la conversación hacia una decisión o una cita.",
+                "La idea es que se sienta como alguien del equipo, no como un formulario con patas.",
+            ]
+
+        if any(marker in normalized for marker in ("si te pregunto por un procedimiento", "si te pregunto por precio")):
+            return [
+                "Te respondo lo que sí pueda orientarte con claridad y te aterrizo el siguiente paso útil.",
+                "Si algo depende de valoración o de confirmación del negocio, te lo digo así, sin humo ni datos inventados.",
+            ]
+
+        if any(marker in normalized for marker in (
+            "quiero entender si recuerdas",
+            "recuerdas lo que te digo",
+            "como recuerdas",
+            "cómo recuerdas",
+        )):
+            return [
+                "Sí, la idea es ir guardando lo importante de la conversación para no hacerte repetir todo.",
+                "Y si algo no me queda claro, prefiero confirmártelo a fingir que me acuerdo de algo que no tengo bien amarrado.",
+            ]
+
+        clinic_name = str(clinic.get("name") or "").strip()
+        return [
+            f"Soy {persona.identity}, la asesora virtual{f' de {clinic_name}' if clinic_name else ''}",
+            "Soy una IA hecha para llevar este canal con contexto, seguimiento y criterio para que la conversación avance bien",
+        ]
+
+    def _build_first_contextual_followup(
+        self,
+        persona: PersonaProfile,
+        clinic: Dict[str, Any],
+        normalized: str,
+    ) -> List[str]:
+        intro = self._build_first_turn(persona, clinic)[0]
+        topic = self._extract_topic(persona, clinic, normalized)
+        if topic:
+            if persona.contextual_followups:
+                for key, value in persona.contextual_followups.items():
+                    if self._normalize(str(key)) == self._normalize(topic):
+                        return [intro, str(value).strip()]
+            sector = clinic.get("sector")
+            if sector == "estetica":
+                return [intro, f"{topic} lo manejan acá. Si quieres, te cuento cómo lo trabajan y qué suelen revisar para que se vea natural."]
+            return [intro, f"{topic} lo manejan acá. Si quieres, te cuento cómo lo trabajan o revisamos valoración y disponibilidad."]
+        followup = "Cuéntame qué estás buscando y te ubico rápido."
+        if clinic.get("sector") == "estetica":
+            followup = "Cuéntame qué te gustaría mejorar o qué tratamiento estás mirando, y te ubico rápido."
+        return [intro, followup]
+
+    def _extract_topic(self, persona: PersonaProfile, clinic: Dict[str, Any], normalized: str) -> str:
+        overrides = persona.contextual_followups or {}
+        for key in overrides.keys():
+            key_norm = self._normalize(str(key))
+            if key_norm and key_norm in normalized:
+                return str(key).strip()
+
+        services = clinic.get("services") if isinstance(clinic.get("services"), list) else []
+        for service in services:
+            service_text = str(service).strip()
+            if not service_text:
+                continue
+            if self._normalize(service_text) in normalized:
+                return service_text
+
+        topics = {
+            "botox": "Botox",
+            "relleno": "Rellenos",
+            "rellenos": "Rellenos",
+            "laser": "Láser",
+            "láser": "Láser",
+            "peeling": "Peeling",
+            "mesoterapia": "Mesoterapia",
+            "precio": "Precio",
+            "horario": "Horario",
+            "agenda": "Cita",
+            "cita": "Cita",
+            "disponibilidad": "Disponibilidad",
+        }
+        for marker, label in topics.items():
+            if marker in normalized:
+                return label
+        return ""
+
+    def _extract_recent_topic_from_history(
+        self,
+        persona: PersonaProfile,
+        clinic: Dict[str, Any],
+        history: Optional[List[Dict[str, Any]]],
+    ) -> str:
+        history = history or []
+        generic_fallback = ""
+        generic_labels = {"Precio", "Horario", "Cita", "Disponibilidad"}
+        for msg in reversed(history):
+            if msg.get("role") != "user":
+                continue
+            topic = self._extract_topic(persona, clinic, self._normalize(str(msg.get("content") or "")))
+            if not topic:
+                continue
+            if topic not in generic_labels:
+                return topic
+            if not generic_fallback:
+                generic_fallback = topic
+        return generic_fallback
+
+    def _hours_since_last_turn(self, history: Optional[List[Dict[str, Any]]]) -> Optional[float]:
+        history = history or []
+        for msg in reversed(history):
+            raw_ts = str(msg.get("ts") or "").strip()
+            if not raw_ts:
+                continue
+            try:
+                then = datetime.fromisoformat(raw_ts)
+            except ValueError:
+                continue
+            return max(0.0, (datetime.now() - then).total_seconds() / 3600.0)
+        return None
+
+    def _choose(self, variants: List[str], normalized: str) -> str:
+        if not variants:
+            return ""
+        index = sum(ord(ch) for ch in normalized) % len(variants)
+        return variants[index]