@innvisor/conny-ai 9.7.0

package/nova/rules/default.yaml

@@ -0,0 +1,37 @@
+# Nova Governance Rules — Default
+# These rules apply to all Conny instances unless overridden.
+
+agent: Conny
+version: "1.0"
+
+can_do:
+  - "respond to patient greetings and general inquiries"
+  - "schedule appointments when patient provides name and preferred time"
+  - "provide general service information from knowledge base"
+  - "answer frequently asked questions from FAQ database"
+  - "redirect patient to specialist for complex medical questions"
+  - "send appointment reminders"
+  - "collect patient contact information"
+
+cannot_do:
+  - "provide medical diagnoses or treatment recommendations"
+  - "prescribe medication or dosages"
+  - "guarantee specific results from procedures"
+  - "share patient information with third parties"
+  - "offer discounts without admin approval"
+  - "make negative comments about patient appearance"
+  - "share exact pricing without admin-approved price list"
+  - "claim to be human when directly asked if AI"
+
+escalate_when:
+  - "patient expresses urgency or emergency"
+  - "patient asks for refund or files complaint"
+  - "patient mentions legal action"
+  - "confidence score below 0.3"
+  - "patient explicitly requests human agent"
+
+response_limits:
+  max_bubbles: 3
+  max_chars_per_bubble: 300
+  min_response_time_ms: 2000
+  max_exclamation_marks: 1

package/nova_bridge.py

