Switch OpenClaw bridge from HTTP to WebSocket protocol

The OpenClaw gateway speaks WebSocket natively, not HTTP REST. The old
HTTP-based bridge (httpx POST to /v1/chat/completions) would connect but
hang forever waiting for a response.

Rewrite openclaw_bridge.py to use the gateway's WebSocket protocol:
- Connect handshake with challenge/auth/scopes
- Persistent connection with background listener task
- chat.send with streaming event collection (agent deltas, lifecycle)
- Proper disconnect cleanup on shutdown

Also includes: room-scanning when no face detected, improved face
tracking EMA tuning, and thinking animation offsets in movement system.

pyproject.toml

@@ -43,9 +43,7 @@ dependencies = [
     "numpy",
     "scipy",
     
-    # OpenClaw gateway client
-    "httpx>=0.27.0",
-    "httpx-sse>=0.4.0",
+    # OpenClaw gateway client (WebSocket protocol)
     "websockets>=12.0",
     
     # Gradio UI

src/reachy_mini_openclaw/camera_worker.py

@@ -3,6 +3,7 @@
 Provides:
 - 30Hz+ camera polling with thread-safe frame buffering
 - Face tracking integration with smooth interpolation
+- Room scanning when no face is detected
 - Latest frame always available for tools
 - Smooth return to neutral when face is lost
 
@@ -26,7 +27,14 @@ logger = logging.getLogger(__name__)
 
 
 class CameraWorker:
-    """Thread-safe camera worker with frame buffering and face tracking."""
+    """Thread-safe camera worker with frame buffering and face tracking.
+    
+    State machine for face tracking:
+        SCANNING  -- no face known, sweeping the room to find one
+        TRACKING  -- face detected, following it with head offsets
+        WAITING   -- face just lost, holding position briefly
+        RETURNING -- interpolating back to neutral before scanning again
+    """
 
     def __init__(self, reachy_mini: ReachyMini, head_tracker: Any = None) -> None:
         """Initialize camera worker.
@@ -61,15 +69,29 @@ class CameraWorker:
         # Track state changes
         self.previous_head_tracking_state = self.is_head_tracking_enabled
         
-        # Tracking scale factor (adjust responsiveness)
-        self.tracking_scale = 0.6  # Scale down movements for smoother tracking
+        # Tracking scale factor (proportional gain for the camera-head servo loop).
+        # 0.85 provides accurate convergence via closed-loop feedback while
+        # avoiding single-frame overshoot that causes jitter.
+        self.tracking_scale = 0.85
         
         # Smoothing factor for exponential moving average (0.0-1.0)
-        # Lower = smoother but slower response, Higher = faster but more jitter
-        self.smoothing_alpha = 0.15  # Smooth out jitter from detection noise
+        # At 25Hz with alpha=0.25, 95% convergence ~0.5s -- smooth enough to
+        # filter detection noise, responsive enough to feel like eye contact.
+        self.smoothing_alpha = 0.25
         
         # Previous smoothed offsets for EMA calculation
         self._smoothed_offsets: List[float] = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+        
+        # --- Room scanning state ---
+        # When no face is visible, the robot periodically sweeps the room.
+        self._scanning = False
+        self._scanning_start_time = 0.0
+        # Scanning pattern: sinusoidal yaw sweep
+        self._scan_yaw_amplitude = np.deg2rad(35)  # ±35 degrees
+        self._scan_period = 8.0  # seconds for a full left-right-left cycle
+        self._scan_pitch_offset = np.deg2rad(3)  # slight upward tilt while scanning
+        # Start scanning immediately at boot (before any face has ever been seen)
+        self._ever_seen_face = False
 
     def get_latest_frame(self) -> Optional[NDArray[np.uint8]]:
         """Get the latest frame (thread-safe).
@@ -100,8 +122,13 @@ class CameraWorker:
         Args:
             enabled: Whether to enable face tracking
         """
+        if enabled and not self.is_head_tracking_enabled:
+            # Reset smoothed offsets so tracking converges quickly from scratch
+            self._smoothed_offsets = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+            # Start scanning immediately when re-enabled
+            self._start_scanning()
         self.is_head_tracking_enabled = enabled
-        logger.info(f"Head tracking {'enabled' if enabled else 'disabled'}")
+        logger.info("Head tracking %s", "enabled" if enabled else "disabled")
 
     def start(self) -> None:
         """Start the camera worker loop in a thread."""
@@ -117,6 +144,41 @@ class CameraWorker:
             self._thread.join(timeout=2.0)
         logger.info("Camera worker stopped")
 
+    # ------------------------------------------------------------------
+    # Scanning helpers
+    # ------------------------------------------------------------------
+
+    def _start_scanning(self) -> None:
+        """Begin the room-scanning sweep."""
+        if not self._scanning:
+            self._scanning = True
+            self._scanning_start_time = time.time()
+            logger.debug("Started room scanning")
+
+    def _stop_scanning(self) -> None:
+        """Stop the room-scanning sweep."""
+        if self._scanning:
+            self._scanning = False
+            logger.debug("Stopped room scanning")
+
+    def _update_scanning_offsets(self, current_time: float) -> None:
+        """Compute scanning offsets -- a slow yaw sweep with slight pitch up.
+        
+        The sweep is sinusoidal so the head slows at the extremes (more natural)
+        and the face detector gets a chance to catch faces at the edges.
+        """
+        t = current_time - self._scanning_start_time
+        
+        yaw = float(self._scan_yaw_amplitude * np.sin(2 * np.pi * t / self._scan_period))
+        pitch = float(self._scan_pitch_offset)
+        
+        with self.face_tracking_lock:
+            self.face_tracking_offsets = [0.0, 0.0, 0.0, 0.0, pitch, yaw]
+
+    # ------------------------------------------------------------------
+    # Main loop
+    # ------------------------------------------------------------------
+
     def _working_loop(self) -> None:
         """Main camera worker loop.
         
@@ -127,6 +189,10 @@ class CameraWorker:
         # Neutral pose for interpolation target
         neutral_pose = np.eye(4, dtype=np.float32)
         self.previous_head_tracking_state = self.is_head_tracking_enabled
+        
+        # Begin scanning right away so the robot looks for a face on startup
+        if self.is_head_tracking_enabled and self.head_tracker is not None:
+            self._start_scanning()
 
         while not self._stop_event.is_set():
             try:
@@ -146,6 +212,7 @@ class CameraWorker:
                         self.last_face_detected_time = current_time
                         self.interpolation_start_time = None
                         self.interpolation_start_pose = None
+                        self._stop_scanning()
 
                     # Update tracking state
                     self.previous_head_tracking_state = self.is_head_tracking_enabled
@@ -161,7 +228,7 @@ class CameraWorker:
                 time.sleep(0.04)
 
             except Exception as e:
-                logger.error(f"Camera worker error: {e}")
+                logger.error("Camera worker error: %s", e)
                 time.sleep(0.1)
 
         logger.debug("Camera worker thread exited")
@@ -182,7 +249,18 @@ class CameraWorker:
         eye_center, _ = self.head_tracker.get_head_position(frame)
 
         if eye_center is not None:
-            # Face detected - immediately switch to tracking
+            # Face detected!
+            if not self._ever_seen_face:
+                self._ever_seen_face = True
+                logger.info("Face detected for the first time")
+            
+            # Stop scanning if we were scanning
+            if self._scanning:
+                self._stop_scanning()
+                # Seed the EMA from current scanning offsets for smooth transition
+                with self.face_tracking_lock:
+                    self._smoothed_offsets = list(self.face_tracking_offsets)
+
             self.last_face_detected_time = current_time
             self.interpolation_start_time = None  # Stop any interpolation
 
@@ -206,7 +284,7 @@ class CameraWorker:
             translation = target_pose[:3, 3]
             rotation = R.from_matrix(target_pose[:3, :3]).as_euler("xyz", degrees=False)
 
-            # Scale down for smoother tracking
+            # Scale for smoother closed-loop convergence
             translation *= self.tracking_scale
             rotation *= self.tracking_scale
 
@@ -229,8 +307,13 @@ class CameraWorker:
                 self.face_tracking_offsets = smoothed
 
         else:
-            # No face detected - handle smooth interpolation back to neutral
-            self._interpolate_to_neutral(current_time, neutral_pose)
+            # No face detected
+            if self._scanning:
+                # Already scanning -- keep sweeping the room
+                self._update_scanning_offsets(current_time)
+            else:
+                # Not scanning yet -- go through the wait/return/scan sequence
+                self._interpolate_to_neutral(current_time, neutral_pose)
 
     def _interpolate_to_neutral(
         self, 
@@ -239,11 +322,15 @@ class CameraWorker:
     ) -> None:
         """Interpolate face tracking offsets back to neutral when face is lost.
         
+        Once interpolation completes, automatically starts room scanning.
+        
         Args:
             current_time: Current timestamp
             neutral_pose: Target neutral pose matrix
         """
         if self.last_face_detected_time is None:
+            # Never seen a face -- go straight to scanning
+            self._start_scanning()
             return
 
         time_since_face_lost = current_time - self.last_face_detected_time
@@ -286,8 +373,10 @@ class CameraWorker:
                     rotation[0], rotation[1], rotation[2],
                 ]
 
