Cleanup, fixes, logger

src/reachy_mini_conversation_demo/audio/speech_tapper.py

@@ -120,7 +120,6 @@ class SwayRollRT:
         self._seed = int(rng_seed)
         self.samples = deque(maxlen=10 * SR)  # sliding window for VAD/env
         self.carry = np.zeros(0, dtype=np.float32)
-        self.frame_idx = 0
 
         self.vad_on = False
         self.vad_above = 0
@@ -143,7 +142,6 @@ class SwayRollRT:
         """Reset state (VAD/env/buffers/time) but keep initial phases/seed."""
         self.samples.clear()
         self.carry = np.zeros(0, dtype=np.float32)
-        self.frame_idx = 0
         self.vad_on = False
         self.vad_above = 0
         self.vad_below = 0
@@ -152,16 +150,6 @@ class SwayRollRT:
         self.sway_down = 0
         self.t = 0.0
 
-    def reset_phases(self) -> None:
-        """Re-randomize phases deterministically from stored seed (Optional)."""
-        rng = np.random.default_rng(self._seed)
-        self.phase_pitch = float(rng.random() * 2 * math.pi)
-        self.phase_yaw = float(rng.random() * 2 * math.pi)
-        self.phase_roll = float(rng.random() * 2 * math.pi)
-        self.phase_x = float(rng.random() * 2 * math.pi)
-        self.phase_y = float(rng.random() * 2 * math.pi)
-        self.phase_z = float(rng.random() * 2 * math.pi)
-
     def feed(self, pcm: np.ndarray, sr: Optional[int]) -> List[Dict[str, float]]:
         """Stream in PCM chunk. Returns a list of sway dicts, one per hop (HOP_MS).
 
@@ -196,7 +184,6 @@ class SwayRollRT:
             self.samples.extend(hop.tolist())
             if len(self.samples) < FRAME:
                 self.t += HOP_MS / 1000.0
-                self.frame_idx += 1
                 continue
 
             frame = np.fromiter(

src/reachy_mini_conversation_demo/camera_worker.py

@@ -229,7 +229,7 @@ class CameraWorker:
                 time.sleep(0.01)
 
             except Exception as e:
-                logger.error(f"Camera worker error: {e}")
+                logger.exception(f"Camera worker error: {e}")
                 time.sleep(0.1)  # Longer sleep on error
 
         logger.debug("Camera worker thread exited")

src/reachy_mini_conversation_demo/config.py

@@ -1,17 +1,28 @@
 import os
+import logging
+from pathlib import Path
 
 from dotenv import load_dotenv
 
 
-load_dotenv()
+logger = logging.getLogger(__name__)
 
+# Check if .env file exists
+env_file = Path(".env")
+if not env_file.exists():
+    raise RuntimeError(
+        ".env file not found. Please create one based on .env.example:\n"
+        "  cp .env.example .env\n"
+        "Then add your OPENAI_API_KEY to the .env file."
+    )
 
-def getenv_bool(key: str, default: bool = False) -> bool:
-    """Read env var as a Python bool (case-insensitive)."""
-    val = os.getenv(key)
-    if val is None:
-        return default
-    return val.strip().lower() in {"true", "1", "yes", "on"}
+# Load .env and verify it was loaded successfully
+if not load_dotenv():
+    raise RuntimeError(
+        "Failed to load .env file. Please ensure the file is readable and properly formatted."
+    )
+
+logger.info("Configuration loaded from .env file")
 
 
 class Config:
@@ -19,13 +30,23 @@ class Config:
 
     # Required
     OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-    if not OPENAI_API_KEY:
-        raise RuntimeError("OPENAI_API_KEY is missing in .env")
+    if OPENAI_API_KEY is None:
+        raise RuntimeError(
+            "OPENAI_API_KEY is not set in .env file. Please add it:\n"
+            "  OPENAI_API_KEY=your_api_key_here"
+        )
+    if not OPENAI_API_KEY.strip():
+        raise RuntimeError(
+            "OPENAI_API_KEY is empty in .env file. Please provide a valid API key."
+        )
 
     # Optional
     MODEL_NAME = os.getenv("MODEL_NAME", "gpt-realtime")
     HF_HOME = os.getenv("HF_HOME", "./cache")
+    LOCAL_VISION_MODEL = os.getenv("LOCAL_VISION_MODEL", "HuggingFaceTB/SmolVLM2-2.2B-Instruct")
     HF_TOKEN = os.getenv("HF_TOKEN")  # Optional, falls back to hf auth login if not set
 
+    logger.debug(f"Model: {MODEL_NAME}, HF_HOME: {HF_HOME}, Vision Model: {LOCAL_VISION_MODEL}")
+
 
 config = Config()

src/reachy_mini_conversation_demo/console.py

@@ -19,14 +19,19 @@ logger = logging.getLogger(__name__)
 class LocalStream:
     """LocalStream using Reachy Mini's recorder/player."""
 
