@innvisor/conny-ai 9.7.0

package/conny_demo_v2.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+"""conny_demo_v2.py — Ultra-realistic demo with Colombian personas and memory."""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import random
+import sys
+import time
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import httpx
+
+API_URL = "http://localhost:8001/test"
+MASTER_KEY = os.getenv("MASTER_API_KEY", "conny_master_2026_santiago")
+
+DEMO_PERSONAS = {
+    "dona_carmen": {
+        "profile": "Mujer 65 años, Medellín, no tecnológica, formal",
+        "typing_wpm": 20,
+        "typos": True,
+        "messages": [
+            "buenas tardes quiero saber si hay cita para el medico",
+            "es que me duele el pecho hace dias",
+            "cuanto vale la consulta",
+            "y el doctor atiende mañana",
+            "no pues gracias mija que Dios la bendiga",
+        ],
+    },
+    "juan_ejecutivo": {
+        "profile": "Hombre 35 años, ocupado, directo, WhatsApp",
+        "typing_wpm": 60,
+        "typos": False,
+        "messages": [
+            "Hola! Cita cardio para mañana si hay?",
+            "Cuánto tarda la espera normalmente",
+            "Ok perfecto, quedamos así entonces 👍",
+        ],
+    },
+    "mama_preocupada": {
+        "profile": "Mamá 40 años, hijo enfermo, ansiosa",
+        "typing_wpm": 45,
+        "typos": False,
+        "messages": [
+            "Hola urgente mi hijo de 8 años tiene fiebre alta",
+            "Me pueden atender hoy??",
+            "Tiene 39.5 grados y lleva 2 días así",
+            "A qué hora hay pediatra",
+        ],
+    },
+    "joven_curioso": {
+        "profile": "Hombre 22 años, primera vez, informal",
+        "typing_wpm": 70,
+        "typos": True,
+        "messages": [
+            "ey hola q tal",
+            "quiero saber si hacen limpieza facial",
+            "y eso duele? jaja",
+            "bueno listo agendame pa cuando haya",
+            "vale gracias bro",
+        ],
+    },
+    "abuela_tecnologica": {
+        "profile": "Mujer 72 años, nietos le enseñaron WhatsApp, muy educada",
+        "typing_wpm": 15,
+        "typos": True,
+        "messages": [
+            "Buenos dias señorita",
+            "Disculpe la molestia quisiera saber si puedo sacar una cita",
+            "Es para un control de tension arterial",
+            "Mi nombre es Rosa Elena Martinez",
+            "Muchas gracias señorita muy amable Dios la bendiga",
+        ],
+    },
+}
+
+TYPO_MAP = {
+    "que": "q", "para": "pa", "por favor": "porfa", "está": "esta",
+    "también": "tambien", "después": "despues", "cuánto": "cuanto",
+}
+
+
+def inject_typos(text: str, rate: float = 0.05) -> str:
+    """Inject realistic typos based on rate."""
+    words = text.split()
+    result = []
+    for w in words:
+        if random.random() < rate and len(w) > 3:
+            # Swap two adjacent chars
+            i = random.randint(0, len(w) - 2)
+            w = w[:i] + w[i + 1] + w[i] + w[i + 2:]
+        result.append(w)
+    return " ".join(result)
+
+
+def simulate_typing_delay(text: str, wpm: int = 35) -> float:
+    """Calculate realistic typing delay."""
+    chars_per_second = (wpm * 5) / 60
+    delay = len(text) / chars_per_second
+    return min(delay, 6.0)
+
+
+def color(text, code):
+    return f"\033[{code}m{text}\033[0m"
+
+
+async def send_to_conny(message: str, chat_id: str) -> Dict:
+    """Send message to Conny API."""
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        r = await client.post(
+            API_URL,
+            json={"message": message, "chat_id": chat_id},
+            headers={"X-Master-Key": MASTER_KEY, "Content-Type": "application/json"},
+        )
+        return r.json()
+
+
+async def run_demo(persona_key: str = "dona_carmen", instance_id: str = "default"):
+    """Run a full multi-turn demo with a persona."""
+    persona = DEMO_PERSONAS.get(persona_key)
+    if not persona:
+        print(f"Persona '{persona_key}' not found. Available: {list(DEMO_PERSONAS.keys())}")
+        return
+
+    chat_id = f"demo_{persona_key}_{int(time.time())}"
+
+    print()
+    print(color("╔══════════════════════════════════════════════╗", "1;36"))
+    print(color("║  CONNY DEMO v2.0 — Simulación Realista     ║", "1;36"))
+    print(color("╚══════════════════════════════════════════════╝", "1;36"))
+    print(f"  Persona: {color(persona_key, '1')} — {persona['profile']}")
+    print(f"  Instance: {instance_id}")
+    print(f"  Velocidad: {persona['typing_wpm']} WPM | Typos: {'sí' if persona['typos'] else 'no'}")
+    print("─" * 50)
+    print()
+
+    for i, msg in enumerate(persona["messages"]):
+        # Simulate typing delay
+        delay = simulate_typing_delay(msg, persona["typing_wpm"])
+        if i > 0:
+            # Thinking time before next message
+            await asyncio.sleep(random.uniform(1.5, 4.0))
+
+        # Apply typos if persona has them
+        display_msg = msg
+        if persona["typos"] and random.random() < 0.3:
+            display_msg = inject_typos(msg, rate=0.08)
+
+        # Show user typing indicator
+        print(f"  {color('...typing...', '90')}", end="\r")
+        await asyncio.sleep(min(delay, 3.0))
+        print(f"  {color(f'[{persona_key.upper()}]', '1;33')} {display_msg}")
+
+        # Get Conny's response
+        try:
+            result = await send_to_conny(display_msg, chat_id)
+            bubbles = result.get("bubbles", [result.get("response", "error")])
+            # Simulate Conny "thinking"
+            await asyncio.sleep(random.uniform(1.0, 2.5))
+            for bubble in bubbles:
+                print(f"  {color('[CONNY]', '1;35')} {bubble}")
+                if len(bubbles) > 1:
+                    await asyncio.sleep(random.uniform(0.5, 1.5))
+        except Exception as e:
+            print(f"  {color('[ERROR]', '31')} {e}")
+
+        print()
+
+    print("─" * 50)
+    print(color("  Demo completada.", "90"))
+    print(f"  {len(persona['messages'])} turnos | Chat ID: {chat_id}")
+    print()
+
+
+async def run_all_demos(instance_id: str = "default"):
+    """Run all demo personas sequentially."""
+    for persona_key in DEMO_PERSONAS:
+        await run_demo(persona_key, instance_id)
+        print("\n" + "═" * 50 + "\n")
+        await asyncio.sleep(2)
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Conny Demo v2 — Realistic Colombian personas")
+    parser.add_argument("--persona", "-p", default="dona_carmen",
+                        choices=list(DEMO_PERSONAS.keys()) + ["all"],
+                        help="Which persona to simulate")
+    parser.add_argument("--instance", "-i", default="default", help="Instance ID")
+    parser.add_argument("--list", "-l", action="store_true", help="List available personas")
+    args = parser.parse_args()
+
+    if args.list:
+        print("Available demo personas:")
+        for key, p in DEMO_PERSONAS.items():
+            print(f"  {key:20s} — {p['profile']}")
+        return
+
+    if args.persona == "all":
+        asyncio.run(run_all_demos(args.instance))
+    else:
+        asyncio.run(run_demo(args.persona, args.instance))
+
+
+if __name__ == "__main__":
+    main()