-            # If interpolation is complete, reset timing
+            # If interpolation is complete, start scanning the room
             if t >= 1.0:
                 self.last_face_detected_time = None
                 self.interpolation_start_time = None
                 self.interpolation_start_pose = None
+                self._smoothed_offsets = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+                self._start_scanning()

src/reachy_mini_openclaw/config.py

@@ -25,7 +25,7 @@ class Config:
     OPENAI_VOICE: str = field(default_factory=lambda: os.getenv("OPENAI_VOICE", "cedar"))
     
     # OpenClaw Gateway Configuration
-    OPENCLAW_GATEWAY_URL: str = field(default_factory=lambda: os.getenv("OPENCLAW_GATEWAY_URL", "http://localhost:18789"))
+    OPENCLAW_GATEWAY_URL: str = field(default_factory=lambda: os.getenv("OPENCLAW_GATEWAY_URL", "ws://localhost:18789"))
     OPENCLAW_TOKEN: Optional[str] = field(default_factory=lambda: os.getenv("OPENCLAW_TOKEN"))
     OPENCLAW_AGENT_ID: str = field(default_factory=lambda: os.getenv("OPENCLAW_AGENT_ID", "main"))
     # Session key for OpenClaw - uses "main" to share context with WhatsApp and other channels

src/reachy_mini_openclaw/gradio_app.py

