alive-ai 0.1.0

package/output/images/fal_gen.py

@@ -0,0 +1,43 @@
+"""
+Output: Fal.ai Image Generator
+Generate images using fal.ai API
+"""
+
+import aiohttp
+
+class FalImageGen:
+    """Image generator via fal.ai"""
+
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.base_url = "https://queue.fal.run/fal-ai/flux/schnell"
+
+    async def generate(self, prompt: str, size: str = "square_hd") -> str:
+        """Generate image, return URL"""
+        if not self.api_key:
+            print("[Fal.ai] No API key configured")
+            return ""
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    self.base_url,
+                    headers={
+                        "Authorization": f"Key {self.api_key}",
+                        "Content-Type": "application/json"
+                    },
+                    json={
+                        "prompt": prompt,
+                        "image_size": size
+                    },
+                    timeout=aiohttp.ClientTimeout(total=60)
+                ) as resp:
+                    if resp.status == 200:
+                        result = await resp.json()
+                        return result.get("images", [{}])[0].get("url", "")
+                    else:
+                        print(f"[Fal.ai] Error: {resp.status}")
+                        return ""
+        except Exception as e:
+            print(f"[Fal.ai] Error: {e}")
+            return ""

package/output/manifest.md

@@ -0,0 +1,26 @@
+# Output - Actions
+
+How the AI responds to users.
+
+## Modules
+- `text/` - Text message sender
+- `voice/` - Voice synthesis via VibeTTS
+  - `vibe_tts.py` - TTS client with auto-splitting (5000 char limit)
+  - `sender.py` - Voice file sender
+- `images/` - Image generation via Fal.ai
+  - `fal_gen.py` - Fal.ai API client
+
+## Voice (VibeTTS)
+- Connects to VibeVoice server (VIBE_TTS_URL)
+- Mood-based CFG scaling (high_desire=1.9, neutral=1.5)
+- Auto-splits long texts at paragraph boundaries
+- Output: OGG format for Telegram
+
+## Image Generation
+- Fal.ai API for AI image generation
+- Prompt enhancement based on mood/context
+
+## Integration Points
+- Receives events: `send_text`, `send_voice_file`, `send_image`, `send_video`
+- Voice triggered by: user request, high desire, is_high_desire state
+- Images/videos selected based on arousal level and context

package/output/text/__init__.py

@@ -0,0 +1 @@
+"""Text output"""

package/output/text/sender.py

@@ -0,0 +1,22 @@
+"""
+Output: Text Sender
+Send text messages
+"""
+
+class TextSender:
+    """Text message sender"""
+
+    def __init__(self, nervous, config):
+        self.nervous = nervous
+        self.config = config
+
+        # Listen for send events
+        nervous.on("send_text", self._send)
+
+    async def _send(self, data: dict):
+        """Handle text send (actual sending done by TelegramListener)"""
+        text = data.get("text", "")
+        mood = data.get("mood", "neutral")
+
+        # Log the message
+        print(f"[Outgoing {mood}] {text[:100]}{'...' if len(text) > 100 else ''}")

package/output/voice/__init__.py

@@ -0,0 +1,64 @@
+"""
+Output: Voice TTS Factory
+Creates the appropriate TTS provider based on settings
+"""
+
+from typing import Optional
+
+
+async def create_tts(provider: str = "vibe", **kwargs) -> Optional[object]:
+    """
+    Create a TTS instance based on provider setting.
+
+    Args:
+        provider: "vibe", "google", or "gtts"
+        **kwargs: Provider-specific arguments:
+            - vibe: url (required)
+            - google: api_key (optional)
+            - gtts: no arguments needed
+
+    Returns:
+        TTS instance or None if unavailable
+    """
+    provider = provider.lower()
+
+    if provider == "vibe" or provider == "vibevoice":
+        from .vibe_tts import VibeTTS
+        url = kwargs.get("url", "http://localhost:8080")
+        tts = VibeTTS(url)
+        if await tts.is_available():
+            print(f"[TTS] Connected to VibeVoice at {url}")
+            return tts
+        else:
+            print(f"[TTS] VibeVoice not available at {url}")
+            return None
+
+    elif provider == "google" or provider == "google-tts":
+        from .google_tts import GoogleTTS
+        api_key = kwargs.get("api_key")
+        tts = GoogleTTS(api_key)
+        if await tts.is_available():
+            print(f"[TTS] Connected to Google Cloud TTS")
+            return tts
+        else:
+            print(f"[TTS] Google Cloud TTS not available")
+            return None
+
+    elif provider == "gtts" or provider == "gtranslate":
+        from .gtts_tts import GTTS
+        tts = GTTS()
+        if await tts.is_available():
+            print(f"[TTS] Connected to gTTS (Google Translate - FREE)")
+            return tts
+        else:
+            print(f"[TTS] gTTS not available. Install with: pip install gtts")
+            return None
+
+    else:
+        print(f"[TTS] Unknown provider: {provider}")
+        return None
+
+
+def get_available_providers() -> list:
+    """Get list of available TTS providers"""
+    return ["vibe", "google", "gtts"]

