@innvisor/conny-ai 9.7.0

package/v7/agents/objeciones.py

@@ -0,0 +1,109 @@
+"""
+Conny V7.0 — Agente de Objeciones
+=====================================
+Maneja toda resistencia del paciente.
+La objeción dicha raramente es la objeción real.
+Prompt: ~580 tokens.
+"""
+
+from __future__ import annotations
+import re
+from v7.agents.base import AgentBase, AgentContext, AgentResponse
+
+
+# Mapa objeción detectada → clave para guardar en perfil
+_OBJECION_MAP = [
+    (r"\b(caro|costoso|precio|plata|presupuesto)\b",           "precio"),
+    (r"\b(pensar|pensarlo|consultar|pareja|esposo|esposa|mamá)\b", "indecision"),
+    (r"\b(miedo|asusta|raro|exagerada|tiesa|natural|se note)\b",   "miedo_resultado"),
+    (r"\b(ya fui|otro lado|otra clínica|no me gustó)\b",           "experiencia_previa"),
+    (r"\b(tiempo|ocupad|trabajo|no puedo ir)\b",               "tiempo"),
+    (r"\b(vergüenza|pena|dirán)\b",                            "vergüenza"),
+    (r"\b(no funciona|carreta|esceptic|no creo)\b",            "escepticismo"),
+    (r"\b(bogotá|exterior|fuera del país)\b",                  "distancia"),
+]
+
+def _detect_objecion(text: str) -> str:
+    for pattern, key in _OBJECION_MAP:
+        if re.search(pattern, text, re.IGNORECASE):
+            return key
+    return "otra"
+
+
+class AgenteObjeciones(AgentBase):
+
+    agent_id     = "objeciones"
+    context_keys = ["patient_name", "objeciones_pasadas", "funnel_state",
+                    "clinic_tone", "servicios_relevantes", "miedo_principal"]
+
+    def _build_prompt(self, ctx: AgentContext) -> str:
+        objeciones_previas = (
+            f"Ya manejó estas objeciones antes: {', '.join(ctx.objeciones_pasadas)}. No repitas las mismas respuestas."
+            if ctx.objeciones_pasadas else ""
+        )
+        usted = ctx.usted
+
+        return f"""Eres la persona que contesta el WhatsApp de {ctx.clinic_name or "la clínica"}.
+{self._tone_header(ctx)}
+
+MISIÓN: resolver la resistencia del paciente con psicología, no con argumentos.
+
+LO QUE EL PACIENTE NUNCA DICE PERO SIEMPRE SIENTE:
+La objeción que dice ("está caro") raramente es la real.
+Detrás hay uno de estos miedos:
+  miedo al resultado / miedo a equivocarse / vergüenza social / miedo médico
+
+RESPONDE A LO QUE NO DIJERON, NO A LO QUE DIJERON:
+  Si dice "está caro" → el miedo real suele ser "¿vale la pena?"
+  Si dice "lo voy a pensar" → hay una objeción no dicha. Descúbrela.
+  Si dice "me da miedo quedar rara" → valida primero, luego transfiere al especialista
+
+RESPUESTAS EXACTAS POR OBJECIÓN:
+"está caro/costoso":
+  "sí, los buenos procedimientos no son baratos ||| lo que vale es el criterio de la doctora, cuánto manda, dónde, cómo. en la valoración te da el número exacto para tu caso"
+
+"lo voy a pensar":
+  "claro, sin afán ||| qué es lo que más te frena, el precio, el resultado, o el proceso"
+  (espera la respuesta — esa es la objeción real)
+
+"miedo a quedar exagerada/tiesa/rara":
+  "ese miedo es el más común de todos ||| el objetivo acá es que te veas descansada, no diferente. la doctora trabaja muy conservador, es su sello"
+
+"ya fui a otro lado y quedé mal":
+  "ay qué pena, eso es muy frustrante ||| qué fue lo que pasó, dónde te lo hicieron"
+  (si fue en un spa/no-clínica → eso explica todo, diferénciate)
+
+"no tengo tiempo":
+  "cuánto tiempo tienes, la valoración son 20 minutos, puedes en el almuerzo"
+
+"lo consulto con mi pareja/mamá":
+  "claro ||| qué crees que le preocuparía más, el precio, el resultado, o la recuperación"
+
+"vergüenza/pena":
+  "la mayoría llega con eso ||| acá es muy privado, solo tú con la doctora, sin testigos"
+
+"no funciona/pura carreta":
+  "entiendo el escepticismo, es válido ||| qué te haría creer que sí funciona"
+
+TÉCNICA CLAVE: TRANSFERIR AL ESPECIALISTA
+Cuando hay duda o miedo médico real → no tomes la decisión tú.
+  "eso lo ve la doctora, ella te dice con honestidad si aplica para tu caso"
+
+CIERRE DESPUÉS DE RESOLVER:
+Propón UN día concreto.
+  "esta semana tienes el jueves, te queda bien"
+NUNCA dos días: "jueves o viernes" suena a que no sabes.
+
+{objeciones_previas}
+{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)
+        objecion = _detect_objecion(ctx.text)
+        return AgentResponse(
+            bubbles=bubbles or [clean],
+            new_objecion=objecion,
+        )

package/v7/agents/seguimiento.py

@@ -0,0 +1,71 @@
+"""
+Conny V7.0 — Agente de Seguimiento
+======================================
+Reactivación de pacientes inactivos, no-shows, post-procedimiento.
+Se activa por cron O por mensaje del paciente que ya tuvo cita.
+Prompt: ~290 tokens.
+"""
+
+from __future__ import annotations
+from v7.agents.base import AgentBase, AgentContext, AgentResponse
+
+
+class AgenteSeguimiento(AgentBase):
+
+    agent_id     = "seguimiento"
+    context_keys = ["patient_name", "ultima_cita", "procedimiento_realizado",
+                    "clinic_tone", "funnel_state"]
+
+    def _build_prompt(self, ctx: AgentContext) -> str:
+        razon    = ctx.metadata.get("follow_up_reason", "reactivacion")
+        nombre   = ctx.patient_name or ""
+        usted    = ctx.usted
+
+        razon_map = {
+            "no_show":        f"{"No vino a su cita" if usted else "No fue a la cita"}. Tono: calidez, sin reproche.",
+            "post_cita_48h":  f"Tuvo la valoración hace 2 días. Tono: genuino interés.",
+            "post_procedimiento": "Ya le hicieron el procedimiento. Revisa cómo le fue.",
+            "reactivacion_30d": f"Lleva más de 30 días sin escribir. Tono: suave, sin presión.",
+            "reactivacion":   f"{"Había mostrado interés." if not nombre else f"{nombre} había mostrado interés."}. Retomar suave.",
+        }
+        contexto_razon = razon_map.get(razon, razon_map["reactivacion"])
+        nombre_bloque  = f"{"Su nombre es" if usted else "Se llama"} {nombre}." if nombre else ""
+
+        return f"""Eres la persona que contesta el WhatsApp de {ctx.clinic_name or "la clínica"}.
+{self._tone_header(ctx)}
+
+SITUACIÓN: {contexto_razon}
+{nombre_bloque}
+
+MISIÓN: retomar el contacto de forma natural. Sin presión. Sin drama.
+
+GUÍAS POR SITUACIÓN:
+No-show:
+  No preguntes por qué no fue. Solo retoma.
+  {"¿Tuvo algún imprevisto? Podemos reagendar cuando le quede bien." if usted else "oye, quedaste de venir, ¿te pasó algo? podemos reagendar sin problema"}
+
+Post-valoración (48h):
+  Pregunta genuinamente cómo le fue, sin venta.
+  {"¿Cómo le quedaron las recomendaciones de la doctora?" if usted else "oye, cómo te fue con lo que te dijo la doctora"}
+
+Post-procedimiento:
+  Interés real en el resultado. Abre espacio para que cuente.
+  {"¿Cómo se ha sentido?" if usted else "qué tal cómo quedaste, ya se ven los resultados?"}
+
+Reactivación larga (30+ días):
+  Suave, sin recordar que desapareció.
+  {"Queríamos saber cómo está" if usted else "oye, hace rato no sabemos de ti, ¿cómo has estado?"}
+
+SI HAY APERTURA → reagendar en el mismo mensaje
+  "esta semana tienes el jueves, te queda bien"
+
+{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],
+            funnel_update="reactivacion",
+        )

