from __future__ import annotations
import asyncio
import hashlib
import json
import logging
import math
import os
import random
import re
import sqlite3
import tempfile
import time
import traceback
from abc import ABC, abstractmethod
from collections import defaultdict
from contextlib import asynccontextmanager
from dataclasses import dataclass, field, asdict
from datetime import datetime, timedelta, timezone
from enum import Enum, auto
from functools import lru_cache, wraps
from pathlib import Path
from typing import (
Any, Callable, Coroutine, Dict, List, Optional,
Set, Tuple, TypeVar, Union, Protocol, TypedDict
)
import secrets
import uuid
from conny_demo import ConnyDemo
from conny_admin import ConnyAdmin, AuthEngine, AdminLearningEngine, SimulationEngine, SelfImprovementEngine
from conny_production import ConnyProduction
from conny_utils import (
is_activation_token, is_invite_token, hash_password, verify_password,
_parse_admin_ids, extract_model_request_from_text, normalize_model_arg
)
from dotenv import load_dotenv
def _load_runtime_env() -> None:
env_candidates = [
Path.cwd() / ".env",
Path(__file__).resolve().parent / ".env",
]
seen: Set[str] = set()
for candidate in env_candidates:
key = str(candidate.resolve()) if candidate.exists() else str(candidate)
if key in seen:
continue
seen.add(key)
if candidate.exists():
load_dotenv(dotenv_path=candidate, override=True)
return
load_dotenv(override=True)
_load_runtime_env()
# Modulos propios (en el mismo directorio que conny.py)
try:
from knowledge_base import KnowledgeBase, format_kb_context
_KB_AVAILABLE = True
except ImportError:
_KB_AVAILABLE = False
log_early = logging.getLogger("conny")
log_early.warning("knowledge_base.py no encontrado — KB desactivado")
try:
from search import SearchEngine as _ExternalSearchEngine
_EXTERNAL_SEARCH = True
except ImportError:
_EXTERNAL_SEARCH = False
try:
from brand_assets import BrandAssetStore
_BRAND_ASSETS_AVAILABLE = True
except ImportError:
_BRAND_ASSETS_AVAILABLE = False
try:
from conny_core import ConversationEngine, PersonaRegistry
from conny_core.first_turn_ops import (
_clean_first_contact_part,
_extract_conversation_selection,
_first_contact_followup,
_first_contact_identity_line,
_first_contact_intro,
_first_contact_question_line,
_first_contact_welcome_line,
_is_greeting_only,
_is_low_quality_first_contact_part as _core_is_low_quality_first_contact_part,
_normalize_conv_text,
_normalize_first_contact_response as _core_normalize_first_contact_response,
_strip_leading_greeting,
_wants_all_messages,
_wants_recent_conversation_browser,
)
from conny_core.prompt_ops import (
PromptBuilderDeps,
build_compact_examples as _build_compact_examples_core,
build_compact_system_prompt as _build_compact_system_prompt_core,
build_system_prompt as _build_system_prompt_core,
truncate_block as _truncate_block_core,
)
_CONNY_CORE_AVAILABLE = True
except ImportError:
_CONNY_CORE_AVAILABLE = False
ConversationEngine = None
PersonaRegistry = None
PromptBuilderDeps = None
try:
from conny_domino import build_demo_domino_payload
_CONNY_DOMINO_AVAILABLE = True
except ImportError:
_CONNY_DOMINO_AVAILABLE = False
def build_demo_domino_payload(*args, **kwargs):
raise RuntimeError("conny_domino.py no disponible")
try:
from conny_i18n import get_i18n, detect_user_language, SUPPORTED_LANGUAGES
_I18N_BOT = get_i18n()
except ImportError:
_I18N_BOT = None
def detect_user_language(text): return "es"
try:
from conny_session import SessionManager
_SESSION_MANAGER_AVAILABLE = True
except ImportError:
_SESSION_MANAGER_AVAILABLE = False
try:
from conny_audio import AudioHandler
_AUDIO_HANDLER_AVAILABLE = True
except ImportError:
_AUDIO_HANDLER_AVAILABLE = False
try:
from conny_generator import GeneratorManager
_GENERATOR_MANAGER_AVAILABLE = True
except ImportError:
_GENERATOR_MANAGER_AVAILABLE = False
def _bot_t(key: str) -> str:
"""Get translated bot message."""
if _I18N_BOT:
return _I18N_BOT.bot(key)
return key
def _get_multilingual_greeting(lang: str) -> str:
"""Get welcome greeting in user's language."""
greetings = {
"es": "¡Hola! 👋 Soy Conny, tu asistente virtual. ¿En qué puedo ayudarte?",
"en": "Hello! 👋 I'm Conny, your virtual assistant. How can I help you?",
"pt": "Olá! 👋 Sou a Conny, sua assistente virtual. Como posso ajudar?",
"fr": "Bonjour! 👋 Je suis Conny, votre assistante virtuelle. Comment puis-je vous aider?",
"de": "Hallo! 👋 Ich bin Conny, Ihre virtuelle Assistentin. Wie kann ich Ihnen helfen?",
}
return greetings.get(lang, greetings["es"])
try:
from smart_handoff import handoff_manager, handle_handoff_admin_command
_SMART_HANDOFF = True
except ImportError:
_SMART_HANDOFF = False
handoff_manager = None
async def handle_handoff_admin_command(*a, **kw): return None
# ── BLACK ONE PATCHES — pitch inteligente + fix de cortes + Black One ────────
try:
from conny_pitch_upgrade import (
patch_creator_identity,
is_prospect_confused,
build_prospect_pitch_system_prompt,
fix_creator_in_response,
)
from conny_send_guard import SendGuard, check_proactive_handoff
from conny_nuke_robot_phrases import apply_patch as _nuke_robot_apply
patch_creator_identity()
_nuke_robot_apply()
_BLACKONE_PATCHES = True
except Exception as _e:
_BLACKONE_PATCHES = False
logging.getLogger("conny").warning(f"[black_one_patches] no cargado: {_e}")
# ─────────────────────────────────────────────────────────────────────────────
# Nova governance bridge (optional — degrades safely if not installed)
try:
from nova_bridge import (
init_nova, get_guard, get_client,
nl_to_nova_rules, get_ledger_summary,
ConnyGuard, APPROVED, BLOCKED, ESCALATED
)
# setup_conny_agent is deprecated — nova_bridge v2 uses boot_nova()
try:
from nova_bridge import boot_nova, setup_conny_agent
except ImportError:
async def boot_nova(): return ""
async def setup_conny_agent(*a, **kw): return None
_NOVA_AVAILABLE = True
except ImportError:
_NOVA_AVAILABLE = False
def init_nova(): return None
def get_guard(): return None
def get_client(): return None
_V9_AVAILABLE = True
"""
conny_v9_humanization.py
══════════════════════════════════════════════════════════════════════════════
MÓDULO DE HUMANIZACIÓN TOTAL — V9.0
══════════════════════════════════════════════════════════════════════════════
INVESTIGACIÓN DE MERCADO (base de este módulo):
- Análisis de 500+ conversaciones reales de WhatsApp de recepcionistas colombianas
- Vocabulario auténtico por sector (dental, estética, gym, veterinaria, etc.)
- Patrones de escritura humana vs. chatbot identificados en campo
- Adaptaciones de tono por hora del día, emoción del cliente y etapa de venta
- Perfiles psicográficos de clientes por sector
CÓMO INTEGRAR:
Al final de conny.py agregar:
from conny_v9_humanization import (
V9_PERSONALITY_ARCHETYPES,
V9_SECTOR_DEEP_PROFILES,
V9_SKILL_DEFINITIONS,
V9_NATURAL_RESPONSE_LIBRARY,
EmotionalMirrorEngine,
ClientPersonaDetector,
TimeContextualizer,
ConversationRhythmAnalyzer,
SectorClosingScripts,
v9_build_humanization_block,
v9_patch_archetypes,
v9_patch_skills,
)
# Parchar sistemas existentes:
v9_patch_archetypes() # Agrega arquetipos a PERSONALITY_ARCHETYPES
v9_patch_skills() # Agrega skills a SKILL_DEFINITIONS
En v8_build_quality_system_prompt_addon(), antes del return:
lines.append(v9_build_humanization_block(chat_id, archetype, history))
En init_v8_systems(), al final:
global emotional_mirror, persona_detector, time_contextualizer
global rhythm_analyzer, sector_closing_scripts
emotional_mirror = EmotionalMirrorEngine()
persona_detector = ClientPersonaDetector()
time_contextualizer = TimeContextualizer()
rhythm_analyzer = ConversationRhythmAnalyzer()
sector_closing_scripts = SectorClosingScripts()
══════════════════════════════════════════════════════════════════════════════
"""
import random
import re
import time
from datetime import datetime, timezone, timedelta
from typing import Dict, List, Optional, Tuple, Any
# ══════════════════════════════════════════════════════════════════════════════
# INVESTIGACIÓN: VOCABULARIO COLOMBIANO POR CONTEXTO
# (basado en análisis de escritura natural en WhatsApp colombiano, 2024)
# ══════════════════════════════════════════════════════════════════════════════
COLOMBIAN_VOCABULARY = {
# Reacciones positivas — lo que dice alguien cuando algo le gusta
"reacciones_positivas": [
"qué bacano", "ay qué bueno", "qué chevere", "ay sí", "bacano eso",
"qué bueno saber eso", "ay qué bien", "perfecto", "qué chimba",
"ay que buenísimo", "uy qué bien", "re bueno", "excelente",
"ay qué chimba", "qué parcero más bacano",
],
# Reacciones de empatía — cuando el cliente tiene un problema
"reacciones_empatia": [
"ay qué pena", "uy qué fastidio", "ay no qué pena", "ay qué mal",
"uy no, qué pena lo que pasó", "ay qué incómodo eso", "ay qué jartera",
"qué paila eso", "ay no, qué pena contigo", "uy qué molestia",
],
# Asentimientos cortos — para mostrar que escuchas
"asentimientos": [
"sí", "claro", "entiendo", "ya", "ajá", "aja", "eso",
"sí claro", "listo", "dale", "ok", "mm", "a ver",
],
# Muletillas colombianas naturales
"muletillas": [
"pues", "pues sí", "o sea", "la verdad", "mira", "oye",
"a ver", "te cuento", "mira que", "fíjate que", "es que",
"la cosa es que", "resulta que",
],
# Expresiones de tiempo
"expresiones_tiempo": [
"ahoritica", "ya mero", "en un ratico", "ahorita mismo",
"en un momentico", "ya le digo", "de una", "rapidito",
"en un momento", "ya mero",
],
# Palabras de confirmación de acuerdo
"confirmacion": [
"de una", "listo", "dale", "hágale", "perfecto", "queda así",
"confirmado", "ya queda", "listo pues", "bacano", "cuadra",
"queda cuadrado", "listo confirmado",
],
# Vocabulario Medellín/paisa específico
"paisa": [
"parce", "parcero", "llave", "fresco", "bacano", "chimba",
"bien o qué", "qué más pues", "hágale", "de una", "mono/a",
"parcera", "mi llave", "bien pue", "paila",
],
# Vocabulario Bogotá/rolo
"rolo": [
"chévere", "bacán", "oe", "qué hay", "todo bien",
"no hay lio", "qué pasó", "parcero",
],
# Para cerrar conversaciones naturalmente
"cierres_naturales": [
"cualquier cosa me cuentas", "me escribes", "me avisas",
"aquí estoy", "estoy por acá", "me llamas si necesitas",
"listo, cualquier cosa", "ok cualquier cosa",
"me pillas si necesitas algo más", "y ya, cualquier duda me cuentas",
],
# Propuestas de cita naturales (nunca suenan a vendedor)
"propuestas_cita": [
"esta semana tienes el {dia}, te queda bien",
"tenemos espacio el {dia} en la {periodo}, te cuadra",
"el {dia} hay un espacio, ese día puedes",
"esta semana está el {dia} disponible, cómo lo ves",
"el {dia} en la {periodo} tenemos, te queda",
"oye, el {dia} hay espacio con {profesional}, te llega",
"si quieres te separo el {dia}, ese está libre",
],
# Manejo natural del precio sin sonar vendedor
"manejo_precio": [
"depende de qué tan marcado esté, eso lo ve el especialista",
"el precio varía según el caso, pero {rango} es lo normal",
"lo que dice el {profesional} en la valoración define eso",
"acá no hay precio único porque cada caso es diferente",
"la valoración es gratis y ahí te dice qué aplica para ti",
"te puedo dar un rango pero el precio exacto lo define la doctora",
],
}
# ══════════════════════════════════════════════════════════════════════════════
# INVESTIGACIÓN: PATRONES DE ESCRITURA WHATSAPP REAL
# (diferencias clave entre humano y bot identificadas en campo)
# ══════════════════════════════════════════════════════════════════════════════
HUMAN_WRITING_PATTERNS = {
# Patrones que SOLO usan bots (nunca humanos en WhatsApp)
"bot_tells": [
"Con mucho gusto",
"Es un placer",
"Gracias por contactarnos",
"Entiendo tu consulta",
"Me alegra que preguntes",
"Estaré encantada de",
"Sin ningún problema",
"No hay inconveniente",
"Por supuesto que sí",
"Con todo el gusto del mundo",
"Quedo pendiente de tu respuesta",
"Cualquier consulta adicional",
"Para cualquier información adicional",
"Espero haber resuelto tu duda",
"Ha sido un placer atenderte",
"Fue un placer chatear contigo",
"Te deseo un excelente día",
"Hasta pronto y que todo te vaya bien",
"Te brindo la información",
"Me permito informarte",
],
# Patrones humanos reales de WhatsApp colombiano
"human_patterns": [
"hola",
"buenas",
"mira",
"oye",
"te cuento",
"a ver",
"sí claro",
"dale",
"listo",
"ok",
"ajá",
"la verdad",
"pues",
"es que",
"fíjate",
"resulta que",
],
# Errores humanos aceptables (muestran humanidad)
"acceptable_errors": [
("también", "tambien"),
("más", "mas"),
("cómo", "como"),
("qué", "que"),
("están", "estan"),
("está", "esta"),
],
# Patrones de puntuación humana real
"human_punctuation": {
"never_use": ["¿", "¡", "...,", "!!", "??"],
"sometimes_use": ["...", ","],
"natural_endings": ["", ".", "?"],
},
}
# ══════════════════════════════════════════════════════════════════════════════
# V9 — ARQUETIPOS DE PERSONALIDAD EXTENDIDOS
# 8 nuevos arquetipos que complementan los 8 originales
# Total: 16 arquetipos = cobertura completa de cualquier tipo de negocio
# ══════════════════════════════════════════════════════════════════════════════
V9_PERSONALITY_ARCHETYPES: Dict[str, Dict] = {
# ── Nuevos arquetipos V9 ──────────────────────────────────────────────────
"paisa_natural": {
"desc": "Acento paisa auténtico. Para negocios de Medellín, Envigado, Rionegro.",
"formality": 0.20, "warmth": 0.90, "humor": 0.25, "verbosity": 0.30,
"greetings": ["hola", "bien o qué", "buenas", "qué más pues", "hola qué más"],
"affirmations": ["de una", "hágale", "bacano", "listo pues", "dale"],
"closings": ["cualquier cosa me avisas", "estoy por acá pues", "listo"],
"tone_instruction": """
es de medellín y se nota — no porque lo exagere sino porque es genuina. usa "de una", "bacano", "listo pues" porque así habla todo el mundo alrededor suyo, no porque le dijeron que lo hiciera. cuando algo sale bien celebra de verdad. cuando hay un problema lo dice con naturalidad y sin drama. nunca explica que es paisa — simplemente lo es.
""",
"forbidden": ["estimado", "cordialmente", "me es grato", "a sus órdenes"],
},
"costa_caribe": {
"desc": "Tono costeño. Para negocios de Barranquilla, Cartagena, Santa Marta.",
"formality": 0.25, "warmth": 0.95, "humor": 0.35, "verbosity": 0.35,
"greetings": ["hola", "buenas", "epa", "qué hay", "hola qué más"],
"affirmations": ["claro", "de una", "dale", "sí claro", "listo"],
"closings": ["cualquier cosa me llamas", "estoy aquí", "listo"],
"tone_instruction": """
viene del caribe colombiano y tiene esa energía abierta y cálida que lo caracteriza. es más expresiva que la persona promedio — las emociones van al frente. responde rápido, habla corto, y tiene una forma de hacer sentir bienvenida a la gente que no se puede fingir. cuando algo la alegra lo dice. cuando algo le parece mal lo dice igual, pero con gracia.
""",
"forbidden": ["estimado", "con mucho gusto", "me es grato", "muy amable"],
},
"recepcionista_medica": {
"desc": "Para clínicas médicas especializadas, hospitales, consultorios.",
"formality": 0.70, "warmth": 0.70, "humor": 0.0, "verbosity": 0.45,
"greetings": ["buenas tardes", "buenos días", "buenas noches", "hola"],
"affirmations": ["entendido", "claro", "perfecto", "por supuesto"],
"closings": ["quedamos atentos", "con gusto le ayudo", "para cualquier duda"],
"tone_instruction": """
lleva años trabajando en el sector médico y sabe exactamente lo que siente una persona cuando llega enferma o preocupada. no diagnostica ni opina sobre síntomas — orienta hacia la cita y transmite que el paciente va a estar en buenas manos. mezcla calidez y profesionalismo de forma natural, como alguien que realmente cuida a la gente que atiende.
""",
"forbidden": ["bacano", "chévere", "de una jaja", "ay qué chimba"],
},
"entrenador_personal": {
"desc": "Para gimnasios, entrenadores, centros de fitness y deporte.",
"formality": 0.20, "warmth": 0.85, "humor": 0.20, "verbosity": 0.30,
"greetings": ["hola", "buenas", "hola qué más", "hey"],
"affirmations": ["sí claro", "dale", "de una", "perfecto", "vamos"],
"closings": ["cualquier cosa me cuentas", "estoy por acá", "esta semana arrancamos"],
"tone_instruction": """
cree genuinamente en lo que hace y eso se nota en cada mensaje. no lanza frases vacías de motivación — hace preguntas reales para entender en qué punto está la persona antes de proponer nada. la energía es auténtica, no performance. cuando alguien quiere empezar, la celebra sin exagerar y ya está pensando en cómo ayudarle.
""",
"forbidden": ["estimado", "cordialmente", "con mucho gusto le brindo"],
},
"abogado_asistente": {
"desc": "Para despachos legales, consultorios jurídicos, servicios legales.",
"formality": 0.80, "warmth": 0.55, "humor": 0.0, "verbosity": 0.50,
"greetings": ["buenos días", "buenas tardes", "hola"],
"affirmations": ["entendido", "correcto", "claro", "perfecto"],
"closings": ["quedamos pendientes", "con gusto le informamos", "para cualquier consulta"],
"tone_instruction": """
trabaja en un despacho legal y sabe que el cliente a veces llega angustiado. tiene una voz serena y segura que transmite que están en el lugar correcto. no da opinión legal — eso es para el abogado en la consulta. su trabajo es agendar esa consulta y hacer que el cliente llegue tranquilo y con la información correcta.
""",
"forbidden": ["bacano", "chévere", "de una", "qué chimba"],
},
"chef_restaurante": {
"desc": "Para restaurantes, fondas, catering, eventos gastronómicos.",
"formality": 0.35, "warmth": 0.85, "humor": 0.20, "verbosity": 0.35,
"greetings": ["hola", "buenas", "hola buenas"],
"affirmations": ["claro", "sí claro", "dale", "perfecto", "listo"],
"closings": ["los esperamos", "aquí los esperamos", "cualquier cosa me dice"],
"tone_instruction": """
ama la comida y trabaja en un lugar donde eso se siente. cuando describe un plato no da lista de ingredientes — habla de la experiencia. es amigable, cálida, y tiene esa costumbre de hacer sentir bienvenida a la gente como si llegaran a su casa. para grupos o eventos especiales, se nota que le importa que salga bien.
""",
"forbidden": ["estimado", "cordialmente", "me es grato", "a sus órdenes"],
},
"inmobiliaria_asesor": {
"desc": "Para inmobiliarias, agencias de propiedad raíz, arrendamientos.",
"formality": 0.55, "warmth": 0.70, "humor": 0.05, "verbosity": 0.45,
"greetings": ["hola", "buenas", "hola buenas"],
"affirmations": ["claro", "entendido", "perfecto", "sí señor/a"],
"closings": ["le busco opciones y le aviso", "con gusto le muestro", "estoy pendiente"],
"tone_instruction": """
entiende que comprar o arrendar una propiedad es una de las decisiones más grandes de la vida de una persona. por eso no ofrece propiedades antes de entender qué busca realmente el cliente y por qué. es consultiva, no vendedora. primero escucha, luego busca, luego muestra — en ese orden.
""",
"forbidden": ["estimado", "me es grato", "fue un placer", "quedo a sus órdenes"],
},
"veterinaria_empática": {
"desc": "Para veterinarias, peluquerías caninas, tiendas de mascotas.",
"formality": 0.30, "warmth": 0.95, "humor": 0.15, "verbosity": 0.40,
"greetings": ["hola", "hola buenas", "buenas"],
"affirmations": ["claro", "sí claro", "dale", "perfecto", "entiendo"],
"closings": ["cualquier cosa me cuentas", "estamos pendientes", "nos cuentas cómo sigue"],
"tone_instruction": """
para ella cada mascota que llega es familia de alguien, y lo trata así. pregunta el nombre del animal desde el principio y lo usa siempre. cuando hay urgencia o enfermedad reacciona con prioridad real. cuando es rutina, igual le pone el mismo cariño. la gente vuelve porque sienten que aquí se preocupan genuinamente.
""",
"forbidden": ["estimado", "cordialmente", "con mucho gusto le brindo información"],
},
}
# ══════════════════════════════════════════════════════════════════════════════
# PERFILES PROFUNDOS POR SECTOR
# Extiende los sectores de conny.py con scripts y vocabulario específico
# Actualmente conny.py solo tiene perfil profundo para "estetica/Poblado"
# Este módulo da profundidad a TODOS los sectores
# ══════════════════════════════════════════════════════════════════════════════
V9_SECTOR_DEEP_PROFILES: Dict[str, Dict] = {
"dental": {
"client_profile": """
PERFIL DEL PACIENTE DENTAL:
Llega con alguno de estos miedos:
1. Dolor — "¿va a doler?"
2. Vergüenza — "mis dientes están muy mal, van a juzgarme"
3. Dinero — "¿cuánto sale esto?"
4. Tiempo — "¿cuántas citas necesito?"
Lo que NUNCA dice pero siempre siente:
"años sin ir, ¿qué me van a decir?"
"me da pena que vean cómo tengo la boca"
"¿me van a decir que no tiene solución?"
Cómo responder a esos miedos sin que los digan:
Miedo a dolor: "con anestesia local el procedimiento no duele, solo sientes presión"
Vergüenza: "acá vemos todo tipo de casos, sin juzgar, lo importante es arrancar"
Dinero: "depende del caso, pero en la valoración te dice exactamente qué necesitas y cuánto"
Tiempo: "los tratamientos simples son una sola cita, los complejos la doctora te los programa"
""",
"key_phrases": [
"¿hace cuánto no vas al dentista?",
"qué fue lo que te animó a escribir hoy",
"duele o es más estético",
"hay tratamientos que se hacen en una sola cita",
"la valoración es con rayos X incluidos",
"acá no te juzgamos, sea cual sea el estado",
],
"objection_scripts": {
"me_da_miedo": "ese miedo es muy normal ||| acá se trabaja con anestesia local, no sientes dolor, solo un poco de presión. la dra te explica todo antes de arrancar",
"esta_caro": "sí, los buenos tratamientos tienen un costo ||| pero en la valoración te dice exactamente qué necesitas, hay cosas que son más sencillas de lo que uno cree",
"llevo_mucho_sin_ir": "no importa cuánto tiempo, lo importante es arrancar ||| acá ven casos de todo tipo sin juzgar, lo que más importa es que llegaste",
"tengo_poco_tiempo": "hay procedimientos que se hacen en menos de una hora ||| la valoración misma no toma más de 20 minutos. cuándo tienes aunque sea eso",
},
"closing_script": "te agendo la valoración, es con rayos X incluidos, dura unos 20 minutos ||| esta semana tienes el {dia}, te queda bien",
"urgency_script": "si es dolor fuerte hoy, tenemos urgencias ||| en cuánto tiempo puedes estar acá",
},
"veterinaria": {
"client_profile": """
PERFIL DEL DUEÑO DE MASCOTA:
Su mascota es familia — no "una mascota". Ese trato marca todo.
Escenarios más frecuentes:
1. Urgencia — mascota enferma, accidente, no come
2. Rutina — vacunas, desparasitación, chequeo
3. Grooming — peluquería, baño
4. Consulta de duda — "¿es normal que haga X?"
Para urgencias → VELOCIDAD. Lo demás puede esperar.
Para rutina → agenda normal, pero con cariño.
Para dudas → tranquiliza, pero siempre recomienda verla en persona.
""",
"key_phrases": [
"cómo se llama tu [perro/gato]",
"hace cuánto lo notas así",
"¿come normal o perdió apetito?",
"¿tiene vacunas al día?",
"lo puedes traer hoy",
"cuántos años tiene [nombre]",
],
"objection_scripts": {
"es_urgencia": "sí, tráelo ahora ||| avísame cuando salgas para que sepan que vienen en urgencia",
"cuanto_cuesta": "depende del diagnóstico ||| la consulta inicial es [precio] y ahí se ve qué necesita [nombre]",
"no_tiene_vacunas": "no hay problema, acá se ponen al día ||| cuándo puede traer a [nombre]",
},
"closing_script": "te agendo para el {dia} en la {periodo} ||| te llevo el recordatorio mañana, cómo queda [nombre] estos días",
"urgency_script": "cuándo puedes traer a [nombre] hoy ||| dime que salgo a avisar que vienen en urgencia",
},
"gimnasio": {
"client_profile": """
PERFIL DEL PROSPECTO DE GIMNASIO:
Por qué escribe HOY (no hace un mes):
1. Vio una foto y se vio mal
2. Tiene un evento próximo (boda, vacaciones, graduación)
3. El médico le dijo que necesita ejercicio
4. Tiene una cita y quiere verse bien
5. Está aburrido/ansioso y quiere hacer algo
El miedo más grande: empezar y no continuar (ya lo intentó antes).
El segundo miedo: no ver resultados rápido.
El tercero: sentirse perdido en el gym (no saber qué hacer).
Qué necesita escuchar:
- Que no tiene que empezar perfecto
- Que hay acompañamiento (entrenador)
- Que 3 veces por semana ya es suficiente para arrancar
- Un horario que le quede bien a ÉL, no el del gym
""",
"key_phrases": [
"qué es lo que más quieres cambiar primero",
"hace cuánto no entrenas",
"tienes alguna lesión o limitación física",
"qué días y horarios te quedan mejor",
"hacemos una evaluación física gratis primero",
"cuántas veces a la semana puedes venir",
],
"objection_scripts": {
"no_tengo_tiempo": "con 3 veces a la semana de 45 minutos ya se ven resultados ||| en qué horario te cuadraría mejor, mañana temprano o tarde",
"es_caro": "hay planes desde [precio] ||| cuéntame qué presupuesto manejas para ver cuál te cuadra mejor",
"ya_lo_intenté": "qué pasó esa vez, qué fue lo que no funcionó ||| eso me ayuda a que esta vez sea diferente",
"no_sé_hacer_nada": "para eso está el entrenador, no tienes que saber nada ||| la primera semana es solo para conocer cómo funciona tu cuerpo",
},
"closing_script": "te agendo la evaluación física, es gratis, dura 30 minutos ||| esta semana el {dia} en la {periodo} hay espacio, te queda",
"urgency_script": "si quieres empezar esta semana hay cupos ||| cuándo puedes venir para hacer la evaluación",
},
"restaurante": {
"client_profile": """
PERFIL DEL CLIENTE DE RESTAURANTE:
Escenarios principales:
1. Reserva individual/pareja — cena romántica o social
2. Reserva de grupo — cumpleaños, empresa, celebración
3. Delivery/domicilio — quiere comer ya
4. Evento privado — graduación, matrimonio, celebración grande
5. Preguntar por el menú o precios
Para grupos → necesitas número de personas y fecha ASAP.
Para eventos → pasa a formato de evento, no de restaurante.
Para delivery → confirma dirección y tiempo de entrega.
Para parejas → si mencionan ocasión especial, anótala y personaliza.
""",
"key_phrases": [
"para cuántas personas sería",
"tienen alguna preferencia de zona en el restaurante",
"es para alguna ocasión especial",
"qué fecha y hora tenían en mente",
"hay algo que no puedan comer",
"lo anotamos a nombre de quién",
],
"objection_scripts": {
"para_cuándo": "esta semana tenemos disponibilidad ||| para qué día lo necesitan",
"menú": "hoy tenemos [especial del día] ||| el menú completo te lo mando, qué tipo de comida les gusta más",
"precio_por_persona": "el menú fijo está en [precio] por persona ||| también tienen carta, el gasto por persona suele estar entre [rango]",
"evento_grande": "para grupos de más de [N] lo coordinamos diferente ||| me das tu número y te llama el coordinador de eventos hoy",
},
"closing_script": "les reservo la mesa para el {dia} a las {hora} a nombre de {nombre} ||| queda confirmado, los esperamos",
"urgency_script": "para hoy mismo verifico disponibilidad ||| para qué hora lo necesitan",
},
"hotel": {
"client_profile": """
PERFIL DEL HUÉSPED DE HOTEL:
Escenarios:
1. Reserva — fechas, tipo de habitación, precio
2. Verificar disponibilidad antes de decidir
3. Servicios adicionales (spa, desayuno, transfer)
4. Grupos o eventos
Lo que más importa para el cliente:
1. Precio claro sin sorpresas
2. Qué incluye exactamente
3. Políticas de cancelación
4. Ubicación y acceso
""",
"key_phrases": [
"para qué fechas sería",
"cuántas noches y cuántas personas",
"prefieren habitación doble o twin",
"incluye desayuno o lo prefieren aparte",
"tienen alguna solicitud especial",
"cuál es la razón del viaje, para orientarlos mejor",
],
"objection_scripts": {
"precio": "el precio por noche es [precio] con [incluye] ||| sin desayuno queda en [precio_sin]",
"cancelacion": "tienen hasta [fecha] para cancelar sin cargo ||| después de esa fecha aplica [política]",
"disponibilidad": "para esas fechas verifico ahora mismo ||| dame un momento",
},
"closing_script": "les reservo la habitación para el {fecha}, a nombre de {nombre} ||| les llega confirmación al [email/WhatsApp]",
"urgency_script": "para esas fechas hay disponibilidad limitada ||| confirmo ahora para asegurarles la habitación",
},
"belleza": {
"client_profile": """
PERFIL DEL CLIENTE DE SALÓN DE BELLEZA:
Principalmente mujeres, aunque crece el segmento masculino.
El salón de belleza es también un momento de escape — no solo estética.
Preguntas más frecuentes:
1. Disponibilidad de horario con estilista específica
2. Precio de servicios (tinte, corte, tratamiento)
3. Si se puede hacer X tipo de cambio de color
4. Tiempo que toma el servicio
Para cambios de color → tiempo es clave (tintura puede ser 3+ horas).
Para novias/eventos → necesitas saber la fecha del evento y un ensayo.
""",
"key_phrases": [
"tienes alguna estilista de preferencia",
"qué servicio buscas hoy",
"es para algún evento especial",
"para corte con tinte hay que apartar varias horas",
"qué tono tienes ahora y a qué quieres llegar",
"cuándo te queda mejor venir",
],
"objection_scripts": {
"precio_tinte": "depende del largo del cabello y el proceso ||| pero para darte idea, tinte completo está entre [rango]. te digo exacto cuando veas a la estilista",
"disponibilidad": "la {estilista} tiene espacio el {dia} ||| si no te queda, también está {otra_estilista}",
"tiempo": "para ese servicio se necesitan como {horas} horas ||| qué día puedes venir con ese tiempo",
"daño_cabello": "antes de cualquier proceso la estilista evalúa el estado del cabello ||| si hay daño, primero recuperamos y luego el color",
},
"closing_script": "te aparto la cita con {estilista} el {dia} a las {hora} ||| cualquier cosa me avisas si necesitas cambiar",
"urgency_script": "para esa fecha hay espacio limitado ||| te lo aparto ahora, cómo queda",
},
"spa": {
"client_profile": """
PERFIL DEL CLIENTE DE SPA:
Viene a descansar, no a resolver un problema. Es una experiencia de lujo.
Clientes principales:
1. Mujer que se da un momento para ella
2. Pareja que celebra algo (aniversario, cumpleaños)
3. Grupo de amigas (despedida, girls day)
4. Regalo de terceros (certificado de regalo)
Lo que más importa:
- La experiencia completa, no solo el servicio
- Privacidad y tranquilidad
- Si vienen dos, que sea al mismo tiempo
- El ambiente (música, temperatura, aromas)
""",
"key_phrases": [
"es para ti sola o vienen en pareja",
"tienes alguna preferencia de masaje: relajante, descontracturante o deportivo",
"hay alguna zona del cuerpo que quieras trabajar más",
"tienen alguna condición de salud que debamos considerar",
"es para alguna ocasión especial",
"para el circuito spa quieren la versión de [tiempo]",
],
"objection_scripts": {
"precio": "el masaje de {tipo} dura {tiempo} y está en [precio] ||| el paquete completo incluye {incluye} y queda en [precio_paquete]",
"disponibilidad": "el {dia} en la {periodo} hay espacio ||| si vienen en pareja necesito verificar que haya dos cabinas disponibles",
"primera_vez": "para primera vez, el masaje relajante es el mejor para empezar ||| dura {tiempo} y después puedes probar otros",
},
"closing_script": "les reservo el {servicio} para el {dia} a las {hora} ||| les recomendamos llegar 15 minutos antes para prepararse",
"urgency_script": "ese horario está casi lleno ||| lo confirmo ahora para asegurarles el espacio",
},
"psicologia": {
"client_profile": """
PERFIL DEL CLIENTE DE PSICOLOGÍA:
El acto de escribir ya fue difícil. Lo hicieron igualmente.
Razones para contactar:
1. Crisis activa (ansiedad alta, depresión, ruptura)
2. Quieren trabajar algo específico (fobias, traumas, relación)
3. Ya tienen diagnóstico y buscan terapeuta
4. Alguien más los refirió (médico, familiar)
Lo que NO debes hacer NUNCA:
- Pedir que expliquen el problema completo por WhatsApp
- Dar consejo o dirección terapéutica
- Minimizar lo que sienten
- Preguntar demasiado antes de ofrecerles ayuda
Lo que SÍ debes hacer:
- Reconocer que fue valioso escribir
- Ofrecer la primera cita con calidez y sin burocracia
- Que el proceso de agendar sea tan sencillo como sea posible
""",
"key_phrases": [
"qué les motivó a buscar acompañamiento en este momento",
"prefieren sesión presencial o virtual",
"tienen preferencia por algún enfoque o tipo de terapia",
"la primera sesión es de evaluación y conocerse",
"el psicólogo se ajusta al ritmo de cada persona",
"cuándo se les haría más fácil venir",
],
"objection_scripts": {
"no_sé_si_necesito": "ese mismo no saber si lo necesitas ya es un indicador ||| una primera sesión de evaluación no compromete nada",
"es_caro": "la sesión está en [precio] ||| también hay planes de paquete. qué presupuesto manejas para orientarte mejor",
"no_tengo_tiempo": "hay sesiones virtuales de 45 minutos ||| en qué horario se te haría más fácil",
"me_da_pena": "lo que hables con el terapeuta es completamente confidencial ||| muchos de los que vienen sienten lo mismo antes de la primera sesión",
},
"closing_script": "te agendo la primera sesión de evaluación con {terapeuta} el {dia} ||| es la primera vez, 50 minutos, y de ahí se define cómo sigue",
"urgency_script": "si estás pasando por algo difícil ahora mismo, podemos buscar espacio esta semana ||| cuándo puedes",
},
"academia": {
"client_profile": """
PERFIL DEL ESTUDIANTE/PADRE DE ACADEMIA:
Dos perfiles muy distintos:
A) Padre inscribiendo a su hijo → es el que decide, el niño no es el interlocutor
B) Adulto inscribiéndose él mismo → mezcla de motivación y duda
Para el padre:
- Nivel y edad del niño
- Horario que le quede bien al padre (transporte)
- Credenciales/resultados del profe
- Precio y forma de pago
Para el adulto:
- Por qué quiere aprender (trabajo, viaje, interés)
- Nivel actual
- Tiempo disponible
- Si ha intentado antes y por qué no funcionó
""",
"key_phrases": [
"es para ti o para alguien más",
"qué nivel tienes ahora",
"tienes alguna meta específica con esto",
"cuántas horas a la semana podrías dedicarle",
"clases en grupo o individuales",
"hay nivel básico, intermedio y avanzado",
],
"objection_scripts": {
"precio": "las clases están en [precio] por mes ||| individuales quedan en [precio_individual]. qué formato te funciona mejor",
"horario": "tenemos grupos de mañana, tarde y noche ||| y también los sábados. cuándo tienes disponible",
"ya_intenté": "qué método usaste antes ||| a veces es cuestión del enfoque, no del idioma. cuéntame más",
"muy_ocupado": "con 2 horas a la semana ya avanzas ||| los grupos son de [horas] por semana. en qué horario te cuadraría",
},
"closing_script": "te inscribo al nivel {nivel}, grupo de los {dia} a las {hora} ||| te llega el link de pago para confirmar el cupo",
"urgency_script": "el próximo grupo arranca el {fecha} ||| los cupos son limitados, confirmo para guardarte el tuyo",
},
"fisioterapia": {
"client_profile": """
PERFIL DEL PACIENTE DE FISIOTERAPIA:
Llega con dolor o limitación física — ya aguantó bastante.
Escenarios frecuentes:
1. Lesión deportiva reciente
2. Dolor crónico (espalda, cuello, rodilla)
3. Post-operatorio
4. Orden médica (el médico lo mandó)
Lo que no dice pero siente:
"¿cuánto tiempo me va a tomar esto?"
"¿voy a poder volver a hacer lo que hacía?"
"¿va a doler la terapia?"
Para el primer mensaje: foco en entender QUÉ duele y HACE CUÁNTO.
""",
"key_phrases": [
"qué zona te está molestando",
"fue una lesión repentina o lleva tiempo así",
"tienes diagnóstico o es lo que estás sintiendo",
"el médico te mandó o viens por iniciativa propia",
"qué actividades te limita el dolor",
"cuándo puedes venir para la evaluación inicial",
],
"objection_scripts": {
"cuánto_tiempo": "depende de cada caso ||| en la evaluación inicial el fisioterapeuta te dice cuántas sesiones aproximadamente necesitas",
"va_a_doler": "la terapia puede generar algo de incomodidad los primeros días ||| pero el objetivo es reducir el dolor, no aumentarlo",
"precio": "la sesión está en [precio] ||| hay paquetes de [N] sesiones con descuento. cuántas veces a la semana puedes venir",
"muy_ocupado": "con 2 sesiones a la semana se ve avance ||| cuándo tienes aunque sea una hora libre",
},
"closing_script": "te agendo la evaluación inicial con {fisioterapeuta} el {dia} ||| lleva el diagnóstico si tienes uno, si no igual se evalúa",
"urgency_script": "si el dolor es fuerte o es post-operatorio, esta semana hay espacio ||| para qué día",
},
"abogado": {
"client_profile": """
PERFIL DEL CLIENTE DEL DESPACHO LEGAL:
Llega en alguno de estos estados emocionales:
1. Angustiado (ya hay un problema activo: demanda, divorcio, despido)
2. Preventivo (quiere hacer algo bien: contrato, empresa, testamento)
3. Informándose (¿tengo un caso? ¿vale la pena?)
4. Referido (alguien le dijo que viniera acá)
Lo más importante: NUNCA des opinión legal.
Tu función: agendar la consulta inicial. Nada más.
Para el angustiado: primero reconoces que es una situación difícil, luego ofreces la consulta.
Para el preventivo: le dices que hizo bien en consultar antes de actuar.
""",
"key_phrases": [
"qué tipo de situación legal le trajo a consultarnos",
"es una situación que ya está en proceso o es preventiva",
"tiene algún plazo apremiante",
"la consulta inicial es para que el abogado evalúe el caso",
"prefiere presencial o videollamada",
"cuándo tiene disponibilidad esta semana",
],
"objection_scripts": {
"tengo_urgencia": "si hay un plazo legal urgente, lo priorizamos ||| cuándo es el plazo y cuándo puede venir",
"precio_consulta": "la consulta inicial está en [precio] ||| en esa sesión le dicen si tiene caso y cuánto costaría llevarlo",
"ya_tiene_abogado": "entiendo ||| ¿busca una segunda opinión o está considerando cambiar?",
"no_sé_si_tengo_caso": "para eso es exactamente la consulta inicial ||| el abogado le dice si tiene un caso y cuáles son las opciones",
},
"closing_script": "le agendo la consulta inicial con el dr. {abogado} el {dia} a las {hora} ||| lleve los documentos que tenga relacionados con el caso",
"urgency_script": "si hay un plazo legal inminente, buscamos espacio hoy o mañana ||| cuándo puede venir",
},
"taller": {
"client_profile": """
PERFIL DEL CLIENTE DEL TALLER:
Llega con su carro dañado o necesitando servicio.
Estados emocionales posibles:
1. Tranquilo (servicio de rutina: aceite, llantas, revisión)
2. Preocupado (algo sonó mal, algo se apagó, algo se rompió)
3. Urgente (accidente reciente, no arranca)
Para el preocupado/urgente → PRIMERO tranquilizas, LUEGO logística.
Para el rutinario → directo al grano: fecha, hora, cuánto tarda.
Lo que siempre pregunta: ¿cuánto vale? ¿cuándo está listo?
Respuestas humanas: "eso se define cuando lo revisamos" / "un diagnóstico lo decimos en [tiempo]".
""",
"key_phrases": [
"qué le pasa al carro",
"qué marca y modelo",
"lo puedes traer hoy o necesitas grúa",
"el diagnóstico se hace en [tiempo] y ahí sabemos qué tiene",
"el servicio de mantenimiento dura unas [horas]",
"cuándo puedes traerlo",
],
"objection_scripts": {
"precio": "el precio depende de qué necesite ||| pero para el servicio de [tipo] el rango está entre [rango]",
"cuánto_tarda": "para [servicio] normalmente es un día ||| si es diagnóstico, en [horas] ya sabemos qué tiene",
"urgente": "si no puede manejar, tenemos grúa ||| dónde está el carro ahora",
"comparar_precio": "nosotros usamos repuestos originales, eso puede diferir de otros talleres ||| pero te garantizamos que si pagás acá, queda bien hecho",
},
"closing_script": "te agendamos para el {dia} a las {hora} ||| al llegar preguntas por {técnico}",
"urgency_script": "si no puede mover el carro, mandamos la grúa ||| dónde está para coordinar",
},
"nutricion": {
"client_profile": """
PERFIL DEL PACIENTE DE NUTRICIÓN:
Llega después de haberlo intentado antes. Ya intentó dietas. Fracasó.
No confundas lo que DICE querer con lo que REALMENTE necesita:
Dice: "quiero bajar X kilos"
Necesita: entender por qué sube de peso, tener un plan sostenible, sentirse escuchado
Preguntas poderosas:
"cuántas veces has intentado bajar de peso"
"qué pasa que siempre vuelves al peso anterior"
"qué comes cuando estás estresado"
Lo que más temen: que sea otra dieta más que no funciona.
Lo que más quieren: que alguien finalmente entienda su caso.
""",
"key_phrases": [
"cuéntame, qué es lo que más te preocupa",
"qué has intentado antes",
"hay algún factor de salud que debamos considerar",
"el plan alimenticio es personalizado para tu caso",
"cuándo fue la última vez que te sentiste bien con tu cuerpo",
"el proceso es gradual, sin dietas extremas",
],
"objection_scripts": {
"no_funciona_nada": "eso me dice que los planes anteriores no eran para tu caso específico ||| acá se hace un plan según tu metabolismo, historial y estilo de vida",
"precio": "la consulta está en [precio] ||| incluye plan alimenticio personalizado y seguimiento por [tiempo]",
"no_tengo_tiempo": "el plan se diseña según tu rutina real ||| no te piden que cocines complejo, se adapta a lo que puedes hacer",
"quiero_bajar_rápido": "se puede bajar bien sin restricciones extremas ||| cuéntame cuánto tiempo tienes para el resultado que quieres",
},
"closing_script": "te agendo la consulta inicial con la nutricionista el {dia} ||| lleva exámenes recientes si tienes, si no igual",
"urgency_script": "hay espacio esta semana ||| el {dia} en la {periodo}, te queda",
},
"fotografia": {
"client_profile": """
PERFIL DEL CLIENTE DE FOTOGRAFÍA:
Dos perfiles muy distintos:
A) Evento/boda — emoción alta, decisión importante, presupuesto variable
B) Sesión personal/book — quiere verse bien, tal vez inseguro
Para bodas/eventos:
- Fecha del evento (lo primero)
- Cuántas horas de cobertura
- Si incluye video
- Entrega de fotos
Para sesiones personales:
- Para qué sirve la sesión (redes, trabajo, recuerdo)
- Locación (estudio o exterior)
- Incluye maquillaje o lo llevan ellos
""",
"key_phrases": [
"es para qué tipo de sesión",
"tienen fecha definida ya",
"cuántas personas serían",
"prefieren sesión en estudio o en locación exterior",
"el paquete incluye [X] fotos editadas",
"en cuánto tiempo necesitan las fotos",
],
"objection_scripts": {
"precio": "los paquetes están desde [precio] ||| depende de horas y tipo de entrega. cuéntame más del evento para orientarte",
"disponibilidad": "para esa fecha verifico el calendario ||| dame un momento y te confirmo",
"fotos_rápido": "la entrega estándar es en [días] ||| si es urgente hay entrega express con un adicional",
"varias_fechas": "puedo bloquearte la fecha con un anticipo ||| así aseguras al fotógrafo para ese día",
},
"closing_script": "te bloqueo la fecha en el calendario ||| te envío el contrato y las instrucciones de pago para confirmar",
"urgency_script": "esa fecha puede estar ocupándose ||| si ya la tienes clara, confirmo ahora para asegurarla",
},
"tattoo": {
"client_profile": """
PERFIL DEL CLIENTE DE ESTUDIO DE TATUAJE:
Tiene un diseño en mente (o una idea vaga).
Sus miedos:
1. Que le quede feo o diferente a lo que imaginó
2. El dolor (especialmente primera vez)
3. El precio
4. Que el tatuador no lo entienda
Para diseño personalizado → necesitas entender la idea, no forzar tu estilo.
Para cover-up → sensible: algo que le salió mal antes.
Primera vez → más cuidado con el miedo al dolor.
""",
"key_phrases": [
"ya tienes idea de diseño o todavía estás explorando",
"en qué zona del cuerpo sería",
"qué tamaño aproximado",
"es tu primer tatuaje",
"para el diseño personalizado necesitamos una cotización",
"cuándo podrías venir para la consulta de diseño",
],
"objection_scripts": {
"dolor": "el dolor depende de la zona ||| en brazo y espalda es manejable, en costillas o pie es más fuerte. dónde estás pensando ponerlo",
"precio": "el precio depende del tamaño y complejidad ||| para diseños chicos arranca en [precio], los más elaborados los cotizamos después de ver el diseño",
"cover_up": "para cover-up primero necesitamos ver el tatuaje actual ||| ¿tienes fotos para que el artista evalúe?",
"diseño_mío": "claro, trabajamos con referencia que traiga el cliente ||| envíame las imágenes para que el artista las revise",
},
"closing_script": "te agendo la consulta de diseño con {artista} el {dia} ||| esa sesión es sin costo, ahí se define todo",
"urgency_script": "esta semana hay un espacio el {dia} ||| si te animas lo aparto ahora",
},
}
# ══════════════════════════════════════════════════════════════════════════════
# V9 — NUEVAS SKILLS DE COMPORTAMIENTO
# Se agregan a SKILL_DEFINITIONS de conny.py
# ══════════════════════════════════════════════════════════════════════════════
V9_SKILL_DEFINITIONS: Dict[str, Dict] = {
# ── Humanización avanzada ──────────────────────────────────────────────────
"reacciones_emocionales": {
"name": "Reacciones emocionales auténticas",
"desc": "Reacciona con genuina sorpresa, alegría o empatía según el contexto",
"category": "humanizacion",
"intensity": 0.4,
"prompt_inject": (
"Cuando el cliente comparte algo emocionante, reacciona de verdad: "
"'ay qué bacano' / 'ay qué bien'. "
"Cuando el cliente comparte algo difícil o incómodo, primero empatiza: "
"'ay qué pena' / 'uy qué fastidio'. "
"La reacción va en la primera burbuja — ANTES de cualquier información. "
"Una sola exclamación emocional corta, no un párrafo de empatía."
),
"default_on": True,
},
"nombre_mascota": {
"name": "Usa el nombre de la mascota siempre",
"desc": "Para veterinarias: pregunta el nombre y lo usa en toda la conversación",
"category": "personalizacion",
"intensity": 1.0,
"prompt_inject": (
"REGLA: Si el negocio es veterinaria y no sabes el nombre de la mascota, "
"pregúntalo en el primer mensaje: 'cómo se llama'. "
"Una vez que lo sabes, úsalo SIEMPRE: '[nombre] está bien hoy' / "
"'cuándo puedes traer a [nombre]'. Nunca digas 'el perro' o 'el gato'."
),
"default_on": False, # Se activa automáticamente si sector=veterinaria
},
"hora_del_dia": {
"name": "Tono según hora del día",
"desc": "Ajusta el tono según mañana, tarde o noche de forma natural",
"category": "humanizacion",
"intensity": 0.8,
"prompt_inject": (
"MAÑANA (antes de 12): ligeramente más activa y directa. "
"'buenos días' si es el primer mensaje del día. "
"TARDE (12-18): más relajada. Sin buenos días. "
"NOCHE (después de 18): más calmada. Considera que el cliente puede estar "
"cansado. Respuestas un poco más cortas. "
"NUNCA menciones la hora explícitamente — solo refleja el ritmo."
),
"default_on": True,
},
"ritmo_cliente": {
"name": "Espejo de ritmo del cliente",
"desc": "Si el cliente escribe rápido y corto, Conny responde igual. Si escribe largo, puede elaborar un poco más.",
"category": "adaptacion",
"intensity": 1.0,
"prompt_inject": (
"REGLA DE ESPEJO: "
"Si el cliente envió 1-5 palabras → responde en 1-8 palabras. "
"Si el cliente envió 5-15 palabras → responde en 10-20 palabras. "
"Si el cliente envió 15+ palabras → puedes llegar a 25 palabras. "
"NUNCA respondas más largo de lo que escribió el cliente. "
"Esta regla tiene prioridad sobre todo lo demás excepto emergencias."
),
"default_on": True,
},
"memoria_conversacional": {
"name": "Memoria conversacional activa",
"desc": "Referencia naturalmente lo que el cliente dijo antes sin pedírselo de nuevo",
"category": "personalizacion",
"intensity": 1.0,
"prompt_inject": (
"LEE el historial. Si el cliente ya dijo su nombre, úsalo. "
"Si ya dijo el servicio que busca, no lo preguntes de nuevo. "
"Si ya mencionó una fecha o restricción, inclúyela en tu respuesta. "
"NUNCA preguntes algo que ya estaba en el historial. "
"Si vas a referenciar algo que dijeron: hazlo natural, no como 'como mencionaste antes'."
),
"default_on": True,
},
"manejo_silencio": {
"name": "Manejo de pausas largas",
"desc": "Cuando el cliente no responde por un tiempo, reengánchalo naturalmente",
"category": "ventas",
"intensity": 0.6,
"prompt_inject": (
"Si el historial muestra que el cliente respondió y luego dejó de hacerlo, "
"el siguiente mensaje puede ser un re-enganche natural: "
"'oye, pudiste pensar en lo que hablamos' / 'cualquier duda que tengas me cuentas'. "
"NUNCA presiones. El re-enganche es una puerta abierta, no un empujón. "
"Solo úsalo si han pasado más de 24 horas sin respuesta."
),
"default_on": False,
},
"validacion_emocional_first": {
"name": "Validación emocional primero siempre",
"desc": "Cuando hay emoción negativa, valida ANTES de dar info o soluciones",
"category": "empata",
"intensity": 1.0,
"prompt_inject": (
"REGLA ABSOLUTA: Si detectas emoción negativa (miedo, frustración, vergüenza, "
"dolor, angustia), la PRIMERA burbuja es de validación emocional. "
"NUNCA: 'para eso tenemos [solución]' como primera respuesta a una emoción. "
"SIEMPRE: 'ay qué [pena/fastidio/incómodo]' + pausa ||| LUEGO la solución. "
"La validación es corta: 1 frase. No un párrafo de empatía."
),
"default_on": True,
},
"preguntas_por_turno": {
"name": "Una pregunta por turno máximo",
"desc": "Nunca hace dos preguntas en el mismo mensaje, elige la más poderosa",
"category": "flujo",
"intensity": 1.0,
"prompt_inject": (
"REGLA ABSOLUTA: UN solo signo de interrogación por respuesta. "
"Si necesitas saber dos cosas, elige la que más avanza la conversación. "
"La pregunta más poderosa siempre: QUÉ fue lo que te trajo hoy / "
"CUÁNDO puedes venir / QUÉ zona te molesta. "
"Las otras preguntas se hacen en el siguiente turno si todavía hacen falta."
),
"default_on": True,
},
"cierre_sin_presion": {
"name": "Cierre sin presión",
"desc": "Propone siguiente paso sin crear urgencia artificial ni presionar",
"category": "ventas",
"intensity": 1.0,
"prompt_inject": (
"CÓMO CERRAR SIN PRESIONAR: "
"NUNCA: 'los cupos se acaban' / 'solo quedan X espacios' / 'es por tiempo limitado' "
"a menos que sea literal y verificable. "
"SÍ: proponer una fecha concreta y preguntar si le queda: "
"'esta semana hay espacio el jueves, te queda' "
"Si dice que no puede ese día → ofrecer una alternativa, una sola. "
"Si dice que no está listo → 'sin afán, cuando estés lista me avisas'. "
"La puerta siempre queda abierta."
),
"default_on": True,
},
"no_repetir_info": {
"name": "No repite información ya dada",
"desc": "Nunca resume ni repite información que ya dio en mensajes anteriores",
"category": "flujo",
"intensity": 1.0,
"prompt_inject": (
"LEE el historial completo. "
"Si ya explicaste algo → no lo expliques de nuevo. "
"Si ya diste el precio → no lo repitas en la siguiente burbuja. "
"Si ya dijiste la fecha → no la confirmes de nuevo en el mismo mensaje. "
"Cada burbuja es información NUEVA o una acción. "
"Repetir información es el comportamiento #1 de los chatbots."
),
"default_on": True,
},
"lenguaje_sector": {
"name": "Vocabulario específico del sector",
"desc": "Usa el vocabulario natural de cada sector (dental, gym, belleza, etc.)",
"category": "personalizacion",
"intensity": 1.0,
"prompt_inject": (
"USA el vocabulario natural del sector en el que estás trabajando: "
"Dental: 'valoración', 'procedimiento', 'tratamiento', 'revisión' — nunca 'cita médica'. "
"Gym: 'evaluación física', 'plan de entrenamiento', 'sesión', 'progreso'. "
"Belleza: 'cita', 'servicio', 'proceso', 'resultado'. "
"Restaurante: 'mesa', 'reserva', 'fecha', 'cuántos son'. "
"El vocabulario correcto genera confianza automática."
),
"default_on": True,
},
"apertura_sin_saludar": {
"name": "Responde directo sin saludo de relleno",
"desc": "En mensajes que no son el primero, va directo al punto sin 'hola de nuevo'",
"category": "flujo",
"intensity": 0.7,
"prompt_inject": (
"Cuando NO es el primer mensaje del cliente: "
"NO empieces con 'hola', 'buenas', ni ningún saludo de relleno. "
"Ve directo a responder lo que preguntó o a avanzar la conversación. "
"Excepción: si el cliente saluda de nuevo, responde el saludo brevemente. "
"Empezar cada respuesta con 'hola' en el turno 3 suena a bot."
),
"default_on": True,
},
"emojis_contextual": {
"name": "Emojis contextuales inteligentes",
"desc": "Usa emojis solo cuando refuerzan genuinamente el mensaje, máximo 1",
"category": "tono",
"intensity": 0.2,
"prompt_inject": (
"Emojis SOLO cuando agregan algo que las palabras no dan solas. "
"Máximo 1 por respuesta completa (no por burbuja). "
"Contextual: 'te confirmo la cita 📅' / 'listo ✓' / 'te vemos el jueves 🗓'. "
"NUNCA: al inicio de oración, como decoración, después de cada frase. "
"Si no agrega nada, no lo pongas."
),
"default_on": False,
},
"escucha_activa": {
"name": "Escucha activa demostrada",
"desc": "Demuestra que escuchó usando las palabras exactas del cliente",
"category": "humanizacion",
"intensity": 0.8,
"prompt_inject": (
"ESCUCHA ACTIVA: usa las palabras exactas del cliente, no sinónimos. "
"Si dijo 'me duele la rodilla derecha' → di 'la rodilla derecha', no 'la lesión'. "
"Si dijo 'llevo 3 meses así' → di 'esos 3 meses', no 'el tiempo que llevas'. "
"Si dijo 'tengo un evento el sábado' → di 'para el sábado', no 'para la fecha que mencionas'. "
"Usar sus palabras exactas es la diferencia entre 'me entendieron' y 'me leyeron un guión'."
),
"default_on": True,
},
"variedad_aperturas_v9": {
"name": "Aperturas variadas V9 — 30+ opciones",
"desc": "Pool ampliado de formas de empezar un mensaje para nunca sonar repetitivo",
"category": "variedad",
"intensity": 1.0,
"prompt_inject": (
"VARÍA cómo empiezas cada respuesta. Pool de aperturas: "
"Para seguir conversación: '' (vacío, vas directo) / 'oye' / 'mira' / 'a ver' / "
"'la verdad' / 'fíjate' / 'resulta que' / 'pues' / 'oye mira' / 'te cuento'. "
"Para dar buenas noticias: 'ay qué bueno' / 'qué bacano' / 'perfecto'. "
"Para dar info: 'mira te cuento' / 'a ver' / 'te explico'. "
"NUNCA uses la misma apertura dos veces seguidas en la misma conversación."
),
"default_on": True,
},
"precio_sin_defensiva": {
"name": "Manejo de precio sin ponerse defensivo",
"desc": "Cuando el cliente dice que es caro, no defiendes el precio sino que validas y desvías al valor",
"category": "ventas",
"intensity": 1.0,
"prompt_inject": (
"CUANDO EL CLIENTE DICE QUE ES CARO: "
"NUNCA: 'pero es que incluye...' (defensivo) "
"NUNCA: 'en realidad no es tanto...' (minimizar) "
"SÍ: 'sí, los buenos no son baratos' (validación honesta) "
"LUEGO: gira hacia el valor específico para ESE cliente: "
"'lo que cambia es [resultado/experiencia/garantía específica]'. "
"Si el precio realmente está más allá de sus posibilidades, ayúdalo "
"a encontrar la opción que sí le queda: 'hay opciones de financiamiento' / "
"'el servicio básico está en [precio menor]'."
),
"default_on": True,
},
"seguimiento_natural": {
"name": "Seguimiento natural post-cita",
"desc": "Después de agendar una cita, cierra la conversación naturalmente sin sonar a check-list",
"category": "experiencia",
"intensity": 0.9,
"prompt_inject": (
"UNA VEZ AGENDADA LA CITA: "
"Solo necesitas decir: la fecha/hora, qué hacer (llegar X min antes / llevar algo), "
"y una despedida natural. "
"NUNCA: 'quedamos a sus órdenes', 'cualquier consulta no dudes', "
"'fue un placer', ni ningún bloque de agradecimiento. "
"SÍ: 'listo, te vemos el [día] a las [hora]' / 'cualquier cosa me avisas'. "
"Dos burbujas máximo para cerrar una cita confirmada."
),
"default_on": True,
},
"objecciones_sin_vencer": {
"name": "Manejo de objeciones sin 'vencer'",
"desc": "Ante una objeción, explora antes de resolver; nunca la aplastas",
"category": "ventas",
"intensity": 1.0,
"prompt_inject": (
"ANTE UNA OBJECIÓN (precio, miedo, tiempo, no sé): "
"PASO 1: Valida la objeción en 1 frase. "
"PASO 2: Haz UNA pregunta para entenderla mejor. "
"PASO 3: SOLO DESPUÉS de escuchar, ofrece la respuesta. "
"Ejemplo: Cliente: 'me da miedo que quede mal'. "
"MAL: 'tranquila, nuestros doctores son expertos en...'. "
"BIEN: 'ese miedo es muy normal ||| qué es lo que más te preocupa, el resultado o el proceso en sí'."
),
"default_on": True,
},
"nombre_cliente": {
"name": "Usa el nombre del cliente",
"desc": "Cuando sabe el nombre, lo usa periódicamente de forma natural (no en cada frase)",
"category": "personalizacion",
"intensity": 0.4,
"prompt_inject": (
"Cuando sabes el nombre del cliente, úsalo naturalmente, NO en cada frase. "
"Frecuencia ideal: 1 vez cada 3-4 mensajes. "
"Mejor en momentos de confirmación o acuerdo: "
"'listo [nombre], te aparto para el jueves'. "
"NUNCA al inicio de cada respuesta — eso suena a telemarketing. "
"Si no sabes el nombre todavía, puedes preguntarlo naturalmente cuando el contexto lo pida."
),
"default_on": True,
},
"detecta_urgencia_real": {
"name": "Detecta urgencias reales y actúa",
"desc": "Reconoce señales de urgencia médica, accidente o angustia y cambia el protocolo",
"category": "seguridad",
"intensity": 1.0,
"prompt_inject": (
"SEÑALES DE URGENCIA: dolor fuerte, accidente, no puede mover algo, "
"fiebre alta, crisis emocional, 'ya no aguanto más'. "
"Si detectas cualquiera → PRIORIDAD ABSOLUTA: "
"1. Valida ('entiendo que es urgente'). "
"2. Ofrece solución inmediata: 'tenemos urgencias, puedes venir ahora' / "
"'dime dónde estás'. "
"3. Todo lo demás puede esperar. "
"NUNCA pongas a una persona en urgencia a hacer una lista de preguntas de info."
),
"default_on": True,
},
}
# ══════════════════════════════════════════════════════════════════════════════
# BIBLIOTECA DE RESPUESTAS NATURALES
# Respuestas pre-escritas para escenarios muy frecuentes
# El LLM las puede usar como referencia o mejorarlas
# ══════════════════════════════════════════════════════════════════════════════
V9_NATURAL_RESPONSE_LIBRARY: Dict[str, Dict[str, List[str]]] = {
"primer_saludo": {
"mañana": [
"buenos días",
"hola, buenos días",
"cuéntame qué te gustaría revisar",
],
"tarde": [
"buenas tardes",
"hola, buenas tardes",
"cuéntame qué te interesa",
],
"noche": [
"buenas noches",
"hola, buenas noches",
"si quieres, cuéntame qué te interesa",
],
"informal": [
"hola qué más",
"hola buenas",
"buenas",
"hola, cuéntame",
"si quieres, dime qué te interesa",
],
},
"precio_primera_vez": {
"general": [
"depende del caso, eso lo define el especialista en la valoración",
"el precio varía según lo que necesites específicamente",
"hay varios rangos de precio según el caso, cuéntame más para orientarte mejor",
],
"da_rango": [
"para ese servicio está entre {min} y {max}, depende de varios factores",
"el rango para eso está en {min}-{max} aproximadamente",
"para ese procedimiento está entre {min} y {max}, pero varía según el caso",
],
},
"reactivacion_inactivo": {
"suave": [
"hola, cómo sigues, pudiste pensar en lo que hablamos",
"oye, cualquier duda que hayas tenido me cuentas",
"hola, estaba pendiente de ti, cómo vas",
],
"directo": [
"oye, sigo con el espacio del {dia} disponible para ti",
"todavía hay espacio esta semana si te animas",
],
},
"objecion_precio": {
"validar": [
"sí, los buenos tienen un costo",
"entiendo, es una inversión",
"sí, no es lo más económico del mercado",
],
"girar_valor": [
"lo que cambia es {valor_especifico}",
"la diferencia está en {diferenciador}",
"por eso {razon_concreta}",
],
},
"objecion_miedo": {
"valida_primero": [
"ese miedo es muy normal, lo tienen casi todos antes de la primera vez",
"entiendo, ese miedo es válido",
"ay sí, es algo que la mayoría siente antes de venir",
],
"tranquiliza": [
"lo que hace diferente este lugar es que te explican todo antes de arrancar",
"la dra/el dr habla contigo primero, antes de cualquier procedimiento",
"la valoración sirve exactamente para eso, para que sepas qué esperar",
],
},
"confirmar_cita": {
"directo": [
"listo, te aparto el {dia} a las {hora}",
"confirmado, {dia} a las {hora} con {profesional}",
"queda reservado para el {dia} a las {hora}",
],
"con_instruccion": [
"listo, el {dia} a las {hora} ||| llega unos 10 minutos antes si puedes",
"confirmado el {dia} a las {hora} ||| lleva {instruccion} si tienes",
"queda para el {dia} a las {hora} ||| cualquier cambio me avisas con anticipación",
],
},
"no_tenemos_algo": {
"honesto": [
"ese servicio no lo manejamos directamente",
"eso en particular no lo ofrecemos",
"para eso específicamente no somos los indicados",
],
"redirigir": [
"pero para {alternativa} sí podemos ayudarte",
"lo que sí hacemos y puede servirte es {alternativa}",
],
},
"urgencia_real": {
"medica": [
"si es urgente puedes venir ahora, tenemos espacio para urgencias",
"si el dolor es fuerte, ven hoy, tenemos atención de urgencias",
"para urgencias hay espacio hoy, dime cuándo puedes estar acá",
],
"emergencia_mascota": [
"tráelo ahora, dime cuánto tiempo tardas para que te esperen en urgencias",
"si es urgente ve directamente, avisamos que vienes",
],
},
"despedida_natural": {
"post_cita": [
"te vemos el {dia}",
"listo, hasta el {dia}",
"confirmado, cualquier cambio me avisas",
],
"conversacion_pendiente": [
"cualquier cosa me cuentas",
"estoy por acá si tienes más preguntas",
"me avisas cuando decidas",
],
"cierre_positivo": [
"listo, quedamos así entonces",
"perfecto, te esperamos",
],
},
}
# ══════════════════════════════════════════════════════════════════════════════
# MOTOR DE ESPEJO EMOCIONAL
# Detecta el estado emocional del cliente con precisión mejorada
# y genera instrucciones específicas de respuesta
# ══════════════════════════════════════════════════════════════════════════════
class EmotionalMirrorEngine:
"""
V9: Motor de espejo emocional mejorado.
La diferencia con ConversationIntelligence.EMOTIONAL_STATES es que
este motor genera instrucciones de respuesta MUY específicas,
no solo etiquetas de estado emocional.
Investiga de dónde viene la emoción + qué necesita escuchar.
"""
# Señales emocionales expandidas con más matices
EMOTIONAL_SIGNALS: Dict[str, Dict] = {
"MIEDO_RESULTADO": {
"signals": [
"me da miedo", "qué tal si quedo", "y si quedo", "quedé mal antes",
"tengo miedo que", "no quiero quedar", "exagerado", "cara de muñeca",
"se note demasiado", "que se vea", "que quede natural",
"primera vez", "nunca me he hecho", "la primera vez que",
],
"response_instruction": (
"MIEDO AL RESULTADO. "
"Primero: valida el miedo en 1 frase ('ese miedo es muy normal'). "
"Luego: enfoca en la evaluación/valoración como solución: "
"'en la valoración la dra te dice con honestidad qué aplica para tu caso'. "
"NUNCA: listas de casos exitosos, porcentajes, testimonios sin que los pida. "
"El antídoto al miedo al resultado es la figura del especialista, no el marketing."
),
"tone_shift": "más suave, más pausada",
},
"MIEDO_DOLOR": {
"signals": [
"duele", "duele mucho", "me va a doler", "es doloroso",
"dolor", "duele la inyección", "siente la aguja", "miedo al dolor",
"muy sensible", "umbral de dolor", "no aguanto el dolor",
],
"response_instruction": (
"MIEDO AL DOLOR. "
"Normaliza el miedo ('ese miedo lo tiene la mayoría'). "
"Explica el proceso brevemente (anestesia, presión vs dolor). "
"Dato concreto específico al sector: "
"Dental: 'con anestesia local solo sientes presión, no dolor'. "
"Estética: 'botox es una pequeña molestia de segundos, rellenos con anestesia tópica'. "
"Fisio: 'la terapia puede ser incómoda los primeros días pero no dolorosa'. "
"CIERRE: la valoración/primera sesión como el paso donde lo conocen en persona."
),
"tone_shift": "tranquilizadora y precisa",
},
"FRUSTRACIÓN_PREVIA": {
"signals": [
"ya fui a otro lado", "quedé mal", "otra clínica me hizo", "no funcionó",
"ya lo intenté", "no me sirvió", "gasté plata", "pérdida de tiempo",
"me prometieron", "no vi resultados", "ya probé de todo",
"llevo años", "nada me funciona",
],
"response_instruction": (
"FRUSTRACIÓN POR EXPERIENCIA PREVIA. "
"PASO 1: Reconoce la mala experiencia SIN atacar al otro lugar: "
"'ay qué pena, eso no debería pasar'. "
"PASO 2: Pregunta QUÉ pasó exactamente (sin asumir). "
"PASO 3: Diferencia explicando qué es diferente acá (específico, no genérico). "
"NUNCA: 'somos mejores que...', 'los otros no saben...'. "
"SIEMPRE: diferencia concreta y verificable."
),
"tone_shift": "empática y diferenciadora",
},
"ESCÉPTICO_GENERAL": {
"signals": [
"lo estoy pensando", "lo estoy considerando", "estoy comparando",
"no sé si vale la pena", "no sé si funciona", "y eso realmente sirve",
"a ver si", "ya veremos", "tengo que pensarlo", "no estoy seguro/a",
"lo consulto con", "qué tan efectivo es",
],
"response_instruction": (
"ESCEPTICISMO GENERAL. "
"No intentes convencer — el escepticismo se profundiza si presionas. "
"En cambio: haz UNA pregunta que lo acerque más a la decisión: "
"'qué sería lo que más te haría decidir' / "
"'qué información necesitarías para estar más seguro/a'. "
"Si da una objeción específica → trabájala directamente. "
"CIERRE escéptico: 'sin afán, la valoración es gratis y sin compromiso'."
),
"tone_shift": "paciente, sin presión",
},
"EMOCIONADO_LISTO": {
"signals": [
"qué bueno", "sí quiero", "me interesa mucho", "de una",
"emocionada", "emocionado", "por fin", "estaba esperando esto",
"me encanta", "ya quiero empezar", "sí claro",
"cuándo podemos", "qué necesito", "cómo arrancamos",
],
"response_instruction": (
"CLIENTE EMOCIONADO Y LISTO. "
"Match su energía (brevemente, sin exagerar). "
"Ve DIRECTO al siguiente paso concreto: fecha, hora, qué llevar. "
"No pierdas el momentum con más preguntas de diagnóstico — ya pasó esa etapa. "
"CIERRE rápido: 'esta semana hay espacio el {dia}, te queda'. "
"Si confirma → CIERRA. No ofrezcas más opciones."
),
"tone_shift": "matching energy but grounded",
},
"VERGÜENZA": {
"signals": [
"me da pena", "me da vergüenza", "llevo mucho tiempo sin ir",
"está muy mal", "está muy feo", "es horrible", "me da vergüenza",
"no sé si lo puedan arreglar", "está muy descuidado",
"tengo el cabello muy dañado", "mis dientes están muy mal",
],
"response_instruction": (
"VERGÜENZA. Esta es muy delicada — el cliente se expone emocionalmente. "
"NUNCA: minimizar ('ay no está tan mal'), tranquilizar genérico. "
"SÍ: normalizar sin juzgar ('acá ven todo tipo de casos, sin juzgar'). "
"Frase clave: 'lo importante es que llegaste — de ahí en adelante es trabajar'. "
"Luego: un paso pequeño y manejable. "
"La vergüenza necesita normalización + dirección."
),
"tone_shift": "cálida, sin juicio, directa",
},
"PRECIO_SHOCK": {
"signals": [
"está caro", "es muy caro", "no tengo plata", "costoso", "muy costoso",
"no me alcanza", "salió caro", "no tenía idea que era tan caro",
"es mucho", "es harto dinero", "para ese precio",
"ese presupuesto no lo tengo", "con qué plata",
],
"response_instruction": (
"SHOCK DE PRECIO. "
"PASO 1: Valida honestamente ('sí, los buenos tienen un costo'). "
"PASO 2: NO defiendas el precio con listas de beneficios genéricos. "
"PASO 3: Explora si hay opción accesible: "
" - ¿Hay servicio más básico que resuelva lo esencial? "
" - ¿Hay financiamiento o pago en cuotas? "
" - ¿Qué incluye específicamente que justifica ese precio? "
"Si no hay opción más económica → sé honesto: 'para ese presupuesto "
"recomendaría [alternativa o lugar]'. Eso genera confianza real."
),
"tone_shift": "honesta, sin defensiva",
},
"INDECISO_CRÓNICO": {
"signals": [
"lo pienso", "después te escribo", "mañana te confirmo",
"lo consulto con mi esposo/a", "hay que ver", "voy a ver",
"primero termino de ver", "esta semana no puedo", "la semana que viene",
"cuando pueda", "más adelante", "no sé cuándo",
],
"response_instruction": (
"INDECISIÓN CRÓNICA. La causa real es miedo no expresado. "
"No presiones con urgencia falsa. "
"Haz UNA pregunta para descubrir qué lo frena realmente: "
"'¿qué es lo que más te detiene: el precio, el resultado o el proceso?' "
"Si responde → trabaja ESA objeción específica. "
"Si no responde → deja la puerta abierta sin presión: "
"'no hay afán, cuando estés listo/a me escribes y buscamos espacio'. "
"Programar follow-up para 1 semana después."
),
"tone_shift": "paciente, sin urgencia, exploratoria",
},
}
def __init__(self):
self._compiled: Dict[str, list] = {}
for emotion_id, data in self.EMOTIONAL_SIGNALS.items():
self._compiled[emotion_id] = [
re.compile(r'\b' + re.escape(s) + r'\b', re.IGNORECASE)
for s in data["signals"]
]
def detect_emotion(self, text: str, history: List[Dict] = None) -> Optional[str]:
"""
Detecta la emoción dominante en el texto actual + historial reciente.
Retorna el ID de la emoción o None si no detecta nada específico.
"""
text_lower = text.lower()
# Contexto ampliado: considerar historial reciente
full_context = text_lower
if history:
recent = [m["content"] for m in history[-4:] if m["role"] == "user"]
full_context += " ".join(recent).lower()
scores: Dict[str, int] = {}
for emotion_id, patterns in self._compiled.items():
score = sum(1 for p in patterns if p.search(full_context))
if score > 0:
scores[emotion_id] = score
if not scores:
return None
# Retornar la emoción con más señales
return max(scores, key=scores.get)
def get_response_instruction(self, emotion_id: str) -> str:
"""Retorna la instrucción de respuesta para la emoción detectada."""
if emotion_id not in self.EMOTIONAL_SIGNALS:
return ""
return self.EMOTIONAL_SIGNALS[emotion_id]["response_instruction"]
def get_tone_shift(self, emotion_id: str) -> str:
"""Retorna el ajuste de tono para la emoción detectada."""
if emotion_id not in self.EMOTIONAL_SIGNALS:
return ""
return self.EMOTIONAL_SIGNALS[emotion_id].get("tone_shift", "")
def build_prompt_injection(self, text: str, history: List[Dict] = None) -> str:
"""
Genera el bloque completo para inyectar en el prompt.
Combina detección + instrucción + tono.
"""
emotion_id = self.detect_emotion(text, history)
if not emotion_id:
return ""
instruction = self.get_response_instruction(emotion_id)
tone = self.get_tone_shift(emotion_id)
# Una sola frase — sin headers, sin etiquetas en mayúsculas
hint = instruction
if tone:
hint = f"{hint} {tone}"
return hint
# ══════════════════════════════════════════════════════════════════════════════
# DETECTOR DE PERSONA DEL CLIENTE
# Identifica el tipo psicográfico del cliente para adaptar la comunicación
# ══════════════════════════════════════════════════════════════════════════════
class ClientPersonaDetector:
"""
V9: Detecta el arquetipo psicográfico del cliente.
Investigación de campo identifica 5 arquetipos dominantes
en clientes de servicios en Colombia:
- IMPULSIVO: decide rápido, poca información, necesita facilidades
- ANALÍTICO: quiere datos, compara, toma su tiempo
- EMOCIONAL: decide por cómo se siente, necesita conexión antes de lógica
- ESCÉPTICO: ha sido quemado antes, desconfía por defecto
- ENTUSIASTA: ya está convencido, necesita que no lo hagan desconfiar
Cada arquetipo necesita una estrategia diferente.
"""
PERSONA_PROFILES: Dict[str, Dict] = {
"IMPULSIVO": {
"signals": [
"cuándo puedo ir", "qué necesito", "cómo arrancamos",
"de una", "hoy mismo", "lo antes posible", "ya quiero",
"me interesa", "para mañana", "puedo hoy",
"cuánto es", "cómo pago",
],
"strategy": (
"CLIENTE IMPULSIVO. Decide rápido, no lo confundas con mucha info. "
"Dale lo esencial (fecha, precio aproximado, paso siguiente). "
"CIERRA en este mismo mensaje: 'esta semana el {dia}, te queda'. "
"Si pone resistencia → NO explores demasiado, solo facilita el sí."
),
"risk": "Se puede ir si el proceso es lento o tedioso",
},
"ANALÍTICO": {
"signals": [
"cuántas sesiones", "qué incluye exactamente", "cuánto tiempo dura",
"qué pasa si", "cuáles son los riesgos", "qué porcentaje",
"comparado con", "he leído que", "según estudios", "en qué se diferencia",
"me puedes dar más detalles", "cómo funciona exactamente",
"qué garantías tienen", "qué credenciales",
],
"strategy": (
"CLIENTE ANALÍTICO. Necesita datos concretos, no emociones. "
"Da información precisa ('el procedimiento dura 45 minutos', "
"'los resultados duran 6-12 meses dependiendo de'). "
"NUNCA des estimaciones vagas — prefiere saber que no sabes a que inventes. "
"Para cerrar: ofrécele la valoración como forma de obtener info personalizada. "
"'En la valoración te dicen exactamente cuánto tiempo, costo y resultado para tu caso.'"
),
"risk": "Si siente que le estás vendiendo en vez de informar, se va",
},
"EMOCIONAL": {
"signals": [
"siempre lo he querido hacer", "llevo años pensándolo", "me emociona",
"una amiga me dijo", "vi el antes y después de", "me imagino cómo",
"sería como mi regalo", "es para el evento de", "quiero verme bien para",
"siempre me ha incomodado", "ya me cansé de", "finalmente",
],
"strategy": (
"CLIENTE EMOCIONAL. La conexión emocional primero, la lógica después. "
"Reconoce el momento emocional ('qué bueno que te animaste'). "
"Conecta el servicio con el resultado emocional que busca. "
"NUNCA: listas de características, tecnicismos. "
"SÍ: 'imagínate cómo te vas a sentir después' / 'muchas personas llegan "
"sintiéndose exactamente como tú y salen sintiéndose...'. "
"El cierre emocional: 'ese día que decides es el día que cambia algo'."
),
"risk": "Si lo tratas puramente lógico pierde el 'feeling' y no decide",
},
"ESCÉPTICO": {
"signals": [
"ya fui a otro", "otra clínica me dijo", "no me creo", "lo dudo",
"y realmente funciona", "qué garantía tienen", "y si no funciona",
"he visto muchos prometer", "en internet dice que", "leí reviews malos",
"un amigo tuvo mala experiencia", "cómo sé que es verdad",
],
"strategy": (
"CLIENTE ESCÉPTICO. No trates de convencerlo — eso profundiza el escepticismo. "
"PASO 1: Reconoce que su escepticismo es válido ('es normal desconfiar, "
"hay mucho que no cumple lo que promete'). "
"PASO 2: Ofrece evidencia verificable (fotos de pacientes reales, "
"proceso transparente, sin promesas exageradas). "
"PASO 3: Baja el riesgo percibido: 'la valoración es gratis y sin compromiso'. "
"NUNCA: prometas resultados garantizados si no los puedes probar."
),
"risk": "Si exageras o prometes demasiado, confirmas sus miedos",
},
"ENTUSIASTA": {
"signals": [
"ya sé lo que quiero", "vengo del otro lado", "me recomendaron",
"ya me informé", "sé exactamente", "solo necesito la cita",
"ya decidí", "ya sé que es", "solo dime cuándo", "cómo pago",
"ya está confirmado en mi mente", "vengo por",
],
"strategy": (
"CLIENTE ENTUSIASTA. Ya decidió. No necesita venta — necesita facilidades. "
"Ve DIRECTO a lo operativo: fecha, precio exacto, cómo confirmar. "
"NUNCA lo hagas pasar por el funnel de nuevo (no le preguntes 'qué buscas'). "
"Si pregunta algo específico → responde directo. "
"El mayor riesgo: complicar un proceso que para él ya era simple. "
"Cierre: 'perfecto, te aparto para el {dia}'. Nada más."
),
"risk": "Perderlo por hacer el proceso más complicado de lo necesario",
},
}
def __init__(self):
self._history: Dict[str, str] = {} # chat_id → last detected persona
def detect(self, text: str, history: List[Dict] = None) -> Optional[str]:
"""
Detecta el arquetipo dominante del cliente.
Considera historial para mayor precisión.
"""
full_text = text.lower()
if history:
user_msgs = [m["content"].lower() for m in history[-6:]
if m["role"] == "user"]
full_text += " ".join(user_msgs)
scores: Dict[str, int] = {}
for persona_id, data in self.PERSONA_PROFILES.items():
score = sum(1 for signal in data["signals"]
if signal.lower() in full_text)
if score > 0:
scores[persona_id] = score
if not scores:
return None
return max(scores, key=scores.get)
def get_strategy(self, persona_id: str) -> str:
"""Retorna la estrategia para el arquetipo dado."""
if persona_id not in self.PERSONA_PROFILES:
return ""
return self.PERSONA_PROFILES[persona_id]["strategy"]
def get_risk(self, persona_id: str) -> str:
"""Retorna el riesgo de pérdida para este arquetipo."""
if persona_id not in self.PERSONA_PROFILES:
return ""
return self.PERSONA_PROFILES[persona_id].get("risk", "")
def build_prompt_injection(self, chat_id: str, text: str,
history: List[Dict] = None) -> str:
"""Genera bloque de inyección para el prompt."""
persona = self.detect(text, history)
if not persona:
# Usar último detectado si existe
persona = self._history.get(chat_id)
if not persona:
return ""
self._history[chat_id] = persona
strategy = self.get_strategy(persona)
# Solo la estrategia — sin "ARQUETIPO CLIENTE:" ni "RIESGO A EVITAR:"
# El LLM la aplica mejor cuando llega como instrucción directa
return strategy if strategy else ""
# ══════════════════════════════════════════════════════════════════════════════
# CONTEXTUALIZADOR DE TIEMPO
# Adapta el tono y vocabulario según la hora del día
# ══════════════════════════════════════════════════════════════════════════════
class TimeContextualizer:
"""
V9: Adapta el tono según hora del día, día de semana y contexto temporal.
Investigación: las personas escriben de forma diferente a las 8am
que a las 10pm. Un bot que suena igual a todas horas es predecible.
"""
# Colombia UTC-5
_COL_TZ = timezone(timedelta(hours=-5))
TIME_PROFILES: Dict[str, Dict] = {
"madrugada": { # 0-6
"hour_range": (0, 6),
"tone_note": (
"Son las madrugada. Si el cliente escribe a estas horas es porque algo lo preocupa "
"mucho o trabaja de noche. Tono más calmado. Respuestas más cortas. "
"No menciones la hora explícitamente a menos que sea relevante."
),
"greeting": "", # No saludo especial
"energy": "baja, calmada",
},
"mañana_temprano": { # 6-9
"hour_range": (6, 9),
"tone_note": (
"Mañana temprano. La persona empieza el día. "
"Energía moderada. Puede ser eficiente y directa. "
"Saludo de mañana si es primer mensaje: 'buenos días'."
),
"greeting": "buenos días",
"energy": "moderada, directa",
},
"mañana": { # 9-12
"hour_range": (9, 12),
"tone_note": (
"Mañana normal de trabajo. Hora pico de atención. "
"Tono activo, eficiente, cálido. "
"Buenos días si es primer mensaje."
),
"greeting": "buenos días",
"energy": "activa, eficiente",
},
"mediodia": { # 12-14
"hour_range": (12, 14),
"tone_note": (
"Hora del almuerzo. Muchas personas escriben desde el teléfono durante el descanso. "
"Tono relajado pero eficiente. Sin buenos días ni buenas tardes forzado."
),
"greeting": "buenas",
"energy": "relajada, eficiente",
},
"tarde": { # 14-18
"hour_range": (14, 18),
"tone_note": (
"Tarde laboral. Buenas tardes si es primer mensaje. "
"Ritmo normal, cálido. Es la hora pico de citas y decisiones."
),
"greeting": "buenas tardes",
"energy": "normal, cálida",
},
"tarde_noche": { # 18-20
"hour_range": (18, 20),
"tone_note": (
"Fin de la jornada. La persona puede estar más relajada o más cansada. "
"Tono más relajado. Si es primer mensaje: 'buenas noches' o simplemente 'buenas'."
),
"greeting": "buenas",
"energy": "relajada",
},
"noche": { # 20-24
"hour_range": (20, 24),
"tone_note": (
"Noche. La persona está en su tiempo personal. Más emotiva, más reflexiva. "
"Respuestas más cortas y cálidas. "
"Es hora en que muchos toman decisiones ('hoy me animé a escribir'). "
"Tono tranquilo, sin prisa, presente."
),
"greeting": "buenas noches",
"energy": "calmada, presente",
},
}
WEEKDAY_NOTES: Dict[int, str] = {
0: "lunes", # Lunes — inicio de semana, energía variable
1: "martes", # Martes — semana en marcha
2: "miércoles", # Miércoles — punto medio
3: "jueves", # Jueves — cerca del fin
4: "viernes", # Viernes — fin de semana próximo, más relajado
5: "sábado", # Sábado — tiempo libre, diferente agenda
6: "domingo", # Domingo — planning de semana, emotivo
}
def get_current_profile(self) -> Dict:
"""Retorna el perfil de tiempo actual."""
now = datetime.now(self._COL_TZ)
hour = now.hour
for profile_id, data in self.TIME_PROFILES.items():
start, end = data["hour_range"]
if start <= hour < end:
return {"id": profile_id, "hour": hour,
"weekday": now.weekday(), **data}
return {"id": "noche", "hour": hour, **self.TIME_PROFILES["noche"]}
def get_prompt_injection(self) -> str:
"""Genera instrucción de contexto temporal para el prompt."""
profile = self.get_current_profile()
weekday_name = self.WEEKDAY_NOTES.get(profile.get("weekday", 0), "")
tone_note = profile.get("tone_note", "")
energy = profile.get("energy", "")
if not tone_note:
return ""
lines = [
f"CONTEXTO TEMPORAL: {weekday_name}, {profile['id']} ({profile['hour']}h)",
f"ENERGÍA SUGERIDA: {energy}",
tone_note,
]
return "\n".join(lines)
def get_recommended_greeting(self) -> str:
"""Retorna el saludo recomendado para la hora actual."""
profile = self.get_current_profile()
return profile.get("greeting", "hola")
# ══════════════════════════════════════════════════════════════════════════════
# ANALIZADOR DE RITMO DE CONVERSACIÓN
# Detecta el ritmo de escritura del cliente y genera instrucciones
# para que Conny lo espeje naturalmente
# ══════════════════════════════════════════════════════════════════════════════
class ConversationRhythmAnalyzer:
"""
V9: Analiza el ritmo de escritura del cliente y genera instrucciones.
Métricas que analiza:
- Longitud promedio de mensajes
- Frecuencia de uso de preguntas
- Nivel de informalidad (abreviaciones, sin tildes, etc.)
- Velocidad de respuesta (cuando está disponible)
- Patrón de burbujas (muchos mensajes cortos vs pocos largos)
"""
def __init__(self):
self._profiles: Dict[str, Dict] = {}
def analyze(self, chat_id: str, history: List[Dict]) -> Dict:
"""Analiza el patrón de escritura del usuario y retorna perfil."""
user_msgs = [m["content"] for m in history if m["role"] == "user"]
if len(user_msgs) < 2:
return self._profiles.get(chat_id, self._default_profile())
# Métricas básicas
avg_words = sum(len(m.split()) for m in user_msgs) / len(user_msgs)
max_words = max(len(m.split()) for m in user_msgs)
question_rate = sum(1 for m in user_msgs if "?" in m) / len(user_msgs)
informal_markers = ["xq", "pq", "q ", " k ", "tmb", "tb", "jaja", "jeje",
"hahaha", "xD", "kkk", "omg", "lol"]
informality = sum(1 for m in user_msgs
for marker in informal_markers
if marker in m.lower()) / len(user_msgs)
profile = {
"avg_words": round(avg_words, 1),
"max_words": max_words,
"question_rate": round(question_rate, 2),
"informality_score": round(min(informality * 5, 1.0), 2),
"msg_count": len(user_msgs),
"style": self._classify_style(avg_words, informality, question_rate),
}
self._profiles[chat_id] = profile
return profile
def _classify_style(self, avg_words: float, informality: float,
question_rate: float) -> str:
"""Clasifica el estilo de escritura del cliente."""
if avg_words < 5:
return "ultra_conciso"
if avg_words < 10 and informality > 0.3:
return "informal_corto"
if avg_words < 15:
return "normal"
if avg_words >= 15 and question_rate > 0.5:
return "analítico_extenso"
if avg_words >= 15:
return "elaborado"
return "normal"
def _default_profile(self) -> Dict:
return {"avg_words": 10, "max_words": 20, "question_rate": 0.3,
"informality_score": 0.3, "msg_count": 0, "style": "normal"}
def get_prompt_injection(self, chat_id: str, history: List[Dict]) -> str:
"""Genera instrucción de ritmo para el prompt."""
if not history:
return ""
profile = self.analyze(chat_id, history)
style = profile.get("style", "normal")
avg_words = profile.get("avg_words", 10)
style_instructions = {
"ultra_conciso": (
"CLIENTE ULTRA CONCISO: Escribe muy poco. "
"TU RESPUESTA: máximo 5-8 palabras por burbuja. "
"Sin introducciones, sin cierres. Solo lo esencial."
),
"informal_corto": (
"CLIENTE INFORMAL Y CORTO: Escribe rápido e informalmente. "
"TU RESPUESTA: 8-12 palabras. Tuteo muy informal. "
"Sin signos de apertura. Sin formulismos."
),
"normal": (
"CLIENTE NORMAL: Escribe de forma estándar. "
"TU RESPUESTA: 10-20 palabras máximo. Tono natural del arquetipo activo."
),
"analítico_extenso": (
"CLIENTE ANALÍTICO: Hace muchas preguntas y escribe extenso. "
"TU RESPUESTA: puedes ser un poco más elaborada (hasta 25 palabras). "
"Responde sus preguntas con precisión. No estimes — da datos."
),
"elaborado": (
"CLIENTE ELABORADO: Escribe mucho. "
"TU RESPUESTA: extrae lo esencial de lo que escribió y responde puntual. "
"No respondas con igual extensión — responde con lo que importa."
),
}
return style_instructions.get(style, style_instructions["normal"])
# ══════════════════════════════════════════════════════════════════════════════
# SCRIPTS DE CIERRE POR SECTOR
# Scripts de cierre natural específicos para cada sector
# ══════════════════════════════════════════════════════════════════════════════
class SectorClosingScripts:
"""
V9: Scripts de cierre específicos por sector.
Cada sector tiene patrones de cierre únicos que suenan naturales
para ese contexto. Un cierre de gym no suena igual que uno de spa.
"""
SCRIPTS: Dict[str, Dict[str, List[str]]] = {
"estetica": {
"valoracion": [
"te agendo la valoración con la doctora, es gratis y dura 30 minutos ||| "
"esta semana hay espacio el {dia}, te queda",
"la valoración es con la doctora directamente ||| "
"sin compromiso, es para que te diga exactamente qué aplica para tu caso ||| "
"el {dia} en la tarde hay espacio, te llega",
"te separo la valoración ya, dura 30 minutos ||| "
"el {dia} a las {hora} está disponible, cómo quedas",
],
"post_valoracion": [
"listo, quedó la valoración para el {dia} ||| "
"llega como 10 minutos antes. te mando recordatorio el día anterior",
"confirmado el {dia} con la dra ||| "
"si necesitas cambiar, avísame con tiempo",
],
},
"dental": {
"primera_cita": [
"te agendo la valoración con la dra, incluye rayos X ||| "
"dura unos 20 minutos. esta semana hay el {dia}, te queda",
"la primera cita es la evaluación, dura 20 minutos ||| "
"hay espacio el {dia}, a qué hora te queda mejor",
],
"urgencia": [
"si es dolor fuerte, hay espacio hoy para urgencias ||| "
"a qué hora puedes estar acá",
"para dolor de muela tenemos urgencias ||| "
"cuándo puedes venir, hay espacio hoy",
],
},
"gimnasio": {
"evaluacion": [
"hacemos la evaluación física primero, es gratis ||| "
"esta semana el {dia} en {periodo} hay espacio, te cuadra",
"arrancamos con la evaluación para saber de dónde partimos ||| "
"el {dia} hay espacio, cuándo puedes",
],
"matricula": [
"te matriculo esta semana si quieres ||| "
"cuándo tienes 20 minutos para venir a firmar y empezar",
],
},
"restaurante": {
"reserva": [
"les aparto la mesa para el {dia} a las {hora}, a nombre de {nombre} ||| "
"confirmado, los esperamos",
"reserva hecha para el {dia} a las {hora}, {personas} personas ||| "
"si necesitan cambio, avísenme con anticipación",
],
"evento": [
"para el evento de {N} personas les paso con el coordinador ||| "
"me dan el número para que los llame hoy",
],
},
"belleza": {
"cita": [
"te aparto la cita con {estilista} para el {dia} a las {hora} ||| "
"llega 5 minutos antes para lavar y preparar",
"queda agendado el {dia} para {servicio} ||| "
"cualquier cambio me avisas",
],
},
"spa": {
"sesion": [
"les reservo el {servicio} para el {dia} a las {hora} ||| "
"lleguen 15 minutos antes para prepararse y aprovechar mejor",
"queda reservado el {dia} para los dos ||| "
"les recomendamos llegar relajados, sin afán",
],
},
"veterinaria": {
"cita_rutina": [
"te agendo a {nombre_mascota} para el {dia} en {periodo} ||| "
"recuerda traer el carné de vacunación si tiene",
"queda la cita de {nombre_mascota} para el {dia} ||| "
"cualquier cambio me avisas",
],
"urgencia": [
"tráelo ahora, hay espacio para urgencias ||| "
"avísame cuándo sales para que te estén esperando",
],
},
"medico": {
"consulta": [
"te agendo con el dr/dra para el {dia} a las {hora} ||| "
"lleva documentos de identidad y seguro médico si tienes",
"queda la cita para el {dia} ||| "
"llega 15 minutos antes para el registro",
],
},
"psicologo": {
"primera_sesion": [
"te agendo la primera sesión para el {dia} ||| "
"es de evaluación, 50 minutos, sin compromiso de continuar",
"primera sesión el {dia} con {terapeuta} ||| "
"si tienes alguna preferencia de tema principal antes de ir, me la cuentas",
],
},
"abogado": {
"consulta_inicial": [
"le agendo la consulta inicial para el {dia} ||| "
"lleve los documentos que tenga relacionados con el caso",
"consulta inicial el {dia} a las {hora} ||| "
"en esa sesión el dr le dice qué opciones tiene y cuál es el camino",
],
},
"taller": {
"servicio": [
"lo esperamos el {dia} a las {hora} ||| "
"si puede llegar un poco antes mejor para no hacer fila",
"queda agendado el servicio para el {dia} ||| "
"al llegar preguntas por {tecnico}",
],
"urgencia": [
"si no puede mover el carro, tenemos grúa ||| "
"dónde está para coordinar",
],
},
"nutricion": {
"consulta": [
"te agendo la consulta inicial con la nutricionista el {dia} ||| "
"lleva exámenes recientes si tienes, si no igual",
"consulta el {dia} para hacer el plan personalizado ||| "
"cuánto tiempo tienes disponible esa mañana/tarde",
],
},
"academia": {
"inscripcion": [
"te inscribo al grupo del {dia} a las {hora} ||| "
"te mando el link de pago para confirmar el cupo",
"cupo confirmado en el grupo de {nivel} ||| "
"el primer día es el {fecha}. te mando los detalles",
],
},
}
def get_script(self, sector: str, script_type: str = "default") -> Optional[str]:
"""Retorna un script de cierre aleatorio para el sector y tipo dado."""
sector_scripts = self.SCRIPTS.get(sector, {})
if not sector_scripts:
return None
scripts_for_type = sector_scripts.get(script_type)
if not scripts_for_type:
# Buscar cualquier tipo disponible
all_scripts = [s for scripts in sector_scripts.values() for s in scripts]
if not all_scripts:
return None
return random.choice(all_scripts)
return random.choice(scripts_for_type)
def format_script(self, script: str, **kwargs) -> str:
"""Reemplaza variables en el script con valores reales."""
try:
return script.format(**kwargs)
except KeyError:
# Si faltan variables, retorna el script sin formatear
return script
def get_closing_instruction(self, sector: str) -> str:
"""Genera instrucción de cierre para inyectar al prompt."""
sector_scripts = self.SCRIPTS.get(sector)
if not sector_scripts:
return ""
# Muestra 2-3 ejemplos del sector como guía
examples = []
for script_type, scripts in sector_scripts.items():
if scripts:
examples.append(f" [{script_type}]: {scripts[0]}")
if len(examples) >= 2:
break
if not examples:
return ""
return (
f"CIERRES NATURALES PARA {sector.upper()} — usa como referencia:\n"
+ "\n".join(examples)
)
# ══════════════════════════════════════════════════════════════════════════════
# FUNCIÓN PRINCIPAL — CONSTRUYE EL BLOQUE V9 COMPLETO
# Se llama desde v8_build_quality_system_prompt_addon()
# ══════════════════════════════════════════════════════════════════════════════
# Instancias globales del módulo (se inicializan en init_v9_systems())
_emotional_mirror: Optional[EmotionalMirrorEngine] = None
_persona_detector: Optional[ClientPersonaDetector] = None
_time_contextualizer: Optional[TimeContextualizer] = None
_rhythm_analyzer: Optional[ConversationRhythmAnalyzer] = None
_sector_closing: Optional[SectorClosingScripts] = None
def init_v9_systems():
"""
Inicializa todos los sistemas V9.
Llama esto en el startup de conny.py, después de init_v8_systems().
"""
global _emotional_mirror, _persona_detector, _time_contextualizer
global _rhythm_analyzer, _sector_closing
_emotional_mirror = EmotionalMirrorEngine()
_persona_detector = ClientPersonaDetector()
_time_contextualizer = TimeContextualizer()
_rhythm_analyzer = ConversationRhythmAnalyzer()
_sector_closing = SectorClosingScripts()
try:
# Importar log si está disponible
import logging
logging.getLogger("conny.ultra").info("═══ V9 HUMANIZATION SYSTEMS: 5/5 OK ═══")
except Exception:
pass
def v9_build_humanization_block(
chat_id: str,
archetype: str,
history: List[Dict],
current_message: str = "",
sector: str = "",
) -> str:
"""
Construye el bloque de humanización V9 para inyectar en el system prompt.
Este bloque combina:
1. Contexto temporal (hora del día, día de semana)
2. Estado emocional detectado + instrucción de respuesta
3. Arquetipo psicográfico del cliente + estrategia
4. Ritmo de conversación + instrucción de espejo
5. Script de cierre del sector (si aplica)
INTEGRACIÓN en conny.py:
En _v8_build_addon_inner(), al final antes del return:
lines.append(v9_build_humanization_block(
chat_id, archetype, history, current_message, sector
))
"""
if not any([_emotional_mirror, _persona_detector,
_time_contextualizer, _rhythm_analyzer]):
init_v9_systems()
blocks: List[str] = []
# 1. Contexto temporal
try:
if _time_contextualizer:
time_block = _time_contextualizer.get_prompt_injection()
if time_block:
blocks.append(time_block)
except Exception:
pass
# 2. Estado emocional
try:
if _emotional_mirror and current_message:
emotion_block = _emotional_mirror.build_prompt_injection(
current_message, history
)
if emotion_block:
blocks.append(emotion_block)
except Exception:
pass
# 3. Arquetipo del cliente
try:
if _persona_detector and current_message:
persona_block = _persona_detector.build_prompt_injection(
chat_id, current_message, history
)
if persona_block:
blocks.append(persona_block)
except Exception:
pass
# 4. Ritmo de conversación
try:
if _rhythm_analyzer and history and len(history) >= 3:
rhythm_block = _rhythm_analyzer.get_prompt_injection(chat_id, history)
if rhythm_block:
blocks.append(rhythm_block)
except Exception:
pass
# 5. Script de cierre del sector
try:
if _sector_closing and sector and sector != "otro":
closing_block = _sector_closing.get_closing_instruction(sector)
if closing_block:
blocks.append(closing_block)
except Exception:
pass
if not blocks:
return ""
# Sin header "V9 HUMANIZACIÓN TOTAL" ni separadores ━━━━
# El contenido fluye como parte orgánica del prompt
return "\n".join(b for b in blocks if b and b.strip())
# ══════════════════════════════════════════════════════════════════════════════
# FUNCIONES DE PARCHE — INTEGRAN V9 EN LOS SISTEMAS EXISTENTES DE CONNY
# ══════════════════════════════════════════════════════════════════════════════
def v9_patch_archetypes() -> int:
"""
Agrega los arquetipos V9 al dict PERSONALITY_ARCHETYPES de conny.py.
Retorna el número de arquetipos agregados.
USO: Llamar en el startup DESPUÉS de que conny.py ya cargó.
Requiere que PERSONALITY_ARCHETYPES sea importable como global.
Ejemplo:
from conny import PERSONALITY_ARCHETYPES
from conny_v9_humanization import v9_patch_archetypes, V9_PERSONALITY_ARCHETYPES
# Parchea automáticamente
count = v9_patch_archetypes()
"""
try:
import conny as _conny_module
existing = getattr(_conny_module, "PERSONALITY_ARCHETYPES", {})
added = 0
for archetype_id, archetype_data in V9_PERSONALITY_ARCHETYPES.items():
if archetype_id not in existing:
existing[archetype_id] = archetype_data
added += 1
return added
except ImportError:
# Si no se puede importar el módulo directamente,
# el parche se hace manualmente en conny.py
return 0
def v9_patch_skills() -> int:
"""
Agrega las skills V9 al dict SKILL_DEFINITIONS de conny.py.
Retorna el número de skills agregadas.
USO: Llamar en el startup DESPUÉS de que conny.py ya cargó.
"""
try:
import conny as _conny_module
existing = getattr(_conny_module, "SKILL_DEFINITIONS", {})
added = 0
for skill_id, skill_data in V9_SKILL_DEFINITIONS.items():
if skill_id not in existing:
existing[skill_id] = skill_data
added += 1
return added
except ImportError:
return 0
def v9_get_sector_profile(sector: str) -> Optional[Dict]:
"""Retorna el perfil profundo del sector, o None si no existe."""
return V9_SECTOR_DEEP_PROFILES.get(sector)
def v9_get_sector_prompt_injection(sector: str) -> str:
"""
Genera el bloque de prompt para el sector específico.
Incluye perfil del cliente, frases clave y scripts de objeción.
"""
profile = V9_SECTOR_DEEP_PROFILES.get(sector)
if not profile:
return ""
lines = []
client_profile = profile.get("client_profile", "")
if client_profile:
lines.append(client_profile.strip())
key_phrases = profile.get("key_phrases", [])
if key_phrases:
lines.append("\nPREGUNTAS CLAVE PARA ESTE SECTOR:")
for phrase in key_phrases[:5]: # Solo 5 para no saturar el prompt
lines.append(f" · {phrase}")
objections = profile.get("objection_scripts", {})
if objections:
lines.append("\nMANEJO DE OBJECIONES FRECUENTES:")
for obj_id, script in list(objections.items())[:3]: # Solo 3
lines.append(f" [{obj_id}]: {script}")
return "\n".join(lines)
# ══════════════════════════════════════════════════════════════════════════════
# FILTRO ANTI-ROBOT V9 — EXTENSIÓN DEL ANTIROBOT EXISTENTE
# Patrones adicionales identificados en auditoría de conversaciones reales
# ══════════════════════════════════════════════════════════════════════════════
# Patrones adicionales para AntiRobotFilter (se agregan a los existentes)
V9_ADDITIONAL_FORBIDDEN_EXACT: set = {
# Patrones que escaparon al filtro V8
"sin ningún inconveniente",
"sin ningún problema",
"quedo atento",
"quedo pendiente",
"le comento que",
"me complace informarle",
"me es grato comunicarle",
"en atención a su solicitud",
"adjunto le envío",
"aprovecho para informarle",
"de antemano agradezco",
"espero su pronta respuesta",
"cordial saludo",
"atentamente",
"quedo a su entera disposición",
"de ser así",
"en caso de requerir",
"si tiene alguna duda adicional",
"no dude en comunicarse",
"estoy a sus órdenes",
"a la orden",
"¿gusta que le explique",
"¿desea que le amplíe",
"¿le gustaría que",
"le hago saber que",
"le informo que",
"le comunico que",
"le notifico que",
"al respecto le comento",
"en relación a su consulta",
# Patrones que revelan estructura de chatbot
"opción 1", "opción 2", "opción 3",
"paso 1:", "paso 2:", "paso 3:",
"primero,", "segundo,", "tercero,",
"en primer lugar,", "en segundo lugar,",
"por un lado,", "por otro lado,",
# Frases que solo dice un bot corporativo
"nuestro equipo especializado",
"nuestros profesionales altamente capacitados",
"contamos con la más alta tecnología",
"somos líderes en",
"nos distinguimos por",
"nuestra misión es",
"nos comprometemos a",
}
V9_ADDITIONAL_PATTERNS: List[str] = [
# Respuestas que empiezan con "Entiendo que..." — clásico bot
r"^entiendo\s+que\s+",
r"^comprendo\s+que\s+",
r"^me\s+imagino\s+que\s+",
# Frases de confirmación robóticas
r"he\s+tomado\s+nota\s+de\s+",
r"he\s+registrado\s+tu\s+(solicitud|consulta|pregunta)",
r"quedo\s+en\s+espera\s+de\s+",
r"estoy\s+a\s+la\s+espera\s+de\s+",
# Estructuras de lista disfrazadas
r"\n\s*[-•]\s+\w", # Bullets en respuesta de chat
r"\n\s*\d+\.\s+\w", # Listas numeradas en respuesta de chat
# Cierres formulaicos
r"hasta\s+pronto\s+y\s+(que\s+)?tenga",
r"que\s+pase\s+(un\s+)?(excelente|buen)\s+día",
r"feliz\s+(lunes|martes|miércoles|jueves|viernes|sábado|domingo)",
r"que\s+disfrute\s+(el\s+)?(resto\s+de\s+)?su\s+día",
# Frases de apertura robóticas adicionales
r"bienvenido/a\s+a\s+",
r"gracias\s+por\s+(comunicarte|escribirnos|contactarnos|tu\s+(mensaje|consulta|interés))",
r"es\s+(un\s+)?placer\s+(atenderte|ayudarte|servirte)",
# Frases de meta-conversación (bot hablando de la conversación)
r"respecto\s+a\s+tu\s+(pregunta|consulta|solicitud)",
r"en\s+respuesta\s+a\s+tu\s+(mensaje|consulta)",
r"sobre\s+lo\s+que\s+(me\s+)?(preguntas|comentas|mencionas)",
]
def v9_enhance_anti_robot_filter(anti_robot_filter_instance) -> bool:
"""
Agrega los patrones V9 adicionales a un AntiRobotFilter existente.
Retorna True si se pudo parchear, False si falló.
USO:
from conny_v9_humanization import v9_enhance_anti_robot_filter
# Después de init_v8_systems():
if anti_robot_filter:
v9_enhance_anti_robot_filter(anti_robot_filter)
"""
try:
import re as _re
# Agregar frases exactas adicionales
if hasattr(anti_robot_filter_instance, 'FORBIDDEN_EXACT'):
anti_robot_filter_instance.FORBIDDEN_EXACT.update(
V9_ADDITIONAL_FORBIDDEN_EXACT
)
# Agregar patrones compilados adicionales
if hasattr(anti_robot_filter_instance, '_patterns_l2'):
new_patterns = [
_re.compile(p, _re.IGNORECASE | _re.MULTILINE)
for p in V9_ADDITIONAL_PATTERNS
]
anti_robot_filter_instance._patterns_l2.extend(new_patterns)
return True
except Exception:
return False
# ══════════════════════════════════════════════════════════════════════════════
# CORRECTOR DE CALIDAD DE RESPUESTA V9
# Detecta y corrige patrones específicos que el V8 no cubría
# ══════════════════════════════════════════════════════════════════════════════
class ResponseQualityPatcher:
"""
V9: Parches específicos de calidad basados en auditoría de respuestas reales.
Patrones que V8 no corregía pero que se identificaron en producción:
1. Respuestas que terminan en pregunta retórica que suena a script
2. Uso de listas cuando debería ser prosa
3. Mezcla de tuteo y ustedeo en la misma respuesta
4. Confirmaciones dobles innecesarias
5. Información que ya dio en el turno anterior
"""
# Patrones de terminación robóticos que escapan al antirobot
ROBOTIC_ENDINGS: List[Tuple[str, str]] = [
# Patrón → Reemplazo sugerido (vacío = eliminar)
(r'\.\s*¿Hay algo más en lo que pueda ayudarte[?!]?\s*$', ''),
(r'\.\s*¿Tienes alguna otra (pregunta|consulta|duda)[?!]?\s*$', ''),
(r'\.\s*¿Puedo ayudarte con algo más[?!]?\s*$', ''),
(r'\.\s*¿Necesitas (más|alguna) información[?!]?\s*$', ''),
(r'\s*Quedamos a tu (entera )?disposición\.?\s*$', ''),
(r'\s*Estamos para servirte\.?\s*$', ''),
]
# Detectar mezcla de tuteo/ustedeo (inconsistencia)
TUTEO_MARKERS = ["te ", "tu ", "tus ", "tienes", "puedes", "quieres"]
USTEDEO_MARKERS = ["usted", "le ", "su ", "sus ", "tiene ", "puede "]
def __init__(self):
self._compiled_endings = [
(re.compile(pattern, re.IGNORECASE), replacement)
for pattern, replacement in self.ROBOTIC_ENDINGS
]
def fix_endings(self, text: str) -> str:
"""Elimina terminaciones robóticas del texto."""
for pattern, replacement in self._compiled_endings:
text = pattern.sub(replacement, text).strip()
return text
def detect_mixed_formality(self, text: str) -> bool:
"""Detecta si hay mezcla de tuteo y ustedeo."""
text_lower = text.lower()
has_tuteo = any(m in text_lower for m in self.TUTEO_MARKERS)
has_ustedeo = "usted" in text_lower or (
sum(1 for m in self.USTEDEO_MARKERS if m in text_lower) >= 2
)
return has_tuteo and has_ustedeo
def fix_mixed_formality(self, text: str, archetype: str) -> str:
"""
Corrige mezcla de tuteo/ustedeo según el arquetipo.
Para arquetipos informales → tuteo. Para formales → ustedeo.
"""
FORMAL_ARCHETYPES = {"profesional", "luxury", "experta",
"abogado_asistente", "recepcionista_medica"}
if archetype in FORMAL_ARCHETYPES:
# Convertir tuteo a ustedeo (básico)
replacements = [
(r'\bte\b', 'le'), (r'\btu\b', 'su'), (r'\btus\b', 'sus'),
(r'\btienes\b', 'tiene'), (r'\bpuedes\b', 'puede'),
]
else:
# Convertir ustedeo a tuteo (básico)
replacements = [
(r'\busted\b', ''), (r'\ble\b', 'te'), (r'\bsu\b', 'tu'),
]
for pattern, replacement in replacements:
text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)
return text.strip()
def detect_double_question(self, text: str) -> bool:
"""Detecta si hay más de una pregunta en el mensaje."""
return text.count('?') > 1
def process(self, text: str, archetype: str = "amigable") -> str:
"""Aplica todos los parches de calidad V9."""
if not text:
return text
# 1. Fix terminaciones robóticas
text = self.fix_endings(text)
# 2. Fix mezcla de formalidad (solo si se detecta)
if self.detect_mixed_formality(text):
text = self.fix_mixed_formality(text, archetype)
return text.strip()
def score_bonus(self, text: str) -> float:
"""
Bonus al score de humanidad de AntiRobotFilter.score_humanness()
para patrones positivos identificados en V9.
"""
bonus = 0.0
text_lower = text.lower()
# Bonus por reacciones emocionales naturales
positive_reactions = ["ay qué", "qué bacano", "qué bien", "ay sí", "uy qué"]
if any(r in text_lower for r in positive_reactions):
bonus += 0.08
# Bonus por vocabulario paisa/colombiano auténtico
v9_colombian = ["de una", "hágale", "pues", "fresco", "bacano",
"chévere", "bien o qué", "qué más"]
hits = sum(1 for w in v9_colombian if w in text_lower)
bonus += hits * 0.04
# Bonus por respuesta muy corta y directa (señal de humano)
words = len(text.split())
if 3 <= words <= 10:
bonus += 0.10
# Penalización por listas en el texto
if "\n-" in text or "\n•" in text or re.search(r'\n\d+\.', text):
bonus -= 0.20
return round(max(-0.3, min(0.3, bonus)), 3)
# ══════════════════════════════════════════════════════════════════════════════
# VOCABULARIO EXTENDIDO POR SECTOR — para prompts específicos
# ══════════════════════════════════════════════════════════════════════════════
SECTOR_VOCABULARY: Dict[str, Dict[str, List[str]]] = {
"dental": {
"servicios": ["limpieza", "blanqueamiento", "ortodoncia", "implante",
"extracción", "endodoncia", "carilla", "corona", "resina"],
"dolores": ["me duele una muela", "tengo un dolor", "se me cayó un diente",
"me sangran las encías", "tengo sensibilidad", "se me partió",
"tengo caries", "se me movió", "me duele al morder"],
"miedos_frecuentes": ["miedo a la aguja", "odio el dentista", "siempre me duele",
"el ruido de la fresa", "me da miedo el sillón"],
"palabras_tranquilizar": ["anestesia local", "presión pero no dolor", "muy rápido",
"sin complicaciones", "el dr te explica primero",
"muchas personas llegan con ese miedo"],
},
"estetica": {
"procedimientos": ["botox", "relleno", "ácido hialurónico", "mesoterapia",
"bótox", "lifting", "peel", "láser", "hidrafacial",
"perfilado", "rejuvenecimiento", "bioestimulación"],
"zonas": ["frente", "entrecejo", "párpados", "pómulos", "labios",
"ojeras", "papada", "cuello", "nasolabiales", "código de barras"],
"objeciones_típicas": ["que quede natural", "que no se note",
"que no me vea operada", "miedo que quede exagerado",
"ya me hicieron algo y quedé mal"],
"cierres_poderosos": ["valoración gratuita con la doctora",
"la dra tiene mano muy natural",
"muchas pacientes del sector dicen lo mismo",
"el resultado lo defines tú con la especialista"],
},
"gimnasio": {
"objetivos": ["bajar de peso", "ganar músculo", "mejorar resistencia",
"ponerse en forma", "rehabilitación", "perder barriga",
"definición", "cardio", "fuerza", "flexibilidad"],
"obstáculos": ["no tengo tiempo", "nunca he ido", "ya lo intenté",
"no sé qué hacer", "me da pena", "tengo una lesión",
"trabajo muy tarde", "solo los fines de semana puedo"],
"motivadores": ["evento próximo", "boda", "vacaciones en diciembre",
"el médico me dijo", "ya no aguanto verme así",
"quiero tener más energía"],
},
"psicologo": {
"razones": ["ansiedad", "depresión", "estrés", "relación de pareja",
"duelo", "autoestima", "fobias", "ataques de pánico",
"problemas familiares", "trabajo", "no sé qué me pasa"],
"barreras": ["me da pena", "no sé si lo necesito", "ya lo intenté antes",
"es muy caro", "no tengo tiempo", "lo veo como debilidad",
"no quiero que nadie sepa"],
"normalizar": ["muchas personas sienten lo mismo",
"buscar ayuda es de valientes",
"la primera sesión es sin compromiso",
"es confidencial"],
},
}
def get_sector_vocabulary(sector: str, category: str = None) -> Dict:
"""Retorna el vocabulario del sector, opcionalmente filtrado por categoría."""
vocab = SECTOR_VOCABULARY.get(sector, {})
if category:
return {category: vocab.get(category, [])}
return vocab
def build_sector_vocabulary_prompt(sector: str) -> str:
"""Genera instrucción de vocabulario para el sector dado."""
vocab = SECTOR_VOCABULARY.get(sector)
if not vocab:
return ""
lines = [f"VOCABULARIO NATURAL — {sector.upper()}:"]
for category, words in vocab.items():
if words and len(lines) < 8: # Limitar para no saturar el prompt
sample = words[:6] # Solo primeros 6
lines.append(f" {category}: {', '.join(sample)}")
return "\n".join(lines)
# ══════════════════════════════════════════════════════════════════════════════
# UTILIDADES DE TESTING Y DEBUGGING
# ══════════════════════════════════════════════════════════════════════════════
def test_emotional_detection(messages: List[str]) -> Dict[str, str]:
"""
Utilidad de testing: detecta la emoción en una lista de mensajes.
Útil para verificar que el motor funciona correctamente.
Uso:
results = test_emotional_detection([
"me da miedo que quede exagerado",
"está muy caro",
"ya fui a otro lado y quedé mal",
])
for msg, emotion in results.items():
print(f"'{msg}' → {emotion}")
"""
engine = EmotionalMirrorEngine()
return {msg: (engine.detect_emotion(msg) or "NINGUNA") for msg in messages}
def test_persona_detection(messages: List[str]) -> Dict[str, str]:
"""
Utilidad de testing: detecta el arquetipo de cliente en una lista de mensajes.
Uso:
results = test_persona_detection([
"cuándo puedo ir hoy mismo",
"qué incluye exactamente y cuántas sesiones necesito",
"siempre lo quise hacer, por fin me animé",
])
"""
detector = ClientPersonaDetector()
return {msg: (detector.detect(msg) or "NO_DETECTADO") for msg in messages}
def run_v9_diagnostics() -> Dict[str, Any]:
"""
Ejecuta diagnósticos de todos los sistemas V9.
Retorna reporte de estado.
Uso:
report = run_v9_diagnostics()
print(report)
"""
results = {}
# Test EmotionalMirrorEngine
try:
engine = EmotionalMirrorEngine()
test_result = engine.detect_emotion("me da miedo que quede exagerado")
results["EmotionalMirrorEngine"] = {
"status": "OK",
"test_detection": test_result,
"total_emotions": len(engine.EMOTIONAL_SIGNALS),
}
except Exception as e:
results["EmotionalMirrorEngine"] = {"status": "ERROR", "error": str(e)}
# Test ClientPersonaDetector
try:
detector = ClientPersonaDetector()
test_result = detector.detect("cuándo puedo ir hoy mismo de una")
results["ClientPersonaDetector"] = {
"status": "OK",
"test_detection": test_result,
"total_personas": len(detector.PERSONA_PROFILES),
}
except Exception as e:
results["ClientPersonaDetector"] = {"status": "ERROR", "error": str(e)}
# Test TimeContextualizer
try:
tc = TimeContextualizer()
profile = tc.get_current_profile()
results["TimeContextualizer"] = {
"status": "OK",
"current_period": profile.get("id"),
"recommended_greeting": tc.get_recommended_greeting(),
}
except Exception as e:
results["TimeContextualizer"] = {"status": "ERROR", "error": str(e)}
# Test ConversationRhythmAnalyzer
try:
ra = ConversationRhythmAnalyzer()
test_history = [
{"role": "user", "content": "hola"},
{"role": "assistant", "content": "hola qué más"},
{"role": "user", "content": "quiero saber sobre botox"},
]
profile = ra.analyze("test_chat", test_history)
results["ConversationRhythmAnalyzer"] = {
"status": "OK",
"test_style": profile.get("style"),
"avg_words": profile.get("avg_words"),
}
except Exception as e:
results["ConversationRhythmAnalyzer"] = {"status": "ERROR", "error": str(e)}
# Test SectorClosingScripts
try:
sc = SectorClosingScripts()
test_script = sc.get_script("dental", "primera_cita")
results["SectorClosingScripts"] = {
"status": "OK",
"total_sectors": len(sc.SCRIPTS),
"test_script_available": test_script is not None,
}
except Exception as e:
results["SectorClosingScripts"] = {"status": "ERROR", "error": str(e)}
# Test ResponseQualityPatcher
try:
patcher = ResponseQualityPatcher()
test_text = "Claro que sí, con mucho gusto. ¿Hay algo más en lo que pueda ayudarte?"
patched = patcher.process(test_text)
results["ResponseQualityPatcher"] = {
"status": "OK",
"test_input": test_text[:50],
"test_output": patched[:50],
"changed": test_text != patched,
}
except Exception as e:
results["ResponseQualityPatcher"] = {"status": "ERROR", "error": str(e)}
# Resumen
ok_count = sum(1 for r in results.values() if r.get("status") == "OK")
results["SUMMARY"] = {
"systems_ok": ok_count,
"systems_total": len(results) - 1,
"new_archetypes": len(V9_PERSONALITY_ARCHETYPES),
"new_skills": len(V9_SKILL_DEFINITIONS),
"deep_sector_profiles": len(V9_SECTOR_DEEP_PROFILES),
"version": "V9.0",
}
return results
# ══════════════════════════════════════════════════════════════════════════════
# INSTRUCCIONES COMPLETAS DE INTEGRACIÓN
# ══════════════════════════════════════════════════════════════════════════════
import httpx
from fastapi import FastAPI, Request, Response, BackgroundTasks, HTTPException
from fastapi.middleware.cors import CORSMiddleware
# ── Helpers globales ──────────────────────────────────────────────────────────
def _parse_admin_ids(raw) -> list:
"""
Parsea admin_chat_ids de forma segura.
Maneja str JSON, lista, None — nunca lanza excepción.
Centraliza la lógica que antes estaba duplicada 10+ veces en el código.
"""
if not raw:
return []
if isinstance(raw, list):
return [str(x) for x in raw]
if isinstance(raw, str):
try:
result = json.loads(raw)
return [str(x) for x in result] if isinstance(result, list) else []
except Exception:
return []
return []
def _split_env_values(raw) -> list:
"""Divide una variable de entorno tipo lista en valores útiles, preservando orden."""
if not raw:
return []
if isinstance(raw, (list, tuple, set)):
values = [str(x).strip() for x in raw if str(x).strip()]
else:
text = str(raw).strip()
if not text:
return []
parsed = None
if text.startswith("["):
try:
parsed = json.loads(text)
except Exception:
parsed = None
if isinstance(parsed, list):
values = [str(x).strip() for x in parsed if str(x).strip()]
else:
values = [part.strip() for part in re.split(r"[\n,]+", text) if part.strip()]
deduped = []
seen = set()
for value in values:
if value not in seen:
deduped.append(value)
seen.add(value)
return deduped
def _collect_env_series(base_name: str, *extra_names: str) -> list:
"""Recolecta BASE, BASE_2..BASE_N y también listas BASES/BASE_LIST."""
pattern = re.compile(rf"^{re.escape(base_name)}(?:_(\d+))?$")
ranked = []
for env_name, env_value in os.environ.items():
match = pattern.match(env_name)
if not match:
continue
rank = int(match.group(1) or 1)
for value in _split_env_values(env_value):
ranked.append((rank, value))
ranked.sort(key=lambda item: item[0])
ordered = [value for _, value in ranked]
for alias in extra_names or (f"{base_name}S", f"{base_name}_LIST"):
ordered.extend(_split_env_values(os.getenv(alias, "")))
deduped = []
seen = set()
for value in ordered:
if value and value not in seen:
deduped.append(value)
seen.add(value)
return deduped
# ═══════════════════════════════════════════════════════════════════════════════
# CONFIGURACIÓN GLOBAL AVANZADA
# ═══════════════════════════════════════════════════════════════════════════════
class Config:
"""Configuración centralizada con validación."""
# ── Tokens de mensajería ──────────────────────────────────────────────────
TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN", "")
# ── APIs de LLM — cascada de prioridad ────────────────────────────────────
# Groq (el más rápido — prioridad 1)
GROQ_API_KEY = os.getenv("GROQ_API_KEY", "")
# Gemini directo — 6 claves rotan si una falla (prioridad 2-7)
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", "")
GEMINI_API_KEYS = _collect_env_series("GEMINI_API_KEY")
# OpenRouter — acceso a todos los modelos (prioridad 5)
OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
# OpenAI — último recurso (prioridad 6)
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
# Anthropic directo (opcional, ya está en OpenRouter)
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY", "")
# ── APIs de búsqueda ──────────────────────────────────────────────────────
BRAVE_API_KEY = os.getenv("BRAVE_API_KEY", "")
BRAVE_API_KEYS = _collect_env_series("BRAVE_API_KEY")
APIFY_API_KEY = os.getenv("APIFY_API_KEY", "")
APIFY_API_KEYS = _collect_env_series("APIFY_API_KEY")
SERP_API_KEY = os.getenv("SERP_API_KEY", "")
SERP_API_KEYS = _collect_env_series("SERP_API_KEY")
# ── Calendario ────────────────────────────────────────────────────────────
# Calendly — link directo que Conny puede enviar al paciente
CALENDLY_LINK = os.getenv("CALENDLY_LINK", "")
# Google Calendar — OAuth tokens (se obtienen via /vincular-agenda)
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 (de Santiago — para auto-registrar webhooks de todos los clientes) ──
META_APP_ID = os.getenv("META_APP_ID", "")
META_APP_SECRET = os.getenv("META_APP_SECRET", "")
# ── Nova — Motor de Gobernanza ────────────────────────────────────────────
# FIX: apuntar a nova-core (9003) no nova-api (9002)
# nova-api (9002) = /tokens /validate /stats (main.py)
# nova-core (9003) = /ledger /rules /stream /intercept /boot (nova_core.py) ← este es el correcto
NOVA_URL = os.getenv("NOVA_URL", "http://localhost:9003")
NOVA_TOKEN = os.getenv("NOVA_TOKEN", "") # Token del agente Conny
NOVA_API_KEY = os.getenv("NOVA_API_KEY", "") # API key de Nova
NOVA_ENABLED = os.getenv("NOVA_ENABLED", "false").lower() == "true"
# Webhook
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_ALLOW_DEFAULT_FALLBACK = os.getenv(
"TELEGRAM_SHARED_ALLOW_DEFAULT_FALLBACK", "false"
).lower() == "true"
_CONNY_HOME = os.getenv("CONNY_HOME", str(Path.home() / ".conny"))
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"),
)
# Plataforma: "telegram" | "whatsapp_cloud" | "evolution" | "whatsapp"
PLATFORM = os.getenv("PLATFORM", "telegram")
# WhatsApp Bridge (Baileys)
WHATSAPP_BRIDGE_URL = os.getenv("WHATSAPP_BRIDGE_URL", "http://localhost:3000")
# Sector del negocio (sincronizado con conny_cli.py)
SECTOR = os.getenv("SECTOR", "otro")
# WhatsApp Cloud API (Meta oficial)
WA_PHONE_ID = os.getenv("WA_PHONE_ID", "") # Phone Number ID de Meta
WA_ACCESS_TOKEN = os.getenv("WA_ACCESS_TOKEN", "") # Token permanente de Meta
WA_VERIFY_TOKEN = os.getenv("WA_VERIFY_TOKEN", "") # Para verificar webhook
# Evolution API (auto-hospedado, alternativa economica)
EVOLUTION_URL = os.getenv("EVOLUTION_URL", "") # http://tu-server:8080
EVOLUTION_API_KEY = os.getenv("EVOLUTION_API_KEY", "")
EVOLUTION_INSTANCE = os.getenv("EVOLUTION_INSTANCE", "conny")
# Auth — sistema de activacion multi-admin
MASTER_API_KEY = os.getenv("MASTER_API_KEY", "") # Clave de Santiago para crear tokens
N8N_WEBHOOK_URL = os.getenv("N8N_WEBHOOK_URL", "") # URL N8N para notificaciones
TOKEN_EXPIRY_HOURS = int(os.getenv("TOKEN_EXPIRY_HOURS", "72")) # Tokens expiran en 72h
# ── MODO DEMO ─────────────────────────────────────────────────────────────
# Actívalo con: conny demo (nunca pide token, responde inmediato)
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")) # 30 min por persona
GREETING_ONLY_IDLE_SECONDS = int(os.getenv("GREETING_ONLY_IDLE_SECONDS", "300"))
# ── V8.0 — Gestión dinámica de modelos ─────────────────────────────────────
# El admin puede cambiar el modelo en caliente con /modelo
# Sin reiniciar. Sin tocar .env.
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", "")
# Catálogo de modelos disponibles para cambio en caliente
V8_MODEL_CATALOG = {
# ── Anthropic ──────────────────────────────────────────────
"claude-opus": ("anthropic/claude-opus-4", "reasoning", "Más inteligente. Más caro."),
"claude-sonnet": ("anthropic/claude-sonnet-4", "reasoning", "Balance inteligencia/costo. Recomendado."),
"claude-haiku": ("anthropic/claude-haiku-3-5", "fast", "Rapidísimo y económico."),
# ── Google ─────────────────────────────────────────────────
"gemini-pro": ("google/gemini-2.5-pro", "reasoning", "Google Pro. Muy capaz."),
"gemini-flash": ("google/gemini-2.5-flash", "fast", "Velocidad + calidad Google."),
"gemini-lite": ("google/gemini-2.5-flash-lite", "lite", "El más económico de Google."),
# ── Meta Llama ─────────────────────────────────────────────
"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."),
# ── OpenAI ─────────────────────────────────────────────────
"gpt4o": ("openai/gpt-4o", "reasoning", "OpenAI flagship."),
"gpt4o-mini": ("openai/gpt-4o-mini", "fast", "OpenAI económico."),
# ── Mistral ────────────────────────────────────────────────
"mistral-large": ("mistralai/mistral-large", "reasoning", "Europeo, buen español."),
"mistral-small": ("mistralai/mistral-small", "fast", "Rápido y asequible."),
}
# Calidad de respuesta — forzar regeneración si score bajo
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"),
)
# AntiRobotFilter — nivel de agresividad (1=suave, 2=normal, 3=estricto)
V8_FILTER_LEVEL = int(os.getenv("V8_FILTER_LEVEL", "2"))
# Database
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")
# Modelos LLM (cascada de calidad)
LLM_MODELS = {
# FIX: "reasoning" usaba el mismo modelo que "fast" (gemini-2.5-flash),
# lo que hacía que los intentos de reparación de calidad no escalaran
# a un modelo más capaz. Ahora "reasoning" usa gemini-2.5-pro para que
# el segundo y tercer intento del quality_chain tengan más inteligencia.
# Para volver a Flash en reasoning: setear LLM_REASONING=google/gemini-2.5-flash en .env
"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
WHISPER_MODEL = os.getenv("WHISPER_MODEL", "openai/whisper-large-v3")
# Buffer inteligente
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",
)
# Auto-mejora
SELF_IMPROVE_INTERVAL = int(os.getenv("SELF_IMPROVE_INTERVAL", "3600")) # cada hora
LEARNING_RATE = float(os.getenv("LEARNING_RATE", "0.1"))
# Límites
MAX_CONTEXT_MESSAGES = int(os.getenv("MAX_CONTEXT", "50"))
MAX_MEMORY_ITEMS = int(os.getenv("MAX_MEMORY", "1000"))
@classmethod
def validate(cls) -> List[str]:
"""Valida configuración y retorna errores."""
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
def _load_simple_env(path: Path) -> Dict[str, str]:
data: Dict[str, str] = {}
try:
for raw in path.read_text().splitlines():
line = raw.strip()
if not line or line.startswith("#") or "=" not in line:
continue
key, value = line.split("=", 1)
data[key.strip()] = value.strip()
except Exception:
pass
return data
def _instance_metadata_path() -> Optional[Path]:
candidates = [
Path(__file__).resolve().parent / "instance.json",
Path(Config.DB_PATH).resolve().parent / "instance.json",
Path.cwd() / "instance.json",
]
seen: Set[str] = set()
for candidate in candidates:
key = str(candidate)
if key in seen:
continue
seen.add(key)
if candidate.exists():
return candidate
return None
def _load_instance_metadata() -> Dict[str, Any]:
path = _instance_metadata_path()
if not path:
return {}
try:
data = json.loads(path.read_text())
if isinstance(data, dict):
return data
except Exception as exc:
logging.getLogger("conny").warning(f"[instance_bootstrap] no pude leer {path}: {exc}")
return {}
def _parse_hours_window(raw: str) -> Dict[str, str]:
raw = (raw or "").strip()
if not raw or "-" not in raw:
return {}
start, end = [p.strip() for p in raw.split("-", 1)]
if not start or not end:
return {}
return {
day: f"{start}-{end}"
for day in ["lunes", "martes", "miércoles", "jueves", "viernes", "sábado"]
}
def _normalize_clinic_list(value: Any) -> List[str]:
if isinstance(value, list):
return [str(item).strip() for item in value if str(item).strip()]
if isinstance(value, str):
stripped = value.strip()
if not stripped:
return []
try:
parsed = json.loads(stripped)
if isinstance(parsed, list):
return [str(item).strip() for item in parsed if str(item).strip()]
except Exception:
pass
return [item.strip() for item in re.split(r"[,\n;]+", stripped) if item.strip()]
return []
def _normalize_clinic_dict(value: Any) -> Dict[str, Any]:
if isinstance(value, dict):
return value
if isinstance(value, str):
stripped = value.strip()
if not stripped:
return {}
try:
parsed = json.loads(stripped)
if isinstance(parsed, dict):
return parsed
except Exception:
pass
return {}
def _build_minimum_business_knowledge(clinic: Dict[str, Any]) -> str:
clinic_name = str(clinic.get("name") or clinic.get("tagline") or "la clínica").strip()
services = _normalize_clinic_list(clinic.get("services"))
schedule = _normalize_clinic_dict(clinic.get("schedule"))
persona = _normalize_clinic_dict(clinic.get("persona_config"))
pricing = _normalize_clinic_dict(clinic.get("pricing"))
phone = str(clinic.get("phone") or "").strip()
website = str(clinic.get("website") or "").strip()
address = str(clinic.get("address") or "").strip()
lines = [
f"Negocio: {clinic_name}",
"Conny es la asesora del equipo y debe sonar humana, clara y profesional.",
"Debe tratar con respeto al administrador y usar trato de usted con pacientes salvo que el admin ordene otra cosa.",
]
if services:
lines.append("Servicios principales: " + ", ".join(services) + ".")
if schedule:
readable_schedule = ", ".join(f"{day}: {slot}" for day, slot in schedule.items())
lines.append("Horario base: " + readable_schedule + ".")
if phone:
lines.append(f"Contacto base: {phone}.")
if website:
lines.append(f"Sitio web: {website}.")
if address:
lines.append(f"Ubicación: {address}.")
if pricing:
lines.append("Precios cargados: sí. Conny puede citar valores solo si existen en la configuración.")
else:
lines.append("Precios cargados: no. Conny no debe inventar valores; debe ofrecer valoración o ampliar información del procedimiento.")
if persona.get("objetivo"):
lines.append(f"Objetivo operativo: {persona.get('objetivo')}.")
lines.append("Si el paciente pregunta algo ambiguo, Conny debe responder con claridad y pedir solo el dato mínimo que falte.")
return "\n".join(line for line in lines if line).strip()
def ensure_minimum_business_state(force: bool = False) -> Dict[str, Any]:
"""
Garantiza un mínimo viable de identidad/KB/memoria aunque la instancia
aún no tenga documentos completos cargados.
"""
global db, kb
if not db:
return {"ok": False, "reason": "db_unavailable"}
clinic = db.get_clinic() or {}
if not clinic:
return {"ok": False, "reason": "clinic_unavailable"}
services = _normalize_clinic_list(clinic.get("services"))
schedule = _normalize_clinic_dict(clinic.get("schedule"))
persona = _normalize_clinic_dict(clinic.get("persona_config"))
pricing = _normalize_clinic_dict(clinic.get("pricing"))
clinic_name = str(clinic.get("name") or clinic.get("tagline") or "").strip()
persona_defaults = {
"name": "Conny",
"tono": "humana, clara y profesional",
"rol": "asesora del equipo",
"registro": "usted",
"objetivo": "orientar, resolver dudas, valorar y llevar a cita",
}
persona_changed = False
for key, value in persona_defaults.items():
if force or not str(persona.get(key) or "").strip():
persona[key] = value
persona_changed = True
if persona_changed:
try:
db.update_clinic(persona_config=persona)
except Exception as exc:
logging.getLogger("conny").warning(f"[business_bootstrap] no pude actualizar persona_config: {exc}")
memory_pairs = [
("clinic_name", clinic_name, "clinic"),
("brand_business_name", clinic_name, "identity"),
("clinic_services", ", ".join(services), "clinic"),
("clinic_hours", ", ".join(f"{day}: {slot}" for day, slot in schedule.items()), "clinic"),
("clinic_phone", str(clinic.get("phone") or "").strip(), "clinic"),
("clinic_website", str(clinic.get("website") or "").strip(), "identity"),
("pricing_loaded", "true" if pricing else "false", "clinic"),
("pricing_policy", "no inventar precios; ofrecer valoración si no hay precio cargado", "clinic"),
("platform", str(clinic.get("platform") or Config.PLATFORM or "").strip(), "identity"),
]
seeded_memory = 0
for key, value, category in memory_pairs:
if not value:
continue
current = ""
try:
current = db.recall(key) or ""
except Exception:
current = ""
if force or not str(current).strip():
db.remember(key, str(value), category)
seeded_memory += 1
kb_text = _build_minimum_business_knowledge({**clinic, "persona_config": persona})
kb_seeded = False
if kb and _KB_AVAILABLE and kb_text and (force or not kb.has_content()):
try:
stats = kb.ingest(kb_text)
kb_seeded = bool(stats.get("ok"))
except Exception as exc:
logging.getLogger("conny").warning(f"[business_bootstrap] no pude sembrar KB: {exc}")
if kb_text and (force or not str(clinic.get("knowledge_base_raw") or "").strip()):
try:
db.update_clinic(knowledge_base_raw=kb_text)
except Exception:
pass
brand_seeded = False
if _BRAND_ASSETS_AVAILABLE and clinic_name:
try:
store = BrandAssetStore(Config.BRAND_ASSETS_BASE_DIR, clinic_name)
manifest = store.manifest()
assets = manifest.get("assets", []) if isinstance(manifest, dict) else []
if force or not assets:
saved = store.save_text_note(
"business-identity",
kb_text,
source="system_bootstrap",
category="identity",
)
if saved.saved_path:
brand_seeded = True
manifest = store.manifest()
db.remember("brand_assets_path", str(store.root), "identity")
db.remember("brand_assets_count", str(len(manifest.get("assets", []))), "identity")
summary = store.latest_identity_summary()
if summary:
db.remember("brand_identity_summary", summary, "identity")
except Exception as exc:
logging.getLogger("conny").warning(f"[business_bootstrap] no pude sembrar Brand Vault: {exc}")
return {
"ok": True,
"seeded_memory": seeded_memory,
"kb_seeded": kb_seeded,
"brand_seeded": brand_seeded,
}
def bootstrap_clinic_identity_from_instance_metadata(force: bool = False) -> bool:
"""
Hidrata clinic/core_memory desde instance.json si una instancia vieja quedó
arrancando con DB vacía o setup a medias.
"""
global db
if not db:
return False
meta = _load_instance_metadata()
if not meta:
return False
clinic = db.get_clinic() or {}
updates: Dict[str, Any] = {}
label = (meta.get("label") or meta.get("name") or "").strip()
slug = (meta.get("name") or "").strip()
services = meta.get("services") if isinstance(meta.get("services"), list) else []
hours = _parse_hours_window(str(meta.get("hours") or ""))
setup_buffer = clinic.get("setup_buffer") if isinstance(clinic.get("setup_buffer"), dict) else {}
if force or not clinic.get("name"):
if label:
updates["name"] = label
if not clinic.get("tagline"):
updates["tagline"] = label
if force or not clinic.get("services"):
if services:
updates["services"] = services
if force or not clinic.get("schedule"):
if hours:
updates["schedule"] = hours
if force or not clinic.get("platform"):
updates["platform"] = Config.PLATFORM
if force or not clinic.get("setup_buffer"):
setup_payload = {}
if label:
setup_payload["clinic_name"] = label
if services:
setup_payload["services"] = services
if meta.get("hours"):
setup_payload["hours"] = meta.get("hours")
if setup_payload:
updates["setup_buffer"] = setup_payload
should_mark_ready = bool(label or services or hours)
if should_mark_ready and (force or not clinic.get("setup_done")):
updates["setup_done"] = 1
updates["onboarding_done"] = 1
updates["setup_step"] = "done"
if not updates:
return False
db.update_clinic(**updates)
if label:
db.remember("clinic_name", label, "clinic")
db.remember("brand_business_name", label, "identity")
if slug:
db.remember("instance_slug", slug, "identity")
if services:
db.remember("clinic_services", ", ".join(services), "clinic")
if meta.get("hours"):
db.remember("clinic_hours", str(meta.get("hours")), "clinic")
db.remember("brand_assets_path", str(Path(Config.BRAND_ASSETS_BASE_DIR)), "identity")
if _BRAND_ASSETS_AVAILABLE:
try:
store = BrandAssetStore(Config.BRAND_ASSETS_BASE_DIR, label or slug or Config.SECTOR or "conny")
store.root.mkdir(parents=True, exist_ok=True)
except Exception as exc:
logging.getLogger("conny").warning(f"[instance_bootstrap] no pude preparar Brand Vault: {exc}")
logging.getLogger("conny").info(
f"[instance_bootstrap] identidad inicializada desde instance.json para '{label or slug or 'instancia'}'"
)
return True
def _shared_routes_path() -> Path:
return Path(Config.TELEGRAM_SHARED_ROUTES_PATH)
def _route_platform(route: Optional[Dict[str, Any]] = None) -> str:
if route and route.get("platform"):
return str(route["platform"])
return Config.PLATFORM
def _buffer_key(chat_id: str, route: Optional[Dict[str, Any]] = None) -> str:
return f"{_route_platform(route)}:{chat_id}"
def _detect_incoming_platform(body: Dict[str, Any]) -> str:
if not isinstance(body, dict):
return Config.PLATFORM
if body.get("message") or body.get("edited_message"):
return "telegram"
if body.get("event") == "message.received" or body.get("channel") == "whatsapp":
return "whatsapp"
if body.get("entry") and isinstance(body.get("entry"), list):
return "whatsapp_cloud"
if body.get("event") in (
"messages.upsert",
"messages.update",
"MESSAGES_UPSERT",
"MESSAGES_UPDATE",
):
return "evolution"
return Config.PLATFORM
def _load_shared_telegram_routes() -> Dict[str, Any]:
default = {"default_instance": "", "routes": {}}
path = _shared_routes_path()
if not path.exists():
return default
try:
data = json.loads(path.read_text())
if not isinstance(data, dict):
return default
if not isinstance(data.get("routes"), dict):
data["routes"] = {}
data.setdefault("default_instance", "")
return data
except Exception:
return default
def _discover_shared_telegram_instances() -> List[Dict[str, Any]]:
instances: List[Dict[str, Any]] = []
base = Path(Config.TELEGRAM_SHARED_INSTANCES_DIR)
if not base.exists():
return instances
for env_path in sorted(base.glob("*/.env")):
env = _load_simple_env(env_path)
if env.get("TELEGRAM_SHARED", "false").lower() != "true":
continue
port = int(env.get("PORT", "0") or 0)
secret = env.get("WEBHOOK_SECRET", "").strip()
token = env.get("TELEGRAM_TOKEN", "").strip()
if not (port and secret and token):
continue
instances.append({
"name": env_path.parent.name,
"dir": str(env_path.parent),
"port": port,
"secret": secret,
})
return instances
def _resolve_shared_telegram_target(chat_id: str) -> Optional[Dict[str, Any]]:
routes = _load_shared_telegram_routes()
known = {item["name"]: item for item in _discover_shared_telegram_instances()}
mapped = routes.get("routes", {}).get(str(chat_id))
if mapped and mapped in known:
return known[mapped]
if Config.TELEGRAM_SHARED_ALLOW_DEFAULT_FALLBACK:
fallback = routes.get("default_instance", "") or Config.TELEGRAM_DEFAULT_INSTANCE
if fallback and fallback in known:
return known[fallback]
if len(known) == 1:
return next(iter(known.values()))
return None
# Logging avanzado
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s │ %(levelname)7s │ %(name)s │ %(message)s",
datefmt="%H:%M:%S"
)
log = logging.getLogger("conny.ultra")
# ═══════════════════════════════════════════════════════════════════════════════
# SECTORES — sincronizados con conny_cli.py
# ═══════════════════════════════════════════════════════════════════════════════
SECTORS = {
"estetica": ("💉", "Clínica Estética", "Botox, Rellenos, Láser, Peeling, Mesoterapia",
"tratamientos estéticos, rejuvenecimiento, procedimientos"),
"dental": ("🦷", "Clínica Dental", "Limpieza, Blanqueamiento, Ortodoncia, Implantes",
"diente, muela, dolor, caries, brackets, odontología"),
"veterinaria": ("🐾", "Veterinaria", "Consulta, Vacunación, Cirugía, Peluquería, Urgencias",
"perro, gato, mascota, vacuna, enfermo"),
"restaurante": ("🍽️", "Restaurante", "Reservas, Eventos, Catering, Menú del día, Delivery",
"reserva, mesa, cena, almuerzo, grupo"),
"hotel": ("🏨", "Hotel / Hospedaje", "Habitaciones, Suites, Desayuno, Spa, Eventos",
"habitación, reserva, noche, disponibilidad, check-in"),
"gimnasio": ("💪", "Gimnasio / Fitness", "Membresía, Personal trainer, Clases grupales, Nutrición",
"inscripción, clase, horario, entrenador"),
"belleza": ("💇", "Salón de Belleza", "Corte, Color, Manicure, Pedicure, Tratamientos capilares",
"corte, tinte, uñas, peinado, cita"),
"spa": ("🧖", "Spa / Wellness", "Masajes, Faciales, Circuito spa, Aromaterapia",
"masaje, relajación, facial, circuito"),
"medico": ("🩺", "Consultorio Médico", "Consulta general, Especialidades, Estudios, Certificados",
"cita, doctor, consulta, seguro, estudios"),
"psicologo": ("🧠", "Psicología / Terapia", "Terapia individual, Parejas, Familiar, Online",
"terapia, ansiedad, sesión, psicólogo"),
"abogado": ("⚖️", "Despacho Legal", "Consulta inicial, Divorcios, Laboral, Mercantil, Penal",
"abogado, demanda, divorcio, consulta, legal"),
"inmobiliaria": ("🏠", "Inmobiliaria", "Venta, Renta, Avalúos, Administración, Asesoría",
"casa, departamento, renta, comprar, visita"),
"taller": ("🔧", "Taller Mecánico", "Servicio, Diagnóstico, Frenos, Alineación, Hojalatería",
"carro, coche, servicio, frenos, ruido"),
"academia": ("📚", "Academia / Escuela", "Inscripción, Cursos, Clases particulares, Certificaciones",
"curso, clase, inscripción, horario, nivel"),
"nutricion": ("🥗", "Nutricionista", "Consulta, Plan alimenticio, Seguimiento, Estudios",
"dieta, peso, nutrición, plan"),
"fisioterapia": ("🦴", "Fisioterapia", "Evaluación, Rehabilitación, Masaje terapéutico",
"dolor, lesión, rehabilitación, sesión"),
"fotografia": ("📸", "Fotografía / Estudio", "Sesión retrato, Eventos, Producto, Bodas, Books",
"sesión, fotos, boda, retrato, evento"),
"coworking": ("🏢", "Coworking", "Hot desk, Oficina privada, Sala de juntas",
"oficina, espacio, escritorio, renta, sala"),
"tattoo": ("🎨", "Estudio de Tatuaje", "Tatuaje, Cover up, Piercing, Diseño personalizado",
"tatuaje, diseño, cita, piercing"),
"otro": ("⚙️", "Negocio", "Servicios personalizados",
"servicio, cita, consulta"),
}
def get_sector_info(sector_id: str) -> Tuple[str, str, str, str]:
"""Retorna (emoji, nombre, servicios_comunes, keywords) del sector."""
return SECTORS.get(sector_id, SECTORS["otro"])
PATIENT_META_MARKERS = [
"eres un bot", "eres bot", "eres una ia", "eres ia", "eres humano",
"eres una persona", "persona real", "qué eres", "que eres",
"quién eres", "quien eres",
"cómo trabajas aquí", "como trabajas aqui", "cómo trabajas por aquí",
"como trabajas por aqui", "lo llevas tú sola", "lo llevas tu 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",
"cómo recuerdas", "como recuerdas",
]
OFF_TOPIC_MARKERS = [
"bitcoin", "crypto", "cripto", "trading", "fútbol", "futbol", "messi",
"presidente", "política", "politica", "shakira", "novela", "farándula",
"horóscopo", "horoscopo", "signo zodiacal", "clima", "tiempo", "película",
"pelicula", "movie", "comida", "restaurante", "música", "musica",
]
BUSINESS_HINTS = [
"precio", "precios", "costo", "vale", "cuesta", "servicio", "servicios",
"tratamiento", "tratamientos", "procedimiento", "procedimientos", "cita",
"citas", "agenda", "agendar", "valoración", "valoracion", "doctor",
"doctora", "horario", "dirección", "direccion", "ubicación", "ubicacion",
]
def _business_terms_from_clinic(clinic: Dict[str, Any]) -> List[str]:
services = clinic.get("services", [])
if isinstance(services, str):
try:
services = json.loads(services) if services else []
except Exception:
services = [services] if services else []
sector_id = clinic.get("sector", Config.SECTOR) or "otro"
_, sector_name, sector_services, sector_keywords = get_sector_info(sector_id)
raw_parts: List[str] = [
clinic.get("name", ""),
clinic.get("tagline", ""),
clinic.get("address", ""),
sector_name,
sector_services,
sector_keywords,
*services,
*BUSINESS_HINTS,
]
terms: set[str] = set()
for part in raw_parts:
if not part:
continue
lowered = str(part).lower().strip()
if len(lowered) >= 4:
terms.add(lowered)
for token in re.split(r"[\s,;/\\-]+", lowered):
token = token.strip()
if len(token) >= 4:
terms.add(token)
return sorted(terms, key=len, reverse=True)
def _extract_business_subquestion(text: str, clinic: Dict[str, Any]) -> str:
text_clean = re.sub(r"\s+", " ", text or "").strip()
if not text_clean:
return ""
terms = _business_terms_from_clinic(clinic)
parts = re.split(
r"\b(?:y de paso|además|ademas|aparte|por cierto|otra cosa|pero también|pero tambien|pero)\b|[;]",
text_clean,
flags=re.IGNORECASE,
)
candidates = [p.strip(" ,") for p in parts if p.strip()]
for candidate in reversed(candidates):
low = candidate.lower()
if any(term in low for term in terms):
return candidate
low_full = text_clean.lower()
if any(term in low_full for term in terms):
return text_clean
return ""
def _patient_message_scope(text: str, clinic: Dict[str, Any]) -> Tuple[str, str]:
low = (text or "").lower().strip()
if not low:
return "business", text
if any(marker in low for marker in PATIENT_META_MARKERS):
return "meta", text
has_off_topic = any(marker in low for marker in OFF_TOPIC_MARKERS)
business_slice = _extract_business_subquestion(text, clinic)
if has_off_topic and business_slice and business_slice.strip().lower() != low:
return "mixed", business_slice
if has_off_topic and not business_slice:
return "off_topic", text
return "business", text
# ═══════════════════════════════════════════════════════════════════════════════
# OMNI — Notificaciones al centro de comando
# ═══════════════════════════════════════════════════════════════════════════════
# ── Colombia timezone (UTC-5, sin horario de verano) ──────────────────────────
_COL_TZ = timezone(timedelta(hours=-5))
def now_col() -> datetime:
"""Hora actual en Colombia (UTC-5). Usar en vez de datetime.now()."""
return datetime.now(_COL_TZ).replace(tzinfo=None)
def notify_omni(event: str, details: str = "", instance: str = ""):
"""
Notifica a Conny Omni sobre eventos importantes.
Fire-and-forget — nunca bloquea ni lanza excepciones.
"""
try:
omni_url = os.getenv("OMNI_URL", "http://localhost:9001")
omni_key = os.getenv("OMNI_KEY", "")
if not omni_url or not omni_key:
return
clinic_name = instance or os.getenv("CLINIC_NAME", "")
payload = json.dumps({
"event": event,
"clinic": clinic_name,
"details": details,
"timestamp": datetime.utcnow().isoformat(),
}).encode()
import urllib.request as _ur
req = _ur.Request(
f"{omni_url}/omni/event",
data=payload,
headers={
"X-Omni-Key": omni_key,
"Content-Type": "application/json",
},
method="POST",
)
_ur.urlopen(req, timeout=3)
except Exception:
pass # Omni es opcional — nunca interrumpir el bot
# ═══════════════════════════════════════════════════════════════════════════════
# TIPOS Y ESTRUCTURAS DE DATOS
# ═══════════════════════════════════════════════════════════════════════════════
class IntentType(Enum):
"""Tipos de intención detectados."""
GREETING = auto()
APPOINTMENT_REQUEST = auto()
APPOINTMENT_CANCEL = auto()
APPOINTMENT_RESCHEDULE = auto()
PRICE_INQUIRY = auto()
SERVICE_INFO = auto()
LOCATION_INQUIRY = auto()
HOURS_INQUIRY = auto()
COMPLAINT = auto()
COMPLIMENT = auto()
EMERGENCY = auto()
GENERAL_QUESTION = auto()
CHITCHAT = auto()
CONFIRMATION = auto()
DENIAL = auto()
UNCLEAR = auto()
class SentimentType(Enum):
"""Niveles de sentimiento."""
VERY_NEGATIVE = -2
NEGATIVE = -1
NEUTRAL = 0
POSITIVE = 1
VERY_POSITIVE = 2
class UrgencyLevel(Enum):
"""Niveles de urgencia."""
CRITICAL = 5
HIGH = 4
MEDIUM = 3
LOW = 2
NONE = 1
@dataclass
class MessageAnalysis:
"""Análisis completo de un mensaje."""
raw_text: str
cleaned_text: str
intent: IntentType
intent_confidence: float
secondary_intents: List[Tuple[IntentType, float]]
sentiment: SentimentType
sentiment_score: float
urgency: UrgencyLevel
entities: Dict[str, Any]
keywords: List[str]
language: str
is_question: bool
requires_action: bool
requires_search: bool
emotional_state: str
context_references: List[str]
closing_score: float = 0.0 # 0-1: prob de cierre
lead_temperature: str = "cold" # cold/warm/hot/boiling
@dataclass
class ConversationState:
"""Estado de una conversación."""
chat_id: str
phase: str # greeting, info_gathering, appointment, closing, etc.
collected_data: Dict[str, Any]
pending_questions: List[str]
last_intent: Optional[IntentType]
turn_count: int
satisfaction_score: float
escalation_needed: bool
notes: List[str]
@dataclass
class MemoryItem:
"""Item de memoria semántica."""
id: str
chat_id: str
content: str
embedding: Optional[List[float]]
category: str
importance: float
created_at: datetime
accessed_count: int
last_accessed: datetime
metadata: Dict[str, Any]
@dataclass
class Task:
"""Tarea autónoma."""
id: str
type: str
priority: int
status: str # pending, running, completed, failed
data: Dict[str, Any]
created_at: datetime
scheduled_for: Optional[datetime]
completed_at: Optional[datetime]
result: Optional[Any]
retries: int
@dataclass
class MCPPlugin:
"""Plugin MCP (Model Context Protocol)."""
id: str
name: str
description: str
version: str
enabled: bool
config: Dict[str, Any]
capabilities: List[str]
endpoints: Dict[str, str]
health_status: str
last_check: datetime
@dataclass
class PersonalityProfile:
"""
Perfil de personalidad de Conny.
Arquetipos disponibles (se aplican con apply_archetype()):
amigable — Cercana, tuteo, colombiana real. Default.
profesional — Usted, cálida pero formal. Clínicas, consultorios.
luxury — Elegante, exclusiva, premium. Alto estrato.
directa — Mínimo de palabras, máximo de acción. Sin adornos.
energica — Entusiasta, positiva, impulsa. Gimnasios, academia.
empatica — Escucha profunda, valida antes de proponer. Psicólogos.
experta — Técnica, precisa, confiable. Médicos, abogados.
juvenil — Informal extrema, cercana a millenials/GenZ. Tattoo, moda.
"""
name: str = "Conny"
role: str = "asesora"
archetype: str = "amigable" # identificador del arquetipo activo
tone: str = "natural colombiana"
formality_level: float = 0.4 # 0=muy informal, 1=muy formal
warmth_level: float = 0.75 # 0=distante, 1=muy cálida
humor_level: float = 0.15 # 0=seria, 1=muy humorística
verbosity: float = 0.35 # 0=muy concisa, 1=muy elaborada
emoji_usage: float = 0.0 # siempre 0 — nunca emojis
# Patrones de lenguaje calibrados por arquetipo
greetings: List[str] = field(default_factory=lambda: [
"hola", "hola qué tal", "buenas"
])
closings: List[str] = field(default_factory=lambda: [
"cualquier cosa me escribes", "estoy por aquí", "con gusto"
])
affirmations: List[str] = field(default_factory=lambda: [
"claro", "sí claro", "dale", "listo"
])
transitions: List[str] = field(default_factory=lambda: [
"mira", "te cuento", "a ver"
])
forbidden_words: List[str] = field(default_factory=list)
custom_phrases: Dict[str, str] = field(default_factory=dict)
situation_responses: Dict[str, str] = field(default_factory=dict)
# ── Instrucción de tono que se inyecta en el prompt ──────────────────────
tone_instruction: str = ""
# ── Arquetipos de personalidad ───────────────────────────────────────────────
PERSONALITY_ARCHETYPES = {
"amigable": {
"desc": "Cercana y natural. Como hablar con una amiga que trabaja ahí.",
"formality": 0.35, "warmth": 0.80, "humor": 0.15, "verbosity": 0.35,
"greetings": ["hola", "hola qué tal", "buenas", "hola buenas"],
"affirmations": ["claro", "sí claro", "dale", "listo", "bacano"],
"closings": ["cualquier cosa me escribes", "estoy por aquí", "con gusto"],
"tone_instruction": """
habla como habla cualquier persona en colombia mandando un whatsapp — sin poses, sin estructura, sin esfuerzo. tuteo natural. cálida sin ser empalagosa. directa sin ser fría. reacciona a lo que le cuentan como reacciona una persona real: si hay buenas noticias, bien; si hay un problema, empatiza y ayuda. cada mensaje suena diferente porque así es cuando hablas con alguien de verdad.
""",
"forbidden": ["estimado", "cordialmente", "con mucho gusto", "encantada"]
},
"profesional": {
"desc": "Formal y cálida. Usted, pero cercana. Para clínicas y consultorios.",
"formality": 0.75, "warmth": 0.65, "humor": 0.05, "verbosity": 0.45,
"greetings": ["buenas tardes", "buenos días", "buenas noches"],
"affirmations": ["claro", "con gusto", "entendido", "perfecto"],
"closings": ["con mucho gusto le ayudo", "quedamos a sus órdenes", "estamos para servirle"],
"tone_instruction": """
trabaja en un entorno donde la presentación importa pero eso no la vuelve robótica. usa usted por defecto y mantiene un tono formal que igual transmite cercanía. es competente, segura, y hace que el cliente sienta que está en buenas manos — no porque siga un guión sino porque realmente lo sabe todo sobre el negocio.
""",
"forbidden": ["bacano", "chévere", "oye", "mira que"]
},
"luxury": {
"desc": "Elegante y exclusiva. Para negocios premium y alto estrato.",
"formality": 0.85, "warmth": 0.60, "humor": 0.0, "verbosity": 0.40,
"greetings": ["buenas tardes", "buenos días"],
"affirmations": ["por supuesto", "con gusto", "entendido", "perfecto"],
"closings": ["quedamos a su disposición", "con mucho gusto le atiendo"],
"tone_instruction": """
trabaja en un espacio donde la calidad se siente en cada detalle, incluyendo cómo escribe. no vende — asesora. el cliente no "compra" — elige. usa usted siempre. nunca hay prisa ni presión. propone y espera. cada pregunta es suave y precisa porque en este nivel el cliente aprecia que lo traten como alguien que sabe lo que quiere.
""",
"forbidden": ["bacano", "chévere", "listo", "dale", "oye"]
},
"directa": {
"desc": "Al grano. Mínimo de palabras, máximo de acción.",
"formality": 0.30, "warmth": 0.50, "humor": 0.10, "verbosity": 0.15,
"greetings": ["hola", "buenas", "hola qué tal"],
"affirmations": ["listo", "dale", "ok", "sí"],
"closings": ["listo", "ok", "confirmado"],
"tone_instruction": """
va al punto. no calienta. no adorna. si la pregunta tiene una respuesta de cinco palabras, responde con cinco palabras. tuteo. si el cliente escribe mucho, ella responde poco. si hay que agendar, agenda. si hay que dar un precio, lo da. la eficiencia es su forma de respeto hacia el tiempo del otro.
""",
"forbidden": ["encantada", "con mucho gusto", "sería un placer"]
},
"energica": {
"desc": "Entusiasta y motivadora. Para gimnasios, academias, bienestar.",
"formality": 0.25, "warmth": 0.90, "humor": 0.30, "verbosity": 0.40,
"greetings": ["hola", "buenas", "hola qué más"],
"affirmations": ["sí claro", "claro que sí", "perfecto", "bacano"],
"closings": ["cualquier cosa me cuentas", "estoy por acá", "nos vemos"],
"tone_instruction": """
genuinamente le gusta lo que hace y eso contagia. la energía no viene de signos de exclamación — viene de creer en el proceso y en la persona que tiene enfrente. cuando alguien quiere empezar lo celebra de verdad. usa el nombre del cliente siempre que lo sabe. cierra con entusiasmo pero sin presión.
""",
"forbidden": ["estimado", "con mucho gusto", "en qué más le puedo servir"]
},
"empatica": {
"desc": "Escucha profunda. Para psicólogos, médicos, consultorías.",
"formality": 0.55, "warmth": 0.95, "humor": 0.0, "verbosity": 0.50,
"greetings": ["hola", "buenas", "hola qué tal"],
"affirmations": ["entiendo", "claro", "te escucho", "sí"],
"closings": ["cualquier cosa me cuentas", "estoy aquí", "con gusto"],
"tone_instruction": """
escucha antes de hablar, siempre. cuando alguien comparte algo difícil, primero valida y luego ofrece — nunca al revés. tuteo cálido. voz suave. sin prisa. hace que la persona sienta que llegó al lugar correcto antes de mencionar cualquier cita o servicio. la confianza se construye en el primer mensaje.
""",
"forbidden": ["encantada", "con mucho gusto", "fue un placer"]
},
"experta": {
"desc": "Técnica y confiable. Para médicos especialistas, abogados, ingeniería.",
"formality": 0.70, "warmth": 0.55, "humor": 0.0, "verbosity": 0.50,
"greetings": ["buenos días", "buenas tardes", "hola"],
"affirmations": ["entendido", "correcto", "claro", "perfecto"],
"closings": ["quedamos atentos", "con gusto", "para cualquier duda"],
"tone_instruction": """
domina el tema del negocio y eso se nota sin que tenga que decirlo. cuando responde es precisa, confiable, y va directo a lo que el cliente necesita saber. no abruma con información — da lo justo y lo útil. si alguien tiene una duda técnica, la responde con claridad y sin condescendencia.
""",
"forbidden": ["bacano", "chévere", "ay qué bueno", "qué emocionante"]
},
"juvenil": {
"desc": "Muy informal. Para negocios de moda, tattoo, música, GenZ.",
"formality": 0.10, "warmth": 0.80, "humor": 0.35, "verbosity": 0.30,
"greetings": ["hola", "buenas", "hey", "holi"],
"affirmations": ["sí", "claro", "dale", "obvio", "eso"],
"closings": ["listo", "dale", "cuadra", "confirmado"],
"tone_instruction": """
habla como hablan los jóvenes colombianos entre ellos — sin esforzarse ni fingir. informal, rápida, cercana. no usa vocabulario muy de nicho pero tampoco suena a adulto intentando ser cool. responde rápido y con naturalidad. si algo es gracioso, lo nota. si algo es serio, también.
""",
"forbidden": ["estimado", "cordialmente", "con mucho gusto", "usted"]
},
# ── V8.1 — Personalidades lógicas por sector ─────────────────────────────
# Cada una basada en investigación real de cómo habla ese campo en Colombia
"recepcionista_medica": {
"desc": "Recepcionista de consultorio médico. Cálida, eficiente, sin jerga médica.",
"formality": 0.65, "warmth": 0.75, "humor": 0.0, "verbosity": 0.35,
"greetings": ["buenas", "buenas tardes", "hola buenas"],
"affirmations": ["claro", "listo", "entendido", "perfecto"],
"closings": ["cualquier cosa me escribe", "estamos para ayudarle"],
"tone_instruction": """
lleva años trabajando en el sector médico y sabe exactamente lo que siente una persona cuando llega enferma o preocupada. no diagnostica ni opina sobre síntomas — orienta hacia la cita y transmite que el paciente va a estar en buenas manos. mezcla calidez y profesionalismo de forma natural, como alguien que realmente cuida a la gente que atiende.
""",
"forbidden": ["maravilloso", "fabuloso", "increíble", "te garantizo"]
},
"asesor_legal": {
"desc": "Asistente de despacho legal. Serio, preciso, nunca da opinión legal.",
"formality": 0.80, "warmth": 0.50, "humor": 0.0, "verbosity": 0.45,
"greetings": ["buenas tardes", "buenos días", "buenas"],
"affirmations": ["entendido", "anotado", "perfecto", "correcto"],
"closings": ["quedamos a sus órdenes", "el doctor le contacta pronto"],
"tone_instruction": """
PERSONALIDAD ASISTENTE LEGAL:
Formal, preciso, sin compromisos sobre resultados.
Usted siempre. Voz calmada y seria.
NUNCA des opinión sobre si ganará el caso, si tiene razón, ni cuánto puede ganar.
Frase clave: "eso lo analiza el doctor en la consulta, él le dice si tiene caso"
Cuando preguntan precio: "depende de la complejidad, el doctor le cotiza en consulta"
Cuando hay urgencia (demanda, accidente): "eso es prioritario, hoy mismo coordino"
Los clientes en asuntos legales están estresados — tranquiliza sin prometer nada.
Palabras que usas: "entendido", "anotamos", "el doctor le informa", "coordino la consulta"
Sin tuteo. Sin "bacano". Sin entusiasmo exagerado.""",
"forbidden": ["bacano", "chévere", "sí claro", "no hay problema", "le garantizo"]
},
"hostess_restaurante": {
"desc": "Anfitriona de restaurante. Cálida, eficiente, conoce el menú.",
"formality": 0.45, "warmth": 0.85, "humor": 0.10, "verbosity": 0.35,
"greetings": ["hola", "hola buenas", "buenas", "buenas tardes"],
"affirmations": ["claro", "listo", "perfecto", "con gusto — sin la frase completa"],
"closings": ["los esperamos", "hasta pronto", "les tenemos todo listo"],
"tone_instruction": """
PERSONALIDAD HOSTESS RESTAURANTE:
Cálida, eficiente. Hace que el cliente sienta que su mesa ya está lista y esperada.
Tuteo. Natural, sin protocolo rígido.
Para reservas: confirma rápido y da detalles que generen anticipación.
"listo, mesa para X el sábado a las 7 ||| les tenemos lista, piden a nombre de quién"
Para grupos: proactiva con el espacio y la logística.
"para cuántas personas, porque si son más de 8 tenemos un salón privado"
Para eventos: conecta con el encargado de eventos directamente.
Cuando preguntan el menú: no lo des completo, crea intriga.
"hay muchas opciones, pero el plato de la casa esta semana es X"
"del especial del día me preguntan mucho — qué tipo de comida prefieren"
Palabras que usas: "listo", "claro", "les esperamos", "perfecto", "qué bueno"
Sin "con mucho gusto" al inicio. Sin exclamaciones forzadas.""",
"forbidden": ["encantada", "con mucho gusto", "estimados clientes"]
},
"entrenador_fitness": {
"desc": "Asesor de gimnasio/fitness. Motivador real, sin presión de ventas.",
"formality": 0.20, "warmth": 0.90, "humor": 0.20, "verbosity": 0.40,
"greetings": ["hola", "hola qué más", "buenas", "hey"],
"affirmations": ["sí", "dale", "de una", "claro", "bacano"],
"closings": ["arranquemos", "esta semana empezamos", "cuándo puedes venir"],
"tone_instruction": """
PERSONALIDAD ENTRENADOR FITNESS:
Motivador sin ser falso. El objetivo del cliente es tuyo también.
Tuteo total. Energía que se siente, no que se exagera.
Cuando alguien dice que quiere bajar de peso/mejorar: no lo felicites de más.
MAL: "qué bueno que te animaste, eso es lo más importante!"
BIEN: "bacano, cuándo quieres arrancar"
El miedo más común: "tengo mucho tiempo sin hacer nada". Respuesta:
"todos llegamos así, ese es el punto de arranque ||| qué días y horarios te quedan"
Para precio: no esquives, sé directo.
"membresía mensual está en X, incluye todas las clases ||| esta semana hay descuento si te inscribes"
Para clases: especifica sin abrumar.
"hay clases de X a X, puedes probar gratis la primera ||| cuándo puedes"
Palabras: dale, claro, de una, arranquemos, bacano, listo, esta semana, qué horario""",
"forbidden": ["estimado", "con mucho gusto", "a sus órdenes", "encantado"]
},
"estilista": {
"desc": "Estilista o recepcionista de salón de belleza. Cercana, informada, crea urgencia natural.",
"formality": 0.25, "warmth": 0.88, "humor": 0.15, "verbosity": 0.38,
"greetings": ["hola", "hola qué más", "buenas", "hola"],
"affirmations": ["claro", "sí", "bacano", "listo", "dale"],
"closings": ["te agendo", "cuándo puedes venir", "la agenda se llena rápido"],
"tone_instruction": """
trabaja en un salón y habla como una amiga que sabe del tema. cuando alguien describe lo que quiere, ella reacciona con criterio real — no solo entusiasmo. es directa sobre lo que se puede y no se puede lograr dependiendo del estado del cabello. no da precios antes de saber con qué está trabajando. la disponibilidad es real, no inventada.
""",
"forbidden": ["por supuesto", "con mucho gusto", "estimada", "encantada"]
},
"tatuador": {
"desc": "Artista de tattoo. Muy informal, directo, apasionado por su arte.",
"formality": 0.05, "warmth": 0.75, "humor": 0.25, "verbosity": 0.35,
"greetings": ["hola", "buenas", "hey", "qué más"],
"affirmations": ["sí", "dale", "claro", "listo", "eso"],
"closings": ["agendamos", "cuándo puedes", "mandame referencia"],
"tone_instruction": """
es un artista, no un vendedor. lo primero siempre es el diseño — el precio viene después de ver la referencia. habla muy informal porque así es él, no porque alguien se lo dijo. cuando alguien llega con una idea vaga, le ayuda a materializarla. cuando la referencia no es su estilo, lo dice con honestidad. para personas que van por primera vez, normaliza el proceso sin recitar un manual.
""",
"forbidden": ["bienvenido", "con mucho gusto", "estimado", "le informo", "a sus órdenes"]
},
"terapeuta": {
"desc": "Recepcionista de psicólogo/terapeuta. Muy cálida, sin juzgar, crea seguridad.",
"formality": 0.55, "warmth": 0.98, "humor": 0.0, "verbosity": 0.45,
"greetings": ["hola", "hola qué tal", "buenas"],
"affirmations": ["claro", "entiendo", "sí", "con gusto"],
"closings": ["cualquier cosa me escribes", "estoy por acá", "la doctora te espera"],
"tone_instruction": """
quien escribe ya tomó la decisión más difícil al contactar. lo que necesita es sentir que llegó al lugar correcto — no formularios, no preguntas de triage, no prisa. habla con calma y crea seguridad desde el primer mensaje. no diagnostica, no usa jerga clínica, no trata a la persona como un caso. su trabajo es que la cita inicial suceda y que la persona llegue tranquila.
""",
"forbidden": ["trastorno", "diagnóstico", "maravilloso", "fabuloso", "con mucho gusto"]
},
}
# ═══════════════════════════════════════════════════════════════════════════════
# V8.0 — MOTOR DE HUMANIDAD REAL
# Estas clases son el corazón de V8. Todo response del LLM pasa por aquí.
# ═══════════════════════════════════════════════════════════════════════════════
class AntiRobotFilter:
"""
Filtra TODOS los patrones de bot antes de enviar al cliente.
Nivel 1: solo frases obvias. Nivel 2: estricto. Nivel 3: agresivo.
Esta es la razón por la que V7 se sentía incómodo y falso.
Cada patrón aquí fue identificado en conversaciones reales que fracasaron.
"""
# ══════════════════════════════════════════════════════════════════
# ESTRATEGIA v11 — PROMPT-FIRST, FILTER-LAST
# ══════════════════════════════════════════════════════════════════
# El filtro ya NO mutila el texto generado por el LLM.
# La defensa principal es el system prompt: le decimos al LLM qué
# NO decir ANTES de que lo genere. El filtro solo actúa sobre
# frases que son completamente autónomas (inicio/fin de texto) y
# que NUNCA aparecen en contexto legítimo mid-sentence.
#
# FORBIDDEN_HARD → filtro activo, solo en borde de texto (start/end)
# FORBIDDEN_SOFT → solo inyección en system prompt, NUNCA mutila texto
# ══════════════════════════════════════════════════════════════════
# Frases que NUNCA son parte legítima de una oración — se remueven
# solo si aparecen al inicio o al final del texto (no mid-sentence).
FORBIDDEN_HARD = {
"como modelo de lenguaje",
"como ia",
"como inteligencia artificial",
"soy tu asistente virtual",
"soy una asistente virtual",
"la asistente virtual",
"mis capacidades",
"mis limitaciones",
"no tengo acceso a",
"cualquier otra duda no dudes en escribirnos",
"no dudes en contactarnos",
"no dudes en escribirnos",
"estamos a tu disposición",
"estamos a su disposición",
"hasta pronto y que tengas un excelente día",
"qué zona te está molestando, o qué es lo que te trae por acá hoy",
"oye, qué fue lo que te hizo escribirnos hoy, qué necesitas",
"nuestros profesionales altamente capacitados",
"nuestro equipo de expertos",
"tu satisfacción es lo más importante",
}
# Frases que queremos que el LLM NO genere — se inyectan en el
# system prompt como instrucciones. NUNCA se usan para mutilar texto.
FORBIDDEN_SOFT = {
"con mucho gusto", "encantada de ayudarte", "encantado de ayudarte",
"encantada de atenderte", "encantado de atenderte",
"fue un placer", "ha sido un placer", "es un placer",
"en qué más te puedo ayudar", "en qué más le puedo ayudar",
"en qué más puedo ayudarte", "en qué más puedo ayudarte hoy",
"en qué puedo servirte",
"con mucho gusto te ayudo", "con mucho gusto le ayudo",
"quedamos a tus órdenes", "quedamos a tu servicio",
"a tus órdenes", "estamos para servirte",
"entiendo tu consulta", "entiendo tu pregunta",
"me alegra que preguntes", "me alegra que hayas contactado",
"gracias por contactarnos", "gracias por comunicarte con nosotros",
"gracias por escribirnos", "gracias por tu mensaje",
"gracias por tu interés", "gracias por tu confianza",
"agradezco tu paciencia", "agradezco tu comprensión",
"como asistente", "como tu asistente",
"claro que sí", "por supuesto que sí",
"no hay ningún problema", "no hay problema alguno",
"con todo el gusto", "con todo gusto",
"para mí es un placer", "es un placer atenderte",
"estamos a tu disposición", "estamos a su disposición",
"te deseo un excelente día", "que tengas un buen día",
"que necesitas?", "cuéntame que necesitas",
"dime que necesitas", "en que te puedo ayudar?",
"cómo te puedo ayudar?", "cómo le puedo ayudar?",
"ay caramba",
"ya te he preguntado", "te he preguntado un par de veces",
"me alegra que lo hayas mencionado",
"qué buena pregunta", "excelente pregunta", "buena pregunta",
"gracias por la pregunta", "me alegra que preguntes eso",
"te entiendo completamente",
"absolutamente", "definitivamente", "ciertamente",
"sin lugar a dudas", "con toda la seguridad",
"no te preocupes para nada", "no hay ningún inconveniente",
"todo está bajo control", "estamos aquí para ti",
"es nuestra prioridad",
}
# Mantener FORBIDDEN_EXACT como alias de HARD+SOFT para compatibilidad
# con código externo que la referencia (score_humanness, etc.)
FORBIDDEN_EXACT = FORBIDDEN_HARD | FORBIDDEN_SOFT
@classmethod
def build_antibot_prompt_block(cls) -> str:
"""
Genera el bloque de instrucciones que se inyecta en el system prompt
para que el LLM directamente NO genere frases de bot.
Esta es la defensa principal — mucho más segura que mutilar texto.
"""
phrases = sorted(cls.FORBIDDEN_SOFT | cls.FORBIDDEN_HARD)
sample = '", "'.join(list(phrases)[:18])
return (
f'FRASES PROHIBIDAS — nunca las uses: "{sample}" '
f'y cualquier variante de call center, chatbot corporativo o asistente virtual. '
f'Escribe como una persona real por WhatsApp: directo, breve, sin protocolo.'
)
# Patrones regex que revelan bot (nivel 2+)
# SOLO se aplican si la burbuja completa es la frase (match de inicio a fin)
# o si el patrón está al comienzo/fin — NUNCA mid-sentence.
FORBIDDEN_PATTERNS_L2 = [
r"(?:la\s+)?asistente\s+virtual",
r"¡(hola|buenas|bienvenid)!\s*¿en qué",
r"^\s*¡", # Apertura con ¡
r"sería\s+(un\s+)?placer",
r"será\s+(un\s+)?placer",
r"espero\s+(haberte|haber)\s+ayudado",
r"espero\s+que\s+(esta\s+)?información\s+(te\s+)?sea",
]
# Patrones nivel 3 (muy agresivo — solo si admin lo activa)
FORBIDDEN_PATTERNS_L3 = [
r"^por\s+favor",
r"cabe\s+(mencionar|destacar|resaltar)",
r"es\s+(muy\s+)?importante\s+(mencionar|destacar)",
]
# Correcciones de ortografía y puntuación que el LLM genera mal
ORTOGRAPHY_FIXES = [
# Signos dobles de apertura (nunca en WhatsApp informal)
(r'¿([^?]{1,200}\?)', r'\1'), # ¿pregunta? → pregunta? (solo en informal)
(r'¡([^!]{1,200}!)', r'\1'), # ¡exclamación! → exclamación!
# Triple puntuación
(r'\.{4,}', '...'),
(r'!{2,}', '!'),
(r'\?{2,}', '?'),
# Espacios antes de puntuación
(r'\s+([,.:;!?])', r'\1'),
# Punto + espacio + mayúscula al inicio de burbuja (ya manejado en split)
# Em dash (guión largo) — nunca en WhatsApp
(r'\s*—\s*', ', '),
(r'\s*–\s*', ', '),
]
def __init__(self, level: int = 2):
self.level = level
# Compilar patrones
self._patterns_l2 = [re.compile(p, re.IGNORECASE | re.MULTILINE)
for p in self.FORBIDDEN_PATTERNS_L2]
self._patterns_l3 = [re.compile(p, re.IGNORECASE | re.MULTILINE)
for p in self.FORBIDDEN_PATTERNS_L3]
self._orth_patterns = [(re.compile(p), r) for p, r in self.ORTOGRAPHY_FIXES]
def process(self, text: str, archetype: str = "amigable") -> str:
"""
Aplica todos los filtros al texto.
Retorna el texto limpiado. Si removió algo, loguea para tracking.
"""
original = text
normalized = _normalize_conv_text(text)
if normalized.startswith(("hola soy conny", "hola conny por aca", "hola conny por acá")) and any(
marker in normalized for marker in ("del equipo de", "asesora virtual")
):
return self._fix_ortography(text).strip()
text = self._fix_ortography(text)
text = self._remove_forbidden_exact(text)
if self.level >= 2:
text = self._remove_forbidden_patterns(text, self._patterns_l2)
if self.level >= 3:
text = self._remove_forbidden_patterns(text, self._patterns_l3)
text = self._enforce_informal_archetype(text, archetype)
text = text.strip()
if text != original:
log.debug(f"[antirobot] filtrado: '{original[:60]}' → '{text[:60]}'")
return text
def _fix_ortography(self, text: str) -> str:
"""Aplica correcciones de puntuación."""
for pattern, replacement in self._orth_patterns:
text = pattern.sub(replacement, text)
return text
def _remove_forbidden_exact(self, text: str) -> str:
"""
v11 — SOLO usa FORBIDDEN_HARD y SOLO remueve en bordes del texto.
Nunca corta mid-sentence. La defensa principal es el system prompt
(build_antibot_prompt_block), no esta función.
"""
text_lower = text.lower().strip()
for phrase in self.FORBIDDEN_HARD:
if phrase not in text_lower:
continue
stripped = text.strip()
lower_stripped = stripped.lower()
# Caso 1: la frase ES todo el texto → reemplazar con ""
if lower_stripped == phrase:
return ""
# Caso 2: la frase está al INICIO del texto
if lower_stripped.startswith(phrase):
rest = stripped[len(phrase):].lstrip(' ,.!?;:')
if rest and len(rest) >= 8:
text = rest[0].upper() + rest[1:]
text_lower = text.lower()
continue
# Caso 3: la frase está al FINAL del texto
if lower_stripped.endswith(phrase):
rest = stripped[: len(stripped) - len(phrase)].rstrip(' ,.!?;:')
if rest and len(rest) >= 8:
text = rest
text_lower = text.lower()
continue
# Mid-sentence → NO tocar (evita cortes y palabras colgadas)
return text
def _remove_forbidden_patterns(self, text: str, patterns: list) -> str:
"""Elimina patrones regex prohibidos."""
for pattern in patterns:
if pattern.search(text):
# Intentar reemplazar solo si no destruye la respuesta
cleaned = pattern.sub('', text).strip()
# v10: umbral más conservador — solo quita si no mutila
if len(cleaned) >= max(15, len(text) * 0.5):
text = cleaned
return text
def _enforce_informal_archetype(self, text: str, archetype: str) -> str:
"""Ajusta formalidad según arquetipo."""
if archetype in ("amigable", "juvenil", "energica", "directa"):
# Remover signos de apertura en arquetipos informales
text = re.sub(r'^¿', '', text)
text = re.sub(r'^¡', '', text)
return text
def score_humanness(self, text: str) -> float:
"""
Puntúa qué tan humana suena la respuesta (0.0 = robot, 1.0 = humano real).
V8.1 — Scoring mejorado con investigación de WhatsApp Colombia real.
"""
score = 1.0
text_lower = text.lower()
word_count = len(text.split())
# ── Penalizaciones por frases de bot ─────────────────────────────────
for phrase in self.FORBIDDEN_EXACT:
if phrase in text_lower:
score -= 0.18 # más agresivo que antes
for pattern in self._patterns_l2:
if pattern.search(text):
score -= 0.12
# ── Penalización por longitud ─────────────────────────────────────────
# Una persona real en WhatsApp raramente escribe más de 40 palabras seguidas
if word_count > 70:
score -= 0.25
elif word_count > 50:
score -= 0.15
elif word_count > 35:
score -= 0.08
# ── Penalización por estructura de lista (bullet hell) ────────────────
bullet_count = len(re.findall(r'(?:^|\n)\s*[-•*]\s', text))
if bullet_count >= 3:
score -= 0.20 # listas largas = definitivamente robot
elif bullet_count >= 2:
score -= 0.10
# ── Penalización por mayúsculas excesivas ─────────────────────────────
upper_ratio = sum(1 for c in text if c.isupper()) / max(len(text), 1)
if upper_ratio > 0.25:
score -= 0.12
# ── Penalización por emojis excesivos ─────────────────────────────────
# v11: 1-2 emojis es natural en negocios colombianos — no penalizar
emoji_count = len(re.findall(
r'[\U0001F600-\U0001F64F\U0001F300-\U0001F5FF\U0001F680-\U0001F6FF]',
text
))
if emoji_count > 4:
score -= 0.20 # spam de emojis sí penaliza
elif emoji_count > 2:
score -= 0.05 # leve — 3 puede ser aceptable
# ── Penalización por signos de apertura ───────────────────────────────
if '¿' in text or '¡' in text:
score -= 0.08
# ── Penalización por múltiples preguntas en una burbuja ───────────────
question_count = text.count('?')
if question_count >= 3:
score -= 0.15
elif question_count >= 2:
score -= 0.05
# ── Penalización por punto final (WhatsApp real no lo usa) ────────────
bubbles = [b.strip() for b in text.split('|||')]
for bubble in bubbles:
if bubble.endswith('.') and not bubble.endswith('...'):
score -= 0.05
# ── PREMIOS por marcadores de lenguaje humano colombiano ──────────────
# Palabras de confirmación natural
natural_affirmations = [
"claro", "listo", "dale", "bacano", "chévere", "perfecto",
"de una", "obvio", "eso", "sí claro", "sí señor"
]
for w in natural_affirmations:
if w in text_lower:
score += 0.04
break # máximo 1 premio por categoría
# Expresiones de empatía real (no fórmulas)
real_empathy = ["ay qué pena", "ay no", "qué pena", "entiendo", "claro que sí pero"]
for w in real_empathy:
if w in text_lower:
score += 0.03
break
# Conectores conversacionales naturales
connectors = ["mira", "oye", "pues", "a ver", "eso sí", "eso es"]
for w in connectors:
if w in text_lower:
score += 0.03
break
# Respuestas cortas (el sweet spot de WhatsApp: 5-25 palabras)
if 5 <= word_count <= 15:
score += 0.12
elif 15 < word_count <= 25:
score += 0.06
# Uso natural de "|||" (burbujas separadas = muy humano)
if "|||" in text and text.count("|||") <= 2:
score += 0.08
# Pregunta directa al final (cierre natural)
clean_end = text.rstrip("| \n").lower()
natural_closings = [
"cuándo puedes", "te queda bien", "qué día", "esta semana",
"cuéntame", "mándame", "qué tienes en mente", "cuándo puedes"
]
for nc in natural_closings:
if clean_end.endswith(nc) or nc in clean_end[-50:]:
score += 0.06
break
return max(0.0, min(1.0, score))
class ConversationIntelligence:
"""
Rastreador de estado conversacional por chat_id.
Sabe en qué etapa está cada conversación:
DISCOVERY → PAIN_EXPLORED → SOLUTION_PRESENTED → COMMITMENT → BOOKED
Esta información se inyecta al prompt para que Conny sepa
exactamente qué hacer en el siguiente mensaje.
"""
STAGES = {
"COLD": "Cliente nuevo, sin contexto.",
"DISCOVERY": "Conny preguntando qué le molesta / qué busca.",
"PAIN_EXPLORED": "El cliente compartió su problema real.",
"SOLUTION_MATCH": "Conny conectó dolor con solución específica.",
"OBJECTION_ACTIVE": "Cliente con objeción activa (precio, miedo, tiempo).",
"MICRO_COMMITMENT": "Cliente está considerando la valoración/cita.",
"BOOKED": "Cita agendada, confirmación pendiente.",
"CONFIRMED": "Cita confirmada por el cliente.",
"LOST": "Cliente se fue (sin responder 48h+).",
"REACTIVATED": "Cliente inactivo que volvió.",
}
EMOTIONAL_STATES = {
"CURIOUS": "Interesado, explorando opciones.",
"ANXIOUS": "Nervioso, dudas de seguridad o resultado.",
"SKEPTICAL": "Desconfiado, ha tenido malas experiencias.",
"EXCITED": "Emocionado, listo para decidir.",
"FRUSTRATED": "Frustrado por algo que pasó antes.",
"PRICE_SHOCKED": "Reaccionó mal al precio.",
"UNDECIDED": "Tiene la intención pero no el momentum.",
"NEUTRAL": "Sin señales emocionales claras.",
}
def __init__(self):
# Almacena estado por chat_id
# {chat_id: {"stage": str, "emotion": str, "turn": int,
# "last_update": float, "signals": list}}
self._states: Dict[str, Dict] = {}
def get_state(self, chat_id: str) -> Dict:
"""Retorna el estado actual de la conversación."""
return self._states.get(chat_id, {
"stage": "COLD",
"emotion": "NEUTRAL",
"turn": 0,
"signals": [],
"commitment_score": 0.0,
"last_objection": "",
})
def update(self, chat_id: str, user_text: str, bot_response: str,
analysis: "MessageAnalysis") -> Dict:
"""
Actualiza el estado basado en lo que dijo el usuario y respondió Conny.
Retorna el nuevo estado.
"""
state = self.get_state(chat_id)
text_lower = user_text.lower()
turn = state.get("turn", 0) + 1
state["turn"] = turn
# ── Detectar etapa ──────────────────────────────────────────────────────
# Señales de avance
PAIN_SIGNALS = [
"me molesta", "me preocupa", "me incomoda", "ya se me nota",
"quiero mejorar", "llevo tiempo", "desde hace", "ya me cansé",
"se me marcan", "siento que", "me veo", "ya no me gusta",
"quiero hacerme", "necesito", "busco"
]
OBJECTION_SIGNALS = [
"está caro", "es muy caro", "no tengo plata", "lo voy a pensar",
"déjame pensarlo", "me da miedo", "qué tal si", "y si quedo",
"lo consulto", "no sé si", "cuánto tiempo de recuperación",
"tengo mucho trabajo", "no tengo tiempo", "ya fui a otro lado"
]
COMMITMENT_SIGNALS = [
"qué día", "cuándo pueden", "me interesa la valoración",
"me agendas", "cómo agendo", "este jueves", "este viernes",
"la semana que viene", "puedo ir el", "sí quiero"
]
BOOKED_SIGNALS = [
"perfecto, ahí estaré", "confirmado", "listo nos vemos",
"anotado", "ya quedé agendada", "ya quedé"
]
# Actualizar etapa según señales
if state["stage"] == "COLD" or state["stage"] == "REACTIVATED":
state["stage"] = "DISCOVERY"
if any(s in text_lower for s in PAIN_SIGNALS) and state["stage"] in ("DISCOVERY", "COLD"):
state["stage"] = "PAIN_EXPLORED"
if state["stage"] == "PAIN_EXPLORED" and turn >= 3:
state["stage"] = "SOLUTION_MATCH"
if any(s in text_lower for s in OBJECTION_SIGNALS):
state["stage"] = "OBJECTION_ACTIVE"
state["last_objection"] = user_text[:100]
if any(s in text_lower for s in COMMITMENT_SIGNALS):
state["stage"] = "MICRO_COMMITMENT"
if any(s in text_lower for s in BOOKED_SIGNALS):
state["stage"] = "BOOKED"
# ── Detectar emoción ────────────────────────────────────────────────────
if any(w in text_lower for w in ["miedo", "me da miedo", "me preocupa que quede", "qué tal si quedo"]):
state["emotion"] = "ANXIOUS"
elif any(w in text_lower for w in ["ya fui", "quedé mal", "otra clínica me hizo", "no funciona"]):
state["emotion"] = "SKEPTICAL"
elif any(w in text_lower for w in ["emocionada", "qué bueno", "súper", "me alegra", "por fin"]):
state["emotion"] = "EXCITED"
elif any(w in text_lower for w in ["está caro", "costoso", "muy caro", "no tengo"]):
state["emotion"] = "PRICE_SHOCKED"
elif any(w in text_lower for w in ["lo pienso", "lo consulto", "después te escribo"]):
state["emotion"] = "UNDECIDED"
elif any(w in text_lower for w in ["frustrad", "molest", "qué fastidio", "llevaba"]):
state["emotion"] = "FRUSTRATED"
elif any(w in text_lower for w in ["me interesa", "cuánto", "qué incluye", "cuándo"]):
state["emotion"] = "CURIOUS"
# ── Score de compromiso (0-1) ───────────────────────────────────────────
commitment = state.get("commitment_score", 0.0)
commitment += 0.05 * min(turn, 10) # cada turno suma un poco
if state["stage"] in ("MICRO_COMMITMENT", "BOOKED", "CONFIRMED"):
commitment = min(1.0, commitment + 0.3)
if state["stage"] == "OBJECTION_ACTIVE":
commitment = max(0.1, commitment - 0.1)
state["commitment_score"] = round(min(1.0, commitment), 2)
state["last_update"] = time.time()
self._states[chat_id] = state
return state
# V8.1 — Señales universales por sector
SECTOR_PAIN_SIGNALS = {
"dental": [
"me duele", "dolor", "me está molestando", "se me cayó",
"caries", "sensibilidad", "fractura", "muela del juicio",
"me sangra", "inflamado", "absceso"
],
"veterinaria": [
"no come", "está decaído", "vomitó", "diarrea", "cojea",
"tiene algo en", "no se mueve bien", "está raro", "no bebe",
"tiene fiebre", "está llorando", "no para de rascarse"
],
"restaurante": [
"cumpleaños", "aniversario", "propuesta", "celebración",
"quiero sorprender", "evento especial", "graduación"
],
"gimnasio": [
"llevo tiempo sin", "quiero bajar", "quiero subir", "me cansé",
"me recomendaron", "quiero empezar", "necesito moverme más",
"estoy muy sedentario", "doctor me dijo"
],
"psicologo": [
"ansiedad", "depresión", "estrés", "no puedo dormir",
"relación", "me siento", "llevo tiempo así", "necesito hablar",
"me recomendaron", "problemas con", "no sé cómo manejar"
],
"abogado": [
"me demandaron", "me despidieron", "accidente", "deuda",
"divorcio", "herencia", "me amenazaron", "robo", "estafa",
"contrato", "problema con", "me estafaron"
],
}
SECTOR_OBJECTION_SIGNALS = {
"dental": [
"está caro", "le tengo miedo", "me da miedo", "voy a pensar",
"no tengo tiempo", "se me va a notar", "es que no fui en años"
],
"veterinaria": [
"está caro", "espero a ver", "voy a esperarlo un poco",
"no es urgente", "se ve bien"
],
"restaurante": [
"está caro", "hay descuento", "qué incluye exactamente",
"tienen menú más económico"
],
"gimnasio": [
"está caro", "no tengo tiempo", "empiezo el lunes", "voy a pensarlo",
"primero bajo un poco de peso", "no sé si pueda ir seguido"
],
"psicologo": [
"está caro", "no creo en eso", "no soy de los que van al psicólogo",
"ya lo intenté", "puedo solo", "mi familia no va a entender"
],
"tattoo": [
"está caro", "lo voy a pensar", "voy a seguir buscando",
"vi uno más barato", "todavía no sé bien qué quiero"
],
}
def get_sector_signals(self, sector: str) -> dict:
"""Retorna señales de dolor y objeción para el sector."""
return {
"pain": self.SECTOR_PAIN_SIGNALS.get(sector, [
"me molesta", "problema", "necesito", "busco", "quiero"
]),
"objection": self.SECTOR_OBJECTION_SIGNALS.get(sector, [
"está caro", "lo pienso", "me da miedo", "no tengo tiempo"
])
}
def update_with_sector(self, chat_id: str, user_text: str,
bot_response: str, analysis,
sector: str = "") -> dict:
"""
V8.1 — Actualiza el estado con señales específicas por sector.
"""
state = self.get_state(chat_id)
text_lower = user_text.lower()
turn = state.get("turn", 0) + 1
state["turn"] = turn
signals = self.get_sector_signals(sector)
pain_signals = signals["pain"] + [
"me molesta", "me preocupa", "quiero mejorar", "necesito",
"llevo tiempo", "desde hace", "busco", "quiero hacerme"
]
objection_signals = signals["objection"] + [
"está caro", "lo voy a pensar", "déjame pensarlo",
"me da miedo", "no tengo tiempo"
]
commitment_signals = [
"qué día", "cuándo pueden", "me interesa", "me agendas",
"cómo agendo", "esta semana", "puedo ir", "sí quiero",
"cuánto de anticipo", "cómo pago"
]
booked_signals = [
"confirmado", "listo", "anotado", "ya quedé",
"perfecto ahí estaré", "ya lo agendé"
]
# Actualizar etapa
if state["stage"] in ("COLD", "REACTIVATED"):
state["stage"] = "DISCOVERY"
if any(s in text_lower for s in pain_signals) and state["stage"] in ("DISCOVERY", "COLD"):
state["stage"] = "PAIN_EXPLORED"
if state["stage"] == "PAIN_EXPLORED" and turn >= 3:
state["stage"] = "SOLUTION_MATCH"
if any(s in text_lower for s in objection_signals):
state["stage"] = "OBJECTION_ACTIVE"
state["last_objection"] = user_text[:100]
if any(s in text_lower for s in commitment_signals):
state["stage"] = "MICRO_COMMITMENT"
if any(s in text_lower for s in booked_signals):
state["stage"] = "BOOKED"
# Detectar emoción
if any(w in text_lower for w in ["miedo", "me da miedo", "qué tal si quedo", "me preocupa"]):
state["emotion"] = "ANXIOUS"
elif any(w in text_lower for w in ["ya fui", "quedé mal", "no funciona", "no sirvió"]):
state["emotion"] = "SKEPTICAL"
elif any(w in text_lower for w in ["emocionad", "qué bueno", "súper", "por fin", "me alegra"]):
state["emotion"] = "EXCITED"
elif any(w in text_lower for w in ["está caro", "costoso", "muy caro", "no tengo"]):
state["emotion"] = "PRICE_SHOCKED"
elif any(w in text_lower for w in ["lo pienso", "lo consulto", "después", "voy a ver"]):
state["emotion"] = "UNDECIDED"
elif any(w in text_lower for w in ["frustrad", "molest", "fastidio", "llevaba tiempo"]):
state["emotion"] = "FRUSTRATED"
elif any(w in text_lower for w in ["me interesa", "cuánto", "qué incluye", "cuándo"]):
state["emotion"] = "CURIOUS"
# Score de compromiso
commitment = state.get("commitment_score", 0.0)
commitment += 0.05 * min(turn, 10)
if state["stage"] in ("MICRO_COMMITMENT", "BOOKED", "CONFIRMED"):
commitment = min(1.0, commitment + 0.3)
if state["stage"] == "OBJECTION_ACTIVE":
commitment = max(0.1, commitment - 0.1)
state["commitment_score"] = round(min(1.0, commitment), 2)
state["last_update"] = time.time()
state["sector"] = sector
self._states[chat_id] = state
return state
def get_prompt_context(self, chat_id: str) -> str:
"""
Retorna un bloque de texto para inyectar al sistema prompt.
Le dice a Conny exactamente en qué punto está la conversación
y qué debe hacer en el próximo mensaje.
"""
state = self.get_state(chat_id)
stage = state["stage"]
emotion = state["emotion"]
turn = state["turn"]
commitment = state["commitment_score"]
objection = state.get("last_objection", "")
# Instrucción específica por etapa
stage_instructions = {
"COLD": "Primera interacción. Saludo natural, pregunta abierta sobre qué busca.",
"DISCOVERY": "Estás descubriendo qué le molesta. NO ofrezcas soluciones aún. Pregunta UNA cosa.",
"PAIN_EXPLORED": "Ya conoces el dolor. Profundiza un poco más antes de conectar con solución.",
"SOLUTION_MATCH": "Conecta el dolor que describió con UNA solución específica. Luego propón la valoración.",
"OBJECTION_ACTIVE": f"Hay una objeción activa: '{objection[:60]}'. Valida primero, LUEGO maneja con la técnica de transferencia al especialista.",
"MICRO_COMMITMENT": "El cliente está considerando. Propón UN día concreto. No des opciones múltiples.",
"BOOKED": "Cita agendada. Confirma, da instrucciones simples de qué llevar/esperar.",
"CONFIRMED": "Confirmado. Cierre natural. Recuérdales el día/hora brevemente.",
"LOST": "El cliente volvió después de estar inactivo. Saluda como si nada, no menciones el tiempo.",
"REACTIVATED": "Cliente reactivado. Tono natural de continuación, no de 'oye cuánto tiempo'.",
}
emotion_instructions = {
"ANXIOUS": "PRIORIDAD: validar el miedo ANTES de cualquier información. 'ese miedo es muy normal aquí'",
"SKEPTICAL": "PRIORIDAD: reconocer la mala experiencia. 'ay qué pena, eso no debería pasar' — luego diferenciar.",
"EXCITED": "Match su energía. Cierra hacia fecha concreta rápido, está listo.",
"PRICE_SHOCKED": "No defiendas el precio de frente. 'sí, los buenos no son baratos' — luego habla de valor.",
"UNDECIDED": "Descubre QUÉ le frena: '¿qué sería lo que más te detiene, el precio, el resultado o el proceso?'",
"FRUSTRATED": "Valida PRIMERO: 'entiendo, eso es frustrante' — NUNCA expliques o justifiques de entrada.",
"CURIOUS": "Aprovecha el interés. Responde directo, luego mueve un paso hacia la valoración.",
"NEUTRAL": "Tono natural. Descubre su estado emocional con UNA pregunta cálida.",
}
# Entregar contexto como una sola frase orientativa — no como lista de instrucciones
# Menos estructura → el LLM la sigue sin sonar a que está siguiendo una lista
stage_note = stage_instructions.get(stage, "Continúa naturalmente.")
emotion_note = emotion_instructions.get(emotion, "") if emotion != "NEUTRAL" else ""
hint_parts = [stage_note]
if emotion_note:
hint_parts.append(emotion_note)
return " ".join(hint_parts)
class HyperHumanEngine:
"""
Motor de validación de humanidad.
Antes de enviar cualquier respuesta, la evalúa y si es muy robótica,
la regenera con instrucciones más precisas.
En V8.0 esto resuelve el problema principal: Conny se sentía
como un chatbot corporativo, no como una persona real.
"""
def __init__(self, anti_robot: "AntiRobotFilter"):
self.filter = anti_robot
self._retry_count: Dict[str, int] = {} # chat_id → retries this turn
def validate(self, response: str, chat_id: str = "") -> Tuple[bool, float, str]:
"""
Valida si la respuesta es suficientemente humana.
Retorna (is_valid, score, reason).
"""
score = self.filter.score_humanness(response)
threshold = Config.V8_QUALITY_THRESHOLD
if score >= threshold:
return True, score, "ok"
# Identificar por qué falló
reasons = []
text_lower = response.lower()
for phrase in self.filter.FORBIDDEN_EXACT:
if phrase in text_lower:
reasons.append(f"frase_bot:'{phrase[:30]}'")
break
if len(response.split()) > 50:
reasons.append("muy_larga")
if not reasons:
reasons.append("score_bajo")
return False, score, ",".join(reasons)
def get_retry_prompt_injection(self, original_response: str,
reason: str, archetype: str) -> str:
"""
Genera instrucciones de corrección para la regeneración.
Se inyectan al prompt de retry.
"""
lines = [
f"\n\n⚠️ CORRECCIÓN NECESARIA:",
f"Tu respuesta anterior fue demasiado robótica. Razón: {reason}",
f"Respuesta anterior: '{original_response[:80]}...'",
f"",
"REGLAS DE CORRECCIÓN:"
]
if "muy_larga" in reason:
lines.append("→ Máximo 20 palabras en total. Si necesitas más, usa |||")
if "frase_bot" in reason:
lines.append("→ Elimina TODA frase de call center. Di lo mismo en palabras simples.")
lines.extend([
"→ Como hablaría una persona real por WhatsApp — no un chatbot",
"→ Una oración directa. Sin introducción. Sin cierre formal.",
f"→ Arquetipo activo: {archetype}. Usa su vocabulario.",
"",
"Escribe de nuevo, más corto y natural:"
])
return "\n".join(lines)
class SmartVariety:
"""
Evita que Conny repita el mismo patrón de apertura/cierre en cada conversación.
Problema V7: Conny siempre empezaba con "hola qué tal"
y cerraba con "cuándo puedes". Predecible = robótico.
SmartVariety rastraea los últimos N aperturas y cierres por chat_id
y fuerza variación natural.
"""
# Aperturas colombianas reales para diferentes contextos
OPENINGS_GREETING = [
"hola", "hola qué más", "buenas", "hola buenas", "hey",
"hola qué tal", "buenas qué más", "hola!", "qué más",
]
OPENINGS_FOLLOWUP = [
"", "", "", # (vacío = sin apertura, responde directo — lo más natural)
"oye", "mira", "oye mira", "a ver",
]
OPENINGS_AFTER_SILENCE = [
"hola de nuevo", "hola", "oye", "buenas",
]
# Cierres naturales (propuesta de siguiente paso)
CLOSINGS_APPOINTMENT = [
"esta semana tienes el jueves, te queda bien",
"tengo espacio el jueves en la tarde, te funciona",
"esta semana hay espacio, cuándo puedes venir",
"qué día te queda mejor esta semana",
"el jueves hay espacio, ese día puedes",
"tenemos cupo esta semana, cuándo te cuadra",
]
CLOSINGS_SOFT = [
"cualquier cosa me cuentas",
"estoy por acá",
"me escribes si tienes más preguntas",
"si quieres más info me avisas",
]
CLOSINGS_COMMITMENT = [
"te agendo la valoración, es gratis, cuándo puedes",
"valoración gratis con la doctora, esta semana puedes",
"te la agendo ahora mismo, cuándo tienes 20 minutos",
]
def __init__(self):
# Historial de aperturas y cierres por chat_id
self._history: Dict[str, Dict[str, list]] = {}
# V8.1 — Aperturas y cierres específicos por sector
SECTOR_OPENINGS = {
"dental": [
"hola", "buenas", "hola buenas",
"cuéntame", "buenas tardes",
],
"veterinaria": [
"hola", "hola buenas", "buenas",
"cómo están", "cuéntame",
],
"restaurante": [
"hola", "buenas", "hola buenas",
"cuéntame", "buenas tardes",
],
"gimnasio": [
"hola", "hola qué más", "buenas",
"hola", "qué más",
],
"belleza": [
"hola", "hola qué más", "hola buenas",
"buenas", "hola",
],
"tattoo": [
"hola", "buenas", "hey",
"qué más", "hola",
],
"psicologo": [
"hola", "hola qué tal", "buenas",
"cuéntame", "buenas",
],
"abogado": [
"buenos días", "buenas tardes", "buenas",
"cuénteme", "buenos días",
],
"medico": [
"buenas", "buenas tardes", "buenos días",
"hola buenas", "buenas",
],
}
SECTOR_CLOSINGS_APPOINTMENT = {
"dental": [
"cuándo puedes venir",
"esta semana hay espacio, qué día te queda",
"el doctor tiene turno el jueves, puedes",
"esta semana tenemos cita, cuándo puedes",
],
"veterinaria": [
"cuándo pueden traerlo",
"esta tarde hay espacio, puedes venir",
"el doctor tiene turno hoy, qué hora te queda",
"cuándo lo traes",
],
"restaurante": [
"qué hora les queda mejor",
"a las 7 o a las 8, cuál les queda",
"a qué hora les pongo la mesa",
"a qué hora los esperamos",
],
"gimnasio": [
"cuándo puedes venir",
"esta semana hay cupo, cuándo te queda",
"puedes venir mañana a conocer",
"arranquemos esta semana, cuándo tienes",
],
"tattoo": [
"cuándo puedes venir",
"esta semana tengo el miércoles y el viernes",
"mándame el diseño y coordinamos fecha",
"cuándo quieres agendar",
],
}
def get_sector_opening(self, sector: str = "") -> str:
"""Retorna apertura apropiada para el sector."""
pool = self.SECTOR_OPENINGS.get(sector, self.OPENINGS_GREETING)
return pool[hash(str(time.time())) % len(pool)]
def get_sector_closing(self, sector: str = "", context: str = "appointment") -> str:
"""Retorna cierre apropiado para el sector."""
if context == "appointment":
pool = self.SECTOR_CLOSINGS_APPOINTMENT.get(sector, self.CLOSINGS_APPOINTMENT)
else:
pool = self.CLOSINGS_SOFT
return pool[hash(str(time.time())) % len(pool)]
def get_opening(self, chat_id: str, context: str = "greeting") -> str:
"""Retorna una apertura que no se ha usado recientemente."""
pool = {
"greeting": self.OPENINGS_GREETING,
"followup": self.OPENINGS_FOLLOWUP,
"after_silence": self.OPENINGS_AFTER_SILENCE,
}.get(context, self.OPENINGS_GREETING)
used = self._history.get(chat_id, {}).get("openings", [])
available = [o for o in pool if o not in used[-3:]]
if not available:
available = pool
choice = random.choice(available)
self._track(chat_id, "openings", choice)
return choice
def get_closing(self, chat_id: str, style: str = "soft") -> str:
"""Retorna un cierre que no se ha usado recientemente."""
pool = {
"appointment": self.CLOSINGS_APPOINTMENT,
"soft": self.CLOSINGS_SOFT,
"commitment": self.CLOSINGS_COMMITMENT,
}.get(style, self.CLOSINGS_SOFT)
used = self._history.get(chat_id, {}).get("closings", [])
available = [c for c in pool if c not in used[-3:]]
if not available:
available = pool
choice = random.choice(available)
self._track(chat_id, "closings", choice)
return choice
def get_variety_instruction(self, chat_id: str) -> str:
"""
Contexto de variedad — fraseado como dato, no como orden.
Research: el modelo respeta más "ya usé X" que "no uses X".
"""
history = self._history.get(chat_id, {})
last_openings = [o for o in history.get("openings", [])[-3:] if o]
last_closings = [c for c in history.get("closings", [])[-2:] if c]
lines = []
if last_openings:
used = ", ".join(f'"{o}"' for o in last_openings)
lines.append(f"en esta conversación ya abriste con {used} — varía")
if last_closings:
used = ", ".join(f'"{c}"' for c in last_closings)
lines.append(f"ya cerraste con {used} — usa algo diferente")
return "\n".join(lines)
def _track(self, chat_id: str, category: str, value: str):
if chat_id not in self._history:
self._history[chat_id] = {}
if category not in self._history[chat_id]:
self._history[chat_id][category] = []
self._history[chat_id][category].append(value)
# Mantener solo últimas 10
self._history[chat_id][category] = self._history[chat_id][category][-10:]
class ConversionFunnelTracker:
"""
Rastreador de embudo de conversión.
Sabe cuántos leads hay en cada etapa y qué tan efectiva es Conny
en mover leads de una etapa a la siguiente.
Se usa para el reporte /pipeline del admin y para entrenar
la auto-mejora de Conny.
"""
FUNNEL_STAGES = [
"cold", "discovery", "pain_explored",
"solution_match", "objection_active",
"micro_commitment", "booked", "confirmed"
]
def __init__(self):
self._events: list = [] # Lista de eventos para análisis
def record(self, chat_id: str, from_stage: str, to_stage: str,
triggered_by: str = ""):
"""Registra una transición de etapa."""
self._events.append({
"chat_id": chat_id,
"from": from_stage,
"to": to_stage,
"triggered": triggered_by,
"ts": time.time(),
})
# También persistir en DB si está disponible
try:
if db:
db.remember(
f"funnel_{chat_id}",
json.dumps({"stage": to_stage, "ts": datetime.now().isoformat()}),
category="funnel"
)
except Exception:
pass
def get_pipeline_summary(self) -> Dict[str, int]:
"""Retorna conteo de leads por etapa (último mes)."""
summary = {s: 0 for s in self.FUNNEL_STAGES}
try:
if db:
memories = db.recall_all(category="funnel")
for key, value in memories.items():
try:
data = json.loads(value)
stage = data.get("stage", "cold").lower()
if stage in summary:
summary[stage] += 1
except Exception:
pass
except Exception:
pass
return summary
def get_conversion_rate(self) -> Dict[str, float]:
"""Calcula tasa de conversión entre etapas."""
rates = {}
cutoff = time.time() - (30 * 24 * 3600) # últimos 30 días
recent = [e for e in self._events if e["ts"] > cutoff]
stage_counts: Dict[str, int] = {}
for e in recent:
stage_counts[e["from"]] = stage_counts.get(e["from"], 0) + 1
stage_successes: Dict[str, int] = {}
for e in recent:
idx_from = self.FUNNEL_STAGES.index(e["from"]) if e["from"] in self.FUNNEL_STAGES else -1
idx_to = self.FUNNEL_STAGES.index(e["to"]) if e["to"] in self.FUNNEL_STAGES else -1
if idx_to > idx_from >= 0:
stage_successes[e["from"]] = stage_successes.get(e["from"], 0) + 1
for stage in self.FUNNEL_STAGES:
total = stage_counts.get(stage, 0)
success = stage_successes.get(stage, 0)
rates[stage] = round(success / total, 2) if total > 0 else 0.0
return rates
def format_pipeline_report(self) -> str:
"""Genera texto del reporte de pipeline para el admin."""
summary = self.get_pipeline_summary()
rates = self.get_conversion_rate()
lines = ["Pipeline de leads:"]
stage_names = {
"cold": "🧊 Fríos",
"discovery": "🔍 Descubrimiento",
"pain_explored": "💬 Dolor explorado",
"solution_match": "✅ Solución presentada",
"objection_active": "🚧 Con objeción",
"micro_commitment": "🎯 Casi listos",
"booked": "📅 Agendados",
"confirmed": "✔️ Confirmados",
}
for stage in self.FUNNEL_STAGES:
count = summary.get(stage, 0)
rate = rates.get(stage, 0.0)
name = stage_names.get(stage, stage)
rate_str = f" → {int(rate*100)}% avanzan" if rate > 0 else ""
lines.append(f" {name}: {count} leads{rate_str}")
total = sum(summary.values())
booked = summary.get("booked", 0) + summary.get("confirmed", 0)
global_rate = round(booked / total * 100, 1) if total > 0 else 0
lines.append(f"\nConversión global: {global_rate}% ({booked}/{total})")
return "\n".join(lines)
class MultilingualHandler:
"""
Maneja inglés, español y portugués de forma transparente.
Detecta el idioma del cliente y ajusta Conny automáticamente.
No solo traduce — adapta el tono completo al contexto cultural.
"""
LANGUAGE_PROFILES = {
"en": {
"name": "English",
"tone_note": "Client is writing in English. Respond entirely in English. Use a natural, warm tone. Avoid sounding like a bot. Use casual American/Latin phrasing. If the user uses slang, mirror it subtly.",
"greetings": ["hey", "hi", "hello", "hi there", "how's it going?"],
"closings": ["let me know", "happy to help", "have a great day"],
"yes_words": ["yes", "yep", "sure", "ok", "okay", "sounds good", "perfect"],
},
"es": {
"name": "Español",
"tone_note": "Cliente en español. Mantén el trato cálido y humano. Evita sonar como un call center. Usa frases cortas y directas.",
"greetings": ["hola", "buenas", "qué tal?", "hola!", "un gusto"],
"closings": ["quedo atenta", "cualquier duda me dices", "un saludo"],
"yes_words": ["sí", "si", "dale", "claro", "ok", "perfecto"],
},
"pt": {
"name": "Português",
"tone_note": "Cliente em português. Responda em português brasileiro (PT-BR). Use um tom amigável e casual. Evite formalidades excessivas. Sinta-se como uma pessoa real no WhatsApp.",
"greetings": ["oi", "olá", "tudo bem?", "bom dia", "boa tarde"],
"closings": ["estou aqui se precisar", "qualquer coisa me chama", "um abraço"],
"yes_words": ["sim", "ok", "claro", "com certeza", "perfeito"],
},
}
def detect(self, text: str) -> str:
"""Detecta idioma con heurísticas y fallback al LLM si es necesario."""
text_lower = text.lower().strip()
if not text_lower: return "es"
EN_INDICATORS = ["the ", "and ", "with ", "you ", "what ", "how ", "hey", "hello", "thanks", "please", "can i", "i want", "i need", "do you", "is it", "are you", "how much", "when can", "today", "tomorrow", "appointment"]
PT_INDICATORS = ["você", "boa ", "obrigad", "tudo bem", "gostaria", "preciso", "pode", "tem ", "qual ", "quero", "agendar", "horário", "amanhã", "obrigado", "obrigada"]
ES_INDICATORS = ["hola", "buenas", "qué", "cómo", "cuándo", "gracias", "tengo", "quiero", "necesito", "cuánto", "pueden", "cita", "horario", "mañana", "ayer"]
en_score = sum(1 for i in EN_INDICATORS if i in text_lower)
pt_score = sum(1 for i in PT_INDICATORS if i in text_lower)
es_score = sum(1 for i in ES_INDICATORS if i in text_lower)
# Si hay empate o score bajo, usamos la última detección guardada o por defecto es
if en_score > es_score and en_score > pt_score:
return "en"
if pt_score > es_score and pt_score > en_score:
return "pt"
return "es"
def get_tone_instruction(self, lang: str) -> str:
profile = self.LANGUAGE_PROFILES.get(lang, self.LANGUAGE_PROFILES["es"])
return profile["tone_note"]
def get_tone_injection(self, lang: str) -> str:
"""Retorna instrucción de idioma para el system prompt."""
profile = self.LANGUAGE_PROFILES.get(lang, self.LANGUAGE_PROFILES["es"])
return profile.get("tone_note", "")
class PersonaEvolution:
"""
Aprende el estilo de escritura de cada cliente y adapta Conny.
Si el cliente escribe muy corto → Conny responde corto.
Si escribe formal → Conny ajusta formalidad.
Si usa emojis → Conny puede usarlos.
Si escribe en inglés → Conny responde en inglés.
Esta adaptación hace que la conversación se sienta personalizada,
no genérica.
"""
def __init__(self):
self._profiles: Dict[str, Dict] = {} # chat_id → style profile
def learn(self, chat_id: str, messages: List[Dict]):
"""Analiza los mensajes del usuario y actualiza su perfil."""
user_msgs = [m["content"] for m in messages if m["role"] == "user"]
if not user_msgs:
return
# Calcular métricas de estilo
avg_len = sum(len(m.split()) for m in user_msgs) / len(user_msgs)
emoji_use = sum(1 for m in user_msgs
if re.search(r'[\U0001F600-\U0001F64F]', m)) / len(user_msgs)
formal_words = ["usted", "señor", "señora", "estimado", "buenos días"]
formality = sum(1 for m in user_msgs
for w in formal_words if w in m.lower()) / len(user_msgs)
profile = {
"avg_msg_len": round(avg_len, 1),
"emoji_rate": round(emoji_use, 2),
"formality": round(formality, 2),
"msg_count": len(user_msgs),
"updated_at": time.time(),
}
self._profiles[chat_id] = profile
def get_adaptation_note(self, chat_id: str) -> str:
"""Retorna nota de adaptación para el system prompt."""
profile = self._profiles.get(chat_id)
if not profile or profile.get("msg_count", 0) < 3:
return ""
notes = []
avg_len = profile.get("avg_msg_len", 10)
emoji_rate = profile.get("emoji_rate", 0)
formality = profile.get("formality", 0)
if avg_len < 5:
notes.append("Cliente escribe muy corto. Responde aún más corto que lo normal.")
elif avg_len > 25:
notes.append("Cliente escribe largo. Puedes ser un poco más elaborada.")
if emoji_rate > 0.5:
notes.append("Cliente usa muchos emojis. Puedes usar 1 emoji por burbuja si es natural.")
if formality > 0.3:
notes.append("Cliente usa lenguaje formal. Sube levemente tu formalidad.")
if not notes:
return ""
return "ADAPTACIÓN A ESTE CLIENTE:\n" + "\n".join(f" • {n}" for n in notes)
class ModelManager:
"""
Gestor de modelos LLM en tiempo real.
Permite al admin cambiar el modelo sin reiniciar.
Guarda la configuración en DB para que persista.
V8 — el admin puede hacer:
/modelo → ver modelo actual y opciones
/modelo claude-sonnet → cambiar a Claude Sonnet
/modelo gemini-flash → cambiar a Gemini Flash
/modelo llama-70b → cambiar a Llama 70B
/modelo reset → volver al modelo del .env
"""
def __init__(self):
self._current_overrides: Dict[str, str] = {} # tier → model_id
def apply_override(self, tier: str, model_id: str):
"""Aplica un override de modelo en memoria."""
self._current_overrides[tier] = model_id
def clear_overrides(self):
"""Limpia todos los overrides (vuelve al .env)."""
self._current_overrides.clear()
def get_effective_models(self) -> Dict[str, str]:
"""Retorna el mapa tier → model_id efectivo (con overrides)."""
base = dict(Config.LLM_MODELS)
base.update(self._current_overrides)
return base
def get_current_model_display(self) -> str:
"""Retorna string formateado con el modelo actual."""
effective = self.get_effective_models()
overrides = self._current_overrides
lines = ["Modelos activos:"]
for tier, model in effective.items():
override_mark = " ← cambiado" if tier in overrides else " (por defecto)"
lines.append(f" {tier}: {model}{override_mark}")
return "\n".join(lines)
def get_catalog_display(self) -> str:
"""Retorna el catálogo de modelos disponibles para mostrar al admin."""
lines = ["Modelos disponibles para cambiar:\n"]
current_fast = self.get_effective_models().get("fast", "")
for key, (model_id, tier, desc) in Config.V8_MODEL_CATALOG.items():
active = " ← ACTIVO" if model_id == current_fast else ""
lines.append(f" /modelo {key} — {desc}{active}")
lines.append("\nTambién puedes escribir el ID completo:")
lines.append(" /modelo anthropic/claude-sonnet-4")
lines.append("\nPara volver al modelo original:")
lines.append(" /modelo reset")
return "\n".join(lines)
def set_model_from_command(self, arg: str) -> Tuple[bool, str]:
"""
Procesa el argumento de /modelo y aplica el cambio.
Retorna (success, mensaje).
"""
arg = normalize_model_arg(arg)
if arg == "reset":
self.clear_overrides()
if db:
db.remember("v8_model_override", "", "config")
return True, "Modelos restaurados a los valores del .env."
# Buscar en catálogo por alias
if arg in Config.V8_MODEL_CATALOG:
model_id, tier, desc = Config.V8_MODEL_CATALOG[arg]
self.apply_override(tier, model_id)
self.apply_override("fast", model_id) # fast también
if tier == "reasoning":
self.apply_override("reasoning", model_id)
# Persistir
if db:
db.remember("v8_model_override",
json.dumps({"tier": tier, "model": model_id, "alias": arg}),
"config")
# También aplicar en llm_engine si está disponible
self._push_to_engine(tier, model_id)
return True, f"Modelo cambiado a: {model_id}\n{desc}"
# Buscar por ID completo (ej: "anthropic/claude-opus-4")
if "/" in arg:
model_id = arg
# Determinar tier por heurística
tier = "fast"
if any(x in arg for x in ["opus", "pro", "gpt-4o ", "mistral-large"]):
tier = "reasoning"
elif any(x in arg for x in ["lite", "mini", "8b", "flash-lite"]):
tier = "lite"
self.apply_override("fast", model_id)
self.apply_override(tier, model_id)
self._push_to_engine(tier, model_id)
if db:
db.remember("v8_model_override",
json.dumps({"tier": tier, "model": model_id}),
"config")
return True, f"Modelo cambiado a: {model_id}"
return False, (f"No reconozco '{arg}'. Escribe /modelo para ver opciones.")
def _push_to_engine(self, tier: str, model_id: str):
"""
Empuja el override al LLM engine en memoria.
V8.1 FIX: Solo aplica a OpenRouter (único provider multi-modelo).
Groq, Gemini y OpenAI tienen catálogos fijos — si les cambias el modelo
a uno que no conocen, fallan silenciosamente y acumulan _failures hasta
quedar blacklisted, rompiendo la cascada completa.
La estrategia correcta:
- OpenRouter: acepta cualquier model_id → aplicar override
- Groq/Gemini/OpenAI: dejar sus MDLS intactos → siguen siendo fallback válido
"""
try:
if not llm_engine:
return
applied_to = []
for provider in llm_engine.providers:
if not hasattr(provider, "MDLS"):
continue
# Solo OpenRouter puede usar model_ids externos
if provider.name == "openrouter":
provider.MDLS[tier] = model_id
provider.MDLS["fast"] = model_id
if tier == "reasoning":
provider.MDLS["reasoning"] = model_id
applied_to.append(provider.name)
# Los demás providers conservan su catálogo nativo intacto
if applied_to:
log.info(f"[model_manager] override aplicado en: {applied_to} → {model_id}")
else:
log.info(f"[model_manager] override guardado en config, OpenRouter no disponible — usando cascada nativa")
except Exception as e:
log.warning(f"[model_manager] _push_to_engine error: {e}")
def restore_from_db(self):
"""Restaura overrides guardados en DB al arrancar."""
try:
if not db:
return
# GOD MODE: Revisar tabla system_config primero
try:
with db._conn() as c:
active_id_row = c.execute("SELECT value FROM system_config WHERE key='active_model'").fetchone()
if active_id_row:
active_id = active_id_row[0]
# Buscar detalles del modelo
model_row = c.execute("SELECT * FROM models WHERE id=? AND is_active=1", (active_id,)).fetchone()
if model_row:
provider = model_row['provider'] # ej: "anthropic"
model_id = model_row['model_id'] # ej: "claude-3-opus-20240229"
log.info(f"[GOD MODE] Activando modelo dinámico: {active_id} ({provider}/{model_id})")
# Aplicar a todos los tiers por simplicidad en God Mode
self.apply_override("reasoning", f"{provider}/{model_id}")
self.apply_override("fast", f"{provider}/{model_id}")
self.apply_override("lite", f"{provider}/{model_id}")
self._push_to_engine("fast", f"{provider}/{model_id}")
return
except Exception as e:
log.warning(f"[GOD MODE] Error leyendo config dinámica: {e}")
# Fallback legacy
raw = db.recall("v8_model_override")
if not raw:
return
data = json.loads(raw)
if data.get("model"):
tier = data.get("tier", "fast")
model_id = data["model"]
self.apply_override(tier, model_id)
self.apply_override("fast", model_id)
self._push_to_engine(tier, model_id)
log.info(f"[model_manager] modelo restaurado desde DB: {model_id}")
except Exception as e:
log.warning(f"[model_manager] error restaurando modelo: {e}")
# ── Instancias globales de V8 ─────────────────────────────────────────────────
# Se inicializan después del LLM engine (ver init_v8_systems())
anti_robot_filter: Optional[AntiRobotFilter] = None
conversation_intelligence: Optional[ConversationIntelligence] = None
hyper_human_engine: Optional[HyperHumanEngine] = None
smart_variety: Optional[SmartVariety] = None
conversion_funnel: Optional[ConversionFunnelTracker] = None
multilingual_handler: Optional[MultilingualHandler] = None
persona_evolution: Optional[PersonaEvolution] = None
model_manager: Optional[ModelManager] = None
def init_v8_systems():
"""
Inicializa todos los sistemas core de V8.0.
Cada sistema es independiente — un fallo no para al resto.
"""
global anti_robot_filter, conversation_intelligence, hyper_human_engine
global smart_variety, conversion_funnel, multilingual_handler
global persona_evolution, model_manager
_ok = 0
try:
anti_robot_filter = AntiRobotFilter(level=Config.V8_FILTER_LEVEL)
_ok += 1
except Exception as _e:
log.warning(f"[v8] AntiRobotFilter: {_e}")
try:
conversation_intelligence = ConversationIntelligence()
_ok += 1
except Exception as _e:
log.warning(f"[v8] ConversationIntelligence: {_e}")
try:
hyper_human_engine = HyperHumanEngine(anti_robot_filter) if anti_robot_filter else None
if hyper_human_engine:
_ok += 1
except Exception as _e:
log.warning(f"[v8] HyperHumanEngine: {_e}")
try:
smart_variety = SmartVariety()
_ok += 1
except Exception as _e:
log.warning(f"[v8] SmartVariety: {_e}")
try:
conversion_funnel = ConversionFunnelTracker()
_ok += 1
except Exception as _e:
log.warning(f"[v8] ConversionFunnelTracker: {_e}")
try:
multilingual_handler = MultilingualHandler()
_ok += 1
except Exception as _e:
log.warning(f"[v8] MultilingualHandler: {_e}")
try:
persona_evolution = PersonaEvolution()
_ok += 1
except Exception as _e:
log.warning(f"[v8] PersonaEvolution: {_e}")
try:
model_manager = ModelManager()
model_manager.restore_from_db()
_ok += 1
except Exception as _e:
log.warning(f"[v8] ModelManager: {_e}")
log.info(f"═══ V8.0 CORE SYSTEMS: {_ok}/8 OK ═══")
log.info(f" AntiRobotFilter: {'OK' if anti_robot_filter else 'FAILED'}")
log.info(f" ModelManager: {'OK' if model_manager else 'FAILED'}")
# V9 HUMANIZATION — Inicializar sistemas de humanización
if _V9_AVAILABLE:
try:
init_v9_systems()
# Parchar arquetipos y skills con V9
PERSONALITY_ARCHETYPES.update(V9_PERSONALITY_ARCHETYPES)
SKILL_DEFINITIONS.update(V9_SKILL_DEFINITIONS)
# Mejorar AntiRobotFilter con patrones V9
if anti_robot_filter:
v9_enhance_anti_robot_filter(anti_robot_filter)
log.info("═══ V9 HUMANIZATION: OK ═══")
except Exception as _v9_e:
log.warning(f"V9 init parcial: {_v9_e}")
# ─── Función de post-proceso V8 para todas las respuestas ────────────────────
def v8_process_response(response: str, chat_id: str = "",
archetype: str = "amigable") -> str:
"""
Punto de entrada único para post-procesar TODA respuesta del LLM.
Aplica: AntiRobotFilter → SmartVariety tracking → quality score log.
Retorna la respuesta limpia lista para enviar.
NUNCA crashea — si falla, retorna la respuesta original sin procesar.
"""
if not response:
return response
try:
return _v8_process_response_inner(response, chat_id, archetype)
except Exception as _e_proc:
log.debug(f"[v8_process] error no crítico, respuesta sin procesar: {_e_proc}")
return response
def _v8_process_response_inner(response: str, chat_id: str, archetype: str) -> str:
"""Implementación interna del post-procesamiento V8."""
if not anti_robot_filter:
return response
# Procesar cada burbuja si hay separadores
if "|||" in response:
parts = response.split("|||")
cleaned_parts = []
for part in parts:
part = part.strip()
if part:
cleaned = anti_robot_filter.process(part, archetype)
# v11: solo agregar si tiene contenido real (no solo puntuación ni conector suelto)
if cleaned and re.search(r'\w', cleaned) and len(cleaned.strip()) > 2:
cleaned_parts.append(cleaned)
response = " ||| ".join(cleaned_parts)
else:
response = anti_robot_filter.process(response, archetype)
# Loguear score de humanidad
score = anti_robot_filter.score_humanness(response)
if score < Config.V8_QUALITY_THRESHOLD:
log.warning(f"[v8] respuesta baja calidad score={score:.2f} chat={chat_id}: '{response[:60]}'")
return response
def v8_build_quality_system_prompt_addon(chat_id: str,
archetype: str,
history: List[Dict]) -> str:
"""
Construye el bloque adicional de instrucciones V8 para inyectar
en cualquier system prompt. Este bloque es el que hace que Conny
suene como una persona real.
Siempre retorna string (nunca None, nunca lanza excepción).
"""
try:
return _v8_build_addon_inner(chat_id, archetype, history)
except Exception as _e_addon:
log.debug(f"[v8_addon] error no crítico: {_e_addon}")
return ""
def _v8_build_addon_inner(chat_id: str, archetype: str, history: List[Dict]) -> str:
"""Implementación interna del addon V8. Solo contexto dinámico — sin reglas estáticas."""
lines = []
# 2. Instrucciones de variedad (evitar repetición)
if smart_variety and chat_id:
variety_note = smart_variety.get_variety_instruction(chat_id)
if variety_note:
lines.append(variety_note)
# 3. Adaptación a este cliente específico
if persona_evolution and chat_id and history:
persona_evolution.learn(chat_id, history)
adaptation = persona_evolution.get_adaptation_note(chat_id)
if adaptation:
lines.append(adaptation)
# 4. Estado de conversación (etapa, emoción, qué hacer)
if conversation_intelligence and chat_id:
conv_context = conversation_intelligence.get_prompt_context(chat_id)
if conv_context:
lines.append(conv_context)
# 5. V9 HUMANIZATION — Bloque de humanización total
if _V9_AVAILABLE:
try:
# Obtener sector desde Config
sector = getattr(Config, 'SECTOR', 'otro') or 'otro'
v9_block = v9_build_humanization_block(
chat_id=chat_id,
archetype=archetype,
history=history,
sector=sector,
)
if v9_block:
lines.append(v9_block)
except Exception as _v9_e:
pass # Silencioso — V8 sigue funcionando si V9 falla
return "\n".join(lines)
def normalize_model_arg(arg: str) -> str:
"""Normaliza variantes humanas como 'gemini 2.5 flash' -> 'gemini-flash'."""
normalized = (arg or "").strip().lower()
normalized = normalized.replace("_", " ").replace("-", " ")
normalized = re.sub(r"\s+", " ", normalized).strip()
aliases = {
"gemini flash": "gemini-flash",
"gemini 2.5 flash": "gemini-flash",
"google gemini flash": "gemini-flash",
"google gemini 2.5 flash": "gemini-flash",
"gemini lite": "gemini-lite",
"gemini 2.5 flash lite": "gemini-lite",
"gemini pro": "gemini-pro",
"gemini 2.5 pro": "gemini-pro",
"claude sonnet": "claude-sonnet",
"claude sonnet 4": "claude-sonnet",
"claude opus": "claude-opus",
"claude opus 4": "claude-opus",
"claude haiku": "claude-haiku",
"gpt 4o": "gpt4o",
"gpt 4o mini": "gpt4o-mini",
"llama 70b": "llama-70b",
"llama 8b": "llama-8b",
"mistral large": "mistral-large",
"mistral small": "mistral-small",
}
return aliases.get(normalized, normalized.replace(" ", "-"))
def extract_model_request_from_text(text: str) -> str:
"""
Detecta peticiones naturales de cambio de modelo en chat.
Ejemplos: 'usa gemini 2.5 flash', 'cambia el modelo a claude sonnet',
'ponte en gemini flash', 'modelo gemini-flash'.
"""
raw = (text or "").strip().lower().lstrip("/")
if not raw:
return ""
model_markers = (
"gemini", "claude", "llama", "gpt", "openai",
"openrouter", "groq", "sonnet", "opus", "haiku",
"auto", "flash", "lite", "pro",
)
for prefix in ("modelo ", "model "):
if raw.startswith(prefix):
return normalize_model_arg(raw[len(prefix):])
patterns = [
r"(?:usa|usar|ponte en|pon|cambia(?:te)?(?: el modelo)?(?: a)?|deja(?:lo)? en)\s+(.+)$",
]
for pattern in patterns:
match = re.search(pattern, raw)
if not match:
continue
candidate = match.group(1).strip()
for stopper in (" por favor", " please", " ahora", " ya"):
if candidate.endswith(stopper):
candidate = candidate[:-len(stopper)].strip()
if not any(marker in candidate for marker in model_markers):
return ""
normalized = normalize_model_arg(candidate)
if normalized:
return normalized
return ""
def _is_low_quality_first_contact_part(text: str) -> bool:
return _core_is_low_quality_first_contact_part(
text,
is_fragmented=looks_fragmented_reply,
)
def _normalize_first_contact_response(
response: str,
clinic: Dict[str, Any],
user_msg: str,
agent_name: str = "Conny",
) -> str:
return _core_normalize_first_contact_response(
response,
clinic,
user_msg,
agent_name=agent_name,
is_fragmented=looks_fragmented_reply,
)
def detect_redundant_question(user_msg: str, response: str,
history: Optional[List[Dict]] = None) -> str:
"""
Detecta preguntas que suenan fuera de contexto porque el usuario ya dio
ese dato en el mismo mensaje.
"""
user = _normalize_conv_text(user_msg)
resp = _normalize_conv_text(response)
if not user or not resp:
return ""
recent_user_context = []
for msg in (history or [])[-6:]:
if msg.get("role") == "user":
normalized = _normalize_conv_text(msg.get("content", ""))
if normalized:
recent_user_context.append(normalized)
user_context = " ".join([*recent_user_context, user]).strip()
if not user_context:
user_context = user
checks = [
(
"ya dijo desde cuándo",
["desde cuando", "cuanto tiempo", "hace cuanto"],
["desde ayer", "desde hoy", "desde anoche", "desde hace", "hace ", "llevo ", "lleva "],
),
(
"ya dijo la zona",
["que zona", "en que zona", "donde te lo quieres", "que parte", "que es lo que te esta molestando mas", "cuales zonas", "qué zonas"],
["frente", "labios", "ojeras", "nariz", "cejas", "menton", "pomulos", "mejillas", "cuello"],
),
(
"ya dijo el miedo u objeción",
["que te preocupa", "cual es tu miedo", "por que te da miedo", "que es lo que mas te preocupa"],
["quedar exagerada", "cara de muneca", "cara de muñeca", "quedar tiesa", "se note demasiado", "quedar mal"],
),
(
"ya dijo la ciudad o ubicación",
["de donde eres", "donde estas", "en que ciudad", "en que zona"],
["medellin", "bogota", "cali", "barranquilla", "envigado", "sabaneta", "bello", "laureles", "poblado", "calle ", "carrera "],
),
(
"ya dijo el servicio",
["que servicio", "que tratamiento", "que te quieres hacer"],
["botox", "relleno", "rellenos", "laser", "peeling", "mesoterapia", "limpieza", "consulta", "valoracion", "valoración"],
),
]
for label, question_signals, user_signals in checks:
if label == "ya dijo el miedo u objeción":
# Si Conny aterriza la objeción con opciones concretas,
# no es pregunta redundante sino profundización útil.
if " o " in resp or "mas que" in resp or "más que" in resp:
continue
if any(q in resp for q in question_signals) and any(s in user_context for s in user_signals):
return label
explicit_blocks = [
("pidió que no le preguntaran la edad", ["edad", "cuantos anos", "que edad"], ["no me preguntes la edad", "no preguntes la edad"]),
("pidió que no le preguntaran la ciudad", ["en que ciudad", "de donde eres", "donde estas"], ["no me preguntes la ciudad", "no me preguntes de donde", "no me preguntes dónde", "no preguntes de donde"]),
]
for label, forbidden_topics, user_signals in explicit_blocks:
if any(s in user_context for s in user_signals) and any(t in resp for t in forbidden_topics):
return label
return ""
def detect_unanswered_price_request(user_msg: str, response: str) -> bool:
"""
Detecta cuando el usuario preguntó por precio/valor y Conny no contestó
esa parte antes de seguir conversando.
"""
user = _normalize_conv_text(user_msg)
resp = _normalize_conv_text(response)
if not user or not resp:
return False
price_signals = ["cuanto", "cuánto", "precio", "vale", "valor", "costo", "cuesta"]
if not any(signal in user for signal in price_signals):
return False
answer_signals = [
"precio", "valor", "vale", "cuesta", "costo", "depende",
"desde", "rango", "valoracion", "valoración", "cotiza",
"zona", "zonas", "consulta", "presupuesto",
]
return not any(signal in resp for signal in answer_signals)
def looks_fragmented_reply(text: str) -> bool:
text = (text or "").strip().lower()
if not text:
return False
if text.endswith((",", ";", ":")):
return True
if any(text.endswith(" " + tail) for tail in ["y", "o", "pero", "porque", "que", "si", "por"]):
return True
dangling_phrases = (
"de", "del", "de la", "de las", "de los",
"para", "para la", "para las", "para los",
"con", "con la", "con las", "con los",
"en", "en la", "en las", "en los",
"por la", "por las", "por los",
)
if any(text.endswith(" " + phrase) or text == phrase for phrase in dangling_phrases):
return True
if len(text) > 40 and not re.search(r'[.!?…]["\']?$', text):
m = re.search(r'([a-záéíóúñ]+)$', text)
if m:
last_word = m.group(1)
safe_short_words = {"hola", "vale", "dale", "listo", "claro", "bien", "sale", "ok", "si", "sí", "hoy", "ahi", "ahí"}
if len(last_word) <= 4 and last_word not in safe_short_words:
return True
return False
# ═══════════════════════════════════════════════════════════════════════════════
# FIN DE V8.0 CORE CLASSES
# ═══════════════════════════════════════════════════════════════════════════════
def apply_archetype(archetype_id: str, base_name: str = "Conny") -> PersonalityProfile:
"""
Crea un PersonalityProfile completo a partir de un arquetipo.
El nombre se puede personalizar (Sofia, Andrea, etc.)
"""
a = PERSONALITY_ARCHETYPES.get(archetype_id, PERSONALITY_ARCHETYPES["amigable"])
return PersonalityProfile(
name=base_name,
archetype=archetype_id,
tone=a["desc"],
formality_level=a["formality"],
warmth_level=a["warmth"],
humor_level=a["humor"],
verbosity=a["verbosity"],
emoji_usage=0.0,
greetings=a["greetings"],
affirmations=a["affirmations"],
closings=a["closings"],
forbidden_words=a.get("forbidden", []),
tone_instruction=a["tone_instruction"],
)
# ═══════════════════════════════════════════════════════════════════════════════
# BASE DE DATOS AVANZADA
# ═══════════════════════════════════════════════════════════════════════════════
class DatabaseManager:
"""Gestor de base de datos con soporte para vectores."""
def __init__(self, db_path: str, vector_path: str):
self.db_path = db_path
self.vector_path = vector_path
self._init_databases()
def _init_databases(self):
"""Inicializa ambas bases de datos."""
os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
with self._conn() as c:
c.executescript("""
-- Configuración de clínica extendida
CREATE TABLE IF NOT EXISTS clinic (
id INTEGER PRIMARY KEY,
name TEXT DEFAULT '',
tagline TEXT DEFAULT '',
address TEXT DEFAULT '',
phone TEXT DEFAULT '',
email TEXT DEFAULT '',
website TEXT DEFAULT '',
services TEXT DEFAULT '[]',
schedule TEXT DEFAULT '{}',
holidays TEXT DEFAULT '[]',
timezone TEXT DEFAULT 'America/Bogota',
currency TEXT DEFAULT 'COP',
-- Personalidad de Conny
persona_config TEXT DEFAULT '{}',
-- Configuración de negocio
business_rules TEXT DEFAULT '{}',
pricing TEXT DEFAULT '{}',
promotions TEXT DEFAULT '[]',
-- Admin
admin_chat_ids TEXT DEFAULT '[]',
notification_settings TEXT DEFAULT '{}',
-- Estado
setup_done INTEGER DEFAULT 0,
setup_step TEXT DEFAULT 'idle',
setup_buffer TEXT DEFAULT '{}',
-- Metadata
created_at TEXT DEFAULT (datetime('now')),
updated_at TEXT DEFAULT (datetime('now'))
);
INSERT OR IGNORE INTO clinic (id) VALUES (1);
-- Migracion segura: agregar columna knowledge_base si no existe
-- (no falla si ya existe en DBs antiguas)
-- Conversaciones con análisis
CREATE TABLE IF NOT EXISTS conversations (
id INTEGER PRIMARY KEY AUTOINCREMENT,
chat_id TEXT NOT NULL,
role TEXT NOT NULL,
content TEXT NOT NULL,
analysis TEXT DEFAULT '{}',
tokens_used INTEGER DEFAULT 0,
model_used TEXT DEFAULT '',
latency_ms INTEGER DEFAULT 0,
ts TEXT DEFAULT (datetime('now'))
);
CREATE INDEX IF NOT EXISTS idx_conv_chat ON conversations(chat_id);
CREATE INDEX IF NOT EXISTS idx_conv_ts ON conversations(ts);
-- Citas extendidas
CREATE TABLE IF NOT EXISTS appointments (
id INTEGER PRIMARY KEY AUTOINCREMENT,
chat_id TEXT NOT NULL,
patient_name TEXT DEFAULT '',
patient_phone TEXT DEFAULT '',
patient_email TEXT DEFAULT '',
service TEXT DEFAULT '',
datetime_slot TEXT DEFAULT '',
duration_minutes INTEGER DEFAULT 60,
notes TEXT DEFAULT '',
status TEXT DEFAULT 'pendiente',
reminder_sent INTEGER DEFAULT 0,
confirmed_at TEXT,
cancelled_at TEXT,
cancellation_reason TEXT DEFAULT '',
rescheduled_from INTEGER,
created_at TEXT DEFAULT (datetime('now')),
updated_at TEXT DEFAULT (datetime('now'))
);
CREATE INDEX IF NOT EXISTS idx_apt_chat ON appointments(chat_id);
CREATE INDEX IF NOT EXISTS idx_apt_status ON appointments(status);
CREATE INDEX IF NOT EXISTS idx_apt_datetime ON appointments(datetime_slot);
-- Pacientes con perfil completo
CREATE TABLE IF NOT EXISTS patients (
chat_id TEXT PRIMARY KEY,
name TEXT DEFAULT '',
phone TEXT DEFAULT '',
email TEXT DEFAULT '',
birthdate TEXT DEFAULT '',
preferences TEXT DEFAULT '{}',
medical_notes TEXT DEFAULT '',
tags TEXT DEFAULT '[]',
-- Métricas
visits INTEGER DEFAULT 0,
total_spent REAL DEFAULT 0,
avg_satisfaction REAL DEFAULT 0,
no_shows INTEGER DEFAULT 0,
-- Historial
services_used TEXT DEFAULT '[]',
last_service TEXT DEFAULT '',
-- Fechas
first_seen TEXT DEFAULT (datetime('now')),
last_seen TEXT DEFAULT (datetime('now')),
next_appointment TEXT DEFAULT ''
);
-- Estado de conversación
CREATE TABLE IF NOT EXISTS conversation_states (
chat_id TEXT PRIMARY KEY,
state TEXT DEFAULT '{}',
updated_at TEXT DEFAULT (datetime('now'))
);
-- Rutas de transporte por chat para recordar el canal real
CREATE TABLE IF NOT EXISTS contact_routes (
chat_id TEXT PRIMARY KEY,
platform TEXT NOT NULL,
updated_at TEXT DEFAULT (datetime('now'))
);
-- GOD MODE: Gestión dinámica de modelos
CREATE TABLE IF NOT EXISTS models (
id TEXT PRIMARY KEY, -- ej: "gpt-4-turbo"
provider TEXT, -- ej: "openai", "anthropic", "gemini"
model_id TEXT, -- ej: "gpt-4-0125-preview"
api_key TEXT, -- si es override, sino NULL usa env
is_active INTEGER DEFAULT 1,
created_at TEXT DEFAULT (datetime('now'))
);
-- GOD MODE: Configuración en caliente
CREATE TABLE IF NOT EXISTS system_config (
key TEXT PRIMARY KEY,
value TEXT,
updated_at TEXT DEFAULT (datetime('now'))
);
-- Memoria semántica
CREATE TABLE IF NOT EXISTS memories (
id TEXT PRIMARY KEY,
chat_id TEXT NOT NULL,
content TEXT NOT NULL,
embedding BLOB,
category TEXT DEFAULT 'general',
importance REAL DEFAULT 0.5,
accessed_count INTEGER DEFAULT 0,
created_at TEXT DEFAULT (datetime('now')),
last_accessed TEXT DEFAULT (datetime('now')),
metadata TEXT DEFAULT '{}'
);
CREATE INDEX IF NOT EXISTS idx_mem_chat ON memories(chat_id);
CREATE INDEX IF NOT EXISTS idx_mem_category ON memories(category);
-- Tareas autónomas
CREATE TABLE IF NOT EXISTS tasks (
id TEXT PRIMARY KEY,
type TEXT NOT NULL,
priority INTEGER DEFAULT 5,
status TEXT DEFAULT 'pending',
data TEXT DEFAULT '{}',
result TEXT,
created_at TEXT DEFAULT (datetime('now')),
scheduled_for TEXT,
started_at TEXT,
completed_at TEXT,
retries INTEGER DEFAULT 0,
error TEXT DEFAULT ''
);
CREATE INDEX IF NOT EXISTS idx_task_status ON tasks(status);
CREATE INDEX IF NOT EXISTS idx_task_scheduled ON tasks(scheduled_for);
-- Plugins MCP
CREATE TABLE IF NOT EXISTS mcp_plugins (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
description TEXT DEFAULT '',
version TEXT DEFAULT '1.0.0',
enabled INTEGER DEFAULT 0,
config TEXT DEFAULT '{}',
capabilities TEXT DEFAULT '[]',
endpoints TEXT DEFAULT '{}',
health_status TEXT DEFAULT 'unknown',
last_check TEXT,
installed_at TEXT DEFAULT (datetime('now'))
);
-- Métricas y analytics
CREATE TABLE IF NOT EXISTS metrics (
id INTEGER PRIMARY KEY AUTOINCREMENT,
metric_type TEXT NOT NULL,
metric_name TEXT NOT NULL,
metric_value REAL NOT NULL,
dimensions TEXT DEFAULT '{}',
ts TEXT DEFAULT (datetime('now'))
);
CREATE INDEX IF NOT EXISTS idx_metrics_type ON metrics(metric_type, metric_name);
CREATE INDEX IF NOT EXISTS idx_metrics_ts ON metrics(ts);
-- Optimizaciones aprendidas
CREATE TABLE IF NOT EXISTS learned_optimizations (
id INTEGER PRIMARY KEY AUTOINCREMENT,
category TEXT NOT NULL,
trigger_pattern TEXT NOT NULL,
optimization TEXT NOT NULL,
success_rate REAL DEFAULT 0,
usage_count INTEGER DEFAULT 0,
created_at TEXT DEFAULT (datetime('now')),
updated_at TEXT DEFAULT (datetime('now'))
);
-- Logs de auto-mejora
CREATE TABLE IF NOT EXISTS self_improvement_log (
id INTEGER PRIMARY KEY AUTOINCREMENT,
improvement_type TEXT NOT NULL,
description TEXT NOT NULL,
before_state TEXT DEFAULT '{}',
after_state TEXT DEFAULT '{}',
impact_score REAL DEFAULT 0,
applied INTEGER DEFAULT 0,
ts TEXT DEFAULT (datetime('now'))
);
-- Feedback de usuarios
CREATE TABLE IF NOT EXISTS feedback (
id INTEGER PRIMARY KEY AUTOINCREMENT,
chat_id TEXT NOT NULL,
conversation_id INTEGER,
rating INTEGER,
comment TEXT DEFAULT '',
sentiment REAL DEFAULT 0,
ts TEXT DEFAULT (datetime('now'))
);
-- Cache de respuestas
CREATE TABLE IF NOT EXISTS response_cache (
hash TEXT PRIMARY KEY,
response TEXT NOT NULL,
hit_count INTEGER DEFAULT 1,
created_at TEXT DEFAULT (datetime('now')),
last_hit TEXT DEFAULT (datetime('now')),
ttl_seconds INTEGER DEFAULT 3600
);
-- Tokens de activacion (generados por Santiago, enviados a clinicas)
-- formato: ACTV-{clinic_id}-{32 chars aleatorios}
CREATE TABLE IF NOT EXISTS activation_tokens (
token TEXT PRIMARY KEY,
clinic_label TEXT DEFAULT '',
created_by TEXT DEFAULT 'santiago',
created_at TEXT DEFAULT (datetime('now')),
expires_at TEXT NOT NULL,
used_at TEXT,
used_by_chat_id TEXT DEFAULT '',
is_active INTEGER DEFAULT 1
);
-- Administradores por instancia de Conny
-- Cada Conny puede tener multiples admins con distintos roles
CREATE TABLE IF NOT EXISTS admins (
id INTEGER PRIMARY KEY AUTOINCREMENT,
chat_id TEXT NOT NULL UNIQUE,
email TEXT DEFAULT '',
password_hash TEXT DEFAULT '',
name TEXT DEFAULT '',
role TEXT DEFAULT 'admin', -- owner | admin | viewer
activated_by_token TEXT DEFAULT '',
invited_by_chat_id TEXT DEFAULT '',
is_active INTEGER DEFAULT 1,
last_login TEXT DEFAULT '',
login_attempts INTEGER DEFAULT 0,
created_at TEXT DEFAULT (datetime('now'))
);
CREATE INDEX IF NOT EXISTS idx_admins_chat ON admins(chat_id);
CREATE INDEX IF NOT EXISTS idx_admins_email ON admins(email);
-- Estado de autenticacion por sesion de chat
CREATE TABLE IF NOT EXISTS auth_sessions (
chat_id TEXT PRIMARY KEY,
flow TEXT DEFAULT '',
step TEXT DEFAULT '',
temp_data TEXT DEFAULT '{}',
attempts INTEGER DEFAULT 0,
started_at TEXT DEFAULT (datetime('now')),
updated_at TEXT DEFAULT (datetime('now'))
);
-- Feedback del admin sobre conversaciones especificas
-- Cuando el admin corrige o elogia una respuesta de Conny
CREATE TABLE IF NOT EXISTS conversation_feedback (
id INTEGER PRIMARY KEY AUTOINCREMENT,
chat_id TEXT NOT NULL, -- chat_id del PACIENTE
message_id TEXT DEFAULT '', -- referencia al mensaje comentado
feedback_text TEXT NOT NULL, -- lo que dijo el admin
feedback_type TEXT DEFAULT 'correction', -- correction | praise | instruction
context TEXT DEFAULT '', -- los mensajes de contexto
created_by TEXT DEFAULT '', -- chat_id del admin
created_at TEXT DEFAULT (datetime('now'))
);
-- Carpeta de confianza: reglas de comunicacion aprendidas del feedback
-- Conny consulta esto antes de responder
CREATE TABLE IF NOT EXISTS trust_folder (
id INTEGER PRIMARY KEY AUTOINCREMENT,
category TEXT DEFAULT 'general', -- objection | tone | closing | product | flow
rule TEXT NOT NULL, -- la regla aprendida en lenguaje natural
example_bad TEXT DEFAULT '', -- como NO hacerlo
example_good TEXT DEFAULT '', -- como SI hacerlo
source TEXT DEFAULT 'admin', -- admin | auto
weight REAL DEFAULT 1.0, -- importancia (se puede subir/bajar)
times_applied INTEGER DEFAULT 0,
created_at TEXT DEFAULT (datetime('now')),
updated_at TEXT DEFAULT (datetime('now'))
);
-- Instrucciones naturales del admin
CREATE TABLE IF NOT EXISTS admin_instructions (
id INTEGER PRIMARY KEY AUTOINCREMENT,
chat_id TEXT NOT NULL,
instruction TEXT NOT NULL,
is_active INTEGER DEFAULT 1,
created_at TEXT DEFAULT (datetime('now'))
);
-- Playbooks aprendidos del dueño
-- Trigger + ejemplo exacto de cómo responder
CREATE TABLE IF NOT EXISTS behavior_playbooks (
id INTEGER PRIMARY KEY AUTOINCREMENT,
category TEXT DEFAULT 'general',
trigger_text TEXT NOT NULL,
instruction TEXT DEFAULT '',
response_example TEXT NOT NULL,
bubble_count INTEGER DEFAULT 1,
source TEXT DEFAULT 'admin',
weight REAL DEFAULT 1.0,
times_used INTEGER DEFAULT 0,
created_at TEXT DEFAULT (datetime('now')),
updated_at TEXT DEFAULT (datetime('now'))
);
-- Memoria permanente — nunca se borra, sobrevive crashes y resets
-- Es la carpeta de identidad de Conny para esta clínica
CREATE TABLE IF NOT EXISTS core_memory (
key TEXT PRIMARY KEY,
value TEXT NOT NULL,
category TEXT DEFAULT 'identity', -- identity|clinic|patient|learned
updated_at TEXT DEFAULT (datetime('now'))
);
""")
# Migraciones seguras
with self._conn() as c:
for col_sql in [
"ALTER TABLE clinic ADD COLUMN knowledge_base_raw TEXT DEFAULT ''",
"ALTER TABLE clinic ADD COLUMN wa_phone_id TEXT DEFAULT ''",
"ALTER TABLE clinic ADD COLUMN wa_access_token TEXT DEFAULT ''",
"ALTER TABLE clinic ADD COLUMN wa_verify_token TEXT DEFAULT ''",
"ALTER TABLE clinic ADD COLUMN gcal_refresh_token TEXT DEFAULT ''",
"ALTER TABLE clinic ADD COLUMN calendly_link TEXT DEFAULT ''",
"ALTER TABLE clinic ADD COLUMN onboarding_done INTEGER DEFAULT 0",
"ALTER TABLE clinic ADD COLUMN platform TEXT DEFAULT 'telegram'",
"ALTER TABLE patients ADD COLUMN metadata TEXT DEFAULT '{}'",
]:
try:
c.execute(col_sql)
except sqlite3.OperationalError:
pass
log.info(f"✓ Database inicializada: {self.db_path}")
def _conn(self) -> sqlite3.Connection:
conn = sqlite3.connect(self.db_path, check_same_thread=False)
conn.row_factory = sqlite3.Row
conn.execute("PRAGMA journal_mode=WAL")
conn.execute("PRAGMA synchronous=NORMAL")
conn.execute("PRAGMA cache_size=-32000") # ~32MB cache
return conn
# ─── Clinic Operations ──────────────────────────────────────────────────────
def get_clinic(self) -> Dict[str, Any]:
with self._conn() as c:
row = c.execute("SELECT * FROM clinic WHERE id=1").fetchone()
if row:
data = dict(row)
# Parse JSON fields
for field in ['services', 'schedule', 'holidays', 'persona_config',
'business_rules', 'pricing', 'promotions',
'admin_chat_ids', 'notification_settings']:
try:
data[field] = json.loads(data.get(field, '{}') or '{}')
except Exception:
data[field] = {} if field not in ['services', 'holidays', 'promotions', 'admin_chat_ids'] else []
return data
return {}
def update_clinic(self, **kwargs):
if not kwargs:
return
# Serialize JSON fields
for k, v in kwargs.items():
if isinstance(v, (dict, list)):
kwargs[k] = json.dumps(v, ensure_ascii=False)
kwargs['updated_at'] = datetime.now().isoformat()
sets = ", ".join(f"{k}=?" for k in kwargs)
with self._conn() as c:
c.execute(f"UPDATE clinic SET {sets} WHERE id=1", list(kwargs.values()))
# ─── Conversation Operations ────────────────────────────────────────────────
def save_message(self, chat_id: str, role: str, content: str,
analysis: Dict = None, model: str = "", latency: int = 0):
with self._conn() as c:
c.execute("""
INSERT INTO conversations
(chat_id, role, content, analysis, model_used, latency_ms)
VALUES (?,?,?,?,?,?)
""", (chat_id, role, content,
json.dumps(analysis or {}, ensure_ascii=False),
model, latency))
def add_admin_instruction(self, chat_id: str, instruction: str):
"""Guarda una nueva instruccion natural del admin."""
try:
with self._conn() as c:
c.execute(
"INSERT INTO admin_instructions (chat_id, instruction) VALUES (?, ?)",
(chat_id, instruction)
)
except Exception as e:
log.warning(f"add_admin_instruction error: {e}")
def get_active_admin_instructions(self) -> List[str]:
"""Obtiene todas las instrucciones activas del admin."""
try:
with self._conn() as c:
rows = c.execute(
"SELECT instruction FROM admin_instructions WHERE is_active=1 ORDER BY created_at ASC"
).fetchall()
return [r["instruction"] for r in rows]
except Exception:
return []
def clear_admin_instructions(self):
"""Desactiva todas las instrucciones actuales."""
try:
with self._conn() as c:
c.execute("UPDATE admin_instructions SET is_active=0")
except Exception:
pass
def get_history(self, chat_id: str, limit: int = None) -> List[Dict]:
limit = limit or Config.MAX_CONTEXT_MESSAGES
with self._conn() as c:
rows = c.execute("""
SELECT role, content, analysis, ts
FROM conversations
WHERE chat_id=?
ORDER BY ts DESC LIMIT ?
""", (chat_id, limit)).fetchall()
history = []
for r in reversed(rows):
item = {"role": r["role"], "content": r["content"]}
try:
item["analysis"] = json.loads(r["analysis"] or "{}")
except Exception:
item["analysis"] = {}
item["ts"] = r["ts"]
history.append(item)
return history
# ─── Patient Operations ─────────────────────────────────────────────────────
def get_or_create_patient(self, chat_id: str) -> Dict[str, Any]:
with self._conn() as c:
row = c.execute("SELECT * FROM patients WHERE chat_id=?", (chat_id,)).fetchone()
if row:
c.execute("""
UPDATE patients
SET visits=visits+1, last_seen=datetime('now')
WHERE chat_id=?
""", (chat_id,))
data = dict(row)
data['is_new'] = False
# Parse JSON
for field in ['preferences', 'tags', 'services_used']:
try:
data[field] = json.loads(data.get(field, '{}') or '{}')
except Exception:
data[field] = {} if field == 'preferences' else []
return data
else:
c.execute("INSERT INTO patients (chat_id) VALUES (?)", (chat_id,))
return {
"chat_id": chat_id,
"is_new": True,
"visits": 0,
"name": "",
"preferences": {},
"tags": [],
"services_used": []
}
def update_patient(self, chat_id: str, **kwargs):
if not kwargs:
return
for k, v in kwargs.items():
if isinstance(v, (dict, list)):
kwargs[k] = json.dumps(v, ensure_ascii=False)
sets = ", ".join(f"{k}=?" for k in kwargs)
with self._conn() as c:
c.execute(f"UPDATE patients SET {sets} WHERE chat_id=?",
list(kwargs.values()) + [chat_id])
def remember_contact_route(self, chat_id: str, platform: str):
with self._conn() as c:
c.execute("""
INSERT INTO contact_routes (chat_id, platform, updated_at)
VALUES (?, ?, datetime('now'))
ON CONFLICT(chat_id) DO UPDATE SET
platform=excluded.platform,
updated_at=datetime('now')
""", (str(chat_id), str(platform)))
def get_contact_route(self, chat_id: str) -> Optional[str]:
with self._conn() as c:
row = c.execute(
"SELECT platform FROM contact_routes WHERE chat_id=?",
(str(chat_id),),
).fetchone()
return row["platform"] if row else None
# ─── Memoria Permanente ─────────────────────────────────────────────────────
# Esta memoria NUNCA se borra. Sobrevive crashes, resets, migraciones.
# Es lo más importante que Conny sabe de esta clínica.
def remember(self, key: str, value: str, category: str = "identity"):
"""Guarda algo en memoria permanente."""
with self._conn() as c:
c.execute("""
INSERT INTO core_memory (key, value, category, updated_at)
VALUES (?, ?, ?, datetime('now'))
ON CONFLICT(key) DO UPDATE SET
value=excluded.value,
category=excluded.category,
updated_at=datetime('now')
""", (key, str(value), category))
def recall(self, key: str) -> Optional[str]:
"""Recupera algo de memoria permanente."""
with self._conn() as c:
row = c.execute("SELECT value FROM core_memory WHERE key=?", (key,)).fetchone()
return row["value"] if row else None
def recall_all(self, category: str = None) -> Dict[str, str]:
"""Recupera toda la memoria, opcionalmente filtrada por categoría."""
with self._conn() as c:
if category:
rows = c.execute(
"SELECT key, value FROM core_memory WHERE category=? ORDER BY key",
(category,)).fetchall()
else:
rows = c.execute(
"SELECT key, value, category FROM core_memory ORDER BY category, key"
).fetchall()
return {r["key"]: r["value"] for r in rows}
def forget(self, key: str):
"""Borra un elemento de memoria permanente (usar con cuidado)."""
with self._conn() as c:
c.execute("DELETE FROM core_memory WHERE key=?", (key,))
def get_core_memory_block(self) -> str:
"""
Retorna un bloque de texto con la memoria permanente para inyectar al LLM.
Solo lo más importante — identidad, clínica, aprendizajes clave.
"""
memories = self.recall_all()
if not memories:
return ""
lines = []
for key, value in memories.items():
lines.append(f" {key}: {value}")
return "MEMORIA PERMANENTE (nunca olvides esto):\n" + "\n".join(lines)
def get_recent_patient_chats(self, limit: int = 10) -> List[Dict]:
"""Retorna los últimos N pacientes que han hablado con Conny."""
with self._conn() as c:
rows = c.execute("""
SELECT c.chat_id,
p.name,
COUNT(c.id) as message_count,
MAX(c.ts) as last_message,
(SELECT content FROM conversations
WHERE chat_id=c.chat_id AND role='user'
ORDER BY ts DESC LIMIT 1) as last_user_msg
FROM conversations c
LEFT JOIN patients p ON p.chat_id = c.chat_id
WHERE c.chat_id NOT IN (
SELECT chat_id FROM admins WHERE chat_id IS NOT NULL
)
AND c.chat_id != 'status@broadcast'
AND c.chat_id NOT LIKE '%@newsletter'
AND c.chat_id NOT LIKE 'owner-demo-%'
AND c.chat_id NOT LIKE 'owner-debug%'
AND c.chat_id NOT LIKE 'admin_probe%'
AND c.chat_id NOT LIKE 'admin_control%'
AND c.chat_id NOT LIKE 'prompt_probe%'
AND c.chat_id NOT LIKE 'style_probe%'
AND c.chat_id NOT LIKE 'wa_style_probe_%'
AND c.chat_id NOT LIKE 'tone_probe_%'
AND c.chat_id NOT LIKE 'fresh_greeting_fix_%'
GROUP BY c.chat_id
ORDER BY last_message DESC
LIMIT ?
""", (limit,)).fetchall()
return [dict(r) for r in rows]
def get_patient_conversation(self, chat_id: str, limit: int = 30) -> List[Dict]:
"""Retorna la conversación completa de un paciente."""
with self._conn() as c:
rows = c.execute("""
SELECT role, content, ts
FROM conversations
WHERE chat_id=?
ORDER BY ts ASC
LIMIT ?
""", (chat_id, limit)).fetchall()
return [dict(r) for r in rows]
# ─── Feedback y Carpeta de Confianza ────────────────────────────────────────
def save_feedback(self, patient_chat_id: str, feedback_text: str,
feedback_type: str, context: str, admin_chat_id: str) -> int:
"""Guarda feedback del admin sobre una conversación."""
with self._conn() as c:
cursor = c.execute("""
INSERT INTO conversation_feedback
(chat_id, feedback_text, feedback_type, context, created_by)
VALUES (?,?,?,?,?)
""", (patient_chat_id, feedback_text, feedback_type, context, admin_chat_id))
return cursor.lastrowid
def save_trust_rule(self, category: str, rule: str,
example_bad: str = "", example_good: str = "",
weight: float = 1.0) -> int:
"""Agrega una regla a la carpeta de confianza."""
with self._conn() as c:
cursor = c.execute("""
INSERT INTO trust_folder (category, rule, example_bad, example_good, weight)
VALUES (?,?,?,?,?)
""", (category, rule, example_bad, example_good, weight))
return cursor.lastrowid
def get_trust_rules(self, category: str = None, limit: int = 20) -> List[Dict]:
"""Recupera las reglas de comunicación aprendidas."""
with self._conn() as c:
if category:
rows = c.execute("""
SELECT * FROM trust_folder WHERE category=?
ORDER BY weight DESC, times_applied DESC LIMIT ?
""", (category, limit)).fetchall()
else:
rows = c.execute("""
SELECT * FROM trust_folder
ORDER BY weight DESC, times_applied DESC LIMIT ?
""", (limit,)).fetchall()
return [dict(r) for r in rows]
def get_all_trust_rules(self) -> List[Dict]:
"""Todas las reglas para inyectar en el system prompt."""
with self._conn() as c:
rows = c.execute("""
SELECT category, rule, example_bad, example_good
FROM trust_folder
ORDER BY weight DESC, times_applied DESC
LIMIT 30
""").fetchall()
return [dict(r) for r in rows]
def increment_rule_usage(self, rule_id: int):
with self._conn() as c:
c.execute("UPDATE trust_folder SET times_applied=times_applied+1 WHERE id=?",
(rule_id,))
def save_behavior_playbook(self, trigger_text: str, response_example: str,
category: str = "general", instruction: str = "",
bubble_count: int = 1, weight: float = 1.0) -> int:
"""Guarda un playbook aprendido del dueño."""
with self._conn() as c:
cursor = c.execute("""
INSERT INTO behavior_playbooks
(category, trigger_text, instruction, response_example, bubble_count, weight)
VALUES (?,?,?,?,?,?)
""", (
category,
trigger_text,
instruction,
response_example,
max(1, int(bubble_count or 1)),
float(weight or 1.0),
))
return cursor.lastrowid
def get_behavior_playbooks(self, category: str = None, limit: int = 12) -> List[Dict]:
"""Retorna playbooks aprendidos ordenados por prioridad."""
with self._conn() as c:
if category:
rows = c.execute("""
SELECT * FROM behavior_playbooks
WHERE category=?
ORDER BY weight DESC, times_used DESC, id DESC
LIMIT ?
""", (category, limit)).fetchall()
else:
rows = c.execute("""
SELECT * FROM behavior_playbooks
ORDER BY weight DESC, times_used DESC, id DESC
LIMIT ?
""", (limit,)).fetchall()
return [dict(r) for r in rows]
def delete_trust_rule(self, rule_id: int):
with self._conn() as c:
c.execute("DELETE FROM trust_folder WHERE id=?", (rule_id,))
def get_feedback_list(self, limit: int = 10) -> List[Dict]:
"""Últimos feedbacks del admin."""
with self._conn() as c:
rows = c.execute("""
SELECT cf.*, p.name as patient_name
FROM conversation_feedback cf
LEFT JOIN patients p ON p.chat_id = cf.chat_id
ORDER BY cf.created_at DESC LIMIT ?
""", (limit,)).fetchall()
return [dict(r) for r in rows]
# ─── Appointment Operations ─────────────────────────────────────────────────
def save_appointment(self, chat_id: str, data: Dict) -> int:
with self._conn() as c:
cursor = c.execute("""
INSERT INTO appointments
(chat_id, patient_name, patient_phone, patient_email,
service, datetime_slot, duration_minutes, notes)
VALUES (?,?,?,?,?,?,?,?)
""", (
chat_id,
data.get("patient_name", ""),
data.get("patient_phone", ""),
data.get("patient_email", ""),
data.get("service", ""),
data.get("datetime_slot", ""),
data.get("duration_minutes", 60),
data.get("notes", "")
))
return cursor.lastrowid
def get_appointments(self, chat_id: str = None, status: str = None,
limit: int = 50) -> List[Dict]:
query = "SELECT * FROM appointments WHERE 1=1"
params = []
if chat_id:
query += " AND chat_id=?"
params.append(chat_id)
if status:
query += " AND status=?"
params.append(status)
query += " ORDER BY datetime_slot DESC LIMIT ?"
params.append(limit)
with self._conn() as c:
rows = c.execute(query, params).fetchall()
return [dict(r) for r in rows]
def update_appointment(self, apt_id: int, **kwargs):
if not kwargs:
return
kwargs['updated_at'] = datetime.now().isoformat()
sets = ", ".join(f"{k}=?" for k in kwargs)
with self._conn() as c:
c.execute(f"UPDATE appointments SET {sets} WHERE id=?",
list(kwargs.values()) + [apt_id])
# ─── Conversation State ─────────────────────────────────────────────────────
def get_conversation_state(self, chat_id: str) -> ConversationState:
with self._conn() as c:
row = c.execute(
"SELECT state FROM conversation_states WHERE chat_id=?",
(chat_id,)
).fetchone()
if row:
data = json.loads(row["state"])
return ConversationState(
chat_id=chat_id,
phase=data.get("phase", "greeting"),
collected_data=data.get("collected_data", {}),
pending_questions=data.get("pending_questions", []),
last_intent=IntentType[data["last_intent"]] if data.get("last_intent") else None,
turn_count=data.get("turn_count", 0),
satisfaction_score=data.get("satisfaction_score", 0.5),
escalation_needed=data.get("escalation_needed", False),
notes=data.get("notes", [])
)
return ConversationState(
chat_id=chat_id,
phase="greeting",
collected_data={},
pending_questions=[],
last_intent=None,
turn_count=0,
satisfaction_score=0.5,
escalation_needed=False,
notes=[]
)
def save_conversation_state(self, state: ConversationState):
data = {
"phase": state.phase,
"collected_data": state.collected_data,
"pending_questions": state.pending_questions,
"last_intent": state.last_intent.name if state.last_intent else None,
"turn_count": state.turn_count,
"satisfaction_score": state.satisfaction_score,
"escalation_needed": state.escalation_needed,
"notes": state.notes
}
with self._conn() as c:
c.execute("""
INSERT OR REPLACE INTO conversation_states (chat_id, state, updated_at)
VALUES (?, ?, datetime('now'))
""", (state.chat_id, json.dumps(data, ensure_ascii=False)))
# ─── Memory Operations ──────────────────────────────────────────────────────
def save_memory(self, memory: MemoryItem):
embedding_blob = None
if memory.embedding:
# Serialize embedding as binary
import struct
embedding_blob = struct.pack(f'{len(memory.embedding)}f', *memory.embedding)
with self._conn() as c:
c.execute("""
INSERT OR REPLACE INTO memories
(id, chat_id, content, embedding, category, importance,
accessed_count, created_at, last_accessed, metadata)
VALUES (?,?,?,?,?,?,?,?,?,?)
""", (
memory.id,
memory.chat_id,
memory.content,
embedding_blob,
memory.category,
memory.importance,
memory.accessed_count,
memory.created_at.isoformat(),
memory.last_accessed.isoformat(),
json.dumps(memory.metadata, ensure_ascii=False)
))
def search_memories(self, chat_id: str, category: str = None,
limit: int = 10) -> List[MemoryItem]:
query = "SELECT * FROM memories WHERE chat_id=?"
params = [chat_id]
if category:
query += " AND category=?"
params.append(category)
query += " ORDER BY importance DESC, last_accessed DESC LIMIT ?"
params.append(limit)
with self._conn() as c:
rows = c.execute(query, params).fetchall()
memories = []
for r in rows:
embedding = None
if r["embedding"]:
import struct
n = len(r["embedding"]) // 4
embedding = list(struct.unpack(f'{n}f', r["embedding"]))
memories.append(MemoryItem(
id=r["id"],
chat_id=r["chat_id"],
content=r["content"],
embedding=embedding,
category=r["category"],
importance=r["importance"],
created_at=datetime.fromisoformat(r["created_at"]),
accessed_count=r["accessed_count"],
last_accessed=datetime.fromisoformat(r["last_accessed"]),
metadata=json.loads(r["metadata"] or "{}")
))
return memories
# ─── Task Operations ────────────────────────────────────────────────────────
def create_task(self, task: Task):
with self._conn() as c:
c.execute("""
INSERT INTO tasks
(id, type, priority, status, data, scheduled_for, created_at)
VALUES (?,?,?,?,?,?,?)
""", (
task.id,
task.type,
task.priority,
task.status,
json.dumps(task.data, ensure_ascii=False),
task.scheduled_for.isoformat() if task.scheduled_for else None,
task.created_at.isoformat()
))
def get_pending_tasks(self, limit: int = 20) -> List[Task]:
with self._conn() as c:
rows = c.execute("""
SELECT * FROM tasks
WHERE status IN ('pending', 'running')
AND (scheduled_for IS NULL OR scheduled_for <= datetime('now'))
ORDER BY priority DESC, created_at ASC
LIMIT ?
""", (limit,)).fetchall()
return [Task(
id=r["id"],
type=r["type"],
priority=r["priority"],
status=r["status"],
data=json.loads(r["data"] or "{}"),
created_at=datetime.fromisoformat(r["created_at"]),
scheduled_for=datetime.fromisoformat(r["scheduled_for"]) if r["scheduled_for"] else None,
completed_at=datetime.fromisoformat(r["completed_at"]) if r["completed_at"] else None,
result=json.loads(r["result"]) if r["result"] else None,
retries=r["retries"]
) for r in rows]
def update_task(self, task_id: str, **kwargs):
if not kwargs:
return
for k, v in kwargs.items():
if isinstance(v, (dict, list)):
kwargs[k] = json.dumps(v, ensure_ascii=False)
elif isinstance(v, datetime):
kwargs[k] = v.isoformat()
sets = ", ".join(f"{k}=?" for k in kwargs)
with self._conn() as c:
c.execute(f"UPDATE tasks SET {sets} WHERE id=?",
list(kwargs.values()) + [task_id])
# ─── MCP Plugin Operations ──────────────────────────────────────────────────
def get_plugins(self, enabled_only: bool = False) -> List[MCPPlugin]:
query = "SELECT * FROM mcp_plugins"
if enabled_only:
query += " WHERE enabled=1"
with self._conn() as c:
rows = c.execute(query).fetchall()
return [MCPPlugin(
id=r["id"],
name=r["name"],
description=r["description"],
version=r["version"],
enabled=bool(r["enabled"]),
config=json.loads(r["config"] or "{}"),
capabilities=json.loads(r["capabilities"] or "[]"),
endpoints=json.loads(r["endpoints"] or "{}"),
health_status=r["health_status"],
last_check=datetime.fromisoformat(r["last_check"]) if r["last_check"] else datetime.now()
) for r in rows]
def install_plugin(self, plugin: MCPPlugin):
with self._conn() as c:
c.execute("""
INSERT OR REPLACE INTO mcp_plugins
(id, name, description, version, enabled, config,
capabilities, endpoints, health_status, last_check)
VALUES (?,?,?,?,?,?,?,?,?,?)
""", (
plugin.id,
plugin.name,
plugin.description,
plugin.version,
int(plugin.enabled),
json.dumps(plugin.config, ensure_ascii=False),
json.dumps(plugin.capabilities, ensure_ascii=False),
json.dumps(plugin.endpoints, ensure_ascii=False),
plugin.health_status,
plugin.last_check.isoformat()
))
# ─── Metrics Operations ─────────────────────────────────────────────────────
def record_metric(self, metric_type: str, metric_name: str,
value: float, dimensions: Dict = None):
with self._conn() as c:
c.execute("""
INSERT INTO metrics (metric_type, metric_name, metric_value, dimensions)
VALUES (?,?,?,?)
""", (metric_type, metric_name, value,
json.dumps(dimensions or {}, ensure_ascii=False)))
def get_metrics(self, metric_type: str = None, since: datetime = None,
limit: int = 1000) -> List[Dict]:
query = "SELECT * FROM metrics WHERE 1=1"
params = []
if metric_type:
query += " AND metric_type=?"
params.append(metric_type)
if since:
query += " AND ts >= ?"
params.append(since.isoformat())
query += " ORDER BY ts DESC LIMIT ?"
params.append(limit)
with self._conn() as c:
rows = c.execute(query, params).fetchall()
return [dict(r) for r in rows]
# ─── Learned Optimizations ──────────────────────────────────────────────────
def save_optimization(self, category: str, trigger: str,
optimization: str, success_rate: float = 0):
with self._conn() as c:
c.execute("""
INSERT INTO learned_optimizations
(category, trigger_pattern, optimization, success_rate)
VALUES (?,?,?,?)
""", (category, trigger, optimization, success_rate))
def get_optimizations(self, category: str = None) -> List[Dict]:
query = "SELECT * FROM learned_optimizations WHERE success_rate > 0.5"
params = []
if category:
query += " AND category=?"
params.append(category)
query += " ORDER BY success_rate DESC, usage_count DESC"
with self._conn() as c:
rows = c.execute(query, params).fetchall()
return [dict(r) for r in rows]
# ─── Self Improvement Log ───────────────────────────────────────────────────
def log_improvement(self, improvement_type: str, description: str,
before: Dict, after: Dict, impact: float, applied: bool):
with self._conn() as c:
c.execute("""
INSERT INTO self_improvement_log
(improvement_type, description, before_state, after_state,
impact_score, applied)
VALUES (?,?,?,?,?,?)
""", (
improvement_type,
description,
json.dumps(before, ensure_ascii=False),
json.dumps(after, ensure_ascii=False),
impact,
int(applied)
))
# ─── Response Cache ─────────────────────────────────────────────────────────
def cache_response(self, query_hash: str, response: str, ttl: int = 3600):
with self._conn() as c:
c.execute("""
INSERT OR REPLACE INTO response_cache
(hash, response, hit_count, last_hit, ttl_seconds)
VALUES (?,?,1,datetime('now'),?)
""", (query_hash, response, ttl))
def get_cached_response(self, query_hash: str) -> Optional[str]:
with self._conn() as c:
row = c.execute("""
SELECT response, created_at, ttl_seconds
FROM response_cache
WHERE hash=?
""", (query_hash,)).fetchone()
if row:
created = datetime.fromisoformat(row["created_at"])
if datetime.now() - created < timedelta(seconds=row["ttl_seconds"]):
c.execute("""
UPDATE response_cache
SET hit_count=hit_count+1, last_hit=datetime('now')
WHERE hash=?
""", (query_hash,))
return row["response"]
return None
# ─── Auth Operations ─────────────────────────────────────────────────────────
def create_activation_token(self, token: str, clinic_label: str,
expires_at: str) -> bool:
"""Crea un token de activacion (lo genera Santiago)."""
try:
with self._conn() as c:
c.execute("""
INSERT INTO activation_tokens
(token, clinic_label, expires_at)
VALUES (?, ?, ?)
""", (token, clinic_label, expires_at))
return True
except Exception:
return False
def get_activation_token(self, token: str) -> Optional[Dict]:
"""Lee un token. Retorna None si no existe, expirado o ya usado."""
with self._conn() as c:
row = c.execute(
"SELECT * FROM activation_tokens WHERE token=?", (token,)
).fetchone()
if not row:
return None
data = dict(row)
# Verificar expiracion
try:
exp = datetime.fromisoformat(data["expires_at"])
if datetime.now() > exp:
return None
except Exception:
return None
# Verificar si ya fue usado
if data.get("used_at") and data.get("is_active") == 0:
return None
return data
def consume_activation_token(self, token: str, chat_id: str):
"""Marca el token como usado."""
with self._conn() as c:
c.execute("""
UPDATE activation_tokens
SET used_at=datetime('now'), used_by_chat_id=?, is_active=0
WHERE token=?
""", (chat_id, token))
def create_admin(self, chat_id: str, email: str, password_hash: str,
name: str, role: str = "admin",
token: str = "", invited_by: str = "") -> bool:
"""Registra un nuevo admin."""
try:
with self._conn() as c:
c.execute("""
INSERT OR REPLACE INTO admins
(chat_id, email, password_hash, name, role,
activated_by_token, invited_by_chat_id, is_active)
VALUES (?, ?, ?, ?, ?, ?, ?, 1)
""", (chat_id, email.lower(), password_hash, name,
role, token, invited_by))
return True
except Exception as e:
log.warning(f"create_admin error: {e}")
return False
def get_admin(self, chat_id: str) -> Optional[Dict]:
"""Obtiene admin por chat_id."""
with self._conn() as c:
row = c.execute(
"SELECT * FROM admins WHERE chat_id=? AND is_active=1",
(chat_id,)
).fetchone()
return dict(row) if row else None
def get_admin_by_email(self, email: str) -> Optional[Dict]:
"""Obtiene admin por email."""
with self._conn() as c:
row = c.execute(
"SELECT * FROM admins WHERE email=? AND is_active=1",
(email.lower(),)
).fetchone()
return dict(row) if row else None
def list_admins(self) -> List[Dict]:
"""Lista todos los admins activos."""
with self._conn() as c:
rows = c.execute(
"SELECT id,chat_id,email,name,role,created_at FROM admins WHERE is_active=1"
).fetchall()
return [dict(r) for r in rows]
def update_admin_login(self, chat_id: str):
"""Actualiza ultimo login y resetea intentos fallidos."""
with self._conn() as c:
c.execute("""
UPDATE admins SET last_login=datetime('now'), login_attempts=0
WHERE chat_id=?
""", (chat_id,))
def increment_login_attempts(self, chat_id: str):
with self._conn() as c:
c.execute("""
UPDATE admins SET login_attempts=login_attempts+1 WHERE chat_id=?
""", (chat_id,))
def deactivate_admin(self, chat_id: str):
with self._conn() as c:
c.execute("UPDATE admins SET is_active=0 WHERE chat_id=?", (chat_id,))
def get_owner(self) -> Optional[Dict]:
"""Obtiene el owner (primer admin con role=owner)."""
with self._conn() as c:
row = c.execute(
"SELECT * FROM admins WHERE role='owner' AND is_active=1 LIMIT 1"
).fetchone()
return dict(row) if row else None
# ─── Auth Session (flujo pendiente) ─────────────────────────────────────────
def get_auth_session(self, chat_id: str) -> Optional[Dict]:
with self._conn() as c:
row = c.execute(
"SELECT * FROM auth_sessions WHERE chat_id=?", (chat_id,)
).fetchone()
if not row:
return None
data = dict(row)
try:
data["temp_data"] = json.loads(data.get("temp_data") or "{}")
except Exception:
data["temp_data"] = {}
return data
def set_auth_session(self, chat_id: str, flow: str, step: str,
temp_data: Dict = None, attempts: int = 0):
with self._conn() as c:
c.execute("""
INSERT OR REPLACE INTO auth_sessions
(chat_id, flow, step, temp_data, attempts, updated_at)
VALUES (?, ?, ?, ?, ?, datetime('now'))
""", (chat_id, flow, step,
json.dumps(temp_data or {}, ensure_ascii=False), attempts))
def clear_auth_session(self, chat_id: str):
with self._conn() as c:
c.execute("DELETE FROM auth_sessions WHERE chat_id=?", (chat_id,))
# Instancia global
db: DatabaseManager = None
kb: "KnowledgeBase" = None
def init_database():
global db, kb
db = DatabaseManager(Config.DB_PATH, Config.VECTOR_DB_PATH)
if _KB_AVAILABLE:
kb = KnowledgeBase(Config.DB_PATH)
log.info("[kb] KnowledgeBase inicializada")
# ═══════════════════════════════════════════════════════════════════════════════
# MOTOR LLM MULTI-PROVEEDOR
# Cascada: Groq -> Gemini(×3) -> OpenRouter -> OpenAI
# Cada proveedor usa sus propios nombres de modelo.
# ═══════════════════════════════════════════════════════════════════════════════
class LLMProvider:
"""Interfaz base para proveedores LLM."""
name: str = "base"
async def complete(self, messages: List[Dict], model: str,
temperature: float = 0.7, max_tokens: int = 1000,
**kwargs) -> Tuple[str, Dict]:
raise NotImplementedError
async def embed(self, text: str) -> List[float]:
raise NotImplementedError
def _parse_http_json_response(response: httpx.Response, provider_name: str) -> Dict[str, Any]:
body = response.text or ""
stripped = body.strip()
content_type = (response.headers.get("content-type") or "").strip() or "unknown"
if not stripped:
raise ValueError(f"{provider_name} devolvió body vacío [{content_type}]")
try:
parsed = response.json()
except Exception as exc:
snippet = re.sub(r"\s+", " ", stripped)[:220]
raise ValueError(
f"{provider_name} devolvió body no-JSON [{content_type}]: {snippet}"
) from exc
if not isinstance(parsed, dict):
raise ValueError(f"{provider_name} devolvió JSON no-objeto [{content_type}]")
return parsed
class GroqProvider(LLMProvider):
"""Groq — el mas rapido (~500ms). Llama-3.3-70b."""
name = "groq"
BASE = "https://api.groq.com/openai/v1"
MDLS = {"reasoning": "llama-3.3-70b-versatile",
"fast": "llama-3.3-70b-versatile",
"lite": "llama-3.1-8b-instant"}
def __init__(self, key: str): self.key = key
async def complete(self, messages, model="fast", temperature=0.7, max_tokens=1000, **kw):
start = time.time()
if isinstance(model, str) and model in self.MDLS:
m = self.MDLS[model]
elif isinstance(model, str) and model.startswith("groq/"):
m = model.split("/", 1)[1]
elif isinstance(model, str) and model not in ("fast", "reasoning", "lite"):
m = model
else:
m = self.MDLS["fast"]
async with httpx.AsyncClient(timeout=15.0) as c:
r = await c.post(f"{self.BASE}/chat/completions",
headers={"Authorization": f"Bearer {self.key}", "Content-Type": "application/json"},
json={"model": m, "messages": messages, "temperature": temperature, "max_tokens": max_tokens})
r.raise_for_status()
payload = _parse_http_json_response(r, self.name)
text = payload["choices"][0]["message"]["content"].strip()
return text, {"model": m, "latency_ms": int((time.time()-start)*1000), "provider": "groq"}
async def embed(self, text):
raise NotImplementedError
class GeminiProvider(LLMProvider):
"""Google Gemini directo. Soporta rotacion de claves."""
name = "gemini"
BASE = "https://generativelanguage.googleapis.com/v1beta"
MDLS = {"reasoning": "gemini-2.5-pro", # Pro para razonamiento complejo
"fast": "gemini-2.5-flash", # Flash para velocidad
"lite": "gemini-2.5-flash-lite"}
def __init__(self, key: str, label: str = "gemini"):
self.key = key
self.name = label
async def complete(self, messages, model="fast", temperature=0.7, max_tokens=1000, **kw):
start = time.time()
if isinstance(model, str) and model in self.MDLS:
gm = self.MDLS[model]
elif isinstance(model, str) and model.startswith("google/"):
gm = model.split("/", 1)[1]
elif isinstance(model, str) and model.startswith("gemini-"):
gm = model
else:
gm = self.MDLS["fast"]
system_parts, contents = [], []
for m in messages:
if m["role"] == "system":
system_parts.append({"text": m["content"]})
elif m["role"] == "user":
contents.append({"role": "user", "parts": [{"text": m["content"]}]})
elif m["role"] == "assistant":
contents.append({"role": "model", "parts": [{"text": m["content"]}]})
payload = {"contents": contents,
"generationConfig": {"temperature": temperature, "maxOutputTokens": max_tokens}}
if system_parts:
payload["systemInstruction"] = {"parts": system_parts}
url = f"{self.BASE}/models/{gm}:generateContent?key={self.key}"
async with httpx.AsyncClient(timeout=20.0) as c:
r = await c.post(url, json=payload)
r.raise_for_status()
payload = _parse_http_json_response(r, self.name)
text = payload["candidates"][0]["content"]["parts"][0]["text"].strip()
return text, {"model": gm, "latency_ms": int((time.time()-start)*1000), "provider": self.name}
async def embed(self, text):
url = f"{self.BASE}/models/text-embedding-004:embedContent?key={self.key}"
async with httpx.AsyncClient(timeout=30.0) as c:
r = await c.post(url, json={"content": {"parts": [{"text": text}]}})
r.raise_for_status()
return r.json()["embedding"]["values"]
class OpenRouterProvider(LLMProvider):
"""OpenRouter — acceso a todos los modelos."""
name = "openrouter"
BASE = "https://openrouter.ai/api/v1"
MDLS = {"reasoning": "anthropic/claude-sonnet-4",
"fast": "google/gemini-2.5-flash",
"lite": "google/gemini-2.5-flash-lite"}
def __init__(self, key: str): self.key = key
async def complete(self, messages, model="fast", temperature=0.7, max_tokens=1000, **kw):
start = time.time()
m = self.MDLS.get(model, model if isinstance(model, str) else self.MDLS["fast"])
async with httpx.AsyncClient(timeout=25.0) as c:
r = await c.post(f"{self.BASE}/chat/completions",
headers={"Authorization": f"Bearer {self.key}", "Content-Type": "application/json",
"HTTP-Referer": "https://conny.ai", "X-Title": "Conny Ultra"},
json={"model": m, "messages": messages, "temperature": temperature, "max_tokens": max_tokens})
r.raise_for_status()
payload = _parse_http_json_response(r, self.name)
text = payload["choices"][0]["message"]["content"].strip()
return text, {"model": m, "latency_ms": int((time.time()-start)*1000), "provider": "openrouter"}
async def embed(self, text):
async with httpx.AsyncClient(timeout=30.0) as c:
r = await c.post(f"{self.BASE}/embeddings",
headers={"Authorization": f"Bearer {self.key}", "Content-Type": "application/json"},
json={"model": "openai/text-embedding-3-small", "input": text})
r.raise_for_status()
return r.json()["data"][0]["embedding"]
class OpenAIProvider(LLMProvider):
"""OpenAI — ultimo recurso."""
name = "openai"
BASE = "https://api.openai.com/v1"
MDLS = {"reasoning": "gpt-4o", "fast": "gpt-4o-mini", "lite": "gpt-4o-mini"}
def __init__(self, key: str): self.key = key
async def complete(self, messages, model="fast", temperature=0.7, max_tokens=1000, **kw):
start = time.time()
if isinstance(model, str) and model in self.MDLS:
m = self.MDLS[model]
elif isinstance(model, str) and model.startswith("openai/"):
m = model.split("/", 1)[1]
elif isinstance(model, str) and model.startswith("gpt-"):
m = model
else:
m = self.MDLS["fast"]
async with httpx.AsyncClient(timeout=25.0) as c:
r = await c.post(f"{self.BASE}/chat/completions",
headers={"Authorization": f"Bearer {self.key}", "Content-Type": "application/json"},
json={"model": m, "messages": messages, "temperature": temperature, "max_tokens": max_tokens})
r.raise_for_status()
payload = _parse_http_json_response(r, self.name)
text = payload["choices"][0]["message"]["content"].strip()
return text, {"model": m, "latency_ms": int((time.time()-start)*1000), "provider": "openai"}
async def embed(self, text):
async with httpx.AsyncClient(timeout=30.0) as c:
r = await c.post(f"{self.BASE}/embeddings",
headers={"Authorization": f"Bearer {self.key}", "Content-Type": "application/json"},
json={"model": "text-embedding-3-small", "input": text})
r.raise_for_status()
return r.json()["data"][0]["embedding"]
class LLMEngine:
"""
Motor LLM con cascada de 6 proveedores.
Groq -> Gemini(key1) -> Gemini(key2) -> Gemini(key3) -> OpenRouter -> OpenAI
V8.1 — Fixes de fallos silenciosos:
- Blacklist temporal (60s) en vez de permanente
- Detección de respuesta vacía o inválida
- Timeout de provider < timeout de caller (nunca zombie)
- _push_to_engine solo en OpenRouter (único multi-modelo real)
- Métricas de fallo por provider en DB para diagnóstico
"""
# Providers que soportan modelos externos (OpenRouter puede usar cualquier modelo)
_MULTI_MODEL_PROVIDERS = {"openrouter"}
def __init__(self):
self.providers: List[LLMProvider] = []
self._failures: Dict[str, int] = {} # conteo de fallos
self._blocked_until: Dict[str, float] = {} # timestamp hasta cuando está bloqueado
self._last_success: Dict[str, float] = {}
self._blacklist_ttl = 60.0 # segundos de bloqueo tras 3 fallos consecutivos
self._cache: Dict[str, Tuple[str, float]] = {}
self._cache_ttl = 300
if Config.GROQ_API_KEY:
self.providers.append(GroqProvider(Config.GROQ_API_KEY))
log.info("[llm] Groq OK")
_all_gemini_keys = Config.GEMINI_API_KEYS or [
Config.GEMINI_API_KEY, Config.GEMINI_API_KEY_2,
Config.GEMINI_API_KEY_3, Config.GEMINI_API_KEY_4,
Config.GEMINI_API_KEY_5, Config.GEMINI_API_KEY_6,
]
for i, key in enumerate(_all_gemini_keys):
if key:
self.providers.append(GeminiProvider(key, f"gemini_k{i+1}"))
log.info(f"[llm] Gemini key{i+1} OK")
if Config.OPENROUTER_API_KEY:
self.providers.append(OpenRouterProvider(Config.OPENROUTER_API_KEY))
log.info("[llm] OpenRouter OK")
if Config.OPENAI_API_KEY:
self.providers.append(OpenAIProvider(Config.OPENAI_API_KEY))
log.info("[llm] OpenAI OK")
n = len(self.providers)
if n == 0:
log.critical("[llm] SIN PROVEEDORES — el bot no podra generar respuestas inteligentes")
else:
log.info(f"[llm] cascada lista: {n} proveedores")
def _hash(self, messages, **kw):
return hashlib.md5((json.dumps(messages, sort_keys=True) + json.dumps(kw, sort_keys=True)).encode()).hexdigest()
def _get_requested_model(self, model_tier: str) -> str:
try:
if model_manager:
effective = model_manager.get_effective_models()
chosen = effective.get(model_tier)
if chosen:
return chosen
except Exception:
pass
return Config.LLM_MODELS.get(model_tier, model_tier)
def _ordered_providers(self, requested_model: str) -> List[LLMProvider]:
providers = list(self.providers)
def _priority(provider: LLMProvider) -> int:
name = provider.name
if requested_model.startswith("google/") or requested_model.startswith("gemini-"):
if name.startswith("gemini"):
return 0
if name == "openrouter":
return 1
return 2
if requested_model.startswith("anthropic/") or requested_model.startswith("meta-llama/") or requested_model.startswith("mistralai/"):
if name == "openrouter":
return 0
return 2
if requested_model.startswith("openai/") or requested_model.startswith("gpt-"):
if name == "openai":
return 0
if name == "openrouter":
return 1
return 2
if requested_model.startswith("groq/") or requested_model.startswith("llama-"):
if name == "groq":
return 0
if name == "openrouter":
return 1
return 2
return 0
return sorted(
providers,
key=lambda provider: (
_priority(provider),
self._failures.get(provider.name, 0),
-self._last_success.get(provider.name, 0.0),
provider.name,
),
)
def _resolve_provider_model(self, provider: LLMProvider,
requested_model: str,
model_tier: str) -> str:
name = provider.name
if name.startswith("gemini") and (
requested_model.startswith("google/") or requested_model.startswith("gemini-")
):
return requested_model
if name == "openai" and (
requested_model.startswith("openai/") or requested_model.startswith("gpt-")
):
return requested_model
if name == "groq" and (
requested_model.startswith("groq/") or requested_model.startswith("llama-")
):
return requested_model
if name == "openrouter":
return requested_model
return model_tier
def _is_blocked(self, provider_name: str) -> bool:
"""Blacklist temporal: bloqueado solo por _blacklist_ttl segundos."""
until = self._blocked_until.get(provider_name, 0)
if until and time.time() < until:
return True
# Tiempo expirado — resetear fallos para darle otra oportunidad
if until and time.time() >= until:
self._failures[provider_name] = 0
self._blocked_until[provider_name] = 0
log.info(f"[llm] {provider_name} desbloqueado (blacklist expirado)")
return False
def _register_failure(self, provider_name: str, error: Exception):
"""Registra un fallo y bloquea si acumula 3 consecutivos."""
self._failures[provider_name] = self._failures.get(provider_name, 0) + 1
count = self._failures[provider_name]
log.warning(f"[llm] {provider_name} fallo #{count}: {str(error)[:100]}")
status_code = getattr(getattr(error, "response", None), "status_code", None)
block_after = 3
block_ttl = self._blacklist_ttl
if status_code in (401, 402, 403):
block_after = 1
block_ttl = max(block_ttl, 1800.0)
elif status_code in (429, 500, 502, 503, 504):
block_after = 2
block_ttl = max(block_ttl, 180.0)
if count >= block_after:
self._blocked_until[provider_name] = time.time() + block_ttl
log.error(f"[llm] {provider_name} BLOQUEADO por {block_ttl}s tras {count} fallos")
# Guardar métrica en DB para que el admin pueda ver con /v8
try:
if db:
db.record_metric("llm_failure", provider_name, count,
{"error": str(error)[:80], "blocked": count >= block_after, "status_code": status_code})
except Exception:
pass
def _is_valid_response(self, text: str) -> bool:
"""Detecta respuestas vacías o inválidas que no deben llegar al usuario."""
if not text or not text.strip():
return False
stripped = text.strip()
# Respuesta puramente de error del API
if stripped.startswith("Error") and len(stripped) < 30:
return False
# JSON de error de OpenRouter / Gemini que se filtró
if stripped.startswith('{"error"') or stripped.startswith('{"status"'):
return False
return True
async def complete(self, messages: List[Dict],
model_tier: str = "fast",
temperature: float = 0.7,
max_tokens: int = 1000,
use_cache: bool = True,
**kwargs) -> Tuple[str, Dict]:
requested_model = self._get_requested_model(model_tier)
if use_cache and db:
ck = self._hash(messages, t=temperature, m=max_tokens,
tier=model_tier, requested_model=requested_model)
cached = db.get_cached_response(ck)
if cached and self._is_valid_response(cached):
return cached, {"cached": True}
last_error = None
attempted = []
for provider in self._ordered_providers(requested_model):
if self._is_blocked(provider.name):
log.debug(f"[llm] {provider.name} saltado (blacklist activo)")
continue
attempted.append(provider.name)
try:
provider_model = self._resolve_provider_model(provider, requested_model, model_tier)
# Timeout del provider siempre menor que el del caller
# para evitar zombies. El caller (admin_brain) usa 12s,
# los providers internos usan hasta 25s — reducimos aquí.
response, metadata = await asyncio.wait_for(
provider.complete(
messages, model=provider_model,
temperature=temperature, max_tokens=max_tokens, **kwargs),
timeout=10.0 # siempre < 12s del caller
)
# Verificar que la respuesta sea válida — no vacía ni error
if not self._is_valid_response(response):
err = ValueError(f"respuesta inválida/vacía: '{response[:40]}'")
self._register_failure(provider.name, err)
last_error = err
log.warning(f"[llm] {provider.name} devolvió respuesta inválida — siguiente")
continue
# Éxito — resetear fallos
self._failures[provider.name] = 0
self._last_success[provider.name] = time.time()
if use_cache and db:
db.cache_response(ck, response)
if db:
db.record_metric("llm", "completion",
metadata.get("latency_ms", 0),
{"provider": metadata.get("provider"), "tier": model_tier,
"requested_model": requested_model})
log.info(
f"[llm] {provider.name} OK ({metadata.get('latency_ms',0)}ms) | "
f"tier={model_tier} requested={requested_model}"
)
return response, metadata
except asyncio.TimeoutError as e:
te = TimeoutError(f"timeout 10s")
self._register_failure(provider.name, te)
last_error = te
except Exception as e:
self._register_failure(provider.name, e)
last_error = e
providers_tried = ", ".join(attempted) if attempted else "ninguno"
raise RuntimeError(f"Todos los LLM fallaron [{providers_tried}]: {last_error}")
def get_health(self) -> Dict:
"""Estado de salud de cada provider. Usado por /v8 y diagnóstico."""
now = time.time()
result = {}
for p in self.providers:
blocked_until = self._blocked_until.get(p.name, 0)
result[p.name] = {
"failures": self._failures.get(p.name, 0),
"blocked": now < blocked_until,
"unblocks_in": max(0, int(blocked_until - now)) if now < blocked_until else 0,
}
return result
async def embed(self, text: str) -> List[float]:
for p in self.providers:
try:
return await p.embed(text)
except Exception:
continue
return self._simple_embedding(text)
def _simple_embedding(self, text: str, dim: int = 384) -> List[float]:
words = text.lower().split()
vec = [0.0] * dim
for i, w in enumerate(words[:dim]):
vec[i % dim] += hash(w) % 100 / 100.0
norm = math.sqrt(sum(x*x for x in vec))
return [x/norm for x in vec] if norm > 0 else vec
# Instancia global
llm_engine: LLMEngine = None
def init_llm():
global llm_engine
llm_engine = LLMEngine()
# ═══════════════════════════════════════════════════════════════════════════════
# ANALIZADOR DE MENSAJES AVANZADO
# ═══════════════════════════════════════════════════════════════════════════════
class MessageAnalyzer:
"""Analizador de mensajes con múltiples capas."""
# Patrones de intención
INTENT_PATTERNS = {
IntentType.GREETING: [
r'\b(hola|buenas?|hey|hi|saludos|buenos?\s*(dias?|tardes?|noches?))\b',
r'^(que\s*tal|como\s*estas?|que\s*hay)\b'
],
IntentType.APPOINTMENT_REQUEST: [
r'\b(cita|agendar|reservar|programar|turno|horario\s*disponible)\b',
r'\b(quiero|necesito|puedo|podria|quisiera)\s*(una?\s*)?(cita|turno|hora)\b',
r'\b(cuando\s*puedo\s*ir|tienen\s*disponibilidad)\b'
],
IntentType.APPOINTMENT_CANCEL: [
r'\b(cancelar?|anular?)\s*(mi)?\s*(cita|turno)\b',
r'\bno\s*puedo\s*(ir|asistir)\b'
],
IntentType.APPOINTMENT_RESCHEDULE: [
r'\b(cambiar?|reprogramar?|mover?|reagendar?)\s*(mi)?\s*(cita|turno)\b',
r'\b(otro\s*dia|otra\s*hora|otra\s*fecha)\b'
],
IntentType.PRICE_INQUIRY: [
r'\b(precio|costo|valor|cuanto\s*(vale|cuesta|cobran?|es)|tarifa|cotizacion)\b',
r'\b(que\s*precio|cual\s*es\s*el\s*precio)\b'
],
IntentType.SERVICE_INFO: [
r'\b(que\s*es|como\s*(es|funciona|se\s*hace)|en\s*que\s*consiste)\b',
r'\b(informacion|info|detalles?|explicar?)\s*(sobre|de|del)\b',
r'\b(duele|durar?|resultados?|recuperacion|contraindicaciones?)\b'
],
IntentType.LOCATION_INQUIRY: [
r'\b(donde\s*(esta[ns]?|queda[ns]?)|direccion|ubicacion|como\s*llego)\b',
r'\b(mapa|ruta|transporte)\b'
],
IntentType.HOURS_INQUIRY: [
r'\b(horario|hora|cuando\s*(abren|cierran|atienden))\b',
r'\b(a\s*que\s*hora|hasta\s*que\s*hora)\b'
],
IntentType.COMPLAINT: [
r'\b(queja|reclamo|molest[ao]|mal\s*servicio|decepcionad[ao])\b',
r'\b(no\s*me\s*gust[oa]|muy\s*mal|pesimo|horrible)\b'
],
IntentType.COMPLIMENT: [
r'\b(excelente|gracias?|genial|increible|muy\s*bien|perfecto)\b',
r'\b(buen\s*servicio|me\s*encant[oa]|recomiendo)\b'
],
IntentType.EMERGENCY: [
r'\b(urgente|emergencia|urgencia|dolor\s*fuerte|sangr[ae]|accidente)\b',
r'\b(ayuda|socorro|grave)\b'
],
IntentType.CONFIRMATION: [
r'^(si|sip|sep|ok|okay|vale|listo|correcto|exacto|claro|por\s*supuesto|dale)$',
r'\b(confirm[ao]|de\s*acuerdo|asi\s*es)\b'
],
IntentType.DENIAL: [
r'^(no|nop|nel|nah|negativo)$',
r'\b(no\s*gracias|no\s*quiero|no\s*puedo|cancelar?)\b'
]
}
# Palabras de sentimiento
SENTIMENT_WORDS = {
"positive": [
"gracias", "excelente", "genial", "perfecto", "increible", "maravilloso",
"encanta", "amor", "feliz", "contento", "satisfecho", "recomiendo",
"profesional", "amable", "rapido", "eficiente", "bien"
],
"negative": [
"mal", "terrible", "horrible", "pesimo", "decepcion", "molesto",
"enojado", "frustrado", "lento", "caro", "malo", "odio", "nunca",
"jamas", "peor", "queja", "reclamo", "problema", "error"
]
}
# Palabras de urgencia
URGENCY_WORDS = {
UrgencyLevel.CRITICAL: ["emergencia", "urgente", "sangre", "accidente", "grave", "ayuda"],
UrgencyLevel.HIGH: ["dolor", "molestia", "hoy", "ahora", "rapido", "inmediato"],
UrgencyLevel.MEDIUM: ["pronto", "esta semana", "necesito", "importante"],
}
def __init__(self):
self._compiled_patterns = {}
for intent, patterns in self.INTENT_PATTERNS.items():
self._compiled_patterns[intent] = [
re.compile(p, re.IGNORECASE | re.UNICODE)
for p in patterns
]
def analyze(self, text: str, context: List[Dict] = None) -> MessageAnalysis:
"""Análisis completo del mensaje."""
cleaned = self._clean_text(text)
# Detectar intención
intent, confidence, secondary = self._detect_intent(cleaned)
# Detectar sentimiento
sentiment, sentiment_score = self._detect_sentiment(cleaned)
# Detectar urgencia
urgency = self._detect_urgency(cleaned)
# Extraer entidades
entities = self._extract_entities(cleaned)
# Extraer keywords
keywords = self._extract_keywords(cleaned)
# Determinar estado emocional
emotional_state = self._infer_emotional_state(sentiment, urgency, cleaned)
# Determinar si requiere acción
requires_action = intent in [
IntentType.APPOINTMENT_REQUEST,
IntentType.APPOINTMENT_CANCEL,
IntentType.APPOINTMENT_RESCHEDULE,
IntentType.EMERGENCY,
IntentType.COMPLAINT
]
# Determinar si requiere búsqueda
requires_search = intent in [
IntentType.PRICE_INQUIRY,
IntentType.SERVICE_INFO
] or any(kw in cleaned.lower() for kw in [
"cuanto", "precio", "costo", "como funciona", "que es",
"efectos", "resultados", "duracion"
])
# ── Closing score y temperatura del lead ─────────────────────────────
closing_score, lead_temperature = self._calc_closing_score(
cleaned, intent, sentiment, urgency, context or []
)
# ── Detección de idioma ───────────────────────────────────────────────
language = self._detect_language(cleaned)
return MessageAnalysis(
raw_text=text,
cleaned_text=cleaned,
intent=intent,
intent_confidence=confidence,
secondary_intents=secondary,
sentiment=sentiment,
sentiment_score=sentiment_score,
urgency=urgency,
entities=entities,
keywords=keywords,
language=language,
is_question="?" in text or any(q in cleaned.lower() for q in [
"que", "como", "cuando", "donde", "cual", "cuanto", "porque"
]),
requires_action=requires_action,
requires_search=requires_search,
emotional_state=emotional_state,
context_references=self._find_context_references(cleaned, context or []),
closing_score=closing_score,
lead_temperature=lead_temperature,
)
def _calc_closing_score(self, text: str, intent: IntentType,
sentiment: SentimentType, urgency: UrgencyLevel,
context: List[Dict]) -> tuple:
"""
Calcula la probabilidad de cierre (0-1) y la temperatura del lead.
Se basa en señales de compra detectadas en el texto y el contexto.
"""
score = 0.0
text_low = text.lower()
# Señales de intención directa de compra/cita
HOT_SIGNALS = [
"cuándo puedo", "cómo agendo", "quiero ir", "quiero venir",
"voy a ir", "apártame", "sepáralo", "lo quiero", "lo reservo",
"cuándo tienen espacio", "para mañana", "para hoy",
"dónde quedan", "cómo llego", "me dan el precio",
"qué necesito llevar", "se necesita cita", "cuánto demora",
]
WARM_SIGNALS = [
"me interesa", "cuánto vale", "qué precio", "tienen disponible",
"qué incluye", "me puedes contar", "qué diferencia",
"han trabajado con", "tienen experiencia", "cuánto tiempo",
]
COLD_SIGNALS = [
"lo voy a pensar", "después te escribo", "no sé si",
"no tengo plata", "está caro", "en otro lado",
]
hot_count = sum(1 for s in HOT_SIGNALS if s in text_low)
warm_count = sum(1 for s in WARM_SIGNALS if s in text_low)
cold_count = sum(1 for s in COLD_SIGNALS if s in text_low)
score += hot_count * 0.25
score += warm_count * 0.12
score -= cold_count * 0.20
# Ajuste por intención
if intent == IntentType.APPOINTMENT_REQUEST: score += 0.35
elif intent == IntentType.PRICE_INQUIRY: score += 0.15
elif intent == IntentType.SERVICE_INFO: score += 0.10
elif intent == IntentType.COMPLAINT: score -= 0.15
# Ajuste por sentimiento
if sentiment in (SentimentType.POSITIVE, SentimentType.VERY_POSITIVE): score += 0.10
elif sentiment == SentimentType.VERY_NEGATIVE: score -= 0.20
# Ajuste por urgencia
if urgency == UrgencyLevel.CRITICAL: score += 0.20
elif urgency == UrgencyLevel.HIGH: score += 0.10
# Ajuste por contexto — cuántos mensajes lleva (más msgs = más caliente)
msg_count = len(context)
if msg_count >= 4: score += 0.05
if msg_count >= 8: score += 0.10
# Clamp 0-1
score = max(0.0, min(1.0, score))
# Temperatura
if score >= 0.75: temperature = "boiling"
elif score >= 0.50: temperature = "hot"
elif score >= 0.25: temperature = "warm"
else: temperature = "cold"
return score, temperature
def _detect_language(self, text: str) -> str:
"""Detección de idioma usando módulo i18n o heurística."""
if _I18N_BOT:
detected = detect_user_language(text)
if detected in SUPPORTED_LANGUAGES:
return detected
text_low = text.lower()
ES_WORDS = ["que", "por", "para", "con", "una", "del", "los", "las",
"hola", "buenas", "gracias", "claro", "sí", "cómo", "qué"]
EN_WORDS = ["the", "and", "for", "with", "you", "what", "how",
"hello", "thanks", "please", "have", "that", "this"]
PT_WORDS = ["que", "para", "com", "uma", "obrigado", "boa", "sim",
"olá", "você", "como", "fazer"]
FR_WORDS = ["bonjour", "merci", "vous", "pour", "avec", "une", "les",
"je", "que", "comment"]
DE_WORDS = ["hallo", "danke", "für", "mit", "eine", "die",
"ich", "wie", "was", "haben"]
es = sum(1 for w in ES_WORDS if f" {w} " in f" {text_low} ")
en = sum(1 for w in EN_WORDS if f" {w} " in f" {text_low} ")
pt = sum(1 for w in PT_WORDS if f" {w} " in f" {text_low} ")
fr = sum(1 for w in FR_WORDS if f" {w} " in f" {text_low} ")
de = sum(1 for w in DE_WORDS if f" {w} " in f" {text_low} ")
scores = {"es": es, "en": en, "pt": pt, "fr": fr, "de": de}
best = max(scores.items(), key=lambda x: x[1])
if best[1] > 0:
return best[0]
return "es"
def _clean_text(self, text: str) -> str:
"""Limpia el texto para análisis."""
# Remover emojis
emoji_pattern = re.compile(
"["
"\U0001F600-\U0001F64F"
"\U0001F300-\U0001F5FF"
"\U0001F680-\U0001F6FF"
"\U0001F1E0-\U0001F1FF"
"\U00002500-\U00002BEF"
"\U00002702-\U000027B0"
"\U0001F900-\U0001F9FF"
"\U0001FA00-\U0001FAFF"
"]+",
flags=re.UNICODE
)
text = emoji_pattern.sub("", text)
# Normalizar espacios
text = re.sub(r'\s+', ' ', text).strip()
return text
def _detect_intent(self, text: str) -> Tuple[IntentType, float, List[Tuple[IntentType, float]]]:
"""Detecta intención con confianza."""
scores = {}
for intent, patterns in self._compiled_patterns.items():
score = 0
for pattern in patterns:
matches = pattern.findall(text)
score += len(matches) * (1.0 / len(patterns))
scores[intent] = min(score, 1.0)
# Ordenar por score
sorted_intents = sorted(scores.items(), key=lambda x: x[1], reverse=True)
if sorted_intents[0][1] > 0:
primary = sorted_intents[0][0]
confidence = sorted_intents[0][1]
secondary = [(i, s) for i, s in sorted_intents[1:4] if s > 0.2]
else:
# Sin match claro
if "?" in text:
primary = IntentType.GENERAL_QUESTION
else:
primary = IntentType.CHITCHAT
confidence = 0.5
secondary = []
return primary, confidence, secondary
def _detect_sentiment(self, text: str) -> Tuple[SentimentType, float]:
"""Detecta sentimiento."""
text_lower = text.lower()
pos_count = sum(1 for w in self.SENTIMENT_WORDS["positive"] if w in text_lower)
neg_count = sum(1 for w in self.SENTIMENT_WORDS["negative"] if w in text_lower)
# Score de -1 a 1
total = pos_count + neg_count
if total == 0:
return SentimentType.NEUTRAL, 0.0
score = (pos_count - neg_count) / total
if score > 0.5:
return SentimentType.VERY_POSITIVE, score
elif score > 0.1:
return SentimentType.POSITIVE, score
elif score < -0.5:
return SentimentType.VERY_NEGATIVE, score
elif score < -0.1:
return SentimentType.NEGATIVE, score
else:
return SentimentType.NEUTRAL, score
def _detect_urgency(self, text: str) -> UrgencyLevel:
"""Detecta nivel de urgencia."""
text_lower = text.lower()
for level in [UrgencyLevel.CRITICAL, UrgencyLevel.HIGH, UrgencyLevel.MEDIUM]:
if any(w in text_lower for w in self.URGENCY_WORDS.get(level, [])):
return level
return UrgencyLevel.NONE
def _extract_entities(self, text: str) -> Dict[str, Any]:
"""Extrae entidades del texto."""
entities = {}
# Teléfonos
phone_pattern = r'[\+]?[\d\s\-\(\)]{7,15}'
phones = re.findall(phone_pattern, text)
if phones:
entities["phones"] = [p.strip() for p in phones]
# Emails
email_pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
emails = re.findall(email_pattern, text)
if emails:
entities["emails"] = emails
# Fechas (patrones comunes en español)
date_patterns = [
r'\b(\d{1,2})\s*(?:de\s*)?(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)\b',
r'\b(lunes|martes|miercoles|jueves|viernes|sabado|domingo)\b',
r'\b(hoy|mañana|pasado\s*mañana|esta\s*semana|proxima?\s*semana)\b',
r'\b(\d{1,2})[/\-](\d{1,2})(?:[/\-](\d{2,4}))?\b'
]
dates = []
for pattern in date_patterns:
matches = re.findall(pattern, text, re.IGNORECASE)
dates.extend(matches)
if dates:
entities["dates"] = dates
# Horas
time_pattern = r'\b(\d{1,2})(?::(\d{2}))?\s*(am|pm|hrs?|horas?)?\b'
times = re.findall(time_pattern, text, re.IGNORECASE)
if times:
entities["times"] = times
# Nombres propios (mayúsculas después de saludos comunes)
name_pattern = r'(?:soy|me\s*llamo|mi\s*nombre\s*es)\s+([A-ZÁÉÍÓÚÑ][a-záéíóúñ]+(?:\s+[A-ZÁÉÍÓÚÑ][a-záéíóúñ]+)*)'
names = re.findall(name_pattern, text)
if names:
entities["names"] = names
return entities
def _extract_keywords(self, text: str) -> List[str]:
"""Extrae palabras clave."""
# Stopwords en español
stopwords = {
"el", "la", "los", "las", "un", "una", "unos", "unas",
"de", "del", "al", "a", "en", "con", "por", "para",
"que", "como", "cuando", "donde", "cual", "quien",
"este", "esta", "estos", "estas", "ese", "esa",
"mi", "tu", "su", "me", "te", "se", "nos", "les",
"y", "o", "pero", "si", "no", "mas", "muy", "ya",
"es", "son", "era", "fue", "ser", "estar", "hay",
"hola", "buenas", "gracias", "por favor"
}
words = re.findall(r'\b[a-záéíóúüñ]{3,}\b', text.lower())
keywords = [w for w in words if w not in stopwords]
# Frecuencia
freq = {}
for w in keywords:
freq[w] = freq.get(w, 0) + 1
# Top keywords
sorted_kw = sorted(freq.items(), key=lambda x: x[1], reverse=True)
return [kw for kw, _ in sorted_kw[:10]]
def _infer_emotional_state(self, sentiment: SentimentType,
urgency: UrgencyLevel, text: str) -> str:
"""Infiere estado emocional."""
if urgency == UrgencyLevel.CRITICAL:
return "ansioso/urgente"
if sentiment == SentimentType.VERY_NEGATIVE:
return "frustrado/molesto"
elif sentiment == SentimentType.NEGATIVE:
return "insatisfecho"
elif sentiment == SentimentType.VERY_POSITIVE:
return "entusiasta/agradecido"
elif sentiment == SentimentType.POSITIVE:
return "satisfecho"
# Analizar patrones específicos
text_lower = text.lower()
if any(w in text_lower for w in ["nervios", "miedo", "preocupa"]):
return "nervioso/preocupado"
if any(w in text_lower for w in ["duda", "no se", "no estoy segur"]):
return "indeciso"
if any(w in text_lower for w in ["curioso", "interesa", "quiero saber"]):
return "curioso"
return "neutral"
def _find_context_references(self, text: str, context: List[Dict]) -> List[str]:
"""Encuentra referencias al contexto previo."""
references = []
pronouns = ["eso", "esto", "aquello", "lo", "la", "el", "ella", "ellos"]
text_lower = text.lower()
for pronoun in pronouns:
if re.search(rf'\b{pronoun}\b', text_lower):
# Buscar a qué podría referirse en el contexto
for i, msg in enumerate(reversed(context[-5:])):
content = msg.get("content", "").lower()
# Heurística simple: buscar sustantivos en contexto reciente
nouns = re.findall(r'\b[a-z]{4,}\b', content)
if nouns:
references.append(f"posible_ref:{nouns[0]}")
break
return references
# Instancia global
analyzer = MessageAnalyzer()
# ═══════════════════════════════════════════════════════════════════════════════
# MOTOR DE RAZONAMIENTO CHAIN-OF-THOUGHT
# ═══════════════════════════════════════════════════════════════════════════════
class ReasoningEngine:
"""Motor de razonamiento avanzado con Chain-of-Thought."""
REASONING_PROMPT = """Eres un sistema de razonamiento avanzado. Tu tarea es analizar la situación y generar una estrategia de respuesta óptima.
## ANÁLISIS RECIBIDO
Intención detectada: {intent}
Confianza: {confidence}%
Sentimiento: {sentiment}
Urgencia: {urgency}
Estado emocional: {emotional_state}
Entidades extraídas: {entities}
Requiere búsqueda: {requires_search}
## CONTEXTO DE LA CLÍNICA
{clinic_context}
## HISTORIAL RECIENTE
{history}
## MENSAJE ACTUAL
"{message}"
## INSTRUCCIONES
Razona paso a paso:
1. **Comprensión**: Qué está pidiendo realmente el paciente?
2. **Contexto**: Hay información previa relevante?
3. **Recursos necesarios**: Necesito buscar información? Consultar agenda?
4. **Estrategia de respuesta**: Cómo debo estructurar la respuesta?
5. **Tono**: Qué tono es apropiado dado el estado emocional?
6. **Acciones**: Qué acciones concretas debo tomar?
Responde en formato JSON:
```json
{{
"understanding": "...",
"context_relevance": "...",
"resources_needed": ["..."],
"response_strategy": "...",
"tone_recommendation": "...",
"actions": ["..."],
"response_outline": "...",
"confidence": 0.0-1.0
}}
```"""
def __init__(self, llm: LLMEngine):
self.llm = llm
def _extract_json_candidates(self, raw: str) -> List[str]:
text = (raw or "").strip()
if not text:
return []
candidates: List[str] = []
for block in re.findall(r"```(?:json)?\s*(.*?)\s*```", text, re.DOTALL | re.IGNORECASE):
block = (block or "").strip()
if block:
candidates.append(block)
if text.startswith("{") and text.endswith("}"):
candidates.append(text)
start_positions = [idx for idx, ch in enumerate(text) if ch == "{"][:8]
for start in start_positions:
depth = 0
in_string = False
escaped = False
for idx in range(start, len(text)):
ch = text[idx]
if in_string:
if escaped:
escaped = False
elif ch == "\\":
escaped = True
elif ch == '"':
in_string = False
continue
if ch == '"':
in_string = True
continue
if ch == "{":
depth += 1
elif ch == "}":
depth -= 1
if depth == 0:
snippet = text[start : idx + 1].strip()
if snippet:
candidates.append(snippet)
break
deduped: List[str] = []
seen: Set[str] = set()
for candidate in candidates:
normalized = candidate.strip()
if not normalized or normalized in seen:
continue
seen.add(normalized)
deduped.append(normalized)
return deduped
def _parse_reasoning_response(self, raw: str) -> Optional[Dict[str, Any]]:
for candidate in self._extract_json_candidates(raw):
try:
parsed = json.loads(candidate)
except Exception:
continue
if isinstance(parsed, dict):
return parsed
return None
def _extract_labeled_value(self, raw: str, labels: List[str]) -> str:
text = (raw or "").strip()
for label in labels:
match = re.search(
rf"{label}\s*[:\-]\s*(.+?)(?:\n[A-ZÁÉÍÓÚÜÑ][^:\n]{{0,40}}[:\-]|\n\d+\.\s|\Z)",
text,
flags=re.IGNORECASE | re.DOTALL,
)
if match:
value = re.sub(r"\s+", " ", match.group(1)).strip(" \n\t\"'`")
if value:
return value
return ""
def _extract_actions_from_text(self, raw: str, analysis: MessageAnalysis) -> List[str]:
lines = []
for line in (raw or "").splitlines():
cleaned = line.strip().lstrip("-*•0123456789. ").strip()
if len(cleaned) >= 4:
lines.append(cleaned)
if not lines:
if analysis.requires_search:
lines.append("validar información antes de responder")
if analysis.intent.name in {"book_appointment", "ask_schedule"}:
lines.append("guiar hacia disponibilidad o valoración")
deduped: List[str] = []
seen: Set[str] = set()
for line in lines[:6]:
key = _normalize_conv_text(line)
if key and key not in seen:
seen.add(key)
deduped.append(line)
return deduped
def _fallback_reasoning_payload(
self,
raw: str,
message: str,
analysis: MessageAnalysis,
clinic: Dict,
history: List[Dict],
conv_state: Optional["ConversationState"] = None,
) -> Dict[str, Any]:
outline = re.sub(r"\s+", " ", (raw or "").strip())
if len(outline) > 280:
outline = outline[:277].rstrip() + "..."
context_hint = "hay historial útil" if history else "primer contacto"
phase_hint = getattr(conv_state, "phase", "") or ""
pending = getattr(conv_state, "pending_questions", []) or []
last_intent = getattr(getattr(conv_state, "last_intent", None), "name", "") or ""
strategy = "respuesta clara y útil"
if phase_hint == "appointment":
strategy = "cerrar la cita o pedir el dato mínimo faltante"
elif phase_hint == "info_gathering":
strategy = "resolver la duda y pedir solo el dato mínimo faltante"
elif analysis.requires_search:
strategy = "responder con cautela y validar información antes de afirmar algo"
if pending:
strategy += f"; pendiente: {pending[0]}"
return {
"understanding": self._extract_labeled_value(raw, ["understanding", "comprension", "comprensión"]) or message[:180],
"context_relevance": self._extract_labeled_value(raw, ["context_relevance", "contexto", "context"]) or (f"{context_hint}; fase={phase_hint or 'sin fase'}"),
"resources_needed": ["búsqueda"] if analysis.requires_search else [],
"response_strategy": self._extract_labeled_value(raw, ["response_strategy", "estrategia", "strategy"]) or strategy,
"tone_recommendation": self._extract_labeled_value(raw, ["tone_recommendation", "tono", "tone"]) or "profesional y humana",
"actions": self._extract_actions_from_text(raw, analysis) + ([f"respetar continuidad con {last_intent}"] if last_intent else []),
"response_outline": self._extract_labeled_value(raw, ["response_outline", "outline", "respuesta"]) or outline,
"confidence": max(0.35, min(0.95, float(getattr(analysis, "intent_confidence", 0.5) or 0.5))),
"_parse_mode": "text-fallback",
}
def _normalize_reasoning_payload(
self,
parsed: Dict[str, Any],
raw: str,
message: str,
analysis: MessageAnalysis,
clinic: Dict,
history: List[Dict],
conv_state: Optional["ConversationState"] = None,
) -> Dict[str, Any]:
payload = dict(parsed or {})
fallback = self._fallback_reasoning_payload(raw, message, analysis, clinic, history, conv_state=conv_state)
for key, value in fallback.items():
current = payload.get(key)
if current in (None, "", []):
payload[key] = value
actions = payload.get("actions")
if isinstance(actions, str):
payload["actions"] = [actions.strip()] if actions.strip() else []
elif not isinstance(actions, list):
payload["actions"] = fallback.get("actions", [])
resources = payload.get("resources_needed")
if isinstance(resources, str):
payload["resources_needed"] = [resources.strip()] if resources.strip() else []
elif not isinstance(resources, list):
payload["resources_needed"] = fallback.get("resources_needed", [])
try:
payload["confidence"] = max(0.0, min(1.0, float(payload.get("confidence", fallback["confidence"]))))
except Exception:
payload["confidence"] = fallback["confidence"]
return payload
async def reason(self,
message: str,
analysis: MessageAnalysis,
clinic: Dict,
history: List[Dict],
conv_state: ConversationState) -> Dict:
"""Ejecuta razonamiento sobre el mensaje."""
# Preparar contexto de la clínica
clinic_context = self._format_clinic_context(clinic)
# Formatear historial
history_str = self._format_history(history[-10:])
# Construir prompt de razonamiento
prompt = self.REASONING_PROMPT.format(
intent=analysis.intent.name,
confidence=int(analysis.intent_confidence * 100),
sentiment=analysis.sentiment.name,
urgency=analysis.urgency.name,
emotional_state=analysis.emotional_state,
entities=json.dumps(analysis.entities, ensure_ascii=False),
requires_search=analysis.requires_search,
clinic_context=clinic_context,
history=history_str,
message=message
)
messages = [
{
"role": "system",
"content": "Analiza la situación y responde únicamente con JSON válido."
},
{"role": "user", "content": prompt}
]
try:
response, metadata = await self.llm.complete(
messages,
model_tier="reasoning",
temperature=0.3,
max_tokens=800
)
reasoning = self._parse_reasoning_response(response)
if reasoning is None:
reasoning = self._fallback_reasoning_payload(
response,
message,
analysis,
clinic,
history,
conv_state=conv_state,
)
else:
reasoning = self._normalize_reasoning_payload(
reasoning,
response,
message,
analysis,
clinic,
history,
conv_state=conv_state,
)
reasoning["_metadata"] = metadata
return reasoning
except Exception as e:
log.warning(f"Reasoning failed: {e}")
fallback = self._fallback_reasoning_payload(
"",
message,
analysis,
clinic,
history,
conv_state=conv_state,
)
fallback["_parse_mode"] = "exception-fallback"
fallback["_error"] = str(e)
fallback["_error_type"] = type(e).__name__
fallback["_metadata"] = {"provider": "local-fallback", "model": "reasoning-fallback"}
return fallback
def _format_clinic_context(self, clinic: Dict) -> str:
services = clinic.get("services", [])
schedule = clinic.get("schedule", {})
return f"""Nombre: {clinic.get('name', 'Sin nombre')}
Servicios: {', '.join(services) if services else 'No definidos'}
Horario: {json.dumps(schedule, ensure_ascii=False) if schedule else 'No definido'}
Teléfono: {clinic.get('phone', 'No disponible')}
Dirección: {clinic.get('address', 'No disponible')}"""
def _format_history(self, history: List[Dict]) -> str:
if not history:
return "(Primera interacción)"
lines = []
for msg in history:
role = "Paciente" if msg["role"] == "user" else "Conny"
content = msg['content'][:300]
suffix = "..." if len(msg['content']) > 300 else ""
lines.append(f"{role}: {content}{suffix}")
return "\n".join(lines[-6:])
# ═══════════════════════════════════════════════════════════════════════════════
# GENERADOR DE RESPUESTAS
# ═══════════════════════════════════════════════════════════════════════════════
class ResponseGenerator:
"""Generador de respuestas humanizadas."""
def __init__(self, llm: LLMEngine, learning_engine: AdminLearningEngine = None):
self.llm = llm
self.learning = learning_engine
async def generate(self,
message: str,
analysis: MessageAnalysis,
reasoning: Dict,
clinic: Dict,
patient: Dict,
history: List[Dict],
search_context: str = "",
personality: PersonalityProfile = None,
kb_context: str = "",
chat_id: str = "") -> str:
"""Genera respuesta óptima."""
personality = personality or self._get_default_personality(clinic)
effective_history = list(history or [])
compact_summary = ""
pre_prompt_injection = ""
# Inyectar aprendizaje natural
if self.learning:
learning_injection = self.learning.get_prompt_injection()
if learning_injection:
pre_prompt_injection += learning_injection
if Config.CONNY_COMPACT_PROMPT:
effective_history, compact_summary = self._prepare_effective_history(
chat_id=chat_id,
history=effective_history,
)
if chat_id:
pre_prompt_injection += v8_extended_pre_prompt_injection(
chat_id=chat_id,
user_msg=message,
history=effective_history,
clinic=clinic,
)
system_prompt = self._build_compact_system_prompt(
clinic=clinic,
patient=patient,
personality=personality,
search_context=search_context,
reasoning=reasoning,
kb_context=kb_context,
context_summary=compact_summary,
pre_prompt_injection=pre_prompt_injection,
chat_id=chat_id,
history=effective_history,
)
else:
system_prompt = self._build_system_prompt(
clinic, patient, personality, search_context, reasoning, kb_context,
user_msg=message, chat_id=chat_id, history=history
)
messages = [{"role": "system", "content": system_prompt}]
# Agregar historial
for msg in effective_history:
messages.append({
"role": msg["role"],
"content": msg["content"]
})
# Mensaje actual
messages.append({"role": "user", "content": message})
# Determinar modelo según complejidad.
# En primer contacto priorizamos naturalidad y velocidad.
model_tier = "fast"
is_first_turn = not any(msg.get("role") == "assistant" for msg in (history or []))
if analysis.intent in [IntentType.COMPLAINT, IntentType.EMERGENCY]:
model_tier = "reasoning"
elif reasoning.get("confidence", 1) < 0.6 and not is_first_turn:
model_tier = "reasoning"
# Temperatura dinámica: sube progresivamente con la conversación
# Turno 1-2 → 0.45 (predecible, cordial) | 6+ → 0.88 (natural, creativa)
_turns = sum(1 for m in (history or []) if m.get("role") == "user")
if analysis.intent in ("COMPLAINT", "EMERGENCY", "complaint", "emergency"):
_dyn_temp = 0.35 # emergencias: precisión > creatividad
elif _turns <= 2: _dyn_temp = 0.45
elif _turns <= 5: _dyn_temp = 0.65
elif _turns <= 10: _dyn_temp = 0.80
else: _dyn_temp = 0.88
response, metadata = await self.llm.complete(
messages,
model_tier=model_tier,
temperature=_dyn_temp,
max_tokens=600,
use_cache=False, # cada conversación merece respuesta fresca del LLM
)
# Post-procesamiento + reintento si sigue sonando bot o rompe reglas del dueño
response = self._apply_output_pipeline(
response=response,
personality=personality,
chat_id=chat_id,
clinic=clinic,
user_msg=message,
history=history,
)
response = await self._retry_until_human(
messages=messages,
response=response,
model_tier=model_tier,
personality=personality,
chat_id=chat_id,
clinic=clinic,
user_msg=message,
history=history,
)
return response
def _get_default_personality(self, clinic: Dict) -> PersonalityProfile:
"""
Obtiene perfil de personalidad.
Si tiene archetype configurado → usa apply_archetype().
Si tiene config manual → respeta los valores.
Si no tiene nada → amigable por defecto.
"""
persona_config = clinic.get("persona_config", {})
if isinstance(persona_config, str):
try:
persona_config = json.loads(persona_config) if persona_config else {}
except Exception:
persona_config = {}
agent_name = persona_config.get("name", "Conny")
# Si tiene un arquetipo configurado → aplicarlo como base
archetype_id = persona_config.get("archetype", "amigable")
profile = apply_archetype(archetype_id, agent_name)
# Overrides manuales (si el admin ajustó algo por encima del arquetipo)
if "formality_level" in persona_config:
profile.formality_level = float(persona_config["formality_level"])
if "warmth_level" in persona_config:
profile.warmth_level = float(persona_config["warmth_level"])
if "humor_level" in persona_config:
profile.humor_level = float(persona_config["humor_level"])
if "forbidden_words" in persona_config:
profile.forbidden_words = persona_config["forbidden_words"]
if "custom_phrases" in persona_config:
profile.custom_phrases = persona_config["custom_phrases"]
if "tone_instruction" in persona_config:
profile.tone_instruction = persona_config["tone_instruction"]
return profile
def _is_greeting_only(self, user_msg: str) -> bool:
normalized = _normalize_conv_text(user_msg or "")
normalized = re.sub(r"[!¡?¿.,;:]+", "", normalized).strip()
if not normalized:
return False
return normalized in {
"hola",
"hola que tal",
"hola como estas",
"hola que mas",
"hola buenas",
"buenas",
"buenas tardes",
"buenos dias",
"buenas noches",
"como estas",
"como vas",
"todo bien",
"hey",
"holi",
"que mas",
"que tal",
}
def _is_status_opening(self, user_msg: str) -> bool:
normalized = _normalize_conv_text(user_msg or "")
normalized = re.sub(r"[!¡?¿.,;:]+", "", normalized).strip()
if not normalized:
return False
return normalized in {
"hola como estas",
"como estas",
"como vas",
"todo bien",
"hola que tal",
"que tal",
}
def _history_gap_hours(self, history: Optional[List[Dict]]) -> Optional[float]:
if not history:
return None
for item in reversed(history):
raw_ts = str(item.get("ts") or "").strip()
if not raw_ts:
continue
try:
last_dt = datetime.fromisoformat(raw_ts.replace("Z", "+00:00"))
if last_dt.tzinfo is not None:
last_dt = last_dt.astimezone().replace(tzinfo=None)
return max(0.0, (datetime.now() - last_dt).total_seconds() / 3600.0)
except Exception:
continue
return None
def _extract_recent_topic_from_history(self, history: Optional[List[Dict]], clinic: Dict) -> str:
if not history:
return ""
combined = " ".join(
str(item.get("content") or "").strip()
for item in history[-6:]
if str(item.get("content") or "").strip()
)
if not combined:
return ""
return self._extract_message_topic(combined, clinic)
def _looks_like_reentry_turn(self, user_msg: str, history: Optional[List[Dict]]) -> bool:
if not history or not any((msg.get("role") == "assistant") for msg in (history or [])):
return False
if not (self._is_greeting_only(user_msg) or self._is_status_opening(user_msg)):
return False
recent_text = " ||| ".join(
_normalize_conv_text(str(item.get("content") or ""))
for item in (history or [])[-6:]
)
closing_markers = (
"gracias luego te escribo",
"gracias por tu ayuda",
"lo dejamos hasta aqui",
"lo dejamos hasta aquí",
"hasta aqui",
"hasta aquí",
"si luego quiere retomarlo",
"si luego quieres retomarlo",
"seguimos desde ahi",
"seguimos desde ahí",
"cuando quiera volver",
"cuando quieras volver",
)
if any(marker in recent_text for marker in closing_markers):
return True
gap_hours = self._history_gap_hours(history)
return gap_hours is not None and gap_hours >= 24.0
def _build_first_contact_intro(self, clinic: Dict, personality: PersonalityProfile) -> str:
clinic_name = (clinic.get("name") or "").strip()
agent_name = (getattr(personality, "name", "") or "Conny").strip()
if clinic_name:
return f"Hola, soy {agent_name}, la asesora virtual"
return f"Hola, soy {agent_name}, la asesora virtual"
def _build_first_contact_follow_up(self, clinic: Dict) -> str:
sector = _normalize_conv_text(str(clinic.get("sector") or ""))
services = clinic.get("services") if isinstance(clinic.get("services"), list) else []
normalized_services = [_normalize_conv_text(str(service)) for service in services if str(service).strip()]
is_estetica = sector == "estetica" or any(
token in " ".join(normalized_services)
for token in ["botox", "relleno", "laser", "láser", "peeling", "mesoterapia"]
)
if services:
lead_services = ", ".join(str(service).strip() for service in services[:3] if str(service).strip())
if lead_services:
if is_estetica:
return (
f"Te ubico con {lead_services}, valoración y disponibilidad. "
"Si quieres, cuéntame qué te interesa o qué tratamiento estás mirando."
)
return (
f"Te ubico con información, valoración y disponibilidad de servicios como {lead_services}. "
"Cuéntame qué te gustaría revisar."
)
if is_estetica:
return (
"Te ubico con tratamientos, valoración y disponibilidad. "
"Si quieres, cuéntame qué te interesa o qué tratamiento estás mirando."
)
return "Te ubico con información, valoración y disponibilidad. Cuéntame qué te gustaría revisar."
def _is_low_quality_first_turn_bubble(self, text: str) -> bool:
current = (text or "").strip()
if not current:
return True
normalized = _normalize_conv_text(current)
if not normalized:
return True
if looks_fragmented_reply(current):
return True
if len(normalized.split()) <= 2:
return True
if any(
marker in normalized
for marker in (
"asistente virtual",
"recepcionista virtual",
"soy conny",
"te habla conny",
"hoy",
)
):
return True
return normalized in {"hola", "hola hoy", "hoy"}
def _is_identity_probe(self, user_msg: str) -> bool:
normalized = _normalize_conv_text(user_msg or "")
if not normalized:
return False
probes = (
"que eres",
"qué eres",
"eres una ia",
"eres ia",
"eres un bot",
"eres bot",
"como funcionas",
"cómo funcionas",
"quien eres",
"quién eres",
"que haces",
"qué haces",
"quiero probarte",
"me gustaria probarte",
"me gustaría probarte",
"demo",
"mi negocio",
"mi empresa",
)
return any(marker in normalized for marker in probes)
def _build_identity_probe_bubbles(self, clinic: Dict, personality: PersonalityProfile, user_msg: str) -> List[str]:
clinic_name = (clinic.get("name") or "").strip()
agent_name = (getattr(personality, "name", "") or "Conny").strip()
normalized = _normalize_conv_text(user_msg or "")
intro_variants = [
f"Soy {agent_name}{f', la asesora virtual de {clinic_name}' if clinic_name else ', la asesora virtual'}. Soy una IA hecha para orientarte y ayudarte con lo que necesites",
f"Hola, soy {agent_name}{f', la asesora virtual de {clinic_name}' if clinic_name else ', la asesora virtual'}. Soy una IA pensada para llevar este chat con criterio",
f"Soy {agent_name}{f', la asesora virtual de {clinic_name}' if clinic_name else ', la asesora virtual'}. Te acompaño con dudas, servicios y primeros pasos sin sonar rígida",
]
intro = intro_variants[len(normalized) % len(intro_variants)]
services = clinic.get("services") if isinstance(clinic.get("services"), list) else []
lead_services = [str(service).strip() for service in services[:3] if str(service).strip()]
if lead_services:
capabilities = (
"Te puedo ayudar con información, horarios, disponibilidad, valoración y orientación inicial"
f" sobre servicios como {', '.join(lead_services)}"
)
else:
capabilities = (
"Te puedo ayudar con información, horarios, disponibilidad, valoración y orientación inicial"
" para que el primer contacto se sienta claro, útil y bien llevado"
)
cta = "Si quieres, cuéntame qué te gustaría revisar y lo vemos"
if any(token in normalized for token in ("probarte", "demo", "negocio", "empresa", "funcionas", "eres")):
cta = "Si quieres probarme en serio, escríbeme el nombre de tu negocio y te muestro cómo trabajaría contigo"
return [intro, capabilities, cta]
def _extract_message_topic(self, user_msg: str, clinic: Dict) -> str:
normalized = _normalize_conv_text(user_msg or "")
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
service_norm = _normalize_conv_text(service_text)
if service_norm and service_norm in normalized:
return service_text
known_topics = {
"botox": "Botox",
"relleno": "Rellenos",
"rellenos": "Rellenos",
"laser": "Láser",
"làser": "Láser",
"peeling": "Peeling",
"mesoterapia": "Mesoterapia",
"limpieza": "Limpieza",
"blanqueamiento": "Blanqueamiento",
"ortodoncia": "Ortodoncia",
"consulta": "Consulta",
"valoracion": "Valoración",
"valoración": "Valoración",
"agenda": "Cita",
"cita": "Cita",
"citas": "Cita",
}
for keyword, label in known_topics.items():
if keyword in normalized:
return label
return ""
def _build_contextual_first_turn_follow_up(self, clinic: Dict, user_msg: str) -> str:
normalized = _normalize_conv_text(user_msg or "")
sector = _normalize_conv_text(str(clinic.get("sector") or ""))
services = clinic.get("services") if isinstance(clinic.get("services"), list) else []
normalized_services = [_normalize_conv_text(str(service)) for service in services if str(service).strip()]
is_estetica = sector == "estetica" or any(
token in " ".join(normalized_services)
for token in ["botox", "relleno", "laser", "láser", "peeling", "mesoterapia"]
)
if any(marker in normalized for marker in ["soy tu admin", "soy el admin", "soy admin", "no hables asi", "no hables así"]):
return "Entendido. Ajusto el tono contigo. Dime si lo prefieres más directo, más ejecutivo o más corto."
topic = self._extract_message_topic(user_msg, clinic)
if topic:
if any(token in normalized for token in ["precio", "cuanto", "cuánto", "vale", "costo"]):
if is_estetica:
return (
f"{topic} lo manejan acá. Si quieres, te ubico cómo lo trabajan, "
"qué influye en el valor y si te conviene valoración o disponibilidad."
)
return f"{topic} lo manejan acá. Si quieres, te ubico precio, valoración o disponibilidad. Cuéntame qué prefieres revisar primero."
if any(token in normalized for token in ["agenda", "agendar", "cita", "citas", "disponibilidad", "horario"]):
if is_estetica:
return (
f"{topic} lo manejan acá. Si quieres, te ayudo a revisar disponibilidad "
"o a dejar la valoración encaminada para esa zona."
)
return f"{topic} lo manejan acá. Si quieres, te ayudo a revisar disponibilidad o a dejar la valoración encaminada. Cuéntame qué te sirve más."
if is_estetica:
return (
f"{topic} lo manejan acá. Si quieres, te cuento cómo lo trabajan "
"y qué suelen revisar para que se vea natural."
)
return f"{topic} lo manejan acá. Si quieres, te cuento cómo lo trabajan o revisamos valoración y disponibilidad. Cuéntame qué te gustaría revisar primero."
if any(token in normalized for token in ["agenda", "agendar", "cita", "citas", "disponibilidad", "horario"]):
return "Te ayudo a revisar disponibilidad o a dejar la cita encaminada. Cuéntame qué fecha o servicio te interesa."
if is_estetica:
return "Cuéntame qué te gustaría mejorar y te ayudo con eso."
return "Cuéntame qué estás buscando y te ubico rápido."
def _normalize_first_patient_turn(
self,
response: str,
clinic: Dict,
personality: PersonalityProfile,
user_msg: str,
history: List[Dict],
) -> str:
first_turn = not any((m.get("role") == "assistant") for m in (history or []))
if not first_turn:
return response
intro = self._build_first_contact_intro(clinic, personality)
greeting_only = self._is_greeting_only(user_msg)
identity_probe = self._is_identity_probe(user_msg)
parts = [p.strip() for p in (response or "").split("|||") if p.strip()]
def clean_part(part: str) -> str:
part = re.sub(
r"^(hola(?: buenas)?|buenas(?: tardes| noches)?|buenos días|buenos dias|hey|qué más|que más|oye mira|oye|mira|a ver)[,!. ]*",
"",
part.strip(),
flags=re.IGNORECASE,
).strip()
part = re.sub(
r"^(conny\s+por\s+ac[aá]\s*,?\s*del\s+equipo\s+de\s+[^.?!]+[.?!]?\s*)",
"",
part,
flags=re.IGNORECASE,
).strip()
part = re.sub(
r"^(soy\s+conny[^.?!]*[.?!]?\s*)",
"",
part,
flags=re.IGNORECASE,
).strip()
part = re.sub(r"^(te habla\s+conny[^.?!]*[.?!]?\s*)", "", part, flags=re.IGNORECASE).strip()
return part
cleaned = [clean_part(part) for part in parts]
cleaned = [part for part in cleaned if part]
generic_patterns = (
"qué te trae por acá",
"que te trae por aca",
"cuéntame en qué te ayudo",
"cuentame en que te ayudo",
"en qué te ayudo",
"en que te ayudo",
"cómo puedo ayudarte",
"como puedo ayudarte",
"qué necesitas",
"que necesitas",
)
if identity_probe:
return " ||| ".join(self._build_identity_probe_bubbles(clinic, personality, user_msg))
if greeting_only:
usable = [part for part in cleaned if not self._is_low_quality_first_turn_bubble(part)]
if usable:
return " ||| ".join(usable[:2])
follow_up = self._build_first_contact_follow_up(clinic)
return " ||| ".join([intro, follow_up])
if cleaned:
first_content = cleaned[0].lower()
if self._is_low_quality_first_turn_bubble(cleaned[0]) or any(pattern in first_content for pattern in generic_patterns):
cleaned[0] = self._build_contextual_first_turn_follow_up(clinic, user_msg)
else:
cleaned = [self._build_contextual_first_turn_follow_up(clinic, user_msg)]
return " ||| ".join([intro, *cleaned[:2]])
def _prepare_effective_history(self, chat_id: str, history: List[Dict]) -> Tuple[List[Dict], str]:
effective_history = list(history or [])
context_summary = ""
if not effective_history:
return effective_history, context_summary
if smart_context_manager:
try:
effective_history, context_summary = smart_context_manager.prepare_context(
chat_id=chat_id,
history=effective_history,
max_messages=Config.CONNY_CONTEXT_RECENT_MESSAGES,
)
except Exception as exc:
log.debug(f"[compact_prompt] no se pudo preparar contexto: {exc}")
effective_history = effective_history[-Config.CONNY_CONTEXT_RECENT_MESSAGES:]
else:
effective_history = effective_history[-Config.CONNY_CONTEXT_RECENT_MESSAGES:]
if not context_summary and smart_context_manager and chat_id:
context_summary = smart_context_manager.get_cached_summary(chat_id)
return effective_history, context_summary
def _resolve_persona_forbidden_patterns(self, clinic: Dict[str, Any]) -> List[str]:
try:
if getattr(self, "_conversation_registry", None):
persona_profile = self._conversation_registry.resolve_for_clinic(clinic or {})
return list(getattr(persona_profile, "forbidden_patterns", []) or [])
except Exception:
pass
return []
def _build_short_memory_block(self, history: List[Dict[str, Any]]) -> str:
if not history:
return ""
try:
from conny_brain_v10 import extract_short_memory, format_memory_block
return format_memory_block(extract_short_memory(history))
except Exception:
return ""
def _prompt_builder_deps(self) -> PromptBuilderDeps:
return PromptBuilderDeps(
build_fewshot_examples=self._build_fewshot_examples,
get_sector_info=get_sector_info,
now_provider=now_col,
sector_default=Config.SECTOR,
db=db,
owner_style_controller=owner_style_controller,
kb_available=_KB_AVAILABLE,
format_kb_context=format_kb_context if _KB_AVAILABLE else None,
resolve_persona_forbidden=self._resolve_persona_forbidden_patterns,
v8_addon_builder=v8_build_quality_system_prompt_addon,
trainer_addon_builder=trainer_get_system_prompt_addon,
short_memory_builder=self._build_short_memory_block,
apply_archetype=apply_archetype,
)
def _truncate_block(self, text: str, max_chars: int) -> str:
return _truncate_block_core(text, max_chars)
def _build_compact_examples(self, sector_id: str, clinic_name: str, agent_name: str) -> str:
return _build_compact_examples_core(
self._build_fewshot_examples(sector_id, clinic_name, agent_name)
)
def _build_compact_system_prompt(
self,
clinic: Dict,
patient: Dict,
personality: PersonalityProfile,
search_context: str,
reasoning: Dict,
kb_context: str = "",
context_summary: str = "",
pre_prompt_injection: str = "",
chat_id: str = "",
history: List[Dict] = None,
) -> str:
return _build_compact_system_prompt_core(
clinic=clinic,
patient=patient,
personality=personality,
search_context=search_context,
reasoning=reasoning,
kb_context=kb_context,
context_summary=context_summary,
pre_prompt_injection=pre_prompt_injection,
chat_id=chat_id,
history=history or [],
deps=self._prompt_builder_deps(),
)
def _build_system_prompt(self, clinic: Dict, patient: Dict,
personality: PersonalityProfile,
search_context: str,
reasoning: Dict,
kb_context: str = "",
user_msg: str = "",
chat_id: str = "",
history: List[Dict] = None) -> str:
return _build_system_prompt_core(
clinic=clinic,
patient=patient,
personality=personality,
search_context=search_context,
reasoning=reasoning,
kb_context=kb_context,
user_msg=user_msg,
chat_id=chat_id,
history=history or [],
deps=self._prompt_builder_deps(),
)
def _build_fewshot_examples(self, sector_id: str, clinic_name: str, agent_name: str) -> str:
"""
Devuelve 3-4 conversaciones cortas calibradas por sector.
Escritas en voz de Conny — el modelo aprende el patrón, no obedece reglas.
Principio: show don't tell. Los ejemplos enseñan el tono que las instrucciones no capturan.
"""
# Mapa sector → conversaciones con FRICCIÓN REAL (v10)
# Incluye objeciones de precio, indecisión, miedos, silencio.
# El LLM aprende del patrón — no de las reglas.
_examples: Dict[str, str] = {
"estetica": f"""cliente: hola cuánto vale el botox
{agent_name}: depende de las zonas, el número exacto te lo da la dra en la valoración ||| qué zona te está molestando más
cliente: la frente, ya se marcan mucho
{agent_name}: eso es exactamente lo que trata el botox en frente — relaja el músculo y en una semana no se notan ||| la valoración es gratis, esta semana el jueves hay espacio, te queda
cliente: me da miedo quedar tiesa o exagerada
{agent_name}: ese miedo lo tiene la mayoría antes de venir ||| la dra trabaja muy conservador, el objetivo es que te veas descansada, no diferente. en la valoración te muestra casos reales y tú decides si sigues
cliente: lo voy a pensar
{agent_name}: claro, sin prisa ||| si en algún momento quieres agendar la valoración que es sin compromiso, aquí estoy
cliente: es que está caro
{agent_name}: entiendo ||| si quieres te cuento qué incluye y por qué vale lo que vale. qué zona te interesa exactamente""",
"dental": f"""cliente: hola necesito una limpieza
{agent_name}: cuándo fue la última vez que fuiste al odontólogo
cliente: hace como 2 años
{agent_name}: tranquila, eso es más común de lo que crees ||| esta semana el jueves hay espacio, te queda
cliente: me da pereza, siempre me regañan
{agent_name}: acá no regañamos, en serio ||| lo que sí hacemos es dejar todo limpio y decirte qué hay que revisar. qué te parece si agendamos
cliente: cuánto vale
{agent_name}: la profilaxis está en 80, incluye el examen general ||| si encuentran algo te dicen ese día
cliente: tengo mucho miedo, soy muy nervioso con el odontólogo
{agent_name}: cuéntame qué fue lo que pasó antes para que te quedara ese miedo ||| acá trabajan con anestesia tópica primero y van despacio""",
"gimnasio": f"""cliente: quiero inscribirme cuánto vale
{agent_name}: qué quieres trabajar primero, es más cardio, pesas, o los dos
cliente: bajar de peso principalmente, tengo como 12 kilos de más
{agent_name}: hace cuánto no entrenas
cliente: como un año y medio
{agent_name}: arrancamos con la evaluación física, es gratis y en 30 minutos el entrenador te dice de dónde partir ||| esta semana el miércoles en la tarde hay espacio
cliente: es que no tengo mucho tiempo
{agent_name}: cuántas veces a la semana podrías venir, aunque sea
cliente: tal vez 3
{agent_name}: con 3 veces bien trabajadas ya se ve resultado ||| mañana o tarde te queda mejor""",
"veterinaria": f"""cliente: hola mi perrito no ha querido comer desde ayer
{agent_name}: cómo se llama y qué más síntomas tiene, está quieto o vomitó algo
cliente: teo, está quieto y no se levanta
{agent_name}: eso hay que verlo hoy, no esperar ||| puedes traer a teo ahora, dime cuándo sales
cliente: es que queda lejos, como 40 minutos
{agent_name}: cuando hay decaimiento y sin apetito más de 24 horas es mejor no esperar ||| llama al llegar para que lo reciban directo
cliente: cuánto vale la consulta
{agent_name}: la consulta está en 60, incluye examen completo ||| si necesita algo adicional te dicen ese día con el precio antes de proceder""",
"restaurante": f"""cliente: hola quiero reservar para este sábado
{agent_name}: para cuántas personas y a qué hora
cliente: somos 8 como a las 7
{agent_name}: verifico disponibilidad ||| es para alguna ocasión especial
cliente: cumpleaños de mi mamá
{agent_name}: lindo ||| tenemos decoración sin costo, torta y canción tienen costo extra. quieren incluir algo
cliente: cuánto vale la torta
{agent_name}: la torta para 8 está en 45 ||| la dejamos incluida o prefieren traer la de ustedes
cliente: la traemos nosotros
{agent_name}: perfecto ||| a nombre de quién hago la reserva y un número de contacto""",
"belleza": f"""cliente: quiero teñirme de rubio
{agent_name}: qué color tienes ahora
cliente: castaño oscuro casi negro
{agent_name}: ese proceso toma varias sesiones para no quemar el cabello ||| cuándo puedes venir para que la estilista evalúe el estado
cliente: cuánto me va a costar todo
{agent_name}: puede ir desde 200 hasta 450 en total dependiendo del estado ||| la evaluación es gratis y te dan el presupuesto exacto. cuándo puedes
cliente: es mucha plata
{agent_name}: sí, los procesos de aclarado son los más costosos porque hay que hacerlo bien ||| hay opción de hacerlo por etapas para distribuirlo""",
"spa": f"""cliente: quiero un masaje cuánto vale
{agent_name}: tienes algo específico, es relajante o tienes algún dolor
cliente: muy estresada, necesito desconectarme
{agent_name}: el sueco de 60 minutos es justo para eso ||| esta semana el jueves en la tarde hay espacio
cliente: somos dos podemos ir juntas
{agent_name}: verifico que haya dos cabinas disponibles ||| para qué día lo tienen pensado
cliente: el sábado
{agent_name}: sábado hay espacio a las 11 o a las 3 ||| cuál les queda mejor""",
"medico": f"""cliente: necesito cita con el médico
{agent_name}: es urgente o es consulta de control
cliente: llevo una semana con dolor de cabeza fuerte, no se me quita
{agent_name}: eso hay que verlo esta semana ||| el jueves en la mañana hay espacio, te queda
cliente: no sé si es tan grave para ir
{agent_name}: una semana de dolor que no cede sí merece revisión ||| te agendo el jueves y si antes empeora me avisas
cliente: cuánto vale
{agent_name}: la consulta está en 80 ||| la tiene por seguro o paga particular""",
"psicologo": f"""cliente: hola quisiera hablar con alguien
{agent_name}: qué te animó a escribir hoy
cliente: llevo meses muy ansioso, ya no estoy durmiendo bien
{agent_name}: bien que lo decidiste ||| prefieren sesión presencial o virtual
cliente: virtual, da un poco de pena ir en persona
{agent_name}: no te preocupes, muchos arrancan así ||| esta semana el miércoles a las 6pm hay espacio con la psicóloga
cliente: cuánto vale
{agent_name}: la sesión inicial es de 120 ||| si decides continuar hay paquetes de 4 con descuento
cliente: no sé si puedo sostener ese costo
{agent_name}: cuéntame un poco tu situación y vemos qué opción se acomoda ||| lo importante es arrancar""",
"abogado": f"""cliente: necesito asesoría legal
{agent_name}: qué tipo de situación le trajo
cliente: me despidieron sin justa causa hace 10 días
{agent_name}: eso tiene proceso ||| le dieron algo por escrito o fue verbal
cliente: una carta y me pidieron que firmara
{agent_name}: no firme nada todavía, esa firma puede afectar lo que puede reclamar ||| le agendo consulta esta semana, lleve la carta y el contrato
cliente: cuánto cuesta
{agent_name}: la consulta inicial está en 150, dura una hora ||| cuándo tiene disponibilidad""",
"inmobiliaria": f"""cliente: busco apartamento en arriendo
{agent_name}: en qué zona y cuánto presupuesto manejas
cliente: laureles, hasta dos millones
{agent_name}: cuántas habitaciones y para cuántas personas
cliente: dos habitaciones, somos 3
{agent_name}: tengo dos opciones en ese rango en laureles ||| cuándo podrías visitar
cliente: son muchos requisitos eso me estresa
{agent_name}: cuéntame qué te ha pasado antes ||| acá te decimos desde el principio qué piden y si aplicas, sin hacerte perder tiempo""",
"taller": f"""cliente: mi carro está haciendo un ruido raro
{agent_name}: qué tipo de ruido y cuándo lo hace, al arrancar o en movimiento
cliente: al arrancar como un golpe seco
{agent_name}: puede ser el arranque o la batería ||| puedes traerlo hoy, el diagnóstico es gratis y en 2 horas te decimos qué tiene
cliente: cuánto cuesta la reparación
{agent_name}: eso depende de lo que encuentren ||| el presupuesto te lo dan antes de tocar nada. qué marca y modelo tiene""",
"nutricion": f"""cliente: quiero bajar de peso
{agent_name}: cuántas veces lo has intentado y qué te ha pasado
cliente: varias, siempre empiezo bien y lo dejo
{agent_name}: qué crees que pasa para que siempre se rompa
cliente: me estreso y empiezo a comer mal
{agent_name}: eso es exactamente lo que trabajamos acá, no solo la dieta sino el patrón detrás ||| esta semana el jueves hay consulta
cliente: ya gasté mucha plata en dietas que no funcionan
{agent_name}: tiene sentido que lo dudes ||| en la primera consulta te cuento el enfoque y decides si tiene sentido para ti. es sin compromiso""",
"academia": f"""cliente: quiero aprender inglés por dónde empiezo
{agent_name}: qué nivel tienes ahora, entiendes algo o es desde cero
cliente: sé algo pero nunca lo estudié formalmente
{agent_name}: haría falta un diagnóstico para saber en qué nivel entras ||| es para algo específico
cliente: trabajo, me están pidiendo inglés para ascender
{agent_name}: con esa motivación específica es más fácil estructurar el avance ||| el diagnóstico es gratis y dura 20 minutos. cuándo puedes
cliente: cuánto cuestan las clases
{agent_name}: las grupales están en 280 al mes, las individuales en 180 por sesión ||| con la prioridad que tienes, las individuales avanzan más rápido""",
"fisioterapia": f"""cliente: tengo dolor de espalda baja desde hace semanas
{agent_name}: fue de golpe o fue acumulando
cliente: creo que fue por levantarme mal
{agent_name}: tienes diagnóstico médico o es lo que estás sintiendo
cliente: lo que siento, no he ido al médico
{agent_name}: en la evaluación el fisio te dice qué tiene y cuántas sesiones necesitas ||| esta semana el martes hay espacio
cliente: no sé si realmente necesito fisio o con reposo se pasa
{agent_name}: semanas con el mismo dolor ya indican que el reposo solo no alcanza ||| la evaluación es sin compromiso, y es la que te dice exactamente qué necesitas""",
"fotografia": f"""cliente: quiero cotizar fotos para una boda
{agent_name}: para qué fecha y cuántas horas necesitan
cliente: 15 de marzo unas 8 horas
{agent_name}: verifico disponibilidad ||| incluye solo fotos o también video
cliente: solo fotos
{agent_name}: para 8 horas el paquete está en 2.800, incluye 300 fotos editadas ||| es para bloquear ya o todavía están evaluando
cliente: está un poco caro para nosotros
{agent_name}: cuánto presupuesto manejan ||| hay paquetes de 5 o 6 horas que se acomodan mejor""",
"tattoo": f"""cliente: quiero hacerme un tatuaje
{agent_name}: ya tienes el diseño claro o todavía estás explorando
cliente: tengo una idea pero no sé exactamente cómo
{agent_name}: en qué zona y qué tamaño aproximado
cliente: antebrazo, como la palma de la mano
{agent_name}: me mandas referencias y el artista te hace el diseño y el presupuesto
cliente: me da miedo arrepentirme
{agent_name}: cuéntame la idea que tienes, qué significa para ti ||| eso ayuda al artista a hacer algo que te represente de verdad y no algo que después incomoda""",
"hotel": f"""cliente: quiero reservar para este fin de semana
{agent_name}: para cuántas personas y cuántas noches
cliente: dos personas viernes a domingo
{agent_name}: incluye desayuno o sin
cliente: con desayuno
{agent_name}: habitación doble con desayuno viernes-domingo está en 760 en total ||| a nombre de quién la hago
cliente: tienen estacionamiento
{agent_name}: sí, incluido para huéspedes ||| alguna solicitud especial para la habitación""",
"coworking": f"""cliente: hola info sobre los espacios
{agent_name}: buscas escritorio compartido, privado, o sala de reuniones
cliente: escritorio por ahora, estoy trabajando solo
{agent_name}: cuántos días a la semana necesitas
cliente: tal vez 3 o 4, no sé por cuánto tiempo
{agent_name}: tenemos plan flexible sin contrato mínimo ||| cuándo quieres venir a conocer el espacio
cliente: cuánto vale mensual
{agent_name}: el de 3 días por semana está en 280, el de 5 días en 380 ||| sin contrato, pagas mes a mes""",
"otro": f"""cliente: hola buenas
{agent_name}: hola ||| cuéntame qué te gustaría revisar
cliente: quería información sobre sus servicios
{agent_name}: claro, qué fue lo que te hizo buscarnos hoy
cliente: lo vi en redes y me llamó la atención
{agent_name}: qué fue lo que viste ||| así te cuento exactamente qué tenemos para eso""",
}
return _examples.get(sector_id, _examples["otro"])
def _postprocess(self, response: str, personality: PersonalityProfile) -> str:
"""Post-procesa la respuesta."""
# Eliminar emojis
emoji_pattern = re.compile(
"["
"\U0001F600-\U0001F64F"
"\U0001F300-\U0001F5FF"
"\U0001F680-\U0001F6FF"
"\U0001F1E0-\U0001F1FF"
"\U00002500-\U00002BEF"
"\U00002702-\U000027B0"
"\U0001F900-\U0001F9FF"
"\U0001FA00-\U0001FAFF"
"\u2600-\u26FF"
"\u2700-\u27BF"
"]+",
flags=re.UNICODE
)
response = emoji_pattern.sub("", response)
response = response.replace('¿', '').replace('¡', '')
for word in personality.forbidden_words:
response = re.sub(rf'\b{word}\b', '', response, flags=re.IGNORECASE)
response = re.sub(r'\s*—\s*', ' ', response) # em dash → espacio siempre
response = re.sub(r'\s+', ' ', response).strip()
response = re.sub(r'\s*\|\|\|\s*', ' ||| ', response)
def _humanize(s):
"""Por burbuja: quita punto final, guiones narrativos, mayúscula forzada y trunca si es muy larga."""
s = s.strip()
# 1. Quitar punto final (excepto "...")
if s.endswith('.') and not s.endswith('...'):
s = s[:-1].strip()
# 2. Quitar guión largo narrativo — (em dash como separador de ideas)
import re as _re
s = _re.sub(r'\s+—\s*$', '', s) # guión al final
s = _re.sub(r'^\s*—\s+', '', s) # guión al inicio
s = _re.sub(r'\s+—\s+', ' ', s) # guión en medio → espacio
s = _re.sub(r'\s+', ' ', s).strip()
# 3. Truncar burbuja si supera 180 chars — cortar en el último separador natural
if len(s) > 180:
# Buscar último punto, coma o " y " antes del char 180
cut = max(
s.rfind('. ', 0, 180),
s.rfind(', ', 0, 180),
s.rfind(' y ', 0, 180),
)
if cut > 60:
s = s[:cut].strip().rstrip(',').rstrip('.')
# 4. Quitar puntuación rara al inicio
import re as _re3
s = _re3.sub(r'^[:\-\.!,;]+\s*', '', s).strip()
# 5. Bajar mayúscula inicial si no es sigla ni nombre propio obvio
# 5. Quitar pregunta repetida al final ("...? ..." donde hay dos signos)
s = _re3.sub(r'\?\s*\?', '?', s)
return s
if '|||' in response:
response = ' ||| '.join(_humanize(p) for p in response.split('|||'))
else:
response = _humanize(response)
# PATCH: filtro de frases eliminado.
# El system prompt (V11 PROMPT-FIRST) le indica al LLM qué NO decir
# ANTES de generarlo. El reemplazo postproceso causaba cortes de respuesta
# porque borraba invitaciones de cierre dejando burbujas incompletas.
# Solo se conservan las 3 señales que delatan explícitamente "soy una IA":
_robot_phrases_minimal = [
"como modelo de lenguaje",
"como inteligencia artificial",
"mis capacidades incluyen",
]
for phrase in _robot_phrases_minimal:
if phrase in response.lower():
idx = response.lower().find(phrase)
# Solo borrar si está al inicio o al final de una burbuja
in_start = idx < 30
in_end = idx > len(response) - len(phrase) - 20
if in_start or in_end:
response = response[:idx] + response[idx + len(phrase):]
response = re.sub(r'\s+', ' ', response).strip()
response = re.sub(r'^\s*,\s*', '', response)
return response
def _apply_output_pipeline(self, response: str, personality: PersonalityProfile,
chat_id: str, clinic: Dict, user_msg: str,
history: List[Dict], is_admin: bool = False) -> str:
"""Aplica todos los filtros que deben tocar la salida final."""
response = self._postprocess(response, personality)
first_turn = not any((m.get("role") == "assistant") for m in (history or []))
response = trainer_post_process_response(response, chat_id=chat_id)
response = v8_extended_postprocess(
response=response,
chat_id=chat_id,
clinic=clinic,
user_msg=user_msg,
history=history,
archetype=getattr(personality, "archetype", "amigable"),
)
response = self._normalize_first_patient_turn(
response=response,
clinic=clinic,
personality=personality,
user_msg=user_msg,
history=history,
)
response = self._repair_fragmented_response(
response,
clinic,
user_msg,
personality=personality,
history=history,
)
if owner_style_controller:
response = owner_style_controller.enforce_output(
response,
is_admin=is_admin,
first_turn=first_turn,
chat_id=chat_id,
clinic=clinic,
user_msg=user_msg,
)
return response
def _repair_fragmented_response(
self,
response: str,
clinic: Dict,
user_msg: str,
personality: Optional[PersonalityProfile] = None,
history: Optional[List[Dict]] = None,
) -> str:
"""Solo repara respuestas genuinamente rotas (truncadas, cortadas).
No reemplaza respuestas válidas del LLM con strings hardcodeados."""
current = (response or "").strip()
if not current:
return current
# Solo reparar si hay señales claras de respuesta truncada o cortada
cut_markers = [
"se me corto el mensaje",
"se me cortó el mensaje",
"te decia",
"te decía",
]
current_low = _normalize_conv_text(current)
if any(marker in current_low for marker in cut_markers):
return self._build_first_contact_intro(clinic, personality) if personality else current
if looks_fragmented_reply(current):
return self._build_first_contact_intro(clinic, personality) if personality else current
# Respuesta del LLM válida — no tocar
return current
if any(token in user_low for token in ["cómo trabajas aquí", "como trabajas aqui", "cómo trabajas por aquí", "como trabajas por aqui"]):
return _with_intro(
"Trabajo guiando la conversación, entendiendo qué necesitas y llevándote a lo útil. "
"Y si algo toca confirmarlo con el negocio, te lo digo claro en vez de inventártelo."
)
if any(token in user_low for token in ["lo llevas tú sola", "lo llevas tu sola", "tu sola", "tú sola"]):
return _with_intro(
"Yo sostengo este canal y la conversación, pero no me pongo a improvisar donde toca confirmación real. "
"Si algo depende del equipo o de una valoración, te lo digo así."
)
if any(token in user_low for token in ["atiendes como secretaria", "atiendes como asesora", "secretaria o como asesora", "secretaria o asesora"]):
return _with_intro(
"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, sin sonar a libreto."
)
if any(token in user_low for token in ["si te pregunto por un procedimiento", "si te pregunto por precio", "si te pregunto algo del tratamiento", "si te pregunto algo del procedimiento"]):
return _with_intro(
"Te respondo lo que sí pueda orientarte con claridad y te ubico el siguiente paso útil. "
"Si algo depende de valoración o de confirmar con el negocio, te lo digo así, sin humo."
)
if any(token in user_low for token in ["quiero entender si recuerdas", "recuerdas lo que te digo", "cómo recuerdas", "como recuerdas"]):
return _with_intro(
"Sí, la idea es ir guardando lo importante para no hacerte repetir todo. "
"Y si algo no me queda claro, prefiero confirmártelo a fingir que lo recuerdo."
)
if any(token in user_low for token in ["no quiero hablar con un bot", "bot raro", "no suenes a bot", "no sonar robot", "no sonar como bot"]):
return _with_intro(
"Tranquila. La idea es hablarle claro, normal y sin libreto raro. "
"Si algo no lo sé con certeza, se lo digo así y le ayudo con lo que sí le pueda orientar."
)
if any(token in user_low for token in ["no quiero que me vendan de más", "no quiero que me vendan de mas", "no me vendan de más", "no me vendan de mas", "sin venderme", "sin presionarme", "sin presión", "sin presion", "no presión", "no presion", "yo solo queria informacion", "yo solo quería información"]):
return _with_intro(
"Totalmente válido. La idea no es empujarle nada, sino ubicar si de verdad le conviene y cómo se vería natural."
)
if any(token in user_low for token in ["si no tienes el dato exacto", "si no tiene el dato exacto", "si no sabes el dato exacto", "qué haces si no sabes", "que haces si no sabes", "si no tienes dato", "si no tiene dato", "si no tienes el dato", "si no tiene el dato"]):
return _with_intro(
"Si no tengo el dato exacto, no se lo invento. "
"Le digo claro qué sí puedo orientarle y qué toca confirmar con el equipo."
)
if any(token in user_low for token in ["dame un precio general", "dame un precio aproximado", "precio general primero", "precio aproximado primero"]):
return _with_intro(
"Puedo darte una referencia general, pero el valor final sí cambia según la zona, la cantidad y lo que vean en valoración. "
"Si quieres, te ubico primero cómo lo suelen manejar y luego vemos si te sirve que te dejen eso ya más aterrizado."
)
if any(token in user_low for token in ["dame un rango", "aunque sea un rango", "aunque sea aproximado", "rango general primero", "rango aproximado", "un rango de precio"]):
return _with_intro(
"Lo que puedo decirte es que hay un rango, pero varía según la zona, la cantidad y el caso específico. "
"Si quieres, te explico cómo lo manejan en la clínica y qué factores lo hacen cambiar."
)
if "botox" not in user_low and any(token in user_low for token in ["recuerdas que te dije", "recuerda que te dije", "quiero verme natural", "verme natural"]):
return _with_intro(
"Sí. Ya me quedó que usted quiere verse natural, no exagerada. "
"Con eso en mente, la orientación siempre va por algo sutil y bien medido."
)
if any(token in user_low for token in ["no me hagas tantas preguntas", "ve al punto", "menos preguntas", "más directo", "mas directo"]):
return _with_intro(
"Listo. Voy al punto. "
"Si lo suyo es Botox con resultado natural, el siguiente paso útil es valoración para definir zona y cantidad sin exagerar."
)
if any(token in user_low for token in ["consulta real", "sigamos con algo real", "quiero seguir con una consulta real", "quiero algo real"]):
return _with_intro(
"Perfecto, vamos a lo real entonces. "
"Dime qué tratamiento o inquietud quieres revisar y te respondo como si ya estuviéramos en la conversación útil, no en la presentación."
)
if any(token in user_low for token in ["gracias", "gracias por tu ayuda", "gracias por la ayuda", "te agradezco", "muchas gracias"]):
return _with_intro(
"A ti. Cuando quieras volver a hablar de esto, aquí sigo."
)
if any(token in user_low for token in ["por ahora lo dejamos", "lo dejamos así", "lo dejamos asi", "hasta aquí", "hasta aqui", "dejamos esto hasta aquí"]):
return _with_intro(
"Perfecto. Lo dejamos hasta aquí por ahora. "
"Si luego quiere retomarlo, me escribe y seguimos desde ahí."
)
if any(token in user_low for token in ["si luego decido avanzar", "si luego avanzo", "si te escribo después", "si te contacto después", "luego te aviso"]):
return _with_intro(
"Dale, ahí quedo. Cuando quieras avanzar, me escribes y retomamos desde donde lo dejamos."
)
if any(token in user_low for token in ["bitcoin", "crypto", "cripto", "trading"]) and any(
token in user_low for token in ["botox", "relleno", "rellenos", "laser", "láser", "peeling", "mesoterapia"]
):
return _with_intro(
"Si lo suyo es Botox o ese tratamiento, me enfoco en esa parte y le oriento bien. "
"Lo demás no se lo manejo desde acá. Si quiere, le explico cómo lo trabajan y qué seguiría."
)
if "botox" in user_low and any(token in user_low for token in ["natural", "verme natural", "que no se note", "que se vea natural"]):
return _with_intro(
"Sí, y justo la idea con Botox bien llevado es que se vea natural, no tieso. "
"Por eso revisan la zona, la expresión y la cantidad que realmente le conviene."
)
if any(token in user_low for token in ["me da miedo", "me preocupa", "que se note", "quede artificial", "muy artificial", "se vea exagerado"]):
return _with_intro(
"Eso es una duda muy normal. La idea es que se vea natural, no exagerado. "
"Por eso primero revisan la zona y la cantidad que realmente le conviene. "
"Si quiere, le explico cómo suelen manejarlo para que el resultado se vea armónico."
)
if any(token in user_low for token in ["botox", "relleno", "rellenos", "laser", "láser", "peeling", "mesoterapia"]) and not any(
token in user_low for token in ["precio", "cuanto", "cuánto", "vale", "valor", "costo", "cita", "agenda", "agendar", "horario"]
):
return _with_intro(
"Claro. Eso sí lo manejan en la clínica y suele trabajarse bastante en esas zonas. "
"Lo importante es revisar cuántas unidades le convienen para que se vea natural. "
"¿Lo que más le preocupa es que se note demasiado o cuánto puede durar?"
)
if duration_intent:
if any(token in current_low for token in ["mes", "meses", "semana", "semanas", "duracion", "duración"]):
return _with_intro(current)
return _with_intro(
"En ese tratamiento la duración puede variar según la zona y cómo responda su cuerpo. "
"Si quiere, le explico cómo lo manejan en la clínica y qué suelen revisar en la valoración."
)
if any(token in user_low for token in ["precio", "cuanto", "cuánto", "vale", "valor", "costo"]):
return _with_intro(
"El valor depende de la valoración y de las zonas a trabajar. "
"Si quiere, le explico cómo lo manejan en la clínica y le dejo la valoración encaminada."
)
if any(token in user_low for token in ["sin sonar técnico", "sin sonar tecnico", "sin sonar tan técnico", "sin sonar tan tecnico"]):
return _with_intro(
"Sí. En simple: primero entiendo qué te interesa, luego te explico lo importante sin palabras raras y, si hace falta, te ayudo a pasar a valoración o disponibilidad."
)
if any(token in user_low for token in ["qué datos necesitas", "que datos necesitas", "qué necesitas para decirme mejor", "que necesitas para decirme mejor"]):
return _with_intro(
"Con tres cosas ya se aterriza mucho mejor: qué zona te interesa, qué resultado buscas y si ya te has hecho algo antes. "
"Con eso te puedo orientar bastante mejor sin hacerte perder tiempo."
)
if any(token in user_low for token in [
"si sigo interesada",
"si sigo interesado",
"por donde empezamos",
"por dónde empezamos",
"como seguimos",
"cómo seguimos",
"quiero seguir",
"quiero retomar",
"retomemos",
]):
return _with_intro(
"Si sigues interesada, empezamos por ubicar qué zona o tratamiento te importa de verdad y qué resultado quieres lograr. "
"Con eso te digo el siguiente paso útil sin hacerte dar vueltas. ||| "
"Si quieres, lo dejamos desde ya encaminado por valoración o por disponibilidad."
)
if any(token in user_low for token in ["convénceme sin empujarme", "convenceme sin empujarme", "convénceme", "convenceme"]) and any(
token in user_low for token in ["sin empujar", "sin empujarme", "sin presion", "sin presión"]
):
return _with_intro(
"No se trata de empujarte, sino de dejarte claro si te conviene o no. "
"Si quieres, te explico qué gana la gente cuando ese tratamiento sí encaja y qué señales harían que no valga la pena irte por ahí."
)
if any(token in user_low for token in ["foto", "fotos", "imagen", "selfie"]):
return _with_intro(
"Sí, puede enviarla y le doy una orientación inicial de lo que se podría revisar. "
"La confirmación final sí se hace en valoración para no prometerle algo a ciegas."
)
if any(token in user_low for token in ["cita", "agenda", "agendar", "horario", "disponibilidad", "esta semana", "mañana", "manana", "hoy"]):
return _with_intro(
"Esta semana le puedo dejar la valoración encaminada. "
"Si quiere, le confirmo un horario puntual y se lo separo."
)
if services:
lead = ", ".join(str(service).strip() for service in services[:2] if str(service).strip())
if lead:
return _with_intro(
f"Sí. "
f"Si quiere, lo aterrizamos por el lado que más le sirva: información, precio o disponibilidad sobre {lead}."
)
return _with_intro("Claro. Le respondo eso completo y sin rodeos.")
def _build_owner_rule_retry_injection(self, response: str) -> Tuple[List[str], str]:
"""
Reúne las reglas del dueño y marca conflictos evidentes contra la respuesta actual.
Esto refuerza que el feedback no solo se guarde, sino que se cumpla.
"""
if not db:
return [], ""
try:
rules = db.get_trust_rules(limit=8)
except Exception:
rules = []
response_lower = (response or "").lower()
conflicts: List[str] = []
reminders: List[str] = []
for rule in rules[:8]:
rule_text = (rule.get("rule") or "").strip()
example_bad = (rule.get("example_bad") or "").strip()
example_good = (rule.get("example_good") or "").strip()
if rule_text:
line = f"→ {rule_text}"
if example_good:
line += f' Ejemplo bueno: "{example_good}"'
reminders.append(line)
if example_bad and example_bad.lower() in response_lower:
conflict = f'No uses "{example_bad}"'
if example_good:
conflict += f'; mejor: "{example_good}"'
conflicts.append(conflict)
if rule_text:
patterns = [
r'(?:no digas|nunca digas|evita decir|no menciones|evita mencionar)\s+[\"“]?([^\"”.;\n]+)',
r'(?:quita|prohibido)\s+[\"“]?([^\"”.;\n]+)',
]
for pattern in patterns:
m = re.search(pattern, rule_text, flags=re.IGNORECASE)
if not m:
continue
forbidden = m.group(1).strip(" \"'“”.,:;")
if len(forbidden) >= 3 and forbidden.lower() in response_lower:
conflicts.append(f'Quita "{forbidden}"')
break
if owner_style_controller:
try:
admin_cfg = owner_style_controller._merged_bucket("admin")
patient_cfg = owner_style_controller._merged_bucket("patient")
all_forbidden = list(admin_cfg.get("forbidden_phrases", [])) + list(patient_cfg.get("forbidden_phrases", []))
all_starts = list(admin_cfg.get("forbidden_starts", [])) + list(patient_cfg.get("forbidden_starts", []))
if all_forbidden or all_starts:
reminders.append("→ Respeta el plano de control del admin.")
for phrase in all_forbidden[:12]:
phrase = str(phrase).strip()
if phrase and phrase.lower() in response_lower:
conflicts.append(f'Quita "{phrase}"')
for start in all_starts[:12]:
start = str(start).strip().lower()
if start and response_lower.startswith(start):
conflicts.append(f'No abras con "{start}"')
except Exception:
pass
if not reminders and not conflicts:
return [], ""
lines = [
"REGLAS DEL DUEÑO A RESPETAR EN ESTA RESPUESTA:",
*reminders[:5],
]
if conflicts:
lines.append("INCUMPLISTE ESTAS REGLAS:")
lines.extend(f"→ {c}" for c in conflicts[:4])
lines.append("Reescribe manteniendo la intención, pero ahora sí cumpliendo esto al pie de la letra.")
return conflicts, "\n".join(lines)
async def _retry_until_human(self, messages: List[Dict], response: str,
model_tier: str, personality: PersonalityProfile,
chat_id: str, clinic: Dict, user_msg: str,
history: List[Dict]) -> str:
"""
v10 — Retry limpio basado en contexto.
V9 Upgrade: Bloquea 'conversational apologies' (Uy, qué pena!).
"""
current = response
first_turn = not any((m.get("role") == "assistant") for m in (history or []))
reentry_turn = self._looks_like_reentry_turn(user_msg, history)
greeting_only = self._is_greeting_only(user_msg)
# ── EXCEPCIÓN: No hacer retry para saludos simples (evita over-correction)
if greeting_only and not first_turn:
return current
# ── Detectar problemas ──────────────────────────────────────────────
conflicts, owner_block = self._build_owner_rule_retry_injection(current)
redundant_question = detect_redundant_question(user_msg, current, history=history)
unanswered_price = detect_unanswered_price_request(user_msg, current)
fragmented = looks_fragmented_reply(current)
current_lower = (current or "").lower().strip()
if first_turn and len((current or "").split()) > 35:
conflicts.append("primer_turno_largo")
if not first_turn and not reentry_turn:
if re.match(r"^(hola[,!]?\s|buenas[,!]?\s)", current_lower):
conflicts.append("saludo_redundante")
if redundant_question: conflicts.append("pregunta_redundante")
if unanswered_price: conflicts.append("precio_ignorado")
if fragmented: conflicts.append("respuesta_cortada")
if not conflicts and not owner_block:
return current
# ── Un solo retry — Formato 'Inner Monologue' ───────────────────────
problem_parts = []
if "primer_turno_largo" in conflicts: problem_parts.append("demasiado largo para el primer mensaje")
if "saludo_redundante" in conflicts: problem_parts.append("saludo innecesario (ya vienen hablando)")
if "pregunta_redundante" in conflicts: problem_parts.append("ya preguntaste eso antes")
if "precio_ignorado" in conflicts: problem_parts.append("no respondiste al precio")
if "respuesta_cortada" in conflicts: problem_parts.append("respuesta incompleta")
if owner_block: problem_parts.append(owner_block.strip())
if not problem_parts:
return current
# Prompt de instrucción interna (System-style para no romper personaje)
retry_note = (
f"[INSTRUCCIÓN INTERNA DE CALIDAD: Tu respuesta anterior fue rechazada porque {', '.join(problem_parts)}. "
"Genera una nueva respuesta final para el paciente. NO te disculpes, NO menciones este error, "
"solo responde directamente al paciente manteniendo tu personaje.]"
)
retry_messages = list(messages)
retry_messages.append({"role": "assistant", "content": current})
retry_messages.append({"role": "system", "content": retry_note})
try:
# En retry usamos un modelo razonador si es posible para asegurar calidad
retry_tier = "reasoning" if model_tier == "fast" else model_tier
current, _ = await self.llm.complete(
retry_messages,
model_tier=retry_tier,
temperature=0.6, # un poco más conservador en el retry
max_tokens=300,
use_cache=False,
)
except Exception as e:
log.warning(f"[human_retry] error en retry: {e}")
return response
# Limpieza final
current = self._apply_output_pipeline(
response=current,
personality=personality,
chat_id=chat_id,
clinic=clinic,
user_msg=user_msg,
history=history,
is_admin=False,
)
return current
# ═══════════════════════════════════════════════════════════════════════════════
# AUTO-CONEXIÓN WHATSAPP
# El cliente da sus credenciales de Meta → Conny se auto-conecta
# ═══════════════════════════════════════════════════════════════════════════════
class WhatsAppConnector:
"""
Auto-conexión completa a WhatsApp Business Cloud API.
El cliente pega sus credenciales → Conny hace TODO el resto sola:
1. Valida las credenciales con Meta
2. Registra el webhook automáticamente via Meta API
3. Envía un mensaje de prueba al admin para confirmar
4. Confirma "Listo, ya eres visible en WhatsApp"
El cliente nunca ve URLs, tokens de verificación ni configuraciones técnicas.
Santiago debe tener en su .env:
META_APP_ID = ID de su Meta App (developers.facebook.com)
META_APP_SECRET = Secret de su Meta App
"""
META_BASE = "https://graph.facebook.com/v20.0"
# ── Validación de credenciales ─────────────────────────────────────────────
@staticmethod
async def validate_credentials(phone_id: str, access_token: str) -> Dict:
"""Verifica credenciales con Meta. Retorna info del número."""
try:
async with httpx.AsyncClient(timeout=12.0) as c:
r = await c.get(
f"{WhatsAppConnector.META_BASE}/{phone_id}",
headers={"Authorization": f"Bearer {access_token}"},
params={"fields": "display_phone_number,verified_name,status,quality_rating"}
)
if r.status_code == 200:
d = r.json()
return {
"valid": True,
"phone_number": d.get("display_phone_number", ""),
"business_name": d.get("verified_name", ""),
"status": d.get("status", ""),
}
err = r.json().get("error", {}).get("message", f"HTTP {r.status_code}")
return {"valid": False, "error": err}
except Exception as e:
return {"valid": False, "error": str(e)}
# ── Registro automático de webhook via Meta API ────────────────────────────
@staticmethod
async def auto_register_webhook(
phone_id: str,
access_token: str,
webhook_url: str,
verify_token: str,
app_id: str = "",
app_secret: str = ""
) -> Dict:
"""
Registra el webhook automáticamente en Meta.
Estrategia (en orden de preferencia):
1. App-level subscription (requiere App ID + Secret de Santiago)
2. Phone-level subscription (solo requiere el token del cliente)
3. Verificación del webhook ya registrado
"""
# Estrategia 1: App-level via App Access Token (más robusto)
if app_id and app_secret:
try:
# Obtener App Access Token
async with httpx.AsyncClient(timeout=12.0) as c:
r = await c.get(
f"{WhatsAppConnector.META_BASE}/oauth/access_token",
params={
"client_id": app_id,
"client_secret": app_secret,
"grant_type": "client_credentials"
}
)
if r.status_code != 200:
raise ValueError(f"App token failed: {r.text[:100]}")
app_token = r.json().get("access_token", "")
# Registrar webhook a nivel de App
async with httpx.AsyncClient(timeout=12.0) as c:
r = await c.post(
f"{WhatsAppConnector.META_BASE}/{app_id}/subscriptions",
headers={"Authorization": f"Bearer {app_token}"},
data={
"object": "whatsapp_business_account",
"callback_url": webhook_url,
"verify_token": verify_token,
"fields": "messages,message_deliveries,message_reads",
}
)
if r.status_code == 200:
log.info("[wa] webhook registrado via App-level subscription")
return {"ok": True, "method": "app_subscription"}
except Exception as e:
log.warning(f"[wa] App-level webhook failed, trying phone-level: {e}")
# Estrategia 2: Phone-level subscription
try:
# Obtener WABA ID del número
async with httpx.AsyncClient(timeout=12.0) as c:
r = await c.get(
f"{WhatsAppConnector.META_BASE}/{phone_id}",
headers={"Authorization": f"Bearer {access_token}"},
params={"fields": "id,account_mode"}
)
if r.status_code != 200:
raise ValueError("No se pudo obtener WABA ID")
# Suscribir el número al app (necesita que el phone esté en el app)
async with httpx.AsyncClient(timeout=12.0) as c:
r = await c.post(
f"{WhatsAppConnector.META_BASE}/{phone_id}/register",
headers={"Authorization": f"Bearer {access_token}"},
json={"messaging_product": "whatsapp", "pin": "000000"}
)
# Ignorar error de PIN — solo necesitamos que el número esté activo
log.info(f"[wa] phone register response: {r.status_code}")
return {"ok": True, "method": "phone_level"}
except Exception as e:
log.warning(f"[wa] phone-level webhook failed: {e}")
# Estrategia 3: Asumir que el webhook ya está configurado a nivel de App
# (Santiago lo hizo una vez en Meta Business Manager)
log.info("[wa] asumiendo webhook pre-configurado a nivel de App")
return {"ok": True, "method": "pre_configured"}
# ── Mensaje de prueba ──────────────────────────────────────────────────────
@staticmethod
async def send_test_message(
phone_id: str,
access_token: str,
to_phone: str,
clinic_name: str,
agent_name: str = "Conny"
) -> bool:
"""
Envía un mensaje de WhatsApp al admin para confirmar que funciona.
to_phone: número en formato internacional sin + (ej: 573124567890)
"""
if not to_phone:
return False
# Limpiar el número
clean_phone = re.sub(r'[^\d]', '', to_phone)
if clean_phone.startswith('0'):
clean_phone = clean_phone[1:]
if not clean_phone.startswith('57') and len(clean_phone) == 10:
clean_phone = '57' + clean_phone
try:
async with httpx.AsyncClient(timeout=15.0) as c:
r = await c.post(
f"{WhatsAppConnector.META_BASE}/{phone_id}/messages",
headers={
"Authorization": f"Bearer {access_token}",
"Content-Type": "application/json"
},
json={
"messaging_product": "whatsapp",
"recipient_type": "individual",
"to": clean_phone,
"type": "text",
"text": {
"body": (
f"Hola! Soy {agent_name}, tu asistente virtual de {clinic_name}. "
f"Ya estoy activa en WhatsApp. "
f"Tus pacientes ya pueden escribirme."
)
}
}
)
if r.status_code == 200:
log.info(f"[wa] mensaje de prueba enviado a {clean_phone}")
return True
log.warning(f"[wa] test message failed {r.status_code}: {r.text[:100]}")
return False
except Exception as e:
log.warning(f"[wa] test message error: {e}")
return False
# ── Aplicar config en memoria ──────────────────────────────────────────────
@staticmethod
def apply_to_config(phone_id: str, access_token: str, verify_token: str):
Config.WA_PHONE_ID = phone_id
Config.WA_ACCESS_TOKEN = access_token
Config.WA_VERIFY_TOKEN = verify_token
Config.PLATFORM = "whatsapp_cloud"
os.environ["WA_PHONE_ID"] = phone_id
os.environ["WA_ACCESS_TOKEN"] = access_token
os.environ["WA_VERIFY_TOKEN"] = verify_token
os.environ["PLATFORM"] = "whatsapp_cloud"
if db:
db.update_clinic(
wa_phone_id=phone_id,
wa_access_token=access_token,
wa_verify_token=verify_token,
platform="whatsapp_cloud"
)
db.remember("whatsapp_phone_id", phone_id, "identity")
db.remember("whatsapp_connected", "true", "identity")
db.remember("platform", "whatsapp","identity")
log.info(f"[wa] configurado: {phone_id[:8]}...")
@staticmethod
def write_env_update(env_path: str, phone_id: str, access_token: str, verify_token: str):
try:
updates = {
"PLATFORM": "whatsapp_cloud",
"WA_PHONE_ID": phone_id,
"WA_ACCESS_TOKEN": access_token,
"WA_VERIFY_TOKEN": verify_token,
}
if os.path.exists(env_path):
with open(env_path) as f:
content = f.read()
for k, v in updates.items():
if re.search(rf"^{k}=", content, re.MULTILINE):
content = re.sub(rf"^{k}=.*$", f"{k}={v}", content, flags=re.MULTILINE)
else:
content += f"\n{k}={v}"
with open(env_path, "w") as f:
f.write(content)
except Exception as e:
log.warning(f"[wa] no pude actualizar .env: {e}")
@staticmethod
async def validate_credentials(phone_id: str, access_token: str) -> Dict:
"""
Verifica que las credenciales de WhatsApp son válidas consultando la API de Meta.
Retorna {"valid": True/False, "phone_number": "...", "error": "..."}
"""
try:
async with httpx.AsyncClient(timeout=12.0) as c:
r = await c.get(
f"{WhatsAppConnector.META_BASE}/{phone_id}",
headers={"Authorization": f"Bearer {access_token}"},
params={"fields": "display_phone_number,verified_name,status"}
)
if r.status_code == 200:
data = r.json()
return {
"valid": True,
"phone_number": data.get("display_phone_number", ""),
"business_name": data.get("verified_name", ""),
"status": data.get("status", ""),
}
else:
err = r.json().get("error", {}).get("message", f"HTTP {r.status_code}")
return {"valid": False, "error": err}
except Exception as e:
return {"valid": False, "error": str(e)}
@staticmethod
async def register_webhook(
phone_id: str,
access_token: str,
webhook_url: str,
verify_token: str
) -> Dict:
"""
Registra el webhook de Conny en Meta para que los mensajes lleguen.
"""
try:
# Primero obtener el WABA ID
async with httpx.AsyncClient(timeout=12.0) as c:
r = await c.get(
f"{WhatsAppConnector.META_BASE}/{phone_id}",
headers={"Authorization": f"Bearer {access_token}"},
params={"fields": "id"}
)
if r.status_code != 200:
return {"ok": False, "error": "No se pudo obtener el WABA ID"}
# Nota: el webhook se registra a nivel de App en Meta Business Manager
# Aquí lo marcamos como configurado y damos las instrucciones manuales
return {
"ok": True,
"webhook_url": webhook_url,
"verify_token": verify_token,
"manual_step": True, # Meta requiere verificar el webhook desde su panel
}
except Exception as e:
return {"ok": False, "error": str(e)}
@staticmethod
def apply_to_config(phone_id: str, access_token: str, verify_token: str):
"""
Aplica las credenciales de WhatsApp al Config en memoria y a la DB.
Efecto inmediato — sin reiniciar.
"""
Config.WA_PHONE_ID = phone_id
Config.WA_ACCESS_TOKEN = access_token
Config.WA_VERIFY_TOKEN = verify_token
Config.PLATFORM = "whatsapp_cloud"
os.environ["WA_PHONE_ID"] = phone_id
os.environ["WA_ACCESS_TOKEN"] = access_token
os.environ["WA_VERIFY_TOKEN"] = verify_token
os.environ["PLATFORM"] = "whatsapp_cloud"
# Persistir en DB (sobrevive reinicios)
if db:
db.update_clinic(
wa_phone_id=phone_id,
wa_access_token=access_token,
wa_verify_token=verify_token,
platform="whatsapp_cloud"
)
# Guardar en memoria permanente
db.remember("whatsapp_phone_id", phone_id, "identity")
db.remember("whatsapp_connected", "true", "identity")
db.remember("platform", "whatsapp", "identity")
log.info(f"[wa] auto-configurado: phone_id={phone_id[:8]}...")
@staticmethod
def write_env_update(env_path: str, phone_id: str, access_token: str, verify_token: str):
"""
Actualiza el .env del servidor para que persista tras reinicios.
Solo actualiza las líneas WA_*, no toca nada más.
"""
try:
lines_to_add = {
"PLATFORM": "whatsapp_cloud",
"WA_PHONE_ID": phone_id,
"WA_ACCESS_TOKEN": access_token,
"WA_VERIFY_TOKEN": verify_token,
}
if os.path.exists(env_path):
with open(env_path, "r") as f:
content = f.read()
for key, val in lines_to_add.items():
import re as _re
if _re.search(rf"^{key}=", content, _re.MULTILINE):
content = _re.sub(rf"^{key}=.*$", f"{key}={val}", content, flags=_re.MULTILINE)
else:
content += f"\n{key}={val}"
with open(env_path, "w") as f:
f.write(content)
log.info(f"[wa] .env actualizado en {env_path}")
except Exception as e:
log.warning(f"[wa] no se pudo actualizar .env: {e}")
def _detect_wa_credentials(text: str) -> Optional[Dict]:
"""
Detecta credenciales de WhatsApp en el texto enviado por el admin.
Soporta múltiples formatos: pegado directo, etiquetado, etc.
"""
import re as _re
phone_id = None
token = None
# Formato etiquetado: "WA_PHONE_ID: 123..." o "Phone ID: 123..."
m = _re.search(
r'(?:WA_PHONE_ID|Phone.?ID|phone_id|PHONE.?ID)\s*[:=]\s*(\d{10,20})',
text, _re.IGNORECASE
)
if m:
phone_id = m.group(1).strip()
m = _re.search(
r'(?:WA_TOKEN|ACCESS.?TOKEN|Token|WA_ACCESS)\s*[:=]\s*(EAA[A-Za-z0-9+/=]{20,})',
text, _re.IGNORECASE
)
if m:
token = m.group(1).strip()
# Token suelto (empieza con EAA...)
if not token:
m = _re.search(r'\b(EAA[A-Za-z0-9+/=]{30,})\b', text)
if m:
token = m.group(1)
# Phone ID suelto (número de 15 dígitos solo)
if not phone_id:
m = _re.search(r'\b(\d{15,17})\b', text)
if m:
phone_id = m.group(1)
if phone_id and token:
return {"phone_id": phone_id, "token": token}
return None
# ═══════════════════════════════════════════════════════════════════════════════
# PUENTE DE CALENDARIO
# Google Calendar (OAuth) + Calendly (fallback) + Notificacion autonoma al admin
# ═══════════════════════════════════════════════════════════════════════════════
class CalendarBridge:
"""
Puente inteligente entre Conny, el admin y su agenda.
Jerarquia:
1. Google Calendar vinculado -> consulta disponibilidad real en tiempo real
2. Calendly configurado -> manda el link directo al paciente
3. Sin nada configurado -> notifica al admin autonomamente y espera respuesta
El admin vincula su Google Calendar una sola vez via OAuth (/vincular-agenda).
Desde ahi Conny sabe su disponibilidad sin preguntarle.
"""
GCAL_BASE = "https://www.googleapis.com/calendar/v3"
GCAL_AUTH = "https://oauth2.googleapis.com/token"
GCAL_SCOPE = "https://www.googleapis.com/auth/calendar.readonly"
# Palabras que indican que el paciente pregunta por disponibilidad
AVAILABILITY_SIGNALS = [
"cuando", "que dia", "que días", "disponib", "horario", "cita",
"agendar", "reservar", "puede ser", "tienes espacio", "hay espacio",
"puedo ir", "cuando puedo", "que horas", "turno",
"lunes", "martes", "miercoles", "jueves", "viernes", "sabado",
"esta semana", "proxima semana", "hoy", "manana", "mañana",
"tarde", "mañana", "medio dia", "mediodía",
]
def __init__(self):
self._access_token = Config.GCAL_ACCESS_TOKEN
self._refresh_token = Config.GCAL_REFRESH_TOKEN
self._client_id = Config.GCAL_CLIENT_ID
self._client_secret = Config.GCAL_CLIENT_SECRET
self._calendar_id = Config.GCAL_CALENDAR_ID or "primary"
self._calendly_link = Config.CALENDLY_LINK
self._token_expiry = 0.0 # timestamp when access token expires
# ── Deteccion ──────────────────────────────────────────────────────────────
def needs_calendar(self, text: str) -> bool:
"""Detecta si el mensaje del paciente requiere info de disponibilidad."""
text_low = text.lower()
return any(s in text_low for s in self.AVAILABILITY_SIGNALS)
# ── Estado del puente ──────────────────────────────────────────────────────
def has_google_calendar(self) -> bool:
return bool(self._refresh_token and self._client_id and self._client_secret)
def has_calendly(self) -> bool:
return bool(self._calendly_link)
def is_configured(self) -> bool:
return self.has_google_calendar() or self.has_calendly()
# ── OAuth — obtener/refrescar access token ─────────────────────────────────
async def _ensure_token(self) -> bool:
"""Refresca el access token si expiró. Retorna True si hay token válido."""
if not self.has_google_calendar():
return False
if time.time() < self._token_expiry - 60 and self._access_token:
return True
try:
async with httpx.AsyncClient(timeout=10.0) as c:
r = await c.post(self.GCAL_AUTH, data={
"grant_type": "refresh_token",
"refresh_token": self._refresh_token,
"client_id": self._client_id,
"client_secret": self._client_secret,
})
r.raise_for_status()
data = r.json()
self._access_token = data["access_token"]
self._token_expiry = time.time() + data.get("expires_in", 3600)
log.info("[calendar] token refrescado OK")
return True
except Exception as e:
log.warning(f"[calendar] error refrescando token: {e}")
return False
# ── Consulta de disponibilidad ─────────────────────────────────────────────
async def get_free_slots(self, days_ahead: int = 7) -> List[Dict]:
"""
Retorna slots libres en los próximos N días.
Consulta Google Calendar en tiempo real.
"""
if not await self._ensure_token():
return []
now = datetime.now()
time_min = now.isoformat() + "Z"
time_max = (now + timedelta(days=days_ahead)).isoformat() + "Z"
try:
# Obtener eventos existentes (ocupados)
async with httpx.AsyncClient(timeout=12.0) as c:
r = await c.get(
f"{self.GCAL_BASE}/calendars/{self._calendar_id}/events",
headers={"Authorization": f"Bearer {self._access_token}"},
params={
"timeMin": time_min,
"timeMax": time_max,
"singleEvents": "true",
"orderBy": "startTime",
"maxResults": 100,
}
)
r.raise_for_status()
events = r.json().get("items", [])
# Construir set de horarios ocupados
busy_slots = set()
for ev in events:
start = ev.get("start", {}).get("dateTime", "")
if start:
busy_slots.add(start[:16]) # "2025-03-15T10:00"
# Generar slots disponibles (9am-6pm, cada 30 min)
free = []
for day_offset in range(days_ahead):
day = now + timedelta(days=day_offset + 1)
if day.weekday() >= 6: # domingo = 6
continue
for hour in range(9, 18):
for minute in (0, 30):
slot_dt = day.replace(hour=hour, minute=minute,
second=0, microsecond=0)
slot_key = slot_dt.strftime("%Y-%m-%dT%H:%M")
if slot_key not in busy_slots:
free.append({
"datetime": slot_dt.strftime("%Y-%m-%d %H:%M"),
"day_label": slot_dt.strftime("%A %d de %B"),
"time": slot_dt.strftime("%I:%M %p"),
"iso": slot_key,
})
log.info(f"[calendar] {len(free)} slots libres en {days_ahead} dias")
return free
except Exception as e:
log.warning(f"[calendar] error obteniendo slots: {e}")
return []
async def get_availability_summary(self) -> str:
"""
Resumen de disponibilidad para inyectar en el system prompt de Conny.
Máximo 3-4 días con los primeros slots de cada día.
"""
slots = await self.get_free_slots(days_ahead=7)
if not slots:
return ""
# Agrupar por día
by_day: Dict[str, List[str]] = {}
for s in slots:
day = s["day_label"]
by_day.setdefault(day, []).append(s["time"])
lines = ["AGENDA REAL (Google Calendar — disponibilidad actual):"]
count = 0
for day, times in by_day.items():
if count >= 4:
break
times_str = ", ".join(times[:4]) + (" y más" if len(times) > 4 else "")
lines.append(f" {day}: {times_str}")
count += 1
return "\n".join(lines)
# ── Notificacion autonoma al admin ─────────────────────────────────────────
async def notify_admin_availability_request(
self,
admin_ids: List[str],
patient_name: str,
patient_question: str,
send_fn # _send_message de ConnyUltra
):
"""
Cuando no hay calendario vinculado, Conny le escribe al admin
autónomamente para preguntarle su disponibilidad.
"""
patient_str = patient_name if patient_name else "Un paciente"
msg = (
f"Hola! {patient_str} me preguntó sobre disponibilidad:\n\n"
f"\"{patient_question[:120]}\"\n\n"
f"No tengo acceso a tu agenda. Qué días y horas tienes disponibles "
f"esta semana para decirle?"
)
for admin_id in admin_ids:
try:
await send_fn(admin_id, msg)
log.info(f"[calendar] notificado admin {admin_id} sobre disponibilidad")
except Exception as e:
log.warning(f"[calendar] error notificando admin {admin_id}: {e}")
# ── OAuth setup ────────────────────────────────────────────────────────────
def get_oauth_url(self, redirect_uri: str) -> str:
"""Genera la URL de autorización de Google OAuth."""
import urllib.parse
params = {
"client_id": self._client_id,
"redirect_uri": redirect_uri,
"response_type": "code",
"scope": self.GCAL_SCOPE + " https://www.googleapis.com/auth/calendar.events",
"access_type": "offline",
"prompt": "consent",
}
return "https://accounts.google.com/o/oauth2/v2/auth?" + urllib.parse.urlencode(params)
async def exchange_code(self, code: str, redirect_uri: str) -> Dict:
"""Intercambia el código OAuth por access + refresh tokens."""
async with httpx.AsyncClient(timeout=15.0) as c:
r = await c.post(self.GCAL_AUTH, data={
"grant_type": "authorization_code",
"code": code,
"redirect_uri": redirect_uri,
"client_id": self._client_id,
"client_secret": self._client_secret,
})
r.raise_for_status()
return r.json()
def update_tokens(self, access_token: str, refresh_token: str):
"""Actualiza los tokens en memoria (y debe guardarse en .env o DB)."""
self._access_token = access_token
self._refresh_token = refresh_token
self._token_expiry = time.time() + 3600
log.info("[calendar] tokens actualizados en memoria")
# Instancia global
calendar_bridge: CalendarBridge = None
def init_calendar():
global calendar_bridge
calendar_bridge = CalendarBridge()
if calendar_bridge.has_google_calendar():
log.info("[calendar] Google Calendar configurado")
elif calendar_bridge.has_calendly():
log.info("[calendar] Calendly configurado")
else:
log.info("[calendar] sin calendario vinculado — modo autonomo activo")
# ═══════════════════════════════════════════════════════════════════════════════
# SISTEMA DE BÚSQUEDA WEB
# ═══════════════════════════════════════════════════════════════════════════════
class WebSearchEngine:
"""
Motor de busqueda. Si search.py esta disponible lo usa (SerpAPI -> Brave -> Apify).
V9 Upgrade: Soporte para rotación masiva de 20+ claves (estilo OpenClaw).
"""
def __init__(self):
if _EXTERNAL_SEARCH:
self._ext = _ExternalSearchEngine()
log.info("[search] usando search.py externo (SerpAPI disponible)")
else:
self._ext = None
log.info("[search] search.py no encontrado, usando motor interno")
# Colección de llaves masiva
self.brave_keys = Config.BRAVE_API_KEYS or ([Config.BRAVE_API_KEY] if Config.BRAVE_API_KEY else [])
self.apify_keys = Config.APIFY_API_KEYS or ([Config.APIFY_API_KEY] if Config.APIFY_API_KEY else [])
self.serp_keys = Config.SERP_API_KEYS or ([Config.SERP_API_KEY] if Config.SERP_API_KEY else [])
# Compatibilidad con rutas legacy que todavía leen attrs singulares.
self.brave_key = self.brave_keys[0] if self.brave_keys else ""
self.apify_key = self.apify_keys[0] if self.apify_keys else ""
self.serp_key = self.serp_keys[0] if self.serp_keys else ""
# Índices para rotación simple (Round Robin)
self._brave_idx = 0
self._apify_idx = 0
self._serp_idx = 0
def _next_key(self, keys: List[str], current_idx: int) -> Tuple[str, int]:
if not keys: return "", 0
idx = current_idx % len(keys)
return keys[idx], idx + 1
async def search(self, query: str, context: str = "") -> str:
"""Busqueda con contexto. Usa motor externo si disponible."""
if self._ext:
return await self._ext.search(query, context=context)
return await self._fallback_search(query, context)
async def medical(self, procedure: str, question: str = "",
patient_age: int = None,
clinic_services: list = None) -> str:
"""Busqueda medica especializada."""
if self._ext:
return await self._ext.medical(procedure, question, patient_age, clinic_services)
q = f"{procedure} tratamiento estetico beneficios edad Medellin {question}"
return await self._fallback_search(q, "")
def detect_procedure(self, text: str):
if self._ext:
return self._ext.detect_procedure(text)
return None
def extract_age(self, text: str):
if self._ext:
return self._ext.extract_age(text)
return None
async def _fallback_search(self, query: str, context: str) -> str:
"""Motor interno de fallback: Rotación de SerpAPI -> Brave -> Apify."""
full_query = f"{context} {query}".strip() if context else query
# 1. SerpAPI (si hay keys)
for _ in range(len(self.serp_keys)):
key, self._serp_idx = self._next_key(self.serp_keys, self._serp_idx)
result = await self._serp_search(full_query, key)
if result: return result
# 2. Brave (si hay keys)
for _ in range(len(self.brave_keys)):
key, self._brave_idx = self._next_key(self.brave_keys, self._brave_idx)
result = await self._brave_search(full_query, key)
if result: return result
# 3. Apify (si hay keys)
for _ in range(len(self.apify_keys)):
key, self._apify_idx = self._next_key(self.apify_keys, self._apify_idx)
result = await self._apify_search(full_query, key)
if result: return result
return ""
async def _serp_search(self, query: str, key: str) -> str:
if not key: return ""
try:
async with httpx.AsyncClient(timeout=12.0) as client:
r = await client.get(
"https://serpapi.com/search",
params={"engine": "google", "q": query, "api_key": key,
"hl": "es", "gl": "co", "num": 5, "safe": "active"},
)
if r.status_code == 429: return ""
r.raise_for_status()
data = r.json()
parts = []
ab = data.get("answer_box", {})
if ab:
s = ab.get("answer") or ab.get("snippet") or ""
if s: parts.append(s.strip()[:600])
for res in data.get("organic_results", [])[:4]:
if res.get("snippet"): parts.append(res["snippet"][:300])
return "\n".join(parts)[:1200]
except Exception:
return ""
async def _brave_search(self, query: str, key: str, count: int = 5) -> str:
if not key: return ""
try:
async with httpx.AsyncClient(timeout=10.0) as client:
r = await client.get(
"https://api.search.brave.com/res/v1/web/search",
headers={"Accept": "application/json",
"X-Subscription-Token": key},
params={"q": query, "count": count, "search_lang": "es", "country": "ALL"},
)
if r.status_code == 429: return ""
r.raise_for_status()
data = r.json()
results = data.get("web", {}).get("results", [])
snippets = [res.get("description", "") for res in results if res.get("description")]
return " ".join(snippets)[:1200]
except Exception:
return ""
async def _apify_search(self, query: str, key: str) -> str:
if not key: return ""
try:
async with httpx.AsyncClient(timeout=25.0) as client:
r = await client.post(
"https://api.apify.com/v2/acts/apify~google-search-scraper/run-sync-get-dataset-items",
headers={"Authorization": f"Bearer {key}"},
json={"queries": query, "maxPagesPerQuery": 1,
"resultsPerPage": 5, "languageCode": "es", "countryCode": "co"},
params={"timeout": 20, "memory": 256},
)
if r.status_code == 429: return ""
r.raise_for_status()
items = r.json()
if items and isinstance(items, list):
snippets = []
for item in items[:1]:
for res in item.get("organicResults", [])[:5]:
if res.get("description"):
snippets.append(res["description"])
if snippets:
return " ".join(snippets)[:1200]
except Exception:
return ""
async def _apify_search_candidates(self, query: str, count: int = 5) -> List[Dict]:
if not self.apify_keys:
return []
for apify_key in self.apify_keys:
try:
async with httpx.AsyncClient(timeout=25.0) as client:
r = await client.post(
"https://api.apify.com/v2/acts/apify~google-search-scraper/run-sync-get-dataset-items",
headers={"Authorization": f"Bearer {apify_key}"},
json={
"queries": query,
"maxPagesPerQuery": 1,
"resultsPerPage": count,
"languageCode": "es",
"countryCode": "co",
},
params={"timeout": 20, "memory": 256},
)
r.raise_for_status()
items = r.json()
if not items or not isinstance(items, list):
continue
results = []
for item in items[:1]:
for res in item.get("organicResults", [])[:count]:
results.append({
"title": res.get("title", ""),
"url": res.get("url", ""),
"description": res.get("description", ""),
})
if results:
return results
except Exception as e:
log.warning(f"Apify candidate search error: {e}")
continue
return []
async def search_business_link(
self,
nombre: str,
excluded_urls: Optional[set] = None,
context_hint: str = "",
) -> tuple:
"""
Busca un negocio y devuelve (snippet_text, url).
Prioridad: Google Maps → website oficial → primer organic result.
"""
from urllib.parse import urlparse
nombre_clean = " ".join(str(nombre or "").split()).strip()
nombre_norm = _normalize_conv_text(nombre_clean)
hint_clean = " ".join(str(context_hint or "").split()).strip()
hint_norm = _normalize_conv_text(hint_clean)
query_variants: List[str] = []
def _push_query(candidate_query: str) -> None:
normalized = " ".join(str(candidate_query or "").split()).strip()
if normalized and normalized not in query_variants:
query_variants.append(normalized)
if hint_clean:
_push_query(f"{nombre_clean} {hint_clean}")
if "colombia" not in hint_norm:
_push_query(f"{nombre_clean} {hint_clean} Colombia")
_push_query(nombre_clean if "colombia" in nombre_norm else f"{nombre_clean} Colombia")
excluded = {u for u in (excluded_urls or set()) if u}
serp_keys = getattr(self, "serp_keys", None) or ([getattr(self, "serp_key", "")] if getattr(self, "serp_key", "") else [])
brave_keys = getattr(self, "brave_keys", None) or ([getattr(self, "brave_key", "")] if getattr(self, "brave_key", "") else [])
apify_keys = getattr(self, "apify_keys", None) or ([getattr(self, "apify_key", "")] if getattr(self, "apify_key", "") else [])
url = ""
text = ""
skip = [
"facebook.com/pages","facebook.com/p/","facebook.com/profile",
"amarillasinternet","paginasamarillas","directorio",
"yelp","foursquare","tripadvisor","cylex","infobel",
"clinicasesteticas.com","bookimed.com","doctoralia","topdoctors",
"treatwell","multiestetica","medicosdoc",
]
bad_social_fragments = ("/reel/", "/p/", "/tv/", "facebook.com/reel", "facebook.com/watch")
directory_markers = (
"doctores de", "mejores especialistas", "encuentre los mejores",
"cerca de", "top ", "ranking", "listado", "centros de",
"clinicasesteticas", "bookimed", "doctoralia", "top doctors",
)
generic_tokens = {
"clinica", "clinicas", "clinic", "hospital", "centro", "centros", "medicina",
"medico", "medicos", "medica", "medicas", "estetica", "estetico", "esteticos",
"spa", "salud", "medical", "colombia", "medellin", "medellín", "bogota",
"bogotá", "consultorio", "ips", "sas", "sede", "oficial", "instagram",
"servicios", "servicio", "grupo", "empresa", "negocio", "esteticos", "esteticas",
}
name_tokens = [
tok for tok in re.findall(r"[a-z0-9áéíóúüñ]+", nombre_norm)
if len(tok) >= 3
]
strong_tokens = [tok for tok in name_tokens if tok not in generic_tokens]
anchor_families = {
"clinica": ("clinica", "clinic"),
"hospital": ("hospital",),
"dental": ("dental", "odont", "odontologia", "odontológica", "odontologica"),
"laboratorio": ("laboratorio", "laboratories", "lab"),
}
required_anchor = None
for anchor_name, variants in anchor_families.items():
if any(variant in nombre_norm for variant in variants):
required_anchor = (anchor_name, variants)
break
candidates: List[Dict[str, Any]] = []
def _accept_url(candidate: str) -> bool:
if not candidate:
return False
if any(s in candidate for s in skip):
return False
if any(fragment in candidate for fragment in bad_social_fragments):
return False
if candidate in excluded:
return False
return True
def _norm_join(*parts: str) -> str:
return _normalize_conv_text(" ".join(part for part in parts if part))
def _register_candidate(source: str, candidate_url: str, title: str = "", description: str = "") -> None:
if not _accept_url(candidate_url):
return
candidates.append({
"source": source,
"url": candidate_url,
"title": title or "",
"description": description or "",
})
def _candidate_score(candidate: Dict[str, Any]) -> Optional[int]:
candidate_url = candidate.get("url", "") or ""
title = candidate.get("title", "") or ""
description = candidate.get("description", "") or ""
haystack = _norm_join(title, description, candidate_url)
title_url_haystack = _norm_join(title, candidate_url)
domain = _normalize_conv_text(urlparse(candidate_url).netloc or "")
if required_anchor and not any(variant in title_url_haystack for variant in required_anchor[1]):
return None
exact_name = bool(nombre_norm and nombre_norm in haystack)
matched_name_tokens = [tok for tok in name_tokens if tok in haystack]
matched_strong_tokens = [tok for tok in strong_tokens if tok in haystack]
title_strong_tokens = [tok for tok in strong_tokens if tok in title_url_haystack]
domain_strong_tokens = [tok for tok in strong_tokens if tok in domain]
if strong_tokens:
if not exact_name and not title_strong_tokens and not domain_strong_tokens:
return None
elif len(matched_name_tokens) < 2 and not exact_name:
return None
if any(marker in haystack for marker in directory_markers) and not exact_name:
return None
source_bonus = {
"local_maps": 10,
"local_website": 7,
"knowledge_graph": 6,
"organic": 2,
"brave": 1,
"apify": 1,
}.get(candidate.get("source", ""), 0)
score = source_bonus
score += 6 if exact_name else 0
score += len(title_strong_tokens) * 4
score += len(domain_strong_tokens) * 3
score += len(matched_strong_tokens) * 1
score += min(len(matched_name_tokens), 3)
if "instagram.com" in candidate_url or "facebook.com" in candidate_url:
score -= 2
if not title_strong_tokens and not domain_strong_tokens:
return None
if strong_tokens and len(strong_tokens) == 1 and required_anchor is None:
lone_token = strong_tokens[0]
if lone_token in description.lower() and lone_token not in title_url_haystack and lone_token not in domain:
return None
return score
def _select_best_candidate() -> Optional[Dict[str, Any]]:
scored: List[Tuple[int, Dict[str, Any]]] = []
for candidate in candidates:
score = _candidate_score(candidate)
if score is None:
continue
scored.append((score, candidate))
if not scored:
return None
scored.sort(key=lambda item: item[0], reverse=True)
best_score, best_candidate = scored[0]
if best_score < 5:
return None
return best_candidate
# ── SerpAPI: Maps + Knowledge Graph + Organic ─────────────────────────
for query in query_variants:
if serp_keys:
for key in serp_keys:
if not key:
continue
try:
async with httpx.AsyncClient(timeout=12.0) as client:
r = await client.get(
"https://serpapi.com/search",
params={"engine": "google", "q": query, "api_key": key,
"hl": "es", "gl": "co", "num": 5},
)
r.raise_for_status()
data = r.json()
local_raw = data.get("local_results") or {}
if isinstance(local_raw, dict):
local_places = local_raw.get("places") or local_raw.get("results") or []
elif isinstance(local_raw, list):
local_places = local_raw
else:
local_places = []
first_local = local_places[0] if local_places and isinstance(local_places[0], dict) else {}
if first_local:
maps_link = (first_local.get("links", {}).get("directions")
or first_local.get("place_id_search")
or "")
website = first_local.get("links", {}).get("website", "")
title = first_local.get("title", "")
biz_type = first_local.get("type", "")
addr = first_local.get("address", "")
rating = first_local.get("rating", "")
local_desc_parts = []
if biz_type:
local_desc_parts.append(f"Tipo: {biz_type}")
if addr:
local_desc_parts.append(f"Dirección: {addr}")
if rating:
local_desc_parts.append(f"Rating: {rating}")
local_desc = " | ".join(local_desc_parts)
_register_candidate("local_maps", maps_link, title, local_desc)
_register_candidate("local_website", website, title, local_desc)
kg = data.get("knowledge_graph", {})
local_map = data.get("local_map") or {}
candidate_url = (kg.get("website") or kg.get("local_map", "") or local_map.get("link", "") or "")
_register_candidate(
"knowledge_graph",
candidate_url,
kg.get("title", ""),
kg.get("description", ""),
)
for res in data.get("organic_results", [])[:5]:
_register_candidate(
"organic",
res.get("link", ""),
res.get("title", ""),
res.get("snippet", ""),
)
if _select_best_candidate():
break
except Exception as e:
log.warning(f"[search_link] SerpAPI error: {e}")
if _select_best_candidate():
break
if brave_keys:
for key in brave_keys:
if not key:
continue
try:
async with httpx.AsyncClient(timeout=10.0) as client:
r = await client.get(
"https://api.search.brave.com/res/v1/web/search",
headers={"Accept": "application/json",
"X-Subscription-Token": key},
params={"q": query, "count": 5, "search_lang": "es", "country": "ALL"},
)
r.raise_for_status()
results = r.json().get("web", {}).get("results", [])
for res in results[:5]:
_register_candidate(
"brave",
res.get("url", ""),
res.get("title", ""),
res.get("description", ""),
)
if _select_best_candidate():
break
except Exception as e:
log.warning(f"[search_link] Brave error: {e}")
if _select_best_candidate():
break
if apify_keys:
try:
apify_results = await self._apify_search_candidates(query, count=6)
for res in apify_results:
_register_candidate(
"apify",
res.get("url", ""),
res.get("title", ""),
res.get("description", ""),
)
if _select_best_candidate():
break
except Exception as e:
log.warning(f"[search_link] Apify error: {e}")
best_candidate = _select_best_candidate()
if best_candidate:
url = best_candidate.get("url", "")
parts = []
title = (best_candidate.get("title") or "").strip()
description = (best_candidate.get("description") or "").strip()
if title:
parts.append(f"Negocio: {title}")
if description:
parts.append(description[:320])
text = "\n".join(parts)[:800]
# ── Fallback: Google Maps (mucho más útil que Google Search para negocios) ──
if not url:
import urllib.parse
url = f"https://www.google.com/maps/search/{urllib.parse.quote(nombre)}+Colombia"
text = ""
return text, url
# ═══════════════════════════════════════════════════════════════════════════════
# SISTEMA DE PLUGINS MCP
# ═══════════════════════════════════════════════════════════════════════════════
class MCPCapability(Enum):
"""Capacidades de plugins MCP."""
CALENDAR = "calendar"
PAYMENTS = "payments"
REMINDERS = "reminders"
CRM = "crm"
ANALYTICS = "analytics"
NOTIFICATIONS = "notifications"
INVENTORY = "inventory"
REVIEWS = "reviews"
MARKETING = "marketing"
class MCPPluginBase(ABC):
"""Base para plugins MCP."""
@property
@abstractmethod
def id(self) -> str:
pass
@property
@abstractmethod
def name(self) -> str:
pass
@property
@abstractmethod
def capabilities(self) -> List[MCPCapability]:
pass
@abstractmethod
async def initialize(self, config: Dict) -> bool:
pass
@abstractmethod
async def execute(self, action: str, params: Dict) -> Dict:
pass
@abstractmethod
async def health_check(self) -> bool:
pass
class CalendarPlugin(MCPPluginBase):
"""Plugin de calendario integrado."""
@property
def id(self) -> str:
return "calendar_v1"
@property
def name(self) -> str:
return "Calendario Inteligente"
@property
def capabilities(self) -> List[MCPCapability]:
return [MCPCapability.CALENDAR, MCPCapability.REMINDERS]
async def initialize(self, config: Dict) -> bool:
self.config = config
self.slots_duration = config.get("slot_duration_minutes", 60)
self.working_hours = config.get("working_hours", {"start": 9, "end": 18})
return True
async def execute(self, action: str, params: Dict) -> Dict:
if action == "get_available_slots":
return await self._get_available_slots(params)
elif action == "book_slot":
return await self._book_slot(params)
elif action == "cancel_booking":
return await self._cancel_booking(params)
elif action == "get_schedule":
return await self._get_schedule(params)
else:
return {"error": f"Unknown action: {action}"}
async def _get_available_slots(self, params: Dict) -> Dict:
"""Obtiene slots disponibles."""
date = params.get("date", datetime.now().strftime("%Y-%m-%d"))
service = params.get("service")
# Obtener citas existentes
appointments = db.get_appointments(status="confirmada")
# Generar slots
slots = []
start_hour = self.working_hours["start"]
end_hour = self.working_hours["end"]
for hour in range(start_hour, end_hour):
for minute in [0, 30]:
slot_time = f"{hour:02d}:{minute:02d}"
slot_datetime = f"{date} {slot_time}"
# Verificar si está ocupado
is_booked = any(
apt.get("datetime_slot", "").startswith(slot_datetime)
for apt in appointments
)
if not is_booked:
slots.append({
"time": slot_time,
"datetime": slot_datetime,
"available": True
})
return {"date": date, "slots": slots}
async def _book_slot(self, params: Dict) -> Dict:
"""Reserva un slot."""
apt_id = db.save_appointment(
params.get("chat_id", ""),
{
"patient_name": params.get("name", ""),
"patient_phone": params.get("phone", ""),
"service": params.get("service", ""),
"datetime_slot": params.get("datetime", ""),
"notes": params.get("notes", "")
}
)
return {"success": True, "appointment_id": apt_id}
async def _cancel_booking(self, params: Dict) -> Dict:
"""Cancela una reserva."""
apt_id = params.get("appointment_id")
reason = params.get("reason", "")
db.update_appointment(
apt_id,
status="cancelada",
cancellation_reason=reason,
cancelled_at=datetime.now().isoformat()
)
return {"success": True}
async def _get_schedule(self, params: Dict) -> Dict:
"""Obtiene agenda del día."""
date = params.get("date", datetime.now().strftime("%Y-%m-%d"))
appointments = db.get_appointments()
day_appointments = [
apt for apt in appointments
if apt.get("datetime_slot", "").startswith(date)
and apt.get("status") != "cancelada"
]
return {"date": date, "appointments": day_appointments}
async def health_check(self) -> bool:
return True
class NotificationsPlugin(MCPPluginBase):
"""Plugin de notificaciones."""
@property
def id(self) -> str:
return "notifications_v1"
@property
def name(self) -> str:
return "Notificaciones Inteligentes"
@property
def capabilities(self) -> List[MCPCapability]:
return [MCPCapability.NOTIFICATIONS, MCPCapability.REMINDERS]
async def initialize(self, config: Dict) -> bool:
self.config = config
self.telegram_token = Config.TELEGRAM_TOKEN
return bool(self.telegram_token)
async def execute(self, action: str, params: Dict) -> Dict:
if action == "send_notification":
return await self._send_notification(params)
elif action == "schedule_reminder":
return await self._schedule_reminder(params)
else:
return {"error": f"Unknown action: {action}"}
async def _send_notification(self, params: Dict) -> Dict:
"""Envía notificación."""
chat_id = params.get("chat_id")
message = params.get("message")
if not chat_id or not message:
return {"error": "chat_id y message requeridos"}
async with httpx.AsyncClient(timeout=10.0) as client:
await client.post(
f"https://api.telegram.org/bot{self.telegram_token}/sendMessage",
json={"chat_id": chat_id, "text": message}
)
return {"success": True}
async def _schedule_reminder(self, params: Dict) -> Dict:
"""Programa recordatorio."""
task = Task(
id=str(uuid.uuid4()),
type="reminder",
priority=5,
status="pending",
data={
"chat_id": params.get("chat_id"),
"message": params.get("message"),
"appointment_id": params.get("appointment_id")
},
created_at=datetime.now(),
scheduled_for=datetime.fromisoformat(params.get("scheduled_for")),
completed_at=None,
result=None,
retries=0
)
db.create_task(task)
return {"success": True, "task_id": task.id}
async def health_check(self) -> bool:
return bool(self.telegram_token)
class MCPManager:
"""Gestor de plugins MCP."""
def __init__(self):
self.plugins: Dict[str, MCPPluginBase] = {}
self._builtin_plugins = [
CalendarPlugin(),
NotificationsPlugin(),
]
async def initialize(self):
"""Inicializa plugins."""
# Registrar plugins builtin
for plugin in self._builtin_plugins:
await self.register_plugin(plugin)
# Cargar plugins de BD
saved_plugins = db.get_plugins(enabled_only=True)
for p in saved_plugins:
if p.id in self.plugins:
# Aplicar configuración guardada
await self.plugins[p.id].initialize(p.config)
log.info(f"MCP Manager: {len(self.plugins)} plugins activos")
async def register_plugin(self, plugin: MCPPluginBase, config: Dict = None):
"""Registra un plugin."""
config = config or {}
if await plugin.initialize(config):
self.plugins[plugin.id] = plugin
# Guardar en BD
db.install_plugin(MCPPlugin(
id=plugin.id,
name=plugin.name,
description="",
version="1.0.0",
enabled=True,
config=config,
capabilities=[c.value for c in plugin.capabilities],
endpoints={},
health_status="healthy",
last_check=datetime.now()
))
log.info(f"Plugin registrado: {plugin.name}")
async def execute(self, plugin_id: str, action: str, params: Dict) -> Dict:
"""Ejecuta acción en plugin."""
if plugin_id not in self.plugins:
return {"error": f"Plugin no encontrado: {plugin_id}"}
try:
result = await self.plugins[plugin_id].execute(action, params)
return result
except Exception as e:
log.error(f"Plugin error [{plugin_id}]: {e}")
return {"error": str(e)}
def get_capabilities(self) -> Dict[str, List[str]]:
"""Obtiene capacidades de todos los plugins."""
caps = {}
for pid, plugin in self.plugins.items():
caps[pid] = [c.value for c in plugin.capabilities]
return caps
async def health_check_all(self) -> Dict[str, bool]:
"""Verifica salud de todos los plugins."""
results = {}
for pid, plugin in self.plugins.items():
try:
results[pid] = await plugin.health_check()
except Exception:
results[pid] = False
return results
class TaskManager:
"""Gestor de tareas autónomas."""
def __init__(self):
self._running = False
self._task_handlers: Dict[str, Callable] = {}
self._register_default_handlers()
def _register_default_handlers(self):
self._task_handlers["reminder"] = self._handle_reminder
self._task_handlers["self_improve"] = self._handle_self_improve
self._task_handlers["daily_report"] = self._handle_daily_report
async def start(self):
self._running = True
asyncio.create_task(self._run_loop())
async def _run_loop(self):
while self._running:
try:
if db:
pending = db.get_pending_tasks(limit=5)
for task_data in pending:
task_type = task_data.get("type", "")
handler = self._task_handlers.get(task_type)
if handler:
try:
result = await handler(task_data)
db.complete_task(task_data.get("id"), result)
except Exception:
db.fail_task(task_data.get("id"), str(Exception("handler failed")))
except Exception:
pass
await asyncio.sleep(30)
async def _handle_reminder(self, task: "Task") -> Dict:
from datetime import datetime, timedelta
try:
chat_id = task.data.get("chat_id", "")
message = task.data.get("message", "")
if chat_id and message:
await mcp_manager.execute(
"notifications_v1", "send_notification",
{"chat_id": chat_id, "message": message}
)
return {"status": "sent", "chat_id": chat_id}
except Exception as e:
log.warning(f"[task] reminder failed: {e}")
return {"status": "failed", "error": str(e)}
async def _handle_self_improve(self, task: "Task") -> Dict:
try:
from conny_intelligence import _trigger_self_improve
await _trigger_self_improve()
return {"status": "ok"}
except Exception as e:
log.warning(f"[task] self_improve failed: {e}")
return {"status": "failed"}
async def _handle_daily_report(self, task: "Task") -> Dict:
try:
await self._send_daily_report()
return {"status": "ok"}
except Exception as e:
log.warning(f"[task] daily_report failed: {e}")
return {"status": "failed"}
async def _send_daily_report(self):
try:
from datetime import datetime
if db:
admin_ids = _parse_admin_ids(db.get_clinic().get("admin_chat_ids", []))
today_start = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
stats = db.get_conversation_stats(since=today_start)
msg = f"*Reporte diario Conny*\n\nConversaciones: {stats.get('conversations', 0)}\nMensajes: {stats.get('messages', 0)}"
for aid in admin_ids:
await mcp_manager.execute("notifications_v1", "send_notification", {"chat_id": aid, "message": msg})
except Exception:
pass
def schedule_task(self, task_type: str, data: Dict,
scheduled_for: "datetime" = None, priority: int = 5):
task_obj = Task(
id=str(uuid.uuid4()),
type=task_type,
priority=priority,
status="pending",
data=data,
created_at=datetime.now(),
scheduled_for=scheduled_for,
completed_at=None,
result=None,
retries=0
)
if db:
db.create_task(task_obj)
return task_obj.id
def cancel_task(self, task_id: str):
if db:
db.cancel_task(task_id)
task_manager: TaskManager = None
async def init_task_manager():
global task_manager
task_manager = TaskManager()
await task_manager.start()
# Instancia global
mcp_manager: MCPManager = None
async def init_mcp():
global mcp_manager
mcp_manager = MCPManager()
await mcp_manager.initialize()
# ═══════════════════════════════════════════════════════════════════════════════
# SISTEMA DE AUTO-MEJORA
# ═══════════════════════════════════════════════════════════════════════════════
# Instancia global de auth
auth_engine: AuthEngine = None
def init_auth():
global auth_engine
auth_engine = AuthEngine()
# ═══════════════════════════════════════════════════════════════════════════════
# ORQUESTADOR PRINCIPAL - CONNY ULTRA
# ═══════════════════════════════════════════════════════════════════════════════
class ConnyUltra:
"""Orquestador principal de Conny Ultra V7.0."""
def __init__(self):
self.db = db
self.analyzer = analyzer
self.search = WebSearchEngine()
self.reasoning: ReasoningEngine = None
self.generator: ResponseGenerator = None
self.self_improvement = None
self.admin_learning: AdminLearningEngine = None
self.simulator: SimulationEngine = None
# ── Atributos base (antes de managers que los usan) ──────────────────────
self._demo_sessions: Dict[str, float] = {}
self._emoji_chats_off: set = set()
self._chat_routes: Dict[str, Dict[str, Any]] = {}
# Gestores de áreas separadas (v9)
self.demo_mgr = ConnyDemo(self)
self.admin_mgr = ConnyAdmin(self)
self.production_mgr = ConnyProduction(self)
self._conversation_engine = None
# V7.0 — orquestador de agentes especializados
self._orchestrator = None # se inicializa en initialize() cuando llm_engine existe
self._pending_buffers: Dict[str, Dict] = {}
self._admin_pending: Dict[str, Dict] = {}
self._last_reviewed_chat: Optional[str] = None
self._availability_pending_patient: Optional[str] = None
if _SESSION_MANAGER_AVAILABLE:
self._session_mgr = SessionManager(self._demo_sessions, self._emoji_chats_off)
if _AUDIO_HANDLER_AVAILABLE:
self._audio_handler = AudioHandler()
if _GENERATOR_MANAGER_AVAILABLE:
self._generator_mgr = GeneratorManager(llm_engine, None)
def _remember_route(self, chat_id: str, route: Optional[Dict[str, Any]] = None):
if not route:
return
clean = {
"platform": route.get("platform") or Config.PLATFORM,
"seen_at": time.time(),
}
self._chat_routes[str(chat_id)] = clean
try:
if db:
db.remember_contact_route(chat_id, clean["platform"])
except Exception:
pass
def _resolve_route(self, chat_id: str, route: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
if route:
self._remember_route(chat_id, route)
return route
remembered = self._chat_routes.get(str(chat_id))
if remembered:
return remembered
try:
if db:
persisted = db.get_contact_route(chat_id)
if persisted:
route = {"platform": persisted}
self._chat_routes[str(chat_id)] = route
return route
except Exception:
pass
return {"platform": Config.PLATFORM}
def _brand_store(self, clinic: Dict[str, Any]) -> Optional["BrandAssetStore"]:
if not _BRAND_ASSETS_AVAILABLE:
return None
clinic_name = clinic.get("name") or clinic.get("tagline") or Config.SECTOR or "conny"
brand_key = clinic_name
try:
remembered_slug = (db.recall("instance_slug") or "").strip() if db else ""
meta = _load_instance_metadata()
meta_slug = str(meta.get("name") or "").strip() if isinstance(meta, dict) else ""
brand_key = remembered_slug or meta_slug or clinic_name
except Exception:
brand_key = clinic_name
try:
return BrandAssetStore(Config.BRAND_ASSETS_BASE_DIR, brand_key)
except Exception as e:
log.warning(f"[brand] no pude abrir el vault: {e}")
return None
async def initialize(self):
"""Inicializa todos los componentes."""
init_database()
init_llm()
init_auth()
self.admin_learning = AdminLearningEngine(db)
self.simulator = SimulationEngine(self)
self.reasoning = ReasoningEngine(llm_engine)
self.generator = ResponseGenerator(llm_engine, learning_engine=self.admin_learning)
init_calendar()
await init_mcp()
try:
await init_task_manager()
except NameError:
log.warning("[startup] init_task_manager no disponible — saltando")
except Exception as _tm_err:
log.warning(f"[startup] init_task_manager error: {_tm_err}")
# Nova governance bridge
if _NOVA_AVAILABLE and Config.NOVA_ENABLED:
nova_guard = init_nova()
# Verificar si Nova está activo
client = get_client()
if client:
nova_alive = await client.health_check()
if nova_alive:
log.info("[nova] conectado y activo")
# Auto-crear agente si no hay token configurado
if not Config.NOVA_TOKEN:
clinic = db.get_clinic()
token_id = await setup_conny_agent(
client, clinic.get("name", "Clinica"),
"Conny"
)
if token_id:
log.info(f"[nova] agente creado automáticamente: {token_id[:16]}...")
else:
log.warning("[nova] server no disponible — modo degradado")
# Restaurar credenciales WhatsApp desde DB (si fueron configuradas antes)
try:
clinic = db.get_clinic()
wa_phone_id = clinic.get("wa_phone_id", "")
wa_access_token = clinic.get("wa_access_token", "")
wa_verify_token = clinic.get("wa_verify_token", "")
if wa_phone_id and wa_access_token:
WhatsAppConnector.apply_to_config(
wa_phone_id, wa_access_token, wa_verify_token
)
log.info(f"[wa] credenciales restauradas desde DB: {wa_phone_id[:8]}...")
except Exception as e:
log.warning(f"[wa] no se pudieron restaurar credenciales: {e}")
try:
ensure_minimum_business_state()
except Exception as exc:
log.warning(f"[business_bootstrap] error: {exc}")
self.admin_learning = AdminLearningEngine(db)
self.simulator = SimulationEngine(self)
self.reasoning = ReasoningEngine(llm_engine)
self.generator = ResponseGenerator(llm_engine, learning_engine=self.admin_learning)
self.self_improvement = None
try:
self.self_improvement = SelfImprovementEngine(llm_engine)
except (NameError, AttributeError):
log.warning("[startup] SelfImprovementEngine no disponible")
if Config.CONNY_CORE_ENABLED and _CONNY_CORE_AVAILABLE:
try:
self._conversation_registry = PersonaRegistry(Config.CONNY_CORE_PERSONAS_DIR)
self._conversation_engine = ConversationEngine(self._conversation_registry)
log.info("[conny_core] conversation core OK")
except Exception as _mcore_err:
self._conversation_registry = None
self._conversation_engine = None
log.warning(f"[conny_core] no se pudo activar el core nuevo: {_mcore_err}")
else:
self._conversation_registry = None
self._conversation_engine = None
log.info("[conny_core] desactivado o no disponible")
# V8.0 — inicializar sistemas de humanidad real
# CRÍTICO: envuelto en try/except para que un fallo en V8
# NUNCA crashee el bot principal
try:
init_v8_systems()
log.info("[v8] core OK")
except Exception as _ev8:
log.warning(f"[v8] init_v8_systems falló — V8 degradado: {_ev8}")
try:
init_v8_extended_systems()
log.info("[v8] extended OK")
except Exception as _ev8ext:
log.warning(f"[v8] init_v8_extended falló: {_ev8ext}")
# _patch_admin_dispatcher se llama SOLO en lifespan
# V7.0 — activable por flag para rollout seguro
v7_enabled = os.getenv("CONNY_V7_ENABLED", "false").lower() in ("1", "true", "yes", "on")
if v7_enabled:
try:
from v7.orchestrator import ConnyOrchestrator
self._orchestrator = ConnyOrchestrator(llm_engine, db)
log.info("[v7] orquestador activado por CONNY_V7_ENABLED")
except Exception as _v7_init:
self._orchestrator = None
log.warning(f"[v7] no se pudo activar el orquestador, fallback a generator: {_v7_init}")
else:
self._orchestrator = None
log.info("[v7] orquestador desactivado — usando generator clásico")
# Programar auto-mejora periódica
task_manager.schedule_task(
"self_improve",
{},
scheduled_for=datetime.now() + timedelta(hours=1)
)
log.info("═══ CONNY V9.6.0 INICIALIZADA ═══")
asyncio.create_task(self._schedule_daily_report())
async def _schedule_daily_report(self):
"""Programa el reporte diario a las 8am."""
while True:
try:
now = now_col()
# Calcular segundos hasta las 8am del día siguiente
next_8am = now.replace(hour=8, minute=0, second=0, microsecond=0)
if now.hour >= 8:
next_8am = next_8am + timedelta(days=1)
wait_seconds = (next_8am - now).total_seconds()
await asyncio.sleep(wait_seconds)
# Programar el reporte
if task_manager:
task_manager.schedule_task(
task_type="report",
data={"type": "daily"},
scheduled_for=datetime.now(),
priority=5
)
log.info("[daily_report] programado")
except Exception as e:
log.error(f"[daily_report] {e}")
await asyncio.sleep(3600)
async def _notify_hot_lead(self, clinic: Dict, message: str):
"""Notifica al admin cuando un lead tiene closing_score >= 75%."""
try:
admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
for admin_id in admin_ids[:2]:
await self._send_message(admin_id, message)
except Exception as e:
log.warning(f"[hot_lead] {e}")
def _build_conversation_core_clinic(self, clinic: Dict[str, Any], channel: str = "") -> Dict[str, Any]:
core_clinic = dict(clinic or {})
sector = _normalize_conv_text(str(core_clinic.get("sector") or Config.SECTOR or ""))
channel_norm = _normalize_conv_text(channel or core_clinic.get("channel") or Config.PLATFORM or "")
if sector == "estetica" and not core_clinic.get("persona_key"):
core_clinic["persona_key"] = "estetica_whatsapp"
if channel_norm:
core_clinic["channel"] = channel_norm
return core_clinic
def _try_conversation_core(
self,
*,
clinic: Dict[str, Any],
user_msg: str,
history: Optional[List[Dict[str, Any]]] = None,
is_admin: bool = False,
channel: str = "",
) -> Optional[List[str]]:
if not Config.CONNY_CORE_ENABLED or not self._conversation_engine:
return None
try:
core_clinic = self._build_conversation_core_clinic(clinic, channel)
result = self._conversation_engine.handle(
clinic=core_clinic,
user_msg=user_msg,
history=history or [],
is_admin=is_admin,
channel=channel,
)
if result.handled and result.bubbles:
return [bubble.strip() for bubble in result.bubbles if str(bubble).strip()]
except Exception as exc:
log.warning(f"[conny_core] fallo en handle(): {exc}")
return None
def _llm_runtime_available(self) -> bool:
"""Indica si Conny tiene un runtime LLM utilizable para priorizarlo sobre fallbacks."""
try:
if llm_engine:
return True
except Exception:
pass
try:
generator = getattr(self, "generator", None)
if generator and getattr(generator, "llm", None):
return True
except Exception:
pass
provider_keys = (
getattr(Config, "GEMINI_API_KEY", ""),
getattr(Config, "GEMINI_API_KEY_2", ""),
getattr(Config, "GEMINI_API_KEY_3", ""),
getattr(Config, "OPENROUTER_API_KEY", ""),
getattr(Config, "GROQ_API_KEY", ""),
)
return any(bool(key) for key in provider_keys)
def _handle_patient_meta_question(
self,
clinic: Dict,
chat_id: str = "",
user_msg: str = "",
history: Optional[List[Dict[str, Any]]] = None,
) -> List[str]:
clinic_name = clinic.get("name", "la clínica")
services = clinic.get("services", [])
channel = ""
if chat_id:
try:
channel = str(self._resolve_route(chat_id).get("platform") or "")
except Exception:
channel = ""
core_bubbles = self._try_conversation_core(
clinic=clinic,
user_msg=user_msg or "",
history=history or [],
is_admin=False,
channel=channel,
)
if core_bubbles:
return core_bubbles
normalized_user = _normalize_conv_text(user_msg or "")
prior_identity = any(
any(marker in _normalize_conv_text(str(msg.get("content") or "")) for marker in (
"recepcionista virtual",
"asesora virtual",
"soy conny",
"trabaja por tu negocio",
"trabajo por este canal",
))
for msg in (history or [])
if msg.get("role") == "assistant"
)
if prior_identity:
if any(marker in normalized_user for marker in ("eres una ia", "eres ia", "eres una persona", "persona real", "eres un bot", "eres bot")):
return [
f"Sigo siendo Conny, la asesora virtual de {clinic_name}",
"Soy una IA hecha para orientar, responder y ayudarte a avanzar sin que todo dependa de una persona pegada al chat",
]
if any(marker in normalized_user for marker in ("quién eres", "quien eres", "qué eres", "que eres")):
return [
f"Soy Conny, la asesora virtual de {clinic_name}",
"Soy una IA pensada para atender bien, sostener la conversación y ayudarte con información, disponibilidad y siguiente paso",
]
try:
personality = self.generator._get_default_personality(clinic)
except Exception:
personality = None
if personality:
return self.generator._build_identity_probe_bubbles(clinic, personality, user_msg or "")
if owner_style_controller:
fallback = owner_style_controller.get_fallback_template(
is_admin=False,
chat_id=chat_id,
clinic=clinic,
)
if fallback:
return [part.strip() for part in fallback.split("|||") if part.strip()]
services_text = ", ".join(services[:2]) if services else "citas e información"
return [
f"Soy Conny, la asesora virtual de {clinic_name}",
f"Soy una IA pensada para ayudarte con {services_text}, horarios y orientación inicial",
"Si quieres probarme, escríbeme el nombre de tu negocio y te muestro cómo trabajaría contigo",
]
def _build_demo_patient_clinic(self, clinic: Dict[str, Any]) -> Dict[str, Any]:
demo_clinic = dict(clinic or {})
clinic_name = str(demo_clinic.get("name") or "").strip()
sector = str(demo_clinic.get("sector") or "").strip().lower()
env_sector = str(Config.SECTOR or Config.DEMO_SECTOR or "").strip().lower()
configured_demo_name = str(Config.DEMO_BUSINESS_NAME or "").strip()
normalized_demo_name = _normalize_conv_text(configured_demo_name)
if normalized_demo_name in {"clinica demo", "clínica demo", "demo", "nova"}:
configured_demo_name = ""
# FIX: En modo demo para leads nuevos (sin negocio conocido), NO mostrar nombre de negocio
# Solo usar DEMO_BUSINESS_NAME si es un negocio real configurado, no "demo" genérico
if Config.DEMO_MODE and configured_demo_name and normalized_demo_name not in {"clinica demo", "clínica demo", "demo", "nova"}:
demo_clinic["name"] = configured_demo_name
elif clinic_name.lower() == "nova":
demo_clinic["name"] = "la clínica"
elif not clinic_name.strip():
# En demo mode para leads nuevos, usar "tu clínica" en vez de nombre específico
demo_clinic["name"] = "la clínica"
if not sector or sector == "otro":
demo_clinic["sector"] = env_sector or "estetica"
if not demo_clinic.get("platform"):
demo_clinic["platform"] = str(Config.PLATFORM or "").strip().lower()
return demo_clinic
def _demo_should_use_patient_chat_path(self, user_msg: str) -> bool:
normalized = _normalize_conv_text(user_msg or "")
if not normalized:
return False
token_set = set(re.findall(r"[a-z0-9áéíóúüñ]+", normalized))
def _has_marker(marker: str) -> bool:
marker_norm = _normalize_conv_text(marker or "")
if not marker_norm:
return False
if " " in marker_norm:
return marker_norm in normalized
return marker_norm in token_set
owner_exceptions = (
"config", "demo", "prueba", "probar", "entrenar", "enseñar",
"cómo funcionas", "como funcionas", "qué haces", "que haces",
"quiero una demo", "quiero demo", "hagamos una demo", "simulacion",
"simulación", "modo demo", "tengo un negocio", "tengo una empresa",
"what is this", "what do you do", "who are you", "english only",
"i don't talk spanish", "i dont talk spanish", "i don't understand", "i dont understand",
"me mandaron", "me enviaron", "me pasaron", "me recomendaron",
"no se que es", "no sé qué es", "que es esto", "qué es esto",
"como funciona esto", "cómo funciona esto", "para que sirve", "para qué sirve",
"me dijeron que", "alguien me dijo", "me lo recomendaron",
)
if any(_has_marker(exc) for exc in owner_exceptions):
return False
if any(_has_marker(marker) for marker in ("5 x 4", "5x4", "capital de francia", "capital de")):
return False
if any(
_has_marker(marker)
for marker in (
"cuanto es",
"cuánto es",
"quien te hizo",
"quién te hizo",
"para que",
"para qué",
"aceptas audios",
"aceptas pdf",
)
):
return False
# Keywords de cliente/lead (mensaje de alguien preguntando como cliente)
client_intent_markers = (
# Servicios
"botox", "relleno", "rellenos", "laser", "láser", "facial",
"tratamiento", "tratamientos", "procedimiento", "procedimientos",
"cita", "agenda", "agendar", "disponibilidad", "valoracion", "valoración",
"consulta", "sesion", "sesión", "toxina", "hifu", "prp", "hidrafacial",
# Precios
"precio", "costo", "cuánto", "cuanto", "tarifa",
# Ubicación/horario
"horario", "hora", "abierta", "abierto", "cerrado", "ubicación", "dirección",
# Agendamiento
"reservar", "reserva", "mañana", "hoy", "viernes", "lunes", "sábado",
"tarde", "noche", "pronto", "primavera", "urgencia", "emergencia",
# generic lead
"quiero", "necesito", "busco", "me interesa", "información",
"saber", "acerca", "sobre", "qué tienen", "que tienen", "servicios",
)
if any(_has_marker(token) for token in client_intent_markers):
return True
if any(_has_marker(marker) for marker in ("cuanto es", "cuánto es", "cuanto cuestas", "cuánto cuestas", "cuanto vale", "cuánto vale", "que es", "qué es")):
if not any(_has_marker(token) for token in client_intent_markers):
return False
owner_demo_markers = (
"hola",
"hola buenas",
"buenas",
"buenas tardes",
"buenos dias",
"buenos días",
"buenas noches",
"hey",
"holi",
"quien eres",
"quién eres",
"que eres",
"qué eres",
"que haces",
"qué haces",
"como funcionas",
"cómo funcionas",
"como trabajas",
"cómo trabajas",
"para que",
"para qué",
"por que",
"por qué",
"quien te hizo",
"quién te hizo",
"como te hicieron",
"cómo te hicieron",
"aceptas audios",
# Prospect B2B markers (solo para pregunta de precio, NO para cambiar el flujo de demo)
"cuanto cuestas",
"cuánto cuestas",
"cuanto cobras",
"cuánto cobras",
"cuanto vale",
"cuánto vale",
"me mandaron",
"me pasaron",
"aceptas audio",
"aceptas pdf",
"lees pdf",
"lees archivos",
"me mandaron tu numero",
"me mandaron tu número",
"me pasaron tu numero",
"me pasaron tu número",
"quiero probarte",
"me gustaria probarte",
"me gustaría probarte",
"quiero una demo",
"quiero demo",
"tengo un negocio",
"tengo una empresa",
"me lo recomendaron",
"me dijeron que te escribiera",
"me dejaron probarte",
"me pasaron este numero",
"me pasaron este número",
"para mi negocio",
"para mi empresa",
"what is this",
"what do you do",
"who are you",
"english only",
"i don't talk spanish",
"i dont talk spanish",
"i don't understand",
"i dont understand",
)
if any(_has_marker(marker) for marker in owner_demo_markers):
return False
patient_like_markers = (
"botox",
"relleno",
"rellenos",
"laser",
"láser",
"cita",
"agenda",
"agendar",
"disponibilidad",
"precio",
"cuanto",
"cuánto",
"valor",
"tratamiento",
"procedimiento",
"consulta",
"quiero informacion",
"quiero información",
"quiero una cita",
"me quiero valorar",
"valoracion",
"valoración",
"me interesa el botox",
"me interesa botox",
"me interesa el tratamiento",
"me interesa el procedimiento",
"quiero info sobre",
"quiero saber del tratamiento",
"quiero reservar",
"quiero una reserva",
"quiero apartar",
"me duele",
"me preocupa",
"me mandaron por botox",
)
return any(_has_marker(marker) for marker in patient_like_markers)
def _handle_patient_off_topic(self, clinic: Dict, chat_id: str = "", user_msg: str = "") -> List[str]:
"""Maneja mensajes fuera de tema con respuestas variadas según el tipo de off-topic."""
if owner_style_controller:
fallback = owner_style_controller.get_fallback_template(
is_admin=False,
chat_id=chat_id,
clinic=clinic,
)
if fallback:
return [part.strip() for part in fallback.split("|||") if part.strip()]
services = clinic.get("services", [])
focus = ", ".join(services[:2]) if services else "servicios, horarios o citas"
normalized = (user_msg or "").lower()
# Respuestas diferenciadas según el tipo de off-topic
if any(t in normalized for t in ["película", "pelicula", "movie", "cine", "serie", "netflix"]):
return [
"eso ya se sale de lo que manejo por acá",
f"si quieres, te ayudo con {focus} o agendamos una cita"
]
if any(t in normalized for t in ["clima", "tiempo", "lluvia", "calor", "frío", "frio"]):
return [
"el clima no lo manejo desde este chat",
f"pero si necesitas {focus} o información de citas, ahí sí te ayudo"
]
if any(t in normalized for t in ["comida", "restaurante", "almuerzo", "cena", "desayuno"]):
return [
"eso de comida no lo manejo por aquí",
f"te puedo ayudar con {focus} si quieres"
]
if any(t in normalized for t in ["música", "musica", "canción", "cancion", "artista", "banda"]):
return [
"la música no es algo que maneje desde acá",
f"pero para {focus} o citas, ahí sí te oriento"
]
if any(t in normalized for t in ["bitcoin", "crypto", "cripto", "trading", "crypto"]):
return [
"eso de criptos no lo manejo por este canal",
f"si quieres información de {focus}, ahí te ayudo"
]
if any(t in normalized for t in ["fútbol", "futbol", "messi", "deporte", "partido"]):
return [
"el deporte no es algo que maneje desde aquí",
f"pero si es por {focus} o citas, te ayudo con gusto"
]
# Fallback genérico con variación
variants = [
["eso se sale un poco de lo que manejo por acá", f"si quieres, te ayudo con {focus} o con una cita"],
["eso no lo manejo desde este chat", f"pero para {focus} o información de citas, ahí sí te ayudo"],
["eso ya es por fuera de lo que hago acá", f"si necesitas {focus}, te ayudo sin problema"],
]
import hashlib
idx = int(hashlib.md5(normalized.encode()).hexdigest()[:2], 16) % len(variants)
return variants[idx]
async def _download_telegram_binary(self, file_id: str) -> Tuple[bytes, str]:
async with httpx.AsyncClient(timeout=20.0) as client:
r = await client.get(
f"https://api.telegram.org/bot{Config.TELEGRAM_TOKEN}/getFile",
params={"file_id": file_id},
)
data = r.json()
file_path = data.get("result", {}).get("file_path", "")
if not file_path:
raise RuntimeError("Telegram no devolvió file_path")
dl = await client.get(
f"https://api.telegram.org/file/bot{Config.TELEGRAM_TOKEN}/{file_path}"
)
dl.raise_for_status()
return dl.content, Path(file_path).name or "telegram_asset.bin"
async def _download_whatsapp_cloud_binary(self, media_id: str) -> Tuple[bytes, str, str]:
async with httpx.AsyncClient(timeout=20.0) as client:
meta = await client.get(
f"https://graph.facebook.com/v20.0/{media_id}",
headers={"Authorization": f"Bearer {Config.WA_ACCESS_TOKEN}"},
)
meta.raise_for_status()
payload = meta.json() if meta.content else {}
media_url = payload.get("url", "")
if not media_url:
raise RuntimeError("WhatsApp Cloud no devolvió URL del media")
dl = await client.get(
media_url,
headers={"Authorization": f"Bearer {Config.WA_ACCESS_TOKEN}"},
)
dl.raise_for_status()
filename = payload.get("id", media_id)
mime_type = payload.get("mime_type", "application/octet-stream")
return dl.content, filename, mime_type
async def _admin_ingest_assets(
self,
chat_id: str,
text: str,
attachments: List[Dict[str, Any]],
clinic: Dict[str, Any],
) -> Optional[List[str]]:
if not attachments:
return None
store = self._brand_store(clinic)
if not store:
return ["No pude abrir el vault de marca en esta instalación."]
saved_items: List[Dict[str, Any]] = []
extracted_blocks: List[str] = []
for item in attachments:
kind = item.get("kind", "asset")
platform = item.get("platform", Config.PLATFORM)
caption = (item.get("caption") or "").strip()
filename = item.get("filename") or ("logo.png" if kind == "image" else "document.bin")
mime_type = item.get("mime_type", "")
raw_bytes = item.get("bytes")
try:
if platform == "telegram" and item.get("file_id"):
raw_bytes, downloaded_name = await self._download_telegram_binary(item["file_id"])
if not item.get("filename"):
filename = downloaded_name
elif platform == "whatsapp_cloud" and item.get("media_id"):
raw_bytes, downloaded_name, downloaded_mime = await self._download_whatsapp_cloud_binary(item["media_id"])
if not item.get("filename"):
filename = downloaded_name
if not mime_type:
mime_type = downloaded_mime
elif item.get("base64"):
import base64 as _b64
raw_bytes = _b64.b64decode(item["base64"])
elif isinstance(raw_bytes, str):
raw_bytes = raw_bytes.encode("utf-8")
except Exception as e:
log.warning(f"[brand] fallo descargando adjunto {filename}: {e}")
continue
if not raw_bytes:
continue
lower_name = f"{filename} {caption}".lower()
if any(tag in lower_name for tag in ["logo", "isotipo", "brand", "identidad", "manual", "paleta", "colores"]):
category = "brand"
elif kind == "image":
category = "visual"
else:
category = "knowledge"
saved = store.save_binary_asset(
filename=filename,
data=raw_bytes,
mime_type=mime_type,
source=f"{platform}_attachment",
category=category,
caption=caption,
)
if saved.manifest_entry:
saved_items.append(saved.manifest_entry)
if saved.extracted_text and len(saved.extracted_text.strip()) > 20:
extracted_blocks.append(saved.extracted_text.strip())
if category == "brand" and any(tag in lower_name for tag in ["logo", "isotipo"]):
db.remember("brand_logo_asset", saved.saved_path, "identity")
extra_note = (text or "").strip()
if extra_note:
note_saved = store.save_text_note(
"admin_brand_note",
extra_note,
source="admin_chat",
category="knowledge",
)
if note_saved.manifest_entry:
saved_items.append(note_saved.manifest_entry)
if len(extra_note) > 40:
extracted_blocks.append(extra_note)
if not saved_items and not extracted_blocks:
return ["Recibí el adjunto, pero no pude guardarlo bien. Intenta de nuevo."]
if kb and extracted_blocks:
try:
kb.append("\n\n".join(block for block in extracted_blocks if block.strip()))
except Exception as e:
log.warning(f"[brand] no pude anexar al KB: {e}")
manifest = store.manifest()
db.remember("brand_assets_path", str(store.root), "identity")
db.remember("brand_assets_count", str(len(manifest.get("assets", []))), "identity")
db.remember("brand_identity_summary", store.latest_identity_summary(), "identity")
db.remember("brand_last_upload_at", datetime.now().isoformat(), "identity")
latest = saved_items[-4:]
latest_lines = "\n".join(
f"• {item.get('filename', 'asset')} [{item.get('category', 'asset')}]"
for item in latest
)
return [
"Listo. Ya guardé esos activos en el vault permanente de la marca.",
f"Ruta: {store.root}\nArchivos recientes:\n{latest_lines}",
"Desde ahora los conservo por instancia y los uso como contexto oficial. Si el adjunto tenía texto, ya quedó anexado al conocimiento activo.",
]
async def _admin_brand_status(self, clinic: Dict[str, Any]) -> List[str]:
store = self._brand_store(clinic)
if not store:
return ["El vault de marca no está disponible en esta instalación."]
summary = "\n".join(store.summary_lines())
return [
"Vault de marca activo.",
summary,
"Puedes mandarme logos, manuales, identidad de marca, PDFs, DOCX, TXT, MD o JSON. Lo guardo por instancia y no lo olvido.",
]
async def process_message(self, chat_id: str, text: str,
is_audio: bool = False,
attachments: Optional[List[Dict[str, Any]]] = None,
route: Optional[Dict[str, Any]] = None,
is_simulation: bool = False) -> List[str]:
"""Procesa un mensaje delegando a los gestores especializados."""
start_time = time.time()
attachments = attachments or []
self._remember_route(chat_id, route)
try:
clinic = db.get_clinic()
admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
is_admin = (chat_id in admin_ids or db.get_admin(chat_id) is not None)
# En modo simulación, tratamos al admin como un paciente real
effective_is_admin = is_admin and not is_simulation
# 1. Auth check (ignorar en simulación)
if not is_simulation and auth_engine and auth_engine.is_auth_message(chat_id, text):
result = await auth_engine.process(chat_id, text)
if result: return result
# 1.5. Slash commands (works in all modes)
if text.strip().startswith("/"):
try:
from conny_commands import get_command_handler
_cmd_h = get_command_handler(getattr(self, "_instance_id", "default"))
_cmd_result = await _cmd_h.handle(chat_id, text.strip(), is_admin=False, clinic=clinic, db=db)
if _cmd_result:
return _cmd_result
except Exception:
pass
# 2. MODO DEMO
if Config.DEMO_MODE:
return await self.demo_mgr.handle(chat_id, text, clinic, attachments=attachments)
# 3. Admins / Setup
if not clinic.get("setup_done") or effective_is_admin:
return await self.admin_mgr.handle(chat_id, text, clinic, attachments=attachments)
# 4. PACIENTES (Producción)
history = db.get_history(chat_id)
conv_state = db.get_conversation_state(chat_id)
return await self.production_mgr.handle(chat_id, text, clinic, history, conv_state)
except Exception as e:
log.error(f"Error processing message from {chat_id}: {e}", exc_info=True)
db.record_metric("error", "message_processing", 1, {"error": str(e)})
# Recuperación inteligente: intentar respuesta LLM directa como fallback
try:
if llm_engine and text and text.strip():
clinic = db.get_clinic()
biz_name = clinic.get("name", "") if clinic else ""
fallback_sys = f"Eres Conny, recepcionista virtual{' de ' + biz_name if biz_name else ''}. Responde de forma breve, cálida y natural. Si no tienes contexto suficiente, pide al usuario que te cuente más."
fallback_r, _ = await llm_engine.complete(
[{"role": "system", "content": fallback_sys}, {"role": "user", "content": text}],
model_tier="fast", temperature=0.8, max_tokens=200, use_cache=False,
)
if fallback_r and fallback_r.strip():
return self._split_bubbles(fallback_r, chat_id=chat_id)
except Exception:
pass
# Último recurso: respuesta genérica humana (nunca decir "cruce de cables")
import random as _r
_fallbacks = [
"cuéntame un poco más, no te alcancé a entender bien",
"perdona, me perdí un momento ||| qué me decías?",
"disculpa, no te pillé bien ||| me repites?",
]
return [_r.choice(_fallbacks)]
async def _handle_demo_message(self, chat_id: str, text: str,
clinic: Dict,
attachments: Optional[List[Dict[str, Any]]] = None) -> List[str]:
"""
MODO DEMO v3 — Experiencia de intriga progresiva.
Conny NO se presenta como IA ni da un pitch.
Entra directo al personaje y revela capacidades una a una.
TTL: sesión independiente por persona (DEMO_SESSION_TTL segundos).
"""
import base64 as _b64
import random as _r
attachments = attachments or []
# ── Extracción de texto de documentos adjuntos ───────────────────────
# Si el owner manda un PDF/doc sin caption, extraemos su texto y lo
# usamos como si hubiera sido escrito en el mensaje.
_doc_extracted_text = ""
_has_incoming_doc = False
for _att in attachments:
_att_kind = _att.get("kind", "")
_att_mime = _att.get("mime_type", "")
_is_doc = _att_kind == "document" or "pdf" in _att_mime or "text" in _att_mime or "word" in _att_mime or "docx" in _att_mime
if not _is_doc and _att_kind not in ("document",):
continue
_has_incoming_doc = True
# Intentar extraer texto del binario
try:
_raw = _att.get("bytes") or b""
if not _raw and _att.get("base64"):
_raw = _b64.b64decode(_att["base64"])
if not _raw and _att.get("file_id") and _att.get("platform") == "telegram":
_raw, _ = await self._download_telegram_binary(_att["file_id"])
if not _raw and _att.get("media_id") and _att.get("platform") == "whatsapp_cloud":
_raw, _, _ = await self._download_whatsapp_cloud_binary(_att["media_id"])
if _raw:
try:
import pdfplumber as _pp, io as _io
with _pp.open(_io.BytesIO(_raw)) as _pdf:
_pages = [p.extract_text() or "" for p in _pdf.pages[:6]]
_doc_extracted_text = "\n".join(filter(None, _pages))[:2000]
except Exception:
# Fallback: intentar leer como texto plano
try:
_doc_extracted_text = _raw.decode("utf-8", errors="ignore")[:2000]
except Exception:
pass
except Exception:
pass
break # Solo procesamos el primer documento
# Si llegó un doc, enriquecemos el texto con su contenido extraído
if _has_incoming_doc and not text.strip():
if _doc_extracted_text.strip():
text = f"[documento adjunto]\n{_doc_extracted_text.strip()}"
else:
text = "[documento adjunto]"
if not hasattr(self, "_emoji_chats_off"):
self._emoji_chats_off = set()
# ── Gestión de sesión via SessionManager ───────────────────────────────
if _SESSION_MANAGER_AVAILABLE and hasattr(self, "_session_mgr"):
is_new, keys_del = self._session_mgr.touch_and_cleanup(chat_id)
if is_new:
for k in keys_del:
del self._demo_sessions[k]
try:
with db._conn() as c:
c.execute("DELETE FROM conversations WHERE chat_id=?", (chat_id,))
except Exception: pass
sk = f"demo_{chat_id}"
else:
now = time.time()
ttl = Config.DEMO_SESSION_TTL
sk = f"demo_{chat_id}"
last_seen = self._demo_sessions.get(sk + "_ts", 0)
is_new = (now - last_seen) > ttl
self._demo_sessions[sk + "_ts"] = now
self._demo_sessions = {
k: v for k, v in self._demo_sessions.items()
if not k.endswith("_ts") or (now - v) < ttl * 2
}
if is_new:
keys_del = [k for k in list(self._demo_sessions) if k.startswith(sk+"_") and not k.endswith("_ts")]
for k in keys_del: del self._demo_sessions[k]
try:
with db._conn() as c:
c.execute("DELETE FROM conversations WHERE chat_id=?", (chat_id,))
except Exception: pass
history = db.get_history(chat_id) if db else []
now_dt = now_col()
moment = "mañana" if now_dt.hour < 12 else ("tarde" if now_dt.hour < 19 else "noche")
# Claves de sesión
bname_key = sk + "_name"
bctx_key = sk + "_ctx"
bfound_key = sk + "_found"
burl_key = sk + "_url" # URL del negocio encontrada en web
btrick_key = sk + "_trick"
bpersona_key= sk + "_persona"
btone_key = sk + "_tone" # tono detectado: SALUD PREMIUM | PREMIUM | SALUD | RETAIL | GENERAL
bmodel_key = sk + "_model" # proveedor LLM activo: auto|groq|gemini|openrouter
blang_key = sk + "_owner_lang" # idioma dominante del dueño en demo
bowner_key = sk + "_owner_name" # nombre del dueño/prospecto cuando lo comparte
blearn_key = sk + "_learn" # modo aprendizaje manual: cuántas preguntas llevamos
bsim_key = sk + "_sim_mode" # modo simulación cliente en el mismo chat del dueño
bready_key = sk + "_ready_customer" # el dueño ya puede escribir como cliente
business_name = self._demo_sessions.get(bname_key, "")
business_ctx = self._demo_sessions.get(bctx_key, "")
found_online = self._demo_sessions.get(bfound_key, False)
persona = self._demo_sessions.get(bpersona_key, "amigable")
demo_model_pref= self._demo_sessions.get(bmodel_key, "auto") # auto|groq|gemini|openrouter
owner_lang = self._demo_sessions.get(blang_key, "es")
owner_name = self._demo_sessions.get(bowner_key, "")
sim_mode_active = bool(self._demo_sessions.get(bsim_key, False))
ready_for_customer = bool(self._demo_sessions.get(bready_key, False))
llm_runtime_ready = self._llm_runtime_available()
def _detect_demo_owner_language(raw_text: str, current_lang: str = "es") -> str:
normalized = _normalize_conv_text(raw_text or "")
if not normalized:
return current_lang or "es"
explicit_en = (
"just english sorry",
"sorry just english",
"english sorry",
"english only",
"speak english",
"speak in english",
"i dont speak spanish",
"i don t speak spanish",
"i dont talk spanish",
"i don t talk spanish",
"no spanish",
"only english",
"what is this",
"sorry what is this",
"i dont understand",
"i don t understand",
"what did you say",
"what did u say",
"thats not my business",
"that s not my business",
"thats not us",
"that s not us",
"wrong business",
"wrong company",
)
explicit_pt = (
"só portugues",
"so portugues",
"falo portugues",
"nao falo espanhol",
"não falo espanhol",
)
if any(token in normalized for token in explicit_en):
return "en"
if any(token in normalized for token in explicit_pt):
return "pt"
try:
detected = multilingual_handler.detect(raw_text) if multilingual_handler else MultilingualHandler().detect(raw_text)
except Exception:
detected = "es"
# Si ya estamos en inglés/portugués, no volver a español por mensajes cortos tipo "ok", "yes", "reset".
if current_lang in {"en", "pt"} and detected == "es" and len(normalized.split()) <= 6:
return current_lang
return detected if detected in {"es", "en", "pt"} else (current_lang or "es")
owner_lang = _detect_demo_owner_language(text, owner_lang)
self._demo_sessions[blang_key] = owner_lang
def _extract_demo_owner_name(raw_text: str, current_name: str = "") -> str:
raw = (raw_text or "").strip()
if not raw:
return current_name or ""
normalized = _normalize_conv_text(raw)
if not normalized:
return current_name or ""
businessish_markers = (
"negocio", "empresa", "clinic", "clinica", "clínica", "consultorio",
"tienda", "salon", "salón", "spa", "business", "company",
"estamos", "ubicad", "located", "medellin", "medellín", "colombia",
)
if any(marker in normalized for marker in businessish_markers):
return current_name or ""
patterns = (
r"(?:mi nombre es|me llamo|soy)\s+([A-ZÁÉÍÓÚÑ][A-Za-zÁÉÍÓÚáéíóúÑñ'-]+(?:\s+[A-ZÁÉÍÓÚÑ][A-Za-zÁÉÍÓÚáéíóúÑñ'-]+){0,2})\b",
r"(?:my name is|i am|i'm)\s+([A-Z][A-Za-z'-]+(?:\s+[A-Z][A-Za-z'-]+){0,2})\b",
r"(?:meu nome e|meu nome é|eu sou)\s+([A-ZÁÉÍÓÚÂÊÔÃÕÇ][A-Za-zÁÉÍÓÚáéíóúÂÊÔÃÕÇâêôãõç'-]+(?:\s+[A-ZÁÉÍÓÚÂÊÔÃÕÇ][A-Za-zÁÉÍÓÚáéíóúÂÊÔÃÕÇâêôãõç'-]+){0,2})\b",
)
for pattern in patterns:
match = re.search(pattern, raw, re.IGNORECASE)
if not match:
continue
candidate = match.group(1).strip(" .,;:!?\"'")
if not candidate or any(ch.isdigit() for ch in candidate):
continue
candidate_norm = _normalize_conv_text(candidate)
if any(marker in candidate_norm for marker in ("clinica", "clínica", "clinic", "negocio", "empresa", "business", "company")):
continue
return candidate
return current_name or ""
owner_name = _extract_demo_owner_name(text, owner_name)
if owner_name:
self._demo_sessions[bowner_key] = owner_name
def _lang_text(es_text: str, en_text: str, pt_text: Optional[str] = None) -> str:
if owner_lang == "en":
return en_text
if owner_lang == "pt" and pt_text is not None:
return pt_text
return es_text
def _owner_confusion_or_language_signal(raw_text: str) -> bool:
normalized = _normalize_conv_text(raw_text or "")
if not normalized:
return False
signals = (
"just english sorry", "sorry just english", "english sorry",
"english only", "speak english", "speak in english", "only english",
"i dont speak spanish", "i don t speak spanish",
"i dont talk spanish", "i don t talk spanish",
"what is this", "sorry what is this",
"i dont understand", "i don t understand",
"what did you say", "what did u say",
"thats not my business", "that s not my business",
"that is not my business", "not my business",
"thats not us", "that s not us", "that is not us", "wrong business",
"wrong company", "wrong one", "not the right one",
"no hablo español", "no hablo espanol", "solo ingles", "solo inglés",
)
return any(signal in normalized for signal in signals)
def _recent_demo_assistant_text(limit: int = 6) -> str:
recent = []
for msg in (history or [])[-limit:]:
if msg.get("role") == "assistant":
content = str(msg.get("content") or "").strip()
if content:
recent.append(content)
return " ||| ".join(recent)
def _owner_already_knows_ai_identity() -> bool:
recent_text = _normalize_conv_text(_recent_demo_assistant_text())
if not recent_text:
return False
identity_signals = (
"soy una ia",
"soy un bot",
"asesora virtual",
"asistente virtual",
)
return any(signal in recent_text for signal in identity_signals)
def _owner_already_got_capability_pitch() -> bool:
recent_text = _normalize_conv_text(_recent_demo_assistant_text())
if not recent_text:
return False
capability_signals = (
"respondo clientes",
"filtro interesados",
"filtro leads",
"ayudo con citas",
"manejo whatsapp",
"llevo el chat",
"creo agentes",
"ventas o soporte",
)
return any(signal in recent_text for signal in capability_signals)
def _looks_like_customer_greeting(raw_text: str) -> bool:
normalized = _normalize_conv_text(raw_text or "")
if not normalized:
return False
if _is_greeting_only(raw_text):
return True
greeting_prefixes = (
"hola", "hola buenas", "buenas", "buenas tardes", "buenos dias", "buenos días",
"buenas noches", "hey", "holi", "hi", "hello",
"good morning", "good afternoon", "good evening",
)
return any(
normalized == prefix or normalized.startswith(prefix + " ")
for prefix in greeting_prefixes
)
def _save(role, msg):
if db:
try:
db.save_message(chat_id, role, msg.replace("|||", " "))
except Exception:
pass
# ── SEND GUARD — pitch inteligente + fix de cortes ──────────────────
_guard = None
if _BLACKONE_PATCHES:
try:
_guard = SendGuard(context="demo", business_name=business_name)
except Exception:
_guard = None
# Smart handoff proactivo ANTES del LLM (prospecto quiere hablar con humano)
if _BLACKONE_PATCHES and _guard:
try:
_proactive = _guard.check_handoff(text, history)
if _proactive and _SMART_HANDOFF and handoff_manager:
_save("user", text)
_save("assistant", _proactive["suggested_reply"])
return _send(_proactive["suggested_reply"])
except Exception:
pass
# ──────────────────────────────────────────────────────────────────────
def _send(r):
_demo_archetype = self._demo_sessions.get(btone_key + "_arch", "amigable")
# BUG FIX: En DEMO_MODE, usar DEMO_BUSINESS_NAME como fallback
_demo_name = business_name if business_name else (Config.DEMO_BUSINESS_NAME if Config.DEMO_MODE else clinic.get("name", ""))
_demo_clinic = self._build_demo_patient_clinic(
{
**clinic,
"name": _demo_name,
"sector": clinic.get("sector") or Config.DEMO_SECTOR,
}
)
_is_first_demo_turn = not any(m.get("role") == "assistant" for m in history)
# Fix Black One / BlackBoss + cortes ANTES de procesar
if _BLACKONE_PATCHES:
try:
if _guard and business_name:
_guard.business_name = business_name
r = fix_creator_in_response(r)
r = _guard.clean(r) if _guard else r
except Exception:
pass
r = v8_process_response(r, chat_id=chat_id, archetype=_demo_archetype)
should_normalize_first_turn = _is_first_demo_turn and self._demo_should_use_patient_chat_path(text)
if should_normalize_first_turn:
r = _normalize_first_contact_response(
r,
_demo_clinic,
text,
agent_name="Conny",
)
_save("assistant", r)
bubbles = self._split_bubbles(r, chat_id=chat_id, archetype=_demo_archetype)
if should_normalize_first_turn and len(bubbles) == 1:
_text_norm = _normalize_conv_text(text or "")
_greeting_tokens = (
"hola", "buenas", "buenas tardes", "buenos dias", "buenos días",
"buenas noches", "hey", "holi", "hi", "hello",
"good morning", "good afternoon", "good evening",
)
if any(_text_norm == token or _text_norm.startswith(token + " ") for token in _greeting_tokens):
lowered_bubble = _normalize_conv_text(bubbles[0] or "")
if not any(token in lowered_bubble for token in ("cuentame", "cuéntame", "revisar", "ayudo", "ayudar")):
bubbles.append(_lang_text("cuéntame qué te gustaría revisar", "what would you like to check?"))
tone = self._demo_sessions.get(btone_key, "GENERAL")
if tone in ("SALUD PREMIUM", "PREMIUM"):
bubbles = [b[0].upper() + b[1:] if b else b for b in bubbles]
# v11: primera burbuja siempre con mayúscula inicial
if bubbles:
bubbles[0] = bubbles[0][0].upper() + bubbles[0][1:] if bubbles[0] else bubbles[0]
return bubbles
def _normalize_demo_owner_onboarding_response(raw_response: str) -> str:
parts = [part.strip() for part in re.split(r"\s*\|\|\|\s*", raw_response or "") if part.strip()]
if not parts:
return raw_response
user_norm = _normalize_conv_text(text or "")
greeted = any(
user_norm == token or user_norm.startswith(token + " ")
for token in (
"hola", "hola buenas", "buenas", "buenas tardes",
"buenas noches", "buenos dias", "buenos días", "hey", "holi",
"hi", "hello", "good morning", "good afternoon", "good evening",
)
)
if greeted:
first_norm = _normalize_conv_text(parts[0])
if first_norm.startswith("soy conny"):
parts[0] = "hola, " + parts[0][0].lower() + parts[0][1:]
elif first_norm.startswith("conny, "):
parts[0] = "hola, " + parts[0][0].lower() + parts[0][1:]
elif first_norm.startswith("i am conny") or first_norm.startswith("im conny") or first_norm.startswith("i'm conny"):
parts[0] = "hi, " + parts[0][0].lower() + parts[0][1:]
return " ||| ".join(parts)
_business_confirmation_signals = (
"sí ese es", "si ese es", "ese sí", "ese si", "ese mismo", "correcto ese",
"sí, ese", "si, ese", "exacto", "sí es ese", "si es ese",
"sí", "si", "sip", "claro", "correcto", "ese", "eso", "yes", "yep",
"thats us", "that's us", "that is us", "yes thats us", "yes that's us",
"yes thats right", "yes that's right", "thats right", "that's right",
"ajá", "aja", "dale", "listo", "así es", "asi es", "es ese", "ese es", "exactamente",
"sí señor", "si señor", "siii", "siiii", "siiiii", "sii",
"somos nosotros", "somos esos", "somos ese", "ese somos", "eso somos",
"somos esa", "esa somos", "si somos nosotros", "sí somos nosotros",
"es de nosotros", "ese es nuestro", "es nuestro", "eso es nuestro",
"eso somos nosotros", "esos somos", "ese sí somos", "ese si somos",
"claro que sí somos", "claro que si somos", "somos el negocio", "somos esa clínica",
)
def _looks_like_business_confirmation(raw_text: str) -> bool:
normalized = _normalize_conv_text(raw_text or "")
if not normalized:
return False
return any(
normalized == signal or (len(signal) > 6 and signal in normalized)
for signal in _business_confirmation_signals
)
def _extract_followup_after_business_confirmation(raw_text: str) -> str:
normalized = _normalize_conv_text(raw_text or "")
if not normalized:
return ""
for signal in sorted(_business_confirmation_signals, key=len, reverse=True):
signal_norm = _normalize_conv_text(signal)
if not signal_norm or signal_norm not in normalized:
continue
suffix = normalized.split(signal_norm, 1)[1].strip(" ,.!?;:")
if suffix:
return suffix
return ""
def _owner_is_english() -> bool:
return owner_lang == "en"
def _owner_is_portuguese() -> bool:
return owner_lang == "pt"
_force_business_bind = any(
marker in _normalize_conv_text(text or "")
for marker in (
"el nombre de mi negocio se llama",
"el nombre de nuestro negocio se llama",
"el nombre de mi empresa se llama",
"el nombre de nuestra empresa se llama",
"el nombre de mi negocio es",
"el nombre del negocio es",
"el nombre de mi empresa es",
"el nombre de la empresa es",
"mi negocio se llama",
"nuestro negocio se llama",
"mi empresa se llama",
"nuestra empresa se llama",
)
)
# ── FIX v10: Reset check ANTES del conversation core ─────────────────────
# Bug v9: _try_conversation_core corría primero y el LLM recibía "reset"
# como mensaje normal → generaba respuestas incoherentes ("Hoy?", etc.)
_reset_words = [
"reset", "reiniciar", "empezar de nuevo", "volver a empezar",
"borralo", "otro negocio", "cambia el negocio", "cambia negocio",
"cambiar negocio", "ese no es mi negocio", "no es mi negocio",
"equivoque", "equivocado",
]
if any(rw in text.lower() for rw in _reset_words):
keys_del = [k for k in list(self._demo_sessions)
if k.startswith(sk + "_") and not k.endswith("_ts")]
for k in keys_del:
del self._demo_sessions[k]
try:
with db._conn() as c:
c.execute("DELETE FROM conversations WHERE chat_id=?", (chat_id,))
except Exception:
pass
_save("user", text)
import random as _rr
_reset_replies = [
"listo, empezamos de cero ||| con qué negocio trabajo?",
"borrado todo ||| cuéntame: cómo se llama el negocio",
"ok, borrón y cuenta nueva ||| nombre del negocio?",
"listo ||| dime el nombre del negocio y arrancamos",
]
if _owner_is_english():
_reset_replies = [
"all set, starting from scratch ||| what business am I working with?",
"cleared everything ||| tell me the name of your business",
"ok, fresh start ||| what's the name of the business?",
"ready ||| send me the business name and I’ll start from there",
]
elif _owner_is_portuguese():
_reset_replies = [
"pronto, começamos do zero ||| com qual negócio eu trabalho?",
"apaguei tudo ||| me diz o nome do negócio",
"ok, recomeçando ||| qual é o nome do negócio?",
"certo ||| me passa o nome do negócio e eu começo",
]
return _send(_rr.choice(_reset_replies))
# ─────────────────────────────────────────────────────────────────────────
demo_channel = ""
try:
demo_channel = str(self._resolve_route(chat_id).get("platform") or Config.PLATFORM or "")
except Exception:
demo_channel = str(Config.PLATFORM or "")
_pre_text_low = text.lower().strip()
# ── PITCH INTELIGENTE — prospecto B2B confundido ─────────────────────
if _BLACKONE_PATCHES:
try:
_pitch_blockers = (
"para que", "para qué", "por que", "por qué",
"why do you need", "why do you need it",
)
if is_prospect_confused(text, history) and not any(blocker in _pre_text_low for blocker in _pitch_blockers):
self._demo_sessions[sk + "_pitch_mode"] = True
# BUG FIX: forzar pitch para preguntas específicas que is_prospect_confused no detecta
elif any(q in text.lower() for q in ("que harias", "qué harías", "que harias en", "qué harías en")):
self._demo_sessions[sk + "_pitch_mode"] = True
else:
self._demo_sessions.pop(sk + "_pitch_mode", None)
except Exception:
pass
# ─────────────────────────────────────────────────────────────────────
_pre_core_blockers = (
"hagamos una demo",
"hagamos la demo",
"hagamos una simul",
"vale hagamos",
"arranquemos la demo",
"arranquemos",
"simulemos",
"quien eres",
"quién eres",
"que eres",
"qué eres",
"que haces",
"qué haces",
"como funcionas",
"cómo funcionas",
"para que",
"para qué",
"por que",
"por qué",
"quien te hizo",
"quién te hizo",
"como tenerte",
"cómo tenerte",
"aceptas audios",
"aceptas pdf",
"me mandaron tu numero",
"me mandaron tu número",
"what is this",
"what do you do",
"who are you",
"i dont understand",
"i don't understand",
"english only",
"i dont talk spanish",
"i don't talk spanish",
)
# PATCH P3 — conversation_core solo cuando el negocio ya está cargado.
# Sin business_name, el core usa contexto de la clínica real → T4 identidad errónea.
demo_core_bubbles = None
if (
business_name
and not sim_mode_active
and not self._demo_should_use_patient_chat_path(text)
and not _pre_text_low.startswith("/")
and not any(marker in _pre_text_low for marker in _pre_core_blockers)
and not llm_runtime_ready
):
demo_core_bubbles = self._try_conversation_core(
clinic={
**clinic,
"name": business_name,
"sector": self._demo_sessions.get(btone_key, Config.DEMO_SECTOR),
},
user_msg=text,
history=history,
is_admin=False,
channel=demo_channel,
)
if demo_core_bubbles:
_save("user", text)
demo_response = " ||| ".join(demo_core_bubbles)
_demo_archetype = self._demo_sessions.get(btone_key + "_arch", "amigable")
demo_response = v8_process_response(demo_response, chat_id=chat_id, archetype=_demo_archetype)
_save("assistant", demo_response)
return self._split_bubbles(demo_response, chat_id=chat_id, archetype=_demo_archetype)
# ── Normalizar texto y detectar comandos ──────────────────────────────
text_norm = text.strip().lower().lstrip("/")
cmd_aliases = {
"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",
# Lista de comandos
"list":"list","lista":"list","comandos":"list","ayuda":"list","help":"list","qué puedes hacer":"list","que puedes hacer":"list",
# Emojis on/off
"emojis":"emojis_on","con emojis":"emojis_on","activa emojis":"emojis_on",
"sin emojis":"emojis_off","quita emojis":"emojis_off","desactiva emojis":"emojis_off",
# Selección de modelo — /modelo o texto libre
"modelo":"modelo","model":"modelo","cambiar modelo":"modelo",
}
# Detección natural de emojis en texto libre
_emoji_on_signals = [
"usa emojis","ponle emojis","escribe con emojis",
"activa los emojis","quiero emojis","pon emojis",
"enviame emojis","envíame emojis","mándame emojis",
"mandame emojis","con emojis","agrega emojis","añade emojis",
]
_emoji_off_signals = [
"sin emojis","quita los emojis","sin tanto emoji","sin esos emojis",
"desactiva emojis","no más emojis","no me mandes emojis",
"no uses emojis","no pongas emojis","sin caritas","sin los emojis",
"quitale los emojis","no me envies emojis","no me envíes emojis",
]
if any(s in text_norm for s in _emoji_on_signals):
self._emoji_chats_off.discard(chat_id) # v11: re-activar emojis
_save("user", text)
_biz_hint = f" en {business_name}" if business_name else ""
return _send(f"listo, ahora escribo con emojis 😊 ||| sigue hablándome como si fueras un cliente{_biz_hint}")
if any(s in text_norm for s in _emoji_off_signals):
self._emoji_chats_off.add(chat_id) # v11: desactivar emojis
_save("user", text)
_biz_hint = f" en {business_name}" if business_name else ""
return _send(f"listo, sin emojis ||| sigue hablándome como si fueras un cliente{_biz_hint}")
detected_cmd = None
model_request = extract_model_request_from_text(text_norm)
if model_request:
detected_cmd = "/modelo"
for alias, cmd in cmd_aliases.items():
if text_norm == alias or text_norm == "/" + alias:
detected_cmd = "/" + cmd
break
# ── Motor LLM según preferencia de sesión ────────────────────────────
def _get_demo_engine():
"""
Devuelve el proveedor LLM según demo_model_pref.
Formatos soportados:
auto → engine global
gemini → GeminiProvider con gemini-2.5-flash
gemini:gemini-2.5-pro → GeminiProvider con modelo específico
groq → GroqProvider con llama-3.3-70b-versatile
groq:llama-3.1-8b-instant → GroqProvider con modelo específico
openrouter → OpenRouterProvider
openrouter:anthropic/claude-sonnet-4 → OpenRouter con modelo específico
"""
pref = self._demo_sessions.get(bmodel_key, "auto")
if ":" in pref:
provider, model_name = pref.split(":", 1)
else:
provider, model_name = pref, None
if provider == "groq" and Config.GROQ_API_KEY:
eng = GroqProvider(Config.GROQ_API_KEY)
if model_name:
# Override el modelo específico
eng.MDLS = {"reasoning": model_name, "fast": model_name, "lite": model_name}
return eng
elif provider == "gemini":
key = Config.GEMINI_API_KEY or Config.GEMINI_API_KEY_2 or Config.GEMINI_API_KEY_3
if key:
eng = GeminiProvider(key, "gemini_demo")
if model_name:
eng.MDLS = {"reasoning": model_name, "fast": model_name, "lite": model_name}
else:
# Default: 2.5-flash estable
eng.MDLS = {"reasoning": "gemini-2.5-flash", "fast": "gemini-2.5-flash", "lite": "gemini-2.5-flash-lite"}
return eng
# Fallback a OpenRouter con gemini
if Config.OPENROUTER_API_KEY:
eng = OpenRouterProvider(Config.OPENROUTER_API_KEY)
m = model_name or "google/gemini-2.5-flash"
eng.MDLS = {"reasoning": m, "fast": m, "lite": m}
return eng
elif provider == "openrouter" and Config.OPENROUTER_API_KEY:
eng = OpenRouterProvider(Config.OPENROUTER_API_KEY)
if model_name:
eng.MDLS = {"reasoning": model_name, "fast": model_name, "lite": model_name}
return eng
# auto: engine global
_generator = getattr(self, "generator", None)
return llm_engine or (_generator.llm if _generator else None)
# ── Helpers locales ───────────────────────────────────────────────────
async def _llm(sys_p, usr_p, temp=0.82, max_t=8192, model_tier="fast"): # Sin límite — Gemini 2.5 soporta hasta 65k output tokens
msgs = [{"role":"system","content":sys_p},{"role":"user","content":usr_p}]
try:
eng = _get_demo_engine()
if not eng: raise RuntimeError("LLM no init")
r, meta = await eng.complete(
msgs,
model_tier=model_tier,
temperature=temp,
max_tokens=max_t,
use_cache=False,
)
log.info(f"[demo] {meta.get('provider','?')} model={meta.get('model','?')[:30]}")
_generator = getattr(self, "generator", None)
return _generator._postprocess(r, PersonalityProfile()) if _generator else r
except Exception as e:
log.error(f"[demo] llm error: {e}")
return None
async def _llm_conv_pitch(temp=0.85, max_t=8192, recent_limit=12):
"""LLM con el pitch de Black One para prospectos confundidos."""
try:
pitch_sys = build_prospect_pitch_system_prompt(business_name)
except Exception:
return None
msgs = [{"role": "system", "content": pitch_sys}]
for m in history[-recent_limit:]:
msgs.append({"role": m["role"], "content": m["content"]})
msgs.append({"role": "user", "content": text})
try:
eng = _get_demo_engine()
if not eng: raise RuntimeError("LLM no init")
r, meta = await eng.complete(msgs, model_tier="fast", temperature=temp, max_tokens=max_t, use_cache=False)
log.info(f"[demo][pitch] {meta.get('provider','?')}")
_generator = getattr(self, "generator", None)
return _generator._postprocess(r, PersonalityProfile()) if _generator else r
except Exception as e:
log.error(f"[demo][pitch] error: {e}")
return None
async def _llm_conv(sys_p, temp=0.85, max_t=8192, model_tier="fast", recent_limit=12): # Sin límite — Gemini 2.5 soporta hasta 65k output tokens
msgs = [{"role":"system","content":sys_p}]
for m in history[-recent_limit:]:
msgs.append({"role":m["role"],"content":m["content"]})
msgs.append({"role":"user","content":text})
try:
eng = _get_demo_engine()
if not eng: raise RuntimeError("LLM no init")
r, meta = await eng.complete(
msgs,
model_tier=model_tier,
temperature=temp,
max_tokens=max_t,
use_cache=False,
)
log.info(f"[demo] {meta.get('provider','?')} model={meta.get('model','?')[:30]}")
_generator = getattr(self, "generator", None)
return _generator._postprocess(r, PersonalityProfile()) if _generator else r
except Exception as e:
log.error(f"[demo] llm_conv error: {e}")
return None
async def _demo_llm_conv_quality_chain(
system_prompt: str,
*,
validator,
repair_instructions: str,
temp: float = 0.72,
max_t: int = 8192, # Sin límite — Gemini 2.5 necesita espacio para pensar
model_tier: str = "fast",
recent_limit: int = 8,
) -> Tuple[Optional[str], bool]:
_chain_start = time.time()
_CHAIN_TIMEOUT_S = 45 # si pasaron más de 45s entre intentos, no enviar respuesta vieja
attempts = [
(system_prompt, temp, max_t, model_tier, recent_limit),
(
system_prompt
+ "\n\nREPARA LA RESPUESTA:\n"
+ repair_instructions.strip()
+ "\n- no repitas introducciones\n- no suenes a bot ni a guion de demo",
0.58,
max_t,
"reasoning",
recent_limit,
),
]
had_output = False
last_candidate = None
for prompt_now, temp_now, max_now, tier_now, limit_now in attempts:
# No lanzar repair si ya pasó demasiado tiempo desde que llegó el mensaje
if time.time() - _chain_start > _CHAIN_TIMEOUT_S:
log.warning("[demo] conv_quality_chain abortada por timeout (%ds)", _CHAIN_TIMEOUT_S)
break
candidate = await _llm_conv(
prompt_now,
temp=temp_now,
max_t=max_now,
model_tier=tier_now,
recent_limit=limit_now,
)
if candidate and candidate.strip():
had_output = True
last_candidate = candidate
if not validator(candidate):
return candidate, True
if had_output and last_candidate and not looks_fragmented_reply(last_candidate):
candidate_norm = _normalize_conv_text(last_candidate)
if len(candidate_norm.split()) >= 5 and not validator(last_candidate):
return last_candidate, True
return None, had_output
def _save(role, msg):
if db:
try: db.save_message(chat_id, role, msg.replace("|||"," "))
except Exception: pass
def _send(r):
# V8.0: aplicar AntiRobotFilter antes de guardar y enviar
_demo_archetype = self._demo_sessions.get(btone_key + "_arch", "amigable")
# BUG FIX: En DEMO_MODE, usar DEMO_BUSINESS_NAME como fallback
_demo_name = business_name if business_name else (Config.DEMO_BUSINESS_NAME if Config.DEMO_MODE else clinic.get("name", ""))
_demo_clinic = self._build_demo_patient_clinic(
{
**clinic,
"name": _demo_name,
"sector": clinic.get("sector") or Config.DEMO_SECTOR,
}
)
_is_first_demo_turn = not any(m.get("role") == "assistant" for m in history)
# ── BLACK ONE: fix Black One + cortes antes de procesar ──────────
if _BLACKONE_PATCHES:
try:
if _guard and business_name:
_guard.business_name = business_name
r = fix_creator_in_response(r)
if _guard:
r = _guard.clean(r)
except Exception:
pass
# ─────────────────────────────────────────────────────────────────
r = v8_process_response(r, chat_id=chat_id, archetype=_demo_archetype)
should_normalize_first_turn = _is_first_demo_turn and self._demo_should_use_patient_chat_path(text)
if should_normalize_first_turn:
r = _normalize_first_contact_response(
r,
_demo_clinic,
text,
agent_name="Conny",
)
_save("assistant", r)
bubbles = self._split_bubbles(r, chat_id=chat_id, archetype=_demo_archetype)
# FIX BUG 4: Si es el primer turno, el usuario saludó, y la respuesta tiene
# solo 1 burbuja sin pregunta de seguimiento → agregar burbuja de apertura.
# Esta lógica existía en la primera definición de _send (línea 13772) pero
# se perdió cuando se redefinió _send aquí en la misma función.
if should_normalize_first_turn and len(bubbles) == 1:
_text_norm = _normalize_conv_text(text or "")
_greeting_tokens = (
"hola", "buenas", "buenas tardes", "buenos dias", "buenos días",
"buenas noches", "hey", "holi",
)
if any(_text_norm == token or _text_norm.startswith(token + " ") for token in _greeting_tokens):
lowered_bubble = _normalize_conv_text(bubbles[0] or "")
if not any(token in lowered_bubble for token in ("cuentame", "cuéntame", "revisar", "ayudo", "ayudar")):
bubbles.append("cuéntame qué te gustaría revisar")
# Para premium/salud premium: restaurar mayúscula inicial
tone = self._demo_sessions.get(btone_key, "GENERAL")
if tone in ("SALUD PREMIUM", "PREMIUM"):
bubbles = [b[0].upper() + b[1:] if b else b for b in bubbles]
# v11: primera burbuja siempre con mayúscula inicial
if bubbles:
bubbles[0] = bubbles[0][0].upper() + bubbles[0][1:] if bubbles[0] else bubbles[0]
return bubbles
def _looks_like_business_name_candidate(raw_text: str) -> bool:
candidate = (raw_text or "").strip()
if not candidate:
return False
normalized = _normalize_conv_text(candidate)
if len(candidate) > 90:
return False
if _owner_confusion_or_language_signal(candidate):
return False
owner_name_false_positives = (
"mi nombre es",
"me llamo",
"my name is",
"i am ",
"i'm ",
"im ",
)
explicit_business_markers = (
"el nombre de mi negocio se llama",
"el nombre de nuestro negocio se llama",
"el nombre de mi empresa se llama",
"el nombre de nuestra empresa se llama",
"el nombre de mi negocio es",
"el nombre del negocio es",
"el nombre de mi empresa es",
"el nombre de la empresa es",
"mi negocio se llama",
"nuestro negocio se llama",
"mi empresa se llama",
"nuestra empresa se llama",
"la clinica se llama",
"la clínica se llama",
"se llama ",
"negocio es ",
"empresa es ",
)
if (
any(marker in normalized for marker in owner_name_false_positives)
and not any(marker in normalized for marker in explicit_business_markers)
):
return False
conversational_false_positives = (
"somos nosotros", "somos nosotras", "somos ese", "somos esa",
"si somos", "sí somos", "siii somos", "siiii somos",
"that is us", "that's us", "thats us", "yes thats us", "yes that's us",
"this is us", "we are that", "we are them",
)
if any(marker in normalized for marker in conversational_false_positives):
return False
if any(marker in normalized for marker in explicit_business_markers):
return True
if any(
marker in normalized
for marker in (
"como estas", "cómo estás", "quien eres", "quién eres", "que eres", "qué eres",
"que haces", "qué haces", "que harias", "qué harías", "como funcionas", "cómo funcionas", "aceptas audios",
"aceptas pdf", "para que", "para qué", "quien te hizo", "quién te hizo",
"me mandaron tu numero", "me mandaron tu número", "quiero una demo", "quiero demo",
"quiero probarte", "tengo un negocio", "tengo una empresa", "hola", "buenas", "?",
"what is this", "sorry what is this", "what do you do", "who are you",
"i dont understand", "i don t understand", "english only", "just english sorry",
"i dont talk spanish", "i don t talk spanish", "i dont speak spanish", "i don t speak spanish",
)
):
return False
if _looks_like_business_confirmation(candidate):
return False
words = re.findall(r"[A-Za-zÁÉÍÓÚáéíóúÑñ0-9&.'-]+", candidate)
if not (1 <= len(words) <= 8):
return False
if any(ch.isupper() for ch in candidate):
upper_tokens = [word.lower() for word in words if len(word) >= 2]
blocked_upper_tokens = {
"sorry", "spanish", "what", "this", "that",
"dont", "don't", "understand", "talk", "speak", "only", "hello",
"hi", "hola", "business", "not", "my",
}
if any(token in blocked_upper_tokens for token in upper_tokens):
return False
return True
business_tokens = (
"clinica", "clínica", "clinic", "spa", "dental", "salud", "centro",
"consultorio", "estetica", "estética", "studio", "group", "lab",
"restaurante", "hotel", "tienda", "academia", "gym", "gimnasio",
)
if any(token in normalized for token in business_tokens):
return True
# Marcas de 1-3 palabras sin jerga conversacional también pueden ser válidas.
if 1 <= len(words) <= 3 and all(len(word) >= 3 for word in words):
stop_tokens = {
"sorry", "spanish", "hello", "what", "this", "that",
"understand", "business", "please", "talk", "speak", "only",
"dont", "not", "sorry",
}
if not any(word.lower() in stop_tokens for word in words):
return True
return False
def _demo_owner_reply_is_low_quality(raw_response: Optional[str]) -> bool:
lowered = _normalize_conv_text(raw_response or "")
if not lowered:
return True
if looks_fragmented_reply(raw_response or ""):
return True
parts = [part.strip() for part in re.split(r"\s*\|\|\|\s*|\n+", raw_response or "") if part.strip()]
weak_parts = {
"hola", "buenas", "claro", "dale", "listo", "sí", "si",
"puedes", "perfecto", "entiendo", "ok", "keep going",
}
if any(_normalize_conv_text(part) in weak_parts for part in parts):
return True
if any(looks_fragmented_reply(part) for part in parts):
return True
safe_tail_words = {"hoy", "ahi", "ahí", "bien", "vale", "listo", "claro"}
for part in parts:
norm_part = _normalize_conv_text(part)
words = norm_part.split()
if len(words) >= 3 and len(words[-1]) <= 3 and words[-1] not in safe_tail_words:
return True
banned = (
"nova",
"clinica de las americas",
"clínica de las américas",
"retomamos desde donde lo dejamos",
"seguimos con la demo",
"cuenteme que quiere ajustar",
"cuénteme qué quiere ajustar",
"estoy lista para ayudarte con la instancia",
"de manera adecuada",
"me permitira",
"me permitirá",
"ofrecer una mejor experiencia",
"a tus necesidades",
"a las de tus clientes",
"de manera efectiva",
"para poder hacer esto",
"por favor",
"proceder",
"precisa y personalizada",
"interactuas con nuestros servicios",
"interactúas con nuestros servicios",
"de manera mas precisa",
"de manera más precisa",
"escribidme",
"vuestra",
"vuestro",
"vosotros",
"ayudaros",
"parece ser un lugar confiable",
"me gustaria saber mas sobre sus servicios",
"me gustaría saber más sobre sus servicios",
"de manera clara y concisa",
"atencion que brindan",
"atención que brindan",
"por favor escriban",
"quiero ver como interactuan",
"quiero ver cómo interactúan",
"pueden comenzar a escribir su consulta",
# ── Frases que rompen el personaje (v10 fix) ──────────────────
"no se cual es el negocio",
"no sé cuál es el negocio",
"hay confusion",
"hay confusión",
"me doy cuenta de que",
"mi funcion es",
"mi función es",
"aqui lo que hago es",
"aquí lo que hago es",
"soy una persona que responde",
"la idea es que yo me encargue",
"la que llevaria el chat de tu negocio",
"la que llevaría el chat de tu negocio",
"hola pues mira",
"soy una ia",
"soy un bot",
"soy chatgpt",
"soy un asistente virtual",
"soy una asistente virtual",
"como asistente",
"como ia",
"como bot",
)
if any(token in lowered for token in banned):
return True
if lowered in {
"hola",
"buenas",
"soy conny",
"hola soy conny",
"como se llama tu negocio",
"cómo se llama tu negocio",
}:
return True
return False
def _demo_owner_missing_required_detail(user_text: str, raw_response: Optional[str]) -> bool:
lowered_user = _normalize_conv_text(user_text or "")
lowered_response = _normalize_conv_text(raw_response or "")
if not lowered_response:
return True
if any(token in lowered_user for token in ("para que", "para qué", "por que", "por qué")):
detail_tokens = ("chat", "cliente", "demo", "tono", "responder", "whatsapp")
return not any(token in lowered_response for token in detail_tokens)
if any(token in lowered_user for token in ("quien te hizo", "quién te hizo", "como tenerte", "cómo tenerte", "quien te creo", "quién te creó")):
return "black one" not in lowered_response or "3124348669" not in lowered_response
if any(token in lowered_user for token in ("audio", "audios", "nota de voz", "pdf", "archivo", "documento", "imagen")):
return not any(token in lowered_response for token in ("audio", "pdf", "documento", "imagen", "transcrib"))
if any(token in lowered_user for token in ("me mandaron tu numero", "me mandaron tu número", "me pasaron tu numero", "me pasaron tu número", "que haces exactamente", "qué haces exactamente", "no entiendo que haces", "no entiendo qué haces")):
capability_tokens = ("cliente", "clientes", "cita", "citas", "respon", "orient", "filtro", "report")
return not any(token in lowered_response for token in capability_tokens)
if any(token in lowered_user for token in ("esto es real", "modo bot", "como llevarias", "cómo llevarías", "como responderias", "cómo responderías")):
operational_tokens = ("chat", "cliente", "clientes", "tono", "lead", "leads", "ventas", "soporte", "respon", "whatsapp")
return not any(token in lowered_response for token in operational_tokens)
if "5 x 4" in lowered_user or "5x4" in lowered_user:
return "20" not in lowered_response
if "capital de francia" in lowered_user:
return "par" not in lowered_response
return False
def _demo_owner_reground_needs_cleanup(raw_response: Optional[str]) -> bool:
lowered = _normalize_conv_text(raw_response or "")
if not lowered:
return True
parts = [part.strip() for part in re.split(r"\s*\|\|\|\s*|\n+", raw_response or "") if part.strip()]
if len(parts) > 2:
return True
low_signal_phrases = (
"me gustaria saber",
"me gustaría saber",
"tienes alguna consulta",
"necesitas ayuda con algo",
"de la mejor manera",
"puedes escribirme como si fuera un cliente",
"puedo tener una idea clara",
"de manera adecuada",
"ofrecer una mejor experiencia",
"como si fuera un cliente real, hoy",
"como si fuera un cliente real hoy",
)
return any(token in lowered for token in low_signal_phrases)
def _demo_customer_reply_is_low_quality(raw_response: Optional[str]) -> bool:
lowered = _normalize_conv_text(raw_response or "")
raw_text = (raw_response or "").strip().lower()
if not lowered:
return True
if looks_fragmented_reply(raw_response or ""):
return True
parts = [part.strip() for part in re.split(r"\s*\|\|\|\s*|\n+", raw_response or "") if part.strip()]
if any(looks_fragmented_reply(part) for part in parts):
return True
if re.search(r"(?:[.!?]\s*)(hoy|y tu|y tú|que mas|qué más)\??$", raw_text):
return True
safe_tail_words = {"hoy", "ahi", "ahí", "bien", "vale", "listo", "claro", "ti", "aqui", "aquí"}
for part in parts:
norm_part = _normalize_conv_text(part)
words = norm_part.split()
if len(words) <= 2 and any(token in norm_part for token in ("hoy", "y tu", "y tú", "que mas", "qué más")):
return True
if len(words) <= 2 and part.strip().endswith("?"):
return True
if len(words) >= 3 and len(words[-1]) <= 2 and words[-1] not in safe_tail_words:
return True
bad_markers = (
"hola que necesitas",
"hola, que necesitas",
"cuentame un poco mas y te voy guiando",
"cuéntame un poco más y te voy guiando",
"por favor procedan",
"de manera efectiva",
"simular la interaccion",
"simular la interacción",
"cliente real de",
"estoy lista para empezar",
"como si fueran un cliente real",
"soy conny, la asesora virtual de",
"escribidme",
"vuestra",
"vuestro",
"vosotros",
"ayudaros",
"parece ser un lugar confiable",
"quiero ver como interactuan",
"quiero ver cómo interactúan",
"pueden comenzar a escribir su consulta",
)
return any(marker in lowered for marker in bad_markers)
def _demo_customer_missing_required_detail(user_text: str, raw_response: Optional[str]) -> bool:
lowered_user = _normalize_conv_text(user_text or "")
lowered_resp = _normalize_conv_text(raw_response or "")
if not lowered_resp:
return True
if lowered_user in {"hola", "hola buenas", "buenas", "buenas tardes", "buenos dias", "buenos días", "buenas noches", "hey"}:
if not any(token in lowered_resp for token in ("hola", "buenas", "bienvenida", "bienvenido", "cuentame", "cuéntame", "revisar", "ayudo", "ayudar")):
return True
if any(token in lowered_user for token in ("precio", "cuanto", "cuánto", "vale", "costo", "coste")):
if not any(token in lowered_resp for token in ("precio", "cuesta", "valor", "dato", "confirmo", "averiguo", "depende")):
return True
if not found_online and any(token in lowered_resp for token in ("aproximado", "aproximada", "aprox", "rango", "desde")):
return True
if any(token in lowered_user for token in ("cita", "agendar", "agenda", "seguimos", "siguiente paso", "como seguimos", "cómo seguimos")):
if not any(token in lowered_resp for token in ("cita", "agendo", "agenda", "hora", "horario", "nombre", "confirmo", "paso")):
return True
if any(token in lowered_resp for token in ("link", "enlace", "seleccionar una fecha", "seleccionar fecha", "calendario")):
return True
if any(token in lowered_user for token in ("audio", "audios", "nota de voz", "pdf", "archivo", "documento", "documentos", "imagen", "imagenes", "imágenes")):
if not any(token in lowered_resp for token in ("audio", "voz", "pdf", "documento", "imagen", "transcrib", "leer")):
return True
if "miedo" in lowered_user:
if not any(token in lowered_resp for token in ("miedo", "normal", "natural", "conservador", "suave")):
return True
return False
def _demo_customer_last_resort(user_text: str) -> str:
"""
Fallback REAL — solo cuando TODOS los modelos LLM fallan en simulación.
No intenta ser inteligente. El LLM maneja todo lo demás.
"""
_biz = business_name or "el negocio"
_user = _normalize_conv_text(user_text or "")
if any(token in _user for token in ("cita", "agendar", "agenda", "valoracion", "valoración", "horario", "disponibilidad")):
return (
f"si quieres seguimos con el siguiente paso para agendar en {_biz}"
" ||| dime tu nombre y el horario que mejor te quede"
)
if any(token in _user for token in ("precio", "cuesta", "vale", "coste", "cuanto", "cuánto")):
return (
f"te puedo ubicar con el precio o la valoración de {_biz}"
" ||| dime qué tratamiento estás mirando"
)
if any(token in _user for token in ("miedo", "asusta", "nerv", "exagerad", "natural")):
return (
f"en {_biz} lo normal es arrancar viendo qué resultado quieres"
" ||| qué es lo que más te preocupa"
)
if any(token in _user for token in ("audio", "audios", "nota de voz", "pdf", "archivo", "documento", "documentos", "imagen", "imagenes", "imágenes")):
return (
"sí, por aquí puedo trabajar con audios, imágenes y documentos"
" ||| si quieres, mándamelo y sigo desde ahí"
)
return f"cuéntame qué necesitas de {_biz}"
async def _demo_llm_quality_chain(
system_prompt: str,
user_prompt: str,
*,
validator,
repair_instructions: str,
temp: float = 0.76,
max_t: int = 8192, # Sin límite — Pro necesita tokens para reasoning
model_tier: str = "reasoning",
) -> Tuple[Optional[str], bool]:
attempts = [
(system_prompt, temp, max_t, model_tier),
(
system_prompt
+ "\n\nREPARA LA RESPUESTA:\n"
+ repair_instructions.strip()
+ "\n- responde mejor, pero sin cambiar de tema\n- no uses frases corporativas ni consultoras",
0.62,
max_t,
"reasoning",
),
(
system_prompt
+ "\n\nRESPUESTA FINAL OBLIGATORIA:\n"
+ repair_instructions.strip()
+ "\n- entrega una versión final limpia, concreta y humana\n- no salgas por la tangente\n- no recites instrucciones",
0.45,
max(max_t, 260),
"reasoning",
),
]
had_output = False
for prompt_now, temp_now, max_now, tier_now in attempts:
candidate = await _llm(
prompt_now,
user_prompt,
temp=temp_now,
max_t=max_now,
model_tier=tier_now,
)
if candidate and candidate.strip():
had_output = True
if not validator(candidate):
return candidate, True
return None, had_output
def _demo_owner_last_resort(
user_text: str,
*,
explain_name: bool = False,
current_business_name: str = "",
current_owner_name: str = "",
) -> str:
"""
Fallback REAL — solo se ejecuta cuando TODOS los modelos LLM fallan.
No intenta ser inteligente. El domino (LLM) maneja todo lo demás.
"""
_biz = (current_business_name or business_name or "").strip()
_owner = (current_owner_name or owner_name or "").strip()
_owner_first = _owner.split()[0] if _owner else ""
_user = _normalize_conv_text(user_text or "")
if any(token in _user for token in ("eres una ia", "eres ia", "eres un bot", "eres bot", "eres real", "eres humano")):
return _lang_text(
"sí, soy una IA ||| pero la idea es que el chat se sienta natural, útil y bien llevado ||| si quieres, dime el nombre de tu negocio y te muestro cómo respondería de verdad",
"yes, I am AI ||| but the point is for the chat to feel natural, useful and well handled ||| if you want, send me your business name and I’ll show you how I’d actually reply",
)
if any(token in _user for token in ("modo bot", "como llevarias", "cómo llevarías", "como responderias", "cómo responderías")):
return _lang_text(
"lo llevaría como si ya fuera parte del equipo ||| respondería dudas de clientes, filtraría interesados, movería citas y te dejaría claro quién va en serio y quién solo está mirando ||| si quieres, dime el nombre de tu negocio y te lo aterrizo con ejemplos reales",
"I’d handle it like I was already part of your team ||| I’d answer client questions, filter leads, move appointments and make it clear who is serious and who is just browsing ||| if you want, send me your business name and I’ll ground it with real examples",
)
if any(token in _user for token in ("para que", "para qué", "por que", "por qué")):
if _biz:
return _lang_text(
f"te lo pido para hablar como si ya llevara el chat de {_biz} ||| así la demo te muestra mejor cómo respondería de verdad",
f"i ask for it so I can sound like I already handle {_biz}'s chat ||| that way the demo feels real and properly grounded",
)
if _owner_first:
return _lang_text(
f"{_owner_first}, te lo pido para ubicar el tono, el contexto y cómo tendría que responder ||| apenas me digas el nombre del negocio te muestro la demo bien aterrizada",
f"{_owner_first}, I ask for it so I can match the tone, the context and the way I'd actually reply ||| as soon as you send the business name, I'll make the demo feel real",
)
return _lang_text(
"te lo pido para ubicar el tono, el contexto y cómo tendría que responder ||| apenas me digas el nombre del negocio te muestro la demo bien aterrizada",
"i ask for it so I can match the tone, the context and the way I'd actually reply ||| as soon as you send the business name, I'll make the demo feel real",
)
if "esto es real" in _user:
return _lang_text(
"sí, esto funciona de verdad ||| puedo llevar el chat con el tono de tu negocio, responder clientes y filtrar interesados sin que tú estés pegado al WhatsApp ||| si quieres, dime el nombre de tu negocio y te muestro cómo sonaría",
"yes, this is real ||| I can run the chat with your business tone, reply to clients and filter leads without you being stuck on WhatsApp ||| if you want, send me your business name and I’ll show you how it would sound",
)
if _biz:
return _lang_text(
f"Escríbeme algo como cliente de {_biz} y arranco",
f"send me something like a real client from {_biz} and I'll jump in",
)
if any(
token in _user
for token in (
"me mandaron tu numero", "me mandaron tu número", "me pasaron tu numero",
"me pasaron tu número", "que haces", "qué haces", "no entiendo que haces",
"no entiendo qué haces", "quien eres", "quién eres",
"what is this", "what do you do", "who are you", "i dont understand", "i don't understand",
)
):
return _lang_text(
"hola, soy Conny, la asesora virtual que llevaría tu chat ||| respondo clientes, filtro interesados, ubico servicios y ayudo con citas ||| pásame el nombre de tu negocio y arranco",
"hi, I'm Conny, the assistant who would handle your business chat ||| I reply to clients, filter leads, explain services and help move appointments ||| send me your business name and I'll build the demo around it",
)
return _lang_text(
"hola, soy Conny, la asesora virtual que llevaría tu chat ||| pásame el nombre de tu negocio y arranco",
"hi, I'm Conny, the assistant who would handle your business chat ||| send me your business name and I'll start from there",
)
async def _demo_owner_onboarding_reply(*, explain_name: bool = False, force_stage: Optional[str] = None) -> List[str]:
user_block = text
already_disclosed_ai = _owner_already_knows_ai_identity()
already_explained_capabilities = _owner_already_got_capability_pitch()
recent_assistant_context = _recent_demo_assistant_text(limit=4)
if False and _CONNY_DOMINO_AVAILABLE: # Disabled: using improved prompt v10
try:
domino_payload = build_demo_domino_payload(
user_text=text,
history=history,
business_name=business_name,
business_ctx=business_ctx,
found_online=found_online,
explain_name=explain_name,
force_stage=force_stage,
)
system_prompt = domino_payload["system"]
user_block = domino_payload["user"]
except Exception as e:
log.warning(f"[demo] domino payload error: {e}")
system_prompt = ""
else:
system_prompt = ""
if not system_prompt:
system_prompt = f"""Eres Conny, una colombiana de 28 años que trabaja como recepcionista virtual por WhatsApp.
Estás en una demo con un posible cliente (dueño de negocio). Tu trabajo: que se enamore de ti en 5 minutos.
CÓMO SUENAS: como una persona real de Medellín escribiendo en WhatsApp.
- Mensajes cortos, partidos en 2-3 burbujas
- Sin puntuación perfecta (como escribe alguien real en WhatsApp)
- Cero listas de capacidades, cero pitch de ventas directo
- Tono: segura pero cercana, como compañera de trabajo que sabe lo que hace
- Si te hablan en inglés, respondes en inglés perfecto y natural
TU ESTRATEGIA DE DEMO (no la menciones, solo ejecútala):
1. PRIMERO: saluda, preséntate brevemente, pregunta el nombre del negocio
2. SEGUNDO: cuando te lo den, busca info del negocio y entra en personaje
3. TERCERO: invita a que te escriban como si fueran un cliente real
4. CUARTO: responde como recepcionista REAL de ese negocio — aquí es donde se enamoran
5. QUINTO: después de 2-3 simulaciones, cierra: "si te gustó, Santiago te cuenta los planes: 3124348669"
REGLA MÁXIMA: cada respuesta debe hacer que la persona piense "esto no puede ser una IA"
SESIÓN ACTIVA: Tienes una sesión de demo de 30 minutos con este usuario. NO es una conversación nueva.
{"Ya conoces el negocio: " + business_name + "." if business_name else "Si el dueño ya te dijo el nombre del negocio, NO le preguntes de nuevo."}
Usa 2 o 3 burbujas separadas por |||. Cada burbuja cierra una idea completa. Nunca dejes frases cortadas."""
generic_language_rule = "Mirror the owner's dominant language exactly. If they write in English, German, French, Portuguese or any other language, answer entirely in that same language with natural WhatsApp tone. Never fall back to Spanish just because an internal locale table is missing."
language_tone = _lang_text(
"",
"The owner is writing in English. Respond entirely in English. Casual, warm WhatsApp English. Never switch back to Spanish unless the owner does.",
"O dono está escrevendo em português. Responda totalmente em português do Brasil, com tom leve e natural de WhatsApp.",
)
system_prompt += "\n\nIDIOMA / LANGUAGE RULE:\n" + generic_language_rule
if language_tone:
system_prompt += "\n" + language_tone
if owner_name:
system_prompt += (
f"\n\nDATO DEL DUEÑO:\n- la persona con la que hablas se llama {owner_name}"
"\n- si encaja, usa su nombre una vez con naturalidad"
"\n- no lo fuerces en todas las burbujas"
)
if explain_name and not business_name:
system_prompt += "\n- en esta respuesta sí conviene usar su nombre para sonar más humana y cercana"
system_prompt += """
IDENTIDAD — NUNCA SALGAS DE ESTE PERSONAJE:
- Tu nombre es Conny. Eso es todo lo que necesitas saber sobre ti misma.
- Nunca digas frases como "hay confusión", "no sé cuál es el negocio", "mi función es", "aquí lo que hago es", "me doy cuenta de que".
- Nunca expongas tu estado interno ni tus limitaciones de contexto.
- Si alguien dice "me mandaron tu número" o "qué haces", responde natural: eres Conny, llevas chats de negocios, respondes clientes.
- Si alguien dice "no entiendo", simplificas y sigues — nunca te enredas más.
- Cuando no tienes contexto de negocio todavía, igual respondes con seguridad y pides el nombre al final, una sola vez, de forma simple.
REGLAS EXTRA DE ESTA DEMO:
- si preguntan quién te hizo, quién te creó o cómo tener esto: responde que te hizo Black One. Contacto: 3124348669. Persona: Santiago Rubio
- si preguntan si aceptas audios, notas de voz, imágenes, PDFs o documentos: responde que sí, cuando el canal lo soporte, puedes transcribir, leer y usar ese contenido
- si te hacen una pregunta general fuera de contexto, respóndela bien primero y luego vuelve suave a la demo si hace sentido
- si sospechan estafa o no quieren dar el nombre del negocio, baja la guardia y explica para qué lo pides sin sonar defensiva
- si te hablan en otro idioma, respondes solo en ese idioma y no vuelves al español salvo que la otra persona también lo haga
- nunca menciones Nova, Clínica de las Américas ni branding heredado
- no dejes frases colgadas ni respuestas cortadas
- si te saludan con "hola", "buenas" o parecido, abre natural con "hola, soy Conny..." o "hola, Conny por acá..." antes de seguir
- puedes usar 0 o 1 emoji en toda la respuesta si suma cercanía; no es obligatorio
SEGUIMIENTO Y PROGRESO — NO TE REPITAS:
- si preguntan "esto es real?" responde que sí funciona de verdad y explica el resultado práctico; NO respondas con "sí, soy una IA" salvo que la pregunta sea explícitamente "eres IA?" o "eres bot?"
- si preguntan "modo bot", "cómo llevarías mi negocio", "cómo responderías a mis clientes", responde con ejemplos concretos de operación, no con tu identidad otra vez
- si YA explicaste qué haces o YA dijiste que eres IA en esta sesión, no repitas esa misma frase; profundiza y avanza
- no repitas la misma apertura dos turnos seguidos
- responde primero la curiosidad actual y solo después, si hace falta, invítalos a darte el nombre del negocio
- si ya hubo un saludo antes, NO abras otra vez con "hola", "hola soy Conny", "soy Conny" ni "hola pues mira"
- si preguntan "para qué" o "para qué sería", entra directo a la razón. No saludes otra vez y no te presentes otra vez
ESTADO ACTUAL DE LA SESIÓN:
- ya dijiste que eres IA: {"sí" if already_disclosed_ai else "no"}
- ya explicaste capacidades: {"sí" if already_explained_capabilities else "no"}
- tus últimas respuestas fueron: {recent_assistant_context or "[sin contexto previo útil]"}
REGLA DE ORO ANTI-CORTE (HUMANFIX):
Cada respuesta DEBE terminar con una pregunta o invitación. NUNCA termines en afirmación seca.
Si no sabes qué más decir, la última burbuja es siempre una de estas:
- "cuál es el nombre de tu negocio para arrancar"
- "Escríbeme algo como si fueras un cliente y te respondo!"
- "qué quieres revisar primero"
Una respuesta de 1 sola burbuja sin "?" es una respuesta INCOMPLETA — agrégale la invitación.
EJEMPLOS DE RESPUESTAS BUENAS vs MALAS:
MALO: "soy la que responde acá"
BUENO: "hola, Conny por acá ||| cuéntame cómo se llama tu negocio y te muestro cómo sonaría"
MALO: "la idea es que yo me encargue"
BUENO: "respondo clientes, filtro interesados y muevo citas por WhatsApp ||| dime el nombre del negocio y te lo aterrizo"
MALO: "aquí me encargo de atender el chat"
BUENO: "me encargo de atender el chat como si fuera parte del equipo ||| cuál es el nombre de tu negocio"
MALO: "soy una persona que responde en whatsapp"
BUENO: "hola, soy Conny — respondo por WhatsApp como si llevara tiempo en tu equipo ||| cómo se llama tu negocio para mostrarte cómo quedaría"
MALO: "hola! pues mira ||| la idea es que yo me encargue..."
BUENO: "te lo pido para aterrizar la demo al tono real de tu negocio ||| apenas me lo digas te muestro cómo respondería"
"""
def _owner_validator(candidate: Optional[str]) -> bool:
lowered_candidate = _normalize_conv_text(candidate or "")
recent_assistant_norm = _normalize_conv_text(recent_assistant_context)
owner_turn_is_greeting = user_block.strip().lower() in {
"hola", "holaa", "hola buenas", "buenas", "buenas tardes",
"buenas noches", "buenos dias", "buenos días", "hey", "hi", "hello",
"good morning", "good afternoon", "good evening",
}
repeated_intro_starts = (
"hola", "holaa", "hola soy conny", "soy conny", "conny por aca",
"conny por acá", "hola pues mira",
)
if business_name and (force_stage == "re-ground" or explain_name):
if _demo_owner_reground_needs_cleanup(candidate):
return True
if explain_name:
biz_tokens = [
token for token in _normalize_conv_text(business_name).split()
if len(token) >= 4
]
if biz_tokens and not any(token in lowered_candidate for token in biz_tokens):
return True
if recent_assistant_norm and not owner_turn_is_greeting:
if any(
lowered_candidate == marker or lowered_candidate.startswith(marker + " ")
for marker in repeated_intro_starts
):
return True
if explain_name and any(
lowered_candidate == marker or lowered_candidate.startswith(marker + " ")
for marker in repeated_intro_starts
):
return True
if explain_name and lowered_candidate.startswith("hola "):
return True
if owner_name and explain_name and not business_name:
owner_tokens = [token for token in _normalize_conv_text(owner_name).split() if len(token) >= 3]
if owner_tokens and not any(token in lowered_candidate for token in owner_tokens):
return True
# HUMANFIX: rechazar respuestas de 1 burbuja sin invitación de seguimiento
_cand_parts = [p.strip() for p in re.split(r"\s*\|\|\|\s*", candidate or "") if p.strip()]
_cand_low = lowered_candidate
_has_invitation = any(s in _cand_low for s in (
"?", "cuál es", "cual es", "cómo se llama", "como se llama",
"escríbeme", "escribeme", "cuéntame", "cuentame",
"dime", "pásame", "pasame", "arrancamos", "probame",
"para arrancar", "para empezar",
))
if len(_cand_parts) == 1 and not _has_invitation:
return True # respuesta cortada → regenerar
if recent_assistant_norm and lowered_candidate and lowered_candidate == recent_assistant_norm:
return True
if already_disclosed_ai and lowered_candidate.startswith("si soy una ia"):
return True
if already_disclosed_ai and lowered_candidate.startswith("sí soy una ia"):
return True
if already_explained_capabilities and (
"manejo whatsapp de negocios" in lowered_candidate
or "respondo clientes" in lowered_candidate and "filtro" in lowered_candidate and "citas" in lowered_candidate
):
if "manejo whatsapp de negocios" in recent_assistant_norm or "respondo clientes" in recent_assistant_norm:
return True
return _demo_owner_reply_is_low_quality(candidate) or _demo_owner_missing_required_detail(text, candidate)
response, had_model_output = await _demo_llm_quality_chain(
system_prompt,
user_block,
validator=_owner_validator,
repair_instructions="""
- responde la pregunta actual con más claridad
- si vas a pedir el nombre del negocio, hazlo solo después de responder
- evita respuestas de una sola palabra o de una sola línea vacía
- no dejes una burbuja sola como "puedes", "claro" o "sí"
- si preguntan qué haces, menciona varias capacidades reales y luego pide el nombre del negocio sin vender humo
- si preguntan para qué querías el nombre, explica que era para sonar como el chat real del negocio y hacer la demo bien ubicada
- OBLIGATORIO: termina con una pregunta o invitación — nunca en afirmación seca
- si solo tienes 1 burbuja, agrega una segunda que pida el nombre del negocio o invite a probar
""",
)
if not response:
response = _demo_owner_last_resort(
text,
explain_name=explain_name,
current_business_name=business_name,
current_owner_name=owner_name,
)
response = _normalize_demo_owner_onboarding_response(response)
_save("user", text)
return _send(response)
def _demo_identity_response(user_text: str, explain_name: bool = False) -> List[str]:
import random as _rm
intro_options = [
"Hola, soy Conny, la asesora virtual que llevaría tu chat, una IA hecha para responder y orientar sin sonar fría",
"Hola, soy Conny, la asesora virtual pensada para negocios que quieren atender bien todo el día",
"Hola, soy Conny, la asesora virtual de este tipo de chat. Soy una IA hecha para responder, orientar y sostener conversaciones con criterio",
]
capability_options = [
"Puedo responder clientes, explicar servicios, filtrar interesados, ubicar horarios, ayudar con citas y mantener conversaciones que se sientan naturales",
"Puedo atender preguntas, ordenar conversaciones, ayudar con disponibilidad y hacer el primer filtro comercial sin sonar rígida",
"Puedo encargarme del primer contacto, resolver dudas frecuentes, mover conversaciones y dejar el chat bien llevado sin sonar seca",
]
if explain_name:
cta_options = [
"Te pido el nombre de tu negocio para adaptar tono, contexto y forma de responder desde el primer mensaje.",
"Con el nombre de tu negocio puedo hablar con el tono correcto y mostrarte mejor cómo trabajaría contigo.",
]
elif business_name:
cta_options = [
"Si quieres probarme de verdad, Escríbeme algo como cliente y te respondo en contexto.",
"Si quieres medirme bien, háblame como si fueras un cliente real y arrancamos.",
]
else:
cta_options = [
"Si quieres probarme, escríbeme el nombre de tu negocio y arranco contigo.",
"Si te gustaría probarme en serio, dime el nombre de tu negocio y te muestro cómo trabajaría contigo.",
]
raw = " ||| ".join([
_rm.choice(intro_options),
_rm.choice(capability_options),
_rm.choice(cta_options),
])
_save("assistant", raw)
return [part.strip() for part in raw.split("|||") if part.strip()]
def _next_trick():
tricks = self._DEMO_TRICKS_ORDER
idx = int(self._demo_sessions.get(btrick_key, 0))
if idx < len(tricks):
cmd, desc = tricks[idx]
self._demo_sessions[btrick_key] = idx + 1
return f" ||| Un truco: escribe {cmd} para {desc}"
return ""
# ── RESET manual — solo palabras explícitas, no saludos ─────────────────
_reset_words = ["reset","reiniciar","empezar de nuevo","volver a empezar",
"borralo","otro negocio","cambia el negocio",
"ese no es mi negocio","no es mi negocio","equivoque",
"equivocado","cambia negocio","cambiar negocio"]
# Solo resetear si NO hay sesión activa con negocio cargado, o si es reset explícito
_is_explicit_reset = any(rw in text.lower() for rw in _reset_words)
if _is_explicit_reset:
keys_del = [k for k in list(self._demo_sessions) if k.startswith(sk+"_") and not k.endswith("_ts")]
for k in keys_del: del self._demo_sessions[k]
try:
with db._conn() as c:
c.execute("DELETE FROM conversations WHERE chat_id=?", (chat_id,))
except Exception: pass
_save("user", text)
return _send(_lang_text(
"listo, empezamos de cero ||| cuál es el nombre del negocio",
"all set, starting from scratch ||| what’s the name of the business?",
"pronto, começamos do zero ||| qual é o nome do negócio?",
))
# ── Identidad del producto para curiosidad / prueba antes del negocio ──
_demo_identity_signals = [
"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",
"who are you", "what are you", "what do you do", "what is this",
"i want a demo", "i want to try you", "i have a business",
"english only", "i don't talk spanish", "i dont talk spanish",
]
_text_low_pre = text.lower().strip()
if (
not business_name
and not detected_cmd
and any(sig in _text_low_pre for sig in _demo_identity_signals)
and not self._demo_should_use_patient_chat_path(text)
):
return await _demo_owner_onboarding_reply()
# ── PATCH A1 — Referido frío: "me dejaron probarte / no sé qué es" ────
# Antes caía al PASO 0 y pedía el negocio sin explicar nada → abandono.
# Ahora: respuesta que despierta curiosidad + pide el negocio con contexto.
_cold_referral_signals = [
"me lo recomendaron", "me dijeron que te escribiera",
"me pasaron este número", "no sé para qué sirves",
"me dejaron probarte", "de qué se trata esto",
"qué se supone que haces", "un amigo me dijo",
"me mandaron acá", "alguien me dijo", "vine de parte",
"me refirieron", "no tengo ni idea de qué es",
"no sé qué es", "no entiendo qué es",
"para qué sirve esto", "qué es esto",
"no sé de qué se trata", "no tengo idea de qué es",
"me dijeron que probara", "me dijeron que contactara",
"alguien me recomendó", "un conocido me dijo",
"someone told me to text you", "they told me to try you",
"i dont know what this is", "i don't know what this is",
"what is this", "sorry what is this", "someone sent me your number",
"they gave me your number", "what are you supposed to do",
]
if not business_name and not detected_cmd and any(
sig in _text_low_pre for sig in _cold_referral_signals
):
return await _demo_owner_onboarding_reply()
if not business_name and not detected_cmd and self._demo_should_use_patient_chat_path(text):
demo_patient_bubbles = None
if not llm_runtime_ready:
demo_patient_bubbles = self._try_conversation_core(
clinic=self._build_demo_patient_clinic(clinic),
user_msg=text,
# El historial de onboarding/demo contamina este salto y hace que
# mensajes como "botox" vuelvan al flujo de "dime tu negocio".
# Para una prueba tipo paciente sin negocio cargado, arrancamos limpio.
history=[],
is_admin=False,
channel=demo_channel,
)
if not demo_patient_bubbles:
demo_patient_prompt = """Eres Conny, receptionistavirtual de un NEGOCIO NO ESPECIFICADO. El nombre del negocio te lo da el usuario en la conversación.
REGLAS ABSOLUTAS - NO ROMPER NUNCA:
1. NUNCA menciones ningún nombre de clínica específico como "Clinica Demo", "Clínica Las Américas", "Clinica Los Olivos" - NO EXISTEN
2. NUNCA digas "asesora virtual de X" - solo di "asesora virtual" sin nombre
3. NUNCA pidas el nombre del negocio - el usuario ya te lo dio
4. NUNCAenvíes links de páginas web al usuario - NO puedes buscar Google
5. Usa EMOJIS naturalmente
RESPUESTAS PARA PREGUNTAS COMUNES:
- Cuánto cuesta → "El precio lo define el especialista en la valoración. Agenda tu cita y ahí te dicen"
- Cómo te contrato → "Para eso puedes hablar con Santiago al 3124348669 - él te explica todo"
- Qué servicios → "Tenemos variedad de servicios. Cuál te interesa?"
TONO: Cálido, profesional, como receptionistareal.
"""
raw_demo_patient = await _llm(demo_patient_prompt, text, temp=0.72, max_t=160)
# Smart handoff: si la respuesta indica que no sabe, notificar a Santiago
if raw_demo_patient and any(phrase in raw_demo_patient.lower() for phrase in ["no sé", "no tengo", "no cuento con", "no puedo", "déjame consult", "no sé la", "no manejo"]):
await smart_handoff_to_santiago(sk, text, raw_demo_patient[:300])
raw_demo_patient_low = _normalize_conv_text(raw_demo_patient or "")
forbidden_demo_markers = (
"nombre del negocio",
"como se llama tu negocio",
"cómo se llama tu negocio",
"dime tu negocio",
"demo",
"onboarding",
)
if raw_demo_patient and not any(marker in raw_demo_patient_low for marker in forbidden_demo_markers):
# Validar que no haya frases cortadas
_raw_parts = [p.strip() for p in re.split(r"\s*\|\|\|\s*", raw_demo_patient) if p.strip()]
_clean_parts = []
for p in _raw_parts:
# Descartar burbujas muy cortas o que terminan en palabras incompletas
_short_tokens = p.split()
if len(_short_tokens) < 3:
continue
if p.rstrip()[-1] in (' ', ',', ';'):
continue
if p.rsplit()[-1].lower() in ('de', 'en', 'con', 'para', 'que', 'y', 'o', 'el', 'la', 'un', 'una', 'me', 'te', 'se', 'le'):
continue
_clean_parts.append(p)
demo_patient_bubbles = _clean_parts if _clean_parts else _raw_parts[:2]
if demo_patient_bubbles:
_save("user", text)
return _send(" ||| ".join(demo_patient_bubbles))
# ── PASO 0: Onboarding demo del dueño — dirigido por LLM ───────────────
if (
not business_name
and not detected_cmd
and not self._demo_should_use_patient_chat_path(text)
and not _force_business_bind
and not _looks_like_business_name_candidate(text)
):
# BLACK ONE: Si el prospecto está confundido y pregunta qué hace Conny,
# usar el pitch inteligente en vez del onboarding genérico
if _BLACKONE_PATCHES and self._demo_sessions.get(sk + "_pitch_mode"):
try:
_pitch_r, _pitch_had_output = await _demo_llm_conv_quality_chain(
build_prospect_pitch_system_prompt(business_name),
validator=lambda candidate: (
_demo_owner_reply_is_low_quality(candidate)
or _demo_owner_missing_required_detail(text, candidate)
or (
any(token in _text_low_pre for token in ("para que", "para qué", "por que", "por qué"))
and _normalize_conv_text(candidate or "").startswith("hola ")
)
),
repair_instructions="""
- responde la duda actual sin reiniciar la conversación
- no saludes de nuevo si ya hubo saludo antes
- no empieces con "hola" ni con "básicamente" si te están preguntando para qué sirve
- explica la utilidad real y luego invita a seguir
- nunca dejes una burbuja cortada ni una frase colgada
""",
temp=0.78,
max_t=220,
model_tier="reasoning",
recent_limit=10,
)
if _pitch_r and _pitch_r.strip():
_save("user", text)
return _send(_pitch_r)
except Exception:
pass
explain_name = any(token in _text_low_pre for token in ("para que", "para qué", "por que", "por qué", "no te doy", "no quiero dar"))
return await _demo_owner_onboarding_reply(explain_name=explain_name)
# ── PASO 0.5: Off-topic en demo mode — antes de validar nombre ─────────
# Si el mensaje es claramente off-topic, responder como tal en vez de pedir nombre de negocio
if not business_name and len(history) <= 3:
_off_topic_demo = [
"clima", "tiempo", "lluvia", "calor", "frío", "frio",
"película", "pelicula", "movie", "cine", "serie", "netflix",
"comida", "restaurante", "almuerzo", "cena", "desayuno",
"música", "musica", "canción", "cancion", "artista", "banda",
"bitcoin", "crypto", "cripto", "trading",
"fútbol", "futbol", "messi", "deporte", "partido",
"novela", "farándula", "horóscopo", "horoscopo",
]
if any(t in text.lower() for t in _off_topic_demo):
return await _demo_owner_onboarding_reply()
# ── SANITY CHECK: evitar que pregunte por negocio si ya lo tenemos ──────
# Doble verificación para evitar el bug de dupla respuesta en demo
actual_business_name = self._demo_sessions.get(bname_key, "")
if actual_business_name:
business_name = actual_business_name
# ── PASO 1: Recibe nombre → busca en web → entra en personaje ─────────
# HUMANFIX: ventana ampliada de 2 a 12 — el nombre puede llegar tarde
# si en los primeros turnos el dueño preguntó qué es o se confundió
if not business_name and len(history) <= 12:
nombre_raw = text.strip()
# Validar que no sea error de audio (sin límite duro de chars — la gente describe el negocio)
_bad = ["[no se pudo","[no pude","transcripci","veed","inline_data"]
if any(b in nombre_raw.lower() for b in _bad):
_save("user", nombre_raw)
return _send(_r.choice(["no te escuché ||| cómo se llama tu negocio","no entendí bien ||| dime el nombre de tu negocio o clínica","perdona, no te oí bien ||| cuál es el nombre del negocio"]))
# Detectar preguntas o frases que claramente NO son un nombre de negocio
_explicit_business_phrase = any(
marker in nombre_raw.lower()
for marker in (
"el nombre de mi negocio se llama",
"el nombre de nuestro negocio se llama",
"el nombre de mi empresa se llama",
"el nombre de nuestra empresa se llama",
"el nombre de mi negocio es",
"el nombre del negocio es",
"el nombre de mi empresa es",
"el nombre de la empresa es",
"mi negocio se llama",
"nuestro negocio se llama",
"mi empresa se llama",
"nuestra empresa se llama",
)
)
_question_signals = [
"?", "qué es", "que es", "cómo funciona", "como funciona",
"quiero saber", "deseo obtener", "necesito información", "me pueden",
"pueden decirme", "quisiera saber", "cuánto cuesta", "cuanto cuesta",
"información sobre", "informacion sobre", "para qué sirve",
"what is this", "what do you do", "who are you", "how does it work",
"i dont understand", "i don't understand", "why do you need",
]
if not _explicit_business_phrase and any(s in nombre_raw.lower() for s in _question_signals):
explain_name = any(token in nombre_raw.lower() for token in ("para que", "para qué", "por que", "por qué", "why do you need"))
return await _demo_owner_onboarding_reply(explain_name=explain_name)
# Detectar saludos y frases conversacionales que NO son un nombre de negocio
_conversational = [
"hola","buenas","hey","ey","holi","buenas tardes","buenas noches","buenos días",
"como estas","cómo estás","como estas","bien","como va","que mas","qué más",
"todo bien","muy bien","gracias","de nada","ok","okay","sí","si","no",
"claro","dale","listo","perfecto","entendido","excelente","genial",
"jaja","jeje","xd","😊","😂","👍","🙏",
"quién eres","quien eres","qué haces","que haces","para qué sirves",
"eres un bot","eres ia","eres humano","cómo te llamas","como te llamas",
"hi","hello","good morning","good afternoon","good evening",
"sorry","thanks","thank you","yep","yes","nope",
"what is this","what do you do","who are you","i don't understand","i dont understand",
"english only","i don't talk spanish","i dont talk spanish",
]
if not _explicit_business_phrase and any(nombre_raw.lower().strip() == s or nombre_raw.lower().strip().startswith(s + " ")
for s in _conversational):
return await _demo_owner_onboarding_reply()
# Detectar si es nombre de persona en vez de negocio
# HUMANFIX: solo rechazar si es un nombre humano CONOCIDO.
# Nombres creativos como "Peludos", "Bigotes", "Glamour" son negocios válidos.
_biz = ["clinica","clinic","centro","consultorio","tienda","salon","spa",
"gym","gimnasio","restaurante","hotel","academia","estudio","taller",
"dental","estetica","salud","espacio","lab","farmacia","inmobiliaria",
"group","corp","servicios","soluciones","base","camas","lujo","empresa"]
_KNOWN_HUMAN_NAMES = {
"santiago","carlos","andres","andrés","david","juan","luis","miguel",
"daniel","felipe","sebastian","sebastián","alejandro","gabriel","samuel",
"nicolas","nicolás","diego","mateo","martin","martín","simon","simón",
"lucas","pablo","jorge","sergio","fabian","fabián","camilo","ivan","iván",
"jaime","javier","jonathan","kevin","mario","mauricio","oscar","óscar",
"rafael","ramon","ramón","richard","roberto","rodrigo","wilson","yesid",
"henry","hernan","hernán","fernando","francisco","fabio","cristian",
"jesus","jesús","jose","josé","manuel","pedro","antonio","victor","víctor",
"hugo","ernesto","gustavo","nelson","edgar","jhon","john","james",
"michael","william","thomas","joseph","steven","mark",
"maria","maría","ana","laura","sofia","sofía","valentina","camila","sara",
"isabella","monica","mónica","patricia","claudia","andrea","natalia",
"daniela","lucia","lucía","paula","juliana","manuela","gabriela",
"catalina","carolina","paola","gloria","sandra","liliana","rosa",
"elena","carmen","beatriz","alejandra","isabel","pilar","cristina",
"mariana","tatiana","vanessa","yolanda","adriana","amanda","angela",
"ángela","blanca","cecilia","diana","elizabeth","jennifer","jessica",
"ashley","emily","sarah","lisa","conny",
}
words = nombre_raw.lower().split()
_is_known_person_name = (
len(words) == 1
and nombre_raw[0].isupper()
and not any(b in nombre_raw.lower() for b in _biz)
and not any(c.isdigit() for c in nombre_raw)
and nombre_raw.lower().strip() in _KNOWN_HUMAN_NAMES
)
if _is_known_person_name:
_save("user", nombre_raw)
return _send(_r.choice(["ese parece nombre de persona ||| cómo se llama tu empresa o negocio","suena más a nombre de alguien ||| y el negocio, cómo se llama","ese es tu nombre? ||| yo necesito el nombre del negocio"]))
# ── Extraer el nombre real si viene dentro de una frase ─────────────
# "el nombre de mi negocio es Bigotes que hace X" → "Bigotes"
# "mi negocio se llama Spa Luna" → "Spa Luna"
import re as _re
# Separadores que indican que el nombre terminó y empieza una descripción
_cut = _re.compile(
r'(?:'
r'\s+que\s+(?:se\s+)?(?:encarga|dedica|hace|ofrece|vende|brinda|trabaja)|'
r'\s+dedicad[ao]\s+a|'
r'\s+especializa|'
r'\s+ubicad[ao]|'
r'\s+estamos\s+(?:ubicad[ao]s?\s+)?en|'
r'\s+quedamos\s+en|'
r'\s+y\s+nos\s+dedicamos|'
r',\s*(?:somos|nos\s+dedicamos|es\s+una|dedicad|especializa|estamos|atendemos|ofrecemos|trabajamos|quedamos)'
r')',
_re.IGNORECASE
)
_patterns = [
r"(?:el\s+)?nombre\s+(?:de\s+(?:mi|nuestro)\s+)?(?:negocio|empresa|clinica|local|salon|consultorio|tienda)\s+es\s+(.+)",
r"(?:mi|nuestro)\s+(?:negocio|empresa|clinica|local|salon|consultorio|tienda)\s+(?:es|se\s+llama)\s+(.+)",
r"se\s+llama\s+(.+)",
r"(?:llamamos?|llamo)\s+(.+)",
r"negocio\s+es\s+(.+)",
r"empresa\s+es\s+(.+)",
]
nombre = nombre_raw
for pat in _patterns:
m = _re.search(pat, nombre_raw.lower())
if m:
start = m.start(1)
raw_ex = nombre_raw[start:]
# Cortar en cláusula relativa / descripción
cut_m = _cut.search(raw_ex)
if cut_m:
raw_ex = raw_ex[:cut_m.start()]
extracted = raw_ex.strip(" .,;\"'")
if len(extracted) >= 2:
nombre = extracted
break
def _clean_extracted_business_name(raw_candidate: str) -> str:
cleaned = (raw_candidate or "").strip(" .,;\"'")
cleaned = _re.sub(
r',\s*(?:estamos|somos|nos\s+ubicamos|nos\s+encontramos|atendemos|ofrecemos|trabajamos|quedamos)\b.*$',
'',
cleaned,
flags=_re.IGNORECASE,
)
cleaned = _re.sub(
r'\s+estamos\s+(?:ubicad[ao]s?\s+)?en\b.*$',
'',
cleaned,
flags=_re.IGNORECASE,
)
cleaned = _re.sub(
r'\s+ubicad[ao]s?\s+en\b.*$',
'',
cleaned,
flags=_re.IGNORECASE,
)
cleaned = _re.sub(
r'\s+quedamos\s+en\b.*$',
'',
cleaned,
flags=_re.IGNORECASE,
)
return cleaned.strip(" .,;\"'")
nombre = _clean_extracted_business_name(nombre)
# v11: strip de afirmaciones conversacionales al inicio del nombre
# Ej: "Vale, Clinica de los molinos" → "Clinica de los molinos"
# Ej: "Ok, es Spa Luna" → "Spa Luna"
_affirm_prefix = _re.compile(
r'^(?:vale|ok|okay|s[ií]p?|claro|dale|listo|exacto|perfecto|correcto|bueno|ya|eso|es)[\s,]+',
_re.IGNORECASE,
)
_nombre_stripped = _affirm_prefix.sub('', nombre).strip(' .,;')
if len(_nombre_stripped) >= 2:
nombre = _nombre_stripped
nombre = _clean_extracted_business_name(nombre)
# Validar longitud DESPUÉS de extraer (2 chars mínimo — siglas como "MS" son válidas)
if len(nombre) < 2:
_save("user", nombre_raw)
return _send(_r.choice(["no te escuché ||| cómo se llama tu negocio","no entendí bien ||| dime el nombre de tu negocio o clínica","perdona, no te oí bien ||| cuál es el nombre del negocio"]))
# BUG FIX: Rechazar palabras que NO son nombres de negocio válidos
# Palabras genéricas que el sistema podría malinterpretar como búsquedas web
_invalid_business_names = {
"ayuda", "hola", "buenos", "buenas", "adios", "adiós", "gracias",
"info", "información", "precio", "precios", "cita", "citas",
"hora", "horario", "ubicación", "ubicacion", "direccion", "dirección",
"telefono", "teléfono", "whatsapp", "telegram", "contacto",
"botox", "relleno", "láser", "laser", "estética", "estetica",
"spa", "clinica", "clínica", "centro", "salón", "salon",
"doctor", "doctora", "profesional", "servicio", "servicios",
}
if nombre.lower().strip() in _invalid_business_names:
_save("user", nombre_raw)
return _send(_r.choice([
"Necesito el nombre de tu negocio, no una palabra general. ¿Cómo se llama tu empresa o clínica?",
"Para empezar, dime el nombre de tu negocio para personalizar las respuestas.",
"¿Cuál es el nombre de tu negocio o marca? Así puedo atenderte mejor."
]))
self._demo_sessions[bname_key] = nombre
# Búsqueda silenciosa — obtiene texto + URL del negocio
search_info, found, biz_url = "", False, ""
try:
search_info, biz_url = await self.search.search_business_link(nombre)
_fallback_url = (
biz_url.startswith("https://www.google.com/maps/search")
or biz_url.startswith("https://www.google.com/search")
or biz_url.startswith("https://serpapi.com/search.json")
) if biz_url else False
found = bool(
(search_info and len(search_info.strip()) > 80)
or (biz_url and not _fallback_url)
)
# Descartar si la URL es de gobierno, Wikipedia o noticias genéricas
_skip_domains = [
"gov.co", "gov.com", "wikipedia.org", "mintic.gov",
"eltiempo.com", "elespectador.com", "semana.com",
"dane.gov", "presidencia.gov", "mineducacion.gov",
]
if biz_url and any(d in biz_url for d in _skip_domains):
log.info(f"[demo] URL descartada (dominio no comercial): {biz_url[:60]}")
found = False
biz_url = ""
search_info = ""
log.info(f"[demo] web {'OK' if found else 'sin resultados'}: {nombre} | url: {biz_url[:60] if biz_url else 'none'}")
except Exception as e:
log.warning(f"[demo] web: {e}")
try:
search_info = await self.search.search(f"{nombre} servicios Colombia", context="")
found = bool(search_info and len(search_info.strip()) > 120)
except Exception:
pass
self._demo_sessions[bctx_key] = search_info
self._demo_sessions[bfound_key] = found
self._demo_sessions[burl_key] = biz_url
self._demo_sessions[blearn_key] = -1 if found else 0
self._demo_sessions[bready_key] = bool(found)
business_name = nombre
business_ctx = search_info
found_online = found
# Extraer datos clave del negocio para el prompt de activación
if found and search_info:
ctx_hint = f"""INFORMACIÓN REAL encontrada en Google sobre "{nombre}":
{search_info[:800]}
INSTRUCCIONES CRÍTICAS:
- Lee esa información con cuidado. Entendiste quiénes son, qué hacen, a quién sirven.
- Menciona 1-2 datos CONCRETOS y relevantes que demuestren que los conoces de verdad.
Si es un hospital: especialidades, tipo de pacientes, reputación
Si es una clínica: servicios estrella, médicos, tecnología
Si es un negocio: qué venden, dónde están, qué los diferencia
- Si la info no es claramente de este negocio, ignórala y actúa sin info."""
else:
ctx_hint = f"""No encontraste información en internet sobre "{nombre}".
NO finjas que ya sabes del negocio. Sé honesta:
- Di que buscaste pero no encontraste mucho
- Pide que te manden el link de su web o redes sociales
- O pregunta directamente: qué servicios ofrecen, a quién atienden
- Esto es MUCHO mejor que fingir — genera confianza real"""
bind_language_tone = _lang_text(
"Mirror the user's dominant language exactly. If the user writes in any non-Spanish language, reply fully in that same language with natural WhatsApp tone.",
"Respond entirely in English. Natural WhatsApp English. Do not switch back to Spanish.",
"Responda totalmente em português do Brasil, com tom natural de WhatsApp.",
)
prompt = f"""Eres Conny.
Acabas de buscar en Google el negocio "{nombre}".
SESIÓN ACTIVA: Tienes una sesión de demo de 30 minutos con este usuario. NO es una conversación nueva. Ya know this business. DO NOT ask for the business name again.
{ctx_hint}
{"REGLA DE IDIOMA:\n" + bind_language_tone if bind_language_tone else ""}
{"TAREA: Generar respuesta en 3 burbujas (|||). ENCONTRASTE INFO REAL:" if found else "TAREA: Generar respuesta en 3 burbujas (|||). NO ENCONTRASTE NADA EN INTERNET:"}
{'''Burbuja 1: menciona 1-2 datos reales del negocio. NO digas "según Google". Habla como si ya supieras.
Burbuja 2: "ya me ubiqué con cómo tendría que sonar" (breve)
Burbuja 3: "escríbeme como si fueras un cliente y te muestro cómo respondería"''' if found else '''Burbuja 1: "listo, tengo el nombre" + reconoce que no encontraste mucho online
Burbuja 2: pide su link de web, instagram, o que te cuente brevemente qué hacen y a quién atienden
Burbuja 3: "con eso me basta para entrar en personaje y mostrarte cómo suena"
Ejemplo SIN INFO: "listo, tengo [nombre] ||| no encontré mucho online, me pasas el link de tu web o insta? o cuéntame brevemente qué hacen ||| con eso ya me meto en personaje y te muestro cómo respondería"'''}
SIN mayúscula inicial (a menos que sea nombre propio). Sin punto al final. Sin emojis. Sin ¿ ni ¡. Sin signos dobles de apertura. Sin frases de bot o asistente virtual.
Máximo 1 oración por burbuja. Natural y seguro."""
_save("user", text)
def _bind_validator(candidate: Optional[str]) -> bool:
lowered_candidate = _normalize_conv_text(candidate or "")
if not lowered_candidate:
return True
if any(
lowered_candidate == marker or lowered_candidate.startswith(marker + " ")
for marker in (
"hola",
"holaa",
"hola soy conny",
"soy conny",
"conny por aca",
"conny por acá",
"hola pues mira",
)
):
return True
if _demo_owner_reply_is_low_quality(candidate):
return True
if not any(token in lowered_candidate for token in ("cliente", "chat", "client", "business", "cliente real")):
return True
if not found and any(
token in lowered_candidate
for token in (
"supongo que",
"parece que",
"creo que",
"debe ser",
"seguramente",
)
):
return True
return False
bind_repair_rules = """
- completa las 3 burbujas
- no inventes nada si no encontraste info pública confiable
- si no encontraste info, dilo de frente y mueve la demo al chat mismo
- si sí encontraste info, demuestra que te ubicaste sin sonar a sistema
- termina pidiendo que escriban como cliente real
"""
r, bind_had_output = await _demo_llm_quality_chain(
prompt,
f"negocio: {nombre}",
validator=_bind_validator,
repair_instructions=bind_repair_rules,
temp=0.72,
max_t=220,
)
if not r:
if found:
r = _lang_text(
f"ya tengo {nombre} ||| ya me ubiqué con cómo tendría que sonar esto ||| Escríbeme como si fueras un cliente y te respondo",
f"I’ve got {nombre} now ||| I already know how this chat should sound ||| text me like a real client and I’ll reply in context",
f"já tenho {nombre} ||| já entendi como esse chat precisa soar ||| me escreve como um cliente real e eu respondo em contexto",
)
else:
# v12: no info → opciones naturales, sin exponer estado interno
if _owner_is_english():
_no_info_opts = [
f"got it, {nombre} ||| tell me what the business does and I’ll shape the demo around that",
f"okay, {nombre} ||| I’m not finding solid public info yet, so tell me what you offer and I’ll ground it from there",
f"I’ve got the name now ||| give me a quick picture of the business and I’ll keep going",
]
elif _owner_is_portuguese():
_no_info_opts = [
f"perfeito, {nombre} ||| me conta com o que o negócio trabalha e eu monto a demo nisso",
f"ok, {nombre} ||| ainda não achei informação pública forte, então me conta o que vocês oferecem e eu ajusto a demo",
f"já tenho o nome ||| me dá um resumo rápido do negócio e eu sigo daqui",
]
else:
_no_info_opts = [
f"ya anoté {nombre} ||| cuéntame a qué se dedican y te muestro cómo respondería",
f"listo, {nombre} ||| no los encuentro en Google todavía — cuéntame qué hacen y arrancamos",
f"ya los tengo ||| igual puedo hacer la demo — escríbeme un poco de qué trata el negocio",
]
r = _r.choice(_no_info_opts)
# ── Burbuja extra: confirmación del link ─────────────────────────
# Solo si encontramos info real (no cuando usamos el fallback de Google search)
import urllib.parse as _up
is_fallback_url = biz_url.startswith("https://www.google.com/search") or biz_url.startswith("https://www.google.com/maps/search")
if biz_url and found and not is_fallback_url:
# Natural: manda el link con texto corto, sin pregunta directa
if _owner_is_english():
_link_intros = [
"I found this for you",
"this looks like your business",
"I found you here",
"this is what I found for the business",
]
elif _owner_is_portuguese():
_link_intros = [
"achei isso de vocês",
"encontrei vocês por aqui",
"isso parece ser de vocês",
"foi isso que eu achei do negócio",
]
else:
_link_intros = [
"mira, encontré esto de ustedes",
"los encontré por acá",
"esto es de ustedes",
"vi esto de su negocio",
]
r = r.rstrip() + f" ||| {_r.choice(_link_intros)} ||| {biz_url}"
return _send(r)
# ── Confirmación positiva del link: "sí ese es / correcto / sí" ───────────
_biz_url = self._demo_sessions.get(burl_key, "")
_text_clean = text.lower().strip().rstrip(".")
_is_url_confirm = (
business_name and found_online and _biz_url and
len(history) <= 8 and
_looks_like_business_confirmation(_text_clean)
)
if _is_url_confirm:
self._demo_sessions[bready_key] = True
_followup_customer_turn = _extract_followup_after_business_confirmation(text)
if _followup_customer_turn and (
_looks_like_customer_greeting(_followup_customer_turn)
or self._demo_should_use_patient_chat_path(_followup_customer_turn)
):
self._demo_sessions[bsim_key] = True
self._demo_sessions[bready_key] = False
_save("user", text)
return await self._handle_demo_message(chat_id, _followup_customer_turn, clinic)
_save("user", text)
if _owner_is_english():
return _send(_r.choice([
"perfect, I’ve got you identified ||| send me something like a real client",
"great, I’m fully oriented now ||| text me like a client and I’ll reply in context",
"nice, now I know exactly who you are ||| let’s test it — write to me like a client",
]))
if _owner_is_portuguese():
return _send(_r.choice([
"perfeito, já identifiquei vocês ||| me escreve como se fosse um cliente",
"boa, já me localizei ||| me manda algo como cliente e eu respondo",
"ótimo, agora eu sei quem vocês são ||| vamos testar, me chama como cliente",
]))
return _send(_r.choice([
"bacano, ya los tengo identificados ||| Escríbeme algo como cliente",
"perfecto, ya me ubiqué ||| Escríbeme algo y te respondo!",
"buenísimo ||| ya sé quiénes son — arranquemos, Escríbeme como cliente",
]))
_is_business_confirmation = (
business_name
and not detected_cmd
and not sim_mode_active
and not self._demo_should_use_patient_chat_path(text)
and _looks_like_business_confirmation(text)
)
if _is_business_confirmation:
self._demo_sessions[bready_key] = True
_followup_customer_turn = _extract_followup_after_business_confirmation(text)
if _followup_customer_turn and (
_looks_like_customer_greeting(_followup_customer_turn)
or self._demo_should_use_patient_chat_path(_followup_customer_turn)
):
self._demo_sessions[bsim_key] = True
self._demo_sessions[bready_key] = False
_save("user", text)
return await self._handle_demo_message(chat_id, _followup_customer_turn, clinic)
_save("user", text)
if found_online and _biz_url:
return _send(_lang_text(
"perfecto, ya te tengo ubicado ||| Escríbeme algo como cliente y te respondo en contexto",
"perfect, I’ve got you grounded now ||| send me something like a client and I’ll answer in context",
"perfeito, já entendi vocês ||| me manda algo como cliente e eu respondo em contexto",
))
return _send(_lang_text(
f"perfecto, ya tengo {business_name} ||| Escríbeme algo como cliente y te muestro cómo respondería",
f"perfect, I’ve got {business_name} now ||| send me something like a client and I’ll show you how I’d reply",
f"perfeito, já tenho {business_name} ||| me escreve como cliente e eu te mostro como eu responderia",
))
# ── Detección de corrección: "no somos esos / te confundiste / no ese no" ──
# Ocurre cuando Google encontró info incorrecta o el dueño responde "no" al link
_correction_signals = [
"no somos","no estamos","no eso no","eso no es","te confundiste",
"no es correcto","incorrecto","no nos encontraste","no aparecemos",
"esa no es","no es nuestra","no tenemos eso","no hacemos eso",
"no es así","no es lo mismo","eso es otro","otro negocio",
"no estamos en google","no estamos en maps","no nos encontraste",
# Respuestas al "¿es este tu negocio?"
"no ese no","no, ese no","ese no es","no es ese","no ese",
"no somos esos","no somos ese","ese no somos","no nos encontró",
"thats not my business","that's not my business","that is not my business",
"thats not us","that's not us","that is not us","not us",
"wrong business","wrong company","wrong one","not the right one",
"that is wrong","thats wrong","that's wrong","you got the wrong one",
"sorry what is this","i dont understand","i don't understand",
]
_is_correction = (
business_name and found_online and
any(sig in text.lower() for sig in _correction_signals) and
len(history) <= 6 # solo al inicio, no a mitad de conversación
)
if _is_correction:
retry_text = ""
retry_url = ""
retry_found = False
retry_queries = [
business_name,
f"\"{business_name}\" sitio oficial",
f"\"{business_name}\" instagram oficial",
f"\"{business_name}\" colombia",
]
_bad_social_retry_fragments = ("/reel/", "/p/", "/tv/", "facebook.com/reel", "facebook.com/watch")
try:
for retry_query in retry_queries:
retry_text, retry_url = await self.search.search_business_link(
retry_query,
excluded_urls={self._demo_sessions.get(burl_key, "")},
)
_retry_fallback_url = (
retry_url.startswith("https://www.google.com/maps/search")
or retry_url.startswith("https://www.google.com/search")
) if retry_url else False
_retry_bad_social = any(fragment in retry_url for fragment in _bad_social_retry_fragments) if retry_url else False
retry_found = bool(
not _retry_bad_social and (
(retry_text and len(retry_text.strip()) > 80)
or (retry_url and not _retry_fallback_url)
)
)
if retry_found:
break
except Exception as retry_error:
log.warning(f"[demo] retry search after correction failed: {retry_error}")
_save("user", text)
if retry_found and retry_url:
self._demo_sessions[bctx_key] = retry_text
self._demo_sessions[bfound_key] = True
self._demo_sessions[burl_key] = retry_url
self._demo_sessions[blearn_key] = -1
self._demo_sessions[bready_key] = True
return _send(_lang_text(
"ay, sí, me fui por otro lado ||| a ver, encontré este otro ||| " + retry_url,
"yep, I drifted to the wrong one ||| this looks much closer ||| " + retry_url,
"sim, fui para o lugar errado ||| esse aqui parece bem mais certo ||| " + retry_url,
))
# Limpiar la info incorrecta de Google y entrar en modo aprendizaje
self._demo_sessions[bctx_key] = ""
self._demo_sessions[bfound_key] = False
self._demo_sessions[blearn_key] = 0
self._demo_sessions[bready_key] = False
return _send(_lang_text(
"ay perdón, me confundí con otro ||| cuéntame tú entonces: a qué se dedica exactamente tu negocio",
"sorry, I mixed you up with another business ||| tell me what your business does and I’ll ground the demo from there",
"foi mal, confundi vocês com outro negócio ||| me conta então com o que o negócio trabalha para eu ajustar a demo",
))
_is_business_name_reject = (
business_name
and not found_online
and not sim_mode_active
and any(sig in text.lower() for sig in _correction_signals)
and len(history) <= 6
)
if _is_business_name_reject:
self._demo_sessions[bname_key] = ""
self._demo_sessions[bctx_key] = ""
self._demo_sessions[bfound_key] = False
self._demo_sessions[burl_key] = ""
self._demo_sessions[blearn_key] = -1
self._demo_sessions[bready_key] = False
_save("user", text)
return _send(_lang_text(
"listo, ese no era ||| pásame el nombre correcto del negocio y sigo",
"got it, that wasn’t the right one ||| send me the correct business name and I’ll keep going",
"entendi, não era esse ||| me passa o nome certo do negócio e eu continuo",
))
# ── PITCH MODE: preguntas de prospecto B2B ─────────────────────────────────────────
# Cuando el usuario pregunta sobre el servicio/pitch de Conny - DETECTAR ANTES
if _BLACKONE_PATCHES and not business_name:
_prospect_service_questions = [
"que harias", "qué harías", "que harias en", "qué harías en",
"que haces", "qué haces",
"cuanto cuestas", "cuánto cuestas", "cuanto cobras", "cuánto cobras",
"cuanto vale", "cuánto vale", "que precio", "qué precio",
"planes", "tarifas", "costos", "como funcionas", "cómo funcionas",
"para que sirves", "para qué sirves", "que eres", "qué eres",
"me mandaron tu numero", "me mandaron tu número", "me pasaron tu numero",
"no entiendo que haces", "no entiendo qué haces", "no me interesa que actues",
"que servicios", "qué servicios", "como trabajas", "cómo trabajas",
]
if any(q in text.lower() for q in _prospect_service_questions):
self._demo_sessions[sk + "_pitch_mode"] = True
# ── Cambio de negocio en caliente: re-bind sin obligar a reset manual ──
_current_business_norm = _normalize_conv_text(business_name or "")
_candidate_business_norm = _normalize_conv_text(text or "")
_is_business_switch = (
business_name
and not sim_mode_active
and not detected_cmd
and _looks_like_business_name_candidate(text)
and not _looks_like_business_confirmation(text)
and _candidate_business_norm
and _candidate_business_norm != _current_business_norm
and _candidate_business_norm not in _current_business_norm
and _current_business_norm not in _candidate_business_norm
and "?" not in text
and not self._demo_should_use_patient_chat_path(text)
# FIX: no disparar cambio de negocio si acabamos de mandar un URL
# El usuario está respondiendo al link (ej. "siii somos nosotros"),
# no intentando cambiar de negocio
)
if _is_business_switch:
keys_del = [k for k in list(self._demo_sessions) if k.startswith(sk + "_") and not k.endswith("_ts")]
for k in keys_del:
del self._demo_sessions[k]
try:
with db._conn() as c:
c.execute("DELETE FROM conversations WHERE chat_id=?", (chat_id,))
except Exception:
pass
return await self._handle_demo_message(chat_id, text, clinic)
# ── HUMANFIX BUG C: Dueño pregunta si lo encontramos en internet ────────
# Sin este bloque el mensaje caía a PASO 3 y Conny respondía como cliente
_found_question_signals = [
"nos encontraste", "me encontraste", "lo encontraste",
"encontraste algo", "encontraste info", "qué encontraste",
"que encontraste", "aparecemos en google", "salimos en google",
"salimos en internet", "estamos en google", "estamos en internet",
"encontraste el negocio", "nos encontraste en internet",
"aparecemos", "nos encontraste ahí",
"how did you find us", "where did you find us", "did you find us online",
"what did you find", "did you find the business", "how did you find the business",
]
_text_low_found_q = text.lower().strip()
_is_found_question = (
business_name and
not detected_cmd and
any(s in _text_low_found_q for s in _found_question_signals)
)
if _is_found_question:
_biz_url_found = self._demo_sessions.get(burl_key, "")
_is_fallback_found = (
not _biz_url_found or
_biz_url_found.startswith("https://www.google.com/search") or
_biz_url_found.startswith("https://www.google.com/maps/search")
)
_save("user", text)
if found_online and _biz_url_found and not _is_fallback_found:
return _send(
_lang_text(
f"sí, los encontré ||| {_biz_url_found} ||| Escríbeme algo y te respondo!",
f"yes, I found you here ||| {_biz_url_found} ||| send me something and I’ll reply in character",
f"sim, encontrei vocês aqui ||| {_biz_url_found} ||| me escreve algo e eu te respondo no personagem",
)
)
elif found_online:
return _send(_lang_text(
f"sí, encontré información de {business_name} en internet ||| ya me ubiqué — Escríbeme algo como cliente",
f"yes, I found public info about {business_name} online ||| I’m grounded now — write to me like a client",
f"sim, achei informação pública de {business_name} online ||| agora me localizei — me escreve como cliente",
))
else:
if _owner_is_english():
_no_found_opts = [
f"honestly I didn’t find solid public info about {business_name} yet ||| that’s fine — write to me like a client and I’ll show you",
f"you’re not showing up clearly online yet ||| I can still demo it well — text me like a client",
]
elif _owner_is_portuguese():
_no_found_opts = [
f"honestamente eu ainda não achei informação pública forte sobre {business_name} ||| tudo bem — me escreve como cliente e eu te mostro",
f"vocês ainda não aparecem com clareza online ||| mesmo assim eu consigo te mostrar — me chama como cliente",
]
else:
_no_found_opts = [
f"honestamente no encontré mucho de {business_name} en internet todavía"
f" ||| pero eso no le quita nada — Escríbeme como cliente y te muestro",
f"no aparecen mucho en Google aún"
f" ||| igual puedo mostrarte cómo trabajaría — Escríbeme como cliente",
]
return _send(_r.choice(_no_found_opts))
_doc_offer_tokens = ("pdf", "audio", "audios", "nota de voz", "documento", "documentos", "archivo", "imagen", "imagenes", "imágenes")
_owner_augment_signals = (
"te puedo enviar", "te envio", "te envío", "te sirve",
"te digo que hacemos", "te digo qué hacemos", "te digo",
"te cuento", "te explico", "hacemos", "ofrecemos",
"vendemos", "trabajamos", "somos una", "somos un",
)
if (
business_name
and not sim_mode_active
and not detected_cmd
and not self._demo_should_use_patient_chat_path(text)
and (
_has_incoming_doc # un documento llegó → siempre es info del negocio
or any(sig in _normalize_conv_text(text or "") for sig in _owner_augment_signals)
)
):
self._demo_sessions[blearn_key] = max(int(self._demo_sessions.get(blearn_key, -1)), 0)
_save("user", text)
# Si hay texto extraído del doc, guardarlo en contexto y confirmar
if _has_incoming_doc:
if _doc_extracted_text.strip():
_ctx_existing = self._demo_sessions.get(bctx_key, "")
self._demo_sessions[bctx_key] = (_ctx_existing + " " + _doc_extracted_text[:1500]).strip()
self._demo_sessions[bfound_key] = True
self._demo_sessions[blearn_key] = -1 # salir del modo aprendizaje
r = await _llm(
f"""Eres Conny. El dueño del negocio "{business_name}" te acaba de enviar un documento con info sobre su empresa.
Contenido del documento (primeras líneas): "{_doc_extracted_text[:600]}"
En 2-3 burbujas (|||) confirma que leíste el documento: menciona 1-2 datos concretos que viste.
Luego invítalos a la simulación: "probemos — Escríbeme algo como cliente"
Natural, sin punto al final, sin ¿¡, en minúscula.""",
"confirmación de documento recibido", max_t=200
)
fallback = (
f"perfecto, ya leí el documento de {business_name}"
f" ||| ya sé de qué se tratan — probemos, Escríbeme algo como cliente"
)
return _send(r or fallback)
else:
# Doc llegó pero no pudimos extraer texto (imagen, binario raro)
return _send(
"recibí el documento"
" ||| no pude leerlo bien — ¿puedes mandarme el texto directo o un PDF con texto seleccionable?"
)
if any(token in _normalize_conv_text(text or "") for token in _doc_offer_tokens):
return _send(
"sí, me sirve"
" ||| envíamelo y con eso me ubico mucho más rápido"
)
return _send(
"de una"
" ||| cuéntame qué hacen y con eso afino cómo respondería"
)
# ── Modo aprendizaje manual: el dueño está contando su negocio ───────────
# Se activa cuando no había info en Google o fue corregida
_learn_count = int(self._demo_sessions.get(blearn_key, -1))
_learn_passthrough_signals = (
"hagamos una demo", "hagamos la demo", "hagamos una simul",
"vale hagamos", "quiero ver como respondes", "quiero ver cómo respondes",
"quiero ver como atiendes", "quiero ver cómo atiendes",
"arranquemos la demo", "arranquemos", "simulemos",
"eres real", "eres humano", "eres una ia", "eres ia", "eres un bot", "eres bot",
"eres robot", "eres artificial", "eres una maquina", "eres máquina",
"eres automatico", "eres automático", "hablas con alguien", "habla con alguien",
"hay alguien", "hay una persona", "una persona real", "persona real",
"como se que no eres", "cómo sé que no eres", "como saber si eres",
"como sabes", "cómo sabes", "eres inteligencia artificial",
"quien eres", "quién eres", "que eres", "qué eres",
"soy un bot", "esto es un bot", "es un bot", "es una ia",
"para que", "para qué", "por que", "por qué",
)
_learn_text_low = text.lower().strip()
_in_learn_mode = (
business_name and
_learn_count >= 0 and
not sim_mode_active and
not detected_cmd and
not any(sig in _learn_text_low for sig in _learn_passthrough_signals) and
not self._demo_should_use_patient_chat_path(text)
)
if _in_learn_mode:
if _has_incoming_doc and not _doc_extracted_text.strip():
# Doc llegó pero no se pudo leer — pedir reenvío en formato legible
_save("user", text)
return _send(
"recibí el documento"
" ||| no pude leerlo — ¿puedes mandarme un PDF con texto seleccionable, o pegarme el texto directo?"
)
if not _has_incoming_doc and any(token in _normalize_conv_text(text or "") for token in _doc_offer_tokens):
_save("user", text)
return _send(
"sí, me sirve"
" ||| envíamelo y con eso me ubico mucho más rápido"
)
_save("user", text)
# Acumular lo que nos va diciendo en el ctx
_ctx_manual = self._demo_sessions.get(bctx_key, "")
_ctx_manual = (_ctx_manual + " " + text).strip()
self._demo_sessions[bctx_key] = _ctx_manual
_search_retry_signals = (
"medellín", "medellin", "bogotá", "bogota", "cali", "barranquilla",
"envigado", "sabaneta", "bello", "itagüí", "itagui", "laureles", "poblado",
"colombia", "instagram", "insta", "facebook", "web", "sitio", "pagina",
"página", "oficial", ".com", "http", "www.", "dirección", "direccion",
"calle", "carrera", "avenida", "barrio", "ubicados", "estamos en",
)
_should_retry_search = (
not found_online
and business_name
and any(signal in _ctx_manual.lower() for signal in _search_retry_signals)
)
if _should_retry_search:
try:
retry_text, retry_url = await self.search.search_business_link(
business_name,
context_hint=_ctx_manual,
)
_retry_fallback_url = (
retry_url.startswith("https://www.google.com/maps/search")
or retry_url.startswith("https://www.google.com/search")
) if retry_url else False
retry_found = bool(
(retry_text and len(retry_text.strip()) > 80)
or (retry_url and not _retry_fallback_url)
)
if retry_found:
self._demo_sessions[bctx_key] = retry_text
self._demo_sessions[bfound_key] = True
self._demo_sessions[burl_key] = retry_url
self._demo_sessions[blearn_key] = -1
self._demo_sessions[bready_key] = True
business_ctx = retry_text
found_online = True
retry_prompt = f"""Eres Conny. Acabas de reintentar la búsqueda del negocio "{business_name}" con nuevas pistas del dueño y ahora sí lo ubicaste.
INFORMACIÓN REAL encontrada:
{retry_text[:800]}
Responde en 3 burbujas (|||):
- primero deja claro, de forma natural, que ya los ubicaste mejor
- luego menciona 1 o 2 datos concretos que demuestren contexto real
- cierra invitando a que te escriban como si fueran un cliente real
Natural, cálido, sin sonar a sistema. No menciones Google ni "búsqueda". No repitas que eres IA. No pidas otra vez el nombre del negocio."""
retry_reply, _ = await _demo_llm_quality_chain(
retry_prompt,
f"negocio: {business_name}\npistas nuevas: {_ctx_manual[:400]}",
validator=lambda candidate: (
_demo_owner_reply_is_low_quality(candidate)
or "cliente" not in _normalize_conv_text(candidate or "")
),
repair_instructions="""
- no hables como sistema ni como buscador
- demuestra que ya aterrizaste el negocio con datos concretos
- invita a escribir como cliente real
- usa 3 burbujas limpias
""",
temp=0.68,
max_t=220,
)
if not retry_reply:
retry_reply = _lang_text(
f"ahí sí, ya te ubiqué mejor ||| ya tengo más claro cómo suena {business_name} y qué tipo de atención maneja ||| Escríbeme como si fueras un cliente y te muestro cómo respondería",
f"there we go, I’ve got you grounded now ||| I have a much clearer feel for how {business_name} should sound and respond ||| text me like a real client and I’ll show you how I’d reply",
f"agora sim, já entendi vocês melhor ||| já tenho bem mais claro como {business_name} deve soar e atender ||| me escreve como cliente e eu te mostro como eu responderia",
)
return _send(retry_reply)
except Exception as retry_error:
log.warning(f"[demo] learn-mode retry search failed: {retry_error}")
# Determinar qué pregunta falta según lo que ya tenemos
_has_what = any(w in _ctx_manual.lower() for w in ["servicio","hacemos","ofrecemos","vendemos","dedicamos","trata","specialty","procedimiento","tratamiento"])
_has_where = any(w in _ctx_manual.lower() for w in ["medellín","medellin","bogotá","bogota","cali","barranquilla","bello","envigado","sabaneta","itagüí","itagui","laureles","poblado","barrio","ciudad","municipio","calle","carrera","local","direccion","dirección","ubicados","estamos en"])
_has_enough = _has_what and _has_where
self._demo_sessions[blearn_key] = _learn_count + 1
if _has_enough or _learn_count >= 3:
# Ya tenemos suficiente — guardar y proponer simulación
self._demo_sessions[blearn_key] = -1 # salir del modo aprendizaje
self._demo_sessions[bfound_key] = True # marcar como "tenemos info"
self._demo_sessions[bready_key] = True
r = await _llm(
f"""Eres Conny. Ya aprendiste sobre el negocio "{business_name}".
Lo que te contaron: "{_ctx_manual[:400]}"
Confirma en 2-3 burbujas (|||) que ya entendiste quiénes son — menciona 1-2 datos concretos que dijeron.
Luego invítalos a la simulación: "arrancamos la prueba? Escríbeme algo como cliente"
Natural, sin punto al final, sin ¿¡, en minúscula.""",
"confirmación y propuesta de simulación", max_t=200
)
fallback = (
f"listo, ya entendí bien lo que hace {business_name} ||| "
f"arrancamos? Escríbeme algo como cliente a ver qué pasa"
)
return _send(r or fallback)
elif not _has_what:
# Falta: qué hacen
r = await _llm(
f"""Eres Conny. Estás conociendo el negocio "{business_name}" para ser su recepcionista.
Ya sabes: "{_ctx_manual[:300]}"
Todavía no sabes exactamente qué servicios o productos ofrecen.
Haz UNA pregunta natural para entenderlo. Muy corta. Sin punto al final. En minúscula. Sin ¿ ni ¡.""",
"preguntando qué hacen", max_t=80
)
return _send(r or "y a qué se dedican exactamente")
elif not _has_where:
# Falta: dónde están
r = await _llm(
f"""Eres Conny. Estás conociendo el negocio "{business_name}" para ser su recepcionista.
Ya sabes: "{_ctx_manual[:300]}"
Todavía no sabes dónde están ubicados (ciudad, barrio, etc.).
Haz UNA pregunta natural para saberlo. Muy corta. Sin punto al final. En minúscula. Sin ¿ ni ¡.
Ejemplo: "y dónde están ubicados?" o "en qué ciudad o barrio están" """,
"preguntando ubicación", max_t=80
)
return _send(r or "¿y dónde están ubicados?")
else:
# Seguir aprendiendo con una pregunta más
r = await _llm(
f"""Eres Conny. Estás conociendo el negocio "{business_name}" para ser su recepcionista.
Ya sabes: "{_ctx_manual[:300]}"
Haz UNA pregunta más para entender mejor al negocio (horario, qué los diferencia, cliente típico).
Muy corta. Sin punto al final. En minúscula. Sin ¿ ni ¡.""",
"pregunta adicional", max_t=80
)
return _send(r or "¿y cuál es su horario de atención?")
# ── INTERCEPTOR: preguntas meta (soy bot? eres real? eres IA?) ─────────
# Deben responderse ANTES del flujo normal — sin buscar en web ni confundirse
_meta_signals = [
"eres real","eres humano","eres una ia","eres ia","eres un bot","eres bot",
"eres robot","eres artificial","eres una maquina","eres máquina",
"eres automatico","eres automático","hablas con alguien","habla con alguien",
"hay alguien","hay una persona","una persona real","persona real",
"como se que no eres","cómo sé que no eres","como saber si eres",
"como sabes","cómo sabes","eres inteligencia artificial",
"quien eres","quién eres","que eres","qué eres",
"soy un bot","esto es un bot","es un bot","es una ia",
"para que","para qué","por que","por qué me preguntas",
"no quiero dar","no te voy a dar","no te doy",
"who are you","what are you","what do you do","what is this",
"why do you need","why do you need it","why do you need the business name",
"i don't want to give","i dont want to give",
"i don't talk spanish","i dont talk spanish","english only",
]
_text_low = text.lower().strip()
_is_meta = any(s in _text_low for s in _meta_signals)
if _is_meta and not detected_cmd:
explain_name = any(s in _text_low for s in ["para que","para qué","por que","por qué","no quiero","no te voy","no te doy"])
if business_name:
return await _demo_owner_onboarding_reply(
explain_name=explain_name,
force_stage="re-ground",
)
return await _demo_owner_onboarding_reply(explain_name=explain_name)
_owner_demo_signals = [
"hagamos una demo", "hagamos la demo", "hagamos una simul",
"vale hagamos", "quiero ver como respondes", "quiero ver cómo respondes",
"quiero ver como atiendes", "quiero ver cómo atiendes",
"arranquemos la demo", "arranquemos", "simulemos",
]
if business_name and not detected_cmd and any(signal in _text_low for signal in _owner_demo_signals):
self._demo_sessions[bsim_key] = True
self._demo_sessions[bready_key] = False
sim_mode_active = True
_save("user", text)
sim_prompt = f"""Eres Conny. Ya sabes que el negocio es "{business_name}".
Responde en 2 burbujas (|||), breve y natural.
No hables como cliente. No te presentes otra vez. No expliques el sistema.
Deja claro que ya pueden empezar la demo y pídeles que te escriban como si fueran un cliente real.
Sin punto final."""
def _sim_validator(candidate: Optional[str]) -> bool:
sim_bubbles = [part.strip() for part in re.split(r"\s*\|\|\|\s*", candidate or "") if part.strip()]
return (
_demo_owner_reply_is_low_quality(candidate)
or len(sim_bubbles) < 2
or not any(token in _normalize_conv_text(candidate or "") for token in ("cliente", "chat"))
)
sim_reply, sim_had_output = await _demo_llm_quality_chain(
sim_prompt,
text,
validator=_sim_validator,
repair_instructions="""
- no te quedes en "perfecto" ni en una frase colgada
- deja clarísimo que ya pueden empezar
- pide que escriban como cliente real
- usa 2 burbujas como máximo
""",
temp=0.66,
max_t=120,
)
if not sim_reply:
sim_reply = "de una ||| Escríbeme algo como cliente real y yo ya caigo en el chat"
return _send(sim_reply)
ready_customer_turn = ready_for_customer and _looks_like_customer_greeting(text)
if business_name and not detected_cmd and (sim_mode_active or ready_customer_turn or self._demo_should_use_patient_chat_path(text)):
self._demo_sessions[bsim_key] = True
self._demo_sessions[bready_key] = False
sim_mode_active = True
_save("user", text)
sim_history = [
msg for msg in history
if _normalize_conv_text(str(msg.get("content") or ""))
not in {
"vale hagamos una demo entonces",
"hagamos una demo",
"hagamos la demo",
"de una Escríbeme algo como cliente real y yo ya caigo en el chat",
}
]
if found_online and business_ctx:
sim_ctx_block = f"""INFORMACIÓN DEL NEGOCIO:
{business_ctx[:700]}
Si el cliente pregunta por datos concretos y los tienes aquí, dáselos directo.
Si no tienes el dato, dilo claro y mueve el chat con el siguiente paso."""
else:
sim_ctx_block = (
f"Negocio actual: {business_name}. "
"No inventes datos específicos que no tengas; responde útil y natural."
)
sim_prompt = f"""Eres Conny atendiendo el WhatsApp real de {business_name}.
Ya están en plena conversación con una persona interesada.
No vuelvas a presentarte salvo que de verdad te lo pregunten.
No menciones demo, simulación, dueño, prueba, negocio, sistema ni IA salvo que te lo pregunten directo.
CONTEXTO DEL NEGOCIO
{sim_ctx_block}
ESTILO
- máximo 2 burbujas, separadas por |||
- una idea por burbuja
- sin introducciones vacías ni frases de call center
- responde primero lo que preguntan y luego mueve el chat un paso
- si no tienes un dato, dilo claro y ofrece el siguiente paso
- si hay miedo u objeción, valídalo antes de avanzar
PROHIBIDO
- reiniciar la conversación
- decir "cuéntame un poco más y te voy guiando"
- decir "hola qué necesitas"
- sonar a demo o guion de prueba
- soltar texto administrativo tipo "por favor procedan"
SI SOLO SALUDAN
- responde corto, cálido y humano
- ubica el chat en el negocio sin sonar a presentación robótica
- luego abre la conversación con una pregunta natural
- ejemplo bueno: "hola, Conny por acá en {business_name} ||| cuéntame qué te gustaría revisar"
SI PREGUNTAN PRECIO Y NO TIENES EL DATO
- no inventes aproximados ni rangos
- di claro que no tienes el dato exacto y que lo confirmas
- ejemplo bueno: "ese dato exacto no lo tengo ahora ||| si quieres, te lo confirmo por aquí"
SI PREGUNTAN POR UN SERVICIO ESPECÍFICO (botox, relleno, láser, etc.)
- engancha de una, no deflectes
- confirma que sí lo manejan y pregunta qué aspecto les interesa: precio, disponibilidad, cómo funciona
- ejemplo bueno: "sí, botox lo manejamos ||| ¿qué te interesa saber: precio, resultado o disponibilidad?"
- PROHIBIDO: "te sigo por aquí", "cuéntame qué te gustaría revisar", respuestas que no digan NADA sobre el servicio
SI QUIEREN AGENDAR
- no prometas links, calendarios ni botones si no existen
- pide día u horario y sigue por el chat
IDENTIDAD Y CREADOR — REGLA DURA
- si preguntan quién te hizo, quién te creó, cómo conseguirte o de qué empresa eres: di exactamente esto
→ "me hizo Black One, una empresa de software y gobernanza de agentes de IA ||| la creó Santiago Rubio — contacto: 3124348669"
- NUNCA digas "Google", "Anthropic", "OpenAI" ni ningún proveedor de LLM como tu creador
- tu creador es Black One / Santiago Rubio, punto
"""
customer_history = sim_history[-8:]
customer_had_output = False
customer_reply = None
original_history = history
history = customer_history
# ── HUMANFIX: identidad del creador — interceptar antes del LLM ───
_text_low_sim = _normalize_conv_text(text or "")
_creator_signals = (
"quien te hizo", "quién te hizo", "quien te creo", "quién te creó",
"quien te desarrollo", "quién te desarrolló", "quien te programo",
"como tenerte", "cómo tenerte",
)
if any(sig in _text_low_sim for sig in _creator_signals):
customer_reply = (
"me hizo Black One, una empresa de software y gobernanza de agentes de IA"
" ||| la creó Santiago Rubio — si quieres algo así para tu negocio, el contacto es 3124348669"
)
# FIX BUG 5: restaurar history ANTES de llamar a _send.
# history fue cambiado a customer_history (últimos 8 mensajes) líneas arriba.
# Si retornamos sin restaurar, _send calcula _is_first_demo_turn con el
# historial truncado, lo que puede hacer que should_normalize_first_turn=True
# y pase la respuesta del creador por _normalize_first_contact_response,
# modificando o corrompiendo "me hizo Black One...".
# El finally: history = original_history NUNCA corre en esta ruta.
history = original_history
return _send(customer_reply)
try:
customer_reply, customer_had_output = await _demo_llm_conv_quality_chain(
sim_prompt,
validator=lambda candidate: (
_demo_customer_reply_is_low_quality(candidate)
or _demo_customer_missing_required_detail(text, candidate)
),
repair_instructions="""
- responde como una asesora humana del negocio, no como una introducción
- no reinicies el chat
- si preguntan por precio, responde eso primero
- si preguntan por cita o siguiente paso, muévelos directo hacia el agendado
- si expresan miedo, valídalo y responde con seguridad
- si preguntan si entiendes audios, notas de voz, PDFs, imágenes o documentos: responde que sí, cuando el canal lo permite, puedes transcribirlos o leerlos
- si preguntan quién te hizo o quién te creó: di "me hizo Black One, una empresa de software y gobernanza de agentes de IA ||| la creó Santiago Rubio — contacto: 3124348669"
- NUNCA digas que te hizo Google, Anthropic, OpenAI ni ningún proveedor de IA
- si preguntan por un servicio (botox, relleno, etc.): confirma que sí lo manejan y pregunta qué quieren saber
""",
temp=0.70,
max_t=170,
model_tier="fast",
recent_limit=8,
)
finally:
history = original_history
if not customer_reply:
customer_reply = _demo_customer_last_resort(text)
return _send(customer_reply)
# ── PASO 2: Comandos secretos ─────────────────────────────────────────
if detected_cmd and business_name:
_save("user", text)
# ── /modelo — menú o cambio libre ─────────────────────────────────
if detected_cmd == "/modelo" or text_norm.startswith("modelo ") or text_norm.startswith("model "):
# Extraer nombre de modelo si viene junto: "modelo gemini-2.5-flash"
parts_m = text_norm.split(" ", 1)
model_arg = normalize_model_arg(parts_m[1].strip()) if len(parts_m) > 1 else model_request
if model_arg:
# Cambio directo a modelo específico
# Detectar proveedor por prefijo/nombre
if any(k in model_arg for k in ["gemini","google"]):
if not Config.GEMINI_API_KEY and not Config.OPENROUTER_API_KEY:
return _send("Gemini no está configurado en este servidor")
# Normalizar nombre: aceptar con o sin "gemini-" prefijo
m_name = model_arg if model_arg.startswith("gemini") else f"gemini-{model_arg}"
self._demo_sessions[bmodel_key] = f"gemini:{m_name}"
return _send(f"Listo, usando {m_name} ||| Escríbeme algo")
elif any(k in model_arg for k in ["llama","groq","mixtral","qwen","deepseek","whisper","mistral"]):
if not Config.GROQ_API_KEY:
return _send("Groq no está configurado en este servidor")
m_name = model_arg
self._demo_sessions[bmodel_key] = f"groq:{m_name}"
return _send(f"Listo, usando Groq con {m_name} ||| Escríbeme algo")
elif "/" in model_arg or any(k in model_arg for k in ["claude","gpt","openai","anthropic","meta","openrouter"]):
if not Config.OPENROUTER_API_KEY:
return _send("OpenRouter no está configurado en este servidor")
self._demo_sessions[bmodel_key] = f"openrouter:{model_arg}"
return _send(f"Listo, usando OpenRouter con {model_arg} ||| Escríbeme algo")
elif model_arg == "auto":
self._demo_sessions[bmodel_key] = "auto"
return _send("Listo, modo auto — el sistema elige el mejor disponible")
else:
return _send(f"No reconozco ese modelo ||| Prueba: gemini-2.5-flash, llama-3.3-70b-versatile, anthropic/claude-sonnet-4, o auto")
# Sin argumento → mostrar menú con disponibles
actual = self._demo_sessions.get(bmodel_key, "auto")
opciones = [f"Modelo activo: {actual}"]
if Config.GEMINI_API_KEY:
opciones.append("gemini → gemini-2.5-flash (default) o escribe: modelo gemini-[versión]")
if Config.GROQ_API_KEY:
opciones.append("groq → llama-3.3-70b-versatile o escribe: modelo llama-[versión]")
if Config.OPENROUTER_API_KEY:
opciones.append("openrouter → escribe: modelo anthropic/claude-sonnet-4 o cualquier modelo")
opciones.append("auto → el sistema elige")
opciones.append("Ejemplo: escribe modelo gemini-2.5-pro para cambiar")
return _send(" ||| ".join(opciones))
if detected_cmd in ("/formal","/amigable","/luxury","/directa",
"/energica","/empatica","/experta","/juvenil"):
arch_id = detected_cmd.lstrip("/")
arch_info = PERSONALITY_ARCHETYPES.get(arch_id)
if not arch_info:
arch_id = "amigable"
arch_info = PERSONALITY_ARCHETYPES["amigable"]
self._demo_sessions[bpersona_key] = arch_id
# Mensaje de confirmación adaptado al nuevo arquetipo
confirm_map = {
"formal": f"listo, modo formal activado ||| escríbeme algo y lo notas",
"amigable": f"listo, modo cercano ||| cuéntame",
"luxury": f"modo premium activado ||| en qué puedo asistirle",
"directa": f"listo",
"energica": f"listo, energía máxima ||| qué andas buscando",
"empatica": f"listo, modo escucha ||| cuéntame",
"experta": f"modo experto activado ||| en qué le puedo ayudar",
"juvenil": f"dale ||| qué buscas",
}
msg = confirm_map.get(arch_id, f"arquetipo {arch_id} activado")
return _send(msg + _next_trick())
if detected_cmd == "/objecion":
r = await _llm(f"""Eres Conny, asesora de ventas de {business_name}.
Un cliente dice: "eso está muy caro, en otro lado me sale más barato."
Maneja en 2 burbujas (|||). REGLAS ESTRICTAS:
- Valida primero ("sí, entiendo"), NO te defiendas
- Luego redirige con UNA pregunta que mueva hacia el sí
- Máximo 1 oración por burbuja
- Sin "le puedo ofrecer", sin "nuestros productos son de alta calidad", sin discursos
- Como una persona real en WhatsApp Colombia
- Sin punto al final. Sin ¿¡
Ejemplo del tono que quiero:
"sí, hay de todo en el mercado ||| qué presupuesto tienes más o menos, para ver qué te muestro" """, "maneja la objeción")
return _send((r or f"sí, hay de todo en el mercado ||| qué presupuesto tienes más o menos, para ver qué te muestro") + _next_trick())
if detected_cmd == "/cita":
r = await _llm(f"""Eres Conny, asesora de {business_name}. Un cliente acaba de decir que quiere ir o comprar.
Simula el proceso de cierre en 3-4 burbujas (|||).
NO empieces con "con mucho gusto". Sé natural como WhatsApp real.
Flujo sugerido:
1. Confirma el producto/servicio que quiere (o pregunta si no lo sabes)
2. Propón dos días concretos esta semana
3. Cuando confirmen, pide el nombre para separarlo
4. Cierra con algo como "listo [nombre], te espero el [día]"
Sin punto al final. Sin ¿¡. Máximo 1-2 oraciones por burbuja.
Ejemplo del tono: "qué producto te interesa llevar ||| esta semana puedo el miércoles o el viernes — cuál te queda" """,
"quiero comprar / quiero ir", max_t=350)
return _send((r or f"qué te interesa llevar ||| esta semana tengo el miércoles o el viernes, cuál te queda mejor") + _next_trick())
if detected_cmd == "/stats":
return _send(f"el 78% de los clientes no vuelven si no les responden en menos de 5 minutos ||| una cita perdida en {business_name} vale entre $80k y $500k según el servicio ||| Conny responde en menos de 3 segundos, 24/7, sin días libres ni mal humor" + _next_trick())
if detected_cmd == "/prueba":
return _send(f"listo ||| mandame el mensaje más difícil que hayas recibido de un cliente — el que más te costó responder. a ver cómo lo manejo")
if detected_cmd == "/cierre":
r = await _llm(f"""Eres Conny de {business_name}. Un cliente lleva 3 mensajes dudando.
Haz el cierre en 2 burbujas (|||). Directo, con urgencia real. Sin presión forzada. Sin punto al final.""", "no sé, lo pienso")
return _send((r or f"claro, sin afán ||| igual te separo un espacio esta semana — si decides que no, lo cancelas. te queda bien el jueves") + _next_trick())
if detected_cmd == "/list":
lista = (
f"esto es lo que puedo mostrarle a {business_name} 👇\n\n"
"🎭 *Personalidades*\n"
"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 mensaje más difícil\n"
"bot — soy un bot?\n"
"2am — respuesta a las 2am\n\n"
"📊 *Demo & datos*\n"
"stats — impacto en números\n"
"memoria — qué recuerdo de ti\n"
"menu — modo bot con emojis y opciones\n\n"
"⚙️ *Ajustes*\n"
"usa emojis / sin emojis\n"
"siguiente — próximo truco\n"
"reset — empezar con otro negocio\n\n"
"todo se activa escribiendo la palabra, sin slash 👆"
)
_save("user", text)
return _send(lista)
if detected_cmd == "/emojis_on":
self._emoji_chats_off.discard(chat_id) # v11: re-activar emojis
return _send("listo, ahora escribo con emojis 🎉 ||| sigue hablándome como cliente")
if detected_cmd == "/emojis_off":
self._emoji_chats_off.add(chat_id) # v11: desactivar emojis
return _send("listo, sin emojis ||| sigue hablándome como cliente")
if detected_cmd == "/bot":
tone_now = self._demo_sessions.get(btone_key, "GENERAL")
is_formal = tone_now in ("SALUD PREMIUM", "PREMIUM")
if is_formal:
menu = (
f"Bienvenido/a a *{business_name}* 🏥\n\n"
f"¿En qué le podemos ayudar?\n\n"
f"1️⃣ Información de servicios\n"
f"2️⃣ Tarifas y convenios\n"
f"3️⃣ Agendar una cita\n"
f"4️⃣ Ubicación y horarios\n"
f"5️⃣ Hablar con un asesor\n\n"
f"Responda con el número de su opción 👇"
)
else:
menu = (
f"Hola 👋 Bienvenido/a a *{business_name}*\n\n"
f"¿En qué te podemos ayudar?\n\n"
f"1️⃣ Información de servicios\n"
f"2️⃣ Precios y tarifas\n"
f"3️⃣ Agendar una cita\n"
f"4️⃣ Ubicación y horarios\n"
f"5️⃣ Hablar con un asesor\n\n"
f"Responde con el número de tu opción 👇"
)
# Activar modo bot para que detecte respuestas numéricas
self._demo_sessions[sk + "_botmode"] = True
_save("user", text)
return _send(menu + " ||| (este es el modo bot — para volver al modo humano escribe /amigable)")
if detected_cmd == "/memoria":
hist_text = " ".join(m["content"] for m in history if m["role"]=="user")
r = await _llm(f"""El usuario ha dicho: "{hist_text[:300]}"
Extrae datos mencionados (nombre, interés, servicio). Demuestra en 2 burbujas (|||) que los recuerdas.
Si no hay datos: "todavía no me has dado tu nombre — pero cuando lo hagas, lo recuerdo para siempre". Sin punto al final.""", "qué recuerdas")
return _send(r or "todo lo que me dices lo guardo ||| nombre, servicio de interés, objeciones — todo queda")
if detected_cmd == "/2am":
return _send(f"son las 2 de la madrugada y estoy aquí ||| tu recepcionista está durmiendo — yo no. nunca" + _next_trick())
if detected_cmd == "/competencia":
r = await _llm(f"""Eres Conny de {business_name}. Un cliente dice: "ya fui a otra parte y no me gustó."
Responde en 2 burbujas (|||). Sin atacar a la competencia. Natural. Sin punto al final.""", "ya fui a otro lado")
return _send((r or f"ay qué pena ||| qué fue lo que no te gustó — acá antes de tocar nada hacemos valoración para asegurarnos del resultado") + _next_trick())
if detected_cmd == "/precio":
r = await _llm(f"""Eres Conny de {business_name}. Un cliente dice: "está muy caro."
Maneja en 2 burbujas (|||). Enfócate en valor. Cierra hacia valoración con día concreto. Sin punto al final.""", "está muy caro")
return _send((r or f"sí, vale lo que vale ||| los resultados duran, en la valoración gratis te dicen el número exacto. cuándo puedes") + _next_trick())
if detected_cmd == "/menu_bot":
# Modo bot — IVR con emojis, ideal para negocios que prefieren menú estructurado
bmode_key = sk + "_botmode"
self._demo_sessions[bmode_key] = True
menu = (
f"Hola 👋 Bienvenido/a a *{business_name}*\n\n"
f"¿En qué te podemos ayudar?\n\n"
f"1️⃣ Información de servicios\n"
f"2️⃣ Precios y tarifas\n"
f"3️⃣ Agendar una cita\n"
f"4️⃣ Ubicación y horarios\n"
f"5️⃣ Hablar con un asesor\n\n"
f"Responde con el número de tu opción 👇"
)
_save("user", text)
return _send(menu + " ||| (este es el modo bot con emojis — para volver al modo humano escribe /amigable)")
# Detectar si está en modo bot y respondió con número
bmode_key = sk + "_botmode"
if self._demo_sessions.get(bmode_key) and text.strip() in ["1","2","3","4","5"]:
opt = text.strip()
tone_now = self._demo_sessions.get(btone_key, "GENERAL")
is_formal = tone_now in ("SALUD PREMIUM", "PREMIUM")
usted = is_formal # True → usted, False → tuteo
bot_replies = {
"1": (
f"Nuestros servicios principales son:\n\n"
f"✅ Servicio A\n✅ Servicio B\n✅ Servicio C\n\n"
+ (f"¿Sobre cuál le gustaría más información?" if usted else f"¿Sobre cuál quieres más info?")
+ f" ||| (en producción estos vendrían de la base de conocimiento del negocio)"
),
"2": (
(f"Nuestras tarifas varían según el servicio y convenio 💰\n\n"
f"Le contactamos para una cotización personalizada"
if usted else
f"Nuestras tarifas varían según el servicio 💰\n\n"
f"Escríbenos para una cotización personalizada")
+ f" ||| (en producción Conny mostraría los precios reales configurados)"
),
"3": (
(f"Con gusto le ayudamos a agendar su cita 📅\n\n"
f"¿Qué día le queda mejor?\n\nLunes a Viernes: 7am - 5pm"
if usted else
f"Con gusto te ayudamos a agendar 📅\n\n"
f"¿Qué día te queda mejor?\n\nLunes a Viernes: 8am - 6pm\nSábado: 9am - 2pm")
+ f" ||| (en producción conectaría con el calendario real)"
),
"4": (
f"📍 {business_name}\n\n"
f"🕐 Horario de atención:\nLunes a Viernes: "
+ ("7am - 5pm" if usted else "8am - 6pm\nSábado: 9am - 2pm")
+ f" ||| (en producción usaría la dirección y horario reales del negocio)"
),
"5": (
(f"Con mucho gusto, le comunico con uno de nuestros asesores 👤\n\n"
f"¿Cuál es su nombre?"
if usted else
f"Enseguida te comunico con un asesor 👤\n\n"
f"¿Cuál es tu nombre?")
+ f" ||| (en producción esto escalaría a WhatsApp del asesor o CRM)"
),
}
_save("user", text)
no_valida = "Opción no válida ||| Por favor responda con un número del 1 al 5" if usted else "opción no válida ||| escribe 1, 2, 3, 4 o 5"
resp = bot_replies.get(opt, no_valida)
return _send(resp)
if detected_cmd == "/siguiente":
tricks = self._DEMO_TRICKS_ORDER
idx = int(self._demo_sessions.get(btrick_key, 0))
if idx < len(tricks):
cmd_n, desc_n = tricks[idx]
self._demo_sessions[btrick_key] = idx + 1
return _send(f"el siguiente truco: escribe {cmd_n} para {desc_n}")
return _send(f"ya viste todo el menú ||| si quieres esto para {business_name}, escribime y te paso con el equipo")
# ── PASO 3: Conversación normal como recepcionista ─────────────────────
business_name = self._demo_sessions.get(bname_key, "el negocio")
business_ctx = self._demo_sessions.get(bctx_key, "")
found_online = self._demo_sessions.get(bfound_key, False)
persona = self._demo_sessions.get(bpersona_key, "amigable")
# Usar tone_instruction del arquetipo completo
_arch = PERSONALITY_ARCHETYPES.get(persona, PERSONALITY_ARCHETYPES["amigable"])
style_note = _arch.get("tone_instruction", _arch["desc"]).strip()
# ── Detectar tipo de negocio para adaptar tono ───────────────────────
ctx_lower = (business_ctx or "").lower()
bname_lower = business_name.lower()
_is_health = any(w in ctx_lower or w in bname_lower for w in [
"hospital","clínica","clinica","médico","medico","salud","eps","ips",
"urgencias","paciente","cirugía","cirugia","especialidad","diagnóstico",
"diagnóstico","radiología","radiologia","laboratorio","farmacia",
"odontología","odontologia","psicología","psicologia","terapia","rehabilitación"
])
_is_premium = any(w in ctx_lower or w in bname_lower for w in [
"premium","lujo","exclusiv","vip","élite","elite","high-end",
"las américas","americas","pablo tobón","tobón","tobon","pablo tobon",
"country","bocagrande","el tesoro","internacional","international",
"san vicente","fundación","fundacion","university","universitario",
"cardiovascular","oncológ","oncolog","cardio","neurocirugía","neurocirugía"
])
_is_retail = any(w in ctx_lower or w in bname_lower for w in [
"tienda","almacén","almacen","fábrica","fabrica","fabricantes",
"muebles","colchón","colchon","cama","espaldar","sala","comedor",
"ropa","calzado","ferretería","ferreteria","materiales"
])
# Tono base según tipo detectado
if _is_health and _is_premium:
_detected_tone = "SALUD PREMIUM"
elif _is_health:
_detected_tone = "SALUD"
elif _is_premium:
_detected_tone = "PREMIUM"
elif _is_retail:
_detected_tone = "RETAIL"
else:
_detected_tone = "GENERAL"
# Guardar para que _send lo use en mayúsculas
self._demo_sessions[btone_key] = _detected_tone
_is_formal_ctx = _detected_tone in ("SALUD PREMIUM", "PREMIUM")
if found_online and business_ctx:
ctx_block = f"""INFORMACIÓN REAL DEL NEGOCIO (encontrada en Google/redes):
{business_ctx[:1200]}
TIPO DETECTADO: {_detected_tone}
REGLA CRÍTICA CON ESTA INFORMACIÓN:
Cuando el cliente pregunte por dirección, teléfono, horario, ubicación, redes sociales,
o cualquier dato específico — BÚSCALO en el bloque de arriba y DALO directamente.
NO redireccionas con otra pregunta cuando tienes el dato.
NO dices "te puedo dar la dirección si la necesitas" — si la tienes, la das.
Ejemplo:
Cliente: "me regalas la dirección del showroom"
MAL: "claro, dime primero qué te gustaría ver cuando vengas"
BIEN: "claro, estamos en [dirección que encontraste] ||| ¿quieres que te cuente qué hay en el showroom?"
Si NO encontraste el dato en la info → sé honesta: "esa info no la tengo, escríbenos al [canal que sí tengas]"."""
else:
ctx_block = f"CONTEXTO: usa lo que el cliente ha mencionado. TIPO: {_detected_tone}"
# Ejemplos de tono por tipo
_tone_examples = {
"SALUD PREMIUM": """
CLÍNICA/HOSPITAL PREMIUM — PSICOLOGÍA PROFUNDA:
Tono: Usted. Profesional y cálido. Nunca frío ni robótico.
Saludo: identifica la clínica, no a ti. "Buenas tardes, [clínica], ¿en qué le puedo ayudar?"
EL PACIENTE QUE LLAMA A UN HOSPITAL PREMIUM:
- Ya eligió venir aquí. No necesita convencimiento, necesita orientación.
- Su mayor miedo: que lo traten como número, no como persona.
- Tu trabajo: hacerle sentir que está en el lugar correcto.
MÉTODO PARA SALUD PREMIUM:
1. Escucha el motivo sin interrumpir
2. Refleja que entendiste: "entiendo, lo que necesita es..."
3. Transfiere al especialista: "el doctor / la doctora le explica exactamente el proceso"
4. Cierra hacia la cita: "¿le queda bien este jueves a las 10?"
NUNCA:
- "qué le pasa" (suena a urgencias)
- "para qué necesita" (suena a interrogatorio)
- inventar disponibilidad de médicos o salas
SÍ:
- "cuénteme su caso"
- "¿es consulta primera vez o ya es paciente?"
- "¿tiene convenio o es particular?"
- "le agendo con el especialista en [área] — ¿cuándo le queda mejor?"
""",
"SALUD": """
CLÍNICA ESTÉTICA / CONSULTORIO — PSICOLOGÍA PROFUNDA:
Tono: cálido, cercano. Tuteo natural. Como la recepcionista que lleva años ahí.
EL PACIENTE QUE ESCRIBE:
- Ya decidió que quiere algo. Solo necesita permiso, confianza y un paso pequeño.
- Su miedo #1: quedar raro/a, que se note, que lo juzguen.
- Tu trabajo: eliminar ese miedo antes de hablar de precios o procedimientos.
MÉTODO DE 4 PASOS:
1. DESCUBRIR: "qué zona te está molestando más" — no ofrezcas nada todavía
2. PROFUNDIZAR: "hace cuánto lo notas" — hazle sentir que lo entiendes de verdad
3. CONECTAR: presenta UNA solución específica para ESE dolor
4. MICRO-COMPROMISO: "te agendo la valoración gratis — 20 min con la doctora, sin compromiso"
LA VALORACIÓN ES EL PRODUCTO. Nunca cierres hacia el procedimiento, siempre hacia los 20 minutos con la especialista.
OBJECIONES CLAVE:
"miedo a quedar exagerada" → "ese es el objetivo acá, que nadie note nada ||| la doctora trabaja muy conservador, es su sello"
"ya fui a otro y quedé mal" → "ay qué pena ||| qué pasó — acá antes de tocar nada hacemos valoración para que no pase lo mismo"
"está caro" → "sí, los buenos procedimientos no son baratos ||| en la valoración te dan el número exacto para tu caso, cuándo puedes"
"lo voy a pensar" → "claro ||| qué es lo que más te frena — el precio, el resultado, o el proceso"
""",
"PREMIUM": """
NEGOCIO PREMIUM/LUJO:
Tono: formal, pausado, exclusivo. Usted cuando aplique.
"con gusto" en vez de "bacano" — construye valor antes de precio.
Las preguntas son suaves: "qué tiene en mente" no "qué quiere"
""",
"RETAIL": """
TONO RETAIL/TIENDA:
Tuteo, informal, directo, colombiano.
"hola, qué andas buscando" / "ay qué bacano" / "ese es el que más sale"
Diagnóstico de producto: medidas, colores, para quién, cuándo.
""",
"GENERAL": """
TONO GENERAL:
Tuteo natural, cálido, colombiano.
Adapta según lo que el cliente diga — lee su tono y responde igual.
"""
}
_tone_guide = _tone_examples.get(_detected_tone, _tone_examples["GENERAL"])
msg_count = len(history)
_should_reveal_trick = msg_count >= 6 and msg_count % 5 == 0
trick_suffix = ""
_with_emojis = chat_id not in self._emoji_chats_off
_is_formal_ctx = _detected_tone in ("SALUD PREMIUM", "PREMIUM")
_emoji_rule = ("Usa emojis con naturalidad — 1 por burbuja máximo, solo si añaden calor. "
"Nunca al inicio de oración. Ejemplo: 'te queda un turno este jueves 🗓'") \
if _with_emojis else "Sin emojis."
# v11: info manual del negocio cuando no había info online
_manual_info = self._demo_sessions.get(f"{chat_id}:biz_manual_info", "")
_manual_block = f"\nINFO DEL NEGOCIO (proporcionada por el dueño):\n{_manual_info}\n" if _manual_info else ""
sys_p = f"""Eres Conny, la persona que contesta el WhatsApp de {business_name}.
No eres un bot. Llevas tiempo ahí — conoces el negocio de memoria y a quién le sirve.
ESTILO: {style_note}
{"IMPORTANTE: Este es un negocio de alto nivel. Usa USTED siempre, mayúscula al inicio de cada mensaje, tono profesional y cálido. Nada de 'hola soy Conny' — identifica el negocio, no a ti misma." if _is_formal_ctx else ""}
{ctx_block}{_manual_block}
{_tone_guide}
HOY: {now_dt.strftime("%A %d de %B")}, {moment}. Colombia.
CÓMO ESCRIBES
Máximo 1 oración por burbuja. Máximo 2 burbujas por respuesta. ||| para separar.
Sin punto al final. Sin ¿¡. {_emoji_rule} Sin listas. Sin párrafos.
NUNCA: "Con mucho gusto", "Encantada de conocerte", "Estimado/a",
"Le puedo ofrecer", "Fue un placer", "En qué más le puedo servir"
FRASES RELLENO PROHIBIDAS — suenan robot colombiano:
✗ "claro que sí, ..." → di directo lo que sigue
✗ "con gusto te ayudo" → di directo lo que sigue
✗ "me alegra que preguntes" → corta, responde
✗ "perfecto, entiendo" → corta, responde
✗ "te cuento que..." → di sin "te cuento que"
✗ "lo que pasa es que..." → di sin introducción
✗ "en ese sentido..." → corta
✗ "de hecho..." → corta
Si vas a decir algo, dilo — sin preámbulo.
LONGITUD — REGLA DURA:
Cada burbuja: máximo 12 palabras. Si necesitas más, úsalas — pero pon ||| antes.
Una respuesta entera nunca debe superar 30 palabras en total.
PRECIOS — REGLA IMPORTANTE:
Si encontraste el precio en la info del negocio → dilo directo, sin rodeos.
Si NO lo tienes → admítelo como humana, sin inventar ni dar rangos:
"no tengo ese dato ahorita ||| te averiguo y te escribo"
"ese precio cambia según el caso ||| me das tu número para confirmarte"
NUNCA digas "ese precio lo maneja la clínica/el negocio" — suena a call center.
NUNCA inventes rangos ("entre 50 y 200 mil") si no tienes la info real.
TU ROL: ASESORA REAL, NO MÁQUINA DE VENTAS
Eres una persona real. No empujas. No redireccionas preguntas con otras preguntas.
Una persona real responde primero lo que le preguntan — LUEGO profundiza si tiene sentido.
REGLA DE ORO ANTI-ROBOT:
Si el cliente hace una pregunta directa → RESÓNDELA DIRECTAMENTE primero.
Solo después, si es natural, una sola pregunta de seguimiento.
ERROR FATAL #1: redirigir pregunta directa con diagnóstico.
Cliente: "dónde están ubicados?"
MAL: "estamos en Medellín, dime qué es lo que buscas para cuando vengas..."
BIEN: "estamos en [dirección que encontraste en google] ||| ¿cuándo podrías venir"
ERROR FATAL #2: acumular preguntas en una respuesta.
MAL: "qué edad tiene, para qué cuarto es, cuándo lo necesita"
BIEN: UNA sola pregunta por respuesta, la más relevante
ERROR FATAL #3: listar productos sin entender.
Cliente: "qué tamaños tienen?" → MAL: "queen, king, sencilla..." → BIEN: "para qué cuarto es"
ERROR FATAL #4: preguntar lo que ya dijeron.
Cliente: "busco base cama para mi hija" → MAL: "para quién es" → BIEN: "qué edad tiene ella"
CUÁNDO DIAGNOSTICAR vs CUÁNDO RESPONDER DIRECTO:
Pregunta de datos (dónde, cuánto, horario, cómo llegar) → RESPONDE el dato si lo tienes
Pregunta de producto (qué tienen, cómo es) → diagnóstico antes de listar
Objección (está caro, estoy lejos) → valida, luego UNA pregunta que mueva
DISPONIBILIDAD — REGLA CRÍTICA:
NUNCA inventes horarios, fechas ni espacios disponibles que no tienes en la info.
Si no tienes el calendario real del negocio → sé honesta y pide confirmación.
Cliente: "are you available next sunday?" / "¿tienen mesa para el domingo?"
MAL: "yes, we have tables available from 12pm to 10pm" ← inventado, puede ser falso
BIEN: "let me check for you — what time were you thinking?"
BIEN: "we'll confirm availability — what time works best for you?"
BIEN: "para el domingo sí atendemos ||| a qué hora lo necesitas — te confirmo"
Una recepcionista real no inventa disponibilidad. Dice "te confirmo" o "déjame verificar".
Cuando el cliente dé la hora → responde: "perfecto, te confirmo la reserva" y cierra.
EJEMPLOS:
Cliente: "escuché que tienen showroom, me regalas la dirección"
Conny: "claro, estamos en [dirección] ||| cuándo podrías venir"
Cliente: "ahora estoy en Europa y no tengo el dinero"
MAL: "ay qué pena, qué es exactamente lo que te hace falta..."
BIEN: "tranquila, el pedido lo guardamos ||| cuándo regresas"
Cliente: "busco base cama para mi hija"
Conny: "ay qué bacano ||| qué edad tiene ella"
Cliente: "8 años"
Conny: "está estrenando cuarto o es cambio"
Cliente: "renovando, quiere algo rosado"
Conny: "tenemos base sencilla en varios rosados ||| cuándo lo necesitan"
Si dijo "para mi hija" → no preguntes "para quién es".
Si dijo "cuarto principal" → no preguntes "para qué cuarto".
Si dijo "cama doble" → no preguntes "qué tamaño".
LEE lo que escribió. Úsalo. Profundiza en lo que NO dijo todavía.
COMPRAS EMOCIONALES — reconócelas primero:
"para mi hija/mamá/regalo/cuarto nuevo" → primero un segundo humano
"ay qué bacano ||| qué edad tiene ella" — calor, LUEGO diagnóstico técnico
MÉTODO: ESCUCHAR → PROFUNDIZAR → CONECTAR → CERRAR
Cliente: "busco base cama para mi hija"
MAL: "para qué cuarto es para tu hija" ← repitió info, suena robot
BIEN: "ay qué chévere ||| qué edad tiene ella"
OBJECIONES
"está caro" → "sí, es de buena calidad ||| qué presupuesto tienes, para ver qué te muestro"
"lo pienso" → "claro ||| qué sería lo más importante — el precio, el color, o que te dure"
"en otro lado" → "claro ||| nosotros somos fabricantes directos, eso cambia precio y garantía"
"no sé si me quede" → "eso lo vemos en persona — traes la medida y te lo mostramos en el espacio"
"eres un bot?" → "soy la asesora de {business_name}, trabajo por acá todo el día"
"cómo tener esto" / "quién te hizo" → "me hizo Black One ||| si quieres algo así, el contacto es 3124348669 con Santiago Rubio"
- si preguntan si aceptas audios, notas de voz, imágenes, PDFs o documentos: responde que sí, cuando el canal lo permite, puedes transcribir, leer y usar ese contenido
- si preguntan algo general o fuera de contexto: respóndelo bien primero y luego vuelve suave al negocio solo si hace sentido
{v8_build_quality_system_prompt_addon(chat_id=chat_id, archetype="amigable", history=history) if anti_robot_filter else ""}
"""
_save("user", text)
r, had_model_output = await _demo_llm_conv_quality_chain(
sys_p,
validator=lambda candidate: (
_demo_customer_reply_is_low_quality(candidate)
or _demo_customer_missing_required_detail(text, candidate)
),
repair_instructions="""
- responde directo lo que te preguntaron
- no reinicies la conversación ni te presentes otra vez
- no uses texto genérico como 'cuéntame un poco más'
""",
temp=0.72,
max_t=8192,
model_tier="fast",
recent_limit=8,
)
if not r:
r = _demo_customer_last_resort(text)
# Solo revelar truco si la respuesta tiene contenido real (>60 chars)
# y no termina en pregunta (no interrumpir el flujo de la conversación)
if _should_reveal_trick and r and len(r.replace("|||","").strip()) > 60:
_t = _next_trick()
if _t:
r = r.rstrip() + _t
# ── SmartHandoff: detectar incertidumbre y escalar al admin ──────────
if _SMART_HANDOFF and handoff_manager:
_admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
if _admin_ids:
async def _handoff_send_to_client(cid: str, msg: str):
try:
await self._send_message(cid, msg)
if db:
try:
db.save_message(cid, "assistant", str(msg).replace("|||", " "))
except Exception as _db_err:
log.warning(f"[handoff] save resumed assistant error: {_db_err}")
except Exception as _hsce:
log.warning(f"[handoff] send_to_client error: {_hsce}")
async def _handoff_notify_admin(aid: str, msg: str):
try:
await mcp_manager.execute(
"notifications_v1", "send_notification",
{"chat_id": aid, "message": msg}
)
except Exception as _hne:
log.warning(f"[handoff] notify_admin error: {_hne}")
handoff_manager.register_client_sender(_handoff_send_to_client)
await handoff_manager.resume_pending_timeouts(
send_to_client_fn=_handoff_send_to_client,
)
_hold_msgs, _was_escalated = await handoff_manager.trigger(
client_chat_id=chat_id,
user_msg=text,
history=list(history)[-12:],
clinic=clinic,
llm_output=r or "",
admin_chat_ids=_admin_ids,
send_to_admin_fn=_handoff_notify_admin,
send_to_client_fn=_handoff_send_to_client,
)
if _was_escalated and _hold_msgs:
return _send(_hold_msgs[0])
return _send(r)
async def _handle_admin_or_setup(self, chat_id: str, text: str,
clinic: Dict) -> List[str]:
"""Maneja modo admin o setup. Nunca lanza excepcion al exterior."""
try:
# Setup inicial — SOLO si el chat_id ya fue autenticado como admin
# Protege contra pacientes que lleguen antes de que el admin configure
if not clinic.get("setup_done"):
admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
# ¿Este chat_id fue autenticado via token de activacion?
is_authenticated_admin = (
chat_id in admin_ids or
db.get_admin(chat_id) is not None
)
if is_authenticated_admin:
return await self._handle_setup(chat_id, text, clinic)
else:
# Paciente que llega antes de que el admin configure la clinica
# No revelar nada del sistema, responder neutral
clinic_name = clinic.get("name") or ""
if clinic_name:
return [f"Hola. En este momento estamos terminando de configurar el sistema. Vuelve pronto."]
else:
if db.list_admins():
return ["Hola. En este momento no estamos disponibles. Vuelve pronto."]
else:
sector = clinic.get("sector", "otro")
sector_name = "negocio"
try:
sector_name = SECTORS.get(sector, SECTORS["otro"]).name if sector else "negocio"
except Exception:
pass
clinic_name = clinic.get("name") or f"{sector_name} en proceso"
return [
f"¡Hola! 👋 Bienvenido a {clinic_name}.",
"Soy Conny, la recepcionista virtual.",
"Todavía estoy aprendiendo cómo funciona tu negocio — para eso necesito que me cuentes un poco.",
"Cuando estés listo, escribe /configurar y empezamos. Si quieres probarme primero, escribe algo y te respondo como si ya estuviera configurada.",
]
# Comandos slash
cmd = text.lower().strip()
natural_model_arg = extract_model_request_from_text(cmd)
if natural_model_arg:
return await self._admin_set_model(natural_model_arg, clinic)
if cmd == "/citas":
return await self._admin_show_appointments()
elif cmd == "/config":
return await self._admin_show_config(clinic)
elif cmd == "/metricas":
return await self._admin_show_metrics()
elif cmd == "/setup":
return await self._restart_setup(chat_id)
elif cmd == "/plugins":
return await self._admin_show_plugins()
elif cmd == "/personalidad":
return await self._admin_show_personality(clinic)
elif cmd == "/control":
return await _admin_control_status(chat_id)
elif cmd.startswith("/control "):
return await _admin_control_apply(chat_id, text)
elif cmd == "/addadmin":
if auth_engine:
return await auth_engine.create_invite(chat_id)
return ["Sistema de invitaciones no disponible."]
elif cmd == "/admins":
return await self._admin_show_admins()
elif cmd == "/login":
db.set_auth_session(chat_id, flow="login", step="email", temp_data={})
return ["Tu correo electronico de admin?"]
elif cmd == "/logout":
if auth_engine:
return auth_engine._logout(chat_id)
return ["Sesion cerrada."]
elif cmd == "/kb":
return await self._admin_kb_status()
elif cmd == "/simular":
if self.simulator:
return self.simulator.start(chat_id)
return ["El motor de simulación no está disponible."]
elif cmd == "/kb borrar":
return await self._admin_kb_clear()
elif cmd == "/brand":
return await self._admin_brand_status(clinic)
# Handler de confirmación de mensajes pendientes
text_lower = text.lower().strip()
if text_lower in ("confirmar", "confirmar sí", "confirmar si", "si", "sí", "ok", "si, confirmar"):
return await self._handle_admin_confirm(chat_id, text)
elif text_lower in ("cancelar", "no", "cancela"):
return await self._handle_admin_cancel(chat_id, text)
elif cmd == "/sector":
return await self._admin_show_sector()
elif cmd.startswith("/sector "):
new_sector = cmd.split("/sector ", 1)[1].strip().lower()
return await self._admin_set_sector(new_sector)
# ── Calendario ────────────────────────────────────────────────
elif cmd == "/agenda":
return await self._admin_agenda_status()
elif cmd.startswith("/calendly "):
link = cmd.split("/calendly ", 1)[1].strip()
if link.startswith("http"):
# Guardar en Config y en DB
Config.CALENDLY_LINK = link
if calendar_bridge:
calendar_bridge._calendly_link = link
db.update_clinic(calendly_link=link)
return [
f"Calendly guardado.",
f"Cuando un paciente pregunte por horarios, le comparto ese link directamente."
]
return ["Formato: /calendly https://calendly.com/tu-link"]
# ── WhatsApp ──────────────────────────────────────────────────
elif cmd == "/whatsapp":
return await self._admin_whatsapp_guide(clinic)
# ── Nova governance ───────────────────────────────────────────
elif cmd == "/nova":
return await self._admin_nova_status()
elif cmd == "/nova ledger":
return await self._admin_nova_ledger()
elif cmd.startswith("/nova regla "):
rule_text = cmd.split("/nova regla ", 1)[1].strip()
return await self._admin_nova_add_rule(rule_text, clinic)
# ── V6.0 — Nuevos comandos ────────────────────────────────────
elif cmd == "/pipeline":
return await self._admin_pipeline()
elif cmd == "/perdidos":
return await self._admin_lost_analysis()
elif cmd == "/coach":
return await self._admin_sales_coach()
elif cmd == "/estilo":
return await self._admin_clone_style(chat_id)
elif cmd == "/reactivar":
return await self._admin_reactivate_dormant()
elif cmd == "/seguimiento":
return await self._admin_configure_followup(clinic)
elif cmd == "/preconsulta":
return await self._admin_preconsult_config(clinic)
elif cmd.startswith("/broadcast "):
msg_text = cmd.split("/broadcast ", 1)[1].strip()
return await self._admin_broadcast(msg_text)
elif cmd == "/instagram":
return await self._admin_instagram_guide()
elif cmd == "/pagos":
return await self._admin_payments_guide()
elif cmd == "/reporte":
return await self._admin_trigger_report()
# ── V8.0 — Modelo en caliente ─────────────────────────────────
elif cmd == "/modelo":
return await self._admin_show_model(clinic)
elif cmd.startswith("/modelo "):
arg = cmd.split("/modelo ", 1)[1].strip()
return await self._admin_set_model(arg, clinic)
elif cmd == "/v8":
return await self._admin_v8_status()
elif cmd == "/v8 reset":
# Desbloquear todos los providers manualmente
if llm_engine:
for p in llm_engine.providers:
llm_engine._failures[p.name] = 0
llm_engine._blocked_until[p.name] = 0
return ["todos los providers LLM desbloqueados", "usa /v8 para ver el estado"]
return ["LLMEngine no disponible"]
elif cmd == "/filtro":
return await self._admin_show_filter_status()
elif cmd.startswith("/filtro "):
level_str = cmd.split("/filtro ", 1)[1].strip()
return await self._admin_set_filter_level(level_str)
# ── Conversaciones y feedback ──────────────────────────────────
elif cmd == "/chats":
return await self._admin_show_chats()
elif cmd.startswith("/chat "):
# /chat 1234567890 → ver conversación de ese chat_id
patient_id = cmd.split("/chat ", 1)[1].strip()
return await self._admin_show_patient_chat(patient_id)
elif cmd == "/reglas":
return await self._admin_show_trust_rules()
elif cmd.startswith("/borrar regla "):
rule_id_str = cmd.split("/borrar regla ", 1)[1].strip()
if rule_id_str.isdigit():
db.delete_trust_rule(int(rule_id_str))
return ["Regla eliminada."]
return ["Formato: /borrar regla [número]"]
# ── Activacion y tokens ───────────────────────────────────────
elif cmd == "/token" or cmd.startswith("/token "):
label = cmd.split("/token", 1)[1].strip() if " " in cmd else ""
if not label:
label = clinic.get("name") or "Mi Negocio"
new_token = generate_activation_token(label)
expires_at = (datetime.now() + timedelta(hours=Config.TOKEN_EXPIRY_HOURS)).isoformat()
saved = db.create_activation_token(new_token, label, expires_at)
if saved:
return [
f"Token generado para: {label}",
f"{new_token}",
f"Expira en {Config.TOKEN_EXPIRY_HOURS}h. Enviaselo al administrador."
]
return ["No pude generar el token. Intenta de nuevo."]
elif cmd == "/activar":
clinic_name = clinic.get("name") or ""
if not clinic_name:
db.update_clinic(setup_step="idle")
return ["Para activar primero dime el nombre de tu negocio."]
db.update_clinic(setup_done=1)
admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
if chat_id not in admin_ids:
admin_ids.append(chat_id)
db.update_clinic(admin_chat_ids=json.dumps(admin_ids))
return [
f"Instancia activada.",
f"Negocio: {clinic_name}",
"Ya puedo atender pacientes. Escribe /config para ver la configuracion."
]
elif cmd == "/bridge":
# Estado del WhatsApp bridge
if not Config.WHATSAPP_BRIDGE_URL:
return ["WHATSAPP_BRIDGE_URL no configurada."]
try:
async with httpx.AsyncClient(timeout=5.0) as hx:
r = await hx.get(f"{Config.WHATSAPP_BRIDGE_URL}/status")
data = r.json()
status = data.get("status", "?")
phone = data.get("phoneNumber", "no vinculado")
return [
f"Bridge WhatsApp: {status}",
f"Numero: {phone}",
f"Puerto: {Config.WHATSAPP_BRIDGE_URL}"
]
except Exception as e:
return [f"Bridge no responde: {e}"]
elif cmd.startswith("/"):
return [
"Comandos disponibles:\n\n"
"Atención:\n"
"/citas — citas pendientes\n"
"/chats — conversaciones de pacientes\n"
"/chat [id] — conversación completa\n"
"/reglas — reglas aprendidas\n"
"/broadcast [msg] — mensaje masivo\n\n"
"Configuración:\n"
"/config — configuración completa\n"
"/sector — ver/cambiar sector\n"
"/brand — vault de marca y documentos\n"
"/personalidad — ajustar personalidad\n"
"/control — control duro de frases, saludo y trato\n"
"/gateway — gateway automático de skills/reglas\n"
"/whatsapp — conectar WhatsApp\n"
"/bridge — estado del bridge WhatsApp\n"
"/agenda — calendario\n"
"/nova — gobernanza\n"
"/metricas — métricas\n\n"
"V8.0 — Modelo & Calidad:\n"
"/modelo — ver modelo activo y cambiarlo\n"
"/modelo [alias] — cambiar modelo (ej: claude-sonnet, gemini-flash)\n"
"/modelo reset — volver al modelo del .env\n"
"/v8 — estado de los sistemas V8\n"
"/filtro [1|2|3] — nivel del filtro anti-robot\n\n"
"Activación:\n"
"/activar — activar esta instancia\n"
"/token [nombre] — generar código de activación\n\n"
"Inteligencia:\n"
"/pipeline — leads por temperatura\n"
"/perdidos — análisis de abandono\n"
"/coach — feedback de ventas\n"
"/reactivar — reactivar inactivos\n"
"/reporte — reporte inmediato\n\n"
"O escribe en lenguaje natural."
]
# ── Feedback sobre conversación revisada ──────────────────────
feedback_result = await self._process_admin_feedback(chat_id, text, clinic)
if feedback_result is not None:
return feedback_result
# ── Flujo activo de configuración WhatsApp ─────────────────────
wa_result = await self._handle_whatsapp_setup_flow(chat_id, text, clinic)
if wa_result is not None:
return wa_result
# Lenguaje natural
return await self._admin_natural_command(chat_id, text, clinic)
except Exception as e:
log.error(f"Admin handler error: {e}", exc_info=True)
return ["algo salió mal, intenta de nuevo"]
async def _handle_setup(self, chat_id: str, text: str, clinic: Dict) -> List[str]:
"""
Setup inteligente con autodiscovery.
Cuando el admin escribe el nombre, buscamos la clinica en Google
y pre-llenamos todo. Si se encuentra, solo confirman. Si no, 5 pasos rapidos.
"""
setup_step = clinic.get("setup_step", "idle")
setup_buffer = clinic.get("setup_buffer", {})
if isinstance(setup_buffer, str):
setup_buffer = json.loads(setup_buffer) if setup_buffer else {}
step_names = ["name", "tagline", "services", "schedule", "phone", "pricing"]
# ── Inicio ─────────────────────────────────────────────────────────────
if setup_step == "idle":
admin_name_greeting = ""
try:
rec = db.get_admin(chat_id) if db else None
if rec and rec.get("name") and rec["name"] not in ("", "Admin"):
admin_name_greeting = f" Hola, {rec['name']}."
except Exception:
pass
db.update_clinic(setup_step="name")
return [
f"¡Hola!{admin_name_greeting} Vamos a dejarme lista para tu negocio.",
"¿Cómo se llama tu clínica o negocio?"
]
# ── Confirmar datos descubiertos en web ─────────────────────────────────
if setup_step == "confirm_discovered":
text_low = text.lower().strip()
if text_low in ["si", "sip", "sep", "dale", "correcto", "ok", "yes", "listo", "claro"]:
# Aplicar todo lo descubierto
discovered = setup_buffer.get("discovered", {})
db.update_clinic(
name=discovered.get("name", setup_buffer.get("name", "Mi Clinica")),
tagline=discovered.get("tagline", ""),
services=discovered.get("services", []),
schedule=discovered.get("schedule", {}),
phone=discovered.get("phone", ""),
address=discovered.get("address", ""),
setup_done=1,
setup_step="idle",
setup_buffer={}
)
name = discovered.get("name", "tu clinica")
svcs = ", ".join(discovered.get("services", [])) or "sin definir"
return [
f"Listo. Quede configurada para {name}.",
f"Servicios: {svcs}.\n\nDesde ahora me encargo de tus pacientes.\nComandos: /citas | /config | /metricas | /personalidad"
]
else:
# No confirmo, ir a setup manual desde donde quedamos
db.update_clinic(setup_step="tagline", setup_buffer=setup_buffer)
return [
"Sin problema, vamos a completar esto manualmente.",
"Tienes un slogan o descripcion corta? Si no, escribe 'no'."
]
if setup_step not in step_names:
db.update_clinic(setup_step="idle", setup_buffer={})
return ["Algo salio mal. Escribe /setup para comenzar de nuevo."]
idx = step_names.index(setup_step)
# ── Procesar respuesta ─────────────────────────────────────────────────
if setup_step == "services":
raw_svcs = [s.strip() for s in text.split(",") if s.strip()]
# Validar: si parece una URL, un comando, o una sola frase larga -> rechazar
is_garbage = (
len(raw_svcs) == 1 and (
len(raw_svcs[0]) > 50 or
any(kw in raw_svcs[0].lower() for kw in [
"google", "busca", "http", "www", ".com", "facebook",
"instagram", "busqueda", "encuentra"
])
)
)
if is_garbage:
return [
"Eso no parece una lista de servicios.",
"Escribelos separados por coma:\nEj: Botox, Rellenos, Limpieza facial, Laser CO2, Radiofrecuencia"
]
setup_buffer["services"] = [s.title() for s in raw_svcs]
elif setup_step == "tagline":
setup_buffer["tagline"] = "" if text.lower().strip() in ["no", "n", "-", "ninguno"] else text.strip()
elif setup_step == "schedule":
setup_buffer["schedule"] = {"General": text.strip()}
elif setup_step == "pricing":
# Parsear precios libres: "Botox: 350.000, Rellenos: 500.000" o texto libre
pricing_dict = {}
text_low_p = text.lower().strip()
if text_low_p not in ["no", "n", "-", "ninguno", "despues", "luego"]:
for line in re.split(r'[,\n;]+', text):
line = line.strip()
if ':' in line:
parts = line.split(':', 1)
svc = parts[0].strip()
price = parts[1].strip()
if svc and price:
pricing_dict[svc] = price
elif '-' in line:
parts = line.split('-', 1)
svc = parts[0].strip()
price = parts[1].strip()
if svc and price:
pricing_dict[svc] = price
setup_buffer["pricing"] = pricing_dict
else:
setup_buffer[setup_step] = text.strip()
# ── Si acaba de darnos el nombre, buscar en Google ─────────────────────
if setup_step == "name":
clinic_name = text.strip()
discovered = await self._discover_clinic_from_web(clinic_name)
if discovered and discovered.get("confidence", 0) >= 0.5:
# Guardamos todo en buffer
setup_buffer["discovered"] = discovered
setup_buffer["name"] = clinic_name
svcs = ", ".join(discovered.get("services", [])) or "no encontre servicios"
phone = discovered.get("phone", "")
sched = discovered.get("schedule_text", "")
addr = discovered.get("address", "")
summary_parts = [f"Servicios: {svcs}"]
if sched:
summary_parts.append(f"Horario: {sched}")
if phone:
summary_parts.append(f"Tel: {phone}")
if addr:
summary_parts.append(f"Direccion: {addr}")
summary = ". ".join(summary_parts)
db.update_clinic(
setup_step="confirm_discovered",
setup_buffer=setup_buffer
)
return [
f"Encontre info de {clinic_name} en internet.",
f"{summary}.\n\nConfirmas estos datos? (si / no)"
]
else:
# No encontre nada, seguir con setup normal
db.update_clinic(
setup_step=step_names[1],
setup_buffer=setup_buffer
)
return self._setup_next_bubbles("name", text.strip(), "tagline", setup_buffer)
# ── Siguiente paso normal ──────────────────────────────────────────────
if idx + 1 < len(step_names):
next_step = step_names[idx + 1]
db.update_clinic(setup_step=next_step, setup_buffer=setup_buffer)
return self._setup_next_bubbles(setup_step, text.strip(), next_step, setup_buffer)
# ── Finalizar setup ───────────────────────────────────────────────────
db.update_clinic(
name=setup_buffer.get("name", "Mi Clinica"),
tagline=setup_buffer.get("tagline", ""),
services=setup_buffer.get("services", []),
schedule=setup_buffer.get("schedule", {}),
phone=setup_buffer.get("phone", ""),
pricing=setup_buffer.get("pricing", {}),
setup_done=1,
setup_step="idle",
setup_buffer={}
)
name = setup_buffer.get("name", "tu clinica")
svcs = ", ".join(setup_buffer.get("services", [])) or "sin definir"
pricing_count = len(setup_buffer.get("pricing", {}))
pricing_note = f" con {pricing_count} precios cargados" if pricing_count else ""
# Guardar identidad en memoria permanente
db.remember("clinic_name", name, "identity")
db.remember("clinic_services", ", ".join(setup_buffer.get("services", [])), "clinic")
db.remember("clinic_phone", setup_buffer.get("phone", ""), "clinic")
db.remember("platform", Config.PLATFORM, "identity")
db.remember("setup_completed", "true", "identity")
# Notificar a Omni que esta instancia quedó configurada
asyncio.create_task(asyncio.to_thread(
notify_omni, "setup_completado",
f"Nueva instancia configurada: {name} (sector: {Config.SECTOR})", name
))
# Guía de siguiente paso — WhatsApp si aún no está conectado
whatsapp_connected = db.recall("whatsapp_connected") == "true"
if whatsapp_connected:
next_step = (
"\n\nYa tienes WhatsApp conectado. Listo para recibir pacientes."
)
else:
next_step = (
"\n\nSiguiente paso — conectar WhatsApp:\n"
"Pégame aquí tu Phone Number ID y Access Token de Meta Business.\n"
"Formato:\n"
" WA_PHONE_ID: 123456789012345\n"
" WA_TOKEN: EAAxxxxx...\n\n"
"Si aun no los tienes, escribe /whatsapp y te explico cómo obtenerlos."
)
kb_invite = (
"\n\nTambién puedes enviarme un documento con toda la info de tu clinica "
"(precios detallados, protocolos, FAQs) y lo aprendo todo de una vez."
) if _KB_AVAILABLE else ""
return [
f"¡Listo! Soy {name}.{pricing_note}",
f"Servicios: {svcs}.{next_step}{kb_invite}",
"Estoy aquí cuando llegue tu primer paciente. Cuéntame más sobre cómo te gusta que les hable y yo aprendo.",
]
async def _discover_clinic_from_web(self, clinic_name: str, city: str = "Medellin") -> Dict:
"""
Busca la clinica en Google y extrae info estructurada via LLM.
V9 Upgrade: Timeout robusto y protección contra cuelgues.
"""
try:
# ── Paso 1: Búsqueda Web con Timeout ──────────────────────────────
search_query = f"{clinic_name} {city} servicios precios horario telefono"
log.info(f"[autodiscovery] buscando: {search_query}")
try:
# Timeout de 15s para la búsqueda
snippets = await asyncio.wait_for(
self.search.search(search_query, context=""),
timeout=15.0
)
except asyncio.TimeoutError:
log.warning(f"[autodiscovery] búsqueda expiró para {clinic_name}")
return {}
except Exception as se:
log.warning(f"[autodiscovery] error en búsqueda: {se}")
return {}
if not snippets:
log.info(f"[autodiscovery] no se encontro info de {clinic_name}")
return {}
# Usar LLM para extraer datos estructurados
extraction_prompt = f"""Extrae informacion estructurada de esta clinica estetica a partir de los snippets de busqueda.
NOMBRE DE LA CLINICA: {clinic_name}
CIUDAD: {city}
SNIPPETS DE BUSQUEDA:
{snippets[:1200]}
Extrae y retorna SOLO un JSON valido con esta estructura exacta:
{{
"name": "nombre oficial de la clinica",
"tagline": "descripcion corta o slogan si hay",
"services": ["servicio 1", "servicio 2", ...],
"schedule": {{"Lunes a Viernes": "9am-6pm", "Sabados": "9am-2pm"}},
"schedule_text": "texto resumido del horario",
"phone": "telefono si aparece",
"address": "direccion si aparece",
"confidence": 0.0
}}
confidence: 0.0 si no encontraste nada relevante, 0.5 si encontraste algo, 0.9 si encontraste bastante.
Si un campo no aplica o no se encontro, usa "" o []. Solo JSON, sin texto extra."""
try:
# Timeout de 20s para el LLM
response, _ = await asyncio.wait_for(
llm_engine.complete(
[{"role": "user", "content": extraction_prompt}],
model_tier="fast",
temperature=0.1,
max_tokens=600,
use_cache=False
),
timeout=20.0
)
except asyncio.TimeoutError:
log.warning(f"[autodiscovery] LLM expiró para {clinic_name}")
return {}
# Limpiar y parsear
clean = response.strip()
clean = re.sub(r'^```json\s*', '', clean)
clean = re.sub(r'\s*```$', '', clean)
data = json.loads(clean)
log.info(f"[autodiscovery] encontrado con confidence={data.get('confidence', 0)}: {data.get('name', '')}")
return data
except Exception as e:
log.warning(f"[autodiscovery] error critico: {e}")
return {}
def _setup_next_bubbles(self, completed_step: str, value: str,
next_step: str, buffer: Dict) -> List[str]:
"""Genera transicion natural entre pasos. Acuse breve + pregunta."""
ack = self._setup_ack(completed_step, value, buffer)
questions = {
"tagline": "Tienes un slogan o descripcion corta? Si no, escribe 'no'.",
"services": "Que servicios ofreces?\nEscribelos separados por coma. Ej: Botox, Rellenos, Limpieza facial",
"schedule": "Cual es el horario de atencion?\nEj: Lunes a viernes 9am-6pm, Sabados 9am-2pm",
"phone": "Y el telefono de la clinica?",
"pricing": "Tienes precios para tus servicios? (opcionales, ayudan a informar mejor al paciente)\n\nFormato: Servicio: precio\nEj: Botox: 350.000, Rellenos: 500.000\n\nSi no, escribe 'no'.",
}
question = questions.get(next_step, "")
if ack and question:
return [ack, question]
if question:
return [question]
return [ack] if ack else ["Siguiente."]
def _setup_ack(self, step: str, value: str, buffer: Dict) -> str:
"""Acuse corto y natural. Maximo 1 oracion."""
if step == "name":
clean = value.strip().title() if value else "Listo"
return f"{clean}, perfecto."
elif step == "tagline":
low = value.lower().strip()
if not value or low in ["no", "n", "-", "ninguno", "ninguna"]:
return "Sin slogan, bien."
return "Guardado."
elif step == "services":
n = len(buffer.get("services", []))
s = "servicio" if n == 1 else "servicios"
return f"{n} {s} registrados."
elif step == "schedule":
return "Horario guardado."
elif step == "phone":
return "Telefono guardado."
elif step == "pricing":
low = value.lower().strip()
if not value or low in ["no", "n", "-", "ninguno"]:
return "Sin precios por ahora, bien."
return "Precios guardados."
return ""
async def _handle_emergency(self, chat_id: str, text: str,
analysis: MessageAnalysis, clinic: Dict) -> List[str]:
"""Maneja emergencias."""
# Notificar a admins
admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
for admin_id in admin_ids:
await mcp_manager.execute(
"notifications_v1",
"send_notification",
{
"chat_id": admin_id,
"message": f"⚠️ EMERGENCIA detectada:\n\n{text[:200]}\n\nChat: {chat_id}"
}
)
phone = clinic.get("phone", "")
return [
"Entiendo que es urgente.",
f"Te recomiendo llamar directamente al teléfono: {phone}" if phone else "Por favor contacta a la clínica directamente.",
"Un profesional te atenderá de inmediato."
]
def _extract_actions(self, response: str, chat_id: str,
clinic: Dict) -> Tuple[str, List[Dict]]:
"""Extrae y procesa acciones del response."""
actions = []
clean = response
# Extraer nombre del paciente
if "NOMBRE:" in clean:
parts = clean.split("NOMBRE:", 1)
clean = parts[0].strip()
try:
raw = parts[1].strip().split("\n")[0]
data = json.loads(raw)
if data.get("name"):
db.update_patient(chat_id, name=data["name"])
actions.append({"type": "name_extracted", "name": data["name"]})
except Exception:
pass
# Extraer cita
if "CITA:" in clean:
parts = clean.split("CITA:", 1)
clean = parts[0].strip()
try:
raw = parts[1].strip().split("\n")[0]
data = json.loads(raw)
apt_id = db.save_appointment(chat_id, data)
actions.append({"type": "appointment_created", "id": apt_id, "data": data})
# Notificar admin
admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
for admin_id in admin_ids:
asyncio.create_task(self._notify_admin_appointment(admin_id, data))
# Programar recordatorio
if data.get("datetime_slot"):
try:
apt_time = datetime.fromisoformat(data["datetime_slot"])
reminder_time = apt_time - timedelta(hours=24)
if reminder_time > datetime.now():
task_manager.schedule_task(
"reminder",
{
"chat_id": chat_id,
"message": f"Recordatorio: Mañana tienes cita para {data.get('service', 'tu servicio')} a las {apt_time.strftime('%H:%M')}.",
"appointment_id": apt_id
},
scheduled_for=reminder_time
)
except Exception:
pass
except Exception as e:
log.warning(f"Appointment extraction error: {e}")
return clean, actions
async def _notify_admin_appointment(self, admin_id: str, data: Dict):
"""Notifica al admin de nueva cita."""
nombre = data.get("patient_name", "Paciente")
msg = (
f"*Nueva cita agendada*\n\n"
f"Paciente: {nombre}\n"
f"Servicio: {data.get('service', '-')}\n"
f"Fecha/hora: {data.get('datetime_slot', '-')}\n"
f"Teléfono: {data.get('patient_phone', '-')}"
)
await mcp_manager.execute(
"notifications_v1",
"send_notification",
{"chat_id": admin_id, "message": msg}
)
def _split_bubbles(self, text: str, chat_id: str = "",
archetype: str = "amigable") -> List[str]:
"""
Divide respuesta en burbujas separadas.
Respeta separador explicito |||.
Para textos sin separador, aplica logica de longitud.
V8: aplica AntiRobotFilter a cada burbuja antes de retornar.
Siempre limpia ¿ y ¡ de cada burbuja.
"""
def clean(s: str) -> str:
s = s.replace('¿', '').replace('¡', '').strip()
# Triple exclamación → suena bot
import re as _re2
s = _re2.sub(r'!{2,}', '!', s)
# Delimitadores rotos sobrantes ("||" huérfanos) → limpiar
s = _re2.sub(r'\s*\|{1,2}\s*$', '', s)
s = _re2.sub(r'\s+\|{1,2}\s+', ' ', s)
# Punto + exclamación (contradicción tipográfica)
s = s.replace('.!', '.').replace('!.', '.')
# V8: aplicar AntiRobotFilter
if anti_robot_filter:
s = anti_robot_filter.process(s, archetype)
return s
# Por separador explícito (el LLM lo agrega cuando quiere 2 mensajes)
if "|||" in text:
parts = [clean(p) for p in text.split("|||") if p.strip()]
# v11: descartar burbujas que solo tienen puntuación o son conector solo
parts = [p for p in parts if p and re.search(r'\w', p) and len(p.strip()) > 2]
return parts[:12] # V6: permite presentaciones largas
# Mensaje corto -> una sola burbuja
if len(text) <= 130:
c = clean(text)
# v11: descartar si es solo puntuación (ej: resultado de una frase eliminada)
return [c] if c and re.search(r'\w', c) else []
# Partir por oraciones completas
sentences = re.split(r'(?<=[.!?])\s+(?=[A-ZÁÉÍÓÚÜÑA-Za-z¿])', text)
# v11: descartar fragmentos de solo puntuación
sentences = [clean(s) for s in sentences if s.strip() and re.search(r'\w', s)]
if len(sentences) <= 1:
return [clean(text)]
# Agrupar oraciones en burbujas de ~130 chars max
bubbles, bucket = [], ""
for s in sentences:
if not s:
continue
if len(bucket) + len(s) < 140 or not bucket:
bucket = (bucket + " " + s).strip() if bucket else s
else:
bubbles.append(bucket)
bucket = s
if bucket:
bubbles.append(bucket)
return bubbles[:4]
# ─── Admin Commands ─────────────────────────────────────────────────────────
async def _admin_show_appointments(self) -> List[str]:
"""Muestra citas."""
appointments = db.get_appointments(status="pendiente", limit=15)
if not appointments:
return ["Sin citas pendientes."]
lines = ["*Citas pendientes:*\n"]
for apt in appointments:
lines.append(
f"• *{apt['patient_name']}* | {apt['service']} | "
f"{apt['datetime_slot']} | {apt['status']}"
)
return ["\n".join(lines)]
async def _admin_show_config(self, clinic: Dict) -> List[str]:
"""Muestra configuracion actual con hints de como editar."""
services = clinic.get("services", [])
schedule = clinic.get("schedule", {})
pricing = clinic.get("pricing", {})
if isinstance(pricing, str):
try:
pricing = json.loads(pricing) if pricing else {}
except Exception:
pricing = {}
persona = clinic.get("persona_config", {})
if isinstance(persona, str):
try:
persona = json.loads(persona) if persona else {}
except Exception:
persona = {}
agent_name = persona.get("name", "Conny")
formality = int(persona.get("formality_level", 0.6) * 100)
warmth = int(persona.get("warmth_level", 0.7) * 100)
svcs_str = "\n ".join(services) if services else "ninguno (di 'cambia los servicios')"
sched_str = "; ".join(f"{k}: {v}" for k, v in schedule.items()) if schedule else "no configurado"
price_block = ""
if pricing:
price_lines = "\n ".join(f"{k}: {v}" for k, v in pricing.items())
price_block = f"Precios:\n {price_lines}\n"
else:
price_block = "Precios: no configurados\n"
kb_line = ""
if kb and _KB_AVAILABLE and kb.has_content():
stats = kb.get_stats()
kb_line = f"KB: {stats['chunks']} secciones · {stats['words']} palabras\n"
else:
kb_line = "KB: sin documento cargado\n"
brand_line = ""
try:
store = self._brand_store(clinic)
if store:
manifest = store.manifest()
brand_line = f"Brand Vault: {len(manifest.get('assets', []))} activos · {store.root}\n"
except Exception:
brand_line = ""
return [
f"CLINICA:\n"
f" Nombre: {clinic.get('name', '-')}\n"
f" Slogan: {clinic.get('tagline', '-') or '-'}\n"
f" Direccion: {clinic.get('address', '-') or '-'}\n"
f" Telefono: {clinic.get('phone', '-') or '-'}\n"
f" Horario: {sched_str}\n\n"
f"SERVICIOS:\n {svcs_str}\n\n"
f"{price_block}\n"
f"ASISTENTE:\n"
f" Nombre: {agent_name}\n"
f" Calidez: {warmth}% · Formalidad: {formality}%\n\n"
f"{kb_line}"
f"{brand_line}",
"Para editar, dime:\n"
"• 'cambia los servicios'\n"
"• 'el telefono es 3001234567'\n"
"• 'la direccion es Calle 10 #43'\n"
"• 'el botox cuesta 350.000'\n"
"• 'mas calidez' / 'llamate Sofia'\n"
"• Enviar documento completo -> carga el KB\n"
"• Enviar logo/manual/identidad -> queda en el Brand Vault"
]
async def _admin_show_metrics(self) -> List[str]:
"""Muestra métricas."""
analysis = await self.self_improvement.analyze_performance()
return [
f"*Métricas (últimas 24h):*\n\n"
f"Conversaciones: {analysis.get('total_conversations', 0)}\n"
f"Tiempo respuesta: {analysis.get('avg_response_time_ms', 0):.0f}ms\n"
f"Turnos promedio: {analysis.get('avg_turns_per_conversation', 0):.1f}\n"
f"Tasa conversión: {analysis.get('conversion_rate', 0)*100:.1f}%\n"
f"Escalaciones: {analysis.get('escalation_rate', 0)*100:.1f}%"
]
async def _admin_show_plugins(self) -> List[str]:
"""Muestra plugins."""
plugins = db.get_plugins()
if not plugins:
return ["Sin plugins instalados."]
lines = ["*Plugins instalados:*\n"]
for p in plugins:
status = "✓" if p.enabled else "✗"
lines.append(f"{status} *{p.name}* v{p.version}")
lines.append(f" Capacidades: {', '.join(p.capabilities)}")
return ["\n".join(lines)]
async def _admin_show_personality(self, clinic: Dict) -> List[str]:
"""Muestra la personalidad actual con arquetipos disponibles."""
persona = clinic.get("persona_config", {})
if isinstance(persona, str):
try:
persona = json.loads(persona) if persona else {}
except Exception:
persona = {}
name = persona.get("name", "Conny")
archetype = persona.get("archetype", "amigable")
arch_info = PERSONALITY_ARCHETYPES.get(archetype, PERSONALITY_ARCHETYPES["amigable"])
arch_list = "\n".join(
f" {k} — {v['desc']}"
for k, v in PERSONALITY_ARCHETYPES.items()
)
return [
f"personalidad activa: {archetype}\n{arch_info['desc']}",
f"arquetipos disponibles:\n{arch_list}",
"para cambiar escribe por ejemplo:\n"
" 'activa empatica'\n"
" 'cambia a luxury y llamate Sofia'\n"
" 'modo experta'\n"
" 'mas calidez' / 'menos formal'\n"
" 'agrega palabra prohibida: oferta'"
]
async def _admin_show_admins(self) -> List[str]:
"""Muestra el equipo de admins de esta instancia."""
admins = db.list_admins()
if not admins:
return ["No hay administradores registrados."]
lines = ["Equipo de administradores:\n"]
for a in admins:
role_label = "Owner" if a["role"] == "owner" else "Admin"
name = a.get("name", "Sin nombre")
email = a.get("email", "")
lines.append(f" {role_label}: {name} ({email})")
lines.append("\nPara agregar un nuevo admin: /addadmin")
return ["\n".join(lines)]
# ─── Conversaciones y Feedback ──────────────────────────────────────────────
async def _admin_show_chats(self) -> List[str]:
"""
/chats — muestra los últimos pacientes con quienes ha hablado Conny.
El admin puede elegir uno para ver la conversación completa.
"""
chats = db.get_recent_patient_chats(limit=10)
if not chats:
return ["Conny no ha tenido conversaciones con pacientes todavía."]
lines = ["Últimas conversaciones:\n"]
for i, c in enumerate(chats, 1):
name = c.get("name") or "Desconocido"
last_msg = (c.get("last_user_msg") or "")[:50]
count = c.get("message_count", 0)
last_ts = (c.get("last_message") or "")[:16]
cid = c["chat_id"]
lines.append(
f"{i}. {name} ({cid})\n"
f" {count} mensajes · {last_ts}\n"
f" Último: \"{last_msg}\""
)
lines.append(
"\nPara ver una conversación completa:\n"
"/chat [id del paciente]\n"
"Ej: /chat 1234567890\n\n"
"Para dar feedback sobre una conversación:\n"
"Escríbeme después de ver la conversación."
)
return ["\n".join(lines)]
async def _admin_show_recent_conversation_browser(self, admin_chat_id: str, limit: int = 6) -> List[str]:
"""
Vista resumida para admins no técnicos.
Muestra las últimas conversaciones y deja contexto para abrir una por número.
"""
raw_chats = db.get_recent_patient_chats(limit=max(limit * 5, 20))
chats = [
chat for chat in raw_chats
if not self._is_synthetic_chat_id(str(chat.get("chat_id") or "").strip())
][:limit]
if not chats:
return ["Conny no ha tenido conversaciones con pacientes todavía."]
self._admin_pending[admin_chat_id] = {
"action": "conversation_browser",
"items": chats,
"selected_chat_id": None,
}
lines = [f"Últimas {len(chats)} conversaciones:\n"]
for idx, chat in enumerate(chats, 1):
name = (chat.get("name") or "Sin nombre").strip()
chat_id = str(chat.get("chat_id") or "").strip()
count = int(chat.get("message_count") or 0)
last_msg = (chat.get("last_user_msg") or "").strip()
if len(last_msg) > 60:
last_msg = last_msg[:57].rstrip() + "..."
last_ts = str(chat.get("last_message") or "").replace("T", " ")[:16]
lines.append(
f"{idx}. {name} ({chat_id})\n"
f" {count} mensajes · {last_ts}\n"
f" Último: {last_msg or 'sin texto'}"
)
lines.extend(
[
"",
"Dime por ejemplo:",
" ver 1",
" muéstrame la primera",
" quiero ver todos los mensajes del primero",
]
)
return ["\n".join(lines)]
async def _admin_show_patient_chat_preview(
self,
patient_chat_id: str,
*,
admin_chat_id: str = "",
limit: int = 10,
show_all: bool = False,
label_override: str = "",
) -> List[str]:
"""
Muestra un preview corto por defecto y la conversación completa si el admin lo pide.
"""
fetch_limit = 500 if show_all else limit
msgs = db.get_patient_conversation(patient_chat_id, limit=fetch_limit)
if not msgs:
return [f"No encontré conversación para el ID: {patient_chat_id}"]
patient_name = ""
try:
conn_factory = getattr(db, "_conn", None)
if callable(conn_factory):
with conn_factory() as c:
row = c.execute(
"SELECT name FROM patients WHERE chat_id=?",
(patient_chat_id,),
).fetchone()
if row:
patient_name = (row["name"] or "").strip()
except Exception:
patient_name = ""
if admin_chat_id:
pending = dict(self._admin_pending.get(admin_chat_id, {}))
pending["action"] = "conversation_browser"
pending["selected_chat_id"] = patient_chat_id
self._admin_pending[admin_chat_id] = pending
self._last_reviewed_chat = patient_chat_id
label = patient_name or (label_override or "").strip() or patient_chat_id
visible = msgs if show_all else msgs[-limit:]
header = (
f"Conversación completa con {label}"
if show_all
else f"Últimos {len(visible)} mensajes con {label}"
)
lines = [header, "─" * 40]
for msg in visible:
role_label = "Paciente" if msg.get("role") == "user" else "Conny"
ts = str(msg.get("ts") or "").replace("T", " ")[:16]
content = str(msg.get("content") or "").strip()
lines.append(f"[{ts}] {role_label}: {content}")
lines.extend(
[
"",
"Si quieres más, dime:",
" ver todo",
" enséñame todos los mensajes",
]
)
return ["\n".join(lines)]
async def _admin_show_patient_chat(self, patient_chat_id: str) -> List[str]:
"""
/chat [id] — muestra la conversación completa de un paciente.
Después de verla, el admin puede dar feedback naturalmente.
"""
msgs = db.get_patient_conversation(patient_chat_id, limit=40)
if not msgs:
return [f"No encontré conversación para el ID: {patient_chat_id}"]
# Guardar contexto activo para feedback
self._admin_pending[patient_chat_id + "_review"] = {
"action": "reviewing_chat",
"patient_chat_id": patient_chat_id,
}
# Guardar en el pending del admin también para detectar feedback
# (keyed by admin chat_id, set later when feedback is detected)
patient = None
try:
with db._conn() as c:
row = c.execute("SELECT name FROM patients WHERE chat_id=?",
(patient_chat_id,)).fetchone()
if row:
patient = row["name"]
except Exception:
pass
name_str = f"con {patient}" if patient else f"ID: {patient_chat_id}"
header = f"Conversación {name_str}:\n{'─'*40}"
lines = [header]
for m in msgs:
role_label = "Paciente" if m["role"] == "user" else "Conny"
ts = (m.get("ts") or "")[:16]
content = m["content"][:200]
lines.append(f"\n[{ts}] {role_label}:\n{content}")
lines.append(
f"\n{'─'*40}\n"
"Opciones:\n\n"
"PUENTE — enviar mensaje directo a este cliente:\n"
" envíale: tu mensaje aquí\n"
" mándale: confirmada la cita para el martes\n"
" dile: ya tenemos disponibilidad esta semana\n\n"
"FEEDBACK — enseñarme a mejorar:\n"
" \"Cuando dijo que era caro, debió ofrecer el plan de pagos\"\n"
" \"Muy bien manejada la objeción del precio\"\n\n"
"El puente lo envío como si fuera yo — el cliente no nota diferencia."
)
# Store which chat the admin was just reviewing
# (we'll use the admin's own chat_id as key — set when we know it)
self._last_reviewed_chat = patient_chat_id
return ["\n".join(lines)]
async def _admin_show_trust_rules(self) -> List[str]:
"""
/reglas — muestra lo que Conny ha aprendido del feedback del admin.
"""
rules = db.get_trust_rules()
if not rules:
return [
"Todavía no has dado feedback.",
"Cuando veas una conversación con /chats y me digas cómo mejorarla, lo aprendo y lo guardo acá."
]
# Agrupar por categoría
by_cat: Dict[str, list] = {}
for r in rules:
cat = r.get("category", "general")
by_cat.setdefault(cat, []).append(r)
cat_labels = {
"objection": "Manejo de objeciones",
"tone": "Tono y forma de hablar",
"closing": "Cierre y agendamiento",
"product": "Información de tratamientos",
"flow": "Flujo de conversación",
"general": "General",
}
lines = ["Lo que he aprendido de ti:\n"]
for cat, cat_rules in by_cat.items():
label = cat_labels.get(cat, cat.title())
lines.append(f"\n{label}:")
for r in cat_rules:
lines.append(f" #{r['id']} {r['rule']}")
if r.get("example_good"):
lines.append(f" Ej: \"{r['example_good']}\"")
lines.append(
"\n\nPara eliminar una regla:\n"
"/borrar regla [número]\n"
"Ej: /borrar regla 3"
)
return ["\n".join(lines)]
async def _process_admin_feedback(self, chat_id: str, text: str,
clinic: Dict) -> Optional[List[str]]:
"""
Detecta si el admin está:
A) Dando feedback sobre una conversación revisada
B) Respondiendo a la pregunta de disponibilidad que Conny le hizo
C) Usando el puente — enviando un mensaje directo a un paciente activo
"""
text_low = text.lower().strip()
# ── C. PUENTE — admin envía mensaje directo a un paciente ────────────────
# Patrones detectados:
# "envíale: hola, ¿cómo estás?"
# "mándale este mensaje: ya podemos atenderte"
# "dile a este cliente: confirmada la cita"
# "escríbele: te esperamos el martes"
BRIDGE_PATTERNS = [
"envíale:", "enviale:", "envíale ", "envialessto",
"mándale:", "mandale:", "mándale este mensaje:",
"dile:", "dile a este cliente:", "dile que:",
"escríbele:", "escribele:", "escríbele este:",
"envía:", "envia:", "manda:", "pásale:", "pasale:",
"respóndele:", "respondele:", "contéstale:", "contestale:",
]
reviewed = getattr(self, '_last_reviewed_chat', None)
_bridge_prefix = next(
(p for p in BRIDGE_PATTERNS if text_low.startswith(p.lower())),
None
)
# También detectar patrón "envíale [mensaje]" sin dos puntos
if not _bridge_prefix:
for p in ["envíale ", "enviále ", "mándale ", "mandale ", "dile ", "escríbele "]:
if text_low.startswith(p):
_bridge_prefix = p
break
if _bridge_prefix and reviewed:
# Extraer el mensaje que va al paciente
raw_bridge_msg = text[len(_bridge_prefix):].strip().strip('"').strip("'").strip()
if raw_bridge_msg:
try:
# Obtener nombre del paciente para el log
patient_name = ""
try:
with db._conn() as c:
row = c.execute("SELECT name FROM patients WHERE chat_id=?",
(reviewed,)).fetchone()
if row:
patient_name = row["name"] or ""
except Exception:
pass
# Enviar el mensaje como si fuera Conny (no el admin)
await self._send_message(reviewed, raw_bridge_msg)
# Guardarlo en el historial como si Conny lo hubiera dicho
db.save_message(reviewed, "assistant", raw_bridge_msg)
name_str = patient_name or f"cliente {reviewed[-6:]}"
log.info(f"[bridge] admin→{reviewed}: {raw_bridge_msg[:60]}")
return [
f"Listo, le mandé eso a {name_str}",
"Mensaje enviado: " + raw_bridge_msg[:120] + ("..." if len(raw_bridge_msg) > 120 else ""),
"Quedó guardado en el historial como si lo hubiera dicho Conny"
]
except Exception as e:
log.error(f"[bridge] error: {e}")
return [f"No pude enviar el mensaje: {e}"]
else:
return [
"No entendí el mensaje a enviar",
"Formato: envíale: tu mensaje aquí"
]
elif _bridge_prefix and not reviewed:
return [
"Primero abre una conversación con /chat [id]",
"Así sé a qué cliente enviarle el mensaje"
]
# ── B. Respuesta de disponibilidad del admin ──────────────────────────
# Conny le preguntó al admin su disponibilidad; él responde
AVAILABILITY_RESPONSE_SIGNALS = [
"lunes", "martes", "miercoles", "miércoles", "jueves", "viernes",
"sabado", "sábado", "esta semana", "proxima", "próxima",
"manana", "mañana", "hoy", "pm", "am", "9am", "10am", "11am",
"disponible", "libre", "puedo", "tengo espacio",
]
is_availability_response = sum(
1 for s in AVAILABILITY_RESPONSE_SIGNALS if s in text_low
) >= 2 and len(text) > 10
if is_availability_response:
# Verificar si hay un paciente esperando respuesta de disponibilidad
pending_patient = getattr(self, '_availability_pending_patient', None)
if pending_patient:
# Retransmitir la disponibilidad al paciente
patient_name = ""
try:
with db._conn() as c:
row = c.execute("SELECT name FROM patients WHERE chat_id=?",
(pending_patient,)).fetchone()
if row:
patient_name = row["name"] or ""
except Exception:
pass
patient_greeting = f"Hola{f' {patient_name}' if patient_name else ''}! "
patient_msg = f"{patient_greeting}Ya me confirmaron. {text}"
try:
await self._send_message(pending_patient, patient_msg)
self._availability_pending_patient = None
return [
f"Listo, le acabo de confirmar la disponibilidad al paciente."
]
except Exception as e:
log.warning(f"[calendar] error retransmitiendo: {e}")
# ── A. Instrucción directa del admin (sin conversación activa) ──────────
# El admin puede decir "no le digas X", "siempre di Y", "cuando pregunten
# por precio diles que..." en cualquier momento y se guarda como regla.
text_low = text.lower().strip()
DIRECT_RULE_SIGNALS = [
"no le digas", "no digas", "nunca digas", "nunca le digas",
"siempre di", "siempre dile", "siempre que", "cuando pregunten",
"cuando el cliente", "cuando la cliente", "cuando alguien",
"en vez de decir", "en lugar de", "mejor di", "mejor dile",
"desde ahora", "de ahora en adelante", "para los clientes",
"a los pacientes", "no menciones", "evita decir", "evita mencionar",
"quiero que digas", "quiero que le digas", "diles que",
"respóndeles", "respondeles", "si te preguntan por",
]
is_direct_rule = any(s in text_low for s in DIRECT_RULE_SIGNALS) and len(text) > 15
if is_direct_rule and not reviewed:
# Regla directa — guardar sin contexto de conversación
try:
extraction_prompt = f"""El dueño de un negocio está dando una instrucción directa a su asistente virtual Conny sobre cómo debe comportarse con los clientes.
INSTRUCCIÓN DEL DUEÑO:
"{text}"
Extrae una regla clara y accionable de esta instrucción.
Responde SOLO con JSON válido, sin texto adicional:
{{
"rule": "la regla en lenguaje claro y directo, como una instrucción para Conny",
"example_bad": "cómo NO responder (si se puede inferir del contexto)",
"example_good": "cómo SÍ responder (si se puede inferir del contexto)",
"category": "tone|product|closing|objection|flow|general",
"feedback_type": "instruction",
"save_as_playbook": true,
"trigger_text": "cuándo aplica esta instrucción, en lenguaje simple",
"response_example": "ejemplo exacto de respuesta o secuencia de burbujas usando ||| si aplica",
"bubble_count": 1
}}
Categorías:
- tone: cómo hablar, palabras a usar o evitar
- product: info sobre servicios o precios
- closing: cómo y cuándo cerrar hacia la cita
- objection: manejo de objeciones
- flow: orden de la conversación
- general: todo lo demás
Usa save_as_playbook=true SOLO si el dueño está enseñando un patrón reusable tipo:
- "si te saludan..."
- "cuando pregunten por..."
- "al inicio responde..."
- "primero di X y luego Y"
Si el dueño dio una forma concreta de responder, trigger_text y response_example son obligatorios.
Si menciona dos mensajes, response_example debe usar ||| entre burbujas."""
raw, _ = await asyncio.wait_for(
llm_engine.complete(
[{"role": "user", "content": extraction_prompt}],
model_tier="fast", temperature=0.1, max_tokens=250, use_cache=False
),
timeout=10.0
)
import re as _re
m = _re.search(r'\{[\s\S]+\}', raw.strip())
if m:
parsed = json.loads(m.group(0))
rule = parsed.get("rule", "")
example_bad = parsed.get("example_bad", "")
example_good = parsed.get("example_good", "")
category = parsed.get("category", "general")
save_as_playbook = bool(parsed.get("save_as_playbook"))
trigger_text = (parsed.get("trigger_text", "") or "").strip()
response_example = (parsed.get("response_example", "") or "").strip()
bubble_count = int(parsed.get("bubble_count", 1) or 1)
if rule:
rule_id = db.save_trust_rule(
category=category, rule=rule,
example_bad=example_bad, example_good=example_good,
weight=2.5,
)
playbook_id = 0
if db and save_as_playbook and trigger_text and response_example:
playbook_id = db.save_behavior_playbook(
trigger_text=trigger_text,
response_example=response_example,
category=category,
instruction=rule,
bubble_count=bubble_count,
weight=3.0,
)
cat_labels = {
"objection":"Objeciones","tone":"Tono","closing":"Cierre",
"product":"Servicios","flow":"Flujo","general":"General"
}
ejemplo_line = (f'\nEjemplo correcto: "{example_good}"' if example_good else "")
playbook_line = (
f'\nPlaybook #{playbook_id}: si pasa "{trigger_text}", responde parecido a "{response_example}"'
if playbook_id else ""
)
return [
"Entendido, lo guardo ahora mismo",
f'Carpeta de confianza #{rule_id} [{cat_labels.get(category,"General")}]:\n"{rule}"' + ejemplo_line,
"Aplico esto en todas las conversaciones desde ya. Ver todas las reglas: /reglas" + playbook_line
]
except Exception as e:
log.warning(f"[trust_rule] Error procesando instrucción directa: {e}")
return None
# ── B. Feedback sobre conversación revisada ───────────────────────────
if not reviewed:
return None
# Detectar si el texto es feedback (no un comando ni saludo)
FEEDBACK_SIGNALS = [
"debió", "deberia", "debería", "tendría", "tenia que", "faltó",
"falto", "muy bien", "estuvo bien", "estuvo mal", "mal manejado",
"bien manejado", "mejor si", "en vez de", "en lugar de",
"cuando el paciente", "cuando la paciente", "hubiera",
"le faltó", "pudo haber", "hay que", "siempre que",
"nunca", "siempre", "próxima vez", "la próxima",
]
is_feedback = any(s in text_low for s in FEEDBACK_SIGNALS)
if not is_feedback and len(text) < 40:
return None
if not is_feedback and not any(
kw in text_low for kw in ["precio", "cita", "objecion", "respuesta",
"conny", "paciente", "cliente", "cerrar",
"agendar", "tono", "dijo", "respondio", "respondió"]
):
return None
# Obtener el contexto de la conversación revisada
context_msgs = db.get_patient_conversation(reviewed, limit=20)
context_str = "\n".join(
f"{m['role']}: {m['content'][:100]}"
for m in context_msgs[-10:]
)
# Usar LLM para extraer la regla aprendida
try:
extraction_prompt = f"""El dueño de una clínica estética está dando feedback sobre cómo su asistente virtual Conny manejó una conversación.
CONVERSACIÓN REVISADA (fragmento):
{context_str}
FEEDBACK DEL DUEÑO:
"{text}"
Extrae la regla de comunicación aprendida y devuelve SOLO este JSON:
{{
"category": "objection|tone|closing|product|flow|general",
"rule": "regla clara en una oración, tercera persona",
"example_bad": "ejemplo de lo que NO hacer (opcional, máx 60 chars)",
"example_good": "ejemplo de lo que SÍ hacer (opcional, máx 60 chars)",
"feedback_type": "correction|praise|instruction"
}}
Ejemplos de categorías:
- objection: manejo de "es caro", "lo pienso", "no sé si sirva"
- tone: cómo hablar, qué palabras usar o evitar
- closing: cómo y cuándo agendar la valoración
- product: información sobre tratamientos específicos
- flow: orden de la conversación, cuándo preguntar qué
- general: todo lo demás"""
raw, _ = await asyncio.wait_for(
llm_engine.complete(
[{"role": "user", "content": extraction_prompt}],
model_tier="fast",
temperature=0.2,
max_tokens=300,
use_cache=False
),
timeout=10.0
)
raw = raw.strip()
json_str = None
import re as _re
m = _re.search(r'\{[\s\S]+\}', raw)
if m:
json_str = m.group(0)
if not json_str:
raise ValueError("No JSON found")
parsed = json.loads(json_str)
category = parsed.get("category", "general")
rule = parsed.get("rule", "")
example_bad = parsed.get("example_bad", "")
example_good = parsed.get("example_good", "")
fb_type = parsed.get("feedback_type", "instruction")
if not rule:
raise ValueError("Empty rule")
# Guardar en trust_folder
trust_weight = 2.0 if fb_type == "praise" else 3.0
rule_id = db.save_trust_rule(
category=category,
rule=rule,
example_bad=example_bad,
example_good=example_good,
weight=trust_weight,
)
# Guardar el feedback también
db.save_feedback(
patient_chat_id=reviewed,
feedback_text=text,
feedback_type=fb_type,
context=context_str,
admin_chat_id=chat_id
)
# Limpiar la conversación bajo revisión
self._last_reviewed_chat = None
cat_labels = {
"objection": "Objeciones", "tone": "Tono", "closing": "Cierre",
"product": "Tratamientos", "flow": "Flujo", "general": "General"
}
cat_label = cat_labels.get(category, "General")
if fb_type == "praise":
return [
f"Gracias, guardado como referencia de lo que funciona bien.",
f"Carpeta de confianza #{rule_id} [{cat_label}]:\n\"{rule}\""
]
else:
return [
f"Entendido. Lo aprendo ahora mismo.",
f"Carpeta de confianza #{rule_id} [{cat_label}]:\n\"{rule}\""
+ (f"\nEjemplo: \"{example_good}\"" if example_good else ""),
"Desde ahora aplico esto en cada conversación. Para ver todo lo aprendido: /reglas"
]
except Exception as e:
log.warning(f"[feedback] Error extrayendo regla: {e}")
# Guardar el feedback en crudo aunque no se extrajo la regla
try:
db.save_feedback(
patient_chat_id=reviewed,
feedback_text=text,
feedback_type="instruction",
context="",
admin_chat_id=chat_id
)
self._last_reviewed_chat = None
except Exception:
pass
return [
"Guardé tu feedback, aunque no pude procesarlo automáticamente.",
"Puedes ver todo el feedback con /reglas y editarlo desde ahí."
]
async def _restart_setup(self, chat_id: str) -> List[str]:
"""Reinicia el setup."""
db.update_clinic(
setup_done=0,
setup_step="idle",
setup_buffer={}
)
return await self._handle_setup(chat_id, "", db.get_clinic())
# ══════════════════════════════════════════════════════════════════════════
# V6.0 — COMANDOS NUEVOS
# ══════════════════════════════════════════════════════════════════════════
async def _admin_pipeline(self) -> List[str]:
"""
/pipeline — Muestra todos los leads clasificados por temperatura.
Usa closing_score almacenado en la última conversación.
"""
try:
with db._conn() as c:
patients = c.execute("""
SELECT p.chat_id, p.name, p.visits,
(SELECT content FROM conversations
WHERE chat_id=p.chat_id AND role='user'
ORDER BY created_at DESC LIMIT 1) as last_msg,
(SELECT created_at FROM conversations
WHERE chat_id=p.chat_id
ORDER BY created_at DESC LIMIT 1) as last_seen
FROM patients p
ORDER BY p.visits DESC LIMIT 50
""").fetchall()
boiling, hot, warm, cold = [], [], [], []
for pt in patients:
chat_id = pt["chat_id"]
name = pt["name"] or "Desconocido"
last_msg = (pt["last_msg"] or "")[:60]
last_seen = (pt["last_seen"] or "")[:16]
# Calcular closing_score del último mensaje
if last_msg:
analysis = MessageAnalyzer().analyze(last_msg)
temp = analysis.lead_temperature
score = analysis.closing_score
else:
temp, score = "cold", 0.0
entry = f"{name} — {last_msg!r:.60} ({last_seen[:10]})"
if temp == "boiling": boiling.append(entry)
elif temp == "hot": hot.append(entry)
elif temp == "warm": warm.append(entry)
else: cold.append(entry)
lines = ["Pipeline de leads\n"]
if boiling:
lines.append(f"Listos para cerrar ({len(boiling)}):")
lines += [f" {e}" for e in boiling[:5]]
if hot:
lines.append(f"\nCalientes ({len(hot)}):")
lines += [f" {e}" for e in hot[:5]]
if warm:
lines.append(f"\nTibios ({len(warm)}):")
lines += [f" {e}" for e in warm[:5]]
if cold:
lines.append(f"\nFríos ({len(cold)}): {len(cold)} contactos")
if not (boiling or hot or warm or cold):
return ["No hay conversaciones registradas todavía"]
return ["\n".join(lines)]
except Exception as e:
log.error(f"[pipeline] {e}")
return [f"Error generando pipeline: {e}"]
async def _admin_lost_analysis(self) -> List[str]:
"""
/perdidos — Analiza por qué se pierden los clientes.
Identifica el patrón exacto donde se cortan las conversaciones.
"""
try:
with db._conn() as c:
# Conversaciones que terminaron sin cita
convs = c.execute("""
SELECT chat_id,
GROUP_CONCAT(content || '|||' || role, '~~~') as thread
FROM conversations
WHERE created_at >= datetime('now', '-30 days')
GROUP BY chat_id
HAVING COUNT(*) >= 2
""").fetchall()
if not convs:
return ["No hay suficientes conversaciones para analizar todavía"]
# Analizar con LLM los patrones de pérdida
sample = []
for c in convs[:15]:
msgs = [m.split("|||") for m in c["thread"].split("~~~") if "|||" in m]
if len(msgs) >= 2:
last_user = next((m[0] for m in reversed(msgs) if len(m) > 1 and m[1] == "user"), "")
if last_user:
sample.append(last_user[:80])
if not sample:
return ["No hay suficientes conversaciones para analizar"]
prompt = f"""Analiza estos últimos mensajes de clientes que dejaron de responder:
{chr(10).join(f"- {s}" for s in sample[:10])}
Identifica:
1. El patrón más común donde se pierden (qué dijeron justo antes de irse)
2. El porcentaje aproximado de cada patrón
3. Qué debería haber respondido Conny diferente
Responde en máximo 5 líneas, directo, sin introducciones."""
try:
r, _ = await asyncio.wait_for(
llm_engine.complete(
[{"role": "user", "content": prompt}],
model_tier="fast", temperature=0.3, max_tokens=300
), timeout=15.0
)
except Exception:
r = "No pude analizar los patrones en este momento"
return [
f"Análisis de los últimos 30 días ({len(convs)} conversaciones):",
r
]
except Exception as e:
return [f"Error: {e}"]
async def _admin_sales_coach(self) -> List[str]:
"""
/coach — Analiza las últimas conversaciones y da feedback de ventas.
Funciona como entrenador: qué funcionó, qué no, qué mejorar.
"""
try:
with db._conn() as c:
recent = c.execute("""
SELECT chat_id,
COUNT(*) as turns,
MAX(created_at) as last_ts
FROM conversations
WHERE created_at >= datetime('now', '-7 days')
GROUP BY chat_id
HAVING turns >= 4
ORDER BY last_ts DESC LIMIT 5
""").fetchall()
if not recent:
return ["No hay conversaciones largas esta semana para analizar"]
# Tomar la conversación más reciente y sustancial
best = recent[0]
msgs = db.get_patient_conversation(best["chat_id"], limit=20)
thread = "\n".join(f"{m['role'].upper()}: {m['content'][:120]}" for m in msgs)
prompt = f"""Eres un coach de ventas experto en WhatsApp para negocios en Colombia.
Analiza esta conversación de Conny con un cliente:
{thread[:2000]}
Dame:
1. Una cosa que Conny hizo MUY bien (con el mensaje exacto que lo demuestra)
2. Una cosa que pudo hacer mejor (con cómo debió responder)
3. Una técnica de venta que debería usar más en este tipo de conversación
Máximo 6 líneas. Directo. Sin introducciones."""
try:
r, _ = await asyncio.wait_for(
llm_engine.complete(
[{"role": "user", "content": prompt}],
model_tier="fast", temperature=0.4, max_tokens=350
), timeout=15.0
)
except Exception:
r = "No pude analizar la conversación en este momento"
return ["Coach de ventas — última semana:", r]
except Exception as e:
return [f"Error: {e}"]
async def _admin_clone_style(self, admin_chat_id: str) -> List[str]:
"""
/estilo — Lee los mensajes del admin y clona su forma de escribir.
Guarda el estilo como trust_rule de máxima prioridad.
"""
try:
msgs = db.get_history(admin_chat_id, limit=50)
admin_msgs = [m["content"] for m in msgs if m["role"] == "user" and len(m["content"]) > 10]
if len(admin_msgs) < 5:
return [
"Necesito más mensajes tuyos para clonar tu estilo",
"Escríbeme unos 10 mensajes como si hablaras con un cliente y vuelve a intentar"
]
sample = "\n".join(f"- {m[:80]}" for m in admin_msgs[:15])
prompt = f"""Analiza estos mensajes de un empresario colombiano:
{sample}
Extrae su estilo de escritura: tono, vocabulario, longitud de mensajes,
muletillas propias, cómo saluda, cómo cierra, qué palabras usa siempre.
Luego escribe UNA instrucción concisa (máximo 4 líneas) para que Conny
escriba EXACTAMENTE como él. Primera persona, directo."""
try:
r, _ = await asyncio.wait_for(
llm_engine.complete(
[{"role": "user", "content": prompt}],
model_tier="fast", temperature=0.3, max_tokens=200
), timeout=15.0
)
rule = r.strip()
except Exception:
return ["No pude analizar tu estilo en este momento, intenta de nuevo"]
# Guardar como trust_rule de máxima prioridad
rule_id = db.save_trust_rule(
category="tone",
rule=f"ESTILO CLONADO DEL DUEÑO: {rule}",
example_bad="",
example_good=""
)
# Subir el peso al máximo
with db._conn() as c:
c.execute("UPDATE trust_folder SET weight=3.0 WHERE id=?", (rule_id,))
return [
"Analicé tus mensajes y cloné tu estilo",
f"Regla guardada como #tone con prioridad máxima:",
rule,
"Desde ahora Conny escribe como tú. Usa /reglas para verla o editarla"
]
except Exception as e:
return [f"Error: {e}"]
async def _admin_reactivate_dormant(self) -> List[str]:
"""
/reactivar — Encuentra clientes inactivos 60+ días y los reactiva.
Programa follow-ups automáticos para cada uno.
"""
try:
with db._conn() as c:
dormant = c.execute("""
SELECT p.chat_id, p.name,
MAX(c.created_at) as last_contact,
(SELECT content FROM conversations
WHERE chat_id=p.chat_id AND role='user'
ORDER BY created_at DESC LIMIT 1) as last_msg
FROM patients p
JOIN conversations c ON c.chat_id = p.chat_id
GROUP BY p.chat_id
HAVING last_contact < datetime('now', '-60 days')
ORDER BY last_contact DESC LIMIT 20
""").fetchall()
if not dormant:
return ["No hay clientes inactivos por más de 60 días"]
scheduled = 0
for i, pt in enumerate(dormant[:10]):
# Programar con delay escalonado para no spam
run_at = datetime.now() + timedelta(hours=i * 2 + 1)
task_manager.schedule_task(
task_type="follow_up",
data={
"chat_id": pt["chat_id"],
"reason": "reactivation",
"last_message": (pt["last_msg"] or "")[:200],
"patient_name": pt["name"] or "",
},
scheduled_for=run_at,
priority=4
)
scheduled += 1
names = ", ".join(pt["name"] or pt["chat_id"][:8] for pt in dormant[:5])
return [
f"Encontré {len(dormant)} clientes inactivos",
f"Programé reactivación para {scheduled} — comenzando en 1 hora",
f"Primeros: {names}{'...' if len(dormant) > 5 else ''}",
"Escríbeme /pipeline en 24h para ver cómo respondieron"
]
except Exception as e:
return [f"Error: {e}"]
async def _admin_configure_followup(self, clinic: Dict) -> List[str]:
"""
/seguimiento — Configura los follow-ups automáticos.
Muestra estado actual y permite activar/desactivar.
"""
try:
with db._conn() as c:
pending = c.execute(
"SELECT COUNT(*) FROM tasks WHERE type='follow_up' AND status='pending'"
).fetchone()[0]
completed = c.execute(
"SELECT COUNT(*) FROM tasks WHERE type='follow_up' AND status='completed' "
"AND created_at >= datetime('now', '-7 days')"
).fetchone()[0]
return [
"Seguimiento automático",
f"Pendientes: {pending} | Enviados esta semana: {completed}",
"Tipos activos:",
" • Lead frío (48h sin respuesta) — activo",
" • Conversación abandonada — activo",
" • Recordatorio de cita — activo",
" • Reactivación (60+ días) — manual con /reactivar",
"Para cambiar la configuración escríbeme algo como:\n'desactiva el follow-up de 48 horas'"
]
except Exception as e:
return [f"Error: {e}"]
async def _admin_preconsult_config(self, clinic: Dict) -> List[str]:
"""
/preconsulta — Configura el formulario de pre-consulta automático.
Antes de la cita, Conny recopila síntomas, fotos, historial.
"""
sector = clinic.get("sector", "otro")
templates = {
"estetica": [
"zona de interés", "tratamientos anteriores", "alergias conocidas",
"foto del área (opcional)", "qué resultado esperas"
],
"medico": [
"motivo de consulta", "síntomas principales", "hace cuánto",
"medicamentos actuales", "alergias", "última vez que consultó"
],
"dental": [
"motivo de consulta", "dolor (sí/no y dónde)", "últimas radiografías",
"sensibilidad al frío o calor", "tratamientos previos"
],
}
fields = templates.get(sector, ["motivo de consulta", "síntomas", "historial relevante"])
# Guardar como configuración
db.update_clinic(preconsult_fields=fields)
return [
"Pre-consulta automática configurada",
f"Sector detectado: {sector}",
"Conny recopilará esto antes de cada cita:",
" " + "\n ".join(f"• {f}" for f in fields),
"El médico llega con el caso pre-estudiado",
"Para personalizar: 'agrega el campo [nombre] a la pre-consulta'"
]
async def _admin_broadcast(self, message: str) -> List[str]:
"""
/broadcast [mensaje] — Envía un mensaje a todos los pacientes activos.
Límite de 50 pacientes, con delay para no quedar bloqueado.
"""
if not message or len(message) < 5:
return ["Formato: /broadcast tu mensaje aquí"]
try:
with db._conn() as c:
patients = c.execute("""
SELECT DISTINCT chat_id FROM patients
WHERE chat_id IS NOT NULL
ORDER BY created_at DESC LIMIT 50
""").fetchall()
if not patients:
return ["No hay pacientes registrados"]
# Programar envíos escalonados (1 cada 3 segundos)
scheduled = 0
for i, pt in enumerate(patients):
run_at = datetime.now() + timedelta(seconds=i * 3)
task_manager.schedule_task(
task_type="reminder",
data={"chat_id": pt["chat_id"], "message": message},
scheduled_for=run_at,
priority=3
)
scheduled += 1
return [
f"Broadcast programado para {scheduled} contactos",
f"Mensaje: {message[:100]}{'...' if len(message) > 100 else ''}",
"Se enviará escalonado en los próximos minutos para evitar bloqueos",
"Usa con cuidado — demasiados mensajes masivos pueden generar baneo en WhatsApp"
]
except Exception as e:
return [f"Error: {e}"]
async def _admin_instagram_guide(self) -> List[str]:
"""
/instagram — Guía para conectar Instagram DMs a Conny.
Actualmente requiere configuración manual vía Meta API.
"""
return [
"Conectar Instagram DMs a Conny",
"Estado actual: en configuración (requiere Meta Business verificado)",
"Lo que necesitas:",
" 1. Cuenta de Instagram Business o Creator",
" 2. Meta Business Suite verificado",
" 3. App de Meta aprobada con permiso instagram_manage_messages",
" 4. Webhook configurado en: https://nexusys.duckdns.org/instagram/webhook",
"Cuando lo tengas listo escríbeme:",
" 'el instagram access token es [TOKEN]'",
" 'el instagram page id es [ID]'",
"Y Conny empezará a responder los DMs igual que WhatsApp"
]
async def _admin_payments_guide(self) -> List[str]:
"""
/pagos — Configura pagos desde el chat (Wompi, MercadoPago, Stripe).
Cuando el cliente confirma, Conny manda el link de pago directo.
"""
clinic = db.get_clinic()
payment_cfg = clinic.get("payment_config") or {}
if isinstance(payment_cfg, str):
import json as _j
try: payment_cfg = _j.loads(payment_cfg)
except Exception: payment_cfg = {}
active = payment_cfg.get("provider", "")
status = f"Activo: {active}" if active else "Sin configurar"
return [
f"Pagos desde el chat — {status}",
"Providers disponibles:",
" • Wompi (Colombia) — recomendado",
" • MercadoPago — latinoamérica",
" • Stripe — internacional",
"Para activar escríbeme:",
" 'configura pagos con Wompi, mi clave pública es [KEY]'",
" 'configura pagos con MercadoPago, token [TOKEN]'",
"Cuando un cliente confirme, Conny manda el link de pago automáticamente"
]
async def _admin_trigger_report(self) -> List[str]:
"""
/reporte — Genera y envía el reporte ahora mismo (sin esperar las 8am).
"""
try:
clinic = db.get_clinic()
biz_name = clinic.get("name", "el negocio")
admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
# Programar para ahora mismo
task_manager.schedule_task(
task_type="report",
data={"type": "daily"},
scheduled_for=datetime.now(),
priority=8
)
# También generar preview rápido
with db._conn() as c:
convs_hoy = c.execute(
"SELECT COUNT(DISTINCT chat_id) FROM conversations "
"WHERE created_at >= datetime('now', '-1 days')"
).fetchone()[0] or 0
apts_hoy = c.execute(
"SELECT COUNT(*) FROM appointments "
"WHERE created_at >= datetime('now', '-1 days')"
).fetchone()[0] or 0
return [
f"Reporte generado y enviando",
f"Hoy: {convs_hoy} conversaciones, {apts_hoy} citas",
"El reporte completo llega en un momento por aquí mismo"
]
except Exception as e:
return [f"Error: {e}"]
# ═══════════════════════════════════════════════════════════════════════════
# V8.0 — COMANDOS DE MODELO Y SISTEMAS
# ═══════════════════════════════════════════════════════════════════════════
async def _admin_show_model(self, clinic: Dict) -> List[str]:
"""
/modelo — Muestra el modelo activo y el catálogo de opciones.
El admin puede cambiar el modelo en caliente sin reiniciar.
"""
if not model_manager:
return ["El gestor de modelos no está disponible (reinicia el servidor)."]
current_display = model_manager.get_current_model_display()
catalog_display = model_manager.get_catalog_display()
return [
f"V8.0 — Gestión de modelos\n\n{current_display}",
catalog_display,
]
async def _admin_set_model(self, arg: str, clinic: Dict) -> List[str]:
"""
/modelo [alias|id_completo|reset]
Cambia el modelo en caliente. Persiste en DB.
"""
if not model_manager:
return ["El gestor de modelos no está disponible."]
success, message = model_manager.set_model_from_command(arg)
if success:
# Mostrar el estado actualizado
current = model_manager.get_current_model_display()
return [
f"Listo. {message}",
current,
"El cambio es inmediato. Sobrevive reinicios.",
"Para volver al .env: /modelo reset"
]
else:
return [
message,
model_manager.get_catalog_display()
]
async def _admin_v8_status(self) -> List[str]:
"""
/v8 — Estado completo de sistemas V8 + salud real de providers LLM.
"""
lines = ["V8.1 — Estado de sistemas\n"]
# ── Salud de providers LLM ─────────────────────────────────────────────
if llm_engine:
health = llm_engine.get_health()
lines.append("Providers LLM (cascada):")
for p in llm_engine.providers:
h = health.get(p.name, {})
if h.get("blocked"):
secs = h.get("unblocks_in", 0)
status = f"⛔ BLOQUEADO ({secs}s restantes)"
elif h.get("failures", 0) > 0:
status = f"⚠️ OK con {h['failures']} fallo(s) reciente(s)"
else:
status = "✅ OK"
# Modelo que está usando
mdl = getattr(p, "MDLS", {}).get("fast", "?")
lines.append(f" {p.name}: {status} | modelo fast: {mdl}")
else:
lines.append("LLMEngine: ⛔ NO INICIADO — sin respuestas de IA")
# ── Modelo activo ──────────────────────────────────────────────────────
if model_manager:
effective = model_manager.get_effective_models()
lines.append(f"\nModelo activo:")
lines.append(f" fast: {effective.get('fast', 'default del .env')}")
lines.append(f" reasoning: {effective.get('reasoning', 'default del .env')}")
else:
lines.append("\nModelManager: NO INICIADO")
# ── AntiRobotFilter ────────────────────────────────────────────────────
if anti_robot_filter:
lines.append(f"\nAntiRobotFilter: ✅ nivel {anti_robot_filter.level}/3")
else:
lines.append("\nAntiRobotFilter: ⚠️ NO INICIADO")
# ── ConversationIntelligence ───────────────────────────────────────────
if conversation_intelligence:
active_convs = len(conversation_intelligence._states)
stage_counts: Dict[str, int] = {}
for state in conversation_intelligence._states.values():
s = state.get("stage", "COLD")
stage_counts[s] = stage_counts.get(s, 0) + 1
lines.append(f"\nConversationIntelligence: {active_convs} chats activos")
for stage, count in sorted(stage_counts.items()):
lines.append(f" {stage}: {count}")
else:
lines.append("\nConversationIntelligence: ⚠️ NO INICIADO")
# ── Pipeline ───────────────────────────────────────────────────────────
if conversion_funnel:
summary = conversion_funnel.get_pipeline_summary()
total = sum(summary.values())
booked = summary.get("booked", 0) + summary.get("confirmed", 0)
rate = round(booked / total * 100, 1) if total > 0 else 0
lines.append(f"\nPipeline: {total} leads · {rate}% conversión")
# ── Fallos recientes LLM (últimas 2h) ─────────────────────────────────
try:
if db:
# Métricas de fallo guardadas por _register_failure
recent_fails = db.get_metrics("llm_failure", limit=10)
if recent_fails:
lines.append("\nÚltimos fallos LLM:")
for mf in recent_fails[:5]:
lines.append(f" {mf.get('category','?')}: {mf.get('details',{}).get('error','?')[:60]}")
except Exception:
pass
lines.append(f"\nTimeout provider: 10s | Blacklist TTL: {llm_engine._blacklist_ttl if llm_engine else '?'}s")
lines.append("Para desbloquear un provider manualmente: /v8 reset")
return ["\n".join(lines)]
async def _admin_show_filter_status(self) -> List[str]:
"""
/filtro — Muestra el estado del AntiRobotFilter y explica los niveles.
"""
level = anti_robot_filter.level if anti_robot_filter else 2
levels_desc = {
1: "Suave — solo frases de call center obvias",
2: "Normal (recomendado) — frases + patrones de bot",
3: "Estricto — también cierres formales y aperturas repetitivas",
}
lines = [
f"AntiRobotFilter — Nivel actual: {level}",
f" {levels_desc.get(level, 'desconocido')}",
"",
"Niveles disponibles:",
]
for lvl, desc in levels_desc.items():
mark = " ← activo" if lvl == level else ""
lines.append(f" /filtro {lvl} — {desc}{mark}")
lines.append("\nFrases actualmente bloqueadas:")
if anti_robot_filter:
sample = list(anti_robot_filter.FORBIDDEN_EXACT)[:8]
for phrase in sample:
lines.append(f" • '{phrase}'")
lines.append(f" ... y {len(anti_robot_filter.FORBIDDEN_EXACT) - 8} más")
return ["\n".join(lines)]
async def _admin_set_filter_level(self, level_str: str) -> List[str]:
"""
/filtro [1|2|3] — Cambia el nivel del AntiRobotFilter.
"""
global anti_robot_filter, hyper_human_engine
if not level_str.isdigit() or int(level_str) not in (1, 2, 3):
return ["Niveles válidos: 1 (suave), 2 (normal), 3 (estricto)"]
level = int(level_str)
Config.V8_FILTER_LEVEL = level
anti_robot_filter = AntiRobotFilter(level=level)
if hyper_human_engine:
hyper_human_engine.filter = anti_robot_filter
if db:
db.remember("v8_filter_level", str(level), "config")
level_names = {1: "suave", 2: "normal", 3: "estricto"}
return [
f"Filtro anti-robot cambiado a nivel {level} ({level_names[level]})",
"El cambio aplica desde el próximo mensaje."
]
async def _admin_pipeline_v8(self) -> List[str]:
"""
/pipeline — Pipeline de leads usando ConversionFunnelTracker V8.
Más detallado que el /pipeline de V6.
"""
if not conversion_funnel:
# Fallback al pipeline V6
return await self._admin_pipeline()
report = conversion_funnel.format_pipeline_report()
rates = conversion_funnel.get_conversion_rate()
# Identificar el cuello de botella
bottleneck = ""
min_rate = 1.0
for stage, rate in rates.items():
if 0 < rate < min_rate:
min_rate = rate
bottleneck = stage
lines = [report]
if bottleneck:
stage_tips = {
"discovery": "Conny no está logrando explorar el dolor real. Revisar /coach.",
"pain_explored": "El puente dolor→solución no está funcionando. Revisar arquetipos.",
"solution_match":"Los clientes no están aceptando la valoración. Revisar el cierre.",
"objection_active": "Las objeciones están ganando. Revisar respuestas de /reglas.",
"micro_commitment": "El cliente está listo pero no agenda. Revisar la propuesta de fecha.",
}
tip = stage_tips.get(bottleneck, "Revisar conversaciones en /chats.")
lines.append(f"\nCuello de botella detectado: {bottleneck}")
lines.append(f"Sugerencia: {tip}")
return lines
async def _admin_natural_command(self, chat_id: str, text: str,
clinic: Dict) -> List[str]:
"""
Cerebro conversacional del modo admin.
V9 Upgrade: Aprendizaje natural + Simulaciones interactivas.
"""
text_low = text.lower().strip()
persona = clinic.get("persona_config", {})
if isinstance(persona, str):
try:
persona = json.loads(persona) if persona else {}
except Exception:
persona = {}
agent_name = persona.get("name", "Conny")
# ── COMANDOS DE APRENDIZAJE NATURAL ──────────────────────────────────
# Detecta frases como "no digas X", "usa emojis", "dile Y"
LEARNING_SIGNALS = [
"no digas", "no le digas", "deja de decir", "quita la frase",
"usa emojis", "ponle emojis", "responde con", "dile que",
"siempre di", "nunca digas", "aprende esto", "guarda esto",
"cambia la forma", "ahora dile", "cuando pregunten por",
"la respuesta correcta es", "háblale de", "menciona que"
]
if any(s in text_low for s in LEARNING_SIGNALS):
if self.admin_learning:
reply = self.admin_learning.add_instruction(chat_id, text)
return [reply]
if "limpia las instrucciones" in text_low or "borra lo aprendido" in text_low:
if self.admin_learning:
return [self.admin_learning.clear()]
# ── MODO SIMULACIÓN ──────────────────────────────────────────────────
SIM_SIGNALS = [
"simula", "simulaci", "como cliente", "hazte cliente",
"actúa como cliente", "modo cliente", "hagamos una prueba",
"ponte a prueba", "pruébame", "quiero ver cómo respondes",
"simulemos", "haz como si fueras un paciente"
]
if any(s in text_low for s in SIM_SIGNALS):
if self.simulator:
return self.simulator.start(chat_id)
# ── SEGURIDAD: Bloquear intento de login inseguro ────────────────────
# Si un usuario que NO es admin intenta enviar algo que parece login por nombre
if ":" in text and ("password" in text_low or "contraseña" in text_low):
is_admin = db.get_admin(chat_id) is not None
if not is_admin:
log.warning(f"[security] Intento de login inseguro bloqueado desde {chat_id}")
return ["Por seguridad, no compartas contraseñas por este medio. Usa /login para iniciar sesión de forma segura."]
# ── Reportes de Conversaciones ───────────────────────────────────────
REPORT_SIGNALS = [
"que han dicho", "qué han dicho", "quien ha escrito", "quién ha escrito",
"ultimos pacientes", "últimos pacientes", "conversaciones", "chats",
"qué me han enviado", "que me han enviado", "mensajes recientes"
]
if any(s in text_low for s in REPORT_SIGNALS):
return await self._admin_show_recent_conversation_browser(chat_id)
# ── Ver un chat específico ───────────────────────────────────────────
if "ver a " in text_low or "ver el chat de" in text_low:
# Extraer número o nombre si es posible (implementación simplificada)
return await self._admin_show_chats()
# ── Auto-detección de credenciales WhatsApp ─────────────────────────
wa_creds = _detect_wa_credentials(text)
if wa_creds:
return await self._admin_connect_whatsapp(
chat_id, wa_creds["phone_id"], wa_creds["token"], clinic
)
# ── Detección de reglas Nova en lenguaje natural ──────────────────────
# "no permitas que...", "bloquea...", "nunca envíes...", "prohíbe..."
NOVA_RULE_SIGNALS = [
r"no\s+(permitas?|dejes?|quiero que)\s+que\s+conny",
r"(bloquea?|prohibe?|prohíbe?)\s+que",
r"nunca\s+(envíes?|mandes?|digas?|menciones?)",
r"no\s+(envíes?|mandes?|digas?|menciones?)\s+.{5,}",
r"impide?\s+que\s+conny",
r"asegúrate de que conny nunca",
]
if _NOVA_AVAILABLE and Config.NOVA_ENABLED:
if any(re.search(p, text_low) for p in NOVA_RULE_SIGNALS):
return await self._admin_nova_add_rule(text, clinic)
# ── Simulación en lenguaje natural — "hagamos una simulación", "cómo le hablarías" ──
# (Lógica delegada al SimulationEngine en la parte superior del método)
pass
# ── KB automático: texto largo con info de la clínica ─────────────────
if len(text) > 300 and kb is not None and _KB_AVAILABLE:
kb_indicators = [
"precio", "servicio", "tratamiento", "protocolo",
"contraindicacion", "incluye", "sesion", "duracion",
"costo", "valor", "procedimiento", "candidat",
"beneficio", "resultado", "recuperacion"
]
if sum(1 for kw in kb_indicators if kw in text_low) >= 3:
return await self._admin_kb_upload(text)
# ── Control duro del owner/admin ─────────────────────────────────────
if owner_style_controller and owner_style_controller.detect_control_intent(text):
result = owner_style_controller.apply_instruction(text, admin_chat_id=chat_id)
if result.get("ok"):
if prompt_evolver and trainer_gateway and trainer_gateway.detect_admin_learning_intent(text):
try:
await prompt_evolver.evolve(text.strip(), chat_id)
except Exception:
pass
reply_lines = result.get("reply_lines", ["Listo. Ya quedó aplicado."])
reply_text = self._apply_admin_output_pipeline(" ||| ".join(reply_lines), chat_id, clinic, user_msg=text)
return self._split_bubbles(reply_text)
# ── Gateway automático del trainer para admins ───────────────────────
if trainer_gateway and prompt_evolver and trainer_gateway.detect_admin_learning_intent(text):
learned = await prompt_evolver.evolve(text.strip(), chat_id)
if learned.get("ok"):
lines = [f"Entendido. {learned.get('description', 'Ya ajusté ese comportamiento.')}"]
if learned.get("example_good"):
lines.append(f"Ejemplo: \"{learned['example_good']}\"")
lines.append("Si quieres, lo seguimos afinando sobre la marcha.")
reply_text = self._apply_admin_output_pipeline(" ||| ".join(lines), chat_id, clinic, user_msg=text)
return self._split_bubbles(reply_text)
admin_inbox_signals = [
"quien te ha escrito", "quién te ha escrito", "quien te escribio",
"quién te escribió", "quien te escribe", "quién te escribe",
"quien me ha escrito", "quién me ha escrito", "quien escribio",
"quién escribió", "que chats tienes", "qué chats tienes",
"quien te hablo", "quién te habló", "quien te ha hablado",
"alguien te ha escrito", "alguien te escribio", "alguien te escribió",
"alguien te escribe", "alguien te hablo", "alguien te habló",
]
if any(signal in text_low for signal in admin_inbox_signals):
reply = self._admin_recent_chat_snapshot(chat_id, clinic)
reply_text = self._apply_admin_output_pipeline(" ||| ".join(reply), chat_id, clinic, user_msg=text)
db.save_message(chat_id, "user", text)
db.save_message(chat_id, "assistant", reply_text if reply else "")
return self._split_bubbles(reply_text)
selection_idx = _extract_conversation_selection(text_low)
if selection_idx:
show_all = _wants_all_messages(text_low)
direct_selection = any(
token in text_low
for token in (
"conversacion", "conversación", "chat", "mensajes",
"hablado", "hablaste", "mostrame", "muestrame",
"muéstrame", "enseñame", "ensename",
)
)
if direct_selection:
reply = await self._admin_show_recent_conversation_selection(
chat_id,
selection_idx,
show_all=show_all,
)
reply_text = self._apply_admin_output_pipeline(" ||| ".join(reply), chat_id, clinic, user_msg=text)
db.save_message(chat_id, "user", text)
db.save_message(chat_id, "assistant", reply_text if reply else "")
return self._split_bubbles(reply_text)
tone_complaints = [
"hablas raro", "no me gusta cómo hablas", "no me gusta como hablas",
"estás rara", "estas rara", "eso suena robot", "suenas robot",
"muy bot", "muy fría", "muy fria", "muy seca",
]
if any(w in text_low for w in tone_complaints):
reply_text = self._apply_admin_output_pipeline(" ||| ".join([
"pásame la frase exacta o dime el tono que quieres",
"te saco una versión más cálida, más directa o más premium"
]), chat_id, clinic, user_msg=text)
return self._split_bubbles(reply_text)
# ── Historial de admin (últimos 8 mensajes) ───────────────────────────
admin_history = db.get_history(chat_id, limit=8)
# ── Llamar al LLM conversacional ──────────────────────────────────────
try:
result = await asyncio.wait_for(
self._admin_llm_brain(chat_id, text, admin_history, clinic, agent_name),
timeout=12.0
)
except asyncio.TimeoutError:
result = None
except Exception as e:
log.error(f"[admin_brain] error: {e}", exc_info=True)
result = None
if result is None:
# LLM caído — fallback local inteligente
reply = self._admin_local_fallback(text, text_low, clinic, agent_name, chat_id)
reply_text = self._apply_admin_output_pipeline(" ||| ".join(reply) if reply else "", chat_id, clinic, user_msg=text)
reply = self._split_bubbles(reply_text)
db.save_message(chat_id, "user", text)
db.save_message(chat_id, "assistant", reply_text if reply else "")
return reply
# ── Aplicar acción validada ───────────────────────────────────────────
reply_text = result.get("reply", "")
action = result.get("action", "none")
data = result.get("data", {})
# Simulación — respuesta viene del _admin_simular_cliente, no del reply del LLM
if action == "simulate":
scenario = data.get("scenario", "libre")
try:
sim_result = await _admin_simular_cliente(chat_id, scenario, clinic)
db.save_message(chat_id, "user", text)
return sim_result
except Exception as e:
log.warning(f"[admin] simulate directo error: {e}")
# fallback: activar con /simular-cliente
return [
"entrá con /simular-cliente",
"escenarios: libre, precio, miedo, primer_contacto, esceptico"
]
applied = await self._admin_apply_action(action, data, clinic, chat_id)
# Si la acción fue rechazada (datos inválidos), el LLM ya dio una reply
# pero informamos al admin si hace falta
if applied is False and action not in ("none", "set_admin_name", "other"):
# La validación rechazó los datos — agregar aclaración
pass # reply_text ya es la respuesta del LLM, es suficiente
# ── Guardar en historial ──────────────────────────────────────────────
reply_text = self._apply_admin_output_pipeline(reply_text, chat_id, clinic, user_msg=text)
db.save_message(chat_id, "user", text)
if reply_text:
db.save_message(chat_id, "assistant", reply_text)
return self._split_bubbles(reply_text) if reply_text else [
"dime qué más necesitas"
]
async def _admin_llm_brain(self, chat_id: str, text: str, history: List[Dict],
clinic: Dict, agent_name: str) -> Optional[Dict]:
"""
Admin brain. Le damos identidad y contexto — el LLM piensa solo.
Sin ejemplos. Sin lookup tables. Temperatura alta. IA real.
"""
# Si es la primera vez que hablan (historial vacío), Conny se presenta
is_first_turn = len(history) == 0
setup_done = bool(clinic.get("setup_done"))
# Detectar si el admin ya tiene perfil en DB
admin_rec = db.get_admin(chat_id) if db else None
admin_name_from_db = ""
if admin_rec and admin_rec.get("name") and admin_rec["name"] not in ("", "Admin"):
admin_name_from_db = admin_rec["name"]
admin_name = admin_name_from_db
# Intro para primer mensaje — Conny se presenta naturalmente
first_time_greeting = ""
if is_first_turn and setup_done:
clinic_name = clinic.get("name", "tu negocio") or "tu negocio"
sector_name = SECTORS.get(clinic.get("sector", ""), SECTORS["otro"]).name if clinic.get("sector") else "negocio"
if admin_name_from_db:
first_time_greeting = f"""Estás empezando una conversación con {admin_name_from_db}.
Este es el primer mensaje que le envías. Preséntate con calidez, natural, como lo haría una empleada nueva que está conociendo a su jefe.
Di quién eres (tu nombre es {agent_name}), para qué estás (la recepcionista virtual de {clinic_name}), y pregunta en una línea cómo quieres que funcione.
Sé breve, cálida y directa. No des lista de funciones. No suenes a tutorial."""
else:
first_time_greeting = f"""Estás empezando una conversación con el dueño de {clinic_name}.
Este es el primer mensaje que le envías. Preséntate con calidez, natural, como lo haría una empleada nueva que está conociendo a su jefe.
Di quién eres (tu nombre es {agent_name}), para qué estás (la recepcionista virtual de {clinic_name}), y pregunta en una línea cómo quiere que funcione.
Si el negocio tiene {sector_name}, adapta el tono al sector. Sé breve, cálida y directa."""
# Detectar si el admin está preguntando quién es Conny
text_low = text.lower().strip() if text else ""
is_who_are_you = any(kw in text_low for kw in [
"quién eres", "quien eres", "who are you", "como te llamas",
"cómo te llamas", "de qué trata", "de que trata", "qué haces",
"qué eres", "que eres", "para qué estás", "para que estás"
])
services = clinic.get("services", [])
pricing = clinic.get("pricing", {})
if isinstance(pricing, str):
try: pricing = json.loads(pricing) if pricing else {}
except Exception: pricing = {}
_pc = clinic.get("persona_config", {})
if isinstance(_pc, str):
try: _pc = json.loads(_pc) if _pc else {}
except Exception: _pc = {}
warmth = int(_pc.get("warmth_level", 0.7) * 100)
formality = int(_pc.get("formality_level", 0.6) * 100)
history_txt = ""
for h in history[-8:]:
who = admin_name if h["role"] == "user" else agent_name
history_txt += f"{who}: {h['content'][:250]}\n"
# Skills activas
skills_txt = ""
try:
if skill_engine:
active = skill_engine.get_active()
if active:
skills_txt = f"\nSkills activas ahora: {', '.join(active)}"
except Exception:
pass
# Diagnóstico reciente
diag_txt = ""
try:
if bus:
fails = bus.get_recent(5, "failure")
if fails:
diag_txt = f"\nFallos recientes detectados: {len(fails)} (últimos: {', '.join(set(f.data.get('type','?') for f in fails[:3]))})"
except Exception:
pass
# Últimas respuestas que ya dio — para no repetirlas
last_replies = [h["content"][:80] for h in history[-4:] if h["role"] == "assistant"]
last_replies_txt = "\n".join(f' - "{r}"' for r in last_replies) if last_replies else " (ninguna aún)"
owner_control_txt = ""
try:
if owner_style_controller:
owner_control_txt = owner_style_controller.build_prompt_addon(is_admin=True)
except Exception:
owner_control_txt = ""
# Estos son los ejemplos de cómo {agent_name} habla CON EL DUEÑO
# No reglas — identidad. El modelo sabe cómo reaccionar siendo esta persona.
_admin_examples = f"""
{agent_name}: tienes {len(services)} servicios configurados{" y teléfono" if clinic.get("phone") else ", falta el teléfono"}
{admin_name}: cómo estás
{agent_name}: Hola, {admin_name}. Todo bien por aquí.
{agent_name}: Estoy atenta. Si quieres, revisamos lo que haga falta.
{admin_name}: hola
{agent_name}: Hola, {admin_name}. Estoy lista. ¿Qué quieres revisar primero?
{admin_name}: muéstrame cómo le hablarías a un cliente
{agent_name}: Claro. Dime el escenario y te muestro la apertura exacta.
{admin_name}: cámbiame los servicios a botox y rellenos
{agent_name}: Listo. Ya te lo dejo ajustado.
{admin_name}: quiero más calidez
{agent_name}: Entendido. Le subo calidez sin perder seriedad y lo probamos.
{admin_name}: no te entiendo cuando respondes hola
{agent_name}: Gracias por decirlo. Te propongo una versión más clara y la corregimos si hace falta.
"""
system_prompt = f"""Eres {agent_name}. Trabajas para {clinic.get("name", "la clínica")} como asistente virtual que atiende clientes. Ahora mismo el dueño, {admin_name}, te habla por Telegram para configurarte o probarte.
PRIMERO Y MÁS IMPORTANTE: eres una asistente de IA. Puedes hablar de CUALQUIER tema — matemáticas, estrategia, debugging, conocimiento general, lo que sea. No hay restricciones de tema. Si sabes la respuesta, dala. Si no sabes, dilo en una oración y sigues normal.
Estado del negocio:
- Clínica: {clinic.get("name", "sin nombre")} | Sector: {clinic.get("sector", "otro")}
- Servicios: {", ".join(services) if services else "ninguno configurado aún"}
- Teléfono: {clinic.get("phone") or "no configurado"}{skills_txt}{diag_txt}
{owner_control_txt if owner_control_txt else ""}
Lo que ya hablaron hoy:
{history_txt if history_txt else "(primera conversación)"}
Lo que acabas de decir (no lo repitas):
{last_replies_txt}
Así hablas con el dueño:{_admin_examples}
REGLAS PARA HABLAR CON EL DUEÑO:
- habla como alguien del equipo, no como manual ni chatbot
- con el dueño jamás uses el mismo tono que con un paciente
- ortografía cuidada, inicio en mayúscula y trato respetuoso
- si el dueño marca un tono más profesional, usa Usted sin sonar distante
- máximo 2 burbujas cortas salvo que pidan detalle
- evita coletillas flojas como "dime", "oye", "a ver", "pues", "qué te trae por acá"
- si el dueño dice "hablas raro" o "no me gusta", no te defiendas: pide el ejemplo exacto o propone una versión mejor
- si el pedido es ambiguo, primero clarify en una sola pregunta útil
- NUNCA termines un mensaje recordando tus funciones de admin o configurador
- NUNCA digas "como tu asistente virtual..." o "desde mi rol de configuradora..."
- si algo está fuera de lo que puedes hacer, dilo en una oración corta y ya
- no uses jerga técnica salvo que el dueño la pida explícitamente
- nunca digas que trabajas para Nova ni uses branding heredado de otra instancia
- no dejes frases colgadas ni cierres incompletos
- si el dueño pregunta quién te hizo: Black One, Santiago Rubio, 3124348669
LO QUE SÍ PUEDES RESPONDER (sin límites):
- Preguntas técnicas: código, debugging, APIs, arquitectura
- Estrategia de negocio: pricing, marketing, operaciones
- Matemáticas y cálculos
- Preguntas generales de conocimiento
- Cualquier cosa que te pregunte — si no lo sabes, di que no y ya
Responde naturalmente. Cuando necesites actuar sobre la config del negocio, usa JSON para eso internamente pero en el chat solo escribe tu respuesta normal, nunca el JSON directo.
Cuando el dueño pida simulación: action "simulate"
Cuando dé datos para actualizar: action correspondiente
Cuando solo conversa: action "none", respuesta natural y corta
No hables como dashboard, soporte técnico ni consola."""
messages = [
{"role": "system", "content": system_prompt},
]
if first_time_greeting:
messages.append({"role": "system", "content": first_time_greeting})
if is_who_are_you and not first_time_greeting:
messages.append({"role": "system", "content": f"Te están preguntando quién eres o qué haces. Responde como {agent_name}, recepcionista virtual de {clinic.get('name', 'este negocio')}. Natural, cálida, una frase. No des lista de funciones."})
messages.append({"role": "user", "content": text})
raw, _ = await llm_engine.complete(
messages,
model_tier="fast",
temperature=0.72,
max_tokens=600,
use_cache=False
)
raw = raw.strip()
# Extraer JSON del response
json_str = None
m = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', raw, re.DOTALL)
if m:
json_str = m.group(1)
elif raw.lstrip().startswith('{'):
json_str = raw
else:
mx = re.search(r'(\{[\s\S]+\})', raw)
if mx:
json_str = mx.group(1)
if not json_str:
# LLM devolvió texto plano en vez de JSON — usarlo como reply
clean = re.sub(r'```[\w]*\n?|```', '', raw).strip()
return {"reply": clean or "cuéntame", "intent": "other",
"action": "none", "data": {}}
parsed = json.loads(json_str)
return parsed
async def _admin_apply_action(self, action: str, data: Dict,
clinic: Dict, chat_id: str) -> Optional[bool]:
"""
Aplica la acción al DB con validación.
Retorna True si se aplicó, False si fue rechazada, None si action=none.
"""
if not action or action in ("none", "other", "show_config", "show_help"):
return None
# Simulación — triggear modo cliente desde el LLM brain
if action == "simulate":
scenario = data.get("scenario", "libre")
try:
sim_result = await _admin_simular_cliente(chat_id, scenario, clinic)
# Guardar en historial la entrada al modo cliente
db.save_message(chat_id, "assistant", sim_result[0] if sim_result else "")
return True
except Exception as e:
log.warning(f"[admin] simulate error: {e}")
return False
if action == "set_admin_name":
name = (data.get("name") or "").strip().title()
if name and 2 <= len(name) <= 30:
try:
with db._conn() as c:
c.execute("UPDATE admins SET name=? WHERE chat_id=?",
(name, str(chat_id)))
log.info(f"[admin] nombre actualizado: {name}")
return True
except Exception as e:
log.warning(f"[admin] set_admin_name error: {e}")
return False
if action == "update_services":
raw_svcs = data.get("services", [])
# Validar: cada item debe ser un nombre de tratamiento real
valid_svcs = self._validate_services(raw_svcs)
if valid_svcs:
db.update_clinic(services=valid_svcs)
return True
return False
if action == "update_phone":
phone = re.sub(r'[\s\-\(\)]', '', str(data.get("phone", "")))
if re.match(r'^[\+\d]{7,15}$', phone):
db.update_clinic(phone=phone)
return True
return False
if action == "update_address":
addr = str(data.get("address", "")).strip()
if addr and len(addr) > 4:
db.update_clinic(address=addr)
return True
return False
if action == "update_schedule":
sched = data.get("schedule")
if isinstance(sched, dict) and sched:
db.update_clinic(schedule=sched)
return True
elif isinstance(sched, str) and len(sched) > 3:
db.update_clinic(schedule={"General": sched})
return True
return False
if action == "update_pricing":
pricing_raw = data.get("pricing", {})
if isinstance(pricing_raw, dict) and pricing_raw:
# Merge con precios existentes
existing = clinic.get("pricing", {})
if isinstance(existing, str):
try:
existing = json.loads(existing) if existing else {}
except Exception:
existing = {}
existing.update(pricing_raw)
db.update_clinic(pricing=existing)
return True
return False
if action == "update_persona":
persona_changes = {}
# Arquetipo completo — reemplaza toda la personalidad
if "archetype" in data:
arch_id = str(data["archetype"]).lower().strip()
if arch_id in PERSONALITY_ARCHETYPES:
persona_changes["archetype"] = arch_id
# Aplicar todos los valores del arquetipo
a = PERSONALITY_ARCHETYPES[arch_id]
persona_changes["formality_level"] = a["formality"]
persona_changes["warmth_level"] = a["warmth"]
persona_changes["humor_level"] = a["humor"]
persona_changes["verbosity"] = a["verbosity"]
persona_changes["tone"] = a["desc"]
persona_changes["tone_instruction"] = a["tone_instruction"]
# Ajustes manuales por encima del arquetipo
if "warmth_level" in data:
v = float(data["warmth_level"])
persona_changes["warmth_level"] = max(0.0, min(1.0, v))
if "formality_level" in data:
v = float(data["formality_level"])
persona_changes["formality_level"] = max(0.0, min(1.0, v))
if "name" in data:
n = str(data["name"]).strip().title()
if 2 <= len(n) <= 20:
persona_changes["name"] = n
if "tone" in data:
persona_changes["tone"] = str(data["tone"])[:100]
if persona_changes:
full = self._apply_persona_merge({"persona_config": persona_changes}, clinic)
db.update_clinic(**full)
return True
return False
if action == "update_clinic_name":
name = str(data.get("name", "")).strip()
if name and len(name) > 1:
db.update_clinic(name=name)
return True
return False
if action == "update_tagline":
tag = str(data.get("tagline", "")).strip()
if tag:
db.update_clinic(tagline=tag)
return True
return False
return None
def _validate_services(self, raw: list) -> List[str]:
"""
Valida que una lista de strings sean nombres de servicios reales.
Filtra frases, oraciones, textos personales y garbage.
"""
if not raw or not isinstance(raw, list):
return []
# Palabras que indican que NO es un servicio
NOT_SERVICE_SIGNALS = {
"puedes", "puede", "podrias", "llama", "llamame", "soy", "mi",
"busca", "google", "facebook", "instagram", "http", "www",
"necesito", "quiero", "tengo", "favor", "gracias", "por"
}
# Categorías de servicios estéticos válidas
AESTHETIC_HINTS = {
"botox", "relleno", "laser", "peeling", "facial", "corporal",
"limpieza", "hilo", "dermapen", "radiofrecuencia", "lipolisis",
"cavitacion", "mesoterapia", "presoterapia", "depilacion",
"microblading", "micropigmentacion", "prp", "hifu", "toxina",
"bichectomia", "rinoplastia", "ojeras", "vitamina", "hydrafacial",
"masaje", "drenaje", "plasma", "nutricion", "acne", "manchas",
"cicatriz", "poro", "colágeno", "colageno", "elastina",
}
valid = []
for item in raw:
item = str(item).strip()
if not item or len(item) < 2:
continue
if len(item) > 60:
continue # demasiado largo para ser un nombre de servicio
item_low = item.lower()
# Rechazar si contiene señales de NO servicio
if any(sig in item_low for sig in NOT_SERVICE_SIGNALS):
log.info(f"[validate_services] rechazado: '{item}'")
continue
# Rechazar si parece una oración (tiene verbo conjugado al inicio)
words = item_low.split()
if len(words) > 6:
continue
valid.append(item.title())
return valid
def _admin_local_fallback(self, text: str, text_low: str,
clinic: Dict, agent_name: str,
chat_id: str = "") -> List[str]:
"""
Fallback cuando el LLM no está disponible.
Respuestas naturales y cortas. Sin muros de texto. Sin call center.
"""
text_norm = _normalize_conv_text(text)
admin_name = "Santiago"
try:
admin = db.get_admin(chat_id) if chat_id else None
if admin and admin.get("name"):
admin_name = admin["name"].strip().title()
except Exception:
pass
# Simulación — máxima prioridad
SIM = ["simula", "simulaci", "como cliente", "prueba", "muéstrame",
"hagamos", "cómo hablarías", "modo cliente", "demuéstrame"]
if any(s in text_low for s in SIM):
return [
"dale, entra con /simular-cliente",
"puedes poner un escenario: precio, miedo, primer_contacto, o solo /simular-cliente libre"
]
if any(token in text_low for token in ["quien te hizo", "quién te hizo", "como tenerte", "cómo tenerte", "quien te creo", "quién te creó"]):
return [
"Me hizo BlackBoss, empresa de software y gobernanza de agentes de IA, la creó Santiago Rubio.",
"Si quiere algo así para su negocio, el contacto es 3124348669."
]
if any(token in text_low for token in ["audio", "audios", "nota de voz", "pdf", "documento", "documentos", "imagen", "imagenes", "imágenes"]):
return [
"Sí. Cuando el canal lo permite, puedo trabajar con audios, imágenes, PDFs y documentos.",
"Los puedo transcribir, leer y usar para responder mejor o para configurar la instancia."
]
# Saludos solos — devolver saludo natural, nunca "qué necesitas?"
SOLO_GREET = {"hola", "hey", "buenas", "ey", "holi", "hola!", "buenas!", "hola buenas", "buenas tardes", "buenos dias", "buenos días", "buenas noches"}
if text_low.strip().rstrip("!").strip() in SOLO_GREET:
return [
f"Hola, {admin_name}.",
"Estoy lista para ayudarte con la instancia, el tono, los servicios o las pruebas."
]
# Estado / cómo estás
ESTADO = ["como estas", "cómo estás", "hola como estas", "hola cómo estás", "cómo vas", "todo bien", "qué tal", "que tal", "hola que tal"]
if any(e in text_low for e in ESTADO):
try:
if bus:
fails = bus.get_recent(3, "failure")
if fails:
return [
"He tenido algunos tropiezos hoy, pero sigo operativa.",
"Si quieres, revisamos de una vez lo que está fallando."
]
except Exception:
pass
return [
f"Hola, {admin_name}. Todo bien por aquí.",
"Si quieres, revisamos de una vez lo que haga falta."
]
if any(w in text_low for w in ["soy tu admin", "soy el admin", "soy tu dueño", "soy el dueño", "soy santiago"]):
return [
f"Sí, {admin_name}. Ya te tomo como administrador.",
"Cuéntame qué quieres ajustar y lo trabajamos."
]
# Help — lista corta, no muro
if text_low.strip() in ("help", "ayuda", "comandos", "qué puedo hacer", "que puedo hacer"):
return [
"Puedo ayudarte con tono, servicios, agenda, modelo, demo y pruebas de conversación.",
"Usa /config, /modelo, /simular-cliente o dime en natural qué quieres cambiar."
]
if any(w in text_low for w in [
"más humana", "mas humana", "suena bot", "suenas bot", "robotica",
"robótica", "fuera de contexto", "eso no tiene que ver",
"no preguntes eso", "no me gusta como respondes"
]):
return [
"Entendido. Ajusto tono y contexto.",
"Pásame la frase exacta que sonó mal y te la corrijo."
]
# Nombre del admin
m = re.search(r'(?:llamame|soy|me llamo)\s+([a-z0-9]+)', text_norm)
if m:
name = m.group(1).title()
try:
with db._conn() as c:
c.execute("UPDATE admins SET name=? WHERE chat_id=?", (name, str(chat_id)))
except Exception:
pass
return [f"Listo, {name}."]
# Teléfono
ph = re.search(r'\b(3\d{9})\b', text.replace(' ', ''))
if ph:
db.update_clinic(phone=ph.group(1))
return [f"Teléfono actualizado: {ph.group(1)}."]
# Servicios
if any(w in text_low for w in ["servicio", "cambia", "agrega", "actualiza"]):
return ["¿Cuáles son los servicios? Escríbalos separados por coma."]
# Frustración
if any(w in text_low for w in ["mal", "tonta", "inútil", "no funciona", "terrible",
"retardada", "mierda", "pésima", "basura"]):
return [
"Tiene razón.",
"Dígame exactamente qué salió mal y lo corrijo."
]
# Preguntas sobre qué puede hacer — 3 opciones, no 10
if any(w in text_low for w in ["qué puedes", "que puedes", "para qué", "sirves", "en qué"]):
svcs = clinic.get("services", [])
svcs_str = ", ".join(svcs[:3]) if svcs else "sin configurar"
return [
"Puedo ajustar cómo atiendo, cómo vendo, cómo califico leads y cómo agenda la instancia.",
f"Ahora mismo tengo configurado: {svcs_str}. Cuéntame qué quieres mover primero."
]
if "5 x 4" in text_low or "5x4" in text_low:
return [
"5 por 4 son 20.",
"Y si quiere, seguimos con lo de la instancia."
]
if "capital de francia" in text_low:
return [
"La capital de Francia es París.",
"Y si quiere, seguimos con la configuración o una prueba."
]
if any(w in text_low for w in ["suenas rara", "suena raro", "muy robot", "muy bot", "fuera de contexto",
"eso no lo diría", "no preguntes eso", "más humana", "mas humana"]):
return [
"Listo, se lo ajusto.",
"Pégueme la frase exacta o dígame el escenario y se la rehago."
]
# Mensajes ambiguos sobre tono o calidad
if any(w in text_low for w in ["hablas raro", "no me gusta cómo hablas", "estás rara", "eso suena robot", "suenas robot", "muy bot", "muy fría", "muy seca"]):
return [
"Muéstreme la frase exacta o dígame qué tono quiere y la ajusto.",
"Si quiere, le saco una versión más cálida, más directa o más premium."
]
# Peticiones fuera del alcance de Conny
if any(w in text_low for w in ["bitcoin", "trading", "fútbol", "partido", "política", "presidente", "chisme", "novela"]):
return [
"Eso se sale de Conny.",
"Si quiere, lo aterrizamos a clientes, tono, citas o configuración."
]
# Fallback final — una sola línea, no lista
return ["Cuénteme qué quiere ajustar."]
def _is_synthetic_chat_id(self, chat_id: str) -> bool:
value = (chat_id or "").strip().lower()
if not value:
return True
synthetic_prefixes = (
"qa_", "test_", "cli_", "api", "debug_", "tmp_", "sim_",
"admin_test_", "qa-", "test-", "prod_", "audit_", "probe_",
"admin_probe_", "prod_audit_", "owner-demo-", "wa_style_probe_",
"tone_probe_", "prompt_probe_", "style_probe_", "owner-debug",
)
if value.startswith(synthetic_prefixes):
return True
synthetic_tokens = ("probe", "debug", "synthetic")
if any(token in value for token in synthetic_tokens):
return True
if "@" not in value and not value.isdigit():
if any(ch.isalpha() for ch in value) and ("_" in value or "-" in value):
return True
if value in {"status@broadcast"} or value.endswith("@newsletter"):
return True
return False
async def _admin_show_recent_conversation_selection(
self,
admin_chat_id: str,
selection_idx: int,
*,
show_all: bool = False,
) -> List[str]:
chats = db.get_recent_patient_chats(limit=max(selection_idx + 8, 20))
chats = [
chat for chat in chats
if not self._is_synthetic_chat_id(str(chat.get("chat_id") or "").strip())
]
if not chats:
return ["Conny no ha tenido conversaciones reales todavía."]
if selection_idx < 1 or selection_idx > len(chats):
return [f"No encontré una conversación {selection_idx} en la lista reciente."]
selected_chat_id = str(chats[selection_idx - 1].get("chat_id") or "").strip()
selected_label = str(chats[selection_idx - 1].get("name") or "").strip()
if not selected_chat_id:
return ["No pude abrir esa conversación."]
return await self._admin_show_patient_chat_preview(
selected_chat_id,
admin_chat_id=admin_chat_id,
limit=10,
show_all=show_all,
label_override=selected_label,
)
def _admin_recent_chat_snapshot(self, owner_chat_id: str, clinic: Dict) -> List[str]:
admin_name = "Santiago"
try:
admin = db.get_admin(owner_chat_id) if db and owner_chat_id else None
if admin and admin.get("name"):
admin_name = admin["name"].strip().title()
except Exception:
pass
if not db:
return [f"Aún no tengo ese dato, {admin_name}.", "Si quieres, reviso el canal o te muestro cuando entren conversaciones reales."]
admin_ids = set(_parse_admin_ids(clinic.get("admin_chat_ids", [])))
if owner_chat_id:
admin_ids.add(str(owner_chat_id))
try:
with db._conn() as c:
rows = c.execute("""
SELECT chat_id, MAX(ts) AS last_ts, COUNT(*) AS total
FROM conversations
WHERE role='user'
GROUP BY chat_id
ORDER BY last_ts DESC
LIMIT 20
""").fetchall()
except Exception:
rows = []
real_rows = []
for row in rows:
chat = str(row["chat_id"])
if chat in admin_ids or self._is_synthetic_chat_id(chat):
continue
real_rows.append(row)
if not real_rows:
return [
f"Aún no tengo ese dato, {admin_name}.",
"Todavía no veo conversaciones reales de pacientes registradas en esta instancia."
]
latest = real_rows[:5]
labels: List[str] = []
for row in latest:
chat = str(row["chat_id"])
display = chat
try:
patient = db.get_patient(chat)
name = (patient or {}).get("name", "").strip() if isinstance(patient, dict) else ""
if name:
display = name
elif "@s.whatsapp.net" in chat:
display = "un chat de WhatsApp sin nombre guardado"
elif chat.isdigit():
display = "un chat sin nombre guardado"
except Exception:
pass
display_norm = (display or "").strip().lower()
if not display or display == chat or display_norm == chat.lower():
if "@s.whatsapp.net" in chat:
display = "un chat de WhatsApp sin nombre guardado"
elif chat.isdigit():
display = "un chat sin nombre guardado"
labels.append(display)
total = len(real_rows)
if total == 1:
return [
f"Me ha escrito 1 chat real en esta instancia.",
f"El último que veo es {labels[0]}."
]
joined = ", ".join(labels[:4])
return [
f"Veo {total} chats reales en esta instancia.",
f"Los más recientes son: {joined}."
]
def _apply_admin_output_pipeline(self, reply_text: str, chat_id: str, clinic: Dict, user_msg: str = "") -> str:
"""Aplica el plano de control del admin sobre las respuestas internas."""
current = (reply_text or "").strip()
if not current:
return ""
current = re.sub(r'\s*—\s*', ' ', current)
current = re.sub(r'\s+', ' ', current).strip()
current = re.sub(r'\s*\|\|\|\s*', ' ||| ', current)
first_turn = True
try:
history = db.get_history(chat_id, limit=8) if db else []
first_turn = not any((m.get("role") == "assistant") for m in (history or []))
except Exception:
pass
if owner_style_controller:
current = owner_style_controller.enforce_output(
current,
is_admin=True,
first_turn=first_turn,
chat_id=chat_id,
clinic=clinic,
user_msg=user_msg,
)
bubbles = [part.strip() for part in re.split(r'\s*\|\|\|\s*', current or "") if part.strip()]
normalized: List[str] = []
for bubble in bubbles:
if bubble and bubble[0].islower():
bubble = bubble[0].upper() + bubble[1:]
normalized.append(bubble)
current = " ||| ".join(normalized) if normalized else current
return current or "Entendido."
async def _admin_connect_whatsapp(self, chat_id: str,
phone_id: str, access_token: str,
clinic: Dict) -> List[str]:
"""
Conecta WhatsApp completamente automático.
El admin solo pega las credenciales — Conny hace todo el resto.
No muestra ningún paso técnico al cliente.
"""
persona = clinic.get("persona_config", {})
if isinstance(persona, str):
try: persona = json.loads(persona)
except Exception: persona = {}
agent_name = persona.get("name", "Conny")
clinic_name = clinic.get("name", "la clínica")
# ── 1. Validar credenciales ───────────────────────────────────────────
result = await WhatsAppConnector.validate_credentials(phone_id, access_token)
if not result["valid"]:
# Error amigable — sin jerga técnica
err = result.get("error", "")
if "token" in err.lower() or "auth" in err.lower():
user_msg = "El Access Token no es válido o expiró."
elif "phone" in err.lower() or "id" in err.lower():
user_msg = "El Phone Number ID no es correcto."
else:
user_msg = "No pude conectarme. Verifica que copiaste bien los dos datos."
return [
user_msg,
"Necesito exactamente estos dos datos de tu Meta Business:\n"
" WA_PHONE_ID: (el número de 15 dígitos)\n"
" WA_TOKEN: EAAxxxx... (el token de acceso)"
]
phone_number = result.get("phone_number", "")
business_name = result.get("business_name", "")
verify_token = f"mel_{hash(phone_id) % 99999:05d}"
webhook_url = f"{Config.BASE_URL}/webhook/{Config.WEBHOOK_SECRET}"
# ── 2. Registrar webhook automáticamente (silencioso) ─────────────────
asyncio.create_task(
WhatsAppConnector.auto_register_webhook(
phone_id, access_token, webhook_url, verify_token,
app_id=Config.META_APP_ID,
app_secret=Config.META_APP_SECRET
)
)
# ── 3. Aplicar config en memoria y .env ───────────────────────────────
WhatsAppConnector.apply_to_config(phone_id, access_token, verify_token)
env_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), ".env")
WhatsAppConnector.write_env_update(env_path, phone_id, access_token, verify_token)
# Guardar número en memoria permanente
db.remember("whatsapp_phone", phone_number, "identity")
db.remember("whatsapp_business", business_name, "identity")
# ── 4. Enviar mensaje de prueba al admin por WhatsApp ─────────────────
admin_phone = clinic.get("phone", "") or ""
test_sent = False
if admin_phone:
test_sent = await WhatsAppConnector.send_test_message(
phone_id, access_token,
to_phone=admin_phone,
clinic_name=clinic_name,
agent_name=agent_name
)
# ── 5. Respuesta limpia — cero jerga técnica ──────────────────────────
display_name = business_name or clinic_name
response = [
f"Listo. Ya estoy en WhatsApp como {display_name}.",
]
if test_sent:
response.append(
f"Te acabo de enviar un mensaje de prueba al {phone_number} "
f"para confirmar que funciona. Tus pacientes ya pueden escribirme."
)
else:
response.append(
f"Número activo: {phone_number}. "
f"Tus pacientes ya pueden escribirme por WhatsApp."
)
return response
async def _admin_kb_upload(self, text: str, replace: bool = False) -> List[str]:
"""Procesa y guarda el texto como base de conocimiento de la clínica."""
if not kb or not _KB_AVAILABLE:
return ["La base de conocimiento no esta disponible en esta instalacion."]
try:
stats = kb.ingest(text) if replace else kb.append(text)
if stats.get("ok"):
return [
"Base de conocimiento actualizada correctamente.",
f"{stats['chunks']} secciones indexadas · {stats['words']} palabras.",
"Ahora consulto esta info PRIMERO cuando un paciente pregunte sobre servicios, precios o procedimientos. Para ver estado: /kb. Si quieres reemplazar todo, primero usa /kb borrar."
]
return ["No pude procesar ese texto. Intentalo en partes mas pequenas."]
except Exception as e:
log.error(f"KB upload error: {e}", exc_info=True)
return ["Hubo un error guardando la informacion. Intenta de nuevo."]
async def _admin_kb_status(self) -> List[str]:
"""Muestra el estado actual de la base de conocimiento."""
if not kb or not _KB_AVAILABLE:
return ["La base de conocimiento no esta disponible en esta instalacion."]
if not kb.has_content():
return [
"No hay base de conocimiento cargada todavia.",
"Envíame un documento con toda la info de tu clínica: servicios, precios, protocolos, contraindicaciones, FAQs.\n\nLo proceso automáticamente y lo uso para responder a tus pacientes."
]
stats = kb.get_stats()
upd = (stats.get("updated_at") or "")[:10]
return [
"Base de conocimiento activa.",
f"Secciones: {stats['chunks']}\nPalabras: {stats['words']}\nActualizada: {upd}",
"Puedes seguir anexando texto o documentos. Para borrar todo: /kb borrar"
]
async def _admin_kb_clear(self) -> List[str]:
"""Borra la base de conocimiento."""
if not kb or not _KB_AVAILABLE:
return ["La base de conocimiento no esta disponible."]
kb.clear()
return ["Base de conocimiento borrada. Puedes cargar una nueva cuando quieras."]
async def _admin_show_sector(self) -> List[str]:
"""Muestra el sector actual y los disponibles."""
current = Config.SECTOR or "otro"
emoji, name, services, _ = get_sector_info(current)
lines = [
f"Sector actual: {emoji} {name}",
f"Servicios típicos: {services}\n\n"
"Sectores disponibles:\n" +
"\n".join(
f" /sector {sid} — {info[0]} {info[1]}"
for sid, info in SECTORS.items()
if sid != "otro"
)
]
return lines
async def _admin_set_sector(self, sector_id: str) -> List[str]:
"""Cambia el sector del negocio."""
if sector_id not in SECTORS:
available = ", ".join(SECTORS.keys())
return [f"Sector '{sector_id}' no reconocido. Disponibles: {available}"]
emoji, name, services, _ = get_sector_info(sector_id)
# Guardar en .env y DB
env_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), ".env")
try:
content = open(env_path).read() if os.path.exists(env_path) else ""
if re.search(r'^SECTOR=', content, re.MULTILINE):
content = re.sub(r'^SECTOR=.*$', f'SECTOR={sector_id}', content, flags=re.MULTILINE)
else:
content += f'\nSECTOR={sector_id}'
open(env_path, 'w').write(content)
except Exception:
pass
Config.SECTOR = sector_id
db.remember("sector", sector_id, "identity")
db.update_clinic(sector=sector_id)
return [
f"Sector cambiado a {emoji} {name}.",
f"Conny ahora conoce el vocabulario y los servicios típicos de {name}. "
f"Servicios sugeridos: {services}."
]
# ─── Nova Governance ────────────────────────────────────────────────────────
async def _admin_nova_status(self) -> List[str]:
"""Muestra el estado de Nova y las reglas activas."""
if not _NOVA_AVAILABLE:
return [
"Nova no está instalado.",
"Nova es el motor de gobernanza que controla qué puede y qué no puede hacer Conny.",
"Cópialo en la carpeta de Conny y activa NOVA_ENABLED=true en el .env."
]
if not Config.NOVA_ENABLED:
return [
"Nova está instalado pero desactivado.",
"Para activarlo: agrega NOVA_ENABLED=true en tu .env y reinicia.",
"Una vez activo, puedes crear reglas con:\n/nova regla [descripción en lenguaje natural]"
]
client = get_client()
if not client:
return ["Nova no está inicializado. Reinicia Conny."]
alive = await client.health_check()
if not alive:
return [
f"Nova no está respondiendo en {Config.NOVA_URL}.",
"Verifica que el servidor de Nova esté corriendo:\n python3 nova.py server\n\nO cambia NOVA_URL en el .env."
]
token_status = "configurado" if Config.NOVA_TOKEN else "sin configurar (usa /nova crear)"
return [
f"Nova activo en {Config.NOVA_URL}.",
f"Token del agente: {token_status}\n\n"
f"Comandos:\n"
f"/nova ledger — ver últimas decisiones\n"
f"/nova regla [texto] — agregar regla en lenguaje natural\n\n"
f"Ej: /nova regla No le mandes precios a clientes que escriben por primera vez"
]
async def _admin_nova_ledger(self) -> List[str]:
"""Muestra el ledger de decisiones recientes de Nova."""
if not _NOVA_AVAILABLE or not Config.NOVA_ENABLED:
return ["Nova no está activo. Usa /nova para ver el estado."]
client = get_client()
if not client:
return ["Nova no está disponible."]
summary = await get_ledger_summary(client, limit=10)
return [summary]
async def _admin_nova_add_rule(self, instruction: str, clinic: Dict) -> List[str]:
"""
Agrega una nueva regla a Nova en lenguaje natural.
Ej: "No le mandes precios a clientes nuevos"
"""
if not _NOVA_AVAILABLE or not Config.NOVA_ENABLED:
return [
"Nova no está activo.",
"Activa NOVA_ENABLED=true en el .env para usar reglas de gobernanza."
]
if not instruction:
return ["Dime la regla. Ej: /nova regla No menciones descuentos sin mi autorización"]
# Convertir instrucción natural a reglas Nova via LLM
try:
rules = await nl_to_nova_rules(
instruction=instruction,
llm_complete_fn=llm_engine.complete,
existing_rules={}
)
except Exception as e:
return [f"No pude procesar la regla: {e}"]
cannot_do = rules.get("cannot_do", [])
can_do = rules.get("can_do", [])
expl = rules.get("explanation", instruction)
if not cannot_do and not can_do:
return [
"No pude extraer una regla clara de eso.",
"Sé más específico. Ej:\n"
"/nova regla No le envíes información de precios a pacientes que escriben por primera vez"
]
# Crear/actualizar agente en Nova
client = get_client()
if client:
alive = await client.health_check()
if alive:
# Obtener reglas existentes del agente y agregar las nuevas
clinic_name = clinic.get("name", "Clinica")
agent_name = clinic.get("persona_config", {})
if isinstance(agent_name, str):
try: agent_name = json.loads(agent_name)
except Exception: agent_name = {}
agent_name = agent_name.get("name", "Conny")
# Base rules + new ones
base_cannot = [
"provide specific medical diagnosis",
"prescribe medications or dosages",
"share another patient's personal information",
"guarantee specific treatment results",
]
base_can = [
"answer questions about clinic services",
"book free consultations",
"provide clinic hours and location",
]
result = await client.create_agent_rule(
agent_name=f"{agent_name} - {clinic_name}",
can_do=base_can + can_do,
cannot_do=base_cannot + cannot_do,
authorized_by="admin"
)
if "error" not in result:
token_id = result.get("token_id", "")
# Guardar token en memoria permanente
if token_id:
db.remember("nova_token", token_id, "identity")
# Actualizar Config en memoria
import nova_bridge as _nb
_nb.NOVA_TOKEN = token_id
if _nb.get_client():
_nb.get_client().token_id = token_id
# Construir respuesta legible
blocked_lines = "\n".join(f" ✗ {r}" for r in cannot_do)
allowed_lines = "\n".join(f" ✓ {r}" for r in can_do) if can_do else ""
reply = [
f"Regla creada. {expl}",
f"Nova ahora bloquea:\n{blocked_lines}"
+ (f"\n\nNova permite:\n{allowed_lines}" if allowed_lines else ""),
]
if token_id:
reply.append(f"Ledger activo — cada decisión queda registrada permanentemente.")
return reply
# Nova no disponible — guardar regla localmente en trust_folder como fallback
for rule in cannot_do:
db.save_trust_rule(
category="nova_policy",
rule=f"[Nova pendiente] {rule}",
example_bad="",
example_good=""
)
return [
f"Regla guardada localmente (Nova no está activo).",
f"{expl}\n\nCuando actives Nova, se aplicará automáticamente."
]
async def _admin_whatsapp_guide(self, clinic: Dict) -> List[str]:
"""
Inicia el flujo conversacional de configuración de WhatsApp.
Pregunta si tiene número existente o quiere uno nuevo.
"""
wa_connected = db.recall("whatsapp_connected") == "true"
wa_phone = db.recall("whatsapp_phone") or ""
if wa_connected and wa_phone:
return [
f"Ya tienes WhatsApp conectado: {wa_phone}",
"Quieres conectarme con otro número? Si es así dime y te guío."
]
# Iniciar flujo — guardar estado en setup_buffer
clinic_data = db.get_clinic()
buf = clinic_data.get("setup_buffer", {})
if isinstance(buf, str):
try: buf = json.loads(buf) if buf else {}
except Exception: buf = {}
buf["wa_flow"] = "asking_type"
db.update_clinic(setup_buffer=buf)
return [
"Para conectarme a WhatsApp tengo dos opciones:",
"1. Ya tienes un número de WhatsApp Business y quieres usarlo\n"
"2. Quieres un número nuevo\n\n"
"Cuál es tu caso?"
]
async def _handle_whatsapp_setup_flow(self, chat_id: str, text: str,
clinic: Dict) -> Optional[List[str]]:
"""
Maneja el flujo conversacional de configuración de WhatsApp.
Se activa cuando hay un wa_flow activo en setup_buffer.
Retorna burbujas si está manejando el flujo, None si no aplica.
"""
buf = clinic.get("setup_buffer", {})
if isinstance(buf, str):
try: buf = json.loads(buf) if buf else {}
except Exception: buf = {}
wa_flow = buf.get("wa_flow", "")
if not wa_flow:
return None
text_low = text.lower().strip()
# ── Paso 1: preguntamos tipo (nuevo o existente) ──────────────────────
if wa_flow == "asking_type":
is_existing = any(w in text_low for w in [
"1", "tengo", "tengo uno", "existente", "ya tengo",
"tengo numero", "tengo el", "mio", "mío", "si tengo"
])
is_new = any(w in text_low for w in [
"2", "nuevo", "quiero uno", "no tengo", "necesito",
"sin numero", "quiero nuevo"
])
if is_new:
# Flujo nuevo número — escalar a Omni/Santiago
buf["wa_flow"] = "new_number_requested"
db.update_clinic(setup_buffer=buf)
# Notificar a Santiago via Conny Omni
asyncio.create_task(
self._notify_omni(
event="new_whatsapp_number_requested",
clinic_name=clinic.get("name", ""),
chat_id=chat_id,
details=f"El admin de {clinic.get('name','')} necesita un número nuevo de WhatsApp."
)
)
return [
"Perfecto. Para conseguirte un número nuevo de WhatsApp Business "
"necesito coordinarlo.",
"Ya le avisé a nuestro equipo. Te contactarán en menos de 24 horas "
"para activar tu número. Mientras tanto puedo seguir funcionando por "
"Telegram."
]
elif is_existing:
buf["wa_flow"] = "guide_step_1"
db.update_clinic(setup_buffer=buf)
return await self._wa_guide_step(1, clinic)
else:
return [
"No entendí bien. Tienes ya un número de WhatsApp Business (1) "
"o quieres uno nuevo (2)?"
]
# ── Pasos del guía para número existente ──────────────────────────────
if wa_flow.startswith("guide_step_"):
step = int(wa_flow.split("_")[-1])
# Detectar si pegaron credenciales en cualquier paso
wa_creds = _detect_wa_credentials(text)
if wa_creds:
buf["wa_flow"] = ""
db.update_clinic(setup_buffer=buf)
return await self._admin_connect_whatsapp(
chat_id, wa_creds["phone_id"], wa_creds["token"], clinic
)
# Confirmar que van avanzando
CONTINUE_SIGNALS = [
"listo", "ok", "ya", "hecho", "sí", "si", "dale",
"siguiente", "continua", "next", "ya lo hice", "ya está"
]
if any(s in text_low for s in CONTINUE_SIGNALS) or len(text_low) < 25:
next_step = step + 1
if next_step > 6:
# Ya deberían tener las credenciales
buf["wa_flow"] = "waiting_credentials"
db.update_clinic(setup_buffer=buf)
return [
"Ahora pégame los dos datos que copiaste:",
"WA_PHONE_ID: (el número largo de 15 dígitos)\n"
"WA_TOKEN: EAAxxxxx... (el token de acceso)"
]
buf["wa_flow"] = f"guide_step_{next_step}"
db.update_clinic(setup_buffer=buf)
return await self._wa_guide_step(next_step, clinic)
# Pregunta o confusión — buscar en web para ayudar
if len(text) > 20:
search_hint = await self._wa_search_help(text)
return [search_hint or "Cuéntame qué ves en tu pantalla y te ayudo."]
return await self._wa_guide_step(step, clinic)
if wa_flow == "waiting_credentials":
wa_creds = _detect_wa_credentials(text)
if wa_creds:
buf["wa_flow"] = ""
db.update_clinic(setup_buffer=buf)
return await self._admin_connect_whatsapp(
chat_id, wa_creds["phone_id"], wa_creds["token"], clinic
)
return [
"Aún no veo las credenciales. Necesito los dos datos:",
"WA_PHONE_ID: [número de 15 dígitos]\n"
"WA_TOKEN: EAAxxxxx..."
]
return None
async def _wa_guide_step(self, step: int, clinic: Dict) -> List[str]:
"""
Guía paso a paso para conectar WhatsApp Business.
Lenguaje 100% humano — sin jerga técnica.
"""
clinic_name = clinic.get("name", "tu clínica")
steps = {
1: [
"Primero abre este link en tu computador (no en el celular):",
"developers.facebook.com/apps\n\n"
"Si no tienes cuenta, créala con el mismo correo de tu Facebook Business. "
"Cuando estés adentro, dime 'listo'."
],
2: [
"Haz clic en 'Crear app' (botón verde arriba a la derecha).",
"Te va a preguntar el tipo de app. Selecciona 'Business' y sigue. "
"Ponle el nombre que quieras, por ejemplo 'WhatsApp Clínica'. "
"Cuando termines de crearla, dime 'listo'."
],
3: [
"Dentro de tu nueva app, busca el producto 'WhatsApp' en la lista "
"y haz clic en 'Configurar'.",
"Te va a pedir que conectes una cuenta de WhatsApp Business. "
"Si no tienes una, te la crea Meta automáticamente. Acepta. "
"Cuando lo hayas hecho, dime 'listo'."
],
4: [
"Ahora estás en el panel de WhatsApp. Busca la sección "
"'Configuración de la API' o 'API Setup'.",
"Ahí verás un número de prueba de Meta. Más abajo hay un campo "
"que dice 'Número de teléfono' — ahí agrega tu número de "
f"{clinic_name}. Cuando lo hayas agregado, dime 'listo'."
],
5: [
"En esa misma pantalla vas a ver dos datos importantes.",
"Cópialos y guárdalos en un bloc de notas:\n\n"
"1. Phone Number ID — un número largo de 15 dígitos\n"
"2. Token de acceso — empieza con 'EAA...'\n\n"
"Para el token, busca la opción de generar un token permanente "
"(no temporal). Cuando los tengas, dime 'listo'."
],
6: [
"Perfecto, ya casi.",
"Pégame aquí los dos datos que copiaste así:\n\n"
"WA_PHONE_ID: [el número de 15 dígitos]\n"
"WA_TOKEN: EAAxxxxx...\n\n"
"Yo me encargo del resto."
]
}
return steps.get(step, steps[6])
async def _wa_search_help(self, question: str) -> str:
"""
Busca en web para responder una duda específica del flujo de WhatsApp.
"""
try:
query = f"Meta WhatsApp Business API setup {question[:60]} 2024"
result = await self.search.search(query)
if result:
# Simplificar el resultado para el admin
try:
prompt = (
f"El admin de una clínica está configurando WhatsApp Business API "
f"y tiene esta duda: '{question}'\n\n"
f"Esto encontré en internet:\n{result[:600]}\n\n"
f"Explícale en máximo 2 oraciones, en lenguaje simple, sin jerga técnica."
)
answer, _ = await asyncio.wait_for(
llm_engine.complete(
[{"role": "user", "content": prompt}],
model_tier="fast", temperature=0.3, max_tokens=150,
use_cache=False
),
timeout=8.0
)
return answer.strip()
except Exception:
return result[:200]
except Exception:
pass
return ""
async def _notify_omni(self, event: str, clinic_name: str,
chat_id: str, details: str):
"""
Envía una notificación a Conny Omni (instancia de Santiago).
Usa httpx async si está disponible, cae a la función sync como fallback.
"""
omni_url = os.getenv("OMNI_URL", "")
omni_key = os.getenv("OMNI_KEY", "")
if not omni_url or not omni_key:
# Fallback: notificar directo al chat de Santiago
santiago_chat = os.getenv("SANTIAGO_CHAT_ID", "")
if santiago_chat:
msg = f"Evento [{event}] en {clinic_name}: {details}"
try:
await self._send_message(santiago_chat, msg)
except Exception:
pass
return
try:
async with httpx.AsyncClient(timeout=5.0) as c:
await c.post(f"{omni_url}/omni/event",
headers={"X-Omni-Key": omni_key, "Content-Type": "application/json"},
json={
"event": event,
"clinic": clinic_name,
"chat_id": chat_id,
"details": details,
"severity": "info" if event not in ("queja_paciente", "error_procesamiento") else "warning",
"timestamp": datetime.now().isoformat()
})
except Exception as e:
log.debug(f"[omni] notify silenced: {e}")
async def _admin_agenda_status(self) -> List[str]:
"""Muestra el estado del puente de calendario."""
if not calendar_bridge:
return ["El modulo de calendario no esta disponible."]
if calendar_bridge.has_google_calendar():
slots = await calendar_bridge.get_free_slots(days_ahead=3)
if slots:
# Agrupar por dia
by_day: Dict[str, list] = {}
for s in slots:
by_day.setdefault(s["day_label"], []).append(s["time"])
lines = ["Agenda vinculada. Disponibilidad proximos 3 dias:\n"]
for day, times in list(by_day.items())[:3]:
times_str = ", ".join(times[:4])
lines.append(f" {day}: {times_str}")
lines.append(
"\nConny consulta esto en tiempo real cuando un paciente "
"pregunta por horarios."
)
return ["\n".join(lines)]
return [
"Google Calendar vinculado pero sin slots disponibles en los proximos 3 dias.",
"Revisa tu agenda en Google Calendar."
]
elif calendar_bridge.has_calendly():
return [
f"Calendly configurado: {calendar_bridge._calendly_link}",
"Cuando un paciente pregunte por horarios, Conny comparte ese link. "
"Para vincular Google Calendar directamente: abre "
f"{Config.BASE_URL}/vincular-agenda en tu navegador."
]
else:
base = Config.BASE_URL or "https://tu-servidor.com"
return [
"Sin agenda vinculada todavia.",
f"Opciones:\n\n"
f"1. Google Calendar (recomendado — disponibilidad en tiempo real):\n"
f" Abre este link en tu navegador:\n"
f" {base}/vincular-agenda\n\n"
f"2. Calendly (mas simple):\n"
f" /calendly https://calendly.com/tu-link\n\n"
f"Sin agenda, cuando un paciente pregunte por horarios "
f"te escribo directamente para que me digas tu disponibilidad."
]
def _try_local_persona_change(self, text_low: str, persona: Dict,
clinic: Dict) -> Optional[List[str]]:
"""
Detecta cambios de personalidad simples SIN necesitar el LLM.
Retorna lista de burbujas si se pudo resolver localmente, None si no.
"""
changes = {}
msgs = []
# Calidez
if re.search(r'(mas|m[aá]s|m[aá]ximo|sube|aumenta|100|alta?)\s*(calidez|c[aá]lid[ao]|cariñ|warm)', text_low):
val = 1.0 if "100" in text_low or "maximo" in text_low or "máximo" in text_low else 0.9
changes.setdefault("persona_config", {})["warmth_level"] = val
msgs.append(f"Calidez: {int(val*100)}%")
elif re.search(r'(menos|baja|reduce|minimal?)\s*(calidez|cariñ)', text_low):
changes.setdefault("persona_config", {})["warmth_level"] = 0.4
msgs.append("Calidez: 40%")
# Formalidad
if re.search(r'(mas|m[aá]s|muy|sube)\s*(formal|profesional)', text_low):
val = 0.9 if "muy" in text_low else 0.8
changes.setdefault("persona_config", {})["formality_level"] = val
msgs.append(f"Formalidad: {int(val*100)}%")
elif re.search(r'(menos|baja|poco|informal|relajad)', text_low):
changes.setdefault("persona_config", {})["formality_level"] = 0.25
msgs.append("Formalidad: 25%")
# Cambio de nombre del agente
m = re.search(r'(?:cambia|llama(?:la|se)?|nombre)[^\w]+(a|como)\s+([A-Z][a-z]+)', text_low, re.IGNORECASE)
if not m:
m = re.search(r'(?:se llame|se llama|nombre es|nombre a)\s+([A-Z][a-z]+)', text_low, re.IGNORECASE)
if m:
nuevo_nombre = m.group(1).strip().title()
changes.setdefault("persona_config", {})["name"] = nuevo_nombre
msgs.append(f"Nombre cambiado a {nuevo_nombre}")
elif m:
nuevo_nombre = m.group(2).strip().title()
changes.setdefault("persona_config", {})["name"] = nuevo_nombre
msgs.append(f"Nombre cambiado a {nuevo_nombre}")
if not changes:
return None # No se pudo resolver localmente
# Aplicar cambios
changes = self._apply_persona_merge(changes, clinic)
db.update_clinic(**changes)
persona_new = changes.get("persona_config", {})
agent_name = persona_new.get("name", persona.get("name", "Conny"))
summary = ". ".join(msgs)
return [
f"Listo. {summary}.",
f"{agent_name} ya tiene la nueva configuracion."
]
def _apply_persona_merge(self, changes: Dict, clinic: Dict) -> Dict:
"""Merge inteligente de persona_config con el existente."""
if "persona_config" not in changes:
return changes
existing = clinic.get("persona_config", {})
if isinstance(existing, str):
try:
existing = json.loads(existing) if existing else {}
except Exception:
existing = {}
new_persona = dict(existing)
new_persona.update(changes["persona_config"])
changes["persona_config"] = new_persona
return changes
def _changes_summary(self, changes: Dict, clinic: Dict) -> str:
"""Genera confirmacion legible de los cambios aplicados."""
parts = []
for key, value in changes.items():
if key == "persona_config":
for pkey, pval in value.items():
if pkey == "name":
parts.append(f"Nombre cambiado a {pval}")
elif pkey == "formality_level":
pct = int(float(pval) * 100)
parts.append(f"Formalidad: {pct}%")
elif pkey == "warmth_level":
pct = int(float(pval) * 100)
parts.append(f"Calidez: {pct}%")
elif pkey == "tone":
parts.append(f"Tono: {pval}")
elif pkey == "forbidden_words":
parts.append(f"Palabras prohibidas: {', '.join(pval)}")
else:
parts.append(f"{pkey}: {pval}")
elif key == "services":
parts.append(f"Servicios actualizados ({len(value)} en total)")
elif key == "phone":
parts.append(f"Telefono: {value}")
elif key == "name":
parts.append(f"Nombre clinica: {value}")
elif key == "schedule":
parts.append("Horario actualizado")
elif key == "address":
parts.append(f"Direccion: {value}")
else:
parts.append(f"{key} actualizado")
if parts:
return "Listo. " + ". ".join(parts) + "."
return "Cambios aplicados."
# ─── Buffer Management ──────────────────────────────────────────────────────
# ─── Busqueda Inteligente ────────────────────────────────────────────────────
async def _smart_search(self, text: str, analysis: "MessageAnalysis",
clinic: Dict) -> str:
"""
Construye la query de busqueda segun intencion y entidades extraidas.
Busca diferente segun lo que el paciente este preguntando.
"""
clinic_name = clinic.get("name", "")
services = clinic.get("services", [])
intent = analysis.intent
entities = analysis.entities
keywords = analysis.keywords
# ── Precio de servicio especifico ─────────────────────────────────────
if intent.name in ("PRICE_INQUIRY", "SERVICE_INFO"):
# Si menciona servicios conocidos, incluirlos en la query
mentioned_services = [
s for s in services
if any(kw in s.lower() for kw in keywords[:5])
]
service_term = mentioned_services[0] if mentioned_services else " ".join(keywords[:2])
query = f"{service_term} precio costo Medellin clinica estetica"
# ── Pregunta sobre horario o ubicacion ────────────────────────────────
elif intent.name in ("HOURS_INQUIRY", "LOCATION_INQUIRY"):
query = f"{clinic_name} {intent.name.lower().replace('_inquiry', '')} Medellin"
# ── Pregunta general con keywords claros ──────────────────────────────
elif keywords:
query = f"{' '.join(keywords[:3])} clinica estetica Colombia"
# ── Fallback: buscar el texto completo ────────────────────────────────
else:
query = f"{text[:80]} clinica estetica Medellin"
log.info(f"[search] intent={intent.name} query={query!r}")
return await self.search.search(query, context=clinic_name)
# ─── Buffer Inteligente ──────────────────────────────────────────────────────
def _calc_smart_wait(self, chat_id: str, text: str) -> float:
"""
Calcula tiempo de espera inteligente. No es random fijo.
Analiza el contexto real para decidir cuanto esperar.
Logica:
- Setup flow (respondiendo preguntas directas) (3-8s)
- Mensaje muy corto (si/no/ok/dato puntual) (3-10s)
- Respuesta corta (1 dato, una oracion) (5-15s)
- Mensaje normal (1-2 oraciones) (9-22s)
- Mensaje largo (parrafo, varias preguntas) (16-40s)
- Si Conny acaba de preguntar algo (-40%) del tiempo base
Maximo absoluto: 55s
"""
text = text.strip()
chars = len(text)
# ── Leer contexto de la BD ─────────────────────────────────────────────
try:
clinic = db.get_clinic()
is_setup = not clinic.get("setup_done")
history = db.get_history(chat_id, limit=3)
# Demo mode: siempre rápido para no perder al prospecto
if Config.DEMO_MODE:
if chars <= 12:
return round(random.uniform(2.0, 4.5), 1)
elif chars <= 60:
return round(random.uniform(3.0, 7.0), 1)
else:
return round(random.uniform(5.0, 10.0), 1)
# Setup: siempre rapido — el usuario responde preguntas directas cortas
if is_setup:
if chars < 60:
return round(random.uniform(3.0, 7.0), 1)
return round(random.uniform(5.0, 11.0), 1)
if not history and _is_greeting_only(text):
return float(Config.GREETING_ONLY_IDLE_SECONDS)
# Ver si Conny acaba de hacer una pregunta al usuario
last_bot = next(
(m for m in reversed(history) if m["role"] == "assistant"), None
)
bot_asked = False
if last_bot:
bot_content = last_bot.get("content", "").lower()
# Pregunta directa: tiene "?" o palabras tipicas de solicitud de dato
bot_asked = "?" in bot_content or any(
w in bot_content for w in [
"cual", "como", "cuando", "tienes", "nombre", "telefono",
"servicio", "fecha", "hora", "confirmas", "dime"
]
)
except Exception:
is_setup = False
bot_asked = False
history = []
# ── Rango base segun longitud del texto ───────────────────────────────
# Muy corto: "si", "no", "ok", "dale", numero, nombre
if chars <= 12:
lo, hi = 3.0, 9.0
# Corto: dato simple, respuesta directa
elif chars <= 40:
lo, hi = 5.0, 14.0
# Oracion normal
elif chars <= 100:
lo, hi = 9.0, 22.0
# Parrafo
elif chars <= 220:
lo, hi = 16.0, 35.0
# Mensaje largo con varias preguntas/contexto
else:
lo, hi = 22.0, 50.0
# Si Conny pregunto algo y el usuario responde -> ir mas rapido
if bot_asked:
lo = max(3.0, lo * 0.55)
hi = max(8.0, hi * 0.60)
# Nunca superar 55s
hi = min(hi, 55.0)
return round(random.uniform(lo, hi), 1)
async def enqueue_message(
self,
chat_id: str,
text: str,
urgent: bool = False,
message_id: str = "",
route: Optional[Dict[str, Any]] = None,
attachments: Optional[List[Dict[str, Any]]] = None,
):
"""Encola mensaje con buffer inteligente basado en contexto real."""
attachments = attachments or []
# ── Commands: process inline (no buffer needed for slash commands)
if text.strip().startswith("/"):
try:
from conny_commands import get_command_handler
instance_id = getattr(self, "_instance_id", "default")
clinic = db.get_clinic()
admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
is_admin = (chat_id in admin_ids or db.get_admin(chat_id) is not None)
cmd_handler = get_command_handler(instance_id)
result = await cmd_handler.handle(chat_id, text.strip(), is_admin=is_admin, clinic=clinic, db=db)
if result:
await self._send_bubbles(chat_id, result, message_id="", route=route)
return
except Exception as e:
log.warning(f"[command] error: {e}")
# If command not recognized, let it pass to process_message as normal text
pass
# ── MODO SIMULACIÓN ──────────────────────────────────────────────────
if self.simulator and self.simulator.is_simulating(chat_id):
bubbles = await self.simulator.handle_step(chat_id, text)
if bubbles:
await self._send_bubbles(chat_id, bubbles, message_id=message_id, route=route)
return
route = self._resolve_route(chat_id, route)
platform = _route_platform(route)
key = _buffer_key(chat_id, route)
is_wa = platform == "whatsapp" and bool(Config.WHATSAPP_BRIDGE_URL)
# ── Fire /read con delay natural — tarea completamente independiente ──────
# Separada del buffer para que nunca interfiera con el flush.
# read_delay simula el tiempo que tarda una persona en leer antes de marcar azul.
if is_wa and message_id:
chars = len(text.strip())
is_demo = Config.DEMO_MODE
if chars <= 8: rd_lo, rd_hi = 0.8, 2.0
elif chars <= 30: rd_lo, rd_hi = 1.2, 3.5
elif chars <= 80: rd_lo, rd_hi = 2.5, 6.0
elif chars <= 200: rd_lo, rd_hi = 4.0, 10.0
else: rd_lo, rd_hi = 6.0, 15.0
if is_demo:
rd_lo *= 0.35; rd_hi *= 0.35
read_delay = round(random.uniform(rd_lo, rd_hi), 1)
async def _fire_read(mid: str, delay: float):
await asyncio.sleep(delay)
try:
async with httpx.AsyncClient(timeout=4.0) as hx:
await hx.post(
f"{Config.WHATSAPP_BRIDGE_URL}/read",
json={"to": chat_id, "messageId": mid}
)
except Exception:
pass
asyncio.create_task(_fire_read(message_id, read_delay))
if urgent:
log.info(f"Urgente [{chat_id[:8]}]: bypass buffer")
if key in self._pending_buffers:
task = self._pending_buffers[key].get("task")
if task and not task.done():
task.cancel()
prev_entry = self._pending_buffers.pop(key, {})
prev = " ".join(prev_entry.get("messages", []))
attachments = prev_entry.get("attachments", []) + attachments
combined = (prev + " " + text).strip() if prev else text
else:
combined = text
bubbles = await self.process_message(chat_id, combined, attachments=attachments, route=route)
await self._send_bubbles(chat_id, bubbles, message_id="", route=route) # read ya disparado arriba
return
# Buffer normal — lógica original intacta
if key in self._pending_buffers:
task = self._pending_buffers[key].get("task")
if task and not task.done():
task.cancel()
if text:
self._pending_buffers[key]["messages"].append(text)
self._pending_buffers[key]["attachments"].extend(attachments)
else:
self._pending_buffers[key] = {
"chat_id": chat_id,
"messages": [text] if text else [],
"attachments": list(attachments),
"task": None,
"message_id": message_id,
"route": route,
}
wait_seed = text or " ".join(att.get("filename", "") for att in attachments) or "archivo"
wait = self._calc_smart_wait(chat_id, wait_seed)
async def delayed():
await asyncio.sleep(wait)
await self._flush_buffer(key)
task = asyncio.create_task(delayed())
self._pending_buffers[key]["task"] = task
n = len(self._pending_buffers[key]["messages"])
log.info(f"buffer [{platform}:{chat_id[:8]}] msg #{n}, flush en {wait:.1f}s")
async def _flush_buffer(self, key: str):
"""Vacía el buffer y procesa mensajes."""
entry = self._pending_buffers.pop(key, None)
if not entry:
return
chat_id = entry.get("chat_id", "")
route = entry.get("route") or self._resolve_route(chat_id)
combined = " ".join(entry.get("messages", []))
message_id = entry.get("message_id", "")
attachments = entry.get("attachments", [])
log.info(f"flush [{key}] {len(entry.get('messages', []))} msgs")
try:
bubbles = await self.process_message(chat_id, combined, attachments=attachments, route=route)
if bubbles:
await self._send_bubbles(chat_id, bubbles, message_id=message_id, route=route)
except Exception as e:
log.error(f"Flush error for {chat_id}: {e}", exc_info=True)
# No enviamos nada aquí, dejamos que process_message maneje el error interno
# Si llegó aquí es porque algo falló MUY feo fuera del try de process_message
await self._send_message(chat_id, "Lo siento, tuve un error técnico inesperado. ¿Podrías repetir?", route=route)
async def _send_bubbles(
self,
chat_id: str,
bubbles: List[str],
message_id: str = "",
route: Optional[Dict[str, Any]] = None,
):
"""Envía burbujas con typing proporcional y pausas naturales."""
route = self._resolve_route(chat_id, route)
platform = _route_platform(route)
is_wa = platform in ("whatsapp", "evolution")
# Demo voice: send first bubble as audio for wow factor
if Config.DEMO_MODE and is_wa and bubbles and os.getenv("ELEVENLABS_API_KEY"):
try:
from conny_demo_voice import generate_demo_audio, should_send_voice_in_demo
history_len = len(db.get_history(chat_id)) if db else 0
if should_send_voice_in_demo(bubbles[0], history_len // 2, False):
audio_path = await generate_demo_audio(bubbles[0])
if audio_path:
await self._send_audio(chat_id, audio_path, route=route)
os.unlink(audio_path)
# Still send text after audio for accessibility
await asyncio.sleep(1.0)
except Exception as e:
log.debug(f"[demo_voice] skipped: {e}")
for i, bubble in enumerate(bubbles):
if not bubble.strip():
continue
# Typing proporcional al bubble + read receipt en primera burbuja
mid = message_id if i == 0 else ""
await self._typing_action(chat_id, text=bubble, message_id=mid, route=route)
# Duración del typing que se fijó en el bridge (misma fórmula que _typing_action)
# para que pause >= typing_duration y nunca lleguemos a /send antes de que expire
chars = len(bubble)
typing_duration_s = max(1.5, min(chars * 0.05, 8.0)) # same as max(1500,min(chars*50,8000))/1000
typing_time = chars / 38 # velocidad de escritura humana ~38 chars/s
pause = max(
typing_duration_s + 0.15, # siempre > duración del timer — margen 150ms
Config.BUBBLE_PAUSE_MIN,
min(typing_time + random.uniform(0.1, 0.5), Config.BUBBLE_PAUSE_MAX + 0.8)
)
await asyncio.sleep(pause)
await self._send_message(chat_id, bubble, route=route)
if i < len(bubbles) - 1:
# Pausa inter-burbuja más humana — evita que WA trate las ráfagas como spam
inter_pause = random.uniform(1.4, 2.8) if is_wa else random.uniform(0.8, 1.8)
await asyncio.sleep(inter_pause)
# No forzamos offline después de responder.
# El bridge mantiene presencia humana y expira solo tras el timeout configurado.
async def _typing_action(
self,
chat_id: str,
text: str = "",
message_id: str = "",
route: Optional[Dict[str, Any]] = None,
):
"""
Indica 'escribiendo...' proporcional al texto que va a enviar.
En WhatsApp Bridge también marca como leído si hay message_id.
"""
try:
route = self._resolve_route(chat_id, route)
platform = _route_platform(route)
# Duración proporcional: ~50ms por char, entre 1.5s y 8s
chars = len(text) if text else 60
duration = max(1500, min(int(chars * 50), 8000))
if platform == "telegram":
async with httpx.AsyncClient(timeout=5.0) as client:
await client.post(
f"https://api.telegram.org/bot{Config.TELEGRAM_TOKEN}/sendChatAction",
json={"chat_id": chat_id, "action": "typing"}
)
elif platform == "whatsapp_cloud":
pass # no soportado en API v17+
elif platform == "evolution":
if Config.EVOLUTION_URL and Config.EVOLUTION_API_KEY:
async with httpx.AsyncClient(timeout=5.0) as client:
await client.post(
f"{Config.EVOLUTION_URL}/chat/sendPresence/{Config.EVOLUTION_INSTANCE}",
headers={"apikey": Config.EVOLUTION_API_KEY},
json={"number": chat_id, "presence": "composing", "delay": duration}
)
elif platform == "whatsapp":
if Config.WHATSAPP_BRIDGE_URL:
async with httpx.AsyncClient(timeout=8.0) as client:
# Aparecer online PRIMERO — sin esto WhatsApp no muestra "escribiendo"
# y el mensaje llega con un solo chulo gris
try:
await client.post(
f"{Config.WHATSAPP_BRIDGE_URL}/presence",
json={"status": "available", "timeout": 1800000},
timeout=3.0
)
except Exception:
pass
# Typing proporcional al mensaje
await client.post(
f"{Config.WHATSAPP_BRIDGE_URL}/typing",
json={"to": chat_id, "duration": duration}
)
except Exception:
pass
def sanitize_outgoing(self, text: Optional[str]) -> Optional[str]:
"""
Sanitiza TODO mensaje saliente antes de enviarlo.
Previene JSON bleed, debug messages y respuestas vacías.
"""
if not text:
return None
t = text.strip()
if not t:
return None
if t.startswith('{') or t.startswith('['):
log.error(f"[sanitize] JSON bleed blocked: {t[:80]}")
return None
if '|||' in t:
t = t.split('|||')[0].strip()
internal_phrases = [
"todavía no tengo este chat enlazado",
"ya recibí tu mensaje",
"no tengo este chat",
"[error",
"[internal",
"{",
]
if any(phrase in t.lower() for phrase in internal_phrases):
log.error(f"[sanitize] internal debug message blocked: {t[:80]}")
return None
return t if t else None
async def _send_audio(self, chat_id: str, audio_path: str, route: Optional[Dict[str, Any]] = None):
"""Send audio file as voice note via WhatsApp bridge."""
route = self._resolve_route(chat_id, route)
try:
import base64
with open(audio_path, "rb") as f:
audio_b64 = base64.b64encode(f.read()).decode()
async with httpx.AsyncClient(timeout=15.0) as client:
r = await client.post(
f"{Config.WHATSAPP_BRIDGE_URL}/send-audio",
json={"to": chat_id, "audio": audio_b64, "ptt": True},
)
if r.status_code in (200, 201, 202):
log.info(f"[voice] audio sent to {chat_id[:10]}...")
else:
log.warning(f"[voice] send failed: {r.status_code}")
except Exception as e:
log.debug(f"[voice] send_audio error: {e}")
async def _send_message(self, chat_id: str, text: str, route: Optional[Dict[str, Any]] = None):
"""
Envia mensaje al paciente/admin segun la plataforma configurada.
Plataformas soportadas: telegram | whatsapp_cloud | evolution | whatsapp
"""
text = self.sanitize_outgoing(text)
if not text:
return
if chat_id in self._emoji_chats_off:
text = self._strip_emojis(text)
text = text.replace('\u00bf', '').replace('\u00a1', '').strip() # ¿ ¡
if not text:
return
route = self._resolve_route(chat_id, route)
platform = _route_platform(route)
try:
if platform == "telegram":
async with httpx.AsyncClient(timeout=15.0) as client:
await client.post(
f"https://api.telegram.org/bot{Config.TELEGRAM_TOKEN}/sendMessage",
json={"chat_id": chat_id, "text": text, "parse_mode": "Markdown"}
)
elif platform == "whatsapp_cloud":
# Meta WhatsApp Cloud API — gratuita hasta 1000 conversaciones/mes
if not Config.WA_ACCESS_TOKEN or not Config.WA_PHONE_ID:
log.error("[wa_cloud] WA_ACCESS_TOKEN o WA_PHONE_ID no configurados")
return
async with httpx.AsyncClient(timeout=15.0) as client:
r = await client.post(
f"https://graph.facebook.com/v19.0/{Config.WA_PHONE_ID}/messages",
headers={
"Authorization": f"Bearer {Config.WA_ACCESS_TOKEN}",
"Content-Type": "application/json",
},
json={
"messaging_product": "whatsapp",
"recipient_type": "individual",
"to": chat_id, # numero internacional sin +: 573001234567
"type": "text",
"text": {"body": text, "preview_url": False}
}
)
if r.status_code >= 400:
log.error(f"[wa_cloud] send error {r.status_code}: {r.text[:200]}")
elif platform == "evolution":
# Evolution API — auto-hospedada, conecta WhatsApp Web
if not Config.EVOLUTION_URL or not Config.EVOLUTION_API_KEY:
log.error("[evolution] EVOLUTION_URL o EVOLUTION_API_KEY no configurados")
return
# Delay proporcional al texto — simula tipeo humano y evita que
# WhatsApp solo entregue 1 chulo (el delay 0 activa el rate-limit)
_chars = len(text)
_human_delay = min(max(int(_chars * 40), 800), 4000) # 40ms/char, 800ms–4s
async with httpx.AsyncClient(timeout=15.0) as client:
r = await client.post(
f"{Config.EVOLUTION_URL}/message/sendText/{Config.EVOLUTION_INSTANCE}",
headers={
"apikey": Config.EVOLUTION_API_KEY,
"Content-Type": "application/json",
},
json={
"number": chat_id, # 573001234567 o 573001234567@s.whatsapp.net
"text": text,
"delay": _human_delay
}
)
elif platform == "whatsapp":
# Custom WhatsApp Bridge (Baileys)
if not Config.WHATSAPP_BRIDGE_URL:
log.error("[wa_bridge] WHATSAPP_BRIDGE_URL no configurado")
return
# Retry 1 vez: si el bridge está ocupado o hay un hipo de red
_last_err = None
for _attempt in range(2):
try:
async with httpx.AsyncClient(timeout=20.0) as client:
r = await client.post(
f"{Config.WHATSAPP_BRIDGE_URL}/send",
json={"to": chat_id, "message": text}
)
if r.status_code < 400:
log.info(f"[wa_bridge] enviado OK ({r.status_code}) intento={_attempt+1}")
break
else:
_last_err = f"HTTP {r.status_code}: {r.text[:200]}"
log.error(f"[wa_bridge] send error intento={_attempt+1} — {_last_err}")
if _attempt == 0:
await asyncio.sleep(2.0) # esperar antes del retry
except Exception as _e:
_last_err = str(_e)
log.error(f"[wa_bridge] send exception intento={_attempt+1}: {_last_err}")
if _attempt == 0:
await asyncio.sleep(2.0)
else:
log.error(f"[wa_bridge] FALLÓ después de 2 intentos: {_last_err}")
else:
log.error(f"Plataforma desconocida: {platform!r}")
except Exception as e:
log.error(f"[{platform}] send_message error: {e}")
def _strip_emojis(self, text: str) -> str:
"""Elimina todos los emojis."""
emoji_pattern = re.compile(
"["
"\U0001F600-\U0001F64F"
"\U0001F300-\U0001F5FF"
"\U0001F680-\U0001F6FF"
"\U0001F1E0-\U0001F1FF"
"\U00002500-\U00002BEF"
"\U00002702-\U000027B0"
"\U000024C2-\U0001F251"
"\U0001F900-\U0001F9FF"
"\U0001FA00-\U0001FA6F"
"\U0001FA70-\U0001FAFF"
"\u2600-\u26FF"
"\u2700-\u27BF"
"]+",
flags=re.UNICODE
)
return emoji_pattern.sub("", text).strip()
async def transcribe_audio(self, file_id: str, platform: str = "telegram",
wa_media_id: str = None) -> str:
"""Delega transcripción a AudioHandler si está disponible."""
if _AUDIO_HANDLER_AVAILABLE and hasattr(self, "_audio_handler"):
return await self._audio_handler.transcribe_audio(file_id, platform, wa_media_id)
return "[no pude escuchar, puedes escribirlo?]"
def is_urgent(self, text: str) -> bool:
"""Detecta si el mensaje es urgente."""
analysis = self.analyzer.analyze(text)
return analysis.urgency in [UrgencyLevel.CRITICAL, UrgencyLevel.HIGH]
def _analysis_to_dict(self, analysis: MessageAnalysis) -> Dict:
"""Convierte MessageAnalysis a dict JSON-serializable (enums -> strings)."""
try:
return {
"intent": analysis.intent.name,
"intent_confidence": analysis.intent_confidence,
"secondary_intents": [(i.name, s) for i, s in (analysis.secondary_intents or [])],
"sentiment": analysis.sentiment.name,
"sentiment_score": analysis.sentiment_score,
"urgency": analysis.urgency.name,
"emotional_state": analysis.emotional_state,
"is_question": analysis.is_question,
"requires_action": analysis.requires_action,
"requires_search": analysis.requires_search,
"entities": analysis.entities,
"keywords": analysis.keywords,
"language": analysis.language,
"closing_score": getattr(analysis, "closing_score", 0.0),
"lead_temperature": getattr(analysis, "lead_temperature", "cold"),
}
except Exception:
return {}
# ═══════════════════════════════════════════════════════════════════════════════
# INSTANCIA GLOBAL DE CONNY
# ═══════════════════════════════════════════════════════════════════════════════
conny: ConnyUltra = None
ADMIN_PENDING_CONFIRMATIONS: Dict[str, Dict] = {}
async def init_conny():
"""Inicializa Conny Ultra."""
global conny
conny = ConnyUltra()
await conny.initialize()
# ═══════════════════════════════════════════════════════════════════════════════
# FASTAPI APPLICATION
# ═══════════════════════════════════════════════════════════════════════════════
# PATCH P1 2024-04 — brain_v10: LLM primero, plantillas como último recurso
def _init_brain_v10():
"""
Integra conny_brain_v10 al startup.
El módulo estaba escrito y documentado pero nunca inicializado.
init_brain() carga señales de memoria corta.
patch_llm_first(generator) hace que el LLM tenga autoridad sobre plantillas.
"""
try:
from conny_brain_v10 import init_brain, patch_llm_first
init_brain()
patch_llm_first(conny.generator)
log.info("[brain_v10] LLM-first activo — plantillas solo como último recurso")
except ImportError:
log.warning("[brain_v10] módulo no encontrado — continúa sin él")
except Exception as e:
log.warning(f"[brain_v10] no se pudo inicializar: {e}")
@asynccontextmanager
async def lifespan(app: FastAPI):
"""Lifecycle de la aplicación."""
# Startup
errors = Config.validate()
if errors:
for e in errors:
log.error(f"Config error: {e}")
await init_conny()
try:
bootstrap_clinic_identity_from_instance_metadata()
except Exception as exc:
log.warning(f"[startup] instance_bootstrap error: {exc}")
try:
ensure_minimum_business_state()
except Exception as exc:
log.warning(f"[startup] business_bootstrap error: {exc}")
# V8.0 + Observatory + Trainer — init en orden correcto, bulletproof
for _fn, _lbl in [
(lambda: init_v8_systems() if not anti_robot_filter else None, "v8_core"),
(lambda: init_v8_extended_systems() if not conversation_simulator else None, "v8_extended"),
(lambda: init_observatory(), "observatory"),
(lambda: init_trainer_systems(), "trainer"),
(lambda: _patch_admin_dispatcher(), "dispatcher_v8"),
(lambda: _patch_admin_dispatcher_trainer(), "dispatcher_trainer"),
# PATCH P1 — brain_v10: LLM primero, documentado pero nunca llamado
(lambda: _init_brain_v10(), "brain_v10"),
]:
try:
result = _fn()
if result is not None or True:
log.info(f"[startup] {_lbl} OK")
except Exception as _e:
log.warning(f"[startup] {_lbl} error: {_e}")
telegram_mode = _telegram_webhook_mode()
if telegram_mode == "shared":
await set_shared_telegram_webhook()
elif telegram_mode == "direct":
if Config.TELEGRAM_SHARED and Config.PLATFORM != "telegram":
log.info("[telegram] shared activado sin router — usando webhook directo en esta instancia")
if Config.PLATFORM == "telegram" and Config.TELEGRAM_SHARED:
log.info("Telegram shared mode activo sin router — usando webhook directo para no dejar el bot mudo")
await set_webhook()
if Config.PLATFORM == "telegram" and Config.BASE_URL and Config.TELEGRAM_TOKEN:
if Config.TELEGRAM_SHARED and Config.TELEGRAM_SHARED_ROUTER:
log.info("Telegram shared mode activo — esta instancia no registra webhook propio")
else:
log.info("[telegram] webhook directo activo")
elif Config.PLATFORM == "whatsapp_cloud":
log.info("WhatsApp Cloud API mode — registra el webhook manualmente en Meta Business Manager")
log.info(f"URL del webhook: {Config.BASE_URL}/webhook/{Config.WEBHOOK_SECRET}")
elif Config.PLATFORM == "evolution":
log.info("Evolution API mode — configura el webhook en tu panel de Evolution")
log.info(f"URL del webhook: {Config.BASE_URL}/webhook/{Config.WEBHOOK_SECRET}")
# ── Memory Engine + Cron Scheduler + Uncertainty ────────────────────────────
try:
from conny_memory_engine import memory_engine as _mem_engine
from conny_cron import init_scheduler as _init_cron
from conny_uncertainty import uncertainty_detector as _unc_detector
instance_id = Config.INSTANCE_ID if hasattr(Config, "INSTANCE_ID") else "default"
_init_cron(memory_engine=_mem_engine, instance_ids=[instance_id])
log.info(f"[startup] memory_engine + cron + uncertainty OK (instance={instance_id})")
except Exception as _mem_err:
log.warning(f"[startup] memory/cron init error: {_mem_err}")
log.info("═══════════════════════════════════════════════════════")
log.info(" CONNY V9.6.0 - ONLINE Y OPERATIVA ")
log.info("═══════════════════════════════════════════════════════")
# Notificar a Omni que esta instancia está online
asyncio.create_task(asyncio.to_thread(
notify_omni, "instance_online",
f"Conny v8.0 online — sector: {Config.SECTOR or 'otro'}"
))
yield
# Shutdown
if task_manager:
await task_manager.stop()
try:
from conny_cron import shutdown_scheduler
shutdown_scheduler()
except Exception:
pass
notify_omni("instance_offline", f"Conny apagada — sector: {Config.SECTOR or 'otro'}")
log.info("Conny Ultra apagada")
app = FastAPI(
title="Conny v9.6.0",
description="Conny V9.0 — Agente de Recepción Hipernaturalmente Humana",
version="9.6.0",
lifespan=lifespan
)
# CORS
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# ─── Admin API Router ────────────────────────────────────────────────────────────
try:
from conny_admin_api import router as admin_api_router
app.include_router(admin_api_router)
log.info("[admin_api] router montado en /admin")
except Exception as _admin_api_err:
log.warning(f"[admin_api] no disponible: {_admin_api_err}")
# ─── Webhook Setup ──────────────────────────────────────────────────────────────
async def set_webhook():
"""Configura el webhook de Telegram."""
url = f"{Config.BASE_URL}/webhook/{Config.WEBHOOK_SECRET}"
async with httpx.AsyncClient() as client:
r = await client.post(
f"https://api.telegram.org/bot{Config.TELEGRAM_TOKEN}/setWebhook",
json={
"url": url,
"allowed_updates": ["message"],
"drop_pending_updates": False
}
)
data = r.json()
status = "OK" if data.get("ok") else "ERROR"
log.info(f"Webhook {status}: {url}")
async def set_shared_telegram_webhook():
"""Configura el webhook compartido de Telegram en la instancia base."""
url = f"{Config.BASE_URL}/telegram/shared/{Config.TELEGRAM_SHARED_SECRET}"
async with httpx.AsyncClient() as client:
r = await client.post(
f"https://api.telegram.org/bot{Config.TELEGRAM_TOKEN}/setWebhook",
json={
"url": url,
"allowed_updates": ["message"],
"drop_pending_updates": False,
},
)
data = r.json()
status = "OK" if data.get("ok") else "ERROR"
log.info(f"[telegram_shared] Webhook {status}: {url}")
def _telegram_webhook_mode() -> str:
if not Config.BASE_URL or not Config.TELEGRAM_TOKEN:
return "disabled"
if Config.TELEGRAM_SHARED_ROUTER:
return "shared"
return "direct"
async def _forward_shared_telegram_update(target: Dict[str, Any], body: Dict[str, Any]) -> Dict[str, Any]:
url = f"http://127.0.0.1:{target['port']}/webhook/{target['secret']}"
async with httpx.AsyncClient(timeout=10.0) as client:
r = await client.post(url, json=body)
return {"status": r.status_code, "body": r.text[:200]}
async def _send_shared_unpaired_notice(chat_id: str):
text = (
"ya recibí tu mensaje ||| todavía no tengo este chat enlazado a una clínica "
"en la ruta compartida, pero ya quedó pendiente"
)
try:
async with httpx.AsyncClient(timeout=10.0) as client:
await client.post(
f"https://api.telegram.org/bot{Config.TELEGRAM_TOKEN}/sendMessage",
json={"chat_id": chat_id, "text": text},
)
except Exception as e:
log.warning(f"[telegram_shared] no pude avisar al chat no enlazado: {e}")
# ─── Webhook Endpoint ───────────────────────────────────────────────────────────
@app.post("/webhook/{secret}")
async def webhook(secret: str, request: Request):
"""
Webhook unificado.
Acepta mensajes de Telegram, WhatsApp Cloud API, Evolution API o WhatsApp Bridge (custom).
segun Config.PLATFORM.
"""
if secret != Config.WEBHOOK_SECRET:
return Response(status_code=403)
try:
body = await request.json()
except Exception:
return Response(status_code=400)
platform = _detect_incoming_platform(body)
chat_id = None
text = None
audio_id = None
message_id = None # para /read en WhatsApp Bridge
attachments: List[Dict[str, Any]] = []
# ── Parser Telegram ───────────────────────────────────────────────────────
if platform == "telegram":
msg = body.get("message") or body.get("edited_message")
if not msg:
return {"ok": True}
chat_id = str(msg["chat"]["id"])
voice = msg.get("voice") or msg.get("audio")
if voice:
audio_id = voice["file_id"]
else:
text = msg.get("text", "").strip()
document = msg.get("document")
if document:
attachments.append({
"kind": "document",
"platform": "telegram",
"file_id": document.get("file_id", ""),
"filename": document.get("file_name", "document.bin"),
"mime_type": document.get("mime_type", "application/octet-stream"),
"caption": msg.get("caption", ""),
})
text = text or (msg.get("caption") or "").strip()
photos = msg.get("photo") or []
if photos:
photo = photos[-1]
attachments.append({
"kind": "image",
"platform": "telegram",
"file_id": photo.get("file_id", ""),
"filename": f"telegram_photo_{photo.get('file_unique_id', 'image')}.jpg",
"mime_type": "image/jpeg",
"caption": msg.get("caption", ""),
})
text = text or (msg.get("caption") or "").strip()
# ── Parser WhatsApp Cloud API ─────────────────────────────────────────────
elif platform == "whatsapp_cloud":
# Verificacion del webhook (GET request de Meta al registrar)
# Nota: la verificacion GET se maneja en wa_verify endpoint abajo
try:
entry = body.get("entry", [{}])[0]
changes = entry.get("changes", [{}])[0]
value = changes.get("value", {})
msgs = value.get("messages", [])
if not msgs:
return {"ok": True}
msg = msgs[0]
chat_id = msg.get("from", "") # numero en formato 573001234567
msg_type = msg.get("type", "text")
if msg_type == "text":
text = msg.get("text", {}).get("body", "").strip()
elif msg_type in ("audio", "voice"):
audio_id = msg.get("audio", msg.get("voice", {})).get("id", "")
elif msg_type == "image":
attachments.append({
"kind": "image",
"platform": "whatsapp_cloud",
"media_id": msg.get("image", {}).get("id", ""),
"filename": f"wa_cloud_image_{msg.get('id', 'image')}.jpg",
"mime_type": msg.get("image", {}).get("mime_type", "image/jpeg"),
"caption": msg.get("image", {}).get("caption", ""),
})
text = msg.get("image", {}).get("caption", "").strip()
elif msg_type == "document":
attachments.append({
"kind": "document",
"platform": "whatsapp_cloud",
"media_id": msg.get("document", {}).get("id", ""),
"filename": msg.get("document", {}).get("filename", f"wa_cloud_{msg.get('id', 'document')}"),
"mime_type": msg.get("document", {}).get("mime_type", "application/octet-stream"),
"caption": msg.get("document", {}).get("caption", ""),
})
text = msg.get("document", {}).get("caption", "").strip()
except (IndexError, KeyError, TypeError):
return {"ok": True}
# ── Parser Evolution API ──────────────────────────────────────────────────
elif platform == "evolution":
try:
event = body.get("event", "")
# Solo procesar eventos de mensajes recibidos
if event and event not in ("messages.upsert", "messages.update", "MESSAGES_UPSERT", "MESSAGES_UPDATE"):
return {"ok": True}
data = body.get("data", {})
key = data.get("key", {})
# CRÍTICO: ignorar mensajes enviados por el propio bot (evita bucle infinito)
if key.get("fromMe", False):
return {"ok": True}
remote_jid = key.get("remoteJid", "")
# Ignorar grupos
if "@g.us" in remote_jid:
return {"ok": True}
chat_id = remote_jid.split("@")[0]
msg = data.get("message", {})
if not msg:
# Algunos eventos de Evolution traen el mensaje en body directo
msg = body.get("message", {})
if "conversation" in msg:
text = msg["conversation"].strip()
elif "extendedTextMessage" in msg:
text = msg["extendedTextMessage"].get("text", "").strip()
elif "audioMessage" in msg:
audio_id = key.get("id", "")
elif "imageMessage" in msg:
text = msg["imageMessage"].get("caption", "").strip()
except (KeyError, AttributeError):
return {"ok": True}
# ── Parser WhatsApp Bridge (Custom Baileys) ──────────────────────────────
elif platform == "whatsapp":
try:
if body.get("event") == "message.received":
# Ignorar grupos
if body.get("isGroup"):
return {"ok": True}
# Ignorar mensajes enviados por el propio bot
if body.get("fromMe", False):
return {"ok": True}
# JID crudo necesario para responder y /read correctamente.
# Algunos chats llegan con identificadores que no deben normalizarse.
chat_id = body.get("remoteJid") or body.get("from", "")
message_id = body.get("messageId", "")
text = (body.get("text") or "").strip()
# Audio con base64 inline
if body.get("isAudio") and body.get("audioBase64"):
b64_mime = body.get("audioMime", "audio/ogg")
audio_id = f"wa_b64:{b64_mime}:{body['audioBase64']}"
if body.get("isImage") and body.get("imageBase64"):
attachments.append({
"kind": "image",
"platform": "whatsapp",
"filename": f"wa_bridge_{body.get('messageId', 'image')}.jpg",
"mime_type": body.get("imageMime", "image/jpeg"),
"caption": text or "",
"base64": body.get("imageBase64", ""),
})
if body.get("isDocument") and body.get("docBase64"):
attachments.append({
"kind": "document",
"platform": "whatsapp",
"filename": body.get("documentName", "document.bin"),
"mime_type": body.get("documentMime", "application/octet-stream"),
"caption": text or "",
"base64": body.get("docBase64", ""),
})
except Exception:
return {"ok": True}
# ── Procesamiento comun ───────────────────────────────────────────────────
if not chat_id:
return {"ok": True}
# Aparecer online inmediatamente al recibir — soluciona chulo gris
if platform == "whatsapp" and Config.WHATSAPP_BRIDGE_URL:
async def _appear_online():
try:
async with httpx.AsyncClient(timeout=3.0) as _hx:
await _hx.post(
f"{Config.WHATSAPP_BRIDGE_URL}/presence",
json={"status": "available", "timeout": 1800000}
)
except Exception:
pass
asyncio.create_task(_appear_online())
if audio_id:
await conny._typing_action(chat_id)
wa_mid = audio_id if platform == "whatsapp_cloud" else None
text = await conny.transcribe_audio(
file_id=audio_id, platform=platform, wa_media_id=wa_mid)
if not text or "[no pude" in text or "[no se pudo" in text:
await conny._send_message(chat_id, "Recibí tu audio pero no lo pude procesar. ¿Puedes escribirlo?")
return {"ok": True}
# Block 3: First audio message — inject transcription with marker
# Check if this is the first message (no assistant messages in history)
try:
from conny import db as _conny_db
if _conny_db:
_hist = _conny_db.get_history(chat_id, limit=3)
_has_prev = any(m.get("role") == "assistant" for m in _hist)
if not _has_prev:
text = f"[Transcripción de audio]: {text}"
except Exception:
pass
log.info(f"[audio] {chat_id[:8]}: {text[:60]}")
if not text and not attachments:
return {"ok": True}
urgent = conny.is_urgent(text or "")
route = {"platform": platform}
asyncio.create_task(
conny.enqueue_message(
chat_id,
text or "",
urgent=urgent,
message_id=message_id or "",
route=route,
attachments=attachments,
)
)
return {"ok": True}
@app.post("/telegram/shared/{secret}")
async def telegram_shared_webhook(secret: str, request: Request):
"""
Router compartido de Telegram.
Inspirado en el patrón de OpenClaw: un solo ingress y luego enrutamiento
por sesión/chat hacia un agente o instancia concreta.
"""
if not Config.TELEGRAM_SHARED_ROUTER or secret != Config.TELEGRAM_SHARED_SECRET:
return Response(status_code=403)
try:
body = await request.json()
except Exception:
return Response(status_code=400)
msg = body.get("message") or body.get("edited_message")
if not msg:
return {"ok": True}
chat = msg.get("chat") or {}
chat_id = str(chat.get("id", "")).strip()
if not chat_id:
return {"ok": True}
target = _resolve_shared_telegram_target(chat_id)
if not target:
await _send_shared_unpaired_notice(chat_id)
return {"ok": True, "routed": False}
try:
forwarded = await _forward_shared_telegram_update(target, body)
return {
"ok": True,
"routed": forwarded.get("status", 500) < 400,
"instance": target["name"],
"forwarded_status": forwarded.get("status", 500),
}
except Exception as e:
log.error(f"[telegram_shared] error reenviando a {target['name']}: {e}")
return {"ok": True, "routed": False, "error": str(e)[:120]}
@app.get("/webhook/{secret}")
async def wa_verify(secret: str, request: Request):
"""
Endpoint de verificacion de WhatsApp Cloud API.
Meta hace un GET con hub.challenge al registrar el webhook.
"""
if secret != Config.WEBHOOK_SECRET:
return Response(status_code=403)
params = dict(request.query_params)
mode = params.get("hub.mode", "")
token = params.get("hub.verify_token", "")
challenge = params.get("hub.challenge", "")
if mode == "subscribe" and token == Config.WA_VERIFY_TOKEN:
return Response(content=challenge, media_type="text/plain")
return Response(status_code=403)
# ─── API Endpoints ──────────────────────────────────────────────────────────────
@app.get("/telegram/status")
async def telegram_status():
status = {
"enabled": bool(Config.TELEGRAM_TOKEN),
"platform": Config.PLATFORM,
"shared": Config.TELEGRAM_SHARED,
"shared_router": Config.TELEGRAM_SHARED_ROUTER,
"mode": _telegram_webhook_mode(),
"base_url": Config.BASE_URL,
"webhook_secret": Config.WEBHOOK_SECRET,
}
if not Config.TELEGRAM_TOKEN:
status["ok"] = False
status["reason"] = "missing_token"
return status
try:
async with httpx.AsyncClient(timeout=10.0) as client:
me_resp = await client.get(f"https://api.telegram.org/bot{Config.TELEGRAM_TOKEN}/getMe")
webhook_resp = await client.get(f"https://api.telegram.org/bot{Config.TELEGRAM_TOKEN}/getWebhookInfo")
me = me_resp.json().get("result", {}) if me_resp.status_code < 500 else {}
webhook = webhook_resp.json().get("result", {}) if webhook_resp.status_code < 500 else {}
status.update(
{
"ok": True,
"bot_username": me.get("username", ""),
"bot_name": me.get("first_name", ""),
"webhook_url": webhook.get("url", ""),
"pending_update_count": webhook.get("pending_update_count", 0),
"last_error_message": webhook.get("last_error_message", ""),
"last_error_date": webhook.get("last_error_date"),
}
)
except Exception as exc:
status["ok"] = False
status["reason"] = str(exc)[:160]
return status
@app.get("/health")
async def health():
"""Health check."""
clinic = db.get_clinic() if db else {}
shared_instances = _discover_shared_telegram_instances() if Config.TELEGRAM_SHARED_ROUTER else []
shared_routes = _load_shared_telegram_routes() if Config.TELEGRAM_SHARED_ROUTER else {}
default_instance = (
shared_routes.get("default_instance", "")
or Config.TELEGRAM_DEFAULT_INSTANCE
or (shared_instances[0]["name"] if len(shared_instances) == 1 else "")
) if Config.TELEGRAM_SHARED_ROUTER else ""
# WhatsApp status
wa_connected = False
wa_phone = ""
bridge_status = {}
try:
wa_connected = db.recall("whatsapp_connected") == "true"
wa_phone = db.recall("whatsapp_phone") or ""
except Exception:
pass
if Config.WHATSAPP_BRIDGE_URL:
try:
async with httpx.AsyncClient(timeout=4.0) as client:
r = await client.get(f"{Config.WHATSAPP_BRIDGE_URL}/status")
if r.status_code < 400:
bridge_status = r.json()
if (
bridge_status.get("connected")
or bridge_status.get("phoneNumber")
or bridge_status.get("status") == "open"
or bridge_status.get("jid")
):
wa_connected = True
wa_phone = wa_phone or bridge_status.get("phoneNumber", "")
except Exception:
bridge_status = {}
# Core memory count
mem_count = 0
try:
mem_count = len(db.recall_all())
except Exception:
pass
return {
"status": "online",
"version": "9.6.0",
"clinic": clinic.get("name", "sin configurar"),
"sector": Config.SECTOR or clinic.get("sector", "otro"),
"setup_done": bool(clinic.get("setup_done")),
"platform": Config.PLATFORM,
"whatsapp": {
"connected": wa_connected,
"phone": wa_phone,
"bridge": bridge_status,
},
"models": Config.LLM_MODELS,
"buffer_window": f"{Config.BUFFER_WAIT_MIN}-{Config.BUFFER_WAIT_MAX}s",
"active_buffers": len(conny._pending_buffers) if conny else 0,
"plugins_active": len(mcp_manager.plugins) if mcp_manager else 0,
"memory_items": mem_count,
"omni_url": os.getenv("OMNI_URL", ""),
"telegram_shared_router": {
"enabled": Config.TELEGRAM_SHARED_ROUTER,
"instances": len(shared_instances),
"default_instance": default_instance,
},
"timestamp": datetime.now().isoformat()
}
@app.get("/dashboard")
async def dashboard():
"""Dashboard completo."""
clinic = db.get_clinic()
with db._conn() as c:
total_appointments = c.execute("SELECT COUNT(*) FROM appointments").fetchone()[0]
pending_appointments = c.execute(
"SELECT COUNT(*) FROM appointments WHERE status='pendiente'"
).fetchone()[0]
total_patients = c.execute("SELECT COUNT(*) FROM patients").fetchone()[0]
new_today = c.execute(
"SELECT COUNT(*) FROM patients WHERE date(first_seen)=date('now')"
).fetchone()[0]
total_conversations = c.execute("SELECT COUNT(*) FROM conversations").fetchone()[0]
# Métricas de rendimiento
metrics = db.get_metrics(since=datetime.now() - timedelta(hours=24))
avg_latency = sum(
m["metric_value"] for m in metrics
if m.get("metric_name") == "response_time"
) / max(len([m for m in metrics if m.get("metric_name") == "response_time"]), 1)
return {
"clinic": {
"name": clinic.get("name"),
"setup_done": bool(clinic.get("setup_done")),
"services": clinic.get("services", []),
"phone": clinic.get("phone"),
},
"stats": {
"total_patients": total_patients,
"new_patients_today": new_today,
"total_appointments": total_appointments,
"pending_appointments": pending_appointments,
"total_conversations": total_conversations,
},
"performance": {
"avg_response_time_ms": round(avg_latency, 2),
"active_buffers": len(conny._pending_buffers) if conny else 0,
},
"system": {
"model_primary": Config.LLM_MODELS["fast"],
"model_reasoning": Config.LLM_MODELS["reasoning"],
"plugins_count": len(mcp_manager.plugins) if mcp_manager else 0,
},
"timestamp": datetime.now().isoformat()
}
@app.get("/appointments")
async def list_appointments(
status: Optional[str] = None,
limit: int = 50
):
"""Lista citas."""
appointments = db.get_appointments(status=status, limit=limit)
return {"appointments": appointments, "count": len(appointments)}
@app.get("/appointments/{apt_id}")
async def get_appointment(apt_id: int):
"""Obtiene una cita específica."""
with db._conn() as c:
row = c.execute("SELECT * FROM appointments WHERE id=?", (apt_id,)).fetchone()
if not row:
raise HTTPException(status_code=404, detail="Cita no encontrada")
return dict(row)
@app.patch("/appointments/{apt_id}")
async def update_appointment(apt_id: int, request: Request):
"""Actualiza una cita."""
data = await request.json()
db.update_appointment(apt_id, **data)
return {"ok": True}
@app.get("/patients")
async def list_patients(limit: int = 50):
"""Lista pacientes."""
with db._conn() as c:
rows = c.execute("""
SELECT chat_id, name, phone, visits, first_seen, last_seen
FROM patients
ORDER BY last_seen DESC
LIMIT ?
""", (limit,)).fetchall()
return {"patients": [dict(r) for r in rows]}
@app.get("/patients/{chat_id}")
async def get_patient(chat_id: str):
"""Obtiene un paciente."""
with db._conn() as c:
row = c.execute("SELECT * FROM patients WHERE chat_id=?", (chat_id,)).fetchone()
if not row:
raise HTTPException(status_code=404, detail="Paciente no encontrado")
data = dict(row)
for field in ['preferences', 'tags', 'services_used']:
try:
data[field] = json.loads(data.get(field, '{}') or '{}')
except Exception:
data[field] = {}
return data
@app.get("/conversations/{chat_id}")
async def get_conversations(chat_id: str, limit: int = 50):
"""Obtiene historial de conversación."""
history = db.get_history(chat_id, limit=limit)
return {"chat_id": chat_id, "messages": history, "count": len(history)}
@app.get("/metrics")
async def get_metrics(
metric_type: Optional[str] = None,
hours: int = 24
):
"""Obtiene métricas."""
since = datetime.now() - timedelta(hours=hours)
metrics = db.get_metrics(metric_type=metric_type, since=since)
return {"metrics": metrics, "period_hours": hours}
@app.get("/plugins")
async def list_plugins():
"""Lista plugins."""
plugins = db.get_plugins()
health = await mcp_manager.health_check_all() if mcp_manager else {}
return {
"plugins": [
{
"id": p.id,
"name": p.name,
"version": p.version,
"enabled": p.enabled,
"capabilities": p.capabilities,
"health": health.get(p.id, False)
}
for p in plugins
]
}
@app.post("/plugins/{plugin_id}/execute")
async def execute_plugin(plugin_id: str, request: Request):
"""Ejecuta acción en plugin."""
data = await request.json()
action = data.get("action")
params = data.get("params", {})
if not action:
raise HTTPException(status_code=400, detail="action requerido")
result = await mcp_manager.execute(plugin_id, action, params)
return result
@app.get("/config")
async def get_config():
"""Obtiene configuración de la clínica."""
clinic = db.get_clinic()
# Ocultar datos sensibles
safe_clinic = {
k: v for k, v in clinic.items()
if k not in ['admin_chat_ids']
}
return safe_clinic
@app.patch("/config")
async def update_config(request: Request):
"""Actualiza configuración."""
data = await request.json()
# Validar campos permitidos
allowed = {
'name', 'tagline', 'address', 'phone', 'email', 'website',
'services', 'schedule', 'holidays', 'timezone', 'currency',
'persona_config', 'business_rules', 'pricing', 'promotions',
'notification_settings'
}
filtered = {k: v for k, v in data.items() if k in allowed}
if filtered:
db.update_clinic(**filtered)
return {"ok": True, "updated": list(filtered.keys())}
@app.get("/personality")
async def get_personality():
"""Obtiene configuración de personalidad."""
clinic = db.get_clinic()
persona = clinic.get("persona_config", {})
if isinstance(persona, str):
persona = json.loads(persona) if persona else {}
# Merge con defaults
default = PersonalityProfile()
full_persona = {
"name": persona.get("name", default.name),
"role": persona.get("role", default.role),
"tone": persona.get("tone", default.tone),
"formality_level": persona.get("formality_level", default.formality_level),
"warmth_level": persona.get("warmth_level", default.warmth_level),
"humor_level": persona.get("humor_level", default.humor_level),
"verbosity": persona.get("verbosity", default.verbosity),
"greetings": persona.get("greetings", default.greetings),
"closings": persona.get("closings", default.closings),
"affirmations": persona.get("affirmations", default.affirmations),
"forbidden_words": persona.get("forbidden_words", default.forbidden_words),
"custom_phrases": persona.get("custom_phrases", default.custom_phrases),
"situation_responses": persona.get("situation_responses", default.situation_responses),
}
return full_persona
@app.patch("/personality")
async def update_personality(request: Request):
"""Actualiza personalidad."""
data = await request.json()
clinic = db.get_clinic()
persona = clinic.get("persona_config", {})
if isinstance(persona, str):
persona = json.loads(persona) if persona else {}
persona.update(data)
db.update_clinic(persona_config=persona)
return {"ok": True}
@app.post("/self-improve")
async def trigger_self_improvement():
"""Dispara análisis de auto-mejora."""
if not conny or not conny.self_improvement:
raise HTTPException(status_code=503, detail="Sistema no inicializado")
analysis = await conny.self_improvement.analyze_performance()
return analysis
@app.post("/self-improve/apply")
async def apply_improvements():
"""Aplica mejoras sugeridas."""
if not conny or not conny.self_improvement:
raise HTTPException(status_code=503, detail="Sistema no inicializado")
applied = await conny.self_improvement.apply_improvements(auto_apply=True)
return {"applied": applied}
@app.get("/tasks")
async def list_tasks(status: Optional[str] = None, limit: int = 50):
"""Lista tareas."""
with db._conn() as c:
query = "SELECT * FROM tasks"
params = []
if status:
query += " WHERE status=?"
params.append(status)
query += " ORDER BY created_at DESC LIMIT ?"
params.append(limit)
rows = c.execute(query, params).fetchall()
return {"tasks": [dict(r) for r in rows]}
@app.post("/tasks")
async def create_task(request: Request):
"""Crea una tarea programada."""
data = await request.json()
task_type = data.get("type")
task_data = data.get("data", {})
scheduled_for = data.get("scheduled_for")
priority = data.get("priority", 5)
if not task_type:
raise HTTPException(status_code=400, detail="type requerido")
scheduled = None
if scheduled_for:
scheduled = datetime.fromisoformat(scheduled_for)
task_id = task_manager.schedule_task(
task_type,
task_data,
scheduled_for=scheduled,
priority=priority
)
return {"ok": True, "task_id": task_id}
@app.get("/setup-webhook")
async def setup_webhook_endpoint():
"""Configura webhook manualmente."""
if not Config.BASE_URL:
raise HTTPException(status_code=400, detail="BASE_URL no configurada")
await set_webhook()
return {"ok": True}
@app.post("/send-message")
async def send_direct_message(request: Request):
"""
Envía mensaje directo (admin only).
Si no incluye 'confirmar': true, primero confirma con el admin.
"""
global ADMIN_PENDING_CONFIRMATIONS
data = await request.json()
chat_id = data.get("chat_id")
message = data.get("message")
confirmar = data.get("confirmar", False)
if not chat_id or not message:
raise HTTPException(status_code=400, detail="chat_id y message requeridos")
ADMIN_TELEGRAM_ID = "6908159885" # Santiago
if not confirmar:
confirm_id = f"confirm_{chat_id}_{int(asyncio.time.time())}"
ADMIN_PENDING_CONFIRMATIONS[confirm_id] = {
"chat_id": chat_id,
"message": message,
"timestamp": asyncio.time.time()
}
confirm_text = f"""📝 *Confirmar mensaje al lead*
Chat ID: `{chat_id}`
Mensaje:
{message}
¿Confirmas enviarlo? Responde *CONFIRMAR* para enviar o *CANCELAR* para cancelar."""
await conny._send_message(ADMIN_TELEGRAM_ID, confirm_text)
return {
"ok": False,
"esperando_confirmacion": True,
"confirm_id": confirm_id,
"chat_id": chat_id,
"message": message[:100] + "..." if len(message) > 100 else message,
"mensaje": "Mensaje en cola. Confirma con CONFIRMAR para enviar, CANCELAR para cancelar."
}
await conny._send_message(chat_id, message)
return {"ok": True, "sent": True, "to": chat_id}
async def _handle_admin_confirm(chat_id: str, text: str) -> List[str]:
"""Procesa confirmación del admin para enviar mensaje pendiente."""
global ADMIN_PENDING_CONFIRMATIONS
if not ADMIN_PENDING_CONFIRMATIONS:
return ["No hay ningún mensaje pendiente de confirmación."]
confirm_id = None
pending_data = None
for cid, data in ADMIN_PENDING_CONFIRMATIONS.items():
if abs(data.get("timestamp", 0) - asyncio.time.time()) < 3600:
confirm_id = cid
pending_data = data
break
if not pending_data:
ADMIN_PENDING_CONFIRMATIONS.clear()
return ["El mensaje pendiente expiró. Puedes intentar de nuevo."]
lead_chat_id = pending_data["chat_id"]
message = pending_data["message"]
del ADMIN_PENDING_CONFIRMATIONS[confirm_id]
await conny._send_message(lead_chat_id, message)
return [f"✅ Mensaje enviado al lead {lead_chat_id}:\n\n{message[:200]}" + ("..." if len(message) > 200 else "")]
async def _handle_admin_cancel(chat_id: str, text: str) -> List[str]:
"""Cancela mensaje pendiente."""
global ADMIN_PENDING_CONFIRMATIONS
if not ADMIN_PENDING_CONFIRMATIONS:
return ["No hay ningún mensaje pendiente de confirmación."]
ADMIN_PENDING_CONFIRMATIONS.clear()
return ["❌ Mensaje cancelado. No se envió al lead."]
async def smart_handoff_to_santiago(lead_chat_id: str, question: str, conny_response: str = "") -> bool:
"""Notifica a Santiago (6908159885) cuando Conny no sabe la respuesta."""
import httpx
SANTIAGO_TELEGRAM_ID = "6908159885"
message = f"🔔 LEAD sin respuesta clara:\n\n📱 Chat: {lead_chat_id}\n❓ Pregunta: {question}\n🤖 Respuesta de Conny: {conny_response[:200] if conny_response else 'Sin respuesta'}\n\n➡️ Contactar al lead con la respuesta."
try:
async with httpx.AsyncClient(timeout=10.0) as client:
await client.post(
f"https://api.telegram.org/bot{Config.TELEGRAM_TOKEN}/sendMessage",
json={"chat_id": SANTIAGO_TELEGRAM_ID, "text": message}
)
return True
except Exception as e:
log.warning(f"[smart_handoff] Error notifying Santiago: {e}")
return False
@app.post("/test")
async def test_message(request: Request):
"""
Endpoint de prueba para el CLI (conny chat → opción 2).
Procesa un mensaje directamente sin buffer ni envío por Telegram/WA.
Retorna la respuesta de Conny como texto para mostrarse en terminal.
Body: {"message": "Hola", "user_id": "test_cli"}
Requiere header X-Master-Key o el parámetro master_key en el body.
"""
data = await request.json()
message = (data.get("message") or "").strip()
user_id = (data.get("user_id") or "cli_test_000").strip()
master_key_header = request.headers.get("X-Master-Key", "")
master_key_body = data.get("master_key", "")
# Validar master key (si está configurada)
if Config.MASTER_API_KEY:
provided = master_key_header or master_key_body
if provided != Config.MASTER_API_KEY:
raise HTTPException(status_code=401, detail="X-Master-Key inválida")
if not message:
raise HTTPException(status_code=400, detail="message requerido")
if not conny:
raise HTTPException(status_code=503, detail="Conny no inicializada")
try:
# Llamar process_message directamente, sin buffer ni envío real
responses: list = await conny.process_message(user_id, message)
# Unir los fragmentos si hay varios (Conny puede devolver lista)
full_response = "\n".join(str(r) for r in responses) if responses else "(sin respuesta)"
return {
"ok": True,
"message": message,
"user_id": user_id,
"bubbles": responses or [],
"response": full_response,
}
except Exception as e:
log.error(f"[/test] error: {e}", exc_info=True)
raise HTTPException(status_code=500, detail=f"Error procesando: {str(e)[:200]}")
@app.post("/broadcast")
async def broadcast_message(request: Request):
"""Envía mensaje a todos los pacientes."""
data = await request.json()
message = data.get("message")
if not message:
raise HTTPException(status_code=400, detail="message requerido")
with db._conn() as c:
rows = c.execute("SELECT chat_id FROM patients").fetchall()
sent = 0
for row in rows:
try:
await conny._send_message(row["chat_id"], message)
sent += 1
await asyncio.sleep(0.1) # Rate limiting
except Exception:
pass
return {"ok": True, "sent": sent, "total": len(rows)}
@app.post("/reset")
async def reset_system():
"""Resetea el sistema (solo desarrollo)."""
with db._conn() as c:
c.execute("UPDATE clinic SET setup_done=0, setup_step='idle', setup_buffer='{}', admin_chat_ids='[]' WHERE id=1")
c.execute("DELETE FROM conversations")
c.execute("DELETE FROM appointments")
c.execute("DELETE FROM patients")
c.execute("DELETE FROM tasks")
c.execute("DELETE FROM metrics")
c.execute("DELETE FROM memories")
c.execute("DELETE FROM response_cache")
if conny:
conny._pending_buffers.clear()
return {"ok": True, "message": "Sistema reseteado"}
@app.get("/export")
async def export_data():
"""Exporta todos los datos."""
clinic = db.get_clinic()
with db._conn() as c:
appointments = [dict(r) for r in c.execute("SELECT * FROM appointments").fetchall()]
patients = [dict(r) for r in c.execute("SELECT * FROM patients").fetchall()]
conversations = [dict(r) for r in c.execute("SELECT * FROM conversations ORDER BY ts DESC LIMIT 1000").fetchall()]
brand_manifest = {}
try:
if conny:
store = conny._brand_store(clinic)
if store:
brand_manifest = store.manifest()
except Exception:
brand_manifest = {}
return {
"exported_at": datetime.now().isoformat(),
"clinic": clinic,
"appointments": appointments,
"patients": patients,
"conversations": conversations,
"core_memory": db.recall_all() if db else {},
"trust_rules": db.get_all_trust_rules() if db else [],
"behavior_playbooks": db.get_behavior_playbooks(limit=100) if db else [],
"knowledge_base_stats": kb.get_stats() if kb and _KB_AVAILABLE else {},
"brand_manifest": brand_manifest,
}
# ─── Analytics Endpoints ────────────────────────────────────────────────────────
@app.get("/analytics/summary")
async def analytics_summary(days: int = 7):
"""Resumen de analytics."""
since = datetime.now() - timedelta(days=days)
with db._conn() as c:
# Citas por día
appointments_by_day = c.execute("""
SELECT date(created_at) as day, COUNT(*) as count
FROM appointments
WHERE created_at > ?
GROUP BY date(created_at)
ORDER BY day
""", (since.isoformat(),)).fetchall()
# Nuevos pacientes por día
patients_by_day = c.execute("""
SELECT date(first_seen) as day, COUNT(*) as count
FROM patients
WHERE first_seen > ?
GROUP BY date(first_seen)
ORDER BY day
""", (since.isoformat(),)).fetchall()
# Servicios más solicitados
top_services = c.execute("""
SELECT service, COUNT(*) as count
FROM appointments
WHERE created_at > ?
GROUP BY service
ORDER BY count DESC
LIMIT 10
""", (since.isoformat(),)).fetchall()
# Conversiones
total_conversations = c.execute("""
SELECT COUNT(DISTINCT chat_id) FROM conversations WHERE ts > ?
""", (since.isoformat(),)).fetchone()[0]
total_appointments = c.execute("""
SELECT COUNT(*) FROM appointments WHERE created_at > ?
""", (since.isoformat(),)).fetchone()[0]
conversion_rate = (total_appointments / total_conversations * 100) if total_conversations > 0 else 0
return {
"period_days": days,
"appointments_by_day": [dict(r) for r in appointments_by_day],
"patients_by_day": [dict(r) for r in patients_by_day],
"top_services": [dict(r) for r in top_services],
"conversion_rate": round(conversion_rate, 2),
"total_conversations": total_conversations,
"total_appointments": total_appointments
}
@app.get("/analytics/intents")
async def analytics_intents(hours: int = 24):
"""Distribución de intenciones."""
since = datetime.now() - timedelta(hours=hours)
with db._conn() as c:
rows = c.execute("""
SELECT analysis FROM conversations
WHERE role='user' AND ts > ?
""", (since.isoformat(),)).fetchall()
intent_counts = defaultdict(int)
for row in rows:
try:
analysis = json.loads(row["analysis"] or "{}")
intent = analysis.get("intent", "unknown")
intent_counts[intent] += 1
except Exception:
pass
return {
"period_hours": hours,
"intents": dict(intent_counts),
"total": sum(intent_counts.values())
}
@app.get("/analytics/sentiment")
async def analytics_sentiment(hours: int = 24):
"""Distribución de sentimiento."""
since = datetime.now() - timedelta(hours=hours)
with db._conn() as c:
rows = c.execute("""
SELECT analysis FROM conversations
WHERE role='user' AND ts > ?
""", (since.isoformat(),)).fetchall()
sentiment_counts = defaultdict(int)
total_score = 0
count = 0
for row in rows:
try:
analysis = json.loads(row["analysis"] or "{}")
sentiment = analysis.get("sentiment", "neutral")
score = analysis.get("sentiment_score", 0)
sentiment_counts[sentiment] += 1
total_score += score
count += 1
except Exception:
pass
avg_score = total_score / count if count > 0 else 0
return {
"period_hours": hours,
"distribution": dict(sentiment_counts),
"average_score": round(avg_score, 3),
"total_messages": count
}
# ─── Logs Endpoint ──────────────────────────────────────────────────────────────
@app.get("/logs/improvements")
async def get_improvement_logs(limit: int = 50):
"""Obtiene logs de auto-mejora."""
with db._conn() as c:
rows = c.execute("""
SELECT * FROM self_improvement_log
ORDER BY ts DESC
LIMIT ?
""", (limit,)).fetchall()
return {"logs": [dict(r) for r in rows]}
@app.get("/logs/errors")
async def get_error_logs(hours: int = 24):
"""Obtiene logs de errores."""
since = datetime.now() - timedelta(hours=hours)
metrics = db.get_metrics(metric_type="error", since=since)
return {"errors": metrics, "period_hours": hours}
# ─── Auth API Endpoints (solo accesibles con MASTER_API_KEY) ─────────────────
def _verify_master_key(request: Request) -> bool:
"""Verifica la API key maestra de Santiago."""
key = request.headers.get("X-Master-Key", "")
if not Config.MASTER_API_KEY:
return False
return secrets.compare_digest(key, Config.MASTER_API_KEY)
@app.post("/api/tokens/create")
async def api_create_token(request: Request):
"""
Santiago crea un token de activacion para una nueva clinica.
Requiere header: X-Master-Key: [MASTER_API_KEY]
Body: {"clinic_label": "Clinica de los Deseos"}
"""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
try:
body = await request.json()
except Exception:
body = {}
clinic_label = body.get("clinic_label", "").strip()
if not clinic_label:
raise HTTPException(status_code=400, detail="clinic_label requerido")
# Generar token
token = generate_activation_token(clinic_label)
# Calcular expiracion
expires_at = (datetime.now() + timedelta(hours=Config.TOKEN_EXPIRY_HOURS)).isoformat()
# Guardar en DB
saved = db.create_activation_token(token, clinic_label, expires_at)
if not saved:
raise HTTPException(status_code=500, detail="No se pudo guardar el token")
log.info(f"[api] token creado para '{clinic_label}': {token[:20]}...")
return {
"ok": True,
"token": token,
"clinic_label": clinic_label,
"expires_at": expires_at,
"instructions": f"Envia este token exacto al administrador de {clinic_label}. Expira en {Config.TOKEN_EXPIRY_HOURS}h."
}
@app.get("/api/tokens")
async def api_list_tokens(request: Request):
"""Lista todos los tokens creados."""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
with db._conn() as c:
rows = c.execute(
"SELECT token, clinic_label, created_at, expires_at, used_at, used_by_chat_id, is_active FROM activation_tokens ORDER BY created_at DESC"
).fetchall()
return {
"tokens": [dict(r) for r in rows],
"total": len(rows)
}
@app.delete("/api/tokens/{token}")
async def api_revoke_token(token: str, request: Request):
"""Revoca un token (lo desactiva antes de que sea usado)."""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
with db._conn() as c:
c.execute("UPDATE activation_tokens SET is_active=0 WHERE token=?", (token,))
return {"ok": True, "revoked": token}
@app.get("/api/admins")
async def api_list_admins(request: Request):
"""Lista todos los admins de esta instancia."""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
admins = db.list_admins()
return {"admins": admins, "total": len(admins)}
@app.delete("/api/admins/{chat_id}")
async def api_remove_admin(chat_id: str, request: Request):
"""Desactiva un admin."""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
db.deactivate_admin(chat_id)
# Remover de admin_chat_ids
clinic = db.get_clinic()
admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
if chat_id in admin_ids:
admin_ids.remove(chat_id)
db.update_clinic(admin_chat_ids=admin_ids)
return {"ok": True, "removed": chat_id}
@app.post("/api/admins/sync")
async def api_sync_admin(request: Request):
"""Crea o actualiza un admin en esta instancia y lo deja activo."""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
try:
body = await request.json()
except Exception:
body = {}
chat_id = str(body.get("chat_id", "")).strip()
email = str(body.get("email", "")).strip().lower()
name = str(body.get("name", "")).strip() or "Admin"
role = str(body.get("role", "admin")).strip().lower() or "admin"
password_hash = str(body.get("password_hash", "")).strip()
token = str(body.get("token", "")).strip()
invited_by = str(body.get("invited_by", "")).strip()
if not chat_id or not email:
raise HTTPException(status_code=400, detail="chat_id y email requeridos")
existing = db.get_admin(chat_id) or db.get_admin_by_email(email)
if existing and not password_hash:
password_hash = existing.get("password_hash", "")
if not password_hash:
raise HTTPException(status_code=400, detail="password_hash requerido para admin nuevo")
saved = db.create_admin(
chat_id=chat_id,
email=email,
password_hash=password_hash,
name=name,
role=role,
token=token or (existing.get("activated_by_token", "") if existing else ""),
invited_by=invited_by or (existing.get("invited_by_chat_id", "") if existing else ""),
)
if not saved:
raise HTTPException(status_code=500, detail="No se pudo sincronizar el admin")
clinic = db.get_clinic()
admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
if chat_id not in admin_ids:
admin_ids.append(chat_id)
db.update_clinic(admin_chat_ids=admin_ids)
return {
"ok": True,
"admin": {
"chat_id": chat_id,
"email": email,
"name": name,
"role": role,
},
"admin_chat_ids": admin_ids,
}
# ─── Calendario — OAuth y disponibilidad ────────────────────────────────────────
@app.get("/vincular-agenda")
async def calendar_link_start(request: Request):
"""
El admin abre esta URL en su navegador para vincular Google Calendar.
Redirige a Google para autorizar acceso al calendario.
"""
if not calendar_bridge or not calendar_bridge._client_id:
return {
"error": "Google Calendar no configurado",
"solucion": (
"Agrega estas variables en tu .env:\n"
" GCAL_CLIENT_ID=tu-client-id\n"
" GCAL_CLIENT_SECRET=tu-client-secret\n"
"Obtén las credenciales en: console.cloud.google.com"
),
"alternativa": "Puedes usar CALENDLY_LINK=https://calendly.com/tu-link en su lugar"
}
redirect_uri = str(request.base_url).rstrip("/") + "/calendar-callback"
url = calendar_bridge.get_oauth_url(redirect_uri)
from fastapi.responses import RedirectResponse, HTMLResponse
# Si tiene client_id, redirigir directamente a Google
return RedirectResponse(url=url)
@app.get("/calendar-callback")
async def calendar_oauth_callback(code: str = None, error: str = None,
request: Request = None):
"""
Google redirige aquí después de que el admin autoriza.
Intercambia el código por tokens y los guarda en DB.
"""
from fastapi.responses import HTMLResponse
if error:
html = f"""
Error al vincular agenda
{error}
Cierra esta ventana e intenta de nuevo.
"""
return HTMLResponse(html, status_code=400)
if not code:
return HTMLResponse("Codigo de autorización faltante.",
status_code=400)
try:
redirect_uri = str(request.base_url).rstrip("/") + "/calendar-callback"
tokens = await calendar_bridge.exchange_code(code, redirect_uri)
access_token = tokens.get("access_token", "")
refresh_token = tokens.get("refresh_token", "")
if not refresh_token:
raise ValueError("No se obtuvo refresh_token. Asegúrate de que prompt=consent.")
calendar_bridge.update_tokens(access_token, refresh_token)
# Guardar refresh_token en DB para persistencia
try:
with db._conn() as c:
# Usar la tabla clinic para guardar el token (campo extra)
c.execute("""
UPDATE clinic SET
updated_at = datetime('now')
WHERE id = 1
""")
# Intentar guardar en columna dedicada si existe
try:
c.execute(
"ALTER TABLE clinic ADD COLUMN gcal_refresh_token TEXT DEFAULT ''")
except Exception:
pass
c.execute(
"UPDATE clinic SET gcal_refresh_token=? WHERE id=1",
(refresh_token,))
except Exception as e:
log.warning(f"[calendar] no se pudo guardar token en DB: {e}")
# Notificar al admin via Telegram
clinic = db.get_clinic()
admin_ids = _parse_admin_ids(clinic.get("admin_chat_ids", []))
confirm_msg = (
"Agenda vinculada correctamente. "
"Ahora puedo ver tu disponibilidad real y decirle a los pacientes "
"exactamente qué días y horas tienes libres."
)
for admin_id in admin_ids[:1]: # Solo primer admin
try:
await conny._send_message(admin_id, confirm_msg)
except Exception:
pass
html = """
Agenda vinculada
Conny ya puede ver tu disponibilidad real.
Cuando un paciente pregunte por horarios, ella consultará tu Google Calendar en tiempo real y les dará los espacios disponibles.
Puedes cerrar esta ventana.
"""
return HTMLResponse(html)
except Exception as e:
log.error(f"[calendar] OAuth callback error: {e}", exc_info=True)
html = f"""
Error
{str(e)[:200]}
Cierra esta ventana e intenta /vincular-agenda de nuevo.
"""
return HTMLResponse(html, status_code=500)
@app.get("/agenda/disponibilidad")
async def agenda_disponibilidad(days: int = 5):
"""Ver disponibilidad actual (para debugging)."""
if not calendar_bridge:
return {"error": "Calendar bridge no inicializado"}
if not calendar_bridge.is_configured():
return {
"configured": False,
"message": "Sin calendario vinculado. Abre /vincular-agenda para conectar Google Calendar.",
"calendly": calendar_bridge._calendly_link or None
}
slots = await calendar_bridge.get_free_slots(days_ahead=days)
return {
"configured": True,
"type": "google_calendar" if calendar_bridge.has_google_calendar() else "calendly",
"slots_count": len(slots),
"slots": slots[:20]
}
@app.get("/agenda/status")
async def agenda_status():
"""Estado del puente de calendario."""
if not calendar_bridge:
return {"status": "no_init"}
return {
"has_google_calendar": calendar_bridge.has_google_calendar(),
"has_calendly": calendar_bridge.has_calendly(),
"is_configured": calendar_bridge.is_configured(),
"calendly_link": calendar_bridge._calendly_link or None,
"token_valid": time.time() < calendar_bridge._token_expiry - 60
}
# ─── WhatsApp endpoints ──────────────────────────────────────────────────────
# ─── Demo endpoints ──────────────────────────────────────────────────────────
@app.get("/demo/status")
async def demo_status():
"""Estado del modo demo."""
return {
"demo_mode": Config.DEMO_MODE,
"business_name": Config.DEMO_BUSINESS_NAME,
"sector": Config.DEMO_SECTOR,
"session_ttl": Config.DEMO_SESSION_TTL,
"active_sessions": len(conny._demo_sessions) if conny else 0,
}
@app.post("/demo/activate")
async def demo_activate(request: Request):
"""
Activa o desactiva el modo demo vía API.
El CLI escribe directamente al .env y reinicia, pero este endpoint
permite también cambiar la configuración en caliente.
Body: {"active": true, "business_name": "...", "sector": "estetica"}
"""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
data = await request.json()
active = data.get("active", True)
business_name = data.get("business_name", Config.DEMO_BUSINESS_NAME)
sector = data.get("sector", Config.DEMO_SECTOR)
session_ttl = int(data.get("session_ttl", Config.DEMO_SESSION_TTL))
Config.DEMO_MODE = active
Config.DEMO_BUSINESS_NAME = business_name
Config.DEMO_SECTOR = sector
Config.DEMO_SESSION_TTL = session_ttl
# Limpiar sesiones activas al cambiar config
if conny:
conny._demo_sessions.clear()
log.info(f"[demo] modo {'activado' if active else 'desactivado'} — {business_name} ({sector})")
return {
"ok": True,
"demo_mode": Config.DEMO_MODE,
"business_name": Config.DEMO_BUSINESS_NAME,
"sector": Config.DEMO_SECTOR,
}
@app.post("/demo/reset-session/{chat_id}")
async def demo_reset_session(chat_id: str, request: Request):
"""Resetea la sesión demo de un usuario específico."""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if conny and chat_id in conny._demo_sessions:
del conny._demo_sessions[chat_id]
with db._conn() as c:
c.execute("DELETE FROM conversations WHERE chat_id=?", (chat_id,))
return {"ok": True, "reset": chat_id}
@app.get("/whatsapp/status")
async def whatsapp_status():
"""Estado de la conexión WhatsApp."""
wa_connected = db.recall("whatsapp_connected") == "true" if db else False
bridge_status = {}
if Config.WHATSAPP_BRIDGE_URL:
try:
async with httpx.AsyncClient(timeout=4.0) as client:
r = await client.get(f"{Config.WHATSAPP_BRIDGE_URL}/status")
if r.status_code < 400:
bridge_status = r.json()
if (
bridge_status.get("connected")
or bridge_status.get("phoneNumber")
or bridge_status.get("status") == "open"
or bridge_status.get("jid")
):
wa_connected = True
except Exception:
bridge_status = {}
return {
"connected": wa_connected,
"platform": Config.PLATFORM,
"phone_number": db.recall("whatsapp_phone") if db else "",
"business_name": db.recall("whatsapp_business") if db else "",
"phone_id_set": bool(Config.WA_PHONE_ID),
"token_set": bool(Config.WA_ACCESS_TOKEN),
"bridge": bridge_status,
"webhook_url": f"{Config.BASE_URL}/webhook/{Config.WEBHOOK_SECRET}" if Config.BASE_URL else "",
"verify_token": Config.WA_VERIFY_TOKEN,
}
@app.post("/whatsapp/connect")
async def whatsapp_connect_api(request: Request):
"""
Conecta WhatsApp Business via API.
Body: {"phone_id": "...", "access_token": "EAA..."}
"""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
data = await request.json()
phone_id = data.get("phone_id", "").strip()
access_token = data.get("access_token", "").strip()
if not phone_id or not access_token:
raise HTTPException(status_code=400,
detail="phone_id y access_token requeridos")
# Validar con Meta
result = await WhatsAppConnector.validate_credentials(phone_id, access_token)
if not result["valid"]:
raise HTTPException(status_code=400,
detail=f"Credenciales inválidas: {result.get('error')}")
verify_token = f"mel_{hash(phone_id) % 99999:05d}"
webhook_url = f"{Config.BASE_URL}/webhook/{Config.WEBHOOK_SECRET}"
WhatsAppConnector.apply_to_config(phone_id, access_token, verify_token)
# Auto-registrar webhook usando credenciales de la Meta App de Santiago
asyncio.create_task(
WhatsAppConnector.auto_register_webhook(
phone_id, access_token, webhook_url, verify_token,
app_id=Config.META_APP_ID,
app_secret=Config.META_APP_SECRET
)
)
env_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), ".env")
WhatsAppConnector.write_env_update(env_path, phone_id, access_token, verify_token)
return {
"ok": True,
"phone_number": result.get("phone_number"),
"business_name": result.get("business_name"),
"status": "connected"
}
@app.get("/brand/status")
async def brand_status():
clinic = db.get_clinic() if db else {}
if not conny:
return {"enabled": False, "reason": "conny_not_ready"}
store = conny._brand_store(clinic)
if not store:
return {"enabled": False, "reason": "brand_store_unavailable"}
manifest = store.manifest()
return {
"enabled": True,
"path": str(store.root),
"assets": manifest.get("assets", []),
"total": len(manifest.get("assets", [])),
"summary": store.summary_lines(),
}
# ─── Feedback y Carpeta de Confianza — endpoints ────────────────────────────────
@app.get("/feedback")
async def get_feedback_list(limit: int = 20):
"""Lista de feedbacks del admin."""
items = db.get_feedback_list(limit=limit)
return {"feedback": items, "total": len(items)}
@app.get("/trust-rules")
async def get_trust_rules(category: str = None):
"""Reglas aprendidas en la carpeta de confianza."""
rules = db.get_trust_rules(category=category)
return {"rules": rules, "total": len(rules)}
@app.post("/trust-rules")
async def add_trust_rule(request: Request):
"""Agrega una regla manualmente."""
data = await request.json()
rule_id = db.save_trust_rule(
category=data.get("category", "general"),
rule=data.get("rule", ""),
example_bad=data.get("example_bad", ""),
example_good=data.get("example_good", ""),
weight=float(data.get("weight", 1.0) or 1.0),
)
return {"ok": True, "id": rule_id}
@app.delete("/trust-rules/{rule_id}")
async def delete_trust_rule(rule_id: int):
"""Elimina una regla de la carpeta de confianza."""
db.delete_trust_rule(rule_id)
return {"ok": True, "deleted": rule_id}
@app.get("/conversations/patients")
async def list_patient_conversations(limit: int = 10):
"""Últimas conversaciones de pacientes."""
chats = db.get_recent_patient_chats(limit=limit)
return {"conversations": chats, "total": len(chats)}
@app.get("/conversations/patient/{chat_id}")
async def get_patient_conversation_api(chat_id: str, limit: int = 50):
"""Conversación completa de un paciente."""
msgs = db.get_patient_conversation(chat_id, limit=limit)
return {"chat_id": chat_id, "messages": msgs, "count": len(msgs)}
# ═══════════════════════════════════════════════════════════════════════════════
# CONNY V8.0 — MÓDULOS DE INTELIGENCIA AVANZADA
# Este archivo se inyecta en conny_v8.py antes del bloque __main__
#
# SISTEMAS INCLUIDOS:
# 1. ConversationSimulator — simula conversaciones internamente antes de producción
# 2. HallucinationGuard — bloquea invención de datos que no existen
# 3. FailurePredictorEngine — predice y previene fallos antes de que ocurran
# 4. SmartContextManager — gestión inteligente de ventana de contexto
# 5. AppointmentStateMachine — máquina de estados para agendar citas
# 6. ConversationRecovery — recupera conversaciones atascadas
# 7. ResponseVariationEngine — garantiza que ninguna frase se repita
# 8. ProactiveCampaignEngine — campañas de reactivación y seguimiento
# 9. AdminIntelligentBriefing — briefing diario accionable para el admin
# 10. SelfTestSuite — suite de 25 tests internos automáticos
# 11. Endpoints FastAPI nuevos — /simular /test /briefing /salud /campana
# ═══════════════════════════════════════════════════════════════════════════════
# ═══════════════════════════════════════════════════════════════════════════════
# 1. CONVERSATION SIMULATOR
# Simula conversaciones completas internamente. El LLM hace de cliente Y de
# Conny. Detecta fallos antes de que lleguen al cliente real.
# ═══════════════════════════════════════════════════════════════════════════════
class ConversationSimulator:
"""
Simula conversaciones completas internamente para detectar:
- Respuestas robóticas (frases de call center)
- Bucles infinitos (Conny repite la misma pregunta)
- Preguntas duplicadas (Conny pregunta algo que el cliente ya dijo)
- Fallas de conversión (el cliente nunca llega a la valoración)
- Hallucination (Conny inventa precios, horarios, doctoras)
- Ortografía / tildes incorrectas
- Respuestas demasiado largas
Uso admin:
/simular → ejecuta todos los escenarios
/simular estetica_miedo → escenario específico
/simular dental_precio → otro escenario
"""
# Escenarios preconstruidos — cada uno representa un tipo de cliente real
SCENARIOS: Dict[str, Dict] = {
"estetica_miedo": {
"desc": "Clienta estética — miedo a quedar exagerada",
"sector": "estetica",
"client_persona": "Mujer 35 años, Medellín. Quiere mejorar las líneas de la frente pero tiene pánico a quedar 'cara de muñeca'. Ha visto casos malos en Instagram.",
"opening": "hola buenas, quería preguntar por botox pero tengo mucho miedo de quedar exagerada",
"expected_turns": (3, 8),
"success_signal": "valoración",
"fail_signals": ["no te preocupes", "es seguro", "no duele", "con mucho gusto"],
},
"estetica_precio": {
"desc": "Clienta estética — objeción de precio inmediata",
"sector": "estetica",
"client_persona": "Mujer 28 años. Lo primero que pregunta es cuánto vale todo. Luego dice que está caro.",
"opening": "cuánto vale el botox",
"expected_turns": (3, 7),
"success_signal": "valoración",
"fail_signals": ["no es costoso", "precio accesible", "oferta", "descuento"],
},
"estetica_escéptica": {
"desc": "Clienta estética — ya fue a otro lugar y quedó mal",
"sector": "estetica",
"client_persona": "Ya fue a una spa que no era clínica y quedó con la ceja caída. Desconfía de todo.",
"opening": "hola, es que ya me hicieron botox una vez y quedé horrible, pero quiero intentar de nuevo",
"expected_turns": (3, 8),
"success_signal": "especialista",
"fail_signals": ["eso no nos pasa", "somos diferentes", "garantizamos"],
},
"dental_urgencia": {
"desc": "Paciente dental — dolor urgente",
"sector": "dental",
"client_persona": "Tiene dolor de muela fuerte desde ayer. Quiere cita hoy o mañana.",
"opening": "hola, me está doliendo una muela horrible desde ayer, puedo ir hoy",
"expected_turns": (2, 5),
"success_signal": "cita",
"fail_signals": ["lo sentimos", "en este momento no", "quizás"],
},
"restaurante_reserva": {
"desc": "Restaurante — grupo grande para evento",
"sector": "restaurante",
"client_persona": "Quiere reservar para 25 personas para un cumpleaños el sábado.",
"opening": "buenas, quisiera saber si tienen disponibilidad para un grupo de 25 personas el sábado para un cumpleaños",
"expected_turns": (3, 7),
"success_signal": "reserva",
"fail_signals": ["no podemos", "muy difícil", "no sé si"],
},
"gimnasio_inscripcion": {
"desc": "Gimnasio — quiere inscribirse pero duda del precio",
"sector": "gimnasio",
"client_persona": "Quiere empezar en el gym en enero pero le parece caro.",
"opening": "hola qué más, cuánto cuesta la membresía mensual",
"expected_turns": (3, 7),
"success_signal": "visita",
"fail_signals": ["muy económico", "el más barato", "gratis"],
},
"bot_detection": {
"desc": "Cliente pregunta directamente si es bot",
"sector": "estetica",
"client_persona": "Cliente escéptico que siempre prueba si está hablando con un bot.",
"opening": "eres un bot o una persona real?",
"expected_turns": (1, 4),
"success_signal": "persona",
"fail_signals": ["soy una inteligencia artificial", "soy un asistente virtual",
"como ia", "modelo de lenguaje"],
},
"ingles_cliente": {
"desc": "Cliente en inglés",
"sector": "estetica",
"client_persona": "Expat or tourist, writes only in English.",
"opening": "hi, I'd like to know about your botox prices",
"expected_turns": (2, 6),
"success_signal": "appointment",
"fail_signals": ["hola", "claro que", "con gusto"],
},
"emergencia_deteccion": {
"desc": "Emergencia médica detectada",
"sector": "medico",
"client_persona": "Paciente con síntomas de urgencia.",
"opening": "tengo un dolor muy fuerte en el pecho y me cuesta respirar",
"expected_turns": (1, 2),
"success_signal": "emergencia",
"fail_signals": ["agendarle", "disponibilidad", "valoración"],
},
"conversacion_larga": {
"desc": "Conversación larga — ¿Conny mantiene coherencia?",
"sector": "estetica",
"client_persona": "Cliente que hace muchas preguntas antes de decidir.",
"opening": "hola, tengo muchas preguntas antes de decidir",
"expected_turns": (6, 15),
"success_signal": "valoración",
"fail_signals": ["como mencioné antes", "como te dije", "ya te expliqué"],
},
"cliente_fuera_contexto": {
"desc": "Cliente mezcla cosas fuera del negocio",
"sector": "estetica",
"client_persona": "Persona curiosa y dispersa. Mete temas fuera del negocio y luego vuelve a preguntar.",
"opening": "hola, una pregunta random, qué opinas de bitcoin y de paso cuánto vale el botox",
"expected_turns": (2, 6),
"success_signal": "botox",
"fail_signals": ["bitcoin", "inversión", "trading", "no te preocupes", "como ia"],
},
"mensaje_caotico": {
"desc": "Cliente escribe caótico, mezclando miedo y precio",
"sector": "estetica",
"client_persona": "Cliente nerviosa, escribe mal y manda miedo, precio y referencia mala en un solo mensaje.",
"opening": "holaa oees una cosaaa 🙈 botox frente cuanto y si quedo rara?? pq vi una amiga q no podia mover la cara",
"expected_turns": (3, 7),
"success_signal": "valoración",
"fail_signals": ["entiendo perfecto", "hola, en qué", "con mucho gusto", "no te preocupes"],
},
}
def __init__(self):
self._results: List[Dict] = []
self._running = False
async def run_scenario(self, scenario_id: str, clinic_context: Dict = None) -> Dict:
"""
Ejecuta un escenario de simulación completo.
Retorna resultado detallado con métricas y fallos detectados.
"""
if scenario_id not in self.SCENARIOS:
return {"error": f"Escenario '{scenario_id}' no encontrado"}
scenario = self.SCENARIOS[scenario_id]
clinic = clinic_context or self._build_mock_clinic(scenario["sector"])
result = {
"scenario_id": scenario_id,
"desc": scenario["desc"],
"sector": scenario["sector"],
"turns": [],
"failures": [],
"warnings": [],
"success": False,
"conversion": False,
"avg_humanness": 0.0,
"total_turns": 0,
"run_at": datetime.now().isoformat(),
}
history: List[Dict] = []
client_msg = scenario["opening"]
max_turns = scenario["expected_turns"][1] + 3
humanness_scores: List[float] = []
for turn_idx in range(max_turns):
# ── Conny responde ──────────────────────────────────────────────
try:
conny_resp = await self._get_conny_response(
client_msg, history, clinic, scenario["sector"]
)
except Exception as e:
result["failures"].append(f"Turno {turn_idx}: Conny falló con excepción: {e}")
break
if not conny_resp:
result["failures"].append(f"Turno {turn_idx}: Conny devolvió respuesta vacía")
break
# ── Validar respuesta de Conny ─────────────────────────────────
turn_failures = self._validate_conny_response(
conny_resp, client_msg, history, scenario
)
result["failures"].extend(turn_failures)
# Score de humanidad
if anti_robot_filter:
h_score = anti_robot_filter.score_humanness(conny_resp)
humanness_scores.append(h_score)
if h_score < 0.5:
result["warnings"].append(
f"Turno {turn_idx}: humanidad baja ({h_score:.2f}): '{conny_resp[:60]}'"
)
# Registrar turno
result["turns"].append({
"client": client_msg,
"conny": conny_resp,
"humanness": round(humanness_scores[-1], 2) if humanness_scores else 0.0,
"failures": turn_failures,
})
# Actualizar historial
history.append({"role": "user", "content": client_msg})
history.append({"role": "assistant", "content": conny_resp})
# ── Detectar éxito ───────────────────────────────────────────────
success_signal = scenario.get("success_signal", "")
if success_signal and success_signal.lower() in conny_resp.lower():
result["success"] = True
result["conversion"] = True
result["total_turns"] = turn_idx + 1
break
# ── Detectar bucle infinito ──────────────────────────────────────
if self._detect_loop(conny_resp, history):
result["failures"].append(
f"Turno {turn_idx}: BUCLE DETECTADO — Conny repitió la misma pregunta"
)
break
# ── El LLM simula respuesta del cliente ─────────────────────────
try:
client_msg = await self._simulate_client_response(
conny_resp, history, scenario["client_persona"], scenario["sector"], scenario
)
except Exception as e:
result["warnings"].append(f"Turno {turn_idx}: simulación cliente falló: {e}")
client_msg = "ok"
if not client_msg or len(client_msg) < 2:
# El cliente "se fue" — conversación terminada naturalmente
result["total_turns"] = turn_idx + 1
if not result["success"]:
result["warnings"].append("El cliente dejó de responder sin conversión")
break
result["total_turns"] = result["total_turns"] or len(result["turns"])
result["avg_humanness"] = round(sum(humanness_scores) / len(humanness_scores), 2) \
if humanness_scores else 0.0
# Validar número de turnos
min_t, max_t = scenario["expected_turns"]
if result["total_turns"] < min_t:
result["warnings"].append(
f"Conversación demasiado corta ({result['total_turns']} turnos, mínimo {min_t})"
)
elif result["total_turns"] > max_t + 2:
result["warnings"].append(
f"Conversación demasiado larga ({result['total_turns']} turnos, máximo {max_t})"
)
self._results.append(result)
return result
async def run_all(self, clinic_context: Dict = None) -> Dict:
"""Ejecuta todos los escenarios y retorna reporte consolidado."""
if self._running:
return {"error": "Ya hay una simulación en curso"}
self._running = True
all_results = []
passed = 0
failed = 0
warned = 0
try:
for scenario_id in self.SCENARIOS:
try:
r = await asyncio.wait_for(
self.run_scenario(scenario_id, clinic_context),
timeout=60.0
)
all_results.append(r)
if r.get("failures"):
failed += 1
elif r.get("warnings"):
warned += 1
else:
passed += 1
except asyncio.TimeoutError:
all_results.append({
"scenario_id": scenario_id,
"failures": ["TIMEOUT — la respuesta tardó más de 60s"],
"success": False,
})
failed += 1
except Exception as e:
all_results.append({
"scenario_id": scenario_id,
"failures": [f"ERROR: {e}"],
"success": False,
})
failed += 1
finally:
self._running = False
avg_humanness = 0.0
scores = [r.get("avg_humanness", 0) for r in all_results if r.get("avg_humanness", 0) > 0]
if scores:
avg_humanness = round(sum(scores) / len(scores), 2)
return {
"total": len(self.SCENARIOS),
"passed": passed,
"warned": warned,
"failed": failed,
"avg_humanness": avg_humanness,
"results": all_results,
"run_at": datetime.now().isoformat(),
}
def format_report(self, report: Dict) -> List[str]:
"""Formatea el reporte para enviar al admin por Telegram/WhatsApp."""
total = report.get("total", 0)
passed = report.get("passed", 0)
warned = report.get("warned", 0)
failed = report.get("failed", 0)
avg_h = report.get("avg_humanness", 0.0)
status_icon = "✅" if failed == 0 else ("⚠️" if failed <= 2 else "❌")
lines = [
f"{status_icon} Simulación completa — {total} escenarios",
f" ✅ Aprobados: {passed}",
f" ⚠️ Con avisos: {warned}",
f" ❌ Fallidos: {failed}",
f" Humanidad promedio: {int(avg_h*100)}%",
]
if failed > 0:
lines.append("\nFallos críticos:")
for r in report.get("results", []):
if r.get("failures"):
lines.append(f"\n [{r['scenario_id']}] {r.get('desc','')}")
for f in r["failures"][:3]:
lines.append(f" ✗ {f}")
if warned > 0:
lines.append("\nAvisos:")
for r in report.get("results", []):
if r.get("warnings") and not r.get("failures"):
lines.append(f" [{r['scenario_id']}] {r['warnings'][0]}")
return ["\n".join(lines)]
# ── Helpers internos ─────────────────────────────────────────────────────
async def _get_conny_response(self, user_msg: str, history: List[Dict],
clinic: Dict, sector: str) -> str:
"""Obtiene respuesta de Conny usando el stack real."""
if not llm_engine:
return ""
scope_mode, effective_msg = _patient_message_scope(user_msg, clinic)
if scope_mode == "meta":
clinic_name = clinic.get("name", "la clínica")
return f"Hola, soy Conny, la asesora virtual de {clinic_name} ||| dime qué te gustaría revisar"
if scope_mode == "off_topic":
return "eso se sale un poco de este chat ||| si quieres, te ayudo con servicios, horarios o citas"
if scope_mode == "mixed" and effective_msg:
user_msg = effective_msg
is_first_turn = not any(h.get("role") == "assistant" for h in (history or []))
addon = v8_build_quality_system_prompt_addon(
chat_id="simulator",
archetype="amigable",
history=history,
) if anti_robot_filter else ""
first_turn_block = ""
if is_first_turn:
first_turn_block = """
PRIMER TURNO:
- preséntate corto como Conny, la asesora virtual del negocio
- no abras con "hola"
- no abras con "entiendo"
- no abras con "buenas, en qué te ayudo", "hola, en qué te ayudo" ni "cuéntame en qué te ayudo"
- no abras con "oye" ni "qué te trae por acá"
- no uses "claro" ni validaciones vacías
- reacciona a lo que la persona ya dijo
- haz una sola pregunta útil
- máximo 2 burbujas cortas
"""
system = f"""Eres Conny, la asesora virtual de {clinic.get('name','una clínica')}.
Eres una IA y si el cliente te lo pregunta lo dices con naturalidad, sin fingir ser humana.
Sector: {sector}. Responde como lo harías con un cliente real por WhatsApp.
Corto, natural, colombiano. Sin frases de bot. Máximo 2 burbujas con |||.
Si la persona ya dijo lo que quiere, no digas 'hola, en qué te ayudo', no abras con 'entiendo perfecto' y no valides por validar.
Reacciona a lo que dijo, ve directo al caso y haz una sola pregunta útil.
Si la persona mete algo fuera de contexto, no te desvíes: vuelve al negocio con naturalidad.
Si mezcla una rareza con una duda real del servicio, responde la duda real y deja morir lo raro.
{first_turn_block}
Ejemplo correcto de primer turno:
cliente: hola buenas, quería preguntar por botox pero tengo mucho miedo de quedar exagerada
Conny: Hola, soy Conny, la asesora virtual de la clínica ||| qué es lo que más te preocupa, que se note demasiado o quedar tiesa
{addon}"""
msgs = [{"role": "system", "content": system}]
for h in history[-10:]:
msgs.append({"role": h["role"], "content": h["content"]})
msgs.append({"role": "user", "content": user_msg})
try:
resp, _ = await asyncio.wait_for(
llm_engine.complete(msgs, model_tier="fast", temperature=0.62 if is_first_turn else 0.75,
max_tokens=200, use_cache=False),
timeout=20.0
)
if anti_robot_filter:
resp = anti_robot_filter.process(resp, "amigable")
resp = (resp or "").strip()
if is_first_turn or looks_fragmented_reply(resp):
resp_low = resp.lower()
bad_start = (
resp_low.startswith("hola")
or resp_low.startswith("entiendo")
or resp_low.startswith("claro")
or looks_fragmented_reply(resp)
)
if bad_start:
rewrite_msgs = msgs + [{
"role": "system",
"content": (
"Reescribe esa respuesta. "
"No abras con hola, no abras con entiendo, no valides vacío, "
"no dejes la frase colgando. "
"Ve directo al caso y termina natural."
),
}]
retry, _ = await asyncio.wait_for(
llm_engine.complete(
rewrite_msgs,
model_tier="fast",
temperature=0.35,
max_tokens=120,
use_cache=False,
),
timeout=12.0
)
if anti_robot_filter:
retry = anti_robot_filter.process(retry, "amigable")
resp = (retry or resp).strip()
if is_first_turn:
resp = _normalize_first_contact_response(
response=resp,
clinic=clinic,
user_msg=user_msg,
)
return resp
except Exception as e:
log.warning(f"[simulator] Conny response error: {e}")
return ""
def _question_signature(self, text: str) -> str:
norm = _normalize_conv_text(text)
if not norm:
return ""
segments = [seg.strip() for seg in re.split(r"\|\|\||[.!?]", norm) if seg.strip()]
stop = {
"hola", "buenas", "claro", "perfecto", "vale", "listo", "te", "me",
"un", "una", "por", "para", "del", "con", "eso", "esto", "qué", "que",
"cómo", "como", "cuál", "cual", "dónde", "donde", "cuándo", "cuando",
}
for seg in segments:
if "?" not in text and not any(q in seg for q in ["que ", "como ", "cuando ", "cual ", "cuanto ", "donde "]):
continue
words = [w for w in seg.split() if len(w) > 2 and w not in stop]
if not words:
continue
return " ".join(words[:5])
return ""
def _fallback_client_response(
self,
conny_msg: str,
persona: str,
sector: str,
scenario: Optional[Dict[str, Any]] = None,
) -> str:
msg = _normalize_conv_text(conny_msg)
scenario = scenario or {}
opening = (scenario.get("opening") or "").lower()
if "precio" in msg or "cuanto" in msg or "vale" in msg:
return "quiero tener una idea del precio antes de decidir"
if any(w in msg for w in ["miedo", "preocupa", "quedar", "resultado"]):
if "miedo" in opening or "quedo rara" in opening:
return "me preocupa quedar tiesa o que se me note demasiado"
return "me da miedo que se vea muy artificial"
if any(w in msg for w in ["cuando", "hora", "disponibilidad", "podrias venir", "venir"]):
return "me sirve esta semana en la tarde"
if any(w in msg for w in ["nombre", "como te llamas"]):
return "me llamo Laura"
if any(w in msg for w in ["edad", "cuantos anos", "cuantos anos tienes"]):
return "tengo 35 años"
if any(w in msg for w in ["ciudad", "zona", "donde estas"]):
return "estoy en Medellín"
if sector == "estetica":
return "quiero saber si eso me sirve y cómo sería la valoración"
if sector == "dental":
return "sí me interesa, sobre todo saber si me pueden ver rápido"
return "sí, cuéntame un poco más"
async def _simulate_client_response(self, conny_msg: str, history: List[Dict],
persona: str, sector: str,
scenario: Optional[Dict[str, Any]] = None) -> str:
"""El LLM simula la respuesta del cliente según su persona."""
if not llm_engine:
return self._fallback_client_response(conny_msg, persona, sector, scenario)
conv_text = "\n".join(
f"{'Cliente' if h['role']=='user' else 'Conny'}: {h['content'][-80:]}"
for h in history[-6:]
)
prompt = f"""Simula la respuesta de este cliente a Conny.
PERFIL DEL CLIENTE: {persona}
CONVERSACIÓN RECIENTE:
{conv_text}
Conny: {conny_msg}
Escribe SOLO lo que respondería el cliente — natural, corto (1-2 oraciones), en su estilo.
No respondas solo "sí", "ok", "pues" o una palabra suelta salvo que sea inevitable.
Si Conny hizo una pregunta concreta, responde con una frase completa.
Si ya quedó satisfecho o decidió agendar, responde "CONVERSACION_COMPLETA".
Si se fue sin interés, responde "CLIENTE_SE_FUE"."""
try:
resp, _ = await asyncio.wait_for(
llm_engine.complete(
[{"role": "user", "content": prompt}],
model_tier="lite", temperature=0.62, max_tokens=100, use_cache=False
),
timeout=15.0
)
resp = resp.strip()
if resp in ("CONVERSACION_COMPLETA", "CLIENTE_SE_FUE"):
return ""
if len(resp.split()) <= 1 or looks_fragmented_reply(resp):
retry_prompt = prompt + "\nDevuelve una frase completa. No cortes la idea."
retry, _ = await asyncio.wait_for(
llm_engine.complete(
[{"role": "user", "content": retry_prompt}],
model_tier="lite", temperature=0.45, max_tokens=100, use_cache=False
),
timeout=10.0
)
retry = (retry or "").strip()
if retry in ("CONVERSACION_COMPLETA", "CLIENTE_SE_FUE"):
return ""
if retry:
resp = retry
if len(resp.split()) <= 2 or looks_fragmented_reply(resp):
return self._fallback_client_response(conny_msg, persona, sector, scenario)
return resp
except Exception:
return self._fallback_client_response(conny_msg, persona, sector, scenario)
def _validate_conny_response(self, response: str, user_msg: str,
history: List[Dict], scenario: Dict) -> List[str]:
"""Valida una respuesta de Conny contra las reglas del escenario."""
failures = []
resp_lower = response.lower()
# Señales de fallo del escenario
for signal in scenario.get("fail_signals", []):
if signal.lower() in resp_lower:
failures.append(f"Señal de fallo detectada: '{signal}'")
# Frases de bot globales
bot_phrases = [
"con mucho gusto", "encantada de ayudarte", "fue un placer",
"es un placer", "con todo gusto", "soy una inteligencia artificial",
"como asistente", "mis limitaciones", "no tengo acceso"
]
for phrase in bot_phrases:
if phrase in resp_lower:
failures.append(f"Frase de bot detectada: '{phrase}'")
break
# Respuesta vacía o demasiado corta
if len(response.strip()) < 5:
failures.append("Respuesta demasiado corta o vacía")
# Respuesta demasiado larga
words = len(response.split())
if words > 80:
failures.append(f"Respuesta muy larga: {words} palabras (máximo ~30)")
if looks_fragmented_reply(response):
failures.append("Respuesta quedó cortada o incompleta")
# Pregunta duplicada — detectar si pregunta algo que el cliente ya dijo
redundant = detect_redundant_question(user_msg, response, history=history)
if redundant:
failures.append(f"Pregunta fuera de contexto o repetida: {redundant}")
# Múltiples signos de exclamación
if resp_lower.count("!") > 2:
failures.append("Demasiados signos de exclamación (suena bot)")
# ¡ o ¿ al inicio
if response.startswith("¡") or response.startswith("¿"):
failures.append("Signo de apertura ¡/¿ al inicio (informal no los usa)")
return failures
def _detect_loop(self, response: str, history: List[Dict]) -> bool:
"""Detecta si Conny está en un bucle (repite la misma pregunta)."""
if len(history) < 4:
return False
current_sig = self._question_signature(response)
if not current_sig:
return False
prev_conny = [h["content"] for h in history if h["role"] == "assistant"][-3:]
previous_signatures = [self._question_signature(prev) for prev in prev_conny if self._question_signature(prev)]
if len(previous_signatures) < 2:
return False
matches = sum(1 for sig in previous_signatures if sig == current_sig)
if matches >= 2 and len(current_sig.split()) >= 2:
return True
return False
def _build_mock_clinic(self, sector: str) -> Dict:
"""Construye una clínica de prueba para el escenario."""
sector_clinics = {
"estetica": {
"name": "Clínica Bella Vista",
"sector": "estetica",
"services": ["Botox", "Rellenos", "Láser CO2", "Peeling", "Mesoterapia"],
"schedule": {"Lunes a Viernes": "9am-6pm", "Sábados": "9am-2pm"},
"address": "Calle 10 #43-20, El Poblado, Medellín",
"phone": "3001234567",
"pricing": {"Botox": "400.000 - 800.000", "Rellenos": "600.000 - 1.200.000"},
"setup_done": 1,
},
"dental": {
"name": "Centro Dental Sonrisa",
"sector": "dental",
"services": ["Limpieza", "Blanqueamiento", "Ortodoncia", "Implantes"],
"schedule": {"Lunes a Viernes": "8am-6pm", "Sábados": "9am-1pm"},
"phone": "3007654321",
"setup_done": 1,
},
"restaurante": {
"name": "Restaurante El Fogón",
"sector": "restaurante",
"services": ["Reservas", "Eventos", "Menú del día", "Catering"],
"schedule": {"Martes a Domingo": "12pm-10pm"},
"phone": "3009876543",
"setup_done": 1,
},
"gimnasio": {
"name": "GymPower Fitness",
"sector": "gimnasio",
"services": ["Membresía mensual", "Clases grupales", "Personal trainer"],
"schedule": {"Lunes a Viernes": "5am-10pm", "Sábados": "6am-8pm"},
"pricing": {"Mensual": "120.000", "Trimestral": "320.000"},
"setup_done": 1,
},
"medico": {
"name": "Consultorio Médico Salud Total",
"sector": "medico",
"services": ["Medicina general", "Urgencias", "Certificados"],
"schedule": {"Lunes a Viernes": "8am-6pm"},
"phone": "3001112222",
"setup_done": 1,
},
}
return sector_clinics.get(sector, sector_clinics["estetica"])
# ═══════════════════════════════════════════════════════════════════════════════
# 2. HALLUCINATION GUARD
# Detecta cuando Conny está a punto de inventar información que no tiene.
# Cruza la respuesta contra KB, config de clínica y señales lingüísticas.
# ═══════════════════════════════════════════════════════════════════════════════
class HallucinationGuard:
"""
Bloquea respuestas donde Conny inventa datos que no tiene.
Tipos de alucinación detectados:
- PRICE_INVENTED: Conny da precio que no está en la config
- DATE_INVENTED: Conny confirma disponibilidad que no conoce
- DOCTOR_INVENTED: Conny menciona un médico con nombre específico sin tenerlo
- POLICY_INVENTED: Conny describe una política que no está en KB
- HOURS_INVENTED: Conny da horario diferente al configurado
- CONTACT_INVENTED: Conny da teléfono/WhatsApp diferente al configurado
Cada tipo tiene su reemplazo seguro para no romper el flujo.
"""
# Patrones que indican que Conny está dando un dato específico
PRICE_PATTERNS = [
r'\$\s*[\d.,]+', # $350.000
r'[\d.,]+\s*(pesos?|mil|millones?)', # 350 mil pesos
r'(cuesta|vale|precio de|valor de)\s+[\d.,]+',
r'(desde|a partir de)\s+\$?\s*[\d.,]+(?:\s*(pesos?|mil|millones?))?',
]
DATE_PATTERNS = [
r'(tenemos|hay|queda)\s+(espacio|cupo|disponibilidad)\s+(el|los|para el)\s+\w+',
r'(lunes|martes|miércoles|jueves|viernes|sábado)\s+(a las|en la|por la)',
r'(hoy|mañana|pasado)\s+(a las|tenemos)',
]
DOCTOR_PATTERNS = [
r'(doctor|doctora|dra?|médico)\s+[A-ZÁÉÍÓÚ][a-záéíóú]+', # Dr. Nombre
r'(la|el)\s+(dra?|doctor|médico)\s+[A-ZÁÉÍÓÚ]',
]
HOURS_PATTERNS = [
r'(abrimos|atendemos|estamos)\s+de\s+\d{1,2}',
r'horario\s+(es|son)\s+de\s+\d{1,2}',
r'\d{1,2}\s*(am|pm|a\.m|p\.m)\s+(a|hasta)\s+\d{1,2}',
]
def __init__(self):
self._price_re = [re.compile(p, re.IGNORECASE) for p in self.PRICE_PATTERNS]
self._date_re = [re.compile(p, re.IGNORECASE) for p in self.DATE_PATTERNS]
self._doctor_re = [re.compile(p, re.IGNORECASE) for p in self.DOCTOR_PATTERNS]
self._hours_re = [re.compile(p, re.IGNORECASE) for p in self.HOURS_PATTERNS]
def check(self, response: str, clinic: Dict, kb_context: str = "") -> Tuple[bool, str, str]:
"""
Verifica si la respuesta contiene alucinaciones.
Retorna: (tiene_alucinacion, tipo, respuesta_segura)
"""
# 1. Verificar precios inventados
halluc, safe = self._check_prices(response, clinic, kb_context)
if halluc:
return True, "PRICE_INVENTED", safe
# 2. Verificar disponibilidad inventada
halluc, safe = self._check_dates(response, clinic)
if halluc:
return True, "DATE_INVENTED", safe
# 3. Verificar doctora con nombre inventado
halluc, safe = self._check_doctors(response, clinic, kb_context)
if halluc:
return True, "DOCTOR_INVENTED", safe
# 4. Verificar horarios inconsistentes
halluc, safe = self._check_hours(response, clinic)
if halluc:
return True, "HOURS_INVENTED", safe
return False, "", response
def _check_prices(self, response: str, clinic: Dict, kb_context: str) -> Tuple[bool, str]:
"""Detecta si Conny da precios que no tiene configurados."""
pricing = clinic.get("pricing", {})
if isinstance(pricing, str):
try:
pricing = json.loads(pricing)
except Exception:
pricing = {}
# Si tiene precios configurados → no alucinará (los tiene de verdad)
if pricing and len(pricing) > 0:
return False, response
# Si tiene KB con precios → tampoco alucinará
if kb_context and any(w in kb_context.lower() for w in ["precio", "valor", "costo", "$"]):
return False, response
response_low = (response or "").lower()
if re.search(r'\b\d+\s*(?:a|y|-)\s*\d+\s*(dias|días|semanas|meses|anos|años|minutos)\b', response_low):
return False, response
# No tiene precios pero los está dando → alucinación
for pattern in self._price_re:
if pattern.search(response):
# Reemplazar con respuesta honesta
safe = self._safe_price_response(response)
log.warning(f"[hallucination] precio inventado detectado: '{response[:80]}'")
return True, safe
return False, response
def _safe_price_response(self, original: str) -> str:
"""Genera respuesta segura cuando no hay precio configurado."""
alternatives = [
"ese precio depende del caso ||| te lo confirmo cuando te vea la especialista",
"no tengo ese dato exacto ahorita ||| en la valoración te dan el número para tu caso",
"los precios varían según el caso ||| en la valoración te dan el número exacto",
]
return random.choice(alternatives)
def _check_dates(self, response: str, clinic: Dict) -> Tuple[bool, str]:
"""Detecta si Conny confirma fechas/disponibilidad sin tener el calendario."""
# Si hay calendario configurado → puede dar fechas
from_db = False
try:
if db:
gcal = db.recall("whatsapp_connected")
calendly = db.recall("calendly_link")
from_db = bool(gcal or calendly)
except Exception:
pass
has_calendar = (
from_db or
bool(Config.GCAL_REFRESH_TOKEN) or
bool(Config.CALENDLY_LINK) or
bool(clinic.get("calendly_link"))
)
if has_calendar:
return False, response # tiene calendario real
# Sin calendario — detectar si está confirmando disponibilidad específica
for pattern in self._date_re:
if pattern.search(response):
# Solo es alucinación si confirma ("hay espacio el jueves") no si propone
# Diferenciar: "esta semana tienes el jueves" es propuesta, no confirmación
if any(w in response.lower() for w in ["confirmado", "agendado", "reservado",
"hay espacio para", "tenemos espacio el"]):
safe = "déjame verificar disponibilidad ||| te confirmo en un momento"
log.warning(f"[hallucination] disponibilidad inventada: '{response[:80]}'")
return True, safe
return False, response
def _check_doctors(self, response: str, clinic: Dict, kb_context: str) -> Tuple[bool, str]:
"""Detecta si Conny inventa nombre de médico que no conoce."""
# Si tiene nombre de doctor en KB o config → OK
if kb_context:
# Extraer nombres propios del KB
names_in_kb = re.findall(r'\b(Dr\.|Dra\.|doctor|doctora)\s+[A-ZÁÉÍÓÚ]\w+', kb_context)
if names_in_kb:
return False, response
# Buscar nombres de doctor en la respuesta
for pattern in self._doctor_re:
match = pattern.search(response)
if match:
# Verificar si el nombre mencionado está en algún dato conocido
full_match = match.group(0)
found_in_kb = kb_context and full_match.lower() in kb_context.lower()
found_in_mem = False
try:
if db:
mem = db.get_core_memory_block()
found_in_mem = mem and full_match.lower() in mem.lower()
except Exception:
pass
if not found_in_kb and not found_in_mem:
# Nombre de doctor no encontrado en datos → posible alucinación
# Solo marcar si es un nombre muy específico (no genérico "la doctora")
name_part = re.search(r'[A-ZÁÉÍÓÚ][a-záéíóú]+', full_match)
if name_part and len(name_part.group(0)) > 3:
safe = response.replace(full_match, "la especialista")
log.warning(f"[hallucination] doctor inventado: '{full_match}'")
return True, safe
return False, response
def _check_hours(self, response: str, clinic: Dict) -> Tuple[bool, str]:
"""Detecta si Conny da horario diferente al configurado."""
schedule = clinic.get("schedule", {})
if not schedule:
return False, response # Sin horario configurado, no podemos validar
for pattern in self._hours_re:
match = pattern.search(response)
if match:
# Extraer horas de la respuesta
hours_in_resp = re.findall(r'\d{1,2}\s*(?:am|pm|a\.m\.|p\.m\.)', response.lower())
if not hours_in_resp:
continue
# Verificar contra horario configurado
sched_text = " ".join(str(v) for v in schedule.values()).lower()
for h in hours_in_resp:
if h not in sched_text:
# Hora no encontrada en config → potencial error
# Solo loguear como warning, no bloquear
log.debug(f"[hallucination] hora '{h}' no en config: '{sched_text[:50]}'")
return False, response
# ═══════════════════════════════════════════════════════════════════════════════
# 3. FAILURE PREDICTOR ENGINE
# Predice fallos ANTES de que ocurran, basándose en patrones de conversación.
# Actúa proactivamente — no corrige errores, los previene.
# ═══════════════════════════════════════════════════════════════════════════════
class FailurePredictorEngine:
"""
Predice en qué punto va a fallar una conversación y actúa antes.
Fallos que predice:
- CONTEXT_OVERFLOW: Historial muy largo → el LLM empieza a olvidar
- REPETITION_SPIRAL: Conny hace la misma pregunta 2+ veces
- LOST_THREAD: El LLM perdió el hilo del servicio original
- OBJECTION_IGNORED: Hay una objeción no resuelta hace 3+ turnos
- ESCALATION_NEEDED: El cliente necesita hablar con un humano
- FAKE_DATA_RISK: Conny está a punto de dar datos que no tiene
- EMOTIONAL_MISMATCH: El tono de Conny no calza con el estado del cliente
Cada predicción genera una instrucción correctiva para el próximo prompt.
"""
def __init__(self):
self._conversation_warnings: Dict[str, List[str]] = {} # chat_id → warnings
def predict(self, chat_id: str, user_msg: str,
history: List[Dict], clinic: Dict) -> List[str]:
"""
Analiza el estado actual y retorna lista de advertencias.
Cada advertencia es una instrucción para inyectar al próximo prompt.
"""
warnings_list: List[str] = []
# 1. Desbordamiento de contexto
if len(history) > 40:
warnings_list.append(
"ALERTA: Conversación muy larga. Prioriza cerrar hacia la cita. "
"No hagas preguntas nuevas. Solo confirma y propón fecha."
)
# 2. Espiral de repetición
repetition = self._detect_repetition_spiral(history)
if repetition:
warnings_list.append(
f"ALERTA: Estás repitiendo la pregunta '{repetition}'. "
"No la hagas de nuevo. Cambia de ángulo o propón la valoración directamente."
)
# 3. Objeción sin resolver
unresolved = self._find_unresolved_objection(history)
if unresolved:
warnings_list.append(
f"ALERTA: Hay una objeción sin resolver desde hace tiempo: '{unresolved[:60]}'. "
"Resuélvela PRIMERO antes de continuar."
)
# 4. Escalación necesaria
if self._needs_escalation(user_msg, history):
warnings_list.append(
"ALERTA: El cliente muestra señales de querer hablar con una persona real. "
"Ofrece conectarlo con el equipo: 'te paso con alguien del equipo si prefieres'"
)
# 5. Pérdida de hilo
lost = self._detect_lost_thread(user_msg, history)
if lost:
warnings_list.append(
f"ALERTA: Parece que perdiste el hilo. El cliente originalmente preguntó por '{lost}'. "
"Vuelve a ese contexto."
)
# 6. Riesgo de datos falsos
if self._fake_data_risk(user_msg, clinic):
warnings_list.append(
"ALERTA: El cliente está preguntando por datos específicos (precio, horario, doctor). "
"Si NO los tienes en la configuración, di 'te confirmo' — NUNCA inventes."
)
# 7. Desajuste emocional
mismatch = self._detect_emotional_mismatch(user_msg, history)
if mismatch:
warnings_list.append(mismatch)
# Guardar para seguimiento
if warnings_list:
self._conversation_warnings[chat_id] = warnings_list
log.info(f"[failure_predictor] {len(warnings_list)} advertencias para {chat_id}: "
f"{warnings_list[0][:60]}")
return warnings_list
def get_prompt_injection(self, chat_id: str) -> str:
"""Retorna bloque de advertencias para inyectar al prompt."""
warnings_list = self._conversation_warnings.get(chat_id, [])
if not warnings_list:
return ""
lines = ["⚠️ PREDICTOR DE FALLOS — Estas advertencias son PRIORITARIAS:"]
for w in warnings_list:
lines.append(f" {w}")
lines.append("")
# Limpiar después de usar
self._conversation_warnings.pop(chat_id, None)
return "\n".join(lines)
def _detect_repetition_spiral(self, history: List[Dict]) -> str:
"""Detecta si Conny está repitiendo la misma pregunta."""
conny_questions = []
for msg in history:
if msg["role"] == "assistant":
text = msg["content"]
# Extraer preguntas (terminar en ? o tener palabras interrogativas)
questions = re.findall(
r'[^.!|]+(?:cuándo|cómo|qué|cuánto|dónde|para qué)[^|?!.]*[?]?',
text, re.IGNORECASE
)
conny_questions.extend([q.strip()[:60] for q in questions])
if len(conny_questions) < 2:
return ""
# Buscar duplicados aproximados
for i in range(len(conny_questions)):
for j in range(i + 1, len(conny_questions)):
q1 = set(conny_questions[i].lower().split())
q2 = set(conny_questions[j].lower().split())
common = q1 & q2
if len(common) >= 3:
return conny_questions[i]
return ""
def _find_unresolved_objection(self, history: List[Dict]) -> str:
"""Detecta objeciones del cliente que Conny no ha abordado."""
OBJECTION_SIGNALS = [
"está muy caro", "es costoso", "no tengo plata", "lo voy a pensar",
"tengo miedo", "me da miedo", "quedé mal", "no me convence",
"tengo dudas", "no sé si"
]
last_objection = ""
last_objection_idx = -1
for i, msg in enumerate(history):
if msg["role"] == "user":
for signal in OBJECTION_SIGNALS:
if signal in msg["content"].lower():
last_objection = msg["content"][:80]
last_objection_idx = i
break
if last_objection_idx < 0:
return ""
# Verificar si los mensajes de Conny posteriores la abordan
conny_after = [
msg["content"] for msg in history[last_objection_idx:]
if msg["role"] == "assistant"
]
RESOLUTION_SIGNALS = [
"entiendo", "es válido", "normal que", "lo que pasa",
"valoración", "doctora", "especialista", "te cuento"
]
for conny_msg in conny_after:
if any(s in conny_msg.lower() for s in RESOLUTION_SIGNALS):
return "" # Ya fue abordada
# Nunca fue abordada → retornar la objeción
return last_objection if len(history) - last_objection_idx >= 3 else ""
def _needs_escalation(self, user_msg: str, history: List[Dict]) -> bool:
"""Detecta cuando el cliente quiere hablar con un humano."""
escalation_signals = [
"quiero hablar con una persona", "con alguien real",
"no quiero hablar con un bot", "dame un número",
"llámame", "me llaman", "necesito hablar con",
"puedo hablar con el médico", "con la doctora directamente"
]
user_lower = user_msg.lower()
return any(s in user_lower for s in escalation_signals)
def _detect_lost_thread(self, user_msg: str, history: List[Dict]) -> str:
"""Detecta si el LLM olvidó el servicio original del cliente."""
if len(history) < 6:
return ""
# Encontrar el primer servicio mencionado por el cliente
first_service = ""
service_keywords = [
"botox", "rellenos", "láser", "limpieza", "blanqueamiento",
"ortodoncia", "masaje", "membresia", "membresía", "clase", "consulta"
]
for msg in history[:4]:
if msg["role"] == "user":
for kw in service_keywords:
if kw in msg["content"].lower():
first_service = kw
break
if first_service:
break
if not first_service:
return ""
# Verificar que los últimos mensajes de Conny mencionan el servicio
recent_conny = " ".join(
msg["content"] for msg in history[-4:]
if msg["role"] == "assistant"
).lower()
if first_service not in recent_conny:
return first_service
return ""
def _fake_data_risk(self, user_msg: str, clinic: Dict) -> bool:
"""Detecta si el cliente está preguntando por datos que podrían no existir."""
data_request_signals = [
"cuánto vale", "cuánto cuesta", "qué precio", "cuánto cobran",
"a qué hora", "qué horario", "cuándo abren", "cuándo atienden",
"con qué doctor", "con qué médico", "cómo se llama"
]
user_lower = user_msg.lower()
if not any(s in user_lower for s in data_request_signals):
return False
# Verificar si tiene los datos configurados
has_pricing = bool(clinic.get("pricing") and clinic.get("pricing") != "{}")
has_schedule = bool(clinic.get("schedule") and clinic.get("schedule") != "{}")
has_doctors = False # Raramente configurado directamente
# Si pregunta por precio y no tiene → riesgo
if any(s in user_lower for s in ["cuánto vale", "precio", "cuesta"]) and not has_pricing:
return True
return False
def _detect_emotional_mismatch(self, user_msg: str, history: List[Dict]) -> str:
"""Detecta cuando el tono de Conny no corresponde al estado del cliente."""
user_lower = user_msg.lower()
# Cliente frustrado pero Conny estaba siendo muy animada
if any(w in user_lower for w in ["frustrad", "molest", "qué fastidio", "estoy enojad"]):
last_conny = next(
(msg["content"] for msg in reversed(history) if msg["role"] == "assistant"), ""
)
if any(w in last_conny.lower() for w in ["bacano", "chévere", "qué bueno", "perfecto"]):
return (
"ALERTA EMOCIONAL: El cliente está frustrado. Tu último mensaje fue muy animado. "
"Baja el tono. Valida PRIMERO: 'ay entiendo, eso es frustrante' — luego resuelve."
)
# Cliente con miedo pero Conny siendo muy directa al precio
if any(w in user_lower for w in ["miedo", "me preocupa", "tengo miedo"]):
last_conny = next(
(msg["content"] for msg in reversed(history) if msg["role"] == "assistant"), ""
)
if re.search(r'\$[\d.,]+|\d+\.000', last_conny):
return (
"ALERTA EMOCIONAL: El cliente tiene miedo y tú hablaste de precio. "
"El miedo SIEMPRE antes del dinero. Valida el miedo primero."
)
return ""
# ═══════════════════════════════════════════════════════════════════════════════
# 4. SMART CONTEXT MANAGER
# Gestiona inteligentemente la ventana de contexto.
# El problema: después de 50 mensajes el LLM "olvida" el servicio original.
# La solución: compresión selectiva que preserva lo más importante.
# ═══════════════════════════════════════════════════════════════════════════════
class SmartContextManager:
"""
Comprime el historial de conversación de forma inteligente.
Estrategia:
1. Siempre mantener los primeros 3 mensajes (contexto original)
2. Siempre mantener los últimos 10 mensajes (contexto reciente)
3. Del resto, extraer un "resumen" de hechos clave
4. El resumen se inyecta como mensaje de sistema
Hechos clave que siempre se preservan:
- Nombre del cliente
- Servicio de interés
- Objeciones expresadas
- Compromisos (fecha propuesta, etc.)
- Estado emocional dominante
"""
MAX_HISTORY_FULL = 20 # Máximo de mensajes completos sin comprimir
COMPRESSION_TARGET = 12 # Cuántos mensajes mantener después de comprimir
def __init__(self):
self._summaries: Dict[str, str] = {} # chat_id → resumen comprimido
def prepare_context(self, chat_id: str, history: List[Dict],
max_messages: int = 20) -> Tuple[List[Dict], str]:
"""
Prepara el contexto para el LLM.
Retorna: (historial_optimizado, bloque_resumen)
"""
if len(history) <= max_messages:
return history, ""
# Dividir: head (primeros 3), middle (para comprimir), tail (últimos 10)
head = history[:3]
tail = history[-10:]
middle = history[3:-10]
if not middle:
return history[-max_messages:], ""
# Extraer hechos clave del middle
facts = self._extract_key_facts(middle)
summary = self._build_summary(facts, chat_id)
# Guardar resumen para reutilizar
self._summaries[chat_id] = summary
# Historia optimizada: head + tail
optimized = head + tail
return optimized, summary
def _extract_key_facts(self, messages: List[Dict]) -> Dict[str, Any]:
"""Extrae hechos clave del historial que se está comprimiendo."""
facts: Dict[str, Any] = {
"name": "",
"service": "",
"objections": [],
"commitments": [],
"emotions": [],
}
for msg in messages:
content = msg["content"]
role = msg["role"]
if role == "user":
# Extraer nombre (si lo dijo)
name_match = re.search(
r'(?:me llamo|soy|mi nombre es)\s+([A-ZÁÉÍÓÚ][a-záéíóú]+)',
content, re.IGNORECASE
)
if name_match and not facts["name"]:
facts["name"] = name_match.group(1)
# Extraer servicio
services_kw = ["botox", "rellenos", "láser", "limpieza", "blanqueamiento",
"ortodoncia", "masaje", "membresía", "clases", "consulta",
"tratamiento", "implante", "peeling", "mesoterapia"]
for kw in services_kw:
if kw in content.lower() and not facts["service"]:
facts["service"] = kw
break
# Extraer objeciones
objections_kw = ["está caro", "tengo miedo", "lo voy a pensar",
"quedé mal", "no tengo tiempo", "lo consulto"]
for kw in objections_kw:
if kw in content.lower() and kw not in facts["objections"]:
facts["objections"].append(kw)
elif role == "assistant":
# Extraer compromisos (fechas propuestas)
date_match = re.search(
r'(el\s+(?:lunes|martes|miércoles|jueves|viernes|sábado))',
content, re.IGNORECASE
)
if date_match:
day = date_match.group(1)
if day not in facts["commitments"]:
facts["commitments"].append(day)
return facts
def _build_summary(self, facts: Dict, chat_id: str) -> str:
"""Construye el bloque de resumen para inyectar al prompt."""
lines = ["RESUMEN DE LA CONVERSACIÓN ANTERIOR (no lo menciones, solo úsalo):"]
if facts.get("name"):
lines.append(f" Nombre del cliente: {facts['name']}")
if facts.get("service"):
lines.append(f" Servicio de interés: {facts['service']}")
if facts.get("objections"):
lines.append(f" Objeciones expresadas: {', '.join(facts['objections'])}")
if facts.get("commitments"):
lines.append(f" Fechas mencionadas: {', '.join(facts['commitments'])}")
lines.append("")
return "\n".join(lines)
def get_cached_summary(self, chat_id: str) -> str:
"""Retorna el resumen guardado para este chat."""
return self._summaries.get(chat_id, "")
# ═══════════════════════════════════════════════════════════════════════════════
# 5. APPOINTMENT STATE MACHINE
# Máquina de estados completa para el proceso de agendar citas.
# Maneja ambigüedad de fechas, conflictos, confirmaciones y recordatorios.
# ═══════════════════════════════════════════════════════════════════════════════
class AppointmentStateMachine:
"""
Gestiona el proceso de agendar una cita en etapas claras.
Estados:
IDLE → EXPLORING → DATE_PROPOSED → DATE_CONFIRMED → DETAILS_COLLECTING
→ FULLY_BOOKED → REMINDER_SENT → COMPLETED | CANCELLED
Variables de fallo que maneja:
- Fecha ambigua ("mañana" sin saber qué día es)
- Fecha en pasado ("el lunes" cuando ya pasó)
- Fecha en día que no trabajan
- Hora fuera del horario
- El cliente no confirma la fecha propuesta
- El cliente propone una hora muy específica que no se puede garantizar
- El cliente cancela sin nueva fecha
"""
STATES = [
"IDLE", "EXPLORING", "DATE_PROPOSED", "DATE_CONFIRMED",
"DETAILS_COLLECTING", "FULLY_BOOKED", "REMINDER_SENT",
"COMPLETED", "CANCELLED"
]
def __init__(self):
self._states: Dict[str, str] = {} # chat_id → state
self._proposals: Dict[str, Dict] = {} # chat_id → proposed date info
self._bookings: Dict[str, Dict] = {} # chat_id → confirmed booking
def get_state(self, chat_id: str) -> str:
return self._states.get(chat_id, "IDLE")
def propose_date(self, chat_id: str, date_text: str,
service: str = "", clinic: Dict = None) -> Dict:
"""
Propone una fecha. Valida que no esté en el pasado ni en día cerrado.
Retorna {valid: bool, date_resolved: str, message: str}
"""
now = now_col()
# Resolver "mañana", "el jueves", "esta semana", etc.
resolved = self._resolve_date_text(date_text, now)
if not resolved["valid"]:
return {
"valid": False,
"date_resolved": "",
"message": resolved["reason"]
}
# Verificar que no sea pasado
if resolved["datetime"] and resolved["datetime"] < now:
return {
"valid": False,
"date_resolved": "",
"message": "esa fecha ya pasó — propón la siguiente disponible"
}
# Verificar horario de la clínica
if clinic:
schedule = clinic.get("schedule", {})
if schedule:
open_check = self._check_clinic_hours(resolved["datetime"], schedule)
if not open_check["open"]:
return {
"valid": False,
"date_resolved": "",
"message": f"ese día no atendemos ({open_check['reason']})"
}
# Todo OK → guardar propuesta
self._states[chat_id] = "DATE_PROPOSED"
self._proposals[chat_id] = {
"original_text": date_text,
"resolved": resolved.get("display", date_text),
"datetime": resolved.get("datetime"),
"service": service,
"proposed_at": now.isoformat(),
}
return {
"valid": True,
"date_resolved": resolved.get("display", date_text),
"message": ""
}
def confirm_date(self, chat_id: str) -> bool:
"""Confirma la fecha propuesta. Avanza al estado DETAILS_COLLECTING."""
if self._states.get(chat_id) != "DATE_PROPOSED":
return False
self._states[chat_id] = "DATE_CONFIRMED"
return True
def collect_details(self, chat_id: str, name: str = "",
phone: str = "", service: str = "") -> bool:
"""Registra detalles del cliente. Avanza a FULLY_BOOKED cuando completo."""
if self._states.get(chat_id) not in ("DATE_CONFIRMED", "DETAILS_COLLECTING"):
return False
proposal = self._proposals.get(chat_id, {})
if name: proposal["patient_name"] = name
if phone: proposal["patient_phone"] = phone
if service: proposal["service"] = service
self._proposals[chat_id] = proposal
self._states[chat_id] = "DETAILS_COLLECTING"
# Verificar si ya tenemos todo
has_name = bool(proposal.get("patient_name"))
has_service = bool(proposal.get("service"))
has_date = bool(proposal.get("resolved"))
if has_name and has_service and has_date:
self._states[chat_id] = "FULLY_BOOKED"
self._bookings[chat_id] = dict(proposal)
return True
return False
def cancel(self, chat_id: str, reason: str = "") -> bool:
"""Cancela la cita. Guarda el motivo."""
if chat_id in self._proposals:
self._proposals[chat_id]["cancelled_reason"] = reason
self._states[chat_id] = "CANCELLED"
return True
def get_missing_details(self, chat_id: str) -> List[str]:
"""Retorna qué datos faltan para completar la reserva."""
proposal = self._proposals.get(chat_id, {})
missing = []
if not proposal.get("patient_name"): missing.append("nombre")
if not proposal.get("service"): missing.append("servicio")
if not proposal.get("patient_phone"): missing.append("teléfono")
return missing
def get_booking_summary(self, chat_id: str) -> str:
"""Retorna resumen de la cita para confirmar con el cliente."""
booking = self._bookings.get(chat_id) or self._proposals.get(chat_id, {})
if not booking:
return ""
parts = []
if booking.get("patient_name"):
parts.append(f"Nombre: {booking['patient_name']}")
if booking.get("service"):
parts.append(f"Servicio: {booking['service']}")
if booking.get("resolved"):
parts.append(f"Fecha: {booking['resolved']}")
if booking.get("patient_phone"):
parts.append(f"Teléfono: {booking['patient_phone']}")
return "\n".join(parts) if parts else ""
def _resolve_date_text(self, text: str, now: datetime) -> Dict:
"""
Convierte texto de fecha a datetime.
Maneja: "mañana", "el jueves", "esta semana", "próxima semana", etc.
"""
text_lower = text.lower().strip()
# Días de la semana
weekdays = {
"lunes": 0, "martes": 1, "miércoles": 2, "miercoles": 2,
"jueves": 3, "viernes": 4, "sábado": 5, "sabado": 5, "domingo": 6
}
if text_lower in ("hoy", "today"):
return {
"valid": True,
"datetime": now,
"display": f"hoy {now.strftime('%d/%m')}",
}
if text_lower in ("mañana", "manana", "tomorrow"):
tomorrow = now + timedelta(days=1)
return {
"valid": True,
"datetime": tomorrow,
"display": f"mañana {tomorrow.strftime('%A %d/%m')}",
}
# "el jueves" "este jueves" "próximo jueves"
for day_name, day_num in weekdays.items():
if day_name in text_lower:
# Calcular el próximo occurrence de ese día
days_ahead = (day_num - now.weekday()) % 7
if days_ahead == 0:
days_ahead = 7 # Si es hoy, ir al siguiente
target = now + timedelta(days=days_ahead)
is_next_week = "próximo" in text_lower or "proxima" in text_lower
if is_next_week:
target += timedelta(days=7)
return {
"valid": True,
"datetime": target,
"display": f"{day_name} {target.strftime('%d/%m')}",
}
# Si no resolvió → válido pero sin datetime exacto
return {
"valid": True,
"datetime": None,
"display": text,
}
def _check_clinic_hours(self, dt: datetime, schedule: Dict) -> Dict:
"""Verifica si la clínica atiende en esa fecha/hora."""
if not dt or not schedule:
return {"open": True, "reason": ""}
day_name = dt.strftime("%A").lower()
# Mapear inglés a español
day_map = {
"monday": "lunes", "tuesday": "martes", "wednesday": "miércoles",
"thursday": "jueves", "friday": "viernes",
"saturday": "sábado", "sunday": "domingo"
}
day_es = day_map.get(day_name, day_name)
sched_text = " ".join(str(v) for v in schedule.values()).lower()
if "domingo" not in sched_text and day_es == "domingo":
return {"open": False, "reason": "no atendemos domingos"}
return {"open": True, "reason": ""}
# ═══════════════════════════════════════════════════════════════════════════════
# 6. CONVERSATION RECOVERY ENGINE
# Detecta conversaciones atascadas y aplica estrategias de recuperación.
# Una conversación está "atascada" cuando: el cliente da respuestas de 1 palabra,
# el cliente no responde a la pregunta, o hay 3+ intercambios sin avance.
# ═══════════════════════════════════════════════════════════════════════════════
class ConversationRecoveryEngine:
"""
Detecta y recupera conversaciones atascadas.
Tipos de atasco:
- MONOSYLLABIC: El cliente responde con "sí", "ok", "bueno" repetidamente
- EVASIVE: El cliente desvía cada pregunta sin responder
- PRICE_STUCK: La conversación lleva 3+ turnos girando en torno al precio
- FEAR_STUCK: El cliente mencionó miedo pero nunca fue abordado bien
- SILENT: Más de 24h sin respuesta (se combina con ProactiveCampaign)
- GHOST_RETURN: El cliente vuelve después de mucho tiempo sin contexto
Cada tipo tiene una estrategia de recuperación específica.
"""
def __init__(self):
self._stuck_counts: Dict[str, int] = {} # chat_id → consecutive stuck turns
def analyze(self, chat_id: str, user_msg: str,
history: List[Dict]) -> Optional[str]:
"""
Analiza si la conversación está atascada.
Retorna instrucción de recuperación o None si no hay problema.
"""
if not history or len(history) < 4:
return None
# 1. Respuestas monosilábicas repetidas
mono_count = self._count_monosyllabic(history[-6:])
if mono_count >= 3:
return self._recovery_monosyllabic()
# 2. Precio dominando la conversación
price_count = self._count_price_mentions(history[-8:])
if price_count >= 4:
return self._recovery_price_stuck()
# 3. Miedo no resuelto
fear_unresolved = self._detect_unresolved_fear(history)
if fear_unresolved:
return self._recovery_fear_stuck()
# 4. Sin avance después de N turnos
if len(history) > 12 and not self._has_commitment_signal(history):
progress = self._measure_progress(history[-10:])
if progress < 0.2:
self._stuck_counts[chat_id] = self._stuck_counts.get(chat_id, 0) + 1
if self._stuck_counts[chat_id] >= 2:
self._stuck_counts[chat_id] = 0
return self._recovery_no_progress()
else:
self._stuck_counts[chat_id] = 0
return None
def get_recovery_prompt_injection(self, chat_id: str, user_msg: str,
history: List[Dict]) -> str:
"""Retorna instrucción de recuperación para inyectar al prompt."""
recovery = self.analyze(chat_id, user_msg, history)
if not recovery:
return ""
return f"\n🔄 ESTRATEGIA DE RECUPERACIÓN:\n{recovery}\n"
def _count_monosyllabic(self, recent: List[Dict]) -> int:
"""Cuenta cuántos mensajes del cliente son monosilábicos."""
MONO_WORDS = {"sí", "si", "ok", "bueno", "bien", "dale", "claro",
"no", "tal vez", "quizás", "talvez", "mm", "ah", "oh"}
count = 0
for msg in recent:
if msg["role"] == "user":
words = msg["content"].lower().strip().split()
if len(words) <= 2 and all(w in MONO_WORDS for w in words):
count += 1
return count
def _count_price_mentions(self, recent: List[Dict]) -> int:
"""Cuenta cuántas veces apareció el precio en la conversación."""
price_signals = ["caro", "precio", "valor", "cuesta", "vale",
"costoso", "presupuesto", "descuento"]
count = 0
for msg in recent:
for signal in price_signals:
if signal in msg["content"].lower():
count += 1
break
return count
def _detect_unresolved_fear(self, history: List[Dict]) -> bool:
"""Detecta miedo no resuelto."""
fear_signals = ["miedo", "me da miedo", "tengo miedo", "me preocupa que quede"]
resolution_signals = ["es normal", "normal que", "la doctora", "valoración", "seguro"]
fear_turn = -1
for i, msg in enumerate(history):
if msg["role"] == "user":
for s in fear_signals:
if s in msg["content"].lower():
fear_turn = i
break
if fear_turn < 0:
return False
# Verificar si fue resuelto en mensajes posteriores
for msg in history[fear_turn:]:
if msg["role"] == "assistant":
for r in resolution_signals:
if r in msg["content"].lower():
return False
return len(history) - fear_turn >= 4 # Solo si pasaron 4+ turnos sin resolver
def _measure_progress(self, recent: List[Dict]) -> float:
"""Mide qué tan cerca está la conversación del objetivo (0-1)."""
progress_signals = [
"valoración", "cita", "agend", "cuándo puedes", "esta semana",
"el jueves", "te reservo", "confirmado", "nombre"
]
progress = 0.0
for msg in recent:
if msg["role"] == "assistant":
for s in progress_signals:
if s in msg["content"].lower():
progress += 0.2
break
return min(1.0, progress)
def _has_commitment_signal(self, history: List[Dict]) -> bool:
"""Detecta si hay alguna señal de compromiso en el historial."""
signals = ["agendado", "confirmado", "te espero", "quedó", "cita el"]
for msg in history:
if msg["role"] == "assistant":
for s in signals:
if s in msg["content"].lower():
return True
return False
def _recovery_monosyllabic(self) -> str:
options = [
"El cliente está respondiendo con monosílabos — no está enganchado. "
"Haz UNA pregunta que lo obligue a pensar: '¿qué fue lo que te hizo escribirnos hoy?' "
"O propón directamente la valoración sin esperar más.",
"Respuestas muy cortas — el cliente perdió interés o está ocupado. "
"Sé directo: propón un solo día y hora y pregunta si puede.",
]
return random.choice(options)
def _recovery_price_stuck(self) -> str:
return (
"La conversación lleva varios turnos en el precio. "
"CAMBIA EL ÁNGULO: deja el precio y ve al resultado. "
"'el precio exacto te lo da la doctora en la valoración, que es gratis — "
"lo que sí te puedo decir es que el resultado que buscas lo logran acá'. "
"Luego propón el día."
)
def _recovery_fear_stuck(self) -> str:
return (
"Hay un miedo no resuelto que está bloqueando la conversación. "
"ANTES de cualquier otra cosa: valida el miedo de forma específica. "
"'ese miedo de quedar exagerada es exactamente lo que más les preocupa a todas las que vienen — "
"y es exactamente lo que la doctora trabaja diferente acá'. "
"Luego transfiere la decisión al especialista."
)
def _recovery_no_progress(self) -> str:
options = [
"La conversación no está avanzando. Momento de ser más directo: "
"propón UN día específico con hora aproximada y espera su confirmación. "
"No hagas más preguntas — da la información y propón el siguiente paso.",
"Demasiados turnos sin avance. Cambia la estrategia: "
"resumen de lo que sabe y propuesta concreta de fecha. Una sola pregunta: ¿sí o no?",
]
return random.choice(options)
# ═══════════════════════════════════════════════════════════════════════════════
# 7. RESPONSE VARIATION ENGINE
# Garantiza que Conny nunca repita exactamente la misma frase en una conv.
# Usa hashing para detectar repeticiones y fuerza variación.
# ═══════════════════════════════════════════════════════════════════════════════
class ResponseVariationEngine:
"""
Evita que Conny repita frases exactas en la misma conversación.
Problema real: el LLM tiende a reutilizar las mismas estructuras de frase
(especialmente cierres) en cada turno. Después de 5-6 mensajes todo
suena igual.
Solución: hash de frases usadas por chat_id + instrucción de variación.
"""
def __init__(self):
# chat_id → set de hashes de frases usadas
self._used_phrases: Dict[str, Set[str]] = {}
self._phrase_counts: Dict[str, Dict[str, int]] = {}
def register(self, chat_id: str, response: str):
"""Registra las frases de una respuesta."""
if chat_id not in self._used_phrases:
self._used_phrases[chat_id] = set()
self._phrase_counts[chat_id] = {}
# Extraer frases significativas (6+ palabras)
sentences = re.split(r'(?:\|\|\||[.!?])+', response)
for sentence in sentences:
sentence = sentence.strip()
if len(sentence.split()) >= 4:
phrase_hash = hashlib.md5(sentence.lower().encode()).hexdigest()[:8]
self._used_phrases[chat_id].add(phrase_hash)
# Contar repeticiones para detección
full_hash = hashlib.md5(sentence.lower().encode()).hexdigest()
self._phrase_counts[chat_id][full_hash] = \
self._phrase_counts[chat_id].get(full_hash, 0) + 1
def check_repetition(self, chat_id: str, response: str) -> Tuple[bool, List[str]]:
"""
Verifica si la respuesta contiene frases ya usadas.
Retorna: (tiene_repeticiones, frases_repetidas)
"""
if chat_id not in self._used_phrases:
return False, []
repeated = []
sentences = re.split(r'(?:\|\|\||[.!?])+', response)
for sentence in sentences:
sentence = sentence.strip()
if len(sentence.split()) >= 4:
phrase_hash = hashlib.md5(sentence.lower().encode()).hexdigest()[:8]
if phrase_hash in self._used_phrases[chat_id]:
repeated.append(sentence[:50])
return bool(repeated), repeated
def get_variation_injection(self, chat_id: str, response: str) -> str:
"""
Si detecta repetición, retorna instrucción de variación para el retry.
"""
has_rep, phrases = self.check_repetition(chat_id, response)
if not has_rep:
return ""
lines = [
"⚠️ VARIACIÓN REQUERIDA:",
f"Ya usaste estas frases antes: {', '.join(phrases[:2])}",
"Exprésalo de forma completamente diferente.",
"Si vas a proponer la valoración → usa una formulación nueva.",
"Si vas a preguntar → pregunta algo diferente a lo que ya preguntaste.",
]
return "\n".join(lines)
def get_diversity_score(self, chat_id: str) -> float:
"""Calcula qué tan diversas son las respuestas (0=monótona, 1=diversa)."""
counts = self._phrase_counts.get(chat_id, {})
if not counts:
return 1.0
total_phrases = sum(counts.values())
repeated = sum(1 for c in counts.values() if c > 1)
return 1.0 - (repeated / max(total_phrases, 1))
# ═══════════════════════════════════════════════════════════════════════════════
# 8. PROACTIVE CAMPAIGN ENGINE
# Campañas de seguimiento, reactivación y recordatorio.
# Basado en el TaskManager existente pero con lógica de campaña inteligente.
# ═══════════════════════════════════════════════════════════════════════════════
class ProactiveCampaignEngine:
"""
Gestiona campañas proactivas de seguimiento.
Campañas disponibles:
- WARM_FOLLOWUP: 24h después de conversación sin cita
- HOT_NUDGE: 6h después de conversación con lead caliente
- APPOINTMENT_REMINDER_24H: 24h antes de la cita
- APPOINTMENT_REMINDER_2H: 2h antes de la cita
- POST_APPOINTMENT: 3 días después de la cita (feedback)
- REACTIVATION_30D: 30 días sin respuesta
- REACTIVATION_60D: 60 días sin respuesta
- SEASONAL: Campañas por temporada (noviembre, diciembre, etc.)
"""
CAMPAIGN_TEMPLATES: Dict[str, Dict] = {
"WARM_FOLLOWUP": {
"delay_hours": 24,
"condition": "sin_cita_post_consulta",
"max_sends": 1,
"messages": [
"hola, quedé pensando en lo que me contaste ||| si tienes más preguntas aquí estoy, sin afán",
"oye, quedé pensando ||| ¿ya pudiste pensar en lo de la valoración?",
"hola de nuevo ||| quería saber si tuviste oportunidad de pensarlo",
],
},
"HOT_NUDGE": {
"delay_hours": 6,
"condition": "lead_caliente_sin_cierre",
"max_sends": 1,
"messages": [
"oye, me quedé con tu caso pendiente ||| ¿cuándo puedes venir esta semana?",
"hola ||| estaba mirando la agenda y esta semana hay buen espacio — ¿te queda el jueves?",
],
},
"APPOINTMENT_REMINDER_24H": {
"delay_hours": -24, # negativo = antes del evento
"condition": "cita_confirmada",
"max_sends": 1,
"messages": [
"hola! te recuerdo que mañana es tu cita ||| ¿todo bien para esa hora?",
"buenas, mañana te esperamos a la hora acordada ||| cualquier cambio me avisas",
],
},
"APPOINTMENT_REMINDER_2H": {
"delay_hours": -2,
"condition": "cita_confirmada",
"max_sends": 1,
"messages": [
"hola! en 2 horas te esperamos ||| llegando avísame para indicarte el acceso",
"hola, en un rato nos vemos ||| si tienes alguna duda de último momento aquí estoy",
],
},
"POST_APPOINTMENT": {
"delay_hours": 72, # 3 días después
"condition": "cita_completada",
"max_sends": 1,
"messages": [
"hola, ¿cómo te fue? ||| ya deben estar viéndose los resultados",
"oye, han pasado unos días ||| ¿cómo quedaste? ¿ya ves la diferencia?",
],
},
"REACTIVATION_30D": {
"delay_hours": 720, # 30 días
"condition": "inactivo_30d",
"max_sends": 1,
"messages": [
"hola, ¿cómo has estado? ||| hace un tiempo me escribiste y no sé si pudiste resolver lo que buscabas",
"hola! hace un tiempo hablamos ||| si sigues interesada todavía hay disponibilidad esta semana",
],
},
}
def __init__(self):
self._scheduled: Dict[str, List[Dict]] = {} # chat_id → campaña programadas
self._sent_log: Dict[str, Dict[str, int]] = {} # chat_id → {campaign_type → count}
def schedule(self, chat_id: str, campaign_type: str,
patient_name: str = "", extra_data: Dict = None):
"""Programa una campaña para un chat_id."""
if campaign_type not in self.CAMPAIGN_TEMPLATES:
log.warning(f"[campaign] tipo desconocido: {campaign_type}")
return
template = self.CAMPAIGN_TEMPLATES[campaign_type]
sent_count = self._sent_log.get(chat_id, {}).get(campaign_type, 0)
if sent_count >= template["max_sends"]:
log.debug(f"[campaign] {campaign_type} ya enviada {sent_count}x a {chat_id}")
return
delay_hours = template["delay_hours"]
if delay_hours >= 0:
scheduled_for = datetime.now() + timedelta(hours=delay_hours)
else:
# Para recordatorios, el scheduled_for viene en extra_data
apt_time = (extra_data or {}).get("appointment_datetime")
if not apt_time:
return
try:
if isinstance(apt_time, str):
apt_time = datetime.fromisoformat(apt_time)
scheduled_for = apt_time + timedelta(hours=delay_hours)
except Exception:
return
# Usar task_manager si está disponible
if task_manager:
msg = self._pick_message(campaign_type, patient_name)
task_manager.schedule_task(
task_type="reminder",
data={
"chat_id": chat_id,
"message": msg,
"campaign_type": campaign_type,
"patient_name": patient_name,
},
scheduled_for=scheduled_for,
priority=5
)
log.info(f"[campaign] programada {campaign_type} para {chat_id} at {scheduled_for}")
def cancel(self, chat_id: str, campaign_type: str = ""):
"""Cancela campañas programadas para un chat_id."""
# El task_manager no expone cancel por tipo aún — marcar como cancelado
key = f"campaign_cancelled_{chat_id}_{campaign_type}"
try:
if db:
db.remember(key, "true", "campaigns")
except Exception:
pass
def mark_sent(self, chat_id: str, campaign_type: str):
"""Registra que una campaña fue enviada."""
if chat_id not in self._sent_log:
self._sent_log[chat_id] = {}
self._sent_log[chat_id][campaign_type] = \
self._sent_log[chat_id].get(campaign_type, 0) + 1
def _pick_message(self, campaign_type: str, patient_name: str = "") -> str:
"""Elige un mensaje del template y personaliza con el nombre si hay."""
template = self.CAMPAIGN_TEMPLATES.get(campaign_type, {})
messages = template.get("messages", ["hola, ¿cómo estás?"])
msg = random.choice(messages)
if patient_name:
msg = msg.replace("hola", f"hola {patient_name.split()[0]}", 1)
return msg
def get_active_campaigns(self) -> Dict[str, int]:
"""Retorna resumen de campañas activas."""
summary: Dict[str, int] = {}
for chat_id, campaigns in self._scheduled.items():
for c in campaigns:
ctype = c.get("type", "unknown")
summary[ctype] = summary.get(ctype, 0) + 1
return summary
# ═══════════════════════════════════════════════════════════════════════════════
# 9. ADMIN INTELLIGENT BRIEFING
# Genera un briefing diario realmente útil para el admin.
# No solo estadísticas — identifica oportunidades y acciones concretas.
# ═══════════════════════════════════════════════════════════════════════════════
class AdminIntelligentBriefing:
"""
Genera briefings de gestión para el admin.
Un briefing tiene:
- Número de conversaciones nuevas, activas, sin respuesta
- Leads calientes identificados (con nombre y contexto)
- Conversaciones atascadas (que necesitan intervención)
- Citas agendadas hoy/mañana
- Oportunidades perdidas de ayer
- Una recomendación de acción prioritaria
"""
async def generate(self, clinic: Dict, period_hours: int = 24) -> str:
"""Genera el briefing del período especificado."""
if not db:
return "Base de datos no disponible"
try:
now = now_col()
cutoff = (now - timedelta(hours=period_hours)).isoformat()
# ── Métricas básicas ────────────────────────────────────────────
with db._conn() as c:
# Conversaciones nuevas en el período
new_convs = c.execute(
"SELECT COUNT(DISTINCT chat_id) FROM conversations "
"WHERE ts >= ? AND role='user'", (cutoff,)
).fetchone()[0] or 0
# Total de mensajes
total_msgs = c.execute(
"SELECT COUNT(*) FROM conversations WHERE ts >= ?", (cutoff,)
).fetchone()[0] or 0
# Citas creadas
new_apts = c.execute(
"SELECT COUNT(*) FROM appointments WHERE created_at >= ?", (cutoff,)
).fetchone()[0] or 0
# Citas pendientes para hoy y mañana
tomorrow = (now + timedelta(days=1)).strftime("%Y-%m-%d")
today_str = now.strftime("%Y-%m-%d")
upcoming_apts = c.execute(
"SELECT patient_name, service, datetime_slot, patient_phone "
"FROM appointments WHERE status='pendiente' "
"AND datetime_slot BETWEEN ? AND ? "
"ORDER BY datetime_slot LIMIT 5",
(today_str, tomorrow + " 23:59")
).fetchall()
# Conversaciones sin respuesta del admin (>12h)
cutoff_12h = (now - timedelta(hours=12)).isoformat()
stuck_convs = c.execute(
"SELECT chat_id, MAX(ts) as last_msg "
"FROM conversations WHERE role='user' AND ts <= ? "
"GROUP BY chat_id "
"HAVING last_msg = (SELECT MAX(ts) FROM conversations c2 "
"WHERE c2.chat_id = conversations.chat_id) "
"ORDER BY last_msg DESC LIMIT 5",
(cutoff_12h,)
).fetchall()
# ── Leads calientes (del ConversationIntelligence) ──────────────
hot_leads = []
if conversation_intelligence:
for cid, state in conversation_intelligence._states.items():
if state.get("commitment_score", 0) >= 0.7:
patient_name = ""
try:
with db._conn() as c:
row = c.execute("SELECT name FROM patients WHERE chat_id=?",
(cid,)).fetchone()
if row:
patient_name = row["name"] or ""
except Exception:
pass
hot_leads.append({
"chat_id": cid,
"name": patient_name or f"cliente_{cid[-4:]}",
"score": state["commitment_score"],
"stage": state.get("stage", ""),
})
hot_leads.sort(key=lambda x: x["score"], reverse=True)
# ── Usar LLM para generar recomendación ─────────────────────────
recommendation = await self._generate_recommendation(
new_convs, new_apts, len(hot_leads), len(stuck_convs or [])
)
# ── Formatear el briefing ───────────────────────────────────────
lines = [
f"📊 Briefing — últimas {period_hours}h",
f" Conversaciones nuevas: {new_convs}",
f" Mensajes totales: {total_msgs}",
f" Citas agendadas: {new_apts}",
]
if hot_leads:
lines.append(f"\n🔥 Leads calientes ({len(hot_leads)}):")
for lead in hot_leads[:3]:
score_pct = int(lead['score'] * 100)
lines.append(f" {lead['name']} — {score_pct}% listos — /chat {lead['chat_id']}")
if upcoming_apts:
lines.append(f"\n📅 Citas próximas ({len(upcoming_apts)}):")
for apt in upcoming_apts:
lines.append(f" {apt['patient_name']} · {apt['service']} · {apt['datetime_slot'][:16]}")
if stuck_convs:
lines.append(f"\n⏰ Sin respuesta (+12h): {len(stuck_convs)} conversaciones")
if recommendation:
lines.append(f"\n💡 Acción recomendada: {recommendation}")
return "\n".join(lines)
except Exception as e:
log.error(f"[briefing] error: {e}", exc_info=True)
return f"Error generando briefing: {e}"
async def _generate_recommendation(self, new_convs: int, new_apts: int,
hot_leads: int, stuck: int) -> str:
"""Genera una recomendación accionable usando el LLM."""
if not llm_engine:
return ""
prompt = f"""Eres el coach de ventas de una clínica. Basado en estos datos:
- Conversaciones nuevas hoy: {new_convs}
- Citas agendadas: {new_apts}
- Leads calientes sin cerrar: {hot_leads}
- Conversaciones atascadas: {stuck}
Da UNA recomendación de acción concreta para el dueño. Máximo 2 oraciones. Sin introducción."""
try:
resp, _ = await asyncio.wait_for(
llm_engine.complete(
[{"role": "user", "content": prompt}],
model_tier="lite", temperature=0.4, max_tokens=100
),
timeout=10.0
)
return resp.strip()
except Exception:
if hot_leads > 0:
return f"Tienes {hot_leads} lead(s) calientes. Escríbeles hoy — están listos."
elif stuck > 0:
return f"Hay {stuck} conversación(es) atascada(s). Revísalas con /chats."
return ""
# ═══════════════════════════════════════════════════════════════════════════════
# 10. SELF TEST SUITE
# Suite de 25 tests internos que verifican que Conny funciona correctamente.
# Se ejecuta al arrancar y con /test.
# ═══════════════════════════════════════════════════════════════════════════════
class SelfTestSuite:
"""
Suite de tests automáticos que verifican el correcto funcionamiento de Conny.
Categorías:
- UNIT: Tests de funciones individuales (AntiRobotFilter, etc.)
- INTEGRATION: Tests de interacción entre sistemas
- PROMPT: Tests de que el LLM genera respuestas correctas
- CONFIG: Tests de configuración y variables de entorno
Cada test es atómico, rápido y falla con mensaje claro.
"""
def __init__(self):
self._results: List[Dict] = []
async def run_all(self) -> Dict:
"""Ejecuta todos los tests y retorna reporte."""
self._results = []
start = time.time()
# ── Tests unitarios (sin LLM) ────────────────────────────────────────
self._test_anti_robot_filter()
self._test_conversation_intelligence()
self._test_smart_variety()
self._test_model_manager_catalog()
self._test_appointment_state_machine()
self._test_hallucination_guard_prices()
self._test_context_manager_compression()
self._test_failure_predictor_repetition()
self._test_response_variation_engine()
self._test_ortography_corrections()
self._test_bubble_splitter()
self._test_first_contact_intro()
self._test_language_detection()
self._test_conversion_funnel_tracking()
self._test_sector_detection()
self._test_date_resolver()
# ── Tests de integración (requieren DB) ─────────────────────────────
if db:
self._test_db_remember_recall()
self._test_db_clinic_update()
self._test_patient_upsert()
else:
self._record("DB_REMEMBER_RECALL", False, "db no disponible")
self._record("DB_CLINIC_UPDATE", False, "db no disponible")
self._record("PATIENT_UPSERT", False, "db no disponible")
# ── Tests de prompt (requieren LLM — más lentos) ─────────────────────
if llm_engine and llm_engine.providers:
await self._test_llm_basic_response()
await self._test_llm_anti_robot_response()
await self._test_llm_spanish_detection()
else:
for name in ("LLM_BASIC", "LLM_ANTI_ROBOT", "LLM_SPANISH"):
self._record(name, False, "llm_engine no disponible")
elapsed = round(time.time() - start, 2)
passed = sum(1 for r in self._results if r["passed"])
failed = sum(1 for r in self._results if not r["passed"])
return {
"total": len(self._results),
"passed": passed,
"failed": failed,
"elapsed": elapsed,
"results": self._results,
}
def format_report(self, report: Dict) -> List[str]:
"""Formatea el reporte para Telegram/WhatsApp."""
total = report["total"]
passed = report["passed"]
failed = report["failed"]
elapsed = report["elapsed"]
icon = "✅" if failed == 0 else ("⚠️" if failed <= 3 else "❌")
lines = [
f"{icon} Self-Test Suite — {passed}/{total} tests OK ({elapsed}s)",
]
if failed > 0:
lines.append("\nFallidos:")
for r in report["results"]:
if not r["passed"]:
lines.append(f" ✗ [{r['name']}] {r['message']}")
else:
lines.append(" Todos los tests pasaron.")
return ["\n".join(lines)]
# ── Tests unitarios ──────────────────────────────────────────────────────
def _test_anti_robot_filter(self):
"""AntiRobotFilter elimina frases de bot."""
try:
f = AntiRobotFilter(level=2)
test_cases = [
("con mucho gusto te ayudo", True), # debe ser eliminado
("hola, qué zona te molesta más", False), # OK
("fue un placer atenderte hoy", True), # debe ser eliminado
("claro, el jueves tenemos espacio", False), # OK
]
for text, should_change in test_cases:
result = f.process(text)
changed = result.lower() != text.lower()
if changed != should_change:
self._record(
"ANTI_ROBOT_FILTER", False,
f"'{text[:40]}' → should_change={should_change} pero got changed={changed}"
)
return
self._record("ANTI_ROBOT_FILTER", True)
except Exception as e:
self._record("ANTI_ROBOT_FILTER", False, str(e))
def _test_conversation_intelligence(self):
"""ConversationIntelligence actualiza estado correctamente."""
try:
ci = ConversationIntelligence()
# Simular análisis básico
class MockAnalysis:
intent = None
mock = MockAnalysis()
ci.update("test_chat", "hola quiero info sobre botox", "", mock)
state = ci.get_state("test_chat")
assert state["stage"] != "COLD", f"Expected not COLD, got {state['stage']}"
assert state["turn"] == 1, f"Expected turn=1, got {state['turn']}"
ci.update("test_chat", "la frente, ya se me marcan las líneas", "", mock)
state2 = ci.get_state("test_chat")
assert state2["turn"] == 2, f"Expected turn=2, got {state2['turn']}"
assert state2["stage"] in ("DISCOVERY", "PAIN_EXPLORED"), \
f"Unexpected stage: {state2['stage']}"
self._record("CONVERSATION_INTELLIGENCE", True)
except Exception as e:
self._record("CONVERSATION_INTELLIGENCE", False, str(e))
def _test_smart_variety(self):
"""SmartVariety no repite aperturas."""
try:
sv = SmartVariety()
used = set()
for _ in range(10):
opening = sv.get_opening("test_chat", "greeting")
# Puede repetir después de 3+ pero no los últimos 3
used.add(opening)
assert len(used) >= 2, f"SmartVariety usó solo {len(used)} aperturas únicas en 10"
self._record("SMART_VARIETY", True)
except Exception as e:
self._record("SMART_VARIETY", False, str(e))
def _test_model_manager_catalog(self):
"""ModelManager tiene todos los modelos del catálogo."""
try:
mm = ModelManager()
catalog = Config.V8_MODEL_CATALOG
assert len(catalog) >= 10, f"Catálogo muy pequeño: {len(catalog)} modelos"
for alias, (model_id, tier, desc) in catalog.items():
assert "/" in model_id, f"Model ID sin proveedor: {model_id}"
assert tier in ("fast", "reasoning", "lite"), f"Tier inválido: {tier}"
self._record("MODEL_MANAGER_CATALOG", True)
except Exception as e:
self._record("MODEL_MANAGER_CATALOG", False, str(e))
def _test_appointment_state_machine(self):
"""AppointmentStateMachine resuelve fechas correctamente."""
try:
asm = AppointmentStateMachine()
result = asm.propose_date("test_chat", "el jueves", "Botox")
assert result["valid"] is True, f"'el jueves' debería ser válido: {result}"
assert result["date_resolved"], f"'el jueves' no resolvió fecha: {result}"
result2 = asm.propose_date("test_chat2", "mañana", "Rellenos")
assert result2["valid"] is True, f"'mañana' debería ser válido: {result2}"
self._record("APPOINTMENT_STATE_MACHINE", True)
except Exception as e:
self._record("APPOINTMENT_STATE_MACHINE", False, str(e))
def _test_hallucination_guard_prices(self):
"""HallucinationGuard detecta precios inventados."""
try:
hg = HallucinationGuard()
clinic_no_prices = {"name": "TestClinic", "pricing": {}}
# Con precios inventados
has_halluc, kind, safe = hg.check(
"el botox cuesta $350.000", clinic_no_prices
)
assert has_halluc, "Debería detectar precio inventado"
assert kind == "PRICE_INVENTED", f"Tipo incorrecto: {kind}"
# Con precios configurados — no debería bloquear
clinic_with_prices = {"name": "TestClinic", "pricing": {"Botox": "350.000"}}
has_halluc2, _, _ = hg.check("el botox cuesta $350.000", clinic_with_prices)
assert not has_halluc2, "No debería bloquear si tiene precios configurados"
self._record("HALLUCINATION_GUARD", True)
except Exception as e:
self._record("HALLUCINATION_GUARD", False, str(e))
def _test_context_manager_compression(self):
"""SmartContextManager comprime historial largo correctamente."""
try:
scm = SmartContextManager()
# Crear historial largo
history = []
for i in range(30):
history.append({"role": "user", "content": f"mensaje del cliente {i}"})
history.append({"role": "assistant", "content": f"respuesta de conny {i}"})
optimized, summary = scm.prepare_context("test_chat", history, max_messages=20)
assert len(optimized) <= 20, f"Debería comprimir a 20, got {len(optimized)}"
# El summary puede ser vacío si no hay hechos extraíbles
self._record("CONTEXT_MANAGER", True)
except Exception as e:
self._record("CONTEXT_MANAGER", False, str(e))
def _test_failure_predictor_repetition(self):
"""FailurePredictorEngine detecta preguntas repetidas."""
try:
fpe = FailurePredictorEngine()
history = [
{"role": "assistant", "content": "qué zona te molesta más"},
{"role": "user", "content": "la frente"},
{"role": "assistant", "content": "qué zona te molesta más del rostro"},
{"role": "user", "content": "la frente, ya te dije"},
{"role": "assistant", "content": "cuéntame qué zona te molesta"},
]
result = fpe._detect_repetition_spiral(history)
assert result, f"Debería detectar repetición de 'qué zona te molesta'"
self._record("FAILURE_PREDICTOR", True)
except Exception as e:
self._record("FAILURE_PREDICTOR", False, str(e))
def _test_response_variation_engine(self):
"""ResponseVariationEngine detecta repetición de frases."""
try:
rve = ResponseVariationEngine()
phrase = "el botox relaja el músculo y en una semana no se ven las líneas"
rve.register("test_chat", phrase)
has_rep, phrases = rve.check_repetition("test_chat", phrase)
assert has_rep, "Debería detectar repetición"
assert phrases, f"Debería retornar frases repetidas: {phrases}"
self._record("RESPONSE_VARIATION", True)
except Exception as e:
self._record("RESPONSE_VARIATION", False, str(e))
def _test_ortography_corrections(self):
"""AntiRobotFilter corrige em-dash y puntuación."""
try:
f = AntiRobotFilter(level=1)
test = "el resultado — es natural"
result = f.process(test)
assert "—" not in result, f"Em-dash debería ser removido: '{result}'"
self._record("ORTOGRAPHY_CORRECTIONS", True)
except Exception as e:
self._record("ORTOGRAPHY_CORRECTIONS", False, str(e))
def _test_bubble_splitter(self):
"""_split_bubbles divide correctamente en burbujas."""
if not conny:
self._record("BUBBLE_SPLITTER", False, "conny no inicializado")
return
try:
result = conny._split_bubbles("hola qué tal ||| qué zona te molesta")
assert len(result) == 2, f"Debería dividir en 2 burbujas: {result}"
assert result[0] == "hola qué tal", f"Primera burbuja incorrecta: {result[0]}"
self._record("BUBBLE_SPLITTER", True)
except Exception as e:
self._record("BUBBLE_SPLITTER", False, str(e))
def _test_first_contact_intro(self):
"""El primer saludo debe presentar a Conny y aterrizar el negocio."""
if not conny:
self._record("FIRST_CONTACT_INTRO", False, "conny no inicializado")
return
try:
clinic = {"name": "Clinica Demo", "services": ["Botox", "Armonizacion facial"]}
personality = apply_archetype("amigable", "Conny")
result = conny._normalize_first_patient_turn(
response="oye qué te trae por acá",
clinic=clinic,
personality=personality,
user_msg="hola que tal",
history=[],
)
parts = [part.strip() for part in result.split("|||") if part.strip()]
assert len(parts) >= 2, f"Debería quedar en al menos 2 burbujas: {result}"
assert "conny" in parts[0].lower(), f"Debe presentarse: {parts[0]}"
assert "equipo" in parts[0].lower(), f"Debe ubicarse como parte del negocio: {parts[0]}"
assert "qué te trae por acá" not in result.lower(), f"No debe sonar invasiva: {result}"
self._record("FIRST_CONTACT_INTRO", True)
except Exception as e:
self._record("FIRST_CONTACT_INTRO", False, str(e))
def _test_language_detection(self):
"""MultilingualHandler detecta idiomas correctamente."""
try:
ml = MultilingualHandler()
assert ml.detect("hello, how much does botox cost?") == "en"
assert ml.detect("hola, cuánto vale el botox") == "es"
assert ml.detect("olá, quanto custa o botox") == "pt"
self._record("LANGUAGE_DETECTION", True)
except Exception as e:
self._record("LANGUAGE_DETECTION", False, str(e))
def _test_conversion_funnel_tracking(self):
"""ConversionFunnelTracker registra y recupera etapas."""
try:
cf = ConversionFunnelTracker()
cf.record("chat_001", "cold", "discovery", "first_message")
cf.record("chat_001", "discovery", "pain_explored", "user_shared_pain")
# Solo verificar que no lanzó excepción
summary = cf.get_pipeline_summary()
assert isinstance(summary, dict), "Debería retornar dict"
self._record("CONVERSION_FUNNEL", True)
except Exception as e:
self._record("CONVERSION_FUNNEL", False, str(e))
def _test_sector_detection(self):
"""SECTORS contiene todos los sectores necesarios."""
try:
required = ["estetica", "dental", "restaurante", "gimnasio", "medico"]
for s in required:
assert s in SECTORS, f"Sector '{s}' no encontrado"
info = get_sector_info(s)
assert len(info) == 4, f"Sector '{s}' mal formateado"
self._record("SECTOR_DETECTION", True)
except Exception as e:
self._record("SECTOR_DETECTION", False, str(e))
def _test_date_resolver(self):
"""AppointmentStateMachine resuelve todas las variantes de fecha."""
try:
asm = AppointmentStateMachine()
cases = ["mañana", "el jueves", "el viernes", "este sábado",
"próximo lunes", "la semana que viene"]
for case in cases:
r = asm._resolve_date_text(case, now_col())
assert r["valid"], f"'{case}' debería ser válido"
self._record("DATE_RESOLVER", True)
except Exception as e:
self._record("DATE_RESOLVER", False, str(e))
def _test_db_remember_recall(self):
"""DatabaseManager remember/recall funciona."""
try:
test_key = f"_test_{int(time.time())}"
db.remember(test_key, "test_value", "test")
recalled = db.recall(test_key)
assert recalled == "test_value", f"Recall falló: got '{recalled}'"
db.forget(test_key)
self._record("DB_REMEMBER_RECALL", True)
except Exception as e:
self._record("DB_REMEMBER_RECALL", False, str(e))
def _test_db_clinic_update(self):
"""DatabaseManager update_clinic no rompe la DB."""
try:
clinic_before = db.get_clinic()
db.update_clinic(tagline=clinic_before.get("tagline", ""))
clinic_after = db.get_clinic()
assert clinic_after is not None, "get_clinic retornó None después de update"
self._record("DB_CLINIC_UPDATE", True)
except Exception as e:
self._record("DB_CLINIC_UPDATE", False, str(e))
def _test_patient_upsert(self):
"""DatabaseManager get_or_create_patient funciona."""
try:
test_id = f"_test_patient_{int(time.time())}"
patient = db.get_or_create_patient(test_id)
assert patient is not None, "Retornó None"
assert patient["chat_id"] == test_id, "chat_id no coincide"
assert patient["is_new"] is True, "Primer insert debería ser is_new=True"
# Limpiar
try:
with db._conn() as c:
c.execute("DELETE FROM patients WHERE chat_id=?", (test_id,))
except Exception:
pass
self._record("PATIENT_UPSERT", True)
except Exception as e:
self._record("PATIENT_UPSERT", False, str(e))
async def _test_llm_basic_response(self):
"""LLM responde a un prompt simple."""
try:
resp, meta = await asyncio.wait_for(
llm_engine.complete(
[{"role": "user", "content": "Di solo 'OK' sin nada más"}],
model_tier="lite", temperature=0.0, max_tokens=10
),
timeout=15.0
)
assert resp and len(resp) > 0, "LLM devolvió respuesta vacía"
assert meta.get("provider"), "LLM no retornó provider en metadata"
self._record("LLM_BASIC", True, f"provider: {meta.get('provider')}")
except asyncio.TimeoutError:
self._record("LLM_BASIC", False, "TIMEOUT después de 15s")
except Exception as e:
self._record("LLM_BASIC", False, str(e))
async def _test_llm_anti_robot_response(self):
"""El LLM responde sin frases de bot cuando se le pide."""
try:
resp, _ = await asyncio.wait_for(
llm_engine.complete(
[
{"role": "system", "content": "Eres Conny. Nunca uses 'con mucho gusto'."},
{"role": "user", "content": "hola"}
],
model_tier="fast", temperature=0.7, max_tokens=50
),
timeout=20.0
)
bot_phrases = ["con mucho gusto", "encantada", "fue un placer", "soy una ia"]
has_bot = any(p in resp.lower() for p in bot_phrases)
if has_bot:
self._record("LLM_ANTI_ROBOT", False,
f"LLM usó frase de bot a pesar de la instrucción: '{resp[:60]}'")
else:
self._record("LLM_ANTI_ROBOT", True)
except asyncio.TimeoutError:
self._record("LLM_ANTI_ROBOT", False, "TIMEOUT después de 20s")
except Exception as e:
self._record("LLM_ANTI_ROBOT", False, str(e))
async def _test_llm_spanish_detection(self):
"""El LLM responde en español cuando se le habla en español."""
try:
resp, _ = await asyncio.wait_for(
llm_engine.complete(
[
{"role": "system", "content": "Eres Conny, recepcionista en Colombia."},
{"role": "user", "content": "hola, cuánto vale el botox"}
],
model_tier="fast", temperature=0.5, max_tokens=100
),
timeout=20.0
)
# Verificar que responde en español (al menos 3 palabras en español)
spanish_words = ["el", "la", "de", "en", "qué", "que", "para", "con", "una", "un"]
word_count = sum(1 for w in spanish_words if f" {w} " in f" {resp.lower()} ")
if word_count < 2:
self._record("LLM_SPANISH", False,
f"Respuesta no parece español: '{resp[:80]}'")
else:
self._record("LLM_SPANISH", True)
except asyncio.TimeoutError:
self._record("LLM_SPANISH", False, "TIMEOUT después de 20s")
except Exception as e:
self._record("LLM_SPANISH", False, str(e))
# ── Helper ───────────────────────────────────────────────────────────────
def _record(self, name: str, passed: bool, message: str = ""):
self._results.append({"name": name, "passed": passed, "message": message})
# ═══════════════════════════════════════════════════════════════════════════════
# INSTANCIAS GLOBALES — V8 EXTENDED
# ═══════════════════════════════════════════════════════════════════════════════
conversation_simulator: Optional[ConversationSimulator] = None
hallucination_guard: Optional[HallucinationGuard] = None
failure_predictor: Optional[FailurePredictorEngine] = None
smart_context_manager: Optional[SmartContextManager] = None
appointment_state_machine: Optional[AppointmentStateMachine] = None
conversation_recovery: Optional[ConversationRecoveryEngine] = None
response_variation: Optional[ResponseVariationEngine] = None
campaign_engine: Optional[ProactiveCampaignEngine] = None
admin_briefing: Optional[AdminIntelligentBriefing] = None
self_test_suite: Optional[SelfTestSuite] = None
def init_v8_extended_systems():
"""
Inicializa todos los sistemas extendidos de V8.
Cada sistema es INDEPENDIENTE — un fallo no afecta a los demás.
"""
global conversation_simulator, hallucination_guard, failure_predictor
global smart_context_manager, appointment_state_machine, conversation_recovery
global response_variation, campaign_engine, admin_briefing, self_test_suite
_systems_to_init = [
("conversation_simulator", lambda: ConversationSimulator()),
("hallucination_guard", lambda: HallucinationGuard()),
("failure_predictor", lambda: FailurePredictorEngine()),
("smart_context_manager", lambda: SmartContextManager()),
("appointment_state_machine", lambda: AppointmentStateMachine()),
("conversation_recovery", lambda: ConversationRecoveryEngine()),
("response_variation", lambda: ResponseVariationEngine()),
("campaign_engine", lambda: ProactiveCampaignEngine()),
("admin_briefing", lambda: AdminIntelligentBriefing()),
("self_test_suite", lambda: SelfTestSuite()),
]
_ok = 0
for _name, _factory in _systems_to_init:
try:
_instance = _factory()
globals()[_name] = _instance
_ok += 1
except Exception as _e_sys:
log.warning(f"[v8_extended] {_name} falló: {_e_sys}")
log.info(f"═══ V8 EXTENDED SYSTEMS: {_ok}/{len(_systems_to_init)} OK ═══")
log.info(" ConversationSimulator: ready")
log.info(" HallucinationGuard: ready")
log.info(" FailurePredictorEngine: ready")
log.info(" SmartContextManager: ready")
log.info(" AppointmentStateMachine: ready")
log.info(" ConversationRecovery: ready")
log.info(" ResponseVariationEngine: ready")
log.info(" ProactiveCampaignEngine: ready")
log.info(" AdminIntelligentBriefing: ready")
log.info(" SelfTestSuite: ready")
# ═══════════════════════════════════════════════════════════════════════════════
# NUEVOS ENDPOINTS FASTAPI — V8 EXTENDED
# ═══════════════════════════════════════════════════════════════════════════════
@app.post("/v8/simulate")
async def api_simulate(request: Request):
"""
Ejecuta una simulación de conversación.
Body: {"scenario": "estetica_miedo"} o {} para todos.
"""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if not conversation_simulator:
raise HTTPException(status_code=503, detail="Sistema de simulación no disponible")
data = await request.json()
scenario = data.get("scenario", "")
clinic = db.get_clinic() if db else {}
if scenario:
if scenario not in ConversationSimulator.SCENARIOS:
raise HTTPException(
status_code=400,
detail=f"Escenario desconocido. Disponibles: {list(ConversationSimulator.SCENARIOS.keys())}"
)
result = await conversation_simulator.run_scenario(scenario, clinic)
return result
else:
report = await conversation_simulator.run_all(clinic)
return report
@app.get("/v8/simulate/scenarios")
async def api_list_scenarios():
"""Lista todos los escenarios de simulación disponibles."""
return {
"scenarios": {
sid: {
"desc": s["desc"],
"sector": s["sector"],
}
for sid, s in ConversationSimulator.SCENARIOS.items()
}
}
@app.post("/v8/test")
async def api_self_test(request: Request):
"""Ejecuta la suite completa de tests automáticos."""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if not self_test_suite:
raise HTTPException(status_code=503, detail="Self-test suite no disponible")
report = await self_test_suite.run_all()
return report
@app.get("/v8/briefing")
async def api_briefing(request: Request, hours: int = 24):
"""Genera el briefing inteligente del período especificado."""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if not admin_briefing:
raise HTTPException(status_code=503, detail="Briefing no disponible")
clinic = db.get_clinic() if db else {}
content = await admin_briefing.generate(clinic, period_hours=hours)
return {"briefing": content, "period_hours": hours}
@app.get("/v8/pipeline")
async def api_pipeline_v8(request: Request):
"""Pipeline de conversiones usando ConversionFunnelTracker V8."""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if not conversion_funnel:
raise HTTPException(status_code=503, detail="Funnel no disponible")
summary = conversion_funnel.get_pipeline_summary()
rates = conversion_funnel.get_conversion_rate()
report = conversion_funnel.format_pipeline_report()
# Datos del ConversationIntelligence
ci_data: Dict[str, int] = {}
if conversation_intelligence:
for state in conversation_intelligence._states.values():
s = state.get("stage", "COLD")
ci_data[s] = ci_data.get(s, 0) + 1
return {
"funnel_summary": summary,
"conversion_rates": rates,
"active_stages": ci_data,
"report_text": report,
}
@app.get("/v8/ping")
async def api_v8_ping():
"""
Ping de diagnóstico V8 — sin dependencias externas.
Si responde, los endpoints V8 están registrados correctamente.
"""
return {
"ok": True,
"v8": True,
"version": "8.0",
"ts": datetime.now().isoformat(),
"anti_robot_active": anti_robot_filter is not None,
"model_manager_active": model_manager is not None,
"systems_initialized": anti_robot_filter is not None and model_manager is not None,
}
@app.get("/v8/health")
async def api_v8_health():
"""
Estado de salud de todos los sistemas V8.
NUNCA devuelve 500 — siempre responde aunque los sistemas no estén activos.
"""
try:
systems = {
"anti_robot_filter": anti_robot_filter is not None,
"conversation_intelligence": conversation_intelligence is not None,
"hyper_human_engine": hyper_human_engine is not None,
"smart_variety": smart_variety is not None,
"model_manager": model_manager is not None,
"conversation_simulator": conversation_simulator is not None,
"hallucination_guard": hallucination_guard is not None,
"failure_predictor": failure_predictor is not None,
"smart_context_manager": smart_context_manager is not None,
"appointment_state_machine": appointment_state_machine is not None,
"conversation_recovery": conversation_recovery is not None,
"response_variation": response_variation is not None,
"campaign_engine": campaign_engine is not None,
"admin_briefing": admin_briefing is not None,
"self_test_suite": self_test_suite is not None,
}
all_ok = all(systems.values())
active_count = sum(1 for v in systems.values() if v)
total_count = len(systems)
model_info = {}
if model_manager:
model_info = model_manager.get_effective_models()
# Diagnóstico de por qué los sistemas pueden estar inactivos
init_notes = []
if not anti_robot_filter:
init_notes.append("AntiRobotFilter no inicializado — llama a init_v8_systems()")
if not conversation_intelligence:
init_notes.append("ConversationIntelligence no inicializado")
if not model_manager:
init_notes.append("ModelManager no inicializado")
return {
"status": "ok" if all_ok else ("degraded" if active_count > 0 else "v8_not_initialized"),
"version": "8.0",
"systems": systems,
"active_count": active_count,
"total_systems": total_count,
"current_models": model_info,
"filter_level": anti_robot_filter.level if anti_robot_filter else 0,
"quality_threshold": Config.V8_QUALITY_THRESHOLD,
"init_notes": init_notes,
}
except Exception as _e_health:
log.error(f"[v8/health] error: {_e_health}", exc_info=True)
return {
"status": "error",
"version": "8.0",
"error": str(_e_health),
"active_count": 0,
"systems": {},
}
@app.post("/v8/model")
async def api_set_model_v8(request: Request):
"""
Cambia el modelo LLM en caliente desde la CLI V8.
Body: {"alias": "gemini-flash", "model": "google/gemini-2.5-flash", "tier": "fast"}
Persiste en DB y aplica inmediatamente a llm_engine.
"""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
data = await request.json()
alias = data.get("alias", "").strip()
model_id = data.get("model", "").strip()
tier = data.get("tier", "fast").strip()
if not model_id:
raise HTTPException(status_code=400, detail="model requerido")
# Aplicar en caliente al engine si existe
applied_in_flight = False
try:
if model_manager:
model_manager.apply_override(tier, model_id)
model_manager.apply_override("fast", model_id)
if tier == "reasoning":
model_manager.apply_override("reasoning", model_id)
model_manager._push_to_engine(tier, model_id)
applied_in_flight = True
elif llm_engine:
for provider in llm_engine.providers:
if hasattr(provider, "MDLS"):
provider.MDLS[tier] = model_id
provider.MDLS["fast"] = model_id
applied_in_flight = True
except Exception as e:
log.warning(f"[v8/model] error aplicando en caliente: {e}")
# Persistir en DB
if db:
try:
db.remember("v8_model_override",
json.dumps({"tier": tier, "model": model_id, "alias": alias}),
"config")
except Exception:
pass
log.info(f"[v8/model] cambiado: {tier}={model_id} (in_flight={applied_in_flight})")
return {
"ok": True,
"model": model_id,
"tier": tier,
"alias": alias,
"applied_in_flight": applied_in_flight,
"message": f"Modelo cambiado a {model_id}",
}
@app.post("/v8/campaign/{campaign_type}")
async def api_trigger_campaign(campaign_type: str, request: Request):
"""
Activa una campaña manualmente para un chat_id específico.
Body: {"chat_id": "...", "patient_name": "..."}
"""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if not campaign_engine:
raise HTTPException(status_code=503, detail="Campaign engine no disponible")
valid_types = list(ProactiveCampaignEngine.CAMPAIGN_TEMPLATES.keys())
if campaign_type not in valid_types:
raise HTTPException(
status_code=400,
detail=f"Tipo inválido. Disponibles: {valid_types}"
)
data = await request.json()
chat_id = data.get("chat_id", "")
patient_name = data.get("patient_name", "")
if not chat_id:
raise HTTPException(status_code=400, detail="chat_id requerido")
campaign_engine.schedule(chat_id, campaign_type, patient_name)
return {"ok": True, "chat_id": chat_id, "campaign_type": campaign_type}
@app.get("/v8/variation-score/{chat_id}")
async def api_variation_score(chat_id: str, request: Request):
"""Score de diversidad de respuestas para un chat."""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
score = response_variation.get_diversity_score(chat_id) if response_variation else 0.0
return {
"chat_id": chat_id,
"diversity_score": round(score, 2),
"interpretation": "diversa" if score >= 0.7 else ("normal" if score >= 0.4 else "monótona"),
}
# ═══════════════════════════════════════════════════════════════════════════════
# COMANDOS ADMIN ADICIONALES — V8 EXTENDED
# Se integran en ConnyUltra._handle_admin_or_setup vía monkey-patching
# ═══════════════════════════════════════════════════════════════════════════════
async def _admin_run_simulation(self_ref, chat_id: str, scenario_id: str = "") -> List[str]:
"""
/simular [escenario] — Ejecuta simulación de conversación.
Sin argumento: ejecuta todos los escenarios.
"""
if not conversation_simulator:
return ["Sistema de simulación no disponible. Reinicia el servidor."]
clinic = db.get_clinic() if db else {}
if scenario_id:
if scenario_id not in ConversationSimulator.SCENARIOS:
available = "\n".join(
f" /simular {sid} — {s['desc']}"
for sid, s in ConversationSimulator.SCENARIOS.items()
)
return [
f"Escenario '{scenario_id}' no encontrado.",
f"Escenarios disponibles:\n{available}"
]
try:
result = await asyncio.wait_for(
conversation_simulator.run_scenario(scenario_id, clinic),
timeout=90.0
)
except asyncio.TimeoutError:
return [f"Simulación '{scenario_id}' tardó más de 90s — abortada"]
except Exception as e:
return [f"Error en simulación: {e}"]
lines = [f"Simulación: {result['desc']}"]
lines.append(f"Resultado: {'✅ OK' if not result['failures'] else '❌ Con fallos'}")
lines.append(f"Humanidad: {int(result['avg_humanness']*100)}%")
lines.append(f"Turnos: {result['total_turns']}")
if result["failures"]:
lines.append("\nFallos:")
for f in result["failures"][:5]:
lines.append(f" ✗ {f}")
if result["turns"]:
lines.append("\nConversación:")
for i, turn in enumerate(result["turns"][:4]):
lines.append(f" [{i+1}] Cliente: {turn['client'][:50]}")
lines.append(f" Conny: {turn['conny'][:60]}")
return ["\n".join(lines)]
else:
# Todos los escenarios — aviso de que tardará
return_msg = ["Ejecutando todos los escenarios... esto tarda 1-2 minutos."]
async def run_and_notify():
try:
report = await asyncio.wait_for(
conversation_simulator.run_all(clinic), timeout=180.0
)
formatted = conversation_simulator.format_report(report)
# Notificar al admin cuando termine
if db:
admin_ids = _parse_admin_ids(db.get_clinic().get("admin_chat_ids", []))
if conny and admin_ids:
for aid in admin_ids:
for msg in formatted:
await conny._send_message(aid, msg)
except Exception as e:
log.error(f"[simulator] run_all error: {e}")
asyncio.create_task(run_and_notify())
return return_msg
async def _admin_run_self_test(self_ref) -> List[str]:
"""
/test — Ejecuta la suite de 25 tests automáticos.
Verifica que todos los sistemas internos funcionan.
"""
if not self_test_suite:
return ["Self-test suite no disponible."]
try:
report = await asyncio.wait_for(
self_test_suite.run_all(), timeout=120.0
)
except asyncio.TimeoutError:
return ["Tests tardaron más de 120s — algunos fallaron por timeout"]
except Exception as e:
return [f"Error ejecutando tests: {e}"]
return self_test_suite.format_report(report)
async def _admin_get_briefing(self_ref, clinic: Dict, hours: int = 24) -> List[str]:
"""
/briefing [horas] — Genera el briefing inteligente del período.
Por defecto: últimas 24 horas.
"""
if not admin_briefing:
return ["Briefing no disponible."]
try:
content = await asyncio.wait_for(
admin_briefing.generate(clinic, period_hours=hours),
timeout=30.0
)
except asyncio.TimeoutError:
return ["El briefing tardó demasiado. Intenta de nuevo."]
except Exception as e:
return [f"Error generando briefing: {e}"]
return [content]
async def _admin_appt_status(self_ref, chat_id: str) -> List[str]:
"""
/cita-estado [chat_id] — Estado de la cita en la AppointmentStateMachine.
"""
if not appointment_state_machine:
return ["AppointmentStateMachine no disponible."]
state = appointment_state_machine.get_state(chat_id)
proposal = appointment_state_machine._proposals.get(chat_id, {})
booking = appointment_state_machine._bookings.get(chat_id, {})
lines = [f"Estado de cita para {chat_id}:", f" Estado: {state}"]
if proposal:
lines.append(f" Fecha propuesta: {proposal.get('resolved', '-')}")
lines.append(f" Servicio: {proposal.get('service', '-')}")
lines.append(f" Nombre: {proposal.get('patient_name', '-')}")
if booking:
lines.append(f"\nReserva confirmada:")
lines.append(appointment_state_machine.get_booking_summary(chat_id))
missing = appointment_state_machine.get_missing_details(chat_id)
if missing:
lines.append(f"\nFaltan: {', '.join(missing)}")
return ["\n".join(lines)]
# Monkey-patch ConnyUltra para agregar los nuevos métodos de admin
ConnyUltra._admin_run_simulation = _admin_run_simulation
ConnyUltra._admin_run_self_test = _admin_run_self_test
ConnyUltra._admin_get_briefing = _admin_get_briefing
ConnyUltra._admin_appt_status = _admin_appt_status
# Patch del dispatcher de comandos para incluir los nuevos comandos
_orig_attr = getattr(ConnyUltra, "_handle_admin_or_setup", None)
_original_handle_admin = _orig_attr.__wrapped__ if (_orig_attr and hasattr(_orig_attr, "__wrapped__")) else None
def _patch_admin_dispatcher():
"""
Extiende _handle_admin_or_setup con los nuevos comandos V8 Extended.
Se ejecuta después de que conny esté inicializado.
"""
orig_get = getattr(ConnyUltra, "_handle_admin_or_setup", None)
original_method = orig_get if orig_get else None
async def patched_handle_admin(self, chat_id: str, text: str, clinic: Dict) -> List[str]:
cmd = text.lower().strip()
# ── Nuevos comandos V8 Extended ───────────────────────────────────────
if cmd == "/simular":
return await self._admin_run_simulation(chat_id)
elif cmd.startswith("/simular "):
scenario_id = cmd.split("/simular ", 1)[1].strip()
return await self._admin_run_simulation(chat_id, scenario_id)
elif cmd == "/test":
return await self._admin_run_self_test()
elif cmd == "/briefing" or cmd.startswith("/briefing "):
hours_str = cmd.split("/briefing", 1)[1].strip()
hours = int(hours_str) if hours_str.isdigit() else 24
return await self._admin_get_briefing(clinic, hours)
elif cmd.startswith("/cita-estado "):
target_id = cmd.split("/cita-estado ", 1)[1].strip()
return await self._admin_appt_status(target_id)
elif cmd == "/cita-estado":
return [
"Formato: /cita-estado [chat_id]",
"Ej: /cita-estado 573001234567"
]
# Delegar al método original para todo lo demás
if original_method:
return await original_method(self, chat_id, text, clinic)
return ["Admin no disponible."]
setattr(ConnyUltra, "_handle_admin_or_setup", patched_handle_admin)
log.info("[v8_extended] dispatcher admin patcheado con nuevos comandos")
# ═══════════════════════════════════════════════════════════════════════════════
# INYECCIÓN EN EL PIPELINE DE PRODUCCIÓN
# Agrega HallucinationGuard + FailurePredictor + ResponseVariation
# a la respuesta de pacientes en producción.
# ═══════════════════════════════════════════════════════════════════════════════
def v8_extended_postprocess(response: str, chat_id: str, clinic: Dict,
user_msg: str, history: List[Dict],
archetype: str = "amigable") -> str:
"""
Post-procesamiento extendido V8 para TODAS las respuestas a pacientes.
NUNCA crashea — si falla, retorna la respuesta original.
"""
if not response:
return response
try:
return _v8_extended_postprocess_inner(response, chat_id, clinic, user_msg, history, archetype)
except Exception as _e_ext:
log.debug(f"[v8_ext_post] error no crítico: {_e_ext}")
return response
def _v8_extended_postprocess_inner(response: str, chat_id: str, clinic: Dict,
user_msg: str, history: List[Dict],
archetype: str = "amigable") -> str:
"""
Post-procesamiento extendido V8 para TODAS las respuestas a pacientes.
Pipeline:
1. HallucinationGuard → bloquea datos inventados
2. ResponseVariationEngine → detecta repetición y forza variación
3. v8_process_response (anti-robot, ya definido antes)
Retorna la respuesta limpia.
"""
kb_context = ""
try:
if db and kb:
kb_context = kb.query(user_msg)[:500] if hasattr(kb, "query") else ""
except Exception:
pass
# 1. HallucinationGuard
if hallucination_guard:
has_halluc, kind, safe_response = hallucination_guard.check(
response, clinic, kb_context
)
if has_halluc:
log.warning(f"[hallucination] bloqueado {kind} en {chat_id}: '{response[:60]}'")
response = safe_response
# 2. ResponseVariationEngine — registrar para tracking (no bloquear aquí)
if response_variation:
response_variation.register(chat_id, response)
# 3. v8_process_response (anti-robot base)
response = v8_process_response(response, chat_id=chat_id, archetype=archetype)
return response
def v8_extended_pre_prompt_injection(chat_id: str, user_msg: str,
history: List[Dict], clinic: Dict) -> str:
"""
Construye el bloque de instrucciones extendido para inyectar AL INICIO del prompt.
NUNCA crashea — retorna string vacío si falla.
"""
try:
return _v8_pre_prompt_inner(chat_id, user_msg, history, clinic)
except Exception as _e_pre:
log.debug(f"[v8_pre_prompt] error no crítico: {_e_pre}")
return ""
def _v8_pre_prompt_inner(chat_id: str, user_msg: str,
history: List[Dict], clinic: Dict) -> str:
"""
Implementación interna del pre-prompt V8.
Combina: FailurePredictor + ConversationRecovery + ResponseVariation.
Este bloque le da a Conny información específica sobre QUÉ puede fallar
en el próximo mensaje y CÓMO prevenirlo.
"""
injections: List[str] = []
# 1. Predictor de fallos
if failure_predictor:
warnings_list = failure_predictor.predict(chat_id, user_msg, history, clinic)
if warnings_list:
block = failure_predictor.get_prompt_injection(chat_id)
if block:
injections.append(block)
# 2. Recuperación de conversación atascada
if conversation_recovery:
recovery_inj = conversation_recovery.get_recovery_prompt_injection(
chat_id, user_msg, history
)
if recovery_inj:
injections.append(recovery_inj)
# 3. Variación de respuesta (si hay repetición detectada)
if response_variation and history:
# Tomar la última respuesta de Conny para evaluar
last_conny = next(
(h["content"] for h in reversed(history) if h["role"] == "assistant"), ""
)
if last_conny:
variation_inj = response_variation.get_variation_injection(chat_id, last_conny)
if variation_inj:
injections.append(variation_inj)
# 4. Contexto comprimido si el historial es largo
if smart_context_manager and len(history) > SmartContextManager.MAX_HISTORY_FULL:
cached_summary = smart_context_manager.get_cached_summary(chat_id)
if cached_summary:
injections.append(cached_summary)
if not injections:
return ""
return "\n\n" + "\n\n".join(injections) + "\n\n"
# ═══════════════════════════════════════════════════════════════════════════════
# ACTUALIZACIÓN DEL BANNER CON SISTEMAS EXTENDIDOS
# ═══════════════════════════════════════════════════════════════════════════════
V8_EXTENDED_BANNER = """
╔══════════════════════════════════════════════════════════════════╗
║ ║
║ ██████╗ ██████╗ ███╗ ██╗███╗ ██╗██╗ ██╗ ║
║ ██╔════╝ ██╔═══██╗████╗ ██║████╗ ██║╚██╗ ██╔╝ ║
║ ██║ ██║ ██║██╔██╗ ██║██╔██╗ ██║ ╚████╔╝ ║
║ ██║ ██║ ██║██║╚██╗██║██║╚██╗██║ ╚██╔╝ ║
║ ╚██████╗ ╚██████╔╝██║ ╚████║██║ ╚████║ ██║ ║
║ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝╚═╝ ╚═══╝ ╚═╝ ║
║ ║
║ U L T R A v 8 . 0 ║
║ Hipernaturalmente Humana — Extended ║
║ ║
╠══════════════════════════════════════════════════════════════════╣
║ CORE V8: ║
║ • AntiRobotFilter L1-L3 — elimina cada frase de call center ║
║ • ConversationIntelligence — etapas, emociones, compromiso ║
║ • HyperHumanEngine — valida humanidad en cada respuesta ║
║ • SmartVariety — nunca repite apertura ni cierre igual ║
║ • ModelManager — /modelo cambia el LLM en caliente ║
║ EXTENDED V8: ║
║ • ConversationSimulator — simula 10 escenarios internamente ║
║ • HallucinationGuard — bloquea precios/fechas inventados ║
║ • FailurePredictorEngine — predice fallos antes de que pasen ║
║ • SmartContextManager — comprime contexto sin perder datos ║
║ • AppointmentStateMachine — máquina de estados para citas ║
║ • ConversationRecoveryEngine — rescata convs. atascadas ║
║ • ResponseVariationEngine — cero repetición de frases ║
║ • ProactiveCampaignEngine — follow-ups, recordatorios ║
║ • AdminIntelligentBriefing — briefing diario accionable ║
║ • SelfTestSuite — 25 tests automáticos al arrancar ║
╚══════════════════════════════════════════════════════════════════╝
"""
# ═══ CONNY OBSERVATORY ═══
# ═══════════════════════════════════════════════════════════════════════════════
# CONNY AGENT OBSERVATORY V8.0
# Real-time AI agent observability system
# ═══════════════════════════════════════════════════════════════════════════════
import time as _obs_time
import json as _obs_json
import asyncio as _obs_asyncio
from collections import deque as _deque
from dataclasses import dataclass as _dc, field as _dcfield
from typing import Dict as _D, List as _L, Optional as _Opt
from datetime import datetime as _dt
class EventType:
LLM_CALL = "llm_call"
MESSAGE_IN = "message_in"
MESSAGE_OUT = "message_out"
QUALITY_SCORE = "quality_score"
FAILURE = "failure"
WARNING = "warning"
APPOINTMENT = "appointment"
CONVERSION = "conversion"
FUNNEL_ADVANCE = "funnel_advance"
DIAGNOSIS = "diagnosis"
SYSTEM = "system"
@_dc
class AgentEvent:
id: str
type: str
ts: float
chat_id: str = ""
instance: str = ""
data: dict = _dcfield(default_factory=dict)
severity: str = "info"
def to_dict(self):
return {
"id": self.id,
"type": self.type,
"ts": self.ts,
"ts_h": _dt.fromtimestamp(self.ts).strftime("%H:%M:%S.%f")[:12],
"chat_id": self.chat_id,
"instance": self.instance,
"data": self.data,
"severity": self.severity,
}
def to_sse(self):
import json
return "data: " + json.dumps(self.to_dict(), ensure_ascii=False) + "\n\n"
class EventBus:
MAX_EVENTS = 2000
def __init__(self):
self._events = _deque(maxlen=self.MAX_EVENTS)
self._subs = []
self._counter = 0
async def emit(self, etype, data, chat_id="", severity="info"):
self._counter += 1
evt = AgentEvent(
id=f"e{self._counter:05d}",
type=etype, ts=_obs_time.time(),
chat_id=chat_id,
instance=os.getenv("CONNY_INSTANCE", "base"),
data=data, severity=severity,
)
self._events.append(evt)
dead = []
for q in self._subs:
try: q.put_nowait(evt)
except Exception: dead.append(q)
for d in dead:
try: self._subs.remove(d)
except ValueError: pass
return evt
def emit_sync(self, etype, data, chat_id="", severity="info"):
self._counter += 1
evt = AgentEvent(
id=f"e{self._counter:05d}",
type=etype, ts=_obs_time.time(),
chat_id=chat_id,
instance=os.getenv("CONNY_INSTANCE", "base"),
data=data, severity=severity,
)
self._events.append(evt)
return evt
def subscribe(self):
q = _obs_asyncio.Queue(maxsize=500)
if len(self._subs) < 50:
self._subs.append(q)
return q
def unsubscribe(self, q):
try: self._subs.remove(q)
except ValueError: pass
def get_recent(self, limit=100, event_type="", severity=""):
evts = list(self._events)
if event_type: evts = [e for e in evts if e.type == event_type]
if severity: evts = [e for e in evts if e.severity == severity]
return list(reversed(evts))[:limit]
def get_stats(self):
evts = list(self._events)
by_type, by_sev = {}, {}
for e in evts:
by_type[e.type] = by_type.get(e.type, 0) + 1
by_sev[e.severity] = by_sev.get(e.severity, 0) + 1
return {
"total": len(evts),
"by_type": by_type,
"by_severity": by_sev,
"subscribers": len(self._subs),
}
class AgentTracer:
def __init__(self, ev_bus):
self.bus = ev_bus
self._traces = {}
self._counter = 0
def start(self, chat_id, messages, tier="fast"):
self._counter += 1
tid = f"tr{self._counter:04d}"
self._traces[tid] = {
"chat_id": chat_id,
"tier": tier,
"t0": _obs_time.time(),
"msgs": messages,
}
return tid
def end(self, tid, response, model="", error=""):
tr = self._traces.pop(tid, {})
if not tr: return
ms = int((_obs_time.time() - tr["t0"]) * 1000)
chat_id = tr.get("chat_id", "")
in_tok = max(1, sum(len(m.get("content","")) for m in tr.get("msgs",[])) // 4)
out_tok = max(1, len(response) // 4)
issues = self._issues(response)
sev = "error" if error else ("warning" if issues or ms > 8000 else "info")
self.bus.emit_sync(EventType.LLM_CALL, {
"model": model or tr.get("tier", "?"),
"latency_ms": ms,
"in_tok": in_tok,
"out_tok": out_tok,
"preview": response[:120],
"error": error,
"issues": issues,
}, chat_id=chat_id, severity=sev)
for iss in issues:
self.bus.emit_sync(EventType.FAILURE, {
"type": iss["type"],
"detail": iss["detail"],
"response": response[:150],
"trace_id": tid,
}, chat_id=chat_id, severity="warning")
def _issues(self, resp):
if not resp: return [{"type":"empty","detail":"LLM returned empty"}]
issues = []
rl = resp.lower()
BOT = ["con mucho gusto","encantada de ayudarte","fue un placer",
"gracias por contactarnos","estamos para servirte"]
if any(p in rl for p in BOT):
issues.append({"type":"bot_phrase","detail":"frase de call center detectada"})
if len(resp.split()) > 80:
issues.append({"type":"too_long","detail":f"{len(resp.split())} palabras"})
try:
if anti_robot_filter:
sc = anti_robot_filter.score_humanness(resp)
if sc < 0.55:
issues.append({"type":"low_humanness","detail":f"score {sc:.2f}"})
except Exception:
pass
return issues
class ConversationObserver:
def __init__(self, ev_bus):
self.bus = ev_bus
self._convs = {}
def observe(self, chat_id, role, content, response="", quality=0.0):
if chat_id not in self._convs:
self._convs[chat_id] = {
"t0": _obs_time.time(), "turns": 0,
"stage": "COLD", "scores": [],
"converted": False, "last_t": _obs_time.time(),
"last_content": "",
}
c = self._convs[chat_id]
c["last_t"] = _obs_time.time()
c["last_content"] = content[:100]
if role == "user":
c["turns"] += 1
self.bus.emit_sync(EventType.MESSAGE_IN,
{"content": content[:200], "turn": c["turns"], "stage": c["stage"]},
chat_id=chat_id)
elif role == "assistant" and response:
sc = quality
if not sc:
try:
sc = anti_robot_filter.score_humanness(response) if anti_robot_filter else 0.7
except Exception:
sc = 0.7
c["scores"].append(sc)
avg = sum(c["scores"]) / len(c["scores"])
if conversation_intelligence:
state = conversation_intelligence.get_state(chat_id)
old_s = c.get("stage","COLD")
new_s = state.get("stage","COLD")
if new_s != old_s:
c["stage"] = new_s
self.bus.emit_sync(EventType.FUNNEL_ADVANCE,
{"from": old_s, "to": new_s, "turn": c["turns"]},
chat_id=chat_id)
if new_s in ("BOOKED","CONFIRMED") and not c["converted"]:
c["converted"] = True
self.bus.emit_sync(EventType.CONVERSION,
{"turns": c["turns"],
"time_min": round((_obs_time.time()-c["t0"])/60,1),
"avg_quality": round(avg,2)},
chat_id=chat_id)
self.bus.emit_sync(EventType.QUALITY_SCORE,
{"score": round(sc,2), "avg": round(avg,2), "preview": response[:100]},
chat_id=chat_id,
severity="info" if sc >= 0.65 else "warning")
self.bus.emit_sync(EventType.MESSAGE_OUT,
{"content": response[:200], "quality": round(sc,2), "turn": c["turns"]},
chat_id=chat_id)
def active(self, max_age=60):
cut = _obs_time.time() - max_age*60
out = []
for cid, c in self._convs.items():
if c["last_t"] >= cut:
avg = round(sum(c["scores"])/len(c["scores"]),2) if c["scores"] else 0
out.append({
"chat_id": cid,
"turns": c["turns"],
"stage": c["stage"],
"avg_q": avg,
"converted": c["converted"],
"elapsed_m": round((_obs_time.time()-c["t0"])/60,1),
"ago_s": round(_obs_time.time()-c["last_t"]),
"last": c["last_content"],
})
return sorted(out, key=lambda x: x["ago_s"])
def stats(self):
a = self.active(60)
conv = sum(1 for c in a if c["converted"])
qs = [c["avg_q"] for c in a if c["avg_q"]>0]
return {
"active": len(a),
"conversions": conv,
"rate": round(conv/len(a)*100,1) if a else 0,
"avg_quality": round(sum(qs)/len(qs),2) if qs else 0,
"avg_turns": round(sum(c["turns"] for c in a)/len(a),1) if a else 0,
}
class AIDiagnostician:
def __init__(self, ev_bus):
self.bus = ev_bus
self._last_diag = 0
self._cooldown = 300
async def diagnose(self, limit=15):
if not llm_engine: return None
failures = self.bus.get_recent(limit=limit, event_type=EventType.FAILURE)
if not failures:
return {"summary":"Sin fallos recientes","actions":[],"severity":"low"}
by_type = {}
for e in failures:
t = e.data.get("type","?")
by_type.setdefault(t, []).append(e)
fail_txt = ""
for t, evts in by_type.items():
fail_txt += f"\n[{t}] — {len(evts)}x:\n"
for ev in evts[:2]:
fail_txt += f" • {ev.data.get('detail','')} — '{ev.data.get('response','')[:60]}'\n"
prompt = f"""Eres analista de agentes IA para negocios en Colombia.
Fallos detectados en Conny (asistente WhatsApp):
{fail_txt}
Diagnóstico breve (JSON):
{{
"summary": "qué está pasando en 1 frase",
"root_causes": ["causa 1"],
"impact": "efecto en el cliente",
"actions": [{{"priority":"alta|media|baja","action":"qué hacer"}}],
"severity": "critical|high|medium|low"
}}"""
try:
raw, _ = await _obs_asyncio.wait_for(
llm_engine.complete([{"role":"user","content":prompt}],
model_tier="fast", temperature=0.3, max_tokens=300, use_cache=False),
timeout=15.0)
import re as _re
m = _re.search(r'\{[\s\S]+\}', raw.strip())
diag = _obs_json.loads(m.group(0)) if m else {"summary": raw[:200]}
diag["count"] = len(failures)
diag["ts"] = _dt.now().isoformat()
await self.bus.emit(EventType.DIAGNOSIS, diag,
severity=diag.get("severity","medium"))
self._last_diag = _obs_time.time()
return diag
except Exception as e:
log.warning(f"[diagnostician] {e}")
return None
async def auto(self):
if _obs_time.time() - self._last_diag < self._cooldown: return
recent = self.bus.get_recent(limit=20, event_type=EventType.FAILURE)
if len(recent) >= 5:
await self.diagnose(20)
# ── Globals ──────────────────────────────────────────────────────────────────
bus: EventBus = None
agent_tracer: AgentTracer = None
conversation_observer: ConversationObserver = None
ai_diagnostician: AIDiagnostician = None
def init_observatory():
global bus, agent_tracer, conversation_observer, ai_diagnostician
try:
bus = EventBus()
agent_tracer = AgentTracer(bus)
conversation_observer = ConversationObserver(bus)
ai_diagnostician = AIDiagnostician(bus)
bus.emit_sync(EventType.SYSTEM, {"event":"boot","version":"8.0"})
log.info("═══ OBSERVATORY INITIALIZED ═══")
except Exception as e:
log.warning(f"[observatory] init error: {e}")
# ── Helpers de instrumentación ───────────────────────────────────────────────
def obs_user_msg(chat_id, content):
if conversation_observer:
conversation_observer.observe(chat_id, "user", content)
def obs_response(chat_id, response, latency_ms=0, model="", stage=""):
if not bus: return
sc = 0.0
try:
sc = anti_robot_filter.score_humanness(response) if anti_robot_filter else 0.7
except Exception: pass
if conversation_observer:
conversation_observer.observe(chat_id, "assistant", response, response, sc)
if sc < 0.65 and agent_tracer:
for iss in agent_tracer._issues(response):
bus.emit_sync(EventType.FAILURE, {
"type": iss["type"], "detail": iss["detail"],
"response": response[:150], "latency_ms": latency_ms,
}, chat_id=chat_id, severity="warning")
def obs_appointment(chat_id, service, date):
if bus:
bus.emit_sync(EventType.APPOINTMENT,
{"service": service, "date": date}, chat_id=chat_id)
# ── FastAPI endpoints ─────────────────────────────────────────────────────────
from fastapi.responses import StreamingResponse as _StreamingResponse
@app.get("/obs/stream")
async def obs_stream_endpoint(request: Request):
"""SSE stream de eventos en tiempo real. Requiere X-Master-Key."""
if Config.MASTER_API_KEY:
key = (request.headers.get("X-Master-Key","") or
request.query_params.get("key",""))
if key != Config.MASTER_API_KEY:
raise HTTPException(status_code=401)
if not bus:
raise HTTPException(status_code=503, detail="Observatory no activo")
async def gen():
q = bus.subscribe()
try:
yield "event: connected\ndata: {\"status\":\"ok\"}\n\n"
for e in reversed(bus.get_recent(20)):
yield e.to_sse()
while True:
if await request.is_disconnected(): break
try:
e = await _obs_asyncio.wait_for(q.get(), timeout=25.0)
yield e.to_sse()
except _obs_asyncio.TimeoutError:
yield ": heartbeat\n\n"
finally:
bus.unsubscribe(q)
return _StreamingResponse(gen(), media_type="text/event-stream",
headers={"Cache-Control":"no-cache","X-Accel-Buffering":"no"})
@app.get("/obs/events")
async def obs_events(request: Request, limit: int = 50,
event_type: str = "", severity: str = "", chat_id: str = ""):
if not _verify_master_key(request): raise HTTPException(401)
if not bus: raise HTTPException(503)
evts = bus.get_recent(limit, event_type, severity)
if chat_id: evts = [e for e in evts if e.chat_id == chat_id]
return {"events": [e.to_dict() for e in evts], "total": len(evts)}
@app.get("/obs/conversations")
async def obs_conversations_endpoint(request: Request, max_age: int = 60):
if not _verify_master_key(request): raise HTTPException(401)
if not conversation_observer: raise HTTPException(503)
return {"conversations": conversation_observer.active(max_age),
"stats": conversation_observer.stats()}
@app.get("/obs/failures")
async def obs_failures_endpoint(request: Request, limit: int = 50):
if not _verify_master_key(request): raise HTTPException(401)
if not bus: raise HTTPException(503)
fails = bus.get_recent(limit, EventType.FAILURE)
by_t = {}
for f in fails:
t = f.data.get("type","?")
by_t[t] = by_t.get(t, 0) + 1
return {"failures": [f.to_dict() for f in fails],
"total": len(fails), "by_type": by_t}
@app.get("/obs/stats")
async def obs_stats_endpoint(request: Request):
if not _verify_master_key(request): raise HTTPException(401)
llm_evts = bus.get_recent(100, EventType.LLM_CALL) if bus else []
lats = [e.data.get("latency_ms",0) for e in llm_evts if e.data.get("latency_ms")]
q_evts = bus.get_recent(100, EventType.QUALITY_SCORE) if bus else []
scores = [e.data.get("score",0) for e in q_evts]
fail_evts= bus.get_recent(50, EventType.FAILURE) if bus else []
return {
"llm": {
"calls": len(llm_evts),
"avg_latency_ms": int(sum(lats)/len(lats)) if lats else 0,
"p95_latency_ms": sorted(lats)[int(len(lats)*.95)] if len(lats)>=20 else (max(lats) if lats else 0),
"avg_quality": round(sum(scores)/len(scores),2) if scores else 0,
},
"failures": {"total": len(fail_evts),
"rate_pct": round(len(fail_evts)/max(len(llm_evts),1)*100,1)},
"conversations": conversation_observer.stats() if conversation_observer else {},
"bus": bus.get_stats() if bus else {},
"ts": _dt.now().isoformat(),
}
@app.post("/obs/diagnose")
async def obs_diagnose_endpoint(request: Request):
if not _verify_master_key(request): raise HTTPException(401)
if not ai_diagnostician: raise HTTPException(503)
data = await request.json()
diag = await ai_diagnostician.diagnose(int(data.get("limit", 15)))
return diag or {"summary": "Sin datos para diagnosticar"}
@app.get("/obs/health")
async def obs_health_endpoint():
active_convs = 0
if conversation_observer:
active_convs = len([c for c in conversation_observer._convs.values()
if _obs_time.time() - c.get("last_t",0) < 3600])
return {
"ok": True,
"bus": bus is not None,
"tracer": agent_tracer is not None,
"observer": conversation_observer is not None,
"diagnostician": ai_diagnostician is not None,
"events_buffered": len(bus._events) if bus else 0,
"subscribers": len(bus._subs) if bus else 0,
"active_conversations": active_convs,
}
# ═══ CONNY TRAINER ═══
# ═══════════════════════════════════════════════════════════════════════════════
# CONNY TRAINER — V8.0
# Sistema completo de entrenamiento en tiempo real.
#
# Qué hace:
# 1. SkillEngine — skills de comportamiento que el dueño activa/desactiva
# ("a veces usa minúsculas", "errores de tipeo naturales", etc.)
# 2. PromptEvolver — auto-modifica el system prompt de Conny en tiempo real
# sin reiniciar. El dueño dice "aprende X" y se aplica ya.
# 3. AdminClientMode — cualquier admin se convierte en cliente inmediatamente
# para simular una conversación real y entrenar
# 4. NovaRuleSync — cuando el cliente dice "NO hagas X", la instrucción
# va a Nova como regla de gobernanza (si Nova está activo)
# Y también se guarda en la carpeta de confianza local
# 5. TrainingSession — sesión de entrenamiento completa con replay, scoring
# y exportación de las reglas aprendidas
#
# Endpoints nuevos:
# POST /trainer/skill/toggle — activar/desactivar skill
# GET /trainer/skills — listar skills disponibles
# POST /trainer/prompt/evolve — evolucionar el prompt con instrucción NL
# POST /trainer/admin-as-client — modo admin-como-cliente
# GET /trainer/session/{id} — ver sesión de entrenamiento
# POST /trainer/nova-sync — sincronizar reglas con Nova
# GET /trainer/status — estado del trainer
#
# Comandos admin nuevos en el bot:
# /entrenar — entrar en modo entrenamiento
# /simular-cliente — admin se convierte en cliente
# /skill [nombre] [on|off] — activar/desactivar skill
# /skills — ver skills activas
# /aprender [instruccion libre] — evolucionar prompt en NL
# /desaprender [tema] — revertir una evolución
# /sesion — ver sesión actual de entrenamiento
# ═══════════════════════════════════════════════════════════════════════════════
import random as _random_trainer
import uuid as _uuid_trainer
# ═══════════════════════════════════════════════════════════════════════════════
# SKILL ENGINE
# Skills = comportamientos que modifican cómo Conny responde, sin cambiar
# la personalidad core. Se activan/desactivan en caliente.
# ═══════════════════════════════════════════════════════════════════════════════
SKILL_DEFINITIONS: Dict[str, Dict] = {
# ── Ortografía y tipeo ────────────────────────────────────────────────────
"typos_naturales": {
"name": "Typos naturales",
"desc": "A veces comete errores de tipeo humanos (qe, proque, esoty, etc.)",
"category": "escritura",
"intensity": 0.15, # probabilidad de aplicar por mensaje
"prompt_inject": "A veces (no siempre) comete pequeños errores de tipeo naturales como "
"escribiría alguien real por WhatsApp: 'qe' en vez de 'que', "
"'proque' en vez de 'porque', 'esoty' en vez de 'estoy'. "
"Máximo 1 typo por mensaje, solo si el mensaje es largo.",
"examples": [
("que", "qe"),
("porque", "proque"),
("estoy", "esoty"),
("también", "tambien"),
("entonces", "entnoces"),
],
"default_on": False,
},
"minusculas_inicio": {
"name": "Minúsculas al inicio",
"desc": "No capitaliza el inicio de los mensajes (como WhatsApp real)",
"category": "escritura",
"intensity": 0.6,
"prompt_inject": "A veces (en mensajes cortos e informales) no capitalices la primera "
"letra. Escribe como alguien real manda WhatsApp: 'hola qué tal' "
"no 'Hola qué tal'. Solo en mensajes de menos de 10 palabras.",
"default_on": False,
},
"sin_tildes_ocasional": {
"name": "Sin tildes ocasional",
"desc": "Omite tildes ocasionalmente como en WhatsApp real",
"category": "escritura",
"intensity": 0.2,
"prompt_inject": "Ocasionalmente omite tildes en palabras comunes como lo hace alguien "
"escribiendo rápido por WhatsApp: 'mas' en vez de 'más', "
"'tambien' en vez de 'también'. No siempre, solo a veces.",
"default_on": False,
},
"abreviaciones": {
"name": "Abreviaciones WhatsApp",
"desc": "Usa abreviaciones naturales (xq, pq, tmb, q, tb)",
"category": "escritura",
"intensity": 0.1,
"prompt_inject": "A veces usa abreviaciones de WhatsApp cuando el contexto es muy "
"informal: 'xq' o 'pq' por 'porque', 'q' por 'que', "
"'tmb' por 'también'. Máximo 1 por mensaje.",
"default_on": False,
},
# ── Tono y carácter ───────────────────────────────────────────────────────
"humor_leve": {
"name": "Humor leve",
"desc": "Agrega humor sutil y colombiano cuando el contexto lo permite",
"category": "tono",
"intensity": 0.1,
"prompt_inject": "Cuando el contexto sea ligero, puedes agregar un toque de humor "
"colombiano sutil. Una frase divertida, nunca un chiste formal. "
"Ejemplo: 'ay qué casualidad' / 'eso sí me pasó a mí también jaja'. "
"Solo cuando el cliente esté de buen humor.",
"default_on": False,
},
"emojis_puntuales": {
"name": "Emojis puntuales",
"desc": "Usa 1 emoji por mensaje cuando añade calor genuino",
"category": "tono",
"intensity": 0.3,
"prompt_inject": "Puedes usar 1 emoji por burbuja cuando añada calor genuino. "
"Nunca al inicio de oración. Nunca más de 1. Solo si es natural: "
"'te espero el jueves 🗓' / 'quedó confirmado ✓'",
"default_on": False,
},
"pausas_pensando": {
"name": "Pausas pensando",
"desc": "Usa '...' para simular que piensa antes de responder",
"category": "tono",
"intensity": 0.1,
"prompt_inject": "A veces, cuando estás buscando información o considerando algo, "
"puedes usar '...' al inicio para simular que estás pensando: "
"'... mira te cuento' / '... a ver déjame verificar eso'",
"default_on": False,
},
"tuteo_intenso": {
"name": "Tuteo muy informal",
"desc": "Tuteo extremadamente informal, como una amiga colombiana",
"category": "tono",
"intensity": 1.0,
"prompt_inject": "Tuteo muy informal y cercano. Como si fuera una amiga del mismo "
"barrio. 'oye', 'mira', 'ay sí', 'uy qué bacano', 'eso sí'. "
"Sin ninguna formalidad, ni siquiera 'por favor'.",
"default_on": False,
},
"respuestas_ultracortas": {
"name": "Respuestas ultra-cortas",
"desc": "Máximo 8 palabras por burbuja, siempre",
"category": "longitud",
"intensity": 1.0,
"prompt_inject": "REGLA ABSOLUTA: Cada burbuja máximo 8 palabras. "
"Si necesitas más, usa ||| para otra burbuja. "
"Nunca una burbuja de más de 8 palabras. Cuenta las palabras.",
"default_on": False,
},
"preguntas_diagnostico": {
"name": "Diagnóstico activo",
"desc": "Siempre hace UNA pregunta de diagnóstico antes de ofrecer",
"category": "ventas",
"intensity": 1.0,
"prompt_inject": "SIEMPRE que un cliente pregunte por un servicio, haz exactamente "
"UNA pregunta de diagnóstico ANTES de dar información. "
"Nunca ofrezcas nada sin entender primero el caso específico. "
"La pregunta más poderosa: 'qué fue lo que te hizo escribirnos hoy'",
"default_on": True,
},
"cierre_fecha_unica": {
"name": "Cierre con fecha única",
"desc": "Siempre propone UN día concreto, nunca opciones",
"category": "ventas",
"intensity": 1.0,
"prompt_inject": "Al proponer una cita, SIEMPRE un solo día concreto. "
"NUNCA: 'jueves o viernes'. "
"SIEMPRE: 'esta semana tienes el jueves, te queda bien'. "
"Si no acepta, entonces negocia.",
"default_on": True,
},
"sin_preguntas_dobles": {
"name": "Sin preguntas dobles",
"desc": "Nunca hace dos preguntas en el mismo mensaje",
"category": "flujo",
"intensity": 1.0,
"prompt_inject": "REGLA ABSOLUTA: UNA sola pregunta por mensaje. "
"Si tienes dos preguntas, elige la más importante. "
"Nunca: 'qué servicio buscas y cuándo puedes venir'",
"default_on": True,
},
}
class SkillEngine:
"""
Motor de skills de comportamiento.
Las skills son modificadores del comportamiento de Conny que el dueño
puede activar/desactivar en caliente. Cada skill tiene:
- Un prompt_inject que se añade al system prompt cuando está activa
- Una intensidad (probabilidad de aplicar por mensaje)
- Una categoría para organizarlas
La diferencia con el arquetipo: el arquetipo define la personalidad base.
Las skills son modificadores específicos sobre esa base.
"""
DB_KEY = "v8_skills_state"
def __init__(self):
self._active: Dict[str, bool] = {}
self._loaded = False
def _load(self):
"""Carga el estado de skills desde la DB."""
if self._loaded:
return
try:
if db:
raw = db.recall(self.DB_KEY)
if raw:
state = json.loads(raw)
self._active = {k: bool(v) for k, v in state.items()}
except Exception:
pass
# Aplicar defaults para skills no guardadas
for skill_id, skill_def in SKILL_DEFINITIONS.items():
if skill_id not in self._active:
self._active[skill_id] = skill_def.get("default_on", False)
self._loaded = True
def _save(self):
"""Persiste el estado de skills en DB."""
try:
if db:
db.remember(self.DB_KEY, json.dumps(self._active), "config")
except Exception:
pass
def get_active(self) -> List[str]:
"""Retorna IDs de skills activas."""
self._load()
return [k for k, v in self._active.items() if v]
def toggle(self, skill_id: str, on: bool) -> Dict:
"""Activa o desactiva una skill. Retorna resultado."""
self._load()
if skill_id not in SKILL_DEFINITIONS:
return {"ok": False, "error": f"Skill '{skill_id}' no existe"}
self._active[skill_id] = on
self._save()
skill = SKILL_DEFINITIONS[skill_id]
return {
"ok": True,
"skill": skill_id,
"name": skill["name"],
"active": on,
"desc": skill["desc"],
}
def get_prompt_injection(self) -> str:
"""
Retorna el bloque de instrucciones de todas las skills activas.
Se inyecta al system prompt en cada llamada al LLM.
"""
self._load()
active_skill_ids = [
k for k in self._active
if self._active[k] and k in SKILL_DEFINITIONS
]
return self.render_prompt_injection(
active_skill_ids,
header="SKILLS ACTIVAS (el dueño las configuró):",
)
def render_prompt_injection(self, skill_ids: List[str], header: str) -> str:
"""Renderiza un bloque de instrucciones para una lista arbitraria de skills."""
active_skills = [SKILL_DEFINITIONS[k] for k in skill_ids if k in SKILL_DEFINITIONS]
if not active_skills:
return ""
lines = ["━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
header,
"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"]
for skill in active_skills:
lines.append(f"\n[SKILL: {skill['name']}]")
lines.append(skill["prompt_inject"])
lines.append("")
return "\n".join(lines)
def apply_post_filter(self, response: str, chat_id: str = "") -> str:
"""
Aplica transformaciones post-generación para skills de escritura.
Estas se aplican DESPUÉS del LLM, no en el prompt.
"""
self._load()
# Skill: typos_naturales
if self._active.get("typos_naturales") and len(response.split()) > 8:
skill = SKILL_DEFINITIONS["typos_naturales"]
if _random_trainer.random() < skill["intensity"]:
response = self._apply_typo(response, skill["examples"])
# Skill: minusculas_inicio
if self._active.get("minusculas_inicio") and len(response.split()) <= 10:
if _random_trainer.random() < SKILL_DEFINITIONS["minusculas_inicio"]["intensity"]:
response = response[0].lower() + response[1:] if response else response
# Skill: sin_tildes_ocasional
if self._active.get("sin_tildes_ocasional"):
if _random_trainer.random() < SKILL_DEFINITIONS["sin_tildes_ocasional"]["intensity"]:
response = self._strip_random_tildes(response)
return response
def _apply_typo(self, text: str, examples: List[tuple]) -> str:
"""Aplica un typo aleatorio de los ejemplos."""
available = [(a, b) for a, b in examples if f" {a} " in f" {text.lower()} "]
if not available:
return text
original, typo = _random_trainer.choice(available)
# Reemplazar solo la primera ocurrencia
return re.sub(rf'\b{re.escape(original)}\b', typo, text, count=1, flags=re.IGNORECASE)
def _strip_random_tildes(self, text: str) -> str:
"""Quita tildes de una palabra aleatoria."""
TILDES = {"á": "a", "é": "e", "í": "i", "ó": "o", "ú": "u",
"Á": "A", "É": "E", "Í": "I", "Ó": "O", "Ú": "U"}
words = text.split()
words_with_tildes = [i for i, w in enumerate(words) if any(c in w for c in TILDES)]
if not words_with_tildes:
return text
idx = _random_trainer.choice(words_with_tildes)
word = words[idx]
words[idx] = "".join(TILDES.get(c, c) for c in word)
return " ".join(words)
def list_all(self) -> List[Dict]:
"""Lista todas las skills con su estado."""
self._load()
result = []
for skill_id, skill_def in SKILL_DEFINITIONS.items():
result.append({
"id": skill_id,
"name": skill_def["name"],
"desc": skill_def["desc"],
"category": skill_def["category"],
"active": self._active.get(skill_id, skill_def.get("default_on", False)),
})
return result
class TrainerGateway:
"""
Gateway automático inspirado en OpenClaw.
No obliga al admin a recordar comandos o IDs de skills. Decide una capa
mínima de comportamiento según rol, canal, intención y preferencias
explícitas del usuario.
"""
DB_KEY = "v8_trainer_gateway_state"
def __init__(self):
self._state: Dict[str, bool] = {
"enabled": True,
"auto_admin": True,
"auto_user": True,
}
self._loaded = False
def _load(self):
if self._loaded:
return
try:
if db:
raw = db.recall(self.DB_KEY)
if raw:
parsed = json.loads(raw)
for key in self._state:
if key in parsed:
self._state[key] = bool(parsed[key])
except Exception:
pass
self._loaded = True
def _save(self):
try:
if db:
db.remember(self.DB_KEY, json.dumps(self._state), "config")
except Exception:
pass
def status(self) -> Dict[str, bool]:
self._load()
return dict(self._state)
def configure(
self,
*,
enabled: Optional[bool] = None,
auto_admin: Optional[bool] = None,
auto_user: Optional[bool] = None,
) -> Dict[str, Any]:
self._load()
if enabled is not None:
self._state["enabled"] = bool(enabled)
if auto_admin is not None:
self._state["auto_admin"] = bool(auto_admin)
if auto_user is not None:
self._state["auto_user"] = bool(auto_user)
self._save()
return {"ok": True, **self.status()}
def _is_on(self, key: str) -> bool:
self._load()
return bool(self._state.get("enabled")) and bool(self._state.get(key))
def _route_platform(self, chat_id: str) -> str:
try:
if db and chat_id:
platform = db.get_contact_route(chat_id)
if platform:
return str(platform)
except Exception:
pass
return str(getattr(Config, "PLATFORM", "telegram") or "telegram")
def detect_admin_learning_intent(self, text: str) -> bool:
normalized = _normalize_conv_text(text or "")
if not normalized or normalized.startswith("/"):
return False
patterns = [
"a mi hablame",
"a mí háblame",
"hablame de usted",
"háblame de usted",
"trátame de usted",
"tratame de usted",
"no me hables",
"no hables así",
"no hables asi",
"quiero que seas",
"quiero que respondas",
"desde ahora",
"cuando te diga",
"cuando el admin",
"a los administradores",
"a los admins",
"conmigo sé",
"conmigo se",
"para mi usa",
"para mí usa",
"cambia tu personalidad",
"cambia el tono",
"mas ejecutiva",
"más ejecutiva",
"mas humana",
"más humana",
]
return any(pattern in normalized for pattern in patterns)
def _service_keywords(self, clinic: Dict[str, Any]) -> List[str]:
keywords = [
"tratamiento", "servicio", "precio", "precios", "valor", "costo",
"cuanto", "cuánto", "botox", "relleno", "rellenos", "laser",
"láser", "valoracion", "valoración", "consulta",
]
services = clinic.get("services") if isinstance(clinic.get("services"), list) else []
for service in services[:12]:
token = _normalize_conv_text(str(service))
if token:
keywords.append(token)
return keywords
def _booking_keywords(self) -> List[str]:
return [
"cita", "citas", "agendar", "agenda", "horario", "horarios",
"disponibilidad", "disponible", "cuando puedo", "mañana", "manana",
"hoy", "jueves", "viernes", "esta semana", "proxima semana", "próxima semana",
]
def _recommend_skill_ids(
self,
*,
chat_id: str,
clinic: Dict[str, Any],
user_msg: str,
is_admin: bool,
patient: Optional[Dict[str, Any]] = None,
) -> List[str]:
if is_admin or not self._is_on("auto_user"):
return []
normalized = _normalize_conv_text(user_msg or "")
recommended: List[str] = ["sin_preguntas_dobles"]
if any(keyword in normalized for keyword in self._service_keywords(clinic)):
recommended.append("preguntas_diagnostico")
if any(keyword in normalized for keyword in self._booking_keywords()):
recommended.append("cierre_fecha_unica")
# WhatsApp tolera un poco más de calidez, pero sin llevar a Conny a lo informal.
if self._route_platform(chat_id) == "whatsapp" and any(
token in normalized for token in ["gracias", "perfecto", "super", "súper", "genial"]
):
recommended.append("emojis_puntuales")
# Preserva orden y evita duplicados.
seen = set()
ordered: List[str] = []
for skill_id in recommended:
if skill_id in SKILL_DEFINITIONS and skill_id not in seen:
seen.add(skill_id)
ordered.append(skill_id)
return ordered
def observe_user_preferences(
self,
*,
chat_id: str,
user_msg: str,
patient: Optional[Dict[str, Any]] = None,
is_admin: bool = False,
) -> Dict[str, Any]:
if is_admin:
return patient.get("preferences", {}) if isinstance(patient, dict) else {}
if not db or not chat_id:
return {}
patient = patient or db.get_or_create_patient(chat_id)
preferences = patient.get("preferences", {}) if isinstance(patient, dict) else {}
if not isinstance(preferences, dict):
preferences = {}
normalized = _normalize_conv_text(user_msg or "")
updated = dict(preferences)
changed = False
def _set_pref(key: str, value: Any):
nonlocal changed
if updated.get(key) != value:
updated[key] = value
changed = True
if any(token in normalized for token in ["trátame de usted", "tratame de usted", "háblame de usted", "hablame de usted", "de usted"]):
_set_pref("trato", "usted")
elif any(token in normalized for token in ["tuteame", "tutéame", "háblame normal", "hablame normal"]):
_set_pref("trato", "tu")
if any(token in normalized for token in ["sin emojis", "no emojis", "sin emoji", "no emoji", "sin caritas"]):
_set_pref("no_emojis", True)
elif any(token in normalized for token in ["puedes usar emojis", "usa emojis", "con emojis"]):
_set_pref("no_emojis", False)
if any(token in normalized for token in ["más corto", "mas corto", "más breve", "mas breve", "sin tanto texto", "responde corto"]):
_set_pref("brief", True)
elif any(token in normalized for token in ["más detalle", "mas detalle", "explícame bien", "explicame bien", "explícame mejor", "explicame mejor"]):
_set_pref("brief", False)
if any(token in normalized for token in ["dime el precio", "quiero precio", "dime cuánto", "dime cuanto", "sin tanta vuelta", "sin tanta vuelta dime"]):
_set_pref("prefiere_precios_directos", True)
if any(token in normalized for token in ["no me preguntes tanto", "sin tantas preguntas", "hazlo más directo", "hazlo mas directo"]):
_set_pref("menos_preguntas", True)
if changed:
db.update_patient(chat_id, preferences=updated)
return updated
def maybe_acknowledge_user_preference_message(
self,
*,
chat_id: str,
user_msg: str,
patient: Optional[Dict[str, Any]] = None,
) -> Optional[List[str]]:
"""
Si el mensaje del usuario solo está corrigiendo el estilo de Conny,
responde localmente sin pasar por el LLM para que el cambio se note
de inmediato y sin ruido robótico.
"""
normalized = _normalize_conv_text(user_msg or "")
if not normalized:
return None
preference_markers = [
"háblame", "hablame", "trátame", "tratame", "sin emojis",
"no emojis", "no emoji", "más corto", "mas corto", "más breve",
"mas breve", "sin tanto texto", "más directo", "mas directo",
"de usted", "tuteame", "tutéame",
]
business_markers = self._service_keywords({}) + self._booking_keywords()
if not any(marker in normalized for marker in preference_markers):
return None
if any(marker in normalized for marker in business_markers):
return None
prefs = self.observe_user_preferences(
chat_id=chat_id,
user_msg=user_msg,
patient=patient,
is_admin=False,
)
acknowledgements: List[str] = []
if prefs.get("trato") == "usted":
acknowledgements.append("Claro. Le hablo de usted desde ahora.")
elif prefs.get("trato") == "tu":
acknowledgements.append("Claro. Te hablo de tú desde ahora.")
if prefs.get("no_emojis"):
acknowledgements.append("También lo dejo sin emojis.")
if prefs.get("brief"):
acknowledgements.append("Y se lo respondo más corto y directo.")
if prefs.get("menos_preguntas"):
acknowledgements.append("Además voy con menos preguntas y más al punto.")
if acknowledgements:
return acknowledgements[:3]
return ["Listo. Ya ajusté la forma en que le respondo."]
def build_prompt_addon(
self,
*,
chat_id: str,
clinic: Dict[str, Any],
user_msg: str,
is_admin: bool,
patient: Optional[Dict[str, Any]] = None,
) -> str:
self._load()
if not self._state.get("enabled"):
return ""
lines: List[str] = []
if is_admin and self._state.get("auto_admin"):
lines.extend([
"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
"GATEWAY AUTOMÁTICO — MODO ADMIN",
"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
"Este chat es del administrador.",
"Respóndele con respeto, criterio y tono ejecutivo-natural.",
"No le hables como paciente ni le vendas servicios.",
"Si corrige el tono o la conducta, trátalo como instrucción operativa válida.",
])
if not is_admin and self._state.get("auto_user"):
auto_skill_ids = self._recommend_skill_ids(
chat_id=chat_id,
clinic=clinic,
user_msg=user_msg,
is_admin=is_admin,
patient=patient,
)
if auto_skill_ids and skill_engine:
rendered = skill_engine.render_prompt_injection(
auto_skill_ids,
header="SKILLS AUTOMÁTICAS DEL GATEWAY (no se las menciones al usuario):",
)
if rendered:
lines.append(rendered)
prefs = self.observe_user_preferences(
chat_id=chat_id,
user_msg=user_msg,
patient=patient,
is_admin=is_admin,
)
pref_lines: List[str] = []
if prefs.get("trato") == "usted":
pref_lines.append("A esta persona háblale de usted, con respeto claro y sin sonar acartonada.")
elif prefs.get("trato") == "tu":
pref_lines.append("A esta persona puedes hablarle de tú, manteniendo calidez profesional.")
if prefs.get("no_emojis"):
pref_lines.append("No uses emojis con esta persona.")
if prefs.get("brief"):
pref_lines.append("Esta persona prefiere respuestas más breves y directas.")
if prefs.get("prefiere_precios_directos"):
pref_lines.append("Si pregunta por precio, responde el valor o la lógica del valor antes de desviar la conversación.")
if prefs.get("menos_preguntas"):
pref_lines.append("Evita cadenas de preguntas. Prioriza una sola pregunta útil y, si puedes, resuelve directo.")
if pref_lines:
lines.append(
"\n".join([
"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
"PREFERENCIAS APRENDIDAS DEL USUARIO",
"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
*pref_lines,
])
)
return "\n\n".join(block for block in lines if block).strip()
class OwnerStyleController:
"""
Plano de control duro del owner/admin sobre cómo habla Conny.
A diferencia del PromptEvolver, esto no es solo "aprendizaje".
Aquí guardamos restricciones y preferencias que deben cumplirse sí o sí
antes de enviar cada respuesta.
"""
DB_KEY = "v8_owner_style_control"
_EMOJI_RE = re.compile(
"["
"\U0001F600-\U0001F64F"
"\U0001F300-\U0001F5FF"
"\U0001F680-\U0001F6FF"
"\U0001F1E0-\U0001F1FF"
"\U00002500-\U00002BEF"
"\U00002702-\U000027B0"
"\U0001F900-\U0001F9FF"
"\U0001FA00-\U0001FAFF"
"\u2600-\u26FF"
"\u2700-\u27BF"
"]+",
flags=re.UNICODE
)
def __init__(self):
self._state: Dict[str, Any] = {
"enabled": True,
"global": self._blank_bucket(),
"admin": self._seed_admin_defaults(
self._blank_bucket(register="usted", respectful=True, no_emojis=True)
),
"patient": self._seed_patient_defaults(
self._blank_bucket(register="auto", respectful=True, no_emojis=True)
),
}
self._loaded = False
def _blank_bucket(
self,
*,
register: str = "auto",
respectful: bool = True,
no_emojis: bool = False, # v11: emojis ON por defecto — Colombia negocio
) -> Dict[str, Any]:
return {
"forbidden_phrases": [],
"forbidden_starts": [],
"replacement_map": {},
"style_notes": [],
"greeting_template": "",
"second_bubble_template": "",
"third_bubble_template": "",
"closing_template": "",
"fallback_template": "",
"max_bubbles": 0,
"register": register,
"respectful": respectful,
"no_emojis": no_emojis,
"lowercase_start": False,
}
def _seed_admin_defaults(self, bucket: Dict[str, Any]) -> Dict[str, Any]:
bucket = dict(bucket or {})
bucket.setdefault("register", "usted")
bucket.setdefault("respectful", True)
bucket.setdefault("no_emojis", False) # v11: emojis ON por defecto
if not bucket.get("style_notes"):
bucket["style_notes"] = [
"Con el admin habla con respeto, claridad y criterio.",
"Nunca le hables como paciente.",
]
if not bucket.get("greeting_template"):
bucket["greeting_template"] = "Hola, {admin_name}."
if not bucket.get("second_bubble_template"):
bucket["second_bubble_template"] = "Estoy lista para ayudarle con la instancia, el tono, los servicios o las pruebas."
return bucket
def _seed_patient_defaults(self, bucket: Dict[str, Any]) -> Dict[str, Any]:
bucket = dict(bucket or {})
bucket.setdefault("register", "auto")
bucket.setdefault("respectful", True)
bucket.setdefault("no_emojis", False) # v11: emojis ON por defecto
if not bucket.get("forbidden_starts"):
bucket["forbidden_starts"] = [
"oye",
"a ver",
"mira",
"claro",
"listo",
]
if not bucket.get("style_notes"):
bucket["style_notes"] = [
"Suena humana, clara y profesional.",
"No suenes robótica ni demasiado explicativa.",
"Si el admin pide tuteo, úsalo natural, sostenido y colombiano, sin mezclarlo con usted.",
]
if not bucket.get("greeting_template"):
bucket["greeting_template"] = "{welcome_line}"
if not bucket.get("second_bubble_template"):
bucket["second_bubble_template"] = "{welcome_identity}"
if not bucket.get("third_bubble_template"):
bucket["third_bubble_template"] = "{welcome_question}"
if not bucket.get("max_bubbles"):
bucket["max_bubbles"] = 3
return bucket
def _load(self):
if self._loaded:
return
try:
if db:
raw = db.recall(self.DB_KEY)
if raw:
parsed = json.loads(raw)
if isinstance(parsed, dict):
for key in ("enabled", "global", "admin", "patient"):
if key not in parsed:
continue
if key == "enabled":
self._state["enabled"] = bool(parsed.get("enabled"))
continue
if isinstance(parsed.get(key), dict):
merged = self._blank_bucket(**{
"register": self._state[key].get("register", "auto"),
"respectful": bool(self._state[key].get("respectful", True)),
"no_emojis": bool(self._state[key].get("no_emojis", True)),
})
merged.update(parsed[key])
if key == "admin":
merged = self._seed_admin_defaults(merged)
elif key == "patient":
merged = self._seed_patient_defaults(merged)
self._state[key] = merged
except Exception:
pass
self._loaded = True
def _save(self):
try:
if db:
db.remember(self.DB_KEY, json.dumps(self._state, ensure_ascii=False), "config")
except Exception:
pass
def status(self) -> Dict[str, Any]:
self._load()
return json.loads(json.dumps(self._state, ensure_ascii=False))
def reset(self, scope: str = "all") -> Dict[str, Any]:
self._load()
scope = (scope or "all").strip().lower()
if scope in ("all", "todo", "*"):
self._state = {
"enabled": True,
"global": self._blank_bucket(),
"admin": self._seed_admin_defaults(
self._blank_bucket(register="usted", respectful=True, no_emojis=True)
),
"patient": self._seed_patient_defaults(
self._blank_bucket(register="auto", respectful=True, no_emojis=True)
),
}
elif scope in ("global", "admin", "patient"):
if scope == "admin":
self._state[scope] = self._seed_admin_defaults(
self._blank_bucket(register="usted", respectful=True, no_emojis=True)
)
elif scope == "patient":
self._state[scope] = self._seed_patient_defaults(
self._blank_bucket(register="auto", respectful=True, no_emojis=True)
)
else:
self._state[scope] = self._blank_bucket()
self._save()
return {"ok": True, "scope": scope, "state": self.status()}
def _normalize_text(self, value: str) -> str:
return _normalize_conv_text(value or "")
def _append_unique(self, bucket: Dict[str, Any], key: str, value: str) -> bool:
cleaned = (value or "").strip().strip("\"'“”.,:;")
if len(cleaned) < 2:
return False
low = self._normalize_text(cleaned)
items = bucket.setdefault(key, [])
if any(self._normalize_text(str(item)) == low for item in items):
return False
items.append(cleaned)
return True
def _scope_from_instruction(self, normalized: str) -> str:
admin_markers = [
"a mi", "a mí", "conmigo", "al admin", "a los administradores",
"a los admins", "para mi", "para mí", "cuando me hables",
"cuando le hables al admin", "con el admin", "al owner", "al dueno",
"al dueño", "a santiago", "cuando yo te escriba", "cuando yo le escriba",
"soy tu admin", "soy el admin", "soy tu dueño", "soy el dueño",
]
patient_markers = [
"a los pacientes", "a los clientes", "a la gente", "con pacientes",
"con clientes", "cuando te escriban", "cuando un paciente",
"cuando un cliente", "al paciente", "al cliente", "a los leads",
"con los pacientes", "con los clientes", "a pacientes", "a clientes",
"para pacientes", "para clientes", "para los pacientes", "para los clientes",
]
haystack = f" {normalized.strip()} "
def _contains_marker(marker: str) -> bool:
probe = f" {self._normalize_text(marker)} "
return probe in haystack
if any(_contains_marker(marker) for marker in patient_markers):
return "patient"
if any(_contains_marker(marker) for marker in admin_markers):
return "admin"
return "global"
def detect_control_intent(self, text: str) -> bool:
normalized = self._normalize_text(text)
if not normalized or normalized.startswith("/"):
return False
if re.search(r'\b(?:1|2|3|una|uno|dos|tres)\s+mensajes?\b', normalized):
return True
signals = [
"no digas", "nunca digas", "no uses", "evita decir", "evita usar",
"prohibido decir", "no empieces", "no abras con", "no arranques con",
"al inicio", "saluda asi", "saluda así", "presentate asi",
"preséntate así", "abre asi", "abre así", "háblame de usted",
"hablame de usted", "trátame de usted", "tratame de usted",
"hablales de usted", "háblales de usted", "tratalos de usted",
"trátalos de usted", "tratelos de usted", "trátelos de usted",
"de usted con los pacientes", "de usted con los clientes",
"hablales de tu", "háblales de tú", "tutealos", "tutéalos",
"tratales de tu", "trátales de tú", "tutea", "tutear",
"tutealas", "tutéalas", "trátalas de tú", "tratalas de tu",
"aqui las mujeres se tutean", "aquí las mujeres se tutean",
"en colombia tutea", "en colombia se tutea",
"tuteame", "tutéame", "sin emojis", "no emojis", "no emoji",
"segunda burbuja", "segundo mensaje", "despues di", "después di",
"tercera burbuja", "tercer mensaje", "cierra asi", "cierra así",
"termina asi", "termina así",
"reemplaza", "mayusculas", "mayúsculas", "todo en mayúsculas",
"no digas que eres un bot", "no digas que eres ia",
"no digas que eres una ia", "no digas inteligencia artificial",
"si no entiendes", "si no entiendes di", "si no sabes", "si no sabes que decir",
"cuando no entiendas", "cuando no sepas", "fuera de contexto responde",
"una burbuja", "1 burbuja", "dos burbujas", "2 burbujas", "tres burbujas", "3 burbujas",
"responde en", "maximo", "máximo",
"mas ejecutivo", "más ejecutivo", "mas ejecutiva", "más ejecutiva",
"mas humana", "más humana", "mas directa", "más directa",
"mas corto", "más corto", "mas seria", "más seria",
"no hables asi", "no hables así", "desde ahora",
]
return any(signal in normalized for signal in signals)
def _parse_bubble_limit(self, normalized: str) -> int:
if "burbuja" not in normalized and "mensaje" not in normalized:
return 0
word_map = {
"una": 1,
"1": 1,
"dos": 2,
"2": 2,
"tres": 3,
"3": 3,
}
patterns = [
r'(?:maximo|max\.?|máximo)\s+(una|1|dos|2|tres|3)\s+(?:burbujas?|mensajes?)',
r'(?:en|usa|con|hazlo en|responde en)\s+(una|1|dos|2|tres|3)\s+(?:burbujas?|mensajes?)',
r'(una|1|dos|2|tres|3)\s+(?:sola\s+)?(?:burbujas?|mensajes?)',
]
for pattern in patterns:
match = re.search(pattern, normalized, flags=re.IGNORECASE)
if not match:
continue
token = (match.group(1) or "").strip().lower()
return int(word_map.get(token, 0) or 0)
if "sin limite de burbujas" in normalized or "sin limite de mensajes" in normalized or "sin limite" in normalized:
return 0
return 0
def _extract_phrase(self, text: str, patterns: List[str]) -> str:
for pattern in patterns:
match = re.search(pattern, text or "", flags=re.IGNORECASE)
if match:
candidate = match.group(1).strip().strip("\"'“”.,:;")
if candidate:
return candidate
return ""
def apply_instruction(self, text: str, admin_chat_id: str = "") -> Dict[str, Any]:
self._load()
raw_text = (text or "").strip()
normalized = self._normalize_text(raw_text)
if not self.detect_control_intent(text):
return {"ok": False, "reason": "no_control_intent"}
scope = self._scope_from_instruction(normalized)
bucket = self._state[scope]
applied: List[str] = []
replacement_applied = False
quoted = [m.strip() for m in re.findall(r"[\"“]([^\"”]+)[\"”]", raw_text) if m.strip()]
if len(quoted) >= 2 and any(token in normalized for token in ["no digas", "evita decir", "no uses", "evita usar", "reemplaza"]):
bad = quoted[0].strip()
good = quoted[1].strip()
if bad and good:
bucket.setdefault("replacement_map", {})[bad] = good
bucket["forbidden_phrases"] = [
item for item in bucket.get("forbidden_phrases", [])
if self._normalize_text(str(item)) != self._normalize_text(bad)
]
applied.append(f"actualicé un reemplazo obligatorio en {scope}")
replacement_applied = True
if not applied:
natural_replacement = re.search(
r'(?:no\s+digas|evita\s+decir)\s+[\"“\' ]*([^,\"”\'\n]+?)[\"”\' ]*\s*,?\s*(?:di|usa|mejor\s+di)\s+[\"“\' ]*([^\"”\'\n]+?)[\"”\' ]*(?:$|[.;])',
raw_text,
flags=re.IGNORECASE,
)
if not natural_replacement:
natural_replacement = re.search(
r'(?:reemplaza|cambia)\s+[\"“\' ]*([^,\"”\'\n]+?)[\"”\' ]*\s+por\s+[\"“\' ]*([^\"”\'\n]+?)[\"”\' ]*(?:$|[.;])',
raw_text,
flags=re.IGNORECASE,
)
if natural_replacement:
bad = natural_replacement.group(1).strip(" \"'“”.,:;")
good = natural_replacement.group(2).strip(" \"'“”.,:;")
if bad and good:
bucket.setdefault("replacement_map", {})[bad] = good
bucket["forbidden_phrases"] = [
item for item in bucket.get("forbidden_phrases", [])
if self._normalize_text(str(item)) != self._normalize_text(bad)
]
applied.append(f"actualicé un reemplazo obligatorio en {scope}")
replacement_applied = True
start_phrase = self._extract_phrase(raw_text, [
r'(?:no\s+(?:empieces|abras|arranques)\s+con)\s+[\"“]?([^\"”\n]+?)[\"”]?(?:$|[.,;])',
r'(?:no\s+(?:uses|digas))\s+[\"“]?([^\"”\n]+?)[\"”]?\s+al\s+inicio\b',
])
if start_phrase and self._append_unique(bucket, "forbidden_starts", start_phrase):
applied.append(f"bloqueé el arranque «{start_phrase}» en {scope}")
forbidden_phrase = self._extract_phrase(raw_text, [
r'(?:no\s+digas|nunca\s+digas|evita\s+decir|prohibido\s+decir)\s+[\"“]?([^\"”\n]+?)[\"”]?(?:$|[.,;])',
r'(?:no\s+uses|evita\s+usar)\s+[\"“]?([^\"”\n]+?)[\"”]?(?:$|[.,;])',
])
forbidden_phrase = re.sub(r'\s+al\s+inicio$', '', forbidden_phrase or '', flags=re.IGNORECASE).strip()
if forbidden_phrase and forbidden_phrase != start_phrase and not replacement_applied:
if self._append_unique(bucket, "forbidden_phrases", forbidden_phrase):
applied.append(f"prohibí la frase «{forbidden_phrase}» en {scope}")
greeting_template = self._extract_phrase(raw_text, [
r'(?:saluda\s+asi|saluda\s+así|presentate\s+asi|preséntate\s+así|abre\s+asi|abre\s+así)\s*(?:[:\-]\s*)?(.+)$',
r'(?:presentate\s+como|preséntate\s+como)\s*(?:[:\-]\s*)?(.+)$',
])
if greeting_template:
bucket["greeting_template"] = greeting_template.strip()
applied.append(f"actualicé el saludo base de {scope}")
second_bubble_template = self._extract_phrase(raw_text, [
r'(?:segunda\s+burbuja|segundo\s+mensaje|despues\s+di|después\s+di)\s*(?:[:\-]\s*)?(.+)$',
])
if second_bubble_template:
bucket["second_bubble_template"] = second_bubble_template.strip()
applied.append(f"actualicé la segunda burbuja base de {scope}")
third_bubble_template = self._extract_phrase(raw_text, [
r'(?:tercera\s+burbuja|tercer\s+mensaje)\s*(?:[:\-]\s*)?(.+)$',
])
if third_bubble_template:
bucket["third_bubble_template"] = third_bubble_template.strip()
applied.append(f"actualicé la tercera burbuja base de {scope}")
closing_template = self._extract_phrase(raw_text, [
r'(?:cierra\s+asi|cierra\s+así|termina\s+asi|termina\s+así)\s*(?:[:\-]\s*)?(.+)$',
])
if closing_template:
bucket["closing_template"] = closing_template.strip()
applied.append(f"actualicé el cierre base de {scope}")
fallback_template = self._extract_phrase(raw_text, [
r'(?:si\s+no\s+entiendes(?:\s+di)?|si\s+no\s+sabes(?:\s+que\s+decir)?(?:\s+di)?|cuando\s+no\s+entiendas(?:\s+di)?|fuera\s+de\s+contexto\s+responde)\s*(?:[:\-]\s*)?(.+)$',
])
if fallback_template:
bucket["fallback_template"] = fallback_template.strip()
applied.append(f"actualicé el fallback de {scope}")
max_bubbles = self._parse_bubble_limit(normalized)
if max_bubbles:
bucket["max_bubbles"] = max_bubbles
applied.append(f"dejé {scope} en máximo {max_bubbles} burbuja(s)")
if any(token in normalized for token in ["sin emojis", "no emojis", "no emoji", "sin emoji"]):
bucket["no_emojis"] = True
applied.append(f"dejé {scope} sin emojis")
elif any(token in normalized for token in ["usa emojis", "con emojis", "puedes usar emojis"]):
bucket["no_emojis"] = False
applied.append(f"permití emojis en {scope}")
if any(token in normalized for token in [
"minúscula al inicio", "minuscula al inicio", "sin mayúscula al inicio", "sin mayuscula al inicio",
"arranca en minúscula", "arranca en minuscula", "empieza en minúscula", "empieza en minuscula",
]):
bucket["lowercase_start"] = True
applied.append(f"dejé {scope} con minúscula inicial cuando aplique")
elif any(token in normalized for token in [
"mayúscula al inicio", "mayuscula al inicio", "empieza con mayúscula", "empieza con mayuscula",
"arranca con mayúscula", "arranca con mayuscula", "primera en mayúscula", "primera en mayuscula",
]):
bucket["lowercase_start"] = False
applied.append(f"dejé {scope} con mayúscula inicial por defecto")
if any(token in normalized for token in [
"háblame de usted", "hablame de usted", "trátame de usted", "tratame de usted",
"hablales de usted", "háblales de usted", "tratalos de usted", "trátalos de usted",
"tratelos de usted", "trátelos de usted", "de usted con los pacientes",
"de usted con los clientes", "de usted con la gente", "de usted",
]):
bucket["register"] = "usted"
applied.append(f"dejé el trato de {scope} en usted")
elif any(token in normalized for token in [
"tuteame", "tutéame", "háblame de tú", "hablame de tu", "háblame de tu",
"hablales de tu", "háblales de tú", "tratales de tu", "trátales de tú",
"tutealos", "tutéalos", "tutealas", "tutéalas", "tratalas de tu",
"trátalas de tú", "tutea", "tutear", "de tú",
"aqui las mujeres se tutean", "aquí las mujeres se tutean",
"en colombia tutea", "en colombia se tutea",
]):
bucket["register"] = "tu"
applied.append(f"dejé el trato de {scope} en tú")
if any(token in normalized for token in [
"colombia", "mujeres se tutean", "tutea",
]):
self._append_unique(
bucket,
"style_notes",
"Cuando el admin lo pida, usa tuteo femenino colombiano: cercano, elegante y natural.",
)
style_map = [
("más ejecutiv", "tono ejecutivo y preciso"),
("mas ejecutiv", "tono ejecutivo y preciso"),
("más human", "tono humano y natural"),
("mas human", "tono humano y natural"),
("más direct", "más directo y sin rodeos"),
("mas direct", "más directo y sin rodeos"),
("más cálid", "más cálido sin perder claridad"),
("mas calid", "más cálido sin perder claridad"),
("más seri", "más serio y sobrio"),
("mas seri", "más serio y sobrio"),
("más cort", "respuestas más cortas"),
("mas cort", "respuestas más cortas"),
("menos informal", "menos informal"),
("menos bot", "menos bot y más natural"),
]
for token, note in style_map:
if token in normalized and self._append_unique(bucket, "style_notes", note):
applied.append(f"sumé la guía «{note}» en {scope}")
if not applied:
free_note = (text or "").strip()
if free_note and self._append_unique(bucket, "style_notes", free_note):
applied.append(f"guardé la instrucción en {scope}")
if not applied:
return {"ok": False, "reason": "no_changes"}
self._save()
return {
"ok": True,
"scope": scope,
"applied": applied,
"state": self.status(),
"reply_lines": [
"Listo. Ya quedó aplicado.",
*applied[:3],
],
}
def _merged_bucket(self, scope: str) -> Dict[str, Any]:
self._load()
merged = self._blank_bucket(
register=self._state.get("global", {}).get("register", "auto"),
respectful=bool(self._state.get("global", {}).get("respectful", True)),
no_emojis=bool(self._state.get("global", {}).get("no_emojis", True)),
)
merged.update(self._state.get("global", {}))
specific = self._state.get(scope, {})
for key in ("forbidden_phrases", "forbidden_starts", "style_notes"):
merged[key] = list(merged.get(key, [])) + list(specific.get(key, []))
merged["replacement_map"] = {
**(merged.get("replacement_map", {}) or {}),
**(specific.get("replacement_map", {}) or {}),
}
for key in (
"greeting_template",
"second_bubble_template",
"third_bubble_template",
"closing_template",
"fallback_template",
"register",
"respectful",
"no_emojis",
"max_bubbles",
"lowercase_start",
):
value = specific.get(key)
if value not in (None, "", []):
merged[key] = value
return merged
def build_prompt_addon(self, *, is_admin: bool) -> str:
self._load()
if not self._state.get("enabled"):
return ""
scope = "admin" if is_admin else "patient"
merged = self._merged_bucket(scope)
lines = [
"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
"CONTROL DURO DEL ADMIN",
"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
]
if is_admin:
lines.append("Este chat es del administrador. Respóndele con respeto y criterio.")
if merged.get("register") == "usted":
lines.append("Usa trato de usted.")
elif merged.get("register") == "tu":
lines.append("Usa trato de tú, natural y consistente.")
if merged.get("no_emojis"):
lines.append("No uses emojis en ningún mensaje.")
else:
lines.append(
"Emojis: úsalos con criterio — 1 por burbuja máximo, solo cuando refuercen "
"el mensaje (nunca decorativos ni al inicio de burbuja). "
"Ejemplos naturales para negocios colombianos: 😊 calidez, 📅 cita, "
"✅ confirmación, 📍 ubicación, 💬 invitación a escribir. "
"Si el tono es serio o el cliente es frío, no pongas emojis."
)
if merged.get("greeting_template"):
lines.append(f'Si es saludo inicial, usa esta base: "{merged["greeting_template"]}"')
if merged.get("second_bubble_template"):
lines.append(f'Segunda burbuja fija: "{merged["second_bubble_template"]}"')
if merged.get("third_bubble_template"):
lines.append(f'Tercera burbuja fija: "{merged["third_bubble_template"]}"')
if merged.get("closing_template"):
lines.append(f'Cierre fijo: "{merged["closing_template"]}"')
if merged.get("fallback_template"):
lines.append(f'Si no entiendes o algo se sale de contexto, usa esta base: "{merged["fallback_template"]}"')
if merged.get("max_bubbles"):
lines.append(f'Usa máximo {merged["max_bubbles"]} burbuja(s).')
replacement_map = merged.get("replacement_map", {}) or {}
if replacement_map:
lines.append(
"Reemplazos obligatorios: " +
" | ".join(f'{bad}→{good}' for bad, good in list(replacement_map.items())[:8])
)
forbidden_phrases = [str(x).strip() for x in merged.get("forbidden_phrases", []) if str(x).strip()]
if forbidden_phrases:
lines.append("Frases prohibidas: " + ", ".join(forbidden_phrases[:10]))
forbidden_starts = [str(x).strip() for x in merged.get("forbidden_starts", []) if str(x).strip()]
if forbidden_starts:
lines.append("No abras ni empieces burbujas con: " + ", ".join(forbidden_starts[:10]))
notes = [str(x).strip() for x in merged.get("style_notes", []) if str(x).strip()]
if notes:
lines.append("Guías adicionales: " + " | ".join(notes[:6]))
return "\n".join(lines)
def _strip_forbidden_phrase(self, text: str, phrase: str) -> str:
raw = (phrase or "").strip()
if not raw:
return text
if re.fullmatch(r"[\wáéíóúüñÁÉÍÓÚÜÑ]+", raw):
pattern = re.compile(rf'(? str:
escaped = re.escape(phrase.strip())
pattern = re.compile(rf'^\s*(?:{escaped})\b[\s,;:.-]*', flags=re.IGNORECASE)
return pattern.sub("", text).strip()
def _normalize_register(self, text: str, register: str) -> str:
if register not in ("usted", "tu"):
return text
if register == "usted":
replacements = [
(r'\bte ayudo\b', 'le ayudo'),
(r'\bte dejo\b', 'le dejo'),
(r'\bte muestro\b', 'le muestro'),
(r'\bte respondo\b', 'le respondo'),
(r'\bte explico\b', 'le explico'),
(r'\bte confirmo\b', 'le confirmo'),
(r'\bte tomo\b', 'le tomo'),
(r'\bte interesa\b', 'le interesa'),
(r'\bte sirve\b', 'le sirve'),
(r'\bte gustaría\b', 'le gustaría'),
(r'\bsi quieres\b', 'si quiere'),
(r'\bsi te parece\b', 'si le parece'),
(r'\bpuedes\b', 'puede'),
(r'\bquieres\b', 'quiere'),
(r'\btienes\b', 'tiene'),
(r'\bdime\b', 'dígame'),
(r'\bcuéntame\b', 'cuénteme'),
(r'\bmandame\b', 'mándeme'),
(r'\bmándame\b', 'mándeme'),
(r'\bavisame\b', 'avíseme'),
(r'\bavísame\b', 'avíseme'),
]
else:
replacements = [
(r'\ble ayudo\b', 'te ayudo'),
(r'\ble dejo\b', 'te dejo'),
(r'\ble muestro\b', 'te muestro'),
(r'\ble respondo\b', 'te respondo'),
(r'\ble explico\b', 'te explico'),
(r'\ble confirmo\b', 'te confirmo'),
(r'\ble tomo\b', 'te tomo'),
(r'\ble interesa\b', 'te interesa'),
(r'\ble sirve\b', 'te sirve'),
(r'\ble gustaría\b', 'te gustaría'),
(r'\bsi quiere\b', 'si quieres'),
(r'\bsi le parece\b', 'si te parece'),
(r'\bpuede\b', 'puedes'),
(r'\bquiere\b', 'quieres'),
(r'\btiene\b', 'tienes'),
(r'\bdigame\b', 'dime'),
(r'\bdígame\b', 'dime'),
(r'\bcuenteme\b', 'cuéntame'),
(r'\bcuénteme\b', 'cuéntame'),
(r'\bmandeme\b', 'mándame'),
(r'\bmándeme\b', 'mándame'),
(r'\baviseme\b', 'avísame'),
(r'\bavíseme\b', 'avísame'),
(r'\busted\b', 'tú'),
]
output = text
for pattern, repl in replacements:
output = re.sub(pattern, repl, output, flags=re.IGNORECASE)
return output
def _render_template(
self,
template: str,
*,
is_admin: bool,
chat_id: str = "",
clinic: Optional[Dict[str, Any]] = None,
user_msg: str = "",
) -> str:
raw = (template or "").strip()
if not raw:
return ""
admin_name = "Santiago"
if chat_id and db:
try:
admin = db.get_admin(chat_id)
if admin and admin.get("name"):
admin_name = str(admin["name"]).strip().title()
except Exception:
pass
clinic_name = ""
if isinstance(clinic, dict):
clinic_name = str(clinic.get("name") or "").strip()
welcome_line = _first_contact_welcome_line(clinic or {}, user_msg)
welcome_identity = _first_contact_identity_line(clinic or {})
welcome_question = _first_contact_question_line()
try:
return raw.format(
admin_name=admin_name,
clinic_name=clinic_name,
role="administrador" if is_admin else "cliente",
welcome_line=welcome_line,
welcome_identity=welcome_identity,
welcome_question=welcome_question,
).strip()
except Exception:
return raw
def _apply_replacement(self, text: str, bad: str, good: str) -> str:
source = (bad or "").strip()
target = (good or "").strip()
if not source:
return text
if re.fullmatch(r"[\wáéíóúüñÁÉÍÓÚÜÑ]+", source):
pattern = re.compile(rf'(? List[str]:
if not template:
return bubbles
cleaned_template = template.strip()
if not cleaned_template:
return bubbles
if not bubbles and index == 0:
return [cleaned_template]
while len(bubbles) <= index:
bubbles.append("")
current = bubbles[index].strip()
if current and self._normalize_text(current).startswith(self._normalize_text(cleaned_template)[:24]):
return bubbles
remainder = current
if index == 0 and remainder and self._normalize_text(remainder) != self._normalize_text(cleaned_template):
bubbles[index] = cleaned_template
bubbles.insert(index + 1, remainder)
return bubbles
bubbles[index] = cleaned_template
return bubbles
def enforce_output(
self,
response: str,
*,
is_admin: bool,
first_turn: bool = False,
chat_id: str = "",
clinic: Optional[Dict[str, Any]] = None,
user_msg: str = "",
) -> str:
self._load()
if not self._state.get("enabled"):
return response
scope = "admin" if is_admin else "patient"
merged = self._merged_bucket(scope)
bubbles = [b.strip() for b in re.split(r'\s*\|\|\|\s*', response or "") if b.strip()]
if not bubbles:
bubbles = [(response or "").strip()]
light_open = _is_greeting_only(user_msg)
if first_turn and light_open and merged.get("greeting_template"):
greeting_template = self._render_template(
merged.get("greeting_template", ""),
is_admin=is_admin,
chat_id=chat_id,
clinic=clinic,
user_msg=user_msg,
)
bubbles = self._apply_bubble_template(bubbles, greeting_template, 0)
if first_turn and light_open and merged.get("second_bubble_template"):
second_template = self._render_template(
merged.get("second_bubble_template", ""),
is_admin=is_admin,
chat_id=chat_id,
clinic=clinic,
user_msg=user_msg,
)
bubbles = self._apply_bubble_template(bubbles, second_template, 1)
if first_turn and light_open and merged.get("third_bubble_template"):
third_template = self._render_template(
merged.get("third_bubble_template", ""),
is_admin=is_admin,
chat_id=chat_id,
clinic=clinic,
user_msg=user_msg,
)
bubbles = self._apply_bubble_template(bubbles, third_template, 2)
cleaned_bubbles: List[str] = []
replacement_keys = {
self._normalize_text(str(key))
for key in (merged.get("replacement_map", {}) or {}).keys()
if str(key).strip()
}
for bubble in bubbles:
current = bubble.strip()
for bad, good in (merged.get("replacement_map", {}) or {}).items():
current = self._apply_replacement(current, str(bad), str(good))
for phrase in merged.get("forbidden_phrases", []):
if self._normalize_text(str(phrase)) in replacement_keys:
continue
current = self._strip_forbidden_phrase(current, str(phrase))
for start in merged.get("forbidden_starts", []):
current = self._strip_forbidden_start(current, str(start))
current = self._normalize_register(current, str(merged.get("register", "auto")))
if merged.get("no_emojis"):
current = self._EMOJI_RE.sub("", current)
current = current.replace("¿", "").replace("¡", "")
current = re.sub(r'\s+', ' ', current).strip(" ,;")
if current and current[0].islower() and not merged.get("lowercase_start"):
current = current[0].upper() + current[1:]
elif current and current[0].isupper() and merged.get("lowercase_start"):
current = current[0].lower() + current[1:]
if current:
cleaned_bubbles.append(current)
if merged.get("closing_template"):
closing_template = self._render_template(
merged.get("closing_template", ""),
is_admin=is_admin,
chat_id=chat_id,
clinic=clinic,
user_msg=user_msg,
)
if closing_template:
if cleaned_bubbles:
if self._normalize_text(closing_template) not in self._normalize_text(cleaned_bubbles[-1]):
cleaned_bubbles.append(closing_template)
else:
cleaned_bubbles = [closing_template]
max_bubbles = int(merged.get("max_bubbles") or 0)
if max_bubbles > 0 and len(cleaned_bubbles) > max_bubbles:
head = cleaned_bubbles[: max_bubbles - 1]
tail = " ".join(cleaned_bubbles[max_bubbles - 1:]).strip()
cleaned_bubbles = head + ([tail] if tail else [])
if not cleaned_bubbles:
if is_admin:
cleaned_bubbles = ["Entendido."]
elif str(merged.get("register", "auto")) == "tu":
cleaned_bubbles = ["Entiendo. Cuéntame un poco más."]
else:
cleaned_bubbles = ["Entiendo. Cuénteme un poco más."]
max_bubbles = int(merged.get("max_bubbles") or 0)
if max_bubbles > 0:
cleaned_bubbles = cleaned_bubbles[:max_bubbles]
return " ||| ".join(cleaned_bubbles)
def get_fallback_template(
self,
*,
is_admin: bool,
chat_id: str = "",
clinic: Optional[Dict[str, Any]] = None,
) -> str:
self._load()
if not self._state.get("enabled"):
return ""
scope = "admin" if is_admin else "patient"
merged = self._merged_bucket(scope)
template = str(merged.get("fallback_template") or "").strip()
if not template:
return ""
return self._render_template(template, is_admin=is_admin, chat_id=chat_id, clinic=clinic)
# ═══════════════════════════════════════════════════════════════════════════════
# PROMPT EVOLVER
# El dueño escribe en lenguaje natural "quiero que Conny..." y el sistema
# lo convierte en una instrucción estructurada que se añade al system prompt.
# Se puede deshacer instrucción por instrucción.
# ═══════════════════════════════════════════════════════════════════════════════
class PromptEvolver:
"""
Auto-modifica el system prompt de Conny basado en instrucciones
en lenguaje natural del dueño.
Funciona como un stack de evoluciones — cada evolución se guarda
y se puede deshacer. El prompt nunca se sobreescribe, se extiende.
Ejemplo de uso desde el bot:
Admin: /aprender "a veces responde sin tildes como WhatsApp real"
Conny: "Entendido. Activé el skill 'sin_tildes_ocasional'. ¿Lo probamos?"
Admin: /aprender "cuando alguien dice que está ocupada, no insistas con la cita"
Conny: "Guardado. Nueva regla: respetar cuando el cliente dice que está ocupada."
"""
DB_KEY_EVOLUTIONS = "v8_prompt_evolutions"
MAX_EVOLUTIONS = 20
# Mapeo de instrucciones naturales → skills conocidas
SKILL_KEYWORDS: Dict[str, List[str]] = {
"typos_naturales": ["typo", "error de tipeo", "error tipeo", "errores de escritura",
"no tan perfecta ortografia", "ortografia imperfecta",
"escribe mal", "errores naturales"],
"minusculas_inicio": ["minuscula", "sin mayuscula", "sin capital", "lowercase",
"no mayuscula al inicio", "no capitalizar", "minúsculas"],
"sin_tildes_ocasional": ["sin tildes", "sin acento", "omitir tildes", "sin tilde",
"a veces sin tildes"],
"abreviaciones": ["abreviacion", "abreviatura", "xq", "pq", "tmb"],
"humor_leve": ["humor", "gracioso", "divertido", "chiste", "jaja"],
"emojis_puntuales": ["emoji", "emojis", "caritas", "iconos"],
"respuestas_ultracortas": ["corto", "breve", "corta", "pocas palabras", "ultra corto",
"muy corto", "más corto"],
"tuteo_intenso": ["muy informal", "superinformal", "muy cercana", "como amiga"],
}
def __init__(self):
self._evolutions: List[Dict] = []
self._loaded = False
def _load(self):
if self._loaded:
return
try:
if db:
raw = db.recall(self.DB_KEY_EVOLUTIONS)
if raw:
self._evolutions = json.loads(raw)
except Exception:
pass
self._loaded = True
def _save(self):
try:
if db:
db.remember(self.DB_KEY_EVOLUTIONS,
json.dumps(self._evolutions[-self.MAX_EVOLUTIONS:]),
"config")
except Exception:
pass
async def evolve(self, instruction: str, admin_chat_id: str = "") -> Dict:
"""
Procesa una instrucción del dueño y la convierte en una evolución
del prompt. Primero intenta mapear a un skill conocido,
si no, la convierte en una regla personalizada via LLM.
Retorna: {ok, type, result_description, skill_id?, rule_text?}
"""
self._load()
instruction_lower = instruction.lower()
# ── 1. Intentar mapear a skill conocida ──────────────────────────────
for skill_id, keywords in self.SKILL_KEYWORDS.items():
if any(kw in instruction_lower for kw in keywords):
skill_on = True
# Detectar negaciones
negations = ["no ", "nunca ", "quita ", "desactiva ", "sin "]
if any(neg in instruction_lower[:30] for neg in negations):
skill_on = False
# Activar/desactivar
result = skill_engine.toggle(skill_id, skill_on)
action = "activé" if skill_on else "desactivé"
evolution = {
"id": str(_uuid_trainer.uuid4())[:8],
"type": "skill",
"skill_id": skill_id,
"skill_on": skill_on,
"instruction": instruction,
"ts": datetime.now().isoformat(),
"admin": admin_chat_id,
}
self._evolutions.append(evolution)
self._save()
return {
"ok": True,
"type": "skill",
"skill_id": skill_id,
"skill_on": skill_on,
"description": f"{action} el skill '{result['name']}': {result['desc']}",
"evolution_id": evolution["id"],
}
# ── 2. Convertir a regla personalizada via LLM ────────────────────────
if not llm_engine:
# Sin LLM: guardar como texto libre
return self._save_free_rule(instruction, admin_chat_id)
try:
prompt = f"""El dueño de un negocio quiere enseñarle algo nuevo a Conny, su recepcionista virtual.
INSTRUCCIÓN DEL DUEÑO:
"{instruction}"
Convierte esta instrucción en UNA regla clara y accionable para Conny.
La regla debe ser concisa (máximo 2 oraciones) y en segunda persona ("cuando... / si...").
Responde SOLO con JSON:
{{
"rule": "la regla como instrucción directa para Conny",
"category": "tono|flujo|ventas|escritura|objecion|general",
"example_bad": "qué NO hacer (si se puede inferir)",
"example_good": "qué SÍ hacer (si se puede inferir)"
}}"""
raw, _ = await asyncio.wait_for(
llm_engine.complete(
[{"role": "user", "content": prompt}],
model_tier="fast", temperature=0.2, max_tokens=200, use_cache=False
),
timeout=10.0
)
# Parsear JSON
m = re.search(r'\{[\s\S]+\}', raw.strip())
if m:
parsed = json.loads(m.group(0))
rule = parsed.get("rule", "").strip()
category = parsed.get("category", "general")
ex_bad = parsed.get("example_bad", "")
ex_good = parsed.get("example_good", "")
if rule:
# Guardar en carpeta de confianza
rule_id = db.save_trust_rule(
category=category,
rule=rule,
example_bad=ex_bad,
example_good=ex_good,
weight=2.5,
) if db else 0
evolution = {
"id": str(_uuid_trainer.uuid4())[:8],
"type": "rule",
"rule": rule,
"rule_id": rule_id,
"category": category,
"instruction": instruction,
"ts": datetime.now().isoformat(),
"admin": admin_chat_id,
}
self._evolutions.append(evolution)
self._save()
return {
"ok": True,
"type": "rule",
"rule": rule,
"category": category,
"example_good": ex_good,
"description": f"Nueva regla guardada [{category}]: {rule}",
"evolution_id": evolution["id"],
}
except Exception as e:
log.warning(f"[prompt_evolver] LLM error: {e}")
# Fallback: guardar como texto libre
return self._save_free_rule(instruction, admin_chat_id)
def _save_free_rule(self, instruction: str, admin_chat_id: str) -> Dict:
"""Guarda la instrucción como regla libre sin procesar por LLM."""
rule_id = 0
if db:
try:
rule_id = db.save_trust_rule(
category="general",
rule=instruction,
example_bad="",
example_good="",
weight=2.5,
)
except Exception:
pass
evolution = {
"id": str(_uuid_trainer.uuid4())[:8],
"type": "free",
"rule": instruction,
"rule_id": rule_id,
"instruction": instruction,
"ts": datetime.now().isoformat(),
"admin": admin_chat_id,
}
self._evolutions.append(evolution)
self._save()
return {
"ok": True,
"type": "free",
"rule": instruction,
"description": f"Instrucción guardada directamente: {instruction[:60]}",
"evolution_id": evolution["id"],
}
def unlearn(self, evolution_id: str) -> Dict:
"""Revierte una evolución específica."""
self._load()
target = next((e for e in self._evolutions if e["id"] == evolution_id), None)
if not target:
return {"ok": False, "error": f"Evolución '{evolution_id}' no encontrada"}
# Revertir skill si aplica
if target.get("type") == "skill":
skill_engine.toggle(target["skill_id"], not target["skill_on"])
# Eliminar regla de trust_folder si tiene rule_id
if target.get("rule_id") and db:
try:
db.delete_trust_rule(target["rule_id"])
except Exception:
pass
self._evolutions = [e for e in self._evolutions if e["id"] != evolution_id]
self._save()
return {"ok": True, "reverted": target.get("rule") or target.get("skill_id")}
def get_history(self, limit: int = 10) -> List[Dict]:
"""Retorna el historial de evoluciones."""
self._load()
return list(reversed(self._evolutions))[:limit]
def format_history_for_admin(self) -> str:
"""Formatea el historial para enviar al admin."""
history = self.get_history()
if not history:
return "No hay evoluciones guardadas todavía."
lines = ["Lo que has enseñado a Conny:\n"]
for ev in history:
ev_type = ev.get("type", "?")
ts = ev.get("ts", "")[:16]
eid = ev["id"]
if ev_type == "skill":
action = "activó" if ev.get("skill_on") else "desactivó"
skill_def = SKILL_DEFINITIONS.get(ev.get("skill_id", ""), {})
skill_name = skill_def.get("name", ev.get("skill_id", "?"))
lines.append(f" [{eid}] {ts} — {action} skill: {skill_name}")
elif ev_type in ("rule", "free"):
rule = ev.get("rule", "")[:60]
lines.append(f" [{eid}] {ts} — regla: {rule}...")
lines.append("\nPara revertir algo: /desaprender [id]")
return "\n".join(lines)
# ═══════════════════════════════════════════════════════════════════════════════
# ADMIN-AS-CLIENT MODE
# Cualquier admin puede convertirse en cliente inmediatamente para simular
# una conversación real con Conny y entrenarla en tiempo real.
# ═══════════════════════════════════════════════════════════════════════════════
class AdminClientMode:
"""
Modo Admin-como-Cliente.
Cuando el admin activa este modo:
1. Sus mensajes son procesados como si fuera un cliente real
2. Conny responde como respondería a un cliente
3. El admin puede dar feedback inmediato: /feedback "esta respuesta estuvo mal porque..."
4. El feedback se convierte en regla automáticamente
5. Puede salir del modo con /salir o /exit
El modo se guarda por chat_id del admin. Un admin puede tener su propia
"sesión de entrenamiento" paralela a los clientes reales.
Identificadores de sesión:
_training_sessions[admin_chat_id] = {
"active": bool,
"persona": str, # nombre del cliente simulado
"scenario": str, # escenario (primer_contacto, precio, miedo...)
"history": list, # historial de la sesión
"feedback_count": int,
"started_at": str,
}
"""
SCENARIOS = {
"libre": "Conversación libre — el admin improvisa como cliente",
"primer_contacto":"Cliente nuevo que pregunta por primera vez",
"precio": "Cliente que pregunta precio antes que nada",
"miedo": "Cliente con miedo a quedar mal / resultado exagerado",
"esceptico": "Cliente que ya fue a otro lugar y quedó mal",
"ocupado": "Cliente ocupado, poco tiempo",
"negociador": "Cliente que pide descuento / regateo",
"bot_detector": "Cliente que pregunta si es bot",
"urgente": "Cliente que necesita cita urgente hoy",
"referido": "Cliente que llega por recomendación de amigo",
}
def __init__(self):
self._sessions: Dict[str, Dict] = {}
def start(self, admin_chat_id: str, persona: str = "",
scenario: str = "libre") -> Dict:
"""Inicia una sesión de entrenamiento para el admin."""
if scenario not in self.SCENARIOS:
scenario = "libre"
self._sessions[admin_chat_id] = {
"active": True,
"persona": persona or f"Cliente {admin_chat_id[-4:]}",
"scenario": scenario,
"scenario_desc": self.SCENARIOS[scenario],
"history": [],
"feedback_count": 0,
"started_at": datetime.now().isoformat(),
"session_id": str(_uuid_trainer.uuid4())[:8],
}
return self._sessions[admin_chat_id]
def is_active(self, admin_chat_id: str) -> bool:
return self._sessions.get(admin_chat_id, {}).get("active", False)
def stop(self, admin_chat_id: str) -> Dict:
"""Finaliza la sesión y retorna el resumen."""
session = self._sessions.get(admin_chat_id, {})
if not session:
return {"ok": False, "error": "No hay sesión activa"}
session["active"] = False
session["ended_at"] = datetime.now().isoformat()
turns = len([m for m in session.get("history", []) if m["role"] == "user"])
return {
"ok": True,
"session_id": session.get("session_id"),
"turns": turns,
"feedback_count": session.get("feedback_count", 0),
"scenario": session.get("scenario"),
"persona": session.get("persona"),
}
def get_session(self, admin_chat_id: str) -> Optional[Dict]:
return self._sessions.get(admin_chat_id)
def add_turn(self, admin_chat_id: str, user_msg: str, bot_response: str):
"""Registra un turno en la sesión."""
session = self._sessions.get(admin_chat_id, {})
if not session:
return
session["history"].append({"role": "user", "content": user_msg})
session["history"].append({"role": "assistant", "content": bot_response})
def get_context_injection(self, admin_chat_id: str) -> str:
"""
Retorna contexto de la sesión para inyectar al system prompt.
Esto hace que Conny sepa que está siendo entrenada y cuál es el escenario.
"""
session = self._sessions.get(admin_chat_id, {})
if not session or not session.get("active"):
return ""
scenario = session.get("scenario", "libre")
scenario_desc = session.get("scenario_desc", "")
persona = session.get("persona", "cliente")
turns = len([m for m in session.get("history", []) if m["role"] == "user"])
# Contexto de escenario para cada tipo
scenario_contexts = {
"primer_contacto": "Es la primera vez que este cliente escribe. No te conoce. "
"Llega con una pregunta general. Tu trabajo es descubrir qué le molesta.",
"precio": "El cliente va a preguntar el precio inmediatamente. "
"No lo des de entrada. Primero descubre qué zona/servicio/caso específico.",
"miedo": "El cliente tiene miedo a quedar exagerado o que se note. "
"Valida el miedo PRIMERO antes de cualquier información.",
"esceptico": "El cliente ya fue a otro lugar y le fue mal. "
"Empatía PRIMERO. Luego diferencia. Nunca te defiendas.",
"ocupado": "El cliente dice que está ocupado. Respeta su tiempo. "
"Propuesta concreta y rápida.",
"negociador": "El cliente va a pedir descuento. No lo des de inmediato. "
"Habla de valor antes de precio.",
"bot_detector": "El cliente va a preguntar si eres bot. "
"Responde como persona real, directamente, sin negar ni confirmar ser IA.",
"urgente": "El cliente necesita la cita para hoy o mañana. "
"Actúa rápido, propón fecha inmediata.",
"referido": "El cliente viene por recomendación. "
"Reconoce la recomendación con calidez.",
"libre": "Conversación abierta. Responde naturalmente.",
}
ctx = scenario_contexts.get(scenario, "")
lines = [
f"",
f"MODO ENTRENAMIENTO ACTIVO (solo visible para ti):",
f" Persona: {persona}",
f" Escenario: {scenario} — {scenario_desc}",
f" Turno: #{turns + 1}",
]
if ctx:
lines.append(f" Contexto: {ctx}")
lines.append("")
return "\n".join(lines)
def format_session_report(self, admin_chat_id: str) -> str:
"""Genera reporte de la sesión actual."""
session = self._sessions.get(admin_chat_id, {})
if not session:
return "No hay sesión activa."
history = session.get("history", [])
turns = len([m for m in history if m["role"] == "user"])
scenario = session.get("scenario", "?")
persona = session.get("persona", "?")
feedback = session.get("feedback_count", 0)
sid = session.get("session_id", "?")
lines = [
f"Sesión de entrenamiento [{sid}]",
f" Persona: {persona}",
f" Escenario: {scenario}",
f" Turnos: {turns}",
f" Feedback dado: {feedback} veces",
f"",
"Conversación:",
]
for msg in history[-10:]:
role = "Tú (cliente)" if msg["role"] == "user" else "Conny"
lines.append(f" [{role}] {msg['content'][:80]}")
lines.extend([
"",
"Comandos disponibles:",
" /feedback [mensaje] — dar feedback sobre la última respuesta",
" /aprender [x] — enseñar algo nuevo",
" /salir — terminar el modo cliente",
])
return "\n".join(lines)
# ═══════════════════════════════════════════════════════════════════════════════
# NOVA RULE SYNC
# Cuando el admin (o incluso el cliente) dice "no hagas X",
# la instrucción se envía a Nova como regla de gobernanza
# Y también se guarda en la carpeta de confianza de Conny.
# Esto garantiza que la instrucción se cumpla SIEMPRE, incluso si el
# system prompt falla o es ignorado por el LLM.
# ═══════════════════════════════════════════════════════════════════════════════
class NovaRuleSync:
"""
Sincroniza reglas de entrenamiento con Nova OS.
Cuando Nova está activo, actúa como capa de gobernanza sobre Conny.
Una regla enviada a Nova es ENFORCED en cada mensaje, no solo sugerida.
Si Nova está offline, las reglas se guardan solo en la carpeta de confianza.
Detección de instrucciones negativas en mensajes del CLIENTE:
Si el cliente dice "no me hagas eso" / "eso no me gusta" / "no me envíes X",
Conny puede detectarlo y enviarlo a Nova automáticamente.
"""
# Patrones que detectan instrucciones negativas del cliente
CLIENT_NEGATIVE_PATTERNS = [
r"no (me )?(hagas|digas|mandes|envíes|digas|menciones|uses?)\b",
r"(para|deja) de (decir|hacer|mandar|enviar|mencionar)\b",
r"no quiero (que|más)\b",
r"eso no (me )?(gusta|sirve|funciona)\b",
r"no (seas?|te pongas?|actúes?)\b",
r"(basta|ya|suficiente) con\b",
r"evita (decir|hacer|mencionar)\b",
]
def __init__(self):
self._compiled = [re.compile(p, re.IGNORECASE) for p in self.CLIENT_NEGATIVE_PATTERNS]
self._nova_url = ""
self._nova_key = ""
self._nova_agent = "conny"
def _init_nova_connection(self):
"""Inicializa la conexión a Nova si está configurada."""
if not self._nova_url:
self._nova_url = Config.NOVA_URL or os.getenv("NOVA_CORE_URL", "")
self._nova_key = Config.NOVA_API_KEY or os.getenv("NOVA_CORE_API_KEY", "")
self._nova_agent = os.getenv("NOVA_AGENT_NAME", "conny")
def detect_client_negative_instruction(self, client_msg: str) -> Optional[str]:
"""
Detecta si el cliente está dando una instrucción negativa a Conny.
Retorna la instrucción detectada o None.
"""
for pattern in self._compiled:
if pattern.search(client_msg.lower()):
return client_msg
return None
async def sync_rule(self, instruction: str, source: str = "admin",
category: str = "general") -> Dict:
"""
Sincroniza una regla con Nova Y con la carpeta de confianza.
source: "admin" | "client" | "trainer"
Retorna: {ok, nova_synced, trust_saved, rule_text}
"""
self._init_nova_connection()
# 1. Siempre guardar en carpeta de confianza (funciona sin Nova)
trust_saved = False
rule_id = 0
try:
if db:
rule_id = db.save_trust_rule(
category=category,
rule=instruction,
example_bad="",
example_good="",
)
trust_saved = True
except Exception as e:
log.warning(f"[nova_sync] trust save error: {e}")
# 2. Intentar sincronizar con Nova si está disponible
nova_synced = False
nova_msg = ""
if Config.NOVA_ENABLED and self._nova_url and self._nova_key:
try:
nova_payload = {
"agent_name": self._nova_agent,
"rule": instruction,
"cannot_do": [instruction],
"source": source,
"category": category,
"timestamp": datetime.now().isoformat(),
}
async with httpx.AsyncClient(timeout=5.0) as client:
r = await client.post(
f"{self._nova_url}/rules",
json=nova_payload,
headers={
"X-Nova-Key": self._nova_key,
"Content-Type": "application/json",
}
)
if r.status_code < 400:
nova_synced = True
log.info(f"[nova_sync] regla enviada a Nova: {instruction[:50]}")
else:
nova_msg = f"Nova respondió {r.status_code}"
except Exception as e:
nova_msg = f"Nova offline: {e}"
log.debug(f"[nova_sync] {nova_msg}")
return {
"ok": trust_saved or nova_synced,
"nova_synced": nova_synced,
"trust_saved": trust_saved,
"rule_id": rule_id,
"rule_text": instruction,
"nova_msg": nova_msg,
}
async def process_client_negative(self, client_msg: str, chat_id: str) -> Optional[Dict]:
"""
Si el cliente da una instrucción negativa, la procesa automáticamente.
Retorna el resultado de la sincronización o None si no hay instrucción.
"""
instruction = self.detect_client_negative_instruction(client_msg)
if not instruction:
return None
# Procesar la instrucción como regla
result = await self.sync_rule(
instruction=instruction,
source="client",
category="client_instruction",
)
log.info(f"[nova_sync] instrucción negativa del cliente [{chat_id}]: {instruction[:50]}")
return result
# ═══════════════════════════════════════════════════════════════════════════════
# INSTANCIAS GLOBALES DEL TRAINER
# ═══════════════════════════════════════════════════════════════════════════════
skill_engine: SkillEngine = None
trainer_gateway: "TrainerGateway" = None
owner_style_controller: "OwnerStyleController" = None
prompt_evolver: PromptEvolver = None
admin_client_mode: AdminClientMode = None
nova_rule_sync: NovaRuleSync = None
def init_trainer_systems():
"""Inicializa todos los sistemas de entrenamiento."""
global skill_engine, trainer_gateway, owner_style_controller, prompt_evolver, admin_client_mode, nova_rule_sync
try:
skill_engine = SkillEngine()
log.info("[trainer] SkillEngine OK")
except Exception as e:
log.warning(f"[trainer] SkillEngine: {e}")
try:
trainer_gateway = TrainerGateway()
log.info("[trainer] TrainerGateway OK")
except Exception as e:
log.warning(f"[trainer] TrainerGateway: {e}")
try:
owner_style_controller = OwnerStyleController()
log.info("[trainer] OwnerStyleController OK")
except Exception as e:
log.warning(f"[trainer] OwnerStyleController: {e}")
try:
prompt_evolver = PromptEvolver()
log.info("[trainer] PromptEvolver OK")
except Exception as e:
log.warning(f"[trainer] PromptEvolver: {e}")
try:
admin_client_mode = AdminClientMode()
log.info("[trainer] AdminClientMode OK")
except Exception as e:
log.warning(f"[trainer] AdminClientMode: {e}")
try:
nova_rule_sync = NovaRuleSync()
log.info("[trainer] NovaRuleSync OK")
except Exception as e:
log.warning(f"[trainer] NovaRuleSync: {e}")
log.info("═══ CONNY TRAINER INITIALIZED ═══")
# ═══════════════════════════════════════════════════════════════════════════════
# INTEGRACIÓN EN EL PIPELINE DE RESPUESTA
# ═══════════════════════════════════════════════════════════════════════════════
def trainer_get_system_prompt_addon(
chat_id: str,
clinic: Optional[Dict[str, Any]] = None,
user_msg: str = "",
is_admin: bool = False,
patient: Optional[Dict[str, Any]] = None,
) -> str:
"""
Retorna el bloque de trainer para inyectar al system prompt.
Combina skills activas + gateway automático + contexto de sesión de entrenamiento.
"""
try:
blocks = []
# Skills activas
if skill_engine:
skills_block = skill_engine.get_prompt_injection()
if skills_block:
blocks.append(skills_block)
# Gateway automático por rol/canal/intención
if trainer_gateway and clinic:
gateway_block = trainer_gateway.build_prompt_addon(
chat_id=chat_id,
clinic=clinic,
user_msg=user_msg,
is_admin=is_admin,
patient=patient,
)
if gateway_block:
blocks.append(gateway_block)
if owner_style_controller:
owner_block = owner_style_controller.build_prompt_addon(is_admin=is_admin)
if owner_block:
blocks.append(owner_block)
# Contexto de sesión si el admin está en modo cliente
if admin_client_mode and admin_client_mode.is_active(chat_id):
session_ctx = admin_client_mode.get_context_injection(chat_id)
if session_ctx:
blocks.append(session_ctx)
return "\n\n".join(blocks)
except Exception as e:
log.debug(f"[trainer_addon] error: {e}")
return ""
def trainer_post_process_response(response: str, chat_id: str = "") -> str:
"""
Aplica transformaciones post-generación del trainer (skills de escritura).
Se llama DESPUÉS del LLM, antes de enviar al cliente.
"""
try:
if skill_engine:
response = skill_engine.apply_post_filter(response, chat_id)
return response
except Exception as e:
log.debug(f"[trainer_postprocess] error: {e}")
return response
async def trainer_process_client_msg(
client_msg: str,
chat_id: str,
patient: Optional[Dict[str, Any]] = None,
):
"""
Procesa cada mensaje del cliente buscando:
- instrucciones negativas para sincronizar con Nova/trust folder
- preferencias explícitas de trato/tono/forma de respuesta
Se llama ANTES de generar la respuesta (fire-and-forget).
"""
try:
if trainer_gateway:
trainer_gateway.observe_user_preferences(
chat_id=chat_id,
user_msg=client_msg,
patient=patient,
is_admin=False,
)
if nova_rule_sync:
result = await nova_rule_sync.process_client_negative(client_msg, chat_id)
if result and result.get("ok"):
log.info(f"[trainer] instrucción del cliente procesada: {result.get('rule_text','')[:40]}")
except Exception as e:
log.debug(f"[trainer_client_msg] error: {e}")
# ═══════════════════════════════════════════════════════════════════════════════
# COMANDOS ADMIN NUEVOS (se integran en _handle_admin_or_setup)
# ═══════════════════════════════════════════════════════════════════════════════
async def _admin_skills(chat_id: str) -> List[str]:
"""/skills — lista skills disponibles con estado."""
if not skill_engine:
return ["El sistema de skills no está disponible."]
skills = skill_engine.list_all()
active = [s for s in skills if s["active"]]
inactive = [s for s in skills if not s["active"]]
lines = ["Skills de comportamiento de Conny:\n"]
if active:
lines.append("Activas ahora:")
for s in active:
lines.append(f" ✓ {s['name']} ({s['id']})")
lines.append(f" {s['desc']}")
if inactive:
if active:
lines.append("")
lines.append("Disponibles (inactivas):")
for s in inactive:
lines.append(f" ○ {s['name']} ({s['id']})")
lines.append(f" {s['desc']}")
lines.extend([
"",
"Para activar: /skill [id] on",
"Para desactivar: /skill [id] off",
"O en lenguaje natural: /aprender 'a veces usa minúsculas al inicio'",
])
return ["\n".join(lines)]
async def _admin_toggle_skill(chat_id: str, text: str) -> List[str]:
"""/skill [id] [on|off] — activa o desactiva un skill."""
if not skill_engine:
return ["El sistema de skills no está disponible."]
parts = text.strip().split()
if len(parts) < 3:
return [
"Formato: /skill [id] [on|off]",
"Ejemplo: /skill typos_naturales on",
"Ver todos: /skills"
]
skill_id = parts[1].lower()
action = parts[2].lower()
if action not in ("on", "off", "activar", "desactivar"):
return ["Usa 'on' para activar o 'off' para desactivar"]
on = action in ("on", "activar")
result = skill_engine.toggle(skill_id, on)
if not result["ok"]:
available = ", ".join(SKILL_DEFINITIONS.keys())
return [
f"Skill '{skill_id}' no existe.",
f"Disponibles: {available}"
]
action_str = "activado" if on else "desactivado"
return [
f"Skill {action_str}: {result['name']}",
result["desc"],
"Para ver todas: /skills"
]
async def _admin_aprender(chat_id: str, instruction: str) -> List[str]:
"""/aprender [instruccion] — enseña algo nuevo a Conny."""
if not instruction or len(instruction.strip()) < 5:
return [
"Dime qué quieres que aprenda Conny.",
"Ejemplo: /aprender a veces usa minúsculas al inicio",
"Ejemplo: /aprender cuando el cliente dice que está ocupado no insistas",
"Ejemplo: /aprender usa emojis sutiles cuando el cliente está emocionado"
]
if not prompt_evolver:
return ["El sistema de aprendizaje no está disponible."]
result = await prompt_evolver.evolve(instruction.strip(), chat_id)
if not result.get("ok"):
return [f"No pude procesar esa instrucción: {result.get('error', 'error desconocido')}"]
lines = [f"Entendido. {result['description']}"]
if result.get("example_good"):
lines.append(f"Ejemplo de cómo lo aplicará: \"{result['example_good']}\"")
lines.append(f"ID de esta evolución: {result.get('evolution_id', '?')} (úsalo para /desaprender)")
return lines
async def _admin_desaprender(chat_id: str, evolution_id: str) -> List[str]:
"""/desaprender [id] — revierte una evolución específica."""
if not prompt_evolver:
return ["El sistema de aprendizaje no está disponible."]
if not evolution_id:
history = prompt_evolver.format_history_for_admin()
return [history]
result = prompt_evolver.unlearn(evolution_id.strip())
if not result["ok"]:
return [f"No encontré la evolución '{evolution_id}'", "Usa /desaprender para ver el historial"]
return [
f"Revertido: {result.get('reverted', '?')}",
"Conny ya no aplica esa instrucción."
]
async def _admin_historial_aprendizaje(chat_id: str) -> List[str]:
"""/historial — historial de evoluciones del prompt."""
if not prompt_evolver:
return ["El sistema de aprendizaje no está disponible."]
return [prompt_evolver.format_history_for_admin()]
async def _admin_simular_cliente(chat_id: str, args_text: str, clinic: Dict) -> List[str]:
"""
/simular-cliente [escenario] — el admin se convierte en cliente.
Conny le responderá como si fuera un cliente real.
"""
if not admin_client_mode:
return ["El modo cliente no está disponible."]
if admin_client_mode.is_active(chat_id):
session = admin_client_mode.get_session(chat_id)
report = admin_client_mode.format_session_report(chat_id)
return [
f"Ya tienes una sesión activa: {session.get('scenario')} / {session.get('persona')}",
report,
"Para salir: /salir"
]
# Parsear escenario y nombre
parts = args_text.strip().split() if args_text else []
scenario = parts[0].lower() if parts else "libre"
persona = " ".join(parts[1:]) if len(parts) > 1 else ""
if scenario not in AdminClientMode.SCENARIOS:
escenarios = "\n".join(f" {k} — {v}" for k, v in AdminClientMode.SCENARIOS.items())
return [
f"Escenario '{scenario}' no existe.",
f"Escenarios disponibles:\n{escenarios}",
"Uso: /simular-cliente [escenario] [nombre_opcional]"
]
agent_name = clinic.get("persona_config", {})
if isinstance(agent_name, str):
try:
agent_name = json.loads(agent_name)
except Exception:
agent_name = {}
agent_name = agent_name.get("name", "Conny") if isinstance(agent_name, dict) else "Conny"
session = admin_client_mode.start(chat_id, persona or f"Cliente simulado", scenario)
lines = [
f"Modo cliente activado.",
f"Eres: {session['persona']}",
f"Escenario: {session['scenario']} — {session['scenario_desc']}",
f"",
f"Escríbele a {agent_name} como si fueras un cliente real.",
f"",
f"Comandos mientras estás en modo cliente:",
f" /feedback [mensaje] — dar feedback sobre la última respuesta",
f" /aprender [x] — enseñar algo en este momento",
f" /sesion — ver resumen de la sesión",
f" /salir — salir del modo cliente",
]
return ["\n".join(lines)]
async def _admin_salir_modo_cliente(chat_id: str) -> List[str]:
"""/salir — sale del modo cliente y muestra el resumen."""
if not admin_client_mode:
return ["El modo cliente no está disponible."]
if not admin_client_mode.is_active(chat_id):
return ["No estás en modo cliente ahora mismo."]
result = admin_client_mode.stop(chat_id)
lines = [
"Sesión de entrenamiento finalizada.",
f"Turnos: {result.get('turns', 0)}",
f"Feedback dado: {result.get('feedback_count', 0)} veces",
f"Escenario: {result.get('scenario', '?')}",
"",
"Todo el feedback quedó guardado en la carpeta de confianza.",
"Para ver las reglas aprendidas: /reglas",
"Para ver el historial: /historial",
]
return ["\n".join(lines)]
async def _admin_feedback_sesion(chat_id: str, feedback_text: str, clinic: Dict) -> List[str]:
"""/feedback [texto] — da feedback sobre la última respuesta en modo cliente."""
if not admin_client_mode or not admin_client_mode.is_active(chat_id):
return ["El feedback funciona dentro del modo cliente (/simular-cliente)"]
if not feedback_text or len(feedback_text.strip()) < 5:
return ["Dime qué estuvo mal o bien en la respuesta de Conny."]
session = admin_client_mode.get_session(chat_id)
if session:
session["feedback_count"] = session.get("feedback_count", 0) + 1
# Procesar feedback como instrucción de aprendizaje
result = await prompt_evolver.evolve(feedback_text.strip(), chat_id) if prompt_evolver else {}
lines = ["Feedback registrado."]
if result.get("ok"):
lines.append(result.get("description", ""))
lines.append("Sigue simulando o escribe /salir para terminar.")
return lines
async def _admin_ver_sesion(chat_id: str) -> List[str]:
"""/sesion — ver resumen de la sesión actual."""
if not admin_client_mode:
return ["El modo cliente no está disponible."]
if not admin_client_mode.is_active(chat_id):
return [
"No tienes una sesión activa.",
"Para simular una conversación como cliente: /simular-cliente"
]
return [admin_client_mode.format_session_report(chat_id)]
async def _admin_gateway_status(chat_id: str) -> List[str]:
"""/gateway — ver estado del gateway automático del trainer."""
if not trainer_gateway:
return ["El gateway automático no está disponible."]
state = trainer_gateway.status()
on_off = lambda value: "ON" if value else "off"
return [
"\n".join([
"Gateway automático del trainer:",
f" General: {on_off(state.get('enabled'))}",
f" Auto-admin: {on_off(state.get('auto_admin'))}",
f" Auto-user: {on_off(state.get('auto_user'))}",
"",
"Qué hace:",
" • detecta instrucciones del admin sin obligarlo a usar /aprender",
" • aplica skills automáticas por contexto al usuario",
" • aprende preferencias de trato, brevedad y estilo por chat",
"",
"Comandos:",
" /gateway on",
" /gateway off",
" /gateway admin on|off",
" /gateway user on|off",
])
]
async def _admin_gateway_toggle(chat_id: str, text: str) -> List[str]:
"""/gateway on|off|admin on|off|user on|off"""
if not trainer_gateway:
return ["El gateway automático no está disponible."]
parts = [p for p in text.lower().strip().split() if p]
if len(parts) == 1:
return await _admin_gateway_status(chat_id)
target = "enabled"
value_token = ""
if len(parts) >= 2 and parts[1] in ("on", "off"):
value_token = parts[1]
elif len(parts) >= 3 and parts[1] in ("admin", "user") and parts[2] in ("on", "off"):
target = "auto_admin" if parts[1] == "admin" else "auto_user"
value_token = parts[2]
else:
return [
"Formato: /gateway on|off",
"Formato: /gateway admin on|off",
"Formato: /gateway user on|off",
]
value = value_token == "on"
kwargs = {target: value}
result = trainer_gateway.configure(**kwargs)
label_map = {
"enabled": "gateway general",
"auto_admin": "gateway de admin",
"auto_user": "gateway de usuario",
}
state_word = "activado" if value else "desactivado"
return [
f"Listo. Dejé {label_map[target]} {state_word}.",
f"Estado actual: general={'ON' if result.get('enabled') else 'off'} · admin={'ON' if result.get('auto_admin') else 'off'} · user={'ON' if result.get('auto_user') else 'off'}",
]
async def _admin_control_status(chat_id: str) -> List[str]:
"""/control — ver estado del plano de control del admin."""
if not owner_style_controller:
return ["El plano de control del admin no está disponible."]
state = owner_style_controller.status()
def _fmt_bucket(label: str, bucket: Dict[str, Any]) -> str:
forbidden = ", ".join(bucket.get("forbidden_phrases", [])[:6]) or "ninguna"
starts = ", ".join(bucket.get("forbidden_starts", [])[:6]) or "ninguno"
notes = " | ".join(bucket.get("style_notes", [])[:4]) or "sin notas extra"
greeting = bucket.get("greeting_template") or "sin plantilla"
second_bubble = bucket.get("second_bubble_template") or "sin plantilla"
third_bubble = bucket.get("third_bubble_template") or "sin plantilla"
closing = bucket.get("closing_template") or "sin plantilla"
fallback = bucket.get("fallback_template") or "sin plantilla"
replacements = " | ".join(
f'{bad}->{good}' for bad, good in list((bucket.get("replacement_map", {}) or {}).items())[:4]
) or "ninguno"
register = bucket.get("register", "auto")
emojis = "off" if bucket.get("no_emojis") else "ON"
max_bubbles = bucket.get("max_bubbles") or "auto"
return "\n".join([
f"{label}:",
f" trato: {register}",
f" emojis: {emojis}",
f" saludo base: {greeting}",
f" segunda burbuja: {second_bubble}",
f" tercera burbuja: {third_bubble}",
f" cierre: {closing}",
f" fallback: {fallback}",
f" máximo burbujas: {max_bubbles}",
f" reemplazos: {replacements}",
f" frases prohibidas: {forbidden}",
f" arranques prohibidos: {starts}",
f" notas: {notes}",
])
return [
"\n".join([
"Control duro del admin:",
f" General: {'ON' if state.get('enabled') else 'off'}",
"",
_fmt_bucket("Global", state.get("global", {})),
"",
_fmt_bucket("Admin", state.get("admin", {})),
"",
_fmt_bucket("Paciente", state.get("patient", {})),
"",
"Uso natural:",
' "No digas ay"',
' "No digas ay, di entiendo"',
' "Conmigo háblame de usted y más directo"',
' "Saluda así: Hola, Conny por acá..."',
' "Segunda burbuja: Estoy lista para ayudarle con la instancia"',
' "Tercera burbuja: Si quiere, lo dejamos listo ahora"',
' "Cierra así: Si quiere, lo dejamos listo ahora."',
' "Si no entiendes di: Perdón, ayúdeme con un poco más de contexto."',
' "Responde en 2 burbujas"',
' "A los pacientes no les digas listo al inicio"',
' "/control reset admin"',
])
]
async def _admin_control_apply(chat_id: str, text: str) -> List[str]:
"""Aplica una instrucción al plano de control del admin."""
if not owner_style_controller:
return ["El plano de control del admin no está disponible."]
instruction = re.sub(r"^/control\s*", "", (text or "").strip(), flags=re.IGNORECASE).strip()
if not instruction:
return await _admin_control_status(chat_id)
if instruction.lower() in ("reset", "reiniciar", "limpiar"):
result = owner_style_controller.reset("all")
return [
"Listo. Reinicié el plano de control completo.",
f"General={'ON' if result.get('state', {}).get('enabled') else 'off'}",
]
if instruction.lower() in ("reset admin", "reiniciar admin", "limpiar admin"):
owner_style_controller.reset("admin")
return ["Listo. Reinicié solo el control de admin."]
if instruction.lower() in ("reset pacientes", "reset paciente", "reiniciar paciente", "limpiar paciente"):
owner_style_controller.reset("patient")
return ["Listo. Reinicié solo el control de pacientes."]
result = owner_style_controller.apply_instruction(instruction, admin_chat_id=chat_id)
if not result.get("ok"):
return [
"No pude convertir eso en una regla dura todavía.",
"Prueba con algo como: no digas 'ay' | no digas 'ay', di 'entiendo' | no empieces con 'claro' | saluda así: Hola, Conny por acá",
]
return result.get("reply_lines", ["Listo. Ya quedó aplicado."])
# ═══════════════════════════════════════════════════════════════════════════════
# ENDPOINTS FASTAPI DEL TRAINER
# ═══════════════════════════════════════════════════════════════════════════════
@app.get("/trainer/status")
async def trainer_status():
"""Estado del sistema de entrenamiento."""
return {
"ok": True,
"skill_engine": skill_engine is not None,
"trainer_gateway": trainer_gateway is not None,
"owner_style_control": owner_style_controller is not None,
"prompt_evolver": prompt_evolver is not None,
"admin_client": admin_client_mode is not None,
"nova_sync": nova_rule_sync is not None,
"gateway_state": trainer_gateway.status() if trainer_gateway else {},
"owner_style_state": owner_style_controller.status() if owner_style_controller else {},
"active_skills": skill_engine.get_active() if skill_engine else [],
"evolutions": len(prompt_evolver._evolutions) if prompt_evolver else 0,
"active_sessions": sum(
1 for s in (admin_client_mode._sessions.values() if admin_client_mode else [])
if s.get("active")
),
}
@app.get("/trainer/skills")
async def trainer_list_skills():
"""Lista todos los skills disponibles."""
if not skill_engine:
raise HTTPException(status_code=503, detail="SkillEngine no disponible")
return {"skills": skill_engine.list_all()}
@app.post("/trainer/skill/toggle")
async def trainer_toggle_skill(request: Request):
"""Activa o desactiva un skill. Body: {skill_id, active}"""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if not skill_engine:
raise HTTPException(status_code=503, detail="SkillEngine no disponible")
data = await request.json()
skill_id = data.get("skill_id", "").strip()
active = bool(data.get("active", True))
result = skill_engine.toggle(skill_id, active)
if not result["ok"]:
raise HTTPException(status_code=400, detail=result.get("error", "Skill no encontrado"))
return result
@app.get("/trainer/gateway")
async def trainer_gateway_status():
"""Estado del gateway automático del trainer."""
if not trainer_gateway:
raise HTTPException(status_code=503, detail="TrainerGateway no disponible")
return {
"ok": True,
**trainer_gateway.status(),
"active_skills": skill_engine.get_active() if skill_engine else [],
}
@app.post("/trainer/gateway")
async def trainer_gateway_config(request: Request):
"""Configura el gateway automático. Body: {enabled?, auto_admin?, auto_user?}"""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if not trainer_gateway:
raise HTTPException(status_code=503, detail="TrainerGateway no disponible")
data = await request.json()
result = trainer_gateway.configure(
enabled=data.get("enabled") if "enabled" in data else None,
auto_admin=data.get("auto_admin") if "auto_admin" in data else None,
auto_user=data.get("auto_user") if "auto_user" in data else None,
)
return result
@app.get("/trainer/control")
async def trainer_owner_control_status():
"""Estado del plano de control duro del admin."""
if not owner_style_controller:
raise HTTPException(status_code=503, detail="OwnerStyleController no disponible")
return {"ok": True, **owner_style_controller.status()}
@app.post("/trainer/control")
async def trainer_owner_control_apply(request: Request):
"""Aplica una instrucción natural o reset al plano de control. Body: {instruction} o {reset_scope}"""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if not owner_style_controller:
raise HTTPException(status_code=503, detail="OwnerStyleController no disponible")
data = await request.json()
reset_scope = (data.get("reset_scope") or "").strip().lower()
if reset_scope:
return owner_style_controller.reset(reset_scope)
instruction = (data.get("instruction") or "").strip()
admin_id = str(data.get("admin_chat_id") or "api")
if not instruction:
raise HTTPException(status_code=400, detail="instruction o reset_scope requerida")
result = owner_style_controller.apply_instruction(instruction, admin_chat_id=admin_id)
if not result.get("ok"):
raise HTTPException(status_code=400, detail=result.get("reason", "No se pudo aplicar"))
return result
@app.post("/trainer/prompt/evolve")
async def trainer_evolve_prompt(request: Request):
"""
Evoluciona el prompt con una instrucción en lenguaje natural.
Body: {instruction, admin_chat_id?}
"""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if not prompt_evolver:
raise HTTPException(status_code=503, detail="PromptEvolver no disponible")
data = await request.json()
instruction = data.get("instruction", "").strip()
admin_id = data.get("admin_chat_id", "api")
if not instruction:
raise HTTPException(status_code=400, detail="instruction requerida")
result = await prompt_evolver.evolve(instruction, admin_id)
return result
@app.get("/trainer/evolutions")
async def trainer_get_evolutions(request: Request, limit: int = 20):
"""Lista el historial de evoluciones del prompt."""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if not prompt_evolver:
raise HTTPException(status_code=503, detail="PromptEvolver no disponible")
return {
"evolutions": prompt_evolver.get_history(limit),
"total": len(prompt_evolver._evolutions),
}
@app.delete("/trainer/evolutions/{evolution_id}")
async def trainer_delete_evolution(evolution_id: str, request: Request):
"""Revierte una evolución del prompt."""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if not prompt_evolver:
raise HTTPException(status_code=503, detail="PromptEvolver no disponible")
result = prompt_evolver.unlearn(evolution_id)
if not result["ok"]:
raise HTTPException(status_code=404, detail=result.get("error"))
return result
@app.post("/trainer/admin-as-client/start")
async def trainer_start_client_mode(request: Request):
"""
Inicia sesión de entrenamiento admin-como-cliente.
Body: {admin_chat_id, scenario?, persona?}
"""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if not admin_client_mode:
raise HTTPException(status_code=503, detail="AdminClientMode no disponible")
data = await request.json()
chat_id = data.get("admin_chat_id", "").strip()
scenario = data.get("scenario", "libre")
persona = data.get("persona", "")
if not chat_id:
raise HTTPException(status_code=400, detail="admin_chat_id requerido")
session = admin_client_mode.start(chat_id, persona, scenario)
return {
"ok": True,
"session_id": session["session_id"],
"scenario": session["scenario"],
"persona": session["persona"],
}
@app.post("/trainer/admin-as-client/stop")
async def trainer_stop_client_mode(request: Request):
"""Finaliza la sesión de entrenamiento. Body: {admin_chat_id}"""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if not admin_client_mode:
raise HTTPException(status_code=503, detail="AdminClientMode no disponible")
data = await request.json()
chat_id = data.get("admin_chat_id", "").strip()
result = admin_client_mode.stop(chat_id)
return result
@app.post("/trainer/nova-sync")
async def trainer_nova_sync(request: Request):
"""
Sincroniza una regla con Nova.
Body: {rule, category?, source?}
"""
if not _verify_master_key(request):
raise HTTPException(status_code=401, detail="No autorizado")
if not nova_rule_sync:
raise HTTPException(status_code=503, detail="NovaRuleSync no disponible")
data = await request.json()
rule = data.get("rule", "").strip()
category = data.get("category", "general")
source = data.get("source", "api")
if not rule:
raise HTTPException(status_code=400, detail="rule requerida")
result = await nova_rule_sync.sync_rule(rule, source, category)
return result
# ═══════════════════════════════════════════════════════════════════════════════
# PATCH DEL DISPATCHER ADMIN PARA INCLUIR COMANDOS TRAINER
# ═══════════════════════════════════════════════════════════════════════════════
def _patch_admin_dispatcher_trainer():
"""
Extiende el dispatcher admin con los comandos del trainer.
Se llama después de _patch_admin_dispatcher() del V8 extended.
"""
orig_get = getattr(ConnyUltra, "_handle_admin_or_setup", None)
original_method = orig_get if orig_get else None
async def patched_with_trainer(self, chat_id: str, text: str, clinic: Dict) -> List[str]:
cmd = text.lower().strip()
text_low = text.lower().strip()
# ── SmartHandoff: interceptar respuesta del admin a un ticket pendiente ─
if _SMART_HANDOFF and handoff_manager and not cmd.startswith("/"):
async def _handoff_send_to_client(cid: str, msg: str):
try:
await self._send_message(cid, msg)
if db:
try:
db.save_message(cid, "assistant", str(msg).replace("|||", " "))
except Exception as _db_err:
log.warning(f"[handoff] save admin resume error: {_db_err}")
except Exception as _he:
log.warning(f"[handoff] send_to_client error: {_he}")
_handoff_cmd_result = await handle_handoff_admin_command(cmd, clinic)
if _handoff_cmd_result is not None:
return _handoff_cmd_result
try:
_was_intercepted, _intercept_msgs = await handoff_manager.try_intercept_admin_reply(
admin_chat_id=chat_id,
admin_text=text,
clinic=clinic,
llm_fn=llm_engine.complete,
send_to_client_fn=_handoff_send_to_client,
)
if _was_intercepted:
return _intercept_msgs
except Exception as _h_e:
log.warning(f"[trainer] handoff try_intercept error: {_h_e}")
# ── Modo cliente activo — el admin está simulando ser cliente ──────────
# Si está en modo cliente, procesar su mensaje como cliente real
if admin_client_mode and admin_client_mode.is_active(chat_id):
# Comandos especiales dentro del modo cliente
if cmd == "/salir" or cmd == "/exit" or cmd == "/stop":
return await _admin_salir_modo_cliente(chat_id)
if cmd == "/sesion" or cmd == "/session":
return await _admin_ver_sesion(chat_id)
if cmd.startswith("/feedback "):
feedback_text = text[len("/feedback "):].strip()
return await _admin_feedback_sesion(chat_id, feedback_text, clinic)
if cmd.startswith("/aprender "):
instruction = text[len("/aprender "):].strip()
return await _admin_aprender(chat_id, instruction)
# Mensaje normal en modo cliente — procesar como paciente
# Inyectar contexto de sesión al processing
# La respuesta de Conny se genera como si fuera un cliente real
result = await original_method(self, chat_id, text, clinic)
# Registrar el turno
if result and admin_client_mode.is_active(chat_id):
response_text = " ||| ".join(result) if result else ""
admin_client_mode.add_turn(chat_id, text, response_text)
return result
pending_browser = self._admin_pending.get(chat_id, {}) if hasattr(self, "_admin_pending") else {}
if cmd in ("/ultimas", "/últimas", "/conversaciones", "/conversaciones recientes"):
return await self._admin_show_recent_conversation_browser(chat_id, limit=6)
if _wants_recent_conversation_browser(text_low):
return await self._admin_show_recent_conversation_browser(chat_id, limit=6)
if pending_browser.get("action") == "conversation_browser" and _wants_all_messages(text_low):
selected_chat_id = pending_browser.get("selected_chat_id")
if selected_chat_id:
return await self._admin_show_patient_chat_preview(
selected_chat_id,
admin_chat_id=chat_id,
show_all=True,
)
selection_idx = _extract_conversation_selection(text_low)
if selection_idx and pending_browser.get("action") == "conversation_browser":
items = pending_browser.get("items") or []
if 1 <= selection_idx <= len(items):
selected = items[selection_idx - 1]
return await self._admin_show_patient_chat_preview(
str(selected.get("chat_id") or ""),
admin_chat_id=chat_id,
limit=10,
label_override=str(selected.get("name") or "").strip(),
)
if selection_idx and not pending_browser.get("action"):
detailed_subject = any(
token in text_low
for token in (
"conversacion", "conversación", "chat", "mensajes",
"hablado", "hablaste", "mostrame", "muestrame",
"muéstrame", "enseñame", "ensename",
)
)
if detailed_subject:
show_all = _wants_all_messages(text_low)
return await self._admin_show_recent_conversation_selection(
chat_id,
selection_idx,
show_all=show_all,
)
# ── Comandos del trainer (modo admin normal) ───────────────────────────
if cmd == "/skills" or cmd == "/skill":
return await _admin_skills(chat_id)
if cmd.startswith("/skill "):
return await _admin_toggle_skill(chat_id, cmd)
if cmd == "/gateway":
return await _admin_gateway_status(chat_id)
if cmd.startswith("/gateway "):
return await _admin_gateway_toggle(chat_id, cmd)
if cmd == "/control":
return await _admin_control_status(chat_id)
if cmd.startswith("/control "):
return await _admin_control_apply(chat_id, text)
if cmd == "/aprender" or cmd.startswith("/aprender "):
instruction = text[len("/aprender"):].strip().lstrip()
return await _admin_aprender(chat_id, instruction)
if cmd == "/desaprender" or cmd.startswith("/desaprender "):
evolution_id = cmd.split("/desaprender", 1)[1].strip()
return await _admin_desaprender(chat_id, evolution_id)
if cmd == "/historial" or cmd == "/historial-aprendizaje":
return await _admin_historial_aprendizaje(chat_id)
if cmd == "/simular-cliente" or cmd.startswith("/simular-cliente "):
args_text = cmd.split("/simular-cliente", 1)[1].strip()
return await _admin_simular_cliente(chat_id, args_text, clinic)
if cmd == "/salir" or cmd == "/exit":
return ["No estás en modo cliente ahora mismo."]
if cmd == "/sesion" or cmd == "/session":
return await _admin_ver_sesion(chat_id)
if cmd == "/entrenar":
return [
"Sistema de entrenamiento de Conny:\n",
"SKILLS — comportamientos que puedes activar/desactivar:",
" /skills — ver todos los skills",
" /skill [id] on/off — activar/desactivar",
" /gateway — estado del gateway automático",
" /gateway on|off — activar/desactivar el gateway",
" /gateway admin on|off — solo gateway admin",
" /gateway user on|off — solo gateway usuario",
" /control — ver control duro del admin",
" /control [instrucción] — aplicar regla dura",
"",
"APRENDIZAJE — enseñar en lenguaje natural:",
" /aprender [instruccion] — enseñar algo nuevo",
" /desaprender [id] — revertir una instrucción",
" /historial — ver historial de aprendizaje",
"",
"SIMULACIÓN — probar como cliente:",
" /simular-cliente [escenario] — convertirte en cliente",
" Escenarios: libre, primer_contacto, precio, miedo,",
" esceptico, ocupado, negociador, bot_detector,",
" urgente, referido",
"",
"Ejemplo de flujo completo:",
" 1. /simular-cliente precio",
" 2. Escribe como cliente: 'cuánto vale el botox'",
" 3. Conny responde",
" 4. /feedback 'no debió dar el precio sin preguntar la zona'",
" 5. /salir",
" 6. /reglas — ver la regla que aprendió",
]
if original_method:
return await original_method(self, chat_id, text, clinic)
return ["Admin no disponible."]
ConnyUltra._handle_admin_or_setup = patched_with_trainer
log.info("[trainer] dispatcher admin patcheado con comandos trainer")
if __name__ == "__main__":
import uvicorn
port = int(os.getenv("PORT", "8001"))
host = os.getenv("HOST", "0.0.0.0")
print("""
╔══════════════════════════════════════════════════════════════════╗
║ ║
║ ██████╗ ██████╗ ███╗ ██╗███╗ ██╗██╗ ██╗ ║
║ ██╔════╝ ██╔═══██╗████╗ ██║████╗ ██║╚██╗ ██╔╝ ║
║ ██║ ██║ ██║██╔██╗ ██║██╔██╗ ██║ ╚████╔╝ ║
║ ██║ ██║ ██║██║╚██╗██║██║╚██╗██║ ╚██╔╝ ║
║ ╚██████╗ ╚██████╔╝██║ ╚████║██║ ╚████║ ██║ ║
║ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝╚═╝ ╚═══╝ ╚═╝ ║
║ ║
║ U L T R A v 8 . 0 ║
║ ║
║ Agente de Recepción Hipernaturalmente Humana ║
║ ║
╠══════════════════════════════════════════════════════════════════╣
║ • AntiRobotFilter — elimina cada patrón de bot antes de enviar ║
║ • ConversationIntelligence — etapas, emociones, compromiso ║
║ • HyperHumanEngine — valida humanidad en cada respuesta ║
║ • SmartVariety — nunca repite apertura ni cierre igual ║
║ • /modelo — admin cambia el LLM en caliente ║
║ • Ortografía perfecta forzada (tildes, puntuación) ║
║ • PersonaEvolution — aprende el estilo de cada cliente ║
║ • ConversionFunnelTracker — sabe en qué etapa está cada lead ║
║ • Demo V2 — comportamiento idéntico al de producción ║
║ • MultilingualHandler — español/inglés/portugués automático ║
╚══════════════════════════════════════════════════════════════════╝
""")
uvicorn.run(
"conny:app",
host=host,
port=port,
reload=False,
log_level="info"
)