@innvisor/conny-ai 9.7.0

package/conny_generator.py

@@ -0,0 +1,447 @@
+"""
+Módulo de generación LLM para Conny Ultra.
+
+Contiene la lógica de generación de respuestas:
+- _llm(): Generación básica
+- _llm_conv_pitch(): Generación con pitch para prospectos confuse
+- _llm_conv(): Generación conversacional con historial
+- _demo_llm_conv_quality_chain(): Chain con validación y repair
+- _demo_llm_quality_chain(): Chain de calidad con retries
+
+Este módulo fue extraído de conny.py para reducir su tamaño y mejorar mantenibilidad.
+"""
+from __future__ import annotations
+
+import time
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+try:
+    from conny_config import Config
+except ImportError:
+    class Config:
+        GROQ_API_KEY = ""
+        GEMINI_API_KEY = ""
+        GEMINI_API_KEY_2 = ""
+        GEMINI_API_KEY_3 = ""
+        OPENROUTER_API_KEY = ""
+
+
+class GeneratorManager:
+    """
+    Gestor de generación LLM para Conny Ultra.
+    
+    Proporciona métodos para:
+    - Generación básica de texto
+    - Generación conversacional con historial
+    - Generación con pitch especializado
+    - Chains de calidad con validación y retry
+    """
+    
+    def __init__(self, llm_engine=None, generator=None):
+        self._llm_engine = llm_engine
+        self._generator = generator
+    
+    def _get_demo_engine(self, demo_model_pref: str = "auto", bmodel_key: str = ""):
+        """
+        Devuelve el proveedor LLM según preferencia de sesión.
+        
+        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
+        """
+        from llm_engine import (
+            GeminiProvider, GroqProvider, OpenRouterProvider
+        )
+        
+        pref = demo_model_pref
+        
+        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:
+                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:
+                    eng.MDLS = {
+                        "reasoning": "gemini-2.5-flash", 
+                        "fast": "gemini-2.5-flash", 
+                        "lite": "gemini-2.5-flash-lite"
+                    }
+                return eng
+            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
+        
+        return self._llm_engine or (self._generator.llm if self._generator else None)
+    
+    async def _llm(
+        self,
+        sys_p: str,
+        usr_p: str,
+        temp: float = 0.82,
+        max_t: int = 8192,
+        model_tier: str = "fast",
+        demo_model_pref: str = "auto"
+    ) -> Optional[str]:
+        """
+        Generación básica de texto con LLM.
+        
+        Args:
+            sys_p: Prompt del sistema
+            usr_p: Prompt del usuario
+            temp: Temperatura de generación
+            max_t: Máximo de tokens de salida
+            model_tier: Tier del modelo (fast, reasoning, lite)
+            demo_model_pref: Preferencia de modelo demo
+            
+        Returns:
+            Texto generado o None en caso de error
+        """
+        import logging
+        log = logging.getLogger("conny_generator")
+        
+        msgs = [{"role": "system", "content": sys_p}, {"role": "user", "content": usr_p}]
+        
+        try:
+            eng = self._get_demo_engine(demo_model_pref)
+            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]}")
+            
+            if self._generator:
+                return self._generator._postprocess(r, self._generator.PersonalityProfile())
+            return r
+            
+        except Exception as e:
+            log.error(f"[demo] llm error: {e}")
+            return None
+    
+    async def _llm_conv_pitch(
+        self,
+        pitch_sys: str,
+        history: List[Dict[str, Any]],
+        text: str,
+        temp: float = 0.85,
+        max_t: int = 8192,
+        recent_limit: int = 12,
+        demo_model_pref: str = "auto"
+    ) -> Optional[str]:
+        """
+        LLM con el pitch de Black One para prospectos confundidos.
+        
+        Args:
+            pitch_sys: Prompt de sistema con el pitch
+            history: Historial de conversación
+            text: Mensaje actual
+            temp: Temperatura
+            max_t: Máximo de tokens
+            recent_limit: Límite de mensajes recientes a incluir
+            demo_model_pref: Preferencia de modelo
+            
+        Returns:
+            Texto generado o None
+        """
+        import logging
+        log = logging.getLogger("conny_generator")
+        
+        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 = self._get_demo_engine(demo_model_pref)
+            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','?')}")
+            
+            if self._generator:
+                return self._generator._postprocess(r, self._generator.PersonalityProfile())
+            return r
+            
+        except Exception as e:
+            log.error(f"[demo][pitch] error: {e}")
+            return None
+    
+    async def _llm_conv(
+        self,
+        sys_p: str,
+        history: List[Dict[str, Any]],
+        text: str,
+        temp: float = 0.85,
+        max_t: int = 8192,
+        model_tier: str = "fast",
+        recent_limit: int = 12,
+        demo_model_pref: str = "auto"
+    ) -> Optional[str]:
+        """
+        Generación conversacional con historial.
+        
+        Args:
+            sys_p: Prompt del sistema
+            history: Historial de conversación
+            text: Mensaje actual
+            temp: Temperatura
+            max_t: Máximo de tokens
+            model_tier: Tier del modelo
+            recent_limit: Límite de mensajes recientes
+            demo_model_pref: Preferencia de modelo
+            
+        Returns:
+            Texto generado o None
+        """
+        import logging
+        log = logging.getLogger("conny_generator")
+        
+        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 = self._get_demo_engine(demo_model_pref)
+            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]}")
+            
+            if self._generator:
+                return self._generator._postprocess(r, self._generator.PersonalityProfile())
+            return r
+            
+        except Exception as e:
+            log.error(f"[demo] llm_conv error: {e}")
+            return None
+    
+    async def _demo_llm_conv_quality_chain(
+        self,
+        system_prompt: str,
+        validator: Callable[[str], bool],
+        repair_instructions: str,
+        history: List[Dict[str, Any]],
+        text: str,
+        temp: float = 0.72,
+        max_t: int = 8192,
+        model_tier: str = "fast",
+        recent_limit: int = 8,
+        demo_model_pref: str = "auto"
+    ) -> Tuple[Optional[str], bool]:
+        """
+        Chain de calidad con validación y repair para conversaciones demo.
+        
+        Intenta primero la generación normal, si falla la validación
+        reintenta con instrucciones de repair.
+        
+        Args:
+            system_prompt: Prompt del sistema
+            validator: Función que valida la respuesta
+            repair_instructions: Instrucciones para repair si falla validación
+            history: Historial de conversación
+            text: Mensaje actual
+            temp: Temperatura
+            max_t: Máximo de tokens
+            model_tier: Tier del modelo
+            recent_limit: Límite de mensajes recientes
+            demo_model_pref: Preferencia de modelo
+            
+        Returns:
+            Tuple (respuesta_valida o None, tuvo_output)
+        """
+        import logging
+        log = logging.getLogger("conny_generator")
+        
+        _chain_start = time.time()
+        _CHAIN_TIMEOUT_S = 45  # Timeout entre intentos
+        
+        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
+        
+        for prompt_now, temp_now, max_now, tier_now, limit_now in attempts:
+            if time.time() - _chain_start > _CHAIN_TIMEOUT_S:
+                log.warning("[demo] conv_quality_chain abortada por timeout (%ds)", _CHAIN_TIMEOUT_S)
+                break
+            
+            candidate = await self._llm_conv(
+                prompt_now,
+                history=history,
+                text=text,
+                temp=temp_now,
+                max_t=max_now,
+                model_tier=tier_now,
+                recent_limit=limit_now,
+                demo_model_pref=demo_model_pref,
+            )
+            
+            if candidate and candidate.strip():
+                had_output = True
+                if validator(candidate):
+                    return candidate, True
+        
+        return None, had_output
+    
+    async def _demo_llm_quality_chain(
+        self,
+        system_prompt: str,
+        validator: Callable[[str], bool],
+        repair_instructions: str,
+        user_message: str,
+        temp: float = 0.72,
+        max_t: int = 8192,
+        model_tier: str = "fast",
+        demo_model_pref: str = "auto"
+    ) -> Tuple[Optional[str], bool]:
+        """
+        Chain de calidad simple (sin historial) para generación demo.
+        
+        Args:
+            system_prompt: Prompt del sistema
+            validator: Función que valida la respuesta
+            repair_instructions: Instrucciones para repair
+            user_message: Mensaje del usuario
+            temp: Temperatura
+            max_t: Máximo de tokens
+            model_tier: Tier del modelo
+            demo_model_pref: Preferencia de modelo
+            
+        Returns:
+            Tuple (respuesta o None, tuvo_output)
+        """
+        import logging
+        log = logging.getLogger("conny_generator")
+        
+        _chain_start = time.time()
+        _CHAIN_TIMEOUT_S = 45
+        
+        attempts = [
+            (system_prompt, temp, max_t, model_tier),
+            (
+                system_prompt
+                + "\n\nREPARA LA RESPUESTA:\n"
+                + repair_instructions.strip()
+                + "\n- no repitas introducciones\n- no suenes a bot",
+                0.58,
+                max_t,
+                "reasoning",
+            ),
+        ]
+        
+        had_output = False
+        
+        for prompt_now, temp_now, max_now, tier_now in attempts:
+            if time.time() - _chain_start > _CHAIN_TIMEOUT_S:
+                log.warning("[demo] quality_chain abortada por timeout")
+                break
+            
+            candidate = await self._llm(
+                prompt_now,
+                user_message,
+                temp=temp_now,
+                max_t=max_now,
+                model_tier=tier_now,
+                demo_model_pref=demo_model_pref,
+            )
+            
+            if candidate and candidate.strip():
+                had_output = True
+                if validator(candidate):
+                    return candidate, True
+        
+        return None, had_output
+
+
+def estimate_tokens(text: str) -> int:
+    """
+    Estima el número de tokens en un texto.
+    
+    Args:
+        text: Texto a estimar
+        
+    Returns:
+        Estimación de tokens (approx 4 chars por token)
+    """
+    return len(text) // 4
+
+
+def budget_tokens(
+    system_prompt: str,
+    max_t: int = 8192,
+    safety_margin: float = 0.9
+) -> Tuple[int, int]:
+    """
+    Calcula presupuesto de tokens para generación.
+    
+    Args:
+        system_prompt: Prompt del sistema
+        max_t: Máximo de tokens disponibles
+        safety_margin: Margen de seguridad (0.0-1.0)
+        
+    Returns:
+        Tuple (tokens_disponibles_output, tokens_reservados)
+    """
+    system_tokens = estimate_tokens(system_prompt)
+    available = int(max_t * safety_margin)
+    output_budget = max(available - system_tokens, 512)
+    return output_budget, system_tokens

