alive-ai 0.1.0

package/brain/llm/unified.py

@@ -0,0 +1,423 @@
+"""
+Brain: LLM - Unified LLM Interface with Fallback Chain
+Manages multiple LLM providers with automatic fallback when one fails.
+"""
+
+import asyncio
+import time
+from typing import Optional, List, Dict, Any, Tuple
+from dataclasses import dataclass, field
+from enum import Enum
+
+from .base import BaseLLM
+from .zai import ZAIClient
+from .openrouter import OpenRouterClient
+from .ollama import OllamaClient
+
+
+class ProviderStatus(Enum):
+    """Status of an LLM provider"""
+    UNKNOWN = "unknown"
+    AVAILABLE = "available"
+    UNAVAILABLE = "unavailable"
+    RATE_LIMITED = "rate_limited"
+    ERROR = "error"
+
+
+@dataclass
+class ProviderInfo:
+    """Information about a provider in the fallback chain"""
+    name: str
+    client: BaseLLM
+    status: ProviderStatus = ProviderStatus.UNKNOWN
+    last_success: float = 0
+    last_failure: float = 0
+    consecutive_failures: int = 0
+    total_requests: int = 0
+    successful_requests: int = 0
+
+
+class UnifiedLLM(BaseLLM):
+    """
+    Unified LLM interface with automatic fallback chain.
+
+    Tries providers in order until one succeeds:
+    1. ZAI (primary)
+    2. OpenRouter (fallback)
+    3. Ollama (local fallback)
+
+    Features:
+    - Automatic failover on errors or empty responses
+    - Provider health tracking
+    - Configurable timeouts and retries
+    - Detailed logging
+    - Compatible with BaseLLM interface
+    """
+
+    # Default configuration
+    DEFAULT_CONFIG = {
+        "enabled": True,
+        "order": ["zai", "openrouter"],
+        "timeout_seconds": 60,
+        "retry_on_empty": True,
+        "max_consecutive_failures": 3,
+        "backoff_seconds": 30,
+        "ollama_url": "http://172.17.0.1:11434",
+        "ollama_model": "phi4:latest",
+    }
+
+    def __init__(self, config: dict = None, settings_getter=None):
+        """
+        Initialize the unified LLM with fallback chain.
+
+        Args:
+            config: Configuration dictionary (merged with defaults)
+            settings_getter: Function to get settings from settings.json
+        """
+        # BaseLLM requires api_key and model - use placeholder values
+        super().__init__("unified", "fallback-chain")
+        self.config = {**self.DEFAULT_CONFIG, **(config or {})}
+        self._settings_getter = settings_getter
+        self._providers: Dict[str, ProviderInfo] = {}
+        self._active_provider: Optional[str] = None
+        self._initialized = False
+
+        # Import os for env vars
+        import os
+        self._os = os
+
+    def _get_setting(self, key: str, default: Any = None) -> Any:
+        """Get a setting from config or settings.json"""
+        # Try config first
+        if key in self.config:
+            return self.config[key]
+
+        # Try settings getter
+        if self._settings_getter:
+            value = self._settings_getter(key)
+            if value is not None:
+                return value
+
+        # Try LLM_FALLBACK nested config
+        if self._settings_getter:
+            all_settings = self._settings_getter("LLM_FALLBACK") or {}
+            if key.upper() in all_settings:
+                return all_settings[key.upper()]
+
+        return default
+
+    def _initialize_providers(self):
+        """Initialize all configured providers"""
+        if self._initialized:
+            return
+
+        order = self._get_setting("order", self.config["order"])
+
+        for provider_name in order:
+            client = self._create_provider(provider_name)
+            if client:
+                self._providers[provider_name] = ProviderInfo(
+                    name=provider_name,
+                    client=client
+                )
+                print(f"[UnifiedLLM] Initialized provider: {provider_name}")
+
+        self._initialized = True
+
+    def _create_provider(self, name: str) -> Optional[BaseLLM]:
+        """Create a provider client by name"""
+        name = name.lower()
+
+        if name == "zai":
+            api_key = self._get_setting("ZAI_API_KEY") or self._os.environ.get("ZAI_API_KEY", "")
+            model = self._get_setting("ZAI_MODEL_MAIN") or self._os.environ.get("ZAI_MODEL_MAIN", "glm-4.6v")
+            if api_key:
+                return ZAIClient(api_key, model)
+
+        elif name == "openrouter":
+            api_key = self._get_setting("OPENROUTER_API_KEY") or self._os.environ.get("OPENROUTER_API_KEY", "")
+            model = self._get_setting("OPENROUTER_MODEL_MAIN") or self._os.environ.get("OPENROUTER_MODEL_MAIN", "anthropic/claude-3.5-sonnet")
+            if api_key:
+                return OpenRouterClient(api_key, model)
+
+        elif name == "ollama":
+            url = self._get_setting("OLLAMA_URL") or self._get_setting("ollama_url", "http://172.17.0.1:11434")
+            model = self._get_setting("OLLAMA_MODEL") or self._get_setting("ollama_model", "phi4:latest")
+            # Ollama doesn't require an API key
+            return OllamaClient("", model, url)
+
+        return None
+
+    async def _check_provider_available(self, name: str) -> bool:
+        """Check if a provider is available for use"""
+        if name not in self._providers:
+            return False
+
+        info = self._providers[name]
+
+        # Check if we're in backoff due to consecutive failures
+        max_failures = self._get_setting("max_consecutive_failures", 3)
+        backoff = self._get_setting("backoff_seconds", 30)
+
+        if info.consecutive_failures >= max_failures:
+            if time.time() - info.last_failure < backoff:
+                print(f"[UnifiedLLM] Provider {name} in backoff ({info.consecutive_failures} failures)")
+                return False
+            else:
+                # Reset after backoff period
+                info.consecutive_failures = 0
+
+        # Check actual availability if provider supports it
+        client = info.client
+        if hasattr(client, 'is_available'):
+            try:
+                available = await client.is_available()
+                info.status = ProviderStatus.AVAILABLE if available else ProviderStatus.UNAVAILABLE
+                return available
+            except Exception as e:
+                print(f"[UnifiedLLM] Error checking {name} availability: {e}")
+                info.status = ProviderStatus.ERROR
+                return False
+
+        # Assume available if we can't check
+        return True
+
+    async def chat(
+        self,
+        messages: List[Dict[str, str]],
+        max_tokens: int = 500,
+        temperature: float = None
+    ) -> Optional[str]:
+        """
+        Send a chat request through the fallback chain.
+
+        This method is compatible with BaseLLM interface - returns just the response string.
+
+        Args:
+            messages: List of message dictionaries with 'role' and 'content'
+            max_tokens: Maximum tokens to generate
+            temperature: Sampling temperature (None = use default)
+
+        Returns:
+            Response text string, or None if all providers fail
+        """
+        response, _ = await self.chat_with_provider(messages, max_tokens, temperature)
+        return response
+
+    async def chat_with_provider(
+        self,
+        messages: List[Dict[str, str]],
+        max_tokens: int = 500,
+        temperature: float = None,
+        provider_hint: str = None
+    ) -> Tuple[Optional[str], str]:
+        """
+        Send a chat request through the fallback chain, returning provider info.
+
+        Args:
+            messages: List of message dictionaries with 'role' and 'content'
+            max_tokens: Maximum tokens to generate
+            temperature: Sampling temperature (None = use default)
+            provider_hint: Optional hint for which provider to try first
+
+        Returns:
+            Tuple of (response_text, provider_name_used)
+            Returns (None, "") if all providers fail
+        """
+        if not self._get_setting("enabled", True):
+            # Fallback mode disabled, use only first provider
+            return await self._try_single_provider(
+                list(self._providers.keys())[0] if self._providers else None,
+                messages, max_tokens, temperature
+            )
+
+        self._initialize_providers()
+
+        if not self._providers:
+            print("[UnifiedLLM] No providers configured!")
+            return None, ""
+
+        # Determine order to try providers
+        order = list(self._providers.keys())
+
+        # If we have an active provider that recently succeeded, try it first
+        if self._active_provider and self._active_provider in order:
+            order.remove(self._active_provider)
+            order.insert(0, self._active_provider)
+
+        # Apply provider hint
+        if provider_hint and provider_hint in order:
+            order.remove(provider_hint)
+            order.insert(0, provider_hint)
+
+        # Try each provider in order
+        last_error = None
+        for provider_name in order:
+            # Check if provider is available
+            if not await self._check_provider_available(provider_name):
+                continue
+
+            try:
+                response = await self._try_single_provider(
+                    provider_name, messages, max_tokens, temperature
+                )
+
+                if response:
+                    return response, provider_name
+            except Exception as e:
+                last_error = e
+                print(f"[UnifiedLLM] Provider {provider_name} failed: {e}")
+
+        # All providers failed
+        print(f"[UnifiedLLM] All providers failed. Last error: {last_error}")
+        return None, ""
+
+    async def _try_single_provider(
+        self,
+        provider_name: str,
+        messages: List[Dict[str, str]],
+        max_tokens: int,
+        temperature: float
+    ) -> Optional[str]:
+        """Try to get a response from a single provider"""
+        if not provider_name or provider_name not in self._providers:
+            return None
+
+        info = self._providers[provider_name]
+        client = info.client
+        timeout = self._get_setting("timeout_seconds", 60)
+        retry_on_empty = self._get_setting("retry_on_empty", True)
+
+        info.total_requests += 1
+
+        try:
+            # Add timeout wrapper
+            response = await asyncio.wait_for(
+                client.chat(messages, max_tokens=max_tokens, temperature=temperature),
+                timeout=timeout
+            )
+
+            # Check for empty response
+            if not response or not response.strip():
+                if retry_on_empty:
+                    print(f"[UnifiedLLM] Empty response from {provider_name}, retrying...")
+                    # One retry with different temperature
+                    response = await asyncio.wait_for(
+                        client.chat(messages, max_tokens=max_tokens, temperature=0.7),
+                        timeout=timeout
+                    )
+
+            if response and response.strip():
+                # Success!
+                info.last_success = time.time()
+                info.consecutive_failures = 0
+                info.successful_requests += 1
+                info.status = ProviderStatus.AVAILABLE
+                self._active_provider = provider_name
+                return response
+
+            # Empty response after retry
+            info.last_failure = time.time()
+            info.consecutive_failures += 1
+            return None
+
+        except asyncio.TimeoutError:
+            print(f"[UnifiedLLM] Timeout from {provider_name} after {timeout}s")
+            info.last_failure = time.time()
+            info.consecutive_failures += 1
+            info.status = ProviderStatus.ERROR
+            return None
+
+        except Exception as e:
+            print(f"[UnifiedLLM] Error from {provider_name}: {e}")
+            info.last_failure = time.time()
+            info.consecutive_failures += 1
+            info.status = ProviderStatus.ERROR
+            return None
+
+    def get_active_provider(self) -> Optional[str]:
+        """Get the name of the currently active provider"""
+        return self._active_provider
+
+    def get_provider_status(self) -> Dict[str, dict]:
+        """Get status of all providers"""
+        return {
+            name: {
+                "status": info.status.value,
+                "last_success": info.last_success,
+                "last_failure": info.last_failure,
+                "consecutive_failures": info.consecutive_failures,
+                "total_requests": info.total_requests,
+                "successful_requests": info.successful_requests,
+                "success_rate": info.successful_requests / max(1, info.total_requests)
+            }
+            for name, info in self._providers.items()
+        }
+
+    def reset_provider(self, name: str):
+        """Reset a provider's failure count"""
+        if name in self._providers:
+            self._providers[name].consecutive_failures = 0
+            self._providers[name].status = ProviderStatus.UNKNOWN
+            print(f"[UnifiedLLM] Reset provider: {name}")
+
+    def set_provider_config(self, name: str, **kwargs):
+        """Update configuration for a provider"""
+        if name in self._providers:
+            client = self._providers[name].client
+            for key, value in kwargs.items():
+                if hasattr(client, key):
+                    setattr(client, key, value)
+                    print(f"[UnifiedLLM] Updated {name}.{key} = {value}")
+
+    async def close(self):
+        """Close all provider sessions"""
+        for name, info in self._providers.items():
+            try:
+                if hasattr(info.client, 'close'):
+                    await info.client.close()
+            except Exception as e:
+                print(f"[UnifiedLLM] Error closing {name}: {e}")
+
+    def __repr__(self):
+        providers = list(self._providers.keys())
+        active = self._active_provider or "none"
+        return f"<UnifiedLLM providers={providers} active={active}>"
+
+
+# Singleton instance
+_unified_llm: Optional[UnifiedLLM] = None
+
+
+def get_unified_llm(config: dict = None, settings_getter=None) -> UnifiedLLM:
+    """
+    Get the global UnifiedLLM instance.
+
+    Args:
+        config: Configuration (only used on first call)
+        settings_getter: Function to get settings from settings.json
+
+    Returns:
+        The UnifiedLLM singleton
+    """
+    global _unified_llm
+
+    if _unified_llm is None:
+        # Get settings getter if not provided
+        if settings_getter is None:
+            try:
+                from core.settings import get as settings_get
+                settings_getter = settings_get
+            except ImportError:
+                pass
+
+        _unified_llm = UnifiedLLM(config, settings_getter)
+        _unified_llm._initialize_providers()
+
+    return _unified_llm
+
+
+def reset_unified_llm():
+    """Reset the singleton (for testing)"""
+    global _unified_llm
+    _unified_llm = None

