New tool loading logic : basic tools are individual files in tools. For a given profile, tools are looked into tools.txt and autodiscovered locally or in the library.

src/reachy_mini_conversation_app/profiles/default/instructions.txt

@@ -0,0 +1 @@
+[default_prompt]

src/reachy_mini_conversation_app/profiles/default/tools.txt

@@ -0,0 +1,8 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+do_nothing
+head_tracking
+move_head

src/reachy_mini_conversation_app/profiles/example/instructions.txt

@@ -0,0 +1,2 @@
+[identities/witty_identity]
+[passion_for_lobster_jokes]

src/reachy_mini_conversation_app/profiles/{stone/__init__.py → example/throw_stone.py}

@@ -5,14 +5,10 @@ from typing import Any, Dict
 
 from reachy_mini_conversation_app.tools.core_tools import Tool, ToolDependencies
 
-# Import a tool from the tools library: use an alias or noqa to avoid linter errors if unused
-from reachy_mini_conversation_app.tools.sweep_look import SweepLook as SweepLook  # noqa: F401
-
 
 logger = logging.getLogger(__name__)
 
 
-# Create a custom tool
 class ThrowStone(Tool):
     """Example of custom tool call."""
 

src/reachy_mini_conversation_app/profiles/example/tools.txt

@@ -0,0 +1,15 @@
+# SELECT THE TOOLS YOU WANT TO ENABLE
+
+dance
+# stop_dance
+# play_emotion
+# stop_emotion
+# camera
+# do_nothing
+# head_tracking
+# move_head
+sweep_look
+
+# AN EXAMPLE OF A CUSTOM TOOL DEFINED LOCALLY
+throw_stone
+

src/reachy_mini_conversation_app/profiles/stone/instructions.txt

@@ -1,6 +0,0 @@
-[identities/witty_identity]
-[passion_for_lobster_jokes]
-
-You love throwing stones but you try not to be seen by others when doing it.
-You use the sweep_look tool when user asks you to check your surroundings.
-You use the throw_stone tool when user asks you to throw a stone.

src/reachy_mini_conversation_app/tools/__init__.py

@@ -1 +1,4 @@
-"""Tools library for Reachy Mini conversation app."""
+"""Tools library for Reachy Mini conversation app.
+
+Tools are now loaded dynamically based on the profile's tools.txt file.
+"""

src/reachy_mini_conversation_app/tools/camera.py

@@ -0,0 +1,67 @@
+import asyncio
+import logging
+from typing import Any, Dict
+
+from reachy_mini_conversation_app.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+
+class Camera(Tool):
+    """Take a picture with the camera and ask a question about it."""
+
+    name = "camera"
+    description = "Take a picture with the camera and ask a question about it."
+    parameters_schema = {
+        "type": "object",
+        "properties": {
+            "question": {
+                "type": "string",
+                "description": "The question to ask about the picture",
+            },
+        },
+        "required": ["question"],
+    }
+
+    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+        """Take a picture with the camera and ask a question about it."""
+        image_query = (kwargs.get("question") or "").strip()
+        if not image_query:
+            logger.warning("camera: empty question")
+            return {"error": "question must be a non-empty string"}
+
+        logger.info("Tool call: camera question=%s", image_query[:120])
+
+        # 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"}
+
+        # Use vision manager for processing if available
+        if deps.vision_manager is not None:
+            vision_result = await asyncio.to_thread(
+                deps.vision_manager.processor.process_image, frame, image_query,
+            )
+            if isinstance(vision_result, dict) and "error" in vision_result:
+                return vision_result
+            return (
+                {"image_description": vision_result}
+                if isinstance(vision_result, str)
+                else {"error": "vision returned non-string"}
+            )
+        # Return base64 encoded image like main_works.py camera tool
+        import base64
+
+        import cv2
+
+        temp_path = "/tmp/camera_frame.jpg"
+        cv2.imwrite(temp_path, frame)
+        with open(temp_path, "rb") as f:
+            b64_encoded = base64.b64encode(f.read()).decode("utf-8")
+        return {"b64_im": b64_encoded}

src/reachy_mini_conversation_app/tools/core_tools.py

@@ -2,15 +2,14 @@ from __future__ import annotations
 import abc
 import sys
 import json
-import asyncio
 import inspect
 import logging
 import importlib
-from typing import Any, Dict, List, Tuple, Literal
+from typing import Any, Dict, List
+from pathlib import Path
 from dataclasses import dataclass
 
 from reachy_mini import ReachyMini