package/output/voice/google_tts.py

@@ -0,0 +1,252 @@
+"""
+Output: Google Cloud TTS
+Text-to-speech using Google Cloud Text-to-Speech API
+
+Uses the free tier (up to 4M chars/month) with Emma voice
+"""
+
+import aiohttp
+import asyncio
+import re
+import tempfile
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+VOICE_OUTPUT_PATH = "/tmp/alive_ai_voice.ogg"
+MAX_CHARS = 5000  # Google TTS limit per request
+
+
+class GoogleTTS:
+    """Text-to-speech via Google Cloud TTS API"""
+
+    # Available voices - Emma is the natural sounding one
+    AVAILABLE_VOICES = {
+        "emma": "en-US-Neural2-F",      # Emma - natural female US
+        "emma-uk": "en-GB-Neural2-F",   # UK female
+        "guy": "en-US-Neural2-D",       # Male US
+        "guy-uk": "en-GB-Neural2-D",    # Male UK
+    }
+
+    DEFAULT_VOICE = "emma"
+
+    # Speaking rates by mood (0.25 to 4.0, 1.0 is normal)
+    MOOD_RATES = {
+        "chill": 0.9, "neutral": 1.0, "happy": 1.05,
+        "flirty": 1.0, "excited": 1.1, "high_desire": 0.95, "intense": 1.0,
+        "sad": 0.9, "tired": 0.85
+    }
+
+    def __init__(self, api_key: str = None):
+        """
+        Initialize Google TTS.
+
+        Args:
+            api_key: Google Cloud API key (optional if using ADC)
+        """
+        self.api_key = api_key
+        self.base_url = "https://texttospeech.googleapis.com/v1"
+
+    def prepare_text(self, text: str) -> str:
+        """Clean text for TTS - removes formatting and EMOJIS"""
+        # Remove markdown formatting
+        text = text.replace("**", "").replace("__", "").replace("*", "")
+        text = text.replace("_", "").replace("~", "")
+        text = re.sub(r'\*[^*]+\*', '', text)
+        text = re.sub(r'\.{3,}', '...', text)
+        text = re.sub(r'!{2,}', '!', text)
+        text = re.sub(r'\?{2,}', '?', text)
+
+        # Remove ALL emojis - they break TTS
+        text = re.sub(r'[\U00010000-\U0010ffff]', '', text)
+        text = re.sub(r'[\U0001F600-\U0001F64F]', '', text)  # emoticons
+        text = re.sub(r'[\U0001F300-\U0001F5FF]', '', text)  # symbols & pictographs
+        text = re.sub(r'[\U0001F680-\U0001F6FF]', '', text)  # transport & map
+        text = re.sub(r'[\U0001F700-\U0001F77F]', '', text)  # alchemical
+        text = re.sub(r'[\U0001F780-\U0001F7FF]', '', text)  # Geometric Shapes
+        text = re.sub(r'[\U0001F800-\U0001F8FF]', '', text)  # Supplemental Arrows-C
+        text = re.sub(r'[\U0001F900-\U0001F9FF]', '', text)  # Supplemental Symbols
+        text = re.sub(r'[\U0001FA00-\U0001FA6F]', '', text)  # Chess Symbols
+        text = re.sub(r'[\U0001FA70-\U0001FAFF]', '', text)  # Symbols Extended-A
+        text = re.sub(r'[\U00002702-\U000027B0]', '', text)  # Dingbats
+        text = re.sub(r'[\U000024C2-\U0001F251]', '', text)  # Enclosed characters
+        text = re.sub(r'[\U0001F1E0-\U0001F1FF]', '', text)  # Flags
+
+        # Clean up extra spaces
+        text = re.sub(r'\s+', ' ', text)
+        return text.strip()
+
+    def split_text(self, text: str) -> list:
+        """Split long text at paragraph/sentence boundaries"""
+        if len(text) <= MAX_CHARS:
+            return [text]
+
+        parts = []
+        paragraphs = text.split('\n\n')
+        current = ""
+
+        for para in paragraphs:
+            if len(current) + len(para) + 2 <= MAX_CHARS:
+                current = current + "\n\n" + para if current else para
+            else:
+                if current:
+                    parts.append(current)
+                # If single paragraph is too long, split by sentences
+                if len(para) > MAX_CHARS:
+                    sentences = para.replace('. ', '.\n').split('\n')
+                    chunk = ""
+                    for s in sentences:
+                        if len(chunk) + len(s) + 1 <= MAX_CHARS:
+                            chunk = chunk + " " + s if chunk else s
+                        else:
+                            if chunk:
+                                parts.append(chunk)
+                            chunk = s
+                    if chunk:
+                        parts.append(chunk)
+                else:
+                    current = para
+
+        if current:
+            parts.append(current)
+
+        return parts
+
+    def get_voice_id(self, voice: str) -> str:
+        """Get Google voice ID from friendly name"""
+        return self.AVAILABLE_VOICES.get(voice, self.AVAILABLE_VOICES[self.DEFAULT_VOICE])
+
+    def get_rate_for_mood(self, mood: str) -> float:
+        return self.MOOD_RATES.get(mood, 1.0)
+
+    async def generate(self, text: str, voice: str = None,
+                       cfg: float = None, mood: str = "neutral") -> str:
+        """Generate audio using Google Cloud TTS"""
+        if voice is None:
+            voice = self.DEFAULT_VOICE
+
+        voice_id = self.get_voice_id(voice)
+        speaking_rate = self.get_rate_for_mood(mood)
+
+        text = self.prepare_text(text)
+        print(f"[GoogleTTS] Generating voice for {len(text)} chars with voice {voice_id}...")
+
+        # Split if needed
+        parts = self.split_text(text)
+        if len(parts) > 1:
+            print(f"[GoogleTTS] Split into {len(parts)} parts")
+
+        audio_parts = []
+        for i, part in enumerate(parts):
+            print(f"[GoogleTTS] Processing part {i+1}/{len(parts)} ({len(part)} chars)")
+            audio = await self._generate_single(part, voice_id, speaking_rate)
+            if audio:
+                audio_parts.append(audio)
+            else:
+                print(f"[GoogleTTS] Part {i+1} failed")
+
+        if not audio_parts:
+            return ""
+
+        # Combine all parts
+        if len(audio_parts) == 1:
+            Path(VOICE_OUTPUT_PATH).write_bytes(audio_parts[0])
+        else:
+            # Use ffmpeg to properly concatenate OGG files
+            temp_files = []
+            try:
+                for i, part in enumerate(audio_parts):
+                    tf = tempfile.NamedTemporaryFile(suffix=".ogg", delete=False)
+                    tf.write(part)
+                    tf.close()
+                    temp_files.append(tf.name)
+                list_file = tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False)
+                for tf_name in temp_files:
+                    list_file.write(f"file '{tf_name}'\n")
+                list_file.close()
+                subprocess.run(
+                    ["ffmpeg", "-y", "-f", "concat", "-safe", "0",
+                     "-i", list_file.name, "-c", "copy", VOICE_OUTPUT_PATH],
+                    capture_output=True, timeout=30
+                )
+                Path(list_file.name).unlink(missing_ok=True)
+            except Exception as e:
+                print(f"[GoogleTTS] ffmpeg concat failed, using first part: {e}")
+                Path(VOICE_OUTPUT_PATH).write_bytes(audio_parts[0])
+            finally:
+                for tf_name in temp_files:
+                    Path(tf_name).unlink(missing_ok=True)
+        print(f"[GoogleTTS] Generated audio file")
+        return VOICE_OUTPUT_PATH
+
+    async def _generate_single(self, text: str, voice_id: str, speaking_rate: float) -> bytes:
+        """Generate single audio part via Google Cloud TTS API"""
+        try:
+            # Build request URL
+            url = f"{self.base_url}/text:synthesize"
+            if self.api_key:
+                url += f"?key={self.api_key}"
+
+            # Request body
+            payload = {
+                "input": {"text": text},
+                "voice": {
+                    "languageCode": "en-US",
+                    "name": voice_id
+                },
+                "audioConfig": {
+                    "audioEncoding": "OGG_OPUS",
+                    "speakingRate": speaking_rate,
+                    "pitch": 0.0
+                }
+            }
+
+            # Adjust language code based on voice
+            if "en-GB" in voice_id:
+                payload["voice"]["languageCode"] = "en-GB"
+
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    url,
+                    json=payload,
+                    timeout=aiohttp.ClientTimeout(total=60)
+                ) as resp:
+                    if resp.status == 200:
+                        result = await resp.json()
+                        # Response contains base64-encoded audio
+                        import base64
+                        audio_content = result.get("audioContent", "")
+                        if audio_content:
+                            return base64.b64decode(audio_content)
+                        return b""
+                    else:
+                        error = await resp.text()
+                        print(f"[GoogleTTS] Error {resp.status}: {error[:200]}")
+                        return b""
+        except asyncio.TimeoutError:
+            print("[GoogleTTS] Timeout")
+            return b""
+        except Exception as e:
+            print(f"[GoogleTTS] Error: {e}")
+            return b""
+
+    async def is_available(self) -> bool:
+        """Check if Google TTS is available"""
+        # If we have an API key or ADC is configured, it should work
+        try:
+            # Try a minimal synthesis to check
+            url = f"{self.base_url}/text:synthesize"
+            if self.api_key:
+                url += f"?key={self.api_key}"
+
+            payload = {
+                "input": {"text": "test"},
+                "voice": {"languageCode": "en-US", "name": "en-US-Neural2-F"},
+                "audioConfig": {"audioEncoding": "OGG_OPUS"}
+            }
+
+            async with aiohttp.ClientSession() as session:
+                async with session.post(url, json=payload, timeout=10) as resp:
+                    return resp.status == 200
+        except Exception:
+            return False

