alive-ai 0.1.0

package/brain/llm/openrouter.py

@@ -0,0 +1,151 @@
+"""
+Brain: LLM - OpenRouter API Client
+OpenRouter provides unified access to many LLM providers
+"""
+
+import aiohttp
+import asyncio
+import time
+from typing import Optional, List, Dict
+from .base import BaseLLM
+
+
+class OpenRouterClient(BaseLLM):
+    """OpenRouter API client - unified access to many models"""
+
+    BASE_URL = "https://openrouter.ai/api/v1"
+
+    # Site URL for rankings (required by OpenRouter)
+    SITE_URL = "https://alive_ai.ai"
+    SITE_NAME = "Alive-AI Girlfriend"
+
+    def __init__(self, api_key: str, model: str = "anthropic/claude-3.5-sonnet"):
+        super().__init__(api_key, model)
+        self.session: Optional[aiohttp.ClientSession] = None
+        self._available: Optional[bool] = None
+        self._last_check: float = 0
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        if self.session is None or self.session.closed:
+            self.session = aiohttp.ClientSession()
+        return self.session
+
+    async def is_available(self) -> bool:
+        """Check if OpenRouter API is accessible and configured"""
+        # Cache availability for 60 seconds
+        if self._available is not None and time.time() - self._last_check < 60:
+            return self._available
+
+        if not self.api_key:
+            self._available = False
+            self._last_check = time.time()
+            return False
+
+        try:
+            session = await self._get_session()
+
+            # Check API key validity by listing models
+            async with session.get(
+                f"{self.BASE_URL}/models",
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                },
+                timeout=aiohttp.ClientTimeout(total=10)
+            ) as resp:
+                if resp.status == 200:
+                    self._available = True
+                    self._last_check = time.time()
+                    return True
+                elif resp.status == 401:
+                    print("[OpenRouter] Invalid API key")
+                    self._available = False
+                    self._last_check = time.time()
+                    return False
+        except Exception as e:
+            print(f"[OpenRouter] Availability check failed: {e}")
+
+        self._available = False
+        self._last_check = time.time()
+        return False
+
+    async def chat(
+        self,
+        messages: List[Dict[str, str]],
+        max_tokens: int = 500,
+        temperature: float = None
+    ) -> Optional[str]:
+        """Send chat completion request via OpenRouter"""
+        import os
+        # Use passed temperature, or environment variable, or default high value
+        if temperature is None:
+            temperature = float(os.environ.get("LLM_TEMPERATURE", "0.95"))
+
+        session = await self._get_session()
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": self.SITE_URL,
+            "X-Title": self.SITE_NAME
+        }
+
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "frequency_penalty": 0.8,  # Penalize repeated phrases - increased from 0.5
+            "presence_penalty": 0.6,   # Encourage topic diversity - increased from 0.3
+        }
+
+        try:
+            async with session.post(
+                f"{self.BASE_URL}/chat/completions",
+                headers=headers,
+                json=payload,
+                timeout=aiohttp.ClientTimeout(total=60)
+            ) as resp:
+                if resp.status != 200:
+                    error = await resp.text()
+                    print(f"[OpenRouter] Error {resp.status}: {error[:300]}")
+                    self._available = False
+                    return None
+
+                data = await resp.json()
+                # Check for error response
+                if "error" in data:
+                    print(f"[OpenRouter] API Error: {data['error']}")
+                    self._available = False
+                    return None
+                # Log token usage
+                if "usage" in data:
+                    usage = data["usage"]
+                    print(f"[LLM] Tokens - Input: {usage.get('prompt_tokens', '?')} | Output: {usage.get('completion_tokens', '?')} | Total: {usage.get('total_tokens', '?')}")
+                if "choices" not in data or not data["choices"]:
+                    print(f"[OpenRouter] No choices in response: {list(data.keys())}")
+                    return None
+
+                content = data["choices"][0]["message"]["content"]
+
+                if not content or not content.strip():
+                    print(f"[OpenRouter] Empty content!")
+                    return None
+
+                print(f"[OpenRouter] Response: {content[:100]}...")
+
+                # Mark as available since we got a response
+                self._available = True
+                self._last_check = time.time()
+                return content
+
+        except asyncio.TimeoutError:
+            print(f"[OpenRouter] Timeout (60s)")
+            return None
+        except Exception as e:
+            print(f"[OpenRouter] Exception: {e}")
+            return None
+
+    async def close(self):
+        """Close the client session"""
+        if self.session and not self.session.closed:
+            await self.session.close()

package/brain/llm/provider.py

