xiaozhi-sdk 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

xiaozhi_sdk/__init__.py

@@ -1,222 +1,3 @@
-__version__ = "0.0.4"
+__version__ = "0.0.6"
 
-import asyncio
-import json
-import logging
-import os
-import re
-import uuid
-from collections import deque
-from typing import Any, Callable, Dict, Optional
-
-import websockets
-
-from xiaozhi_sdk.config import INPUT_SERVER_AUDIO_SAMPLE_RATE
-from xiaozhi_sdk.iot import OtaDevice
-from xiaozhi_sdk.mcp import McpTool
-from xiaozhi_sdk.utils import get_wav_info, read_audio_file, setup_opus
-
-setup_opus()
-from xiaozhi_sdk.opus import AudioOpus
-
-logger = logging.getLogger("xiaozhi_sdk")
-
-
-class XiaoZhiWebsocket(McpTool):
-
-    def __init__(
-        self,
-        message_handler_callback: Optional[Callable] = None,
-        url: Optional[str] = None,
-        ota_url: Optional[str] = None,
-        audio_sample_rate: int = 16000,
-        audio_channels: int = 1,
-    ):
-        super().__init__()
-        self.url = url
-        self.ota_url = ota_url
-        self.audio_channels = audio_channels
-        self.audio_opus = AudioOpus(audio_sample_rate, audio_channels)
-
-        # 客户端标识
-        self.client_id = str(uuid.uuid4())
-        self.mac_addr: Optional[str] = None
-
-        # 回调函数
-        self.message_handler_callback = message_handler_callback
-
-        # 连接状态
-        self.hello_received = asyncio.Event()
-        self.session_id = ""
-        self.websocket = None
-        self.message_handler_task: Optional[asyncio.Task] = None
-
-        # 输出音频
-        self.output_audio_queue: deque[bytes] = deque()
-
-        # OTA设备
-        self.ota: Optional[OtaDevice] = None
-
-    async def _send_hello(self, aec: bool) -> None:
-        """发送hello消息"""
-        hello_message = {
-            "type": "hello",
-            "version": 1,
-            "features": {"aec": aec, "mcp": True},
-            "transport": "websocket",
-            "audio_params": {
-                "format": "opus",
-                "sample_rate": INPUT_SERVER_AUDIO_SAMPLE_RATE,
-                "channels": 1,
-                "frame_duration": 60,
-            },
-        }
-        await self.websocket.send(json.dumps(hello_message))
-        await asyncio.wait_for(self.hello_received.wait(), timeout=10.0)
-
-    async def _start_listen(self) -> None:
-        """开始监听"""
-
-        listen_message = {"session_id": self.session_id, "type": "listen", "state": "start", "mode": "realtime"}
-        await self.websocket.send(json.dumps(listen_message))
-
-    async def _activate_iot_device(self, license_key: str, ota_info: Dict[str, Any]) -> None:
-        """激活IoT设备"""
-        if not ota_info.get("activation"):
-            return
-
-        if not self.ota:
-            return
-
-        await self._send_demo_audio()
-        challenge = ota_info["activation"]["challenge"]
-        await asyncio.sleep(3)
-
-        for _ in range(10):
-            if await self.ota.check_activate(challenge, license_key):
-                break
-            await asyncio.sleep(3)
-
-    async def _send_demo_audio(self) -> None:
-        """发送演示音频"""
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        wav_path = os.path.join(current_dir, "../file/audio/greet.wav")
-        framerate, channels = get_wav_info(wav_path)
-        audio_opus = AudioOpus(framerate, channels)
-
-        for pcm_data in read_audio_file(wav_path):
-            opus_data = await audio_opus.pcm_to_opus(pcm_data)
-            await self.websocket.send(opus_data)
-        await self.send_silence_audio()
-
-    async def send_silence_audio(self, duration_seconds: float = 1.2) -> None:
-        """发送静音音频"""
-        frames_count = int(duration_seconds * 1000 / 60)
-        pcm_frame = b"\x00\x00" * int(INPUT_SERVER_AUDIO_SAMPLE_RATE / 1000 * 60)
-
-        for _ in range(frames_count):
-            await self.send_audio(pcm_frame)
-
-    async def _handle_websocket_message(self, message: Any) -> None:
-        """处理接受到的WebSocket消息"""
-
-        # audio data
-        if isinstance(message, bytes):
-            pcm_array = await self.audio_opus.opus_to_pcm(message)
-            self.output_audio_queue.extend(pcm_array)
-            return
-
-        # json message
-        data = json.loads(message)
-        message_type = data["type"]
-        if message_type == "hello":
-            self.hello_received.set()
-            self.session_id = data["session_id"]
-        elif message_type == "mcp":
-            await self.mcp(data)
-        elif self.message_handler_callback:
-            await self.message_handler_callback(data)
-
-    async def _message_handler(self) -> None:
-        """消息处理器"""
-        try:
-            async for message in self.websocket:
-                await self._handle_websocket_message(message)
-        except websockets.ConnectionClosed:
-            if self.message_handler_callback:
-                await self.message_handler_callback(
-                    {"type": "websocket", "state": "close", "source": "sdk.message_handler"}
-                )
-                logger.info("[websocket] close")
-
-    async def set_mcp_tool_callback(self, tool_func: Dict[str, Callable[..., Any]]) -> None:
-        """设置MCP工具回调函数"""
-        self.tool_func = tool_func
-
-    async def init_connection(
-        self, mac_addr: str, aec: bool = False, serial_number: str = "", license_key: str = ""
-    ) -> None:
-        """初始化连接"""
-        # 校验MAC地址格式 XX:XX:XX:XX:XX:XX
-        mac_pattern = r"^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$"
-        if not re.match(mac_pattern, mac_addr):
-            raise ValueError(f"无效的MAC地址格式: {mac_addr}。正确格式应为 XX:XX:XX:XX:XX:XX")
-
-        self.mac_addr = mac_addr.lower()
-
-        self.ota = OtaDevice(self.mac_addr, self.client_id, self.ota_url, serial_number)
-        ota_info = await self.ota.activate_device()
-        ws_url = ota_info["websocket"]["url"]
-        self.url = self.url or ws_url
-
-        if "tenclass.net" not in self.url and "xiaozhi.me" not in self.url:
-            logger.warning("[websocket] 检测到非官方服务器，请谨慎使用！当前链接地址: %s", self.url)
-
-        headers = {
-            "Authorization": "Bearer {}".format(ota_info["websocket"]["token"]),
-            "Protocol-Version": "1",
-            "Device-Id": self.mac_addr,
-            "Client-Id": self.client_id,
-        }
-        try:
-            self.websocket = await websockets.connect(uri=self.url, additional_headers=headers)
-        except websockets.exceptions.InvalidMessage as e:
-            logger.error("[websocket] 连接失败，请检查网络连接或设备状态。当前链接地址: %s, 错误信息：%s", self.url, e)
-            return
-        self.message_handler_task = asyncio.create_task(self._message_handler())
-
-        await self._send_hello(aec)
-        await self._start_listen()
-        asyncio.create_task(self._activate_iot_device(license_key, ota_info))
-        await asyncio.sleep(0.5)
-
-    async def send_audio(self, pcm: bytes) -> None:
-        """发送音频数据"""
-        if not self.websocket:
-            return
-
-        state = self.websocket.state
-        if state == websockets.protocol.State.OPEN:
-            opus_data = await self.audio_opus.pcm_to_opus(pcm)
-            await self.websocket.send(opus_data)
-        elif state in [websockets.protocol.State.CLOSED, websockets.protocol.State.CLOSING]:
-            if self.message_handler_callback:
-                await self.message_handler_callback({"type": "websocket", "state": "close", "source": "sdk.send_audio"})
-                self.websocket = None
-                logger.info("[websocket] close")
-
-            await asyncio.sleep(0.5)
-        else:
-            await asyncio.sleep(0.1)
-
-    async def close(self) -> None:
-        """关闭连接"""
-        if self.message_handler_task and not self.message_handler_task.done():
-            self.message_handler_task.cancel()
-            try:
-                await self.message_handler_task
-            except asyncio.CancelledError:
-                pass
-
-        if self.websocket:
-            await self.websocket.close()
+from xiaozhi_sdk.core import XiaoZhiWebsocket  # noqa

