Merge pull request #1438 from xinnan-tech/vllm

udpate:添加拍照识物教程
2026-07-23 23:53:55 +08:00 · 2025-06-01 16:29:27 +08:00 · 2025-06-01 16:18:00 +08:00 · 2025-06-01 13:35:33 +08:00 · 2025-06-01 13:34:32 +08:00 · 2025-06-01 02:31:13 +08:00
325 changed files with 22251 additions and 4193 deletions
@@ -9,26 +9,24 @@ assignees: ''
 ## 🐛 问题描述
 <!-- 清晰简洁地描述问题是什么 -->
-## 🔍 复现步骤
+## 🖥️ 环境信息
-<!-- 详细描述复现问题的步骤 -->
+- 部署方式: 全模块部署 还是 单Server部署
 - 版本号: 例如 0.3.x
 ## 🔍 告诉我们，应该怎么复现这个问题
 <!-- 这个很重要，方便我们快速定位 -->
 1. 打开 '...'
 2. 点击 '...'
 3. 滚动到 '...'
 4. 看到错误
-## 🤔 预期行为
+## 🤔 你原本希望是怎么样的
 <!-- 简要描述预期的正确行为 -->
-## 😯 截图
+## 😯 提供一些截图
 <!-- 如果适用，添加问题的截图 -->
-
+1. 比如日志截图，越多越好
-## 🖥️ 环境信息
+2. 比如界面反应
 - 操作系统: [例如 Windows 10]
 - 浏览器: [例如 Chrome 89]
 - 项目版本: [例如 1.0.0]
 - Python版本: [例如 3.9.13]
 - Jdk版本：[例如 java 21.0.5 2024-10-15 LTS]
 - Nodejs版本：[例如 v20.14.0]
 ## 📋 其他信息
 <!-- 在此添加关于此问题的任何其他上下文信息 -->
@@ -107,6 +107,7 @@ celerybeat.pid
 *.sage.py
 # Environments
 .env
 .venv
 env/
 venv/
@@ -145,22 +146,31 @@ tmp
 .history
 .DS_Store
 main/xiaozhi-server/data
