Add OpenRouter as final LLM fallback (free tier)

pip_brain.py

@@ -14,6 +14,7 @@ import os
 from services.gemini_client import GeminiClient
 from services.anthropic_client import AnthropicClient
 from services.sambanova_client import SambanovaClient
+from services.openrouter_client import OpenRouterClient
 from pip_prompts import (
     EMOTION_ANALYZER_PROMPT,
     ACTION_DECIDER_PROMPT,
@@ -97,6 +98,9 @@ class PipBrain:
         # Fast LLM for acknowledgments
         self.sambanova = SambanovaClient()
         
+        # Final fallback: OpenRouter (free tier available)
+        self.openrouter = OpenRouterClient()
+        
         # Other services
         self.artist = PipArtist()
         self.voice = PipVoice()
@@ -112,12 +116,14 @@ class PipBrain:
         self._gemini_available = self.gemini.available
         self._claude_available = self.claude is not None and self.claude.available
         self._sambanova_available = self.sambanova.available
+        self._openrouter_available = self.openrouter.available
         
         # Log what's available
         print(f"🧠 PipBrain initialized:")
         print(f"   - Gemini: {'✅' if self._gemini_available else '❌'}")
         print(f"   - Claude: {'✅' if self._claude_available else '❌'}")
         print(f"   - SambaNova: {'✅' if self._sambanova_available else '❌'}")
+        print(f"   - OpenRouter: {'✅' if self._openrouter_available else '❌'}")
     
     def set_mode(self, session_id: str, mode: str):
         """Set the interaction mode for a session."""
@@ -296,7 +302,7 @@ class PipBrain:
     # =========================================================================
     
     async def _quick_acknowledge_with_fallback(self, user_input: str) -> str:
-        """Quick acknowledgment with Gemini -> SambaNova fallback."""
+        """Quick acknowledgment with Gemini -> SambaNova -> OpenRouter fallback."""
         # Try Gemini first
         if self._gemini_available:
             try:
@@ -307,14 +313,25 @@ class PipBrain:
                 print(f"Gemini quick ack failed: {e}")
         
         # Fallback to SambaNova
-        try:
-            return await self.sambanova.quick_acknowledge(user_input, QUICK_ACK_PROMPT)
-        except Exception as e:
-            print(f"SambaNova quick ack failed: {e}")
-            return "I hear you..."
+        if self._sambanova_available:
+            try:
+                result = await self.sambanova.quick_acknowledge(user_input, QUICK_ACK_PROMPT)
+                if result:
+                    return result
+            except Exception as e:
+                print(f"SambaNova quick ack failed: {e}")
+        
+        # Fallback to OpenRouter
+        if self._openrouter_available:
+            try:
+                return await self.openrouter.quick_acknowledge(user_input, QUICK_ACK_PROMPT)
+            except Exception as e:
+                print(f"OpenRouter quick ack failed: {e}")
+        
+        return "I hear you..."
     
     async def _analyze_emotion_with_fallback(self, user_input: str) -> dict:
-        """Emotion analysis with Gemini -> Claude fallback."""
+        """Emotion analysis with Gemini -> Claude -> SambaNova -> OpenRouter fallback."""
         default_emotion = {
             "primary_emotions": ["neutral"],
             "secondary_emotions": [],
@@ -331,7 +348,6 @@ class PipBrain:
                     return result
             except Exception as e:
                 print(f"Gemini emotion analysis failed: {e}")
-                self._gemini_available = False  # Temporarily disable
         
         # Fallback to Claude
         if self._claude_available and self.claude:
@@ -342,6 +358,24 @@ class PipBrain:
             except Exception as e:
                 print(f"Claude emotion analysis failed: {e}")
         
+        # Fallback to SambaNova (fast analysis)
+        if self._sambanova_available:
+            try:
+                result = await self.sambanova.analyze_emotion_fast(user_input, EMOTION_ANALYZER_QUICK_PROMPT)
+                if result:
+                    return result
+            except Exception as e:
+                print(f"SambaNova emotion analysis failed: {e}")
+        
+        # Fallback to OpenRouter
+        if self._openrouter_available:
+            try:
+                result = await self.openrouter.analyze_emotion_fast(user_input, EMOTION_ANALYZER_QUICK_PROMPT)
+                if result:
+                    return result
+            except Exception as e:
+                print(f"OpenRouter emotion analysis failed: {e}")
+        
         return default_emotion
     
     async def _decide_action_with_fallback(self, emotion_state: dict) -> dict:
@@ -379,7 +413,7 @@ class PipBrain:
         action: dict,
         history: list
     ) -> AsyncGenerator[str, None]:
-        """Generate response with Gemini -> Claude -> SambaNova fallback."""
+        """Generate response with Gemini -> Claude -> SambaNova -> OpenRouter fallback."""
         
         # Try Gemini first
         if self._gemini_available:
@@ -409,15 +443,34 @@ class PipBrain:
             except Exception as e:
                 print(f"Claude response generation failed: {e}")
         
-        # Final fallback to SambaNova
-        try:
-            async for chunk in self.sambanova.generate_response_stream(
-                user_input, emotion_state, CONVERSATION_PROMPT
-            ):
-                yield chunk
-        except Exception as e:
-            print(f"All LLMs failed: {e}")
-            yield "I'm here with you. Tell me more about what's on your mind."
+        # Fallback to SambaNova
+        if self._sambanova_available:
+            try:
+                yielded = False
+                async for chunk in self.sambanova.generate_response_stream(
+                    user_input, emotion_state, CONVERSATION_PROMPT
+                ):
+                    yielded = True
+                    yield chunk
+                if yielded:
+                    return
+            except Exception as e:
+                print(f"SambaNova response generation failed: {e}")
+        
+        # Final fallback to OpenRouter (free tier)
+        if self._openrouter_available:
+            try:
+                async for chunk in self.openrouter.generate_response_stream(
+                    user_input, emotion_state, CONVERSATION_PROMPT
+                ):
+                    yield chunk
+                return
+            except Exception as e:
+                print(f"OpenRouter response generation failed: {e}")
+        
+        # All LLMs failed - yield a caring fallback
+        print("⚠️ All LLMs failed!")
+        yield "I'm here with you. Sometimes I need a moment to gather my thoughts, but I'm listening. Please share what's on your mind."
     
     async def _generate_intervention_with_fallback(
         self,

services/openrouter_client.py

@@ -0,0 +1,199 @@
+"""
+OpenRouter client for Pip's fallback responses.
+OpenRouter provides access to multiple LLM providers with a unified API.
+Uses OpenAI-compatible API.
+"""
+
+import os
+import asyncio
+from typing import AsyncGenerator
+from openai import AsyncOpenAI
+
+
+class OpenRouterClient:
+    """OpenRouter-powered fallback for Pip."""
+    
+    # Free/cheap models on OpenRouter
+    DEFAULT_MODEL = "meta-llama/llama-3.1-8b-instruct:free"
+    FALLBACK_MODEL = "meta-llama/llama-3.2-3b-instruct:free"
+    
+    def __init__(self, api_key: str = None):
+        api_key = api_key or os.getenv("OPENROUTER_API_KEY")
+        self.available = bool(api_key)
+        
+        if self.available:
+            self.client = AsyncOpenAI(
+                api_key=api_key,
+                base_url="https://openrouter.ai/api/v1"
+            )
+        else:
+            self.client = None
+            print("⚠️ OpenRouter: No API key found - service disabled")
+        
+        self.model = self.DEFAULT_MODEL
+    
+    async def quick_acknowledge(self, user_input: str, system_prompt: str) -> str:
+        """Generate a quick acknowledgment."""
+        if not self.available or not self.client:
+            return "I hear you..."
+        
+        try:
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                max_tokens=50,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_input}
+                ],
+                extra_headers={
+                    "HTTP-Referer": "https://huggingface.co/spaces/MCP-1st-Birthday/pipV1",
+                    "X-Title": "Pip Emotional Companion"
+                }
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            print(f"OpenRouter quick_acknowledge error: {e}")
+            return "I hear you..."
+    
+    async def analyze_emotion_fast(self, user_input: str, system_prompt: str) -> dict:
+        """Quick emotion analysis."""
+        import json
+        
+        default_response = {
+            "primary_emotions": ["neutral"],
+            "intensity": 5,
+            "pip_expression": "neutral",
+            "intervention_needed": False
+        }
+        
+        if not self.available or not self.client:
+            return default_response
+        
+        try:
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                max_tokens=256,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_input}
+                ],
+                extra_headers={
+                    "HTTP-Referer": "https://huggingface.co/spaces/MCP-1st-Birthday/pipV1",
+                    "X-Title": "Pip Emotional Companion"
+                }
+            )
+            
+            content = response.choices[0].message.content
+            if "```json" in content:
+                content = content.split("```json")[1].split("```")[0]
+            elif "```" in content:
+                content = content.split("```")[1].split("```")[0]
+            return json.loads(content.strip())
+        except Exception as e:
+            print(f"OpenRouter analyze_emotion error: {e}")
+            return default_response
+    
+    async def generate_response_stream(
+        self,
+        user_input: str,
+        emotion_state: dict,
+        system_prompt: str
+    ) -> AsyncGenerator[str, None]:
+        """Generate conversational response with streaming."""
+        if not self.available or not self.client:
+            yield "I'm here with you. Sometimes words take a moment to find..."
+            return
+        
+        context = f"""
+User's emotions: {emotion_state.get('primary_emotions', [])}
+Intensity: {emotion_state.get('intensity', 5)}/10
+
+User said: {user_input}
+"""
+        
+        try:
+            stream = await self.client.chat.completions.create(
+                model=self.model,
+                max_tokens=512,
+                stream=True,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": context}
+                ],
+                extra_headers={
+                    "HTTP-Referer": "https://huggingface.co/spaces/MCP-1st-Birthday/pipV1",
+                    "X-Title": "Pip Emotional Companion"
+                }
+            )
+            
+            async for chunk in stream:
+                if chunk.choices[0].delta.content:
+                    yield chunk.choices[0].delta.content
+        except Exception as e:
+            print(f"OpenRouter generate_response_stream error: {e}")
+            yield "I'm here with you. Let me gather my thoughts..."
+    
+    async def enhance_prompt(
+        self, 
+        user_input: str, 
+        emotion_state: dict,
+        mode: str,
+        system_prompt: str
+    ) -> str:
+        """Transform user context into a detailed image prompt."""
+        emotions = emotion_state.get('primary_emotions', ['peaceful'])
+        fallback = f"A beautiful, calming scene representing {emotions[0] if emotions else 'peace'}, soft colors, dreamy atmosphere"
+        
+        if not self.available or not self.client:
+            return fallback
+        
+        context = f"""
+User said: "{user_input}"
+
+Detected emotions: {emotion_state.get('primary_emotions', [])}
+Emotional intensity: {emotion_state.get('intensity', 5)}/10
+Current mode: {mode}
+
+Generate a vivid, specific image prompt based on THIS user's context.
+"""
+        
+        try:
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                max_tokens=300,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": context}
+                ],
+                extra_headers={
+                    "HTTP-Referer": "https://huggingface.co/spaces/MCP-1st-Birthday/pipV1",
+                    "X-Title": "Pip Emotional Companion"
+                }
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            print(f"OpenRouter enhance_prompt error: {e}")
+            return fallback
+    
+    async def generate_text(self, prompt: str) -> str:
+        """Generate text for various purposes."""
+        if not self.available or not self.client:
+            return ""
+        
+        try:
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                max_tokens=512,
+                messages=[
+                    {"role": "user", "content": prompt}
+                ],
+                extra_headers={
+                    "HTTP-Referer": "https://huggingface.co/spaces/MCP-1st-Birthday/pipV1",
+                    "X-Title": "Pip Emotional Companion"
+                }
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            print(f"OpenRouter generate_text error: {e}")
+            return ""
+