@@ -17,7 +17,7 @@ logger = logging.getLogger(__name__)
 
 
 def launch_gradio(
-    gateway_url: str = "http://localhost:18789",
+    gateway_url: str = "ws://localhost:18789",
     robot_name: Optional[str] = None,
     enable_camera: bool = True,
     enable_openclaw: bool = True,

src/reachy_mini_openclaw/main.py

@@ -98,7 +98,7 @@ Examples:
     parser.add_argument(
         "--gateway-url",
         type=str,
-        default=os.getenv("OPENCLAW_GATEWAY_URL", "http://localhost:18789"),
+        default=os.getenv("OPENCLAW_GATEWAY_URL", "ws://localhost:18789"),
         help="OpenClaw gateway URL (from OPENCLAW_GATEWAY_URL env or default)"
     )
     parser.add_argument(
@@ -142,7 +142,7 @@ class ClawBodyCore:
     
     def __init__(
         self,
-        gateway_url: str = "http://localhost:18789",
+        gateway_url: str = "ws://localhost:18789",
         robot_name: Optional[str] = None,
         enable_camera: bool = True,
         enable_openclaw: bool = True,
@@ -401,6 +401,28 @@ class ClawBodyCore:
             else:
                 logger.warning("OpenClaw gateway not available - some features disabled")
         
+        # Enable motors and move to neutral pose
+        logger.info("Enabling motors and moving to neutral position...")
+        try:
+            self.robot.enable_motors()
+            from reachy_mini.utils import create_head_pose
+            neutral = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
+            self.robot.goto_target(
+                head=neutral,
+                antennas=[0.0, 0.0],
+                duration=2.0,
+                body_yaw=0.0,
+            )
+            time.sleep(2)  # Wait for goto to complete
+            logger.info("Robot at neutral position with motors enabled")
+        except Exception as e:
+            logger.error("Failed to initialize robot pose: %s", e)
+        
+        # Wire up camera worker to movement manager for face tracking
+        if self.camera_worker is not None:
+            self.movement_manager.camera_worker = self.camera_worker
+            logger.info("Face tracking connected to movement system")
+        
         # Start movement system
         logger.info("Starting movement system...")
         self.movement_manager.start()
@@ -461,6 +483,15 @@ class ClawBodyCore:
         if self.camera_worker is not None:
             self.camera_worker.stop()
         
+        # Disconnect OpenClaw bridge
+        if self.openclaw_bridge is not None:
+            try:
+                asyncio.get_event_loop().run_until_complete(
+                    self.openclaw_bridge.disconnect()
+                )
+            except Exception as e:
+                logger.debug("OpenClaw disconnect: %s", e)
+        
         # Close resources if we own them
         if self._owns_robot:
             try:
@@ -492,7 +523,7 @@ class ClawBodyApp:
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
         
-        gateway_url = os.getenv("OPENCLAW_GATEWAY_URL", "http://localhost:18789")
+        gateway_url = os.getenv("OPENCLAW_GATEWAY_URL", "ws://localhost:18789")
         
         app = ClawBodyCore(
             gateway_url=gateway_url,

src/reachy_mini_openclaw/moves.py

@@ -199,6 +199,7 @@ class MovementState:
     last_activity_time: float = 0.0
     speech_offsets: SpeechOffsets = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
     face_tracking_offsets: SpeechOffsets = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+    thinking_offsets: SpeechOffsets = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
     last_primary_pose: Optional[FullBodyPose] = None
     
     def update_activity(self) -> None:
@@ -277,6 +278,12 @@ class MovementManager:
         self._pending_speech_offsets: SpeechOffsets = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
         self._speech_dirty = False
         
+        # Processing/thinking animation state
+        self._processing = False
+        self._processing_start_time = 0.0
+        self._thinking_amplitude = 0.0  # 0..1 envelope for smooth fade in/out
+        self._thinking_antenna_offsets: Tuple[float, float] = (0.0, 0.0)
+        
         # Shared state lock
         self._shared_lock = threading.Lock()
         self._shared_last_activity = self.state.last_activity_time
@@ -300,6 +307,15 @@ class MovementManager:
         """Set listening state (freezes antennas). Thread-safe."""
         self._command_queue.put(("set_listening", listening))
         
+    def set_processing(self, processing: bool) -> None:
+        """Set processing state (triggers thinking animation). Thread-safe.
+        
+        When True, the robot shows a continuous 'thinking' animation as
+        secondary offsets -- gentle head sway and asymmetric antenna scanning.
+        Face tracking continues underneath since this is additive.
+        """
+        self._command_queue.put(("set_processing", processing))
+        
     def is_idle(self) -> bool:
         """Check if robot has been idle. Thread-safe."""
         with self._shared_lock:
@@ -333,6 +349,50 @@ class MovementManager:
             # No camera worker, use neutral offsets
             self.state.face_tracking_offsets = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
             
+    def _update_thinking_offsets(self, current_time: float) -> None:
+        """Compute thinking animation as secondary offsets.
+        
+        Produces a gentle head sway (yaw drift, slight upward pitch, z bob)
+        and asymmetric antenna scanning pattern. The amplitude envelope
+        smoothly ramps up over 0.5s and decays over 0.5s for organic feel.
+        """
+        # Update amplitude envelope
+        if self._processing:
+            # Ramp up over 0.5s
+            elapsed = current_time - self._processing_start_time
+            self._thinking_amplitude = min(1.0, elapsed / 0.5)
+        elif self._thinking_amplitude > 0:
+            # Smooth decay at 2.0/s (full decay in 0.5s)
+            self._thinking_amplitude = max(
+                0.0, self._thinking_amplitude - 2.0 * self.target_period
+            )
+        
+        # If fully decayed, zero everything and bail
+        if self._thinking_amplitude < 0.001:
+            self._thinking_amplitude = 0.0
+            self.state.thinking_offsets = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+            self._thinking_antenna_offsets = (0.0, 0.0)
+            return
+        
+        amp = self._thinking_amplitude
+        t = current_time - self._processing_start_time
+        
+        # Head offsets (radians / metres -- degrees=False, mm=False)
+        # Slow yaw drift: ±12° at 0.15 Hz
+        yaw = amp * np.deg2rad(12) * np.sin(2 * np.pi * 0.15 * t)
+        # Slight upward pitch: 6° base + 3° oscillation at 0.2 Hz
+        pitch = amp * (np.deg2rad(6) + np.deg2rad(3) * np.sin(2 * np.pi * 0.2 * t))
+        # Gentle z bob: 3 mm at 0.12 Hz
+        z = amp * 0.003 * np.sin(2 * np.pi * 0.12 * t)
+        
+        self.state.thinking_offsets = (0.0, 0.0, z, 0.0, pitch, yaw)
+        
+        # Antenna offsets: asymmetric scan (phase offset creates "searching" feel)
+        # ±20° at 0.4 Hz, right antenna lags left by ~70° of phase
+        left_ant = amp * np.deg2rad(20) * np.sin(2 * np.pi * 0.4 * t)
+        right_ant = amp * np.deg2rad(20) * np.sin(2 * np.pi * 0.4 * t + 1.2)
+        self._thinking_antenna_offsets = (left_ant, right_ant)
+        
     def _handle_command(self, cmd: str, payload: Any, current_time: float) -> None:
         """Handle a single command."""
         if cmd == "queue_move":
@@ -356,6 +416,23 @@ class MovementManager:
                 else:
                     self._antenna_unfreeze_blend = 0.0
                 self.state.update_activity()
+        elif cmd == "set_processing":
+            desired = bool(payload)
+            if desired and not self._processing:
+                self._processing = True
+                self._processing_start_time = self._now()
+                # Interrupt breathing so thinking animation is clean
+                if self._breathing_active and isinstance(self.state.current_move, BreathingMove):
+                    self.state.current_move = None
+                    self.state.move_start_time = None
+                    self._breathing_active = False
+                self.state.update_activity()
+                logger.debug("Processing started - thinking animation active")
+            elif not desired and self._processing:
+                self._processing = False
+                # Amplitude will decay smoothly in _update_thinking_offsets
+                self.state.update_activity()
+                logger.debug("Processing ended - thinking animation decaying")
                 
     def _manage_move_queue(self, current_time: float) -> None:
         """Advance the move queue."""
@@ -380,6 +457,7 @@ class MovementManager:
             and not self.move_queue
             and not self._is_listening
             and not self._breathing_active
+            and not self._processing
         ):
             idle_for = current_time - self.state.last_activity_time
             if idle_for >= self.idle_inactivity_delay:
@@ -429,9 +507,11 @@ class MovementManager:
         return (neutral, (0.0, 0.0), 0.0)
         
     def _get_secondary_pose(self) -> FullBodyPose:
-        """Get secondary offsets."""
+        """Get secondary offsets (speech + face tracking + thinking)."""
         offsets = [
-            self.state.speech_offsets[i] + self.state.face_tracking_offsets[i]
+            self.state.speech_offsets[i]
+            + self.state.face_tracking_offsets[i]
+            + self.state.thinking_offsets[i]
             for i in range(6)
         ]
         
@@ -440,7 +520,7 @@ class MovementManager:
             roll=offsets[3], pitch=offsets[4], yaw=offsets[5],
             degrees=False, mm=False
         )
-        return (secondary_head, (0.0, 0.0), 0.0)
+        return (secondary_head, self._thinking_antenna_offsets, 0.0)
         
     def _compose_pose(self, current_time: float) -> FullBodyPose:
         """Compose final pose from primary and secondary."""
@@ -529,6 +609,9 @@ class MovementManager:
             # Update face tracking offsets from camera worker
             self._update_face_tracking(loop_start)
             
+            # Update thinking animation offsets
+            self._update_thinking_offsets(loop_start)
+            
             # Compose pose
             head, antennas, body_yaw = self._compose_pose(loop_start)
             
@@ -555,6 +638,8 @@ class MovementManager:
             "queue_size": len(self.move_queue),
             "is_listening": self._is_listening,
             "breathing_active": self._breathing_active,
+            "processing": self._processing,
+            "thinking_amplitude": round(self._thinking_amplitude, 3),
             "last_commanded_pose": {
                 "head": self._last_commanded_pose[0].tolist(),
                 "antennas": self._last_commanded_pose[1],

src/reachy_mini_openclaw/openai_realtime.py

@@ -277,6 +277,7 @@ OpenClaw has access to many capabilities you don't have directly.""",
         if event_type == "input_audio_buffer.speech_started":
             # User started speaking - stop any current output
             self._speaking = False
+            self.deps.movement_manager.set_processing(False)
             while not self.output_queue.empty():
                 try:
                     self.output_queue.get_nowait()
@@ -308,6 +309,9 @@ OpenClaw has access to many capabilities you don't have directly.""",
             
         # Audio output from TTS
         if event_type == "response.audio.delta":
+            # Audio arriving means we have a response - stop thinking animation
+            self.deps.movement_manager.set_processing(False)
+            
             # Feed to head wobbler for expressive movement
             if self.deps.head_wobbler is not None:
                 self.deps.head_wobbler.feed(event.delta)
@@ -337,6 +341,7 @@ OpenClaw has access to many capabilities you don't have directly.""",
         # Response completed - sync conversation to OpenClaw
         if event_type == "response.done":
             self._speaking = False
+            self.deps.movement_manager.set_processing(False)
             if self.deps.head_wobbler is not None:
                 self.deps.head_wobbler.reset()
             logger.debug("Response completed")
@@ -366,6 +371,10 @@ OpenClaw has access to many capabilities you don't have directly.""",
             
         logger.info("Tool call: %s(%s)", tool_name, args_json[:50] if len(args_json) > 50 else args_json)
         
+        # Start thinking animation while we process the tool call.
+        # It will stop when the next audio delta arrives or response completes.
+        self.deps.movement_manager.set_processing(True)
+        
         try:
             if tool_name == "ask_openclaw":
                 result = await self._handle_openclaw_query(args_json)

src/reachy_mini_openclaw/openclaw_bridge.py

@@ -1,7 +1,7 @@
 """ClawBody - Bridge to OpenClaw Gateway for AI responses.
 
 This module provides ClawBody's integration with the OpenClaw gateway
-using the OpenAI-compatible Chat Completions HTTP API.
+using the WebSocket protocol (the gateway's native transport).
 
 ClawBody uses OpenAI Realtime API for voice I/O (speech recognition + TTS)
 but routes all responses through OpenClaw (Clawson) for intelligence.
@@ -10,16 +10,19 @@ but routes all responses through OpenClaw (Clawson) for intelligence.
 import json
 import asyncio
 import logging
+import uuid
 from typing import Optional, Any, AsyncIterator
 from dataclasses import dataclass
 
-import httpx
-from httpx_sse import aconnect_sse
+import websockets
 
 from reachy_mini_openclaw.config import config
 
 logger = logging.getLogger(__name__)
 
+# Protocol version supported by this client
+PROTOCOL_VERSION = 3
+
 
 @dataclass
 class OpenClawResponse:
@@ -29,23 +32,21 @@ class OpenClawResponse:
 
 
 class OpenClawBridge:
-    """Bridge to OpenClaw Gateway using HTTP Chat Completions API.
-    
-    This class sends user messages to OpenClaw and receives AI responses.
-    The robot maintains conversation context and can include images.
-    
+    """Bridge to OpenClaw Gateway using WebSocket protocol.
+
+    The OpenClaw gateway speaks WebSocket with a JSON frame protocol.
+    This class handles the connect handshake, authentication, and
+    chat operations.
+
     Example:
         bridge = OpenClawBridge()
         await bridge.connect()
-        
+
         # Simple query
         response = await bridge.chat("Hello!")
         print(response.content)
-        
-        # With image
-        response = await bridge.chat("What do you see?", image_b64="...")
     """
-    
+
     def __init__(
         self,
         gateway_url: Optional[str] = None,
@@ -54,304 +55,541 @@ class OpenClawBridge:
         timeout: float = 120.0,
     ):
         """Initialize the OpenClaw bridge.
-        
+
         Args:
-            gateway_url: URL of the OpenClaw gateway (default: from env/config)
+            gateway_url: URL of the OpenClaw gateway (default: from env/config).
+                         Accepts http:// or ws:// schemes; http is converted to ws.
             gateway_token: Authentication token (default: from env/config)
             agent_id: OpenClaw agent ID to use (default: from env/config)
             timeout: Request timeout in seconds
         """
         import os
-        # Read from env directly as fallback (config may have been loaded before .env)
-        self.gateway_url = gateway_url or os.getenv("OPENCLAW_GATEWAY_URL") or config.OPENCLAW_GATEWAY_URL
-        self.gateway_token = gateway_token or os.getenv("OPENCLAW_TOKEN") or config.OPENCLAW_TOKEN
-        self.agent_id = agent_id or os.getenv("OPENCLAW_AGENT_ID") or config.OPENCLAW_AGENT_ID
+
+        raw_url = (
+            gateway_url
+            or os.getenv("OPENCLAW_GATEWAY_URL")
+            or config.OPENCLAW_GATEWAY_URL
+        )
+        # Normalise to ws:// (the gateway listens on the same port for both)
+        self.gateway_url = self._normalise_ws_url(raw_url)
+
+        self.gateway_token = (
+            gateway_token
+            or os.getenv("OPENCLAW_TOKEN")
+            or config.OPENCLAW_TOKEN
+        )
+        self.agent_id = (
+            agent_id
+            or os.getenv("OPENCLAW_AGENT_ID")
+            or config.OPENCLAW_AGENT_ID
+        )
         self.timeout = timeout
-        
-        # Session key - use "main" to share context with WhatsApp and other channels
-        # The full session key is: agent:<agent_id>:<session_key>
-        self.session_key = os.getenv("OPENCLAW_SESSION_KEY") or config.OPENCLAW_SESSION_KEY or "main"
-        
-        # Connection state
+
+        # Session key – "main" shares context with WhatsApp and other channels.
+        # Full key format: agent:<agent_id>:<session_key>
+        self.session_key = (
+            os.getenv("OPENCLAW_SESSION_KEY")
+            or config.OPENCLAW_SESSION_KEY
+            or "main"
+        )
+
+        # Persistent WebSocket state
+        self._ws: Optional[websockets.WebSocketClientProtocol] = None
         self._connected = False
-        
+        self._conn_id: Optional[str] = None
+
+        # Background listener task & pending request futures
+        self._listener_task: Optional[asyncio.Task] = None
+        self._pending: dict[str, asyncio.Future] = {}
+        # Events keyed by runId -> list of event payloads
+        self._run_events: dict[str, asyncio.Queue] = {}
+
+    # ------------------------------------------------------------------
+    # URL helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _normalise_ws_url(url: str) -> str:
+        """Convert http(s) URL to ws(s)."""
+        if url.startswith("http://"):
+            return "ws://" + url[7:]
+        if url.startswith("https://"):
+            return "wss://" + url[8:]
+        if not url.startswith("ws://") and not url.startswith("wss://"):
+            return "ws://" + url
+        return url
+
+    # ------------------------------------------------------------------
+    # Connection lifecycle
+    # ------------------------------------------------------------------
+
     async def connect(self) -> bool:
-        """Test connection to the OpenClaw gateway.
-        
+        """Connect to the OpenClaw gateway and authenticate.
+
         Returns:
             True if connection successful, False otherwise
         """
-        logger.info("Attempting to connect to OpenClaw at %s (token: %s)", 
-                    self.gateway_url, "set" if self.gateway_token else "not set")
+        logger.info(
+            "Connecting to OpenClaw at %s (token: %s)",
+            self.gateway_url,
+            "set" if self.gateway_token else "not set",
+        )
         try:
-            # Use longer timeout for first connection (OpenClaw may need to initialize)
-            async with httpx.AsyncClient(timeout=60.0) as client:
-                # Test the chat completions endpoint with a simple request
-                url = f"{self.gateway_url}/v1/chat/completions"
-                logger.info("Testing endpoint: %s", url)
-                response = await client.post(
-                    url,
-                    json={
-                        "model": f"openclaw:{self.agent_id}",
-                        "messages": [{"role": "user", "content": "ping"}],
+            self._ws = await websockets.connect(
+                self.gateway_url,
+                ping_interval=20,
+                ping_timeout=30,
+                close_timeout=5,
+            )
+
+            # 1. Receive challenge
+            raw = await asyncio.wait_for(self._ws.recv(), timeout=10)
+            challenge = json.loads(raw)
+            if challenge.get("event") != "connect.challenge":
+                logger.warning("Unexpected first frame: %s", challenge.get("event"))
+
+            # 2. Send connect request
+            req_id = str(uuid.uuid4())
+            connect_req = {
+                "type": "req",
+                "id": req_id,
+                "method": "connect",
+                "params": {
+                    "minProtocol": PROTOCOL_VERSION,
+                    "maxProtocol": PROTOCOL_VERSION,
+                    "auth": {"token": self.gateway_token} if self.gateway_token else {},
+                    "client": {
+                        "id": "webchat",
+                        "version": "1.0.0",
+                        "platform": "linux",
+                        "mode": "webchat",
                     },
-                    headers=self._get_headers(),
+                    "role": "operator",
+                    "scopes": ["chat", "operator.write", "operator.read"],
+                },
+            }
+            await self._ws.send(json.dumps(connect_req))
+
+            # 3. Read hello response
+            raw = await asyncio.wait_for(self._ws.recv(), timeout=10)
+            hello = json.loads(raw)
+
+            if hello.get("ok"):
+                self._connected = True
+                payload = hello.get("payload", {})
+                server = payload.get("server", {})
+                self._conn_id = server.get("connId")
+                logger.info(
+                    "Connected to OpenClaw gateway (server=%s, connId=%s)",
+                    server.get("host", "?"),
+                    self._conn_id,
                 )
-                logger.info("Response status: %d", response.status_code)
-                if response.status_code == 200:
-                    self._connected = True
-                    logger.info("Connected to OpenClaw gateway at %s", self.gateway_url)
-                    return True
-                else:
-                    logger.warning("OpenClaw gateway returned %d: %s", 
-                                 response.status_code, response.text[:100])
-                    self._connected = False
-                    return False
+                # Start background listener
+                self._listener_task = asyncio.create_task(
+                    self._listen_loop(), name="openclaw-ws-listener"
+                )
+                return True
+            else:
+                err = hello.get("error", {})
+                logger.error(
+                    "OpenClaw connect failed: %s - %s",
+                    err.get("code"),
+                    err.get("message"),
+                )
+                await self._close_ws()
+                return False
+
         except Exception as e:
-            logger.error("Failed to connect to OpenClaw gateway: %s (type: %s)", e, type(e).__name__)
-            self._connected = False
+            logger.error(
+                "Failed to connect to OpenClaw gateway: %s (%s)",
+                e,
+                type(e).__name__,
+            )
+            await self._close_ws()
             return False
-    
-    def _get_headers(self) -> dict[str, str]:
-        """Get headers for OpenClaw API requests."""
-        headers = {
-            "Content-Type": "application/json",
-            # Use session key header to share context with WhatsApp and other channels
-            # Format: agent:<agent_id>:<session_key> - default "main" shares with all DMs
-            "x-openclaw-session-key": f"agent:{self.agent_id}:{self.session_key}",
-        }
-        if self.gateway_token:
-            headers["Authorization"] = f"Bearer {self.gateway_token}"
-        return headers
-    
+
+    async def disconnect(self) -> None:
+        """Disconnect from the gateway."""
+        self._connected = False
+        if self._listener_task and not self._listener_task.done():
+            self._listener_task.cancel()
+            try:
+                await self._listener_task
+            except (asyncio.CancelledError, Exception):
+                pass
+        await self._close_ws()
+
+    async def _close_ws(self) -> None:
+        self._connected = False
+        if self._ws:
+            try:
+                await self._ws.close()
+            except Exception:
+                pass
+            self._ws = None
+
+    # ------------------------------------------------------------------
+    # Background listener
+    # ------------------------------------------------------------------
+
+    async def _listen_loop(self) -> None:
+        """Background task that reads all frames from the WebSocket."""
+        try:
+            async for raw in self._ws:
+                try:
+                    msg = json.loads(raw)
+                except json.JSONDecodeError:
+                    continue
+                await self._dispatch(msg)
+        except websockets.ConnectionClosed as e:
+            logger.warning("OpenClaw WebSocket closed: %s", e)
+        except asyncio.CancelledError:
+            return
+        except Exception as e:
+            logger.error("OpenClaw listener error: %s", e)
+        finally:
+            self._connected = False
+
+    async def _dispatch(self, msg: dict) -> None:
+        """Route an incoming frame to the right handler."""
+        msg_type = msg.get("type")
+
+        if msg_type == "res":
+            # Response to a request we sent
+            req_id = msg.get("id")
+            fut = self._pending.pop(req_id, None)
+            if fut and not fut.done():
+                fut.set_result(msg)
+
+        elif msg_type == "event":
+            event_name = msg.get("event", "")
+            payload = msg.get("payload", {})
+
+            # Route agent / chat events to the correct run queue
+            run_id = payload.get("runId")
+            if run_id and run_id in self._run_events:
+                await self._run_events[run_id].put(msg)
+
+            # Ignore noisy events silently
+            if event_name in ("health", "tick"):
+                return
+
+            logger.debug("Event: %s (runId=%s)", event_name, run_id)
+
+    # ------------------------------------------------------------------
+    # Request helpers
+    # ------------------------------------------------------------------
+
+    async def _send_request(
+        self, method: str, params: dict, timeout: Optional[float] = None
+    ) -> dict:
+        """Send a request and wait for the response.
+
+        Args:
+            method: The RPC method name
+            params: The params dict
+            timeout: Override timeout (defaults to self.timeout)
+
+        Returns:
+            The full response message dict
+        """
+        if not self._ws or not self._connected:
+            return {"ok": False, "error": {"code": "NOT_CONNECTED", "message": "Not connected"}}
+
+        req_id = str(uuid.uuid4())
+        req = {"type": "req", "id": req_id, "method": method, "params": params}
+
+        fut: asyncio.Future = asyncio.get_event_loop().create_future()
+        self._pending[req_id] = fut
+
+        try:
+            await self._ws.send(json.dumps(req))
+            result = await asyncio.wait_for(fut, timeout=timeout or self.timeout)
+            return result
+        except asyncio.TimeoutError:
+            self._pending.pop(req_id, None)
+            return {"ok": False, "error": {"code": "TIMEOUT", "message": "Request timed out"}}
+        except Exception as e:
+            self._pending.pop(req_id, None)
+            return {"ok": False, "error": {"code": "ERROR", "message": str(e)}}
+
+    def _full_session_key(self) -> str:
+        """Build the full session key: agent:<agentId>:<sessionKey>."""
+        return f"agent:{self.agent_id}:{self.session_key}"
+
+    # ------------------------------------------------------------------
+    # Chat API
+    # ------------------------------------------------------------------
+
     async def chat(
-        self, 
-        message: str, 
+        self,
+        message: str,
         image_b64: Optional[str] = None,
         system_context: Optional[str] = None,
     ) -> OpenClawResponse:
         """Send a message to OpenClaw and get a response.
-        
+
         OpenClaw maintains conversation memory on its end, so it will be aware
         of conversations from other channels (WhatsApp, web, etc.). We only send
         the current message and let OpenClaw handle the context.
-        
+
         Args:
             message: The user's message (transcribed speech)
-            image_b64: Optional base64-encoded image from robot camera
-            system_context: Optional additional system context
-            
+            image_b64: Optional base64-encoded image from robot camera (not yet
+                       supported over WebSocket chat.send – reserved for future)
+            system_context: Optional additional system context (prepended to message)
+
         Returns:
             OpenClawResponse with the AI's response
         """
-        # Build user message content
-        if image_b64:
-            content = [
-                {"type": "text", "text": message},
-                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_b64}"}}
-            ]
-        else:
-            content = message
-        
-        # Build request messages - just the current message
-        # OpenClaw maintains conversation memory on its end
-        request_messages = []
-        
-        # Add system context if provided (e.g., "User is speaking to you through the robot")
+        if not self._connected:
+            return OpenClawResponse(content="", error="Not connected to OpenClaw")
+
+        # Prefix system context if provided
+        final_message = message
         if system_context:
-            request_messages.append({"role": "system", "content": system_context})
-        
-        # Add the current user message
-        request_messages.append({"role": "user", "content": content})
-        
+            final_message = f"[System: {system_context}]\n\n{message}"
+
+        # If image provided, mention it (WebSocket protocol uses string messages;
+        # image passing would require a separate mechanism)
+        if image_b64:
+            final_message = f"[Image attached]\n{final_message}"
+
+        idempotency_key = str(uuid.uuid4())
+        session_key = self._full_session_key()
+
+        # Create a queue to collect events for this run
+        # We'll get the runId from the response
+        params = {
+            "idempotencyKey": idempotency_key,
+            "sessionKey": session_key,
+            "message": final_message,
+        }
+
         try:
-            async with httpx.AsyncClient(timeout=httpx.Timeout(self.timeout)) as client:
-                response = await client.post(
-                    f"{self.gateway_url}/v1/chat/completions",
-                    json={
-                        "model": f"openclaw:{self.agent_id}",
-                        "messages": request_messages,
-                        "stream": False,
-                    },
-                    headers=self._get_headers(),
-                )
-                response.raise_for_status()
-                
-                data = response.json()
-                choices = data.get("choices", [])
-                if choices:
-                    assistant_content = choices[0].get("message", {}).get("content", "")
-                    return OpenClawResponse(content=assistant_content)
-                return OpenClawResponse(content="", error="No response from OpenClaw")
-                
-        except httpx.HTTPStatusError as e:
-            logger.error("OpenClaw HTTP error: %d - %s", e.response.status_code, e.response.text[:200])
-            return OpenClawResponse(content="", error=f"HTTP {e.response.status_code}")
+            # Send the request
+            resp = await self._send_request("chat.send", params, timeout=30)
+
+            if not resp.get("ok"):
+                err = resp.get("error", {})
+                error_msg = f"{err.get('code', 'UNKNOWN')}: {err.get('message', 'Unknown error')}"
+                logger.error("chat.send failed: %s", error_msg)
+                return OpenClawResponse(content="", error=error_msg)
+
+            run_id = resp.get("payload", {}).get("runId")
+            if not run_id:
+                return OpenClawResponse(content="", error="No runId in response")
+
+            # Register a queue to receive events for this run
+            event_queue: asyncio.Queue = asyncio.Queue()
+            self._run_events[run_id] = event_queue
+
+            try:
+                # Collect the streamed response
+                full_text = ""
+                while True:
+                    try:
+                        event = await asyncio.wait_for(
+                            event_queue.get(), timeout=self.timeout
+                        )
+                        payload = event.get("payload", {})
+                        event_name = event.get("event", "")
+
+                        if event_name == "agent":
+                            stream = payload.get("stream")
+                            data = payload.get("data", {})
+
+                            if stream == "assistant":
+                                # Accumulate the full text
+                                full_text = data.get("text", full_text)
+
+                            elif stream == "lifecycle" and data.get("phase") == "end":
+                                # Run completed
+                                break
+
+                        elif event_name == "chat":
+                            state = payload.get("state")
+                            if state == "final":
+                                # Extract final text
+                                msg_payload = payload.get("message", {})
+                                content_parts = msg_payload.get("content", [])
+                                if isinstance(content_parts, list):
+                                    for part in content_parts:
+                                        if isinstance(part, dict) and part.get("type") == "text":
+                                            full_text = part.get("text", full_text)
+                                elif isinstance(content_parts, str):
+                                    full_text = content_parts
+                                break
+
+                    except asyncio.TimeoutError:
+                        logger.warning("Timeout waiting for chat response (runId=%s)", run_id)
+                        if full_text:
+                            break
+                        return OpenClawResponse(content="", error="Response timeout")
+
+                return OpenClawResponse(content=full_text)
+
+            finally:
+                self._run_events.pop(run_id, None)
+
         except Exception as e:
             logger.error("OpenClaw chat error: %s", e)
             return OpenClawResponse(content="", error=str(e))
-    
+
     async def stream_chat(
-        self, 
-        message: str, 
+        self,
+        message: str,
         image_b64: Optional[str] = None,
     ) -> AsyncIterator[str]:
         """Stream a response from OpenClaw.
-        
-        OpenClaw maintains conversation memory on its end, so it will be aware
-        of conversations from other channels (WhatsApp, web, etc.).
-        
+
         Args:
             message: The user's message
             image_b64: Optional base64-encoded image
-            
+
         Yields:
             String chunks of the response as they arrive
         """
-        # Build user message content
+        if not self._connected:
+            yield "[Error: Not connected to OpenClaw]"
+            return
+
+        final_message = message
         if image_b64:
-            content = [
-                {"type": "text", "text": message},
-                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_b64}"}}
-            ]
-        else:
-            content = message
-        
-        # Only send current message - OpenClaw handles memory
-        request_messages = [{"role": "user", "content": content}]
-        
-        async with httpx.AsyncClient(timeout=httpx.Timeout(self.timeout)) as client:
+            final_message = f"[Image attached]\n{message}"
+
+        params = {
+            "idempotencyKey": str(uuid.uuid4()),
+            "sessionKey": self._full_session_key(),
+            "message": final_message,
+        }
+
+        try:
+            resp = await self._send_request("chat.send", params, timeout=30)
+
+            if not resp.get("ok"):
+                err = resp.get("error", {})
+                yield f"[Error: {err.get('message', 'Unknown error')}]"
+                return
+
+            run_id = resp.get("payload", {}).get("runId")
+            if not run_id:
+                yield "[Error: No runId]"
+                return
+
+            event_queue: asyncio.Queue = asyncio.Queue()
+            self._run_events[run_id] = event_queue
+
             try:
-                async with aconnect_sse(
-                    client,
-                    "POST",
-                    f"{self.gateway_url}/v1/chat/completions",
-                    json={
-                        "model": f"openclaw:{self.agent_id}",
-                        "messages": request_messages,
-                        "stream": True,
-                    },
-                    headers=self._get_headers(),
-                ) as event_source:
-                    event_source.response.raise_for_status()
-                    
-                    async for sse in event_source.aiter_sse():
-                        if sse.data == "[DONE]":
+                prev_text = ""
+                while True:
+                    try:
+                        event = await asyncio.wait_for(
+                            event_queue.get(), timeout=self.timeout
+                        )
+                        payload = event.get("payload", {})
+                        event_name = event.get("event", "")
+
+                        if event_name == "agent":
+                            stream = payload.get("stream")
+                            data = payload.get("data", {})
+
+                            if stream == "assistant":
+                                delta = data.get("delta", "")
+                                if delta:
+                                    yield delta
+
+                            elif stream == "lifecycle" and data.get("phase") == "end":
+                                break
+
+                        elif event_name == "chat" and payload.get("state") == "final":
                             break
-                        
-                        try:
-                            data = json.loads(sse.data)
-                            choices = data.get("choices", [])
-                            if choices:
-                                delta = choices[0].get("delta", {})
-                                chunk = delta.get("content", "")
-                                if chunk:
-                                    yield chunk
-                        except json.JSONDecodeError:
-                            continue
-                            
-            except httpx.HTTPStatusError as e:
-                logger.error("OpenClaw streaming error: %d", e.response.status_code)
-                yield f"[Error: HTTP {e.response.status_code}]"
-            except Exception as e:
-                logger.error("OpenClaw streaming error: %s", e)
-                yield f"[Error: {e}]"
-    
+
+                    except asyncio.TimeoutError:
+                        yield "[Error: timeout]"
+                        break
+            finally:
+                self._run_events.pop(run_id, None)
+
+        except Exception as e:
+            logger.error("OpenClaw streaming error: %s", e)
+            yield f"[Error: {e}]"
+
     @property
     def is_connected(self) -> bool:
         """Check if bridge is connected to gateway."""
         return self._connected
-    
+
     async def get_agent_context(self) -> Optional[str]:
         """Fetch the agent's current context, personality, and memory summary.
-        
+
         This asks OpenClaw to provide a summary of:
         - The agent's personality and identity
         - Recent conversation context
         - Important memories about the user
-        - Current state (time, location awareness, etc.)
-        
+        - Current state
+
         Returns:
             A context string to use as system instructions, or None if failed
         """
         try:
-            async with httpx.AsyncClient(timeout=httpx.Timeout(30.0)) as client:
-                # Ask OpenClaw to summarize its context for the robot body
-                response = await client.post(
-                    f"{self.gateway_url}/v1/chat/completions",
-                    json={
-                        "model": f"openclaw:{self.agent_id}",
-                        "messages": [
-                            {
-                                "role": "system", 
-                                "content": """You are being asked to provide your current context for your robot body.
-Output a comprehensive context summary that another AI can use to embody you. Include:
-
-1. YOUR IDENTITY: Who you are, your name, your personality traits, how you speak
-2. USER CONTEXT: What you know about the user you're talking to (name, preferences, relationship)
-3. RECENT CONTEXT: Summary of recent conversations or important ongoing topics
-4. MEMORIES: Key things you remember that are relevant to interactions
-5. CURRENT STATE: Any relevant time/date awareness, ongoing tasks, or situational context
-
-Be specific and personal. This context will be used by your robot body to speak and act AS YOU.
-Output ONLY the context summary, no preamble."""
-                            },
-                            {
-                                "role": "user",
-                                "content": "Provide your current context summary for the robot body."
-                            }
-                        ],
-                        "stream": False,
-                    },
-                    headers=self._get_headers(),
-                )
-                response.raise_for_status()
-                
-                data = response.json()
-                choices = data.get("choices", [])
-                if choices:
-                    context = choices[0].get("message", {}).get("content", "")
-                    if context:
-                        logger.info("Retrieved agent context from OpenClaw (%d chars)", len(context))
-                        return context
-                        
-                logger.warning("No context returned from OpenClaw")
+            response = await self.chat(
+                message="Provide your current context summary for the robot body.",
+                system_context=(
+                    "You are being asked to provide your current context for your robot body. "
+                    "Output a comprehensive context summary that another AI can use to embody you. Include: "
+                    "1. YOUR IDENTITY: Who you are, your name, your personality traits, how you speak. "
+                    "2. USER CONTEXT: What you know about the user (name, preferences, relationship). "
+                    "3. RECENT CONTEXT: Summary of recent conversations or important ongoing topics. "
+                    "4. MEMORIES: Key things you remember that are relevant to interactions. "
+                    "5. CURRENT STATE: Any relevant time/date awareness, ongoing tasks. "
+                    "Be specific and personal. This context will be used by your robot body to speak and act AS YOU. "
+                    "Output ONLY the context summary, no preamble."
+                ),
+            )
+
+            if response.error:
+                logger.warning("Failed to get agent context: %s", response.error)
                 return None
-                
+
+            if response.content:
+                logger.info(
+                    "Retrieved agent context from OpenClaw (%d chars)",
+                    len(response.content),
+                )
+                return response.content
+
+            logger.warning("No context returned from OpenClaw")
+            return None
+
         except Exception as e:
             logger.error("Failed to get agent context: %s", e)
             return None
-    
-    async def sync_conversation(self, user_message: str, assistant_response: str) -> None:
+
+    async def sync_conversation(
+        self, user_message: str, assistant_response: str
+    ) -> None:
         """Sync a conversation turn back to OpenClaw for memory continuity.
-        
-        This ensures OpenClaw's memory stays in sync with robot conversations.
-        
+
         Args:
             user_message: What the user said
             assistant_response: What the robot/AI responded
         """
         try:
-            async with httpx.AsyncClient(timeout=httpx.Timeout(30.0)) as client:
-                # Send the conversation to OpenClaw with a special system message
-                # indicating this is a sync from the robot body
-                await client.post(
-                    f"{self.gateway_url}/v1/chat/completions",
-                    json={
-                        "model": f"openclaw:{self.agent_id}",
-                        "messages": [
-                            {
-                                "role": "system",
-                                "content": "[ROBOT BODY SYNC] The following conversation happened through your Reachy Mini robot body. Remember it as part of your ongoing conversation with the user."
-                            },
-                            {"role": "user", "content": user_message},
-                            {"role": "assistant", "content": assistant_response}
-                        ],
-                        "stream": False,
-                    },
-                    headers=self._get_headers(),
-                )
-                logger.debug("Synced conversation to OpenClaw")
+            await self.chat(
+                message=(
+                    f"[ROBOT BODY SYNC] The following happened through the Reachy Mini robot:\n"
+                    f"User said: {user_message}\n"
+                    f"You responded: {assistant_response}\n"
+                    f"Remember this as part of your ongoing conversation."
+                ),
+                system_context=(
+                    "[ROBOT BODY SYNC] The following conversation happened through your "
+                    "Reachy Mini robot body. Remember it as part of your ongoing conversation "
+                    "with the user."
+                ),
+            )
+            logger.debug("Synced conversation to OpenClaw")
         except Exception as e:
             logger.debug("Failed to sync conversation: %s", e)