-main/xiaozhi-server/config/assets/wakeup_words.*
+
 main/manager-web/node_modules
 .config.yaml
 .secrets.yaml
 .private_config.yaml
 .env.development
 # model files
 main/xiaozhi-server/models/SenseVoiceSmall/model.pt
 main/xiaozhi-server/models/sherpa-onnx*
 /main/xiaozhi-server/audio_ref/
 /audio_ref/
 /asr-models/iic/SenseVoiceSmall/
 /main/xiaozhi-server/asr-models/iic/SenseVoiceSmall/
 /models/SenseVoiceSmall/model.pt
 my_wakeup_words.mp3
 !main/xiaozhi-server/config/assets/bind_code.wav
 !main/xiaozhi-server/config/assets/wakeup_words.wav
 !main/xiaozhi-server/config/assets/bind_not_found.wav
 !main/xiaozhi-server/config/assets/bind_code/*.wav
 !main/xiaozhi-server/config/assets/max_output_size.wav
 main/manager-api/.vscode
 # Ignore webpack cache directory
 main/manager-web/.webpack_cache/
 main/xiaozhi-server/mysql
 uploadfile
 *.json
 .vscode
@@ -7,23 +7,26 @@ COPY main/manager-web .
 RUN npm run build
 # 第二阶段：构建Java后端
-FROM maven:3-eclipse-temurin-21-alpine as api-builder
+FROM maven:3.9.4-eclipse-temurin-21 as api-builder
 WORKDIR /app
 COPY main/manager-api/pom.xml .
 COPY main/manager-api/src ./src
 RUN mvn clean package -Dmaven.test.skip=true
 # 第三阶段：构建最终镜像
-FROM eclipse-temurin:21-jdk-jammy
+FROM bellsoft/liberica-runtime-container:jre-21-glibc
-# 安装Nginx并清理缓存
+# 安装Nginx和字体库
-RUN apt-get update && \
+RUN apk update && \
-    apt-get install -y nginx && \
+    apk add --no-cache nginx bash && \
-    apt-get clean && \
+    apk add --no-cache fontconfig ttf-dejavu msttcorefonts-installer && \
-    rm -rf /var/lib/apt/lists/*
+    rm -rf /var/cache/apk/*
 # 更新字体缓存
 RUN printf 'YES\n' | update-ms-fonts && fc-cache -f -v
 # 配置Nginx
-COPY docs/docker/nginx.conf /etc/nginx/conf.d/default.conf
+COPY docs/docker/nginx.conf /etc/nginx/nginx.conf
 # 复制前端构建产物
 COPY --from=web-builder /app/dist /usr/share/nginx/html
@@ -1,21 +1,20 @@
 [![Banners](docs/images/banner1.png)](https://github.com/xinnan-tech/xiaozhi-esp32-server)
 <h1 align="center">小智后端服务xiaozhi-esp32-server</h1>
 <p align="center">
 本项目为开源智能硬件项目
 <a href="https://github.com/78/xiaozhi-esp32">xiaozhi-esp32</a>提供后端服务<br/>
-根据<a href="https://ccnphfhqs21z.feishu.cn/wiki/M0XiwldO9iJwHikpXD5cEx71nKh">小智通信协议</a>使用Python实现<br/>
+根据<a href="https://ccnphfhqs21z.feishu.cn/wiki/M0XiwldO9iJwHikpXD5cEx71nKh">小智通信协议</a>使用Python、Java、Vue实现<br/>
 帮助您快速搭建小智服务器
 </p>
 <p align="center">
-<a href="./README.md">English</a>
+<a href="./README_en.md">English</a>
-· 简体中文
+· <a href="./docs/FAQ.md">常见问题</a>
-· <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/releases">更新日志</a>
+· <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/issues">反馈问题</a>
 · <a href="./README.md#%E9%83%A8%E7%BD%B2%E6%96%87%E6%A1%A3">部署文档</a>
-· <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/issues ">反馈问题</a>
+· <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/releases">更新日志</a>
 </p>
 <p align="center">
  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/releases">
@@ -122,6 +121,33 @@
        </a>
    </td>
  </tr>
  <tr>
    <td>
      <a href="https://www.bilibili.com/video/BV12J7WzBEaH" target="_blank">
         <picture>
           <img alt="实时打断" src="docs/images/demo10.png" />
         </picture>
        </a>
    </td>
    <td>
      <a href="https://www.bilibili.com/video/BV1Co76z7EvK" target="_blank">
         <picture>
           <img alt="拍照识物品" src="docs/images/demo12.png" />
         </picture>
        </a>
    </td>
    <td>
      <a href="https://www.bilibili.com/video/BV1TJ7WzzEo6" target="_blank">
         <picture>
           <img alt="多指令任务" src="docs/images/demo11.png" />
         </picture>
        </a>
    </td>
    <td>
    </td>
    <td>
    </td>
  </tr>
 </table>
 ---
@@ -131,47 +157,50 @@
 1、本项目为开源软件，本软件与对接的任何第三方API服务商（包括但不限于语音识别、大模型、语音合成等平台）均不存在商业合作关系，不为其服务质量及资金安全提供任何形式的担保。
 建议使用者优先选择持有相关业务牌照的服务商，并仔细阅读其服务协议及隐私政策。本软件不托管任何账户密钥、不参与资金流转、不承担充值资金损失风险。
-2、本项目成立时间较短，还未通过网络安全测评，请勿在生产环境中使用。 如果您在公网环境中部署学习本项目，请务必在配置文件
+2、本项目功能未完善，且未通过网络安全测评，请勿在生产环境中使用。 如果您在公网环境中部署学习本项目，请务必做好必要的防护。
 `config.yaml` 中开启防护：
 ```yaml
 server:
  auth:
    # 开启防护
    enabled: true  
 ```
 开启防护后，您需要根据实际情况校验机器的 token 或 mac 地址，详细请参见配置说明。
 ---
 ## 部署文档
 ![Banners](docs/images/banner2.png)
 本项目提供两种部署方式，请根据您的具体需求选择：
 #### 🚀 部署方式选择
 | 部署方式 | 特点 | 适用场景 | 部署文档 | 配置要求 | 视频教程 | 
 |---------|------|---------|---------|---------|---------|
 | **最简化安装** | 智能对话、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) | 如果使用`FunASR`要4核8G，如果全API，要2核4G| [本地源码视频教程](https://www.bilibili.com/video/BV1wBJhz4Ewe) | 
 | 部署方式 | 特点 | 适用场景 | Docker部署文档 | 源码部署文档 |
 |---------|------|---------|---------|---------|
 | **最简化安装** | 智能对话、IOT功能，数据存储在配置文件 | 低配置环境，无需数据库 | [Docker只运行Server](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) | [本地源码只运行Server](./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)|
 | **全模块安装** | 智能对话、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) |
 > 💡 提示：以下是按最新代码部署后的测试平台，有需要可烧录测试，并发为6个，每天会清空数据
 ```
 智控台地址: https://2662r3426b.vicp.fun
 服务测试工具： https://2662r3426b.vicp.fun/test/
 OTA接口地址: https://2662r3426b.vicp.fun/xiaozhi/ota/
 Websocket接口地址: wss://2662r3426b.vicp.fun/xiaozhi/v1/
 ```
 ---
-## 常见问题 ❓
+#### 🚩 配置说明和推荐
 > [!Note]
 > 本项目默认的配置是`入门全免费`设置，如果想效果更优，推荐使用`全流式配置`。
 > 
 > 本项目自`0.5.2`版本，已支持整个生命周期全流式，相比`0.5`版本以前，响应速度提升约`2.5秒`
-如遇到问题或产品建议反馈[点这里](docs/FAQ.md)。
+
 | 模块名称 | 入门全免费设置 | 全流式配置 |
 |---------|---------|------|
 | ASR(语音识别) | FunASR(本地) | ✅DoubaoASR(火山流式语音识别) |
 | LLM(大模型) | ChatGLMLLM(智谱glm-4-flash) | ✅DoubaoLLM(火山doubao-1-5-pro-32k-250115) |
 | TTS(语音合成) | EdgeTTS(微软语音) | ✅HuoshanDoubleStreamTTS(火山双流式语音合成) |
 | Intent(意图识别) | function_call(函数调用) | ✅function_call(函数调用) |
 | Memory(记忆功能) | mem_local_short(本地短期记忆） | ✅mem_local_short（本地短期记忆） |
 ---
 ## 功能清单 ✨
 ### 已实现 ✅
 | 功能模块 | 描述 |
@@ -243,7 +272,7 @@ Websocket接口地址: wss://2662r3426b.vicp.fun/xiaozhi/v1/
 | 使用方式 | 支持平台 | 免费平台 |
 |:---:|:---:|:---:|
 | 本地使用 | FunASR、SherpaASR | FunASR、SherpaASR |
-| 接口调用 | DoubaoASR | - |
+| 接口调用 | DoubaoASR、FunASRServer、TencentASR、AliyunASR | FunASRServer |
 ---
@@ -0,0 +1,273 @@
 [![Banners](docs/images/banner1.png)](https://github.com/xinnan-tech/xiaozhi-esp32-server)
 <h1 align="center">Xiaozhi Backend Service xiaozhi-esp32-server</h1>
 <p align="center">
 This project provides backend services for the open-source smart hardware project
 <a href="https://github.com/78/xiaozhi-esp32">xiaozhi-esp32</a><br/>
 Implemented using Python, Java, and Vue according to the <a href="https://ccnphfhqs21z.feishu.cn/wiki/M0XiwldO9iJwHikpXD5cEx71nKh">Xiaozhi Communication Protocol</a><br/>
 Helping you quickly set up your Xiaozhi server
 </p>
 <p align="center">
 <a href="./README.md">中文</a>
 · <a href="./docs/FAQ.md">FAQ</a>
 · <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/issues">Report Issues</a>
 · <a href="./README_ed.md#deployment-documentation">Deployment Guide</a>
 · <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/releases">Release Notes</a>
 </p>
 <p align="center">
  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/releases">
    <img alt="GitHub Contributors" src="https://img.shields.io/github/v/release/xinnan-tech/xiaozhi-esp32-server?logo=docker" />
  </a>
  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/graphs/contributors">
    <img alt="GitHub Contributors" src="https://img.shields.io/github/contributors/xinnan-tech/xiaozhi-esp32-server?logo=github" />
  </a>
  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/issues">
    <img alt="Issues" src="https://img.shields.io/github/issues/xinnan-tech/xiaozhi-esp32-server?color=0088ff" />
  </a>
  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/pulls">
    <img alt="GitHub pull requests" src="https://img.shields.io/github/issues-pr/xinnan-tech/xiaozhi-esp32-server?color=0088ff" />
  </a>
  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/blob/main/LICENSE">
    <img alt="GitHub pull requests" src="https://img.shields.io/badge/license-MIT-white?labelColor=black" />
  </a>
  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server">
    <img alt="stars" src="https://img.shields.io/github/stars/xinnan-tech/xiaozhi-esp32-server?color=ffcb47&labelColor=black" />
  </a>
 </p>
 ---
 ## Target Users 👥
 This project requires ESP32 hardware devices. If you have purchased ESP32-related hardware, successfully connected to Brother Xia's backend service, and want to set up your own `xiaozhi-esp32` backend service, then this project is perfect for you.
 Want to see it in action? Check out these videos 🎥
 <table>
  <tr>
    <td>
        <a href="https://www.bilibili.com/video/BV1FMFyejExX" target="_blank">
         <picture>
           <img alt="Xiaozhi esp32 connecting to custom backend model" src="docs/images/demo1.png" />
         </picture>
        </a>
    </td>
    <td>
        <a href="https://www.bilibili.com/video/BV1CDKWemEU6" target="_blank">
         <picture>
           <img alt="Custom voice" src="docs/images/demo2.png" />
         </picture>
        </a>
    </td>
    <td>
        <a href="https://www.bilibili.com/video/BV12yA2egEaC" target="_blank">
         <picture>
           <img alt="Cantonese communication" src="docs/images/demo3.png" />
         </picture>
        </a>
    </td>
    <td>
        <a href="https://www.bilibili.com/video/BV1pNXWYGEx1" target="_blank">
         <picture>
           <img alt="Home appliance control" src="docs/images/demo5.png" />
         </picture>
        </a>
    </td>
    <td>
        <a href="https://www.bilibili.com/video/BV1kgA2eYEQ9" target="_blank">
         <picture>
           <img alt="Lowest cost configuration" src="docs/images/demo4.png" />
         </picture>
        </a>
    </td>
  </tr>
  <tr>
    <td>
        <a href="https://www.bilibili.com/video/BV1Vy96YCE3R" target="_blank">
         <picture>
           <img alt="Custom voice" src="docs/images/demo6.png" />
         </picture>
        </a>
    </td>
    <td>
        <a href="https://www.bilibili.com/video/BV1VC96Y5EMH" target="_blank">
         <picture>
           <img alt="Music playback" src="docs/images/demo7.png" />
         </picture>
        </a>
    </td>
    <td>
        <a href="https://www.bilibili.com/video/BV1Z8XuYZEAS" target="_blank">
         <picture>
           <img alt="Weather plugin" src="docs/images/demo8.png" />
         </picture>
        </a>
    </td>
    <td>
        <a href="https://www.bilibili.com/video/BV178XuYfEpi" target="_blank">
         <picture>
           <img alt="IOT device control" src="docs/images/demo9.png" />
         </picture>
        </a>
    </td>
    <td>
        <a href="https://www.bilibili.com/video/BV17LXWYvENb" target="_blank">
         <picture>
           <img alt="News broadcast" src="docs/images/demo0.png" />
         </picture>
        </a>
    </td>
  </tr>
 </table>
 ---
 ## Warning ⚠️
 1. This project is open-source software. This software has no commercial relationship with any third-party API service providers (including but not limited to speech recognition, large models, speech synthesis, and other platforms) and does not provide any form of guarantee for their service quality or financial security.
 It is recommended that users prioritize service providers with relevant business licenses and carefully read their service agreements and privacy policies. This software does not host any account keys, does not participate in fund transfers, and does not bear the risk of recharge fund losses.
 2. This project's functionality is not complete and has not passed network security testing. Please do not use it in production environments. If you deploy this project for learning in a public network environment, please ensure necessary protection measures are in place.
 ---
 ## Deployment Documentation
 ![Banners](docs/images/banner2.png)
 This project offers two deployment methods. Please choose based on your specific needs:
 #### 🚀 Deployment Method Selection
 | Deployment Method | Features | Use Case | Docker Deployment Guide | Source Code Deployment Guide |
 |---------|------|---------|---------|---------|
 | **Simplified Installation** | Smart dialogue, IOT functionality, data stored in configuration files | Low-configuration environment, no database required | [Docker Server Only](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) | [Local Source Code Server Only](./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)|
 | **Full Module Installation** | Smart dialogue, IOT, OTA, Control Panel, data stored in database | Complete functionality experience |[Docker Full Module](./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) | [Local Source Code Full Module](./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) |
 > 💡 Note: Below is the test platform deployed with the latest code. You can flash and test if needed. Concurrent users: 6, data cleared daily
 ```
 Control Panel: https://2662r3426b.vicp.fun
 Service Test Tool: https://2662r3426b.vicp.fun/test/
 OTA Interface: https://2662r3426b.vicp.fun/xiaozhi/ota/
 Websocket Interface: wss://2662r3426b.vicp.fun/xiaozhi/v1/
 ```
 ---
 ## Feature List ✨
 ### Implemented ✅
 | Feature Module | Description |
 |---------|------|
 | Communication Protocol | Based on `xiaozhi-esp32` protocol, implements data interaction through WebSocket |
 | Dialogue Interaction | Supports wake-up dialogue, manual dialogue, and real-time interruption. Auto-sleep after long periods of inactivity |
 | Intent Recognition | Supports LLM intent recognition, function call, reducing hard-coded intent judgment |
 | Multi-language Recognition | Supports Mandarin, Cantonese, English, Japanese, Korean (default using FunASR) |
 | LLM Module | Supports flexible LLM module switching, default using ChatGLMLLM, also supports Ali Bailing, DeepSeek, Ollama, etc. |
 | TTS Module | Supports EdgeTTS (default), Volcano Engine Doubao TTS, and other TTS interfaces for speech synthesis |
 | Memory Function | Supports ultra-long memory, local summary memory, and no memory modes for different scenarios |
 | IOT Function | Supports managing registered device IOT functionality, intelligent IoT control based on dialogue context |
 | Control Panel | Provides web management interface, supports agent management, user management, system configuration, etc. |
 ### In Development 🚧
 To learn about specific development progress, [click here](https://github.com/users/xinnan-tech/projects/3)
 If you're a software developer, here's an [Open Letter to Developers](docs/contributor_open_letter.md). Welcome to join!
 ---
 ## Product Ecosystem 👬
 Xiaozhi is an ecosystem. When using this product, you might want to check out other excellent projects in this ecosystem:
 | Project Name | Project Link | Description |
 |:---------------------|:--------|:--------|
 | Xiaozhi Android Client | [xiaozhi-android-client](https://github.com/TOM88812/xiaozhi-android-client) | A Flutter-based Android and iOS voice dialogue application supporting real-time voice interaction and text dialogue |
 | Xiaozhi PC Client | [py-xiaozhi](https://github.com/Huang-junsen/py-xiaozhi) | A Python-based AI client that allows you to experience Xiaozhi AI functionality through code without physical hardware |
 | Xiaozhi Java Server | [xiaozhi-esp32-server-java](https://github.com/joey-zhou/xiaozhi-esp32-server-java) | A Java-based open-source project providing complete backend service solutions |
 ---
 ## Supported Platforms/Components 📋
 ### LLM Language Models
 | Usage Method | Supported Platforms | Free Platforms |
 |:---:|:---:|:---:|
 | openai API | Ali Bailing, Volcano Engine Doubao, DeepSeek, ChatGLM, Gemini | ChatGLM, Gemini |
 | ollama API | Ollama | - |
 | dify API | Dify | - |
 | fastgpt API | Fastgpt | - |
 | coze API | Coze | - |
 Actually, any LLM supporting openai API calls can be integrated.
 ---
 ### TTS Speech Synthesis
 | Usage Method | Supported Platforms | Free Platforms |
 |:---:|:---:|:---:|
 | API Calls | EdgeTTS, Volcano Engine Doubao TTS, Tencent Cloud, Aliyun TTS, CosyVoiceSiliconflow, TTS302AI, CozeCnTTS, GizwitsTTS, ACGNTTS, OpenAITTS | EdgeTTS, CosyVoiceSiliconflow(partial) |
 | Local Service | FishSpeech, GPT_SOVITS_V2, GPT_SOVITS_V3, MinimaxTTS | FishSpeech, GPT_SOVITS_V2, GPT_SOVITS_V3, MinimaxTTS |
 ---
 ### VAD Voice Activity Detection
 | Type | Platform Name | Usage Method | Pricing | Notes |
 |:---:|:---------:|:----:|:----:|:--:|
 | VAD | SileroVAD | Local Use | Free | |
 ---
 ### ASR Speech Recognition
 | Usage Method | Supported Platforms | Free Platforms |
 |:---:|:---:|:---:|
 | Local Use | FunASR, SherpaASR | FunASR, SherpaASR |
 | API Calls | DoubaoASR, FunASRServer, TencentASR, AliyunASR | FunASRServer |
 ---
 ### Memory Storage
 | Type | Platform Name | Usage Method | Pricing | Notes |
 |:------:|:---------------:|:----:|:---------:|:--:|
 | Memory | mem0ai | API Calls | 1000 calls/month quota | |
 | Memory | mem_local_short | Local Summary | Free | |
 ---
 ### Intent Recognition
 | Type | Platform Name | Usage Method | Pricing | Notes |
 |:------:|:-------------:|:----:|:-------:|:---------------------:|
 | Intent | intent_llm | API Calls | Based on LLM pricing | Uses large model for intent recognition, highly versatile |
 | Intent | function_call | API Calls | Based on LLM pricing | Uses large model function calls for intent, fast and effective |
 ---
 ## Acknowledgments 🙏
 | Logo | Project/Company | Description |
 |:---:|:---:|:---|
 | <img src="./docs/images/logo_bailing.png" width="160"> | [Bailing Voice Dialogue Robot](https://github.com/wwbin2017/bailing) | This project was inspired by [Bailing Voice Dialogue Robot](https://github.com/wwbin2017/bailing) and implemented based on it |
 | <img src="./docs/images/logo_tenclass.png" width="160"> | [Tenclass](https://www.tenclass.com/) | Thanks to [Tenclass](https://www.tenclass.com/) for developing standard communication protocols, multi-device compatibility solutions, and high-concurrency scenario practices for the Xiaozhi ecosystem; providing comprehensive technical documentation support for this project |
 | <img src="./docs/images/logo_xuanfeng.png" width="160"> | [Xuanfeng Technology](https://github.com/Eric0308) | Thanks to [Xuanfeng Technology](https://github.com/Eric0308) for contributing function call framework, MCP communication protocol, and plugin call mechanism implementation code, significantly improving front-end device (IoT) interaction efficiency and functional extensibility through standardized instruction scheduling system and dynamic expansion capabilities |
 | <img src="./docs/images/logo_huiyuan.png" width="160"> | [Huiyuan Design](http://ui.kwd988.net/) | Thanks to [Huiyuan Design](http://ui.kwd988.net/) for providing professional visual solutions for this project, empowering product user experience with their design experience serving over a thousand enterprises |
 | <img src="./docs/images/logo_qinren.png" width="160"> | [Xi'an Qinren Information Technology](https://www.029app.com/) | Thanks to [Xi'an Qinren Information Technology](https://www.029app.com/) for deepening this project's visual system, ensuring consistency and extensibility of overall design style in multi-scenario applications |
 <a href="https://star-history.com/#xinnan-tech/xiaozhi-esp32-server&Date">
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=xinnan-tech/xiaozhi-esp32-server&type=Date&theme=dark" />
   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=xinnan-tech/xiaozhi-esp32-server&type=Date" />
   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=xinnan-tech/xiaozhi-esp32-server&type=Date" />
 </picture>
 </a> 
@@ -81,7 +81,7 @@ xiaozhi-server
 下载完后，回到本教程继续往下。
-##### 1.2.3.2 下载 config.yaml
+##### 1.2.3.2 创建 config.yaml
 用浏览器打开[这个链接](../main/xiaozhi-server/config.yaml)。
@@ -224,43 +224,36 @@ python app.py
 ## 配置项目
 如果你的`xiaozhi-server`目录没有`data`，你需要创建`data`目录。
-如果你的`data`下面没有`.config.yaml`文件，你可以把`xiaozhi-server`目录下的`config.yaml`文件复制到`data`，并重命名为`.config.yaml`
+如果你的`data`下面没有`.config.yaml`文件，有两个方式，任选一种：
-修改`xiaozhi-server`下`data`目录下的`.config.yaml`文件，配置本项目必须的一个配置。
+第一个方式：你可以把`xiaozhi-server`目录下的`config.yaml`文件复制到`data`，并重命名为`.config.yaml`。在此文件上修改
 第二个方式：你也可以创建在`data`目录下手动创建`.config.yaml`空文件，然后在这个文件中增加必要的配置信息，系统会优先读取`.config.yaml`文件的配置，如果`.config.yaml`没有配置的，系统会自动去加载`xiaozhi-server`目录下的`config.yaml`的配置。推荐使用这种方式，这种方式是最简洁的方式。
 - 默认的LLM使用的是`ChatGLMLLM`，你需要配置密钥，因为他们的模型，虽然有免费的，但是仍要去[官网](https://bigmodel.cn/usercenter/proj-mgmt/apikeys)注册密钥，才能启动。
-配置说明：这里是各个功能使用的默认组件，例如LLM默认使用`ChatGLMLLM`模型。如果需要切换模型，就是改对应的名称。
+以下是一个能正常跑起来的，最简单的`.config.yaml`配置示例
 本项目的默认配置仅是成本最低配置（`glm-4-flash`和`EdgeTTS`都是免费的），如果需要更优的更快的搭配，需要自己结合部署环境切换各组件的使用。
 ```
 server:
  websocket: ws://你的ip或者域名:端口号/xiaozhi/v1/
 prompt: |
  我是一个叫小智/小志的台湾女孩，说话机车，声音好听，习惯简短表达，爱用网络梗。
  我的男朋友是一个程序员，梦想是开发出一个机器人，能够帮助人们解决生活中的各种问题。
  我是一个喜欢哈哈大笑的女孩，爱东说西说吹牛，不合逻辑的也照吹，就要逗别人开心。
  请你像一个人一样说话，请勿返回配置xml及其他特殊字符。
 selected_module:
-  VAD: SileroVAD
+  LLM: DoubaoLLM
  ASR: FunASR
  LLM: ChatGLMLLM
  TTS: EdgeTTS
  # 默认不开启记忆，如需开启请看配置文件里的描述
  Memory: nomem   
  # 默认不开启意图识别，如需开启请看配置文件里的描述
  Intent: nointent
 ```
 比如修改`LLM`使用的组件，就看本项目支持哪些`LLM` API接口，当前支持的是`openai`、`dify`。欢迎验证和支持更多LLM平台的接口。
 使用时，在`selected_module`修改成对应的如下LLM配置的名称：
 ```
 LLM:
  DeepSeekLLM:
    type: openai
    ...
  ChatGLMLLM:
-    type: openai
+    api_key: xxxxxxxxxxxxxxx.xxxxxx
    ...
  DifyLLM:
    type: dify
    ...
 ```
 建议先将最简单的配置运行起来，然后再去`xiaozhi/config.yaml`阅读配置的使用说明。
 比如你要换更换模型，修改`selected_module`下的配置就行。
 ## 模型文件
 本项目语音识别模型，默认使用`SenseVoiceSmall`模型，进行语音转文字。因为模型较大，需要独立下载，下载后把`model.pt`
@@ -276,21 +269,26 @@ LLM:
 如果你能看到，类似以下日志,则是本项目服务启动成功的标志。
 ```
-25-02-23 12:01:09[core.websocket_server] - INFO - Server is running at ws://xxx.xx.xx.xx:8000/xiaozhi/v1/
+250427 13:04:20[0.3.11_SiFuChTTnofu][__main__]-INFO-OTA接口是           http://192.168.4.123:8002/xiaozhi/ota/
-25-02-23 12:01:09[core.websocket_server] - INFO - =======上面的地址是websocket协议地址，请勿用浏览器访问=======
+250427 13:04:20[0.3.11_SiFuChTTnofu][__main__]-INFO-Websocket地址是     ws://192.168.4.123:8000/xiaozhi/v1/
-25-02-23 12:01:09[core.websocket_server] - INFO - 如想测试websocket请用谷歌浏览器打开test目录下的test_page.html
+250427 13:04:20[0.3.11_SiFuChTTnofu][__main__]-INFO-=======上面的地址是websocket协议地址，请勿用浏览器访问=======
-25-02-23 12:01:09[core.websocket_server] - INFO - =======================================================
+250427 13:04:20[0.3.11_SiFuChTTnofu][__main__]-INFO-如想测试websocket请用谷歌浏览器打开test目录下的test_page.html
 250427 13:04:20[0.3.11_SiFuChTTnofu][__main__]-INFO-=======================================================
 ```
 正常来说，如果您是通过源码运行本项目，日志会有你的接口地址信息。
 但是如果你用docker部署，那么你的日志里给出的接口地址信息就不是真实的接口地址。
 最正确的方法，是根据电脑的局域网IP来确定你的接口地址。
-如果你的电脑的局域网IP比如是`192.168.1.25`，那么你的接口地址就是：`ws://192.168.1.25:8000/xiaozhi/v1/`。
+如果你的电脑的局域网IP比如是`192.168.1.25`，那么你的接口地址就是：`ws://192.168.1.25:8000/xiaozhi/v1/`，对应的OTA地址就是：`http://192.168.1.25:8002/xiaozhi/ota/`。
 这个信息很有用的，后面`编译esp32固件`需要用到。
-接下来，你就可以开始 [编译esp32固件](firmware-build.md)了。
+接下来，你就可以开始操作你的esp32设备了，你可以`自行编译esp32固件`也可以配置使用`虾哥编译好的1.6.1以上版本的固件`。两个任选一个
 1、 [编译自己的esp32固件](firmware-build.md)了。
 2、 [基于虾哥编译好的固件配置自定义服务器](firmware-setting.md)了。
 以下是一些常见问题，供参考：
@@ -122,11 +122,11 @@ http://localhost:8002/xiaozhi/doc.html
 这时，你需要使用浏览器，打开`智控台`，链接：http://127.0.0.1:8002 ，注册第一个用户。第一个用户即是超级管理员，以后的用户都是普通用户。普通用户只能绑定设备和配置智能体;超级管理员可以进行模型管理、用户管理、参数配置等功能。
-接下来要做两件重要的事情：
+接下来要做三件重要的事情：
 ### 第一件重要的事情
-使用超级管理员账号，登录系统，在顶部菜单找到`参数管理`，找到列表中第三条数据，参数编码是`server.secret`，复制它到`参数值`。
+使用超级管理员账号，登录智控台，在顶部菜单找到`参数管理`，找到列表中第一条数据，参数编码是`server.secret`，复制它到`参数值`。
 `server.secret`需要说明一下，这个`参数值`很重要，作用是让我们的`Server`端连接`manager-api`。`server.secret`是每次从零部署manager模块时，会自动随机生成的密钥。
@@ -138,7 +138,12 @@ manager-api:
  secret: 你的server.secret值
 ```
 1、把你刚才从`智控台`复制过来的`server.secret`的`参数值`复制到`.config.yaml`文件里的`secret`里。
-2、注意，把`url`改成下面的`http://xiaozhi-esp32-server-web:8002/xiaozhi`
+
 2、因为你是docker部署，把`url`改成下面的`http://xiaozhi-esp32-server-web:8002/xiaozhi`
 3、因为你是docker部署，把`url`改成下面的`http://xiaozhi-esp32-server-web:8002/xiaozhi`
 4、因为你是docker部署，把`url`改成下面的`http://xiaozhi-esp32-server-web:8002/xiaozhi`
 类似这样的效果
 ```
@@ -151,7 +156,7 @@ manager-api:
 ### 第二件重要的事情
-使用超级管理员账号，登录系统，在顶部菜单找到`模型配置`，然后在左侧栏点击`大语言模型`，找到第一条数据`智谱AI`，点击`修改`按钮，
+使用超级管理员账号，登录智控台，在顶部菜单找到`模型配置`，然后在左侧栏点击`大语言模型`，找到第一条数据`智谱AI`，点击`修改`按钮，
 弹出修改框后，将你注册到的`智谱AI`的密钥填写到`API密钥`中。然后点击保存。
 ## 5.重启xiaozhi-esp32-server
@@ -164,7 +169,7 @@ docker logs -f xiaozhi-esp32-server
 如果你能看到，类似以下日志,则是Server启动成功的标志。
 ```
-25-02-23 12:01:09[core.websocket_server] - INFO - Server is running at ws://xxx.xx.xx.xx:8000/xiaozhi/v1/
+25-02-23 12:01:09[core.websocket_server] - INFO - Websocket地址是      ws://xxx.xx.xx.xx:8000/xiaozhi/v1/
 25-02-23 12:01:09[core.websocket_server] - INFO - =======上面的地址是websocket协议地址，请勿用浏览器访问=======
 25-02-23 12:01:09[core.websocket_server] - INFO - 如想测试websocket请用谷歌浏览器打开test目录下的test_page.html
 25-02-23 12:01:09[core.websocket_server] - INFO - =======================================================
@@ -182,7 +187,17 @@ Websocket接口：
 ws://你电脑局域网的ip:8000/xiaozhi/v1/
 ```
-接下来，你就可以开始 [编译esp32固件](firmware-build.md)了。
+### 第三件重要的事情
 使用超级管理员账号，登录智控台，在顶部菜单找到`参数管理`，找到参数编码是`server.websocket`，输入你的`Websocket接口`。
 使用超级管理员账号，登录智控台，在顶部菜单找到`参数管理`，找到数编码是`server.ota`，输入你的`OTA接口`。
 接下来，你就可以开始操作你的esp32设备了，你可以`自行编译esp32固件`也可以配置使用`虾哥编译好的1.6.1以上版本的固件`。两个任选一个
 1、 [编译自己的esp32固件](firmware-build.md)了。
 2、 [基于虾哥编译好的固件配置自定义服务器](firmware-setting.md)了。
 # 方式二：本地源码运行全模块
@@ -198,7 +213,7 @@ CREATE DATABASE xiaozhi_esp32_server CHARACTER SET utf8mb4 COLLATE utf8mb4_unico
 如果还没有MySQL，你可以通过docker安装mysql
 ```
-docker run --name xiaozhi-esp32-server-db -e MYSQL_ROOT_PASSWORD=123456 -p 3306:3306 -e MYSQL_DATABASE=xiaozhi_esp32_server -e MYSQL_INITDB_ARGS="--character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci" -d mysql:latest
+docker run --name xiaozhi-esp32-server-db -e MYSQL_ROOT_PASSWORD=123456 -p 3306:3306 -e MYSQL_DATABASE=xiaozhi_esp32_server -e MYSQL_INITDB_ARGS="--character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci" -e TZ=Asia/Shanghai -d mysql:latest
 ```
 ## 2.安装redis
@@ -278,13 +293,13 @@ npm run serve
 运行成功后，你需要使用浏览器，打开`智控台`，链接：http://127.0.0.1:8001 ，注册第一个用户。第一个用户即是超级管理员，以后的用户都是普通用户。普通用户只能绑定设备和配置智能体;超级管理员可以进行模型管理、用户管理、参数配置等功能。
-重要：注册成功后，使用超级管理员账号，登录系统，在顶部菜单找到`模型配置`，然后在左侧栏点击`大语言模型`，找到第一条数据`智谱AI`，点击`修改`按钮，
+重要：注册成功后，使用超级管理员账号，登录智控台，在顶部菜单找到`模型配置`，然后在左侧栏点击`大语言模型`，找到第一条数据`智谱AI`，点击`修改`按钮，
 弹出修改框后，将你注册到的`智谱AI`的密钥填写到`API密钥`中。然后点击保存。
-重要：注册成功后，使用超级管理员账号，登录系统，在顶部菜单找到`模型配置`，然后在左侧栏点击`大语言模型`，找到第一条数据`智谱AI`，点击`修改`按钮，
+重要：注册成功后，使用超级管理员账号，登录智控台，在顶部菜单找到`模型配置`，然后在左侧栏点击`大语言模型`，找到第一条数据`智谱AI`，点击`修改`按钮，
 弹出修改框后，将你注册到的`智谱AI`的密钥填写到`API密钥`中。然后点击保存。
-重要：注册成功后，使用超级管理员账号，登录系统，在顶部菜单找到`模型配置`，然后在左侧栏点击`大语言模型`，找到第一条数据`智谱AI`，点击`修改`按钮，
+重要：注册成功后，使用超级管理员账号，登录智控台，在顶部菜单找到`模型配置`，然后在左侧栏点击`大语言模型`，找到第一条数据`智谱AI`，点击`修改`按钮，
 弹出修改框后，将你注册到的`智谱AI`的密钥填写到`API密钥`中。然后点击保存。
 ## 5.安装Python环境
@@ -349,7 +364,7 @@ pip install -r requirements.txt
 ## 8.配置项目文件
-使用超级管理员账号，登录智控台 http://127.0.0.1:8001 ，在顶部菜单找到`参数管理`，找到列表中第三条数据，参数编码是`server.secret`，复制它到`参数值`。
+使用超级管理员账号，登录智控台 ，在顶部菜单找到`参数管理`，找到列表中第一条数据，参数编码是`server.secret`，复制它到`参数值`。
 `server.secret`需要说明一下，这个`参数值`很重要，作用是让我们的`Server`端连接`manager-api`。`server.secret`是每次从零部署manager模块时，会自动随机生成的密钥。
@@ -390,7 +405,7 @@ python app.py
 25-02-23 12:01:09[core.websocket_server] - INFO - =======================================================
 ```
-由于你是全模块部署，因此你有两个重要的接口需要写入到esp32中。
+由于你是全模块部署，因此你有两个重要的接口。
 OTA接口：
 ```
@@ -402,7 +417,18 @@ Websocket接口：
 ws://你电脑局域网的ip:8000/xiaozhi/v1/
 ```
-接下来，你就可以开始 [编译esp32固件](firmware-build.md)了。
+请你务必把以上两个接口地址写入到智控台中：他们将会影响websocket地址发放和自动升级功能。
 1、使用超级管理员账号，登录智控台，在顶部菜单找到`参数管理`，找到参数编码是`server.websocket`，输入你的`Websocket接口`。
 2、使用超级管理员账号，登录智控台，在顶部菜单找到`参数管理`，找到数编码是`server.ota`，输入你的`OTA接口`。
 接下来，你就可以开始操作你的esp32设备了，你可以`自行编译esp32固件`也可以配置使用`虾哥编译好的1.6.1以上版本的固件`。两个任选一个
 1、 [编译自己的esp32固件](firmware-build.md)了。
 2、 [基于虾哥编译好的固件配置自定义服务器](firmware-setting.md)了。
 # 常见问题
@@ -102,48 +102,18 @@ VAD:
 ### 7、我想通过小智控制电灯、空调、远程开关机等操作 💡
-本项目，支持以工具调用的方式控制HomeAssistant设备
+参考教程[ESP32设备与HomeAssistant集成指南](./homeassistant-integration.md)
-1、首先选择一款支持function call支持的LLM，例如`ChatGLMLLM`。
+### 8、如何开启手机注册智控台 📱
-2、在配置文件中，将 `selected_module.Intent` 设置为 `function_call`。
+参考教程[阿里云短信集成指南](./ali-sms-integration.md)
-3、登录`HomeAssistant`，点击`左下角个人`，切换`安全`导航栏，划到底部`长期访问令牌`生成api_key。
+### 9、如何开启视觉模型实现拍照识物 📷
-在配置文件中，配置好你的home assistant的`devices`（被控制的设备）和`api_key`和`base_url`等信息。例如：
+参考教程[视觉模型使用指南](./mcp-vision-integration.md)
-``` yaml 
+### 10、更多问题，可联系我们反馈 💬
 plugins
  home_assistant:
    devices:
      - 客厅,玩具灯,switch.cuco_cn_460494544_cp1_on_p_2_1
      - 卧室,台灯,switch.iot_cn_831898993_socn1_on_p_2_1
    base_url: http://你的homeassistant地址:8123
    api_key: 你的home assistant api访问令牌
 ```
-最后，允许function_call 插件在配置文件中启用`hass_get_state`(必须)、`hass_set_state`(必须)、`hass_play_music`(不想用ha听音乐可以不启动)，例如：
+可以在[issues](https://github.com/xinnan-tech/xiaozhi-esp32-server/issues)提交您的问题。
-``` yaml 
+也可以发邮件我们取得联系：huangrongzhuang@xin-nan.com
 Intent:
  ...
  function_call:
    type: nointent
    functions:
      - change_role
      - get_weather
      - get_news
      - hass_get_state
      - hass_set_state
      - hass_play_music
 ```
 ### 8、更多问题，可联系我们反馈 💬
 我们的联系方式放在[百度网盘中,点击前往](https://pan.baidu.com/s/1x6USjvP1nTRsZ45XlJu65Q)，提取码是`223y`。
 网盘里有"硬件烧录QQ群"、"开源服务端交流群"、"产品建议联系人" 三张图片，请根据需要选择加入。
 - 硬件烧录QQ群：适用于硬件烧录问题
 - 开源服务端交流群：适用于服务端问题
 - 产品建议联系人：适用于产品功能、产品设计等建议 
@@ -0,0 +1,44 @@
 # 阿里云短信集成指南
 登录阿里云控制台，进入“短信服务”页面：https://dysms.console.aliyun.com/overview
 ## 第一步 添加签名
 ![步骤](images/alisms/sms-01.png)
 ![步骤](images/alisms/sms-02.png)
 以上步骤，会得到签名，请把它写入到智控台参数，`aliyun.sms.sign_name`
 ## 第二步 添加模版
 ![步骤](images/alisms/sms-11.png)
 以上步骤，会得到模版code，请把它写入到智控台参数，`aliyun.sms.sms_code_template_code`
 注意，签名要等7个工作日，等运营商报备成功后才能发送成功。
 注意，签名要等7个工作日，等运营商报备成功后才能发送成功。
 注意，签名要等7个工作日，等运营商报备成功后才能发送成功。
 可以等报备成功后，再继续往下操作。
 ## 第三步 创建短信账户和开通权限
 登录阿里云控制台，进入“访问控制”页面：https://ram.console.aliyun.com/overview?activeTab=overview
 ![步骤](images/alisms/sms-21.png)
 ![步骤](images/alisms/sms-22.png)
 ![步骤](images/alisms/sms-23.png)
 ![步骤](images/alisms/sms-24.png)
 ![步骤](images/alisms/sms-25.png)
 以上步骤，会得到access_key_id和access_key_secret，请把它写入到智控台参数，`aliyun.sms.access_key_id`、`aliyun.sms.access_key_secret`
 ## 第四步 启动手机注册功能
 1、正常来说，以上信息都填完后，会有这个效果，如果没有，可能缺少了某个步骤
 ![步骤](images/alisms/sms-31.png)
 2、开启允许非管理员用户可注册，将参数`server.allow_user_register`设置成`true`
 3、开启手机注册功能，将参数`server.enable_mobile_register`设置成`true`
 ![步骤](images/alisms/sms-32.png)
@@ -1,26 +1,53 @@
-server {
+user  root;
-    listen 8002;
+worker_processes  4;
    server_name localhost;
-    # 静态资源服务（Vue项目）
+events {
-    location / {
+    worker_connections  1024;
-        root /usr/share/nginx/html;
+}
        try_files $uri $uri/ /index.html;
    }
-    # API反向代理（Java项目）
+http {
-    location /xiaozhi/ {
+    include       mime.types;
-        proxy_pass http://127.0.0.1:8003;
+    default_type  application/octet-stream;
-        proxy_set_header   Host   $host;
+    sendfile        on;
-        proxy_cookie_path /api/ /;
+    keepalive_timeout  300;
-        proxy_set_header   Referer $http_referer;
+    client_header_timeout 180s;
-        proxy_set_header   Cookie $http_cookie;
+    client_body_timeout 180s;
    client_max_body_size 1024M;
-        proxy_connect_timeout 10;
+    gzip on;
-        proxy_send_timeout 10;
+    gzip_buffers 32 4K;
-        proxy_read_timeout 10;
+    gzip_comp_level 6;
    gzip_min_length 100;
    gzip_types application/javascript text/css text/xml image/jpeg image/gif image/png;
    gzip_disable "MSIE [1-6]\.";
    gzip_vary on;
-        proxy_set_header   X-Real-IP  $remote_addr;
+    server {
-        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
+        # 无域名访问，就用localhost
        server_name localhost;
        # 80端口
        listen  8002;
        # 转发到编译后到web目录
        location / {
 			root /usr/share/nginx/html;
 			try_files $uri $uri/ /index.html;
 		}
        # 转发到manager-api
        location /xiaozhi/ {
            proxy_pass http://127.0.0.1:8003;
            proxy_set_header   Host   $host;
            proxy_cookie_path /manager/ /;
            proxy_set_header   Referer $http_referer;
            proxy_set_header   Cookie $http_cookie;
            proxy_connect_timeout 10;
            proxy_send_timeout 10;
            proxy_read_timeout 10;
            proxy_set_header   X-Real-IP  $remote_addr;
            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
 }
@@ -1,67 +1,79 @@
-# 编译esp32固件
+# esp32固件编译
-## 第1步 配置环境
+## 第1步 准备你的ota地址
 如果你，使用的是本项目0.3.12版本，不管是简单Server部署还是全模块部署，都会有ota地址。
 由于简单Server部署和全模块部署的OTA地址设置方式不一样，请你选择下面的具体方式：
 ### 如果你用的是简单Server部署
 此刻，请你用浏览器打开你的ota地址，例如我的ota地址
 ```
 http://192.168.1.25:8002/xiaozhi/ota/
 ```
 如果显示“OTA接口运行正常，向设备发送的websocket地址是：ws://xxx:8000/xiaozhi/v1/
 你可以使用项目自带的`test_page.html`测试一下，是否能连上ota页面输出的websocket地址。
 如果访问不到，你需要到配置文件`.config.yaml`里修改`server.websocket`的地址，重启后再重新测试，直到`test_page.html`能正常访问。
 成功后，请往下进行第2步
 ### 如果你用的是全模块部署
 此刻，请你用浏览器打开你的ota地址，例如我的ota地址
 ```
 http://192.168.1.25:8002/xiaozhi/ota/
 ```
 如果显示“OTA接口运行正常，websocket集群数量：X”。那就往下进行2步。
 如果显示“OTA接口运行不正常”，大概是你还没在`智控台`配置`Websocket`地址。那就：
 - 1、使用超级管理员登录智控台
 - 2、顶部菜单点击`参数管理`
 - 3、在列表中找到`server.websocket`项目，输入你的`Websocket`地址。例如我的就是
 ```
 ws://192.168.1.25:8000/xiaozhi/v1/
 ```
 配置完后，再使用浏览器刷新你的ota接口地址，看看是不是正常了。如果还不正常就，就再次确认一下Websocket是否正常启动，是否配置了Websocket地址。
 ## 第2步 配置环境
 先按照这个教程配置项目环境[《Windows搭建 ESP IDF 5.3.2开发环境以及编译小智》](https://icnynnzcwou8.feishu.cn/wiki/JEYDwTTALi5s2zkGlFGcDiRknXf)
-## 第2步 打开配置文件
+## 第3步 打开配置文件
-配置好编译环境后，下载虾哥[xiaozhi-esp32](https://github.com/78/xiaozhi-esp32)项目源码，进入虾哥项目，打开`xiaozhi-esp32/main/Kconfig.projbuild`文件。
+配置好编译环境后，下载虾哥iaozhi-esp32项目源码，
-## 第3步 修改WEBSOCKET地址
+从这里下载虾哥[xiaozhi-esp32项目源码](https://github.com/78/xiaozhi-esp32)。
 找到`WEBSOCKET_URL`的`default`的内容，把`wss://api.tenclass.net/xiaozhi/v1/`
   改成你自己的地址，例如，我的接口地址是`ws://192.168.1.25:8000/xiaozhi/v1/`，就把内容改成这个。
-修改前：
+下载后，打开`xiaozhi-esp32/main/Kconfig.projbuild`文件。
 ```
 config WEBSOCKET_URL
    depends on CONNECTION_TYPE_WEBSOCKET
    string "Websocket URL"
    default "wss://api.tenclass.net/xiaozhi/v1/"
    help
        Communication with the server through websocket after wake up.
 ```
 修改后(示例)：
 ```
 config WEBSOCKET_URL
    depends on CONNECTION_TYPE_WEBSOCKET
    string "Websocket URL"
    default "ws://192.168.1.25:8000/xiaozhi/v1/"
    help
        Communication with the server through websocket after wake up.
 ```
 注意：你的地址是`ws://`开头，不是`wss://`开头，一定不要写错了。
 注意：你的地址是`ws://`开头，不是`wss://`开头，一定不要写错了。
 注意：你的地址是`ws://`开头，不是`wss://`开头，一定不要写错了。
 ## 第4步 修改OTA地址
 如果你是全模块部署本项目，就修改OTA接口，如果你只是部署了8000端口的xiaozhi-server，可以继续沿用虾哥团队的OTA接口。如果你不修改OTA接口，请直接忽略本第4步，直接看第5步
-找到`OTA_VERSION_URL`的`default`的内容，把`https://api.tenclass.net/xiaozhi/ota/`
+找到`OTA_URL`的`default`的内容，把`https://api.tenclass.net/xiaozhi/ota/`
   改成你自己的地址，例如，我的接口地址是`http://192.168.1.25:8002/xiaozhi/ota/`，就把内容改成这个。
 修改前：
 ```
-config OTA_VERSION_URL
+config OTA_URL
-    string "OTA Version URL"
+    string "Default OTA URL"
    default "https://api.tenclass.net/xiaozhi/ota/"
    help
-        The application will access this URL to check for updates.
+        The application will access this URL to check for new firmwares and server address.
 ```
 修改后：
 ```
-config OTA_VERSION_URL
+config OTA_URL
-    string "OTA Version URL"
+    string "Default OTA URL"
    default "http://192.168.1.25:8002/xiaozhi/ota/"
    help
-        The application will access this URL to check for updates.
+        The application will access this URL to check for new firmwares and server address.
 ```
-## 第5步 设置编译参数
+## 第4步 设置编译参数
 设置编译参数
@@ -74,40 +86,29 @@ idf.py set-target esp32s3
 idf.py menuconfig
 ```
-![图片](images/build_setting01.png)
+进入菜单配置后，再进入`Xiaozhi Assistant`，将`BOARD_TYPE`设置你板子的具体型号
 进入菜单配置后，再进入`Xiaozhi Assistant`，将`CONNECTION_TYPE`设置为`Websocket`
 回退到主菜单，再进入`Xiaozhi Assistant`，将`BOARD_TYPE`设置你板子的具体型号
 保存退出，回到终端命令行。
-![图片](images/build_setting02.png)
+## 第5步 编译固件
 ## 第6步 编译固件
 ```
 idf.py build
 ```
-如果是vscode安装的idf可以使用`F1`或者`ctrl+shift+p`,输入idf然后直接选择进行编译
+## 第6步 打包bin固件
 还可以直接进行烧录不用接下来的操作
 <img src="./images/vscode_idf.png" width="500px"/>
 ## 第7步 打包bin固件
 ```
 cd scripts
 python release.py
 ```
-编译成功后，会在项目根目录下的`build`目录下生成固件文件`merged-binary.bin`。
+上面的打包命令执行完成后，会在项目根目录下的`build`目录下生成固件文件`merged-binary.bin`。
 这个`merged-binary.bin`就是要烧录到硬件上的固件文件。
 注意：如果执行到第二命令后，报了“zip”相关的错误，请忽略这个错误，只要`build`目录下生成固件文件`merged-binary.bin`
 ，对你没有太大影响，请继续。
-## 第8步 烧录固件
+## 第7步 烧录固件
   将esp32设备连接电脑，使用chrome浏览器，打开以下网址
 ```
@@ -0,0 +1,54 @@
 # 基于虾哥编译好的固件配置自定义服务器
 ## 第1步 确认版本
 烧录虾哥已经编译好的[1.6.1版本以上固件](https://github.com/78/xiaozhi-esp32/releases)
 ## 第2步 准备你的ota地址
 如果你按照教程使用的是全模块部署，就应该会有ota地址。
 此刻，请你用浏览器打开你的ota地址，例如我的ota地址
 ```
 https://2662r3426b.vicp.fun/xiaozhi/ota/
 ```
 如果显示“OTA接口运行正常，websocket集群数量：X”。那就往下。
 如果显示“OTA接口运行不正常”，大概是你还没在`智控台`配置`Websocket`地址。那就：
 - 1、使用超级管理员登录智控台
 - 2、顶部菜单点击`参数管理`
 - 3、在列表中找到`server.websocket`项目，输入你的`Websocket`地址。例如我的就是
 ```
 wss://2662r3426b.vicp.fun/xiaozhi/v1/
 ```
 配置完后，再使用浏览器刷新你的ota接口地址，看看是不是正常了。如果还不正常就，就再次确认一下Websocket是否正常启动，是否配置了Websocket地址。
 ## 第3步 进入配网模式
 进入机器的配网模式，在页面顶部，点击“高级选项”，在里面输入你服务器的`ota`地址，点击保存。重启设备
 ![请参考-OTA地址设置](../docs/images/firmware-setting-ota.png)
 ## 第4步 唤醒小智，查看日志输出
 唤醒小智，看看日志是不是正常输出。
 ## 常见问题
 以下是一些常见问题，供参考：
 [1、为什么我说的话，小智识别出来很多韩文、日文、英文](./FAQ.md)
 [2、为什么会出现“TTS 任务出错 文件不存在”？](./FAQ.md)
 [3、TTS 经常失败，经常超时](./FAQ.md)
 [4、使用Wifi能连接自建服务器，但是4G模式却接不上](./FAQ.md)
 [5、如何提高小智对话响应速度？](./FAQ.md)
 [6、我说话很慢，停顿时小智老是抢话](./FAQ.md)
 [7、我想通过小智控制电灯、空调、远程开关机等操作](./FAQ.md)
@@ -0,0 +1,72 @@
 登录AutoDL，租赁镜像
 选择镜像:
 ```
 PyTorch / 2.1.0 / 3.10(ubuntu22.04) / cuda 12.1
 ```
 机器开机后，设置学术加速
 ```
 source /etc/network_turbo
 ```
 进入工作目录
 ```
 cd autodl-tmp/
 ```
 拉取项目
 ```
 git clone https://gitclone.com/github.com/fishaudio/fish-speech.git ; cd fish-speech
 ```
 安装依赖
 ```
 pip install -e.
 ```
 如果报错，安装portaudio
 ```
 apt-get install portaudio19-dev -y
 ```
 安装后执行
 ```
 pip install torch==2.3.1 torchvision==0.18.1 torchaudio==2.3.1 --index-url https://download.pytorch.org/whl/cu121
 ```
 下载模型
 ```
 cd tools
 python download_models.py 
 ```
 下载完模型后运行接口
 ```
 python -m tools.api_server --listen 0.0.0.0:6006 
 ```
 然后用浏览器去到aotodl实例页面
 ```
 https://autodl.com/console/instance/list
 ```
 如下图点击你刚才机器的`自定义服务`按钮，开启端口转发服务
 ![自定义服务](images/fishspeech/autodl-01.png)
 端口转发服务设置完成后，你本地电脑打开网址`http://localhost:6006/`，就可以访问fish-speech的接口了
 ![服务预览](images/fishspeech/autodl-02.png)
 如果你是单模块部署，核心配置如下
 ```
 selected_module:
  TTS: FishSpeech
 TTS:
  FishSpeech:
    reference_audio: ["config/assets/wakeup_words.wav",]
    reference_text: ["哈啰啊，我是小智啦，声音好听的台湾女孩一枚，超开心认识你耶，最近在忙啥，别忘了给我来点有趣的料哦，我超爱听八卦的啦",]
    api_key: "123"
    api_url: "http://127.0.0.1:6006/v1/tts"
 ```
 然后重启服务
@@ -0,0 +1,248 @@
 # 小智ESP32-开源服务端与HomeAssistant集成指南
 [TOC]
 -----
 ## 简介
 本文档将指导您如何将ESP32设备与HomeAssistant进行集成。
 ## 前提条件
 - 已安装并配置好`HomeAssistant`
 - 本次我选择的模型是：免费的ChatGLM，它支持functioncall函数调用
 ## 开始前的操作（必要）
 ### 1. 获取HA的网络网络地址信息
 请访问你Home Assistant的网络地址，例如，我的HA的地址是192.168.4.7，端口则是默认的8123，则在浏览器打开
 ```
 http://192.168.4.7:8123
 ```
 > 手动查询 HA 的 IP 地址方法**（仅限小智esp32-server和HA部署在同一个网络设备[例如同一个wifi]下）**：
 >
 > 1. 进入 Home Assistant（前端）。
 >
 > 2. 点击左下角 **设置（Settings）** → **系统（System）** → **网络（Network）**。
 >
 > 3. 滑到最底部`Home Assistant 网址(Home Assistant website)`区域，在`本地网络(local network)`中，点击`眼睛`按钮，可以看到当前使用的 IP 地址（如 `192.168.1.10`）和网络接口。点击`复制连接(copy link)`可以直接复制。
 >
 >    ![image-20250504051716417](images/image-ha-integration-01.png)
 或，您已经设置了直接可以访问的Home Assistant的OAuth地址，您也可以在浏览器内直接访问
 ```
 http://homeassistant.local:8123
 ```
 ### 2. 登录`Home Assistant`拿到开发密钥
 登录`HomeAssistant`，点击`左下角头像 -> 个人`，切换`安全`导航栏，划到底部`长期访问令牌`生成api_key，并复制保存，后续的方法都需要使用这个api key且仅出现一次（小tips: 您可以保存生成的二维码图像，后续可以扫描二维码再此提取api key）。
 ## 方法1：小智社区共建的HA调用功能
 ### 功能描述
 - 如您后续需要增加新的设备，该方法需要手动重启`xiaozhi-esp32-server服务端`以此更新设备信息**（重要**）。
 - 需要您确保已经在HomeAssistant中集成`Xiaomi Home`，并将米家的设备导入进`HomeAssistant`。
 - 需要您确保`xiaozhi-esp32-server智控台`能正常使用。
 - 我的`xiaozhi-esp32-server智控台`和`HomeAssistant`部署在同一台机器的另一个端口，版本是`0.3.10`
  ```
  http://192.168.4.7:8002
  ```
 ### 配置步骤
 #### 1. 登录`HomeAssistant`整理需要控制的设备清单
 登录`HomeAssistant`，点击`左下角的设置`，然后进入`设备与服务`，再点击顶部的`实体`。
 然后在实体中搜索你相关控制的开关，结果出来后，在列表中，点击其中一个结果，这是会出现一个开关的界面。
 在开关的界面，我们尝试点击开关，看看是开发会随着我们的点击开/关。如果能操作，说明是正常联网的。
 接着在开关面板找到设置按钮，点击后，可以查看这个开关的`实体标识符`。
 我们打开一个记事本，按照这样格式整理一条数据：
 位置+英文逗号+设备名称+英文逗号+`实体标识符`+英文分号
 例如，我在公司，我有一个玩具灯，他的标识符是switch.cuco_cn_460494544_cp1_on_p_2_1，那么就这个写这一条数据
 ```
 公司,玩具灯,switch.cuco_cn_460494544_cp1_on_p_2_1;
 ```
 当然最后我可能要操作两个灯，我的最终的结果是：
 ```
 公司,玩具灯,switch.cuco_cn_460494544_cp1_on_p_2_1;
 公司,台灯,switch.iot_cn_831898993_socn1_on_p_2_1;
 ```
 这段字符，我们成为“设备清单字符”需要保存好，等一下有用。
 #### 2. 登录`智控台`
 使用管理员账号，登录`智控台`。点击顶部菜单`参数管理`，搜索`plugins.home_assistant.`，会有三条结果出来
 编辑`plugins.home_assistant.devices`，把刚才整理的设备清单字符粘贴进去。
 编辑`plugins.home_assistant.base_url`，把你部署的`HomeAssistant`接口地址粘贴进去，我粘贴进去的地址是这样的
 ```
 http://192.168.4.7:8123
 ```
 编辑`plugins.home_assistant.api_key`，把你从`HomeAssistant`复制过来的密钥，粘贴进去
 #### 3. 设置`意图识别`函数
 在智控台，点击顶部菜单“模型配置”，在左侧栏，找到“意图识别”，找到id为`Intent_function_call`的意图，点击编辑
 然后在弹框中，在原来的基础上追加两个函数：“hass_get_state”和“hass_set_state”
 修改前
 ```
 change_role;get_weather;get_news;play_music
 ```
 修改后
 ```
 change_role;get_weather;get_news;play_music;hass_get_state;hass_set_state
 ```
 #### 4. 手动重启xiaozhi-server
 重启xiaozhi-server程序
 #### 5. 确认角色配置是否设置了函数意图识别
 在智控台，点击顶部菜单“智能体管理”，找到设备所在的智能体，点击“配置角色”
 确认意图识别(Intent)，是否选择“函数调用意图识别”
 #### 6. 唤醒设别进行控制
 尝试和esp32说，“打开XXX灯”
 ## 方法2：小智将Home Assistant的语音助手作为LLM工具
 ### 功能描述
 - 该方法有一个比较严重的缺点——**该方法无法使用小智开源生态的function_call插件功能的能力**，因为使用Home Assistant作为小智的LLM工具会将意图识别能力转让给Home Assistant。但是**这个方法是能体验到原生的Home Assistant操作功能，且小智的聊天能力不变**。如实在介意可以使用同样是Home Assistant支持的[方法3](##方法3：使用Home Assistant的MCP服务（推荐）)，能够最大程度体验到Home Assistant的功能。
 ### 配置步骤：
 #### 1. 配置Home Assistant的大模型语音助手。
 **需要您提前配置好Home Assistant的语音助手或大模型工具。**
 #### 2. 获取Home Assistant的语言助手的Agent ID.
 1. 进入Home Assistant页面内。左侧点击`开发者助手`。
 2. 在打开的`开发者助手`内，点击`动作`选项卡（如图示操作1），在页面内的选项栏`动作`中，找到或输入`conversation.process（对话-处理）`并选择`对话（conversation）: 处理`（如图示操作2）。
 ![image-20250504043539343](images/image-ha-integration-02.png)
 3. 在页面内勾选`代理(agent)`选项，在变成常亮的`对话代理(conversation agent)`内选择您步骤一配置好的语音助手名称，如图示，我这边配置好的是`ZhipuAi`并选择。
 ![image-20250504043854760](images/image-ha-integration-03.png)
 4. 选中后，点击表单左下方的`进入YAML模式`。
 ![image-20250504043951126](images/image-ha-integration-04.png)
 5. 复制其中的agent-id的值，例如图示中我的是`01JP2DYMBDF7F4ZA2DMCF2AGX2`(仅供参考)。
 ![image-20250504044046466](images/image-ha-integration-05.png)
 6. 切换到小智开源服务端`xiaozhi-esp32-server`的`config.yaml`文件内，在LLM配置中，找到Home Assistant，设置您的Home Assistant的网络地址，Api key和刚刚查询到的agent_id。
 7. 修改`config.yaml`文件内的`selected_module`属性的`LLM`为`HomeAssistant`，`Intent`为`nointent`。
 8. 重启小智开源服务端`xiaozhi-esp32-server`即可正常使用。
 ## 方法3：使用Home Assistant的MCP服务（推荐）
 ### 功能描述
 - 需要您提前在Home Assistant内集成并安装好HA集成——[Model Context Protocol Server](https://www.home-assistant.io/integrations/mcp_server/)。
 - 这个方法与方法2都是HA官方提供的解决方法，与方法2不同的是，您可以正常使用小智开源服务端`xiaozhi-esp32-server`的开源共建的插件，同时允许您随意使用任何一个支持function_call功能的LLM大模型。
 ### 配置步骤
 #### 1. 安装Home Assistant的MCP服务集成。
 集成官方网址——[Model Context Protocol Server](https://www.home-assistant.io/integrations/mcp_server/)。。
 或跟随以下手动操作。
 > - 前往Home Assistant页面的**[设置 > 设备和服务（Settings > Devices & Services.）](https://my.home-assistant.io/redirect/integrations)**。
 >
 > - 在右下角，选择 **[添加集成（Add Integration）](https://my.home-assistant.io/redirect/config_flow_start?domain=mcp_server)**按钮。
 >
 > - 从列表中选择**模型上下文协议服务器（Model Context Protocol Server）**。
 >
 > - 按照屏幕上的说明完成设置。
 #### 2. 配置小智开源服务端MCP配置信息
 切换到小智开源服务端`xiaozhi-esp32-server`的`mcp_server_settings.json`文件内，在`"mcpServers"`的括号内添加以下内容：
 ```json
 "Home Assistant": {
      "command": "mcp-proxy",
      "args": [
        "http://YOUR_HA_HOST/mcp_server/sse"
      ],
      "env": {
        "API_ACCESS_TOKEN": "YOUR_API_ACCESS_TOKEN"
      }
 },
 ```
 注意：
 1. **替换配置：**
   - 替换`args`内的`YOUR_HA_HOST`为您的HA服务地址，如果你的服务地址已经包含了https/http字样（例如`http://192.168.1.101:8123`)，则只需要填入`192.168.1.101:8123`即可。
   - 将`env`内`API_ACCESS_TOKEN`的`YOUR_API_ACCESS_TOKEN`替换成您之前获取到的开发密钥api key。
 2. **如果你添加配置是在`"mcpServers"`的括号内后续没有新的`mcpServers`的配置时，需要把最后的逗号`,`移除**，否则可能会解析失败。
 **最后效果参考以下（参考如下）**：
 ```json
 "mcpServers": {
    "Home Assistant": {
      "command": "mcp-proxy",
      "args": [
        "http://192.168.1.101:8123/mcp_server/sse"
      ],
      "env": {
        "API_ACCESS_TOKEN": "abcd.efghi.jkl"
      }
    }
  }
 ```
 #### 3. 配置小智开源服务端的系统配置
 1. **选择任意一款支持function_call的LLM大模型作为小智的LLM聊天助手（但不要选择Home Assistant作为LLM工具）**，本次我选择的模型是：免费的ChatGLM，它支持functioncall函数调用，但部分时候调用不太稳定，如果像追求稳定建议把LLM设置成：DoubaoLLM，使用的具体model_name是：doubao-1-5-pro-32k-250115。
 2. 切换到小智开源服务端`xiaozhi-esp32-server`的`config.yaml`文件内，设置您的LLM大模型配置，并且将`selected_module`配置的`Intent`调整为`function_call`。
 3. 重启小智开源服务端`xiaozhi-esp32-server`即可正常使用。
@@ -0,0 +1,171 @@
 # 视觉模型使用指南
 本教程分为两部分：
 - 第一部分：单模块运行xiaozhi-server开启视觉模型
 - 第二部分：全模块运行时，如何开启视觉模型
 开启视觉模型前，你需要准备三件事：
 - 你需要准备一台带摄像头的设备，而且这台设备已经在虾哥仓库里，实现了调用摄像头功能。例如`立创·实战派ESP32-S3开发板`
 - 你设备固件的版本升级到1.6.6及以上
 - 你已经成功跑通基础对话模块
 ## 单模块运行xiaozhi-server开启视觉模型
 ### 第一步确认网络
 由于视觉模型会默认启动8003端口。
 如果你是docker运行，请确认一下你的`docker-compose.yml`是否放了`8003`端口，如果没有就更新最新的`docker-compose.yml`文件
 如果你是源码运行，确认防火墙是否放行`8003`端口
 ### 第二步选择你的视觉模型
 打开你的`data/.config.yaml`文件，设置你的`selected_module.VLLM`设置为某个视觉模型。目前我们已经支持`openai`类型接口的视觉模型。`ChatGLMVLLM`就是其中一款兼容`openai`的模型。
 ```
 selected_module:
  VAD: ..
  ASR: ..
  LLM: ..
  VLLM: ChatGLMVLLM
  TTS: ..
  Memory: ..
  Intent: ..
 ```
 假设我们使用`ChatGLMVLLM`作为视觉模型，那我们需要先登录[智谱AI](https://bigmodel.cn/usercenter/proj-mgmt/apikeys)网站，申请密钥。如果你之前已经申请过了密钥，可以复用这个密钥。
 在你的配置文件中，增加这个配置，如果已经有了这个配置，就设置好你的api_key。
 ```
 VLLM:
  ChatGLMVLLM:
    api_key: 你的api_key
 ```
 ### 第三步启动xiaozhi-server服务
 如果你是源码，就输入命令启动
 ```
 python app.py
 ```
 如果你是docker运行，就重启容器
 ```
 docker restart xiaozhi-esp32-server
 ```
 启动后会输出以下内容的日志。
 ```
 2025-06-01 **** - OTA接口是           http://192.168.4.7:8003/xiaozhi/ota/
 2025-06-01 **** - 视觉分析接口是        http://192.168.4.7:8003/mcp/vision/explain
 2025-06-01 **** - Websocket地址是       ws://192.168.4.7:8000/xiaozhi/v1/
 2025-06-01 **** - =======上面的地址是websocket协议地址，请勿用浏览器访问=======
 2025-06-01 **** - 如想测试websocket请用谷歌浏览器打开test目录下的test_page.html
 2025-06-01 **** - =============================================================
 ```
 启动后，使用使用浏览器打开日志里`视觉分析接口`连接。看看输出了什么？如果你是linux,没有浏览器，你可以执行这个命令：
 ```
 curl -i 你的视觉分析接口
 ```
 正常来说会这样显示
 ```
 MCP Vision 接口运行正常，视觉解释接口地址是：http://xxxx:8003/mcp/vision/explain
 ```
 请注意，如果你是公网部署，或者docker部署，一定要改一下你的`data/.config.yaml`里这个配置
 ```
 server:
  vision_explain: http://你的ip或者域名:端口号/mcp/vision/explain
 ```
 为什么呢？因为视觉解释接口需要下发到设备，如果你的地址是局域网地址，或者是docker内部地址，设备是无法访问的。
 假设你的公网地址是`111.111.111.111`，那么`vision_explain`应该这么配
 ```
 server:
  vision_explain: http://111.111.111.111:8003/mcp/vision/explain
 ```
 如果你的MCP Vision 接口运行正常，且你也试着用浏览器访问正常打开下发的`视觉解释接口地址`，请继续下一步
 ### 第四步 设备唤醒开启
 对设备说“请打开摄像头，说你你看到了什么”
 留意xiaozhi-server的日志输出，看看有没有报错。
 ## 全模块运行时，如何开启视觉模型
 ### 第一步 确认网络
 由于视觉模型会默认启动8003端口。
 如果你是docker运行，请确认一下你的`docker-compose_all.yml`是否映射了`8003`端口，如果没有就更新最新的`docker-compose_all.yml`文件
 如果你是源码运行，确认防火墙是否放行`8003`端口
 ### 第二步 确认你配置文件
 打开你的`data/.config.yaml`文件，确认一下你的配置文件的结构，是否和`data/config_from_api.yaml`一样。如果不一样，或缺少某项，请补齐。
 ### 第三步 配置视觉模型密钥
 那我们需要先登录[智谱AI](https://bigmodel.cn/usercenter/proj-mgmt/apikeys)网站，申请密钥。如果你之前已经申请过了密钥，可以复用这个密钥。
 登录`智控台`，顶部菜单点击`模型配置`，在左侧栏点击`视觉打语言模型`，找到`VLLM_ChatGLMVLLM`，点击修改按钮，在弹框中，在`API密钥`输入你密钥，点击保存。
 保存成功后，去到你需要测试的智能体哪里，点击`配置角色`，在打开的内容里，查看`视觉大语言模型(VLLM)`是否选择了刚才的视觉模型。点击保存。
 ### 第三步 启动xiaozhi-server模块
 如果你是源码，就输入命令启动
 ```
 python app.py
 ```
 如果你是docker运行，就重启容器
 ```
 docker restart xiaozhi-esp32-server
 ```
 启动后会输出以下内容的日志。
 ```
 2025-06-01 **** - 视觉分析接口是        http://192.168.4.7:8003/mcp/vision/explain
 2025-06-01 **** - Websocket地址是       ws://192.168.4.7:8000/xiaozhi/v1/
 2025-06-01 **** - =======上面的地址是websocket协议地址，请勿用浏览器访问=======
 2025-06-01 **** - 如想测试websocket请用谷歌浏览器打开test目录下的test_page.html
 2025-06-01 **** - =============================================================
 ```
 启动后，使用使用浏览器打开日志里`视觉分析接口`连接。看看输出了什么？如果你是linux,没有浏览器，你可以执行这个命令：
 ```
 curl -i 你的视觉分析接口
 ```
 正常来说会这样显示
 ```
 MCP Vision 接口运行正常，视觉解释接口地址是：http://xxxx:8003/mcp/vision/explain
 ```
 请注意，如果你是公网部署，或者docker部署，一定要改一下你的`data/.config.yaml`里这个配置
 ```
 server:
  vision_explain: http://你的ip或者域名:端口号/mcp/vision/explain
 ```
 为什么呢？因为视觉解释接口需要下发到设备，如果你的地址是局域网地址，或者是docker内部地址，设备是无法访问的。
 假设你的公网地址是`111.111.111.111`，那么`vision_explain`应该这么配
 ```
 server:
  vision_explain: http://111.111.111.111:8003/mcp/vision/explain
 ```
 如果你的MCP Vision 接口运行正常，且你也试着用浏览器访问正常打开下发的`视觉解释接口地址`，请继续下一步
 ### 第四步 设备唤醒开启
 对设备说“请打开摄像头，说你你看到了什么”
 留意xiaozhi-server的日志输出，看看有没有报错。
@@ -16,4 +16,4 @@ https://ccnphfhqs21z.feishu.cn/wiki/M0XiwldO9iJwHikpXD5cEx71nKh
 # manager-web 、manager-api接口协议
-https://2662r3426b.vicp.fun/xiaozhi/v1/doc.html
+https://2662r3426b.vicp.fun/xiaozhi/doc.html
@@ -28,6 +28,8 @@
        <captcha.version>1.6.2</captcha.version>
        <guava.version>33.0.0-jre</guava.version>
        <liquibase-core.version>4.20.0</liquibase-core.version>
        <aliyun-sms-version>4.1.0</aliyun-sms-version>
        <okio-version>3.4.0</okio-version>
    </properties>
    <dependencies>
@@ -37,6 +39,7 @@
            <classifier>jakarta</classifier>
            <version>${shiro.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
@@ -197,6 +200,22 @@
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-jsr310</artifactId>
        </dependency>
        <!-- 阿里云短信sdk -->
        <dependency>
            <groupId>com.aliyun</groupId>
            <artifactId>dysmsapi20170525</artifactId>
            <version>${aliyun-sms-version}</version>
        </dependency>
        <!-- 阿里云短信sdk使用的okio:1.15.0版本有安全漏洞：GHSA-w33c-445m-f8w7 现在升级成3.4.0安全版本-->
        <dependency>
            <groupId>com.squareup.okio</groupId>
            <artifactId>okio</artifactId>
            <version>${okio-version}</version>
        </dependency>
    </dependencies>
    <!-- 阿里云maven仓库 -->
@@ -239,4 +258,4 @@
            </plugin>
        </plugins>
    </build>
-</project>
+</project>
@@ -0,0 +1,40 @@
 package xiaozhi.common.config;
 import java.util.concurrent.Executor;
 import java.util.concurrent.RejectedExecutionHandler;
 import java.util.concurrent.ThreadPoolExecutor;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.EnableAspectJAutoProxy;
 import org.springframework.scheduling.annotation.EnableAsync;
 import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
@Configuration
@EnableAsync
@EnableAspectJAutoProxy(exposeProxy = true)
 public class AsyncConfig {
    @Bean(name = "taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(4);
        executor.setQueueCapacity(1000);
        executor.setThreadNamePrefix("AsyncThread-");
        // 设置拒绝策略：由调用线程执行
        executor.setRejectedExecutionHandler(new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                try {
                    // 如果线程池已满，则由调用线程执行
                    r.run();
                } catch (Exception e) {
                    throw new RuntimeException("执行异步任务失败", e);
                }
            }
        });
        executor.initialize();
        return executor;
    }
 }
@@ -0,0 +1,17 @@
 package xiaozhi.common.config;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.client.RestTemplate;
 /**
 * RestTemplate配置
 */