xiaozhi_sdk/__main__.py

@@ -1,123 +1,11 @@
-import argparse
-import asyncio
 import logging
-import time
-from collections import deque
-from typing import Optional
 
-import numpy as np
-import sounddevice as sd
+from xiaozhi_sdk.cli import main
 
-from xiaozhi_sdk import XiaoZhiWebsocket
-from xiaozhi_sdk.config import INPUT_SERVER_AUDIO_SAMPLE_RATE
-
-# 配置logging
-logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
-)
 logger = logging.getLogger("xiaozhi_sdk")
 
-# 全局状态
-input_audio_buffer: deque[bytes] = deque()
-is_playing_audio = False
-is_end = False
-
-
-async def handle_message(message):
-    """处理接收到的消息"""
-    global is_end
-    logger.info("message received: %s", message)
-    if message["type"] == "websocket" and message["state"] == "close":
-        is_end = True
-
-
-async def play_assistant_audio(audio_queue: deque[bytes]):
-    """播放音频流"""
-    global is_playing_audio
-
-    stream = sd.OutputStream(samplerate=INPUT_SERVER_AUDIO_SAMPLE_RATE, channels=1, dtype=np.int16)
-    stream.start()
-    last_audio_time = None
-
-    while True:
-        if is_end:
-            return
-
-        if not audio_queue:
-            await asyncio.sleep(0.01)
-            if last_audio_time and time.time() - last_audio_time > 1:
-                is_playing_audio = False
-            continue
-
-        is_playing_audio = True
-        pcm_data = audio_queue.popleft()
-        stream.write(pcm_data)
-        last_audio_time = time.time()
-
-
-class XiaoZhiClient:
-    """小智客户端类"""
-
-    def __init__(
-        self,
-        url: Optional[str] = None,
-        ota_url: Optional[str] = None,
-    ):
-        self.xiaozhi: Optional[XiaoZhiWebsocket] = None
-        self.url = url
-        self.ota_url = ota_url
-
-    async def start(self, mac_address: str, serial_number: str = "", license_key: str = ""):
-        """启动客户端连接"""
-        self.mac_address = mac_address
-        self.xiaozhi = XiaoZhiWebsocket(handle_message, url=self.url, ota_url=self.ota_url)
-        await self.xiaozhi.init_connection(
-            self.mac_address, aec=False, serial_number=serial_number, license_key=license_key
-        )
-        asyncio.create_task(play_assistant_audio(self.xiaozhi.output_audio_queue))
-
-    def audio_callback(self, indata, frames, time, status):
-        """音频输入回调函数"""
-        pcm_data = (indata.flatten() * 32767).astype(np.int16).tobytes()
-        input_audio_buffer.append(pcm_data)
-
-    async def process_audio_input(self):
-        """处理音频输入"""
-        while True:
-
-            if is_end:
-                return
-
-            if not input_audio_buffer:
-                await asyncio.sleep(0.02)
-                continue
-
-            pcm_data = input_audio_buffer.popleft()
-            if not is_playing_audio:
-                await self.xiaozhi.send_audio(pcm_data)
-
-
-async def main():
-    """主函数"""
-    parser = argparse.ArgumentParser(description="小智SDK客户端")
-    parser.add_argument("device", help="设备的MAC地址 (格式: XX:XX:XX:XX:XX:XX)")
-    parser.add_argument("--url", help="服务端websocket地址")
-    parser.add_argument("--ota_url", help="OTA地址")
-
-    parser.add_argument("--serial_number", default="", help="设备的序列号")
-    parser.add_argument("--license_key", default="", help="设备的授权密钥")
-
-    args = parser.parse_args()
-    logger.info("Recording... Press Ctrl+C to stop.")
-    client = XiaoZhiClient(args.url, args.ota_url)
-    await client.start(args.device, args.serial_number, args.license_key)
-
-    with sd.InputStream(callback=client.audio_callback, channels=1, samplerate=16000, blocksize=960):
-        await client.process_audio_input()
-
-
 if __name__ == "__main__":
     try:
-        asyncio.run(main())
+        main()
     except KeyboardInterrupt:
-        logger.info("Stopping...")
+        logger.debug("Stopping...")

xiaozhi_sdk/cli.py

@@ -0,0 +1,137 @@
+import asyncio
+import logging
+import time
+from collections import deque
+from typing import Optional
+
+import click
+import colorlog
+import numpy as np
+import sounddevice as sd
+
+from xiaozhi_sdk import XiaoZhiWebsocket
+from xiaozhi_sdk.config import INPUT_SERVER_AUDIO_SAMPLE_RATE
+
+# 配置彩色logging
+handler = colorlog.StreamHandler()
+handler.setFormatter(
+    colorlog.ColoredFormatter(
+        "%(log_color)s%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        log_colors={
+            "DEBUG": "green",
+            "INFO": "white",
+            "WARNING": "yellow",
+            "ERROR": "red",
+            "CRITICAL": "red,bg_white",
+        },
+    )
+)
+
+logger = logging.getLogger("xiaozhi_sdk")
+logger.addHandler(handler)
+logger.setLevel(logging.DEBUG)
+
+# 全局状态
+input_audio_buffer: deque[bytes] = deque()
+is_playing_audio = False
+is_end = False
+
+
+async def handle_message(message):
+    """处理接收到的消息"""
+    global is_end
+    logger.info("message received: %s", message)
+    if message["type"] == "websocket" and message["state"] == "close":
+        is_end = True
+
+
+async def play_assistant_audio(audio_queue: deque[bytes]):
+    """播放音频流"""
+    global is_playing_audio
+
+    stream = sd.OutputStream(samplerate=INPUT_SERVER_AUDIO_SAMPLE_RATE, channels=1, dtype=np.int16)
+    stream.start()
+    last_audio_time = None
+
+    while True:
+        if is_end:
+            return
+
+        if not audio_queue:
+            await asyncio.sleep(0.01)
+            if last_audio_time and time.time() - last_audio_time > 1:
+                is_playing_audio = False
+            continue
+
+        is_playing_audio = True
+        pcm_data = audio_queue.popleft()
+        stream.write(pcm_data)
+        last_audio_time = time.time()
+
+
+class XiaoZhiClient:
+    """小智客户端类"""
+
+    def __init__(
+        self,
+        url: Optional[str] = None,
+        ota_url: Optional[str] = None,
+    ):
+        self.xiaozhi: Optional[XiaoZhiWebsocket] = None
+        self.url = url
+        self.ota_url = ota_url
+        self.mac_address = ""
+
+    async def start(self, mac_address: str, serial_number: str = "", license_key: str = ""):
+        """启动客户端连接"""
+        self.mac_address = mac_address
+        self.xiaozhi = XiaoZhiWebsocket(handle_message, url=self.url, ota_url=self.ota_url, send_wake=True)
+        await self.xiaozhi.init_connection(
+            self.mac_address, aec=False, serial_number=serial_number, license_key=license_key
+        )
+        asyncio.create_task(play_assistant_audio(self.xiaozhi.output_audio_queue))
+
+    def audio_callback(self, indata, frames, time, status):
+        """音频输入回调函数"""
+        pcm_data = (indata.flatten() * 32767).astype(np.int16).tobytes()
+        input_audio_buffer.append(pcm_data)
+
+    async def process_audio_input(self):
+        """处理音频输入"""
+        while True:
+
+            if is_end:
+                return
+
+            if not input_audio_buffer:
+                await asyncio.sleep(0.02)
+                continue
+
+            pcm_data = input_audio_buffer.popleft()
+            if not is_playing_audio:
+                await self.xiaozhi.send_audio(pcm_data)
+
+
+async def run_client(mac_address: str, url: str, ota_url: str, serial_number: str, license_key: str):
+    """运行客户端的异步函数"""
+    logger.debug("Recording... Press Ctrl+C to stop.")
+    client = XiaoZhiClient(url, ota_url)
+    await client.start(mac_address, serial_number, license_key)
+
+    with sd.InputStream(callback=client.audio_callback, channels=1, samplerate=16000, blocksize=960):
+        await client.process_audio_input()
+
+
+@click.command()
+@click.argument("mac_address")
+@click.option("--url", help="服务端websocket地址")
+@click.option("--ota_url", help="OTA地址")
+@click.option("--serial_number", default="", help="设备的序列号")
+@click.option("--license_key", default="", help="设备的授权密钥")
+def main(mac_address: str, url: str, ota_url: str, serial_number: str, license_key: str):
+    """小智SDK客户端
+
+    MAC_ADDRESS: 设备的MAC地址 (格式: XX:XX:XX:XX:XX:XX)
+    """
+    asyncio.run(run_client(mac_address, url, ota_url, serial_number, license_key))