package/output/voice/gtts_tts.py

@@ -0,0 +1,214 @@
+"""
+Output: gTTS (Google Translate TTS)
+Free text-to-speech using Google Translate's TTS API
+No API key required!
+"""
+
+import asyncio
+import re
+import tempfile
+import subprocess
+from pathlib import Path
+from typing import Optional
+from concurrent.futures import ThreadPoolExecutor
+
+VOICE_OUTPUT_PATH = "/tmp/alive_ai_voice.ogg"
+MAX_CHARS = 5000  # gTTS limit
+
+# Thread pool for blocking gTTS calls
+_executor = ThreadPoolExecutor(max_workers=2)
+
+
+class GTTS:
+    """Text-to-speech via gTTS (Google Translate TTS) - Completely free!"""
+
+    # Available voices are language codes
+    # gTTS doesn't have named voices like "Emma", just languages/accents
+    AVAILABLE_VOICES = {
+        "en": "en",           # English (default)
+        "en-us": "en",        # US English
+        "en-uk": "co.uk",     # UK English
+        "en-au": "com.au",    # Australian English
+        "en-in": "co.in",     # Indian English
+        "it": "it",           # Italian
+        "es": "es",           # Spanish
+        "fr": "fr",           # French
+        "de": "de",           # German
+        "pt": "pt",           # Portuguese
+    }
+
+    DEFAULT_VOICE = "en"
+    DEFAULT_LANG = "en"
+
+    def __init__(self):
+        """Initialize gTTS - no API key needed!"""
+        self._available = None
+
+    def prepare_text(self, text: str) -> str:
+        """Clean text for TTS"""
+        # Remove markdown formatting
+        text = text.replace("**", "").replace("__", "").replace("*", "")
+        text = text.replace("_", "").replace("~", "")
+        text = re.sub(r'\*[^*]+\*', '', text)
+        text = re.sub(r'\.{3,}', '...', text)
+        text = re.sub(r'!{2,}', '!', text)
+        text = re.sub(r'\?{2,}', '?', text)
+
+        # Remove ALL emojis
+        text = re.sub(r'[\U00010000-\U0010ffff]', '', text)
+        text = re.sub(r'[\U0001F600-\U0001F64F]', '', text)
+        text = re.sub(r'[\U0001F300-\U0001F5FF]', '', text)
+        text = re.sub(r'[\U0001F680-\U0001F6FF]', '', text)
+        text = re.sub(r'[\U00002702-\U000027B0]', '', text)
+        text = re.sub(r'[\U000024C2-\U0001F251]', '', text)
+        text = re.sub(r'[\U0001F1E0-\U0001F1FF]', '', text)
+
+        # Clean up extra spaces
+        text = re.sub(r'\s+', ' ', text)
+        return text.strip()
+
+    def split_text(self, text: str) -> list:
+        """Split long text at paragraph boundaries"""
+        if len(text) <= MAX_CHARS:
+            return [text]
+
+        parts = []
+        paragraphs = text.split('\n\n')
+        current = ""
+
+        for para in paragraphs:
+            if len(current) + len(para) + 2 <= MAX_CHARS:
+                current = current + "\n\n" + para if current else para
+            else:
+                if current:
+                    parts.append(current)
+                if len(para) > MAX_CHARS:
+                    sentences = para.replace('. ', '.\n').split('\n')
+                    chunk = ""
+                    for s in sentences:
+                        if len(chunk) + len(s) + 1 <= MAX_CHARS:
+                            chunk = chunk + " " + s if chunk else s
+                        else:
+                            if chunk:
+                                parts.append(chunk)
+                            chunk = s
+                    if chunk:
+                        parts.append(chunk)
+                else:
+                    current = para
+
+        if current:
+            parts.append(current)
+
+        return parts
+
+    def _generate_blocking(self, text: str, lang: str) -> bytes:
+        """Generate audio in a blocking manner (runs in thread pool)"""
+        try:
+            from gtts import gTTS
+            import io
+
+            tts = gTTS(text=text, lang=lang, slow=False)
+            mp3_buffer = io.BytesIO()
+            tts.write_to_fp(mp3_buffer)
+            mp3_buffer.seek(0)
+
+            # Convert MP3 to OGG for Telegram
+            # If pydub is available, convert to OGG
+            try:
+                from pydub import AudioSegment
+                audio = AudioSegment.from_mp3(mp3_buffer)
+                ogg_buffer = io.BytesIO()
+                audio.export(ogg_buffer, format="ogg")
+                ogg_buffer.seek(0)
+                return ogg_buffer.read()
+            except ImportError:
+                # No pydub - return MP3, Telegram accepts it too
+                mp3_buffer.seek(0)
+                return mp3_buffer.read()
+
+        except ImportError:
+            print("[GTTS] gtts not installed. Run: pip install gtts")
+            return b""
+        except Exception as e:
+            print(f"[GTTS] Error: {e}")
+            return b""
+
+    async def generate(self, text: str, voice: str = None,
+                       cfg: float = None, mood: str = "neutral") -> str:
+        """Generate audio using gTTS"""
+        if voice is None:
+            voice = self.DEFAULT_VOICE
+
+        # Map voice to language code
+        lang = self.AVAILABLE_VOICES.get(voice, self.DEFAULT_LANG)
+
+        text = self.prepare_text(text)
+        print(f"[GTTS] Generating voice for {len(text)} chars with lang={lang}...")
+
+        # Split if needed
+        parts = self.split_text(text)
+        if len(parts) > 1:
+            print(f"[GTTS] Split into {len(parts)} parts")
+
+        audio_parts = []
+        loop = asyncio.get_running_loop()
+
+        for i, part in enumerate(parts):
+            print(f"[GTTS] Processing part {i+1}/{len(parts)} ({len(part)} chars)")
+            audio = await loop.run_in_executor(_executor, self._generate_blocking, part, lang)
+            if audio:
+                audio_parts.append(audio)
+            else:
+                print(f"[GTTS] Part {i+1} failed")
+
+        if not audio_parts:
+            return ""
+
+        # Determine extension based on format
+        ext = ".ogg" if audio_parts[0][:4] == b'OggS' else ".mp3"
+        output_path = VOICE_OUTPUT_PATH.replace(".ogg", ext)
+
+        # Combine all parts
+        if len(audio_parts) == 1:
+            Path(output_path).write_bytes(audio_parts[0])
+        else:
+            # Use ffmpeg to properly concatenate audio files
+            temp_files = []
+            try:
+                for i, part in enumerate(audio_parts):
+                    tf = tempfile.NamedTemporaryFile(suffix=ext, delete=False)
+                    tf.write(part)
+                    tf.close()
+                    temp_files.append(tf.name)
+                list_file = tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False)
+                for tf_name in temp_files:
+                    list_file.write(f"file '{tf_name}'\n")
+                list_file.close()
+                subprocess.run(
+                    ["ffmpeg", "-y", "-f", "concat", "-safe", "0",
+                     "-i", list_file.name, "-c", "copy", output_path],
+                    capture_output=True, timeout=30
+                )
+                Path(list_file.name).unlink(missing_ok=True)
+            except Exception as e:
+                print(f"[GTTS] ffmpeg concat failed, using first part: {e}")
+                Path(output_path).write_bytes(audio_parts[0])
+            finally:
+                for tf_name in temp_files:
+                    Path(tf_name).unlink(missing_ok=True)
+        print(f"[GTTS] Generated audio file")
+        return output_path
+
+    async def is_available(self) -> bool:
+        """Check if gTTS is available"""
+        if self._available is not None:
+            return self._available
+
+        try:
+            from gtts import gTTS
+            self._available = True
+            return True
+        except ImportError:
+            self._available = False
+            return False