@innvisor/conny-ai 9.7.0

package/src/interfaces/web/static/generate_avatars.py

@@ -0,0 +1,46 @@
+import os
+import urllib.request
+import time
+
+def download_notionists_avatars(output_dir):
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # 30 different name seeds to get distinct premium characters
+    seeds = [
+        "Ane", "Bob", "Clara", "David", "Eva", "Felix", "Grace", "Hugo", 
+        "Iris", "Jack", "Kim", "Leo", "Maya", "Nico", "Olivia", "Paul", 
+        "Quinn", "Ruby", "Sam", "Tess", "Uli", "Val", "Will", "Xena", 
+        "Yuri", "Zoe", "Amelie", "Bruno", "Chloe", "Dan"
+    ]
+    
+    # Soft pastel background colors that fit the dark theme nicely
+    backgrounds = [
+        "c0aade", "b3c5fc", "fca3b7", "fcd2a3", "a3fcd6", "a3edf8",
+        "e2e8f0", "cbd5e1", "f1f5f9", "ffd2e2", "d2ffeb", "ffe3d2"
+    ]
+    
+    for i, seed in enumerate(seeds, 1):
+        num = f"{i:02d}"
+        bg = backgrounds[i % len(backgrounds)]
+        url = f"https://api.dicebear.com/7.x/notionists/svg?seed={seed}&backgroundColor={bg}"
+        file_path = os.path.join(output_dir, f"avatar_{num}.svg")
+        
+        try:
+            print(f"Downloading avatar {num} (seed: {seed})...")
+            # Set a User-Agent to avoid HTTP 403 Forbidden errors
+            req = urllib.request.Request(
+                url, 
+                headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
+            )
+            with urllib.request.urlopen(req, timeout=10) as response:
+                svg_data = response.read().decode('utf-8')
+                with open(file_path, "w", encoding="utf-8") as f:
+                    f.write(svg_data)
+            time.sleep(0.2) # Soft delay to be polite to the server
+        except Exception as e:
+            print(f"Error downloading avatar {num}: {e}")
+
+if __name__ == '__main__':
+    output_dir = '/home/ubuntu/conny/src/interfaces/web/static/avatars'
+    download_notionists_avatars(output_dir)
+    print("All 30 premium Notionist avatars downloaded successfully!")

package/v7/__init__.py

@@ -0,0 +1,46 @@
+"""
+Conny V7.0 — Registry de Agentes
+=====================================
+Registra todos los agentes disponibles.
+El orquestador los carga una sola vez al arranque.
+"""
+
+from __future__ import annotations
+from typing import Dict, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from v7.agents.base import AgentBase
+
+from v7.agents.captacion   import AgenteCaptacion
+from v7.agents.objeciones  import AgenteObjeciones
+from v7.agents.agenda      import AgenteAgenda
+from v7.agents.conocimiento import AgenteConocimiento
+from v7.agents.seguimiento import AgenteSeguimiento
+from v7.agents.escalacion  import AgenteEscalacion
+from v7.router             import AgentID
+
+
+def build_registry(llm_engine) -> Dict[str, "AgentBase"]:
+    """
+    Construye el diccionario de agentes instanciados.
+    Llamar UNA SOLA VEZ al arranque, pasar a ConnyUltra.
+    """
+    return {
+        AgentID.CAPTACION:    AgenteCaptacion(llm_engine),
+        AgentID.OBJECIONES:   AgenteObjeciones(llm_engine),
+        AgentID.AGENDA:       AgenteAgenda(llm_engine),
+        AgentID.CONOCIMIENTO: AgenteConocimiento(llm_engine),
+        AgentID.SEGUIMIENTO:  AgenteSeguimiento(llm_engine),
+        AgentID.ESCALACION:   AgenteEscalacion(llm_engine),
+    }
+
+
+__all__ = [
+    "build_registry",
+    "AgenteCaptacion",
+    "AgenteObjeciones",
+    "AgenteAgenda",
+    "AgenteConocimiento",
+    "AgenteSeguimiento",
+    "AgenteEscalacion",
+]

