@innvisor/conny-ai 9.7.0

package/conny_uncertainty.py

@@ -0,0 +1,174 @@
+"""
+Conny Uncertainty Detector — Identifies knowledge gaps and alerts admins.
+
+Detects when Conny is uncertain about her answers and logs gaps
+for future training / admin intervention.
+"""
+
+import re
+import json
+import logging
+import asyncio
+import time
+from pathlib import Path
+from typing import Optional
+from datetime import datetime
+
+log = logging.getLogger("conny.uncertainty")
+
+UNCERTAINTY_MARKERS_ES = [
+    "no sé",
+    "no tengo información",
+    "no estoy segura",
+    "no puedo ayudar",
+    "no cuento con",
+    "no manejo esa información",
+    "no tengo datos",
+    "desconozco",
+    "no sabría decirte",
+    "tendría que consultar",
+    "no tengo acceso",
+    "no dispongo de",
+]
+
+UNCERTAINTY_MARKERS_EN = [
+    "i don't know",
+    "i'm not sure",
+    "i can't help with that",
+    "i don't have that information",
+    "let me check",
+]
+
+
+class UncertaintyDetector:
+    def __init__(self, threshold: float = 0.4):
+        self.threshold = threshold
+        self._gaps_dir = Path("knowledge_gaps")
+        self._gaps_dir.mkdir(exist_ok=True)
+
+    def detect_uncertainty_markers(self, text: str) -> bool:
+        """Return True if the text contains any uncertainty marker."""
+        text_low = text.lower()
+        return any(
+            marker in text_low
+            for marker in UNCERTAINTY_MARKERS_ES + UNCERTAINTY_MARKERS_EN
+        )
+
+    def confidence_score(self, response: str, user_msg: str, history: list) -> float:
+        """Score confidence 0.0-1.0. Detects evasion, not just explicit uncertainty."""
+        score = 1.0
+        text_low = response.lower()
+        user_low = user_msg.lower()
+
+        # Penalty for uncertainty markers
+        marker_count = sum(
+            1
+            for m in UNCERTAINTY_MARKERS_ES + UNCERTAINTY_MARKERS_EN
+            if m in text_low
+        )
+        score -= marker_count * 0.35
+
+        # Extra penalty if response IS the uncertainty (very short + marker)
+        if len(response.split()) < 8 and marker_count > 0:
+            score -= 0.15
+
+        # Penalty for very short responses to complex questions
+        if len(user_msg.split()) > 8 and len(response.split()) < 10:
+            score -= 0.2
+
+        # Penalty for deflection patterns
+        deflection = ["pregunta al", "consulta con", "contacta a", "llama a"]
+        if any(d in text_low for d in deflection):
+            score -= 0.15
+
+        # === NEW: Detect PRICE evasion ===
+        # User asked about price but response has no numbers/amounts
+        price_signals = ["cuanto", "cuánto", "precio", "vale", "cuesta", "cobran", "tarifa", "costo", "promo"]
+        user_asked_price = any(s in user_low for s in price_signals)
+        response_has_price = bool(re.search(r'\$?\d[\d.,]+', response)) or any(
+            w in text_low for w in ("gratis", "sin costo", "incluido")
+        )
+        if user_asked_price and not response_has_price:
+            score -= 0.45  # Heavy penalty: user asked price, we don't know it
+
+        # === NEW: Detect SERVICE evasion ===
+        # User asked about specific service but response says "we don't do that" or redirects
+        service_denial = [
+            "no manejamos", "no ofrecemos", "no realizamos", "no hacemos",
+            "no contamos con", "nuestra especialidad es", "solo manejamos",
+            "solo ofrecemos", "no tenemos ese",
+        ]
+        if any(d in text_low for d in service_denial):
+            score -= 0.3  # She might be wrong — she doesn't actually know the full service list
+
+        # === Detect INFO evasion (horarios, disponibilidad, etc) ===
+        info_signals = ["horario", "atienden", "abren", "cierran", "disponibilidad", "abierto", "cuando"]
+        user_asked_info = any(s in user_low for s in info_signals)
+        response_deflects = any(d in text_low for d in ["verificar", "confirmo", "consultar", "le confirmo"])
+        if user_asked_info and response_deflects:
+            score -= 0.55  # She doesn't know the schedule — must alert admin
+
+        # === Detect "depende" evasion ===
+        vague_deflectors = [
+            "depende del servicio", "depende de la valoración", "depende del caso",
+            "te confirmo", "déjame verificar", "let me check",
+        ]
+        if any(d in text_low for d in vague_deflectors) and user_asked_price:
+            score -= 0.35  # Vague + user wanted specifics = she doesn't know
+
+        # Bonus for specific information (contains numbers/concrete data)
+        if any(c.isdigit() for c in response):
+            score += 0.1
+
+        return max(0.0, min(1.0, score))
+
+    async def log_gap(
+        self,
+        instance_id: str,
+        user_msg: str,
+        bot_response: str,
+        confidence: float,
+        chat_id: str = "",
+    ):
+        """Log a knowledge gap to JSONL file."""
+        today = datetime.now().strftime("%Y-%m-%d")
+        gap_file = self._gaps_dir / f"{today}.jsonl"
+        entry = {
+            "ts": datetime.now().isoformat(),
+            "instance_id": instance_id,
+            "chat_id": chat_id,
+            "user_msg": user_msg,
+            "bot_response": bot_response,
+            "confidence": round(confidence, 3),
+        }
+        with open(gap_file, "a") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+        log.info(
+            f"[uncertainty] gap logged for {instance_id}: confidence={confidence:.2f}"
+        )
+
+    async def alert_admin(
+        self,
+        instance_id: str,
+        user_msg: str,
+        bot_response: str,
+        confidence: float,
+        send_fn=None,
+    ):
+        """Send WhatsApp alert to admin when confidence is low."""
+        alert_text = (
+            f"Hola, soy Conny de {instance_id}. "
+            f"Un paciente preguntó: '{user_msg[:200]}' "
+            f"y no supe responderle bien (confianza: {confidence:.0%}). "
+            f"¿Me puedes dar la información correcta para aprender?"
+        )
+        if send_fn:
+            try:
+                await send_fn(alert_text)
+            except Exception as e:
+                log.error(f"[uncertainty] failed to alert admin: {e}")
+        return alert_text
+
+
+# Singleton
+uncertainty_detector = UncertaintyDetector()