@@ -0,0 +1,205 @@
+"""
+Brain: LLM - Provider Factory
+Creates the appropriate LLM client based on configuration.
+Supports both legacy single-provider mode and new unified fallback mode.
+"""
+
+import os
+from typing import Optional, Tuple
+from .base import BaseLLM
+from .zai import ZAIClient
+from .openrouter import OpenRouterClient
+from .ollama import OllamaClient
+from .unified import UnifiedLLM, get_unified_llm
+from .fallback_router import FallbackRouter, get_fallback_router
+
+
+def get_provider_config(task: str = "main") -> Tuple[str, str, str]:
+    """Get provider and model for a specific task
+
+    Tasks:
+    - main: Main conversation model
+    - thinking: Deep reasoning, complex decisions
+    - fast: Quick responses, impulses, subconscious
+
+    Returns:
+        Tuple of (provider_name, api_key, model_name)
+    """
+    # Try to get from settings.json first
+    try:
+        from core.settings import get as settings_get
+
+        # Check if fallback mode is enabled
+        llm_fallback = settings_get("LLM_FALLBACK", {})
+        if llm_fallback.get("ENABLED", False):
+            # Use unified mode - get config from settings
+            provider = "unified"
+            api_key = ""  # Not used in unified mode
+            model = ""    # Not used in unified mode
+            return provider, api_key, model
+
+        # Legacy mode - use settings.json
+        provider = settings_get("LLM_PROVIDER", "zai").lower()
+
+        if provider == "openrouter":
+            api_key = settings_get("OPENROUTER_API_KEY", "") or os.environ.get("OPENROUTER_API_KEY", "")
+            if task == "fast":
+                model = settings_get("OPENROUTER_MODEL_FAST", "openai/gpt-4o-mini")
+            elif task == "thinking":
+                model = settings_get("OPENROUTER_MODEL_THINKING", "anthropic/claude-3.5-sonnet")
+            else:
+                model = settings_get("OPENROUTER_MODEL_MAIN", "anthropic/claude-3.5-sonnet")
+        else:
+            # Default to ZAI
+            api_key = settings_get("ZAI_API_KEY", "") or os.environ.get("ZAI_API_KEY", "")
+            if task == "fast":
+                model = settings_get("ZAI_MODEL_FAST", "glm-4-flash")
+            elif task == "thinking":
+                model = settings_get("ZAI_MODEL_THINKING", "glm-4.6v")
+            else:
+                model = settings_get("ZAI_MODEL_MAIN", "glm-4.6v")
+
+        return provider, api_key, model
+
+    except ImportError:
+        # Fallback to environment variables
+        pass
+
+    # Environment variable fallback
+    provider = os.environ.get("LLM_PROVIDER", "zai").lower()
+
+    if provider == "openrouter":
+        api_key = os.environ.get("OPENROUTER_API_KEY", "")
+        if task == "fast":
+            model = os.environ.get("OPENROUTER_MODEL_FAST", "openai/gpt-4o-mini")
+        elif task == "thinking":
+            model = os.environ.get("OPENROUTER_MODEL_THINKING", "anthropic/claude-3.5-sonnet")
+        else:
+            model = os.environ.get("OPENROUTER_MODEL_MAIN", "anthropic/claude-3.5-sonnet")
+    else:
+        # Default to ZAI
+        api_key = os.environ.get("ZAI_API_KEY", "")
+        if task == "fast":
+            model = os.environ.get("ZAI_MODEL_FAST", "glm-4-flash")
+        elif task == "thinking":
+            model = os.environ.get("ZAI_MODEL_THINKING", "glm-4.6v")
+        else:
+            model = os.environ.get("ZAI_MODEL_MAIN", "glm-4.6v")
+
+    return provider, api_key, model
+
+
+def get_llm_client(task: str = "main") -> Optional[BaseLLM]:
+    """Get LLM client for a specific task
+
+    Usage:
+        # Main conversation
+        llm = get_llm_client("main")
+
+        # Quick impulse generation
+        fast_llm = get_llm_client("fast")
+
+        # Deep thinking
+        think_llm = get_llm_client("thinking")
+    """
+    provider, api_key, model = get_provider_config(task)
+
+    # Handle unified mode
+    if provider == "unified":
+        return get_unified_llm_client()
+
+    if not api_key:
+        print(f"[LLM] No API key for provider: {provider}")
+        return None
+
+    if provider == "openrouter":
+        return OpenRouterClient(api_key, model)
+    else:
+        return ZAIClient(api_key, model)
+
+
+def get_fast_llm() -> Optional[BaseLLM]:
+    """Get fast LLM for quick tasks (impulses, subconscious)"""
+    return get_llm_client("fast")
+
+
+def get_thinking_llm() -> Optional[BaseLLM]:
+    """Get thinking LLM for complex reasoning"""
+    return get_llm_client("thinking")
+
+
+def get_main_llm() -> Optional[BaseLLM]:
+    """Get main LLM for conversations"""
+    return get_llm_client("main")
+
+
+# ============================================================
+# Unified LLM Support
+# ============================================================
+
+# Cache for the unified client
+_unified_client: Optional[UnifiedLLM] = None
+
+
+def get_unified_llm_client() -> Optional[UnifiedLLM]:
+    """
+    Get the unified LLM client with fallback chain.
+
+    This is the recommended way to get an LLM client as it:
+    - Tries ZAI first
+    - Falls back to OpenRouter if ZAI fails
+    - Falls back to local Ollama if both fail
+    - Handles empty responses and errors gracefully
+
+    Returns:
+        UnifiedLLM instance or None if not configured
+    """
+    global _unified_client
+
+    if _unified_client is not None:
+        return _unified_client
+
+    try:
+        from core.settings import get as settings_get
+
+        # Get fallback configuration
+        llm_config = settings_get("LLM_FALLBACK", {})
+        if not llm_config.get("ENABLED", False):
+            print("[LLM] Fallback not enabled, using single provider")
+            return None
+
+        _unified_client = get_unified_llm(settings_getter=settings_get)
+        print(f"[LLM] Unified LLM initialized with fallback chain")
+        return _unified_client
+
+    except ImportError:
+        print("[LLM] Settings not available for unified LLM")
+        return None
+    except Exception as e:
+        print(f"[LLM] Error creating unified LLM: {e}")
+        return None
+
+
+def get_fallback_llm_client() -> Optional[FallbackRouter]:
+    """
+    Get the fallback router for LLM requests.
+
+    This provides a simpler interface than UnifiedLLM with:
+    - Direct provider list
+    - Simple logging
+    - No state management
+
+    Returns:
+        FallbackRouter instance or None if not configured
+    """
+    try:
+        return get_fallback_router()
+    except Exception as e:
+        print(f"[LLM] Error creating fallback router: {e}")
+        return None
+
+
+def reset_unified_client():
+    """Reset the unified client cache (for testing or reconfiguration)"""
+    global _unified_client
+    _unified_client = None