-    def __init__(self, handler: OpenaiRealtimeHandler, robot: ReachyMini):
-        """Initialize the stream with an OpenAI realtime handler and pipelines."""
-        self.handler = handler
+    def __init__(self, deps, robot: ReachyMini):
+        """Initialize the stream with tool dependencies and robot.
+
+        Args:
+            deps: ToolDependencies for the handler
+            robot: ReachyMini robot instance
+
+        """
         self._robot = robot
         self._stop_event = asyncio.Event()
         self._tasks = []
-        # Allow the handler to flush the player queue when appropriate.
-        self.handler._clear_queue = self.clear_queue  # type: ignore[assignment]
+        # Create handler with callback to this instance's clear_audio_queue method
+        self.handler = OpenaiRealtimeHandler(deps, clear_audio_queue_callback=self.clear_audio_queue)
 
     def launch(self) -> None:
         """Start the recorder/player and run the async processing loops."""
@@ -69,7 +74,7 @@ class LocalStream:
         self._robot.media.stop_recording()
         self._robot.media.stop_playing()
 
-    def clear_queue(self) -> None:
+    def clear_audio_queue(self) -> None:
         """Flush the player's appsrc to drop any queued audio immediately."""
         logger.info("User intervention: flushing player queue")
         self.handler.output_queue = asyncio.Queue()

src/reachy_mini_conversation_demo/main.py

@@ -74,11 +74,11 @@ def main():
     )
     logger.debug(f"Chatbot avatar images: {chatbot.avatar_images}")
 
-    handler = OpenaiRealtimeHandler(deps)
-
     stream_manager = None
 
     if args.gradio:
+        # Gradio mode: no LocalStream, so no audio queue callback needed
+        handler = OpenaiRealtimeHandler(deps)
         stream = Stream(
             handler=handler,
             mode="send-receive",
@@ -92,7 +92,8 @@ def main():
         app = FastAPI()
         app = gr.mount_gradio_app(app, stream.ui, path="/")
     else:
-        stream_manager = LocalStream(handler, robot)
+        # Console mode: LocalStream creates handler internally with proper callback
+        stream_manager = LocalStream(deps, robot)
 
     # Each async service → its own thread/loop
     movement_manager.start()

src/reachy_mini_conversation_demo/moves.py

@@ -190,13 +190,7 @@ class MovementState:
         0.0,
     )
 
-    # Legacy movement state (for goto moves)
-    moving_start: float = 0.0
-    moving_for: float = 0.0
-
     # Status flags
-    is_playing_move: bool = False
-    is_moving: bool = False
     last_primary_pose: Optional[FullBodyPose] = None
 
     def update_activity(self) -> None:
@@ -325,7 +319,7 @@ class MovementManager:
         """
         self._command_queue.put(("queue_move", move))
 
-    def clear_queue(self) -> None:
+    def clear_move_queue(self) -> None:
         """Stop the active move and discard any queued primary moves.
 
         Thread-safe: executed by the worker thread via the command queue.
@@ -361,10 +355,6 @@ class MovementManager:
 
         return self._now() - last_activity >= self.idle_inactivity_delay
 