package/conny_utils.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+import hashlib
+import json
+import secrets
+import re
+from typing import Any, Dict, List, Optional
+
+ACTIVATION_PREFIX = "ACTV-"
+INVITE_PREFIX = "JINV-"
+
+def is_activation_token(text: str) -> bool:
+    """Detecta si el mensaje es un token de activacion."""
+    t = text.strip().upper()
+    return t.startswith(ACTIVATION_PREFIX) and len(t) >= 30
+
+def is_invite_token(text: str) -> bool:
+    """Detecta si el mensaje es un token de invitacion."""
+    t = text.strip().upper()
+    return t.startswith(INVITE_PREFIX) and len(t) >= 15
+
+def generate_activation_token(label: str) -> str:
+    """
+    Genera un token de activacion de alta entropia.
+    Formato: ACTV-[label_sanitizado]-[32_chars_hex]
+    """
+    import string
+    sanitized = re.sub(r'[^a-zA-Z0-9]', '', label.lower())[:10]
+    if not sanitized:
+        sanitized = "generic"
+    entropy = secrets.token_hex(16).upper()
+    return f"{ACTIVATION_PREFIX}{sanitized}-{entropy}"
+
+def hash_password(password: str) -> str:
+    """Hash de contrasena con PBKDF2 + salt."""
+    salt = secrets.token_hex(16)
+    key = hashlib.pbkdf2_hmac(
+        "sha256",
+        password.encode("utf-8"),
+        salt.encode("utf-8"),
+        260_000
+    ).hex()
+    return f"{salt}:{key}"
+
+def verify_password(password: str, stored_hash: str) -> bool:
+    """Verifica contrasena contra hash almacenado."""
+    try:
+        salt, key = stored_hash.split(":", 1)
+        test = hashlib.pbkdf2_hmac(
+            "sha256",
+            password.encode("utf-8"),
+            salt.encode("utf-8"),
+            260_000
+        ).hex()
+        return test == key
+    except Exception:
+        return False
+
+def _parse_admin_ids(raw) -> list:
+    """Parsea admin_chat_ids de forma segura."""
+    if not raw: return []
+    if isinstance(raw, list): return [str(i) for i in raw]
+    if isinstance(raw, str):
+        try:
+            data = json.loads(raw)
+            if isinstance(data, list): return [str(i) for i in data]
+            return [str(data)]
+        except Exception:
+            return [i.strip() for i in raw.split(",") if i.strip()]
+    return []
+
+def extract_model_request_from_text(text: str) -> Optional[str]:
+    """Extrae solicitud de cambio de modelo del lenguaje natural."""
+    t = text.lower().strip()
+    if not t.startswith("/modelo"):
+        if "cambia el modelo a" in t: return t.split("cambia el modelo a")[-1].strip()
+        if "usa el modelo" in t: return t.split("usa el modelo")[-1].strip()
+        return None
+    parts = t.split()
+    return parts[1] if len(parts) > 1 else "reset"
+
+def normalize_model_arg(arg: str) -> str:
+    """Normaliza el nombre del modelo solicitado."""
+    m = arg.lower().strip()
+    if m in ("flash", "gemini"): return "google/gemini-2.5-flash"
+    if m in ("pro", "sonnet"): return "anthropic/claude-3-5-sonnet"
+    if m in ("fast", "haiku"): return "anthropic/claude-3-haiku"
+    return m