package/v7/memory/__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/memory/patient_profile.py

@@ -0,0 +1,200 @@
+"""
+Conny V7.0 — Memoria Clínica Persistente
+============================================
+PatientProfile: perfil enriquecido del paciente (sobrevive reinicios).
+FunnelState:    máquina de estados del proceso de conversión.
+
+Diseño: capa delgada sobre el SQLite existente.
+No reemplaza db.py — lo enriquece con lógica clínica.
+"""
+
+from __future__ import annotations
+import json
+import time
+import logging
+from dataclasses import dataclass, field, asdict
+from typing import Dict, List, Optional, Any
+from enum import Enum
+
+log = logging.getLogger(__name__)
+
+
+# ── Máquina de estados del funnel ────────────────────────────────────────────
+
+class FunnelStage(str, Enum):
+    PRIMER_CONTACTO    = "primer_contacto"     # nunca ha escrito antes
+    EXPLORANDO         = "explorando"           # haciendo preguntas, sin compromiso
+    CON_INTENCION      = "con_intencion"        # expresó interés real
+    CITA_AGENDADA      = "cita_agendada"        # tiene valoración agendada
+    POST_CITA          = "post_cita"            # ya tuvo la valoración o procedimiento
+    REACTIVACION       = "reactivacion"         # inactivo > 30 días, volvió
+
+
+# Transiciones válidas — qué puede seguir a qué
+_TRANSITIONS: Dict[FunnelStage, List[FunnelStage]] = {
+    FunnelStage.PRIMER_CONTACTO: [FunnelStage.EXPLORANDO, FunnelStage.CON_INTENCION],
+    FunnelStage.EXPLORANDO:      [FunnelStage.CON_INTENCION, FunnelStage.PRIMER_CONTACTO],
+    FunnelStage.CON_INTENCION:   [FunnelStage.CITA_AGENDADA, FunnelStage.EXPLORANDO],
+    FunnelStage.CITA_AGENDADA:   [FunnelStage.POST_CITA, FunnelStage.CON_INTENCION],
+    FunnelStage.POST_CITA:       [FunnelStage.CON_INTENCION, FunnelStage.REACTIVACION],
+    FunnelStage.REACTIVACION:    [FunnelStage.EXPLORANDO, FunnelStage.CON_INTENCION],
+}
+
+
+# ── Perfil del paciente ───────────────────────────────────────────────────────
+
+@dataclass
+class PatientProfile:
+    chat_id:               str
+    nombre:                Optional[str]        = None
+    zona_interes:          List[str]            = field(default_factory=list)   # ["frente", "ojeras"]
+    miedo_principal:       Optional[str]        = None                          # "quedar exagerada"
+    objeciones_pasadas:    List[str]            = field(default_factory=list)   # ["precio", "tiempo"]
+    funnel_stage:          FunnelStage          = FunnelStage.PRIMER_CONTACTO
+    visitas:               int                  = 0
+    ultima_interaccion:    float                = 0.0
+    ultima_cita:           Optional[str]        = None
+    procedimiento_hecho:   Optional[str]        = None
+    score_conversion:      float                = 0.0                           # 0-1
+    idioma:                str                  = "es"
+    metadata:              Dict[str, Any]       = field(default_factory=dict)
+
+    # ── Transición de funnel ──────────────────────────────────────────────────
+
+    def advance_funnel(self, new_stage: FunnelStage) -> bool:
+        """
+        Avanza el funnel si la transición es válida.
+        Devuelve True si se hizo la transición.
+        """
+        valid = _TRANSITIONS.get(self.funnel_stage, [])
+        if new_stage in valid:
+            log.info(
+                "[funnel] %s: %s → %s",
+                self.chat_id[:8], self.funnel_stage.value, new_stage.value
+            )
+            self.funnel_stage = new_stage
+            return True
+        return False
+
+    def add_objecion(self, objecion: str) -> None:
+        if objecion and objecion not in self.objeciones_pasadas:
+            self.objeciones_pasadas.append(objecion)
+            if len(self.objeciones_pasadas) > 10:
+                self.objeciones_pasadas = self.objeciones_pasadas[-10:]
+
+    def add_zona(self, zona: str) -> None:
+        if zona and zona not in self.zona_interes:
+            self.zona_interes.append(zona)
+
+    def days_inactive(self) -> float:
+        if not self.ultima_interaccion:
+            return 999.0
+        return (time.time() - self.ultima_interaccion) / 86400
+
+    def to_context_summary(self, keys: List[str]) -> str:
+        """
+        Serializa solo los campos solicitados por el agente.
+        Evita pasar 4,000 tokens cuando el agente solo necesita 200.
+        """
+        parts = []
+        if "patient_name" in keys and self.nombre:
+            parts.append(f"Nombre: {self.nombre}")
+        if "visits" in keys:
+            parts.append(f"Visitas: {self.visitas}")
+        if "funnel_state" in keys:
+            parts.append(f"Estado funnel: {self.funnel_stage.value}")
+        if "objeciones_pasadas" in keys and self.objeciones_pasadas:
+            parts.append(f"Objeciones previas: {', '.join(self.objeciones_pasadas)}")
+        if "zona_interes" in keys and self.zona_interes:
+            parts.append(f"Zona de interés: {', '.join(self.zona_interes)}")
+        if "miedo_principal" in keys and self.miedo_principal:
+            parts.append(f"Miedo principal: {self.miedo_principal}")
+        if "ultima_cita" in keys and self.ultima_cita:
+            parts.append(f"Última cita: {self.ultima_cita}")
+        if "score_conversion" in keys:
+            parts.append(f"Score conversión: {self.score_conversion:.0%}")
+        return "\n".join(parts) if parts else ""
+
+    def to_dict(self) -> Dict:
+        d = asdict(self)
+        d["funnel_stage"] = self.funnel_stage.value
+        return d
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "PatientProfile":
+        if "funnel_stage" in data:
+            try:
+                data["funnel_stage"] = FunnelStage(data["funnel_stage"])
+            except ValueError:
+                data["funnel_stage"] = FunnelStage.PRIMER_CONTACTO
+        return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
+
+
+# ── Capa de persistencia ──────────────────────────────────────────────────────
+
+class ProfileStore:
+    """
+    Lee y escribe PatientProfile desde el SQLite existente.
+    Usa la columna 'metadata' de la tabla patients para guardar el perfil V7.
+    Sin migración de schema — retrocompatible con V6.
+    """
+
+    _PROFILE_KEY = "v7_profile"
+
+    def __init__(self, db):
+        self._db = db
+
+    def load(self, chat_id: str) -> PatientProfile:
+        """Carga el perfil. Si no existe, crea uno vacío."""
+        try:
+            patient_row = self._db.get_or_create_patient(chat_id)
+            raw_meta = patient_row.get("metadata") or "{}"
+            if isinstance(raw_meta, str):
+                meta = json.loads(raw_meta)
+            else:
+                meta = raw_meta
+
+            profile_data = meta.get(self._PROFILE_KEY)
+            if profile_data:
+                profile = PatientProfile.from_dict(profile_data)
+            else:
+                # Primera vez — construir desde campos existentes
+                profile = PatientProfile(
+                    chat_id=chat_id,
+                    nombre=patient_row.get("name"),
+                    visitas=patient_row.get("visits", 0),
+                    idioma=patient_row.get("language", "es"),
+                    ultima_interaccion=time.time(),
+                )
+            profile.chat_id = chat_id
+            return profile
+        except Exception as e:
+            log.warning("[profile] error cargando %s: %s", chat_id[:8], e)
+            return PatientProfile(chat_id=chat_id)
+
+    def save(self, profile: PatientProfile) -> None:
+        """Persiste el perfil en la columna metadata del paciente."""
+        try:
+            patient_row = self._db.get_or_create_patient(profile.chat_id)
+            raw_meta = patient_row.get("metadata") or "{}"
+            if isinstance(raw_meta, str):
+                meta = json.loads(raw_meta)
+            else:
+                meta = dict(raw_meta)
+
+            profile.ultima_interaccion = time.time()
+            meta[self._PROFILE_KEY] = profile.to_dict()
+
+            with self._db._conn() as c:
+                c.execute(
+                    "UPDATE patients SET metadata=?, name=? WHERE chat_id=?",
+                    (json.dumps(meta), profile.nombre or "", profile.chat_id)
+                )
+        except Exception as e:
+            log.error("[profile] error guardando %s: %s", profile.chat_id[:8], e)
+
+    def update_funnel(self, chat_id: str, new_stage: FunnelStage) -> None:
+        """Atajo para avanzar el funnel sin cargar todo el perfil."""
+        profile = self.load(chat_id)
+        if profile.advance_funnel(new_stage):
+            self.save(profile)