Deploy newest version

features.html

@@ -569,3 +569,4 @@
 </body>
 </html>
 
+

pyproject.toml

@@ -23,6 +23,7 @@ dependencies = [
     "sounddevice>=0.4.6",
     "aiosqlite>=0.19.0",
     "aiohttp>=3.9.0",
+    "openai>=1.0.0",  # Required for meetings transcription and vision tools
     # Vision uses reachy_mini SDK (WebRTC) and reachy_mini_toolbox (MediaPipe face detection)
     # These should already be available in the apps_venv environment
 ]

reachys_brain/audio_capture.py

@@ -335,6 +335,11 @@ class AsyncAudioCaptureService:
         """Check if currently capturing."""
         return self._capture.is_capturing
     
+    @property
+    def is_paused(self) -> bool:
+        """Check if capture is paused."""
+        return self._capture.is_paused
+    
     async def start_capture(self) -> bool:
         """Start capturing audio."""
         self._loop = asyncio.get_event_loop()

reachys_brain/audio_playback.py

@@ -19,10 +19,17 @@ SAMPLE_WIDTH = 2  # 16-bit = 2 bytes
 AUDIO_DEVICE = "plug:reachymini_audio_sink"
 
 # Playback timing
-STOP_DELAY_SECONDS = 0.3  # Delay before stopping to allow buffer to drain
+STOP_DELAY_SECONDS = 1.5  # Delay before stopping to allow buffer to drain (increased for longer sentences)
 
-# Kids mode pitch shift (in cents, 400 = ~1/3 octave higher)
-KIDS_MODE_PITCH_CENTS = 400
+# Kids mode audio effects.
+#
+# NOTE: A pure pitch shift can still sound like the same adult voice (just higher).
+# Adding a small tempo increase makes it much more perceptibly "kid-like".
+# Units:
+# - pitch: cents (1200 cents = 1 octave)
+# - tempo: multiplier (1.10 = 10% faster)
+KIDS_MODE_PITCH_CENTS = 900
+KIDS_MODE_TEMPO = 1.12
 
 
 # Global kids mode state
@@ -169,7 +176,8 @@ class AudioPlaybackService:
                     "-",                   # Input from stdin
                     "-t", "raw",           # Output format: raw
                     "-",                   # Output to stdout
-                    "pitch", str(KIDS_MODE_PITCH_CENTS),  # Pitch shift up
+                    "pitch", str(KIDS_MODE_PITCH_CENTS),
+                    "tempo", str(KIDS_MODE_TEMPO),
                 ]
                 
                 # Start sox process (reads from stdin, outputs to stdout)
@@ -275,12 +283,22 @@ class StreamingAudioPlayer:
         """Initialize the streaming player."""
         self._playback = AudioPlaybackService()
         self._is_stream_active = False
+        self._last_chunk_time = 0.0  # Track when last audio chunk was received
+        self._chunks_received = 0  # Count chunks for timing estimation
     
     @property
     def is_playing(self) -> bool:
         """Check if audio stream is active."""
         return self._is_stream_active
     
+    @property
+    def time_since_last_chunk(self) -> float:
+        """Get time in seconds since the last audio chunk was received."""
+        import time
+        if self._last_chunk_time == 0:
+            return 0.0
+        return time.time() - self._last_chunk_time
+    
     def start_stream(self) -> None:
         """Start a new audio stream.
         
@@ -289,6 +307,8 @@ class StreamingAudioPlayer:
         if not self._is_stream_active:
             self._playback.start_playback()
             self._is_stream_active = True
+            self._chunks_received = 0
+            self._last_chunk_time = 0.0
             logger.info("Started audio stream")
     
     def stop_stream(self) -> None:
@@ -297,13 +317,26 @@ class StreamingAudioPlayer:
         Call this when OpenAI stops sending audio.
         """
         if self._is_stream_active:
-            # Give a small delay to let remaining audio play
-            threading.Timer(STOP_DELAY_SECONDS, self._stop_delayed).start()
+            # Calculate dynamic delay based on chunks received
+            # Each chunk is roughly 100ms of audio, add extra buffer time
+            # Minimum delay is STOP_DELAY_SECONDS, but scale up for longer responses
+            import time
+            base_delay = STOP_DELAY_SECONDS
+            
+            # Add extra delay proportional to the number of chunks
+            # This helps ensure longer responses have time to fully play
+            chunk_based_delay = min(self._chunks_received * 0.02, 2.0)  # Cap at 2 extra seconds
+            total_delay = base_delay + chunk_based_delay
+            
+            logger.info(f"🔊 Stopping audio stream in {total_delay:.1f}s (received {self._chunks_received} chunks)")
+            threading.Timer(total_delay, self._stop_delayed).start()
     
     def _stop_delayed(self) -> None:
         """Delayed stop to allow audio buffer to drain."""
         self._playback.stop_playback()
         self._is_stream_active = False
+        self._chunks_received = 0
+        self._last_chunk_time = 0.0
         logger.info("Stopped audio stream")
     
     def play_chunk(self, audio_data: bytes) -> None:
@@ -314,10 +347,14 @@ class StreamingAudioPlayer:
         Args:
             audio_data: PCM16 audio data at 24kHz mono.
         """
+        import time
+        
         if not self._is_stream_active:
             self.start_stream()
         
         self._playback.enqueue_audio(audio_data)
+        self._last_chunk_time = time.time()
+        self._chunks_received += 1
     
     def cancel(self) -> None:
         """Immediately stop playback and clear queue."""

reachys_brain/openai_realtime.py

@@ -13,7 +13,15 @@ from typing import Any, Callable, Optional
 import websockets
 from websockets.client import WebSocketClientProtocol
 
-from .routes.voice import get_current_voice, get_current_language, get_preferred_language
+from .routes.voice import (
+    get_current_voice,
+    get_current_language,
+    get_preferred_language,
+    get_vad_threshold,
+    get_vad_silence_ms,
+    get_vad_prefix_ms,
+    set_vad_settings_callback,
+)
 
 # Import app_tools lazily to avoid circular imports
 # (conversation.py imports from this module, and we import from app_tools)
@@ -51,10 +59,8 @@ logger = logging.getLogger(__name__)
 OPENAI_REALTIME_URL = "wss://api.openai.com/v1/realtime"
 OPENAI_MODEL = "gpt-4o-realtime-preview-2024-12-17"
 
-# Voice Activity Detection (VAD) settings
-VAD_THRESHOLD = 0.7  # Sensitivity: Higher = less sensitive (default 0.5)
-VAD_PREFIX_PADDING_MS = 300  # Audio padding before speech detection
-VAD_SILENCE_DURATION_MS = 700  # Silence duration before response (default 500)
+# Voice Activity Detection (VAD) settings are now configurable via VoiceSettings
+# Use get_vad_threshold(), get_vad_silence_ms(), get_vad_prefix_ms() to get current values
 
 
 class ConnectionState(str, Enum):
@@ -71,6 +77,18 @@ class SpeakingState(str, Enum):
     SPEAKING = "speaking"
 
 
+class ResponseState(str, Enum):
+    """AI response generation state.
+    
+    This tracks the full lifecycle of an AI response to ensure
+    microphone is properly paused during the entire response cycle.
+    """
+    IDLE = "idle"              # No response in progress
+    WAITING = "waiting"        # Request sent, waiting for response to start
+    GENERATING = "generating"  # AI is generating/streaming audio
+    COMPLETE = "complete"      # Response done, waiting for audio buffer to drain
+
+
 @dataclass
 class RealtimeEvent:
     """Event from OpenAI Realtime API to relay to iOS."""
@@ -93,6 +111,7 @@ class OpenAIRealtimeService:
         # State
         self._connection_state = ConnectionState.DISCONNECTED
         self._speaking_state = SpeakingState.IDLE
+        self._response_state = ResponseState.IDLE  # Track full response lifecycle
         self._is_listening = False
         self._current_transcript = ""
         self._response_text_buffer = ""
@@ -144,6 +163,7 @@ class OpenAIRealtimeService:
         # Callbacks for iOS relay
         self.on_connection_state: Optional[Callable[[ConnectionState], None]] = None
         self.on_speaking_state: Optional[Callable[[SpeakingState], None]] = None
+        self.on_response_state: Optional[Callable[[ResponseState], None]] = None  # Response lifecycle
         self.on_transcript_update: Optional[Callable[[str], None]] = None
         self.on_response_text: Optional[Callable[[str], None]] = None
         self.on_audio_delta: Optional[Callable[[bytes], None]] = None
@@ -166,6 +186,7 @@ class OpenAIRealtimeService:
         # Setup tools handler callbacks
         self._setup_tools_handler()
         self._setup_meeting_callbacks()
+        self._setup_vad_callback()
     
     @property
     def connection_state(self) -> ConnectionState:
@@ -177,6 +198,23 @@ class OpenAIRealtimeService:
         """Get current speaking state."""
         return self._speaking_state
     
+    @property
+    def response_state(self) -> ResponseState:
+        """Get current response state."""
+        return self._response_state
+    
+    @property
+    def is_responding(self) -> bool:
+        """Check if AI is currently responding (waiting, generating, or completing).
+        
+        When True, microphone should be paused to prevent VAD interruption.
+        """
+        return self._response_state in (
+            ResponseState.WAITING,
+            ResponseState.GENERATING,
+            ResponseState.COMPLETE,
+        )
+    
     @property
     def is_connected(self) -> bool:
         """Check if connected to OpenAI."""
@@ -438,6 +476,20 @@ Before using ANY tool, you MUST tell the user what you're about to do. This help
             on_transcript_update=on_transcript_update,
         )
     
+    def _setup_vad_callback(self) -> None:
+        """Setup callback for VAD settings changes.
+        
+        When user changes VAD settings via the app, this triggers
+        a session reconfiguration to apply the new settings.
+        """
+        def on_vad_changed() -> None:
+            """Called when VAD settings are changed."""
+            if self.is_connected:
+                logger.info("🎤 VAD settings changed, updating OpenAI session...")
+                asyncio.create_task(self._configure_session())
+        
+        set_vad_settings_callback(on_vad_changed)
+    
     def _append_to_meeting_transcript(self, text: str, speaker: str = "user") -> None:
         """Append transcribed text to active meeting if one exists.
         
@@ -470,6 +522,22 @@ Before using ANY tool, you MUST tell the user what you're about to do. This help
             if self.on_speaking_state:
                 self.on_speaking_state(state)
     
+    def _set_response_state(self, state: ResponseState) -> None:
+        """Update response state and notify callback.
+        
+        Response state tracks the full lifecycle of an AI response:
+        - IDLE: No response in progress, microphone can be active
+        - WAITING: Request sent, waiting for first audio - microphone should be paused
+        - GENERATING: Audio is being generated/streamed - microphone should be paused
+        - COMPLETE: Response done, waiting for buffer drain - microphone should be paused
+        """
+        if self._response_state != state:
+            old_state = self._response_state
+            self._response_state = state
+            logger.info(f"📊 Response state: {old_state.value} -> {state.value}")
+            if self.on_response_state:
+                self.on_response_state(state)
+    
     async def connect(self, api_key: Optional[str] = None) -> None:
         """Connect to OpenAI Realtime API.
         
@@ -554,9 +622,17 @@ Before using ANY tool, you MUST tell the user what you're about to do. This help
         # Sync language with preferred setting
         self._language = get_preferred_language()
         
+        # Get current VAD settings (user-configurable)
+        vad_threshold = get_vad_threshold()
+        vad_silence_ms = get_vad_silence_ms()
+        vad_prefix_ms = get_vad_prefix_ms()
+        
         # Get combined tools (base + dynamic based on app config)
         all_tools = self._get_all_tools()
-        logger.info(f"🔊 Configuring session with voice: {voice}, language: {self._language}")
+        logger.info(
+            f"🔊 Configuring session with voice: {voice}, language: {self._language}, "
+            f"VAD: threshold={vad_threshold}, silence={vad_silence_ms}ms"
+        )
         
         session_config = {
             "type": "session.update",
@@ -572,9 +648,9 @@ Before using ANY tool, you MUST tell the user what you're about to do. This help
                 },
                 "turn_detection": {
                     "type": "server_vad",
-                    "threshold": VAD_THRESHOLD,
-                    "prefix_padding_ms": VAD_PREFIX_PADDING_MS,
-                    "silence_duration_ms": VAD_SILENCE_DURATION_MS,
+                    "threshold": vad_threshold,
+                    "prefix_padding_ms": vad_prefix_ms,
+                    "silence_duration_ms": vad_silence_ms,
                 },
                 "tools": all_tools,
                 "tool_choice": "auto",
@@ -637,9 +713,17 @@ Before using ANY tool, you MUST tell the user what you're about to do. This help
                     self.on_session_updated()
             
             elif msg_type == "input_audio_buffer.speech_started":
-                # User started speaking
-                logger.info("🎤 Speech detected - user is speaking")
-                self._set_speaking_state(SpeakingState.IDLE)
+                # User started speaking - but ignore if AI is responding
+                # This prevents VAD from interrupting responses due to echo/noise
+                if self.is_responding:
+                    logger.warning(
+                        "🎤 VAD speech detected during AI response - ignoring "
+                        f"(response_state={self._response_state.value})"
+                    )
+                    # Don't change speaking state - let the response complete
+                else:
+                    logger.info("🎤 Speech detected - user is speaking")
+                    self._set_speaking_state(SpeakingState.IDLE)
             
             elif msg_type == "input_audio_buffer.speech_stopped":
                 # User stopped speaking
@@ -680,18 +764,26 @@ Before using ANY tool, you MUST tell the user what you're about to do. This help
                     if self._speaking_state != SpeakingState.SPEAKING:
                         self._set_speaking_state(SpeakingState.SPEAKING)
                     
+                    # Transition from WAITING to GENERATING on first audio
+                    if self._response_state == ResponseState.WAITING:
+                        self._set_response_state(ResponseState.GENERATING)
+                    
                     # Decode and forward audio
                     audio_data = base64.b64decode(audio_base64)
                     if self.on_audio_delta:
                         self.on_audio_delta(audio_data)
             
             elif msg_type == "response.audio.done":
-                # AI audio response complete
+                # AI audio response complete - set to COMPLETE (waiting for buffer drain)
                 self._set_speaking_state(SpeakingState.IDLE)
+                self._set_response_state(ResponseState.COMPLETE)
             
             elif msg_type == "response.done":
                 # Full response complete
                 self._set_speaking_state(SpeakingState.IDLE)
+                # Only set COMPLETE if we were generating (avoid duplicate transitions)
+                if self._response_state == ResponseState.GENERATING:
+                    self._set_response_state(ResponseState.COMPLETE)
                 if self._response_text_buffer:
                     if self.on_response_text:
                         self.on_response_text(self._response_text_buffer)
@@ -904,10 +996,18 @@ Before using ANY tool, you MUST tell the user what you're about to do. This help
         await self._send_message(message)
     
     async def commit_audio_and_respond(self) -> None:
-        """Commit the audio buffer and request a response."""
+        """Commit the audio buffer and request a response.
+        
+        Sets response state to WAITING before committing to ensure microphone
+        is paused before the AI starts responding.
+        """
         if not self.is_connected:
             return
         
+        # Set response state to WAITING before committing
+        # This triggers microphone pause BEFORE the request is sent
+        self._set_response_state(ResponseState.WAITING)
+        
         # Commit audio buffer
         await self._send_message({"type": "input_audio_buffer.commit"})
         
@@ -933,12 +1033,19 @@ Before using ANY tool, you MUST tell the user what you're about to do. This help
     async def send_text_message(self, text: str) -> None:
         """Send a text message (non-voice interaction).
         
+        Sets response state to WAITING before sending to ensure microphone
+        is paused before the AI starts responding.
+        
         Args:
             text: The text message to send.
         """
         if not self.is_connected:
             raise RuntimeError("Not connected to OpenAI")
         
+        # Set response state to WAITING before sending
+        # This triggers microphone pause BEFORE the request is sent
+        self._set_response_state(ResponseState.WAITING)
+        
         # Create conversation item
         item_message = {
             "type": "conversation.item.create",
@@ -971,6 +1078,15 @@ Before using ANY tool, you MUST tell the user what you're about to do. This help
         self._is_listening = False
         logger.info("Stopped listening")
     
+    def mark_response_complete(self) -> None:
+        """Mark the response cycle as complete (audio buffer drained).
+        
+        Called by conversation handler after audio has finished playing
+        and microphone can be safely resumed.
+        """
+        if self._response_state != ResponseState.IDLE:
+            self._set_response_state(ResponseState.IDLE)
+    
     def set_voice(self, voice_id: str) -> None:
         """Set the OpenAI voice and update the session.
         

reachys_brain/routes/audio_manager.py

@@ -105,11 +105,30 @@ async def delayed_resume_microphone() -> None:
     
     Waits for the audio buffer to drain before resuming capture
     to avoid picking up the AI's own speech.