package/conny_voice.py

@@ -0,0 +1,156 @@
+"""
+conny_voice.py — Humanization engine v2.
+Post-processes every LLM response to eliminate robot patterns and inject natural warmth.
+"""
+from __future__ import annotations
+import re, random, logging
+from typing import Optional, Dict, List
+
+log = logging.getLogger("conny.voice")
+
+# Patterns that MUST be removed/replaced from any response
+ROBOT_PATTERNS = [
+    (re.compile(r"como (IA|inteligencia artificial|(?:asistente|asesora)\s+virtual|bot)", re.I), ""),
+    (re.compile(r"no (tengo|tenemos) (la )?capacidad", re.I), "no manejo eso ahora mismo"),
+    (re.compile(r"está fuera de mi (alcance|capacidades)", re.I), "eso tendría que verificarlo"),
+    (re.compile(r"no (puedo|podemos) (procesar|entender)", re.I), "no tengo esa información ahora"),
+    (re.compile(r"^(Hola|Buenos días|Buenas tardes)[,!]?\s*(Soy|Me llamo)\s*Conny(?:,\s*(?:tu|la)\s+(?:asistente|asesora)\s+virtual)?[.!?]?(?:\s+|$)", re.I), ""),
+    (re.compile(r"¡?Por supuesto[,!]?\s*", re.I), ""),
+    (re.compile(r"¡?Claro que sí[,!]?\s*", re.I), ""),
+    (re.compile(r"¡?Con gusto[,!]?\s*", re.I), ""),
+    (re.compile(r"¡+", re.I), ""),  # Remove excessive exclamation
+    (re.compile(r"^\s*¡\s*", re.I), ""),
+    (re.compile(r",?\s*(?:tu|la)\s+(?:asistente|asesora)\s+virtual[.,]?\s*", re.I), ". "),
+    (re.compile(r"(?:como|en mi rol de) (?:asistente|asesora)\s+virtual", re.I), ""),
+    (re.compile(r"(?:soy\s+)?(?:tu|la\s+)?(?:asistente|asesora)\s+virtual", re.I), ""),
+    (re.compile(r"estoy aquí para (servirte|atenderte)", re.I), ""),
+    (re.compile(r"no dudes en", re.I), ""),
+    (re.compile(r"estaré encantad[ao] de", re.I), ""),
+    (re.compile(r"será un placer", re.I), ""),
+]
+
+# Natural fillers by sector
+SECTOR_FILLERS = {
+    "estetica": ["con mucho gusto", "perfecto", "listo", "dale"],
+    "salud": ["con gusto", "perfecto", "entendido", "listo"],
+    "restaurante": ["dale", "perfecto", "listo", "va"],
+    "retail": ["dale", "listo", "perfecto", "genial"],
+    "default": ["con gusto", "perfecto", "listo", "entendido"],
+}
+
+# Thinking block to prepend to system prompts
+THINKING_BLOCK_ES = """INSTRUCCIÓN INTERNA (no mostrar al usuario):
+Antes de responder, piensa en silencio:
+1. ¿Qué quiere realmente este usuario? (intención real)
+2. ¿Qué información tengo disponible para responderle?
+3. ¿Hay alguna ambigüedad? ¿Necesito pedir aclaración?
+4. ¿Cómo lo diría una recepcionista colombiana real, cálida, natural?
+5. ¿Mi respuesta suena robótica? Si sí, reescríbela.
+
+SOLO después de pensar, escribe la respuesta al usuario.
+NUNCA menciones este proceso. NUNCA uses frases como "como IA" o "no tengo la capacidad"."""
+
+THINKING_BLOCK_EN = """INTERNAL INSTRUCTION (do not show to user):
+Before responding, think silently:
+1. What does this user actually want?
+2. What information do I have to answer them?
+3. Is there any ambiguity? Should I ask for clarification?
+4. How would a real, warm receptionist say this?
+5. Does my response sound robotic? If yes, rewrite it.
+
+ONLY after thinking, write the response to the user.
+NEVER mention this process."""
+
+
+class ConnyVoice:
+    """Post-processes LLM output to sound human."""
+
+    def __init__(self, sector: str = "default", tone: str = "warm"):
+        self.sector = sector
+        self.tone = tone
+        self._fillers = SECTOR_FILLERS.get(sector, SECTOR_FILLERS["default"])
+
+    def humanize(self, text: str, persona_override: Optional[Dict] = None) -> str:
+        """Main post-processing pipeline."""
+        if not text or not text.strip():
+            return text
+
+        result = text
+
+        # 1. Remove robot patterns
+        for pattern, replacement in ROBOT_PATTERNS:
+            result = pattern.sub(replacement, result)
+
+        # 2. Clean up whitespace artifacts
+        result = re.sub(r'\s{2,}', ' ', result)
+        result = re.sub(r'\n{3,}', '\n\n', result)
+        result = result.strip()
+
+        # 3. Limit exclamation marks (max 1 per response)
+        excl_count = result.count('!')
+        if excl_count > 1:
+            # Keep only the first one
+            parts = result.split('!')
+            result = parts[0] + '!' + ''.join(parts[1:])
+
+        # 4. Response must NOT start with bot name
+        result = re.sub(r'^Conny[,:.]?\s*', '', result, flags=re.I)
+
+        # 5. Capitalize first letter
+        if result and result[0].islower():
+            result = result[0].upper() + result[1:]
+
+        # 6. Apply persona overrides if present
+        if persona_override:
+            forbidden = persona_override.get("forbidden_topics", [])
+            for topic in forbidden:
+                if topic.lower() in result.lower():
+                    result = re.sub(re.escape(topic), "[tema no disponible]", result, flags=re.I)
+
+        return result
+
+    def inject_thinking_block(self, system_prompt: str, lang: str = "es", thinking_budget: int = 0) -> str:
+        """Prepend chain-of-thought instruction to system prompt."""
+        block = THINKING_BLOCK_ES if lang == "es" else THINKING_BLOCK_EN
+        return block + "\n\n" + system_prompt
+
+    def split_long_response(self, text: str, max_chars: int = 300) -> List[str]:
+        """Split long responses into multiple WhatsApp-style messages."""
+        if len(text) <= max_chars:
+            return [text]
+
+        # Split on sentence boundaries
+        sentences = re.split(r'(?<=[.!?])\s+', text)
+        bubbles = []
+        current = ""
+
+        for sentence in sentences:
+            if len(current) + len(sentence) + 1 > max_chars and current:
+                bubbles.append(current.strip())
+                current = sentence
+            else:
+                current = (current + " " + sentence).strip() if current else sentence
+
+        if current:
+            bubbles.append(current.strip())
+
+        return bubbles if bubbles else [text]
+
+    def check_robot_patterns(self, text: str) -> List[str]:
+        """Return list of robot patterns found (for testing/monitoring)."""
+        found = []
+        for pattern, _ in ROBOT_PATTERNS:
+            if pattern.search(text):
+                found.append(pattern.pattern)
+        return found
+
+    @staticmethod
+    def get_thinking_params(provider: str, thinking_budget: int = 0) -> Dict:
+        """Get provider-specific thinking parameters."""
+        if provider == "claude" and thinking_budget > 0:
+            return {"thinking": {"type": "enabled", "budget_tokens": thinking_budget}}
+        return {}
+
+
+# Default instance
+voice = ConnyVoice()