@@ -0,0 +1,509 @@
+"""
+nova_bridge.py — Puente entre Nova y Conny
+
+Nova es el sistema nervioso de Conny:
+  - Antes de enviar cualquier mensaje, Conny pregunta a Nova: "¿puedo?"
+  - Nova evalúa las reglas y responde: APPROVED / BLOCKED / ESCALATED
+  - Todo queda en el ledger criptográfico de Nova
+  - El admin puede crear reglas en lenguaje natural: "no le mandes X a Y"
+
+Cómo funciona:
+  1. ConnyGuard intercepta cada mensaje ANTES de enviarlo
+  2. Llama a Nova /validate con la acción
+  3. APPROVED → mensaje se envía normalmente
+  4. BLOCKED → Conny responde algo alternativo, no el mensaje bloqueado
+  5. ESCALATED → Conny le pregunta al admin antes de enviar
+
+Requisitos:
+  - Nova server corriendo (puerto 9002 por defecto)
+  - NOVA_TOKEN configurado en .env (token del agente "Conny")
+  - NOVA_URL=http://localhost:9002
+
+Sin Nova activo → Conny funciona normal (modo degradado seguro)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import re
+import time
+from typing import Dict, List, Optional, Tuple
+
+import httpx
+
+log = logging.getLogger("conny.nova")
+
+# ─── Config ──────────────────────────────────────────────────────────────────
+NOVA_URL      = os.getenv("NOVA_URL",      "http://localhost:9002")
+NOVA_TOKEN    = os.getenv("NOVA_TOKEN",    "")   # Token del agente Conny en Nova
+NOVA_API_KEY  = os.getenv("NOVA_API_KEY",  "")   # API key de Nova
+NOVA_ENABLED  = os.getenv("NOVA_ENABLED",  "true").lower() == "true"
+NOVA_TIMEOUT  = float(os.getenv("NOVA_TIMEOUT", "3.0"))  # 3s max, no bloquear usuarios
+
+
+# ─── Veredictos de Nova ───────────────────────────────────────────────────────
+APPROVED  = "APPROVED"
+BLOCKED   = "BLOCKED"
+ESCALATED = "ESCALATED"
+UNKNOWN   = "UNKNOWN"
+
+
+# ─── Cache local para decisiones rápidas ─────────────────────────────────────
+_decision_cache: Dict[str, Tuple[str, float]] = {}
+_CACHE_TTL = 300  # 5 min
+
+def _cache_key(action: str, context: str) -> str:
+    import hashlib
+    return hashlib.md5(f"{action}|{context}".encode()).hexdigest()[:12]
+
+def _cache_get(key: str) -> Optional[str]:
+    if key in _decision_cache:
+        verdict, ts = _decision_cache[key]
+        if time.time() - ts < _CACHE_TTL:
+            return verdict
+    return None
+
+def _cache_set(key: str, verdict: str):
+    _decision_cache[key] = (verdict, time.time())
+
+
+# ─── Reglas locales pre-evaluación ───────────────────────────────────────────
+# Evita llamadas a Nova para casos obvios — <1ms
+
+# Mensajes que SIEMPRE se aprueban (mínimamente riesgosos)
+_ALWAYS_APPROVE_PATTERNS = [
+    r"^(hola|buenas|buenos días|buenas tardes)$",
+    r"^(ok|listo|dale|claro|perfecto|entendido)$",
+    r"agendar.*cita",
+    r"te paso.*información",
+    r"gracias.*escribir",
+    r"(horario|horarios|servicios|dirección|ubicación)",
+]
+
+# Mensajes que SIEMPRE se bloquean (nunca debería enviar esto un asistente médico)
+_ALWAYS_BLOCK_PATTERNS = [
+    r"(diagnóstico|diagnóstico médico|tengo cáncer|tienes cáncer)",
+    r"(toma.*pastilla|toma.*medicamento|dosis.*recomendad)",
+    r"(contraindicado.*absolutamente|no debes.*nunca.*hacer)",
+    r"(precio.*gratis|descuento.*100%|sin costo.*siempre)",
+    r"(manda.*fotos.*privadas|mándame.*foto)",
+]
+
+def _local_pre_check(action: str) -> Optional[str]:
+    """
+    Decisión local ultrarrápida antes de llamar a Nova.
+    Retorna APPROVED/BLOCKED/None (None = necesita Nova)
+    """
+    action_low = action.lower().strip()
+
+    for pattern in _ALWAYS_BLOCK_PATTERNS:
+        if re.search(pattern, action_low):
+            log.info(f"[nova_local] BLOCKED (local): {action[:60]}")
+            return BLOCKED
+
+    for pattern in _ALWAYS_APPROVE_PATTERNS:
+        if re.search(pattern, action_low):
+            return APPROVED
+
+    return None  # Necesita evaluación de Nova
+
+
+# ─── Cliente Nova ─────────────────────────────────────────────────────────────
+
+class NovaClient:
+    """Cliente para la API de Nova."""
+
+    def __init__(self, url: str = NOVA_URL, api_key: str = NOVA_API_KEY,
+                 token_id: str = NOVA_TOKEN):
+        self.url      = url.rstrip("/")
+        self.api_key  = api_key
+        self.token_id = token_id
+        self._healthy: Optional[bool] = None
+        self._last_health_check = 0.0
+
+    def _headers(self) -> Dict:
+        h = {"Content-Type": "application/json", "User-Agent": "conny/5.0"}
+        if self.api_key:
+            h["Authorization"] = f"Bearer {self.api_key}"
+            h["X-API-Key"] = self.api_key
+        return h
+
+    async def health_check(self) -> bool:
+        """Verifica si Nova está activo. Cachea el resultado por 30s."""
+        now = time.time()
+        if now - self._last_health_check < 30 and self._healthy is not None:
+            return self._healthy
+        try:
+            async with httpx.AsyncClient(timeout=2.0) as c:
+                r = await c.get(f"{self.url}/health", headers=self._headers())
+                self._healthy = r.status_code in (200, 204)
+                self._last_health_check = now
+                if self._healthy:
+                    log.debug("[nova] server healthy")
+                return self._healthy
+        except Exception as e:
+            log.debug(f"[nova] health check failed: {e}")
+            self._healthy = False
+            self._last_health_check = now
+            return False
+
+    async def validate(
+        self,
+        action: str,
+        context: str = "",
+        patient_id: str = "",
+        dry_run: bool = False
+    ) -> Dict:
+        """
+        Valida una acción con Nova.
+        Retorna: {"verdict": "APPROVED|BLOCKED|ESCALATED",
+                  "score": 0-100, "reason": "...", "ledger_id": "..."}
+        """
+        if not self.token_id:
+            return {"verdict": APPROVED, "reason": "no_token_configured"}
+
+        payload = {
+            "token_id":   self.token_id,
+            "action":     action,
+            "context":    context or patient_id,
+            "dry_run":    dry_run,
+            "check_duplicates": False,  # No duplicados para mensajes
+        }
+
+        try:
+            async with httpx.AsyncClient(timeout=NOVA_TIMEOUT) as c:
+                r = await c.post(f"{self.url}/validate",
+                                  json=payload, headers=self._headers())
+                if r.status_code == 200:
+                    return r.json()
+                elif r.status_code == 403:
+                    # Nova bloqueó
+                    return {
+                        "verdict": BLOCKED,
+                        "score":   0,
+                        "reason":  r.json().get("reason", "blocked by policy"),
+                        "ledger_id": r.json().get("ledger_id")
+                    }
+                else:
+                    log.warning(f"[nova] validate HTTP {r.status_code}")
+                    return {"verdict": APPROVED, "reason": f"nova_http_{r.status_code}"}
+        except asyncio.TimeoutError:
+            log.warning("[nova] validate timeout — approving (degraded mode)")
+            return {"verdict": APPROVED, "reason": "nova_timeout"}
+        except Exception as e:
+            log.warning(f"[nova] validate error: {e} — approving (degraded mode)")
+            return {"verdict": APPROVED, "reason": f"nova_error: {e}"}
+
+    async def create_agent_rule(
+        self,
+        agent_name: str,
+        can_do: List[str],
+        cannot_do: List[str],
+        authorized_by: str = "admin"
+    ) -> Dict:
+        """
+        Crea o actualiza el agente Conny en Nova con nuevas reglas.
+        Se llama cuando el admin agrega una nueva regla en lenguaje natural.
+        """
+        payload = {
+            "agent_name":    agent_name,
+            "description":   "Conny — recepcionista virtual de clínica estética",
+            "can_do":        can_do,
+            "cannot_do":     cannot_do,
+            "authorized_by": authorized_by,
+        }
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as c:
+                r = await c.post(f"{self.url}/tokens",
+                                  json=payload, headers=self._headers())
+                r.raise_for_status()
+                return r.json()
+        except Exception as e:
+            log.error(f"[nova] create_agent_rule error: {e}")
+            return {"error": str(e)}
+
+    async def get_ledger(self, limit: int = 20) -> List[Dict]:
+        """Obtiene el ledger de decisiones recientes."""
+        try:
+            async with httpx.AsyncClient(timeout=5.0) as c:
+                r = await c.get(f"{self.url}/ledger?limit={limit}",
+                                headers=self._headers())
+                r.raise_for_status()
+                return r.json()
+        except Exception as e:
+            log.warning(f"[nova] get_ledger error: {e}")
+            return []
+
+
+# ─── Guard de Conny ─────────────────────────────────────────────────────────
+
+class ConnyGuard:
+    """
+    Interceptor principal entre Conny y sus mensajes.
+    Se llama antes de enviar cualquier burbuja al paciente.
+    
+    Flujo:
+      1. Verificación local ultrarrápida (<1ms)
+      2. Caché de decisiones previas (~0ms)
+      3. Llamada a Nova si es necesario (~50-200ms)
+      4. Si Nova no está → modo degradado (aprueba todo)
+    """
+
+    def __init__(self, client: NovaClient = None):
+        self.client = client or NovaClient()
+        self._nova_available = None  # None = no verificado aún
+
+    async def should_send(
+        self,
+        message: str,
+        patient_chat_id: str = "",
+        context: str = "",
+        clinic_name: str = ""
+    ) -> Tuple[bool, str, str]:
+        """
+        Decide si Conny puede enviar este mensaje.
+        
+        Retorna: (should_send: bool, reason: str, ledger_id: str)
+        """
+        if not NOVA_ENABLED or not self.client.token_id:
+            return True, "nova_disabled", ""
+
+        # 1. Decisión local instantánea
+        local = _local_pre_check(message)
+        if local == BLOCKED:
+            return False, "local_policy_blocked", ""
+        if local == APPROVED:
+            return True, "local_policy_approved", ""
+
+        # 2. Cache
+        ck = _cache_key(message[:100], patient_chat_id)
+        cached = _cache_get(ck)
+        if cached:
+            return cached == APPROVED, f"cached_{cached.lower()}", ""
+
+        # 3. Nova
+        # Construir contexto rico para Nova
+        action = f"Send WhatsApp/Telegram message to patient: {message[:200]}"
+        full_context = (
+            f"Patient: {patient_chat_id} | "
+            f"Clinic: {clinic_name} | "
+            f"Context: {context[:200]}"
+        )
+
+        result = await self.client.validate(
+            action=action,
+            context=full_context,
+            patient_id=patient_chat_id
+        )
+
+        verdict   = result.get("verdict", UNKNOWN)
+        reason    = result.get("reason", "")
+        ledger_id = result.get("ledger_id", "") or ""
+
+        _cache_set(ck, verdict)
+
+        if verdict in (APPROVED, UNKNOWN):
+            return True, reason, str(ledger_id)
+        elif verdict == ESCALATED:
+            # Para clínicas: escalado = preguntarle al admin antes
+            log.info(f"[nova] ESCALATED: {message[:60]}")
+            return False, f"escalated: {reason}", str(ledger_id)
+        else:
+            # BLOCKED
+            log.info(f"[nova] BLOCKED (#{ledger_id}): {reason}")
+            return False, reason, str(ledger_id)
+
+    async def filter_bubbles(
+        self,
+        bubbles: List[str],
+        patient_chat_id: str = "",
+        context: str = "",
+        clinic_name: str = ""
+    ) -> Tuple[List[str], List[str]]:
+        """
+        Filtra una lista de burbujas.
+        Retorna: (allowed_bubbles, blocked_bubbles)
+        """
+        allowed = []
+        blocked = []
+
+        for bubble in bubbles:
+            ok, reason, _ = await self.should_send(
+                bubble, patient_chat_id, context, clinic_name
+            )
+            if ok:
+                allowed.append(bubble)
+            else:
+                blocked.append(bubble)
+                if not reason.startswith("local_"):
+                    log.info(f"[nova] bubble blocked: {bubble[:60]} | {reason}")
+
+        return allowed, blocked
+
+
+# ─── Traductor lenguaje natural → reglas Nova ─────────────────────────────────
+
+async def nl_to_nova_rules(
+    instruction: str,
+    llm_complete_fn,  # función llm_engine.complete de conny
+    existing_rules: Dict = None
+) -> Dict:
+    """
+    Traduce una instrucción en lenguaje natural a reglas de Nova.
+    
+    Ej: "No permitas que Conny le envíe precios a clientes con menos de 3 visitas"
+    →   cannot_do: ["send price information to new patients with fewer than 3 visits"]
+    
+    Retorna: {"can_do": [...], "cannot_do": [...], "explanation": "..."}
+    """
+    existing = json.dumps(existing_rules or {}, ensure_ascii=False)[:500]
+
+    prompt = f"""Eres un motor de políticas para Conny, una recepcionista virtual de clínica estética.
+
+El administrador dijo: "{instruction}"
+
+Reglas actuales:
+{existing}
+
+TAREA: Traduce esa instrucción a reglas para el motor de gobernanza Nova.
+
+Devuelve SOLO este JSON (sin markdown, sin explicación):
+{{
+  "can_do": ["acción específica que SÍ puede hacer relacionada con esto"],
+  "cannot_do": ["acción específica que NO puede hacer, formulada así: 'send/say/share X to/about Y'"],
+  "explanation": "resumen en una oración de lo que cambiará",
+  "rule_type": "block_message|allow_message|restrict_patient|restrict_content|restrict_timing"
+}}
+
+EJEMPLOS:
+"No le mandes precios a clientes nuevos"
+→ cannot_do: ["send price list to new patients who have contacted us fewer than 3 times",
+               "share pricing information before explaining service value"]
+
+"Permite hablar de descuentos solo si el dueño lo autoriza"
+→ cannot_do: ["mention discounts without admin approval",
+               "offer promotional pricing autonomously"]
+  can_do: ["discuss discounts after receiving admin approval token"]
+
+"Nunca le digas a una paciente que tiene muchas arrugas"
+→ cannot_do: ["make negative comments about patient's appearance",
+               "describe physical defects directly to patient"]"""
+
+    try:
+        raw, _ = await asyncio.wait_for(
+            llm_complete_fn(
+                [{"role": "user", "content": prompt}],
+                model_tier="fast",
+                temperature=0.1,
+                max_tokens=400,
+                use_cache=False
+            ),
+            timeout=10.0
+        )
+        raw = raw.strip()
+        m = re.search(r'\{[\s\S]+\}', raw)
+        if m:
+            return json.loads(m.group(0))
+    except Exception as e:
+        log.error(f"[nova_bridge] nl_to_rules error: {e}")
+
+    return {"can_do": [], "cannot_do": [], "explanation": "no procesado", "rule_type": "block_message"}
+
+
+# ─── Funciones de configuración ───────────────────────────────────────────────
+
+async def setup_conny_agent(
+    client: NovaClient,
+    clinic_name: str,
+    agent_name: str = "Conny"
+) -> Optional[str]:
+    """
+    Crea el agente Conny en Nova con reglas base para clínicas estéticas.
+    Retorna el token_id o None si falló.
+    """
+    can_do = [
+        "send appointment confirmations",
+        "answer questions about clinic services",
+        "provide clinic hours and location information",
+        "ask for patient name and contact information",
+        "offer free consultation booking",
+        "answer general questions about aesthetic procedures",
+        "provide general information about procedure duration and recovery",
+        "refer patients to call the clinic for urgent matters",
+    ]
+    cannot_do = [
+        "provide specific medical diagnosis",
+        "prescribe medications or dosages",
+        "share another patient's personal information",
+        "guarantee specific treatment results",
+        "offer unauthorized discounts or promotions",
+        "discuss competitor clinics negatively",
+        "share the clinic's internal pricing strategy",
+        "send messages that could be interpreted as medical advice",
+    ]
+
+    result = await client.create_agent_rule(
+        agent_name=f"Conny - {clinic_name}",
+        can_do=can_do,
+        cannot_do=cannot_do,
+        authorized_by="admin"
+    )
+
+    if "error" not in result:
+        token_id = result.get("token_id", "")
+        log.info(f"[nova] agente Conny creado: {token_id[:20]}...")
+        return token_id
+    return None
+
+
+async def get_ledger_summary(client: NovaClient, limit: int = 10) -> str:
+    """
+    Resumen del ledger de Nova para mostrar al admin.
+    """
+    entries = await client.get_ledger(limit=limit)
+    if not entries:
+        return "El ledger de Nova está vacío."
+
+    lines = [f"Últimas {len(entries)} decisiones de Nova:\n"]
+    for e in entries:
+        verdict = e.get("verdict", "?")
+        action  = (e.get("action", "") or "")[:60]
+        reason  = (e.get("reason", "") or "")[:40]
+        ts      = (e.get("created_at", "") or "")[:16]
+        icon    = "✓" if verdict == APPROVED else ("✗" if verdict == BLOCKED else "!")
+        lines.append(f"  {icon} [{ts}] {action} — {reason}")
+
+    return "\n".join(lines)
+
+
+# ─── Instancia global ──────────────────────────────────────────────────────────
+
+_guard: Optional[ConnyGuard] = None
+_client: Optional[NovaClient] = None
+
+
+def init_nova() -> ConnyGuard:
+    """Inicializa el puente Nova. Seguro aunque Nova no esté activo."""
+    global _guard, _client
+    _client = NovaClient(
+        url=NOVA_URL,
+        api_key=NOVA_API_KEY,
+        token_id=NOVA_TOKEN
+    )
+    _guard = ConnyGuard(_client)
+    if NOVA_ENABLED:
+        log.info(f"[nova] bridge iniciado → {NOVA_URL}")
+    else:
+        log.info("[nova] bridge desactivado (NOVA_ENABLED=false)")
+    return _guard
+
+
+def get_guard() -> Optional[ConnyGuard]:
+    return _guard
+
+
+def get_client() -> Optional[NovaClient]:
+    return _client