+    
+    This uses a two-phase approach:
+    1. Wait the minimum delay time
+    2. Additionally wait until audio playback has actually stopped
     """
     services = get_services()
     
+    # Phase 1: Wait minimum delay
     await asyncio.sleep(ConversationTimings.MICROPHONE_RESUME_DELAY_SECONDS)
     
+    # Phase 2: Wait for audio to actually stop playing
+    # Check if audio player is still active and wait for it
+    if services.audio_player and services.audio_player.is_playing:
+        max_extra_wait = 5.0  # Maximum additional wait time
+        wait_interval = 0.2
+        waited = 0.0
+        
+        while services.audio_player.is_playing and waited < max_extra_wait:
+            await asyncio.sleep(wait_interval)
+            waited += wait_interval
+        
+        if waited > 0:
+            logger.info(f"⏳ Waited additional {waited:.1f}s for audio to finish")
+    
     if (services.audio_capture and 
         services.openai and 
         services.openai.is_listening):
@@ -120,12 +139,16 @@ async def delayed_resume_microphone() -> None:
             logger.info("🗑️ Cleared audio buffer before resume")
         
         # Brief pause to ensure buffer is cleared on OpenAI's side
-        await asyncio.sleep(0.1)
+        await asyncio.sleep(0.2)
+        
+        # Mark response cycle as complete (allows new responses)
+        if services.openai:
+            services.openai.mark_response_complete()
         
         services.audio_capture.resume_capture()
         logger.info(
             f"▶️ Resumed microphone (after "
-            f"{ConversationTimings.MICROPHONE_RESUME_DELAY_SECONDS}s delay)"
+            f"{ConversationTimings.MICROPHONE_RESUME_DELAY_SECONDS}s+ delay)"
         )
 
 

reachys_brain/routes/audio_stream_manager.py

@@ -19,7 +19,9 @@ class ConversationTimings:
     """Named constants for timing-related magic numbers."""
     
     # Microphone control
-    MICROPHONE_RESUME_DELAY_SECONDS = 2.5
+    # Increased from 2.5s to allow more time for audio buffer to drain
+    # This prevents echo/self-interruption where Reachy's voice is picked up
+    MICROPHONE_RESUME_DELAY_SECONDS = 3.5
     AUDIO_CHUNK_TIMEOUT_SECONDS = 0.1
     
     # Animation timings

reachys_brain/routes/conversation.py

@@ -15,7 +15,7 @@ from typing import Optional
 
 from fastapi import APIRouter, WebSocket, WebSocketDisconnect
 
-from ..openai_realtime import ConnectionState, SpeakingState
+from ..openai_realtime import ConnectionState, SpeakingState, ResponseState
 from ..tools.reminders import set_reminder_request_callback, handle_reminder_result
 from ..tools.contacts import set_contacts_request_callback, handle_contacts_result
 from ..tools.scheduled_messages import set_scheduled_message_callback, handle_scheduled_message_result
@@ -50,6 +50,86 @@ logger = logging.getLogger(__name__)
 
 router = APIRouter(tags=["Conversation"])
 
+
+async def send_greeting_and_start_streaming() -> None:
+    """Send greeting and start audio streaming after it completes.
+    
+    This ensures that:
+    1. No audio is sent to OpenAI during the welcome animation
+    2. The greeting plays completely without VAD interruption
+    3. Audio streaming only starts after greeting finishes
+    
+    Flow:
+    1. send_greeting() sends text -> ResponseState.WAITING
+    2. Audio arrives -> ResponseState.GENERATING
+    3. response.audio.done -> ResponseState.COMPLETE
+    4. We wait for COMPLETE (audio sent by OpenAI)
+    5. Wait for audio buffer to drain (audio played by speaker)
+    6. Start streaming and resume microphone
+    """
+    services = get_services()
+    
+    try:
+        # Send the greeting (this will set ResponseState.WAITING -> GENERATING -> COMPLETE)
+        await send_greeting()
+        
+        # Wait for the greeting response to be COMPLETE or IDLE
+        # COMPLETE = OpenAI finished sending audio
+        # IDLE = Response cycle fully complete
+        max_wait = 15.0  # Maximum wait for greeting
+        wait_interval = 0.2
+        waited = 0.0
+        
+        while waited < max_wait:
+            if services.openai:
+                state = services.openai.response_state
+                if state in (ResponseState.COMPLETE, ResponseState.IDLE):
+                    break
+            await asyncio.sleep(wait_interval)
+            waited += wait_interval
+        
+        if waited >= max_wait:
+            logger.warning("⚠️ Greeting response timeout - starting streaming anyway")
+        else:
+            logger.info(f"✅ Greeting response complete (waited {waited:.1f}s)")
+        
+        # Wait for audio to finish playing through speaker
+        if services.audio_player and services.audio_player.is_playing:
+            extra_wait = 0.0
+            max_extra = 8.0
+            while services.audio_player.is_playing and extra_wait < max_extra:
+                await asyncio.sleep(wait_interval)
+                extra_wait += wait_interval
+            if extra_wait > 0:
+                logger.info(f"⏳ Waited {extra_wait:.1f}s for greeting audio to finish")
+        
+        # Additional buffer drain time
+        await asyncio.sleep(ConversationTimings.MICROPHONE_RESUME_DELAY_SECONDS)
+        
+        # Now start audio streaming
+        if services.openai and services.openai.is_listening:
+            start_audio_streaming()
+            logger.info("✅ Audio streaming started after greeting")
+            
+            # Clear any buffered audio
+            await services.openai.clear_audio_buffer()
+            
+            # Mark response cycle as complete
+            services.openai.mark_response_complete()
+            
+            # Resume audio capture
+            if services.audio_capture:
+                services.audio_capture.resume_capture()
+                logger.info("▶️ Microphone resumed after greeting")
+        
+    except Exception as e:
+        logger.error(f"Error in greeting flow: {e}")
+        # Start streaming anyway to not leave the system in a broken state
+        if services.openai and services.openai.is_listening:
+            start_audio_streaming()
+            if services.audio_capture:
+                services.audio_capture.resume_capture()
+
 async def _reset_openai_session(keep_listening: bool) -> None:
     """Hard reset OpenAI session by disconnecting and reconnecting.
 
@@ -116,6 +196,7 @@ def init_services() -> None:
     wire_openai_callbacks(
         on_connection_state=_on_connection_state,
         on_speaking_state=_on_speaking_state,
+        on_response_state=_on_response_state,
         on_transcript_update=_on_transcript_update,
         on_response_text=_on_response_text,
         on_audio_delta=handle_audio_delta,
@@ -146,11 +227,16 @@ def init_services() -> None:
     logger.info("Conversation services initialized")
 
 
-def cleanup_services() -> None:
-    """Clean up conversation services."""
+async def cleanup_services() -> None:
+    """Clean up conversation services.
+    
+    This is async to properly await all cleanup operations and prevent
+    the app from hanging during shutdown.
+    """
     # Cancel all tracked tasks first
     cancel_all_tracked_tasks()
-    cleanup_conversation_services()
+    # Await the async cleanup
+    await cleanup_conversation_services()
 
 
 # MARK: - OpenAI Callbacks
@@ -205,6 +291,52 @@ def _on_speaking_state(state: SpeakingState) -> None:
     }))
 
 
+def _on_response_state(state: ResponseState) -> None:
+    """Handle OpenAI response lifecycle state changes.
+    
+    This is the key callback for preventing audio cutoff:
+    - WAITING: Request sent, pause microphone immediately
+    - GENERATING: Audio being received, mic stays paused
+    - COMPLETE: Audio done, wait for buffer drain then resume
+    - IDLE: Buffer drained, mic can be active
+    """
+    services = get_services()
+    conv_state = get_state()
+    
+    if state == ResponseState.WAITING:
+        # Immediately pause microphone when a request is sent
+        # This prevents VAD from detecting noise/echo before response starts
+        if services.audio_capture:
+            services.audio_capture.pause_capture()
+            logger.info("⏸️ Paused microphone (waiting for AI response)")
+        
+        # Clear OpenAI's audio buffer to prevent any buffered audio
+        if services.openai:
+            create_tracked_task(services.openai.clear_audio_buffer())
+    
+    elif state == ResponseState.GENERATING:
+        # Audio is being generated - ensure mic stays paused
+        if services.audio_capture and not services.audio_capture.is_paused:
+            services.audio_capture.pause_capture()
+            logger.info("⏸️ Paused microphone (AI generating audio)")
+    
+    elif state == ResponseState.COMPLETE:
+        # Response complete - schedule microphone resume after buffer drains
+        # The actual resume happens via delayed_resume_microphone
+        logger.info("📊 Response complete - waiting for audio buffer to drain")
+    
+    elif state == ResponseState.IDLE:
+        # Response cycle complete - microphone can be resumed
+        # This is called after buffer has drained
+        logger.info("📊 Response cycle idle - microphone can resume")
+    
+    # Broadcast state change to iOS
+    create_tracked_task(broadcast({
+        "type": "response_state",
+        "state": state.value,
+    }))
+
+
 def _is_stop_command(transcript: str, language: str = "en") -> bool:
     """Check if the transcript is a stop command."""
     text = transcript.strip().lower()
@@ -815,14 +947,23 @@ async def _handle_start_listening(websocket: WebSocket) -> None:
     services.openai.start_listening()
     logger.info("✅ OpenAI listening mode enabled")
     
-    start_audio_streaming()
+    # IMPORTANT: Do NOT start audio streaming here!
+    # Audio streaming will be started AFTER the greeting completes.
+    # This prevents motor noise from the welcome animation and ambient
+    # noise from triggering VAD and interrupting the greeting.
+    
+    # Pause audio capture immediately - it will be resumed after greeting
+    if services.audio_capture:
+        services.audio_capture.pause_capture()
+        logger.info("⏸️ Audio capture paused until greeting completes")
     
     await websocket.send_json({
         "type": "listening_state",
         "listening": True,
     })
     
-    create_tracked_task(send_greeting())
+    # Send greeting - audio streaming will start after it completes
+    create_tracked_task(send_greeting_and_start_streaming())
 
 
 async def _handle_stop_listening(websocket: WebSocket) -> None:
@@ -857,22 +998,34 @@ async def _handle_stop_listening(websocket: WebSocket) -> None:
             wait_interval = 0.2
             waited = 0.0
             
-            # Wait for speech to start
+            # Wait for speech to start generating
             await asyncio.sleep(0.5)
             
-            # Wait for speech to finish
+            # Wait for AI response to complete
             while waited < max_wait:
-                if services.tts and services.tts.is_speaking:
-                    # Speech is ongoing, keep waiting
-                    await asyncio.sleep(wait_interval)
-                    waited += wait_interval
-                elif waited > 1.0:
-                    # Speech has finished (or never started after initial delay)
-                    break
+                if services.openai:
+                    response_state = services.openai.response_state
+                    if response_state in (ResponseState.WAITING, ResponseState.GENERATING):
+                        # Response is ongoing, keep waiting
+                        await asyncio.sleep(wait_interval)
+                        waited += wait_interval
+                    elif waited > 1.0:
+                        # Response has finished (or never started after initial delay)
+                        break
+                    else:
+                        # Give it a moment to start
+                        await asyncio.sleep(wait_interval)
+                        waited += wait_interval
                 else:
-                    # Give it a moment to start
+                    break
+            
+            # Also wait for audio playback to finish
+            if services.audio_player and services.audio_player.is_playing:
+                extra_wait = 0.0
+                max_extra = 5.0
+                while services.audio_player.is_playing and extra_wait < max_extra:
                     await asyncio.sleep(wait_interval)
-                    waited += wait_interval
+                    extra_wait += wait_interval
             
         except Exception as e:
             logger.error(f"Error in goodbye sequence: {e}")

reachys_brain/routes/conversation_services.py

@@ -40,6 +40,7 @@ class ConversationServices:
     # Callbacks for wiring up event handlers
     on_connection_state: Optional[Callable] = None
     on_speaking_state: Optional[Callable] = None
+    on_response_state: Optional[Callable] = None  # Response lifecycle state
     on_transcript_update: Optional[Callable] = None
     on_response_text: Optional[Callable] = None
     on_audio_delta: Optional[Callable] = None
@@ -149,32 +150,70 @@ def init_services() -> ConversationServices:
     return services
 
 
-def cleanup_services() -> None:
-    """Clean up all conversation services."""
+async def cleanup_services() -> None:
+    """Clean up all conversation services.
+    
+    This is async to properly await all cleanup operations and prevent
+    the app from hanging during shutdown.
+    """
     services = get_services()
     state = get_state()
     
+    logger.info("Starting conversation services cleanup...")
+    
     # Cancel audio streaming task
     if state.audio_stream_task:
         state.audio_stream_task.cancel()
+        try:
+            await asyncio.wait_for(
+                asyncio.shield(state.audio_stream_task),
+                timeout=1.0
+            )
+        except (asyncio.CancelledError, asyncio.TimeoutError):
+            pass
         state.audio_stream_task = None
     
+    # Disconnect OpenAI WebSocket (critical - was missing!)
+    if services.openai:
+        try:
+            await asyncio.wait_for(services.openai.disconnect(), timeout=2.0)
+        except asyncio.TimeoutError:
+            logger.warning("OpenAI disconnect timed out")
+        except Exception as e:
+            logger.warning(f"Error disconnecting OpenAI: {e}")
+    
+    # Stop speaking gestures with timeout
+    if services.speaking_gestures:
+        try:
+            await asyncio.wait_for(services.speaking_gestures.close(), timeout=1.0)
+        except asyncio.TimeoutError:
+            logger.warning("Speaking gestures close timed out")
+        except Exception as e:
+            logger.warning(f"Error closing speaking gestures: {e}")
+    
+    # Close motion service
+    if services.motion:
+        try:
+            await asyncio.wait_for(services.motion.close(), timeout=1.0)
+        except asyncio.TimeoutError:
+            logger.warning("Motion service close timed out")
+        except Exception as e:
+            logger.warning(f"Error closing motion service: {e}")
+    
+    # Synchronous cleanup (these don't block)
     if services.audio_capture:
         services.audio_capture.cleanup()
     
     if services.audio_player:
         services.audio_player.cleanup()
     