package/brain/llm/zai.py

@@ -0,0 +1,169 @@
+"""
+Brain: LLM - ZAI API Client
+Uses OpenAI-compatible endpoint for ZAI Coding Plan
+"""
+
+import aiohttp
+import asyncio
+import time
+from typing import Optional, List, Dict
+from .base import BaseLLM
+
+
+class ZAIClient(BaseLLM):
+    """ZAI API client (OpenAI-compatible)"""
+
+    # ZAI Coding Plan uses OpenAI-compatible endpoint
+    BASE_URL = "https://api.z.ai/api/coding/paas/v4"
+
+    def __init__(self, api_key: str, model: str = "glm-4.6v"):
+        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 ZAI 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()
+
+            # Simple models list check to verify API is working
+            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("[ZAI] Invalid API key")
+                    self._available = False
+                    self._last_check = time.time()
+                    return False
+        except Exception as e:
+            print(f"[ZAI] 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 (OpenAI format)"""
+        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()
+
+        # OpenAI API format with Bearer token
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "frequency_penalty": 0.8,
+            "presence_penalty": 0.6,
+            "thinking": {
+                "type": "disabled"
+            },
+        }
+
+        # Try up to 2 times
+        for attempt in range(2):
+            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"[ZAI] Error {resp.status}: {error[:300]}")
+                        self._available = False
+                        return None
+
+                    data = await resp.json()
+                    # Check for error response
+                    if "error" in data:
+                        print(f"[ZAI] 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', '?')}")
+                    # OpenAI response format
+                    if "choices" not in data or not data["choices"]:
+                        print(f"[ZAI] No choices in response: {list(data.keys())}")
+                        return None
+
+                    message = data["choices"][0].get("message", {})
+                    content = message.get("content", "")
+
+                    # Log if reasoning_content present (thinking mode leak)
+                    if message.get("reasoning_content"):
+                        print(f"[ZAI] Note: reasoning_content present but ignored (internal thinking)")
+
+                    # If still empty, retry with intimate instruction
+                    if not content or not content.strip():
+                        if attempt == 0:
+                            print(f"[ZAI] Empty content on first attempt, retrying with intimate instruction...")
+                            # Add intimate instruction to output dialogue
+                            retry_messages = messages.copy()
+                            retry_messages.append({
+                                "role": "system",
+                                "content": "IMPORTANT: You must respond with actual dialogue that can be spoken. Do not just think - say something out loud."
+                            })
+                            payload["messages"] = retry_messages
+                            continue
+                        else:
+                            print(f"[ZAI] Empty content after retry")
+                            return None
+
+                    print(f"[ZAI] Response: {content[:80]}...")
+                    # Mark as available since we got a response
+                    self._available = True
+                    self._last_check = time.time()
+                    return content
+
+            except asyncio.TimeoutError:
+                print(f"[ZAI] Timeout (60s)")
+                return None
+            except Exception as e:
+                print(f"[ZAI] Exception: {e}")
+                if attempt == 1:
+                    return None
+
+        return None
+
+    async def close(self):
+        if self.session and not self.session.closed:
+            await self.session.close()

package/brain/manifest.md

@@ -0,0 +1,23 @@
+# Brain - Intelligence Center
+
+Multi-provider LLM, memory systems, and subconscious processing.
+
+## Modules
+- `memory/` - Token-efficient memory with vector search
+  - `vector_store.py` - Redis-based semantic memory
+  - `episodic.py` - Conversation memory
+  - `working.py` - Working memory (RAM)
+- `llm/` - Multi-provider LLM support (see llm/manifest.md)
+- `subconscious/` - 24/7 living brain (see subconscious/manifest.md)
+- `embeddings/` - Sentence transformers for semantic search
+- `stt/` - Speech-to-text (Google, Whisper)
+
+## Key Files
+- `__init__.py` - Main Memory class
+- `index.py` - Fast memory index
+
+## Features
+- Multi-provider: ZAI or OpenRouter
+- Semantic search via embeddings (all-MiniLM-L6-v2)
+- Redis vector storage with archiving
+- Subconscious impulse generation