alive-ai 0.1.0

package/brain/llm/fallback_router.py

@@ -0,0 +1,309 @@
+"""
+Brain: LLM - Fallback Router
+Simple router that tries providers in order with logging and error handling.
+"""
+
+import asyncio
+import time
+from typing import Optional, List, Dict, Tuple, Callable
+from dataclasses import dataclass
+from enum import Enum
+
+from .base import BaseLLM
+from .zai import ZAIClient
+from .openrouter import OpenRouterClient
+from .ollama import OllamaClient
+
+
+class FallbackResult(Enum):
+    """Result of a fallback attempt"""
+    SUCCESS = "success"
+    EMPTY_RESPONSE = "empty_response"
+    TIMEOUT = "timeout"
+    ERROR = "error"
+    UNAVAILABLE = "unavailable"
+
+
+@dataclass
+class FallbackLog:
+    """Log entry for a fallback attempt"""
+    provider: str
+    result: FallbackResult
+    latency_ms: float
+    error: Optional[str] = None
+    response_preview: Optional[str] = None
+
+
+class FallbackRouter:
+    """
+    Simple fallback router for LLM providers.
+
+    Tries providers in configured order:
+    1. ZAI (primary)
+    2. OpenRouter (cloud fallback)
+    3. Ollama (local fallback)
+
+    Features:
+    - Automatic failover on errors or empty responses
+    - Configurable timeouts
+    - Detailed logging of all attempts
+    - Health tracking
+    """
+
+    def __init__(
+        self,
+        providers: List[Tuple[str, BaseLLM]],
+        timeout_seconds: float = 60,
+        retry_on_empty: bool = True
+    ):
+        """
+        Initialize the fallback router.
+
+        Args:
+            providers: List of (name, client) tuples in fallback order
+            timeout_seconds: Maximum time per provider
+            retry_on_empty: Whether to retry once on empty response
+        """
+        self.providers = providers
+        self.timeout_seconds = timeout_seconds
+        self.retry_on_empty = retry_on_empty
+        self._log: List[FallbackLog] = []
+        self._max_log_size = 100
+
+    def _log_attempt(self, entry: FallbackLog):
+        """Log an attempt"""
+        self._log.append(entry)
+        # Trim log if too large
+        if len(self._log) > self._max_log_size:
+            self._log = self._log[-self._max_log_size:]
+
+    async def chat(
+        self,
+        messages: List[Dict[str, str]],
+        max_tokens: int = 500,
+        temperature: float = None
+    ) -> Tuple[Optional[str], str]:
+        """
+        Try providers in order until one succeeds.
+
+        Args:
+            messages: Chat messages
+            max_tokens: Max tokens to generate
+            temperature: Sampling temperature
+
+        Returns:
+            Tuple of (response, provider_name) or (None, "") if all fail
+        """
+        for provider_name, client in self.providers:
+            response = await self._try_provider(
+                provider_name, client, messages, max_tokens, temperature
+            )
+
+            if response:
+                return response, provider_name
+
+        return None, ""
+
+    async def _try_provider(
+        self,
+        name: str,
+        client: BaseLLM,
+        messages: List[Dict[str, str]],
+        max_tokens: int,
+        temperature: float
+    ) -> Optional[str]:
+        """Try a single provider"""
+        start_time = time.time()
+
+        # Check availability if supported
+        if hasattr(client, 'is_available'):
+            try:
+                available = await asyncio.wait_for(
+                    client.is_available(),
+                    timeout=5
+                )
+                if not available:
+                    self._log_attempt(FallbackLog(
+                        provider=name,
+                        result=FallbackResult.UNAVAILABLE,
+                        latency_ms=(time.time() - start_time) * 1000,
+                        error="Provider not available"
+                    ))
+                    return None
+            except Exception as e:
+                self._log_attempt(FallbackLog(
+                    provider=name,
+                    result=FallbackResult.UNAVAILABLE,
+                    latency_ms=(time.time() - start_time) * 1000,
+                    error=f"Availability check failed: {e}"
+                ))
+                return None
+
+        # Try the chat request
+        try:
+            response = await asyncio.wait_for(
+                client.chat(messages, max_tokens=max_tokens, temperature=temperature),
+                timeout=self.timeout_seconds
+            )
+
+            latency_ms = (time.time() - start_time) * 1000
+
+            if not response or not response.strip():
+                # Empty response - retry once if configured
+                if self.retry_on_empty:
+                    print(f"[FallbackRouter] Empty response from {name}, retrying...")
+                    response = await asyncio.wait_for(
+                        client.chat(messages, max_tokens=max_tokens, temperature=0.7),
+                        timeout=self.timeout_seconds
+                    )
+
+                if not response or not response.strip():
+                    self._log_attempt(FallbackLog(
+                        provider=name,
+                        result=FallbackResult.EMPTY_RESPONSE,
+                        latency_ms=latency_ms
+                    ))
+                    return None
+
+            # Success!
+            self._log_attempt(FallbackLog(
+                provider=name,
+                result=FallbackResult.SUCCESS,
+                latency_ms=latency_ms,
+                response_preview=response[:50] if response else None
+            ))
+            print(f"[FallbackRouter] Success from {name} in {latency_ms:.0f}ms")
+            return response
+
+        except asyncio.TimeoutError:
+            latency_ms = (time.time() - start_time) * 1000
+            self._log_attempt(FallbackLog(
+                provider=name,
+                result=FallbackResult.TIMEOUT,
+                latency_ms=latency_ms,
+                error=f"Timeout after {self.timeout_seconds}s"
+            ))
+            print(f"[FallbackRouter] Timeout from {name}")
+            return None
+
+        except Exception as e:
+            latency_ms = (time.time() - start_time) * 1000
+            self._log_attempt(FallbackLog(
+                provider=name,
+                result=FallbackResult.ERROR,
+                latency_ms=latency_ms,
+                error=str(e)
+            ))
+            print(f"[FallbackRouter] Error from {name}: {e}")
+            return None
+
+    def get_log(self, limit: int = 20) -> List[FallbackLog]:
+        """Get recent log entries"""
+        return self._log[-limit:]
+
+    def get_stats(self) -> dict:
+        """Get statistics about fallback attempts"""
+        if not self._log:
+            return {"total": 0}
+
+        success_count = sum(1 for e in self._log if e.result == FallbackResult.SUCCESS)
+        by_provider = {}
+        for entry in self._log:
+            if entry.provider not in by_provider:
+                by_provider[entry.provider] = {"total": 0, "success": 0}
+            by_provider[entry.provider]["total"] += 1
+            if entry.result == FallbackResult.SUCCESS:
+                by_provider[entry.provider]["success"] += 1
+
+        return {
+            "total": len(self._log),
+            "success_rate": success_count / len(self._log),
+            "by_provider": by_provider
+        }
+
+
+def create_fallback_router_from_settings(settings_getter: Callable = None) -> FallbackRouter:
+    """
+    Create a FallbackRouter from settings.json configuration.
+
+    Args:
+        settings_getter: Function to get settings
+
+    Returns:
+        Configured FallbackRouter
+    """
+    import os
+
+    # 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:
+            settings_getter = lambda k, d=None: d
+
+    # Get LLM fallback config
+    llm_config = settings_getter("LLM_FALLBACK", {})
+    if not llm_config:
+        llm_config = {}
+
+    # Get fallback order
+    order = llm_config.get("ORDER", ["zai", "openrouter", "ollama"])
+    timeout = llm_config.get("TIMEOUT_SECONDS", 60)
+    retry_on_empty = llm_config.get("RETRY_ON_EMPTY", True)
+
+    providers = []
+
+    for name in order:
+        name_lower = name.lower()
+        client = None
+
+        if name_lower == "zai":
+            api_key = settings_getter("ZAI_API_KEY") or os.environ.get("ZAI_API_KEY", "")
+            model = settings_getter("ZAI_MODEL_MAIN") or os.environ.get("ZAI_MODEL_MAIN", "glm-4.6v")
+            if api_key:
+                client = ZAIClient(api_key, model)
+
+        elif name_lower == "openrouter":
+            api_key = settings_getter("OPENROUTER_API_KEY") or os.environ.get("OPENROUTER_API_KEY", "")
+            model = settings_getter("OPENROUTER_MODEL_MAIN") or os.environ.get("OPENROUTER_MODEL_MAIN", "anthropic/claude-3.5-sonnet")
+            if api_key:
+                client = OpenRouterClient(api_key, model)
+
+        elif name_lower == "ollama":
+            url = llm_config.get("OLLAMA_URL", "http://172.17.0.1:11434")
+            model = llm_config.get("OLLAMA_MODEL", "phi4:latest")
+            client = OllamaClient("", model, url)
+
+        if client:
+            providers.append((name_lower, client))
+            print(f"[FallbackRouter] Added provider: {name_lower}")
+
+    if not providers:
+        print("[FallbackRouter] Warning: No providers configured!")
+
+    return FallbackRouter(
+        providers=providers,
+        timeout_seconds=timeout,
+        retry_on_empty=retry_on_empty
+    )
+
+
+# Singleton instance
+_router: Optional[FallbackRouter] = None
+
+
+def get_fallback_router() -> FallbackRouter:
+    """Get the global FallbackRouter instance"""
+    global _router
+
+    if _router is None:
+        _router = create_fallback_router_from_settings()
+
+    return _router
+
+
+def reset_fallback_router():
+    """Reset the singleton (for testing)"""
+    global _router
+    _router = None