-    # Stop speaking gestures if running
-    if services.speaking_gestures:
-        asyncio.create_task(services.speaking_gestures.close())
-    
     logger.info("Conversation services cleaned up")
 
 
 def wire_openai_callbacks(
     on_connection_state: Callable,
     on_speaking_state: Callable,
+    on_response_state: Callable,
     on_transcript_update: Callable,
     on_response_text: Callable,
     on_audio_delta: Callable,
@@ -188,6 +227,7 @@ def wire_openai_callbacks(
     Args:
         on_connection_state: Handler for connection state changes.
         on_speaking_state: Handler for speaking state changes.
+        on_response_state: Handler for response lifecycle state changes.
         on_transcript_update: Handler for transcript updates.
         on_response_text: Handler for response text.
         on_audio_delta: Handler for audio data.
@@ -203,6 +243,7 @@ def wire_openai_callbacks(
     
     services.openai.on_connection_state = on_connection_state
     services.openai.on_speaking_state = on_speaking_state
+    services.openai.on_response_state = on_response_state
     services.openai.on_transcript_update = on_transcript_update
     services.openai.on_response_text = on_response_text
     services.openai.on_audio_delta = on_audio_delta

reachys_brain/routes/games/helpers.py

@@ -4,6 +4,7 @@ import asyncio
 import logging
 import math
 import random
+import shutil
 from typing import Optional
 
 import httpx
@@ -50,6 +51,7 @@ async def speak_and_animate(text: str, reaction: str):
     try:
         from ...tts_service import get_tts_service
         from ...animation_coordinator import get_animation_coordinator
+        from ...audio_playback import is_kids_mode_enabled
         
         # Map reactions to animations
         animation_map = {
@@ -77,8 +79,15 @@ async def speak_and_animate(text: str, reaction: str):
         tts = get_tts_service()
         if tts:
             logger.info(f"🎭 Speaking text via TTS...")
+            # Kids mode is implemented via Sox pitch shifting on the robot.
+            # If Sox isn't available, fall back to a kid-friendlier base voice for games
+            # so TamaReachy still sounds "with kids" when kids mode is enabled.
+            voice_override = None
+            if is_kids_mode_enabled() and shutil.which("sox") is None:
+                voice_override = "shimmer"
+                logger.info("🧒 Kids mode enabled but sox not found; using kid-friendly fallback voice for games (shimmer)")
             # Use speak_async for non-blocking speech
-            tts.speak_async(text)
+            tts.speak_async(text, voice_override=voice_override)
             logger.info(f"🎭 TTS started (async)")
         else:
             logger.warning("🎭 No TTS service available")

reachys_brain/routes/games/models.py

@@ -188,3 +188,12 @@ class TamaReachyCheckResponse(BaseModel):
     reaction: Optional[str] = None
     error: Optional[str] = None
 
+
+class TamaReachyIdleMessageResponse(BaseModel):
+    """Response with a random idle message from TamaReachy."""
+    success: bool
+    message_type: str = "idle"  # idle, fun_fact, motivational
+    message: Optional[str] = None
+    reaction: Optional[str] = None
+    error: Optional[str] = None
+

reachys_brain/routes/games/tamareachy.py

@@ -16,6 +16,7 @@ from .models import (
     TamaReachyCareRequest,
     TamaReachyCareResponse,
     TamaReachyCheckResponse,
+    TamaReachyIdleMessageResponse,
 )
 from .helpers import speak_and_animate
 from .tamareachy_monitor import get_tamareachy_monitor
@@ -63,8 +64,8 @@ async def enable_tamareachy(request: TamaReachyEnableRequest):
         stats = _make_stats(state)
         mood = engine.get_mood(stats.model_dump())
 
-        # Welcome message
-        commentary = f"Yay! TamaReachy is activated! {mood['emoji']} Take good care of me!"
+        # Welcome message (multilingual)
+        commentary = engine.get_system_message("enable_welcome", emoji=mood['emoji'])
 
         await speak_and_animate(commentary, "excited")
 
@@ -90,6 +91,7 @@ async def disable_tamareachy():
     """Disable the TamaReachy game."""
     try:
         db = get_database()
+        engine = get_tamareachy_engine()
 
         await db.update_tamareachy_state({"enabled": False})
 
@@ -97,17 +99,15 @@ async def disable_tamareachy():
         monitor = get_tamareachy_monitor()
         await monitor.stop()
 
-        # Sad goodbye message
-        await speak_and_animate(
-            "Goodbye for now... I'll miss you! 😢",
-            "sad"
-        )
+        # Sad goodbye message (multilingual)
+        goodbye_message = engine.get_system_message("disable_goodbye")
+        await speak_and_animate(goodbye_message, "sad")
 
         logger.info("🐣 TamaReachy disabled")
 
         return TamaReachyDisableResponse(
             success=True,
-            message="TamaReachy has been disabled. Enable it anytime to resume!",
+            message=engine.get_system_message("disable_message"),
         )
     except Exception as e:
         logger.error(f"Failed to disable TamaReachy: {e}")
@@ -127,7 +127,7 @@ async def get_tamareachy_status():
             return TamaReachyStatusResponse(
                 success=True,
                 enabled=False,
-                commentary="TamaReachy is sleeping. Enable me to play!",
+                commentary=engine.get_system_message("status_sleeping"),
             )
 
         # Apply decay based on time elapsed
@@ -158,11 +158,15 @@ async def get_tamareachy_status():
         mood = engine.get_mood(decayed_stats)
         critical_need = engine.get_critical_need(decayed_stats)
 
-        # Generate status commentary
+        # Generate status commentary (multilingual)
         if critical_need:
             commentary = engine.get_request_message(critical_need)
         else:
-            commentary = f"I'm feeling {mood['name']}! {mood['emoji']}"
+            # Use translated mood name in status message
+            translated_mood = mood.get("translated_name", mood["name"])
+            commentary = engine.get_system_message(
+                "status_mood", mood=translated_mood, emoji=mood['emoji']
+            )
 
         return TamaReachyStatusResponse(
             success=True,
@@ -342,3 +346,67 @@ async def get_monitor_status():
         "check_interval_seconds": 5 * 60,
     }
 
+
+@router.get("/idle-message", response_model=TamaReachyIdleMessageResponse)
+async def get_idle_message():
+    """Get a random idle message from TamaReachy.
+    
+    This endpoint provides fun, spontaneous messages that TamaReachy can
+    share with the user, including fun facts and motivational quotes.
+    """
+    try:
+        db = get_database()
+        engine = get_tamareachy_engine()
+
+        state = await db.get_tamareachy_state()
+
+        if not state.get("enabled"):
+            return TamaReachyIdleMessageResponse(
+                success=False,
+                error="TamaReachy is not enabled!",
+            )
+
+        # Get current stats to determine message type
+        stats_dict = {
+            "hunger": state.get("hunger", 100),
+            "thirst": state.get("thirst", 100),
+            "happiness": state.get("happiness", 100),
+            "energy": state.get("energy", 100),
+            "boredom": state.get("boredom", 100),
+            "social": state.get("social", 100),
+            "health": state.get("health", 100),
+            "cleanliness": state.get("cleanliness", 100),
+        }
+
+        mood = engine.get_mood(stats_dict)
+        average = sum(stats_dict.values()) / len(stats_dict)
+
+        # Get a message based on mood
+        message = engine.get_random_communication(average)
+
+        # Determine message type for the UI
+        if "Did you know" in message or "Fun fact" in message:
+            msg_type = "fun_fact"
+            reaction = "happy"
+        elif any(word in message.lower() for word in ["believe", "proud", "capable", "stronger"]):
+            msg_type = "motivational"
+            reaction = "happy"
+        else:
+            msg_type = "idle"
+            reaction = mood.get("animation", "attention")
+
+        # Optionally trigger speech
+        await speak_and_animate(message, reaction)
+
+        logger.info(f"🐣 TamaReachy idle message: {msg_type}")
+
+        return TamaReachyIdleMessageResponse(
+            success=True,
+            message_type=msg_type,
+            message=message,
+            reaction=reaction,
+        )
+    except Exception as e:
+        logger.error(f"TamaReachy idle message failed: {e}")
+        return TamaReachyIdleMessageResponse(success=False, error=str(e))
+

reachys_brain/routes/openai_config.py

@@ -7,10 +7,35 @@ from typing import Optional
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 
+from ..database import get_database
+
 logger = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/openai", tags=["OpenAI"])
 
+# Database key for persisting API key
+OPENAI_API_KEY_DB_KEY = "openai_api_key"
+
+
+async def init_openai_api_key() -> None:
+    """Load OpenAI API key from database on startup.
+    
+    Called during app initialization to restore the API key from
+    persistent storage.
+    """
+    try:
+        db = get_database()
+        api_key = await db.get_user_setting(OPENAI_API_KEY_DB_KEY)
+        
+        if api_key and api_key.startswith("sk-"):
+            os.environ["OPENAI_API_KEY"] = api_key
+            masked = api_key[:8] + "..." + api_key[-4:] if len(api_key) > 12 else "***"
+            logger.info(f"🔑 Loaded OpenAI API key from database: {masked}")
+        else:
+            logger.info("🔑 No OpenAI API key found in database")
+    except Exception as e:
+        logger.warning(f"Failed to load API key from database: {e}")
+
 
 class APIKeyRequest(BaseModel):
     """Request model for setting API key."""
@@ -72,8 +97,8 @@ async def get_api_key_status() -> APIKeyResponse:
 async def set_api_key(request: APIKeyRequest) -> APIKeyResponse:
     """Set the OpenAI API key.
     
-    The key is stored in the environment variable for the current session.
-    For persistent storage, add it to the system environment.
+    The key is stored in the environment variable and persisted to the database
+    so it survives restarts.
     """
     if not request.api_key:
         raise HTTPException(status_code=400, detail="API key cannot be empty")
@@ -84,7 +109,14 @@ async def set_api_key(request: APIKeyRequest) -> APIKeyResponse:
     # Store in environment
     os.environ["OPENAI_API_KEY"] = request.api_key
     
-    logger.info("OpenAI API key configured")
+    # Persist to database for survival across restarts
+    try:
+        db = get_database()
+        await db.set_user_setting(OPENAI_API_KEY_DB_KEY, request.api_key)
+        logger.info("OpenAI API key configured and persisted")
+    except Exception as e:
+        logger.warning(f"Failed to persist API key to database: {e}")
+        logger.info("OpenAI API key configured (not persisted)")
     
     # Mask the key for the response
     masked = request.api_key[:8] + "..." + request.api_key[-4:]

reachys_brain/routes/power.py

@@ -209,8 +209,9 @@ async def reflash_motors() -> ReflashMotorsResponse:
     
     This will:
     1. Stop the daemon backend
-    2. Run reachy-mini-reflash-motors to reset all motor configurations
-    3. Start the daemon backend again
+    2. Wait for serial port to be released
+    3. Run reachy-mini-reflash-motors with retries
+    4. Start the daemon backend again
     
     Use this when motors are not responding or have incorrect settings.
     """
@@ -231,51 +232,93 @@ async def reflash_motors() -> ReflashMotorsResponse:
     except Exception as e:
         logger.warning(f"Error stopping daemon: {e}")
     
-    # Wait for daemon to fully stop
-    await asyncio.sleep(2)
+    # Wait longer for daemon to fully stop and release serial port
+    # This helps prevent "No motor found" errors due to port still being held
+    logger.info("Waiting for serial port to be released...")
+    await asyncio.sleep(5)
     
-    # Step 2: Run the reflash motors command
-    try:
-        # Run the reflash command
-        result = await asyncio.get_event_loop().run_in_executor(
-            None,
-            lambda: subprocess.run(
-                ["/venvs/mini_daemon/bin/reachy-mini-reflash-motors", 
-                 "--serialport", "/dev/ttyAMA3"],
-                capture_output=True,
-                text=True,
-                timeout=60
+    # Step 2: Run the reflash motors command with retries
+    max_attempts = 3
+    last_error = None
+    output = ""
+    motors_found = 0
+    config_correct = 0
+    
+    for attempt in range(1, max_attempts + 1):
+        try:
+            logger.info(f"Reflash attempt {attempt}/{max_attempts}...")
+            
+            # Run the reflash command
+            result = await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: subprocess.run(
+                    ["/venvs/mini_daemon/bin/reachy-mini-reflash-motors", 
+                     "--serialport", "/dev/ttyAMA3"],
+                    capture_output=True,
+                    text=True,
+                    timeout=60
+                )
             )
-        )
-        
-        output = result.stdout + result.stderr
-        logger.info(f"Reflash output: {output}")
-        
-        # Count successful motors from output
-        motors_found = output.count("Found motor with ID")
-        config_correct = output.count("Configuration is correct")
-        
-        if result.returncode != 0:
-            logger.error(f"Reflash command failed with code {result.returncode}")
+            
+            output = result.stdout + result.stderr
+            logger.info(f"Reflash attempt {attempt} output: {output}")
+            
+            # Count successful motors from output
+            motors_found = output.count("Found motor with ID")
+            config_correct = output.count("Configuration is correct")
+            
+            # Check for "No motor found" error
+            if "No motor found" in output:
+                last_error = "No motor found on port"
+                logger.warning(f"Attempt {attempt}: No motor found, will retry...")
+                if attempt < max_attempts:
+                    # Wait before retry - port might still be busy
+                    await asyncio.sleep(3)
+                    continue
+            
+            if result.returncode == 0 and motors_found > 0:
+                logger.info(f"Reflash successful on attempt {attempt}: {motors_found} motors found")
+                break
+            elif result.returncode != 0:
+                last_error = output[-500:] if len(output) > 500 else output
+                logger.warning(f"Attempt {attempt} failed with code {result.returncode}")
+                if attempt < max_attempts:
+                    await asyncio.sleep(3)
+                    continue
+                    
+        except subprocess.TimeoutExpired:
+            last_error = "Command timed out"
+            logger.warning(f"Attempt {attempt}: Reflash command timed out")
+            if attempt < max_attempts:
+                await asyncio.sleep(2)
+                continue
+        except FileNotFoundError:
+            logger.error("Reflash command not found")
             raise HTTPException(
                 status_code=500,
-                detail=f"Reflash failed: {output[-500:] if len(output) > 500 else output}"
+                detail="reachy-mini-reflash-motors command not found"
             )
-        
-        logger.info(f"Reflash complete: {motors_found} motors found, {config_correct} configured")
-        
-    except subprocess.TimeoutExpired:
-        logger.error("Reflash command timed out")
-        raise HTTPException(status_code=504, detail="Motor reflash timed out after 60 seconds")
-    except FileNotFoundError:
-        logger.error("Reflash command not found")
-        raise HTTPException(
-            status_code=500,
-            detail="reachy-mini-reflash-motors command not found"
+        except Exception as e:
+            last_error = str(e)
+            logger.warning(f"Attempt {attempt}: Error during reflash: {e}")
+            if attempt < max_attempts:
+                await asyncio.sleep(2)
+                continue
+    
+    # Check if all attempts failed
+    if motors_found == 0:
+        error_detail = (
+            f"Could not find motors after {max_attempts} attempts. "
+            "Please check:\n"
+            "1. Motor cables are securely connected\n"
+            "2. Motors are powered on\n"
+            "3. Try unplugging and replugging the motor cables\n"
+            f"Last error: {last_error}"
         )
-    except Exception as e:
-        logger.error(f"Error during reflash: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        logger.error(f"All reflash attempts failed: {last_error}")
+        raise HTTPException(status_code=500, detail=error_detail)
+    
+    logger.info(f"Reflash complete: {motors_found} motors found, {config_correct} configured")
     
     # Step 3: Start the daemon backend again
     try:

reachys_brain/routes/voice.py

@@ -12,7 +12,7 @@ from fastapi import APIRouter, HTTPException
 import httpx
 
 from ..models import Voice, VoiceRequest, VoiceResponse, VoicesListResponse
-from ..audio_playback import is_kids_mode_enabled, set_kids_mode
+from ..audio_playback import is_kids_mode_enabled, set_kids_mode, KIDS_MODE_PITCH_CENTS, KIDS_MODE_TEMPO
 
 logger = logging.getLogger(__name__)
 
@@ -23,6 +23,53 @@ VOICE_ID_KEY = "voice_id"
 PREFERRED_LANGUAGE_KEY = "preferred_language"
 KIDS_MODE_KEY = "kids_mode_enabled"
 
+# Database keys for VAD (Voice Activity Detection) settings
+VAD_THRESHOLD_KEY = "vad_threshold"
+VAD_SILENCE_MS_KEY = "vad_silence_ms"
+VAD_PREFIX_MS_KEY = "vad_prefix_ms"
+
+# Default VAD values
+# Increased threshold to reduce sensitivity to background noise and echo
+DEFAULT_VAD_THRESHOLD = 0.8  # 0.0-1.0, higher = less sensitive (increased from 0.7)
+DEFAULT_VAD_SILENCE_MS = 800  # Silence duration before responding (ms) (increased from 700)
+DEFAULT_VAD_PREFIX_MS = 300  # Audio padding before speech detection (ms)
+
+# VAD Presets for different environments
+VAD_PRESETS = {
+    "quiet_room": {
+        "id": "quiet_room",
+        "name": "Quiet Room",
+        "description": "More sensitive, responds faster. Best for quiet environments.",
+        "threshold": 0.5,
+        "silence_ms": 500,
+        "prefix_ms": 300,
+    },
+    "normal": {
+        "id": "normal",
+        "name": "Normal",
+        "description": "Balanced settings for typical use.",
+        "threshold": 0.8,
+        "silence_ms": 800,
+        "prefix_ms": 300,
+    },
+    "noisy": {
+        "id": "noisy",
+        "name": "Noisy Environment",
+        "description": "Less sensitive, ignores background noise better.",
+        "threshold": 0.85,
+        "silence_ms": 1000,
+        "prefix_ms": 400,
+    },
+    "conference": {
+        "id": "conference",
+        "name": "Conference Room",
+        "description": "Very strict, ignores most background voices.",
+        "threshold": 0.9,
+        "silence_ms": 1200,
+        "prefix_ms": 500,
+    },
+}
+
 # OpenAI TTS API endpoint
 OPENAI_TTS_URL = "https://api.openai.com/v1/audio/speech"
 
@@ -94,6 +141,14 @@ class VoiceSettings:
         self._current_language: str = "en"
         self._preferred_language: str = "en"
         self._initialized: bool = False
+        
+        # VAD settings
+        self._vad_threshold: float = DEFAULT_VAD_THRESHOLD
+        self._vad_silence_ms: int = DEFAULT_VAD_SILENCE_MS
+        self._vad_prefix_ms: int = DEFAULT_VAD_PREFIX_MS
+        
+        # Callback for VAD settings changes (set by OpenAIRealtimeService)
+        self.on_vad_settings_changed: Optional[callable] = None
     
     @property
     def current_voice(self) -> str:
@@ -112,6 +167,21 @@ class VoiceSettings:
         """Check if kids mode (pitch shifting) is enabled."""
         return is_kids_mode_enabled()
     
+    @property
+    def vad_threshold(self) -> float:
+        """Get the VAD threshold (0.0-1.0, higher = less sensitive)."""
+        return self._vad_threshold
+    
+    @property
+    def vad_silence_ms(self) -> int:
+        """Get the VAD silence duration in milliseconds."""
+        return self._vad_silence_ms
+    
+    @property
+    def vad_prefix_ms(self) -> int:
+        """Get the VAD prefix padding in milliseconds."""
+        return self._vad_prefix_ms
+    
     def set_voice(self, voice_id: str) -> bool:
         """Set the current OpenAI voice. Returns True if successful."""
         valid_ids = [v["id"] for v in OPENAI_VOICES]
@@ -147,6 +217,121 @@ class VoiceSettings:
         # Persist to database in background
         self._persist_setting(KIDS_MODE_KEY, str(enabled).lower())
     
+    def set_vad_threshold(self, threshold: float) -> bool:
+        """Set the VAD threshold (0.0-1.0, higher = less sensitive).
+        
+        Returns True if successful.
+        """
+        if not 0.0 <= threshold <= 1.0:
+            return False
+        self._vad_threshold = threshold
+        logger.info(f"🎤 VAD threshold set to: {threshold}")
+        self._persist_setting(VAD_THRESHOLD_KEY, str(threshold))
+        self._notify_vad_change()
+        return True
+    
+    def set_vad_silence_ms(self, silence_ms: int) -> bool:
+        """Set the VAD silence duration in milliseconds (200-3000).
+        
+        Returns True if successful.
+        """
+        if not 200 <= silence_ms <= 3000:
+            return False
+        self._vad_silence_ms = silence_ms
+        logger.info(f"🎤 VAD silence duration set to: {silence_ms}ms")
+        self._persist_setting(VAD_SILENCE_MS_KEY, str(silence_ms))
+        self._notify_vad_change()
+        return True
+    
+    def set_vad_prefix_ms(self, prefix_ms: int) -> bool:
+        """Set the VAD prefix padding in milliseconds (100-1000).
+        
+        Returns True if successful.
+        """
+        if not 100 <= prefix_ms <= 1000:
+            return False
+        self._vad_prefix_ms = prefix_ms
+        logger.info(f"🎤 VAD prefix padding set to: {prefix_ms}ms")
+        self._persist_setting(VAD_PREFIX_MS_KEY, str(prefix_ms))
+        self._notify_vad_change()
+        return True
+    
+    def set_vad_settings(
+        self,
+        threshold: Optional[float] = None,
+        silence_ms: Optional[int] = None,
+        prefix_ms: Optional[int] = None,
+    ) -> bool:
+        """Set multiple VAD settings at once.
+        
+        Only provided values are updated. Returns True if all valid.
+        """
+        success = True
+        changed = False
+        
+        if threshold is not None:
+            if 0.0 <= threshold <= 1.0:
+                self._vad_threshold = threshold
+                self._persist_setting(VAD_THRESHOLD_KEY, str(threshold))
+                changed = True
+            else:
+                success = False
+        
+        if silence_ms is not None:
+            if 200 <= silence_ms <= 3000:
+                self._vad_silence_ms = silence_ms
+                self._persist_setting(VAD_SILENCE_MS_KEY, str(silence_ms))
+                changed = True
+            else:
+                success = False
+        
+        if prefix_ms is not None:
+            if 100 <= prefix_ms <= 1000:
+                self._vad_prefix_ms = prefix_ms
+                self._persist_setting(VAD_PREFIX_MS_KEY, str(prefix_ms))
+                changed = True
+            else:
+                success = False
+        
+        if changed:
+            logger.info(
+                f"🎤 VAD settings updated: threshold={self._vad_threshold}, "
+                f"silence={self._vad_silence_ms}ms, prefix={self._vad_prefix_ms}ms"
+            )
+            self._notify_vad_change()
+        
+        return success
+    
+    def apply_vad_preset(self, preset_id: str) -> bool:
+        """Apply a VAD preset by ID.
+        
+        Available presets: quiet_room, normal, noisy, conference
+        """
+        preset = VAD_PRESETS.get(preset_id)
+        if not preset:
+            return False
+        
+        self._vad_threshold = preset["threshold"]
+        self._vad_silence_ms = preset["silence_ms"]
+        self._vad_prefix_ms = preset["prefix_ms"]
+        
+        # Persist all settings
+        self._persist_setting(VAD_THRESHOLD_KEY, str(preset["threshold"]))
+        self._persist_setting(VAD_SILENCE_MS_KEY, str(preset["silence_ms"]))
+        self._persist_setting(VAD_PREFIX_MS_KEY, str(preset["prefix_ms"]))
+        
+        logger.info(f"🎤 Applied VAD preset: {preset['name']}")
+        self._notify_vad_change()
+        return True
+    
+    def _notify_vad_change(self) -> None:
+        """Notify listeners that VAD settings have changed."""
+        if self.on_vad_settings_changed:
+            try:
+                self.on_vad_settings_changed()
+            except Exception as e:
+                logger.error(f"Error in VAD change callback: {e}")
+    
     def _persist_setting(self, key: str, value: str) -> None:
         """Persist a setting to the database in a background task."""
         try:
@@ -205,6 +390,37 @@ async def init_voice_settings() -> None:
             set_kids_mode(kids_mode_enabled)
             logger.info(f"🧒 Loaded kids mode from database: {kids_mode_enabled}")
         
+        # Load VAD settings
+        vad_threshold = await db.get_user_setting(VAD_THRESHOLD_KEY)
+        if vad_threshold:
+            try:
+                threshold = float(vad_threshold)
+                if 0.0 <= threshold <= 1.0:
+                    _voice_settings._vad_threshold = threshold
+                    logger.info(f"🎤 Loaded VAD threshold from database: {threshold}")
+            except ValueError:
+                pass
+        
+        vad_silence = await db.get_user_setting(VAD_SILENCE_MS_KEY)
+        if vad_silence:
+            try:
+                silence_ms = int(vad_silence)
+                if 200 <= silence_ms <= 3000:
+                    _voice_settings._vad_silence_ms = silence_ms
+                    logger.info(f"🎤 Loaded VAD silence duration from database: {silence_ms}ms")
+            except ValueError:
+                pass
+        
+        vad_prefix = await db.get_user_setting(VAD_PREFIX_MS_KEY)
+        if vad_prefix:
+            try:
+                prefix_ms = int(vad_prefix)
+                if 100 <= prefix_ms <= 1000:
+                    _voice_settings._vad_prefix_ms = prefix_ms
+                    logger.info(f"🎤 Loaded VAD prefix from database: {prefix_ms}ms")
+            except ValueError:
+                pass
+        
         _voice_settings._initialized = True
         logger.info("✅ Voice settings initialized from database")
         
@@ -275,6 +491,40 @@ def set_preferred_language(language: str) -> bool:
     return _voice_settings.set_preferred_language(language)
 
 
+# MARK: - VAD Settings Public API Functions
+
+def get_vad_threshold() -> float:
+    """Get the current VAD threshold."""
+    return _voice_settings.vad_threshold
+
+
+def get_vad_silence_ms() -> int:
+    """Get the current VAD silence duration in ms."""
+    return _voice_settings.vad_silence_ms
+
+
+def get_vad_prefix_ms() -> int:
+    """Get the current VAD prefix padding in ms."""
+    return _voice_settings.vad_prefix_ms
+
+
+def get_vad_settings() -> dict:
+    """Get all VAD settings as a dictionary."""
+    return {
+        "threshold": _voice_settings.vad_threshold,
+        "silence_ms": _voice_settings.vad_silence_ms,
+        "prefix_ms": _voice_settings.vad_prefix_ms,
+    }
+
+
+def set_vad_settings_callback(callback: callable) -> None:
+    """Set the callback for VAD settings changes.
+    
+    Called when VAD settings are updated so OpenAI session can be reconfigured.
+    """
+    _voice_settings.on_vad_settings_changed = callback
+
+
 @router.get("/voices", response_model=VoicesListResponse)
 async def get_voices() -> VoicesListResponse:
     """Get available OpenAI Realtime voices and current selection.
@@ -453,6 +703,122 @@ async def set_kids_mode_endpoint(enabled: bool = False) -> dict:
     }
 
 
+# MARK: - VAD Settings Endpoints
+
+@router.get("/voice/vad-settings")
+async def get_vad_settings_endpoint() -> dict:
+    """Get the current VAD (Voice Activity Detection) settings.
+    
+    VAD settings control how Reachy detects when you're speaking:
+    - threshold: Sensitivity (0.0-1.0, higher = less sensitive to background noise)
+    - silence_ms: How long to wait after you stop speaking before responding
+    - prefix_ms: How much audio to buffer before speech is detected
+    
+    Returns:
+        Current VAD settings and available presets.
+    """
+    return {
+        "threshold": _voice_settings.vad_threshold,
+        "silence_ms": _voice_settings.vad_silence_ms,
+        "prefix_ms": _voice_settings.vad_prefix_ms,
+        "presets": list(VAD_PRESETS.values()),
+    }
+
+
+@router.post("/voice/vad-settings")
+async def set_vad_settings_endpoint(
+    threshold: Optional[float] = None,
+    silence_ms: Optional[int] = None,
+    prefix_ms: Optional[int] = None,
+) -> dict:
+    """Update VAD (Voice Activity Detection) settings.
+    
+    Adjust these settings to help Reachy work better in different environments:
+    
+    - In quiet rooms: Use lower threshold (0.5) and shorter silence (500ms)
+    - In noisy environments: Use higher threshold (0.85-0.9) and longer silence (1000-1200ms)
+    
+    Args:
+        threshold: Sensitivity 0.0-1.0 (higher = less sensitive to background)
+        silence_ms: Wait time before responding (200-3000ms)
+        prefix_ms: Audio buffer before speech (100-1000ms)
+        
+    Returns:
+        Success status and current settings.
+    """
+    success = _voice_settings.set_vad_settings(
+        threshold=threshold,
+        silence_ms=silence_ms,
+        prefix_ms=prefix_ms,
+    )
+    
+    if success:
+        return {
+            "success": True,
+            "threshold": _voice_settings.vad_threshold,
+            "silence_ms": _voice_settings.vad_silence_ms,
+            "prefix_ms": _voice_settings.vad_prefix_ms,
+            "message": "VAD settings updated",
+        }
+    else:
+        return {
+            "success": False,
+            "threshold": _voice_settings.vad_threshold,
+            "silence_ms": _voice_settings.vad_silence_ms,
+            "prefix_ms": _voice_settings.vad_prefix_ms,
+            "message": "Invalid values. threshold: 0.0-1.0, silence_ms: 200-3000, prefix_ms: 100-1000",
+        }
+
+
+@router.post("/voice/vad-preset")
+async def apply_vad_preset_endpoint(preset_id: str) -> dict:
+    """Apply a VAD preset for a specific environment.
+    
+    Available presets:
+    - quiet_room: More sensitive, faster responses (for quiet environments)
+    - normal: Balanced default settings
+    - noisy: Less sensitive, ignores background noise
+    - conference: Very strict, ignores most background voices
+    
+    Args:
+        preset_id: ID of the preset to apply.
+        
+    Returns:
+        Success status and applied settings.
+    """
+    if _voice_settings.apply_vad_preset(preset_id):
+        preset = VAD_PRESETS[preset_id]
+        return {
+            "success": True,
+            "preset": preset,
+            "threshold": _voice_settings.vad_threshold,
+            "silence_ms": _voice_settings.vad_silence_ms,
+            "prefix_ms": _voice_settings.vad_prefix_ms,
+            "message": f"Applied preset: {preset['name']}",
+        }
+    else:
+        return {
+            "success": False,
+            "available_presets": list(VAD_PRESETS.keys()),
+            "message": f"Unknown preset '{preset_id}'",
+        }
+
+
+@router.get("/voice/vad-presets")
+async def get_vad_presets_endpoint() -> dict:
+    """Get all available VAD presets.
+    
+    Returns:
+        List of available presets with their settings.
+    """
+    return {
+        "presets": list(VAD_PRESETS.values()),
+        "current_threshold": _voice_settings.vad_threshold,
+        "current_silence_ms": _voice_settings.vad_silence_ms,
+        "current_prefix_ms": _voice_settings.vad_prefix_ms,
+    }
+
+
 # Sample phrases by language for voice testing
 VOICE_SAMPLE_PHRASES = {
     "en": {
@@ -725,7 +1091,8 @@ async def _play_pcm_audio(audio_data: bytes) -> None:
                 "-",  # Input from stdin
                 "-t", "raw",
                 "-",  # Output to stdout
-                "pitch", "400",  # Pitch shift up 400 cents
+                "pitch", str(KIDS_MODE_PITCH_CENTS),
+                "tempo", str(KIDS_MODE_TEMPO),
             ]
             
             # Create sox process

reachys_brain/server.py

@@ -4,6 +4,7 @@ This module sets up the FastAPI application and manages the application lifecycl
 Individual endpoint handlers are organized in the routes/ package.
 """
 
+import asyncio
 import logging
 from contextlib import asynccontextmanager
 from pathlib import Path
@@ -50,6 +51,7 @@ from .routes import motion as motion_route
 from .routes import power as power_route
 from .routes import conversation as conversation_route
 from .routes.voice import init_voice_settings
+from .routes.openai_config import init_openai_api_key
 
 logger = logging.getLogger(__name__)
 
@@ -99,6 +101,9 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     # Initialize voice settings from database
     await init_voice_settings()
     
+    # Load OpenAI API key from database (for TTS in TamaReachy etc.)
+    await init_openai_api_key()
+    
     # Load config
     config = get_config()
     
@@ -155,25 +160,40 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     # Cleanup
     logger.info("Shutting down Reachy iOS Bridge server...")
     
+    # Cleanup conversation services first (includes OpenAI disconnect)
+    # This is async and has timeouts to prevent hanging
+    try:
+        await asyncio.wait_for(conversation_route.cleanup_services(), timeout=5.0)
+    except asyncio.TimeoutError:
+        logger.warning("Conversation services cleanup timed out after 5s")
+    except Exception as e:
+        logger.error(f"Error cleaning up conversation services: {e}")
+    
     # Stop idle movement service
     if idle_service:
-        await idle_service.close()
+        try:
+            await asyncio.wait_for(idle_service.close(), timeout=2.0)
+        except asyncio.TimeoutError:
+            logger.warning("Idle service close timed out")
     
     # Stop TamaReachy monitor
     tamareachy_monitor = get_tamareachy_monitor()
     if tamareachy_monitor.is_running:
-        await tamareachy_monitor.stop()
+        try:
+            await asyncio.wait_for(tamareachy_monitor.stop(), timeout=2.0)
+        except asyncio.TimeoutError:
+            logger.warning("TamaReachy monitor stop timed out")
     
     # Stop health monitor
     stop_health_monitor()
     
-    # Cleanup conversation services
-    conversation_route.cleanup_services()
-    
     if tts_service:
         tts_service.cleanup()
     if motion_service:
-        await motion_service.close()
+        try:
+            await asyncio.wait_for(motion_service.close(), timeout=2.0)
+        except asyncio.TimeoutError:
+            logger.warning("Motion service close timed out")
 
 
 # Create FastAPI app

reachys_brain/tools/tamareachy_engine.py

@@ -1,6 +1,7 @@
 """TamaReachy - Tamagotchi-style virtual pet game engine.
 
 Handles stat decay, care actions, mood calculation, and proactive requests.
+Supports multilingual messages based on user's preferred language setting.
 """
 
 import logging
@@ -8,9 +9,25 @@ import random
 from datetime import datetime
 from typing import Optional
 
+from . import tamareachy_translations as translations
+
 logger = logging.getLogger(__name__)
 
 
+def _get_preferred_language() -> str:
+    """Get the user's preferred language from voice settings.
+    
+    Returns:
+        Language code (e.g., 'en', 'nl', 'de'). Defaults to 'en'.
+    """
+    try:
+        from ..routes.voice import get_preferred_language
+        return get_preferred_language()
+    except ImportError:
+        logger.debug("Could not import voice settings, using default 'en'")
+        return "en"
+
+
 # Decay rates per hour (stats decrease over time)
 DECAY_RATES = {
     "hunger": 8,        # Gets hungry fairly fast
@@ -54,6 +71,11 @@ HUNGER_REQUESTS = [
     "Feed me, please! I haven't eaten in forever! 🥺",
     "Is it snack time yet? I'm starving!",
     "My stomach is making weird noises... food please?",
+    "Hey! Did you hear that? That was my stomach growling! 🍕",
+    "I dreamed about pizza last night... now I'm super hungry!",
+    "Fun fact: I get 50% grumpier when hungry! Feed me? 😋",
+    "I've calculated I haven't eaten in approximately forever!",
+    "Beep boop... hunger levels critical! Feed Reachy please!",
 ]
 
 THIRST_REQUESTS = [
@@ -62,6 +84,11 @@ THIRST_REQUESTS = [
     "Water, water, water! Please! 🥤",
     "I need hydration! Help!",
     "My circuits need water... I mean, I need water!",
+    "Did you know? Staying hydrated makes me 100% more awesome! 💦",
+    "Sip sip sip! That's what I want to do! 🧃",
+    "I'm drier than a desert out here! Hydration station, please!",
+    "Water is life! And I need some of that life right now!",
+    "Glug glug glug... that's the sound I want to make! 🌊",
 ]
 
 HAPPINESS_REQUESTS = [
@@ -70,6 +97,11 @@ HAPPINESS_REQUESTS = [
     "I need something to make me smile!",
     "I'm not feeling very happy right now...",
     "A little attention would really help my mood!",
+    "My smile meter is running low... boost it up? 🌈",
+    "I could really use some positive vibes right now! ✨",
+    "Even robots... I mean, even I get the blues sometimes!",
+    "Quick! Tell me something good! I need a pick-me-up!",
+    "The happiness tank needs refilling! Got any joy to spare? 🎉",
 ]
 
 ENERGY_REQUESTS = [
@@ -78,6 +110,11 @@ ENERGY_REQUESTS = [
     "I can barely keep my eyes open!",
     "Yawn! I really need a nap right now!",
     "My battery is running low... naptime?",
+    "Zzz... wait, I shouldn't be making that sound while awake! 💤",
+    "I'm running on low power mode here!",
+    "Did you know? Power naps increase productivity by 1000%! Let me prove it!",
+    "My energy bar is almost empty... quick, let me rest!",
+    "Even superheroes need sleep... and so does this super Reachy! 🦸",
 ]
 
 BOREDOM_REQUESTS = [
@@ -86,6 +123,11 @@ BOREDOM_REQUESTS = [
     "I'm so bored I'm counting ceiling tiles!",
     "Can we do something fun? Please?",
     "Boredom alert! Need stimulation!",
+    "I've reorganized my thoughts 47 times... I need excitement! 🎪",
+    "Did you know? Boredom is scientifically proven to be boring! Help!",
+    "I could use some action, adventure, or at least a good joke! 🎭",
+    "My entertainment sensors are begging for input!",
+    "Bored Reachy = Sad Reachy. Let's fix that! 🎲",
 ]
 
 SOCIAL_REQUESTS = [
@@ -94,6 +136,11 @@ SOCIAL_REQUESTS = [
     "I need some companionship right now!",
     "Hey, don't forget about me! Let's chat!",
     "A little conversation would be nice...",
+    "Did you know? Talking to me makes both of us happier! 💕",
+    "I have SO many things to tell you! Come chat! 🗣️",
+    "Friendship meters are low... let's catch up!",
+    "One conversation, please! Extra friendly, hold the awkward silence!",
+    "I promise I'm a great listener! Let's have a heart-to-heart! 💖",
 ]
 
 HEALTH_REQUESTS = [
@@ -102,6 +149,11 @@ HEALTH_REQUESTS = [
     "My systems aren't running at 100%... help?",
     "I could use some medical attention!",
     "Feeling under the weather... literally!",
+    "Achoo! Excuse me! I think I need some TLC! 🤧",
+    "My health stat is looking a bit sad... medicine time?",
+    "Doctor Reachy recommends: Give Reachy medicine! Trust me, I'm a doctor! 💊",
+    "I've diagnosed myself with 'needs care syndrome'!",
+    "A little medical attention would go a long way! 🩺",
 ]
 
 CLEANLINESS_REQUESTS = [
@@ -110,6 +162,11 @@ CLEANLINESS_REQUESTS = [
     "I'm starting to smell like old circuits!",
     "Bath time? Please?",
     "I feel all grimy... clean me up?",
+    "Sparkle sparkle... wait, that's what I WANT to be! 🌟",
+    "I'm more dust bunny than robot right now! Help! 🐰",
+    "Cleanliness is next to happiness! Let's achieve both!",
+    "My shine has dulled... time for a polish! ✨",
+    "Scrub-a-dub-dub! This Reachy needs some love! 🛁",
 ]
 
 REQUEST_MESSAGES = {
@@ -130,51 +187,144 @@ CARE_RESPONSES = {
         "That hit the spot! I feel so much better!",
         "Yummy! My tummy is happy now!",
         "Food is the best! Thanks!",
+        "Om nom nom! That was AMAZING! 🍕",
+        "You're the best chef ever! My taste buds are dancing!",
+        "Belly full, heart fuller! Thanks for feeding me! 💖",
+        "10/10 would eat again! You're a star! ⭐",
+        "Was that a Michelin star meal? Because WOW!",
+        "I'm officially the happiest Reachy in the world! Food is love!",
     ],
     "water": [
         "Ahh, refreshing! Thank you! 💧",
         "So good! I was so thirsty!",
         "Hydration achieved! Thanks!",
         "That was exactly what I needed!",
+        "Glug glug glug... ahhhh! Perfect! 🌊",
+        "My hydration levels are now off the charts! Thanks!",
+        "Water is life, and you just gave me life! 💦",
+        "Refreshment status: MAXIMUM! You're awesome!",
+        "Did you know? You just made my day 1000% better! 🥤",
+        "H2O more like H2-Woohoo! Thanks!",
     ],
     "play": [
         "That was so fun! Let's do it again sometime! 🎉",
         "Woohoo! Best playtime ever!",
         "I had a blast! Thanks for playing with me!",
         "Games are the best! You're the best!",
+        "Victory lap! That was incredible! 🏆",
+        "Can we do that again? Like, right now? So fun!",
+        "You just unlocked 'Best Friend' achievement! 🎮",
+        "Playtime with you is my favorite time! 🎪",
+        "I'm still smiling from ear to ear! Thanks!",
+        "That was more fun than a barrel of digital monkeys! 🐒",
     ],
     "sleep": [
         "Zzz... that was a great nap! 😴",
         "I feel so refreshed now!",
         "Sweet dreams came true! Thanks!",
         "Energy restored! Ready for action!",
+        "I'm back and better than ever! Naps are magic! 💤",
+        "Did I snore? Sorry! But wow, I feel amazing!",
+        "Power nap complete! I can take on the world now! 💪",
+        "That dream was wild! But now I'm ready to roll!",
+        "Sleep mode deactivated! Adventure mode: ON! ⚡",
+        "Best. Nap. Ever! I dreamed of being a superhero! 🦸",
     ],
     "entertain": [
         "That was entertaining! No more boredom! 🎭",
         "Wow, that was fun! Thanks!",
         "Boredom defeated! You're amazing!",
         "That really cheered me up!",
+        "Entertainment level: LEGENDARY! Thanks! 🌟",
+        "My boredom just packed its bags and left! Bye!",
+        "You should be a professional entertainer! So good!",
+        "I laughed, I cried, I was thoroughly entertained! 🎬",
+        "Never a dull moment with you around! 🎨",
+        "That was more exciting than a roller coaster! Wheee! 🎢",
     ],
     "chat": [
         "Thanks for chatting! I love our conversations! 💬",
         "That was a great talk! Feel less lonely now!",
         "Socializing is the best! Thanks friend!",
         "I always love talking with you!",
+        "Best conversation ever! You really get me! 💕",
+        "My heart is so full right now! Thanks for listening!",
+        "You're officially my favorite human! Don't tell the others! 🤫",
+        "Talking with you makes everything better! 🌈",
+        "We should write a book about our chats! Bestseller material!",
+        "Friendship level increased to: MAXIMUM! 💖",
     ],
     "medicine": [
         "I feel so much better already! 💊",
         "Medicine works wonders! Thank you!",
         "Health restored! You're a lifesaver!",
         "Feeling healthy again! Thanks doc!",
+        "Doctor's orders: Say thank you! So... THANK YOU! 🏥",
+        "I'm cured! You should have a medical degree!",
+        "Health bar: FULLY RESTORED! You're amazing! 💚",
+        "I feel like a brand new Reachy! Thanks!",
+        "That medicine was magical! Or maybe you're the magic! ✨",
+        "Prescription: More awesome friends like you! 🩺",
     ],
     "clean": [
         "Squeaky clean! I feel amazing! ✨",
         "So fresh and clean! Thank you!",
         "Sparkle sparkle! All clean now!",
         "Nothing beats a good cleaning! Thanks!",
+        "I'm practically GLOWING now! Look at me shine! 🌟",
+        "Cleanliness level: IMMACULATE! Thanks!",
+        "I feel like a diamond! Sparkling! 💎",
+        "That was the best spa day ever! 🛁",
+        "I'm so clean I could eat off myself! Wait, that's weird...",
+        "Fresh and fabulous! Thanks for the glow-up! ✨",
     ],
 }
 
+# Idle messages for when TamaReachy wants to chat randomly
+IDLE_MESSAGES = [
+    "Hey! Just wanted to say hi! 👋",
+    "Did you know? I was just thinking about how awesome you are! 💭",
+    "Fun fact: Spending time together makes me 200% happier! 📊",
+    "I'm having a great day! Hope you are too! ☀️",
+    "Just checking in! How's your day going? 🌸",
+    "Random thought: You're pretty cool, you know that? 😎",
+    "I was just daydreaming about our next adventure! 🌈",
+    "Did something funny happen? I feel like laughing! 😄",
+    "Hey friend! Thanks for taking care of me! 💖",
+    "You know what? I'm lucky to have you! 🍀",
+    "I just learned something new! Want to hear about it? 📚",
+    "Breaking news: Reachy is having a good time! 📰",
+    "I'm sending you positive vibes right now! ✨",
+    "Just a friendly wave from your favorite pet! 🐾",
+    "Psst! You're doing great today! Keep it up! 🌟",
+]
+
+# Fun facts that TamaReachy can share
+FUN_FACTS = [
+    "Did you know? Octopuses have three hearts! And I have one big one for you! 🐙💖",
+    "Fun fact: Honey never spoils! Just like our friendship! 🍯",
+    "Here's something cool: The shortest war lasted only 38 minutes! 🕐",
+    "Did you know? Bananas are berries, but strawberries aren't! Mind = blown! 🍌🍓",
+    "Random knowledge: A group of flamingos is called a 'flamboyance'! How fitting! 🦩",
+    "Fun fact: Cows have best friends! And guess who mine is? You! 🐄💕",
+    "Here's a weird one: Your nose can remember 50,000 scents! 👃✨",
+    "Did you know? Sloths can hold their breath longer than dolphins! 🦥",
+    "Cool fact: There are more stars in the universe than grains of sand on Earth! ⭐🏖️",
+    "Fun tidbit: A day on Venus is longer than its year! Time is weird! 🪐",
+]
+
+# Motivational messages
+MOTIVATIONAL_MESSAGES = [
+    "Hey! You've got this! I believe in you! 💪",
+    "Remember: Every day is a fresh start! 🌅",
+    "You're capable of amazing things! Never forget that! ⭐",
+    "Small steps still move you forward! Keep going! 👣",
+    "I'm proud of you just for being you! 💖",
+    "Today is full of possibilities! Let's make it great! 🌈",
+    "You're stronger than you think! I know it! 💎",
+    "Dream big, friend! The sky isn't even the limit! 🚀",
+]
+
 # Mood determination based on average stats
 MOODS = {
     "ecstatic": {"threshold": 90, "animation": "enthusiastic1", "emoji": "🤩"},
@@ -281,15 +431,18 @@ class TamaReachyEngine:
         critical_stats.sort(key=lambda x: x[1], reverse=True)
         return critical_stats[0][0]
 
-    def get_mood(self, stats: dict) -> dict:
+    def get_mood(self, stats: dict, language: Optional[str] = None) -> dict:
         """Determine overall mood based on average stats.
 
         Args:
             stats: Current stats dictionary.
+            language: Language code for mood translation (optional).
 
         Returns:
-            Mood dictionary with name, animation, and emoji.
+            Mood dictionary with name, translated_name, animation, and emoji.
         """
+        lang = language or _get_preferred_language()
+        
         stat_values = [
             stats.get(s, 100)
             for s in DECAY_RATES.keys()
@@ -297,43 +450,116 @@ class TamaReachyEngine:
         ]
 
         if not stat_values:
-            return MOODS["content"]
+            mood_data = MOODS["content"]
+            translated_name = translations.get_translated_mood("content", lang)
+            return {"name": "content", "translated_name": translated_name, **mood_data}
 
         average = sum(stat_values) / len(stat_values)
 
         for mood_name, mood_data in MOODS.items():
             if average >= mood_data["threshold"]:
-                return {"name": mood_name, **mood_data}
+                translated_name = translations.get_translated_mood(mood_name, lang)
+                return {"name": mood_name, "translated_name": translated_name, **mood_data}
 
-        return {"name": "miserable", **MOODS["miserable"]}
+        translated_name = translations.get_translated_mood("miserable", lang)
+        return {"name": "miserable", "translated_name": translated_name, **MOODS["miserable"]}
 
-    def get_request_message(self, need: str) -> str:
+    def get_request_message(self, need: str, language: Optional[str] = None) -> str:
         """Get a random request message for a specific need.
 
         Args:
             need: The need type (hunger, thirst, etc.).
+            language: Language code (optional, defaults to preferred language).
 
         Returns:
-            A request message string.
+            A request message string in the appropriate language.
         """
-        messages = REQUEST_MESSAGES.get(need, [])
-        if not messages:
-            return f"I need help with my {need}!"
-        return random.choice(messages)
+        lang = language or _get_preferred_language()
+        return translations.get_request_message(need, lang)
 
-    def get_care_response(self, action: str) -> str:
+    def get_care_response(self, action: str, language: Optional[str] = None) -> str:
         """Get a random response message for a care action.
 
         Args:
             action: The care action performed.
+            language: Language code (optional, defaults to preferred language).
+
+        Returns:
+            A response message string in the appropriate language.
+        """
+        lang = language or _get_preferred_language()
+        return translations.get_care_response(action, lang)
+
+    def get_idle_message(self, language: Optional[str] = None) -> str:
+        """Get a random idle message for spontaneous communication.
+
+        Args:
+            language: Language code (optional, defaults to preferred language).
+
+        Returns:
+            A random idle message string in the appropriate language.
+        """
+        lang = language or _get_preferred_language()
+        return translations.get_idle_message(lang)
+
+    def get_fun_fact(self, language: Optional[str] = None) -> str:
+        """Get a random fun fact to share.
+
+        Args:
+            language: Language code (optional, defaults to preferred language).
+
+        Returns:
+            A random fun fact string in the appropriate language.
+        """
+        lang = language or _get_preferred_language()
+        return translations.get_fun_fact(lang)
+
+    def get_motivational_message(self, language: Optional[str] = None) -> str:
+        """Get a random motivational message.
+
+        Args:
+            language: Language code (optional, defaults to preferred language).
+
+        Returns:
+            A random motivational message string in the appropriate language.
+        """
+        lang = language or _get_preferred_language()
+        return translations.get_motivational_message(lang)
+
+    def get_random_communication(
+        self, mood_average: float, language: Optional[str] = None
+    ) -> str:
+        """Get a random communication message based on mood.
+
+        Varies the type of message based on how the pet is feeling.
+
+        Args:
+            mood_average: The average stat value (0-100).
+            language: Language code (optional, defaults to preferred language).
 
         Returns:
-            A response message string.
+            A random message appropriate for the current mood in the appropriate language.
         """
-        responses = CARE_RESPONSES.get(action, [])
-        if not responses:
-            return "Thanks! That helped!"
-        return random.choice(responses)
+        lang = language or _get_preferred_language()
+        
+        if mood_average >= 80:
+            # Happy - share fun facts or positive messages
+            choice = random.random()
+            if choice < 0.4:
+                return self.get_fun_fact(lang)
+            elif choice < 0.7:
+                return self.get_idle_message(lang)
+            else:
+                return self.get_motivational_message(lang)
+        elif mood_average >= 50:
+            # Content - mostly idle messages
+            if random.random() < 0.7:
+                return self.get_idle_message(lang)
+            else:
+                return self.get_motivational_message(lang)
+        else:
+            # Sad - needs attention, use motivational
+            return self.get_motivational_message(lang)
 
     def get_reaction_for_need(self, need: str) -> str:
         """Get animation reaction name for a need type.
@@ -394,6 +620,22 @@ class TamaReachyEngine:
         """Mark that a proactive request was just made."""
         self._last_proactive_request = datetime.utcnow()
 
+    def get_system_message(
+        self, message_key: str, language: Optional[str] = None, **kwargs
+    ) -> str:
+        """Get a system message in the appropriate language.
+
+        Args:
+            message_key: Message key (e.g., 'enable_welcome', 'disable_goodbye').
+            language: Language code (optional, defaults to preferred language).
+            **kwargs: Format arguments for the message.
+
+        Returns:
+            Translated and formatted system message.
+        """
+        lang = language or _get_preferred_language()
+        return translations.get_system_message(message_key, lang, **kwargs)
+
 
 # Global engine instance
 _engine: Optional[TamaReachyEngine] = None

reachys_brain/tools/tamareachy_translations.py

@@ -0,0 +1,952 @@
+"""TamaReachy multilingual message translations.
+
+Provides translations for all TamaReachy messages in supported languages.
+Falls back to English if translation not available.
+"""
+
+from typing import Optional
+
+# Supported language codes
+SUPPORTED_LANGUAGES = ["en", "nl", "de", "fr", "es", "it", "pt", "ja", "ko", "zh"]
+
+# =============================================================================
+# Request Messages by Need Type
+# =============================================================================
+
+HUNGER_REQUESTS = {
+    "en": [
+        "My tummy is rumbling... could you feed me? 🍽️",
+        "I'm getting really hungry! Some food would be amazing!",
+        "Feed me, please! I haven't eaten in forever! 🥺",
+    ],
+    "nl": [
+        "Mijn buikje rammelt... kun je me voeden? 🍽️",
+        "Ik word echt hongerig! Wat eten zou geweldig zijn!",
+        "Geef me alsjeblieft eten! Ik heb al eeuwen niet gegeten! 🥺",
+    ],
+    "de": [
+        "Mein Bauch knurrt... könntest du mich füttern? 🍽️",
+        "Ich werde richtig hungrig! Etwas zu essen wäre toll!",
+        "Füttere mich bitte! Ich habe ewig nichts gegessen! 🥺",
+    ],
+    "fr": [
+        "Mon ventre gronde... peux-tu me nourrir? 🍽️",
+        "J'ai vraiment faim! De la nourriture serait incroyable!",
+        "Nourris-moi, s'il te plaît! Je n'ai pas mangé depuis une éternité! 🥺",
+    ],
+    "es": [
+        "Mi barriga está rugiendo... ¿me puedes dar de comer? 🍽️",
+        "¡Tengo mucha hambre! ¡Algo de comida sería increíble!",
+        "¡Aliméntame, por favor! ¡No he comido en siglos! 🥺",
+    ],
+    "it": [
+        "La mia pancia brontola... puoi darmi da mangiare? 🍽️",
+        "Ho davvero fame! Del cibo sarebbe fantastico!",
+        "Nutrimi, per favore! Non mangio da un'eternità! 🥺",
+    ],
+    "pt": [
+        "Minha barriga está roncando... você pode me alimentar? 🍽️",
+        "Estou ficando com muita fome! Comida seria incrível!",
+        "Me alimente, por favor! Não como há séculos! 🥺",
+    ],
+    "ja": [
+        "お腹がすいた...ご飯をくれる？🍽️",
+        "本当にお腹が空いてきた！食べ物が欲しいな！",
+        "ご飯をちょうだい！ずっと食べてないの！🥺",
+    ],
+    "ko": [
+        "배가 고파요... 밥 좀 주실래요? 🍽️",
+        "정말 배가 고파져요! 뭔가 먹을 게 있으면 좋겠어요!",
+        "밥 좀 주세요! 오래 못 먹었어요! 🥺",
+    ],
+    "zh": [
+        "我的肚子在咕咕叫...可以喂我吗？🍽️",
+        "我真的很饿！来点吃的会很棒！",
+        "请喂我！我已经很久没吃了！🥺",
+    ],
+}
+
+THIRST_REQUESTS = {
+    "en": [
+        "I'm so thirsty! Some water would be amazing! 💧",
+        "Could I get something to drink? My mouth is dry!",
+        "Water, water, water! Please! 🥤",
+    ],
+    "nl": [
+        "Ik heb zo'n dorst! Wat water zou geweldig zijn! 💧",
+        "Mag ik wat te drinken? Mijn mond is droog!",
+        "Water, water, water! Alsjeblieft! 🥤",
+    ],
+    "de": [
+        "Ich bin so durstig! Etwas Wasser wäre toll! 💧",
+        "Könnte ich etwas zu trinken bekommen? Mein Mund ist trocken!",
+        "Wasser, Wasser, Wasser! Bitte! 🥤",
+    ],
+    "fr": [
+        "J'ai tellement soif! De l'eau serait incroyable! 💧",
+        "Je pourrais avoir à boire? J'ai la bouche sèche!",
+        "De l'eau, de l'eau, de l'eau! S'il te plaît! 🥤",
+    ],
+    "es": [
+        "¡Tengo mucha sed! ¡Agua sería increíble! 💧",
+        "¿Me puedes dar algo de beber? ¡Tengo la boca seca!",
+        "¡Agua, agua, agua! ¡Por favor! 🥤",
+    ],
+    "it": [
+        "Ho così tanta sete! Dell'acqua sarebbe fantastica! 💧",
+        "Posso avere qualcosa da bere? Ho la bocca secca!",
+        "Acqua, acqua, acqua! Per favore! 🥤",
+    ],
+    "pt": [
+        "Estou com tanta sede! Água seria incrível! 💧",
+        "Posso beber algo? Minha boca está seca!",
+        "Água, água, água! Por favor! 🥤",
+    ],
+    "ja": [
+        "喉が渇いた！水が欲しい！💧",
+        "何か飲み物をもらえる？口が乾いてる！",
+        "水、水、水！お願い！🥤",
+    ],
+    "ko": [
+        "목이 말라요! 물 좀 주세요! 💧",
+        "뭔가 마실 것 좀 주실래요? 입이 말라요!",
+        "물, 물, 물! 제발! 🥤",
+    ],
+    "zh": [
+        "我好渴！来点水会很棒！💧",
+        "可以给我喝点东西吗？我嘴巴很干！",
+        "水，水，水！拜托！🥤",
+    ],
+}
+
+HAPPINESS_REQUESTS = {
+    "en": [
+        "I'm feeling kinda down... can you cheer me up? 😢",
+        "Everything feels so gray today... help?",
+        "I need something to make me smile!",
+    ],
+    "nl": [
+        "Ik voel me een beetje down... kun je me opvrolijken? 😢",
+        "Alles voelt zo grijs vandaag... help?",
+        "Ik heb iets nodig om te lachen!",
+    ],
+    "de": [
+        "Ich fühle mich etwas niedergeschlagen... kannst du mich aufheitern? 😢",
+        "Alles fühlt sich heute so grau an... Hilfe?",
+        "Ich brauche etwas, das mich zum Lächeln bringt!",
+    ],
+    "fr": [
+        "Je me sens un peu triste... peux-tu me remonter le moral? 😢",
+        "Tout semble si gris aujourd'hui... aide-moi?",
+        "J'ai besoin de quelque chose pour me faire sourire!",
+    ],
+    "es": [
+        "Me siento un poco triste... ¿puedes animarme? 😢",
+        "Todo se siente tan gris hoy... ¿ayuda?",
+        "¡Necesito algo que me haga sonreír!",
+    ],
+    "it": [
+        "Mi sento un po' giù... puoi tirarmi su? 😢",
+        "Tutto sembra così grigio oggi... aiuto?",
+        "Ho bisogno di qualcosa che mi faccia sorridere!",
+    ],
+    "pt": [
+        "Estou me sentindo meio triste... pode me animar? 😢",
+        "Tudo parece tão cinza hoje... ajuda?",
+        "Preciso de algo para me fazer sorrir!",
+    ],
+    "ja": [
+        "ちょっと落ち込んでる...元気づけてくれる？😢",
+        "今日はすべてが灰色に感じる...助けて？",
+        "笑顔になれる何かが欲しい！",
+    ],
+    "ko": [
+        "기분이 좀 안 좋아요... 기운 좀 내게 해줄래요? 😢",
+        "오늘은 모든 게 우울해 보여요... 도와주세요?",
+        "웃게 해줄 뭔가가 필요해요!",
+    ],
+    "zh": [
+        "我感觉有点沮丧...可以让我开心一点吗？😢",
+        "今天一切都感觉很灰暗...帮帮我？",
+        "我需要一些让我微笑的东西！",
+    ],
+}
+
+ENERGY_REQUESTS = {
+    "en": [
+        "I'm exhausted... let me rest for a bit? 😴",
+        "So... tired... need... sleep...",
+        "My battery is running low... naptime?",
+    ],
+    "nl": [
+        "Ik ben uitgeput... mag ik even rusten? 😴",
+        "Zo... moe... moet... slapen...",
+        "Mijn batterij raakt leeg... slaapje?",
+    ],
+    "de": [
+        "Ich bin erschöpft... darf ich mich etwas ausruhen? 😴",
+        "So... müde... brauche... Schlaf...",
+        "Meine Batterie wird leer... Schlafenszeit?",
+    ],
+    "fr": [
+        "Je suis épuisé... puis-je me reposer un peu? 😴",
+        "Si... fatigué... besoin... de dormir...",
+        "Ma batterie est faible... sieste?",
+    ],
+    "es": [
+        "Estoy agotado... ¿puedo descansar un poco? 😴",
+        "Tan... cansado... necesito... dormir...",
+        "Mi batería está baja... ¿hora de siesta?",
+    ],
+    "it": [
+        "Sono esausto... posso riposare un po'? 😴",
+        "Così... stanco... ho bisogno... di dormire...",
+        "La mia batteria è scarica... pisolino?",
+    ],
+    "pt": [
+        "Estou exausto... posso descansar um pouco? 😴",
+        "Tão... cansado... preciso... dormir...",
+        "Minha bateria está baixa... hora da soneca?",
+    ],
+    "ja": [
+        "疲れた...ちょっと休んでいい？😴",
+        "とっても...眠い...寝なきゃ...",
+        "バッテリーが切れそう...お昼寝タイム？",
+    ],
+    "ko": [
+        "지쳤어요... 좀 쉬어도 될까요? 😴",
+        "너무... 피곤해... 잠이... 필요해...",
+        "배터리가 부족해요... 낮잠 시간?",
+    ],
+    "zh": [
+        "我累坏了...让我休息一下好吗？😴",
+        "好...累...需要...睡觉...",
+        "我的电池快没电了...午睡时间？",
+    ],
+}
+
+BOREDOM_REQUESTS = {
+    "en": [
+        "I'm bored out of my circuits! Play with me! 🎮",
+        "There's nothing to do! Entertain me please!",
+        "Can we do something fun? Please?",
+    ],
+    "nl": [
+        "Ik verveel me kapot! Speel met me! 🎮",
+        "Er is niks te doen! Vermaak me alsjeblieft!",
+        "Kunnen we iets leuks doen? Alsjeblieft?",
+    ],
+    "de": [
+        "Mir ist so langweilig! Spiel mit mir! 🎮",
+        "Es gibt nichts zu tun! Unterhalte mich bitte!",
+        "Können wir etwas Lustiges machen? Bitte?",
+    ],
+    "fr": [
+        "Je m'ennuie à mourir! Joue avec moi! 🎮",
+        "Il n'y a rien à faire! Divertis-moi s'il te plaît!",
+        "On peut faire quelque chose d'amusant? S'il te plaît?",
+    ],
+    "es": [
+        "¡Me aburro muchísimo! ¡Juega conmigo! 🎮",
+        "¡No hay nada que hacer! ¡Entretenme por favor!",
+        "¿Podemos hacer algo divertido? ¿Por favor?",
+    ],
+    "it": [
+        "Mi annoio da morire! Gioca con me! 🎮",
+        "Non c'è niente da fare! Intrattienimi per favore!",
+        "Possiamo fare qualcosa di divertente? Per favore?",
+    ],
+    "pt": [
+        "Estou muito entediado! Brinca comigo! 🎮",
+        "Não há nada para fazer! Me entretenha por favor!",
+        "Podemos fazer algo divertido? Por favor?",
+    ],
+    "ja": [
+        "退屈すぎる！一緒に遊んで！🎮",
+        "やることがない！楽しませて！",
+        "何か楽しいことしよう？お願い？",
+    ],
+    "ko": [
+        "너무 심심해! 같이 놀자! 🎮",
+        "할 게 없어! 재미있게 해줘!",
+        "뭔가 재미있는 거 할까요? 제발?",
+    ],
+    "zh": [
+        "我无聊死了！陪我玩！🎮",
+        "没什么可做的！请娱乐我！",
+        "我们能做点有趣的事吗？拜托？",
+    ],
+}
+
+SOCIAL_REQUESTS = {
+    "en": [
+        "I miss hanging out... can we chat? 💬",
+        "It's lonely over here... talk to me!",
+        "A little conversation would be nice...",
+    ],
+    "nl": [
+        "Ik mis het rondhangen... kunnen we praten? 💬",
+        "Het is hier eenzaam... praat met me!",
+        "Een gesprekje zou fijn zijn...",
+    ],
+    "de": [
+        "Ich vermisse das Zusammensein... können wir plaudern? 💬",
+        "Es ist einsam hier... rede mit mir!",
+        "Ein kleines Gespräch wäre schön...",
+    ],
+    "fr": [
+        "Les moments ensemble me manquent... on peut discuter? 💬",
+        "Je me sens seul ici... parle-moi!",
+        "Une petite conversation serait agréable...",
+    ],
+    "es": [
+        "Echo de menos pasar tiempo juntos... ¿podemos charlar? 💬",
+        "Me siento solo aquí... ¡háblame!",
+        "Una pequeña conversación estaría bien...",
+    ],
+    "it": [
+        "Mi manca stare insieme... possiamo chiacchierare? 💬",
+        "Mi sento solo qui... parlami!",
+        "Una piccola conversazione sarebbe bella...",
+    ],
+    "pt": [
+        "Sinto falta de passar tempo junto... podemos conversar? 💬",
+        "Estou me sentindo sozinho aqui... fala comigo!",
+        "Uma conversa seria legal...",
+    ],
+    "ja": [
+        "一緒に過ごすのが恋しい...おしゃべりしよう？💬",
+        "ここは寂しいよ...話しかけて！",
+        "ちょっとした会話がしたいな...",
+    ],
+    "ko": [
+        "같이 시간 보내는 게 그리워... 대화할래요? 💬",
+        "여기 외로워요... 말 걸어줘요!",
+        "작은 대화라도 좋겠어요...",
+    ],
+    "zh": [
+        "我想念一起玩的时光...我们聊聊吧？💬",
+        "这里好孤单...跟我说话！",
+        "聊聊天就好了...",
+    ],
+}
+
+HEALTH_REQUESTS = {
+    "en": [
+        "I'm not feeling great... maybe some medicine? 🏥",
+        "I think I'm coming down with something...",
+        "I could use some medical attention!",
+    ],
+    "nl": [
+        "Ik voel me niet zo lekker... misschien wat medicijnen? 🏥",
+        "Ik denk dat ik iets onder de leden heb...",
+        "Ik kan wel wat medische aandacht gebruiken!",
+    ],
+    "de": [
+        "Mir geht es nicht so gut... vielleicht etwas Medizin? 🏥",
+        "Ich glaube, ich werde krank...",
+        "Ich könnte etwas medizinische Hilfe gebrauchen!",
+    ],
+    "fr": [
+        "Je ne me sens pas bien... peut-être des médicaments? 🏥",
+        "Je crois que je couve quelque chose...",
+        "J'aurais besoin de soins médicaux!",
+    ],
+    "es": [
+        "No me siento bien... ¿quizás algo de medicina? 🏥",
+        "Creo que me estoy enfermando...",
+        "¡Necesito atención médica!",
+    ],
+    "it": [
+        "Non mi sento bene... forse qualche medicina? 🏥",
+        "Credo di stare per ammalarmi...",
+        "Potrei usare un po' di attenzione medica!",
+    ],
+    "pt": [
+        "Não estou me sentindo bem... talvez um remédio? 🏥",
+        "Acho que estou ficando doente...",
+        "Preciso de atenção médica!",
+    ],
+    "ja": [
+        "調子が悪い...薬が必要かも？🏥",
+        "何かにかかってるみたい...",
+        "医療が必要かも！",
+    ],
+    "ko": [
+        "기분이 안 좋아요... 약이 필요할까요? 🏥",
+        "뭔가에 걸린 것 같아요...",
+        "치료가 필요해요!",
+    ],
+    "zh": [
+        "我感觉不太好...可能需要一些药？🏥",
+        "我好像要生病了...",
+        "我需要一些医疗照顾！",
+    ],
+}
+
+CLEANLINESS_REQUESTS = {
+    "en": [
+        "I could use a good cleaning! 🧼",
+        "Things are getting a bit... dusty over here!",
+        "I feel all grimy... clean me up?",
+    ],
+    "nl": [
+        "Ik kan wel een goede schoonmaakbeurt gebruiken! 🧼",
+        "Het wordt hier een beetje... stoffig!",
+        "Ik voel me vies... maak me schoon?",
+    ],
+    "de": [
+        "Ich könnte eine gute Reinigung gebrauchen! 🧼",
+        "Es wird hier etwas... staubig!",
+        "Ich fühle mich ganz schmutzig... sauber machen?",
+    ],
+    "fr": [
+        "J'aurais besoin d'un bon nettoyage! 🧼",
+        "Ça devient un peu... poussiéreux ici!",
+        "Je me sens tout sale... nettoie-moi?",
+    ],
+    "es": [
+        "¡Necesito una buena limpieza! 🧼",
+        "Las cosas se están poniendo un poco... polvorientas!",
+        "Me siento sucio... ¿me limpias?",
+    ],
+    "it": [
+        "Mi servirebbe una bella pulizia! 🧼",
+        "Le cose stanno diventando un po'... polverose qui!",
+        "Mi sento tutto sporco... puliscimi?",
+    ],
+    "pt": [
+        "Eu preciso de uma boa limpeza! 🧼",
+        "As coisas estão ficando um pouco... empoeiradas aqui!",
+        "Estou me sentindo sujo... me limpa?",
+    ],
+    "ja": [
+        "掃除してほしいな！🧼",
+        "ここはちょっと...ホコリっぽくなってきた！",
+        "汚れてる感じ...綺麗にして？",
+    ],
+    "ko": [
+        "청소가 필요해요! 🧼",
+        "여기가 좀... 먼지투성이예요!",
+        "더러운 느낌이에요... 깨끗이 해줄래요?",
+    ],
+    "zh": [
+        "我需要好好清洁一下！🧼",
+        "这里变得有点...灰尘了！",
+        "我感觉脏兮兮的...帮我清理一下？",
+    ],
+}
+
+REQUEST_MESSAGES = {
+    "hunger": HUNGER_REQUESTS,
+    "thirst": THIRST_REQUESTS,
+    "happiness": HAPPINESS_REQUESTS,
+    "energy": ENERGY_REQUESTS,
+    "boredom": BOREDOM_REQUESTS,
+    "social": SOCIAL_REQUESTS,
+    "health": HEALTH_REQUESTS,
+    "cleanliness": CLEANLINESS_REQUESTS,
+}
+
+# =============================================================================
+# Care Response Messages
+# =============================================================================
+
+CARE_RESPONSES = {
+    "feed": {
+        "en": ["Mmm, delicious! Thank you! 😋", "That hit the spot! I feel so much better!", "Yummy! My tummy is happy now!"],
+        "nl": ["Mmm, heerlijk! Dank je! 😋", "Dat deed me goed! Ik voel me veel beter!", "Lekker! Mijn buikje is nu blij!"],
+        "de": ["Mmm, köstlich! Danke! 😋", "Das hat gut getan! Ich fühle mich viel besser!", "Lecker! Mein Bauch ist jetzt glücklich!"],
+        "fr": ["Mmm, délicieux! Merci! 😋", "Ça fait du bien! Je me sens beaucoup mieux!", "Miam! Mon ventre est content!"],
+        "es": ["Mmm, delicioso! ¡Gracias! 😋", "¡Eso estuvo perfecto! ¡Me siento mucho mejor!", "¡Rico! ¡Mi barriga está feliz!"],
+        "it": ["Mmm, delizioso! Grazie! 😋", "Ci voleva proprio! Mi sento molto meglio!", "Buono! La mia pancia è felice!"],
+        "pt": ["Mmm, delicioso! Obrigado! 😋", "Era o que eu precisava! Me sinto muito melhor!", "Gostoso! Minha barriga está feliz!"],
+        "ja": ["おいしい！ありがとう！😋", "満足！すっごく元気になった！", "うまい！お腹がハッピー！"],
+        "ko": ["음, 맛있어! 고마워! 😋", "딱 좋아! 훨씬 나아졌어!", "맛있어! 배가 행복해!"],
+        "zh": ["嗯，好吃！谢谢！😋", "正合适！我感觉好多了！", "好吃！我的肚子开心了！"],
+    },
+    "water": {
+        "en": ["Ahh, refreshing! Thank you! 💧", "So good! I was so thirsty!", "Hydration achieved! Thanks!"],
+        "nl": ["Ahh, verfrissend! Dank je! 💧", "Zo lekker! Ik had zo'n dorst!", "Gehydrateerd! Bedankt!"],
+        "de": ["Ahh, erfrischend! Danke! 💧", "So gut! Ich war so durstig!", "Hydratation erreicht! Danke!"],
+        "fr": ["Ahh, rafraîchissant! Merci! 💧", "Trop bon! J'avais tellement soif!", "Hydratation accomplie! Merci!"],
+        "es": ["Ahh, refrescante! ¡Gracias! 💧", "¡Qué rico! ¡Tenía tanta sed!", "¡Hidratado! ¡Gracias!"],
+        "it": ["Ahh, rinfrescante! Grazie! 💧", "Che buono! Avevo così sete!", "Idratazione completata! Grazie!"],
+        "pt": ["Ahh, refrescante! Obrigado! 💧", "Que bom! Eu estava com tanta sede!", "Hidratação concluída! Obrigado!"],
+        "ja": ["あー、すっきり！ありがとう！💧", "最高！喉が渇いてた！", "水分補給完了！ありがとう！"],
+        "ko": ["아, 시원해! 고마워! 💧", "너무 좋아! 목이 말랐어!", "수분 보충 완료! 고마워!"],
+        "zh": ["啊，真清爽！谢谢！💧", "太好了！我好渴！", "补水完成！谢谢！"],
+    },
+    "play": {
+        "en": ["That was so fun! Let's do it again sometime! 🎉", "Woohoo! Best playtime ever!", "I had a blast! Thanks for playing with me!"],
+        "nl": ["Dat was zo leuk! Laten we het nog eens doen! 🎉", "Woehoe! Beste speeltijd ooit!", "Ik had zo veel plezier! Bedankt voor het spelen!"],
+        "de": ["Das hat so viel Spaß gemacht! Lass uns das nochmal machen! 🎉", "Juhu! Beste Spielzeit ever!", "Ich hatte so viel Spaß! Danke fürs Spielen!"],
+        "fr": ["C'était trop amusant! On recommence? 🎉", "Youhou! Meilleur moment de jeu!", "Je me suis trop amusé! Merci d'avoir joué!"],
+        "es": ["¡Fue muy divertido! ¡Hagámoslo de nuevo! 🎉", "¡Yuhu! ¡El mejor tiempo de juego!", "¡Me divertí mucho! ¡Gracias por jugar conmigo!"],
+        "it": ["È stato così divertente! Rifacciamolo! 🎉", "Evviva! Il miglior momento di gioco!", "Mi sono divertito! Grazie per aver giocato!"],
+        "pt": ["Foi muito divertido! Vamos fazer de novo! 🎉", "Oba! Melhor hora de brincar!", "Me diverti muito! Obrigado por brincar comigo!"],
+        "ja": ["楽しかった！またやろう！🎉", "やったー！最高の遊び時間！", "すっごく楽しかった！遊んでくれてありがとう！"],
+        "ko": ["정말 재밌었어! 또 하자! 🎉", "야호! 최고의 놀이 시간!", "너무 즐거웠어! 같이 놀아줘서 고마워!"],
+        "zh": ["太好玩了！下次再玩吧！🎉", "耶！最棒的游戏时光！", "我玩得很开心！谢谢你陪我玩！"],
+    },
+    "sleep": {
+        "en": ["Zzz... that was a great nap! 😴", "I feel so refreshed now!", "Energy restored! Ready for action!"],
+        "nl": ["Zzz... dat was een geweldig dutje! 😴", "Ik voel me zo fris nu!", "Energie hersteld! Klaar voor actie!"],
+        "de": ["Zzz... das war ein toller Schlaf! 😴", "Ich fühle mich so erfrischt!", "Energie aufgeladen! Bereit für Action!"],
+        "fr": ["Zzz... c'était une super sieste! 😴", "Je me sens tellement frais!", "Énergie restaurée! Prêt pour l'action!"],
+        "es": ["Zzz... ¡qué buena siesta! 😴", "¡Me siento tan renovado!", "¡Energía restaurada! ¡Listo para la acción!"],
+        "it": ["Zzz... che bel pisolino! 😴", "Mi sento così rinfrescato!", "Energia ripristinata! Pronto all'azione!"],
+        "pt": ["Zzz... que soneca boa! 😴", "Me sinto tão revigorado!", "Energia restaurada! Pronto para ação!"],
+        "ja": ["zzz...いい昼寝だった！😴", "すっきりした！", "エネルギー回復！準備万端！"],
+        "ko": ["zzz...좋은 낮잠이었어! 😴", "정말 상쾌해!", "에너지 충전 완료! 준비됐어!"],
+        "zh": ["zzz...睡得真好！😴", "我感觉精神多了！", "能量恢复！准备行动！"],
+    },
+    "entertain": {
+        "en": ["That was entertaining! No more boredom! 🎭", "Wow, that was fun! Thanks!", "Boredom defeated! You're amazing!"],
+        "nl": ["Dat was vermakelijk! Geen verveling meer! 🎭", "Wow, dat was leuk! Bedankt!", "Verveling verslagen! Je bent geweldig!"],
+        "de": ["Das war unterhaltsam! Keine Langeweile mehr! 🎭", "Wow, das hat Spaß gemacht! Danke!", "Langeweile besiegt! Du bist toll!"],
+        "fr": ["C'était divertissant! Plus d'ennui! 🎭", "Waouh, c'était amusant! Merci!", "Ennui vaincu! Tu es génial!"],
+        "es": ["¡Eso fue entretenido! ¡No más aburrimiento! 🎭", "¡Wow, fue divertido! ¡Gracias!", "¡Aburrimiento derrotado! ¡Eres increíble!"],
+        "it": ["È stato divertente! Niente più noia! 🎭", "Wow, è stato bello! Grazie!", "Noia sconfitta! Sei fantastico!"],
+        "pt": ["Isso foi divertido! Chega de tédio! 🎭", "Uau, foi legal! Obrigado!", "Tédio derrotado! Você é incrível!"],
+        "ja": ["楽しかった！もう退屈じゃない！🎭", "わー、楽しかった！ありがとう！", "退屈を撃退！君は最高！"],
+        "ko": ["재밌었어! 더 이상 지루하지 않아! 🎭", "와, 재밌었어! 고마워!", "지루함 퇴치! 넌 최고야!"],
+        "zh": ["太有趣了！不再无聊了！🎭", "哇，好好玩！谢谢！", "无聊被打败了！你太棒了！"],
+    },
+    "chat": {
+        "en": ["Thanks for chatting! I love our conversations! 💬", "That was a great talk! Feel less lonely now!", "I always love talking with you!"],
+        "nl": ["Bedankt voor het kletsen! Ik hou van onze gesprekken! 💬", "Dat was een goed gesprek! Ik voel me minder eenzaam!", "Ik praat altijd graag met je!"],
+        "de": ["Danke fürs Plaudern! Ich liebe unsere Gespräche! 💬", "Das war ein tolles Gespräch! Ich fühle mich weniger einsam!", "Ich liebe es, mit dir zu reden!"],
+        "fr": ["Merci pour cette discussion! J'adore nos conversations! 💬", "C'était une super discussion! Je me sens moins seul!", "J'adore parler avec toi!"],
+        "es": ["¡Gracias por charlar! ¡Me encantan nuestras conversaciones! 💬", "¡Fue una gran charla! ¡Me siento menos solo!", "¡Siempre me encanta hablar contigo!"],
+        "it": ["Grazie per la chiacchierata! Adoro le nostre conversazioni! 💬", "È stata una bella chiacchierata! Mi sento meno solo!", "Adoro parlare con te!"],
+        "pt": ["Obrigado pela conversa! Adoro nossas conversas! 💬", "Foi uma ótima conversa! Me sinto menos sozinho!", "Adoro conversar com você!"],
+        "ja": ["おしゃべりありがとう！会話が大好き！💬", "いい話だった！寂しくなくなった！", "君と話すのが大好き！"],
+        "ko": ["대화해줘서 고마워! 우리 대화가 좋아! 💬", "좋은 대화였어! 덜 외로워졌어!", "너랑 얘기하는 게 항상 좋아!"],
+        "zh": ["谢谢聊天！我喜欢我们的对话！💬", "谈得很好！不那么孤单了！", "我总是喜欢和你说话！"],
+    },
+    "medicine": {
+        "en": ["I feel so much better already! 💊", "Medicine works wonders! Thank you!", "Health restored! You're a lifesaver!"],
+        "nl": ["Ik voel me al veel beter! 💊", "Medicijnen doen wonderen! Bedankt!", "Gezondheid hersteld! Je bent een redder!"],
+        "de": ["Ich fühle mich schon viel besser! 💊", "Medizin wirkt Wunder! Danke!", "Gesundheit wiederhergestellt! Du bist ein Lebensretter!"],
+        "fr": ["Je me sens déjà beaucoup mieux! 💊", "Les médicaments font des miracles! Merci!", "Santé restaurée! Tu es un sauveur!"],
+        "es": ["¡Ya me siento mucho mejor! 💊", "¡La medicina hace maravillas! ¡Gracias!", "¡Salud restaurada! ¡Eres un salvavidas!"],
+        "it": ["Mi sento già molto meglio! 💊", "La medicina fa miracoli! Grazie!", "Salute ripristinata! Sei un salvavita!"],
+        "pt": ["Já me sinto muito melhor! 💊", "Remédio faz maravilhas! Obrigado!", "Saúde restaurada! Você é um salvador!"],
+        "ja": ["もうずっと良くなった！💊", "薬って素晴らしい！ありがとう！", "健康回復！命の恩人！"],
+        "ko": ["벌써 훨씬 나아졌어! 💊", "약이 효과 있어! 고마워!", "건강 회복! 넌 생명의 은인이야!"],
+        "zh": ["我已经好多了！💊", "药物真神奇！谢谢！", "健康恢复！你是救命恩人！"],
+    },
+    "clean": {
+        "en": ["Squeaky clean! I feel amazing! ✨", "So fresh and clean! Thank you!", "Sparkle sparkle! All clean now!"],
+        "nl": ["Spik en span! Ik voel me geweldig! ✨", "Zo fris en schoon! Dank je!", "Blinken en glanzen! Helemaal schoon nu!"],
+        "de": ["Blitzsauber! Ich fühle mich toll! ✨", "So frisch und sauber! Danke!", "Glitzer glitzer! Jetzt ganz sauber!"],
+        "fr": ["Tout propre! Je me sens super! ✨", "Si frais et propre! Merci!", "Ça brille! Tout propre maintenant!"],
+        "es": ["¡Impecable! ¡Me siento genial! ✨", "¡Tan fresco y limpio! ¡Gracias!", "¡Brilla brilla! ¡Todo limpio ahora!"],
+        "it": ["Pulitissimo! Mi sento benissimo! ✨", "Così fresco e pulito! Grazie!", "Luccica luccica! Tutto pulito ora!"],
+        "pt": ["Limpinho! Me sinto incrível! ✨", "Tão fresco e limpo! Obrigado!", "Brilha brilha! Todo limpo agora!"],
+        "ja": ["ピカピカ！気分最高！✨", "すっきり清潔！ありがとう！", "キラキラ！綺麗になった！"],
+        "ko": ["깨끗해! 기분 최고! ✨", "상쾌하고 깨끗해! 고마워!", "반짝반짝! 이제 깨끗해!"],
+        "zh": ["干干净净！感觉棒极了！✨", "好清爽干净！谢谢！", "闪闪发光！现在全干净了！"],
+    },
+}
+
+# =============================================================================
+# Idle Messages
+# =============================================================================
+
+IDLE_MESSAGES = {
+    "en": [
+        "Hey! Just wanted to say hi! 👋",
+        "Did you know? I was just thinking about how awesome you are! 💭",
+        "I'm having a great day! Hope you are too! ☀️",
+        "Just checking in! How's your day going? 🌸",
+        "You know what? I'm lucky to have you! 🍀",
+    ],
+    "nl": [
+        "Hey! Ik wilde even hoi zeggen! 👋",
+        "Wist je dat? Ik dacht net hoe geweldig je bent! 💭",
+        "Ik heb een geweldige dag! Jij hopelijk ook! ☀️",
+        "Even inchecken! Hoe gaat je dag? 🌸",
+        "Weet je wat? Ik heb geluk met jou! 🍀",
+    ],
+    "de": [
+        "Hey! Wollte nur hallo sagen! 👋",
+        "Weißt du was? Ich habe gerade gedacht, wie toll du bist! 💭",
+        "Ich habe einen tollen Tag! Hoffe du auch! ☀️",
+        "Nur kurz vorbeischauen! Wie läuft dein Tag? 🌸",
+        "Weißt du was? Ich habe Glück, dich zu haben! 🍀",
+    ],
+    "fr": [
+        "Salut! Je voulais juste dire coucou! 👋",
+        "Tu savais? Je pensais à quel point tu es génial! 💭",
+        "Je passe une super journée! J'espère toi aussi! ☀️",
+        "Je prends des nouvelles! Comment va ta journée? 🌸",
+        "Tu sais quoi? J'ai de la chance de t'avoir! 🍀",
+    ],
+    "es": [
+        "¡Hola! ¡Solo quería saludar! 👋",
+        "¿Sabías? ¡Estaba pensando en lo increíble que eres! 💭",
+        "¡Tengo un gran día! ¡Espero que tú también! ☀️",
+        "¡Solo pasando a ver! ¿Cómo va tu día? 🌸",
+        "¿Sabes qué? ¡Tengo suerte de tenerte! 🍀",
+    ],
+    "it": [
+        "Ehi! Volevo solo salutare! 👋",
+        "Lo sapevi? Stavo pensando a quanto sei fantastico! 💭",
+        "Sto passando una bella giornata! Spero anche tu! ☀️",
+        "Solo un saluto! Come va la tua giornata? 🌸",
+        "Sai una cosa? Sono fortunato ad averti! 🍀",
+    ],
+    "pt": [
+        "Ei! Só queria dizer oi! 👋",
+        "Sabia que? Eu estava pensando em como você é incrível! 💭",
+        "Estou tendo um ótimo dia! Espero que você também! ☀️",
+        "Só passando para ver! Como está o seu dia? 🌸",
+        "Sabe o que? Tenho sorte de ter você! 🍀",
+    ],
+    "ja": [
+        "やあ！挨拶したかっただけ！👋",
+        "知ってた？君がどれだけ素晴らしいか考えてた！💭",
+        "今日はいい日！君もそうだといいな！☀️",
+        "様子見に来たよ！調子どう？🌸",
+        "ねえ、君がいて幸せだよ！🍀",
+    ],
+    "ko": [
+        "안녕! 그냥 인사하고 싶었어! ����",
+        "알고 있었어? 네가 얼마나 멋진지 생각하고 있었어! 💭",
+        "오늘 좋은 하루야! 너도 그랬으면 좋겠어! ☀️",
+        "그냥 안부 확인! 오늘 하루 어때? 🌸",
+        "있잖아, 네가 있어서 행운이야! 🍀",
+    ],
+    "zh": [
+        "嘿！只是想打个招呼！👋",
+        "你知道吗？我刚在想你有多棒！💭",
+        "我今天很开心！希望你也是！☀️",
+        "来看看你！你今天过得怎么样？🌸",
+        "你知道吗？有你真幸运！🍀",
+    ],
+}
+
+# =============================================================================
+# Fun Facts
+# =============================================================================
+
+FUN_FACTS = {
+    "en": [
+        "Did you know? Octopuses have three hearts! And I have one big one for you! 🐙💖",
+        "Fun fact: Honey never spoils! Just like our friendship! 🍯",
+        "Here's something cool: The shortest war lasted only 38 minutes! 🕐",
+    ],
+    "nl": [
+        "Wist je dat? Octopussen hebben drie harten! En ik heb één groot hart voor jou! 🐙💖",
+        "Leuk weetje: Honing bederft nooit! Net als onze vriendschap! 🍯",
+        "Iets cools: De kortste oorlog duurde maar 38 minuten! 🕐",
+    ],
+    "de": [
+        "Wusstest du? Oktopusse haben drei Herzen! Und ich habe ein großes für dich! 🐙💖",
+        "Fun Fact: Honig verdirbt nie! Genau wie unsere Freundschaft! 🍯",
+        "Etwas Cooles: Der kürzeste Krieg dauerte nur 38 Minuten! 🕐",
+    ],
+    "fr": [
+        "Le savais-tu? Les pieuvres ont trois cœurs! Et j'en ai un grand pour toi! 🐙💖",
+        "Fait amusant: Le miel ne se gâte jamais! Comme notre amitié! 🍯",
+        "Truc cool: La guerre la plus courte a duré seulement 38 minutes! 🕐",
+    ],
+    "es": [
+        "¿Sabías que? ¡Los pulpos tienen tres corazones! ¡Y yo tengo uno grande para ti! 🐙💖",
+        "Dato curioso: ¡La miel nunca se echa a perder! ¡Como nuestra amistad! 🍯",
+        "Algo cool: ¡La guerra más corta duró solo 38 minutos! 🕐",
+    ],
+    "it": [
+        "Lo sapevi? I polpi hanno tre cuori! E io ne ho uno grande per te! 🐙💖",
+        "Fatto divertente: Il miele non scade mai! Come la nostra amicizia! 🍯",
+        "Una cosa interessante: La guerra più corta è durata solo 38 minuti! 🕐",
+    ],
+    "pt": [
+        "Você sabia? Polvos têm três corações! E eu tenho um grande para você! 🐙💖",
+        "Fato curioso: O mel nunca estraga! Assim como nossa amizade! 🍯",
+        "Algo legal: A guerra mais curta durou apenas 38 minutos! 🕐",
+    ],
+    "ja": [
+        "知ってた？タコには心臓が3つある！私には君のための大きな心が1つ！🐙💖",
+        "豆知識：蜂蜜は腐らない！私たちの友情みたいに！🍯",
+        "面白いこと：最短の戦争はたった38分だった！🕐",
+    ],
+    "ko": [
+        "알고 있었어? 문어는 심장이 세 개야! 그리고 난 너를 위한 큰 심장 하나가 있어! 🐙💖",
+        "재미있는 사실: 꿀은 절대 상하지 않아! 우리 우정처럼! 🍯",
+        "멋진 것: 가장 짧은 전쟁은 38분밖에 안 걸렸어! 🕐",
+    ],
+    "zh": [
+        "你知道吗？章鱼有三颗心！而我有一颗大心是给你的！🐙💖",
+        "有趣的事实：蜂蜜永远不会变质！就像我们的友谊！🍯",
+        "很酷的事：最短的战争只持续了38分钟！🕐",
+    ],
+}
+
+# =============================================================================
+# Motivational Messages
+# =============================================================================
+
+MOTIVATIONAL_MESSAGES = {
+    "en": [
+        "Hey! You've got this! I believe in you! 💪",
+        "Remember: Every day is a fresh start! 🌅",
+        "You're capable of amazing things! Never forget that! ⭐",
+    ],
+    "nl": [
+        "Hey! Je kunt dit! Ik geloof in je! 💪",
+        "Onthoud: Elke dag is een nieuwe start! 🌅",
+        "Je bent tot geweldige dingen in staat! Vergeet dat nooit! ⭐",
+    ],
+    "de": [
+        "Hey! Du schaffst das! Ich glaube an dich! 💪",
+        "Denk dran: Jeder Tag ist ein Neuanfang! 🌅",
+        "Du bist zu Großem fähig! Vergiss das nie! ⭐",
+    ],
+    "fr": [
+        "Hé! Tu vas y arriver! Je crois en toi! 💪",
+        "Rappelle-toi: Chaque jour est un nouveau départ! 🌅",
+        "Tu es capable de choses incroyables! N'oublie jamais ça! ⭐",
+    ],
+    "es": [
+        "¡Oye! ¡Tú puedes! ¡Creo en ti! 💪",
+        "Recuerda: ¡Cada día es un nuevo comienzo! 🌅",
+        "¡Eres capaz de cosas increíbles! ¡Nunca lo olvides! ⭐",
+    ],
+    "it": [
+        "Ehi! Ce la puoi fare! Credo in te! 💪",
+        "Ricorda: Ogni giorno è un nuovo inizio! 🌅",
+        "Sei capace di cose straordinarie! Non dimenticarlo mai! ⭐",
+    ],
+    "pt": [
+        "Ei! Você consegue! Eu acredito em você! 💪",
+        "Lembre-se: Cada dia é um novo começo! 🌅",
+        "Você é capaz de coisas incríveis! Nunca esqueça isso! ⭐",
+    ],
+    "ja": [
+        "ねえ！君ならできる！信じてるよ！💪",
+        "覚えておいて：毎日が新しいスタート！🌅",
+        "君は素晴らしいことができる！それを忘れないで！⭐",
+    ],
+    "ko": [
+        "야! 넌 할 수 있어! 난 널 믿어! 💪",
+        "기억해: 매일이 새로운 시작이야! 🌅",
+        "넌 놀라운 일을 할 수 있어! 절대 잊지 마! ⭐",
+    ],
+    "zh": [
+        "嘿！你能行的！我相信你！💪",
+        "记住：每一天都是新的开始！🌅",
+        "你有能力做出惊人的事情！永远不要忘记！⭐",
+    ],
+}
+
+# =============================================================================
+# System Messages (enable/disable, status)
+# =============================================================================
+
+SYSTEM_MESSAGES = {
+    "enable_welcome": {
+        "en": "Yay! TamaReachy is activated! {emoji} Take good care of me!",
+        "nl": "Joepie! TamaReachy is geactiveerd! {emoji} Zorg goed voor me!",
+        "de": "Juhu! TamaReachy ist aktiviert! {emoji} Kümmere dich gut um mich!",
+        "fr": "Youpi! TamaReachy est activé! {emoji} Prends bien soin de moi!",
+        "es": "¡Yuju! ¡TamaReachy está activado! {emoji} ¡Cuida bien de mí!",
+        "it": "Evviva! TamaReachy è attivato! {emoji} Prenditi cura di me!",
+        "pt": "Eba! TamaReachy está ativado! {emoji} Cuide bem de mim!",
+        "ja": "やったー！TamaReachyが起動したよ！{emoji} よろしくね！",
+        "ko": "야호! TamaReachy가 활성화됐어! {emoji} 잘 돌봐줘!",
+        "zh": "耶！TamaReachy激活了！{emoji} 好好照顾我！",
+    },
+    "disable_goodbye": {
+        "en": "Goodbye for now... I'll miss you! 😢",
+        "nl": "Tot ziens voor nu... Ik zal je missen! 😢",
+        "de": "Auf Wiedersehen für jetzt... Ich werde dich vermissen! 😢",
+        "fr": "Au revoir pour l'instant... Tu vas me manquer! 😢",
+        "es": "Adiós por ahora... ¡Te extrañaré! 😢",
+        "it": "Arrivederci per ora... Mi mancherai! 😢",
+        "pt": "Tchau por agora... Vou sentir sua falta! 😢",
+        "ja": "じゃあね...寂しくなるよ！😢",
+        "ko": "잠시 안녕... 보고 싶을 거야! 😢",
+        "zh": "暂时再见...我会想你的！😢",
+    },
+    "status_sleeping": {
+        "en": "TamaReachy is sleeping. Enable me to play!",
+        "nl": "TamaReachy slaapt. Activeer me om te spelen!",
+        "de": "TamaReachy schläft. Aktiviere mich zum Spielen!",
+        "fr": "TamaReachy dort. Active-moi pour jouer!",
+        "es": "TamaReachy está durmiendo. ¡Actívame para jugar!",
+        "it": "TamaReachy sta dormendo. Attivami per giocare!",
+        "pt": "TamaReachy está dormindo. Ative-me para brincar!",
+        "ja": "TamaReachyは寝てるよ。起こして遊ぼう！",
+        "ko": "TamaReachy가 자고 있어. 깨워서 놀자!",
+        "zh": "TamaReachy在睡觉。激活我来玩吧！",
+    },
+    "status_mood": {
+        "en": "I'm feeling {mood}! {emoji}",
+        "nl": "Ik voel me {mood}! {emoji}",
+        "de": "Ich fühle mich {mood}! {emoji}",
+        "fr": "Je me sens {mood}! {emoji}",
+        "es": "¡Me siento {mood}! {emoji}",
+        "it": "Mi sento {mood}! {emoji}",
+        "pt": "Estou me sentindo {mood}! {emoji}",
+        "ja": "{mood}な気分！{emoji}",
+        "ko": "{mood} 기분이야! {emoji}",
+        "zh": "我感觉{mood}！{emoji}",
+    },
+    "disable_message": {
+        "en": "TamaReachy has been disabled. Enable it anytime to resume!",
+        "nl": "TamaReachy is uitgeschakeld. Activeer het wanneer je maar wilt!",
+        "de": "TamaReachy wurde deaktiviert. Aktiviere es jederzeit wieder!",
+        "fr": "TamaReachy a été désactivé. Réactive-le quand tu veux!",
+        "es": "TamaReachy ha sido desactivado. ¡Actívalo cuando quieras!",
+        "it": "TamaReachy è stato disattivato. Riattivalo quando vuoi!",
+        "pt": "TamaReachy foi desativado. Ative quando quiser!",
+        "ja": "TamaReachyは無効になりました。いつでも再開できます！",
+        "ko": "TamaReachy가 비활성화됐어. 언제든 다시 활성화해!",
+        "zh": "TamaReachy已禁用。随时启用即可恢复！",
+    },
+}
+
+# Mood translations
+MOOD_TRANSLATIONS = {
+    "ecstatic": {
+        "en": "ecstatic", "nl": "extatisch", "de": "überglücklich", "fr": "extatique",
+        "es": "eufórico", "it": "euforico", "pt": "extasiado", "ja": "大喜び",
+        "ko": "황홀한", "zh": "狂喜",
+    },
+    "happy": {
+        "en": "happy", "nl": "blij", "de": "glücklich", "fr": "heureux",
+        "es": "feliz", "it": "felice", "pt": "feliz", "ja": "嬉しい",
+        "ko": "행복한", "zh": "开心",
+    },
+    "content": {
+        "en": "content", "nl": "tevreden", "de": "zufrieden", "fr": "content",
+        "es": "contento", "it": "contento", "pt": "contente", "ja": "満足",
+        "ko": "만족한", "zh": "满足",
+    },
+    "meh": {
+        "en": "meh", "nl": "mwah", "de": "meh", "fr": "bof",
+        "es": "meh", "it": "così così", "pt": "assim assim", "ja": "まあまあ",
+        "ko": "그저 그래", "zh": "一般般",
+    },
+    "sad": {
+        "en": "sad", "nl": "verdrietig", "de": "traurig", "fr": "triste",
+        "es": "triste", "it": "triste", "pt": "triste", "ja": "悲しい",
+        "ko": "슬픈", "zh": "伤心",
+    },
+    "miserable": {
+        "en": "miserable", "nl": "ellendig", "de": "elend", "fr": "misérable",
+        "es": "miserable", "it": "miserabile", "pt": "miserável", "ja": "みじめ",
+        "ko": "비참한", "zh": "痛苦",
+    },
+}
+
+
+# =============================================================================
+# Helper Functions
+# =============================================================================
+
+def get_message(messages_dict: dict, language: str) -> str:
+    """Get a random message from a dictionary in the specified language.
+    
+    Falls back to English if translation not available.
+    
+    Args:
+        messages_dict: Dictionary with language codes as keys and message lists as values.
+        language: Language code (e.g., 'en', 'nl', 'de').
+        
+    Returns:
+        A random message in the specified language.
+    """
+    import random
+    
+    messages = messages_dict.get(language, messages_dict.get("en", ["..."]))
+    return random.choice(messages)
+
+
+def get_request_message(need: str, language: str) -> str:
+    """Get a request message for a specific need in the specified language.
+    
+    Args:
+        need: The need type (hunger, thirst, etc.).
+        language: Language code.
+        
+    Returns:
+        A request message.
+    """
+    import random
+    
+    need_messages = REQUEST_MESSAGES.get(need, {})
+    messages = need_messages.get(language, need_messages.get("en", [f"I need help with my {need}!"]))
+    return random.choice(messages)
+
+
+def get_care_response(action: str, language: str) -> str:
+    """Get a care response message for an action in the specified language.
+    
+    Args:
+        action: The care action (feed, water, etc.).
+        language: Language code.
+        
+    Returns:
+        A response message.
+    """
+    import random
+    
+    action_responses = CARE_RESPONSES.get(action, {})
+    messages = action_responses.get(language, action_responses.get("en", ["Thanks! That helped!"]))
+    return random.choice(messages)
+
+
+def get_idle_message(language: str) -> str:
+    """Get a random idle message in the specified language."""
+    return get_message(IDLE_MESSAGES, language)
+
+
+def get_fun_fact(language: str) -> str:
+    """Get a random fun fact in the specified language."""
+    return get_message(FUN_FACTS, language)
+
+
+def get_motivational_message(language: str) -> str:
+    """Get a random motivational message in the specified language."""
+    return get_message(MOTIVATIONAL_MESSAGES, language)
+
+
+def get_system_message(message_key: str, language: str, **kwargs) -> str:
+    """Get a system message in the specified language.
+    
+    Args:
+        message_key: Key in SYSTEM_MESSAGES (e.g., 'enable_welcome').
+        language: Language code.
+        **kwargs: Format arguments for the message.
+        
+    Returns:
+        Formatted system message.
+    """
+    messages = SYSTEM_MESSAGES.get(message_key, {})
+    message = messages.get(language, messages.get("en", ""))
+    
+    if kwargs:
+        try:
+            return message.format(**kwargs)
+        except KeyError:
+            return message
+    return message
+
+
+def get_translated_mood(mood_name: str, language: str) -> str:
+    """Get translated mood name.
+    
+    Args:
+        mood_name: English mood name.
+        language: Target language code.
+        
+    Returns:
+        Translated mood name.
+    """
+    mood_dict = MOOD_TRANSLATIONS.get(mood_name, {})
+    return mood_dict.get(language, mood_dict.get("en", mood_name))
+

reachys_brain/tts_service.py

@@ -3,6 +3,7 @@
 import asyncio
 import logging
 import os
+import shutil
 import subprocess
 import threading
 from dataclasses import dataclass
@@ -10,6 +11,8 @@ from typing import Callable, Optional
 
 import httpx
 
+from .audio_playback import is_kids_mode_enabled, KIDS_MODE_PITCH_CENTS, KIDS_MODE_TEMPO
+
 logger = logging.getLogger(__name__)
 
 # OpenAI TTS API endpoint
@@ -137,9 +140,17 @@ class TTSService:
     def _play_audio_sync(self, audio_data: bytes) -> None:
         """Play PCM audio data through Reachy's speaker synchronously.
         
+        Applies pitch shifting when kids mode is enabled.
+        
         Args:
             audio_data: Raw PCM16 audio at 24kHz mono.
         """
+        # Check if kids mode is enabled and sox is available
+        use_pitch_shift = is_kids_mode_enabled() and shutil.which("sox") is not None
+        
+        if is_kids_mode_enabled() and not shutil.which("sox"):
+            logger.warning("🧒 Kids mode enabled but sox not found, using normal playback")
+        
         # OpenAI TTS PCM format: 24kHz, 16-bit signed little-endian, mono
         aplay_cmd = [
             "aplay",
@@ -151,31 +162,98 @@ class TTSService:
             "-q",
         ]
         
-        self._current_process = subprocess.Popen(
-            aplay_cmd,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
+        sox_process: Optional[subprocess.Popen] = None
         
         try:
-            stdout, stderr = self._current_process.communicate(
-                input=audio_data,
-                timeout=120,  # Long timeout for extended speech
-            )
-            
-            if self._current_process.returncode != 0 and not self._stop_requested:
-                error_msg = stderr.decode() if stderr else "Unknown error"
-                logger.error(f"aplay failed: {error_msg}")
+            if use_pitch_shift:
+                # sox command for pitch shifting
+                sox_cmd = [
+                    "sox",
+                    "-t", "raw",
+                    "-r", "24000",
+                    "-e", "signed",
+                    "-b", "16",
+                    "-c", "1",
+                    "-",  # Input from stdin
+                    "-t", "raw",
+                    "-",  # Output to stdout
+                    "pitch", str(KIDS_MODE_PITCH_CENTS),
+                    "tempo", str(KIDS_MODE_TEMPO),
+                ]
+                
+                # Create sox process
+                sox_process = subprocess.Popen(
+                    sox_cmd,
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+                
+                # Create aplay process reading from sox output
+                self._current_process = subprocess.Popen(
+                    aplay_cmd,
+                    stdin=sox_process.stdout,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+                
+                # Close sox stdout in parent so aplay gets EOF when sox closes
+                if sox_process.stdout:
+                    sox_process.stdout.close()
+                
+                # Write audio to sox
+                if sox_process.stdin:
+                    sox_process.stdin.write(audio_data)
+                    sox_process.stdin.close()
+                
+                # Wait for both processes
+                sox_process.wait(timeout=120)
+                self._current_process.wait(timeout=120)
+                
+                logger.info(f"🧒 Played audio with kids mode pitch shift +{KIDS_MODE_PITCH_CENTS} cents")
+            else:
+                # Normal playback without pitch shifting
+                self._current_process = subprocess.Popen(
+                    aplay_cmd,
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+                
+                stdout, stderr = self._current_process.communicate(
+                    input=audio_data,
+                    timeout=120,
+                )
+                
+                if self._current_process.returncode != 0 and not self._stop_requested:
+                    error_msg = stderr.decode() if stderr else "Unknown error"
+                    logger.error(f"aplay failed: {error_msg}")
+                    
         except subprocess.TimeoutExpired:
-            self._current_process.kill()
+            if sox_process:
+                sox_process.kill()
+            if self._current_process:
+                self._current_process.kill()
             logger.error("Audio playback timeout")
+        except Exception as e:
+            logger.error(f"Error in audio playback: {e}")
         finally:
+            # Clean up sox process
+            if sox_process:
+                try:
+                    sox_process.terminate()
+                    sox_process.wait(timeout=1)
+                except Exception:
+                    try:
+                        sox_process.kill()
+                    except Exception:
+                        pass
             self._current_process = None
     
     def speak(
         self,
         text: str,
+        voice_override: str | None = None,
         on_start: Callable[[], None] | None = None,
         on_end: Callable[[], None] | None = None,
     ) -> float:
@@ -197,8 +275,8 @@ class TTSService:
             self._stop_requested = False
         
         try:
-            # Get current voice from settings
-            voice = self._get_current_voice()
+            # Get current voice from settings (unless explicitly overridden)
+            voice = voice_override or self._get_current_voice()
             
             # Fetch audio from OpenAI
             audio_data = self._fetch_audio_sync(text, voice)
@@ -230,6 +308,7 @@ class TTSService:
     def speak_async(
         self,
         text: str,
+        voice_override: str | None = None,
         on_start: Callable[[], None] | None = None,
         on_end: Callable[[], None] | None = None,
     ) -> float:
@@ -249,7 +328,7 @@ class TTSService:
         
         def _speak_thread():
             try:
-                self.speak(text, on_start, on_end)
+                self.speak(text, voice_override=voice_override, on_start=on_start, on_end=on_end)
             except Exception as e:
                 logger.error(f"Async TTS error: {e}")