package/conny_voice_engine.py

@@ -0,0 +1,124 @@
+"""conny_voice_engine.py — ElevenLabs voice with intelligent audio triggers."""
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import tempfile
+from typing import Dict, List, Optional, Tuple
+
+log = logging.getLogger("conny.voice_engine")
+
+BOOKING_KEYWORDS = ["confirmad", "agendad", "reservad", "cita quedó", "quedó para"]
+EMPATHY_KEYWORDS = ["dolor", "angustia", "urgente", "miedo", "preocup", "asust", "llor", "fiebre", "grave"]
+FAREWELL_KEYWORDS = ["chao", "gracias", "hasta luego", "bendiciones", "bye", "adiós", "nos vemos"]
+
+
+class ConnyVoiceEngine:
+    """
+    Smart voice engine. Only sends audio when it has high conversion impact.
+    Gracefully disabled if no ELEVENLABS_API_KEY is set.
+    """
+
+    def __init__(self, instance_id: str = "default"):
+        self.instance_id = instance_id
+        self.api_key = os.getenv("ELEVENLABS_API_KEY", "")
+        self.voice_id = os.getenv("ELEVENLABS_VOICE_ID", "21m00Tcm4TlvDq8ikWAM")
+        self.enabled = bool(self.api_key)
+        self._client = None
+        self._recent_audio_count = 0
+
+    def _get_client(self):
+        if not self._client and self.enabled:
+            try:
+                from elevenlabs.client import ElevenLabs
+                self._client = ElevenLabs(api_key=self.api_key)
+            except ImportError:
+                log.warning("[voice_engine] elevenlabs package not installed")
+                self.enabled = False
+        return self._client
+
+    async def should_send_audio(self, response: str, context: Dict, history: List) -> Tuple[bool, str]:
+        if not self.enabled:
+            return False, "disabled"
+        if context.get("user_sent_audio"):
+            return True, "reciprocity"
+        if self._recent_audio_count >= 1:
+            return False, "cooldown"
+        if len(response.strip()) < 20:
+            return False, "too_short"
+        if len(response.strip()) > 300:
+            return False, "too_long"
+
+        response_low = response.lower()
+        if any(kw in response_low for kw in BOOKING_KEYWORDS):
+            return True, "booking_confirmed"
+
+        user_msg = ""
+        for m in reversed(history[-5:]):
+            if m.get("role") == "user":
+                user_msg = m.get("content", "").lower()
+                break
+        if any(kw in user_msg for kw in EMPATHY_KEYWORDS):
+            return True, "empathy_required"
+        if any(kw in response_low for kw in FAREWELL_KEYWORDS):
+            return True, "farewell"
+        if context.get("is_first_turn") and len(history) <= 2:
+            return True, "welcome_new_user"
+
+        return False, "no_trigger"
+
+    async def text_to_audio(self, text: str) -> Optional[str]:
+        if not self.enabled:
+            return None
+        client = self._get_client()
+        if not client:
+            return None
+        try:
+            from elevenlabs import VoiceSettings
+            audio = client.text_to_speech.convert(
+                text=text,
+                voice_id=self.voice_id,
+                model_id="eleven_flash_v2_5",
+                output_format="mp3_44100_128",
+                voice_settings=VoiceSettings(
+                    stability=0.45,
+                    similarity_boost=0.80,
+                    style=0.35,
+                    use_speaker_boost=True,
+                ),
+            )
+            tmp = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False)
+            for chunk in audio:
+                tmp.write(chunk)
+            tmp.close()
+            self._recent_audio_count += 1
+            return tmp.name
+        except Exception as e:
+            log.error(f"[voice_engine] TTS error: {e}")
+            return None
+
+    async def process_response(self, response: str, context: Dict, history: List,
+                               send_text_fn=None, send_audio_fn=None):
+        if not self.enabled or not send_audio_fn:
+            if send_text_fn:
+                await send_text_fn(response)
+            return
+
+        send_audio, reason = await self.should_send_audio(response, context, history)
+        if send_audio:
+            log.info(f"[voice_engine] sending audio [{reason}]: {response[:50]}...")
+            audio_path = await self.text_to_audio(response)
+            if audio_path:
+                await send_audio_fn(audio_path)
+                os.unlink(audio_path)
+                if send_text_fn:
+                    await asyncio.sleep(0.8)
+                    await send_text_fn(f"_{response}_")
+            elif send_text_fn:
+                await send_text_fn(response)
+        elif send_text_fn:
+            await send_text_fn(response)
+
+    def reset_cooldown(self):
+        self._recent_audio_count = 0