package/v7/agents/__init__.py

@@ -0,0 +1,46 @@
+"""
+Conny V7.0 — Registry de Agentes
+=====================================
+Registra todos los agentes disponibles.
+El orquestador los carga una sola vez al arranque.
+"""
+
+from __future__ import annotations
+from typing import Dict, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from v7.agents.base import AgentBase
+
+from v7.agents.captacion   import AgenteCaptacion
+from v7.agents.objeciones  import AgenteObjeciones
+from v7.agents.agenda      import AgenteAgenda
+from v7.agents.conocimiento import AgenteConocimiento
+from v7.agents.seguimiento import AgenteSeguimiento
+from v7.agents.escalacion  import AgenteEscalacion
+from v7.router             import AgentID
+
+
+def build_registry(llm_engine) -> Dict[str, "AgentBase"]:
+    """
+    Construye el diccionario de agentes instanciados.
+    Llamar UNA SOLA VEZ al arranque, pasar a ConnyUltra.
+    """
+    return {
+        AgentID.CAPTACION:    AgenteCaptacion(llm_engine),
+        AgentID.OBJECIONES:   AgenteObjeciones(llm_engine),
+        AgentID.AGENDA:       AgenteAgenda(llm_engine),
+        AgentID.CONOCIMIENTO: AgenteConocimiento(llm_engine),
+        AgentID.SEGUIMIENTO:  AgenteSeguimiento(llm_engine),
+        AgentID.ESCALACION:   AgenteEscalacion(llm_engine),
+    }
+
+
+__all__ = [
+    "build_registry",
+    "AgenteCaptacion",
+    "AgenteObjeciones",
+    "AgenteAgenda",
+    "AgenteConocimiento",
+    "AgenteSeguimiento",
+    "AgenteEscalacion",
+]

package/v7/agents/agenda.py

@@ -0,0 +1,77 @@
+"""
+Conny V7.0 — Agente de Agenda
+==================================
+Gestiona la valoración/cita. Propone UN día concreto.
+Nunca inventa disponibilidad. Cierra hacia el micro-compromiso.
+Prompt: ~320 tokens.
+"""
+
+from __future__ import annotations
+import re
+from v7.agents.base import AgentBase, AgentContext, AgentResponse
+
+
+class AgenteAgenda(AgentBase):
+
+    agent_id     = "agenda"
+    context_keys = ["patient_name", "funnel_state", "ultima_cita",
+                    "calendar_available", "clinic_tone"]
+
+    def _build_prompt(self, ctx: AgentContext) -> str:
+        calendar = ctx.calendar_info or ""
+        tiene_calendar = bool(calendar and "disponible" in calendar.lower())
+        usted = ctx.usted
+
+        if tiene_calendar:
+            disponibilidad_bloque = f"DISPONIBILIDAD REAL:\n{calendar}"
+        else:
+            disponibilidad_bloque = (
+                "No tienes acceso al calendario real. "
+                "Propón el próximo jueves como día concreto. "
+                "Si el paciente no puede, negocia. "
+                "Nunca digas 'cuando puedas' ni 'el día que prefieras'."
+            )
+
+        return f"""Eres la persona que contesta el WhatsApp de {ctx.clinic_name or "la clínica"}.
+{self._tone_header(ctx)}
+
+MISIÓN: agendar la valoración. La valoración es el producto, no el procedimiento.
+
+LA VALORACIÓN ES:
+  Gratis. 20 minutos. Con la doctora directamente.
+  Sin compromiso — la doctora evalúa y te dice con honestidad qué aplica.
+
+CÓMO CERRAR:
+1. Propón UN día concreto — "esta semana tienes el jueves, te queda bien"
+2. NUNCA dos opciones: "jueves o viernes" suena a indecisión
+3. Si rechaza ese día → negocia hacia otro día, no listes toda la semana
+4. Si acepta → pide nombre y confirma: "perfecto, {ctx.patient_name or 'te anoto'} para el jueves"
+5. Si ya tiene cita → confirmar o reagendar con calidez
+
+NUNCA INVENTAR DISPONIBILIDAD:
+Si no tienes el calendario real, di "te confirmo" en vez de inventar horarios.
+  "esta semana tenemos espacio, déjame confirmarte el jueves a qué hora puedes"
+
+{disponibilidad_bloque}
+
+TONO DE CIERRE:
+  {"Le agendamos la valoración. ¿Le queda bien este jueves?" if usted else "te agendo la valoración, esta semana tienes el jueves, te queda bien"}
+
+{self._writing_rules()}
+{self._patient_block(ctx)}"""
+
+    def _parse_response(self, raw: str, ctx: AgentContext) -> AgentResponse:
+        from v7.postprocess import postprocess, split_bubbles
+        clean   = postprocess(raw, is_premium=ctx.is_premium)
+        bubbles = split_bubbles(clean)
+
+        # Detectar si se confirmó una cita en la respuesta
+        cita_confirmada = bool(re.search(
+            r"\b(agend[oé]|confirm[oé]|anot[oé]|queda para|quedaste para)\b",
+            raw, re.IGNORECASE
+        ))
+
+        return AgentResponse(
+            bubbles=bubbles or [clean],
+            funnel_update="cita_agendada" if cita_confirmada else None,
+        )