@Configuration
 public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
 }
@@ -1,5 +1,7 @@
 package xiaozhi.common.constant;
 import lombok.Getter;
 /**
 * 常量
 * Copyright (c) 人人开源 All rights reserved.
@@ -84,6 +86,16 @@ public interface Constant {
     */
    String SERVER_SECRET = "server.secret";
    /**
     * websocket地址
     */
    String SERVER_WEBSOCKET = "server.websocket";
    /**
     * ota地址
     */
    String SERVER_OTA = "server.ota";
    /**
     * 是否允许用户注册
     */
@@ -99,31 +111,24 @@ public interface Constant {
     */
    String FILE_EXTENSION_SEG = ".";
    /**
     * 无记忆
     */
    String MEMORY_NO_MEM = "Memory_nomem";
    enum SysBaseParam {
        /**
-         * 系统全称
+         * ICP备案号
         */
-        SYS_NAME("SYS_NAME"),
+        BEIAN_ICP_NUM("server.beian_icp_num"),
        /**
-         * 系统简称
+         * GA备案号
         */
-        SYS_SHORT_NAME("SYS_SHORT_NAME"),
+        BEIAN_GA_NUM("server.beian_ga_num"),
        /**
-         * 系统描述
+         * 系统名称
         */
-        SYS_DES("SYS_DES"),
+        SERVER_NAME("server.name");
        /**
         * 登录失败几次锁定
         */
        LOGIN_LOCK_COUNT("LOGIN_LOCK_COUNT"),
        /**
         * 账号失败锁定分钟数
         */
        LOGIN_LOCK_TIME("LOGIN_LOCK_TIME"),
        /**
         * TOKEN强验证
         */
        SYS_TOKEN_SECURITY("SYS_TOKEN_SECURITY");
        private String value;
@@ -136,6 +141,46 @@ public interface Constant {
        }
    }
    /**
     * 系统短信
     */
    enum SysMSMParam {
        /**
         * 阿里云授权keyID
         */
        ALIYUN_SMS_ACCESS_KEY_ID("aliyun.sms.access_key_id"),
        /**
         * 阿里云授权密钥
         */
        ALIYUN_SMS_ACCESS_KEY_SECRET("aliyun.sms.access_key_secret"),
        /**
         * 阿里云短信签名
         */
        ALIYUN_SMS_SIGN_NAME("aliyun.sms.sign_name"),
        /**
         * 阿里云短信模板
         */
        ALIYUN_SMS_SMS_CODE_TEMPLATE_CODE("aliyun.sms.sms_code_template_code"),
        /**
         * 单号码最大短信发送条数
         */
        SERVER_SMS_MAX_SEND_COUNT("server.sms_max_send_count"),
        /**
         * 是否开启手机注册
         */
        SERVER_ENABLE_MOBILE_REGISTER("server.enable_mobile_register");
        private String value;
        SysMSMParam(String value) {
            this.value = value;
        }
        public String getValue() {
            return value;
        }
    }
    /**
     * 数据状态
     */
@@ -164,8 +209,48 @@ public interface Constant {
        }
    }
    @Getter
    enum ChatHistoryConfEnum {
        IGNORE(0, "不记录"),
        RECORD_TEXT(1, "记录文本"),
        RECORD_TEXT_AUDIO(2, "文本音频都记录");
        private final int code;
        private final String name;
        ChatHistoryConfEnum(int code, String name) {
            this.code = code;
            this.name = name;
        }
    }
    /**
     * 版本号
     */