xiaozhi_sdk/config.py

@@ -1,3 +1,3 @@
 INPUT_SERVER_AUDIO_SAMPLE_RATE = 16000
 
-OTA_URL = "https://api.tenclass.net/xiaozhi/ota/"
+OTA_URL = "https://api.tenclass.net/xiaozhi/ota"

xiaozhi_sdk/core.py

@@ -0,0 +1,257 @@
+import asyncio
+import json
+import logging
+import os
+import re
+import uuid
+from collections import deque
+from typing import Any, Callable, Dict, Optional
+
+import websockets
+
+from xiaozhi_sdk.config import INPUT_SERVER_AUDIO_SAMPLE_RATE
+from xiaozhi_sdk.iot import OtaDevice
+from xiaozhi_sdk.mcp import McpTool
+from xiaozhi_sdk.utils import get_wav_info, read_audio_file, setup_opus
+
+setup_opus()
+from xiaozhi_sdk.opus import AudioOpus
+
+logger = logging.getLogger("xiaozhi_sdk")
+
+
+class XiaoZhiWebsocket(McpTool):
+
+    def __init__(
+        self,
+        message_handler_callback: Optional[Callable] = None,
+        url: Optional[str] = None,
+        ota_url: Optional[str] = None,
+        audio_sample_rate: int = 16000,
+        audio_channels: int = 1,
+        send_wake: bool = False,
+    ):
+        super().__init__()
+        self.url = url
+        self.ota_url = ota_url
+        self.send_wake = send_wake
+        self.audio_channels = audio_channels
+        self.audio_opus = AudioOpus(audio_sample_rate, audio_channels)
+
+        # 客户端标识
+        self.client_id = str(uuid.uuid4())
+        self.mac_addr: Optional[str] = None
+        self.aec = False
+        self.websocket_token = ""
+
+        # 回调函数
+        self.message_handler_callback = message_handler_callback
+
+        # 连接状态
+        self.hello_received = asyncio.Event()
+        self.session_id = ""
+        self.websocket = None
+        self.message_handler_task: Optional[asyncio.Task] = None
+
+        # 输出音频
+        self.output_audio_queue: deque[bytes] = deque()
+
+        # OTA设备
+        self.ota: Optional[OtaDevice] = None
+        self.iot_task: Optional[asyncio.Task] = None
+        self.wait_device_activated: bool = False
+
+    async def _send_hello(self, aec: bool) -> None:
+        """发送hello消息"""
+        hello_message = {
+            "type": "hello",
+            "version": 1,
+            "features": {"mcp": True, "aec": aec},
+            "transport": "websocket",
+            "audio_params": {
+                "format": "opus",
+                "sample_rate": 16000,
+                "channels": 1,
+                "frame_duration": 60,
+            },
+        }
+        await self.websocket.send(json.dumps(hello_message))
+        await asyncio.wait_for(self.hello_received.wait(), timeout=10.0)
+
+    async def _start_listen(self) -> None:
+        """开始监听"""
+        listen_message = {"session_id": self.session_id, "type": "listen", "state": "start", "mode": "realtime"}
+        await self.websocket.send(json.dumps(listen_message))
+
+    async def is_activate(self, ota_info):
+        """是否激活"""
+        if ota_info.get("activation"):
+            return False
+
+        return True
+
+    async def _activate_iot_device(self, license_key: str, ota_info: Dict[str, Any]) -> None:
+        """激活IoT设备"""
+        if not self.ota:
+            return
+
+        challenge = ota_info["activation"]["challenge"]
+        await asyncio.sleep(3)
+        self.wait_device_activated = True
+        for _ in range(10):
+            if await self.ota.check_activate(challenge, license_key):
+                self.wait_device_activated = False
+                break
+            await asyncio.sleep(3)
+
+    async def _send_demo_audio(self) -> None:
+        """发送演示音频"""
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        wav_path = os.path.join(current_dir, "../file/audio/greet.wav")
+        framerate, channels = get_wav_info(wav_path)
+        audio_opus = AudioOpus(framerate, channels)
+
+        for pcm_data in read_audio_file(wav_path):
+            opus_data = await audio_opus.pcm_to_opus(pcm_data)
+            await self.websocket.send(opus_data)
+        await self.send_silence_audio()
+
+    async def send_wake_word(self, wake_word: str = "你好，小智") -> None:
+        """发送唤醒词"""
+        await self.websocket.send(
+            json.dumps({"session_id": self.session_id, "type": "listen", "state": "detect", "text": wake_word})
+        )
+
+    async def send_silence_audio(self, duration_seconds: float = 1.2) -> None:
+        """发送静音音频"""
+        frames_count = int(duration_seconds * 1000 / 60)
+        pcm_frame = b"\x00\x00" * int(INPUT_SERVER_AUDIO_SAMPLE_RATE / 1000 * 60)
+
+        for _ in range(frames_count):
+            await self.send_audio(pcm_frame)
+
+    async def _handle_websocket_message(self, message: Any) -> None:
+        """处理接受到的WebSocket消息"""
+
+        # audio data
+        if isinstance(message, bytes):
+            pcm_array = await self.audio_opus.opus_to_pcm(message)
+            self.output_audio_queue.extend(pcm_array)
+            return
+
+        # json message
+        data = json.loads(message)
+        message_type = data["type"]
+        if message_type == "hello":
+            self.hello_received.set()
+            self.session_id = data["session_id"]
+        elif message_type == "mcp":
+            await self.mcp(data)
+        elif self.message_handler_callback:
+            await self.message_handler_callback(data)
+
+    async def _message_handler(self) -> None:
+        """消息处理器"""
+        try:
+            async for message in self.websocket:
+                await self._handle_websocket_message(message)
+        except websockets.ConnectionClosed:
+            if self.message_handler_callback:
+                await self.message_handler_callback(
+                    {"type": "websocket", "state": "close", "source": "sdk.message_handler"}
+                )
+                logger.debug("[websocket] close")
+
+    async def set_mcp_tool_callback(self, tool_func: Dict[str, Callable[..., Any]]) -> None:
+        """设置MCP工具回调函数"""
+        self.tool_func = tool_func
+
+    async def connect_websocket(self, websocket_token):
+        """连接websocket"""
+        headers = {
+            "Authorization": "Bearer {}".format(websocket_token),
+            "Protocol-Version": "1",
+            "Device-Id": self.mac_addr,
+            "Client-Id": self.client_id,
+        }
+        try:
+            self.websocket = await websockets.connect(uri=self.url, additional_headers=headers)
+        except websockets.exceptions.InvalidMessage as e:
+            logger.error("[websocket] 连接失败，请检查网络连接或设备状态。当前链接地址: %s, 错误信息：%s", self.url, e)
+            return
+        self.message_handler_task = asyncio.create_task(self._message_handler())
+
+        await self._send_hello(self.aec)
+        await self._start_listen()
+        logger.debug("[websocket] Connection successful")
+        await asyncio.sleep(0.5)
+
+    async def init_connection(
+        self, mac_addr: str, aec: bool = False, serial_number: str = "", license_key: str = ""
+    ) -> None:
+        """初始化连接"""
+        mac_pattern = r"^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$"
+        if not re.match(mac_pattern, mac_addr):
+            raise ValueError(f"无效的MAC地址格式: {mac_addr}。正确格式应为 XX:XX:XX:XX:XX:XX")
+
+        self.mac_addr = mac_addr.lower()
+        self.aec = aec
+
+        self.ota = OtaDevice(self.mac_addr, self.client_id, self.ota_url, serial_number)
+        ota_info = await self.ota.activate_device()
+        ws_url = ota_info.get("websocket", {}).get("url")
+        self.url = self.url or ws_url
+
+        if not self.url:
+            logger.warning("[websocket] 未找到websocket链接地址")
+            return
+
+        if "tenclass.net" not in self.url and "xiaozhi.me" not in self.url:
+            logger.warning("[websocket] 检测到非官方服务器，当前链接地址: %s", self.url)
+
+        self.websocket_token = ota_info["websocket"]["token"]
+        await self.connect_websocket(self.websocket_token)
+
+        if not await self.is_activate(ota_info):
+            self.iot_task = asyncio.create_task(self._activate_iot_device(license_key, ota_info))
+            logger.debug("[IOT] 设备未激活")
+
+        if self.send_wake:
+            await self.send_wake_word()
+
+    async def send_audio(self, pcm: bytes) -> None:
+        """发送音频数据"""
+        if not self.websocket:
+            return
+
+        state = self.websocket.state
+        if state == websockets.protocol.State.OPEN:
+            opus_data = await self.audio_opus.pcm_to_opus(pcm)
+            await self.websocket.send(opus_data)
+        elif state in [websockets.protocol.State.CLOSED, websockets.protocol.State.CLOSING]:
+            if self.wait_device_activated:
+                logger.debug("[websocket] Server actively disconnected, reconnecting...")
+                await self.connect_websocket(self.websocket_token)
+            elif self.message_handler_callback:
+                await self.message_handler_callback({"type": "websocket", "state": "close", "source": "sdk.send_audio"})
+                self.websocket = None
+                logger.debug("[websocket] Server actively disconnected")
+
+            await asyncio.sleep(0.5)
+        else:
+            await asyncio.sleep(0.1)
+
+    async def close(self) -> None:
+        """关闭连接"""
+        if self.message_handler_task and not self.message_handler_task.done():
+            self.message_handler_task.cancel()
+            try:
+                await self.message_handler_task
+            except asyncio.CancelledError:
+                pass
+
+        if self.iot_task:
+            self.iot_task.cancel()
+
+        if self.websocket:
+            await self.websocket.close()