package/conny_demo_voice.py

@@ -0,0 +1,134 @@
+"""conny_demo_voice.py — Voice cascade with ElevenLabs for demo mode."""
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import tempfile
+from typing import List, Optional, Tuple
+
+import httpx
+
+log = logging.getLogger("conny.demo_voice")
+
+# Cascade of API keys — if first fails, try second
+API_KEYS = [
+    os.getenv("ELEVENLABS_API_KEY", "sk_e200c93fe4787b44dae55fdfe4e938d1f07ebbd2b0a67bb7"),
+    os.getenv("ELEVENLABS_API_KEY_2", "sk_199e6c73c2adbdeedd746de08fbb3ec7e9067259c7210c50"),
+]
+
+# Female voices ranked by how natural/warm they sound in Spanish
+# All free tier, tested for WhatsApp voice note quality
+VOICE_CASCADE: List[Tuple[str, str]] = [
+    ("cgSgspJ2msm6clMCkdW9", "Jessica"),   # Playful, Bright, Warm — young (best for Colombian)
+    ("EXAVITQu4vr4xnSDxMaL", "Sarah"),     # Mature, Confident — young (backup)
+    ("FGY2WhTYpPnrIDTdsKH5", "Laura"),      # Enthusiast, quirky — young (energetic)
+    ("hpp4J3VqNfWAUOO0d1Us", "Bella"),      # Professional, Warm — middle_aged (formal fallback)
+]
+
+# Default: Jessica (most natural for Colombian Spanish)
+DEFAULT_VOICE = VOICE_CASCADE[0][0]
+
+
+async def generate_demo_audio(text: str, voice_idx: int = 0) -> Optional[str]:
+    """Generate audio with cascade: try key1 → key2, voice1 → voice2 → voice3."""
+    if not any(API_KEYS):
+        return None
+
+    # Try each API key
+    for key in API_KEYS:
+        if not key:
+            continue
+        # Try voices in order
+        for vid, vname in VOICE_CASCADE[voice_idx:voice_idx + 2]:
+            result = await _try_generate(text, key, vid)
+            if result:
+                log.info(f"[demo_voice] generated with {vname} ({vid[:8]}...)")
+                return result
+            log.debug(f"[demo_voice] {vname} failed with key ...{key[-6:]}, trying next")
+
+    log.warning("[demo_voice] all keys/voices exhausted")
+    return None
+
+
+async def _try_generate(text: str, api_key: str, voice_id: str) -> Optional[str]:
+    """Single attempt to generate audio."""
+    try:
+        async with httpx.AsyncClient(timeout=20.0) as client:
+            r = await client.post(
+                f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}",
+                headers={
+                    "xi-api-key": api_key,
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "text": text,
+                    "model_id": "eleven_flash_v2_5",
+                    "voice_settings": {
+                        "stability": 0.35,          # Lower = more natural variation
+                        "similarity_boost": 0.70,
+                        "style": 0.25,              # Subtle expressiveness
+                        "use_speaker_boost": True,
+                    },
+                },
+            )
+            if r.status_code == 200 and len(r.content) > 1000:
+                tmp = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False)
+                tmp.write(r.content)
+                tmp.close()
+                return tmp.name
+            elif r.status_code == 401:
+                log.debug(f"[demo_voice] key unauthorized")
+                return None
+            elif r.status_code == 429:
+                log.debug(f"[demo_voice] rate limited")
+                return None
+            else:
+                log.debug(f"[demo_voice] HTTP {r.status_code}: {r.text[:100]}")
+                return None
+    except Exception as e:
+        log.debug(f"[demo_voice] error: {e}")
+        return None
+
+
+def should_send_voice_in_demo(text: str, turn_number: int, has_business_name: bool) -> bool:
+    """Decide when to send voice in demo — strategic moments only."""
+    # First greeting: ALWAYS voice (immediate wow)
+    if turn_number <= 1:
+        return True
+
+    # After getting business name and entering character
+    if has_business_name and turn_number <= 4:
+        return True
+
+    # Patient simulation responses (showing the product)
+    if turn_number >= 3 and len(text) < 150:
+        return True
+
+    # Never spam voice — max every 3 turns
+    if turn_number > 5 and turn_number % 3 != 0:
+        return False
+
+    return False
+
+
+# Conversion hooks for demo closing
+DEMO_CLOSING_TRIGGERS = [
+    "como activo", "cómo activo", "como lo contrato", "cómo contrato",
+    "cuanto cuesta", "cuánto cuesta", "precio", "planes",
+    "me interesa", "lo quiero", "activar", "contratar",
+]
+
+
+def detect_buying_intent(text: str) -> bool:
+    """Detect if prospect wants to buy."""
+    return any(t in text.lower() for t in DEMO_CLOSING_TRIGGERS)
+
+
+def get_closing_response() -> str:
+    """When prospect wants to buy, close with Santiago's contact."""
+    return (
+        "me alegra que te haya gustado la demo! |||"
+        " para activarlo en tu negocio, Santiago te explica todo: 3124348669 |||"
+        " la activación es rápida, en menos de 5 minutos ya estoy respondiendo tu WhatsApp"
+    )