-    def mark_user_activity(self) -> None:
-        """Record external activity and postpone idle behaviours (thread-safe)."""
-        self._command_queue.put(("mark_activity", None))
-
     def set_listening(self, listening: bool) -> None:
         """Enable or disable listening mode without touching shared state directly.
 
@@ -427,7 +417,7 @@ class MovementManager:
                         duration_str = str(duration)
                 else:
                     duration_str = "?"
-                logger.info(
+                logger.debug(
                     "Queued move with duration %ss, queue size: %s",
                     duration_str,
                     len(self.move_queue),
@@ -438,7 +428,6 @@ class MovementManager:
             self.move_queue.clear()
             self.state.current_move = None
             self.state.move_start_time = None
-            self.state.is_playing_move = False
             self._breathing_active = False
             logger.info("Cleared move queue and stopped current move")
         elif command == "set_moving_state":
@@ -447,8 +436,6 @@ class MovementManager:
             except (TypeError, ValueError):
                 logger.warning("Invalid moving state duration: %s", payload)
                 return
-            self.state.moving_start = current_time
-            self.state.moving_for = max(0.0, duration)
             self.state.update_activity()
         elif command == "mark_activity":
             self.state.update_activity()
@@ -534,7 +521,7 @@ class MovementManager:
             self.state.current_move = None
             self.state.move_start_time = None
             self._breathing_active = False
-            logger.info("Stopping breathing due to new move activity")
+            logger.debug("Stopping breathing due to new move activity")
 
         if self.state.current_move is not None and not isinstance(self.state.current_move, BreathingMove):
             self._breathing_active = False
@@ -561,14 +548,9 @@ class MovementManager:
                 float(body_yaw),
             )
 
-            self.state.is_playing_move = True
-            self.state.is_moving = True
             self.state.last_primary_pose = clone_full_body_pose(primary_full_body_pose)
         else:
             # Otherwise reuse the last primary pose so we avoid jumps between moves
-            self.state.is_playing_move = False
-            self.state.is_moving = current_time - self.state.moving_start < self.state.moving_for
-
             if self.state.last_primary_pose is not None:
                 primary_full_body_pose = clone_full_body_pose(self.state.last_primary_pose)
             else:
@@ -746,7 +728,6 @@ class MovementManager:
             self._thread.join()
             self._thread = None
         logger.debug("Move worker stopped")
-        logger.debug("Move worker stopped")
 
     def get_status(self) -> dict[str, Any]:
         """Return a lightweight status snapshot for observability."""

src/reachy_mini_conversation_demo/openai_realtime.py

@@ -15,6 +15,7 @@ from reachy_mini_conversation_demo.tools import (
     dispatch_tool_call,
 )
 from reachy_mini_conversation_demo.config import config
+from reachy_mini_conversation_demo.prompts import SESSION_INSTRUCTIONS
 
 
 logger = logging.getLogger(__name__)
@@ -23,19 +24,28 @@ logger = logging.getLogger(__name__)
 class OpenaiRealtimeHandler(AsyncStreamHandler):
     """An OpenAI realtime handler for fastrtc Stream."""
 
-    def __init__(self, deps: ToolDependencies):
-        """Initialize the handler."""
+    def __init__(self, deps: ToolDependencies, clear_audio_queue_callback=None):
+        """Initialize the handler.
+
+        Args:
+            deps: Tool dependencies for executing tools
+            clear_audio_queue_callback: Optional callback to clear the audio queue when speech starts
+
+        """
         super().__init__(
             expected_layout="mono",
             output_sample_rate=24000,  # openai outputs
             input_sample_rate=16000,  # respeaker output
         )
         self.deps = deps
+        self._clear_audio_queue_callback = clear_audio_queue_callback
 
         self.connection = None
         self.output_queue = asyncio.Queue()
 
         self._pending_calls: dict[str, dict] = {}
+        self._response_in_progress = False
+        self._pending_response_queue = asyncio.Queue()
 
         self.last_activity_time = asyncio.get_event_loop().time()
         self.start_time = asyncio.get_event_loop().time()
@@ -43,7 +53,7 @@ class OpenaiRealtimeHandler(AsyncStreamHandler):
 
     def copy(self):
         """Create a copy of the handler."""
-        return OpenaiRealtimeHandler(self.deps)
+        return OpenaiRealtimeHandler(self.deps, self._clear_audio_queue_callback)
 
     async def start_up(self):
         """Start the handler."""
@@ -59,7 +69,7 @@ class OpenaiRealtimeHandler(AsyncStreamHandler):
                         "language": "en",
                     },
                     "voice": "ballad",
-                    "instructions": "We speak in English",
+                    "instructions": SESSION_INSTRUCTIONS,
                     "tools": ALL_TOOL_SPECS,
                     "tool_choice": "auto",
                     "temperature": 0.7,
@@ -71,14 +81,15 @@ class OpenaiRealtimeHandler(AsyncStreamHandler):
             async for event in self.connection:
                 logger.debug(f"OpenAI event: {event.type}")
                 if event.type == "input_audio_buffer.speech_started":
-                    self.clear_queue()
+                    if self._clear_audio_queue_callback:
+                        self._clear_audio_queue_callback()
                     self.deps.head_wobbler.reset()
                     self.deps.movement_manager.set_listening(True)
-                    logger.debug("user speech started")
+                    logger.debug("User speech started")
 
                 if event.type == "input_audio_buffer.speech_stopped":
                     self.deps.movement_manager.set_listening(False)
-                    logger.debug("user speech stopped")
+                    logger.debug("User speech stopped")
 
                 if event.type in ("response.audio.completed", "response.completed"):
                     # Doesn't seem to be called
@@ -87,19 +98,27 @@ class OpenaiRealtimeHandler(AsyncStreamHandler):
 
                 if event.type == "response.created":
                     logger.debug("response created")
+                    self._response_in_progress = True
 
                 if event.type == "response.done":
                     # Doesn't mean the audio is done playing
                     logger.debug("response done")
-                    pass
-                    # self.deps.head_wobbler.reset()
+                    self._response_in_progress = False
+                    # Process any queued response requests
+                    if not self._pending_response_queue.empty():
+                        queued_params = await self._pending_response_queue.get()
+                        logger.debug("Processing queued response request")
+                        try:
+                            await self.connection.response.create(**queued_params)
+                        except Exception as e:
+                            logger.error(f"Failed to create queued response: {e}")
 
                 if event.type == "conversation.item.input_audio_transcription.completed":
-                    logger.debug(f"user transcript: {event.transcript}")
+                    logger.debug(f"User transcript: {event.transcript}")
                     await self.output_queue.put(AdditionalOutputs({"role": "user", "content": event.transcript}))
 
                 if event.type == "response.audio_transcript.done":
-                    logger.debug(f"assistant transcript: {event.transcript}")
+                    logger.debug(f"Assistant transcript: {event.transcript}")
                     await self.output_queue.put(AdditionalOutputs({"role": "assistant", "content": event.transcript}))
 
                 if event.type == "response.audio.delta":
@@ -144,10 +163,10 @@ class OpenaiRealtimeHandler(AsyncStreamHandler):
 
                     try:
                         tool_result = await dispatch_tool_call(tool_name, args_json_str, self.deps)
-                        logger.debug("[Tool %s executed]", tool_name)
+                        logger.debug("Tool '%s' executed successfully", tool_name)
                         logger.debug("Tool result: %s", tool_result)
                     except Exception as e:
-                        logger.error("Tool %s failed", tool_name)
+                        logger.exception("Tool '%s' failed", tool_name)
                         tool_result = {"error": str(e)}
 
                     # send the tool result back
@@ -183,7 +202,7 @@ class OpenaiRealtimeHandler(AsyncStreamHandler):
                                 ],
                             }
                         )
-                        logger.info("additional input camera")
+                        logger.info("Added camera image to conversation")
 
                         np_img = self.deps.camera_worker.get_latest_frame()
                         img = gr.Image(value=np_img)
@@ -198,7 +217,7 @@ class OpenaiRealtimeHandler(AsyncStreamHandler):
                         )
 
                     if not self.is_idle_tool_call:
-                        await self.connection.response.create(
+                        await self._safe_create_response(
                             response={
                                 "instructions": "Use the tool result just returned and answer concisely in speech."
                             }
@@ -215,8 +234,18 @@ class OpenaiRealtimeHandler(AsyncStreamHandler):
                 if event.type == "error":
                     err = getattr(event, "error", None)
                     msg = getattr(err, "message", str(err) if err else "unknown error")
-                    logger.error("Realtime error: %s (raw=%s)", msg, err)
-                    await self.output_queue.put(AdditionalOutputs({"role": "assistant", "content": f"[error] {msg}"}))
+                    err_code = getattr(err, "code", None)
+                    
+                    # Handle concurrent response error gracefully
+                    if err_code == "conversation_already_has_active_response":
+                        logger.warning(
+                            "Attempted to create response while one is in progress. "
+                            "This is expected during rapid tool calls and will be handled automatically."
+                        )
+                        # Don't send error to user for this specific case
+                    else:
+                        logger.error("Realtime error: %s (raw=%s)", msg, err)
+                        await self.output_queue.put(AdditionalOutputs({"role": "assistant", "content": f"[error] {msg}"}))
 
     # Microphone receive
     async def receive(self, frame: tuple[int, np.ndarray]) -> None:
@@ -256,6 +285,28 @@ class OpenaiRealtimeHandler(AsyncStreamHandler):
         dt = datetime.fromtimestamp(current_time)
         return f"[{dt.strftime('%Y-%m-%d %H:%M:%S')} | +{elapsed_seconds:.1f}s]"
 
+    async def _safe_create_response(self, **kwargs) -> None:
+        """Safely create a response, queuing if one is already in progress.
+        
+        Args:
+            **kwargs: Arguments to pass to connection.response.create()
+        
+        """
+        if self._response_in_progress:
+            logger.debug("Response already in progress, queuing request (expected during rapid tool calls)")
+            await self._pending_response_queue.put(kwargs)
+        else:
+            try:
+                await self.connection.response.create(**kwargs)
+            except Exception as e:
+                error_msg = str(e)
+                if "conversation_already_has_active_response" in error_msg:
+                    logger.warning("Race condition detected, queuing response request")
+                    await self._pending_response_queue.put(kwargs)
+                else:
+                    logger.error(f"Failed to create response: {e}")
+                    raise
+
     async def send_idle_signal(self, idle_duration) -> None:
         """Send an idle signal to the openai server."""
         logger.debug("Sending idle signal")
@@ -271,11 +322,10 @@ class OpenaiRealtimeHandler(AsyncStreamHandler):
                 "content": [{"type": "input_text", "text": timestamp_msg}],
             }
         )
-        await self.connection.response.create(
+        await self._safe_create_response(
             response={
                 "modalities": ["text"],
                 "instructions": "You MUST respond with function calls only - no speech or text. Choose appropriate actions for idle behavior.",
                 "tool_choice": "required",
             }
         )
-        # TODO additional inputs

src/reachy_mini_conversation_demo/tools.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 import abc
 import json
-import time
 import asyncio
 import inspect
 import logging
@@ -12,12 +11,8 @@ from reachy_mini import ReachyMini
 from reachy_mini.utils import create_head_pose
 
 
-# from reachy_mini_conversation_demo.vision.processors import VisionManager
-
 logger = logging.getLogger(__name__)
 
-ENABLE_FACE_RECOGNITION = False
-
 # Initialize dance and emotion libraries
 try:
     from reachy_mini.motion.recorded_move import RecordedMoves
@@ -40,16 +35,6 @@ except ImportError as e:
     DANCE_AVAILABLE = False
     EMOTION_AVAILABLE = False
 
-FACE_RECOGNITION_AVAILABLE = False
-if ENABLE_FACE_RECOGNITION:
-    # Initialize face recognition
-    try:
-        from deepface import DeepFace
-
-        FACE_RECOGNITION_AVAILABLE = True
-    except ImportError as e:
-        logger.warning(f"DeepFace not available: {e}")
-
 
 def all_concrete_subclasses(base):
     """Recursively find all concrete (non-abstract) subclasses of a base class."""
@@ -76,30 +61,9 @@ class ToolDependencies:
     camera_worker: Optional[Any] = None  # CameraWorker for frame buffering
     vision_manager: Optional[Any] = None
     head_wobbler: Optional[Any] = None  # HeadWobbler for audio-reactive motion
-    camera_retry_attempts: int = 5
-    camera_retry_delay_s: float = 0.10
-    vision_timeout_s: float = 8.0
     motion_duration_s: float = 1.0
 
 
-# Helpers - removed _read_frame as it's no longer needed with camera worker
-
-
-def _execute_motion(deps: ToolDependencies, target: Any) -> Dict[str, Any]:
-    """Apply motion to reachy_mini and update movement_manager state."""
-    movement_manager = deps.movement_manager
-    movement_manager.moving_start = time.monotonic()
-    movement_manager.moving_for = deps.motion_duration_s
-    movement_manager.current_head_pose = target
-    try:
-        deps.reachy_mini.goto_target(target, duration=deps.motion_duration_s)
-    except Exception as e:
-        logger.exception("motion failed")
-        return {"error": f"motion failed: {type(e).__name__}: {e}"}
-
-    return {"status": "ok"}
-
-
 # Tool base class
 class Tool(abc.ABC):
     """Base abstraction for tools used in function-calling.