package/conny_web_search.py

@@ -0,0 +1,66 @@
+"""conny_web_search.py — Web search via Brave Search API."""
+from __future__ import annotations
+
+import logging
+import os
+from typing import List, Dict, Optional
+
+import httpx
+
+log = logging.getLogger("conny.web_search")
+
+BRAVE_API_KEY = os.getenv("BRAVE_API_KEY", "")
+BRAVE_URL = "https://api.search.brave.com/res/v1/web/search"
+
+
+async def search_web(query: str, num_results: int = 5) -> List[Dict[str, str]]:
+    """Search the web using Brave Search API. Returns list of {title, snippet, url}."""
+    if not BRAVE_API_KEY:
+        log.debug("[web_search] no BRAVE_API_KEY configured")
+        return []
+
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            r = await client.get(
+                BRAVE_URL,
+                params={"q": query, "count": num_results},
+                headers={"X-Subscription-Token": BRAVE_API_KEY, "Accept": "application/json"},
+            )
+            if r.status_code != 200:
+                log.warning(f"[web_search] Brave returned {r.status_code}")
+                return []
+            data = r.json()
+            results = []
+            for item in data.get("web", {}).get("results", [])[:num_results]:
+                results.append({
+                    "title": item.get("title", ""),
+                    "snippet": item.get("description", ""),
+                    "url": item.get("url", ""),
+                })
+            return results
+    except Exception as e:
+        log.error(f"[web_search] error: {e}")
+        return []
+
+
+async def search_business(business_name: str, city: str = "Medellín") -> str:
+    """Search for a business and return a summary string for LLM context."""
+    query = f"{business_name} {city} servicios precios horario"
+    results = await search_web(query, num_results=5)
+    if not results:
+        return ""
+    lines = []
+    for r in results:
+        lines.append(f"- {r['title']}: {r['snippet'][:150]}")
+    return "\n".join(lines)
+
+
+async def search_topic(topic: str) -> str:
+    """General topic search, returns formatted results."""
+    results = await search_web(topic, num_results=3)
+    if not results:
+        return ""
+    lines = []
+    for r in results:
+        lines.append(f"- {r['title']}: {r['snippet'][:200]}")
+    return "\n".join(lines)