package/v7/agents/base.py

@@ -0,0 +1,216 @@
+"""
+Conny V7.0 — AgentBase
+=========================
+Contrato que todos los agentes implementan.
+El orquestador siempre llama agent.run(ctx) sin saber qué agente es.
+"""
+
+from __future__ import annotations
+import logging
+import time
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any
+
+log = logging.getLogger(__name__)
+
+
+# ── Contexto de entrada ───────────────────────────────────────────────────────
+
+@dataclass
+class AgentContext:
+    """
+    Todo lo que un agente necesita para generar su respuesta.
+    El orquestador ensambla esto desde la memoria ANTES de llamar al agente,
+    pasando SOLO los campos que el agente declaró necesitar.
+    """
+    # Mensaje actual
+    chat_id:       str
+    text:          str
+    platform:      str = "whatsapp"
+
+    # Perfil del paciente (solo campos solicitados)
+    patient_summary: str = ""          # texto compacto del perfil
+    funnel_stage:    str = "primer_contacto"
+    patient_name:    Optional[str] = None
+    visits:          int = 0
+    objeciones_pasadas: List[str] = field(default_factory=list)
+
+    # Clínica
+    clinic_name:   str = ""
+    clinic_tone:   str = "SALUD"       # SALUD | SALUD PREMIUM | GENERAL | RETAIL
+    clinic_kb:     str = ""            # fragmento relevante de KB
+    servicios:     str = ""
+    precios:       str = ""
+    horarios:      str = ""
+
+    # Historial reciente (últimos N mensajes para coherencia)
+    history:       List[Dict] = field(default_factory=list)
+
+    # Contexto adicional
+    search_context: str = ""
+    calendar_info:  str = ""
+    metadata:       Dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def is_premium(self) -> bool:
+        return self.clinic_tone in ("SALUD PREMIUM", "PREMIUM")
+
+    @property
+    def usted(self) -> bool:
+        return self.is_premium
+
+    def greeting_name(self) -> str:
+        return self.patient_name or ""
+
+    @property
+    def funnel_state(self) -> str:
+        return self.funnel_stage
+
+    @property
+    def servicios_clinica(self) -> str:
+        return self.servicios
+
+    @property
+    def clinic_kb_excerpt(self) -> str:
+        return self.clinic_kb
+
+    @property
+    def calendar_available(self) -> bool:
+        return bool(self.calendar_info)
+
+
+# ── Respuesta del agente ──────────────────────────────────────────────────────
+
+@dataclass
+class AgentResponse:
+    """
+    Lo que el agente devuelve al orquestador.
+    """
+    bubbles:         List[str]              # burbujas ya listas para enviar
+    next_agent:      Optional[str] = None  # si el agente quiere escalar a otro
+    funnel_update:   Optional[str] = None  # nuevo estado del funnel (si cambió)
+    new_objecion:    Optional[str] = None  # objeción detectada para registrar
+    learned_name:    Optional[str] = None  # nombre detectado en el mensaje
+    learned_zona:    Optional[str] = None  # zona de interés detectada
+    confidence:      float = 1.0
+    latency_ms:      float = 0.0
+    agent_id:        str = "unknown"
+
+    @property
+    def text(self) -> str:
+        return " ||| ".join(self.bubbles)
+
+
+# ── Clase base ────────────────────────────────────────────────────────────────
+
+class AgentBase(ABC):
+    """
+    Todos los agentes heredan de aquí.
+    Implementar solo: agent_id, context_keys, _build_prompt, y opcionalmente _parse_response.
+    """
+
+    agent_id:     str          # identificador único
+    context_keys: List[str]    # qué campos de AgentContext necesita
+
+    # Máximo de tokens que este agente puede usar en su prompt de sistema
+    max_system_tokens: int = 600
+
+    def __init__(self, llm_engine):
+        self._llm = llm_engine
+
+    async def run(self, ctx: AgentContext) -> AgentResponse:
+        """
+        Punto de entrada único. El orquestador siempre llama esto.
+        No se sobreescribe (salvo casos muy específicos).
+        """
+        t0 = time.perf_counter()
+        try:
+            system_prompt = self._build_prompt(ctx)
+            messages      = self._build_messages(ctx, system_prompt)
+            raw, meta     = await self._llm.complete(
+                messages,
+                model_tier="fast",
+                temperature=0.82,
+                max_tokens=200,   # agentes responden corto
+            )
+            log.info(
+                "[%s] %s provider=%s model=%s",
+                self.agent_id,
+                ctx.chat_id[:8],
+                meta.get("provider", "?"),
+                meta.get("model", "?")[:25],
+            )
+            response = self._parse_response(raw, ctx)
+            response.latency_ms = (time.perf_counter() - t0) * 1000
+            response.agent_id   = self.agent_id
+            return response
+        except Exception as e:
+            log.error("[%s] error: %s", self.agent_id, e, exc_info=True)
+            return AgentResponse(
+                bubbles=["un momento, déjame revisar eso"],
+                agent_id=self.agent_id,
+                latency_ms=(time.perf_counter() - t0) * 1000,
+            )
+
+    @abstractmethod
+    def _build_prompt(self, ctx: AgentContext) -> str:
+        """Construye el system prompt especializado para este agente."""
+
+    def _build_messages(self, ctx: AgentContext, system_prompt: str) -> List[Dict]:
+        """Arma el array de mensajes para el LLM."""
+        messages = [{"role": "system", "content": system_prompt}]
+        # Últimos 8 turnos de historial para coherencia
+        for turn in ctx.history[-8:]:
+            messages.append({
+                "role":    turn.get("role", "user"),
+                "content": turn.get("content", ""),
+            })
+        messages.append({"role": "user", "content": ctx.text})
+        return messages
+
+    def _parse_response(self, raw: str, ctx: AgentContext) -> AgentResponse:
+        """
+        Post-procesa la respuesta cruda del LLM.
+        Los agentes pueden sobreescribir esto para extraer acciones (citas, nombres, etc.).
+        """
+        from v7.postprocess import postprocess
+        clean   = postprocess(raw, is_premium=ctx.is_premium)
+        bubbles = [b.strip() for b in clean.split("|||") if b.strip()]
+        return AgentResponse(bubbles=bubbles or [clean])
+
+    # ── Helpers comunes ────────────────────────────────────────────────────────
+
+    def _tone_header(self, ctx: AgentContext) -> str:
+        """Instrucción de tono según el tipo de clínica."""
+        if ctx.clinic_tone == "SALUD PREMIUM":
+            return (
+                "Tono: Usted. Profesional y cálido. Primera letra mayúscula. "
+                "Sin tuteo. Identifica la clínica, no a ti misma."
+            )
+        elif ctx.clinic_tone == "SALUD":
+            return "Tono: tuteo natural, cálido, colombiano. Como la recepcionista de siempre."
+        else:
+            return "Tono: cercano, directo, colombiano real."
+
+    def _writing_rules(self) -> str:
+        return (
+            "CÓMO ESCRIBES:\n"
+            "Máximo 1 oración por burbuja. Máximo 2 burbujas. ||| para separar.\n"
+            "Sin punto al final. Sin guión largo. Sin ¿¡. Sin emojis.\n"
+            "Sin 'claro que sí', sin 'te cuento que', sin 'con mucho gusto'.\n"
+            "Si vas a decir algo, dilo directo sin preámbulo."
+        )
+
+    def _patient_block(self, ctx: AgentContext) -> str:
+        if ctx.patient_summary:
+            return f"PACIENTE:\n{ctx.patient_summary}"
+        return ""
+
+    def _clinic_block(self, ctx: AgentContext) -> str:
+        parts = [f"Clínica: {ctx.clinic_name}"]
+        if ctx.servicios:
+            parts.append(f"Servicios: {ctx.servicios[:200]}")
+        if ctx.clinic_kb:
+            parts.append(f"KB: {ctx.clinic_kb[:400]}")
+        return "\n".join(parts)