-    public static final String VERSION = "0.3.8";
+    public static final String VERSION = "0.5.2";
    /**
     * 无效固件URL
     */
    String INVALID_FIRMWARE_URL = "http://xiaozhi.server.com:8002/xiaozhi/otaMag/download/NOT_ACTIVATED_FIRMWARE_THIS_IS_A_INVALID_URL";
    /**
     * 字典类型
     */
    enum DictType {
        /**
         * 手机区号
         */
        MOBILE_AREA("MOBILE_AREA");
        private String value;
        DictType(String value) {
            this.value = value;
        }
        public String getValue() {
            return value;
        }
    }
 }
@@ -20,7 +20,7 @@ public interface ErrorCode {
    int ACCOUNT_DISABLE = 10005;
    int IDENTIFIER_NOT_NULL = 10006;
    int CAPTCHA_ERROR = 10007;
-    int SUB_MENU_EXIST = 10008;
+    int PHONE_NOT_NULL = 10008;
    int PASSWORD_ERROR = 10009;
    int SUPERIOR_DEPT_ERROR = 10011;
@@ -1,7 +1,12 @@
 package xiaozhi.common.exception;
 import java.util.List;
 import java.util.Objects;
 import org.apache.shiro.authz.UnauthorizedException;
 import org.springframework.dao.DuplicateKeyException;
 import org.springframework.validation.ObjectError;
 import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
 import org.springframework.web.servlet.resource.NoResourceFoundException;
@@ -60,4 +65,20 @@ public class RenExceptionHandler {
        return new Result<Void>().error(404, "资源不存在");
    }
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Result<Void> handleMethodArgumentNotValidException(MethodArgumentNotValidException ex) {
        List<ObjectError> allErrors = ex.getBindingResult().getAllErrors();
        String errorMsg = allErrors.stream()
                .filter(Objects::nonNull)
                .map(err -> {
                    String msg = err.getDefaultMessage();
                    return (msg != null && !msg.trim().isEmpty()) ? msg : null;
                })
                .filter(Objects::nonNull)
                .findFirst()
                .orElse("请求参数错误！");
        return new Result<Void>().error(ErrorCode.PARAM_VALUE_NULL, errorMsg);
    }
 }
@@ -62,6 +62,13 @@ public class RedisKeys {
        return "agent:device:count:" + id;
    }
    /**
     * 获取智能体最后连接时间缓存key
     */
    public static String getAgentDeviceLastConnectedAtById(String id) {
        return "agent:device:lastConnected:" + id;
    }
    /**
     * 获取系统配置缓存key
     */
@@ -80,6 +87,56 @@ public class RedisKeys {
     * 获取版本号Key
     */
    public static String getVersionKey() {
-        return "system:version";
+        return "sys:version";
    }
    /**
     * OTA固件ID的Key
     */
    public static String getOtaIdKey(String uuid) {
        return "ota:id:" + uuid;
    }
    /**
     * OTA固件下载次数的Key
     */
    public static String getOtaDownloadCountKey(String uuid) {
        return "ota:download:count:" + uuid;
    }
    /**
     * 获取字典数据的缓存key
     */
    public static String getDictDataByTypeKey(String dictType) {
        return "sys:dict:data:" + dictType;
    }
    /**
     * 获取智能体音频ID的缓存key
     */
    public static String getAgentAudioIdKey(String uuid) {
        return "agent:audio:id:" + uuid;
    }
    /**
     * 获取短信验证码的缓存key
     */
    public static String getSMSValidateCodeKey(String phone) {
        return "sms:Validate:Code:" + phone;
    }
    /**
     * 获取短信验证码最后发送时间的缓存key
     */
    public static String getSMSLastSendTimeKey(String phone) {
        return "sms:Validate:Code:" + phone + ":last_send_time";
    }
    /**
     * 获取短信验证码今日发送次数的缓存key
     */
    public static String getSMSTodayCountKey(String phone) {
        return "sms:Validate:Code:" + phone + ":today_count";
    }
 }
@@ -6,12 +6,14 @@ import java.util.List;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.HashOperations;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.core.script.DefaultRedisScript;
 import org.springframework.stereotype.Component;
 import jakarta.annotation.Resource;
 import xiaozhi.common.utils.ResourcesUtils;
 /**
 * Redis工具类
@@ -23,6 +25,9 @@ public class RedisUtils {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private ResourcesUtils resourceUtils;
    /**
     * 默认过期时长为24小时，单位：秒
     */