@@ -277,100 +241,6 @@ class HeadTracking(Tool):
         return {"status": f"head tracking {status}"}
 
 
-# class DescribeCurrentScene(Tool):
-#     name = "describe_current_scene"
-#     description = "Get a detailed description of the current scene."
-#     parameters_schema = {"type": "object", "properties": {}, "required": []}
-
-#     async def __call__(self, deps: ToolDependencies, **kwargs) -> Dict[str, Any]:
-#         logger.info("Tool call: describe_current_scene")
-
-#         result = await deps.vision_manager.process_current_frame(
-#             "Describe what you currently see in detail, focusing on people, objects, and activities."
-#         )
-
-#         if isinstance(result, dict) and "error" in result:
-#             return result
-#         return result
-
-
-# class GetSceneContext(Tool):
-#     name = "get_scene_context"
-#     description = (
-#         "Get the most recent automatic scene description for conversational context."
-#     )
-#     parameters_schema = {"type": "object", "properties": {}, "required": []}
-
-#     async def __call__(self, deps: ToolDependencies, **kwargs) -> Dict[str, Any]:
-#         logger.info("Tool call: get_scene_context")
-#         vision_manager = deps.vision_manager
-#         if not vision_manager:
-#             return {"error": "Vision processing not available"}
-
-#         try:
-#             description = await deps.vision_manager.get_current_description()
-
-#             if not description:
-#                 return {
-#                     "context": "No scene description available yet",
-#                     "note": "Vision processing may still be initializing",
-#                 }
-#             return {
-#                 "context": description,
-#                 "note": "This comes from periodic automatic analysis",
-#             }
-#         except Exception as e:
-#             logger.exception("Failed to get scene context")
-#             return {"error": f"Scene context failed: {type(e).__name__}: {e}"}
-
-
-# class AnalyzeSceneFor(Tool):
-#     name = "analyze_scene_for"
-#     description = "Analyze the current scene for a specific purpose."
-#     parameters_schema = {
-#         "type": "object",
-#         "properties": {
-#             "purpose": {
-#                 "type": "string",
-#                 "enum": [
-#                     "safety",
-#                     "people",
-#                     "objects",
-#                     "activity",
-#                     "navigation",
-#                     "general",
-#                 ],
-#                 "default": "general",
-#             }
-#         },
-#         "required": [],
-#     }
-
-#     async def __call__(self, deps: ToolDependencies, **kwargs) -> Dict[str, Any]:
-#         purpose = (kwargs.get("purpose") or "general").lower()
-#         logger.info("Tool call: analyze_scene_for purpose=%s", purpose)
-
-#         prompts = {
-#             "safety": "Look for safety concerns, obstacles, or hazards.",
-#             "people": "Describe people, their positions and actions.",
-#             "objects": "Identify and describe main visible objects.",
-#             "activity": "Describe ongoing activities or actions.",
-#             "navigation": "Describe the space for navigation: obstacles, pathways, layout.",
-#             "general": "Give a general description of the scene including people, objects, and activities.",
-#         }
-#         prompt = prompts.get(purpose, prompts["general"])
-
-#         result = await deps.vision_manager.process_current_frame(prompt)
-
-#         if isinstance(result, dict) and "error" in result:
-#             return result
-
-#         if not isinstance(result, dict):
-#             return {"error": "vision returned non-dict"}
-
-#         result["analysis_purpose"] = purpose
-#         return result
-
 
 class Dance(Tool):
     """Play a named or random dance move once (or repeat). Non-blocking."""