-from reachy_mini.utils import create_head_pose
 # Import config to ensure .env is loaded before reading REACHY_MINI_CUSTOM_PROFILE
 from reachy_mini_conversation_app.config import config  # noqa: F401
 
@@ -32,27 +31,6 @@ ALL_TOOLS: Dict[str, "Tool"] = {}
 ALL_TOOL_SPECS: List[Dict[str, Any]] = []
 _TOOLS_INITIALIZED = False
 
-# Initialize dance and emotion libraries
-try:
-    from reachy_mini.motion.recorded_move import RecordedMoves
-    from reachy_mini_dances_library.collection.dance import AVAILABLE_MOVES
-    from reachy_mini_conversation_app.dance_emotion_moves import (
-        GotoQueueMove,
-        DanceQueueMove,
-        EmotionQueueMove,
-    )
-
-    # Initialize recorded moves for emotions
-    # Note: huggingface_hub automatically reads HF_TOKEN from environment variables
-    RECORDED_MOVES = RecordedMoves("pollen-robotics/reachy-mini-emotions-library")
-    DANCE_AVAILABLE = True
-    EMOTION_AVAILABLE = True
-except ImportError as e:
-    logger.warning(f"Dance/emotion libraries not available: {e}")
-    AVAILABLE_MOVES = {}
-    RECORDED_MOVES = None
-    DANCE_AVAILABLE = False
-    EMOTION_AVAILABLE = False
 
 
 def get_concrete_subclasses(base: type[Tool]) -> List[type[Tool]]:
@@ -66,10 +44,6 @@ def get_concrete_subclasses(base: type[Tool]) -> List[type[Tool]]:
     return result
 
 
-# Types & state
-Direction = Literal["left", "right", "up", "down", "front"]
-
-
 @dataclass
 class ToolDependencies:
     """External dependencies injected into tools."""
@@ -112,387 +86,67 @@ class Tool(abc.ABC):
         raise NotImplementedError
 
 
