Merge pull request #1504 from xinnan-tech/fix-mcp-name

Fix mcp name
update:替换描述里涉及到的原始方法名称
2026-07-23 15:43:54 +08:00 · 2025-06-07 16:00:49 +08:00 · 2025-06-08 15:51:57 +08:00 · 2025-06-07 14:40:08 +08:00 · 2025-06-07 13:48:10 +08:00 · 2025-06-07 13:46:35 +08:00
38 changed files with 1757 additions and 239 deletions
@@ -170,8 +170,8 @@
 #### 🚀 部署方式选择
 | 部署方式 | 特点 | 适用场景 | 部署文档 | 配置要求 | 视频教程 | 
 |---------|------|---------|---------|---------|---------|
-| **最简化安装** | 智能对话、IOT功能，数据存储在配置文件 | 低配置环境，无需数据库 | [①Docker版](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) / [②源码部署](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E5%8F%AA%E8%BF%90%E8%A1%8Cserver)| 如果使用`FunASR`要2核4G，如果全API，要2核2G | - | 
-| **全模块安装** | 智能对话、IOT、OTA、智控台，数据存储在数据库 | 完整功能体验 |[①Docker版](./docs/Deployment_all.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E8%BF%90%E8%A1%8C%E5%85%A8%E6%A8%A1%E5%9D%97) / [②源码部署](./docs/Deployment_all.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E8%BF%90%E8%A1%8C%E5%85%A8%E6%A8%A1%E5%9D%97) / [③源码部署自动更新教程](./docs/dev-ops-integration.md) | 如果使用`FunASR`要4核8G，如果全API，要2核4G| [本地源码启动视频教程](https://www.bilibili.com/video/BV1wBJhz4Ewe) | 
+| **最简化安装** | 智能对话、IOT、MCP、视觉感知，数据存储在配置文件 | 低配置环境，无需数据库 | [①Docker版](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) / [②源码部署](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E5%8F%AA%E8%BF%90%E8%A1%8Cserver)| 如果使用`FunASR`要2核4G，如果全API，要2核2G | - | 
+| **全模块安装** | 智能对话、IOT、MCP、视觉感知、OTA、智控台，数据存储在数据库 | 完整功能体验 |[①Docker版](./docs/Deployment_all.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E8%BF%90%E8%A1%8C%E5%85%A8%E6%A8%A1%E5%9D%97) / [②源码部署](./docs/Deployment_all.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E8%BF%90%E8%A1%8C%E5%85%A8%E6%A8%A1%E5%9D%97) / [③源码部署自动更新教程](./docs/dev-ops-integration.md) | 如果使用`FunASR`要4核8G，如果全API，要2核4G| [本地源码启动视频教程](https://www.bilibili.com/video/BV1wBJhz4Ewe) | 


 > 💡 提示：以下是按最新代码部署后的测试平台，有需要可烧录测试，并发为6个，每天会清空数据
@@ -195,7 +195,7 @@ Websocket接口地址: wss://2662r3426b.vicp.fun/xiaozhi/v1/
 | ASR(语音识别) | FunASR(本地) | 👍DoubaoStreamASR(火山流式语音识别) |
 | LLM(大模型) | ChatGLMLLM(智谱glm-4-flash) | 👍DoubaoLLM(火山doubao-1-5-pro-32k-250115) |
 | VLLM(视觉大模型) | ChatGLMVLLM(智谱glm-4v-flash) | 👍QwenVLVLLM(千问qwen2.5-vl-3b-instructh) |
-| TTS(语音合成) | EdgeTTS(微软语音) | 👍HuoshanDoubleStreamTTS(火山双流式语音合成) |
+| TTS(语音合成) | 👍LinkeraiTTS(灵犀流式) | 👍HuoshanDoubleStreamTTS(火山双流式语音合成) |
 | Intent(意图识别) | function_call(函数调用) | ✅function_call(函数调用) |
 | Memory(记忆功能) | mem_local_short(本地短期记忆） | ✅mem_local_short（本地短期记忆） |

@@ -204,9 +204,9 @@ Websocket接口地址: wss://2662r3426b.vicp.fun/xiaozhi/v1/

 | 工具名称 | 位置 | 使用方法 | 功能说明 |
 |:---:|:---|:---:|:---:|
-| 音频交互测试工具 | 位于`main/xiaozhi-server/test/test_page.html` | 使用谷歌浏览器直接打开 | 测试音频播放和接收功能，验证Python端音频处理是否正常 |
-| 模型响应测试工具1 | 位于`main/xiaozhi-server/performance_tester.py` | 执行 `python performance_tester.py` | 测试ASR(语音识别)、LLM(大模型)、TTS(语音合成)三个核心模块的响应速度 |
-| 模型响应测试工具2 | 位于`main/xiaozhi-server/performance_tester_vllm.py` | 执行 `python performance_tester_vllm.py` | 测试VLLM(视觉模型)的响应速度 |
+| 音频交互测试工具 | main》xiaozhi-server》test》test_page.html | 使用谷歌浏览器直接打开 | 测试音频播放和接收功能，验证Python端音频处理是否正常 |
+| 模型响应测试工具1 | main》xiaozhi-server》performance_tester.py | 执行 `python performance_tester.py` | 测试ASR(语音识别)、LLM(大模型)、TTS(语音合成)三个核心模块的响应速度 |
+| 模型响应测试工具2 | main》xiaozhi-server》performance_tester_vllm.py | 执行 `python performance_tester_vllm.py` | 测试VLLM(视觉模型)的响应速度 |

 > 💡 提示：测试模型速度时，只会测试配置了密钥的模型。

@@ -277,7 +277,7 @@ Websocket接口地址: wss://2662r3426b.vicp.fun/xiaozhi/v1/

 | 使用方式 | 支持平台 | 免费平台 |
 |:---:|:---:|:---:|
-| 接口调用 | EdgeTTS、火山引擎豆包TTS、腾讯云、阿里云TTS、CosyVoiceSiliconflow、TTS302AI、CozeCnTTS、GizwitsTTS、ACGNTTS、OpenAITTS | EdgeTTS、CosyVoiceSiliconflow(部分) |
+| 接口调用 | EdgeTTS、火山引擎豆包TTS、腾讯云、阿里云TTS、CosyVoiceSiliconflow、TTS302AI、CozeCnTTS、GizwitsTTS、ACGNTTS、OpenAITTS、灵犀流式TTS | 灵犀流式TTS、EdgeTTS、CosyVoiceSiliconflow(部分) |
 | 本地服务 | FishSpeech、GPT_SOVITS_V2、GPT_SOVITS_V3、MinimaxTTS | FishSpeech、GPT_SOVITS_V2、GPT_SOVITS_V3、MinimaxTTS |

 ---
@@ -0,0 +1,236 @@
+# Technical Documentation: xiaozhi-esp32-server
+
+**Table of Contents:**
+
+1.  [Introduction](#1-introduction)
+2.  [Overall Architecture](#2-overall-architecture)
+3.  [Component Deep Dive](#3-component-deep-dive)
+    *   [xiaozhi-server (Python AI Engine)](#31-xiaozhi-server-python-ai-engine)
+    *   [manager-api (Java Management Backend)](#32-manager-api-java-management-backend)
+    *   [manager-web (Vue.js Management Frontend)](#33-manager-web-vuejs-management-frontend)
+4.  [Data Flow and Interaction Mechanisms](#4-data-flow-and-interaction-mechanisms)
+5.  [Key Features Summary](#5-key-features-summary)
+6.  [Deployment and Configuration Overview](#6-deployment-and-configuration-overview)
+
+---
+
+## 1. Introduction
+
+The `xiaozhi-esp32-server` project provides a comprehensive backend system designed to power intelligent voice interactions for ESP32-based smart hardware. Its primary purpose is to enable developers to quickly establish a robust server infrastructure capable of understanding natural language commands, interacting with various AI services (for speech recognition, language understanding, and speech synthesis), managing IoT devices, and offering a web-based interface for system configuration and administration. This project facilitates the creation of customizable voice assistants and smart control systems by integrating multiple cutting-edge technologies into a cohesive and extensible platform.
+
+---
+
+## 2. Overall Architecture
+
+The `xiaozhi-esp32-server` system is architected as a distributed suite of interconnected components, each with a distinct role, ensuring modularity and scalability. The primary components are:
+
+1.  **ESP32 Hardware (Client Device):** This is the physical smart hardware device that the end-user interacts with. It's responsible for:
+    *   Capturing user's voice commands.
+    *   Sending captured audio to the `xiaozhi-server`.
+    *   Receiving synthesized audio responses from `xiaozhi-server` and playing them back.
+    *   Potentially controlling other connected peripherals or IoT devices based on commands from `xiaozhi-server`.
+
+2.  **`xiaozhi-server` (Core AI Engine):** This Python-based server is the central brain for voice processing and interaction logic. Its key responsibilities include:
+    *   Establishing real-time, bidirectional WebSocket communication with ESP32 devices.
+    *   Receiving audio streams and performing Voice Activity Detection (VAD).
+    *   Converting speech to text using integrated Automatic Speech Recognition (ASR) services.
+    *   Interpreting user intent and generating responses by interacting with Large Language Models (LLMs).
+    *   Managing dialogue context and memory.
+    *   Converting text responses back to speech using Text-to-Speech (TTS) services.
+    *   Executing commands, including IoT device control via a plugin system.
+    *   Fetching its operational configuration from the `manager-api`.
+
+3.  **`manager-api` (Management Backend):** A Java Spring Boot application that provides a RESTful API for system administration and configuration. It serves as the backend for the `manager-web` frontend and a configuration source for `xiaozhi-server`. Its functions include:
+    *   User authentication and management for the control panel.
+    *   Registration and management of ESP32 devices.
+    *   Storage and retrieval of system configurations (e.g., selected AI service providers, API keys, device settings) in a MySQL database.
+    *   Providing endpoints for `xiaozhi-server` to fetch its configuration.
+    *   Managing voice timbre settings, OTA firmware updates, and other system parameters.
+    *   Utilizing Redis for caching to enhance performance.
+
+4.  **`manager-web` (Web Control Panel):** A Vue.js Single Page Application (SPA) that provides a graphical user interface for administrators. It allows for:
+    *   Easy configuration of `xiaozhi-server`'s AI services and operational parameters.
+    *   Management of users, devices, and their respective settings.
+    *   Monitoring system status (potentially) and managing other administrative tasks.
+    *   Interaction with all backend functionalities exposed by `manager-api`.
+
+**High-Level Interaction Flow:**
+
+*   The **ESP32** device captures voice and communicates primarily with **`xiaozhi-server`** via WebSockets for all voice-related interactions.
+*   **`xiaozhi-server`** processes the voice data, interacts with various AI cloud services or local models, and sends responses back to the ESP32.
+*   The **`manager-web`** frontend communicates with **`manager-api`** using RESTful HTTP calls to manage and configure the entire system.
+*   **`xiaozhi-server`** also communicates with **`manager-api`** (via REST) to pull its latest configuration, ensuring that changes made in the web panel are reflected in its operation.
+
+This separation of concerns allows the `xiaozhi-server` to focus on efficient real-time AI processing, while the `manager-api` and `manager-web` provide a robust and user-friendly interface for administration and setup.
+
+---
+
+## 3. Component Deep Dive
+
+### 3.1. `xiaozhi-server` (Python AI Engine)
+
+The `xiaozhi-server` is the intelligent core of the system, responsible for processing voice interactions, interfacing with AI services, and managing communication with ESP32 devices.
+
+*   **Purpose:**
+    *   To provide real-time processing of voice commands from ESP32 devices.
+    *   To integrate with various AI services for Speech-to-Text (ASR), Natural Language Understanding (via Large Language Models - LLMs), Text-to-Speech (TTS), Voice Activity Detection (VAD), Intent Recognition, and Memory.
+    *   To manage dialogue flow and context with users.
+    *   To execute custom functions and control IoT devices based on user commands.
+    *   To be dynamically configurable through the `manager-api`.
+
+*   **Core Technologies:**
+    *   **Python 3:** The primary programming language.
+    *   **Asyncio:** Python's asynchronous programming framework, crucial for handling concurrent WebSocket connections and non-blocking I/O for AI service API calls.
+    *   **`websockets` Library:** For WebSocket server implementation.
+    *   **HTTP Client (e.g., `aiohttp`, `httpx`):** For asynchronous HTTP requests to `manager-api` and external AI services.
+    *   **YAML (PyYAML):** For local configuration file parsing.
+
+*   **Key Implementation Aspects:**
+
+    1.  **AI Service Provider Pattern (`core/providers/`):**
+        *   **Concept:** A flexible design for integrating AI services. Each service type (ASR, TTS, LLM, etc.) has an abstract base class defining a common interface. Concrete classes implement this interface for specific vendors or local models.
+        *   **Benefit:** Allows easy switching of AI service backends via configuration and simplifies adding new service integrations.
+        *   **Initialization:** `core/utils/modules_initialize.py` acts as a factory to load and instantiate configured providers.
+
+    2.  **WebSocket Communication & Connection Handling (`core/websocket_server.py`, `core/connection.py`):**
+        *   **Server Setup:** Manages WebSocket connections from ESP32 devices.
+        *   **Connection Isolation:** Each ESP32 client gets a dedicated `ConnectionHandler` instance, isolating its session state and dialogue.
+        *   **Dynamic Configuration Updates:** Can fetch updated configurations from `manager-api` and re-initialize AI service modules live, without a full server restart.
+
+    3.  **Message Handling & Dialogue Flow (`core/handle/`):**
+        *   Employs a modular handler pattern. The `ConnectionHandler` dispatches message processing to specialized modules based on message type or dialogue phase (e.g., `receiveAudioHandle.py` for audio input, `intentHandler.py` for NLU, `functionHandler.py` for plugin execution, `sendAudioHandle.py` for TTS output).
+
+    4.  **Plugin System for Extensible Functions (`plugins_func/`):**
+        *   **Purpose:** Allows adding custom "skills" (e.g., weather, news, Home Assistant control).
+        *   **Mechanism:** Plugins define functions and schemas. The LLM can request execution of these functions (function calling). `loadplugins.py` and `register.py` manage plugin discovery and registration.
+
+    5.  **Configuration Management (`config/`):**
+        *   Loads settings from a local `config.yaml` and merges them with configurations fetched from `manager-api` (via `manage_api_client.py`), enabling remote dynamic configuration.
+        *   `logger.py` sets up structured application logging.
+        *   `config/assets/` stores predefined audio files for system notifications.
+
+    6.  **Auxiliary HTTP Server (`core/http_server.py`):**
+        *   Handles specific HTTP requests, notably for OTA firmware updates (`/xiaozhi/ota/`) and other utility endpoints.
+
+### 3.2. `manager-api` (Java Management Backend)
+
+The `manager-api` component is a backend server built using Java and the Spring Boot framework, serving as the administrative hub.
+
+*   **Purpose:**
+    *   Provide a secure RESTful API for the `manager-web` frontend.
+    *   Act as a centralized configuration provider for `xiaozhi-server`.
+    *   Manage persistent data (users, devices, AI configurations, voice timbres, OTA firmware).
+
+*   **Core Technologies:**
+    *   **Java 21 & Spring Boot 3:** Core language and framework.
+    *   **Spring MVC:** For building REST controllers.
+    *   **MyBatis-Plus:** ORM for database interaction with MySQL.
+    *   **MySQL:** Relational database.
+    *   **Druid:** JDBC connection pool.
+    *   **Redis (Spring Data Redis):** For caching.
+    *   **Apache Shiro:** Security framework for authentication and authorization.
+    *   **Liquibase:** Database schema migration.
+    *   **Knife4j:** OpenAPI (Swagger) API documentation.
+    *   **Maven:** Build and dependency management.
+
+*   **Key Implementation Aspects:**
+
+    1.  **Modular Architecture (`modules/` package):**
+        *   Business logic is organized into distinct modules (e.g., `sys` for users/roles, `agent` for assistant configs, `device` for ESP32s, `config` for `xiaozhi-server` settings, `security`, `timbre`, `ota`).
+        *   Each module typically follows a layered pattern: Controller, Service, DAO (Mapper), Entity, DTO.
+
+    2.  **Layered Architecture:**
+        *   **Controller Layer (`@RestController`):** Defines API endpoints, handles HTTP request/response.
+        *   **Service Layer (`@Service`):** Contains business logic, transaction management.
+        *   **Data Access Layer (MyBatis-Plus Mappers):** Interacts with the MySQL database.
+
+    3.  **Common Functionalities (`common/` package):**
+        *   Provides shared code: base classes, global configurations (Spring, MyBatis, Redis, Knife4j), custom annotations (e.g., `@LogOperation`), AOP aspects, global exception handling, utility classes, and XSS protection.
+
+    4.  **Security (Apache Shiro):**
+        *   Manages user authentication and permissions for accessing API endpoints. Configured with Shiro Realms and security filters.
+
+    5.  **Database Schema Management (Liquibase):**
+        *   Ensures consistent database structure across environments through versioned schema changes.
+
+### 3.3. `manager-web` (Vue.js Management Frontend)
+
+The `manager-web` is a Single Page Application (SPA) providing the administrative user interface.
+
+*   **Purpose:**
+    *   Offer a web-based control panel for system configuration and management.
+    *   Enable administrators to configure `xiaozhi-server`'s AI services, manage users and devices, customize voice timbres, and handle OTA updates.
+
+*   **Core Technologies:**
+    *   **Vue.js 2 & Vue CLI:** Core JavaScript framework and build tools.
+    *   **Vue Router:** For client-side routing within the SPA.
+    *   **Vuex:** For centralized state management.
+    *   **Element UI:** UI component library for a consistent look and feel.
+    *   **SCSS:** CSS preprocessor.
+    *   **HTTP Client (Flyio or Axios):** For API calls to `manager-api`.
+    *   **Workbox:** For PWA features (caching, service worker).
+    *   **Opus Libraries:** For potential in-browser audio recording/playback.
+
+*   **Key Implementation Aspects:**
+
+    1.  **SPA Structure:** Single HTML page with dynamic view updates.
+    2.  **Component-Based Architecture:** UI built from reusable Vue components (`.vue` files in `src/views/` for pages and `src/components/` for smaller elements).
+    3.  **Client-Side Routing (`src/router/index.js`):** Maps browser URLs to view components, with route guards for authentication.
+    4.  **State Management (`src/store/index.js`):** Vuex manages global state (user info, device lists, etc.) via state, getters, mutations, and actions (often involving API calls).
+    5.  **API Communication (`src/apis/`):** Modularized API service files make asynchronous calls to `manager-api`.
+    6.  **Build Process & PWA Features:** Vue CLI (Webpack) bundles assets. Workbox enables PWA features like caching.
+    7.  **Environment Configuration (`.env` files):** Manages settings like the `manager-api` base URL for different environments.
+
+---
+
+## 4. Data Flow and Interaction Mechanisms
+
+The system uses WebSockets for real-time voice interactions and RESTful APIs for management tasks.
+
+*   **Core Voice Interaction (ESP32 <-> `xiaozhi-server` - WebSockets):**
+    *   ESP32 connects to `xiaozhi-server` via WebSocket.
+    *   Audio is streamed from ESP32 to server.
+    *   Server processes audio (VAD, ASR), interacts with LLM (possibly executing plugin functions), synthesizes response via TTS.
+    *   Synthesized audio is streamed back to ESP32.
+    *   JSON control/status messages are also exchanged.
+
+*   **Management & Configuration (RESTful APIs - HTTP/JSON):**
+    *   **`manager-web` -> `manager-api`:** Admin actions in the web UI trigger REST API calls to `manager-api` for managing users, devices, configurations, etc. Shiro secures these endpoints.
+    *   **`xiaozhi-server` -> `manager-api`:** `xiaozhi-server` pulls its operational configuration from `manager-api` via REST API calls.
+
+*   **OTA Updates (Conceptual - HTTP & WebSocket):**
+    *   Firmware uploaded via `manager-web` to `manager-api`.
+    *   `xiaozhi-server` may notify ESP32 of updates via WebSocket.
+    *   ESP32 downloads firmware via HTTP from an endpoint (likely on `xiaozhi-server`).
+
+---
+
+## 5. Key Features Summary
+
+*   **Modular AI Services:** Pluggable ASR, LLM, TTS, VAD, Intent, Memory.
+*   **Advanced Dialogue:** Real-time interruption, contextual memory, multi-language support.
+*   **Extensible Skills:** Plugin system for custom functions (e.g., IoT, Home Assistant).
+*   **Comprehensive Web Management:** UI for users, devices, AI configs, OTA, timbres.
+*   **Flexible Deployment:** Docker (simplified/full) and source code options.
+*   **Dynamic Remote Configuration:** `xiaozhi-server` updates settings from `manager-api` live.
+*   **Open Source (MIT License).**
+*   **Cost-Effective Options:** "Entry Level Free Settings" available.
+*   **PWA Admin Panel:** Enhanced caching and user experience.
+*   **API Documentation:** Knife4j for `manager-api`.
+
+---
+
+## 6. Deployment and Configuration Overview
+
+*   **Deployment:**
+    *   **Docker:** Recommended for ease. Options for `xiaozhi-server` only or full stack (all components + databases). `docker-compose.yml` files provided.
+    *   **Source Code:** For development or custom setups, requiring manual environment setup for Python, Java/Maven, and Node.js.
+
+*   **Configuration:**
+    *   **`xiaozhi-server`:** Uses a local `config.yaml`, but primarily pulls dynamic configurations (AI providers, API keys) from `manager-api` via its `manage_api_client.py`.
+    *   **`manager-api`:** Configured via Spring Boot's `application.properties` or `application.yml` (database, Redis, Shiro settings).
+    *   **`manager-web`:** Configured via `.env` files (e.g., `manager-api` URL).
+    *   The `manager-web` UI is the primary interface for most system configurations in a full deployment.
+    *   Predefined profiles like "Entry Level Free Settings" and "Full Streaming Configuration" guide AI service choices.
+
+---
@@ -0,0 +1,450 @@
+# 技术文档：`xiaozhi-esp32-server`
+
+**目录：**
+
+1.  [引言](#1-引言)
+2.  [整体架构](#2-整体架构)
+3.  [核心组件深度剖析](#3-核心组件深度剖析)
+    *   [3.1. `xiaozhi-server` (核心AI引擎 - Python实现)](#31-xiaozhi-server-核心ai引擎---python实现)
+    *   [3.2. `manager-api` (管理后端 - Java Spring Boot实现)](#32-manager-api-管理后端---java-spring-boot实现)
+    *   [3.3. `manager-web` (Web管理前端 - Vue.js实现)](#33-manager-web-web管理前端---vuejs实现)
+4.  [数据流与交互机制](#4-数据流与交互机制)
+5.  [核心功能概要](#5-核心功能概要)
+6.  [部署与配置概述](#6-部署与配置概述)
+
+---
+
+## 1. 引言
+
+`xiaozhi-esp32-server` 项目是一个专为基于ESP32的智能硬件提供支持的**综合性后端系统**。其核心目标是使开发人员能够快速构建一个强大的服务器基础设施，该设施不仅能够理解自然语言指令，还能与多种AI服务（用于语音识别、自然语言理解及语音合成）进行高效交互、管理物联网（IoT）设备，并提供一个基于Web的用户界面以进行系统配置和管理。通过将多种尖端技术整合到一个高内聚且可扩展的平台中，本项目旨在简化和加速可定制化语音助手及智能控制系统的开发进程。它不仅仅是一个简单的服务器，更是一个连接硬件、AI能力与用户管理的桥梁。
+
+---
+
+## 2. 整体架构
+
+`xiaozhi-esp32-server` 系统采用了一种**分布式、多组件协作**的架构设计，确保了系统的模块化、可维护性和可扩展性。各个核心组件各司其职，协同工作。主要组件包括：
+
+1.  **ESP32 硬件 (客户端设备):**
+    这是终端用户直接与之交互的物理智能硬件设备。其主要职责包括：
+    *   捕捉用户的语音指令。
+    *   将捕捉到的原始音频数据安全地发送至 `xiaozhi-server` 进行处理。
+    *   接收来自 `xiaozhi-server` 合成的语音回复，并通过扬声器播放给用户。
+    *   根据从 `xiaozhi-server` 收到的指令，控制与之连接的其他外围设备或IoT设备（例如智能灯泡、传感器等）。
+
+2.  **`xiaozhi-server` (核心AI引擎 - Python实现):**
+    这个基于Python的服务器是整个系统的“大脑”，负责处理所有语音相关的逻辑和AI交互。其关键职责细化如下：
+    *   通过WebSocket协议与ESP32设备建立**稳定、低延迟的实时双向通信链路**。
+    *   接收来自ESP32的音频流，并利用语音活动检测（VAD）技术精确切分有效的语音片段。
+    *   集成并调用自动语音识别（ASR）服务（可配置本地或云端），将语音片段转换为文本。
+    *   通过与大型语言模型（LLM）的交互来解析用户意图、生成智能回复，并支持复杂的自然语言理解任务。
+    *   管理多轮对话中的上下文信息和用户记忆，以提供连贯的交互体验。
+    *   调用文本转语音（TTS）服务，将LLM生成的文本回复合成为自然流畅的语音。
+    *   通过一个灵活的**插件系统**执行自定义命令，包括对IoT设备的控制逻辑。
+    *   从 `manager-api` 服务获取其详细的运行时操作配置。
+
+3.  **`manager-api` (管理后端 - Java实现):**
+    这是一个基于Java Spring Boot框架构建的应用程序，它为整个系统的管理和配置提供了一套安全的RESTful API。它不仅是 `manager-web` 控制台的后端支撑，也是 `xiaozhi-server` 的配置数据来源。其核心功能包括：
+    *   为Web控制台提供用户认证（登录、权限验证）和用户账户管理功能。
+    *   ESP32设备的注册、信息管理以及设备特定配置的维护。
+    *   在**MySQL数据库**中持久化存储系统配置，例如用户选择的AI服务提供商、API密钥、设备参数、插件设置等。
+    *   提供特定的API端点，供 `xiaozhi-server` 拉取其所需的最新配置。
+    *   管理TTS音色选项、处理OTA（Over-The-Air）固件更新流程及相关元数据。
+    *   利用 **Redis** 作为高速缓存，存储热点数据（如会话信息、频繁访问的配置），以提升API响应速度和系统整体性能。
+
+4.  **`manager-web` (Web控制面板 - Vue.js实现):**
+    这是一个基于Vue.js构建的单页应用（SPA），为系统管理员提供了一个图形化、用户友好的操作界面。其主要能力包括：
+    *   便捷地配置 `xiaozhi-server` 所使用的各项AI服务（如ASR、LLM、TTS的提供商切换、参数调整）。
+    *   管理平台用户账户、角色分配及权限控制。
+    *   管理已注册的ESP32设备及其相关设置。
+    *   （潜在功能）监控系统运行状态、查看日志、进行故障排查等。
+    *   与 `manager-api` 提供的所有后端管理功能进行全面的交互。
+
+**高层交互流程概述:**
+
+*   **语音交互主线:** **ESP32设备**捕捉到用户语音后，通过**WebSocket**将音频数据实时传输给**`xiaozhi-server`**。`xiaozhi-server`完成一系列AI处理（VAD、ASR、LLM交互、TTS）后，再通过WebSocket将合成的语音回复发送回ESP32设备进行播放。所有与语音直接相关的实时交互均在此链路完成。
+*   **管理配置主线:** 管理员通过浏览器访问**`manager-web`**控制台。`manager-web`通过调用**`manager-api`**提供的**RESTful HTTP接口**来执行各种管理操作（如修改配置、管理用户或设备）。数据以JSON格式在两者间传递。
+*   **配置同步:** **`xiaozhi-server`**在启动或特定更新机制触发时，会主动通过HTTP请求从**`manager-api`**拉取其最新的操作配置。这确保了管理员在Web界面上所做的配置更改能够及时有效地应用到核心AI引擎的运行中。
+
+这种**前后端分离、核心服务与管理服务分离**的架构设计，使得 `xiaozhi-server`能够专注于高效的实时AI处理任务，而 `manager-api` 和 `manager-web` 则共同提供了一个功能强大且易于使用的管理和配置平台。各组件职责清晰，有利于独立开发、测试、部署和扩展。
+
+---
+
+## 3. 核心组件深度剖析
+
+### 3.1. `xiaozhi-server` (核心AI引擎 - Python实现)
+
+`xiaozhi-server` 作为系统的智能核心，全权负责处理语音交互、对接各类AI服务以及管理与ESP32设备间的通信。其设计目标是实现高效、灵活且可扩展的语音AI处理能力。
+
+*   **核心目标:**
+    *   为ESP32设备提供实时的语音指令处理服务。
+    *   深度集成各类AI服务，包括：自动语音识别 (ASR)、大型语言模型 (LLM) 进行自然语言理解 (NLU)、文本转语音 (TTS)、语音活动检测 (VAD)、意图识别 (Intent Recognition) 及对话记忆 (Memory)。
+    *   精细管理用户与设备间的对话流程及上下文状态。
+    *   基于用户指令，通过插件化机制执行自定义函数及控制物联网 (IoT) 设备。
+    *   支持通过 `manager-api`进行动态配置加载与更新。
+
+*   **核心技术栈:**
+    *   **Python 3:** 作为主要编程语言，Python以其丰富的AI/ML生态库和快速开发特性被选用。
+    *   **Asyncio:** Python的异步编程框架，是`xiaozhi-server`高性能的关键。它被广泛用于高效处理来自大量ESP32设备的并发WebSocket连接，以及执行与外部AI服务API通信时的非阻塞I/O操作，确保服务器在高并发下的响应能力。
+    *   **`websockets` 库:** 提供WebSocket服务器的具体实现，支持与ESP32客户端进行全双工实时通信。
+    *   **HTTP客户端 (如 `aiohttp`, `httpx`):** 用于异步执行HTTP请求，主要目的是从`manager-api`获取配置信息，以及与云端AI服务的API进行交互。
+    *   **YAML (通常通过 PyYAML 库):** 用于解析本地的 `config.yaml` 配置文件。
+    *   **FFmpeg (外部依赖):** 在 `app.py` 启动时会进行检查 (`check_ffmpeg_installed()`)。FFmpeg通常用于音频处理和格式转换，例如，确保音频数据符合特定AI服务的要求或进行内部处理。
+
+*   **关键实现细节:**
+
+    1.  **AI服务提供者模式 (Provider Pattern - `core/providers/`):**
+        *   **设计思想:** 这是`xiaozhi-server`集成不同AI服务的核心设计模式，极大地增强了系统的灵活性和可扩展性。针对每一种AI服务类型（ASR, TTS, LLM, VAD, Intent, Memory, VLLM），都在其对应子目录下定义了一个抽象基类 (ABC, Abstract Base Class)，例如 `core/providers/asr/base.py`。这个基类规定了该类型服务必须实现的通用接口方法（如ASR的 `async def transcribe(self, audio_chunk: bytes) -> str: pass`）。
+        *   **具体实现:** 各种具体的AI服务提供商或本地模型的实现，则以独立的Python类形式存在（例如 `core/providers/asr/fun_local.py` 实现了本地FunASR的逻辑，`core/providers/llm/openai.py` 实现了与OpenAI GPT模型的对接）。这些具体类继承自相应的抽象基类，并实现其定义的接口。部分提供者还使用DTOs (Data Transfer Objects, 存在于各自的 `dto/` 目录) 来结构化与外部服务交换的数据。
+        *   **优势:** 使得核心业务逻辑能够以统一的方式调用不同的AI服务，而无需关心其底层具体实现。用户可以通过配置文件轻松切换AI服务后端。添加对新AI服务的支持也变得相对简单，只需实现对应的Provider接口。
+        *   **动态加载与初始化:** `core/utils/modules_initialize.py` 脚本扮演了工厂的角色。它在服务器启动时，或在接收到配置更新指令时，会根据配置文件中 `selected_module` 及各项服务的具体provider设置，动态地导入并实例化相应的Provider类。
+
+    2.  **WebSocket通信与连接处理 (`app.py`, `core/websocket_server.py`, `core/connection.py`):**
+        *   **服务器启动与入口 (`app.py`):**
+            *   `app.py` 作为主入口，负责初始化应用环境（如检查FFmpeg、加载配置、设置日志）。
+            *   它会生成或加载一个 `auth_key` (JWT密钥)，用于保护特定的HTTP接口（如视觉分析接口 `/mcp/vision/explain`）。若配置中 `manager-api.secret` 为空，则会生成一个UUID作为 `auth_key`。
+            *   使用 `asyncio.create_task()` 并发启动 `WebSocketServer` (监听如 `ws://0.0.0.0:8000/xiaozhi/v1/`) 和 `SimpleHttpServer` (监听如 `http://0.0.0.0:8003/xiaozhi/ota/`)。
+            *   包含一个 `monitor_stdin()` 协程，用于在某些环境下保持应用存活或处理终端输入。
+        *   **WebSocket服务器核心 (`core/websocket_server.py`):**
+            *   `WebSocketServer` 类使用 `websockets` 库监听来自ESP32设备的连接请求。
+            *   对于每一个成功的WebSocket连接，它都会创建一个**独立的 `ConnectionHandler` 实例** (推测定义于 `core/connection.py`)。这种每个连接一个处理程序实例的设计模式，是实现多设备状态隔离和并发处理的关键，确保每个设备的对话流程和上下文信息互不干扰。
+            *   该服务器还提供一个 `_http_response` 方法，允许在同一端口上对非WebSocket升级的HTTP GET请求做出简单响应（例如返回 "Server is running"），便于进行健康检查。
+        *   **动态配置更新:** `WebSocketServer` 包含一个 `update_config()` 异步方法。此方法使用 `config_lock` (一个 `asyncio.Lock`) 保证配置更新的原子性。它调用 `get_config_from_api()` (可能在 `config_loader.py` 中实现，通过 `manage_api_client.py` 与 `manager-api` 通信) 来获取新的配置。通过 `check_vad_update()` 和 `check_asr_update()` 等辅助函数判断是否需要重新初始化特定的AI模块，避免不必要的开销。更新后的配置会用于重新调用 `initialize_modules()`，从而实现AI服务提供者的热切换。
+
+    3.  **消息处理与对话流程控制 (`core/handle/` 和 `ConnectionHandler`):**
+        *   `ConnectionHandler` (推测) 作为每个连接的控制中心，负责接收来自ESP32的消息，并根据消息类型或当前对话状态，将其分发给 `core/handle/` 目录下的相应处理模块。这种模块化的处理器设计使得 `ConnectionHandler` 逻辑更清晰，易于扩展。
+        *   **主要处理模块及其职责:**
+            *   `helloHandle.py`: 处理与ESP32初次连接时的握手协议、设备认证或初始化信息交换。
+            *   `receiveAudioHandle.py`: 接收音频流数据，调用VAD Provider进行语音活动检测，并将有效的音频片段传递给ASR Provider进行识别。
+            *   `textHandle.py` / `intentHandler.py`: 获取ASR识别出的文本后，与Intent Provider (可能利用LLM进行意图识别) 和LLM Provider交互，以理解用户意图并生成初步回复或决策。
+            *   `functionHandler.py`: 当LLM的响应包含执行特定“函数调用”的指令时，此模块负责从插件注册表中查找并执行对应的插件函数。
+            *   `sendAudioHandle.py`: 将LLM最终生成的文本回复交给TTS Provider合成语音，并将音频流通过WebSocket发送回ESP32。
+            *   `abortHandle.py`: 处理来自ESP32的中断请求，例如停止当前的TTS播报。
+            *   `iotHandle.py`, `mcpHandle.py`: 处理与IoT设备控制相关的特定指令或更复杂的模块通信协议 (MCP)。
+
+    4.  **插件化功能扩展系统 (`plugins_func/`):**
+        *   **设计目的:** 提供一种标准化的方式来扩展语音助手的功能和“技能”，而无需修改核心代码。
+        *   **实现机制:**
+            *   各个具体功能以独立的Python脚本形式存在于 `plugins_func/functions/` 目录中（例如 `get_weather.py`, `hass_set_state.py` 用于Home Assistant集成）。
+            *   `loadplugins.py` 在服务器启动时负责扫描并加载这些插件模块。
+            *   `register.py` (或插件模块内部的特定装饰器/函数) 可能用于定义每个插件函数的元数据，包括：
+                *   **函数名称 (Function Name):** LLM调用时使用的标识符。
+                *   **功能描述 (Description):** 供LLM理解此函数的作用。
+                *   **参数模式 (Parameters Schema):** 通常是一个JSON Schema，详细定义了函数所需的参数、类型、是否必需以及描述。这是LLM能够正确生成函数调用参数的关键。
+        *   **执行流程:** 当LLM在其思考过程中决定需要调用某个外部工具或函数来获取信息或执行操作时，它会依据预先提供的函数模式生成一个结构化的“函数调用”请求。`xiaozhi-server`中的`functionHandler.py`捕获此请求，从插件注册表中找到对应的Python函数并执行，然后将执行结果返回给LLM，LLM再基于此结果生成最终给用户的自然语言回复。
+
+    5.  **配置管理 (`config/`):**
+        *   **加载机制:** `config_loader.py` (通过 `settings.py` 被调用) 负责从根目录的 `config.yaml` 文件加载基础配置。
+        *   **远程配置与合并:** 通过 `manage_api_client.py` (使用如`aiohttp`的库与`manager-api`通信) 可以从`manager-api`服务拉取配置。远程配置通常会覆盖本地 `config.yaml` 中的同名设置，从而实现通过Web界面动态调整服务器行为。
+        *   **日志系统:** `logger.py` 初始化应用日志系统（可能使用 `loguru` 或对标准 `logging` 模块进行封装，支持通过 `logger.bind(tag=TAG)` 添加标签，便于追踪和过滤）。
+        *   **静态资源:** `config/assets/` 目录下存放了用于系统提示音的静态音频文件（如设备绑定提示音 `bind_code.wav`、错误提示音等）。
+
+    6.  **辅助HTTP服务 (`core/http_server.py`):**
+        *   与WebSocket服务并行运行一个简单的HTTP服务器，用于处理特定的HTTP请求。最主要的功能是为ESP32设备提供OTA (Over-The-Air) 固件更新的下载服务 (通过 `/xiaozhi/ota/` 端点)。此外，也可能承载其他如 `/mcp/vision/explain` (视觉分析) 等工具性HTTP接口。
+
+综上所述，`xiaozhi-server` 是一个采用现代Python异步编程模型构建的、高度模块化、配置驱动的AI应用服务器。其精心设计的Provider模式和插件架构赋予了它强大的适应性和扩展性，能够灵活接入不同的AI能力并支持日益增长的功能需求。
+
+---
+
+### 3.2. `manager-api` (管理后端 - Java Spring Boot实现)
+
+`manager-api` 组件是使用Java和Spring Boot框架构建的强大后端服务，作为整个`xiaozhi-esp32-server`生态系统的中央行政管理和配置中枢。
+
+*   **核心目标:**
+    *   为`manager-web`（Vue.js前端）提供一套安全、稳定、符合RESTful规范的API接口，使得管理员能够便捷地管理用户、设备、系统配置及其他相关资源。
+    *   充当`xiaozhi-server`（Python核心AI引擎）的集中化配置数据提供者，允许`xiaozhi-server`实例在启动或运行时获取其最新的操作参数。
+    *   持久化存储关键数据，例如：用户账户信息、设备注册详情、AI服务提供商配置（包括API密钥、选定的服务模型等）、TTS音色参数，以及OTA固件版本信息等。
+
+*   **核心技术栈:**
+    *   **Java 21:** 项目采用的JDK版本，确保了对现代Java特性的支持。
+    *   **Spring Boot 3:** 作为核心开发框架，极大地简化了独立、生产级别的Spring应用的创建和部署。它提供了自动配置、内嵌Web服务器（默认为Tomcat）、依赖管理等关键功能。
+    *   **Spring MVC:** Spring框架中用于构建Web应用和RESTful API的模块。
+    *   **MyBatis-Plus:** 一个对MyBatis进行功能增强的ORM（对象关系映射）框架。它简化了数据库操作，提供了强大的CRUD（增删改查）功能、条件构造器、代码生成器等，并能很好地与Spring Boot集成。
+    *   **MySQL:** 作为主要的后端关系型数据库，用于存储所有需要持久化的管理数据和配置信息。
+    *   **Druid (Alibaba Druid):** 一个功能强大的JDBC连接池实现，提供了丰富的监控功能和优秀的性能，用于高效管理数据库连接。
+    *   **Redis (通过 Spring Data Redis):** 一个高性能的内存数据结构存储，常用于实现数据缓存（例如缓存热点配置数据、用户会话信息），以显著提升API的响应速度。
+    *   **Apache Shiro:** 一个成熟且易用的Java安全框架，负责处理应用的认证（用户身份验证）和授权（API访问权限控制）需求。
+    *   **Liquibase:** 一个用于跟踪、管理和应用数据库 schéma（模式）变更的开源工具。它允许开发者以数据库无关的方式定义和版本化数据库结构变更。
+    *   **Knife4j:** 一个集成了Swagger并增强了UI的API文档生成工具，专为Java MVC框架（尤其是Spring Boot）设计。它能生成美观且易于交互的API文档界面（通常通过 `/xiaozhi/doc.html` 访问）。
+    *   **Maven:** 用于项目的构建自动化和依赖项管理。
+    *   **Lombok:** 一个Java库，通过注解自动生成构造函数、getter/setter、equals/hashCode、toString等样板代码，减少冗余。
+    *   **HuTool / Google Guava:** 提供大量实用工具类，简化常见编程任务。
+    *   **Aliyun Dysmsapi:** 阿里云短信服务SDK，用于集成发送短信功能（如验证码、通知）。
+
+*   **关键实现细节:**
+
+    1.  **模块化项目结构 (`modules/` 包):**
+        *   `manager-api` 的核心业务逻辑被清晰地划分到 `src/main/java/xiaozhi/modules/` 目录下的不同模块中。这种按功能领域划分模块的方式（例如 `sys` 负责系统管理，`agent` 负责智能体配置，`device` 负责设备管理，`config` 负责为`xiaozhi-server`提供配置，`security` 负责安全，`timbre` 负责音色管理，`ota` 负责固件升级）极大地提高了代码的可维护性和可扩展性。
+        *   **各模块内部结构:** 每个业务模块通常遵循经典的三层架构或其变体：
+            *   **Controller (控制层):** 位于 `xiaozhi.modules.[模块名].controller`。
+            *   **Service (服务层):** 位于 `xiaozhi.modules.[模块名].service`。
+            *   **DAO/Mapper (数据访问层):** 位于 `xiaozhi.modules.[模块名].dao`。
+            *   **Entity (实体类):** 位于 `xiaozhi.modules.[模块名].entity`。
+            *   **DTO (数据传输对象):** 位于 `xiaozhi.modules.[模块名].dto`。
+
+    2.  **分层架构实现:**
+        *   **Controller层 (`@RestController`):** 这些类使用Spring MVC注解（如 `@GetMapping`, `@PostMapping` 等）来定义API的端点(endpoints)。它们负责接收HTTP请求，将请求体中的JSON数据反序列化为DTO对象，调用相应的Service层方法处理业务逻辑，最后将Service层的返回结果序列化为JSON并作为HTTP响应返回给客户端。
+        *   **Service层 (`@Service`):** 这些类（通常是接口及其实现类的组合）封装了核心的业务规则和操作流程。它们可能会调用一个或多个DAO/Mapper对象来与数据库交互，并常常使用 `@Transactional` 注解来管理数据库事务的原子性。
+        *   **Data Access (DAO/Mapper) 层 (MyBatis-Plus Mappers):** 这些是Java接口，继承自MyBatis-Plus提供的 `BaseMapper<Entity>` 接口。MyBatis-Plus会为这些接口自动提供标准的CRUD方法。对于更复杂的数据库查询，开发者可以通过在Mapper接口中定义方法并使用注解（如 `@Select`, `@Update`）或编写对应的XML映射文件来实现。例如，`UserMapper.selectById(userId)` 会被MyBatis-Plus自动实现。
+        *   **Entity层 (`@TableName`, `@TableId` 等MyBatis-Plus注解):** 这些POJO（Plain Old Java Objects）类直接映射到数据库中的表结构。Lombok的 `@Data` 注解常用于自动生成getter/setter等。
+        *   **DTO层:** 用于在各层之间，特别是Controller层与Service层之间，以及API的请求/响应体中传递数据。使用DTO有助于解耦API接口的数据结构与数据库实体的数据结构，使API更稳定。
+
+    3.  **通用功能与配置 (`common/` 包):**
+        *   `src/main/java/xiaozhi/common/` 包提供了一系列跨模块共享的通用组件和配置：
+            *   **基类:** 如 `BaseDao`, `BaseEntity`, `BaseService`, `CrudService`，为各模块的相应组件提供通用的属性或方法。
+            *   **全局配置:** 包括 `MybatisPlusConfig` (MyBatis-Plus的配置，如分页插件、数据权限插件等)、`RedisConfig` (Redis连接及序列化配置)、`SwaggerConfig` (Knife4j的配置)、`AsyncConfig` (异步任务执行器配置)。
+            *   **自定义注解:** 例如 `@LogOperation` 用于通过AOP记录操作日志，`@DataFilter` 可能用于实现数据范围过滤。
+            *   **AOP切面:** 如 `RedisAspect` 可能用于实现方法级别的缓存逻辑。
+            *   **全局异常处理:** `RenExceptionHandler` (使用 `@ControllerAdvice` 注解) 捕获应用中抛出的特定或所有异常 (如自定义的 `RenException`)，并返回统一格式的JSON错误响应给客户端。`ErrorCode` 定义了标准化的错误码。
+            *   **工具类:** 提供了日期转换、JSON处理(Jackson)、IP地址获取、HTTP上下文操作、统一结果封装 (`Result` 类)等多种实用工具。
+            *   **校验工具:** `ValidatorUtils` 和 `AssertUtils` 用于简化参数校验逻辑。
+            *   **XSS防护:** `XssFilter` 等组件用于防止跨站脚本攻击。
+            *   **MyBatis-Plus自动填充:** `FieldMetaObjectHandler` 用于在执行插入或更新数据库操作时，自动填充如 `createTime`, `updateTime` 等公共字段。
+
+    4.  **安全机制 (Apache Shiro):**
+        *   Shiro的配置（通常在 `modules/security/config/` 或 `common/config/` 下）定义了如何进行用户认证和授权。
+        *   **Realms (域):** 自定义的Shiro Realm类负责从数据库中查询用户信息（用户名、密码、盐值）进行身份验证，以及获取用户的角色和权限信息用于授权决策。
+        *   **Filters (过滤器):** Shiro过滤器链被应用于保护API端点，确保只有经过认证且拥有足够权限的用户才能访问特定资源。
+        *   **Session/Token Management:** Shiro管理用户会话。对于RESTful API，可能结合OAuth2或JWT等令牌机制实现无状态认证。
+
+    5.  **数据库版本控制 (Liquibase):**
+        *   数据库的表结构、索引、初始数据等变更，都通过Liquibase的 `changelog` 文件（通常是XML格式）进行定义和版本化管理。当应用启动时，Liquibase会自动检查并应用必要的数据库结构更新，确保开发、测试和生产环境数据库结构的一致性。
+
+`manager-api` 通过这些精心选择的技术和设计模式，构建了一个功能全面、结构清晰、安全可靠且易于维护和扩展的Java后端服务。其模块化的设计特别适合处理具有多种管理功能需求的复杂系统。
+
+---
+
+### 3.3. `manager-web` (Web管理前端 - Vue.js实现)
+
+`manager-web` 组件是一个采用 Vue.js 2 框架构建的单页应用 (SPA - Single Page Application)。它为系统管理员提供了一个功能丰富、交互友好的图形用户界面，用于全面管理和配置 `xiaozhi-esp32-server` 生态系统。
+
+*   **核心目标:**
+    *   提供一个基于Web的集中式控制面板，供管理员进行系统操作与监控。
+    *   实现对 `xiaozhi-server` 中AI服务提供商（ASR、LLM、TTS等）及其相关API密钥或许可配置的便捷管理。
+    *   支持用户账户、角色及权限的精细化管理。
+    *   提供ESP32设备的注册、配置及状态查看功能。
+    *   允许管理员自定义TTS音色、管理OTA固件更新流程、调整系统级参数及字典数据等。
+    *   作为 `manager-api` 所暴露各项功能的图形化交互前端。
+
+*   **核心技术栈:**
+    *   **Vue.js 2:** 一个渐进式的JavaScript框架，用于构建用户界面。其核心特性包括声明式渲染、组件化系统、数据绑定等，非常适合构建复杂的SPA。
+    *   **Vue CLI (`@vue/cli-service`):** Vue.js的官方命令行工具，用于项目的快速搭建、开发服务器的运行（支持热模块替换HMR）、以及生产环境构建打包（内部集成并配置了Webpack）。
+    *   **Vue Router (`vue-router`):** Vue.js官方的路由管理器。它负责在SPA内部实现不同“页面”或视图组件之间的导航切换，而无需重新加载整个HTML页面，提供了流畅的用户体验。
+    *   **Vuex (`vuex`):** Vue.js官方的状态管理模式和库。它充当了应用中所有组件的“中央数据存储”，用于管理全局共享状态（例如当前登录用户信息、设备列表、应用配置等），特别适用于大型复杂应用。
+    *   **Element UI (`element-ui`):** 一个广受欢迎的基于Vue 2.0的桌面端UI组件库。它提供了大量预先设计和实现的组件（如表单、表格、对话框、导航菜单、按钮、提示等），帮助开发者快速构建出专业且一致的用户界面。
+    *   **JavaScript (ES6+):** 前端逻辑实现的主要编程语言，利用其现代特性进行开发。
+    *   **SCSS (Sassy CSS):** 一种CSS预处理器，它为CSS增加了变量、嵌套规则、混合(Mixin)、继承等高级特性，使得CSS代码更易于组织、维护和复用。
+    *   **HTTP客户端 (Flyio 或 Axios 通过 `vue-axios`):** 用于在浏览器端向 `manager-api` 后端发起异步HTTP（AJAX）请求，以获取数据或提交操作。
+    *   **Webpack:** 一个强大的模块打包工具（由Vue CLI在底层管理和配置）。它将项目中的各种资源（JavaScript文件、CSS、图片、字体等）视为模块，并将它们打包成浏览器可识别的静态文件。
+    *   **Workbox (通过 `workbox-webpack-plugin`):** Google开发的一个库，用于简化Service Worker的编写和PWA（Progressive Web App - 渐进式Web应用）的实现。它可以帮助生成Service Worker脚本，实现资源缓存、离线访问等功能。
+    *   **Opus库 (`opus-decoder`, `opus-recorder`):** 这些音频处理库表明前端可能具备一些直接在浏览器中处理Opus格式音频的能力，例如：用于测试麦克风输入、允许管理员录制自定义音频片段（可能用于TTS音色样本或语音指令测试），或播放在管理界面中预览的Opus编码音频。
+
+*   **关键实现细节:**
+
+    1.  **单页应用 (SPA) 结构:**
+        *   整个前端应用加载一个主HTML文件 (`public/index.html`)。后续的所有页面切换和内容更新都在客户端由Vue Router动态完成，无需每次都从服务器请求新的HTML页面。这种模式能提供更快的页面加载速度和更流畅的交互体验。
+
+    2.  **组件化架构 (Component-Based Architecture):**
+        *   用户界面由一系列可复用的Vue组件 (`.vue` 单文件组件) 构成，形成一个组件树。这种方式提高了代码的模块化程度、可维护性和复用性。
+        *   **`src/main.js`:** 应用的入口JS文件。它负责创建和初始化根Vue实例，注册全局插件（如Vue Router, Vuex, Element UI），并把根Vue实例挂载到 `public/index.html` 中的某个DOM元素上（通常是 `#app`）。
+        *   **`src/App.vue`:** 应用的根组件。它通常定义了应用的基础布局结构（如包含导航栏、侧边栏、主内容区），并通过 `<router-view></router-view>` 标签来显示当前路由匹配到的视图组件。
+        *   **视图组件 (`src/views/`):** 这些组件代表了应用中的各个“页面”或主要功能区（例如 `Login.vue` 登录页, `DeviceManagement.vue` 设备管理页, `UserManagement.vue` 用户管理页, `ModelConfig.vue` 模型配置页）。它们通常由Vue Router直接映射。
+        *   **可复用UI组件 (`src/components/`):** 包含了在不同视图之间共享的、更小粒度的UI组件（例如 `HeaderBar.vue` 顶部导航栏, `AddDeviceDialog.vue` 添加设备对话框, `AudioPlayer.vue` 音频播放器组件）。
+
+    3.  **客户端路由 (`src/router/index.js`):**
+        *   Vue Router在此文件中进行配置，定义了应用的路由表。每个路由规则将一个特定的URL路径映射到一个视图组件。
+        *   常常包含**导航守卫 (Navigation Guards)**，例如 `beforeEach` 守卫，用于在路由跳转前执行逻辑，如检查用户是否已登录，如果未登录则重定向到登录页面，从而保护需要认证才能访问的页面。
+
+    4.  **状态管理 (`src/store/index.js`):**
+        *   Vuex被用来构建一个集中的状态管理中心（Store）。这个Store包含了：
+            *   **State:** 存储应用级别的共享数据（例如，当前登录用户的详细信息、从API获取的设备列表、系统配置等）。
+            *   **Getters:** 类似于Vue组件中的计算属性，用于从State派生出一些状态值，方便组件使用。
+            *   **Mutations:** **唯一**可以同步修改State中数据的方法。它们必须是同步函数。
+            *   **Actions:** 用于处理异步操作（如API调用）或封装多个Mutation提交。Actions会调用API，获取数据后，通过 `commit` 一个或多个Mutation来更新State。
+        *   例如，用户登录时，一个名为 `login` 的Action可能会被调用，它会向后端API发送登录请求，成功后获取到用户信息和token，然后 `commit` 一个名为 `SET_USER_INFO` 的Mutation来更新State中的用户信息和token。
+
+    5.  **API通信 (`src/apis/`):**
+        *   与 `manager-api` 后端的所有HTTP通信逻辑被封装在 `src/apis/` 目录下，通常会按照后端API的模块进行组织（例如 `src/apis/module/agent.js`, `src/apis/module/device.js`）。
+        *   每个模块导出一系列函数，每个函数对应一个具体的API请求。这些函数内部使用配置好的HTTP客户端实例 (例如，在 `src/apis/api.js` 或 `src/apis/httpRequest.js` 中统一配置Axios或Flyio实例，可能包含设置请求基地址、请求/响应拦截器等)。
+        *   **拦截器 (Interceptors):** HTTP客户端的请求拦截器常用于在每个请求发送前自动添加认证令牌（如JWT）；响应拦截器则可用于全局处理API错误（如权限不足、服务器错误）或对响应数据进行预处理。
+
+    6.  **样式与资源 (`src/styles/`, `src/assets/`):**
+        *   `Element UI` 提供了基础的组件样式。
+        *   `src/styles/global.scss` 文件用于定义全局共享的SCSS样式、变量、混合(Mixin)等。
+        *   Vue单文件组件内部的 `<style scoped>` 标签允许编写只作用于当前组件的局部样式。
+        *   `src/assets/` 目录存放图片、字体等静态资源。
+
+    7.  **构建与PWA特性:**
+        *   Vue CLI通过Webpack将所有代码和资源打包成优化的静态文件，用于生产部署。
+        *   `workbox-webpack-plugin` 的使用（体现在 `service-worker.js` 和 `registerServiceWorker.js` 文件）表明项目集成了Service Worker技术。Service Worker可以拦截网络请求，实现前端资源的智能缓存（从而加快后续访问速度），甚至在网络断开时提供一定的离线访问能力，是PWA的核心技术之一。
+
+    8.  **环境配置 (`.env`系列文件):**
+        *   项目根目录下的 `.env` (以及 `.env.development`, `.env.production` 等) 文件用于定义环境变量。这些变量（例如 `VUE_APP_API_BASE_URL` 来指定 `manager-api` 的基础URL）可以在应用代码中通过 `process.env.VUE_APP_XXX` 的形式访问，从而允许为不同构建环境（开发、测试、生产）配置不同的参数。
+
+`manager-web` 通过这些技术的综合运用，构建了一个功能强大、易于维护且用户体验良好的管理界面，为 `xiaozhi-esp32-server` 系统的配置和监控提供了坚实的前端支持。
+
+---
+
+## 4. 数据流与交互机制
+
+`xiaozhi-esp32-server` 系统通过各组件间定义清晰的数据流和交互协议来协同工作。主要的通信方式依赖于针对实时交互优化的WebSocket协议和适用于客户端-服务器请求的RESTful API。
+
+**4.1.核心语音交互流程 (ESP32设备 <-> `xiaozhi-server`)**
+
+此流程是实时的，主要通过WebSocket进行低延迟、双向的数据交换。
+
+*   **连接建立与握手:**
+    *   ESP32设备作为客户端，主动向`xiaozhi-server`的指定端点（例如 `ws://<服务器IP>:<WebSocket端口>/xiaozhi/v1/`）发起WebSocket连接请求。
+    *   `xiaozhi-server` (`core/websocket_server.py`) 接收连接，并为每个成功连接的ESP32设备实例化一个独立的`ConnectionHandler`对象来管理该会话的整个生命周期。
+    *   连接建立后，可能会执行一个初始握手流程（由`core/handle/helloHandle.py`处理），用于交换设备标识、认证信息、协议版本或基本状态。
+
+*   **音频上行传输 (ESP32 -> `xiaozhi-server`):**
+    *   用户对ESP32设备讲话后，设备上的麦克风捕捉原始音频数据（通常是PCM或经过压缩如Opus的格式）。
+    *   ESP32将这些音频数据块（chunks）作为WebSocket的**二进制消息 (binary messages)** 实时推送到`xiaozhi-server`对应的`ConnectionHandler`。
+    *   服务器端的`core/handle/receiveAudioHandle.py`模块负责接收、缓冲并处理这些音频数据。
+
+*   **AI核心处理 (在`xiaozhi-server`内部):**
+    *   **VAD (语音活动检测):** `receiveAudioHandle.py`利用配置的VAD提供者（如SileroVAD）分析音频流，以准确识别语音的起始和结束点，滤除静默或噪声片段。
+    *   **ASR (自动语音识别):** 检测到的有效语音片段被送往配置的ASR提供者（本地如FunASR，或云端服务）。ASR引擎将音频信号转换为文本字符串。
+    *   **NLU/LLM (自然语言理解/大型语言模型):** ASR输出的文本，连同从Memory提供者获取的当前对话上下文历史，以及从`plugins_func/`加载的可用函数（工具）的描述模式，一同被传递给配置的LLM提供者。
+    *   **函数调用执行 (若LLM决策需要):** 如果LLM分析后认为需要调用外部函数（例如查询天气、控制家电），它会生成一个结构化的函数调用请求。`core/handle/functionHandler.py`接收此请求，查找并执行在`plugins_func/`中定义的相应Python函数，并将函数的执行结果返回给LLM。LLM随后基于此结果生成最终的自然语言回复。
+    *   **回复生成:** LLM综合所有信息（用户输入、上下文、函数调用结果等）生成最终的文本回复。
+    *   **记忆更新:** 当前轮次的交互（用户问题、LLM回复、可能的功能调用）会被Memory提供者处理，以更新对话历史，供后续交互使用。
+    *   **TTS (文本转语音):** LLM生成的最终文本回复被送往配置的TTS提供者，后者将文本合成为语音数据流（例如MP3或WAV格式）。
+
+*   **音频下行响应 (`xiaozhi-server` -> ESP32):**
+    *   由TTS提供者合成的语音数据流，通过`core/handle/sendAudioHandle.py`模块，作为WebSocket的**二进制消息**实时发送回ESP32设备。
+    *   ESP32设备接收这些音频数据块并立即通过扬声器播放给用户。
+
+*   **控制与状态消息 (双向):**
+    *   除了音频流，ESP32与`xiaozhi-server`之间也通过WebSocket交换**文本消息 (text messages)**，这些消息通常采用JSON格式封装。
+    *   **ESP32 -> Server:** 设备可能发送状态报告（如网络状况、麦克风状态）、错误代码、或特定的控制命令（例如用户按键触发的“停止TTS播报”）。
+    *   **Server -> ESP32:** 服务器可能发送控制指令给设备（如“开始监听”、“停止监听”、调整灵敏度、下发特定配置参数）。
+    *   `core/handle/abortHandle.py`（处理中断请求）、`core/handle/reportHandle.py`（处理设备报告）等模块负责解析和响应这些控制/状态消息。
+
+**4.2.管理与配置流程 (`manager-web` <-> `manager-api` <-> `xiaozhi-server`)**
+
+此流程主要依赖于基于HTTP/HTTPS的RESTful API进行请求-响应式的交互。
+
+*   **管理员UI后端交互 (`manager-web` -> `manager-api`):**
+    *   当管理员在`manager-web`界面执行操作时（例如保存一项配置、添加一个新用户、注册一台ESP32设备）：
+        *   Vue.js前端应用 (`manager-web`) 会通过其API封装模块（位于`src/apis/module/`）向`manager-api`的对应REST API端点发起异步HTTP请求（通常是GET, POST, PUT, DELETE）。
+        *   请求体和响应体通常使用JSON格式。
+        *   `manager-api`中的`@RestController`类接收这些请求。**Apache Shiro**框架会首先对请求进行认证和授权检查。
+        *   通过验证后，Controller将请求分发给相应的Service层处理业务逻辑。Service层可能会与MySQL数据库（通过MyBatis-Plus）交互，并可能利用Redis进行数据缓存。
+        *   处理完成后，`manager-api`向`manager-web`返回一个JSON格式的HTTP响应。
+        *   `manager-web`根据响应结果更新其Vuex状态存储和用户界面显示。
+
+*   **配置同步 (`manager-api` -> `xiaozhi-server`):**
+    *   `xiaozhi-server`的运行依赖于从`manager-api`获取的动态配置（例如当前选用的AI服务提供商及其API密钥）。
+    *   **拉取机制 (Pull Mechanism):** `xiaozhi-server`内部的`config/manage_api_client.py`模块，在服务器启动时或通过特定更新触发器（例如`WebSocketServer.update_config()`被调用），会向`manager-api`的一个指定端点（例如由`modules/config/controller/`中的某个Controller提供）发起HTTP GET请求。
+    *   `manager-api`响应该请求，返回`xiaozhi-server`所需的配置数据（JSON格式）。
+    *   `xiaozhi-server`接收到配置后，会更新其内部状态，并可能重新初始化相关的AI服务模块，以使新配置生效。
+
+*   **OTA固件更新流程 (概念性描述):**
+    *   管理员通过`manager-web`界面上传新的ESP32固件包到`manager-api`的特定端点。
+    *   `manager-api`将固件文件存储起来，并记录相关元数据（版本号、适用设备型号等）。
+    *   当管理员触发对特定设备的OTA更新时：
+        *   `manager-api`可能会通知`xiaozhi-server`（具体通知机制可能是一个轮询检查点，或`xiaozhi-server`暴露一个接收更新通知的API，或者更松耦合的如消息队列）。
+        *   `xiaozhi-server`随后可以通过WebSocket向目标ESP32设备发送一条包含固件下载URL的指令消息。
+        *   ESP32设备收到指令后，通过HTTP GET请求从该URL下载固件。此URL可能指向`xiaozhi-server`自身运行的`SimpleHttpServer`所服务的路径（如`/xiaozhi/ota/`），或者在某些架构中，也可能直接指向`manager-api`或专用的文件服务器。
+
+**4.3. 主要协议总结:**
+
+*   **WebSocket:** 被选用于ESP32与`xiaozhi-server`之间的通信链路，因为它非常适合实时、低延迟、双向的数据流传输（尤其是音频），以及异步控制消息的传递。
+*   **RESTful APIs (基于HTTP/HTTPS，通常使用JSON作为数据交换格式):** 这是Web服务间通信的标准方式。用于`manager-web`（客户端）与`manager-api`（服务器）之间的请求-响应交互，也用于`xiaozhi-server`（作为客户端）从`manager-api`（作为服务器）拉取配置信息。其无状态特性、广泛的库支持和易于理解的语义使其成为此类交互的理想选择。
+
+这种多协议并用的通信策略，确保了系统内不同类型的交互需求都能得到高效和恰当的处理，兼顾了实时性和标准化的请求-响应模式。
+
+---
+
+## 5. 核心功能概要
+
+`xiaozhi-esp32-server` 系统提供了一系列丰富的功能，旨在支持开发者构建先进的语音控制应用：
+
+1.  **全面的语音交互后端:** 提供从语音捕获指导到响应生成和动作执行的端到端解决方案。
+2.  **模块化和可插拔的AI服务:**
+    *   支持广泛的ASR（自动语音识别）、LLM（大型语言模型）、TTS（文本转语音）、VAD（语音活动检测）、意图识别和记忆提供商。
+    *   允许动态选择和配置这些服务（包括基于云的API和本地模型），以平衡成本、性能、隐私和语言需求。
+3.  **高级对话管理:**
+    *   支持自然交互，具有唤醒词启动对话、手动（按键说话式）对话以及对系统响应的实时打断等功能。
+    *   包含上下文记忆，以在多轮对话中保持连贯性。
+    *   在一段时间不活动后具有自动休眠模式。
+4.  **多语言能力:**
+    *   支持多种语言的识别和合成，包括普通话、粤语、英语、日语和韩语（具体取决于所选的ASR/LLM/TTS提供商）。
+5.  **通过插件实现的可扩展功能:**
+    *   强大的插件系统允许开发人员添加自定义“技能”或函数（例如，获取天气、控制智能家居设备、访问新闻）。
+    *   这些函数可以由LLM使用其函数调用能力，根据提供的模式来触发。
+    *   内置对Home Assistant集成的支持。
+6.  **物联网设备控制:**
+    *   设计用于通过语音命令管理和控制智能家居设备及其他物联网硬件，并利用插件系统。
+7.  **基于Web的管理控制台 (`manager-web` & `manager-api`):**
+    *   提供全面的图形界面，用于：
+        *   系统配置（AI服务选择、API密钥、操作参数）。
+        *   基于角色的访问控制的用户管理。
+        *   ESP32设备注册和管理。
+        *   语音音色/TTS语音定制。
+        *   ESP32设备的OTA（空中下载）固件更新管理。
+        *   系统参数和字典的管理。
+8.  **灵活的部署选项:**
+    *   支持通过Docker容器（用于简化的仅服务器或全栈设置）和直接从源代码部署，以适应各种环境和用户专业知识。
+9.  **动态远程配置:**
+    *   `xiaozhi-server`可以从`manager-api`获取其配置，允许实时更新AI提供商和设置，而无需重新启动服务器。
+10. **开源和社区驱动:**
+    *   根据MIT许可证授权，鼓励透明、协作和社区贡献。
+11. **经济高效的解决方案:**
+    *   提供“入门全免费设置”路径，利用AI服务的免费套餐或本地模型，使其易于进行实验和个人项目。
+12. **渐进式Web应用 (PWA) 特性:**
+    *   `manager-web`控制面板包含Service Worker集成，以增强缓存和潜在的离线访问能力。
+13. **详细的API文档:**
+    *   `manager-api`通过Knife4j提供OpenAPI (Swagger) 文档，以便清晰理解和测试其RESTful端点。
+
+这些功能共同使`xiaozhi-esp32-server`成为一个强大、适应性强且用户友好的平台，用于构建复杂的语音交互应用程序。
+
+---
+
+## 6. 部署与配置概述
+
+`xiaozhi-esp32-server`系统在设计上充分考虑了灵活性，提供了多种部署方法和全面的配置选项，以适应不同的使用场景和需求。
+
+**部署选项:**
+
+项目可以通过多种方式部署，主要包括使用Docker简化安装过程，或直接从源代码部署以获得更大的控制权和进行开发。
+
+1.  **基于Docker的部署:**
+    *   **简化安装 (仅`xiaozhi-server`):** 此选项仅部署核心的基于Python的`xiaozhi-server`。它适用于主要需要语音AI处理能力和IoT控制，而不需要完整Web管理界面和数据库支持功能（如OTA）的用户。在此模式下，配置通常通过本地文件（`config.yaml`）管理，但如果需要，仍可将其指向一个已存在的`manager-api`实例。
+    *   **全模块安装 (所有组件):** 此方案部署所有核心组件：`xiaozhi-server`、基于Java的`manager-api`、以及基于Vue.js的`manager-web`，同时还包括所需的数据库服务（MySQL和Redis）。这提供了完整的系统体验，包括用于全面配置和管理的Web控制面板。
+    *   项目为每个服务提供了`Dockerfile`定义，并使用`docker-compose.yml`文件（例如`docker-compose.yml`用于基础版，`docker-compose_all.yml`用于全功能版）来编排和管理多容器的部署。此外，还可能提供一个`docker-setup.sh`脚本来辅助自动化部分Docker环境的搭建工作。
+
+2.  **源代码部署:**
+    *   这种方法需要为每个组件手动设置相应的开发环境：Python环境用于`xiaozhi-server`，Java/Maven环境用于`manager-api`，Node.js/Vue CLI环境用于`manager-web`。
+    *   对于全模块安装，还需要手动安装和配置MySQL及Redis数据库服务。
+    *   这种方式通常用于项目开发、深度定制、调试，或者在对环境有特殊要求的生产场景中。
+
+**配置管理:**
+
+配置是定制系统行为的关键，尤其是在选择AI服务提供商和管理API密钥方面。
+
+1.  **`xiaozhi-server` 配置:**
+    *   **本地`config.yaml`:** 位于`xiaozhi-server`根目录下的一个主要的YAML格式配置文件。它定义了服务器端口、选定的AI服务提供商（ASR、LLM、TTS、VAD、意图识别、记忆模块等）、它们各自的API密钥或模型路径、插件配置以及日志级别等。
+    *   **通过`manager-api`进行远程配置:** `xiaozhi-server`被设计为可以从`manager-api`获取其运行配置。从`manager-api`获取的设置通常会覆盖本地`config.yaml`中的同名设置。这带来了两大好处：
+        *   **集中管理:** 所有配置都可以通过`manager-web`界面进行统一管理。
+        *   **动态更新:** `xiaozhi-server`可以刷新其配置并重新初始化AI模块，而无需完全重启服务。
+    *   `xiaozhi-server`中的`config/config_loader.py`和`config/manage_api_client.py`负责处理配置的加载、合并及从`manager-api`拉取的逻辑。
+
+2.  **`manager-api` 配置:**
+    *   作为一个Spring Boot应用，其配置主要通过位于`src/main/resources`目录下的`application.properties`或`application.yml`文件进行管理。
+    *   关键配置项包括：数据库连接信息（MySQL的URL、用户名、密码）、Redis服务器地址和端口、应用服务端口（默认为8002）、Apache Shiro安全相关的设置，以及任何集成的第三方服务（如阿里云短信）的配置参数。
+
+3.  **`manager-web` 配置:**
+    *   Vue.js前端应用的环境特定设置通过项目根目录下的`.env`系列文件（例如`.env`, `.env.development`, `.env.production`）进行管理。
+    *   这里最关键的配置通常是`manager-api`后端的API基础URL地址 (例如 `VUE_APP_API_BASE_URL`)，前端应用将向此地址发送所有API请求。
+
+4.  **预定义的配置方案:**
+    *   项目文档（通常是README）中会推荐一些常见的配置组合，例如：
+        *   **“入门全免费设置”:** 该方案旨在利用云AI服务的免费套餐额度或完全免费的本地模型，以最大程度地降低用户的初始使用成本和运营费用。
+        *   **“全流式配置”:** 该方案优先考虑系统的响应速度和交互的流畅性，通常会选用支持流式处理的（可能付费的）AI服务。
+    *   这些预定义方案为用户在`xiaozhi-server`中配置AI服务提供商（通过`manager-web`界面或直接修改`config.yaml`）提供了指导。
+
+在全模块部署的情况下，推荐使用`manager-web`控制面板作为大多数配置任务的主要操作界面，因为它提供了一种用户友好的方式来管理由`manager-api`持久化并最终由`xiaozhi-server`使用的各项设置。
+
+---
@@ -227,7 +227,7 @@ public interface Constant {
    /**
     * 版本号
     */
-    public static final String VERSION = "0.5.4";
+    public static final String VERSION = "0.5.5";

    /**
     * 无效固件URL
@@ -0,0 +1,20 @@
+-- 增加LinkeraiTTS供应器和模型配置
+delete from `ai_model_provider` where id = 'SYSTEM_TTS_LinkeraiTTS';
+INSERT INTO `ai_model_provider` (`id`, `model_type`, `provider_code`, `name`, `fields`, `sort`, `creator`, `create_date`, `updater`, `update_date`) VALUES
+('SYSTEM_TTS_LinkeraiTTS', 'TTS', 'linkerai', 'Linkerai语音合成', '[{"key":"api_url","label":"API地址","type":"string"},{"key":"audio_format","label":"音频格式","type":"string"},{"key":"access_token","label":"访问令牌","type":"string"},{"key":"voice","label":"默认音色","type":"string"}]', 14, 1, NOW(), 1, NOW());
+
+delete from `ai_model_config` where id = 'TTS_LinkeraiTTS';
+INSERT INTO `ai_model_config` VALUES ('TTS_LinkeraiTTS', 'TTS', 'LinkeraiTTS', 'Linkerai语音合成', 0, 1, '{\"type\": \"linkerai\", \"api_url\": \"https://tts.linkerai.cn/tts\", \"audio_format\": \"pcm\", \"access_token\": \"U4YdYXVfpwWnk2t5Gp822zWPCuORyeJL\", \"voice\": \"OUeAo1mhq6IBExi\"}', NULL, NULL, 17, NULL, NULL, NULL, NULL);
+
+-- LinkeraiTTS模型配置说明文档
+UPDATE `ai_model_config` SET 
+`doc_link` = 'https://tts.linkerai.cn/docs',
+`remark` = 'Linkerai语音合成服务配置说明：
+1. 访问 https://linkerai.cn 注册并获取访问令牌
+2. 默认的access_token供测试使用，请勿用于商业用途
+3. 支持声音克隆功能，可自行上传音频，填入voice参数
+4. 如果voice参数为空，将使用默认声音' WHERE `id` = 'TTS_LinkeraiTTS';
+
+
+delete from `ai_tts_voice` where tts_model_id = 'TTS_LinkeraiTTS';
+INSERT INTO `ai_tts_voice` VALUES ('TTS_LinkeraiTTS_0001', 'TTS_LinkeraiTTS', '芷若', 'OUeAo1mhq6IBExi', '中文', NULL, NULL, 1, NULL, NULL, NULL, NULL);
@@ -0,0 +1,3 @@
+-- 智控台开启唤醒词加速
+update `sys_params` set param_value = '你好小智;你好小志;小爱同学;你好小鑫;你好小新;小美同学;小龙小龙;喵喵同学;小滨小滨;小冰小冰;嘿你好呀' where param_code = 'wakeup_words';
+update `sys_params` set param_value = 'true' where param_code = 'enable_wakeup_words_response_cache';
@@ -190,4 +190,18 @@ databaseChangeLog:
      changes:
        - sqlFile:
            encoding: utf8
-            path: classpath:db/changelog/202506032232.sql
+            path: classpath:db/changelog/202506032232.sql
+  - changeSet:
+      id: 202506051538
+      author: hrz
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202506051538.sql
+  - changeSet:
+      id: 202506080955
+      author: hrz
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202506080955.sql
@@ -324,7 +324,7 @@ VAD:
    type: silero
    threshold: 0.5
    model_dir: models/snakers4_silero-vad
-    min_silence_duration_ms: 700  # 如果说话停顿比较长，可以把这个值设置大一些
+    min_silence_duration_ms: 200  # 如果说话停顿比较长，可以把这个值设置大一些

 LLM:
  # 所有openai类型均可以修改超参，以AliLLM为例
@@ -755,4 +755,15 @@ TTS:
    headers: # 自定义请求头
      # Authorization: Bearer xxxx
    format: mp3 # 接口返回的音频格式
+    output_dir: tmp/
+  LinkeraiTTS:
+    type: linkerai
+    api_url: https://tts.linkerai.cn/tts
+    audio_format: "pcm"
+    # 默认的access_token供大家测试时免费使用的，此access_token请勿用于商业用途
+    # 如果效果不错，可自行申请token，申请地址：https://linkerai.cn
+    # 各参数意义见开发文档：https://tts.linkerai.cn/docs
+    # 支持声音克隆，可自行上传音频，填入voice参数，voice参数为空时，使用默认声音
+    access_token: "U4YdYXVfpwWnk2t5Gp822zWPCuORyeJL"
+    voice: "OUeAo1mhq6IBExi"
    output_dir: tmp/
@@ -3,8 +3,9 @@ import sys
 from loguru import logger
 from config.config_loader import load_config
 from config.settings import check_config_file
+from datetime import datetime

-SERVER_VERSION = "0.5.4"
+SERVER_VERSION = "0.5.5"
 _logger_initialized = False


@@ -59,7 +60,7 @@ def setup_logging():
        )
        log_format_file = log_config.get(
            "log_format_file",
-            "{time:YYYY-MM-DD HH:mm:ss} - {version_{extra[selected_module]}} - {name} - {level} - {extra[tag]} - {message}",
+            "{time:YYYY-MM-DD HH:mm:ss} - {version}_{extra[selected_module]} - {name} - {level} - {extra[tag]} - {message}",
        )
        selected_module_str = logger._core.extra["selected_module"]

@@ -84,12 +85,23 @@ def setup_logging():
        # 输出到控制台
        logger.add(sys.stdout, format=log_format, level=log_level, filter=formatter)

-        # 输出到文件
+        # 输出到文件 - 统一目录，按大小轮转
+        # 日志文件完整路径
+        log_file_path = os.path.join(log_dir, log_file)
+        
+        # 添加日志处理器
        logger.add(
-            os.path.join(log_dir, log_file),
+            log_file_path,
            format=log_format_file,
            level=log_level,
            filter=formatter,
+            rotation="10 MB",  # 每个文件最大10MB
+            retention="30 days",  # 保留30天
+            compression=None,
+            encoding="utf-8",
+            enqueue=True,  # 异步安全
+            backtrace=True,
+            diagnose=True,
        )
        _logger_initialized = True  # 标记为已初始化

@@ -116,7 +128,7 @@ def update_module_string(selected_module_str):
        )
        log_format_file = log_config.get(
            "log_format_file",
-            "{time:YYYY-MM-DD HH:mm:ss} - {version_{extra[selected_module]}} - {name} - {level} - {extra[tag]} - {message}",
+            "{time:YYYY-MM-DD HH:mm:ss} - {version}_{extra[selected_module]} - {name} - {level} - {extra[tag]} - {message}",
        )

        log_format = log_format.replace("{version}", SERVER_VERSION)
@@ -133,14 +145,26 @@ def update_module_string(selected_module_str):
            level=log_config.get("log_level", "INFO"),
            filter=formatter,
        )
+        
+        # 更新文件日志配置 - 统一目录，按大小轮转
+        log_dir = log_config.get("log_dir", "tmp")
+        log_file = log_config.get("log_file", "server.log")
+        
+        # 日志文件完整路径
+        log_file_path = os.path.join(log_dir, log_file)
+        
        logger.add(
-            os.path.join(
-                log_config.get("log_dir", "tmp"),
-                log_config.get("log_file", "server.log"),
-            ),
+            log_file_path,
            format=log_format_file,
            level=log_config.get("log_level", "INFO"),
            filter=formatter,
+            rotation="10 MB",  # 每个文件最大10MB
+            retention="30 days",  # 保留30天
+            compression=None,
+            encoding="utf-8",
+            enqueue=True,  # 异步安全
+            backtrace=True,
+            diagnose=True,
        )

    except Exception as e:
@@ -651,7 +651,7 @@ class ConnectionHandler:
                    # print("content_arguments", content_arguments)
                    tool_call_flag = True

-                if tools_call is not None:
+                if tools_call is not None and len(tools_call) > 0:
                    tool_call_flag = True
                    if tools_call[0].id is not None:
                        function_id = tools_call[0].id
@@ -1,30 +1,31 @@
-import os
 import time
 import json
 import random
-import shutil
 import asyncio
-from core.handle.sendAudioHandle import send_stt_message
-from core.utils.util import remove_punctuation_and_length
-from core.providers.tts.dto.dto import ContentType, InterfaceType
+from core.utils.util import audio_to_data
+from core.handle.sendAudioHandle import sendAudioMessage, send_stt_message
+from core.utils.util import remove_punctuation_and_length, opus_datas_to_wav_bytes
+from core.providers.tts.dto.dto import ContentType, SentenceType
 from core.handle.mcpHandle import (
    MCPClient,
    send_mcp_initialize_message,
    send_mcp_tools_list_request,
 )
-
+from core.utils.wakeup_word import WakeupWordsConfig

 TAG = __name__

 WAKEUP_CONFIG = {
-    "dir": "config/assets/",
-    "file_name": "wakeup_words",
-    "create_time": time.time(),
-    "refresh_time": 10,
-    "words": ["你好小智", "你好啊小智", "小智你好", "小智"],
-    "text": "",
+    "refresh_time": 5,
+    "words": ["你好", "你好啊", "嘿，你好", "嗨"],
 }

+# 创建全局的唤醒词配置管理器
+wakeup_words_config = WakeupWordsConfig()
+
+# 用于防止并发调用wakeupWordsResponse的锁
+_wakeup_response_lock = asyncio.Lock()
+

 async def handleHelloMessage(conn, msg_json):
    """处理hello消息"""
@@ -53,85 +54,75 @@ async def checkWakeupWords(conn, text):
    enable_wakeup_words_response_cache = conn.config[
        "enable_wakeup_words_response_cache"
    ]
-    """是否用的是非流式tts"""
-    if conn.tts and conn.tts.interface_type != InterfaceType.NON_STREAM:
+
+    if not enable_wakeup_words_response_cache or not conn.tts:
        return False

-    """是否开启唤醒词加速"""
-    if not enable_wakeup_words_response_cache:
-        return False
-    """检查是否是唤醒词"""
    _, filtered_text = remove_punctuation_and_length(text)
-    if filtered_text in conn.config.get("wakeup_words"):
-        # 设置刚刚被唤醒的标志
-        conn.just_woken_up = True
-        await send_stt_message(conn, text)
+    if filtered_text not in conn.config.get("wakeup_words"):
+        return False

-        file = getWakeupWordFile(WAKEUP_CONFIG["file_name"])
-        if file is None:
+    conn.just_woken_up = True
+    await send_stt_message(conn, text)
+
+    # 获取当前音色
+    voice = getattr(conn.tts, "voice", "default")
+
+    # 获取唤醒词回复配置
+    response = wakeup_words_config.get_wakeup_response(voice)
+
+    # 播放唤醒词回复
+    conn.client_abort = False
+    opus_packets, _ = audio_to_data(response["file_path"])
+
+    conn.logger.bind(tag=TAG).info(f"播放唤醒词回复: {response['text']}")
+    await sendAudioMessage(conn, SentenceType.FIRST, opus_packets, response["text"])
+    await sendAudioMessage(conn, SentenceType.LAST, [], None)
+
+    # 检查是否需要更新唤醒词回复
+    if time.time() - response["time"] > WAKEUP_CONFIG["refresh_time"]:
+        if not _wakeup_response_lock.locked():
            asyncio.create_task(wakeupWordsResponse(conn))
-            return False
-        text_hello = WAKEUP_CONFIG["text"]
-        if not text_hello:
-            text_hello = text
-        if conn.tts is None:
-            return False
-        conn.tts.tts_one_sentence(
-            conn, ContentType.FILE, content_file=file, content_detail=text_hello
-        )
-        if time.time() - WAKEUP_CONFIG["create_time"] > WAKEUP_CONFIG["refresh_time"]:
-            asyncio.create_task(wakeupWordsResponse(conn))
-        return True
-    return False
-
-
-def getWakeupWordFile(file_name):
-    for file in os.listdir(WAKEUP_CONFIG["dir"]):
-        if file.startswith("my_" + file_name):
-            """避免缓存文件是一个空文件"""
-            if os.stat(f"config/assets/{file}").st_size > (15 * 1024):
-                return f"config/assets/{file}"
-
-    """查找config/assets/目录下名称为wakeup_words的文件"""
-    for file in os.listdir(WAKEUP_CONFIG["dir"]):
-        if file.startswith(file_name):
-            return f"config/assets/{file}"
-    return None
+    return True


 async def wakeupWordsResponse(conn):
-    wait_max_time = 5
-    while conn.llm is None or not conn.llm.response_no_stream:
-        await asyncio.sleep(1)
-        wait_max_time -= 1
-        if wait_max_time <= 0:
-            conn.logger.bind(tag=TAG).error("连接对象没有llm")
+    if not conn.tts or not conn.llm or not conn.llm.response_no_stream:
+        return
+
+    try:
+        # 尝试获取锁，如果获取不到就返回
+        if not await _wakeup_response_lock.acquire():
            return

-    """唤醒词响应"""
-    wakeup_word = random.choice(WAKEUP_CONFIG["words"])
-    question = (
-        "此刻用户正在和你说```"
-        + wakeup_word
-        + "```。\n请你根据以上用户的内容，进行简短回复，文字内容控制在15个字以内。\n"
-        + "请勿对这条内容本身进行任何解释和回应，仅返回对用户的内容的回复。"
-    )
-    result = conn.llm.response_no_stream(conn.config["prompt"], question)
-    if result is None or result == "":
-        return
-    tts_file = await asyncio.to_thread(conn.tts.to_tts, result)
-
-    if tts_file is not None and os.path.exists(tts_file):
-        file_type = os.path.splitext(tts_file)[1]
-        if file_type:
-            file_type = file_type.lstrip(".")
-        old_file = getWakeupWordFile("my_" + WAKEUP_CONFIG["file_name"])
-        if old_file is not None:
-            os.remove(old_file)
-        """将文件挪到"wakeup_words.mp3"""
-        shutil.move(
-            tts_file,
-            WAKEUP_CONFIG["dir"] + "my_" + WAKEUP_CONFIG["file_name"] + "." + file_type,
+        # 生成唤醒词回复
+        wakeup_word = random.choice(WAKEUP_CONFIG["words"])
+        question = (
+            "此刻用户正在和你说```"
+            + wakeup_word
+            + "```。\n请你根据以上用户的内容进行简短回复。要像一个人正常人一样说话，不要像机器人一样说话。\n"
+            + "请勿对这条内容本身进行任何解释和回应，请勿返回表情符号，仅返回对用户的内容的回复。"
        )
-        WAKEUP_CONFIG["create_time"] = time.time()
-        WAKEUP_CONFIG["text"] = result
+
+        result = conn.llm.response_no_stream(conn.config["prompt"], question)
+        if not result or len(result) == 0:
+            return
+
+        # 生成TTS音频
+        tts_result = await asyncio.to_thread(conn.tts.to_tts, result)
+        if not tts_result:
+            return
+
+        # 获取当前音色
+        voice = getattr(conn.tts, "voice", "default")
+
+        wav_bytes = opus_datas_to_wav_bytes(tts_result, sample_rate=16000)
+        file_path = wakeup_words_config.generate_file_path(voice)
+        with open(file_path, "wb") as f:
+            f.write(wav_bytes)
+        # 更新配置
+        wakeup_words_config.update_wakeup_response(voice, file_path, result)
+    finally:
+        # 确保在任何情况下都释放锁
+        if _wakeup_response_lock.locked():
+            _wakeup_response_lock.release()
@@ -1,7 +1,7 @@
 import json
 import asyncio
 from concurrent.futures import Future
-from core.utils.util import get_vision_url
+from core.utils.util import get_vision_url, sanitize_tool_name
 from core.utils.auth import AuthToken

 TAG = __name__
@@ -11,7 +11,8 @@ class MCPClient:
    """MCPClient，用于管理MCP状态和工具"""

    def __init__(self):
-        self.tools = {}  # Dictionary for O(1) lookup
+        self.tools = {}  # sanitized_name -> tool_data
+        self.name_mapping = {}
        self.ready = False
        self.call_results = {}  # To store Futures for tool call responses
        self.next_id = 1
@@ -30,7 +31,7 @@ class MCPClient:
        result = []
        for tool_name, tool_data in self.tools.items():
            function_def = {
-                "name": tool_data["name"],
+                "name": tool_name,
                "description": tool_data["description"],
                "parameters": {
                    "type": tool_data["inputSchema"].get("type", "object"),
@@ -53,7 +54,9 @@ class MCPClient:

    async def add_tool(self, tool_data: dict):
        async with self.lock:
-            self.tools[tool_data["name"]] = tool_data
+            sanitized_name = sanitize_tool_name(tool_data["name"])
+            self.tools[sanitized_name] = tool_data
+            self.name_mapping[sanitized_name] = tool_data["name"]
            self._cached_available_tools = (
                None  # Invalidate the cache when a tool is added
            )
@@ -133,9 +136,6 @@ async def handle_mcp_message(conn, mcp_client: MCPClient, payload: dict):
                conn.logger.bind(tag=TAG).info(
                    f"客户端MCP服务器信息: name={name}, version={version}"
                )
-            await send_mcp_tools_list_request(
-                conn
-            )  # After initialization, request tool list
            return

        elif msg_id == 2:  # mcpToolsListID
@@ -174,6 +174,20 @@ async def handle_mcp_message(conn, mcp_client: MCPClient, payload: dict):
                    await mcp_client.add_tool(new_tool)
                    conn.logger.bind(tag=TAG).debug(f"客户端工具 #{i+1}: {name}")

+                # 替换所有工具描述中的工具名称
+                for tool_data in mcp_client.tools.values():
+                    if "description" in tool_data:
+                        description = tool_data["description"]
+                        # 遍历所有工具名称进行替换
+                        for (
+                            sanitized_name,
+                            original_name,
+                        ) in mcp_client.name_mapping.items():
+                            description = description.replace(
+                                original_name, sanitized_name
+                            )
+                        tool_data["description"] = description
+
                next_cursor = result.get("nextCursor", "")
                if next_cursor:
                    conn.logger.bind(tag=TAG).info(
@@ -219,8 +233,6 @@ async def send_mcp_initialize_message(conn):
        "token": token,
    }

-    conn.logger.bind(tag=TAG).info(f"视觉服务信息: {vision}")
-
    payload = {
        "jsonrpc": "2.0",
        "id": 1,  # mcpInitializeID
@@ -333,15 +345,16 @@ async def call_mcp_tool(
            raise ValueError(f"参数处理失败: {str(e)}")
        raise e

+    actual_name = mcp_client.name_mapping.get(tool_name, tool_name)
    payload = {
        "jsonrpc": "2.0",
        "id": tool_call_id,
        "method": "tools/call",
-        "params": {"name": tool_name, "arguments": arguments},
+        "params": {"name": actual_name, "arguments": arguments},
    }

    conn.logger.bind(tag=TAG).info(
-        f"发送客户端mcp工具调用请求: {tool_name}，参数: {args}"
+        f"发送客户端mcp工具调用请求: {actual_name}，参数: {args}"
    )
    await send_mcp_message(conn, payload)

@@ -349,7 +362,7 @@ async def call_mcp_tool(
        # Wait for response or timeout
        raw_result = await asyncio.wait_for(result_future, timeout=timeout)
        conn.logger.bind(tag=TAG).info(
-            f"客户端mcp工具调用 {tool_name} 成功，原始结果: {raw_result}"
+            f"客户端mcp工具调用 {actual_name} 成功，原始结果: {raw_result}"
        )

        if isinstance(raw_result, dict):
@@ -13,12 +13,14 @@ TAG = __name__
 async def handleAudioMessage(conn, audio):
    # 当前片段是否有人说话
    have_voice = conn.vad.is_vad(conn, audio)
-
    # 如果设备刚刚被唤醒，短暂忽略VAD检测
-    if hasattr(conn, "just_woken_up") and conn.just_woken_up:
+    if have_voice and hasattr(conn, "just_woken_up") and conn.just_woken_up:
        have_voice = False
        # 设置一个短暂延迟后恢复VAD检测
-        asyncio.create_task(resume_vad_detection(conn))
+        conn.asr_audio.clear()
+        if not hasattr(conn, "vad_resume_task") or conn.vad_resume_task.done():
+            conn.vad_resume_task = asyncio.create_task(resume_vad_detection(conn))
+        return

    if have_voice:
        if conn.client_is_speaking:
@@ -31,7 +33,7 @@ async def handleAudioMessage(conn, audio):

 async def resume_vad_detection(conn):
    # 等待2秒后恢复VAD检测
-    await asyncio.sleep(2)
+    await asyncio.sleep(1)
    conn.just_woken_up = False


@@ -34,6 +34,7 @@ emoji_map = {

 async def sendAudioMessage(conn, sentenceType, audios, text):
    # 发送句子开始消息
+    conn.logger.bind(tag=TAG).info(f"发送音频消息: {sentenceType}, {text}")
    if text is not None:
        emotion = analyze_emotion(text)
        emoji = emoji_map.get(emotion, "🙂")  # 默认使用笑脸
@@ -9,6 +9,7 @@ from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
 from mcp.client.sse import sse_client
 from config.logger import setup_logging
+from core.utils.util import sanitize_tool_name

 TAG = __name__

@@ -23,7 +24,9 @@ class MCPClient:
        self._shutdown_evt = asyncio.Event()

        self.session: Optional[ClientSession] = None
-        self.tools: List = []
+        self.tools: List = []  # original tool objects
+        self.tools_dict: Dict[str, Any] = {}
+        self.name_mapping: Dict[str, str] = {}

    async def initialize(self):
        if self._worker_task:
@@ -32,7 +35,7 @@ class MCPClient:
        await self._ready_evt.wait()

        self.logger.bind(tag=TAG).info(
-            f"Connected, tools = {[t.name for t in self.tools]}"
+            f"Connected, tools = {[name for name in self.name_mapping.values()]}"
        )

    async def cleanup(self):
@@ -48,27 +51,28 @@ class MCPClient:
            self._worker_task = None

    def has_tool(self, name: str) -> bool:
-        return any(t.name == name for t in self.tools)
+        return name in self.tools_dict

    def get_available_tools(self):
        return [
            {
                "type": "function",
                "function": {
-                    "name": t.name,
-                    "description": t.description,
-                    "parameters": t.inputSchema,
+                    "name": name,
+                    "description": tool.description,
+                    "parameters": tool.inputSchema,
                },
            }
-            for t in self.tools
+            for name, tool in self.tools_dict.items()
        ]

    async def call_tool(self, name: str, args: dict):
        if not self.session:
            raise RuntimeError("MCPClient not initialized")

+        real_name = self.name_mapping.get(name, name)
        loop = self._worker_task.get_loop()
-        coro = self.session.call_tool(name, args)
+        coro = self.session.call_tool(real_name, args)

        if loop is asyncio.get_running_loop():
            return await coro
@@ -123,6 +127,10 @@ class MCPClient:

                # 获取工具
                self.tools = (await self.session.list_tools()).tools
+                for t in self.tools:
+                    sanitized = sanitize_tool_name(t.name)
+                    self.tools_dict[sanitized] = t
+                    self.name_mapping[sanitized] = t.name

                self._ready_evt.set()

@@ -168,6 +168,7 @@ class ASRProvider(ASRProviderBase):
                if (
                    "payload_msg" in result
                    and result["payload_msg"]["code"] != self.success_code
+                    and result["payload_msg"]["code"] != 1013  # 忽略无有效语音的错误
                ):
                    logger.bind(tag=TAG).error(f"ASR error: {result}")
                    return None
@@ -203,6 +204,9 @@ class ASRProvider(ASRProviderBase):
                    if len(result["payload_msg"]["result"]) > 0:
                        return result["payload_msg"]["result"][0]["text"]
                    return None
+                elif "payload_msg" in result and result["payload_msg"]["code"] == 1013:
+                    # 无有效语音，返回空字符串
+                    return ""
                else:
                    logger.bind(tag=TAG).error(f"ASR error: {result}")
                    return None
@@ -157,6 +157,11 @@ class ASRProvider(ASRProviderBase):

                    if "payload_msg" in result:
                        payload = result["payload_msg"]
+                        # 检查是否是错误码1013（无有效语音）
+                        if "code" in payload and payload["code"] == 1013:
+                            # 静默处理，不记录错误日志
+                            continue
+
                        if "result" in payload:
                            utterances = payload["result"].get("utterances", [])
                            # 检查duration和空文本的情况
@@ -2,6 +2,7 @@ import time
 import os
 import sys
 import io
+import psutil
 from config.logger import setup_logging
 from typing import Optional, Tuple, List
 from core.providers.asr.base import ASRProviderBase
@@ -37,6 +38,13 @@ class CaptureOutput:
 class ASRProvider(ASRProviderBase):
    def __init__(self, config: dict, delete_audio_file: bool):
        super().__init__()
+        
+        # 内存检测，要求大于2G
+        min_mem_bytes = 2 * 1024 * 1024 * 1024
+        total_mem = psutil.virtual_memory().total
+        if total_mem < min_mem_bytes:
+            logger.bind(tag=TAG).error(f"可用内存不足2G，当前仅有 {total_mem / (1024*1024):.2f} MB，可能无法启动FunASR")
+        
        self.interface_type = InterfaceType.LOCAL
        self.model_dir = config.get("model_dir")
        self.output_dir = config.get("output_dir")  # 修正配置键名
@@ -91,7 +91,7 @@ class TTSProvider(TTSProviderBase):

        self.appkey = config.get("appkey")
        self.format = config.get("format", "wav")
-
+        self.audio_file_type = config.get("format", "wav")
        sample_rate = config.get("sample_rate", "16000")
        self.sample_rate = int(sample_rate) if sample_rate else 16000

@@ -188,9 +188,12 @@ class TTSProvider(TTSProviderBase):
                )
            # 检查返回请求数据的mime类型是否是audio/***，是则保存到指定路径下；返回的是binary格式的
            if resp.headers["Content-Type"].startswith("audio/"):
-                with open(output_file, "wb") as f:
-                    f.write(resp.content)
-                return output_file
+                if output_file:
+                    with open(output_file, "wb") as f:
+                        f.write(resp.content)
+                    return output_file
+                else:
+                    return resp.content
            else:
                raise Exception(
                    f"{__name__} status_code: {resp.status_code} response: {resp.content}"
@@ -8,7 +8,7 @@ from datetime import datetime
 from core.utils import textUtils
 from abc import ABC, abstractmethod
 from config.logger import setup_logging
-from core.utils.util import audio_to_data
+from core.utils.util import audio_to_data, audio_bytes_to_data
 from core.utils.tts import MarkdownCleaner
 from core.utils.output_counter import add_device_output
 from core.handle.reportHandle import enqueue_tts_report
@@ -20,7 +20,6 @@ from core.providers.tts.dto.dto import (
    InterfaceType,
 )

-
 import traceback

 TAG = __name__
@@ -33,10 +32,12 @@ class TTSProviderBase(ABC):
        self.conn = None
        self.tts_timeout = 10
        self.delete_audio_file = delete_audio_file
+        self.audio_file_type = "wav"
        self.output_file = config.get("output_dir", "tmp/")
        self.tts_text_queue = queue.Queue()
        self.tts_audio_queue = queue.Queue()
        self.tts_audio_first_sentence = True
+        self.before_stop_play_files = []

        self.tts_text_buff = []
        self.punctuations = (
@@ -77,35 +78,62 @@ class TTSProviderBase(ABC):
        )

    def to_tts(self, text):
-        tmp_file = self.generate_filename()
-        try:
-            max_repeat_time = 5
-            text = MarkdownCleaner.clean_markdown(text)
-            while not os.path.exists(tmp_file) and max_repeat_time > 0:
+        text = MarkdownCleaner.clean_markdown(text)
+        max_repeat_time = 5
+        if self.delete_audio_file:
+            # 需要删除文件的直接转为音频数据
+            while max_repeat_time > 0:
                try:
-                    asyncio.run(self.text_to_speak(text, tmp_file))
+                    audio_bytes = asyncio.run(self.text_to_speak(text, None))
+                    if audio_bytes:
+                        audio_datas, _ = audio_bytes_to_data(
+                            audio_bytes, file_type=self.audio_file_type, is_opus=True
+                        )
+                        return audio_datas
+                    else:
+                        max_repeat_time -= 1
                except Exception as e:
                    logger.bind(tag=TAG).warning(
                        f"语音生成失败{5 - max_repeat_time + 1}次: {text}，错误: {e}"
                    )
-                    # 未执行成功，删除文件
-                    if os.path.exists(tmp_file):
-                        os.remove(tmp_file)
                    max_repeat_time -= 1
-
            if max_repeat_time > 0:
                logger.bind(tag=TAG).info(
-                    f"语音生成成功: {text}:{tmp_file}，重试{5 - max_repeat_time}次"
+                    f"语音生成成功: {text}，重试{5 - max_repeat_time}次"
                )
            else:
                logger.bind(tag=TAG).error(
                    f"语音生成失败: {text}，请检查网络或服务是否正常"
                )
-
-            return tmp_file
-        except Exception as e:
-            logger.bind(tag=TAG).error(f"Failed to generate TTS file: {e}")
            return None
+        else:
+            tmp_file = self.generate_filename()
+            try:
+                while not os.path.exists(tmp_file) and max_repeat_time > 0:
+                    try:
+                        asyncio.run(self.text_to_speak(text, tmp_file))
+                    except Exception as e:
+                        logger.bind(tag=TAG).warning(
+                            f"语音生成失败{5 - max_repeat_time + 1}次: {text}，错误: {e}"
+                        )
+                        # 未执行成功，删除文件
+                        if os.path.exists(tmp_file):
+                            os.remove(tmp_file)
+                        max_repeat_time -= 1
+
+                if max_repeat_time > 0:
+                    logger.bind(tag=TAG).info(
+                        f"语音生成成功: {text}:{tmp_file}，重试{5 - max_repeat_time}次"
+                    )
+                else:
+                    logger.bind(tag=TAG).error(
+                        f"语音生成失败: {text}，请检查网络或服务是否正常"
+                    )
+
+                return tmp_file
+            except Exception as e:
+                logger.bind(tag=TAG).error(f"Failed to generate TTS file: {e}")
+                return None

    @abstractmethod
    async def text_to_speak(self, text, output_file):
@@ -193,12 +221,19 @@ class TTSProviderBase(ABC):
                    self.tts_text_buff.append(message.content_detail)
                    segment_text = self._get_segment_text()
                    if segment_text:
-                        tts_file = self.to_tts(segment_text)
-                        if tts_file:
-                            audio_datas = self._process_audio_file(tts_file)
-                            self.tts_audio_queue.put(
-                                (message.sentence_type, audio_datas, segment_text)
-                            )
+                        if self.delete_audio_file:
+                            audio_datas = self.to_tts(segment_text)
+                            if audio_datas:
+                                self.tts_audio_queue.put(
+                                    (message.sentence_type, audio_datas, segment_text)
+                                )
+                        else:
+                            tts_file = self.to_tts(segment_text)
+                            if tts_file:
+                                audio_datas = self._process_audio_file(tts_file)
+                                self.tts_audio_queue.put(
+                                    (message.sentence_type, audio_datas, segment_text)
+                                )
                elif ContentType.FILE == message.content_type:
                    self._process_remaining_text()
                    tts_file = message.content_file
@@ -324,6 +359,14 @@ class TTSProviderBase(ABC):
            os.remove(tts_file)
        return audio_datas

+    def _process_before_stop_play_files(self):
+        for tts_file, text in self.before_stop_play_files:
+            if tts_file and os.path.exists(tts_file):
+                audio_datas = self._process_audio_file(tts_file)
+                self.tts_audio_queue.put((SentenceType.MIDDLE, audio_datas, text))
+        self.before_stop_play_files.clear()
+        self.tts_audio_queue.put((SentenceType.LAST, [], None))
+
    def _process_remaining_text(self):
        """处理剩余的文本并生成语音

@@ -335,11 +378,18 @@ class TTSProviderBase(ABC):
        if remaining_text:
            segment_text = textUtils.get_string_no_punctuation_or_emoji(remaining_text)
            if segment_text:
-                tts_file = self.to_tts(segment_text)
-                audio_datas = self._process_audio_file(tts_file)
-                self.tts_audio_queue.put(
-                    (SentenceType.MIDDLE, audio_datas, segment_text)
-                )
+                if self.delete_audio_file:
+                    audio_datas = self.to_tts(segment_text)
+                    if audio_datas:
+                        self.tts_audio_queue.put(
+                            (SentenceType.MIDDLE, audio_datas, segment_text)
+                        )
+                else:
+                    tts_file = self.to_tts(segment_text)
+                    audio_datas = self._process_audio_file(tts_file)
+                    self.tts_audio_queue.put(
+                        (SentenceType.MIDDLE, audio_datas, segment_text)
+                    )
                self.processed_chars += len(full_text)
                return True
        return False
@@ -11,8 +11,8 @@ class TTSProvider(TTSProviderBase):
            self.voice = config.get("private_voice")
        else:
            self.voice = config.get("voice")
-        self.response_format = config.get("response_format")
-
+        self.response_format = config.get("response_format", "mp3")
+        self.audio_file_type = config.get("response_format", "mp3")
        self.host = "api.coze.cn"
        self.api_url = f"https://{self.host}/v1/audio/speech"

@@ -33,7 +33,10 @@ class TTSProvider(TTSProviderBase):
                "POST", self.api_url, json=request_json, headers=headers
            )
            data = response.content
-            file_to_save = open(output_file, "wb")
-            file_to_save.write(data)
+            if output_file:
+                with open(output_file, "wb") as file_to_save:
+                    file_to_save.write(data)
+            else:
+                return data
        except Exception as e:
            raise Exception(f"{__name__} error: {e}")
@@ -16,8 +16,8 @@ class TTSProvider(TTSProviderBase):
        self.method = config.get("method", "GET")
        self.headers = config.get("headers", {})
        self.format = config.get("format", "wav")
+        self.audio_file_type = config.get("format", "wav")
        self.output_file = config.get("output_dir", "tmp/")
-
        self.params = config.get("params")

        if isinstance(self.params, str):
@@ -43,8 +43,11 @@ class TTSProvider(TTSProviderBase):
        else:
            resp = requests.get(self.url, params=request_params, headers=self.headers)
        if resp.status_code == 200:
-            with open(output_file, "wb") as file:
-                file.write(resp.content)
+            if output_file:
+                with open(output_file, "wb") as file:
+                    file.write(resp.content)
+            else:
+                return resp.content
        else:
            error_msg = f"Custom TTS请求失败: {resp.status_code} - {resp.text}"
            logger.bind(tag=TAG).error(error_msg)
@@ -29,7 +29,7 @@ class TTSProvider(TTSProviderBase):
        speed_ratio = config.get("speed_ratio", "1.0")
        volume_ratio = config.get("volume_ratio", "1.0")
        pitch_ratio = config.get("pitch_ratio", "1.0")
-
+        self.audio_file_type = config.get("format", "wav")
        self.speed_ratio = float(speed_ratio) if speed_ratio else 1.0
        self.volume_ratio = float(volume_ratio) if volume_ratio else 1.0
        self.pitch_ratio = float(pitch_ratio) if pitch_ratio else 1.0
@@ -49,7 +49,7 @@ class TTSProvider(TTSProviderBase):
            "user": {"uid": "1"},
            "audio": {
                "voice_type": self.voice,
-                "encoding": "wav",
+                "encoding": self.audio_file_type,
                "speed_ratio": self.speed_ratio,
                "volume_ratio": self.volume_ratio,
                "pitch_ratio": self.pitch_ratio,
@@ -70,8 +70,12 @@ class TTSProvider(TTSProviderBase):
            )
            if "data" in resp.json():
                data = resp.json()["data"]
-                file_to_save = open(output_file, "wb")
-                file_to_save.write(base64.b64decode(data))
+                audio_bytes = base64.b64decode(data)
+                if output_file:
+                    with open(output_file, "wb") as file_to_save:
+                        file_to_save.write(audio_bytes)
+                else:
+                    return audio_bytes
            else:
                raise Exception(
                    f"{__name__} status_code: {resp.status_code} response: {resp.content}"
@@ -12,6 +12,7 @@ class TTSProvider(TTSProviderBase):
            self.voice = config.get("private_voice")
        else:
            self.voice = config.get("voice")
+        self.audio_file_type = config.get("format", "mp3")

    def generate_filename(self, extension=".mp3"):
        return os.path.join(
@@ -22,16 +23,24 @@ class TTSProvider(TTSProviderBase):
    async def text_to_speak(self, text, output_file):
        try:
            communicate = edge_tts.Communicate(text, voice=self.voice)
-            # 确保目录存在并创建空文件
-            os.makedirs(os.path.dirname(output_file), exist_ok=True)
-            with open(output_file, "wb") as f:
-                pass
+            if output_file:
+                # 确保目录存在并创建空文件
+                os.makedirs(os.path.dirname(output_file), exist_ok=True)
+                with open(output_file, "wb") as f:
+                    pass

-            # 流式写入音频数据
-            with open(output_file, "ab") as f:  # 改为追加模式避免覆盖
+                # 流式写入音频数据
+                with open(output_file, "ab") as f:  # 改为追加模式避免覆盖
+                    async for chunk in communicate.stream():
+                        if chunk["type"] == "audio":  # 只处理音频数据块
+                            f.write(chunk["data"])
+            else:
+                # 返回音频二进制数据
+                audio_bytes = b""
                async for chunk in communicate.stream():
-                    if chunk["type"] == "audio":  # 只处理音频数据块
-                        f.write(chunk["data"])
+                    if chunk["type"] == "audio":
+                        audio_bytes += chunk["data"]
+                return audio_bytes
        except Exception as e:
            error_msg = f"Edge TTS请求失败: {e}"
            raise Exception(error_msg)  # 抛出异常，让调用方捕获
@@ -88,7 +88,7 @@ class TTSProvider(TTSProviderBase):
        self.reference_audio = parse_string_to_list(config.get("reference_audio"))
        self.reference_text = parse_string_to_list(config.get("reference_text"))
        self.format = config.get("response_format", "wav")
-
+        self.audio_file_type = config.get("response_format", "wav")
        self.api_key = config.get("api_key", "YOUR_API_KEY")
        have_key = check_model_key("FishSpeech TTS", self.api_key)
        if not have_key:
@@ -170,8 +170,11 @@ class TTSProvider(TTSProviderBase):
        if response.status_code == 200:
            audio_content = response.content

-            with open(output_file, "wb") as audio_file:
-                audio_file.write(audio_content)
+            if output_file:
+                with open(output_file, "wb") as audio_file:
+                    audio_file.write(audio_content)
+            else:
+                return audio_content

        else:
            error_msg = f"Request failed with status code {response.status_code}"
@@ -65,6 +65,7 @@ class TTSProvider(TTSProviderBase):
        self.aux_ref_audio_paths = parse_string_to_list(
            config.get("aux_ref_audio_paths")
        )
+        self.audio_file_type = config.get("format", "wav")

    async def text_to_speak(self, text, output_file):
        request_json = {
@@ -91,8 +92,11 @@ class TTSProvider(TTSProviderBase):

        resp = requests.post(self.url, json=request_json)
        if resp.status_code == 200:
-            with open(output_file, "wb") as file:
-                file.write(resp.content)
+            if output_file:
+                with open(output_file, "wb") as file:
+                    file.write(resp.content)
+            else:
+                return resp.content
        else:
            error_msg = f"GPT_SoVITS_V2 TTS请求失败: {resp.status_code} - {resp.text}"
            logger.bind(tag=TAG).error(error_msg)
@@ -32,6 +32,7 @@ class TTSProvider(TTSProviderBase):
        self.cut_punc = config.get("cut_punc", "")
        self.inp_refs = parse_string_to_list(config.get("inp_refs"))
        self.if_sr = str(config.get("if_sr", False)).lower() in ("true", "1", "yes")
+        self.audio_file_type = config.get("format", "wav")

    async def text_to_speak(self, text, output_file):
        request_params = {
@@ -52,8 +53,11 @@ class TTSProvider(TTSProviderBase):

        resp = requests.get(self.url, params=request_params)
        if resp.status_code == 200:
-            with open(output_file, "wb") as file:
-                file.write(resp.content)
+            if output_file:
+                with open(output_file, "wb") as file:
+                    file.write(resp.content)
+            else:
+                return resp.content
        else:
            error_msg = f"GPT_SoVITS_V3 TTS请求失败: {resp.status_code} - {resp.text}"
            logger.bind(tag=TAG).error(error_msg)
@@ -145,16 +145,14 @@ class TTSProvider(TTSProviderBase):
        self.cluster = config.get("cluster")
        self.resource_id = config.get("resource_id")
        if config.get("private_voice"):
-            self.speaker = config.get("private_voice")
+            self.voice = config.get("private_voice")
        else:
-            self.speaker = config.get("speaker")
-        self.voice = config.get("voice")
+            self.voice = config.get("speaker")
        self.ws_url = config.get("ws_url")
        self.authorization = config.get("authorization")
        self.header = {"Authorization": f"{self.authorization}{self.access_token}"}
        self.enable_two_way = True
        self.tts_text = ""
-        self.before_stop_play_files = []
        self.opus_encoder = opus_encoder_utils.OpusEncoderUtils(
            sample_rate=16000, channels=1, frame_size_ms=60
        )
@@ -190,10 +188,8 @@ class TTSProvider(TTSProviderBase):

    def tts_text_priority_thread(self):
        """火山引擎双流式TTS的文本处理线程"""
-        logger.bind(tag=TAG).info("TTS文本处理线程启动")
        while not self.conn.stop_event.is_set():
            try:
-                logger.bind(tag=TAG).debug("等待TTS文本队列消息...")
                message = self.tts_text_queue.get(timeout=1)
                logger.bind(tag=TAG).debug(
                    f"收到TTS任务｜{message.sentence_type.name} ｜ {message.content_type.name} | 会话ID: {self.conn.sentence_id}"
@@ -271,7 +267,7 @@ class TTSProvider(TTSProviderBase):
                logger.bind(tag=TAG).error(f"WebSocket连接不存在，终止发送文本")
                return
            # 发送文本
-            await self.send_text(self.speaker, text, self.conn.sentence_id)
+            await self.send_text(self.voice, text, self.conn.sentence_id)
            return
        except Exception as e:
            logger.bind(tag=TAG).error(f"发送TTS文本失败: {str(e)}")
@@ -301,9 +297,9 @@ class TTSProvider(TTSProviderBase):
                event=EVENT_StartSession, sessionId=session_id
            ).as_bytes()
            payload = self.get_payload_bytes(
-                event=EVENT_StartSession, speaker=self.speaker
+                event=EVENT_StartSession, speaker=self.voice
            )
-            await self.send_event(header, optional, payload)
+            await self.send_event(self.ws, header, optional, payload)
            logger.bind(tag=TAG).info("会话启动请求已发送")
        except Exception as e:
            logger.bind(tag=TAG).error(f"启动会话失败: {str(e)}")
@@ -336,7 +332,7 @@ class TTSProvider(TTSProviderBase):
                    event=EVENT_FinishSession, sessionId=session_id
                ).as_bytes()
                payload = str.encode("{}")
-                await self.send_event(header, optional, payload)
+                await self.send_event(self.ws, header, optional, payload)
                logger.bind(tag=TAG).info("会话结束请求已发送")

                # 等待监听任务完成
@@ -383,6 +379,7 @@ class TTSProvider(TTSProviderBase):
        """监听TTS响应"""
        opus_datas_cache = []
        is_first_sentence = True
+        first_sentence_segment_count = 0  # 添加计数器
        try:
            while not self.conn.stop_event.is_set():
                try:
@@ -404,6 +401,7 @@ class TTSProvider(TTSProviderBase):
                            (SentenceType.FIRST, [], self.tts_text)
                        )
                        opus_datas_cache = []
+                        first_sentence_segment_count = 0  # 重置计数器
                    elif (
                        res.optional.event == EVENT_TTSResponse
                        and res.header.message_type == AUDIO_ONLY_RESPONSE
@@ -414,32 +412,28 @@ class TTSProvider(TTSProviderBase):
                            f"推送数据到队列里面帧数～～{len(opus_datas)}"
                        )
                        if is_first_sentence:
-                            # 第一句话直接发送
-                            self.tts_audio_queue.put(
-                                (SentenceType.MIDDLE, opus_datas, self.tts_text)
-                            )
+                            first_sentence_segment_count += 1
+                            if first_sentence_segment_count <= 6:
+                                self.tts_audio_queue.put(
+                                    (SentenceType.MIDDLE, opus_datas, None)
+                                )
+                            else:
+                                opus_datas_cache = opus_datas_cache + opus_datas
                        else:
                            # 后续句子缓存
                            opus_datas_cache = opus_datas_cache + opus_datas
                    elif res.optional.event == EVENT_TTSSentenceEnd:
                        logger.bind(tag=TAG).info(f"句子语音生成成功：{self.tts_text}")
-                        if not is_first_sentence:
-                            # 只有非第一句话才发送缓存的数据
+                        if not is_first_sentence or first_sentence_segment_count > 10:
+                            # 发送缓存的数据
                            self.tts_audio_queue.put(
-                                (SentenceType.MIDDLE, opus_datas_cache, self.tts_text)
+                                (SentenceType.MIDDLE, opus_datas_cache, None)
                            )
                        # 第一句话结束后，将标志设置为False
                        is_first_sentence = False
                    elif res.optional.event == EVENT_SessionFinished:
                        logger.bind(tag=TAG).debug(f"会话结束～～")
-                        for tts_file, text in self.before_stop_play_files:
-                            if tts_file and os.path.exists(tts_file):
-                                audio_datas = self._process_audio_file(tts_file)
-                                self.tts_audio_queue.put(
-                                    (SentenceType.MIDDLE, audio_datas, text)
-                                )
-                        self.before_stop_play_files.clear()
-                        self.tts_audio_queue.put((SentenceType.LAST, [], None))
+                        self._process_before_stop_play_files()
                        break
                except websockets.ConnectionClosed:
                    logger.bind(tag=TAG).warning("WebSocket连接已关闭")
@@ -460,7 +454,11 @@ class TTSProvider(TTSProviderBase):
                self.ws = None

    async def send_event(
-        self, header: bytes, optional: bytes | None = None, payload: bytes = None
+        self,
+        ws: websockets.WebSocketClientProtocol,
+        header: bytes,
+        optional: bytes | None = None,
+        payload: bytes = None,
    ):
        try:
            full_client_request = bytearray(header)
@@ -470,7 +468,7 @@ class TTSProvider(TTSProviderBase):
                payload_size = len(payload).to_bytes(4, "big", signed=True)
                full_client_request.extend(payload_size)
                full_client_request.extend(payload)
-            await self.ws.send(full_client_request)
+            await ws.send(full_client_request)
        except websockets.ConnectionClosed:
            logger.bind(tag=TAG).error(f"ConnectionClosed")
            raise
@@ -485,7 +483,7 @@ class TTSProvider(TTSProviderBase):
        payload = self.get_payload_bytes(
            event=EVENT_TaskRequest, text=text, speaker=speaker
        )
-        return await self.send_event(header, optional, payload)
+        return await self.send_event(self.ws, header, optional, payload)

    # 读取 res 数组某段 字符串内容
    def read_res_content(self, res: bytes, offset: int):
@@ -563,7 +561,7 @@ class TTSProvider(TTSProviderBase):
        ).as_bytes()
        optional = Optional(event=EVENT_Start_Connection).as_bytes()
        payload = str.encode("{}")
-        return await self.send_event(header, optional, payload)
+        return await self.send_event(self.ws, header, optional, payload)

    def print_response(self, res, tag_msg: str):
        logger.bind(tag=TAG).debug(f"===>{tag_msg} header:{res.header.__dict__}")
@@ -599,3 +597,107 @@ class TTSProvider(TTSProviderBase):
    def wav_to_opus_data_audio_raw(self, raw_data_var, is_end=False):
        opus_datas = self.opus_encoder.encode_pcm_to_opus(raw_data_var, is_end)
        return opus_datas
+
+    def to_tts(self, text: str) -> list:
+        """非流式生成音频数据，用于生成音频及测试场景
+
+        Args:
+            text: 要转换的文本
+
+        Returns:
+            list: 音频数据列表
+        """
+        try:
+            # 创建事件循环
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            # 生成会话ID
+            session_id = uuid.uuid4().__str__().replace("-", "")
+
+            # 存储音频数据
+            audio_data = []
+
+            async def _generate_audio():
+                # 创建新的WebSocket连接
+                ws_header = {
+                    "X-Api-App-Key": self.appId,
+                    "X-Api-Access-Key": self.access_token,
+                    "X-Api-Resource-Id": self.resource_id,
+                    "X-Api-Connect-Id": uuid.uuid4(),
+                }
+                ws = await websockets.connect(
+                    self.ws_url, additional_headers=ws_header, max_size=1000000000
+                )
+
+                try:
+                    # 启动会话
+                    header = Header(
+                        message_type=FULL_CLIENT_REQUEST,
+                        message_type_specific_flags=MsgTypeFlagWithEvent,
+                        serial_method=JSON,
+                    ).as_bytes()
+                    optional = Optional(
+                        event=EVENT_StartSession, sessionId=session_id
+                    ).as_bytes()
+                    payload = self.get_payload_bytes(
+                        event=EVENT_StartSession, speaker=self.voice
+                    )
+                    await self.send_event(ws, header, optional, payload)
+
+                    # 发送文本
+                    header = Header(
+                        message_type=FULL_CLIENT_REQUEST,
+                        message_type_specific_flags=MsgTypeFlagWithEvent,
+                        serial_method=JSON,
+                    ).as_bytes()
+                    optional = Optional(
+                        event=EVENT_TaskRequest, sessionId=session_id
+                    ).as_bytes()
+                    payload = self.get_payload_bytes(
+                        event=EVENT_TaskRequest, text=text, speaker=self.voice
+                    )
+                    await self.send_event(ws, header, optional, payload)
+
+                    # 发送结束会话请求
+                    header = Header(
+                        message_type=FULL_CLIENT_REQUEST,
+                        message_type_specific_flags=MsgTypeFlagWithEvent,
+                        serial_method=JSON,
+                    ).as_bytes()
+                    optional = Optional(
+                        event=EVENT_FinishSession, sessionId=session_id
+                    ).as_bytes()
+                    payload = str.encode("{}")
+                    await self.send_event(ws, header, optional, payload)
+
+                    # 接收音频数据
+                    while True:
+                        msg = await ws.recv()
+                        res = self.parser_response(msg)
+
+                        if (
+                            res.optional.event == EVENT_TTSResponse
+                            and res.header.message_type == AUDIO_ONLY_RESPONSE
+                        ):
+                            opus_datas = self.wav_to_opus_data_audio_raw(res.payload)
+                            audio_data.extend(opus_datas)
+                        elif res.optional.event == EVENT_SessionFinished:
+                            break
+
+                finally:
+                    # 清理资源
+                    try:
+                        await ws.close()
+                    except:
+                        pass
+
+            # 运行异步任务
+            loop.run_until_complete(_generate_audio())
+            loop.close()
+
+            return audio_data
+
+        except Exception as e:
+            logger.bind(tag=TAG).error(f"生成音频数据失败: {str(e)}")
+            return []
@@ -0,0 +1,303 @@
+import queue
+import asyncio
+import traceback
+import aiohttp
+import requests
+import time
+from config.logger import setup_logging
+from core.utils.tts import MarkdownCleaner
+from core.providers.tts.base import TTSProviderBase
+from core.utils import opus_encoder_utils, textUtils
+from core.providers.tts.dto.dto import SentenceType, ContentType, InterfaceType
+
+TAG = __name__
+logger = setup_logging()
+
+
+class TTSProvider(TTSProviderBase):
+    def __init__(self, config, delete_audio_file):
+        super().__init__(config, delete_audio_file)
+        self.interface_type = InterfaceType.SINGLE_STREAM
+        self.access_token = config.get("access_token")
+        self.voice = config.get("voice")
+        self.api_url = config.get("api_url")
+        self.audio_format = "pcm"
+        self.before_stop_play_files = []
+        self.segment_count = 0  # 添加片段计数器
+
+        # 创建Opus编码器
+        self.opus_encoder = opus_encoder_utils.OpusEncoderUtils(
+            sample_rate=16000, channels=1, frame_size_ms=60
+        )
+
+        # 添加文本缓冲区
+        self.text_buffer = ""
+
+        # PCM缓冲区
+        self.pcm_buffer = bytearray()
+
+    ###################################################################################
+    # linkerai单流式TTS重写父类的方法--开始
+    ###################################################################################
+
+    def tts_text_priority_thread(self):
+        """流式文本处理线程"""
+        while not self.conn.stop_event.is_set():
+            try:
+                message = self.tts_text_queue.get(timeout=1)
+                if message.sentence_type == SentenceType.FIRST:
+                    # 初始化参数
+                    self.tts_stop_request = False
+                    self.processed_chars = 0
+                    self.tts_text_buff = []
+                    self.segment_count = 0
+                    self.tts_audio_first_sentence = True
+                    self.before_stop_play_files.clear()
+                elif ContentType.TEXT == message.content_type:
+                    self.tts_text_buff.append(message.content_detail)
+                    segment_text = self._get_segment_text()
+                    if segment_text:
+                        self.to_tts_single_stream(segment_text)
+
+                elif ContentType.FILE == message.content_type:
+                    logger.bind(tag=TAG).info(
+                        f"添加音频文件到待播放列表: {message.content_file}"
+                    )
+                    self.before_stop_play_files.append(
+                        (message.content_file, message.content_detail)
+                    )
+
+                if message.sentence_type == SentenceType.LAST:
+                    # 处理剩余的文本
+                    self._process_remaining_text(True)
+
+            except queue.Empty:
+                continue
+            except Exception as e:
+                logger.bind(tag=TAG).error(
+                    f"处理TTS文本失败: {str(e)}, 类型: {type(e).__name__}, 堆栈: {traceback.format_exc()}"
+                )
+
+    def _process_remaining_text(self, is_last=False):
+        """处理剩余的文本并生成语音
+
+        Returns:
+            bool: 是否成功处理了文本
+        """
+        full_text = "".join(self.tts_text_buff)
+        remaining_text = full_text[self.processed_chars :]
+        if remaining_text:
+            segment_text = textUtils.get_string_no_punctuation_or_emoji(remaining_text)
+            if segment_text:
+                self.to_tts_single_stream(segment_text, is_last)
+                self.processed_chars += len(full_text)
+            else:
+                self._process_before_stop_play_files()
+        else:
+            self._process_before_stop_play_files()
+
+    def to_tts_single_stream(self, text, is_last=False):
+        try:
+            max_repeat_time = 5
+            text = MarkdownCleaner.clean_markdown(text)
+            try:
+                asyncio.run(self.text_to_speak(text, is_last))
+            except Exception as e:
+                logger.bind(tag=TAG).warning(
+                    f"语音生成失败{5 - max_repeat_time + 1}次: {text}，错误: {e}"
+                )
+                max_repeat_time -= 1
+
+            if max_repeat_time > 0:
+                logger.bind(tag=TAG).info(
+                    f"语音生成成功: {text}，重试{5 - max_repeat_time}次"
+                )
+            else:
+                logger.bind(tag=TAG).error(
+                    f"语音生成失败: {text}，请检查网络或服务是否正常"
+                )
+        except Exception as e:
+            logger.bind(tag=TAG).error(f"Failed to generate TTS file: {e}")
+        finally:
+            return None
+
+    ###################################################################################
+    # linkerai单流式TTS重写父类的方法--结束
+    ###################################################################################
+
+    async def text_to_speak(self, text, is_last):
+        """流式处理TTS音频，每句只推送一次音频列表"""
+        await self._tts_request(text, is_last)
+
+    async def close(self):
+        """资源清理"""
+        await super().close()
+        if hasattr(self, "opus_encoder"):
+            self.opus_encoder.close()
+
+    async def _tts_request(self, text: str, is_last: bool) -> None:
+        params = {
+            "tts_text": text,
+            "spk_id": self.voice,
+            "frame_durition": 60,
+            "stream": "true",
+            "target_sr": 16000,
+            "audio_format": "pcm",
+            "instruct_text": "请生成一段自然流畅的语音",
+        }
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "Content-Type": "application/json",
+        }
+
+        # 一帧 PCM 所需字节数：60 ms &times; 16 kHz &times; 1 ch &times; 2 B = 1 920
+        frame_bytes = int(
+            self.opus_encoder.sample_rate
+            * self.opus_encoder.channels  # 1
+            * self.opus_encoder.frame_size_ms
+            / 1000
+            * 2
+        )  # 16-bit = 2 bytes
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(
+                    self.api_url, params=params, headers=headers, timeout=10
+                ) as resp:
+
+                    if resp.status != 200:
+                        logger.error(f"TTS请求失败: {resp.status}, {await resp.text()}")
+                        self.tts_audio_queue.put((SentenceType.LAST, [], None))
+                        return
+
+                    self.pcm_buffer.clear()
+                    opus_datas_cache = []
+
+                    self.tts_audio_queue.put((SentenceType.FIRST, [], text))
+
+                    # 兼容 iter_chunked / iter_chunks / iter_any
+                    async for chunk in resp.content.iter_any():
+                        data = chunk[0] if isinstance(chunk, (list, tuple)) else chunk
+                        if not data:
+                            continue
+
+                        # 拼到 buffer
+                        self.pcm_buffer.extend(data)
+
+                        # 够一帧就编码
+                        while len(self.pcm_buffer) >= frame_bytes:
+                            frame = bytes(self.pcm_buffer[:frame_bytes])
+                            del self.pcm_buffer[:frame_bytes]
+
+                            opus = self.opus_encoder.encode_pcm_to_opus(
+                                frame, end_of_stream=False
+                            )
+                            if opus:
+                                if self.segment_count < 10:  # 前10个片段直接发送
+                                    self.tts_audio_queue.put(
+                                        (SentenceType.MIDDLE, opus, None)
+                                    )
+                                    self.segment_count += 1
+                                else:
+                                    opus_datas_cache.extend(opus)
+
+                    # flush 剩余不足一帧的数据
+                    if self.pcm_buffer:
+                        opus = self.opus_encoder.encode_pcm_to_opus(
+                            bytes(self.pcm_buffer), end_of_stream=True
+                        )
+                        if opus:
+                            if self.segment_count < 10:  # 前10个片段直接发送
+                                # 直接发送
+                                self.tts_audio_queue.put(
+                                    (SentenceType.MIDDLE, opus, None)
+                                )
+                                self.segment_count += 1
+                            else:
+                                # 后续片段缓存
+                                opus_datas_cache.extend(opus)
+                        self.pcm_buffer.clear()
+
+                    # 如果不是前10个片段，发送缓存的数据
+                    if self.segment_count >= 10 and opus_datas_cache:
+                        self.tts_audio_queue.put(
+                            (SentenceType.MIDDLE, opus_datas_cache, None)
+                        )
+
+                    # 如果是最后一段，输出音频获取完毕
+                    if is_last:
+                        self._process_before_stop_play_files()
+
+        except Exception as e:
+            logger.error(f"TTS请求异常: {e}")
+            self.tts_audio_queue.put((SentenceType.LAST, [], None))
+
+    def to_tts(self, text: str) -> list:
+        """非流式TTS处理，用于测试及保存音频文件的场景
+
+        Args:
+            text: 要转换的文本
+
+        Returns:
+            list: 返回opus编码后的音频数据列表
+        """
+        start_time = time.time()
+        text = MarkdownCleaner.clean_markdown(text)
+
+        params = {
+            "tts_text": text,
+            "spk_id": self.voice,
+            "frame_duration": 60,
+            "stream": False,
+            "target_sr": 16000,
+            "audio_format": self.audio_format,
+            "instruct_text": "请生成一段自然流畅的语音",
+        }
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "Content-Type": "application/json",
+        }
+
+        try:
+            with requests.get(
+                self.api_url, params=params, headers=headers, timeout=5
+            ) as response:
+                if response.status_code != 200:
+                    logger.error(
+                        f"TTS请求失败: {response.status_code}, {response.text}"
+                    )
+                    return []
+
+                logger.info(f"TTS请求成功: {text}, 耗时: {time.time() - start_time}秒")
+
+                # 使用opus编码器处理PCM数据
+                opus_datas = []
+                pcm_data = response.content
+
+                # 计算每帧的字节数
+                frame_bytes = int(
+                    self.opus_encoder.sample_rate
+                    * self.opus_encoder.channels
+                    * self.opus_encoder.frame_size_ms
+                    / 1000
+                    * 2
+                )
+
+                # 分帧处理PCM数据
+                for i in range(0, len(pcm_data), frame_bytes):
+                    frame = pcm_data[i : i + frame_bytes]
+                    if len(frame) < frame_bytes:
+                        # 最后一帧可能不足，用0填充
+                        frame = frame + b"\x00" * (frame_bytes - len(frame))
+
+                    opus = self.opus_encoder.encode_pcm_to_opus(
+                        frame, end_of_stream=(i + frame_bytes >= len(pcm_data))
+                    )
+                    if opus:
+                        opus_datas.extend(opus)
+
+                return opus_datas
+
+        except Exception as e:
+            logger.error(f"TTS请求异常: {e}")
+            return []
@@ -14,9 +14,9 @@ class TTSProvider(TTSProviderBase):
        self.api_key = config.get("api_key")
        self.model = config.get("model")
        if config.get("private_voice"):
-            self.voice_id = config.get("private_voice")
+            self.voice = config.get("private_voice")
        else:
-            self.voice_id = config.get("voice_id")
+            self.voice = config.get("voice_id")

        default_voice_setting = {
            "voice_id": "female-shaonv",
@@ -43,8 +43,8 @@ class TTSProvider(TTSProviderBase):
        self.audio_setting = {**defult_audio_setting, **config.get("audio_setting", {})}
        self.timber_weights = parse_string_to_list(config.get("timber_weights"))

-        if self.voice_id:
-            self.voice_setting["voice_id"] = self.voice_id
+        if self.voice:
+            self.voice_setting["voice_id"] = self.voice

        self.host = "api.minimax.chat"
        self.api_url = f"https://{self.host}/v1/t2a_v2?GroupId={self.group_id}"
@@ -52,6 +52,7 @@ class TTSProvider(TTSProviderBase):
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}",
        }
+        self.audio_file_type = defult_audio_setting.get("format", "mp3")

    def generate_filename(self, extension=".mp3"):
        return os.path.join(
@@ -80,8 +81,12 @@ class TTSProvider(TTSProviderBase):
            # 检查返回请求数据的status_code是否为0
            if resp.json()["base_resp"]["status_code"] == 0:
                data = resp.json()["data"]["audio"]
-                file_to_save = open(output_file, "wb")
-                file_to_save.write(bytes.fromhex(data))
+                audio_bytes = bytes.fromhex(data)
+                if output_file:
+                    with open(output_file, "wb") as file_to_save:
+                        file_to_save.write(audio_bytes)
+                else:
+                    return audio_bytes
            else:
                raise Exception(
                    f"{__name__} status_code: {resp.status_code} response: {resp.content}"
@@ -17,7 +17,8 @@ class TTSProvider(TTSProviderBase):
            self.voice = config.get("private_voice")
        else:
            self.voice = config.get("voice", "alloy")
-        self.response_format = "wav"
+        self.response_format = config.get("format", "wav")
+        self.audio_file_type = config.get("format", "wav")

        # 处理空字符串的情况
        speed = config.get("speed", "1.0")
@@ -40,8 +41,11 @@ class TTSProvider(TTSProviderBase):
        }
        response = requests.post(self.api_url, json=data, headers=headers)
        if response.status_code == 200:
-            with open(output_file, "wb") as audio_file:
-                audio_file.write(response.content)
+            if output_file:
+                with open(output_file, "wb") as audio_file:
+                    audio_file.write(response.content)
+            else:
+                return response.content
        else:
            raise Exception(
                f"OpenAI TTS请求失败: {response.status_code} - {response.text}"
@@ -11,7 +11,8 @@ class TTSProvider(TTSProviderBase):
            self.voice = config.get("private_voice")
        else:
            self.voice = config.get("voice")
-        self.response_format = config.get("response_format")
+        self.response_format = config.get("response_format", "mp3")
+        self.audio_file_type = config.get("response_format", "mp3")
        self.sample_rate = config.get("sample_rate")
        self.speed = float(config.get("speed", 1.0))
        self.gain = config.get("gain")
@@ -35,7 +36,10 @@ class TTSProvider(TTSProviderBase):
                "POST", self.api_url, json=request_json, headers=headers
            )
            data = response.content
-            file_to_save = open(output_file, "wb")
-            file_to_save.write(data)
+            if output_file:
+                with open(output_file, "wb") as file_to_save:
+                    file_to_save.write(data)
+            else:
+                return data
        except Exception as e:
            raise Exception(f"{__name__} error: {e}")
@@ -22,6 +22,7 @@ class TTSProvider(TTSProviderBase):
        self.api_url = "https://tts.tencentcloudapi.com"  # 正确的API端点
        self.region = config.get("region")
        self.output_file = config.get("output_dir")
+        self.audio_file_type = config.get("format", "wav")

    def _get_auth_headers(self, request_body):
        """生成鉴权请求头"""
@@ -148,12 +149,14 @@ class TTSProvider(TTSProviderBase):
                        f"API返回错误: {error_info['Code']}: {error_info['Message']}"
                    )

-                # 提取音频数据
-                audio_data = response_data["Response"].get("Audio")
-                if audio_data:
-                    # 解码Base64音频数据并保存
-                    with open(output_file, "wb") as f:
-                        f.write(base64.b64decode(audio_data))
+                # 解码Base64音频数据
+                audio_bytes = base64.b64decode(response_data["Response"].get("Audio"))
+                if audio_bytes:
+                    if output_file:
+                        with open(output_file, "wb") as f:
+                            f.write(audio_bytes)
+                    else:
+                        return audio_bytes
                else:
                    raise Exception(f"{__name__}: 没有返回音频数据: {response_data}")
            else:
@@ -19,9 +19,9 @@ class TTSProvider(TTSProviderBase):
            "https://u95167-bd74-2aef8085.westx.seetacloud.com:8443/flashsummary/tts?token=",
        )
        if config.get("private_voice"):
-            self.voice_id = int(config.get("private_voice"))
+            self.voice = int(config.get("private_voice"))
        else:
-            self.voice_id = int(config.get("voice_id", 1695))
+            self.voice = int(config.get("voice_id", 1695))
        self.token = config.get("token")
        self.to_lang = config.get("to_lang")
        self.volume_change_dB = int(config.get("volume_change_dB", 0))
@@ -30,6 +30,7 @@ class TTSProvider(TTSProviderBase):
        self.output_file = config.get("output_dir")
        self.pitch_factor = int(config.get("pitch_factor", 0))
        self.format = config.get("format", "mp3")
+        self.audio_file_type = config.get("format", "mp3")
        self.emotion = int(config.get("emotion", 1))
        self.header = {"Content-Type": "application/json"}

@@ -49,7 +50,7 @@ class TTSProvider(TTSProviderBase):
                "emotion": self.emotion,
                "format": self.format,
                "volume_change_dB": self.volume_change_dB,
-                "voice_id": self.voice_id,
+                "voice_id": self.voice,
                "pitch_factor": self.pitch_factor,
                "speed_factor": self.speed_factor,
                "token": self.token,
@@ -73,9 +74,11 @@ class TTSProvider(TTSProviderBase):
            )

            audio_content = requests.get(result)
-            with open(output_file, "wb") as f:
-                f.write(audio_content.content)
-                return True
+            if output_file:
+                with open(output_file, "wb") as f:
+                    f.write(audio_content.content)
+            else:
+                return audio_content.content
            voice_path = resp_json.get("voice_path")
            des_path = output_file
            shutil.move(voice_path, des_path)
@@ -29,5 +29,31 @@ def decode_opus_from_file(input_file):
            total_frames += 1

    # 计算总时长
+    total_duration = (total_frames * frame_duration_ms) / 1000.0
+    return opus_datas, total_duration
+
+def decode_opus_from_bytes(input_bytes):
+    """
+    从p3二进制数据中解码 Opus 数据，并返回一个 Opus 数据包的列表以及总时长。
+    """
+    import io
+    opus_datas = []
+    total_frames = 0
+    sample_rate = 16000  # 文件采样率
+    frame_duration_ms = 60  # 帧时长
+    frame_size = int(sample_rate * frame_duration_ms / 1000)
+
+    f = io.BytesIO(input_bytes)
+    while True:
+        header = f.read(4)
+        if not header:
+            break
+        _, _, data_len = struct.unpack('>BBH', header)
+        opus_data = f.read(data_len)
+        if len(opus_data) != data_len:
+            raise ValueError(f"Data length({len(opus_data)}) mismatch({data_len}) in the bytes.")
+        opus_datas.append(opus_data)
+        total_frames += 1
+
    total_duration = (total_frames * frame_duration_ms) / 1000.0
    return opus_datas, total_duration
@@ -3,6 +3,9 @@ import socket
 import subprocess
 import re
 import os
+import wave
+from io import BytesIO
+from core.utils import p3
 import numpy as np
 import requests
 import opuslib_next
@@ -773,6 +776,22 @@ def audio_to_data(audio_file_path, is_opus=True):
    return pcm_to_data(raw_data, is_opus), duration


+def audio_bytes_to_data(audio_bytes, file_type, is_opus=True):
+    """
+    直接用音频二进制数据转为opus/pcm数据，支持wav、mp3、p3
+    """
+    if file_type == "p3":
+        # 直接用p3解码
+        return p3.decode_opus_from_bytes(audio_bytes)
+    else:
+        # 其他格式用pydub
+        audio = AudioSegment.from_file(BytesIO(audio_bytes), format=file_type, parameters=["-nostdin"])
+        audio = audio.set_channels(1).set_frame_rate(16000).set_sample_width(2)
+        duration = len(audio) / 1000.0
+        raw_data = audio.raw_data
+        return pcm_to_data(raw_data, is_opus), duration
+
+
 def pcm_to_data(raw_data, is_opus=True):
    # 初始化Opus编码器
    encoder = opuslib_next.Encoder(16000, 1, opuslib_next.APPLICATION_AUDIO)
@@ -804,6 +823,33 @@ def pcm_to_data(raw_data, is_opus=True):
    return datas


+def opus_datas_to_wav_bytes(opus_datas, sample_rate=16000, channels=1):
+    """
+    将opus帧列表解码为wav字节流
+    """
+    decoder = opuslib_next.Decoder(sample_rate, channels)
+    pcm_datas = []
+
+    frame_duration = 60  # ms
+    frame_size = int(sample_rate * frame_duration / 1000)  # 960
+
+    for opus_frame in opus_datas:
+        # 解码为PCM（返回bytes，2字节/采样点）
+        pcm = decoder.decode(opus_frame, frame_size)
+        pcm_datas.append(pcm)
+
+    pcm_bytes = b''.join(pcm_datas)
+
+    # 写入wav字节流
+    wav_buffer = BytesIO()
+    with wave.open(wav_buffer, 'wb') as wf:
+        wf.setnchannels(channels)
+        wf.setsampwidth(2)  # 16bit
+        wf.setframerate(sample_rate)
+        wf.writeframes(pcm_bytes)
+    return wav_buffer.getvalue()
+
+
 def check_vad_update(before_config, new_config):
    if (
        new_config.get("selected_module") is None
@@ -930,3 +976,8 @@ def is_valid_image_file(file_data: bytes) -> bool:
            return True

    return False
+
+
+def sanitize_tool_name(name: str) -> str:
+    """Sanitize tool names for OpenAI compatibility."""
+    return re.sub(r"[^a-zA-Z0-9_-]", "_", name)
@@ -0,0 +1,143 @@
+import os
+import yaml
+import time
+import hashlib
+import fcntl
+from typing import Dict
+from contextlib import contextmanager
+
+
+class FileLock:
+    def __init__(self, file, timeout=5):
+        self.file = file
+        self.timeout = timeout
+        self.start_time = None
+
+    def __enter__(self):
+        self.start_time = time.time()
+        while True:
+            try:
+                fcntl.flock(self.file, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                return self.file
+            except IOError:
+                if time.time() - self.start_time > self.timeout:
+                    raise TimeoutError("获取文件锁超时")
+                time.sleep(0.1)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        fcntl.flock(self.file, fcntl.LOCK_UN)
+
+
+class WakeupWordsConfig:
+    def __init__(self):
+        self.config_file = "data/.wakeup_words.yaml"
+        self.assets_dir = "config/assets/wakeup_words"
+        self._ensure_directories()
+        self._config_cache = None
+        self._last_load_time = 0
+        self._cache_ttl = 1  # 缓存有效期（秒）
+        self._lock_timeout = 5  # 文件锁超时时间（秒）
+
+    def _ensure_directories(self):
+        """确保必要的目录存在"""
+        os.makedirs(os.path.dirname(self.config_file), exist_ok=True)
+        os.makedirs(self.assets_dir, exist_ok=True)
+
+    def _load_config(self) -> Dict:
+        """加载配置文件，使用缓存机制"""
+        current_time = time.time()
+
+        # 如果缓存有效，直接返回缓存
+        if (
+            self._config_cache is not None
+            and current_time - self._last_load_time < self._cache_ttl
+        ):
+            return self._config_cache
+
+        try:
+            with open(self.config_file, "a+") as f:
+                with FileLock(f, timeout=self._lock_timeout):
+                    f.seek(0)
+                    content = f.read()
+                    config = yaml.safe_load(content) if content else {}
+                    self._config_cache = config
+                    self._last_load_time = current_time
+                    return config
+        except (TimeoutError, IOError) as e:
+            print(f"加载配置文件失败: {e}")
+            return {}
+        except Exception as e:
+            print(f"加载配置文件时发生未知错误: {e}")
+            return {}
+
+    def _save_config(self, config: Dict):
+        """保存配置到文件，使用文件锁保护"""
+        try:
+            with open(self.config_file, "w") as f:
+                with FileLock(f, timeout=self._lock_timeout):
+                    yaml.dump(config, f, allow_unicode=True)
+                    self._config_cache = config
+                    self._last_load_time = time.time()
+        except (TimeoutError, IOError) as e:
+            print(f"保存配置文件失败: {e}")
+            raise
+        except Exception as e:
+            print(f"保存配置文件时发生未知错误: {e}")
+            raise
+
+    def get_wakeup_response(self, voice: str) -> Dict:
+        voice = hashlib.md5(voice.encode()).hexdigest()
+        """获取唤醒词回复配置"""
+        config = self._load_config()
+        default_response = {
+            "voice": "default",
+            "file_path": "config/assets/wakeup_words.wav",
+            "time": 0,
+            "text": "哈啰啊，我是小智啦，声音好听的台湾女孩一枚，超开心认识你耶，最近在忙啥，别忘了给我来点有趣的料哦，我超爱听八卦的啦",
+        }
+
+        if not config or voice not in config:
+            return default_response
+
+        # 检查文件大小
+        file_path = config[voice]["file_path"]
+        if not os.path.exists(file_path) or os.stat(file_path).st_size < (15 * 1024):
+            return default_response
+
+        return config[voice]
+
+    def update_wakeup_response(self, voice: str, file_path: str, text: str):
+        """更新唤醒词回复配置"""
+        try:
+            config = self._load_config()
+            voice_hash = hashlib.md5(voice.encode()).hexdigest()
+            config[voice_hash] = {
+                "voice": voice,
+                "file_path": file_path,
+                "time": time.time(),
+                "text": text,
+            }
+            self._save_config(config)
+        except Exception as e:
+            print(f"更新唤醒词回复配置失败: {e}")
+            raise
+
+    def generate_file_path(self, voice: str) -> str:
+        """生成音频文件路径，使用voice的哈希值作为文件名"""
+        try:
+            # 生成voice的哈希值
+            voice_hash = hashlib.md5(voice.encode()).hexdigest()
+            file_path = os.path.join(self.assets_dir, f"{voice_hash}.wav")
+
+            # 如果文件已存在，先删除
+            if os.path.exists(file_path):
+                try:
+                    os.remove(file_path)
+                except Exception as e:
+                    print(f"删除已存在的音频文件失败: {e}")
+                    raise
+
+            return file_path
+        except Exception as e:
+            print(f"生成音频文件路径失败: {e}")
+            raise
@@ -31,4 +31,5 @@ chardet==5.2.0
 aioconsole==0.8.1
 markitdown==0.1.1
 mcp-proxy==0.6.0
-PyJWT==2.8.0
+PyJWT==2.8.0
+psutil==7.0.0
Author	SHA1	Message	Date
欣南科技andGitHub	423626a6bf	Merge pull request #1504 from xinnan-tech/fix-mcp-name Fix mcp name	2025-06-07 16:00:49 +08:00
hrz	182acc0787	update:替换描述里涉及到的原始方法名称	2025-06-08 15:51:57 +08:00
hrzandGitHub	705aef462c	Merge pull request #1502 from whats2000/main update: 修正 MCP tool naming 問題 (OpenAI SDK 命名規範)	2025-06-07 14:40:08 +08:00
whats2000andGitHub	1f092dd80e	update: 修正 MCP tool naming 問題 (OpenAI SDK 命名規範) Fix MCP tool naming for OpenAI	2025-06-07 13:48:10 +08:00
whats2000	4d0ddd7ff3	fix: sanitize MCP tool names for OpenAI	2025-06-07 13:46:35 +08:00
欣南科技andGitHub	2a212ae759	Merge pull request #1500 from xinnan-tech/fix-stream-mem Fix stream mem	2025-06-07 11:59:45 +08:00
hrz	1d57e75d28	update:单流式tts聊天记录上报优化	2025-06-08 11:59:06 +08:00
hrz	ac1e254eed	update:智控台开启唤醒词加速	2025-06-08 11:50:09 +08:00
欣南科技andGitHub	6074431364	Merge pull request #1499 from xinnan-tech/py_Text update:优化流式前帧发送	2025-06-07 02:34:18 +08:00
hrz	d5fc4d48b4	update:优化流失前帧发送	2025-06-08 02:33:07 +08:00
hrz	61232e7dda	update:优化空asr语音	2025-06-08 01:09:32 +08:00
hrz	594b4f1d75	add：增加psutil依赖	2025-06-08 00:21:30 +08:00
hrz	98174bcc16	update:【流式tts】增加【非流式】方法，用于测试及生成文件的场景	2025-06-08 00:06:40 +08:00
hrz	29d90df9ea	Merge branch 'main' into py_Text # Conflicts: # main/xiaozhi-server/core/handle/helloHandle.py # main/xiaozhi-server/core/providers/tts/base.py	2025-06-07 22:48:23 +08:00
hrz	50e6e4817b	update:优化唤醒词答复	2025-06-07 22:08:22 +08:00
欣南科技andGitHub	c6a88e41e1	Merge pull request #1498 from xinnan-tech/py_Text update:优化空asr语音	2025-06-07 01:10:13 +08:00
欣南科技andGitHub	ae1c41ba82	Merge pull request #1497 from xinnan-tech/py_Text add：增加psutil依赖	2025-06-07 00:22:11 +08:00
欣南科技andGitHub	837bb74576	Merge pull request #1496 from xinnan-tech/py_Text 优化唤醒词答复速度	2025-06-07 00:12:21 +08:00
hrzandGitHub	1284418c18	Merge pull request #1481 from xinnan-tech/py_AEC_test funasr添加内存检测判断；修改日志模块，日志轮转（单个文件10MB限制）	2025-06-06 15:02:46 +08:00
hrzandGitHub	3eb3a4502f	Update fun_local.py	2025-06-06 14:08:38 +08:00
欣南科技andGitHub	6023af2f21	Merge pull request #1488 from xinnan-tech/fix-wakeup-bug update:修复被唤醒词打断bug	2025-06-05 20:55:28 +08:00
hrz	2cd90d8066	update:修复被唤醒词打断bug	2025-06-05 20:54:53 +08:00
hrzandGitHub	c1dfb540a3	Merge pull request #1486 from pursue-wind/main fix: 使用deepseek r1-0528模型时，tools_call为空list，tools_call[0]报错	2025-06-05 17:07:59 +08:00
hrzandGitHub	bc44ea8757	Update connection.py	2025-06-05 17:07:29 +08:00
Pursue WindandGitHub	77743ef8ba	Merge branch 'xinnan-tech:main' into main	2025-06-05 16:34:39 +08:00
chan	f8de052d54	fix: 使用deepseek r1-0528模型时，tools_call为空list，tools_call[0]报错	2025-06-05 16:33:47 +08:00
欣南科技andGitHub	cb4eb21551	Merge pull request #1485 from xinnan-tech/py_linkerai_single update：添加免费流式tts（灵犀流式）	2025-06-05 16:26:23 +08:00
hrz	8357d7abc3	update：添加免费流式tts（灵犀流式）	2025-06-05 16:25:40 +08:00
欣南科技andGitHub	5a01bfcdbf	Merge pull request #1484 from xinnan-tech/py_linkerai_single Py linkerai single	2025-06-05 16:13:21 +08:00
hrz	01eb416a03	update:智控台添加免费流式TTS(linkerai)	2025-06-05 16:02:16 +08:00
Sakura-RanChen	dca02c1f4b	update: 唤醒音频兼容	2025-06-05 14:11:50 +08:00
hrz	2654802bb0	update:流式播放	2025-06-05 11:09:09 +08:00
hrz	d7eecfdcea	update:优化代码	2025-06-05 10:49:25 +08:00
CGD	8df9846ad7	update:改为采用日志轮转机制，同时添加自动清理	2025-06-05 09:46:54 +08:00
hrz	e43c0135a7	Merge branch 'main' into py_linkerai_single	2025-06-05 09:26:00 +08:00
hrz	adf1a47945	update:优化配置说明	2025-06-05 09:25:30 +08:00
hrzandGitHub	ca1beb956a	Merge pull request #1458 from nodexiaoyu/add-technical-overview-doc It sounds like you're looking for a detailed technical overview of th…	2025-06-04 23:38:37 +08:00
欣南科技andGitHub	c694d3d6f1	Merge pull request #1478 from xinnan-tech/hot-fix update:优化文档	2025-06-04 22:04:07 +08:00
hrz	a314d03870	update:优化文档	2025-06-04 22:03:34 +08:00
Sakura-RanChen	23cb7616d9	update: 更改to_tts保存临时文件判断	2025-06-04 16:46:49 +08:00
CGD	fba758ea36	update:恢复最初的日志模块	2025-06-04 15:42:52 +08:00
CGD	0268f90e9c	update：修改日志模块，使其按日期和大小分割的日志文件名	2025-06-04 14:46:52 +08:00
CGD	4cc7247c37	update:funasr实例之前添加内存检测判断	2025-06-04 14:35:21 +08:00
google-labs-jules[bot]	0269620e66	Sure, here is the rewritten message: Add detailed technical overview documentation (Chinese) This document provides a comprehensive technical overview of the xiaozhi-esp32-server project in Chinese, including: - Overall architecture - In-depth analysis of xiaozhi-server, manager-api, and manager-web components, covering their purpose, core technologies, and key implementation aspects. - Data flow and interaction mechanisms. - Summary of key features. - Deployment and configuration overview.	2025-06-03 08:50:30 +00:00
google-labs-jules[bot]	10ebe975cf	It sounds like you're looking for a detailed technical overview of the xiaozhi-esp32-server project. I can help you put together documentation that includes: - The overall architecture. - Deep dives into the xiaozhi-server, manager-api, and manager-web components, covering their purpose, core technologies, and key implementation aspects. - How data flows and how different parts of the system interact. - A summary of the key features. - An overview of how to deploy and configure it. Let me know if this is what you had in mind!	2025-06-03 08:45:40 +00:00
Sakura-RanChen	0bc609cac4	优化实时编码	2025-06-03 11:20:54 +08:00
Sakura-RanChen	92affd6e13	待优化	2025-05-30 15:22:41 +08:00
Sakura-RanChen	3130044909	test	2025-05-29 09:05:08 +08:00