@@ -461,25 +331,24 @@ class StopDance(Tool):
         """Stop the current dance move."""
         logger.info("Tool call: stop_dance")
         movement_manager = deps.movement_manager
-        movement_manager.clear_queue()
+        movement_manager.clear_move_queue()
         return {"status": "stopped dance and cleared queue"}
 
 
-def get_available_emotions_and_descriptions():
+def get_available_emotions_and_descriptions() -> str:
     """Get formatted list of available emotions with descriptions."""
-    names = RECORDED_MOVES.list_moves()
-
-    ret = """
-    Available emotions:
-
-    """
-
-    for name in names:
-        description = RECORDED_MOVES.get(name).description
-        ret += f" - {name}: {description}\n"
-
-    return ret
+    if not EMOTION_AVAILABLE:
+        return "Emotions not available"
 
+    try:
+        names = RECORDED_MOVES.list_moves()
+        ret = "Available emotions:\n"
+        for name in names:
+            description = RECORDED_MOVES.get(name).description
+            ret += f" - {name}: {description}\n"
+        return ret
+    except Exception as e:
+        return f"Error getting emotions: {e}"
 
 class PlayEmotion(Tool):
     """Play a pre-recorded emotion."""
@@ -549,70 +418,10 @@ class StopEmotion(Tool):
         """Stop the current emotion."""
         logger.info("Tool call: stop_emotion")
         movement_manager = deps.movement_manager