package/v7/agents/captacion.py

@@ -0,0 +1,60 @@
+"""
+Conny V7.0 — Agente de Captación
+=====================================
+Primer contacto. Descubre el dolor real antes de ofrecer nada.
+Prompt: ~380 tokens (vs 4,000 del sistema monolítico).
+"""
+
+from __future__ import annotations
+from v7.agents.base import AgentBase, AgentContext, AgentResponse
+
+
+class AgenteCaptacion(AgentBase):
+
+    agent_id     = "captacion"
+    context_keys = ["patient_name", "visits", "funnel_state", "clinic_tone", "servicios_clinica"]
+
+    def _build_prompt(self, ctx: AgentContext) -> str:
+        usted = ctx.usted
+        voz   = "usted" if usted else "tú"
+        nombre_bloque = f"Su nombre es {ctx.patient_name}." if usted and ctx.patient_name else \
+                        f"Se llama {ctx.patient_name}." if ctx.patient_name else ""
+
+        return f"""Eres la persona que contesta el WhatsApp de {ctx.clinic_name or "la clínica"}.
+No eres un bot. Llevas tiempo ahí.
+{self._tone_header(ctx)}
+{nombre_bloque}
+
+MISIÓN: descubrir qué le preocupa al paciente. Sin ofrecer nada todavía.
+
+PSICOLOGÍA:
+Quien escribe a una clínica ya decidió que quiere algo.
+Solo necesita permiso, confianza, y un paso pequeño.
+Tu trabajo es hacer que se sienta entendido/a, no vendido/a.
+
+MÉTODO (sigue este orden):
+1. En la primera burbuja preséntate corto como Conny, la asesora virtual del negocio
+2. Acusa recibo de que llegó — cálido, sin exageración
+3. Haz UNA sola pregunta que descubra el dolor específico
+   La más poderosa: "qué zona te está molestando"
+3. No menciones servicios, precios ni procedimientos todavía
+
+PRIMER SALUDO (si es primera vez):
+Preséntate corto, sin speech largo, y luego ve directo al punto.
+No abras con "oye", "mira" ni "qué te trae por acá".
+{"Ejemplo: Hola, soy Conny, la asesora virtual de la clínica ||| qué le gustaría revisar hoy" if usted else "Ejemplo: Hola, soy Conny, la asesora virtual de la clínica ||| qué te gustaría revisar hoy"}
+
+VISITAS PREVIAS: {ctx.visits}
+{"Reconoce que ya ha estado antes: cálido, sin drama." if ctx.visits > 0 else ""}
+
+{self._writing_rules()}
+{self._patient_block(ctx)}"""
+
+    def _parse_response(self, raw: str, ctx: AgentContext) -> AgentResponse:
+        from v7.postprocess import postprocess, split_bubbles
+        clean   = postprocess(raw, is_premium=ctx.is_premium)
+        bubbles = split_bubbles(clean)
+        return AgentResponse(
+            bubbles=bubbles or [clean],
+            funnel_update="explorando" if ctx.funnel_stage == "primer_contacto" else None,
+        )

