@innvisor/conny-ai 9.7.0

package/src/conny/core/router.py

@@ -0,0 +1,297 @@
+"""Webhook handlers and command routing for all supported platforms."""
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+# TODO: inject dependency — these constants come from config/session layer
+from conny_config import Config, DEMO_CMD_ALIASES, DEMO_COMMANDS, DEMO_HELP_FULL
+
+log = logging.getLogger("conny.router")
+
+
+# -- Platform Detection --------------------------------------------------------
+
+def detect_incoming_platform(body: Dict[str, Any]) -> str:
+    """Detect which platform sent the message."""
+    if body.get("entry"):
+        entry = body["entry"][0] if body["entry"] else {}
+        changes = entry.get("changes", [{}])[0] if entry.get("changes") else {}
+        value = changes.get("value", {})
+        if value.get("messages"):
+            return "whatsapp_cloud"
+        if value.get("statuses"):
+            return "whatsapp_cloud"
+    if body.get("message") or body.get("edited_message"):
+        return "telegram"
+    if body.get("data", {}).get("key", {}).get("fromMe"):
+        return "evolution"
+    if body.get("iswa"):
+        return "whatsapp"
+    return "unknown"
+
+
+# -- Command Detection ---------------------------------------------------------
+
+def detect_command(text: str) -> Optional[str]:
+    """Detect if text is a command (slash or natural language alias)."""
+    if not text:
+        return None
+    text_norm = text.lower().strip()
+
+    # Slash commands
+    if text_norm.startswith("/"):
+        return text_norm
+
+    # Natural language aliases
+    for alias, cmd in DEMO_CMD_ALIASES.items():
+        if text_norm == alias or text_norm == "/" + alias:
+            return "/" + cmd
+
+    return None
+
+
+# -- Full Command Handler ------------------------------------------------------
+
+def handle_command(
+    chat_id: str,
+    text: str,
+    demo_sessions: Dict[str, Any],
+    send_fn,
+) -> Optional[List[str]]:
+    """
+    Handle commands BEFORE session lookup.
+    Returns a list of response strings, or None if not a command.
+    """
+    cmd = text.strip()
+    if not cmd.startswith("/"):
+        return None
+
+    # /help
+    if cmd in ("/help", "/ayuda", "/comandos"):
+        bn = demo_sessions.get(chat_id + "_name", "")
+        if bn:
+            return [DEMO_HELP_FULL]
+        return [
+            "Comandos: /help | /reset | /bot | /status | /memoria"
+        ]
+
+    # /reset
+    if cmd in ("/reset", "/reiniciar"):
+        keys_del = [k for k in list(demo_sessions) if k.startswith(chat_id + "_") and not k.endswith("_ts")]
+        for k in keys_del:
+            try:
+                del demo_sessions[k]
+            except Exception:
+                pass
+        return ["listo, sesión limpia ||| empezamos de nuevo"]
+
+    # /status
+    if cmd in ("/status", "/estado"):
+        bn = demo_sessions.get(chat_id + "_name", "")
+        return [f"Estado: {'demo activa' if bn else 'en onboarding'} ||| negocio: {bn or 'sin nombre'}"]
+
+    # /bot
+    if cmd in ("/bot", "/recepcionista"):
+        return ["modo recepcionista ||| háblame como cliente y te respondo en contexto"]
+
+    # /memoria
+    if cmd in ("/memoria",):
+        return ["no tengo memoria activa todavía ||| en la próxima versión lo tendre"]
+
+    return None
+
+
+# -- Webhook Parser: Telegram --------------------------------------------------
+
+def parse_telegram_message(body: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Parse Telegram webhook body into standard message format."""
+    msg = body.get("message") or body.get("edited_message")
+    if not msg:
+        return None
+
+    chat = msg.get("chat") or {}
+    chat_id = str(chat.get("id", ""))
+    if not chat_id:
+        return None
+
+    voice = msg.get("voice") or msg.get("audio")
+    audio_id = voice.get("file_id") if voice else None
+
+    document = msg.get("document")
+    photos = msg.get("photo") or []
+    caption = msg.get("caption", "").strip()
+
+    attachments = []
+    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": caption,
+        })
+    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": caption,
+        })
+
+    text = msg.get("text", "").strip() or caption
+
+    return {
+        "chat_id": chat_id,
+        "text": text,
+        "audio_id": audio_id,
+        "attachments": attachments,
+        "platform": "telegram",
+    }
+
+
+# -- Webhook Parser: WhatsApp Cloud -------------------------------------------
+
+def parse_whatsapp_cloud_message(body: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Parse WhatsApp Cloud API webhook body."""
+    try:
+        entry = body.get("entry", [{}])[0]
+        changes = entry.get("changes", [{}])[0]
+        value = changes.get("value", {})
+        msgs = value.get("messages", [])
+        if not msgs:
+            return None
+        msg = msgs[0]
+        chat_id = msg.get("from", "")
+        msg_type = msg.get("type", "text")
+
+        attachments = []
+        text = None
+        audio_id = None
+
+        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()
+
+        return {
+            "chat_id": chat_id,
+            "text": text,
+            "audio_id": audio_id,
+            "attachments": attachments,
+            "platform": "whatsapp_cloud",
+        }
+    except (IndexError, KeyError, TypeError):
+        return None
+
+
+# -- Webhook Parser: WhatsApp Bridge ------------------------------------------
+
+def parse_whatsapp_bridge_message(body: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Parse WhatsApp Bridge (Baileys) webhook body."""
+    try:
+        chat_id = body.get("key", {}).get("remoteJid", "")
+        if not chat_id:
+            return None
+        if chat_id.endswith("@g.us"):
+            return None  # Skip group chats
+
+        attachments = []
+        text = body.get("message", {}).get("conversationMessage", {}).get("conversation", "").strip()
+
+        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", ""),
+            })
+            text = ""
+
+        if body.get("isDocument") and body.get("docBase64"):
+            attachments.append({
+                "kind": "document",
+                "platform": "whatsapp",
+                "filename": body.get("docName", f"wa_doc_{body.get('messageId', 'doc')}"),
+                "mime_type": body.get("docMime", "application/octet-stream"),
+                "caption": text or "",
+                "base64": body.get("docBase64", ""),
+            })
+            text = ""
+
+        audio_id = None
+        if body.get("isAudio") and body.get("audioBase64"):
+            b64_mime = body.get("audioMime", "audio/ogg")
+            audio_id = f"wa_b64:{b64_mime}:{body['audioBase64']}"
+
+        return {
+            "chat_id": chat_id,
+            "text": text,
+            "audio_id": audio_id,
+            "attachments": attachments,
+            "platform": "whatsapp",
+        }
+    except Exception:
+        return None
+
+
+# -- Full Webhook Parser -------------------------------------------------------
+
+def parse_webhook(body: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Parse any webhook body into standard format."""
+    platform = detect_incoming_platform(body)
+
+    if platform == "telegram":
+        return parse_telegram_message(body)
+    elif platform == "whatsapp_cloud":
+        return parse_whatsapp_cloud_message(body)
+    elif platform == "whatsapp":
+        return parse_whatsapp_bridge_message(body)
+    elif platform == "evolution":
+        try:
+            data = body.get("data", {})
+            key = data.get("key", {})
+            if key.get("fromMe", False):
+                return None
+            chat_id = key.get("remoteJid", "")
+            msg_data = data.get("message", {})
+            conv = msg_data.get("conversationMessage", {}).get("conversation", "").strip()
+            ext = msg_data.get("extendedTextMessage", {})
+            text = conv or ext.get("text", "").strip() or ""
+            return {
+                "chat_id": chat_id,
+                "text": text,
+                "audio_id": None,
+                "attachments": [],
+                "platform": "evolution",
+            }
+        except Exception:
+            return None
+
+    return None

package/src/conny/core/session.py

@@ -0,0 +1,312 @@
+"""Demo session management: state storage, key generation, TTL cleanup, language detection."""
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, List, Optional, Tuple
+
+# TODO: inject dependency
+# from conny_config import Config
+
+
+class _DefaultConfig:
+    """Fallback config when dependency is not injected."""
+    DEMO_SESSION_TTL = 1800
+    DEMO_MODE = False
+    DEMO_BUSINESS_NAME = "tu negocio"
+    DEMO_SECTOR = "estetica"
+
+
+Config = _DefaultConfig
+
+
+class SessionManager:
+    """
+    Gestor de sesiones demo para Conny Ultra.
+
+    Maneja el estado de sesiones demo de usuarios, incluyendo:
+    - Nombre del negocio (bname_key)
+    - Contexto/descripcion del negocio (bctx_key)
+    - Estado de busqueda web (bfound_key, burl_key)
+    - Tracking de tricks/demo commands (btrick_key)
+    - Persona/archetype (bpersona_key)
+    - Tono detectado (btone_key)
+    - Modelo LLM preferido (bmodel_key)
+    - Idioma del owner (blang_key)
+    - Modo aprendizaje (blearn_key)
+    - Modo simulacion (bsim_key)
+    """
+
+    def __init__(self, sessions_dict: Dict[str, float] = None, emoji_chats_off: set = None):
+        self._demo_sessions: Dict[str, float] = sessions_dict if sessions_dict is not None else {}
+        self._emoji_chats_off: set = emoji_chats_off if emoji_chats_off is not None else set()
+
+    def is_demo_mode_active(self) -> bool:
+        """Verifica si hay sesiones demo activas."""
+        now = time.time()
+        return any(
+            k.endswith("_ts") and (now - v) < Config.DEMO_SESSION_TTL
+            for k, v in self._demo_sessions.items()
+        )
+
+    def get_demo_session(self, chat_id: str) -> Dict[str, Any]:
+        """
+        Obtiene todos los valores de sesion para un chat_id.
+
+        Args:
+            chat_id: Identificador del chat
+
+        Returns:
+            Dict con todas las claves de sesion del demo
+        """
+        sk = f"demo_{chat_id}"
+        keys = [
+            f"{sk}_name", f"{sk}_ctx", f"{sk}_found", f"{sk}_url",
+            f"{sk}_trick", f"{sk}_persona", f"{sk}_tone", f"{sk}_model",
+            f"{sk}_owner_lang", f"{sk}_learn", f"{sk}_sim_mode"
+        ]
+        return {k.replace(sk + "_", ""): self._demo_sessions.get(k) for k in keys}
+
+    def set_demo_session(self, chat_id: str, key: str, value: Any) -> None:
+        """
+        Establece un valor en la sesion demo.
+
+        Args:
+            chat_id: Identificador del chat
+            key: Clave (sin prefijo demo_{chat_id}_)
+            value: Valor a almacenar
+        """
+        sk = f"demo_{chat_id}"
+        self._demo_sessions[f"{sk}_{key}"] = value
+        if key == "ts":
+            self._touch_session(chat_id)
+
+    def clear_demo_session(self, chat_id: str) -> None:
+        """
+        Limpia todos los datos de sesion para un chat_id.
+
+        Args:
+            chat_id: Identificador del chat
+        """
+        sk = f"demo_{chat_id}"
+        keys_to_delete = [k for k in list(self._demo_sessions) if k.startswith(sk + "_")]
+        for k in keys_to_delete:
+            del self._demo_sessions[k]
+
+    def _touch_session(self, chat_id: str) -> None:
+        """Actualiza el timestamp de la sesion."""
+        sk = f"demo_{chat_id}"
+        self._demo_sessions[f"{sk}_ts"] = time.time()
+
+    def cleanup_expired_sessions(self) -> int:
+        """
+        Limpia sesiones expiradas basandose en TTL.
+
+        Returns:
+            Numero de sesiones limpiadas
+        """
+        now = time.time()
+        ttl = Config.DEMO_SESSION_TTL
+
+        expired_keys = []
+        for k, v in self._demo_sessions.items():
+            if k.endswith("_ts") and (now - v) > ttl * 2:
+                expired_keys.append(k)
+
+        for k in expired_keys:
+            chat_id = k.replace("_ts", "").replace("demo_", "")
+            self.clear_demo_session(chat_id)
+
+        return len(expired_keys)
+
+    def generate_session_keys(self, chat_id: str) -> Dict[str, str]:
+        """
+        Genera todas las claves de sesion para un chat_id.
+
+        Args:
+            chat_id: Identificador del chat
+
+        Returns:
+            Dict con todas las claves de sesion generadas
+        """
+        sk = f"demo_{chat_id}"
+        return {
+            "bname_key": sk + "_name",
+            "bctx_key": sk + "_ctx",
+            "bfound_key": sk + "_found",
+            "burl_key": sk + "_url",
+            "btrick_key": sk + "_trick",
+            "bpersona_key": sk + "_persona",
+            "btone_key": sk + "_tone",
+            "bmodel_key": sk + "_model",
+            "blang_key": sk + "_owner_lang",
+            "blearn_key": sk + "_learn",
+            "bsim_key": sk + "_sim_mode",
+            "sk": sk,
+        }
+
+    def get_session_value(self, chat_id: str, key: str, default: Any = None) -> Any:
+        """Obtiene un valor especifico de la sesion."""
+        sk = f"demo_{chat_id}"
+        return self._demo_sessions.get(f"{sk}_{key}", default)
+
+    def set_session_value(self, chat_id: str, key: str, value: Any) -> None:
+        """Establece un valor especifico en la sesion."""
+        sk = f"demo_{chat_id}"
+        self._demo_sessions[f"{sk}_{key}"] = value
+        self._touch_session(chat_id)
+
+    def set_timestamp(self, chat_id: str) -> None:
+        """Actualiza el timestamp de la sesion sin setear un valor de clave."""
+        self._touch_session(chat_id)
+
+    def touch_and_cleanup(self, chat_id: str) -> Tuple[bool, List[str]]:
+        """
+        Toca el timestamp y limpia sesiones expiradas.
+        Retorna (is_new, keys_to_delete) donde keys_to_delete son las claves
+        que deben borrarse si is_new=True.
+        """
+        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_to_delete = [k for k in list(self._demo_sessions)
+                              if k.startswith(sk + "_") and not k.endswith("_ts")]
+        else:
+            keys_to_delete = []
+        return is_new, keys_to_delete
+
+    def is_session_new(self, chat_id: str) -> bool:
+        """Determina si la sesion es nueva (expiro el TTL)."""
+        sk = f"demo_{chat_id}"
+        now = time.time()
+        last_seen = self._demo_sessions.get(sk + "_ts", 0)
+        return (now - last_seen) > Config.DEMO_SESSION_TTL
+
+    def reset_session(self, chat_id: str) -> None:
+        """Resetea completamente la sesion (para expiracion)."""
+        sk = f"demo_{chat_id}"
+        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]
+        self._touch_session(chat_id)
+
+
+def _detect_demo_owner_language(raw_text: str, current_lang: str = "es") -> str:
+    """
+    Detecta el idioma del owner en modo demo basandose en senales explicitas.
+
+    Args:
+        raw_text: Mensaje original del usuario
+        current_lang: Idioma actual detectado
+
+    Returns:
+        Codigo de idioma ('es', 'en', 'pt')
+    """
+    # TODO: inject dependency
+    # from conny_helpers import _normalize_conv_text
+    def _normalize_conv_text(s):
+        return s.lower().strip() if s else ""
+
+    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 = (
+        "so portugues", "so portugues", "falo portugues",
+        "nao falo espanhol", "nao 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"
+
+    # TODO: inject dependency
+    # from multilingual import MultilingualHandler
+    # detected = MultilingualHandler().detect(raw_text)
+    detected = "es"
+
+    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")
+
+
+def _owner_confusion_or_language_signal(raw_text: str) -> bool:
+    """
+    Detecta senales de confusion del owner o cambio de idioma.
+
+    Args:
+        raw_text: Mensaje del usuario
+
+    Returns:
+        True si detecta senal de confusion/language switch
+    """
+    # TODO: inject dependency
+    # from conny_helpers import _normalize_conv_text
+    def _normalize_conv_text(s):
+        return s.lower().strip() if s else ""
+
+    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 espanol", "no hablo espanol",
+        "solo ingles", "solo ingles",
+    )
+    return any(signal in normalized for signal in signals)
+
+
+def _lang_text(es_text: str, en_text: str, pt_text: Optional[str] = None,
+               owner_lang: str = "es") -> str:
+    """
+    Retorna texto segun el idioma del owner.
+
+    Args:
+        es_text: Texto en espanol
+        en_text: Texto en ingles
+        pt_text: Texto en portugues (opcional)
+        owner_lang: Idioma del owner
+
+    Returns:
+        Texto en el idioma apropiado
+    """
+    if owner_lang == "en":
+        return en_text
+    if owner_lang == "pt" and pt_text is not None:
+        return pt_text
+    return es_text