-        movement_manager.clear_queue()
+        movement_manager.clear_move_queue()
         return {"status": "stopped emotion and cleared queue"}
 
 
-class FaceRecognition(Tool):
-    """Get the name of the person you are talking to."""
-
-    name = "get_person_name"
-    description = "Get the name of the person you are talking to"
-    parameters_schema = {
-        "type": "object",
-        "properties": {
-            "dummy": {
-                "type": "boolean",
-                "description": "dummy boolean, set it to true",
-            }
-        },
-        "required": ["dummy"],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs) -> Dict[str, Any]:
-        """Get the name of the person you are talking to."""
-        if not FACE_RECOGNITION_AVAILABLE:
-            return {"error": "Face recognition not available"}
-
-        logger.info("Tool call: face_recognition")
-
-        try:
-            # Get frame from camera worker buffer (like main_works.py)
-            if deps.camera_worker is not None:
-                frame = deps.camera_worker.get_latest_frame()
-                if frame is None:
-                    logger.error("No frame available from camera worker")
-                    return {"error": "No frame available"}
-            else:
-                logger.error("Camera worker not available")
-                return {"error": "Camera worker not available"}
-
-            # Save frame temporarily (same as main_works.py pattern)
-            temp_path = "/tmp/face_recognition.jpg"
-            import cv2
-
-            cv2.imwrite(temp_path, frame)
-
-            # Use DeepFace to find face
-            results = await asyncio.to_thread(DeepFace.find, img_path=temp_path, db_path="./pollen_faces")
-
-            if len(results) == 0:
-                return {"error": "Didn't recognize the face"}
-
-            # Extract name from results
-            name = "Unknown"
-            for index, row in results[0].iterrows():
-                file_path = row["identity"]
-                name = file_path.split("/")[-2]
-                break
-
-            return {"answer": f"The name is {name}"}
-
-        except Exception as e:
-            logger.exception("Face recognition failed")
-            return {"error": f"Face recognition failed: {str(e)}"}
-
-
 class DoNothing(Tool):
     """Choose to do nothing - stay still and silent. Use when you want to be contemplative or just chill."""
 