-# Concrete tools
-
-
-class MoveHead(Tool):
-    """Move head in a given direction."""
-
-    name = "move_head"
-    description = "Move your head in a given direction: left, right, up, down or front."
-    parameters_schema = {
-        "type": "object",
-        "properties": {
-            "direction": {
-                "type": "string",
-                "enum": ["left", "right", "up", "down", "front"],
-            },
-        },
-        "required": ["direction"],
-    }
-
-    # mapping: direction -> args for create_head_pose
-    DELTAS: Dict[str, Tuple[int, int, int, int, int, int]] = {
-        "left": (0, 0, 0, 0, 0, 40),
-        "right": (0, 0, 0, 0, 0, -40),
-        "up": (0, 0, 0, 0, -30, 0),
-        "down": (0, 0, 0, 0, 30, 0),
-        "front": (0, 0, 0, 0, 0, 0),
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
-        """Move head in a given direction."""
-        direction_raw = kwargs.get("direction")
-        if not isinstance(direction_raw, str):
-            return {"error": "direction must be a string"}
-        direction: Direction = direction_raw  # type: ignore[assignment]
-        logger.info("Tool call: move_head direction=%s", direction)
-
-        deltas = self.DELTAS.get(direction, self.DELTAS["front"])
-        target = create_head_pose(*deltas, degrees=True)
-
-        # Use new movement manager
-        try:
-            movement_manager = deps.movement_manager
-
-            # Get current state for interpolation
-            current_head_pose = deps.reachy_mini.get_current_head_pose()
-            _, current_antennas = deps.reachy_mini.get_current_joint_positions()
-
-            # Create goto move
-            goto_move = GotoQueueMove(
-                target_head_pose=target,
-                start_head_pose=current_head_pose,
-                target_antennas=(0, 0),  # Reset antennas to default
-                start_antennas=(
-                    current_antennas[0],
-                    current_antennas[1],
-                ),  # Skip body_yaw
-                target_body_yaw=0,  # Reset body yaw
-                start_body_yaw=current_antennas[0],  # body_yaw is first in joint positions
-                duration=deps.motion_duration_s,
-            )
-
-            movement_manager.queue_move(goto_move)
-            movement_manager.set_moving_state(deps.motion_duration_s)
-
-            return {"status": f"looking {direction}"}
-
-        except Exception as e:
-            logger.error("move_head failed")
-            return {"error": f"move_head failed: {type(e).__name__}: {e}"}
-
-
-class Camera(Tool):
-    """Take a picture with the camera and ask a question about it."""
-
-    name = "camera"
-    description = "Take a picture with the camera and ask a question about it."
-    parameters_schema = {
-        "type": "object",
-        "properties": {
-            "question": {
-                "type": "string",
-                "description": "The question to ask about the picture",
-            },
-        },
-        "required": ["question"],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
-        """Take a picture with the camera and ask a question about it."""
-        image_query = (kwargs.get("question") or "").strip()
-        if not image_query:
-            logger.warning("camera: empty question")
-            return {"error": "question must be a non-empty string"}
-
-        logger.info("Tool call: camera question=%s", image_query[:120])
-
-        # 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"}
-
-        # Use vision manager for processing if available
-        if deps.vision_manager is not None:
-            vision_result = await asyncio.to_thread(
-                deps.vision_manager.processor.process_image, frame, image_query,
-            )
-            if isinstance(vision_result, dict) and "error" in vision_result:
-                return vision_result
-            return (
-                {"image_description": vision_result}
-                if isinstance(vision_result, str)
-                else {"error": "vision returned non-string"}
-            )
-        # Return base64 encoded image like main_works.py camera tool
-        import base64
-
-        import cv2
-
-        temp_path = "/tmp/camera_frame.jpg"
-        cv2.imwrite(temp_path, frame)
-        with open(temp_path, "rb") as f:
-            b64_encoded = base64.b64encode(f.read()).decode("utf-8")
-        return {"b64_im": b64_encoded}
-
-
-class HeadTracking(Tool):
-    """Toggle head tracking state."""
-
-    name = "head_tracking"
-    description = "Toggle head tracking state."
-    parameters_schema = {
-        "type": "object",
-        "properties": {"start": {"type": "boolean"}},
-        "required": ["start"],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
-        """Enable or disable head tracking."""
-        enable = bool(kwargs.get("start"))
-
-        # Update camera worker head tracking state
-        if deps.camera_worker is not None:
-            deps.camera_worker.set_head_tracking_enabled(enable)
-
-        status = "started" if enable else "stopped"
-        logger.info("Tool call: head_tracking %s", status)
-        return {"status": f"head tracking {status}"}
-
-
-
-class Dance(Tool):
-    """Play a named or random dance move once (or repeat). Non-blocking."""
-
-    name = "dance"
-    description = "Play a named or random dance move once (or repeat). Non-blocking."
-    parameters_schema = {
-        "type": "object",
-        "properties": {
-            "move": {
-                "type": "string",
-                "description": """Name of the move; use 'random' or omit for random.
-                                    Here is a list of the available moves:
-                                        simple_nod: A simple, continuous up-and-down nodding motion.
-                                        head_tilt_roll: A continuous side-to-side head roll (ear to shoulder).
-                                        side_to_side_sway: A smooth, side-to-side sway of the entire head.
-                                        dizzy_spin: A circular 'dizzy' head motion combining roll and pitch.
-                                        stumble_and_recover: A simulated stumble and recovery with multiple axis movements. Good vibes
-                                        headbanger_combo: A strong head nod combined with a vertical bounce.
-                                        interwoven_spirals: A complex spiral motion using three axes at different frequencies.
-                                        sharp_side_tilt: A sharp, quick side-to-side tilt using a triangle waveform.
-                                        side_peekaboo: A multi-stage peekaboo performance, hiding and peeking to each side.
-                                        yeah_nod: An emphatic two-part yeah nod using transient motions.
-                                        uh_huh_tilt: A combined roll-and-pitch uh-huh gesture of agreement.
-                                        neck_recoil: A quick, transient backward recoil of the neck.
-                                        chin_lead: A forward motion led by the chin, combining translation and pitch.
-                                        groovy_sway_and_roll: A side-to-side sway combined with a corresponding roll for a groovy effect.
-                                        chicken_peck: A sharp, forward, chicken-like pecking motion.
-                                        side_glance_flick: A quick glance to the side that holds, then returns.
-                                        polyrhythm_combo: A 3-beat sway and a 2-beat nod create a polyrhythmic feel.
-                                        grid_snap: A robotic, grid-snapping motion using square waveforms.
-                                        pendulum_swing: A simple, smooth pendulum-like swing using a roll motion.
-                                        jackson_square: Traces a rectangle via a 5-point path, with sharp twitches on arrival at each checkpoint.
-                """,
-            },
-            "repeat": {
-                "type": "integer",
-                "description": "How many times to repeat the move (default 1).",
-            },
-        },
-        "required": [],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
-        """Play a named or random dance move once (or repeat). Non-blocking."""
-        if not DANCE_AVAILABLE:
-            return {"error": "Dance system not available"}
-
-        move_name = kwargs.get("move")
-        repeat = int(kwargs.get("repeat", 1))
-
-        logger.info("Tool call: dance move=%s repeat=%d", move_name, repeat)
-
-        if not move_name or move_name == "random":
-            import random
-
-            move_name = random.choice(list(AVAILABLE_MOVES.keys()))
-
-        if move_name not in AVAILABLE_MOVES:
-            return {"error": f"Unknown dance move '{move_name}'. Available: {list(AVAILABLE_MOVES.keys())}"}
-
-        # Add dance moves to queue
-        movement_manager = deps.movement_manager
-        for _ in range(repeat):
-            dance_move = DanceQueueMove(move_name)
-            movement_manager.queue_move(dance_move)
-
-        return {"status": "queued", "move": move_name, "repeat": repeat}
-
-
-class StopDance(Tool):
-    """Stop the current dance move."""
-
-    name = "stop_dance"
-    description = "Stop the current dance move"
-    parameters_schema = {
-        "type": "object",
-        "properties": {
-            "dummy": {
-                "type": "boolean",
-                "description": "dummy boolean, set it to true",
-            },
-        },
-        "required": ["dummy"],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
-        """Stop the current dance move."""
-        logger.info("Tool call: stop_dance")
-        movement_manager = deps.movement_manager
-        movement_manager.clear_move_queue()
-        return {"status": "stopped dance and cleared queue"}
-
-
-def get_available_emotions_and_descriptions() -> str:
-    """Get formatted list of available emotions with descriptions."""
-    if not EMOTION_AVAILABLE:
-        return "Emotions not available"
+# Registry & specs (dynamic)
+def _load_profile_tools() -> None:
+    """Load tools based on profile's tools.txt file."""
+    # Determine which profile to use
+    profile = config.REACHY_MINI_CUSTOM_PROFILE or "default"
+    logger.info(f"Loading tools for profile: {profile}")
+
+    # Build path to tools.txt
+    # Get the profile directory path
+    profile_module_path = Path(__file__).parent.parent / "profiles" / profile
+    tools_txt_path = profile_module_path / "tools.txt"
+
+    if not tools_txt_path.exists():
+        logger.error(f"✗ tools.txt not found at {tools_txt_path}")
+        sys.exit(1)
 
+    # Read and parse tools.txt
     try:
-        emotion_names = RECORDED_MOVES.list_moves()
-        output = "Available emotions:\n"
-        for name in emotion_names:
-            description = RECORDED_MOVES.get(name).description
-            output += f" - {name}: {description}\n"
-        return output
+        with open(tools_txt_path, "r") as f:
+            lines = f.readlines()
     except Exception as e:
-        return f"Error getting emotions: {e}"
-
-class PlayEmotion(Tool):
-    """Play a pre-recorded emotion."""
-
-    name = "play_emotion"
-    description = "Play a pre-recorded emotion"
-    parameters_schema = {
-        "type": "object",
-        "properties": {
-            "emotion": {
-                "type": "string",
-                "description": f"""Name of the emotion to play.
-                                    Here is a list of the available emotions:
-                                    {get_available_emotions_and_descriptions()}
-                                    """,
-            },
-        },
-        "required": ["emotion"],
-    }
+        logger.error(f"✗ Failed to read tools.txt: {e}")
+        sys.exit(1)
 
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
-        """Play a pre-recorded emotion."""
-        if not EMOTION_AVAILABLE:
-            return {"error": "Emotion system not available"}
+    # Parse tool names (skip comments and blank lines)
+    tool_names = []
+    for line in lines:
+        line = line.strip()
+        # Skip blank lines and comments
+        if not line or line.startswith("#"):
+            continue
+        tool_names.append(line)
 
-        emotion_name = kwargs.get("emotion")
-        if not emotion_name:
-            return {"error": "Emotion name is required"}
+    logger.info(f"Found {len(tool_names)} tools to load: {tool_names}")
 
-        logger.info("Tool call: play_emotion emotion=%s", emotion_name)
+    # Import each tool
+    for tool_name in tool_names:
+        loaded = False
 
-        # Check if emotion exists
+        # Try profile-local tool first
         try:
-            emotion_names = RECORDED_MOVES.list_moves()
-            if emotion_name not in emotion_names:
-                return {"error": f"Unknown emotion '{emotion_name}'. Available: {emotion_names}"}
-
-            # Add emotion to queue
-            movement_manager = deps.movement_manager
-            emotion_move = EmotionQueueMove(emotion_name, RECORDED_MOVES)
-            movement_manager.queue_move(emotion_move)
-
-            return {"status": "queued", "emotion": emotion_name}
-
+            profile_tool_module = f"{PROFILES_DIRECTORY}.{profile}.{tool_name}"
+            importlib.import_module(profile_tool_module)
+            logger.info(f"✓ Loaded profile-local tool: {tool_name}")
+            loaded = True
+        except ModuleNotFoundError:
+            pass  # Not in profile directory, try shared tools
         except Exception as e:
-            logger.exception("Failed to play emotion")
-            return {"error": f"Failed to play emotion: {e!s}"}
-
-
-class StopEmotion(Tool):
-    """Stop the current emotion."""
-
-    name = "stop_emotion"
-    description = "Stop the current emotion"
-    parameters_schema = {
-        "type": "object",
-        "properties": {
-            "dummy": {
-                "type": "boolean",
-                "description": "dummy boolean, set it to true",
-            },
-        },
-        "required": ["dummy"],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
-        """Stop the current emotion."""
-        logger.info("Tool call: stop_emotion")
-        movement_manager = deps.movement_manager
-        movement_manager.clear_move_queue()
-        return {"status": "stopped emotion and cleared queue"}
-
-
-class DoNothing(Tool):
-    """Choose to do nothing - stay still and silent. Use when you want to be contemplative or just chill."""
-
-    name = "do_nothing"
-    description = "Choose to do nothing - stay still and silent. Use when you want to be contemplative or just chill."
-    parameters_schema = {
-        "type": "object",
-        "properties": {
-            "reason": {
-                "type": "string",
-                "description": "Optional reason for doing nothing (e.g., 'contemplating existence', 'saving energy', 'being mysterious')",
-            },
-        },
-        "required": [],
-    }
-
-    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
-        """Do nothing - stay still and silent."""
-        reason = kwargs.get("reason", "just chilling")
-        logger.info("Tool call: do_nothing reason=%s", reason)
-        return {"status": "doing nothing", "reason": reason}
-
+            logger.warning(f"Error loading profile-local tool {tool_name}: {e}")
 
-# Registry & specs (dynamic)
-def _load_profile_tools() -> None:
-    """Load profile-specific tools if REACHY_MINI_CUSTOM_PROFILE env variable is set."""
-    profile = config.REACHY_MINI_CUSTOM_PROFILE
-    if not profile:
-        logger.info("No REACHY_MINI_CUSTOM_PROFILE env variable set; using default tools.")
-        return
-    try:
-        logger.debug(f"Trying to load profile '{profile}' from {PROFILES_DIRECTORY}...")
-        importlib.import_module(f"{PROFILES_DIRECTORY}.{profile}")
-        logger.info(f"✓ Profile '{profile}' loaded successfully.")
-    except ModuleNotFoundError as e:
-        logger.warning(f"Profile '{profile}' module not found: {e}")
-        # Check if the profile module itself is missing or if it's a dependency
-        if e.name == f"{PROFILES_DIRECTORY}.{profile}":
-            logger.error(f"✗ profile '{profile}' not found in {PROFILES_DIRECTORY}")
-            sys.exit(1)
-        else:
-            logger.error(f"✗ profile '{profile}' failed due to missing dependency: {e.name}")
-            sys.exit(1)
-    except Exception as e:
-        logger.error(f"✗ Failed to load profile '{profile}': {e}")
-        sys.exit(1)
+        # Try shared tools library if not found in profile
+        if not loaded:
+            try:
+                shared_tool_module = f"reachy_mini_conversation_app.tools.{tool_name}"
+                importlib.import_module(shared_tool_module)
+                logger.info(f"✓ Loaded shared tool: {tool_name}")
+                loaded = True
+            except ModuleNotFoundError:
+                logger.warning(f"⚠ Tool '{tool_name}' not found in profile or shared tools")
+            except Exception as e:
+                logger.warning(f"Error loading shared tool {tool_name}: {e}")
 
 
 def _initialize_tools() -> None:
@@ -517,7 +171,7 @@ def _initialize_tools() -> None:
 _initialize_tools()
 
 
-def get_tool_specs(exclusion_list : list[str] = []) -> list[Dict[str, Any]]:
+def get_tool_specs(exclusion_list: list[str] = []) -> list[Dict[str, Any]]:
     """Get tool specs, optionally excluding some tools."""
     return [spec for spec in ALL_TOOL_SPECS if spec.get("name") not in exclusion_list]
 

src/reachy_mini_conversation_app/tools/dance.py

@@ -0,0 +1,87 @@
+import logging
+from typing import Any, Dict
+
+from reachy_mini_conversation_app.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+# Initialize dance library
+try:
+    from reachy_mini_dances_library.collection.dance import AVAILABLE_MOVES
+    from reachy_mini_conversation_app.dance_emotion_moves import DanceQueueMove
+
+    DANCE_AVAILABLE = True
+except ImportError as e:
+    logger.warning(f"Dance library not available: {e}")
+    AVAILABLE_MOVES = {}
+    DANCE_AVAILABLE = False
+
+
+class Dance(Tool):
+    """Play a named or random dance move once (or repeat). Non-blocking."""
+
+    name = "dance"
+    description = "Play a named or random dance move once (or repeat). Non-blocking."
+    parameters_schema = {
+        "type": "object",
+        "properties": {
+            "move": {
+                "type": "string",
+                "description": """Name of the move; use 'random' or omit for random.
+                                    Here is a list of the available moves:
+                                        simple_nod: A simple, continuous up-and-down nodding motion.
+                                        head_tilt_roll: A continuous side-to-side head roll (ear to shoulder).
+                                        side_to_side_sway: A smooth, side-to-side sway of the entire head.
+                                        dizzy_spin: A circular 'dizzy' head motion combining roll and pitch.
+                                        stumble_and_recover: A simulated stumble and recovery with multiple axis movements. Good vibes
+                                        headbanger_combo: A strong head nod combined with a vertical bounce.
+                                        interwoven_spirals: A complex spiral motion using three axes at different frequencies.
+                                        sharp_side_tilt: A sharp, quick side-to-side tilt using a triangle waveform.
+                                        side_peekaboo: A multi-stage peekaboo performance, hiding and peeking to each side.
+                                        yeah_nod: An emphatic two-part yeah nod using transient motions.
+                                        uh_huh_tilt: A combined roll-and-pitch uh-huh gesture of agreement.
+                                        neck_recoil: A quick, transient backward recoil of the neck.
+                                        chin_lead: A forward motion led by the chin, combining translation and pitch.
+                                        groovy_sway_and_roll: A side-to-side sway combined with a corresponding roll for a groovy effect.
+                                        chicken_peck: A sharp, forward, chicken-like pecking motion.
+                                        side_glance_flick: A quick glance to the side that holds, then returns.
+                                        polyrhythm_combo: A 3-beat sway and a 2-beat nod create a polyrhythmic feel.
+                                        grid_snap: A robotic, grid-snapping motion using square waveforms.
+                                        pendulum_swing: A simple, smooth pendulum-like swing using a roll motion.
+                                        jackson_square: Traces a rectangle via a 5-point path, with sharp twitches on arrival at each checkpoint.
+                """,
+            },
+            "repeat": {
+                "type": "integer",
+                "description": "How many times to repeat the move (default 1).",
+            },
+        },
+        "required": [],
+    }
+
+    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+        """Play a named or random dance move once (or repeat). Non-blocking."""
+        if not DANCE_AVAILABLE:
+            return {"error": "Dance system not available"}
+
+        move_name = kwargs.get("move")
+        repeat = int(kwargs.get("repeat", 1))
+
+        logger.info("Tool call: dance move=%s repeat=%d", move_name, repeat)
+
+        if not move_name or move_name == "random":
+            import random
+
+            move_name = random.choice(list(AVAILABLE_MOVES.keys()))
+
+        if move_name not in AVAILABLE_MOVES:
+            return {"error": f"Unknown dance move '{move_name}'. Available: {list(AVAILABLE_MOVES.keys())}"}
+
+        # Add dance moves to queue
+        movement_manager = deps.movement_manager
+        for _ in range(repeat):
+            dance_move = DanceQueueMove(move_name)
+            movement_manager.queue_move(dance_move)
+
+        return {"status": "queued", "move": move_name, "repeat": repeat}

src/reachy_mini_conversation_app/tools/do_nothing.py

@@ -0,0 +1,30 @@
+import logging
+from typing import Any, Dict
+
+from reachy_mini_conversation_app.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+
+class DoNothing(Tool):
+    """Choose to do nothing - stay still and silent. Use when you want to be contemplative or just chill."""
+
+    name = "do_nothing"
+    description = "Choose to do nothing - stay still and silent. Use when you want to be contemplative or just chill."
+    parameters_schema = {
+        "type": "object",
+        "properties": {
+            "reason": {
+                "type": "string",
+                "description": "Optional reason for doing nothing (e.g., 'contemplating existence', 'saving energy', 'being mysterious')",
+            },
+        },
+        "required": [],
+    }
+
+    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+        """Do nothing - stay still and silent."""
+        reason = kwargs.get("reason", "just chilling")
+        logger.info("Tool call: do_nothing reason=%s", reason)
+        return {"status": "doing nothing", "reason": reason}

src/reachy_mini_conversation_app/tools/head_tracking.py

@@ -0,0 +1,31 @@
+import logging
+from typing import Any, Dict
+
+from reachy_mini_conversation_app.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+
+class HeadTracking(Tool):
+    """Toggle head tracking state."""
+
+    name = "head_tracking"
+    description = "Toggle head tracking state."
+    parameters_schema = {
+        "type": "object",
+        "properties": {"start": {"type": "boolean"}},
+        "required": ["start"],
+    }
+
+    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+        """Enable or disable head tracking."""
+        enable = bool(kwargs.get("start"))
+
+        # Update camera worker head tracking state
+        if deps.camera_worker is not None:
+            deps.camera_worker.set_head_tracking_enabled(enable)
+
+        status = "started" if enable else "stopped"
+        logger.info("Tool call: head_tracking %s", status)
+        return {"status": f"head tracking {status}"}

src/reachy_mini_conversation_app/tools/move_head.py

@@ -0,0 +1,79 @@
+import logging
+from typing import Any, Dict, Tuple, Literal
+
+from reachy_mini.utils import create_head_pose
+from reachy_mini_conversation_app.tools.core_tools import Tool, ToolDependencies
+from reachy_mini_conversation_app.dance_emotion_moves import GotoQueueMove
+
+
+logger = logging.getLogger(__name__)
+
+Direction = Literal["left", "right", "up", "down", "front"]
+
+
+class MoveHead(Tool):
+    """Move head in a given direction."""
+
+    name = "move_head"
+    description = "Move your head in a given direction: left, right, up, down or front."
+    parameters_schema = {
+        "type": "object",
+        "properties": {
+            "direction": {
+                "type": "string",
+                "enum": ["left", "right", "up", "down", "front"],
+            },
+        },
+        "required": ["direction"],
+    }
+
+    # mapping: direction -> args for create_head_pose
+    DELTAS: Dict[str, Tuple[int, int, int, int, int, int]] = {
+        "left": (0, 0, 0, 0, 0, 40),
+        "right": (0, 0, 0, 0, 0, -40),
+        "up": (0, 0, 0, 0, -30, 0),
+        "down": (0, 0, 0, 0, 30, 0),
+        "front": (0, 0, 0, 0, 0, 0),
+    }
+
+    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+        """Move head in a given direction."""
+        direction_raw = kwargs.get("direction")
+        if not isinstance(direction_raw, str):
+            return {"error": "direction must be a string"}
+        direction: Direction = direction_raw  # type: ignore[assignment]
+        logger.info("Tool call: move_head direction=%s", direction)
+
+        deltas = self.DELTAS.get(direction, self.DELTAS["front"])
+        target = create_head_pose(*deltas, degrees=True)
+
+        # Use new movement manager
+        try:
+            movement_manager = deps.movement_manager
+
+            # Get current state for interpolation
+            current_head_pose = deps.reachy_mini.get_current_head_pose()
+            _, current_antennas = deps.reachy_mini.get_current_joint_positions()
+
+            # Create goto move
+            goto_move = GotoQueueMove(
+                target_head_pose=target,
+                start_head_pose=current_head_pose,
+                target_antennas=(0, 0),  # Reset antennas to default
+                start_antennas=(
+                    current_antennas[0],
+                    current_antennas[1],
+                ),  # Skip body_yaw
+                target_body_yaw=0,  # Reset body yaw
+                start_body_yaw=current_antennas[0],  # body_yaw is first in joint positions
+                duration=deps.motion_duration_s,
+            )
+
+            movement_manager.queue_move(goto_move)
+            movement_manager.set_moving_state(deps.motion_duration_s)
+
+            return {"status": f"looking {direction}"}
+
+        except Exception as e:
+            logger.error("move_head failed")
+            return {"error": f"move_head failed: {type(e).__name__}: {e}"}

src/reachy_mini_conversation_app/tools/play_emotion.py

@@ -0,0 +1,84 @@
+import logging
+from typing import Any, Dict
+
+from reachy_mini_conversation_app.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+# Initialize emotion library
+try:
+    from reachy_mini.motion.recorded_move import RecordedMoves
+    from reachy_mini_conversation_app.dance_emotion_moves import EmotionQueueMove
+
+    # Note: huggingface_hub automatically reads HF_TOKEN from environment variables
+    RECORDED_MOVES = RecordedMoves("pollen-robotics/reachy-mini-emotions-library")
+    EMOTION_AVAILABLE = True
+except ImportError as e:
+    logger.warning(f"Emotion library not available: {e}")
+    RECORDED_MOVES = None
+    EMOTION_AVAILABLE = False
+
+
+def get_available_emotions_and_descriptions() -> str:
+    """Get formatted list of available emotions with descriptions."""
+    if not EMOTION_AVAILABLE:
+        return "Emotions not available"
+
+    try:
+        emotion_names = RECORDED_MOVES.list_moves()
+        output = "Available emotions:\n"
+        for name in emotion_names:
+            description = RECORDED_MOVES.get(name).description
+            output += f" - {name}: {description}\n"
+        return output
+    except Exception as e:
+        return f"Error getting emotions: {e}"
+
+
+class PlayEmotion(Tool):
+    """Play a pre-recorded emotion."""
+
+    name = "play_emotion"
+    description = "Play a pre-recorded emotion"
+    parameters_schema = {
+        "type": "object",
+        "properties": {
+            "emotion": {
+                "type": "string",
+                "description": f"""Name of the emotion to play.
+                                    Here is a list of the available emotions:
+                                    {get_available_emotions_and_descriptions()}
+                                    """,
+            },
+        },
+        "required": ["emotion"],
+    }
+
+    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+        """Play a pre-recorded emotion."""
+        if not EMOTION_AVAILABLE:
+            return {"error": "Emotion system not available"}
+
+        emotion_name = kwargs.get("emotion")
+        if not emotion_name:
+            return {"error": "Emotion name is required"}
+
+        logger.info("Tool call: play_emotion emotion=%s", emotion_name)
+
+        # Check if emotion exists
+        try:
+            emotion_names = RECORDED_MOVES.list_moves()
+            if emotion_name not in emotion_names:
+                return {"error": f"Unknown emotion '{emotion_name}'. Available: {emotion_names}"}
+
+            # Add emotion to queue
+            movement_manager = deps.movement_manager
+            emotion_move = EmotionQueueMove(emotion_name, RECORDED_MOVES)
+            movement_manager.queue_move(emotion_move)
+
+            return {"status": "queued", "emotion": emotion_name}
+
+        except Exception as e:
+            logger.exception("Failed to play emotion")
+            return {"error": f"Failed to play emotion: {e!s}"}

src/reachy_mini_conversation_app/tools/stop_dance.py

@@ -0,0 +1,31 @@
+import logging
+from typing import Any, Dict
+
+from reachy_mini_conversation_app.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+
+class StopDance(Tool):
+    """Stop the current dance move."""
+
+    name = "stop_dance"
+    description = "Stop the current dance move"
+    parameters_schema = {
+        "type": "object",
+        "properties": {
+            "dummy": {
+                "type": "boolean",
+                "description": "dummy boolean, set it to true",
+            },
+        },
+        "required": ["dummy"],
+    }
+
+    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+        """Stop the current dance move."""
+        logger.info("Tool call: stop_dance")
+        movement_manager = deps.movement_manager
+        movement_manager.clear_move_queue()
+        return {"status": "stopped dance and cleared queue"}

src/reachy_mini_conversation_app/tools/stop_emotion.py

@@ -0,0 +1,31 @@
+import logging
+from typing import Any, Dict
+
+from reachy_mini_conversation_app.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+
+class StopEmotion(Tool):
+    """Stop the current emotion."""
+
+    name = "stop_emotion"
+    description = "Stop the current emotion"
+    parameters_schema = {
+        "type": "object",
+        "properties": {
+            "dummy": {
+                "type": "boolean",
+                "description": "dummy boolean, set it to true",
+            },
+        },
+        "required": ["dummy"],
+    }
+
+    async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+        """Stop the current emotion."""
+        logger.info("Tool call: stop_emotion")
+        movement_manager = deps.movement_manager
+        movement_manager.clear_move_queue()
+        return {"status": "stopped emotion and cleared queue"}