package/conny_design.py

@@ -0,0 +1,43 @@
+"""conny_design.py — Single source of truth for all visual elements."""
+from __future__ import annotations
+
+COLORS = {
+    "primary": "#b48ead",      # Lavender/Purple
+    "secondary": "#81a1c1",    # Soft Blue
+    "success": "#a3be8c",      # Sage Green
+    "warning": "#ebcb8b",      # Muted Yellow
+    "error": "#bf616a",        # Soft Red
+    "dim": "#4c566a",          # Slate Grey
+    "text": "#d8dee9",         # Snow Storm White
+    "accent": "#88c0d0",       # Frost Cyan
+}
+
+LOGO_FULL = """\
+[#b48ead] ██████╗  ██████╗ ███╗   ██╗███╗   ██╗██╗   ██╗[/#b48ead]
+[#a690b8]██╔════╝ ██╔═══██╗████╗  ██║████╗  ██║╚██╗ ██╔╝[/#a690b8]
+[#9992c3]██║      ██║   ██║██╔██╗ ██║██╔██╗ ██║ ╚████╔╝ [/#9992c3]
+[#8b93ce]██║      ██║   ██║██║╚██╗██║██║╚██╗██║  ╚██╔╝  [/#8b93ce]
+[#7d95d8]╚██████╗ ╚██████╔╝██║ ╚████║██║ ╚████║   ██║   [/#7d95d8]
+[#6f97e3] ╚═════╝  ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═══╝   ╚═╝   [/#6f97e3]"""
+
+WORM_RESTING = """\
+[#b48ead]◆[/#b48ead][#4c566a]█▓▒░[/#4c566a]╮
+       ╰─╯"""
+
+WORM_INLINE = "[#b48ead]◆[/#b48ead][dim]▓▒░[/dim]"
+
+SEP = "[dim]─────────────────────────────────────────────────────[/dim]"
+
+# Status icons - using standard circles and marks for universal compatibility
+ICON_ONLINE = "[#a3be8c]●[/#a3be8c]"
+ICON_OFFLINE = "[#bf616a]○[/#bf616a]"
+ICON_WARN = "[#ebcb8b]![/#ebcb8b]"
+ICON_OK = "[#a3be8c]✓[/#a3be8c]"
+ICON_ERR = "[#bf616a]✕[/#bf616a]"
+ICON_BRAND = "[#b48ead]✦[/#b48ead]"
+
+# Category icons - professional and clean
+ICON_CORE = "■"
+ICON_BOT = "⬢"
+ICON_INT = "▲"
+ICON_OPS = "◆"