@@ -636,22 +445,6 @@ class DoNothing(Tool):
         return {"status": "doing nothing", "reason": reason}
 
 
-def get_available_emotions_and_descriptions() -> str:
-    """Get formatted list of available emotions with descriptions."""
-    if not EMOTION_AVAILABLE:
-        return "Emotions not available"
-
-    try:
-        names = RECORDED_MOVES.list_moves()
-        ret = "Available emotions:\n"
-        for name in names:
-            description = RECORDED_MOVES.get(name).description
-            ret += f" - {name}: {description}\n"
-        return ret
-    except Exception as e:
-        return f"Error getting emotions: {e}"
-
-
 # Registry & specs (dynamic)
 
 # List of available tool classes

src/reachy_mini_conversation_demo/utils.py

@@ -3,6 +3,7 @@ import argparse
 import warnings
 
 from reachy_mini_conversation_demo.camera_worker import CameraWorker
+from reachy_mini_conversation_demo.vision.processors import initialize_vision_manager
 
 
 def parse_args():
@@ -21,26 +22,27 @@ def parse_args():
 
 
 def handle_vision_stuff(args, current_robot):
-    """Initialize camera, head tracker and camera worker."""
+    """Initialize camera, head tracker, camera worker, and vision manager."""
     camera_worker = None
     head_tracker = None
     vision_manager = None
+
     if not args.no_camera:
+        # Initialize head tracker if specified
         if args.head_tracker is not None:
             if args.head_tracker == "yolo":
-                from reachy_mini_conversation_demo.vision.yolo_head_tracker import (
-                    HeadTracker,
-                )
-
+                from reachy_mini_conversation_demo.vision.yolo_head_tracker import HeadTracker
                 head_tracker = HeadTracker()
-
             elif args.head_tracker == "mediapipe":
                 from reachy_mini_toolbox.vision import HeadTracker
-
                 head_tracker = HeadTracker()
 
+        # Initialize camera worker
         camera_worker = CameraWorker(current_robot, head_tracker)
 
+        # Initialize vision manager (handles model download and configuration)
+        vision_manager = initialize_vision_manager(camera_worker)
+
     return camera_worker, head_tracker, vision_manager
 
 