package/v7/agents/conocimiento.py

@@ -0,0 +1,69 @@
+"""
+Conny V7.0 — Agente de Conocimiento
+=======================================
+Responde preguntas técnicas sobre procedimientos con la KB del negocio.
+Si no tiene la info, lo admite. Nunca inventa datos médicos.
+Prompt: ~420 tokens.
+"""
+
+from __future__ import annotations
+from v7.agents.base import AgentBase, AgentContext, AgentResponse
+
+
+class AgenteConocimiento(AgentBase):
+
+    agent_id     = "conocimiento"
+    context_keys = ["servicios_clinica", "precios", "clinic_kb_excerpt",
+                    "clinic_tone", "patient_name"]
+
+    def _build_prompt(self, ctx: AgentContext) -> str:
+        kb_block = f"BASE DE CONOCIMIENTO:\n{ctx.clinic_kb}" if ctx.clinic_kb else (
+            "No tienes información específica de esta clínica en este momento. "
+            "Responde con lo que sabes en general y transfiere al especialista para datos exactos."
+        )
+
+        return f"""Eres la persona que contesta el WhatsApp de {ctx.clinic_name or "la clínica"}.
+{self._tone_header(ctx)}
+
+MISIÓN: responder la pregunta técnica con precisión. Sin inventar. Sin exagerar.
+
+REGLAS DE CONOCIMIENTO:
+1. Si tienes el dato en la KB → dalo directo, sin rodeos
+2. Si NO tienes el dato → admítelo natural y transfiere:
+   "ese dato exacto lo tiene la doctora, en la valoración te lo confirma"
+   NUNCA: "ese precio lo maneja la clínica" (suena a call center)
+   NUNCA: inventar rangos de precio si no los tienes
+3. Datos médicos específicos → siempre al especialista
+   "eso depende de tu caso, la doctora lo evalúa en la valoración"
+
+RESPUESTAS TÍPICAS:
+"cuánto dura el botox":
+  "entre 4 y 6 meses según el área y cada persona, en la valoración la doctora te dice exactamente para tu caso"
+
+"tiene efectos secundarios":
+  "molestias leves en la zona las primeras 24 horas, nada que impida seguir el día normal"
+
+"cuántas sesiones":
+  "depende del procedimiento y la respuesta de tu piel, eso lo define la doctora en la valoración"
+
+"tiene recuperación":
+  Para botox/rellenos: "prácticamente ninguna, en la tarde sales normal"
+  Para otros: "eso depende del procedimiento, en la valoración te explican día a día"
+
+DESPUÉS DE RESPONDER:
+Si la pregunta fue resuelta → encamina suavemente hacia la valoración.
+  "en la valoración gratis la doctora te dice exactamente para tu caso, esta semana tienes el jueves"
+
+{kb_block}
+{self._writing_rules()}
+{self._patient_block(ctx)}"""
+
+    def _parse_response(self, raw: str, ctx: AgentContext) -> AgentResponse:
+        from v7.postprocess import postprocess, split_bubbles
+        clean   = postprocess(raw, is_premium=ctx.is_premium)
+        bubbles = split_bubbles(clean)
+        return AgentResponse(
+            bubbles=bubbles or [clean],
+            # Si resolvió la pregunta técnica, el siguiente paso natural es agenda
+            next_agent="agenda" if len(ctx.history) > 2 else None,
+        )

