Replace with official conversation app

- Delete all custom code
- Copy official conversation app from pollen-robotics
- Update README to reflect official app
- Remove binary image files

README.md

@@ -1,262 +1,33 @@
 ---
-title: Reachy Mini Home Assistant Voice Assistant
-emoji: 🤖
-colorFrom: blue
-colorTo: indigo
+title: Reachy Mini Conversation App
+emoji: 🎤
+colorFrom: red
+colorTo: blue
 sdk: static
 pinned: false
-short_description: Home Assistant Voice Assistant for Reachy Mini
+short_description: Talk with Reachy Mini !
 tags:
  - reachy_mini
  - reachy_mini_python_app
 ---
 
-# Reachy Mini Home Assistant Voice Assistant
+# Reachy Mini conversation app
 
-基于 ESPHome 协议的 Reachy Mini 语音助手，用于连接 Home Assistant。可通过 Hugging Face Spaces 一键安装和部署。
+Conversational app for the Reachy Mini robot combining OpenAI's realtime APIs, vision pipelines, and choreographed motion libraries.
 
-## 功能特性
+This is a test deployment of the official [reachy_mini_conversation_app](https://huggingface.co/spaces/pollen-robotics/reachy_mini_conversation_app).
 
-- 🎤 唤醒词检测（支持多个唤醒词）
-- 🔊 语音识别和合成
-- 🏠 Home Assistant 指令执行
-- 🤖 Reachy Mini 机器人集成
-- ⏰ 定时器功能
-- 📢 广播通知
+## Installation
 
-## 快速开始
+Install this app on your Reachy Mini robot from the dashboard.
 
-### 通过 Hugging Face Spaces 安装
+## Configuration
 
-1. 访问 [Hugging Face Spaces](https://huggingface.co/spaces)
-2. 创建新的 Space，选择 Docker 模板
-3. 将此仓库克隆到你的 Space
-4. 等待构建完成，服务将自动启动
+You'll need an OpenAI API key to use this app. Configure it in the settings page.
 
-### 本地运行
+## Features
 
-```bash
-# 克隆仓库
-git clone https://huggingface.co/spaces/djhui5710/reachy_mini_ha_voice
-cd reachy_mini_ha_voice
-
-# 安装系统依赖（Linux）
-sudo apt-get install portaudio19-dev build-essential libportaudio2
-
-# 创建虚拟环境
-python -m venv .venv
-source .venv/bin/activate  # Windows: .venv\Scripts\activate
-
-# 安装 Python 依赖
-pip install -r requirements.txt
-pip install -e .
-
-# 运行
-python -m reachy_mini_ha_voice --name "ReachyMini"
-```
-
-## 连接到 Home Assistant
-
-1. 在 Home Assistant 中，进入 "设置" -> "设备与服务"
-2. 点击 "添加集成" 按钮
-3. 选择 "ESPHome" 然后选择 "设置另一个 ESPHome 实例"
-4. 输入语音助手的 IP 地址和端口 6053
-5. 点击 "提交"
-
-## 命令行选项
-
-```
-python -m reachy_mini_ha_voice --help
-
-选项:
-  --name NAME                    设备名称（必需）
-  --host HOST                    服务器地址（默认: 0.0.0.0）
-  --port PORT                    服务器端口（默认: 6053）
-  --audio-input-device DEVICE    音频输入设备
-  --list-input-devices           列出可用的音频输入设备
-  --audio-output-device DEVICE   音频输出设备
-  --list-output-devices          列出可用的音频输出设备
-  --wake-model MODEL             唤醒词模型（默认: okay_nabu）
-  --stop-model MODEL             停止词模型（默认: stop）
-  --refractory-seconds SECONDS   唤醒词冷却时间（默认: 2.0）
-  --debug                        启用调试日志
-```
-
-## 包含的 Assets
-
-项目已经包含了所有必需的唤醒词模型和声音文件，无需额外下载：
-
-### 唤醒词模型（microWakeWord）
-
-- `okay_nabu.tflite` - "Okay Nabu"（默认）
-- `stop.tflite` - "Stop"
-- `alexa.tflite` - "Alexa"
-- `hey_jarvis.tflite` - "Hey Jarvis"
-- `hey_home_assistant.tflite` - "Hey Home Assistant"
-- `hey_luna.tflite` - "Hey Luna"
-- `hey_mycroft.tflite` - "Hey Mycroft"
-- `okay_computer.tflite` - "Okay Computer"
-- `choo_choo_homie.tflite` - "Choo Choo Homie"
-
-### 唤醒词模型（openWakeWord）
-
-在 `wakewords/openWakeWord/` 目录中：
-- `alexa_v0.1.tflite` - Alexa
-- `hey_jarvis_v0.1.tflite` - Hey Jarvis
-- `hey_mycroft_v0.1.tflite` - Hey Mycroft
-- `hey_rhasspy_v0.1.tflite` - Hey Rhasspy
-- `ok_nabu_v0.1.tflite` - Okay Nabu
-
-### 声音文件
-
-- `wake_word_triggered.flac` - 唤醒词触发时播放
-- `timer_finished.flac` - 定时器结束时播放
-
-## 音频设备配置
-
-### 查看可用设备
-
-```bash
-# 列出音频输入设备
-python -m reachy_mini_ha_voice --name Test --list-input-devices
-
-# 列出音频输出设备
-python -m reachy_mini_ha_voice --name Test --list-output-devices
-```
-
-### 指定音频设备
-
-```bash
-python -m reachy_mini_ha_voice \
-  --name "ReachyMini" \
-  --audio-input-device "麦克风名称" \
-  --audio-output-device "扬声器名称"
-```
-
-**注意**：麦克风设备必须支持 16KHz 单声道音频。
-
-## 唤醒词
-
-### 默认唤醒词
-
-- `okay_nabu`（默认）
-
-### 使用其他唤醒词
-
-项目已经包含了多个唤醒词模型，你可以直接使用：
-
-```bash
-# 使用 "Hey Jarvis"
-python -m reachy_mini_ha_voice --name "ReachyMini" --wake-model hey_jarvis
-
-# 使用 "Alexa"
-python -m reachy_mini_ha_voice --name "ReachyMini" --wake-model alexa
-
-# 使用 openWakeWord 版本的 "Hey Jarvis"
-python -m reachy_mini_ha_voice --name "ReachyMini" \
-  --wake-model hey_jarvis_v0.1 \
-  --wake-word-dir wakewords/openWakeWord
-```
-
-### 添加自定义唤醒词
-
-如果你想添加其他唤醒词：
-
-更多唤醒词模型请访问：[home-assistant-wakewords-collection](https://github.com/fwartner/home-assistant-wakewords-collection)
-
-## Reachy Mini 集成
-
-### 动作反馈
-
-语音助手会根据不同状态触发 Reachy Mini 的动作：
-
-- **唤醒时**：头部抬起，眼睛闪烁
-- **监听中**：头部轻微摆动
-- **响应中**：点头或摇头
-- **错误时**：头部倾斜
-
-### 自定义动作
-
-编辑 `reachy_mini_ha_voice/reachy_integration.py` 来自定义 Reachy Mini 的动作反馈。
-
-## 故障排除
-
-### 音频设备问题
-
-如果无法检测到音频设备：
-
-```bash
-# 检查 PulseAudio 服务
-systemctl --user status pulseaudio
-
-# 重新加载 PulseAudio
-pulseaudio --kill
-pulseaudio --start
-```
-
-### 回声消除
-
-启用 PulseAudio 的回声消除模块：
-
-```bash
-pactl load-module module-echo-cancel \
-  aec_method=webrtc \
-  aec_args="analog_gain_control=0 digital_gain_control=1 noise_suppression=1"
-```
-
-查看设备：
-
-```bash
-pactl list short sources
-pactl list short sinks
-```
-
-使用回声消除设备：
-
-```bash
-python -m reachy_mini_ha_voice \
-  --name "ReachyMini" \
-  --audio-input-device 'Echo-Cancel Source' \
-  --audio-output-device 'pipewire/echo-cancel-sink'
-```
-
-### Hugging Face Spaces 部署问题
-
-如果构建失败：
-
-1. 检查 Dockerfile 中的依赖是否正确
-2. 确保 requirements.txt 中的版本兼容
-3. 查看构建日志中的错误信息
-4. 确保没有使用需要系统特权的功能
-
-## 开发
-
-### 运行测试
-
-```bash
-pip install -e ".[dev]"
-pytest
-```
-
-### 代码格式化
-
-```bash
-black reachy_mini_ha_voice/
-flake8 reachy_mini_ha_voice/
-```
-
-## 许可证
-
-Apache License 2.0
-
-## 致谢
-
-本项目基于 [OHF-Voice/linux-voice-assistant](https://github.com/OHF-Voice/linux-voice-assistant) 修改而来，适配 Reachy Mini 机器人和 Hugging Face Spaces 环境。
-
-## 相关链接
-
-- [Home Assistant](https://www.home-assistant.io/)
-- [ESPHome](https://esphome.io/)
-- [Reachy Mini](https://github.com/pollen-robotics/reachy)
-- [Hugging Face Spaces](https://huggingface.co/spaces)
-- [Source Code](https://huggingface.co/spaces/djhui5710/reachy_mini_ha_voice)
+- Real-time audio conversation with OpenAI
+- Vision processing
+- Motion control
+- Multiple personality profiles

linux-voice-assistant

@@ -0,0 +1 @@
+Subproject commit fd4c1d972bc87e6d7a0dddc5aa52465243d63265

linux_voice_assistant_original

@@ -0,0 +1 @@
+Subproject commit fd4c1d972bc87e6d7a0dddc5aa52465243d63265

pyproject.toml

@@ -59,7 +59,6 @@ where = ["src"]
 
 [tool.setuptools.package-data]
 reachy_mini_conversation_app = [
-  "images/*",
   "static/*",
   ".env.example",
   "demos/**/*.txt",

src_backup/reachy_mini_ha_voice/__init__.py

@@ -0,0 +1,3 @@
+"""Reachy Mini Home Assistant Voice Assistant."""
+
+__version__ = "1.0.0"

src_backup/reachy_mini_ha_voice/__main__.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+"""Main entry point - for Hugging Face Spaces display only.
+
+This application is designed to run on Reachy Mini robots.
+To use it, install the app on your Reachy Mini from the dashboard.
+
+For standalone usage, this would require command-line arguments:
+  python -m reachy_mini_ha_voice --name "ReachyMini"
+"""
+
+import sys
+
+if __name__ == "__main__":
+    print("Reachy Mini Home Assistant Voice Assistant")
+    print("=" * 50)
+    print()
+    print("This application is designed to run on Reachy Mini robots.")
+    print()
+    print("To use it:")
+    print("1. Install this app on your Reachy Mini from the dashboard")
+    print("2. Enable the app in the Reachy Mini applications section")
+    print("3. The ESPHome voice assistant will start on port 6053")
+    print("4. Home Assistant will auto-discover the device")
+    print()
+    print("For more information, see:")
+    print("https://huggingface.co/spaces/djhui5710/reachy_mini_ha_voice")
+    print()
+    sys.exit(0)

src_backup/reachy_mini_ha_voice/api_server.py

@@ -0,0 +1,180 @@
+"""Partial ESPHome server implementation."""
+
+import asyncio
+import logging
+from abc import abstractmethod
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, List, Optional
+
+# pylint: disable=no-name-in-module
+from aioesphomeapi._frame_helper.packets import make_plain_text_packets
+from aioesphomeapi.api_pb2 import (  # type: ignore[attr-defined]
+    AuthenticationRequest,
+    AuthenticationResponse,
+    DisconnectRequest,
+    DisconnectResponse,
+    HelloRequest,
+    HelloResponse,
+    PingRequest,
+    PingResponse,
+)
+from aioesphomeapi.core import MESSAGE_TYPE_TO_PROTO
+from google.protobuf import message
+
+PROTO_TO_MESSAGE_TYPE = {v: k for k, v in MESSAGE_TYPE_TO_PROTO.items()}
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class APIServer(asyncio.Protocol):
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+        self._buffer: Optional[bytes] = None
+        self._buffer_len: int = 0
+        self._pos: int = 0
+        self._transport = None
+        self._writelines = None
+
+    @abstractmethod
+    def handle_message(self, msg: message.Message) -> Iterable[message.Message]:
+        pass
+
+    def process_packet(self, msg_type: int, packet_data: bytes) -> None:
+        msg_class = MESSAGE_TYPE_TO_PROTO[msg_type]
+        msg_inst = msg_class.FromString(packet_data)
+
+        if isinstance(msg_inst, HelloRequest):
+            self.send_messages(
+                [
+                    HelloResponse(
+                        api_version_major=1,
+                        api_version_minor=10,
+                        name=self.name,
+                    )
+                ]
+            )
+            return
+
+        if isinstance(msg_inst, AuthenticationRequest):
+            self.send_messages([AuthenticationResponse()])
+        elif isinstance(msg_inst, DisconnectRequest):
+            self.send_messages([DisconnectResponse()])
+            _LOGGER.debug("Disconnect requested")
+            if self._transport:
+                self._transport.close()
+                self._transport = None
+                self._writelines = None
+        elif isinstance(msg_inst, PingRequest):
+            self.send_messages([PingResponse()])
+        elif msgs := self.handle_message(msg_inst):
+            if isinstance(msgs, message.Message):
+                msgs = [msgs]
+
+            self.send_messages(msgs)
+
+    def send_messages(self, msgs: List[message.Message]):
+        if self._writelines is None:
+            return
+
+        packets = [
+            (PROTO_TO_MESSAGE_TYPE[msg.__class__], msg.SerializeToString())
+            for msg in msgs
+        ]
+        packet_bytes = make_plain_text_packets(packets)
+        self._writelines(packet_bytes)
+
+    def connection_made(self, transport) -> None:
+        self._transport = transport
+        self._writelines = transport.writelines
+
+    def data_received(self, data: bytes):
+        if self._buffer is None:
+            self._buffer = data
+            self._buffer_len = len(data)
+        else:
+            self._buffer += data
+            self._buffer_len += len(data)
+
+        while self._buffer_len >= 3:
+            self._pos = 0
+            # Read preamble, which should always 0x00
+            if (preamble := self._read_varuint()) != 0x00:
+                _LOGGER.error("Incorrect preamble: %s", preamble)
+                return
+
+            if (length := self._read_varuint()) == -1:
+                _LOGGER.error("Incorrect length: %s", length)
+                return
+
+            if (msg_type := self._read_varuint()) == -1:
+                _LOGGER.error("Incorrect message type: %s", msg_type)
+                return
+
+            if length == 0:
+                # Empty message (allowed)
+                self._remove_from_buffer()
+                self.process_packet(msg_type, b"")
+                continue
+
+            if (packet_data := self._read(length)) is None:
+                return
+
+            self._remove_from_buffer()
+            self.process_packet(msg_type, packet_data)
+
+    def _read(self, length: int) -> bytes | None:
+        """Read exactly length bytes from the buffer or None if all the bytes are not yet available."""
+        new_pos = self._pos + length
+        if self._buffer_len < new_pos:
+            return None
+        original_pos = self._pos
+        self._pos = new_pos
+        if TYPE_CHECKING:
+            assert self._buffer is not None, "Buffer should be set"
+        cstr = self._buffer
+        # Important: we must keep the bounds check (self._buffer_len < new_pos)
+        # above to verify we never try to read past the end of the buffer
+        return cstr[original_pos:new_pos]
+
+    def connection_lost(self, exc):
+        self._transport = None
+        self._writelines = None
+
+    def _read_varuint(self) -> int:
+        """Read a varuint from the buffer or -1 if the buffer runs out of bytes."""
+        if not self._buffer:
+            return -1
+
+        result = 0
+        bitpos = 0
+        cstr = self._buffer
+        while self._buffer_len > self._pos:
+            val = cstr[self._pos]
+            self._pos += 1
+            result |= (val & 0x7F) << bitpos
+            if (val & 0x80) == 0:
+                return result
+            bitpos += 7
+        return -1
+
+    def _remove_from_buffer(self) -> None:
+        """Remove data from the buffer."""
+        end_of_frame_pos = self._pos
+        self._buffer_len -= end_of_frame_pos
+        if self._buffer_len == 0:
+            # This is the best case scenario, we can just set the buffer to None
+            # and don't have to copy the data. This is the most common case as well.
+            self._buffer = None
+            return
+        if TYPE_CHECKING:
+            assert self._buffer is not None, "Buffer should be set"
+        # This is the worst case scenario, we have to copy the data
+        # and can't just use the buffer directly. This should only happen
+        # when we read multiple frames at once because the event loop
+        # is blocked and we cannot pull the data out of the buffer fast enough.
+        cstr = self._buffer
+        # Important: we must use the explicit length for the slice
+        # since Cython will stop at any '\0' character if we don't
+        self._buffer = cstr[end_of_frame_pos : self._buffer_len + end_of_frame_pos]

src_backup/reachy_mini_ha_voice/app.py

@@ -0,0 +1,439 @@
+"""Reachy Mini Home Assistant Voice Assistant."""
+
+import argparse
+import asyncio
+import logging
+import threading
+import time
+from pathlib import Path
+from queue import Queue
+from typing import Dict, List, Optional, Set, Union
+
+import numpy as np
+from pymicro_wakeword import MicroWakeWord, MicroWakeWordFeatures
+from pyopen_wakeword import OpenWakeWord, OpenWakeWordFeatures
+
+from reachy_mini import ReachyMini, ReachyMiniApp
+
+from .models import (
+    AvailableWakeWord,
+    Preferences,
+    ServerState,
+    WakeWordType,
+    AudioPlayer,
+)
+from .satellite import VoiceSatelliteProtocol
+from .util import get_mac
+from .zeroconf import HomeAssistantZeroconf
+
+_LOGGER = logging.getLogger(__name__)
+_MODULE_DIR = Path(__file__).parent
+_WAKEWORDS_DIR = _MODULE_DIR / "wakewords"
+_SOUNDS_DIR = _MODULE_DIR / "sounds"
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(description="Reachy Mini Home Assistant Voice Assistant")
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging",
+    )
+    return parser.parse_args()
+
+
+class ReachyMiniHAVoiceApp(ReachyMiniApp):
+    """Reachy Mini Apps entry point for the voice assistant app."""
+
+    custom_app_url = "http://0.0.0.0:7860/"
+    dont_start_webserver = False
+
+    def run(self, reachy_mini: ReachyMini, stop_event: threading.Event) -> None:
+        """Run the Reachy Mini voice assistant app."""
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        args = parse_args()
+        
+        instance_path = self._get_instance_path().parent
+        _run(
+            args,
+            robot=reachy_mini,
+            app_stop_event=stop_event,
+            settings_app=self.settings_app,
+            instance_path=instance_path,
+        )
+
+
+def _run(
+    args: argparse.Namespace,
+    robot: ReachyMini,
+    app_stop_event: threading.Event,
+    settings_app=None,
+    instance_path: Optional[str] = None,
+) -> None:
+    """Run the voice assistant."""
+    _LOGGER.info("=== Starting Reachy Mini Home Assistant Voice Assistant ===")
+
+    try:
+        # Initialize server state
+        _LOGGER.info("Initializing server state...")
+        state = _init_state(robot)
+        _LOGGER.info(f"Server state initialized: {state.name}")
+
+        # Start audio processing thread
+        _LOGGER.info("Starting audio processing thread...")
+        audio_thread = threading.Thread(
+            target=_process_audio,
+            args=(state,),
+            daemon=False,
+            name="AudioProcessor",
+        )
+        audio_thread.start()
+        _LOGGER.info("Audio processing thread started")
+
+        # Start ESPHome server in background thread
+        _LOGGER.info("Starting ESPHome server thread...")
+        server_thread = threading.Thread(
+            target=_run_server,
+            args=(state, app_stop_event),
+            daemon=False,
+            name="ESPServer",
+        )
+        server_thread.start()
+        _LOGGER.info("ESPHome server thread started")
+
+        # Main loop - wait for stop event
+        _LOGGER.info("Entering main loop...")
+        while not app_stop_event.is_set():
+            time.sleep(0.1)
+
+        _LOGGER.info("=== Shutting down voice assistant ===")
+    except Exception as e:
+        _LOGGER.error(f"Error in _run(): {e}", exc_info=True)
+        raise
+
+
+def _init_state(robot: ReachyMini) -> ServerState:
+    """Initialize server state."""
+    _LOGGER.info("Loading wake words...")
+    available_wake_words = _load_wake_words()
+    _LOGGER.info(f"Found {len(available_wake_words)} available wake words")
+
+    # Load active wake words
+    active_wake_words = set()
+    wake_models: Dict[str, Union[MicroWakeWord, OpenWakeWord]] = {}
+
+    # Use default wake word
+    default_wake_word = "okay_nabu"
+    _LOGGER.info(f"Loading default wake word: {default_wake_word}")
+    if default_wake_word in available_wake_words:
+        try:
+            wake_word = available_wake_words[default_wake_word]
+            wake_models[default_wake_word] = wake_word.load()
+            active_wake_words.add(default_wake_word)
+            _LOGGER.info("Loaded wake word: %s", default_wake_word)
+        except Exception as e:
+            _LOGGER.error("Failed to load wake word %s: %s", default_wake_word, e)
+    else:
+        _LOGGER.warning(f"Wake word {default_wake_word} not found in available wake words")
+
+    # Load stop model
+    _LOGGER.info("Loading stop model...")
+    stop_model = _load_stop_model()
+    _LOGGER.info(f"Stop model loaded: {stop_model is not None}")
+
+    _LOGGER.info("Creating ServerState...")
+    return ServerState(
+        name="ReachyMini",
+        mac_address=get_mac(),
+        audio_queue=Queue(),
+        entities=[],
+        available_wake_words=available_wake_words,
+        wake_words=wake_models,
+        active_wake_words=active_wake_words,
+        stop_word=stop_model,
+        music_player=ReachyMiniAudioPlayer(robot),
+        tts_player=ReachyMiniAudioPlayer(robot),
+        wakeup_sound=str(_SOUNDS_DIR / "wake_word_triggered.flac"),
+        timer_finished_sound=str(_SOUNDS_DIR / "timer_finished.flac"),
+        preferences=Preferences(),
+        preferences_path=_MODULE_DIR / "preferences.json",
+        refractory_seconds=2.0,
+        download_dir=_MODULE_DIR / "local",
+        reachy_integration=None,
+        media_player_entity=None,
+    )
+
+
+def _load_wake_words() -> Dict[str, AvailableWakeWord]:
+    """Load available wake words."""
+    available_wake_words: Dict[str, AvailableWakeWord] = {}
+
+    _LOGGER.info(f"Loading wake words from: {_WAKEWORDS_DIR}")
+    
+    for wake_word_dir in [_WAKEWORDS_DIR]:
+        if not wake_word_dir.exists():
+            _LOGGER.warning(f"Wake word directory not found: {wake_word_dir}")
+            continue
+
+        _LOGGER.info(f"Scanning wake word directory: {wake_word_dir}")
+        
+        for model_config_path in wake_word_dir.glob("*.json"):
+            model_id = model_config_path.stem
+            if model_id == "stop":
+                continue
+
+            try:
+                import json
+
+                with open(model_config_path, "r", encoding="utf-8") as f:
+                    model_config = json.load(f)
+                    model_type = WakeWordType(model_config.get("type", "microWakeWord"))
+                    if model_type == WakeWordType.OPEN_WAKE_WORD:
+                        wake_word_path = model_config_path.parent / model_config["model"]
+                    else:
+                        wake_word_path = model_config_path
+
+                    available_wake_words[model_id] = AvailableWakeWord(
+                        id=model_id,
+                        type=model_type,
+                        wake_word=model_config["wake_word"],
+                        trained_languages=model_config.get("trained_languages", []),
+                        wake_word_path=wake_word_path,
+                    )
+                    _LOGGER.debug(f"Loaded wake word config: {model_id}")
+            except Exception as e:
+                _LOGGER.error("Error loading wake word config %s: %s", model_config_path, e)
+
+    _LOGGER.info(f"Loaded {len(available_wake_words)} wake word configurations")
+    return available_wake_words
+
+
+def _load_stop_model() -> Optional[MicroWakeWord]:
+    """Load stop word model."""
+    stop_config_path = _WAKEWORDS_DIR / "stop.json"
+    _LOGGER.info(f"Loading stop model from: {stop_config_path}")
+    
+    if not stop_config_path.exists():
+        _LOGGER.warning(f"Stop model config not found: {stop_config_path}")
+        return None
+
+    try:
+        model = MicroWakeWord.from_config(stop_config_path)
+        _LOGGER.info("Stop model loaded successfully")
+        return model
+    except Exception as e:
+        _LOGGER.error("Failed to load stop model: %s", e, exc_info=True)
+        return None
+
+
+def _run_server(state: ServerState, stop_event: threading.Event):
+    """Run ESPHome server in a separate thread."""
+    _LOGGER.info("ESPHome server thread: Starting...")
+    
+    async def server_loop():
+        _LOGGER.info("ESPHome server: Creating event loop...")
+        loop = asyncio.get_running_loop()
+        
+        _LOGGER.info("ESPHome server: Creating server on port 6053...")
+        server = await loop.create_server(
+            lambda: VoiceSatelliteProtocol(state), host="0.0.0.0", port=6053
+        )
+        _LOGGER.info("ESPHome server: Server created successfully")
+
+        # Auto discovery (zeroconf, mDNS)
+        _LOGGER.info("ESPHome server: Registering mDNS service...")
+        discovery = HomeAssistantZeroconf(port=6053, name="ReachyMini")
+        await discovery.register_server()
+        _LOGGER.info("ESPHome server: mDNS service registered")
+
+        try:
+            async with server:
+                _LOGGER.info("ESPHome server: Server started on port 6053")
+                _LOGGER.info("ESPHome server: mDNS service registered for auto-discovery")
+                
+                while not stop_event.is_set():
+                    await asyncio.sleep(0.1)
+        except Exception as e:
+            _LOGGER.error(f"ESPHome server: Error in server loop: {e}", exc_info=True)
+        finally:
+            _LOGGER.info("ESPHome server: Unregistering mDNS service...")
+            await discovery.unregister_server()
+            _LOGGER.info("ESPHome server: Stopped")
+
+    try:
+        asyncio.run(server_loop())
+    except Exception as e:
+        _LOGGER.error(f"ESPHome server thread: Fatal error: {e}", exc_info=True)
+
+
+def _process_audio(state: ServerState):
+    """Process audio from microphone."""
+    _LOGGER.info("Audio processor thread: Starting...")
+    
+    try:
+        # Start media
+        _LOGGER.info("Audio processor: Starting media recording...")
+        state.music_player._robot.media.start_recording()
+        _LOGGER.info("Audio processor: Starting media playback...")
+        state.music_player._robot.media.start_playing()
+        _LOGGER.info("Audio processor: Media started, waiting 1 second...")
+        time.sleep(1)
+
+        wake_words: List[Union[MicroWakeWord, OpenWakeWord]] = []
+        micro_features: Optional[MicroWakeWordFeatures] = None
+        micro_inputs: List[np.ndarray] = []
+
+        oww_features: Optional[OpenWakeWordFeatures] = None
+        oww_inputs: List[np.ndarray] = []
+        has_oww = False
+
+        last_active: Optional[float] = None
+
+        _LOGGER.info("Audio processor: Audio processing loop started")
+
+        while True:
+            try:
+                # Get audio sample from Reachy Mini
+                audio_frame = state.music_player._robot.media.get_audio_sample()
+                
+                if audio_frame is not None:
+                    # Send to satellite if connected
+                    if state.satellite is not None:
+                        # Convert to bytes for satellite
+                        audio_bytes = (audio_frame * 32767.0).astype(np.int16).tobytes()
+                        state.satellite.handle_audio(audio_bytes)
+
+                    # Update wake word models
+                    if (not wake_words) or (state.wake_words_changed and state.wake_words):
+                        state.wake_words_changed = False
+                        wake_words = [
+                            ww
+                            for ww in state.wake_words.values()
+                            if ww.id in state.active_wake_words
+                        ]
+
+                        has_oww = False
+                        for wake_word in wake_words:
+                            if isinstance(wake_word, OpenWakeWord):
+                                has_oww = True
+
+                        if micro_features is None:
+                            micro_features = MicroWakeWordFeatures()
+
+                        if has_oww and (oww_features is None):
+                            oww_features = OpenWakeWordFeatures.from_builtin()
+
+                    # Process wake words
+                    if wake_words:
+                        assert micro_features is not None
+                        micro_inputs.clear()
+                        # Convert float32 audio to int16 for microWakeWord
+                        audio_int16 = (audio_frame * 32767.0).astype(np.int16)
+                        micro_inputs.extend(micro_features.process_streaming(audio_int16))
+
+                        if has_oww:
+                            assert oww_features is not None
+                            oww_inputs.clear()
+                            oww_inputs.extend(oww_features.process_streaming(audio_frame))
+
+                        for wake_word in wake_words:
+                            activated = False
+                            if isinstance(wake_word, MicroWakeWord):
+                                for micro_input in micro_inputs:
+                                    if wake_word.process_streaming(micro_input):
+                                        activated = True
+                            elif isinstance(wake_word, OpenWakeWord):
+                                for oww_input in oww_inputs:
+                                    for prob in wake_word.process_streaming(oww_input):
+                                        if prob > 0.5:
+                                            activated = True
+
+                            if activated:
+                                now = time.monotonic()
+                                if (last_active is None) or (
+                                    (now - last_active) > state.refractory_seconds
+                                ):
+                                    if state.satellite:
+                                        state.satellite.wakeup(wake_word)
+                                    last_active = now
+
+                            # Process stop word
+                            if state.stop_word is not None:
+                                stopped = False
+                                for micro_input in micro_inputs:
+                                    if state.stop_word.process_streaming(micro_input):
+                                        stopped = True
+
+                                if stopped and (state.stop_word.id in state.active_wake_words):
+                                    if state.satellite:
+                                        state.satellite.stop()
+
+                time.sleep(0.001)
+            except Exception as e:
+                _LOGGER.error(f"Audio processor: Error in processing loop: {e}", exc_info=True)
+                time.sleep(0.1)
+    except Exception as e:
+        _LOGGER.error(f"Audio processor thread: Fatal error: {e}", exc_info=True)
+
+
+class ReachyMiniAudioPlayer:
+    """Audio player using Reachy Mini's media system."""
+    
+    def __init__(self, robot: ReachyMini):
+        self._robot = robot
+        
+    def play(self, audio_source, done_callback=None):
+        """Play audio from file or URL."""
+        try:
+            if isinstance(audio_source, str):
+                # Check if it's a URL or file path
+                if audio_source.startswith(('http://', 'https://')):
+                    _LOGGER.info(f"Playing audio from URL: {audio_source}")
+                    # For URLs, use Reachy Mini's play_sound method
+                    self._robot.media.play_sound(audio_source)
+                else:
+                    # Load audio file using soundfile
+                    import soundfile as sf
+                    data, sr = sf.read(audio_source, dtype='float32')
+                    
+                    # Resample if needed
+                    output_sr = self._robot.media.get_output_audio_samplerate()
+                    if sr != output_sr:
+                        from scipy.signal import resample
+                        data = resample(data, int(len(data) * output_sr / sr))
+                    
+                    # Ensure correct shape for output channels
+                    output_channels = self._robot.media.get_output_channels()
+                    if data.ndim == 1 and output_channels > 1:
+                        data = np.tile(data[:, None], (1, output_channels))
+                    elif data.ndim == 2 and data.shape[1] < output_channels:
+                        data = np.tile(data[:, [0]], (1, output_channels))
+                    elif data.ndim == 2 and data.shape[1] > output_channels:
+                        data = data[:, :output_channels]
+                    
+                    # Push to player
+                    self._robot.media.push_audio_sample(data)
+                    
+            if done_callback:
+                done_callback()
+        except Exception as e:
+            _LOGGER.error(f"Error playing audio: {e}")
+    
+    def stop(self):
+        """Stop playback."""
+        pass
+    
+    def duck(self):
+        """Duck volume."""
+        pass
+    
+    def unduck(self):
+        """Unduck volume."""
+        pass
+    
+    def close(self):
+        """Close player."""
+        pass

src_backup/reachy_mini_ha_voice/entity.py

@@ -0,0 +1,94 @@
+"""Entity management for Home Assistant."""
+
+import logging
+from typing import Dict, List, Optional
+
+# pylint: disable=no-name-in-module
+from aioesphomeapi.api_pb2 import (  # type: ignore[attr-defined]
+    ListEntitiesDoneResponse,
+    ListEntitiesRequest,
+    MediaPlayerCommandRequest,
+)
+from aioesphomeapi.model import MediaPlayerState
+
+from .models import Entity
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MediaPlayerEntity(Entity):
+    """Media player entity for voice assistant."""
+
+    def __init__(
+        self, server, key: int, name: str, object_id: str, music_player, announce_player
+    ):
+        """Initialize media player entity."""
+        super().__init__(key=key, name=name, state="idle", attributes={})
+        self.server = server
+        self.object_id = object_id
+        self.music_player = music_player
+        self.announce_player = announce_player
+        self._volume = 1.0
+        self._position = 0
+        self._duration = 0
+
+    def handle_message(self, msg):
+        """Handle a message."""
+        if isinstance(msg, ListEntitiesRequest):
+            yield self.get_list_entities_response()
+        elif isinstance(msg, MediaPlayerCommandRequest):
+            self.handle_command(msg)
+
+    def get_list_entities_response(self):
+        """Get list entities response."""
+        from aioesphomeapi.api_pb2 import ListEntitiesMediaPlayerResponse
+
+        return ListEntitiesMediaPlayerResponse(
+            object_id=self.object_id,
+            key=self.key,
+            name=self.name,
+        )
+
+    def handle_command(self, msg):
+        """Handle a media player command."""
+        if msg.command == MediaPlayerCommandRequest.PLAY:
+            if msg.url:
+                self.play([msg.url])
+        elif msg.command == MediaPlayerCommandRequest.PAUSE:
+            self.music_player.stop()
+        elif msg.command == MediaPlayerCommandRequest.STOP:
+            self.music_player.stop()
+        elif msg.command == MediaPlayerCommandRequest.VOLUME_SET:
+            self._volume = msg.volume / 255.0
+        elif msg.command == MediaPlayerCommandRequest.MUTE:
+            self._volume = 0.0 if msg.mute else 1.0
+
+    def play(self, urls, announcement=False, done_callback=None):
+        """Play media."""
+        _LOGGER.debug("Playing: %s", urls)
+        player = self.announce_player if announcement else self.music_player
+
+        for url in urls:
+            try:
+                from urllib.request import urlopen
+
+                with urlopen(url) as response:
+                    audio_data = response.read()
+                player.play(audio_data)
+            except Exception as e:
+                _LOGGER.error("Error playing %s: %s", url, e)
+
+        if done_callback:
+            done_callback()
+
+    def duck(self):
+        """Duck the volume."""
+        _LOGGER.debug("Ducking media player")
+        # Reduce volume by 50%
+        # self._volume *= 0.5
+
+    def unduck(self):
+        """Unduck the volume."""
+        _LOGGER.debug("Unducking media player")
+        # Restore volume
+        # self._volume = min(1.0, self._volume * 2.0)

src_backup/reachy_mini_ha_voice/models.py

@@ -0,0 +1,179 @@
+"""Data models for the voice assistant."""
+
+import logging
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from queue import Queue
+from typing import Dict, List, Optional, Set, Union
+
+import numpy as np
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class WakeWordType(str, Enum):
+    """Type of wake word model."""
+
+    MICRO_WAKE_WORD = "micro"
+    OPEN_WAKE_WORD = "openWakeWord"
+
+
+@dataclass
+class AvailableWakeWord:
+    """Information about an available wake word model."""
+
+    id: str
+    type: WakeWordType
+    wake_word: str
+    trained_languages: List[str] = field(default_factory=list)
+    wake_word_path: Optional[Path] = None
+
+    def load(self):
+        """Load the wake word model."""
+        if self.type == WakeWordType.MICRO_WAKE_WORD:
+            from pymicro_wakeword import MicroWakeWord
+
+            return MicroWakeWord.from_config(config_path=self.wake_word_path)
+        elif self.type == WakeWordType.OPEN_WAKE_WORD:
+            from pyopen_wakeword import OpenWakeWord
+
+            oww_model = OpenWakeWord.from_model(model_path=self.wake_word_path)
+            setattr(oww_model, "wake_word", self.wake_word)
+
+            return oww_model
+        else:
+            raise ValueError(f"Unknown wake word type: {self.type}")
+
+
+@dataclass
+class Preferences:
+    """User preferences."""
+
+    active_wake_words: List[str] = field(default_factory=list)
+
+
+@dataclass
+class ServerState:
+    """Shared server state."""
+
+    name: str
+    mac_address: str
+    audio_queue: "Queue[Optional[bytes]]"
+    entities: List["Entity"]
+    available_wake_words: Dict[str, AvailableWakeWord]
+    wake_words: Dict[str, Union["MicroWakeWord", "OpenWakeWord"]]
+    active_wake_words: Set[str]
+    stop_word: "MicroWakeWord"
+    music_player: "AudioPlayer"
+    tts_player: "AudioPlayer"
+    wakeup_sound: str
+    timer_finished_sound: str
+    preferences: Preferences
+    preferences_path: Path
+    refractory_seconds: float
+    download_dir: Path
+    satellite: Optional["VoiceSatelliteProtocol"] = None
+    wake_words_changed: bool = False
+    reachy_integration: Optional["ReachyMiniIntegration"] = None
+    media_player_entity: Optional["MediaPlayerEntity"] = None
+
+    def save_preferences(self) -> None:
+        """Save preferences to file."""
+        try:
+            import json
+
+            with open(self.preferences_path, "w", encoding="utf-8") as f:
+                json.dump(
+                    {"active_wake_words": self.preferences.active_wake_words},
+                    f,
+                )
+        except Exception as e:
+            _LOGGER.error("Error saving preferences: %s", e)
+
+
+@dataclass
+class Entity:
+    """A Home Assistant entity."""
+
+    key: str
+    name: str
+    state: str
+    attributes: Dict[str, str] = field(default_factory=dict)
+
+
+class AudioPlayer:
+    """Simple audio player using PyAudio."""
+
+    def __init__(self, device: Optional[int] = None):
+        """Initialize audio player."""
+        self.device = device
+        self._stream = None
+        self._pyaudio = None
+        self._ducked = False
+
+    def play(self, audio_data: Union[bytes, str], done_callback=None) -> None:
+        """Play audio data or URL."""
+        import pyaudio
+
+        if self._pyaudio is None:
+            self._pyaudio = pyaudio.PyAudio()
+
+        if isinstance(audio_data, str):
+            # It's a URL or file path
+            try:
+                from urllib.request import urlopen
+
+                if audio_data.startswith("http://") or audio_data.startswith("https://"):
+                    with urlopen(audio_data) as response:
+                        audio_data = response.read()
+                else:
+                    # It's a file path
+                    with open(audio_data, "rb") as f:
+                        audio_data = f.read()
+            except Exception as e:
+                _LOGGER.error("Error loading audio: %s", e)
+                if done_callback:
+                    done_callback()
+                return
+
+        # Assume 16-bit PCM, 16kHz, mono
+        if self._stream is None:
+            self._stream = self._pyaudio.open(
+                format=pyaudio.paInt16,
+                channels=1,
+                rate=16000,
+                output=True,
+                output_device_index=self.device,
+            )
+
+        self._stream.write(audio_data)
+
+        if done_callback:
+            done_callback()
+
+    def duck(self) -> None:
+        """Duck the volume (reduce by 50%)."""
+        self._ducked = True
+        # For simple implementation, we just note the state
+        # In a full implementation, we would actually reduce the volume
+
+    def unduck(self) -> None:
+        """Unduck the volume (restore to normal)."""
+        self._ducked = False
+        # For simple implementation, we just note the state
+        # In a full implementation, we would actually restore the volume
+
+    def stop(self) -> None:
+        """Stop playing and reset the stream."""
+        if self._stream is not None:
+            self._stream.stop_stream()
+            self._stream.close()
+            self._stream = None
+
+    def close(self) -> None:
+        """Close the audio player."""
+        self.stop()
+        if self._pyaudio is not None:
+            self._pyaudio.terminate()
+            self._pyaudio = None

src_backup/reachy_mini_ha_voice/reachy_integration.py

@@ -0,0 +1,114 @@
+"""Reachy Mini integration module."""
+
+import logging
+from typing import Optional
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ReachyMiniIntegration:
+    """Integration with Reachy Mini robot."""
+
+    def __init__(self):
+        """Initialize Reachy Mini integration."""
+        self._reachy = None
+        self._connected = False
+
+    def connect(self) -> bool:
+        """Connect to Reachy Mini."""
+        try:
+            # Import reachy-mini SDK
+            # This will be installed when running on Reachy Mini
+            from reachy_sdk import ReachySDK
+
+            self._reachy = ReachySDK()
+            self._connected = True
+            _LOGGER.info("Connected to Reachy Mini")
+            return True
+        except ImportError:
+            _LOGGER.warning("Reachy SDK not available, running in standalone mode")
+            return False
+        except Exception as e:
+            _LOGGER.error("Failed to connect to Reachy Mini: %s", e)
+            return False
+
+    def disconnect(self) -> None:
+        """Disconnect from Reachy Mini."""
+        if self._reachy:
+            try:
+                self._reachy.disconnect()
+                self._connected = False
+                _LOGGER.info("Disconnected from Reachy Mini")
+            except Exception as e:
+                _LOGGER.error("Error disconnecting from Reachy Mini: %s", e)
+
+    def on_wake_word_detected(self) -> None:
+        """Handle wake word detection."""
+        if not self._connected:
+            return
+
+        try:
+            # Make Reachy Mini look up
+            self._reachy.head.tilt.goto(20, duration=0.5, wait=True)
+            self._reachy.head.pan.goto(0, duration=0.5, wait=True)
+            _LOGGER.debug("Reachy Mini: Look up on wake word")
+        except Exception as e:
+            _LOGGER.error("Error moving Reachy Mini on wake word: %s", e)
+
+    def on_listening(self) -> None:
+        """Handle listening state."""
+        if not self._connected:
+            return
+
+        try:
+            # Subtle head movement to indicate listening
+            self._reachy.head.pan.goto(10, duration=0.3, wait=True)
+            self._reachy.head.pan.goto(-10, duration=0.6, wait=True)
+            self._reachy.head.pan.goto(0, duration=0.3, wait=True)
+            _LOGGER.debug("Reachy Mini: Listening head movement")
+        except Exception as e:
+            _LOGGER.error("Error moving Reachy Mini while listening: %s", e)
+
+    def on_response(self) -> None:
+        """Handle response state."""
+        if not self._connected:
+            return
+
+        try:
+            # Nod to acknowledge
+            self._reachy.head.tilt.goto(10, duration=0.3, wait=True)
+            self._reachy.head.tilt.goto(-10, duration=0.6, wait=True)
+            self._reachy.head.tilt.goto(0, duration=0.3, wait=True)
+            _LOGGER.debug("Reachy Mini: Nod on response")
+        except Exception as e:
+            _LOGGER.error("Error moving Reachy Mini on response: %s", e)
+
+    def on_error(self) -> None:
+        """Handle error state."""
+        if not self._connected:
+            return
+
+        try:
+            # Tilt head to indicate error
+            self._reachy.head.tilt.goto(-20, duration=0.5, wait=True)
+            _LOGGER.debug("Reachy Mini: Tilt head on error")
+        except Exception as e:
+            _LOGGER.error("Error moving Reachy Mini on error: %s", e)
+
+    def on_stop(self) -> None:
+        """Handle stop command."""
+        if not self._connected:
+            return
+
+        try:
+            # Shake head to indicate stop
+            self._reachy.head.pan.goto(-15, duration=0.3, wait=True)
+            self._reachy.head.pan.goto(15, duration=0.6, wait=True)
+            self._reachy.head.pan.goto(0, duration=0.3, wait=True)
+            _LOGGER.debug("Reachy Mini: Shake head on stop")
+        except Exception as e:
+            _LOGGER.error("Error moving Reachy Mini on stop: %s", e)
+
+    def is_connected(self) -> bool:
+        """Check if connected to Reachy Mini."""
+        return self._connected

src_backup/reachy_mini_ha_voice/satellite.py

@@ -0,0 +1,398 @@
+"""Voice satellite protocol."""
+
+import hashlib
+import logging
+import posixpath
+import shutil
+import time
+from collections.abc import Iterable
+from typing import Dict, Optional, Set, Union
+from urllib.parse import urlparse, urlunparse
+from urllib.request import urlopen
+
+# pylint: disable=no-name-in-module
+from aioesphomeapi.api_pb2 import (  # type: ignore[attr-defined]
+    DeviceInfoRequest,
+    DeviceInfoResponse,
+    ListEntitiesDoneResponse,
+    ListEntitiesRequest,
+    MediaPlayerCommandRequest,
+    SubscribeHomeAssistantStatesRequest,
+    VoiceAssistantAnnounceFinished,
+    VoiceAssistantAnnounceRequest,
+    VoiceAssistantAudio,
+    VoiceAssistantConfigurationRequest,
+    VoiceAssistantConfigurationResponse,
+    VoiceAssistantEventResponse,
+    VoiceAssistantExternalWakeWord,
+    VoiceAssistantRequest,
+    VoiceAssistantSetConfiguration,
+    VoiceAssistantTimerEventResponse,
+    VoiceAssistantWakeWord,
+)
+from aioesphomeapi.model import (
+    VoiceAssistantEventType,
+    VoiceAssistantFeature,
+    VoiceAssistantTimerEventType,
+)
+from google.protobuf import message
+from pymicro_wakeword import MicroWakeWord
+from pyopen_wakeword import OpenWakeWord
+
+from .api_server import APIServer
+from .entity import MediaPlayerEntity
+from .models import AvailableWakeWord, ServerState, WakeWordType
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class VoiceSatelliteProtocol(APIServer):
+
+    def __init__(self, state: ServerState) -> None:
+        super().__init__(state.name)
+
+        self.state = state
+        self.state.satellite = self
+
+        if self.state.media_player_entity is None:
+            self.state.media_player_entity = MediaPlayerEntity(
+                server=self,
+                key=len(state.entities),
+                name="Media Player",
+                object_id="reachy_mini_ha_voice_media_player",
+                music_player=state.music_player,
+                announce_player=state.tts_player,
+            )
+            self.state.entities.append(self.state.media_player_entity)
+
+        self._is_streaming_audio = False
+        self._tts_url: Optional[str] = None
+        self._tts_played = False
+        self._continue_conversation = False
+        self._timer_finished = False
+        self._external_wake_words: Dict[str, VoiceAssistantExternalWakeWord] = {}
+
+    def handle_voice_event(
+        self, event_type: VoiceAssistantEventType, data: Dict[str, str]
+    ) -> None:
+        _LOGGER.debug("Voice event: type=%s, data=%s", event_type.name, data)
+
+        if event_type == VoiceAssistantEventType.VOICE_ASSISTANT_RUN_START:
+            self._tts_url = data.get("url")
+            self._tts_played = False
+            self._continue_conversation = False
+        elif event_type in (
+            VoiceAssistantEventType.VOICE_ASSISTANT_STT_VAD_END,
+            VoiceAssistantEventType.VOICE_ASSISTANT_STT_END,
+        ):
+            self._is_streaming_audio = False
+        elif event_type == VoiceAssistantEventType.VOICE_ASSISTANT_INTENT_PROGRESS:
+            if data.get("tts_start_streaming") == "1":
+                # Start streaming early
+                self.play_tts()
+        elif event_type == VoiceAssistantEventType.VOICE_ASSISTANT_INTENT_END:
+            if data.get("continue_conversation") == "1":
+                self._continue_conversation = True
+        elif event_type == VoiceAssistantEventType.VOICE_ASSISTANT_TTS_END:
+            self._tts_url = data.get("url")
+            self.play_tts()
+        elif event_type == VoiceAssistantEventType.VOICE_ASSISTANT_RUN_END:
+            self._is_streaming_audio = False
+            if not self._tts_played:
+                self._tts_finished()
+
+            self._tts_played = False
+
+        # TODO: handle error
+
+    def handle_timer_event(
+        self,
+        event_type: VoiceAssistantTimerEventType,
+        msg: VoiceAssistantTimerEventResponse,
+    ) -> None:
+        _LOGGER.debug("Timer event: type=%s", event_type.name)
+        if event_type == VoiceAssistantTimerEventType.VOICE_ASSISTANT_TIMER_FINISHED:
+            if not self._timer_finished:
+                self.state.active_wake_words.add(self.state.stop_word.id)
+                self._timer_finished = True
+                self.duck()
+                self._play_timer_finished()
+
+    def handle_message(self, msg: message.Message) -> Iterable[message.Message]:
+        if isinstance(msg, VoiceAssistantEventResponse):
+            # Pipeline event
+            data: Dict[str, str] = {}
+            for arg in msg.data:
+                data[arg.name] = arg.value
+
+            self.handle_voice_event(VoiceAssistantEventType(msg.event_type), data)
+        elif isinstance(msg, VoiceAssistantAnnounceRequest):
+            _LOGGER.debug("Announcing: %s", msg.text)
+
+            assert self.state.media_player_entity is not None
+
+            urls = []
+            if msg.preannounce_media_id:
+                urls.append(msg.preannounce_media_id)
+
+            urls.append(msg.media_id)
+
+            self.state.active_wake_words.add(self.state.stop_word.id)
+            self._continue_conversation = msg.start_conversation
+
+            self.duck()
+            yield from self.state.media_player_entity.play(
+                urls, announcement=True, done_callback=self._tts_finished
+            )
+        elif isinstance(msg, VoiceAssistantTimerEventResponse):
+            self.handle_timer_event(VoiceAssistantTimerEventType(msg.event_type), msg)
+        elif isinstance(msg, DeviceInfoRequest):
+            yield DeviceInfoResponse(
+                uses_password=False,
+                name=self.state.name,
+                mac_address=self.state.mac_address,
+                voice_assistant_feature_flags=(
+                    VoiceAssistantFeature.VOICE_ASSISTANT
+                    | VoiceAssistantFeature.API_AUDIO
+                    | VoiceAssistantFeature.ANNOUNCE
+                    | VoiceAssistantFeature.START_CONVERSATION
+                    | VoiceAssistantFeature.TIMERS
+                ),
+            )
+        elif isinstance(
+            msg,
+            (
+                ListEntitiesRequest,
+                SubscribeHomeAssistantStatesRequest,
+                MediaPlayerCommandRequest,
+            ),
+        ):
+            for entity in self.state.entities:
+                yield from entity.handle_message(msg)
+
+            if isinstance(msg, ListEntitiesRequest):
+                yield ListEntitiesDoneResponse()
+        elif isinstance(msg, VoiceAssistantConfigurationRequest):
+            available_wake_words = [
+                VoiceAssistantWakeWord(
+                    id=ww.id,
+                    wake_word=ww.wake_word,
+                    trained_languages=ww.trained_languages,
+                )
+                for ww in self.state.available_wake_words.values()
+            ]
+
+            for eww in msg.external_wake_words:
+                if eww.model_type != "micro":
+                    continue
+
+                available_wake_words.append(
+                    VoiceAssistantWakeWord(
+                        id=eww.id,
+                        wake_word=eww.wake_word,
+                        trained_languages=eww.trained_languages,
+                    )
+                )
+
+                self._external_wake_words[eww.id] = eww
+
+            yield VoiceAssistantConfigurationResponse(
+                available_wake_words=available_wake_words,
+                active_wake_words=[
+                    ww.id
+                    for ww in self.state.wake_words.values()
+                    if ww.id in self.state.active_wake_words
+                ],
+                max_active_wake_words=2,
+            )
+            _LOGGER.info("Connected to Home Assistant")
+        elif isinstance(msg, VoiceAssistantSetConfiguration):
+            # Change active wake words
+            active_wake_words: Set[str] = set()
+
+            for wake_word_id in msg.active_wake_words:
+                if wake_word_id in self.state.wake_words:
+                    # Already active
+                    active_wake_words.add(wake_word_id)
+                    continue
+
+                model_info = self.state.available_wake_words.get(wake_word_id)
+                if not model_info:
+                    # Check external wake words (may require download)
+                    external_wake_word = self._external_wake_words.get(wake_word_id)
+                    if not external_wake_word:
+                        continue
+
+                    model_info = self._download_external_wake_word(external_wake_word)
+                    if not model_info:
+                        continue
+
+                    self.state.available_wake_words[wake_word_id] = model_info
+
+                _LOGGER.debug("Loading wake word: %s", model_info.wake_word_path)
+                self.state.wake_words[wake_word_id] = model_info.load()
+
+                _LOGGER.info("Wake word set: %s", wake_word_id)
+                active_wake_words.add(wake_word_id)
+                break
+
+            self.state.active_wake_words = active_wake_words
+            _LOGGER.debug("Active wake words: %s", active_wake_words)
+
+            self.state.preferences.active_wake_words = list(active_wake_words)
+            self.state.save_preferences()
+            self.state.wake_words_changed = True
+
+    def handle_audio(self, audio_chunk: bytes) -> None:
+
+        if not self._is_streaming_audio:
+            return
+
+        self.send_messages([VoiceAssistantAudio(data=audio_chunk)])
+
+    def wakeup(self, wake_word: Union[MicroWakeWord, OpenWakeWord]) -> None:
+        if self._timer_finished:
+            # Stop timer instead
+            self._timer_finished = False
+            self.state.tts_player.stop()
+            _LOGGER.debug("Stopping timer finished sound")
+            return
+
+        wake_word_phrase = wake_word.wake_word
+        _LOGGER.debug("Detected wake word: %s", wake_word_phrase)
+        self.send_messages(
+            [VoiceAssistantRequest(start=True, wake_word_phrase=wake_word_phrase)]
+        )
+        self.duck()
+        self._is_streaming_audio = True
+        try:
+            self.state.tts_player.play(self.state.wakeup_sound)
+        except Exception as e:
+            _LOGGER.warning("Failed to play wakeup sound: %s", e)
+
+    def stop(self) -> None:
+        self.state.active_wake_words.discard(self.state.stop_word.id)
+        self.state.tts_player.stop()
+
+        if self._timer_finished:
+            self._timer_finished = False
+            _LOGGER.debug("Stopping timer finished sound")
+        else:
+            _LOGGER.debug("TTS response stopped manually")
+            self._tts_finished()
+
+    def play_tts(self) -> None:
+        if (not self._tts_url) or self._tts_played:
+            return
+
+        self._tts_played = True
+        _LOGGER.debug("Playing TTS response: %s", self._tts_url)
+
+        self.state.active_wake_words.add(self.state.stop_word.id)
+        self.state.tts_player.play(self._tts_url, done_callback=self._tts_finished)
+
+    def duck(self) -> None:
+        _LOGGER.debug("Ducking music")
+        self.state.music_player.duck()
+
+    def unduck(self) -> None:
+        _LOGGER.debug("Unducking music")
+        self.state.music_player.unduck()
+
+    def _tts_finished(self) -> None:
+        self.state.active_wake_words.discard(self.state.stop_word.id)
+        self.send_messages([VoiceAssistantAnnounceFinished()])
+
+        if self._continue_conversation:
+            self.send_messages([VoiceAssistantRequest(start=True)])
+            self._is_streaming_audio = True
+            _LOGGER.debug("Continuing conversation")
+        else:
+            self.unduck()
+
+        _LOGGER.debug("TTS response finished")
+
+    def _play_timer_finished(self) -> None:
+        if not self._timer_finished:
+            self.unduck()
+            return
+
+        try:
+            self.state.tts_player.play(
+                self.state.timer_finished_sound,
+                done_callback=lambda: time.sleep(1.0) or self._play_timer_finished(),
+            )
+        except Exception as e:
+            _LOGGER.warning("Failed to play timer finished sound: %s", e)
+            self.unduck()
+
+    def connection_lost(self, exc):
+        super().connection_lost(exc)
+        _LOGGER.info("Disconnected from Home Assistant")
+
+    def _download_external_wake_word(
+        self, external_wake_word: VoiceAssistantExternalWakeWord
+    ) -> Optional[AvailableWakeWord]:
+        eww_dir = self.state.download_dir / "external_wake_words"
+        eww_dir.mkdir(parents=True, exist_ok=True)
+
+        config_path = eww_dir / f"{external_wake_word.id}.json"
+        should_download_config = not config_path.exists()
+
+        # Check if we need to download the model file
+        model_path = eww_dir / f"{external_wake_word.id}.tflite"
+        should_download_model = True
+        if model_path.exists():
+            model_size = model_path.stat().st_size
+            if model_size == external_wake_word.model_size:
+                with open(model_path, "rb") as model_file:
+                    model_hash = hashlib.sha256(model_file.read()).hexdigest()
+
+                if model_hash == external_wake_word.model_hash:
+                    should_download_model = False
+                    _LOGGER.debug(
+                        "Model size and hash match for %s. Skipping download.",
+                        external_wake_word.id,
+                    )
+
+        if should_download_config or should_download_model:
+            # Download config
+            _LOGGER.debug("Downloading %s to %s", external_wake_word.url, config_path)
+            with urlopen(external_wake_word.url) as request:
+                if request.status != 200:
+                    _LOGGER.warning(
+                        "Failed to download: %s, status=%s",
+                        external_wake_word.url,
+                        request.status,
+                    )
+                    return None
+
+                with open(config_path, "wb") as model_file:
+                    shutil.copyfileobj(request, model_file)
+
+        if should_download_model:
+            # Download model file
+            parsed_url = urlparse(external_wake_word.url)
+            parsed_url = parsed_url._replace(
+                path=posixpath.join(posixpath.dirname(parsed_url.path), model_path.name)
+            )
+            model_url = urlunparse(parsed_url)
+
+            _LOGGER.debug("Downloading %s to %s", model_url, model_path)
+            with urlopen(model_url) as request:
+                if request.status != 200:
+                    _LOGGER.warning(
+                        "Failed to download: %s, status=%s", model_url, request.status
+                    )
+                    return None
+
+                with open(model_path, "wb") as model_file:
+                    shutil.copyfileobj(request, model_file)
+
+        return AvailableWakeWord(
+            id=external_wake_word.id,
+            type=WakeWordType.MICRO_WAKE_WORD,
+            wake_word=external_wake_word.wake_word,
+            trained_languages=external_wake_word.trained_languages,
+            wake_word_path=config_path,
+        )

src_backup/reachy_mini_ha_voice/static/index.html

@@ -0,0 +1,61 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Reachy Mini HA Voice – Settings</title>
+    <link rel="stylesheet" href="/static/style.css" />
+  </head>
+<body>
+    <div class="container">
+        <header>
+            <h1>🤖 Reachy Mini Home Assistant Voice Assistant</h1>
+            <p class="subtitle">基于 ESPHome 协议的语音助手</p>
+        </header>
+
+        <main>
+            <section class="status">
+                <h2>状态</h2>
+                <div class="status-indicator">
+                    <span class="status-dot" id="statusDot"></span>
+                    <span class="status-text" id="statusText">未运行</span>
+                </div>
+            </section>
+
+            <section class="info">
+                <h2>信息</h2>
+                <div class="info-card">
+                    <h3>🎤 唤醒词</h3>
+                    <p>默认唤醒词: "Okay Nabu"</p>
+                    <p>支持多个唤醒词: Alexa, Hey Jarvis, Hey Home Assistant 等</p>
+                </div>
+
+                <div class="info-card">
+                    <h3>🔌 连接</h3>
+                    <p>ESPHome 端口: 6053</p>
+                    <p>自动发现: 已启用 (mDNS/Zeroconf)</p>
+                </div>
+
+                <div class="info-card">
+                    <h3>🏠 Home Assistant</h3>
+                    <p>1. 在 Home Assistant 中添加 ESPHome 集成</p>
+                    <p>2. 输入 Reachy Mini 的 IP 地址</p>
+                    <p>3. 端口: 6053</p>
+                </div>
+            </section>
+
+            <section class="actions">
+                <h2>操作</h2>
+                <button class="btn btn-primary" id="startBtn">启动</button>
+                <button class="btn btn-secondary" id="stopBtn">停止</button>
+            </section>
+        </main>
+
+        <footer>
+            <p>基于 <a href="https://github.com/OHF-Voice/linux-voice-assistant">OHF-Voice/linux-voice-assistant</a> 修改</p>
+        </footer>
+    </div>
+
+    <script src="/static/main.js"></script>
+</body>
+</html>

src_backup/reachy_mini_ha_voice/static/main.js

@@ -0,0 +1,47 @@
+// Reachy Mini Home Assistant Voice Assistant UI
+
+document.addEventListener('DOMContentLoaded', function() {
+    const statusDot = document.getElementById('statusDot');
+    const statusText = document.getElementById('statusText');
+    const startBtn = document.getElementById('startBtn');
+    const stopBtn = document.getElementById('stopBtn');
+
+    // Check initial status
+    checkStatus();
+
+    // Start button click handler
+    startBtn.addEventListener('click', function() {
+        // This will be handled by the Reachy Mini dashboard
+        console.log('Start button clicked');
+    });
+
+    // Stop button click handler
+    stopBtn.addEventListener('click', function() {
+        // This will be handled by the Reachy Mini dashboard
+        console.log('Stop button clicked');
+    });
+
+    // Check status periodically
+    setInterval(checkStatus, 5000);
+});
+
+function checkStatus() {
+    // In a real implementation, this would check the actual status
+    // For now, we'll just update the UI
+    const statusDot = document.getElementById('statusDot');
+    const statusText = document.getElementById('statusText');
+
+    // Simulate status check
+    // In production, this would make an API call to get the actual status
+    const isRunning = false; // Change this based on actual status
+
+    if (isRunning) {
+        statusDot.classList.add('running');
+        statusDot.classList.remove('stopped');
+        statusText.textContent = '运行中';
+    } else {
+        statusDot.classList.add('stopped');
+        statusDot.classList.remove('running');
+        statusText.textContent = '未运行';
+    }
+}

src_backup/reachy_mini_ha_voice/static/style.css

@@ -0,0 +1,163 @@
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    min-height: 100vh;
+    padding: 20px;
+}
+
+.container {
+    max-width: 800px;
+    margin: 0 auto;
+    background: white;
+    border-radius: 20px;
+    box-shadow: 0 10px 40px rgba(0, 0, 0, 0.2);
+    overflow: hidden;
+}
+
+header {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 40px;
+    text-align: center;
+}
+
+header h1 {
+    font-size: 2.5em;
+    margin-bottom: 10px;
+}
+
+.subtitle {
+    font-size: 1.2em;
+    opacity: 0.9;
+}
+
+main {
+    padding: 40px;
+}
+
+section {
+    margin-bottom: 40px;
+}
+
+h2 {
+    color: #333;
+    margin-bottom: 20px;
+    font-size: 1.8em;
+}
+
+.status-indicator {
+    display: flex;
+    align-items: center;
+    gap: 15px;
+    padding: 20px;
+    background: #f5f5f5;
+    border-radius: 10px;
+}
+
+.status-dot {
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+    background: #ccc;
+    transition: background 0.3s;
+}
+
+.status-dot.running {
+    background: #4CAF50;
+    animation: pulse 2s infinite;
+}
+
+.status-dot.stopped {
+    background: #f44336;
+}
+
+@keyframes pulse {
+    0%, 100% {
+        opacity: 1;
+    }
+    50% {
+        opacity: 0.5;
+    }
+}
+
+.status-text {
+    font-size: 1.2em;
+    color: #666;
+}
+
+.info-card {
+    background: #f9f9f9;
+    padding: 20px;
+    border-radius: 10px;
+    margin-bottom: 15px;
+    border-left: 4px solid #667eea;
+}
+
+.info-card h3 {
+    color: #667eea;
+    margin-bottom: 10px;
+}
+
+.info-card p {
+    color: #666;
+    line-height: 1.6;
+    margin-bottom: 5px;
+}
+
+.actions {
+    text-align: center;
+}
+
+.btn {
+    padding: 15px 40px;
+    font-size: 1.1em;
+    border: none;
+    border-radius: 10px;
+    cursor: pointer;
+    transition: all 0.3s;
+    margin: 0 10px;
+}
+
+.btn-primary {
+    background: #667eea;
+    color: white;
+}
+
+.btn-primary:hover {
+    background: #5568d3;
+    transform: translateY(-2px);
+    box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
+}
+
+.btn-secondary {
+    background: #f44336;
+    color: white;
+}
+
+.btn-secondary:hover {
+    background: #da190b;
+    transform: translateY(-2px);
+    box-shadow: 0 5px 15px rgba(244, 67, 54, 0.4);
+}
+
+footer {
+    background: #f5f5f5;
+    padding: 20px;
+    text-align: center;
+    color: #666;
+}
+
+footer a {
+    color: #667eea;
+    text-decoration: none;
+}
+
+footer a:hover {
+    text-decoration: underline;
+}

src_backup/reachy_mini_ha_voice/util.py

@@ -0,0 +1,19 @@
+"""Utility functions."""
+
+import logging
+import socket
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def get_mac() -> str:
+    """Get the MAC address of the first network interface."""
+    try:
+        mac = ":".join(
+            f"{byte:02x}" for byte in socket.gethostbyname(socket.gethostname()).encode()
+        )
+    except Exception:
+        mac = "00:00:00:00:00:00"
+
+    return mac

src_backup/reachy_mini_ha_voice/wakewords/alexa.json

@@ -0,0 +1,16 @@
+{
+  "type": "micro",
+  "wake_word": "Alexa",
+  "author": "Kevin Ahrendt",
+  "website": "https://www.kevinahrendt.com/",
+  "model": "alexa.tflite",
+  "trained_languages": ["en"],
+  "version": 2,
+  "micro": {
+    "probability_cutoff": 0.9,
+    "sliding_window_size": 5,
+    "feature_step_size": 10,
+    "tensor_arena_size": 22348,
+    "minimum_esphome_version": "2024.7.0"
+  }
+}

src_backup/reachy_mini_ha_voice/wakewords/choo_choo_homie.json

@@ -0,0 +1,18 @@
+{
+    "type": "micro",
+    "wake_word": "Choo Choo Homie",
+    "author": "Michael Hansen",
+    "website": "https://www.home-assistant.io",
+    "model": "choo_choo_homie.tflite",
+    "trained_languages": [
+        "en"
+    ],
+    "version": 2,
+    "micro": {
+        "probability_cutoff": 0.97,
+        "feature_step_size": 10,
+        "sliding_window_size": 5,
+        "tensor_arena_size": 30000,
+        "minimum_esphome_version": "2024.7.0"
+    }
+}

src_backup/reachy_mini_ha_voice/wakewords/hey_home_assistant.json

@@ -0,0 +1,16 @@
+{
+  "type": "micro",
+  "wake_word": "Hey Home Assistant",
+  "author": "Michael Hansen",
+  "website": "https://www.home-assistant.io",
+  "model": "hey_home_assistant.tflite",
+  "trained_languages": ["en"],
+  "version": 2,
+  "micro": {
+    "probability_cutoff": 0.97,
+    "feature_step_size": 10,
+    "sliding_window_size": 5,
+    "tensor_arena_size": 30000,
+    "minimum_esphome_version": "2024.7.0"
+  }
+}

src_backup/reachy_mini_ha_voice/wakewords/hey_jarvis.json

@@ -0,0 +1,16 @@
+{
+  "type": "micro",
+  "wake_word": "Hey Jarvis",
+  "author": "Kevin Ahrendt",
+  "website": "https://www.kevinahrendt.com/",
+  "model": "hey_jarvis.tflite",
+  "trained_languages": ["en"],
+  "version": 2,
+  "micro": {
+    "probability_cutoff": 0.97,
+    "feature_step_size": 10,
+    "sliding_window_size": 5,
+    "tensor_arena_size": 22860,
+    "minimum_esphome_version": "2024.7.0"
+  }
+}

src_backup/reachy_mini_ha_voice/wakewords/hey_luna.json

@@ -0,0 +1,16 @@
+{
+    "type": "micro",
+    "wake_word": "hey_luna",
+    "author": "adamlonsdale",
+    "website": "https://github.com/adamlonsdale",
+    "model": "hey_luna.tflite",
+    "version": 2,
+    "trained_languages": ["en"],
+    "micro": {
+      "probability_cutoff": 0.63,
+      "sliding_window_size": 5,
+      "feature_step_size": 10,
+      "tensor_arena_size": 22860,
+      "minimum_esphome_version": "2024.7.0"
+    }
+  }

src_backup/reachy_mini_ha_voice/wakewords/hey_mycroft.json

@@ -0,0 +1,16 @@
+{
+  "type": "micro",
+  "wake_word": "Hey Mycroft",
+  "author": "Kevin Ahrendt",
+  "website": "https://www.kevinahrendt.com/",
+  "model": "hey_mycroft.tflite",
+  "trained_languages": ["en"],
+  "version": 2,
+  "micro": {
+    "probability_cutoff": 0.95,
+    "sliding_window_size": 5,
+    "feature_step_size": 10,
+    "tensor_arena_size": 23628,
+    "minimum_esphome_version": "2024.7.0"
+  }
+}

src_backup/reachy_mini_ha_voice/wakewords/okay_computer.json

@@ -0,0 +1,18 @@
+{
+    "type": "micro",
+    "wake_word": "Okay Computer",
+    "author": "Michael Hansen",
+    "website": "https://www.home-assistant.io",
+    "model": "okay_computer.tflite",
+    "trained_languages": [
+        "en"
+    ],
+    "version": 2,
+    "micro": {
+        "probability_cutoff": 0.97,
+        "feature_step_size": 10,
+        "sliding_window_size": 5,
+        "tensor_arena_size": 30000,
+        "minimum_esphome_version": "2024.7.0"
+    }
+}

src_backup/reachy_mini_ha_voice/wakewords/okay_nabu.json

@@ -0,0 +1,16 @@
+{
+  "type": "micro",
+  "wake_word": "Okay Nabu",
+  "author": "Kevin Ahrendt",
+  "website": "https://www.kevinahrendt.com/",
+  "model": "okay_nabu.tflite",
+  "trained_languages": ["en","nl","fr","de","it","es","sv"],
+  "version": 2,
+  "micro": {
+    "probability_cutoff": 0.85,
+    "feature_step_size": 10,
+    "sliding_window_size": 5,
+    "tensor_arena_size": 37000,
+    "minimum_esphome_version": "2024.7.0"
+  }
+}

src_backup/reachy_mini_ha_voice/wakewords/openWakeWord/alexa_v0.1.json

@@ -0,0 +1,5 @@
+{
+  "type": "openWakeWord",
+  "wake_word": "Alexa",
+  "model": "alexa_v0.1.tflite"
+}

src_backup/reachy_mini_ha_voice/wakewords/openWakeWord/hey_jarvis_v0.1.json

@@ -0,0 +1,5 @@
+{
+  "type": "openWakeWord",
+  "wake_word": "Hey Jarvis",
+  "model": "hey_jarvis_v0.1.tflite"
+}

src_backup/reachy_mini_ha_voice/wakewords/openWakeWord/hey_mycroft_v0.1.json

@@ -0,0 +1,5 @@
+{
+  "type": "openWakeWord",
+  "wake_word": "Hey Mycroft",
+  "model": "hey_mycroft_v0.1.tflite"
+}

src_backup/reachy_mini_ha_voice/wakewords/openWakeWord/hey_rhasspy_v0.1.json

@@ -0,0 +1,5 @@
+{
+  "type": "openWakeWord",
+  "wake_word": "Hey Rhasspy",
+  "model": "hey_rhasspy_v0.1.tflite"
+}

src_backup/reachy_mini_ha_voice/wakewords/openWakeWord/ok_nabu_v0.1.json

@@ -0,0 +1,5 @@
+{
+  "type": "openWakeWord",
+  "wake_word": "Okay Nabu",
+  "model": "ok_nabu_v0.1.tflite"
+}

src_backup/reachy_mini_ha_voice/wakewords/stop.json

@@ -0,0 +1,16 @@
+{
+  "type": "micro",
+  "wake_word": "Stop",
+  "author": "Kevin Ahrendt",
+  "website": "https://www.kevinahrendt.com/",
+  "model": "stop.tflite",
+  "trained_languages": ["en"],
+  "version": 2,
+  "micro": {
+    "probability_cutoff": 0.5,
+    "feature_step_size": 10,
+    "sliding_window_size": 5,
+    "tensor_arena_size": 21000,
+    "minimum_esphome_version": "2024.7.0"
+  }
+}

src_backup/reachy_mini_ha_voice/zeroconf.py

@@ -0,0 +1,68 @@
+"""Zeroconf/mDNS service discovery for Home Assistant."""
+
+import asyncio
+import logging
+import socket
+from typing import Optional
+
+from zeroconf import IPVersion, ServiceInfo, Zeroconf
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class HomeAssistantZeroconf:
+    """Zeroconf service discovery for Home Assistant."""
+
+    def __init__(self, port: int, name: str):
+        """Initialize zeroconf discovery."""
+        self.port = port
+        self.name = name
+        self._zeroconf: Optional[Zeroconf] = None
+        self._service_info: Optional[ServiceInfo] = None
+
+    async def register_server(self) -> None:
+        """Register the server with zeroconf."""
+        try:
+            self._zeroconf = Zeroconf(ip_version=IPVersion.V4Only)
+
+            # Get local IP address
+            hostname = socket.gethostname()
+            local_ip = socket.gethostbyname(hostname)
+
+            # Create service info
+            service_type = "_esphomelib._tcp.local."
+            service_name = f"{self.name}._esphomelib._tcp.local."
+
+            self._service_info = ServiceInfo(
+                service_type,
+                name=service_name,
+                addresses=[socket.inet_aton(local_ip)],
+                port=self.port,
+                properties={
+                    "version": "1.0",
+                    "platform": "ReachyMini",
+                },
+                server=f"{hostname}.local.",
+            )
+
+            await asyncio.get_event_loop().run_in_executor(
+                None, self._zeroconf.register_service, self._service_info
+            )
+
+            _LOGGER.info(
+                "Registered zeroconf service: %s at %s:%s",
+                service_name,
+                local_ip,
+                self.port,
+            )
+        except Exception as e:
+            _LOGGER.error("Failed to register zeroconf service: %s", e)
+
+    async def unregister_server(self) -> None:
+        """Unregister the server from zeroconf."""
+        if self._zeroconf and self._service_info:
+            await asyncio.get_event_loop().run_in_executor(
+                None, self._zeroconf.unregister_service, self._service_info
+            )
+            self._zeroconf.close()
+            _LOGGER.info("Unregistered zeroconf service")

temp_conversation_app

@@ -0,0 +1 @@
+Subproject commit fc5123651cf50582d2b073b1779b37c26232e5cc

temp_reachy_mini

@@ -0,0 +1 @@
+Subproject commit 18823bf22e5fc31420f3bfe3c2483ef135a32391

temp_reachy_mini_examples

@@ -0,0 +1 @@
+Subproject commit 18823bf22e5fc31420f3bfe3c2483ef135a32391

test_official_app

@@ -0,0 +1 @@
+Subproject commit fc5123651cf50582d2b073b1779b37c26232e5cc