src/reachy_mini_conversation_demo/vision/yolo_head_tracker.py

@@ -94,77 +94,6 @@ class HeadTracker:
 
         return np.array([norm_x, norm_y], dtype=np.float32)
 
-    def get_eyes(self, img: np.ndarray) -> Tuple[Optional[np.ndarray], Optional[np.ndarray]]:
-        """Get eye positions (approximated from face bbox).
-
-        Note: YOLO only provides face bbox, so we estimate eye positions
-
-        Args:
-            img: Input image
-
-        Returns:
-            Tuple of (left_eye, right_eye) in [-1, 1] coordinates
-
-        """
-        h, w = img.shape[:2]
-
-        # Run YOLO inference
-        results = self.model(img, verbose=False)
-        detections = Detections.from_ultralytics(results[0])
-
-        # Select best face
-        face_idx = self._select_best_face(detections)
-        if face_idx is None:
-            return None, None
-
-        bbox = detections.xyxy[face_idx]
-
-        # Estimate eye positions from face bbox (approximate locations)
-        face_width = bbox[2] - bbox[0]
-        face_height = bbox[3] - bbox[1]
-
-        # Eye positions are roughly at 1/3 and 2/3 of face width, 1/3 of face height
-        eye_y = bbox[1] + face_height * 0.35
-        left_eye_x = bbox[0] + face_width * 0.35
-        right_eye_x = bbox[0] + face_width * 0.65
-
-        # Convert to MediaPipe coordinates
-        left_eye = np.array([(left_eye_x / w) * 2 - 1, (eye_y / h) * 2 - 1], dtype=np.float32)
-        right_eye = np.array([(right_eye_x / w) * 2 - 1, (eye_y / h) * 2 - 1], dtype=np.float32)
-
-        return left_eye, right_eye
-
-    def get_eyes_from_landmarks(self, face_landmarks) -> Tuple[np.ndarray, np.ndarray]:
-        """Compatibility method - YOLO doesn't have landmarks, so we store bbox in the object."""
-        if not hasattr(face_landmarks, "_bbox") or not hasattr(face_landmarks, "_img_shape"):
-            raise ValueError("Face landmarks object missing required attributes")
-
-        bbox = face_landmarks._bbox
-        h, w = face_landmarks._img_shape[:2]
-
-        # Estimate eyes from stored bbox
-        face_width = bbox[2] - bbox[0]
-        face_height = bbox[3] - bbox[1]
-
-        eye_y = bbox[1] + face_height * 0.35
-        left_eye_x = bbox[0] + face_width * 0.35
-        right_eye_x = bbox[0] + face_width * 0.65
-
-        left_eye = np.array([(left_eye_x / w) * 2 - 1, (eye_y / h) * 2 - 1], dtype=np.float32)
-        right_eye = np.array([(right_eye_x / w) * 2 - 1, (eye_y / h) * 2 - 1], dtype=np.float32)
-
-        return left_eye, right_eye
-
-    def get_eye_center(self, face_landmarks) -> np.ndarray:
-        """Get center point between estimated eyes."""
-        left_eye, right_eye = self.get_eyes_from_landmarks(face_landmarks)
-        return np.mean([left_eye, right_eye], axis=0)
-
-    def get_roll(self, face_landmarks) -> float:
-        """Estimate roll from eye positions (will be 0 for YOLO since we estimate symmetric eyes)."""
-        left_eye, right_eye = self.get_eyes_from_landmarks(face_landmarks)
-        return float(np.arctan2(right_eye[1] - left_eye[1], right_eye[0] - left_eye[0]))
-
     def get_head_position(self, img: np.ndarray) -> Tuple[Optional[np.ndarray], Optional[float]]:
         """Get head position from face detection.
 
@@ -204,18 +133,3 @@ class HeadTracker:
         except Exception as e:
             logger.error(f"Error in head position detection: {e}")
             return None, None
-
-    def cleanup(self):
-        """Clean up resources."""
-        if hasattr(self, "model"):
-            del self.model
-            logger.info("YOLO model cleaned up")
-
-
-class FaceLandmarks:
-    """Simple container for face detection results to maintain API compatibility."""
-
-    def __init__(self, bbox: np.ndarray, img_shape: tuple):
-        """Initialize with bounding box and image shape."""
-        self._bbox = bbox
-        self._img_shape = img_shape