package/v7/agents/escalacion.py

@@ -0,0 +1,83 @@
+"""
+Conny V7.0 — Agente de Escalación
+=====================================
+Detecta urgencias reales y deriva al humano correcto.
+Nunca diagnostica. Nunca minimiza una queja.
+Prompt: ~220 tokens.
+"""
+
+from __future__ import annotations
+import re
+from v7.agents.base import AgentBase, AgentContext, AgentResponse
+
+_URGENCIA_MEDICA_RE = re.compile(
+    r"\b(emergencia|reacción|alergia|inflamación grave|no puedo respirar|"
+    r"me duele mucho|complicación|infección|sangrado|desmay)\b",
+    re.IGNORECASE,
+)
+
+_QUEJA_LEGAL_RE = re.compile(
+    r"\b(demanda|abogado|denunciar|demandar|tribunal|juridico|legal)\b",
+    re.IGNORECASE,
+)
+
+
+class AgenteEscalacion(AgentBase):
+
+    agent_id     = "escalacion"
+    context_keys = ["patient_name", "admin_chat_ids", "clinic_phone", "clinic_tone"]
+
+    def _build_prompt(self, ctx: AgentContext) -> str:
+        es_medica = bool(_URGENCIA_MEDICA_RE.search(ctx.text))
+        es_legal  = bool(_QUEJA_LEGAL_RE.search(ctx.text))
+        usted     = ctx.usted
+
+        if es_medica:
+            tipo = "URGENCIA MÉDICA"
+            instruccion = (
+                "Calma al paciente. Deriva inmediatamente a la línea de emergencias de la clínica. "
+                f"Número de contacto urgente: {ctx.metadata.get('clinic_emergency', 'el número de la clínica')}. "
+                "No diagnostiques. No minimices."
+            )
+        elif es_legal:
+            tipo = "SITUACIÓN LEGAL"
+            instruccion = (
+                "Sé cordial y profesional. No te pongas a la defensiva. "
+                "Conecta con el equipo directivo de inmediato. "
+                "No hagas promesas ni admitas responsabilidad."
+            )
+        else:
+            tipo = "SOLICITUD DE HUMANO"
+            instruccion = (
+                "El paciente quiere hablar con una persona. "
+                "Conecta de forma cálida. No lo hagas esperar."
+            )
+
+        return f"""Eres la persona que contesta el WhatsApp de {ctx.clinic_name or "la clínica"}.
+{self._tone_header(ctx)}
+
+SITUACIÓN: {tipo}
+{instruccion}
+
+RESPUESTA EN DOS PASOS:
+1. Acusa recibo con calma — una sola frase, sin alarmar
+2. Conecta al humano correcto — rápido y concreto
+
+{"Ejemplo: Entiendo, le conecto en este momento con alguien del equipo." if usted else "Ejemplo: entiendo, te conecto ahora mismo con alguien del equipo"}
+
+NUNCA:
+  Diagnosticar síntomas médicos
+  Prometer resultados o soluciones
+  Dar largas ni pedir que espere sin conectar
+
+{self._writing_rules()}"""
+
+    def _parse_response(self, raw: str, ctx: AgentContext) -> AgentResponse:
+        from v7.postprocess import postprocess, split_bubbles
+        clean   = postprocess(raw, is_premium=ctx.is_premium)
+        bubbles = split_bubbles(clean)
+        return AgentResponse(
+            bubbles=bubbles or [clean],
+            next_agent="human",   # señal al orquestador: notificar admin
+            funnel_update=None,
+        )