package/conny_google_auth.py

@@ -0,0 +1,159 @@
+"""conny_google_auth.py — Google OAuth2 flow via WhatsApp chat.
+OpenClaw-inspired: credentials live in vault files, NOT in .env.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Dict, Optional
+from urllib.parse import urlencode
+
+import httpx
+
+log = logging.getLogger("conny.google_auth")
+
+SCOPES = [
+    "https://www.googleapis.com/auth/calendar",
+    "https://www.googleapis.com/auth/calendar.events",
+]
+
+VAULT_DIR = Path("integrations/vault")
+
+
+def _load_google_creds(instance_id: str = "default") -> Dict[str, str]:
+    """Load Google credentials from vault (OpenClaw pattern: vault > env)."""
+    # Priority 1: Vault file (uploaded by admin)
+    creds_file = VAULT_DIR / instance_id / "google_credentials.json"
+    if creds_file.exists():
+        try:
+            data = json.loads(creds_file.read_text())
+            inner = data.get("installed") or data.get("web") or data
+            return {
+                "client_id": inner.get("client_id", ""),
+                "client_secret": inner.get("client_secret", ""),
+                "redirect_uri": inner.get("redirect_uris", ["urn:ietf:wg:oauth:2.0:oob"])[0],
+            }
+        except Exception:
+            pass
+
+    # Priority 2: Environment variables (fallback)
+    return {
+        "client_id": os.getenv("GOOGLE_CLIENT_ID", ""),
+        "client_secret": os.getenv("GOOGLE_CLIENT_SECRET", ""),
+        "redirect_uri": os.getenv("GOOGLE_REDIRECT_URI", "urn:ietf:wg:oauth:2.0:oob"),
+    }
+
+
+def get_oauth_url(instance_id: str = "default") -> Optional[str]:
+    """Generate Google OAuth2 consent URL."""
+    creds = _load_google_creds(instance_id)
+    if not creds["client_id"]:
+        return None
+
+    params = {
+        "client_id": creds["client_id"],
+        "redirect_uri": creds["redirect_uri"],
+        "response_type": "code",
+        "scope": " ".join(SCOPES),
+        "access_type": "offline",
+        "prompt": "consent",
+        "state": instance_id,
+    }
+    return f"https://accounts.google.com/o/oauth2/v2/auth?{urlencode(params)}"
+
+
+async def exchange_code_for_tokens(code: str, instance_id: str = "default") -> Optional[Dict]:
+    """Exchange authorization code for access + refresh tokens."""
+    creds = _load_google_creds(instance_id)
+    if not creds["client_id"] or not creds["client_secret"]:
+        return None
+
+    async with httpx.AsyncClient(timeout=15.0) as client:
+        r = await client.post(
+            "https://oauth2.googleapis.com/token",
+            data={
+                "code": code.strip(),
+                "client_id": creds["client_id"],
+                "client_secret": creds["client_secret"],
+                "redirect_uri": creds["redirect_uri"],
+                "grant_type": "authorization_code",
+            },
+        )
+        if r.status_code == 200:
+            tokens = r.json()
+            tokens_dir = VAULT_DIR / instance_id
+            tokens_dir.mkdir(parents=True, exist_ok=True)
+            (tokens_dir / "google_tokens.json").write_text(json.dumps(tokens, indent=2))
+            log.info(f"[google_auth] tokens saved for {instance_id}")
+            return tokens
+        else:
+            log.error(f"[google_auth] exchange failed: {r.status_code} {r.text[:200]}")
+            return None
+
+
+async def refresh_access_token(instance_id: str = "default") -> Optional[str]:
+    """Refresh access token using stored refresh token."""
+    tokens_file = VAULT_DIR / instance_id / "google_tokens.json"
+    if not tokens_file.exists():
+        return None
+
+    tokens = json.loads(tokens_file.read_text())
+    refresh_token = tokens.get("refresh_token")
+    if not refresh_token:
+        return None
+
+    creds = _load_google_creds(instance_id)
+
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        r = await client.post(
+            "https://oauth2.googleapis.com/token",
+            data={
+                "client_id": creds["client_id"],
+                "client_secret": creds["client_secret"],
+                "refresh_token": refresh_token,
+                "grant_type": "refresh_token",
+            },
+        )
+        if r.status_code == 200:
+            new_tokens = r.json()
+            tokens["access_token"] = new_tokens["access_token"]
+            tokens["expires_in"] = new_tokens.get("expires_in", 3600)
+            tokens_file.write_text(json.dumps(tokens, indent=2))
+            return new_tokens["access_token"]
+        else:
+            log.error(f"[google_auth] refresh failed: {r.status_code}")
+            return None
+
+
+async def get_access_token(instance_id: str = "default") -> Optional[str]:
+    """Get a valid access token (refresh if needed)."""
+    tokens_file = VAULT_DIR / instance_id / "google_tokens.json"
+    if not tokens_file.exists():
+        return None
+    tokens = json.loads(tokens_file.read_text())
+    # Always refresh to ensure valid token
+    refreshed = await refresh_access_token(instance_id)
+    return refreshed or tokens.get("access_token")
+
+
+def has_credentials(instance_id: str = "default") -> bool:
+    """Check if instance has Google OAuth credentials configured."""
+    creds = _load_google_creds(instance_id)
+    return bool(creds["client_id"])
+
+
+def has_tokens(instance_id: str = "default") -> bool:
+    """Check if instance has completed OAuth (has tokens)."""
+    return (VAULT_DIR / instance_id / "google_tokens.json").exists()
+
+
+def is_oauth_code(text: str) -> bool:
+    """Detect if a message looks like a Google OAuth authorization code."""
+    t = text.strip()
+    if t.startswith("4/") and len(t) > 30:
+        return True
+    if len(t) >= 30 and len(t) <= 120 and "/" in t and " " not in t:
+        return True
+    return False