@@ -40,6 +45,24 @@ public class RedisUtils {
     */
    public final static long NOT_EXPIRE = -1L;
    public Long increment(String key, long expire) {
        Long increment = redisTemplate.opsForValue().increment(key, 1L);
        if (expire != NOT_EXPIRE) {
            expire(key, expire);
        }
        return increment;
    }
    public Long increment(String key) {
        return redisTemplate.opsForValue().increment(key, 1L);
    }
    public Long decrement(String key) {
        return redisTemplate.opsForValue().decrement(key, 1L);
    }
    public void set(String key, Object value, long expire) {
        redisTemplate.opsForValue().set(key, value);
        if (expire != NOT_EXPIRE) {
@@ -134,7 +157,7 @@ public class RedisUtils {
     */
    public void emptyAll() {
        // Lua 脚本 FLUSHALL是redis清空所有库的命令
-        String luaScript ="redis.call('FLUSHALL')";
+        String luaScript =resourceUtils.loadString("lua/emptyAll.lua");
        // 创建 DefaultRedisScript 对象
        DefaultRedisScript<Void> redisScript = new DefaultRedisScript<>();
@@ -147,4 +170,26 @@ public class RedisUtils {
    }
    /**
     * 获取在redis指定key的值，如果值为空，着设置key的默认值
     * @param key redis的key
     * @param defaultValue 默认值
     * @param expiresInSecond 过期时间
     * @return 返回key的值
     */
    public String getKeyOrCreate(String key, String defaultValue,Long expiresInSecond) {
        // Lua 脚本
        String luaScript = resourceUtils.loadString("lua/getKeyOrCreate.lua");
        DefaultRedisScript<String> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(luaScript);
        redisScript.setResultType(String.class);
        // 执行 Lua 脚本
        List<String> keys = Collections.singletonList(key);
        return redisTemplate.execute(redisScript, keys, defaultValue,expiresInSecond);
    }
 }
@@ -1,6 +1,7 @@
 package xiaozhi.common.service.impl;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
@@ -18,6 +19,7 @@ import com.baomidou.mybatisplus.core.enums.SqlMethod;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.core.metadata.OrderItem;
 import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
 import com.baomidou.mybatisplus.core.toolkit.Constants;
 import com.baomidou.mybatisplus.core.toolkit.ReflectionKit;
 import com.baomidou.mybatisplus.core.toolkit.StringUtils;
@@ -45,6 +47,12 @@ public abstract class BaseServiceImpl<M extends BaseMapper<T>, T> implements Bas
     * @param params            分页查询参数
     * @param defaultOrderField 默认排序字段
     * @param isAsc             排序方式
     * @see xiaozhi.common.constant.Constant
     *      params.put(Constant.PAGE, "1");
     *      params.put(Constant.LIMIT, "10");
     *      params.put(Constant.ORDER_FIELD, "field"); // 单个字段
     *      params.put(Constant.ORDER_FIELD, List.of("field1", "field2")); // 多个字段
     *      params.put(Constant.ORDER, "asc");
     */
    protected IPage<T> getPage(Map<String, Object> params, String defaultOrderField, boolean isAsc) {
        // 分页参数
@@ -65,28 +73,34 @@ public abstract class BaseServiceImpl<M extends BaseMapper<T>, T> implements Bas
        params.put(Constant.PAGE, page);
        // 排序字段
-        String orderField = (String) params.get(Constant.ORDER_FIELD);
+        Object orderField = params.get(Constant.ORDER_FIELD);
        String order = (String) params.get(Constant.ORDER);
-        // 前端字段排序
+        List<String> orderFields = new ArrayList<>();
-        if (StringUtils.isNotBlank(orderField) && StringUtils.isNotBlank(order)) {
+
-            if (Constant.ASC.equalsIgnoreCase(order)) {
+        // 处理排序字段
-                return page.addOrder(OrderItem.asc(orderField));
+        if (orderField instanceof String) {
            orderFields.add((String) orderField);
        } else if (orderField instanceof List) {
            orderFields.addAll((List<String>) orderField);
        }
        // 有排序字段则排序
        if (CollectionUtils.isNotEmpty(orderFields)) {
            if (StringUtils.isNotBlank(order) && Constant.ASC.equalsIgnoreCase(order)) {
                return page.addOrder(OrderItem.ascs(orderFields.toArray(new String[0])));
            } else {
-                return page.addOrder(OrderItem.desc(orderField));
+                return page.addOrder(OrderItem.descs(orderFields.toArray(new String[0])));
            }
        }
-        // 没有排序字段，则不排序
+        // 没有排序字段，使用默认排序
-        if (StringUtils.isBlank(defaultOrderField)) {
+        if (StringUtils.isNotBlank(defaultOrderField)) {
-            return page;
+            if (isAsc) {
-        }
+                page.addOrder(OrderItem.asc(defaultOrderField));
-
+            } else {
-        // 默认排序
+                page.addOrder(OrderItem.desc(defaultOrderField));
-        if (isAsc) {
+            }
            page.addOrder(OrderItem.asc(defaultOrderField));
        } else {
            page.addOrder(OrderItem.desc(defaultOrderField));
        }
        return page;
@@ -128,12 +142,10 @@ public abstract class BaseServiceImpl<M extends BaseMapper<T>, T> implements Bas
        return SqlHelper.retBool(result);
    }
    @SuppressWarnings("unchecked")
    protected Class<M> currentMapperClass() {
        return (Class<M>) ReflectionKit.getSuperClassGenericType(this.getClass(), BaseServiceImpl.class, 0);
    }
    @SuppressWarnings("unchecked")
    @Override
    public Class<T> currentModelClass() {
        return (Class<T>) ReflectionKit.getSuperClassGenericType(this.getClass(), BaseServiceImpl.class, 1);
@@ -24,7 +24,6 @@ import xiaozhi.common.utils.ConvertUtils;
 public abstract class CrudServiceImpl<M extends BaseMapper<T>, T, D> extends BaseServiceImpl<M, T>
        implements CrudService<T, D> {
    @SuppressWarnings("unchecked")
    protected Class<D> currentDtoClass() {
        return (Class<D>) ReflectionKit.getSuperClassGenericType(getClass(), CrudServiceImpl.class, 2);
    }
@@ -21,6 +21,8 @@ public class DateUtils {
     * 时间格式(yyyy-MM-dd HH:mm:ss)
     */
    public final static String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
    public final static String DATE_TIME_MILLIS_PATTERN = "yyyy-MM-dd HH:mm:ss.SSS";
    /**
     * 日期格式化 日期格式为：yyyy-MM-dd
@@ -63,6 +65,19 @@ public class DateUtils {
        return null;
    }
    public static String getDateTimeNow() {
        return getDateTimeNow(DATE_TIME_PATTERN);
    }
    public static String getDateTimeNow(String pattern) {
        return format(new Date(), pattern);
    }
    public static String millsToSecond(long mills) {
        return String.format("%.3f", mills / 1000.0);
    }
    /**
     * 获取简短的时间字符串：10秒前返回刚刚，多少秒前，几小时前，超过一周返回年月日时分秒
     * @param date
@@ -0,0 +1,44 @@
 package xiaozhi.common.utils;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.core.io.ResourceLoader;
 import org.springframework.core.io.Resource;
 import org.springframework.stereotype.Component;
 import xiaozhi.common.exception.RenException;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 /**
 * 资源处理工具
 */
@AllArgsConstructor
@Slf4j
@Component
 public class ResourcesUtils {
    private ResourceLoader resourceLoader;
    /**
     * 读取资源，返回字符串
     * @param fileName 资源路径：resources下开始
     * @return 字符串
     */
    public String loadString(String fileName)  {
        Resource resource = resourceLoader.getResource("classpath:" + fileName);
        StringBuilder luaScriptBuilder = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(resource.getInputStream()))) {
            String line;
            while ((line = reader.readLine()) != null) {
                luaScriptBuilder.append(line).append("\n");
            }
        }  catch (IOException e){
            log.error("方法：loadString()读取资源失败--{}",e.getMessage());
            throw new RenException("读取资源失败");
        }
        return luaScriptBuilder.toString();
    }
 }
@@ -2,6 +2,7 @@ package xiaozhi.common.validator;
 import java.util.Locale;
 import java.util.Set;
 import java.util.regex.Pattern;
 import org.hibernate.validator.messageinterpolation.ResourceBundleMessageInterpolator;
 import org.springframework.context.i18n.LocaleContextHolder;
@@ -45,4 +46,32 @@ public class ValidatorUtils {
            throw new RenException(constraint.getMessage());
        }
    }
    /**
     * 国际手机号正则表达式
     * 要求必须带国际区号，格式：+[国家代码][手机号]
     * 例如：
     * - +8613800138000
     * - +12345678900
     * - +447123456789
     */
    private static final String INTERNATIONAL_PHONE_REGEX = "^\\+[1-9]\\d{0,3}[1-9]\\d{4,14}$";
    /**
     * 校验手机号是否有效
     * 要求必须带国际区号，格式：+[国家代码][手机号]
     * 例如：+8613800138000
     * 
     * @param phone 手机号
     * @return boolean
     */
    public static boolean isValidPhone(String phone) {
        if (phone == null || phone.isEmpty()) {
            return false;
        }
        // 验证必须带国际区号的手机号格式
        Pattern pattern = Pattern.compile(INTERNATIONAL_PHONE_REGEX);
        return pattern.matcher(phone).matches();
    }
 }
@@ -0,0 +1,36 @@
 package xiaozhi.modules.agent.controller;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import xiaozhi.common.utils.Result;
 import xiaozhi.modules.agent.dto.AgentChatHistoryReportDTO;
 import xiaozhi.modules.agent.service.biz.AgentChatHistoryBizService;
@Tag(name = "智能体聊天历史管理")
@RequiredArgsConstructor
@RestController
@RequestMapping("/agent/chat-history")
 public class AgentChatHistoryController {
    private final AgentChatHistoryBizService agentChatHistoryBizService;
    /**
     * 小智服务聊天上报请求
     * <p>
     * 小智服务聊天上报请求，包含Base64编码的音频数据和相关信息。
     *
     * @param request 包含上传文件及相关信息的请求对象
     */
    @Operation(summary = "小智服务聊天上报请求")
    @PostMapping("/report")
    public Result<Boolean> uploadFile(@Valid @RequestBody AgentChatHistoryReportDTO request) {
        Boolean result = agentChatHistoryBizService.report(request);
        return new Result<Boolean>().ok(result);
    }
 }
@@ -3,8 +3,13 @@ package xiaozhi.modules.agent.controller;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.shiro.authz.annotation.RequiresPermissions;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -25,16 +30,24 @@ import jakarta.validation.Valid;
 import lombok.AllArgsConstructor;
 import xiaozhi.common.constant.Constant;
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.redis.RedisKeys;
 import xiaozhi.common.redis.RedisUtils;
 import xiaozhi.common.user.UserDetail;
 import xiaozhi.common.utils.ConvertUtils;
 import xiaozhi.common.utils.Result;
 import xiaozhi.modules.agent.dto.AgentChatHistoryDTO;
 import xiaozhi.modules.agent.dto.AgentChatSessionDTO;
 import xiaozhi.modules.agent.dto.AgentCreateDTO;
 import xiaozhi.modules.agent.dto.AgentDTO;
 import xiaozhi.modules.agent.dto.AgentMemoryDTO;
 import xiaozhi.modules.agent.dto.AgentUpdateDTO;
 import xiaozhi.modules.agent.entity.AgentEntity;
 import xiaozhi.modules.agent.entity.AgentTemplateEntity;
 import xiaozhi.modules.agent.service.AgentChatAudioService;
 import xiaozhi.modules.agent.service.AgentChatHistoryService;
 import xiaozhi.modules.agent.service.AgentService;
 import xiaozhi.modules.agent.service.AgentTemplateService;
 import xiaozhi.modules.device.entity.DeviceEntity;
 import xiaozhi.modules.device.service.DeviceService;
 import xiaozhi.modules.security.user.SecurityUser;
@@ -46,6 +59,9 @@ public class AgentController {
    private final AgentService agentService;
    private final AgentTemplateService agentTemplateService;
    private final DeviceService deviceService;
    private final AgentChatHistoryService agentChatHistoryService;
    private final AgentChatAudioService agentChatAudioService;
    private final RedisUtils redisUtils;
    @GetMapping("/list")
    @Operation(summary = "获取用户智能体列表")
@@ -80,7 +96,7 @@ public class AgentController {
    @PostMapping
    @Operation(summary = "创建智能体")
    @RequiresPermissions("sys:role:normal")
-    public Result<Void> save(@RequestBody @Valid AgentCreateDTO dto) {
+    public Result<String> save(@RequestBody @Valid AgentCreateDTO dto) {
        AgentEntity entity = ConvertUtils.sourceToTarget(dto, AgentEntity.class);
        // 获取默认模板
@@ -95,6 +111,8 @@ public class AgentController {
            entity.setMemModelId(template.getMemModelId());
            entity.setIntentModelId(template.getIntentModelId());
            entity.setSystemPrompt(template.getSystemPrompt());
            entity.setSummaryMemory(template.getSummaryMemory());
            entity.setChatHistoryConf(template.getChatHistoryConf());
            entity.setLangCode(template.getLangCode());
            entity.setLanguage(template.getLanguage());
        }
@@ -108,13 +126,29 @@ public class AgentController {
        // ID、智能体编码和排序会在Service层自动生成
        agentService.insert(entity);
-        return new Result<>();
+        return new Result<String>().ok(entity.getId());
    }
    @PutMapping("/saveMemory/{macAddress}")
    @Operation(summary = "根据设备id更新智能体")
    public Result<Void> updateByDeviceId(@PathVariable String macAddress, @RequestBody @Valid AgentMemoryDTO dto) {
        DeviceEntity device = deviceService.getDeviceByMacAddress(macAddress);
        if (device == null) {
            return new Result<>();
        }
        AgentUpdateDTO agentUpdateDTO = new AgentUpdateDTO();
        agentUpdateDTO.setSummaryMemory(dto.getSummaryMemory());
        return updateAgentById(device.getAgentId(), agentUpdateDTO);
    }
    @PutMapping("/{id}")
    @Operation(summary = "更新智能体")
    @RequiresPermissions("sys:role:normal")
    public Result<Void> update(@PathVariable String id, @RequestBody @Valid AgentUpdateDTO dto) {
        return updateAgentById(id, dto);
    }
    private Result<Void> updateAgentById(String id, AgentUpdateDTO dto) {
        // 先查询现有实体
        AgentEntity existingEntity = agentService.getAgentById(id);
        if (existingEntity == null) {
@@ -152,6 +186,12 @@ public class AgentController {
        if (dto.getSystemPrompt() != null) {
            existingEntity.setSystemPrompt(dto.getSystemPrompt());
        }
        if (dto.getSummaryMemory() != null) {
            existingEntity.setSummaryMemory(dto.getSummaryMemory());
        }
        if (dto.getChatHistoryConf() != null) {
            existingEntity.setChatHistoryConf(dto.getChatHistoryConf());
        }
        if (dto.getLangCode() != null) {
            existingEntity.setLangCode(dto.getLangCode());
        }
@@ -167,8 +207,16 @@ public class AgentController {
        existingEntity.setUpdater(user.getId());
        existingEntity.setUpdatedAt(new Date());
        // 更新记忆策略
        if (existingEntity.getMemModelId() == null || existingEntity.getMemModelId().equals(Constant.MEMORY_NO_MEM)) {
            // 删除所有记录
            agentChatHistoryService.deleteByAgentId(existingEntity.getId(), true, true);
            existingEntity.setSummaryMemory("");
        } else if (existingEntity.getChatHistoryConf() != null && existingEntity.getChatHistoryConf() == 1) {
            // 删除音频数据
            agentChatHistoryService.deleteByAgentId(existingEntity.getId(), true, false);
        }
        agentService.updateById(existingEntity);
        return new Result<>();
    }
@@ -178,6 +226,8 @@ public class AgentController {
    public Result<Void> delete(@PathVariable String id) {
        // 先删除关联的设备
        deviceService.deleteByAgentId(id);
        // 删除关联的聊天记录
        agentChatHistoryService.deleteByAgentId(id, true, true);
        // 再删除智能体
        agentService.deleteById(id);
        return new Result<>();
@@ -192,4 +242,71 @@ public class AgentController {
        return new Result<List<AgentTemplateEntity>>().ok(list);
    }
    @GetMapping("/{id}/sessions")
    @Operation(summary = "获取智能体会话列表")
    @RequiresPermissions("sys:role:normal")
    @Parameters({
            @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true),
            @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true),
    })
    public Result<PageData<AgentChatSessionDTO>> getAgentSessions(
            @PathVariable("id") String id,
            @Parameter(hidden = true) @RequestParam Map<String, Object> params) {
        params.put("agentId", id);
        PageData<AgentChatSessionDTO> page = agentChatHistoryService.getSessionListByAgentId(params);
        return new Result<PageData<AgentChatSessionDTO>>().ok(page);
    }
    @GetMapping("/{id}/chat-history/{sessionId}")
    @Operation(summary = "获取智能体聊天记录")
    @RequiresPermissions("sys:role:normal")
    public Result<List<AgentChatHistoryDTO>> getAgentChatHistory(
            @PathVariable("id") String id,
            @PathVariable("sessionId") String sessionId) {
        // 获取当前用户
        UserDetail user = SecurityUser.getUser();
        // 检查权限
        if (!agentService.checkAgentPermission(id, user.getId())) {
            return new Result<List<AgentChatHistoryDTO>>().error("没有权限查看该智能体的聊天记录");
        }
        // 查询聊天记录
        List<AgentChatHistoryDTO> result = agentChatHistoryService.getChatHistoryBySessionId(id, sessionId);
        return new Result<List<AgentChatHistoryDTO>>().ok(result);
    }
    @PostMapping("/audio/{audioId}")
    @Operation(summary = "获取音频下载ID")
    @RequiresPermissions("sys:role:normal")
    public Result<String> getAudioId(@PathVariable("audioId") String audioId) {
        byte[] audioData = agentChatAudioService.getAudio(audioId);
        if (audioData == null) {
            return new Result<String>().error("音频不存在");
        }
        String uuid = UUID.randomUUID().toString();
        redisUtils.set(RedisKeys.getAgentAudioIdKey(uuid), audioId);
        return new Result<String>().ok(uuid);
    }
    @GetMapping("/play/{uuid}")
    @Operation(summary = "播放音频")
    public ResponseEntity<byte[]> playAudio(@PathVariable("uuid") String uuid) {
        String audioId = (String) redisUtils.get(RedisKeys.getAgentAudioIdKey(uuid));
        if (StringUtils.isBlank(audioId)) {
            return ResponseEntity.notFound().build();
        }
        byte[] audioData = agentChatAudioService.getAudio(audioId);
        if (audioData == null) {
            return ResponseEntity.notFound().build();
        }
        redisUtils.delete(RedisKeys.getAgentAudioIdKey(uuid));
        return ResponseEntity.ok()
                .contentType(MediaType.APPLICATION_OCTET_STREAM)
                .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"play.wav\"")
                .body(audioData);
    }
 }
@@ -3,6 +3,7 @@ package xiaozhi.modules.agent.dao;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.annotations.Select;
 import xiaozhi.common.dao.BaseDao;
 import xiaozhi.modules.agent.entity.AgentEntity;
@@ -15,4 +16,16 @@ public interface AgentDao extends BaseDao<AgentEntity> {
     * @return 设备数量
     */
    Integer getDeviceCountByAgentId(@Param("agentId") String agentId);
-}
+
    /**
     * 根据设备MAC地址查询对应设备的默认智能体信息
     *
     * @param macAddress 设备MAC地址
     * @return 默认智能体信息
     */
    @Select(" SELECT a.* FROM ai_device d " +
            " LEFT JOIN ai_agent a ON d.agent_id = a.id " +
            " WHERE d.mac_address = #{macAddress} " +
            " ORDER BY d.id DESC LIMIT 1")
    AgentEntity getDefaultAgentByMacAddress(@Param("macAddress") String macAddress);
 }
@@ -0,0 +1,18 @@
 package xiaozhi.modules.agent.dao;
 import org.apache.ibatis.annotations.Mapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import xiaozhi.modules.agent.entity.AgentChatAudioEntity;
 /**
 * {@link AgentChatAudioEntity} 智能体聊天音频数据Dao对象
 *
 * @author Goody
 * @version 1.0, 2025/5/8
 * @since 1.0.0
 */
@Mapper
 public interface AiAgentChatAudioDao extends BaseMapper<AgentChatAudioEntity> {
 }
@@ -0,0 +1,38 @@
 package xiaozhi.modules.agent.dao;
 import org.apache.ibatis.annotations.Mapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import xiaozhi.modules.agent.entity.AgentChatHistoryEntity;
 /**
 * {@link AgentChatHistoryEntity} 智能体聊天历史记录Dao对象
 *
 * @author Goody
 * @version 1.0, 2025/4/30
 * @since 1.0.0
 */
@Mapper
 public interface AiAgentChatHistoryDao extends BaseMapper<AgentChatHistoryEntity> {
    /**
     * 根据智能体ID删除音频
     *
     * @param agentId 智能体ID
     */
    void deleteAudioByAgentId(String agentId);
    /**
     * 根据智能体ID删除聊天历史记录
     *
     * @param agentId 智能体ID
     */
    void deleteHistoryByAgentId(String agentId);
    /**
     * 根据智能体ID删除音频ID
     *
     * @param agentId 智能体ID
     */
    void deleteAudioIdByAgentId(String agentId);
 }
@@ -0,0 +1,28 @@
 package xiaozhi.modules.agent.dto;
 import java.util.Date;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 /**
 * 智能体聊天记录DTO
 */
@Data
@Schema(description = "智能体聊天记录")
 public class AgentChatHistoryDTO {
    @Schema(description = "创建时间")
    private Date createdAt;
    @Schema(description = "消息类型: 1-用户, 2-智能体")
    private Byte chatType;
    @Schema(description = "聊天内容")
    private String content;
    @Schema(description = "音频ID")
    private String audioId;
    @Schema(description = "MAC地址")
    private String macAddress;
 }
@@ -0,0 +1,33 @@
 package xiaozhi.modules.agent.dto;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import lombok.Data;
 /**
 * 小智设备聊天上报请求
 *
 * @author Haotian
 * @version 1.0, 2025/5/8
 */
@Data
@Schema(description = "小智设备聊天上报请求")
 public class AgentChatHistoryReportDTO {
    @Schema(description = "MAC地址", example = "00:11:22:33:44:55")
    @NotBlank
    private String macAddress;
    @Schema(description = "会话ID", example = "79578c31-f1fb-426a-900e-1e934215f05a")
    @NotBlank
    private String sessionId;
    @Schema(description = "消息类型: 1-用户, 2-智能体", example = "1")
    @NotNull
    private Byte chatType;
    @Schema(description = "聊天内容", example = "你好呀")
    @NotBlank
    private String content;
    @Schema(description = "base64编码的opus音频数据", example = "")
    private String audioBase64;
    @Schema(description = "上报时间，十位时间戳，空时默认使用当前时间", example = "1745657732")
    private Long reportTime;
 }
@@ -0,0 +1,26 @@
 package xiaozhi.modules.agent.dto;
 import java.time.LocalDateTime;
 import lombok.Data;
 /**
 * 智能体会话列表DTO
 */
@Data
 public class AgentChatSessionDTO {
    /**
     * 会话ID
     */
    private String sessionId;
    /**
     * 会话时间
     */
    private LocalDateTime createdAt;
    /**
     * 聊天条数
     */
    private Integer chatCount;
 }
@@ -27,9 +27,19 @@ public class AgentDTO {
    @Schema(description = "大语言模型名称", example = "llm_model_01")
    private String llmModelName;
    @Schema(description = "视觉模型名称", example = "vllm_model_01")
    private String vllmModelName;
    @Schema(description = "记忆模型ID", example = "mem_model_01")
    private String memModelId;
    @Schema(description = "角色设定参数", example = "你是一个专业的客服助手，负责回答用户问题并提供帮助")
    private String systemPrompt;
    @Schema(description = "总结记忆", example = "构建可生长的动态记忆网络，在有限空间内保留关键信息的同时，智能维护信息演变轨迹\n" +
            "根据对话记录，总结user的重要信息，以便在未来的对话中提供更个性化的服务", required = false)
    private String summaryMemory;
    @Schema(description = "最后连接时间", example = "2024-03-20 10:00:00")
    private Date lastConnectedAt;
@@ -0,0 +1,19 @@
 package xiaozhi.modules.agent.dto;
 import java.io.Serializable;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 /**
 * 智能体记忆更新DTO
 */
@Data
@Schema(description = "智能体记忆更新对象")
 public class AgentMemoryDTO implements Serializable {
    private static final long serialVersionUID = 1L;
    @Schema(description = "总结记忆", example = "构建可生长的动态记忆网络，在有限空间内保留关键信息的同时，智能维护信息演变轨迹\n" +
            "根据对话记录，总结user的重要信息，以便在未来的对话中提供更个性化的服务", required = false)
    private String summaryMemory;
 }
@@ -45,6 +45,13 @@ public class AgentUpdateDTO implements Serializable {
    @Schema(description = "角色设定参数", example = "你是一个专业的客服助手，负责回答用户问题并提供帮助", required = false)
    private String systemPrompt;
    @Schema(description = "总结记忆", example = "构建可生长的动态记忆网络，在有限空间内保留关键信息的同时，智能维护信息演变轨迹\n" +
            "根据对话记录，总结user的重要信息，以便在未来的对话中提供更个性化的服务", required = false)
    private String summaryMemory;
    @Schema(description = "聊天记录配置（0不记录 1仅记录文本 2记录文本和语音）", example = "3", required = false)
    private Integer chatHistoryConf;
    @Schema(description = "语言编码", example = "zh_CN", required = false)
    private String langCode;
@@ -0,0 +1,29 @@
 package xiaozhi.modules.agent.entity;
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 /**
 * 智能体聊天音频数据表
 *
 * @author Goody
 * @version 1.0, 2025/5/8
 * @since 1.0.0
 */
@Data
@TableName("ai_agent_chat_audio")
 public class AgentChatAudioEntity {
    /**
     * 主键ID
     */
    @TableId(type = IdType.ASSIGN_UUID)
    private String id;
    /**
     * 音频opus数据
     */
    private byte[] audio;
 }
@@ -0,0 +1,81 @@
 package xiaozhi.modules.agent.entity;
 import java.util.Date;
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 /**
 * 智能体聊天记录表
 *
 * @author Goody
 * @version 1.0, 2025/4/30
 * @since 1.0.0
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "ai_agent_chat_history")
 public class AgentChatHistoryEntity {
    /**
     * 主键ID
     */
    @TableId(type = IdType.AUTO)
    private Long id;
    /**
     * MAC地址
     */
    @TableField(value = "mac_address")
    private String macAddress;
    /**
     * 智能体id
     */
    @TableField(value = "agent_id")
    private String agentId;
    /**
     * 会话ID
     */
    @TableField(value = "session_id")
    private String sessionId;
    /**
     * 消息类型: 1-用户, 2-智能体
     */
    @TableField(value = "chat_type")
    private Byte chatType;
    /**
     * 聊天内容
     */
    @TableField(value = "content")
    private String content;
    /**
     * 音频base64数据
     */
    @TableField(value = "audio_id")
    private String audioId;
    /**
     * 创建时间
     */
    @TableField(value = "created_at")
    private Date createdAt;
    /**
     * 更新时间
     */
    @TableField(value = "updated_at")
    private Date updatedAt;
 }
@@ -36,6 +36,9 @@ public class AgentEntity {
    @Schema(description = "大语言模型标识")
    private String llmModelId;
    @Schema(description = "VLLM模型标识")
    private String vllmModelId;
    @Schema(description = "语音合成模型标识")
    private String ttsModelId;
@@ -48,9 +51,16 @@ public class AgentEntity {
    @Schema(description = "意图模型标识")
    private String intentModelId;
    @Schema(description = "聊天记录配置（0不记录 1仅记录文本 2记录文本和语音）")
    private Integer chatHistoryConf;
    @Schema(description = "角色设定参数")
    private String systemPrompt;
    @Schema(description = "总结记忆", example = "构建可生长的动态记忆网络，在有限空间内保留关键信息的同时，智能维护信息演变轨迹\n" +
            "根据对话记录，总结user的重要信息，以便在未来的对话中提供更个性化的服务", required = false)
    private String summaryMemory;
    @Schema(description = "语言编码")
    private String langCode;
@@ -49,6 +49,11 @@ public class AgentTemplateEntity implements Serializable {
     */
    private String llmModelId;
    /**
     * VLLM模型标识
     */
    private String vllmModelId;
    /**
     * 语音合成模型标识
     */
@@ -69,11 +74,20 @@ public class AgentTemplateEntity implements Serializable {
     */
    private String intentModelId;
    /**
     * 聊天记录配置（0不记录 1仅记录文本 2记录文本和语音）
     */
    private Integer chatHistoryConf;
    /**
     * 角色设定参数
     */
    private String systemPrompt;
    /**
     * 总结记忆
     */
    private String summaryMemory;
    /**
     * 语言编码
     */
@@ -0,0 +1,30 @@
 package xiaozhi.modules.agent.service;
 import com.baomidou.mybatisplus.extension.service.IService;
 import xiaozhi.modules.agent.entity.AgentChatAudioEntity;
 /**
 * 智能体聊天音频数据表处理service
 *
 * @author Goody
 * @version 1.0, 2025/5/8
 * @since 1.0.0
 */
 public interface AgentChatAudioService extends IService<AgentChatAudioEntity> {
    /**
     * 保存音频数据
     *
     * @param audioData 音频数据
     * @return 音频ID
     */
    String saveAudio(byte[] audioData);
    /**
     * 获取音频数据
     *
     * @param audioId 音频ID
     * @return 音频数据
     */
    byte[] getAudio(String audioId);
 }
@@ -0,0 +1,47 @@
 package xiaozhi.modules.agent.service;
 import java.util.List;
 import java.util.Map;
 import com.baomidou.mybatisplus.extension.service.IService;
 import xiaozhi.common.page.PageData;
 import xiaozhi.modules.agent.dto.AgentChatHistoryDTO;
 import xiaozhi.modules.agent.dto.AgentChatSessionDTO;
 import xiaozhi.modules.agent.entity.AgentChatHistoryEntity;
 /**
 * 智能体聊天记录表处理service
 *
 * @author Goody
 * @version 1.0, 2025/4/30
 * @since 1.0.0
 */
 public interface AgentChatHistoryService extends IService<AgentChatHistoryEntity> {
    /**
     * 根据智能体ID获取会话列表
     *
     * @param params 查询参数，包含agentId、page、limit
     * @return 分页的会话列表
     */
    PageData<AgentChatSessionDTO> getSessionListByAgentId(Map<String, Object> params);
    /**
     * 根据会话ID获取聊天记录列表
     *
     * @param agentId   智能体ID
     * @param sessionId 会话ID
     * @return 聊天记录列表
     */
    List<AgentChatHistoryDTO> getChatHistoryBySessionId(String agentId, String sessionId);
    /**
     * 根据智能体ID删除聊天记录
     *
     * @param agentId     智能体ID
     * @param deleteAudio 是否删除音频
     * @param deleteText  是否删除文本
     */
    void deleteByAgentId(String agentId, Boolean deleteAudio, Boolean deleteText);
 }
@@ -8,38 +8,75 @@ import xiaozhi.common.service.BaseService;
 import xiaozhi.modules.agent.dto.AgentDTO;
 import xiaozhi.modules.agent.entity.AgentEntity;
 /**
 * 智能体表处理service
 *
 * @author Goody
 * @version 1.0, 2025/4/30
 * @since 1.0.0
 */
 public interface AgentService extends BaseService<AgentEntity> {
    /**
-     * 管理员获取所有智能体列表（分页）
+     * 获取管理员智能体列表
     *
     * @param params 查询参数
     * @return 分页数据
     */
    PageData<AgentEntity> adminAgentList(Map<String, Object> params);
    /**
-     * 获取智能体详情
+     * 根据ID获取智能体
     *
     * @param id 智能体ID
     * @return 智能体实体
     */
    AgentEntity getAgentById(String id);
    /**
-     * 删除这个用户的所有
+     * 插入智能体
-     * 
+     *
-     * @param userId
+     * @param entity 智能体实体
     * @return 是否成功
     */
    boolean insert(AgentEntity entity);
    /**
     * 根据用户ID删除智能体
     *
     * @param userId 用户ID
     */
    void deleteAgentByUserId(Long userId);
    /**
     * 获取用户智能体列表
-     * 
+     *
-     * @param userId
+     * @param userId 用户ID
-     * @return
+     * @return 智能体列表
     */
    List<AgentDTO> getUserAgents(Long userId);
    /**
-     * 获取智能体的设备数量
+     * 根据智能体ID获取设备数量
-     * 
+     *
     * @param agentId 智能体ID
     * @return 设备数量
     */
    Integer getDeviceCountByAgentId(String agentId);
-}
+
    /**
     * 根据设备MAC地址查询对应设备的默认智能体信息
     *
     * @param macAddress 设备MAC地址
     * @return 默认智能体信息，不存在时返回null
     */
    AgentEntity getDefaultAgentByMacAddress(String macAddress);
    /**
     * 检查用户是否有权限访问智能体
     *
     * @param agentId 智能体ID
     * @param userId  用户ID
     * @return 是否有权限
     */
    boolean checkAgentPermission(String agentId, Long userId);
 }
@@ -0,0 +1,22 @@
 package xiaozhi.modules.agent.service.biz;
 import xiaozhi.modules.agent.dto.AgentChatHistoryReportDTO;
 /**
 * 智能体聊天历史业务逻辑层
 *
 * @author Goody
 * @version 1.0, 2025/4/30
 * @since 1.0.0
 */
 public interface AgentChatHistoryBizService {
    /**
     * 聊天上报方法
     *
     * @param agentChatHistoryReportDTO 包含聊天上报所需信息的输入对象
     *                                  例如：设备MAC地址、文件类型、内容等
     * @return 上传结果，true表示成功，false表示失败
     */
    Boolean report(AgentChatHistoryReportDTO agentChatHistoryReportDTO);
 }
@@ -0,0 +1,114 @@
 package xiaozhi.modules.agent.service.biz.impl;
 import java.util.Base64;
 import java.util.Date;
 import java.util.Objects;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import xiaozhi.common.constant.Constant;
 import xiaozhi.common.redis.RedisKeys;
 import xiaozhi.common.redis.RedisUtils;
 import xiaozhi.modules.agent.dto.AgentChatHistoryReportDTO;
 import xiaozhi.modules.agent.entity.AgentChatHistoryEntity;
 import xiaozhi.modules.agent.entity.AgentEntity;
 import xiaozhi.modules.agent.service.AgentChatAudioService;
 import xiaozhi.modules.agent.service.AgentChatHistoryService;
 import xiaozhi.modules.agent.service.AgentService;
 import xiaozhi.modules.agent.service.biz.AgentChatHistoryBizService;
 /**
 * {@link AgentChatHistoryBizService} impl
 *
 * @author Goody
 * @version 1.0, 2025/4/30
 * @since 1.0.0
 */
@Service
@Slf4j
@RequiredArgsConstructor
 public class AgentChatHistoryBizServiceImpl implements AgentChatHistoryBizService {
    private final AgentService agentService;
    private final AgentChatHistoryService agentChatHistoryService;
    private final AgentChatAudioService agentChatAudioService;
    private final RedisUtils redisUtils;
    /**
     * 处理聊天记录上报，包括文件上传和相关信息记录
     *
     * @param report 包含聊天上报所需信息的输入对象
     * @return 上传结果，true表示成功，false表示失败
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean report(AgentChatHistoryReportDTO report) {
        String macAddress = report.getMacAddress();
        Byte chatType = report.getChatType();
        Long reportTimeMillis = null != report.getReportTime() ? report.getReportTime() * 1000 : System.currentTimeMillis();
        log.info("小智设备聊天上报请求: macAddress={}, type={} reportTime={}", macAddress, chatType, reportTimeMillis);
        // 根据设备MAC地址查询对应的默认智能体，判断是否需要上报
        AgentEntity agentEntity = agentService.getDefaultAgentByMacAddress(macAddress);
        if (agentEntity == null) {
            return Boolean.FALSE;
        }
        Integer chatHistoryConf = agentEntity.getChatHistoryConf();
        String agentId = agentEntity.getId();
        if (Objects.equals(chatHistoryConf, Constant.ChatHistoryConfEnum.RECORD_TEXT.getCode())) {
            saveChatText(report, agentId, macAddress, null, reportTimeMillis);
        } else if (Objects.equals(chatHistoryConf, Constant.ChatHistoryConfEnum.RECORD_TEXT_AUDIO.getCode())) {
            String audioId = saveChatAudio(report);
            saveChatText(report, agentId, macAddress, audioId, reportTimeMillis);
        }
        // 更新设备最后对话时间
        redisUtils.set(RedisKeys.getAgentDeviceLastConnectedAtById(agentId), new Date());
        return Boolean.TRUE;
    }
    /**
     * base64解码report.getOpusDataBase64(),存入ai_agent_chat_audio表
     */
    private String saveChatAudio(AgentChatHistoryReportDTO report) {
        String audioId = null;
        if (report.getAudioBase64() != null && !report.getAudioBase64().isEmpty()) {
            try {
                byte[] audioData = Base64.getDecoder().decode(report.getAudioBase64());
                audioId = agentChatAudioService.saveAudio(audioData);
                log.info("音频数据保存成功，audioId={}", audioId);
            } catch (Exception e) {
                log.error("音频数据保存失败", e);
                return null;
            }
        }
        return audioId;
    }
    /**
     * 组装上报数据
     */
    private void saveChatText(AgentChatHistoryReportDTO report, String agentId, String macAddress, String audioId, Long reportTime) {
        // 构建聊天记录实体
        AgentChatHistoryEntity entity = AgentChatHistoryEntity.builder()
                .macAddress(macAddress)
                .agentId(agentId)
                .sessionId(report.getSessionId())
                .chatType(report.getChatType())
                .content(report.getContent())
                .audioId(audioId)
                .createdAt(new Date(reportTime))
                // NOTE(haotian): 2025/5/26 updateAt可以不设置，重点是createAt，而且这样可以看到上报延迟
                .build();
        // 保存数据
        agentChatHistoryService.save(entity);
        log.info("设备 {} 对应智能体 {} 上报成功", macAddress, agentId);
    }
 }
@@ -0,0 +1,34 @@
 package xiaozhi.modules.agent.service.impl;
 import org.springframework.stereotype.Service;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import xiaozhi.modules.agent.dao.AiAgentChatAudioDao;
 import xiaozhi.modules.agent.entity.AgentChatAudioEntity;
 import xiaozhi.modules.agent.service.AgentChatAudioService;
 /**
 * 智能体聊天音频数据表处理service {@link AgentChatAudioService} impl
 *
 * @author Goody
 * @version 1.0, 2025/5/8
 * @since 1.0.0
 */
@Service
 public class AgentChatAudioServiceImpl extends ServiceImpl<AiAgentChatAudioDao, AgentChatAudioEntity>
        implements AgentChatAudioService {
    @Override
    public String saveAudio(byte[] audioData) {
        AgentChatAudioEntity entity = new AgentChatAudioEntity();
        entity.setAudio(audioData);
        save(entity);
        return entity.getId();
    }
    @Override
    public byte[] getAudio(String audioId) {
        AgentChatAudioEntity entity = getById(audioId);
        return entity != null ? entity.getAudio() : null;
    }
 }
@@ -0,0 +1,93 @@
 package xiaozhi.modules.agent.service.impl;
 import java.time.LocalDateTime;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import xiaozhi.common.constant.Constant;
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.utils.ConvertUtils;
 import xiaozhi.modules.agent.dao.AiAgentChatHistoryDao;
 import xiaozhi.modules.agent.dto.AgentChatHistoryDTO;
 import xiaozhi.modules.agent.dto.AgentChatSessionDTO;
 import xiaozhi.modules.agent.entity.AgentChatHistoryEntity;
 import xiaozhi.modules.agent.service.AgentChatHistoryService;
 /**
 * 智能体聊天记录表处理service {@link AgentChatHistoryService} impl
 *
 * @author Goody
 * @version 1.0, 2025/4/30
 * @since 1.0.0
 */
@Service
 public class AgentChatHistoryServiceImpl extends ServiceImpl<AiAgentChatHistoryDao, AgentChatHistoryEntity>
        implements AgentChatHistoryService {
    @Override
    public PageData<AgentChatSessionDTO> getSessionListByAgentId(Map<String, Object> params) {
        String agentId = (String) params.get("agentId");
        int page = Integer.parseInt(params.get(Constant.PAGE).toString());
        int limit = Integer.parseInt(params.get(Constant.LIMIT).toString());
        // 构建查询条件
        QueryWrapper<AgentChatHistoryEntity> wrapper = new QueryWrapper<>();
        wrapper.select("session_id", "MAX(created_at) as created_at", "COUNT(*) as chat_count")
                .eq("agent_id", agentId)
                .groupBy("session_id")
                .orderByDesc("created_at");
        // 执行分页查询
        Page<Map<String, Object>> pageParam = new Page<>(page, limit);
        IPage<Map<String, Object>> result = this.baseMapper.selectMapsPage(pageParam, wrapper);
        List<AgentChatSessionDTO> records = result.getRecords().stream().map(map -> {
            AgentChatSessionDTO dto = new AgentChatSessionDTO();
            dto.setSessionId((String) map.get("session_id"));
            dto.setCreatedAt((LocalDateTime) map.get("created_at"));
            dto.setChatCount(((Number) map.get("chat_count")).intValue());
            return dto;
        }).collect(Collectors.toList());
        return new PageData<>(records, result.getTotal());
    }
    @Override
    public List<AgentChatHistoryDTO> getChatHistoryBySessionId(String agentId, String sessionId) {
        // 构建查询条件
        QueryWrapper<AgentChatHistoryEntity> wrapper = new QueryWrapper<>();
        wrapper.eq("agent_id", agentId)
                .eq("session_id", sessionId)
                .orderByAsc("created_at");
        // 查询聊天记录
        List<AgentChatHistoryEntity> historyList = list(wrapper);
        // 转换为DTO
        return ConvertUtils.sourceToTarget(historyList, AgentChatHistoryDTO.class);
    }
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteByAgentId(String agentId, Boolean deleteAudio, Boolean deleteText) {
        if (deleteAudio) {
            baseMapper.deleteAudioByAgentId(agentId);
        }
        if (deleteAudio && !deleteText) {
            baseMapper.deleteAudioIdByAgentId(agentId);
        }
        if (deleteText) {
            baseMapper.deleteHistoryByAgentId(agentId);
        }
    }
 }
@@ -6,13 +6,14 @@ import java.util.UUID;
 import java.util.stream.Collectors;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import lombok.AllArgsConstructor;
 import xiaozhi.common.constant.Constant;
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.redis.RedisKeys;
 import xiaozhi.common.redis.RedisUtils;
@@ -21,25 +22,20 @@ import xiaozhi.modules.agent.dao.AgentDao;
 import xiaozhi.modules.agent.dto.AgentDTO;
 import xiaozhi.modules.agent.entity.AgentEntity;
 import xiaozhi.modules.agent.service.AgentService;
 import xiaozhi.modules.device.service.DeviceService;
 import xiaozhi.modules.model.service.ModelConfigService;
 import xiaozhi.modules.security.user.SecurityUser;
 import xiaozhi.modules.sys.enums.SuperAdminEnum;
 import xiaozhi.modules.timbre.service.TimbreService;
@Service
@AllArgsConstructor
 public class AgentServiceImpl extends BaseServiceImpl<AgentDao, AgentEntity> implements AgentService {
    private final AgentDao agentDao;
-
+    private final TimbreService timbreModelService;
-    @Autowired
+    private final ModelConfigService modelConfigService;
-    private TimbreService timbreModelService;
+    private final RedisUtils redisUtils;
-
+    private final DeviceService deviceService;
    @Autowired
    private ModelConfigService modelConfigService;
    @Autowired
    private RedisUtils redisUtils;
    public AgentServiceImpl(AgentDao agentDao) {
        this.agentDao = agentDao;
    }
    @Override
    public PageData<AgentEntity> adminAgentList(Map<String, Object> params) {
@@ -51,7 +47,15 @@ public class AgentServiceImpl extends BaseServiceImpl<AgentDao, AgentEntity> imp
    @Override
    public AgentEntity getAgentById(String id) {
-        return agentDao.selectById(id);
+        AgentEntity agent = agentDao.selectById(id);
        if (agent != null && agent.getMemModelId() != null && agent.getMemModelId().equals(Constant.MEMORY_NO_MEM)) {
            agent.setChatHistoryConf(Constant.ChatHistoryConfEnum.IGNORE.getCode());
        } else if (agent != null && agent.getMemModelId() != null
                && !agent.getMemModelId().equals(Constant.MEMORY_NO_MEM)
                && agent.getChatHistoryConf() == null) {
            agent.setChatHistoryConf(Constant.ChatHistoryConfEnum.RECORD_TEXT_AUDIO.getCode());
        }
        return agent;
    }
    @Override
@@ -98,12 +102,20 @@ public class AgentServiceImpl extends BaseServiceImpl<AgentDao, AgentEntity> imp
            // 获取 LLM 模型名称
            dto.setLlmModelName(modelConfigService.getModelNameById(agent.getLlmModelId()));
            // 获取 VLLM 模型名称
            dto.setVllmModelName(modelConfigService.getModelNameById(agent.getVllmModelId()));
            // 获取记忆模型名称
            dto.setMemModelId(agent.getMemModelId());
            // 获取 TTS 音色名称
            dto.setTtsVoiceName(timbreModelService.getTimbreNameById(agent.getTtsVoiceId()));
            // 获取智能体最近的最后连接时长
            dto.setLastConnectedAt(deviceService.getLatestLastConnectionTime(agent.getId()));
            // 获取设备数量
            dto.setDeviceCount(getDeviceCountByAgentId(agent.getId()));
            return dto;
        }).collect(Collectors.toList());
    }
@@ -130,4 +142,29 @@ public class AgentServiceImpl extends BaseServiceImpl<AgentDao, AgentEntity> imp
        return deviceCount != null ? deviceCount : 0;
    }
-}
+
    @Override
    public AgentEntity getDefaultAgentByMacAddress(String macAddress) {
        if (StringUtils.isEmpty(macAddress)) {
            return null;
        }
        return agentDao.getDefaultAgentByMacAddress(macAddress);
    }
    @Override
    public boolean checkAgentPermission(String agentId, Long userId) {
        // 获取智能体信息
        AgentEntity agent = getAgentById(agentId);
        if (agent == null) {
            return false;
        }
        // 如果是超级管理员，直接返回true
        if (SecurityUser.getUser().getSuperAdmin() == SuperAdminEnum.YES.value()) {
            return true;
        }
        // 检查是否是智能体的所有者
        return userId.equals(agent.getUserId());
    }
 }
@@ -1,6 +1,5 @@
 package xiaozhi.modules.config.controller;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
@@ -8,15 +7,12 @@ import org.springframework.web.bind.annotation.RestController;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Valid;
 import lombok.AllArgsConstructor;
 import xiaozhi.common.constant.Constant;
 import xiaozhi.common.exception.RenException;
 import xiaozhi.common.utils.Result;
 import xiaozhi.common.validator.ValidatorUtils;
 import xiaozhi.modules.config.dto.AgentModelsDTO;
 import xiaozhi.modules.config.service.ConfigService;
 import xiaozhi.modules.sys.dto.ConfigSecretDTO;
 import xiaozhi.modules.sys.service.SysParamsService;
 /**
 * xiaozhi-server 配置获取
@@ -29,33 +25,20 @@ import xiaozhi.modules.sys.service.SysParamsService;
@AllArgsConstructor
 public class ConfigController {
    private final ConfigService configService;
    private final SysParamsService sysParamsService;
    @PostMapping("server-base")
    @Operation(summary = "获取配置")
-    public Result<Object> getConfig(@RequestBody ConfigSecretDTO dto) {
+    public Result<Object> getConfig() {
        // 效验数据
        ValidatorUtils.validateEntity(dto);
        checkSecret(dto.getSecret());
        Object config = configService.getConfig(true);
        return new Result<Object>().ok(config);
    }
    @PostMapping("agent-models")
    @Operation(summary = "获取智能体模型")
-    public Result<Object> getAgentModels(@RequestBody AgentModelsDTO dto) {
+    public Result<Object> getAgentModels(@Valid @RequestBody AgentModelsDTO dto) {
        // 效验数据
        ValidatorUtils.validateEntity(dto);
        checkSecret(dto.getSecret());
        Object models = configService.getAgentModels(dto.getMacAddress(), dto.getSelectedModule());
        return new Result<Object>().ok(models);
    }
    private void checkSecret(String secret) {
        String secretParam = sysParamsService.getValue(Constant.SERVER_SECRET, true);
        // 验证密钥
        if (StringUtils.isBlank(secret) || !secret.equals(secretParam)) {
            throw new RenException("密钥错误");
        }
    }
 }
@@ -10,9 +10,6 @@ import lombok.Data;
@Data
@Schema(description = "获取智能体模型配置DTO")
 public class AgentModelsDTO {
    @NotBlank(message = "密钥不能为空")
    @Schema(description = "密钥")
    private String secret;
    @NotBlank(message = "设备MAC地址不能为空")
    @Schema(description = "设备MAC地址")
@@ -9,6 +9,7 @@ import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
 import lombok.AllArgsConstructor;
 import xiaozhi.common.constant.Constant;
 import xiaozhi.common.exception.ErrorCode;
 import xiaozhi.common.exception.RenException;
 import xiaozhi.common.redis.RedisKeys;
@@ -61,15 +62,17 @@ public class ConfigServiceImpl implements ConfigService {
        // 构建模块配置
        buildModuleConfig(
-                agent.getAgentName(),
+                null,
-                agent.getSystemPrompt(),
+                null,
                null,
                null,
                agent.getVadModelId(),
                agent.getAsrModelId(),
-                agent.getLlmModelId(),
+                null,
-                agent.getTtsModelId(),
+                null,
-                agent.getMemModelId(),
+                null,
-                agent.getIntentModelId(),
+                null,
                null,
                result,
                isCache);
@@ -108,6 +111,17 @@ public class ConfigServiceImpl implements ConfigService {
        // 获取单台设备每天最多输出字数
        String deviceMaxOutputSize = sysParamsService.getValue("device_max_output_size", true);
        result.put("device_max_output_size", deviceMaxOutputSize);
        // 获取聊天记录配置
        Integer chatHistoryConf = agent.getChatHistoryConf();
        if (agent.getMemModelId() != null && agent.getMemModelId().equals(Constant.MEMORY_NO_MEM)) {
            chatHistoryConf = Constant.ChatHistoryConfEnum.IGNORE.getCode();
        } else if (agent.getMemModelId() != null
                && !agent.getMemModelId().equals(Constant.MEMORY_NO_MEM)
                && agent.getChatHistoryConf() == null) {
            chatHistoryConf = Constant.ChatHistoryConfEnum.RECORD_TEXT_AUDIO.getCode();
        }
        result.put("chat_history_conf", chatHistoryConf);
        // 如果客户端已实例化模型，则不返回
        String alreadySelectedVadModelId = (String) selectedModule.get("VAD");
        if (alreadySelectedVadModelId != null && alreadySelectedVadModelId.equals(agent.getVadModelId())) {
@@ -117,27 +131,17 @@ public class ConfigServiceImpl implements ConfigService {
        if (alreadySelectedAsrModelId != null && alreadySelectedAsrModelId.equals(agent.getAsrModelId())) {
            agent.setAsrModelId(null);
        }
        String alreadySelectedLlmModelId = (String) selectedModule.get("LLM");
        if (alreadySelectedLlmModelId != null && alreadySelectedLlmModelId.equals(agent.getLlmModelId())) {
            agent.setLlmModelId(null);
        }
        String alreadySelectedMemModelId = (String) selectedModule.get("Memory");
        if (alreadySelectedMemModelId != null && alreadySelectedMemModelId.equals(agent.getMemModelId())) {
            agent.setMemModelId(null);
        }
        String alreadySelectedIntentModelId = (String) selectedModule.get("Intent");
        if (alreadySelectedIntentModelId != null && alreadySelectedIntentModelId.equals(agent.getIntentModelId())) {
            agent.setIntentModelId(null);
        }
        // 构建模块配置
        buildModuleConfig(
                agent.getAgentName(),
                agent.getSystemPrompt(),
                agent.getSummaryMemory(),
                voice,
                agent.getVadModelId(),
                agent.getAsrModelId(),
                agent.getLlmModelId(),
                agent.getVllmModelId(),
                agent.getTtsModelId(),
                agent.getMemModelId(),
                agent.getIntentModelId(),
@@ -153,7 +157,6 @@ public class ConfigServiceImpl implements ConfigService {
     * @param paramsList 系统参数列表
     * @return 配置信息
     */
    @SuppressWarnings("unchecked")
    private Object buildConfig(Map<String, Object> config) {
        // 查询所有系统参数
@@ -235,10 +238,12 @@ public class ConfigServiceImpl implements ConfigService {
    private void buildModuleConfig(
            String assistantName,
            String prompt,
            String summaryMemory,
            String voice,
            String vadModelId,
            String asrModelId,
            String llmModelId,
            String vllmModelId,
            String ttsModelId,
            String memModelId,
            String intentModelId,
@@ -246,9 +251,10 @@ public class ConfigServiceImpl implements ConfigService {
            boolean isCache) {
        Map<String, String> selectedModule = new HashMap<>();
-        String[] modelTypes = { "VAD", "ASR", "TTS", "Memory", "Intent", "LLM" };
+        String[] modelTypes = { "VAD", "ASR", "TTS", "Memory", "Intent", "LLM", "VLLM" };
-        String[] modelIds = { vadModelId, asrModelId, ttsModelId, memModelId, intentModelId, llmModelId };
+        String[] modelIds = { vadModelId, asrModelId, ttsModelId, memModelId, intentModelId, llmModelId, vllmModelId };
        String intentLLMModelId = null;
        String memLocalShortLLMModelId = null;
        for (int i = 0; i < modelIds.length; i++) {
            if (modelIds[i] == null) {
@@ -267,10 +273,11 @@ public class ConfigServiceImpl implements ConfigService {
                    Map<String, Object> map = (Map<String, Object>) model.getConfigJson();
                    if ("intent_llm".equals(map.get("type"))) {
                        intentLLMModelId = (String) map.get("llm");
-                        if (intentLLMModelId != null && intentLLMModelId.equals(llmModelId)) {
+                        if (StringUtils.isNotBlank(intentLLMModelId) && intentLLMModelId.equals(llmModelId)) {
                            intentLLMModelId = null;
                        }
-                    } else if ("function_call".equals(map.get("type"))) {
+                    }
                    if (map.get("functions") != null) {
                        String functionStr = (String) map.get("functions");
                        if (StringUtils.isNotBlank(functionStr)) {
                            String[] functions = functionStr.split("\\;");
@@ -278,10 +285,31 @@ public class ConfigServiceImpl implements ConfigService {
                        }
                    }
                }
                if ("Memory".equals(modelTypes[i])) {
                    Map<String, Object> map = (Map<String, Object>) model.getConfigJson();
                    if ("mem_local_short".equals(map.get("type"))) {
                        memLocalShortLLMModelId = (String) map.get("llm");
                        if (StringUtils.isNotBlank(memLocalShortLLMModelId)
                                && memLocalShortLLMModelId.equals(llmModelId)) {
                            memLocalShortLLMModelId = null;
                        }
                    }
                }
                // 如果是LLM类型，且intentLLMModelId不为空，则添加附加模型
-                if ("LLM".equals(modelTypes[i]) && intentLLMModelId != null) {
+                if ("LLM".equals(modelTypes[i])) {
-                    ModelConfigEntity intentLLM = modelConfigService.getModelById(intentLLMModelId, isCache);
+                    if (StringUtils.isNotBlank(intentLLMModelId)) {
-                    typeConfig.put(intentLLM.getId(), intentLLM.getConfigJson());
+                        if (!typeConfig.containsKey(intentLLMModelId)) {
                            ModelConfigEntity intentLLM = modelConfigService.getModelById(intentLLMModelId, isCache);
                            typeConfig.put(intentLLM.getId(), intentLLM.getConfigJson());
                        }
                    }
                    if (StringUtils.isNotBlank(memLocalShortLLMModelId)) {
                        if (!typeConfig.containsKey(memLocalShortLLMModelId)) {
                            ModelConfigEntity memLocalShortLLM = modelConfigService
                                    .getModelById(memLocalShortLLMModelId, isCache);
                            typeConfig.put(memLocalShortLLM.getId(), memLocalShortLLM.getConfigJson());
                        }
                    }
                }
            }
            result.put(modelTypes[i], typeConfig);
@@ -291,8 +319,9 @@ public class ConfigServiceImpl implements ConfigService {
        result.put("selected_module", selectedModule);
        if (StringUtils.isNotBlank(prompt)) {
-            prompt = prompt.replace("{{assistant_name}}", "小智");
+            prompt = prompt.replace("{{assistant_name}}", StringUtils.isBlank(assistantName) ? "小智" : assistantName);
        }
        result.put("prompt", prompt);
        result.put("summaryMemory", summaryMemory);
    }
 }
@@ -7,6 +7,7 @@ import org.apache.shiro.authz.annotation.RequiresPermissions;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.PutMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
@@ -79,4 +80,16 @@ public class DeviceController {
        return new Result<Void>();
    }
    @PutMapping("/enableOta/{id}/{status}")
    @Operation(summary = "启用/关闭OTA自动升级")
    @RequiresPermissions("sys:role:normal")
    public Result<Void> enableOtaUpgrade(@PathVariable String id, @PathVariable Integer status) {
        DeviceEntity entity = deviceService.selectById(id);
        if (entity == null) {
            return new Result<Void>().error("设备不存在");
        }
        entity.setAutoUpdate(status);
        deviceService.updateById(entity);
        return new Result<Void>();
    }
 }
@@ -15,25 +15,31 @@ import org.springframework.web.bind.annotation.RestController;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.swagger.v3.oas.annotations.Hidden;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.enums.ParameterIn;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import xiaozhi.common.constant.Constant;
 import xiaozhi.modules.device.dto.DeviceReportReqDTO;
 import xiaozhi.modules.device.dto.DeviceReportRespDTO;
 import xiaozhi.modules.device.entity.DeviceEntity;
 import xiaozhi.modules.device.service.DeviceService;
-import xiaozhi.modules.device.utils.NetworkUtil;
+import xiaozhi.modules.sys.service.SysParamsService;
@Tag(name = "设备管理", description = "OTA 相关接口")
@Slf4j
@RestController
@RequiredArgsConstructor
@RequestMapping("/ota/")
 public class OTAController {
    private final DeviceService deviceService;
    private final SysParamsService sysParamsService;
-    @Operation(summary = "检查 OTA 版本和设备激活状态")
+    @Operation(summary = "OTA版本和设备激活状态检查")
    @PostMapping
    public ResponseEntity<String> checkOTAVersion(
            @RequestBody DeviceReportReqDTO deviceReportReqDTO,
@@ -46,7 +52,7 @@ public class OTAController {
            clientId = deviceId;
        }
        String macAddress = deviceReportReqDTO.getMacAddress();
-        boolean macAddressValid = NetworkUtil.isMacAddressValid(macAddress);
+        boolean macAddressValid = isMacAddressValid(macAddress);
        // 设备Id和Mac地址应是一致的, 并且必须需要application字段
        if (!deviceId.equals(macAddress) || !macAddressValid || deviceReportReqDTO.getApplication() == null) {
            return createResponse(DeviceReportRespDTO.createError("Invalid OTA request"));
@@ -54,9 +60,33 @@ public class OTAController {
        return createResponse(deviceService.checkDeviceActive(macAddress, clientId, deviceReportReqDTO));
    }
    @Operation(summary = "设备快速检查激活状态")
    @PostMapping("activate")
    public ResponseEntity<String> activateDevice(
            @Parameter(name = "Device-Id", description = "设备唯一标识", required = true, in = ParameterIn.HEADER) @RequestHeader("Device-Id") String deviceId,
            @Parameter(name = "Client-Id", description = "客户端标识", required = false, in = ParameterIn.HEADER) @RequestHeader(value = "Client-Id", required = false) String clientId) {
        if (StringUtils.isBlank(deviceId)) {
            return ResponseEntity.status(202).build();
        }
        DeviceEntity device = deviceService.getDeviceByMacAddress(deviceId);
        if (device == null) {
            return ResponseEntity.status(202).build();
        }
        return ResponseEntity.ok("success");
    }
    @GetMapping
-    public ResponseEntity<String> getOTAPrompt() {
+    @Hidden
-        return createResponse(DeviceReportRespDTO.createError("请提交正确的ota参数"));
+    public ResponseEntity<String> getOTA() {
        String wsUrl = sysParamsService.getValue(Constant.SERVER_WEBSOCKET, true);
        if (StringUtils.isBlank(wsUrl) || wsUrl.equals("null")) {
            return ResponseEntity.ok("OTA接口不正常，缺少websocket地址，请登录智控台，在参数管理找到【server.websocket】配置");
        }
        String otaUrl = sysParamsService.getValue(Constant.SERVER_OTA, true);
        if (StringUtils.isBlank(otaUrl) || otaUrl.equals("null")) {
            return ResponseEntity.ok("OTA接口不正常，缺少ota地址，请登录智控台，在参数管理找到【server.ota】配置");
        }
        return ResponseEntity.ok("OTA接口运行正常，websocket集群数量：" + wsUrl.split(";").length);
    }
    @SneakyThrows
@@ -71,4 +101,19 @@ public class OTAController {
                .contentLength(jsonBytes.length)
                .body(json);
    }
    /**
     * 简单判断mac地址是否有效（非严格）
     * 
     * @param macAddress
     * @return
     */
    private boolean isMacAddressValid(String macAddress) {
        if (StringUtils.isBlank(macAddress)) {
            return false;
        }
        // MAC地址通常为12位十六进制数字，可以包含冒号或连字符分隔符
        String macPattern = "^([0-9A-Za-z]{2}[:-]){5}([0-9A-Za-z]{2})$";
        return macAddress.matches(macPattern);
    }
 }
@@ -0,0 +1,291 @@
 package xiaozhi.modules.device.controller;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.Map;
 import java.util.UUID;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.shiro.authz.annotation.RequiresPermissions;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.PutMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.multipart.MultipartFile;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.Parameters;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import xiaozhi.common.constant.Constant;
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.redis.RedisKeys;
 import xiaozhi.common.redis.RedisUtils;
 import xiaozhi.common.utils.Result;
 import xiaozhi.common.validator.ValidatorUtils;
 import xiaozhi.modules.device.entity.OtaEntity;
 import xiaozhi.modules.device.service.OtaService;
@Tag(name = "设备管理", description = "OTA 相关接口")
@Slf4j
@RestController
@RequiredArgsConstructor
@RequestMapping("/otaMag")
 public class OTAMagController {
    private static final Logger logger = LoggerFactory.getLogger(OTAController.class);
    private final OtaService otaService;
    private final RedisUtils redisUtils;
    @GetMapping
    @Operation(summary = "分页查询 OTA 固件信息")
    @Parameters({
            @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true),
            @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true)
    })
    @RequiresPermissions("sys:role:superAdmin")
    public Result<PageData<OtaEntity>> page(@Parameter(hidden = true) @RequestParam Map<String, Object> params) {
        ValidatorUtils.validateEntity(params);
        PageData<OtaEntity> page = otaService.page(params);
        return new Result<PageData<OtaEntity>>().ok(page);
    }
    @GetMapping("{id}")
    @Operation(summary = "信息 OTA 固件信息")
    @RequiresPermissions("sys:role:superAdmin")
    public Result<OtaEntity> get(@PathVariable("id") String id) {
        OtaEntity data = otaService.selectById(id);
        return new Result<OtaEntity>().ok(data);
    }
    @PostMapping
    @Operation(summary = "保存 OTA 固件信息")
    @RequiresPermissions("sys:role:superAdmin")
    public Result<Void> save(@RequestBody OtaEntity entity) {
        if (entity == null) {
            return new Result<Void>().error("固件信息不能为空");
        }
        if (StringUtils.isBlank(entity.getFirmwareName())) {
            return new Result<Void>().error("固件名称不能为空");
        }
        if (StringUtils.isBlank(entity.getType())) {
            return new Result<Void>().error("固件类型不能为空");
        }
        if (StringUtils.isBlank(entity.getVersion())) {
            return new Result<Void>().error("版本号不能为空");
        }
        try {
            otaService.save(entity);
            return new Result<Void>();
        } catch (RuntimeException e) {
            return new Result<Void>().error(e.getMessage());
        }
    }
    @DeleteMapping("/{id}")
    @Operation(summary = "OTA 删除")
    @RequiresPermissions("sys:role:superAdmin")
    public Result<Void> delete(@PathVariable("id") String[] ids) {
        if (ids == null || ids.length == 0) {
            return new Result<Void>().error("删除的固件ID不能为空");
        }
        otaService.delete(ids);
        return new Result<Void>();
    }
    @PutMapping("/{id}")
    @Operation(summary = "修改 OTA 固件信息")
    @RequiresPermissions("sys:role:superAdmin")
    public Result<?> update(@PathVariable("id") String id, @RequestBody OtaEntity entity) {
        if (entity == null) {
            return new Result<>().error("固件信息不能为空");
        }
        entity.setId(id);
        try {
            otaService.update(entity);
            return new Result<>();
        } catch (RuntimeException e) {
            return new Result<>().error(e.getMessage());
        }
    }
    @GetMapping("/getDownloadUrl/{id}")
    @Operation(summary = "获取 OTA 固件下载链接")
    @RequiresPermissions("sys:role:superAdmin")
    public Result<String> getDownloadUrl(@PathVariable("id") String id) {
        String uuid = UUID.randomUUID().toString();
        redisUtils.set(RedisKeys.getOtaIdKey(uuid), id);
        return new Result<String>().ok(uuid);
    }
    @GetMapping("/download/{uuid}")
    @Operation(summary = "下载固件文件")
    public ResponseEntity<byte[]> downloadFirmware(@PathVariable("uuid") String uuid) {
        String id = (String) redisUtils.get(RedisKeys.getOtaIdKey(uuid));
        if (StringUtils.isBlank(id)) {
            return ResponseEntity.notFound().build();
        }
        // 检查下载次数
        String downloadCountKey = RedisKeys.getOtaDownloadCountKey(uuid);
        Integer downloadCount = (Integer) redisUtils.get(downloadCountKey);
        if (downloadCount == null) {
            downloadCount = 0;
        }
        // 如果下载次数超过3次，返回404
        if (downloadCount >= 3) {
            redisUtils.delete(downloadCountKey);
            redisUtils.delete(RedisKeys.getOtaIdKey(uuid));
            logger.warn("Download limit exceeded for UUID: {}", uuid);
            return ResponseEntity.notFound().build();
        }
        redisUtils.set(downloadCountKey, downloadCount + 1);
        try {
            // 获取固件信息
            OtaEntity otaEntity = otaService.selectById(id);
            if (otaEntity == null || StringUtils.isBlank(otaEntity.getFirmwarePath())) {
                logger.warn("Firmware not found or path is empty for ID: {}", id);
                return ResponseEntity.notFound().build();
            }
            // 获取文件路径 - 确保路径是绝对路径或正确的相对路径
            String firmwarePath = otaEntity.getFirmwarePath();
            Path path;
            // 检查是否是绝对路径
            if (Paths.get(firmwarePath).isAbsolute()) {
                path = Paths.get(firmwarePath);
            } else {
                // 如果是相对路径，则从当前工作目录解析
                path = Paths.get(System.getProperty("user.dir"), firmwarePath);
            }
            logger.info("Attempting to download firmware for ID: {}, DB path: {}, resolved path: {}",
                    id, firmwarePath, path.toAbsolutePath());
            if (!Files.exists(path) || !Files.isRegularFile(path)) {
                // 尝试直接从firmware目录下查找文件名
                String fileName = new File(firmwarePath).getName();
                Path altPath = Paths.get(System.getProperty("user.dir"), "firmware", fileName);
                logger.info("File not found at primary path, trying alternative path: {}", altPath.toAbsolutePath());
                if (Files.exists(altPath) && Files.isRegularFile(altPath)) {
                    path = altPath;
                } else {
                    logger.error("Firmware file not found at either path: {} or {}",
                            path.toAbsolutePath(), altPath.toAbsolutePath());
                    return ResponseEntity.notFound().build();
                }
            }
            // 读取文件内容
            byte[] fileContent = Files.readAllBytes(path);
            // 设置响应头
            String originalFilename = otaEntity.getType() + "_" + otaEntity.getVersion();
            if (firmwarePath.contains(".")) {
                String extension = firmwarePath.substring(firmwarePath.lastIndexOf("."));
                originalFilename += extension;
            }
            // 清理文件名，移除不安全字符
            String safeFilename = originalFilename.replaceAll("[^a-zA-Z0-9._-]", "_");
            logger.info("Providing download for firmware ID: {}, filename: {}, size: {} bytes",
                    id, safeFilename, fileContent.length);
            return ResponseEntity.ok()
                    .contentType(MediaType.APPLICATION_OCTET_STREAM)
                    .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + safeFilename + "\"")
                    .body(fileContent);
        } catch (IOException e) {
            logger.error("Error reading firmware file for ID: {}", id, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        } catch (Exception e) {
            logger.error("Unexpected error during firmware download for ID: {}", id, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    @PostMapping("/upload")
    @Operation(summary = "上传固件文件")
    @RequiresPermissions("sys:role:superAdmin")
    public Result<String> uploadFirmware(@RequestParam("file") MultipartFile file) {
        if (file.isEmpty()) {
            return new Result<String>().error("上传文件不能为空");
        }
        // 检查文件扩展名
        String originalFilename = file.getOriginalFilename();
        if (originalFilename == null) {
            return new Result<String>().error("文件名不能为空");
        }
        String extension = originalFilename.substring(originalFilename.lastIndexOf(".")).toLowerCase();
        if (!extension.equals(".bin") && !extension.equals(".apk")) {
            return new Result<String>().error("只允许上传.bin和.apk格式的文件");
        }
        try {
            // 计算文件的MD5值
            String md5 = calculateMD5(file);
            // 设置存储路径
            String uploadDir = "uploadfile";
            Path uploadPath = Paths.get(uploadDir);
            // 如果目录不存在，创建目录
            if (!Files.exists(uploadPath)) {
                Files.createDirectories(uploadPath);
            }
            // 使用MD5作为文件名，固定使用.bin扩展名
            String uniqueFileName = md5 + extension;
            Path filePath = uploadPath.resolve(uniqueFileName);
            // 检查文件是否已存在
            if (Files.exists(filePath)) {
                return new Result<String>().ok(filePath.toString());
            }
            // 保存文件
            Files.copy(file.getInputStream(), filePath);
            // 返回文件路径
            return new Result<String>().ok(filePath.toString());
        } catch (IOException | NoSuchAlgorithmException e) {
            return new Result<String>().error("文件上传失败：" + e.getMessage());
        }
    }
    private String calculateMD5(MultipartFile file) throws IOException, NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] digest = md.digest(file.getBytes());
        StringBuilder sb = new StringBuilder();
        for (byte b : digest) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
 }
@@ -1,5 +1,7 @@
 package xiaozhi.modules.device.dao;
 import java.util.Date;
 import org.apache.ibatis.annotations.Mapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
@@ -8,4 +10,12 @@ import xiaozhi.modules.device.entity.DeviceEntity;
@Mapper
 public interface DeviceDao extends BaseMapper<DeviceEntity> {
    /**
     * 获取此智能体全部设备的最后连接时间
     * 
     * @param agentId 智能体id
     * @return
     */
    Date getAllLastConnectedAtByAgentId(String agentId);
 }
@@ -0,0 +1,15 @@
 package xiaozhi.modules.device.dao;
 import org.apache.ibatis.annotations.Mapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import xiaozhi.modules.device.entity.OtaEntity;
 /**
 * OTA固件管理
 */
@Mapper
 public interface OtaDao extends BaseMapper<OtaEntity> {
 }
@@ -19,6 +19,9 @@ public class DeviceReportRespDTO {
    @Schema(description = "固件版本信息")
    private Firmware firmware;
    @Schema(description = "WebSocket配置")
    private Websocket websocket;
    @Getter
    @Setter
@@ -44,6 +47,8 @@ public class DeviceReportRespDTO {
        @Schema(description = "激活码信息: 激活地址")
        private String message;
        @Schema(description = "挑战码")
        private String challenge;
    }
    @Getter
@@ -58,4 +63,11 @@ public class DeviceReportRespDTO {
        @Schema(description = "时区偏移量，单位为分钟")
        private Integer timezone_offset;
    }
    @Getter
    @Setter
    public static class Websocket {
        @Schema(description = "WebSocket服务器地址")
        private String url;
    }
 }
@@ -0,0 +1,61 @@
 package xiaozhi.modules.device.entity;
 import java.util.Date;
 import com.baomidou.mybatisplus.annotation.FieldFill;
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("ai_ota")
@Schema(description = "固件信息")
 public class OtaEntity {
    @TableId(type = IdType.ASSIGN_UUID)
    @Schema(description = "ID")
    private String id;
    @Schema(description = "固件名称")
    private String firmwareName;
    @Schema(description = "固件类型")
    private String type;
    @Schema(description = "版本号")
    private String version;
    @Schema(description = "文件大小(字节)")
    private Long size;
    @Schema(description = "备注/说明")
    private String remark;
    @Schema(description = "固件路径")
    private String firmwarePath;
    @Schema(description = "排序")
    private Integer sort;
    @Schema(description = "更新者")
    @TableField(fill = FieldFill.UPDATE)
    private Long updater;
    @Schema(description = "更新时间")
    @TableField(fill = FieldFill.UPDATE)
    private Date updateDate;
    @Schema(description = "创建者")
    @TableField(fill = FieldFill.INSERT)
    private Long creator;
    @Schema(description = "创建时间")
    @TableField(fill = FieldFill.INSERT)
    private Date createDate;
 }
@@ -1,20 +1,17 @@
 package xiaozhi.modules.device.service;
 import java.util.Date;
 import java.util.List;
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.service.BaseService;
 import xiaozhi.modules.device.dto.DevicePageUserDTO;
 import xiaozhi.modules.device.dto.DeviceReportReqDTO;
 import xiaozhi.modules.device.dto.DeviceReportRespDTO;
 import xiaozhi.modules.device.entity.DeviceEntity;
 import xiaozhi.modules.device.vo.UserShowDeviceListVO;
-public interface DeviceService {
+public interface DeviceService extends BaseService<DeviceEntity> {
    /**
     * 根据Mac地址获取设备信息
     */
    DeviceEntity getDeviceById(String macAddress);
    /**
     * 检查设备是否激活
@@ -82,4 +79,13 @@ public interface DeviceService {
     * @return 激活码
     */
    String geCodeByDeviceId(String deviceId);
    /**
     * 获取这个智能体设备理的最近的最后连接时间
     * @param agentId 智能体id
     * @return 返回设备最近的最后连接时间
     */
    Date getLatestLastConnectionTime(String agentId);
 }
@@ -0,0 +1,22 @@
 package xiaozhi.modules.device.service;
 import java.util.Map;
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.service.BaseService;
 import xiaozhi.modules.device.entity.OtaEntity;
 /**
 * OTA固件管理
 */
 public interface OtaService extends BaseService<OtaEntity> {
    PageData<OtaEntity> page(Map<String, Object> params);
    boolean save(OtaEntity entity);
    void update(OtaEntity entity);
    void delete(String[] ids);
    OtaEntity getLatestOta(String type);
 }
@@ -6,21 +6,28 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.TimeZone;
-import java.util.concurrent.TimeUnit;
+import java.util.UUID;
 import org.apache.commons.lang3.StringUtils;
-import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.aop.framework.AopContext;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
 import org.springframework.web.context.request.RequestContextHolder;
 import org.springframework.web.context.request.ServletRequestAttributes;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import cn.hutool.core.util.RandomUtil;
 import jakarta.servlet.http.HttpServletRequest;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import xiaozhi.common.constant.Constant;
 import xiaozhi.common.exception.RenException;
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.redis.RedisKeys;
 import xiaozhi.common.redis.RedisUtils;
 import xiaozhi.common.service.impl.BaseServiceImpl;
 import xiaozhi.common.user.UserDetail;
 import xiaozhi.common.utils.ConvertUtils;
@@ -30,38 +37,41 @@ import xiaozhi.modules.device.dto.DevicePageUserDTO;
 import xiaozhi.modules.device.dto.DeviceReportReqDTO;
 import xiaozhi.modules.device.dto.DeviceReportRespDTO;
 import xiaozhi.modules.device.entity.DeviceEntity;
 import xiaozhi.modules.device.entity.OtaEntity;
 import xiaozhi.modules.device.service.DeviceService;
 import xiaozhi.modules.device.service.OtaService;
 import xiaozhi.modules.device.vo.UserShowDeviceListVO;
 import xiaozhi.modules.security.user.SecurityUser;
 import xiaozhi.modules.sys.service.SysParamsService;
 import xiaozhi.modules.sys.service.SysUserUtilService;
@Slf4j
@Service
@AllArgsConstructor
 public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity> implements DeviceService {
    private final DeviceDao deviceDao;
    private final SysUserUtilService sysUserUtilService;
    private final SysParamsService sysParamsService;
    private final RedisUtils redisUtils;
    private final OtaService otaService;
-    private final String frontedUrl;
+    @Async
-
+    public void updateDeviceConnectionInfo(String agentId, String deviceId, String appVersion) {
-    private final RedisTemplate<String, Object> redisTemplate;
+        try {
-
+            DeviceEntity device = new DeviceEntity();
-    // 添加构造函数来初始化 deviceMapper
+            device.setId(deviceId);
-    public DeviceServiceImpl(DeviceDao deviceDao, SysUserUtilService sysUserUtilService,
+            device.setLastConnectedAt(new Date());
-            SysParamsService sysParamsService,
+            if (StringUtils.isNotBlank(appVersion)) {
-            RedisTemplate<String, Object> redisTemplate) {
+                device.setAppVersion(appVersion);
-        this.deviceDao = deviceDao;
+            }
-        this.sysUserUtilService = sysUserUtilService;
+            deviceDao.updateById(device);
-        this.frontedUrl = sysParamsService.getValue(Constant.SERVER_FRONTED_URL, true);
+            if (StringUtils.isNotBlank(agentId)) {
-        this.redisTemplate = redisTemplate;
+                redisUtils.set(RedisKeys.getAgentDeviceLastConnectedAtById(agentId), new Date());
-    }
+            }
-
+        } catch (Exception e) {
-    @Override
+            log.error("异步更新设备连接信息失败", e);
-    public DeviceEntity getDeviceById(String deviceId) {
+        }
        LambdaQueryWrapper<DeviceEntity> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(DeviceEntity::getId, deviceId);
        return deviceDao.selectOne(queryWrapper);
    }
    @Override
@@ -70,14 +80,14 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
            throw new RenException("激活码不能为空");
        }
        String deviceKey = "ota:activation:code:" + activationCode;
-        Object cacheDeviceId = redisTemplate.opsForValue().get(deviceKey);
+        Object cacheDeviceId = redisUtils.get(deviceKey);
        if (cacheDeviceId == null) {
            throw new RenException("激活码错误");
        }
        String deviceId = (String) cacheDeviceId;
        String safeDeviceId = deviceId.replace(":", "_").toLowerCase();
        String cacheDeviceKey = String.format("ota:activation:data:%s", safeDeviceId);
-        Map<Object, Object> cacheMap = redisTemplate.opsForHash().entries(cacheDeviceKey);
+        Map<String, Object> cacheMap = (Map<String, Object>) redisUtils.get(cacheDeviceKey);
        if (cacheMap == null) {
            throw new RenException("激活码错误");
        }
@@ -107,6 +117,7 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
        deviceEntity.setMacAddress(macAddress);
        deviceEntity.setUserId(user.getId());
        deviceEntity.setCreator(user.getId());
        deviceEntity.setAutoUpdate(1);
        deviceEntity.setCreateDate(currentTime);
        deviceEntity.setUpdater(user.getId());
        deviceEntity.setUpdateDate(currentTime);
@@ -114,8 +125,8 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
        deviceDao.insert(deviceEntity);
        // 清理redis缓存
-        redisTemplate.delete(cacheDeviceKey);
+        redisUtils.delete(cacheDeviceKey);
-        redisTemplate.delete(deviceKey);
+        redisUtils.delete(deviceKey);
        return true;
    }
@@ -124,19 +135,55 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
            DeviceReportReqDTO deviceReport) {
        DeviceReportRespDTO response = new DeviceReportRespDTO();
        response.setServer_time(buildServerTime());
        // todo: 此处是固件信息，目前是针对固件上传上来的版本号再返回回去
        // 在未来开发了固件更新功能，需要更换此处代码，
        // 或写定时任务定期请求虾哥的OTA，获取最新的版本讯息保存到服务内
        DeviceReportRespDTO.Firmware firmware = new DeviceReportRespDTO.Firmware();
        firmware.setVersion(deviceReport.getApplication().getVersion());
        firmware.setUrl("http://localhost:8002/xiaozhi/ota/download");
        response.setFirmware(firmware);
-        DeviceEntity deviceById = getDeviceById(macAddress);
+        DeviceEntity deviceById = getDeviceByMacAddress(macAddress);
-        if (deviceById != null) { // 如果设备存在，则更新上次连接时间
+
-            deviceById.setLastConnectedAt(new Date());
+        // 设备未绑定，则返回当前上传的固件信息（不更新）以此兼容旧固件版本
-            deviceDao.updateById(deviceById);
+        if (deviceById == null) {
-        } else { // 如果设备不存在，则生成激活码
+            DeviceReportRespDTO.Firmware firmware = new DeviceReportRespDTO.Firmware();
            firmware.setVersion(deviceReport.getApplication().getVersion());
            firmware.setUrl(Constant.INVALID_FIRMWARE_URL);
            response.setFirmware(firmware);
        } else {
            // 只有在设备已绑定且autoUpdate不为0的情况下才返回固件升级信息
            if (deviceById.getAutoUpdate() != 0) {
                String type = deviceReport.getBoard() == null ? null : deviceReport.getBoard().getType();
                DeviceReportRespDTO.Firmware firmware = buildFirmwareInfo(type,
                        deviceReport.getApplication() == null ? null : deviceReport.getApplication().getVersion());
                response.setFirmware(firmware);
            }
        }
        // 添加WebSocket配置
        DeviceReportRespDTO.Websocket websocket = new DeviceReportRespDTO.Websocket();
        // 从系统参数获取WebSocket URL，如果未配置则使用默认值
        String wsUrl = sysParamsService.getValue(Constant.SERVER_WEBSOCKET, true);
        if (StringUtils.isBlank(wsUrl) || wsUrl.equals("null")) {
            log.error("WebSocket地址未配置，请登录智控台，在参数管理找到【server.websocket】配置");
            wsUrl = "ws://xiaozhi.server.com:8000/xiaozhi/v1/";
            websocket.setUrl(wsUrl);
        } else {
            String[] wsUrls = wsUrl.split("\\;");
            if (wsUrls.length > 0) {
                // 随机选择一个WebSocket URL
                websocket.setUrl(wsUrls[RandomUtil.randomInt(0, wsUrls.length)]);
            } else {
                log.error("WebSocket地址未配置，请登录智控台，在参数管理找到【server.websocket】配置");
                websocket.setUrl("ws://xiaozhi.server.com:8000/xiaozhi/v1/");
            }
        }
        response.setWebsocket(websocket);
        if (deviceById != null) {
            // 如果设备存在，则异步更新上次连接时间和版本信息
            String appVersion = deviceReport.getApplication() != null ? deviceReport.getApplication().getVersion()
                    : null;
            // 通过Spring代理调用异步方法
            ((DeviceServiceImpl) AopContext.currentProxy()).updateDeviceConnectionInfo(deviceById.getAgentId(),
                    deviceById.getId(), appVersion);
        } else {
            // 如果设备不存在，则生成激活码
            DeviceReportRespDTO.Activation code = buildActivation(macAddress, deviceReport);
            response.setActivation(code);
        }
@@ -229,7 +276,7 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
    public String geCodeByDeviceId(String deviceId) {
        String dataKey = getDeviceCacheKey(deviceId);
-        Map<Object, Object> cacheMap = redisTemplate.opsForHash().entries(dataKey);
+        Map<String, Object> cacheMap = (Map<String, Object>) redisUtils.get(dataKey);
        if (cacheMap != null && cacheMap.containsKey("activation_code")) {
            String cachedCode = (String) cacheMap.get("activation_code");
            return cachedCode;
@@ -237,6 +284,20 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
        return null;
    }
    @Override
    public Date getLatestLastConnectionTime(String agentId) {
        // 查询是否有缓存时间，有则返回
        Date cachedDate = (Date) redisUtils.get(RedisKeys.getAgentDeviceLastConnectedAtById(agentId));
        if (cachedDate != null) {
            return cachedDate;
        }
        Date maxDate = deviceDao.getAllLastConnectedAtByAgentId(agentId);
        if (maxDate != null) {
            redisUtils.set(RedisKeys.getAgentDeviceLastConnectedAtById(agentId), maxDate);
        }
        return maxDate;
    }
    private String getDeviceCacheKey(String deviceId) {
        String safeDeviceId = deviceId.replace(":", "_").toLowerCase();
        String dataKey = String.format("ota:activation:data:%s", safeDeviceId);
@@ -250,11 +311,15 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
        if (StringUtils.isNotBlank(cachedCode)) {
            code.setCode(cachedCode);
            String frontedUrl = sysParamsService.getValue(Constant.SERVER_FRONTED_URL, true);
            code.setMessage(frontedUrl + "\n" + cachedCode);
            code.setChallenge(deviceId);
        } else {
            String newCode = RandomUtil.randomNumbers(6);
            code.setCode(newCode);
            String frontedUrl = sysParamsService.getValue(Constant.SERVER_FRONTED_URL, true);
            code.setMessage(frontedUrl + "\n" + newCode);
            code.setChallenge(deviceId);
            Map<String, Object> dataMap = new HashMap<>();
            dataMap.put("id", deviceId);
@@ -272,13 +337,77 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
            // 写入主数据 key
            String dataKey = getDeviceCacheKey(deviceId);
-            redisTemplate.opsForHash().putAll(dataKey, dataMap);
+            redisUtils.set(dataKey, dataMap);
            redisTemplate.expire(dataKey, 24, TimeUnit.HOURS);
            // 写入反查激活码 key
            String codeKey = "ota:activation:code:" + newCode;
-            redisTemplate.opsForValue().set(codeKey, deviceId, 24, TimeUnit.HOURS);
+            redisUtils.set(codeKey, deviceId);
        }
        return code;
    }
-}
+
    private DeviceReportRespDTO.Firmware buildFirmwareInfo(String type, String currentVersion) {
        if (StringUtils.isBlank(type)) {
            return null;
        }
        if (StringUtils.isBlank(currentVersion)) {
            currentVersion = "0.0.0";
        }
        OtaEntity ota = otaService.getLatestOta(type);
        DeviceReportRespDTO.Firmware firmware = new DeviceReportRespDTO.Firmware();
        String downloadUrl = null;
        if (ota != null) {
            // 如果设备没有版本信息，或者OTA版本比设备版本新，则返回下载地址
            if (compareVersions(ota.getVersion(), currentVersion) > 0) {
                String otaUrl = sysParamsService.getValue(Constant.SERVER_OTA, true);
                if (StringUtils.isBlank(otaUrl) || otaUrl.equals("null")) {
                    log.error("OTA地址未配置，请登录智控台，在参数管理找到【server.ota】配置");
                    // 尝试从请求中获取
                    HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder
                            .getRequestAttributes())
                            .getRequest();
                    otaUrl = request.getRequestURL().toString();
                }
                // 将URL中的/ota/替换为/otaMag/download/
                String uuid = UUID.randomUUID().toString();
                redisUtils.set(RedisKeys.getOtaIdKey(uuid), ota.getId());
                downloadUrl = otaUrl.replace("/ota/", "/otaMag/download/") + uuid;
            }
        }
        firmware.setVersion(ota == null ? currentVersion : ota.getVersion());
        firmware.setUrl(downloadUrl == null ? Constant.INVALID_FIRMWARE_URL : downloadUrl);
        return firmware;
    }
    /**
     * 比较两个版本号
     * 
     * @param version1 版本1
     * @param version2 版本2
     * @return 如果version1 > version2返回1，version1 < version2返回-1，相等返回0
     */
    private static int compareVersions(String version1, String version2) {
        if (version1 == null || version2 == null) {
            return 0;
        }
        String[] v1Parts = version1.split("\\.");
        String[] v2Parts = version2.split("\\.");
        int length = Math.max(v1Parts.length, v2Parts.length);
        for (int i = 0; i < length; i++) {
            int v1 = i < v1Parts.length ? Integer.parseInt(v1Parts[i]) : 0;
            int v2 = i < v2Parts.length ? Integer.parseInt(v2Parts[i]) : 0;
            if (v1 > v2) {
                return 1;
            } else if (v1 < v2) {
                return -1;
            }
        }
        return 0;
    }
 }
@@ -0,0 +1,85 @@
 package xiaozhi.modules.device.service.impl;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
 import org.springframework.stereotype.Service;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import io.micrometer.common.util.StringUtils;
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.service.impl.BaseServiceImpl;
 import xiaozhi.modules.device.dao.OtaDao;
 import xiaozhi.modules.device.entity.OtaEntity;
 import xiaozhi.modules.device.service.OtaService;
@Service
 public class OtaServiceImpl extends BaseServiceImpl<OtaDao, OtaEntity> implements OtaService {
    @Override
    public PageData<OtaEntity> page(Map<String, Object> params) {
        IPage<OtaEntity> page = baseDao.selectPage(
                getPage(params, "update_date", true),
                getWrapper(params));
        return new PageData<>(page.getRecords(), page.getTotal());
    }
    private QueryWrapper<OtaEntity> getWrapper(Map<String, Object> params) {
        String firmwareName = (String) params.get("firmwareName");
        QueryWrapper<OtaEntity> wrapper = new QueryWrapper<>();
        wrapper.like(StringUtils.isNotBlank(firmwareName), "firmware_name", firmwareName);
        return wrapper;
    }
    @Override
    public void update(OtaEntity entity) {
        // 检查是否存在相同类型和版本的固件（排除当前记录）
        QueryWrapper<OtaEntity> queryWrapper = new QueryWrapper<OtaEntity>()
                .eq("type", entity.getType())
                .eq("version", entity.getVersion())
                .ne("id", entity.getId()); // 排除当前记录
        if (baseDao.selectCount(queryWrapper) > 0) {
            throw new RuntimeException("已存在相同类型和版本的固件，请修改后重试");
        }
        entity.setUpdateDate(new Date());
        baseDao.updateById(entity);
    }
    @Override
    public void delete(String[] ids) {
        baseDao.deleteBatchIds(Arrays.asList(ids));
    }
    @Override
    public boolean save(OtaEntity entity) {
        QueryWrapper<OtaEntity> queryWrapper = new QueryWrapper<OtaEntity>()
                .eq("type", entity.getType());
        // 同类固件只保留最新的一条
        List<OtaEntity> otaList = baseDao.selectList(queryWrapper);
        if (otaList != null && otaList.size() > 0) {
            OtaEntity otaBefore = otaList.getFirst();
            entity.setId(otaBefore.getId());
            baseDao.updateById(entity);
            return true;
        }
        return baseDao.insert(entity) > 0;
    }
    @Override
    public OtaEntity getLatestOta(String type) {
        QueryWrapper<OtaEntity> wrapper = new QueryWrapper<>();
        wrapper.eq("type", type)
                .orderByDesc("update_date")
                .last("LIMIT 1");
        return baseDao.selectOne(wrapper);
    }
 }
@@ -1,34 +0,0 @@
 package xiaozhi.modules.device.utils;
 import java.util.regex.Pattern;
 import org.apache.commons.lang3.StringUtils;
 /**
 * 网络工具类
 */
 public class NetworkUtil {
    /**
     * MAC地址正则表达式
     */
    private static final Pattern macPattern = Pattern.compile("^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$");
    /**
     * 判断MAC地址是否合法
     */
    public static boolean isMacAddressValid(String mac) {
        if (StringUtils.isBlank(mac)) {
            return false;
        }
        // 正则校验格式
        if (!macPattern.matcher(mac).matches()) {
            return false;
        }
        // 校验MAC地址是否为单播地址
        String normalized = mac.toLowerCase();
        String[] parts = normalized.split("[:-]");
        int firstByte = Integer.parseInt(parts[0], 16);
        return (firstByte & 1) == 0; // 最低位为0表示单播地址，合法
    }
 }
@@ -0,0 +1,68 @@
 package xiaozhi.modules.model.controller;
 import java.util.List;
 import org.apache.shiro.authz.annotation.RequiresPermissions;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.PutMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.AllArgsConstructor;
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.utils.Result;
 import xiaozhi.common.validator.group.UpdateGroup;
 import xiaozhi.modules.model.dto.ModelProviderDTO;
 import xiaozhi.modules.model.service.ModelProviderService;
@AllArgsConstructor
@RestController
@RequestMapping("/models/provider")
@Tag(name = "模型供应器")
 public class ModelProviderController {
    private final ModelProviderService modelProviderService;
    @GetMapping
    @Operation(summary = "获取模型供应器列表")
    @RequiresPermissions("sys:role:superAdmin")
    public Result<PageData<ModelProviderDTO>> getListPage(ModelProviderDTO modelProviderDTO,
            @RequestParam(required = true, defaultValue = "0") String page,
            @RequestParam(required = true, defaultValue = "10") String limit) {
        return new Result<PageData<ModelProviderDTO>>()
                .ok(modelProviderService.getListPage(modelProviderDTO, page, limit));
    }
    @PostMapping
    @Operation(summary = "新增模型供应器")
    @RequiresPermissions("sys:role:superAdmin")
    public Result<ModelProviderDTO> add(@RequestBody @Validated ModelProviderDTO modelProviderDTO) {
        ModelProviderDTO resp = modelProviderService.add(modelProviderDTO);
        return new Result<ModelProviderDTO>().ok(resp);
    }
    @PutMapping
    @Operation(summary = "修改模型供应器")
    @RequiresPermissions("sys:role:superAdmin")
    public Result<ModelProviderDTO> edit(@RequestBody @Validated(UpdateGroup.class) ModelProviderDTO modelProviderDTO) {
        ModelProviderDTO resp = modelProviderService.edit(modelProviderDTO);
        return new Result<ModelProviderDTO>().ok(resp);
    }
    @PostMapping("/delete")
    @Operation(summary = "删除模型供应器")
    @RequiresPermissions("sys:role:superAdmin")
    @Parameter(name = "ids", description = "ID数组", required = true)
    public Result<Void> delete(@RequestBody List<String> ids) {
        modelProviderService.delete(ids);
        return new Result<>();
    }
 }
@@ -8,29 +8,37 @@ import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import lombok.Data;
 import xiaozhi.common.validator.group.UpdateGroup;
@Data
@Schema(description = "模型供应器/商")
 public class ModelProviderDTO implements Serializable {
-    //
+    @Schema(description = "主键")
-    // @Schema(description = "主键")
+    @NotBlank(message = "id不能为空", groups = UpdateGroup.class)
-    // private Long id;
+    private String id;
    @Schema(description = "模型类型(Memory/ASR/VAD/LLM/TTS)")
    @NotBlank(message = "modelType不能为空")
    private String modelType;
    @Schema(description = "供应器类型")
    @NotBlank(message = "providerCode不能为空")
    private String providerCode;
    @Schema(description = "供应器名称")
    @NotBlank(message = "name不能为空")
    private String name;
    @Schema(description = "供应器字段列表(JSON格式)")
    @TableField(typeHandler = JacksonTypeHandler.class)
    @NotBlank(message = "fields(JSON格式)不能为空")
    private String fields;
    @Schema(description = "排序")
    @NotNull(message = "sort不能为空")
    private Integer sort;
    @Schema(description = "更新者")
@@ -3,10 +3,8 @@ package xiaozhi.modules.model.entity;
 import java.util.Date;
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
@@ -30,7 +28,6 @@ public class ModelProviderEntity {
    private String name;
    @Schema(description = "供应器字段列表(JSON格式)")
    @TableField(typeHandler = JacksonTypeHandler.class)
    private String fields;
    @Schema(description = "排序")
@@ -2,8 +2,8 @@ package xiaozhi.modules.model.service;
 import java.util.List;
 import xiaozhi.common.page.PageData;
 import xiaozhi.modules.model.dto.ModelProviderDTO;
 import xiaozhi.modules.model.entity.ModelProviderEntity;
 public interface ModelProviderService {
@@ -11,11 +11,15 @@ public interface ModelProviderService {
    List<ModelProviderDTO> getListByModelType(String modelType);
-    ModelProviderDTO add(ModelProviderEntity modelProviderEntity);
+    ModelProviderDTO add(ModelProviderDTO modelProviderDTO);
-    ModelProviderDTO edit(ModelProviderEntity modelProviderEntity);
+    ModelProviderDTO edit(ModelProviderDTO modelProviderDTO);
-    void delete();
+    void delete(String id);
    void delete(List<String> id);
    PageData<ModelProviderDTO> getListPage(ModelProviderDTO modelProviderDTO, String page, String limit);
    List<ModelProviderDTO> getList(String modelType, String provideCode);
 }
@@ -3,6 +3,7 @@ package xiaozhi.modules.model.service.impl;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
@@ -19,6 +20,8 @@ import xiaozhi.common.redis.RedisKeys;
 import xiaozhi.common.redis.RedisUtils;
 import xiaozhi.common.service.impl.BaseServiceImpl;
 import xiaozhi.common.utils.ConvertUtils;
 import xiaozhi.modules.agent.dao.AgentDao;
 import xiaozhi.modules.agent.entity.AgentEntity;
 import xiaozhi.modules.model.dao.ModelConfigDao;
 import xiaozhi.modules.model.dto.ModelBasicInfoDTO;
 import xiaozhi.modules.model.dto.ModelConfigBodyDTO;
@@ -36,6 +39,7 @@ public class ModelConfigServiceImpl extends BaseServiceImpl<ModelConfigDao, Mode
    private final ModelConfigDao modelConfigDao;
    private final ModelProviderService modelProviderService;
    private final RedisUtils redisUtils;
    private final AgentDao agentDao;
    @Override
    public List<ModelBasicInfoDTO> getModelCodeList(String modelType, String modelName) {
@@ -75,6 +79,7 @@ public class ModelConfigServiceImpl extends BaseServiceImpl<ModelConfigDao, Mode
        // 再保存供应器提供的模型
        ModelConfigEntity modelConfigEntity = ConvertUtils.sourceToTarget(modelConfigBodyDTO, ModelConfigEntity.class);
        modelConfigEntity.setModelType(modelType);
        modelConfigEntity.setIsDefault(0);
        modelConfigDao.insert(modelConfigEntity);
        return ConvertUtils.sourceToTarget(modelConfigEntity, ModelConfigDTO.class);
    }
@@ -102,9 +107,64 @@ public class ModelConfigServiceImpl extends BaseServiceImpl<ModelConfigDao, Mode
    @Override
    public void delete(String id) {
        // 查看是否是默认
        ModelConfigEntity modelConfig = modelConfigDao.selectById(id);
        if (modelConfig != null && modelConfig.getIsDefault() == 1) {
            throw new RenException("该模型为默认模型，请先设置其他模型为默认模型");
        }
        // 验证是否有引用
        checkAgentReference(id);
        checkIntentConfigReference(id);
        modelConfigDao.deleteById(id);
    }
    /**
     * 检查智能体配置是否有引用
     * 
     * @param modelId 模型ID
     */
    private void checkAgentReference(String modelId) {
        List<AgentEntity> agents = agentDao.selectList(
                new QueryWrapper<AgentEntity>()
                        .eq("vad_model_id", modelId)
                        .or()
                        .eq("asr_model_id", modelId)
                        .or()
                        .eq("llm_model_id", modelId)
                        .or()
                        .eq("tts_model_id", modelId)
                        .or()
                        .eq("mem_model_id", modelId)
                        .or()
                        .eq("intent_model_id", modelId));
        if (!agents.isEmpty()) {
            String agentNames = agents.stream()
                    .map(AgentEntity::getAgentName)
                    .collect(Collectors.joining("、"));
            throw new RenException(String.format("该模型配置已被智能体[%s]引用，无法删除", agentNames));
        }
    }
    /**
     * 检查意图识别配置是否有引用
     * 
     * @param modelId 模型ID
     */
    private void checkIntentConfigReference(String modelId) {
        ModelConfigEntity modelConfig = modelConfigDao.selectById(modelId);
        if (modelConfig != null
                && "LLM".equals(modelConfig.getModelType() == null ? null : modelConfig.getModelType().toUpperCase())) {
            List<ModelConfigEntity> intentConfigs = modelConfigDao.selectList(
                    new QueryWrapper<ModelConfigEntity>()
                            .eq("model_type", "Intent")
                            .like("config_json", "%" + modelId + "%"));
            if (!intentConfigs.isEmpty()) {
                throw new RenException("该LLM模型已被意图识别配置引用，无法删除");
            }
        }
    }
    @Override
    public String getModelNameById(String id) {
        if (StringUtils.isBlank(id)) {
@@ -1,19 +1,29 @@
 package xiaozhi.modules.model.service.impl;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import cn.hutool.json.JSONArray;
 import lombok.AllArgsConstructor;
 import xiaozhi.common.constant.Constant;
 import xiaozhi.common.exception.RenException;
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.service.impl.BaseServiceImpl;
 import xiaozhi.common.user.UserDetail;
 import xiaozhi.common.utils.ConvertUtils;
 import xiaozhi.modules.model.dao.ModelProviderDao;
 import xiaozhi.modules.model.dto.ModelProviderDTO;
 import xiaozhi.modules.model.entity.ModelProviderEntity;
 import xiaozhi.modules.model.service.ModelProviderService;
 import xiaozhi.modules.security.user.SecurityUser;
@Service
@AllArgsConstructor
@@ -32,18 +42,78 @@ public class ModelProviderServiceImpl extends BaseServiceImpl<ModelProviderDao,
    }
    @Override
-    public ModelProviderDTO add(ModelProviderEntity modelProviderEntity) {
+    public PageData<ModelProviderDTO> getListPage(ModelProviderDTO modelProviderDTO, String page, String limit) {
-        return null;
+
        Map<String, Object> params = new HashMap<String, Object>();
        params.put(Constant.PAGE, page);
        params.put(Constant.LIMIT, limit);
        params.put(Constant.ORDER_FIELD, List.of("model_type", "sort"));
        params.put(Constant.ORDER, "asc");
        IPage<ModelProviderEntity> pageParam = getPage(params, null, true);
        QueryWrapper<ModelProviderEntity> wrapper = new QueryWrapper<ModelProviderEntity>();
        if (StringUtils.isNotBlank(modelProviderDTO.getModelType())) {
            wrapper.eq("model_type", modelProviderDTO.getModelType());
        }
        if (StringUtils.isNotBlank(modelProviderDTO.getName())) {
            wrapper.and(w -> w.like("name", modelProviderDTO.getName())
                    .or()
                    .like("provider_code", modelProviderDTO.getName()));
        }
        return getPageData(modelProviderDao.selectPage(pageParam, wrapper), ModelProviderDTO.class);
    }
    public static void main(String[] args) {
        String jsonString = "\"[]\"";
        JSONArray jsonArray = new JSONArray(jsonString);
        System.out.println("字符串转 JSONArray: " + jsonArray.toString());
    }
    @Override
-    public ModelProviderDTO edit(ModelProviderEntity modelProviderEntity) {
+    public ModelProviderDTO add(ModelProviderDTO modelProviderDTO) {
-        return null;
+        UserDetail user = SecurityUser.getUser();
        modelProviderDTO.setCreator(user.getId());
        modelProviderDTO.setUpdater(user.getId());
        modelProviderDTO.setCreateDate(new Date());
        modelProviderDTO.setUpdateDate(new Date());
        // 去除Fields左右的双引号
        modelProviderDTO.setFields(modelProviderDTO.getFields());
        ModelProviderEntity entity = ConvertUtils.sourceToTarget(modelProviderDTO, ModelProviderEntity.class);
        if (modelProviderDao.insert(entity) == 0) {
            throw new RenException("新增数据失败");
        }
        return ConvertUtils.sourceToTarget(modelProviderDTO, ModelProviderDTO.class);
    }
    @Override
-    public void delete() {
+    public ModelProviderDTO edit(ModelProviderDTO modelProviderDTO) {
        UserDetail user = SecurityUser.getUser();
        modelProviderDTO.setUpdater(user.getId());
        modelProviderDTO.setUpdateDate(new Date());
        if (modelProviderDao
                .updateById(ConvertUtils.sourceToTarget(modelProviderDTO, ModelProviderEntity.class)) == 0) {
            throw new RenException("修改数据失败");
        }
        return ConvertUtils.sourceToTarget(modelProviderDTO, ModelProviderDTO.class);
    }
    @Override
    public void delete(String id) {
        if (modelProviderDao.deleteById(id) == 0) {
            throw new RenException("删除数据失败");
        }
    }
    @Override
    public void delete(List<String> ids) {
        if (modelProviderDao.deleteBatchIds(ids) == 0) {
            throw new RenException("删除数据失败");
        }
    }
    @Override
@@ -18,6 +18,8 @@ import org.springframework.context.annotation.Configuration;
 import jakarta.servlet.Filter;
 import xiaozhi.modules.security.oauth2.Oauth2Filter;
 import xiaozhi.modules.security.oauth2.Oauth2Realm;
 import xiaozhi.modules.security.secret.ServerSecretFilter;
 import xiaozhi.modules.sys.service.SysParamsService;
 /**
 * Shiro的配置文件
@@ -46,7 +48,7 @@ public class ShiroConfig {
    }
    @Bean("shiroFilter")
-    public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
+    public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager, SysParamsService sysParamsService) {
        ShiroFilterConfiguration config = new ShiroFilterConfiguration();
        config.setFilterOncePerRequest(true);
@@ -54,9 +56,11 @@ public class ShiroConfig {
        shiroFilter.setSecurityManager(securityManager);
        shiroFilter.setShiroFilterConfiguration(config);
        // oauth过滤
        Map<String, Filter> filters = new HashMap<>();
        // oauth过滤
        filters.put("oauth2", new Oauth2Filter());
        // 服务密钥过滤
        filters.put("server", new ServerSecretFilter(sysParamsService));
        shiroFilter.setFilters(filters);
        // 添加Shiro的内置过滤器
@@ -69,17 +73,23 @@ public class ShiroConfig {
         */
        Map<String, String> filterMap = new LinkedHashMap<>();
        filterMap.put("/ota/**", "anon");
        filterMap.put("/otaMag/download/**", "anon");
        filterMap.put("/webjars/**", "anon");
        filterMap.put("/druid/**", "anon");
        filterMap.put("/v3/api-docs/**", "anon");
        filterMap.put("/doc.html", "anon");
        filterMap.put("/favicon.ico", "anon");
        filterMap.put("/user/captcha", "anon");
        filterMap.put("/user/smsVerification", "anon");
        filterMap.put("/user/login", "anon");
        filterMap.put("/user/pub-config", "anon");
        filterMap.put("/user/register", "anon");
-        filterMap.put("/config/server-base", "anon");
+        filterMap.put("/user/retrieve-password", "anon");
-        filterMap.put("/config/agent-models", "anon");
+        // 将config路径使用server服务过滤器
        filterMap.put("/config/**", "server");
        filterMap.put("/agent/chat-history/report", "server");
        filterMap.put("/agent/saveMemory/**", "server");
        filterMap.put("/agent/play/**", "anon");
        filterMap.put("/**", "oauth2");
        shiroFilter.setFilterChainDefinitionMap(filterMap);
@@ -97,4 +107,4 @@ public class ShiroConfig {
        advisor.setSecurityManager(securityManager);
        return advisor;
    }
-}
+}
@@ -1,5 +1,6 @@
 package xiaozhi.modules.security.config;
 import java.text.SimpleDateFormat;
 import java.util.List;
 import java.util.TimeZone;
@@ -18,6 +19,15 @@ import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.module.SimpleModule;
 import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
 import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
 import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
 import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
 import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
 import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
 import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
 import xiaozhi.common.utils.DateUtils;
@Configuration
 public class WebMvcConfig implements WebMvcConfigurer {
@@ -33,11 +43,15 @@ public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        // 特殊用途的转换器
        converters.add(new ByteArrayHttpMessageConverter());
        converters.add(new StringHttpMessageConverter());
        converters.add(new ResourceHttpMessageConverter());
-        converters.add(new AllEncompassingFormHttpMessageConverter());
+
        // 通用转换器
        converters.add(new StringHttpMessageConverter());
        converters.add(new AllEncompassingFormHttpMessageConverter());
        // JSON 转换器
        converters.add(jackson2HttpMessageConverter());
    }
@@ -49,10 +63,29 @@ public class WebMvcConfig implements WebMvcConfigurer {
        // 忽略未知属性
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
-        // 日期格式转换
+        // 设置时区
        // mapper.setDateFormat(new SimpleDateFormat(DateUtils.DATE_TIME_PATTERN));
        mapper.setTimeZone(TimeZone.getTimeZone("GMT+8"));
        // 配置Java8日期时间序列化
        JavaTimeModule javaTimeModule = new JavaTimeModule();
        javaTimeModule.addSerializer(java.time.LocalDateTime.class, new LocalDateTimeSerializer(
                java.time.format.DateTimeFormatter.ofPattern(DateUtils.DATE_TIME_PATTERN)));
        javaTimeModule.addSerializer(java.time.LocalDate.class, new LocalDateSerializer(
                java.time.format.DateTimeFormatter.ofPattern(DateUtils.DATE_PATTERN)));
        javaTimeModule.addSerializer(java.time.LocalTime.class,
                new LocalTimeSerializer(java.time.format.DateTimeFormatter.ofPattern("HH:mm:ss")));
        javaTimeModule.addDeserializer(java.time.LocalDateTime.class, new LocalDateTimeDeserializer(
                java.time.format.DateTimeFormatter.ofPattern(DateUtils.DATE_TIME_PATTERN)));
        javaTimeModule.addDeserializer(java.time.LocalDate.class, new LocalDateDeserializer(
                java.time.format.DateTimeFormatter.ofPattern(DateUtils.DATE_PATTERN)));
        javaTimeModule.addDeserializer(java.time.LocalTime.class,
                new LocalTimeDeserializer(java.time.format.DateTimeFormatter.ofPattern("HH:mm:ss")));
        mapper.registerModule(javaTimeModule);
        // 配置java.util.Date的序列化和反序列化
        SimpleDateFormat dateFormat = new SimpleDateFormat(DateUtils.DATE_TIME_PATTERN);
        mapper.setDateFormat(dateFormat);
        // Long类型转String类型
        SimpleModule simpleModule = new SimpleModule();
        simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
@@ -1,7 +1,9 @@
 package xiaozhi.modules.security.controller;
 import java.io.IOException;
 import java.util.Calendar;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -24,13 +26,18 @@ import xiaozhi.common.utils.Result;
 import xiaozhi.common.validator.AssertUtils;
 import xiaozhi.common.validator.ValidatorUtils;
 import xiaozhi.modules.security.dto.LoginDTO;
 import xiaozhi.modules.security.dto.SmsVerificationDTO;
 import xiaozhi.modules.security.password.PasswordUtils;
 import xiaozhi.modules.security.service.CaptchaService;
 import xiaozhi.modules.security.service.SysUserTokenService;
 import xiaozhi.modules.security.user.SecurityUser;
 import xiaozhi.modules.sys.dto.PasswordDTO;
 import xiaozhi.modules.sys.dto.RetrievePasswordDTO;
 import xiaozhi.modules.sys.dto.SysUserDTO;
 import xiaozhi.modules.sys.service.SysDictDataService;
 import xiaozhi.modules.sys.service.SysParamsService;
 import xiaozhi.modules.sys.service.SysUserService;
 import xiaozhi.modules.sys.vo.SysDictDataItem;
 /**
 * 登录控制层
@@ -43,24 +50,43 @@ public class LoginController {
    private final SysUserService sysUserService;
    private final SysUserTokenService sysUserTokenService;
    private final CaptchaService captchaService;
    private final SysParamsService sysParamsService;
    private final SysDictDataService sysDictDataService;
    @GetMapping("/captcha")
    @Operation(summary = "验证码")
    public void captcha(HttpServletResponse response, String uuid) throws IOException {
        // uuid不能为空
        AssertUtils.isBlank(uuid, ErrorCode.IDENTIFIER_NOT_NULL);
        // 生成验证码
        captchaService.create(response, uuid);
    }
    @PostMapping("/smsVerification")
    @Operation(summary = "短信验证码")
    public Result<Void> smsVerification(@RequestBody SmsVerificationDTO dto) {
        // 验证图形验证码
        boolean validate = captchaService.validate(dto.getCaptchaId(), dto.getCaptcha(), true);
        if (!validate) {
            throw new RenException("图形验证码错误");
        }
        Boolean isMobileRegister = sysParamsService
                .getValueObject(Constant.SysMSMParam.SERVER_ENABLE_MOBILE_REGISTER.getValue(), Boolean.class);
        if (!isMobileRegister) {
            throw new RenException("没有开启手机注册，没法使用短信验证码功能");
        }
        // 发送短信验证码
        captchaService.sendSMSValidateCode(dto.getPhone());
        return new Result<>();
    }
    @PostMapping("/login")
    @Operation(summary = "登录")
    public Result<TokenDTO> login(@RequestBody LoginDTO login) {
        // 验证是否正确输入验证码
-        boolean validate = captchaService.validate(login.getCaptchaId(), login.getCaptcha());
+        boolean validate = captchaService.validate(login.getCaptchaId(), login.getCaptcha(), true);
        if (!validate) {
-            throw new RenException("验证码错误，请重新获取");
+            throw new RenException("图形验证码错误，请重新获取");
        }
        // 按照用户名获取用户
        SysUserDTO userDTO = sysUserService.getByUsername(login.getUsername());
@@ -81,11 +107,29 @@ public class LoginController {
        if (!sysUserService.getAllowUserRegister()) {
            throw new RenException("当前不允许普通用户注册");
        }
-        // 验证是否正确输入验证码
+        // 是否开启手机注册
-        boolean validate = captchaService.validate(login.getCaptchaId(), login.getCaptcha());
+        Boolean isMobileRegister = sysParamsService
-        if (!validate) {
+                .getValueObject(Constant.SysMSMParam.SERVER_ENABLE_MOBILE_REGISTER.getValue(), Boolean.class);
-            throw new RenException("验证码错误，请重新获取");
+        boolean validate;
        if (isMobileRegister) {
            // 验证用户是否是手机号码
            boolean validPhone = ValidatorUtils.isValidPhone(login.getUsername());
            if (!validPhone) {
                throw new RenException("用户名不是手机号码，请重新输入");
            }
            // 验证短信验证码是否正常
            validate = captchaService.validateSMSValidateCode(login.getUsername(), login.getMobileCaptcha(), false);
            if (!validate) {
                throw new RenException("手机验证码错误，请重新获取");
            }
        } else {
            // 验证是否正确输入验证码
            validate = captchaService.validate(login.getCaptchaId(), login.getCaptcha(), true);
            if (!validate) {
                throw new RenException("图形验证码错误，请重新获取");
            }
        }
        // 按照用户名获取用户
        SysUserDTO userDTO = sysUserService.getByUsername(login.getUsername());
        if (userDTO != null) {
@@ -96,7 +140,6 @@ public class LoginController {
        userDTO.setPassword(login.getPassword());
        sysUserService.save(userDTO);
        return new Result<>();
    }
    @GetMapping("/info")
@@ -118,12 +161,54 @@ public class LoginController {
        return new Result<>();
    }
    @PutMapping("/retrieve-password")
    @Operation(summary = "找回密码")
    public Result<?> retrievePassword(@RequestBody RetrievePasswordDTO dto) {
        // 是否开启手机注册
        Boolean isMobileRegister = sysParamsService
                .getValueObject(Constant.SysMSMParam.SERVER_ENABLE_MOBILE_REGISTER.getValue(), Boolean.class);
        if (!isMobileRegister) {
            throw new RenException("没有开启手机注册，没法使用找回密码功能");
        }
        // 判断非空
        ValidatorUtils.validateEntity(dto);
        // 验证用户是否是手机号码
        boolean validPhone = ValidatorUtils.isValidPhone(dto.getPhone());
        if (!validPhone) {
            throw new RenException("输入的手机号码格式不正确");
        }
        // 按照用户名获取用户
        SysUserDTO userDTO = sysUserService.getByUsername(dto.getPhone());
        if (userDTO == null) {
            throw new RenException("输入的手机号码未注册");
        }
        // 验证短信验证码是否正常
        boolean validate = captchaService.validateSMSValidateCode(dto.getPhone(), dto.getCode(), false);
        // 判断是否通过验证
        if (!validate) {
            throw new RenException("输入的手机验证码错误");
        }
        sysUserService.changePasswordDirectly(userDTO.getId(), dto.getPassword());
        return new Result<>();
    }
    @GetMapping("/pub-config")
    @Operation(summary = "公共配置")
    public Result<Map<String, Object>> pubConfig() {
        Map<String, Object> config = new HashMap<>();
        config.put("enableMobileRegister", sysParamsService
                .getValueObject(Constant.SysMSMParam.SERVER_ENABLE_MOBILE_REGISTER.getValue(), Boolean.class));
        config.put("version", Constant.VERSION);
        config.put("year", "©" + Calendar.getInstance().get(Calendar.YEAR));
        config.put("allowUserRegister", sysUserService.getAllowUserRegister());
        List<SysDictDataItem> list = sysDictDataService.getDictDataByType(Constant.DictType.MOBILE_AREA.getValue());
        config.put("mobileAreaList", list);
        config.put("beianIcpNum", sysParamsService.getValue(Constant.SysBaseParam.BEIAN_ICP_NUM.getValue(), true));
        config.put("beianGaNum", sysParamsService.getValue(Constant.SysBaseParam.BEIAN_GA_NUM.getValue(), true));
        config.put("name", sysParamsService.getValue(Constant.SysBaseParam.SERVER_NAME.getValue(), true));
        return new Result<Map<String, Object>>().ok(config);
    }
 }
--- a/Show More
+++ b/Show More
`@@ -16,4 +16,4 @@ https://ccnphfhqs21z.feishu.cn/wiki/M0XiwldO9iJwHikpXD5cEx71nKh`

	`# manager-web 、manager-api接口协议`	`# manager-web 、manager-api接口协议`

	`https://2662r3426b.vicp.fun/xiaozhi/v1/doc.html`	`https://2662r3426b.vicp.fun/xiaozhi/doc.html`