package/brain/llm/manifest.md

@@ -0,0 +1,30 @@
+# Brain: LLM Module
+
+Multi-provider LLM support for flexible model selection.
+
+## Files
+- `base.py` - Abstract BaseLLM class
+- `zai.py` - ZAI API client (GLM models)
+- `openrouter.py` - OpenRouter API client
+- `provider.py` - Factory for creating LLM clients
+
+## Provider Selection
+Set `LLM_PROVIDER` env var: `zai` (default) or `openrouter`
+
+## Task-Specific Models
+- **main** - Primary conversation model
+- **thinking** - Deep reasoning, complex decisions
+- **fast** - Quick responses, impulses, subconscious
+
+## Usage
+```python
+from brain.llm import get_main_llm, get_fast_llm, get_thinking_llm
+
+llm = get_main_llm()
+response = await llm.chat(messages, max_tokens=500)
+```
+
+## Environment Variables
+- `LLM_PROVIDER` - zai or openrouter
+- `ZAI_API_KEY`, `ZAI_MODEL_MAIN/FAST/THINKING`
+- `OPENROUTER_API_KEY`, `OPENROUTER_MODEL_MAIN/FAST/THINKING`

package/brain/llm/ollama.py

@@ -0,0 +1,218 @@
+"""
+Brain: LLM - Ollama API Client
+Local LLM support via Ollama for ultimate fallback
+"""
+
+import aiohttp
+import asyncio
+from typing import Optional, List, Dict
+from .base import BaseLLM
+
+
+class OllamaClient(BaseLLM):
+    """Ollama API client for local LLM inference"""
+
+    # Default URLs - try Docker host access first, then localhost
+    DEFAULT_URLS = [
+        "http://172.17.0.1:11434",  # Docker bridge gateway
+        "http://host.docker.internal:11434",  # Docker Desktop
+        "http://localhost:11434",  # Local
+    ]
+
+    def __init__(self, api_key: str = "", model: str = "phi4:latest", base_url: str = None):
+        # Ollama doesn't need an API key, but we keep the interface consistent
+        super().__init__(api_key or "local", model)
+        self.base_url = base_url
+        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 _discover_url(self) -> Optional[str]:
+        """Try to discover a working Ollama URL"""
+        if self.base_url:
+            return self.base_url
+
+        session = await self._get_session()
+
+        for url in self.DEFAULT_URLS:
+            try:
+                async with session.get(
+                    f"{url}/api/tags",
+                    timeout=aiohttp.ClientTimeout(total=2)
+                ) as resp:
+                    if resp.status == 200:
+                        print(f"[Ollama] Discovered at {url}")
+                        self.base_url = url
+                        return url
+            except Exception:
+                continue
+
+        return None
+
+    async def is_available(self) -> bool:
+        """Check if Ollama is running and the model is available"""
+        import time
+
+        # Cache availability for 30 seconds
+        if self._available is not None and time.time() - self._last_check < 30:
+            return self._available
+
+        try:
+            url = await self._discover_url()
+            if not url:
+                self._available = False
+                self._last_check = time.time()
+                return False
+
+            session = await self._get_session()
+
+            # Check if model is available
+            async with session.get(
+                f"{url}/api/tags",
+                timeout=aiohttp.ClientTimeout(total=5)
+            ) as resp:
+                if resp.status == 200:
+                    data = await resp.json()
+                    models = data.get("models", [])
+                    model_names = [m.get("name", "") for m in models]
+
+                    # Check if our model (or base model name) is available
+                    model_base = self.model.split(":")[0]
+                    available = any(
+                        self.model in name or model_base in name
+                        for name in model_names
+                    )
+
+                    if not available and models:
+                        # Fall back to first available model
+                        self.model = models[0].get("name", self.model)
+                        print(f"[Ollama] Model not found, using {self.model}")
+                        available = True
+
+                    self._available = available
+                    self._last_check = time.time()
+                    return available
+
+        except Exception as e:
+            print(f"[Ollama] 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 Ollama API"""
+        import os
+        import time
+
+        # Use passed temperature, or environment variable, or default
+        if temperature is None:
+            temperature = float(os.environ.get("LLM_TEMPERATURE", "0.95"))
+
+        # Discover URL if not set
+        if not self.base_url:
+            url = await self._discover_url()
+            if not url:
+                print("[Ollama] No reachable Ollama instance")
+                return None
+        else:
+            url = self.base_url
+            print(f"[Ollama] Using configured URL: {url}")
+
+        session = await self._get_session()
+
+        # Convert messages to Ollama format
+        # Ollama expects a different format than OpenAI
+        ollama_messages = []
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            if role in ("user", "assistant", "system"):
+                ollama_messages.append({"role": role, "content": content})
+
+        payload = {
+            "model": self.model,
+            "messages": ollama_messages,
+            "stream": False,
+            "options": {
+                "num_predict": max_tokens,
+                "temperature": temperature,
+                "top_p": 0.9,
+                "repeat_penalty": 1.1,
+            }
+        }
+
+        print(f"[Ollama] Request to {url} with model {self.model}")
+
+        try:
+            start_time = time.time()
+
+            async with session.post(
+                f"{url}/api/chat",
+                json=payload,
+                timeout=aiohttp.ClientTimeout(total=120)  # Local can be slower
+            ) as resp:
+                if resp.status != 200:
+                    error = await resp.text()
+                    print(f"[Ollama] Error {resp.status}: {error[:300]}")
+                    return None
+
+                data = await resp.json()
+                print(f"[Ollama] Raw response keys: {list(data.keys())}")
+
+                # Check for error in response
+                if "error" in data:
+                    print(f"[Ollama] API Error: {data['error']}")
+                    return None
+
+                # Ollama response format
+                message = data.get("message", {})
+                content = message.get("content", "")
+
+                # Some models (like deepseek-r1, JOSIEFIED) use 'thinking' field
+                if not content or not content.strip():
+                    thinking = message.get("thinking", "")
+                    if thinking and thinking.strip():
+                        content = thinking
+                        print(f"[Ollama] Using 'thinking' content instead of 'content'")
+
+                if not content or not content.strip():
+                    print(f"[Ollama] Empty content in response: {data}")
+                    return None
+
+                elapsed = time.time() - start_time
+                print(f"[Ollama] Response ({elapsed:.1f}s): {content[:80]}...")
+
+                # Mark as available since we got a response
+                self._available = True
+                self._last_check = time.time()
+
+                return content.strip()
+
+        except asyncio.TimeoutError:
+            print(f"[Ollama] Timeout (120s)")
+            return None
+        except aiohttp.ClientError as e:
+            print(f"[Ollama] Connection error: {e}")
+            self._available = False
+            return None
+        except Exception as e:
+            print(f"[Ollama] Exception: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
+
+    async def close(self):
+        """Close the client session"""
+        if self.session and not self.session.closed:
+            await self.session.close()