xiaozhi_sdk/iot.py

@@ -1,6 +1,7 @@
 import hashlib
 import hmac
 import json
+import logging
 from typing import Any, Dict, Optional
 
 import aiohttp
@@ -13,6 +14,8 @@ BOARD_TYPE = "xiaozhi-sdk-box"
 USER_AGENT = "xiaozhi-sdk/{}".format(__version__)
 BOARD_NAME = "xiaozhi-sdk-{}".format(__version__)
 
+logger = logging.getLogger("xiaozhi_sdk")
+
 
 class OtaDevice:
     """
@@ -56,7 +59,7 @@ class OtaDevice:
         }
 
         async with aiohttp.ClientSession() as session:
-            async with session.post(self.ota_url, headers=headers, data=json.dumps(payload)) as response:
+            async with session.post(self.ota_url + "/", headers=headers, data=json.dumps(payload)) as response:
                 response.raise_for_status()
                 return await response.json()
 
@@ -72,4 +75,7 @@ class OtaDevice:
 
         async with aiohttp.ClientSession() as session:
             async with session.post(url, headers=headers, data=json.dumps(payload)) as response:
-                return response.status == 200
+                is_ok = response.status == 200
+                if not is_ok:
+                    logger.debug("[IOT] wait for activate device...")
+                return is_ok

xiaozhi_sdk/mcp.py

@@ -87,7 +87,7 @@ class McpTool(object):
                     mcp_tool_conf[name]["name"] = name
                     mcp_tools_payload["result"]["tools"].append(mcp_tool_conf[name])
             await self.websocket.send(self.get_mcp_json(mcp_tools_payload))
-            logger.info("[MCP] 加载成功，当前可用工具列表为：%s", tool_list)
+            logger.debug("[MCP] 加载成功，当前可用工具列表为：%s", tool_list)
 
         elif method == "tools/call":
             tool_name = payload["params"]["name"]
@@ -97,6 +97,6 @@ class McpTool(object):
 
             mcp_res = await self.mcp_tool_call(payload)
             await self.websocket.send(mcp_res)
-            logger.info("[MCP] Tool %s called", tool_name)
+            logger.debug("[MCP] Tool %s called", tool_name)
         else:
             logger.warning("[MCP] unknown method %s: %s", method, payload)

xiaozhi_sdk/opus.py

@@ -2,7 +2,7 @@ import av
 import numpy as np
 import opuslib
 
-from xiaozhi_sdk import INPUT_SERVER_AUDIO_SAMPLE_RATE
+from xiaozhi_sdk.config import INPUT_SERVER_AUDIO_SAMPLE_RATE
 
 
 class AudioOpus:

{xiaozhi_sdk-0.0.4.dist-info → xiaozhi_sdk-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xiaozhi-sdk
-Version: 0.0.4
+Version: 0.0.6
 Summary: 一个用于连接和控制小智智能设备的Python SDK，支持实时音频通信、MCP工具集成和设备管理功能。
 Author-email: dairoot <623815825@qq.com>
 License: MIT
@@ -12,13 +12,15 @@ Requires-Python: >=3.8.1
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
-Requires-Dist: websockets
+Requires-Dist: websockets>=15.0.1
 Requires-Dist: aiohttp
 Requires-Dist: av
 Requires-Dist: opuslib
 Requires-Dist: requests
 Requires-Dist: sounddevice
 Requires-Dist: python-socks
+Requires-Dist: click
+Requires-Dist: colorlog
 Dynamic: license-file
 
 # 小智SDK (XiaoZhi SDK)
@@ -53,21 +55,7 @@ pip install xiaozhi-sdk
 #### 查看帮助信息
 
 ```bash
-python -m xiaozhi_sdk -h
-```
-
-输出示例：
-```text
-positional arguments:
-  device             你的小智设备的MAC地址 (格式: XX:XX:XX:XX:XX:XX)
-
-options:
-  -h, --help                    show this help message and exit
-  --url URL                     服务端websocket地址
-  --ota_url OTA_URL             OTA地址
-  --serial_number SERIAL_NUMBER 设备的序列号
-  --license_key LICENSE_KEY     设备的授权密钥
-
+python -m xiaozhi_sdk --help
 ```
 
 #### 连接设备（需要提供 MAC 地址）
@@ -76,11 +64,13 @@ options:
 python -m xiaozhi_sdk 00:22:44:66:88:00
 ```
 
-### 2. 编程使用
+### 2. 编程使用 (高阶用法)
 参考 [examples](examples/) 文件中的示例代码，可以快速开始使用 SDK。
 
 
-### 运行测试
+---
+
+## ✅ 运行测试
 
 ```bash
 pytest tests/

{xiaozhi_sdk-0.0.4.dist-info → xiaozhi_sdk-0.0.6.dist-info}/RECORD

@@ -7,16 +7,18 @@ file/opus/linux-x64-libopus.so,sha256=FmXJqkxLpDzNFOHYkmOzmsp1hP0eIS5b6x_XfOs-IQ
 file/opus/macos-arm64-libopus.dylib,sha256=H7wXwkrGwb-hesMMZGFxWb0Ri1Y4m5GWiKsd8CfOhE8,357584
 file/opus/macos-x64-libopus.dylib,sha256=MqyL_OjwSACF4Xs_-KrGbcScy4IEprr5Rlkk3ddZye8,550856
 file/opus/windows-x86_64-opus.dll,sha256=kLfhioMvbJhOgNMAldpWk3DCZqC5Xd70LRbHnACvAnw,463360
-xiaozhi_sdk/__init__.py,sha256=iNRkEIYK6f4kbbu3dz874LKOxtMitUa2GzHH2gRSD1w,8034
-xiaozhi_sdk/__main__.py,sha256=_Xh6v2oMYXYHsrAkw4PYMJpvi-0r3ujLNRLMxPNarTQ,3807
-xiaozhi_sdk/config.py,sha256=mpjWWklTI2bw4zY3ZWCYvqvpfZSoF5iM7ubAP9y_8cM,90
+xiaozhi_sdk/__init__.py,sha256=byRv-MwEkq9DRNCv9xwhLSqCfHjgMHDa2BizaN55CPo,77
+xiaozhi_sdk/__main__.py,sha256=i0ZJdHUqAKg9vwZrK_w0TJkzdotTYTK8aUeSPcJc1ks,210
+xiaozhi_sdk/cli.py,sha256=0Hq-wPUv5Hfjzn7pVcCNMe3cbKTwwJytDhXSYivFOt8,4239
+xiaozhi_sdk/config.py,sha256=h4mpMeBf2vT9qYAqCCbGVGmMemkgk98pcXP2Rh4TEFc,89
+xiaozhi_sdk/core.py,sha256=a_-JnLMQgT93O9GMytUNLLot8N3dZbNjan-tsC7GwrY,9447
 xiaozhi_sdk/data.py,sha256=8z8erOjBZFvPSBJlPoyTzRYZ3BuMvnPpAFQCbSxs-48,2522
-xiaozhi_sdk/iot.py,sha256=aIrHVZVVObu8VDC20JOc8yO4X7ORMW-R7RNxIEyl9ng,2386
-xiaozhi_sdk/mcp.py,sha256=JA-z6EjGqitEfwMlvxk6XUSjbmfAdyWJVZPjtjqo6Oo,3823
-xiaozhi_sdk/opus.py,sha256=4O-kz-PcUVmpa27Vju6jv-sbwywuAXFvVL23R1-vv5o,2104
+xiaozhi_sdk/iot.py,sha256=IO3SfiuQxucYl_917BCNCwIAv1dajCJI-IFTWwHnSDE,2580
+xiaozhi_sdk/mcp.py,sha256=Q_htzBMunj3-9wARONeCFPTbApQicHWRbG6BlX4oQss,3825
+xiaozhi_sdk/opus.py,sha256=BX5BZATjWSUGbh1z-GjZhIKmZezHPADFYcIpoIsTtRQ,2111
 xiaozhi_sdk/utils.py,sha256=5qHAiI5Nrzeka3TofMPhAVmMovEJJa6QSrKcDM0OF4g,1703
-xiaozhi_sdk-0.0.4.dist-info/licenses/LICENSE,sha256=Vwgps1iODKl43cAtME_0dawTjAzNW-O2BWiN5BHggww,1085
-xiaozhi_sdk-0.0.4.dist-info/METADATA,sha256=WdiQkFfDXnlRiFHZT3Z7lq9d4t94J1imAH6ai_OIuhs,2344
-xiaozhi_sdk-0.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xiaozhi_sdk-0.0.4.dist-info/top_level.txt,sha256=nBpue4hU5Ykm5CtYPsAdxSa_yqbtZsIT_gF_EkBaJPM,12
-xiaozhi_sdk-0.0.4.dist-info/RECORD,,
+xiaozhi_sdk-0.0.6.dist-info/licenses/LICENSE,sha256=Vwgps1iODKl43cAtME_0dawTjAzNW-O2BWiN5BHggww,1085
+xiaozhi_sdk-0.0.6.dist-info/METADATA,sha256=0Mum7x2Ul3YhOeMqk85Rn6SySUVdf2TDfTsyRoQphTM,2014
+xiaozhi_sdk-0.0.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xiaozhi_sdk-0.0.6.dist-info/top_level.txt,sha256=nBpue4hU5Ykm5CtYPsAdxSa_yqbtZsIT_gF_EkBaJPM,12
+xiaozhi_sdk-0.0.6.dist-info/RECORD,,