Merge pull request #1421 from xinnan-tech/test-mcp

Test mcp

.gitignore

@@ -107,6 +107,7 @@ celerybeat.pid
 *.sage.py
 
 # Environments
+.env
 .venv
 env/
 venv/
@@ -145,24 +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

Dockerfile-web

@@ -7,20 +7,23 @@ 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/nginx.conf

README.md

@@ -141,11 +141,11 @@
 本项目提供两种部署方式，请根据您的具体需求选择：
 
 #### 🚀 部署方式选择
+| 部署方式 | 特点 | 适用场景 | 部署文档 | 配置要求 | 视频教程 | 
+|---------|------|---------|---------|---------|---------|
+| **最简化安装** | 智能对话、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个，每天会清空数据
 
@@ -157,9 +157,23 @@ OTA接口地址: https://2662r3426b.vicp.fun/xiaozhi/ota/
 Websocket接口地址: wss://2662r3426b.vicp.fun/xiaozhi/v1/
 ```
 
+#### 🚩 配置说明和推荐
+> [!Note]
+> 本项目默认的配置是`入门全免费`设置，如果想效果更优，推荐使用`全流式配置`。
+> 
+> 本项目自`0.5.2`版本，已支持整个生命周期全流式，相比`0.5`版本以前，响应速度提升约`2.5秒`
+
+
+| 模块名称 | 入门全免费设置 | 全流式配置 |
+|---------|---------|------|
+| 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（本地短期记忆） |
+
 ---
 ## 功能清单 ✨
-
 ### 已实现 ✅
 
 | 功能模块 | 描述 |

docs/FAQ.md

@@ -104,7 +104,11 @@ VAD:
 
 参考教程[ESP32设备与HomeAssistant集成指南](./homeassistant-integration.md)
 
-### 8、更多问题，可联系我们反馈 💬
+### 8、如何开启手机注册智控台 📱
+
+参考教程[阿里云短信集成指南](./ali-sms-integration.md)
+
+### 9、更多问题，可联系我们反馈 💬
 
 可以在[issues](https://github.com/xinnan-tech/xiaozhi-esp32-server/issues)提交您的问题。
 

docs/ali-sms-integration.md

@@ -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)

docs/firmware-setting.md

@@ -1,7 +1,7 @@
 # 基于虾哥编译好的固件配置自定义服务器
 
 ## 第1步 确认版本
-烧录虾哥已经编译好的1.6.1版本固件
+烧录虾哥已经编译好的[1.6.1版本以上固件](https://github.com/78/xiaozhi-esp32/releases)
 
 ## 第2步 准备你的ota地址
 如果你按照教程使用的是全模块部署，就应该会有ota地址。
@@ -29,6 +29,7 @@ wss://2662r3426b.vicp.fun/xiaozhi/v1/
 
 ## 第3步 进入配网模式
 进入机器的配网模式，在页面顶部，点击“高级选项”，在里面输入你服务器的`ota`地址，点击保存。重启设备
+![请参考-OTA地址设置](../docs/images/firmware-setting-ota.png)
 
 ## 第4步 唤醒小智，查看日志输出
 

docs/fish-speech-integration.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"
+```
+
+然后重启服务

docs/homeassistant-integration.md

@@ -1,4 +1,8 @@
-# ESP32设备与HomeAssistant集成指南
+# 小智ESP32-开源服务端与HomeAssistant集成指南
+
+[TOC]
+
+-----
 
 ## 简介
 
@@ -7,26 +11,58 @@
 ## 前提条件
 
 - 已安装并配置好`HomeAssistant`
-- 已经在HomeAssistant中集成`Xiaomi Home`，并将米家的设备导入进`HomeAssistant`
-- `xiaozhi-esp32-server智控台`能正常使用
 - 本次我选择的模型是：免费的ChatGLM，它支持functioncall函数调用
 
-## 网络环境
+## 开始前的操作（必要）
+
+### 1. 获取HA的网络网络地址信息
+
+请访问你Home Assistant的网络地址，例如，我的HA的地址是192.168.4.7，端口则是默认的8123，则在浏览器打开
 
-1、我的`HomeAssistant`部署在下面，版本是`2025.3.4`
 ```
 http://192.168.4.7:8123
 ```
 
-2、我的`xiaozhi-esp32-server智控台`和`HomeAssistant`部署在同一台机器的另一个端口，版本是`0.3.10`
+> 手动查询 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://192.168.4.7:8002
+http://homeassistant.local:8123
 ```
 
+### 2. 登录`Home Assistant`拿到开发密钥
 
-## 配置步骤
+登录`HomeAssistant`，点击`左下角头像 -> 个人`，切换`安全`导航栏，划到底部`长期访问令牌`生成api_key，并复制保存，后续的方法都需要使用这个api key且仅出现一次（小tips: 您可以保存生成的二维码图像，后续可以扫描二维码再此提取api key）。
 
-### 1. 登录`HomeAssistant`整理需要控制的设备清单
+## 方法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`，点击`左下角的设置`，然后进入`设备与服务`，再点击顶部的`实体`。
 
@@ -56,12 +92,7 @@ http://192.168.4.7:8002
 这段字符，我们成为“设备清单字符”需要保存好，等一下有用。
 
 
-### 2. 登录`HomeAssistant`拿到开发密钥
+#### 2. 登录`智控台`
-
-登录`HomeAssistant`，点击`左下角个人`，切换`安全`导航栏，划到底部`长期访问令牌`生成api_key。
-
-
-### 3. 登录`智控台`
 
 使用管理员账号，登录`智控台`。点击顶部菜单`参数管理`，搜索`plugins.home_assistant.`，会有三条结果出来
 
@@ -77,7 +108,7 @@ http://192.168.4.7:8123
 编辑`plugins.home_assistant.api_key`，把你从`HomeAssistant`复制过来的密钥，粘贴进去
 
 
-### 4. 设置`意图识别`函数
+#### 3. 设置`意图识别`函数
 
 在智控台，点击顶部菜单“模型配置”，在左侧栏，找到“意图识别”，找到id为`Intent_function_call`的意图，点击编辑
 
@@ -94,18 +125,124 @@ change_role;get_weather;get_news;play_music
 change_role;get_weather;get_news;play_music;hass_get_state;hass_set_state
 ```
 
-### 6. 手动重启xiaozhi-server
+#### 4. 手动重启xiaozhi-server
 
 重启xiaozhi-server程序
 
 
-### 5. 确认角色配置是否设置了函数意图识别
+#### 5. 确认角色配置是否设置了函数意图识别
 
 在智控台，点击顶部菜单“智能体管理”，找到设备所在的智能体，点击“配置角色”
 
 确认意图识别(Intent)，是否选择“函数调用意图识别”
 
 
-### 6. 唤醒设别进行控制
+#### 6. 唤醒设别进行控制
 
-尝试和esp32说，“打开XXX灯”
+尝试和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`即可正常使用。

main/manager-api/pom.xml

@@ -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>
@@ -201,6 +204,18 @@
             <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仓库 -->
@@ -243,4 +258,4 @@
             </plugin>
         </plugins>
     </build>
-</project>
+</project>

main/manager-api/src/main/java/xiaozhi/common/config/AsyncConfig.java

@@ -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;
+    }
+}

main/manager-api/src/main/java/xiaozhi/common/constant/Constant.java

@@ -1,5 +1,7 @@
 package xiaozhi.common.constant;
 
+import lombok.Getter;
+
 /**
  * 常量
  * Copyright (c) 人人开源 All rights reserved.
@@ -109,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;
 
@@ -146,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;
+        }
+    }
+
     /**
      * 数据状态
      */
@@ -174,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.4.2";
+    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;
+        }
+    }
 }

main/manager-api/src/main/java/xiaozhi/common/exception/ErrorCode.java

@@ -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;

main/manager-api/src/main/java/xiaozhi/common/exception/RenExceptionHandler.java

@@ -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);
+    }
+
 }

main/manager-api/src/main/java/xiaozhi/common/redis/RedisKeys.java

@@ -117,4 +117,26 @@ public class RedisKeys {
     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";
+    }
+
 }

main/manager-api/src/main/java/xiaozhi/common/redis/RedisUtils.java

@@ -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);
+    }
+
+
+
 }

main/manager-api/src/main/java/xiaozhi/common/service/impl/BaseServiceImpl.java

@@ -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;

main/manager-api/src/main/java/xiaozhi/common/utils/DateUtils.java

@@ -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

main/manager-api/src/main/java/xiaozhi/common/utils/ResourcesUtils.java

@@ -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();
+    }
+}

main/manager-api/src/main/java/xiaozhi/common/validator/ValidatorUtils.java

@@ -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();
+    }
 }

main/manager-api/src/main/java/xiaozhi/modules/agent/controller/AgentController.java

@@ -39,6 +39,7 @@ 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;
@@ -46,6 +47,7 @@ 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;
 
@@ -109,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());
         }
@@ -125,10 +129,26 @@ public class AgentController {
         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) {
@@ -166,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());
         }
@@ -181,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<>();
     }
 
@@ -193,7 +227,7 @@ public class AgentController {
         // 先删除关联的设备
         deviceService.deleteByAgentId(id);
         // 删除关联的聊天记录
-        agentChatHistoryService.deleteByAgentId(id);
+        agentChatHistoryService.deleteByAgentId(id, true, true);
         // 再删除智能体
         agentService.deleteById(id);
         return new Result<>();

main/manager-api/src/main/java/xiaozhi/modules/agent/dao/AiAgentChatHistoryDao.java

@@ -28,4 +28,11 @@ public interface AiAgentChatHistoryDao extends BaseMapper<AgentChatHistoryEntity
      * @param agentId 智能体ID
      */
     void deleteHistoryByAgentId(String agentId);
+
+    /**
+     * 根据智能体ID删除音频ID
+     *
+     * @param agentId 智能体ID
+     */
+    void deleteAudioIdByAgentId(String agentId);
 }

main/manager-api/src/main/java/xiaozhi/modules/agent/dto/AgentChatHistoryReportDTO.java

@@ -28,4 +28,6 @@ public class AgentChatHistoryReportDTO {
     private String content;
     @Schema(description = "base64编码的opus音频数据", example = "")
     private String audioBase64;
+    @Schema(description = "上报时间，十位时间戳，空时默认使用当前时间", example = "1745657732")
+    private Long reportTime;
 }

main/manager-api/src/main/java/xiaozhi/modules/agent/dto/AgentDTO.java

@@ -27,9 +27,16 @@ public class AgentDTO {
     @Schema(description = "大语言模型名称", example = "llm_model_01")
     private String llmModelName;
 
+    @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;
 

main/manager-api/src/main/java/xiaozhi/modules/agent/dto/AgentMemoryDTO.java

@@ -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;
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/dto/AgentUpdateDTO.java

@@ -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;
 

main/manager-api/src/main/java/xiaozhi/modules/agent/entity/AgentEntity.java

@@ -48,9 +48,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;
 

main/manager-api/src/main/java/xiaozhi/modules/agent/entity/AgentTemplateEntity.java

@@ -69,11 +69,20 @@ public class AgentTemplateEntity implements Serializable {
      */
     private String intentModelId;
 
+    /**
+     * 聊天记录配置（0不记录 1仅记录文本 2记录文本和语音）
+     */
+    private Integer chatHistoryConf;
+
     /**
      * 角色设定参数
      */
     private String systemPrompt;
 
+    /**
+     * 总结记忆
+     */
+    private String summaryMemory;
     /**
      * 语言编码
      */

main/manager-api/src/main/java/xiaozhi/modules/agent/service/AgentChatAudioService.java

@@ -27,4 +27,4 @@ public interface AgentChatAudioService extends IService<AgentChatAudioEntity> {
      * @return 音频数据
      */
     byte[] getAudio(String audioId);
-}
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/service/AgentChatHistoryService.java

@@ -39,7 +39,9 @@ public interface AgentChatHistoryService extends IService<AgentChatHistoryEntity
     /**
      * 根据智能体ID删除聊天记录
      *
-     * @param agentId 智能体ID
+     * @param agentId     智能体ID
+     * @param deleteAudio 是否删除音频
+     * @param deleteText  是否删除文本
      */
-    void deleteByAgentId(String agentId);
+    void deleteByAgentId(String agentId, Boolean deleteAudio, Boolean deleteText);
 }

main/manager-api/src/main/java/xiaozhi/modules/agent/service/biz/impl/AgentChatHistoryBizServiceImpl.java

@@ -2,12 +2,14 @@ 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;
@@ -45,10 +47,36 @@ public class AgentChatHistoryBizServiceImpl implements AgentChatHistoryBizServic
     public Boolean report(AgentChatHistoryReportDTO report) {
         String macAddress = report.getMacAddress();
         Byte chatType = report.getChatType();
-        log.info("小智设备聊天上报请求: macAddress={}, type={}", macAddress, chatType);
+        Long reportTimeMillis = null != report.getReportTime() ? report.getReportTime() * 1000 : System.currentTimeMillis();
+        log.info("小智设备聊天上报请求: macAddress={}, type={} reportTime={}", macAddress, chatType, reportTimeMillis);
 
-        // 1. base64解码report.getOpusDataBase64(),存入ai_agent_chat_audio表
+        // 根据设备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());
@@ -56,20 +84,17 @@ public class AgentChatHistoryBizServiceImpl implements AgentChatHistoryBizServic
                 log.info("音频数据保存成功，audioId={}", audioId);
             } catch (Exception e) {
                 log.error("音频数据保存失败", e);
-                return false;
+                return null;
             }
         }
+        return audioId;
+    }
 
-        // 2. 组装上报数据
+    /**
-        // 2.1 根据设备MAC地址查询对应的默认智能体，判断是否需要上报
+     * 组装上报数据
-        AgentEntity agentEntity = agentService.getDefaultAgentByMacAddress(macAddress);
+     */
-        if (agentEntity == null) {
+    private void saveChatText(AgentChatHistoryReportDTO report, String agentId, String macAddress, String audioId, Long reportTime) {
-            return false;
+        // 构建聊天记录实体
-        }
-        String agentId = agentEntity.getId();
-        log.info("设备 {} 对应智能体 {} 上报", macAddress, agentEntity.getId());
-
-        // 2.2 构建聊天记录实体
         AgentChatHistoryEntity entity = AgentChatHistoryEntity.builder()
                 .macAddress(macAddress)
                 .agentId(agentId)
@@ -77,12 +102,13 @@ public class AgentChatHistoryBizServiceImpl implements AgentChatHistoryBizServic
                 .chatType(report.getChatType())
                 .content(report.getContent())
                 .audioId(audioId)
+                .createdAt(new Date(reportTime))
+                // NOTE(haotian): 2025/5/26 updateAt可以不设置，重点是createAt，而且这样可以看到上报延迟
                 .build();
 
-        // 3. 保存数据
+        // 保存数据
         agentChatHistoryService.save(entity);
-        // 4. 更新设备最后对话时间
+
-        redisUtils.set(RedisKeys.getAgentDeviceLastConnectedAtById(agentId), new Date());
+        log.info("设备 {} 对应智能体 {} 上报成功", macAddress, agentId);
-        return Boolean.TRUE;
     }
 }

main/manager-api/src/main/java/xiaozhi/modules/agent/service/impl/AgentChatAudioServiceImpl.java

@@ -31,4 +31,4 @@ public class AgentChatAudioServiceImpl extends ServiceImpl<AiAgentChatAudioDao,
         AgentChatAudioEntity entity = getById(audioId);
         return entity != null ? entity.getAudio() : null;
     }
-}
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/service/impl/AgentChatHistoryServiceImpl.java

@@ -78,8 +78,16 @@ public class AgentChatHistoryServiceImpl extends ServiceImpl<AiAgentChatHistoryD
 
     @Override
     @Transactional(rollbackFor = Exception.class)
-    public void deleteByAgentId(String agentId) {
+    public void deleteByAgentId(String agentId, Boolean deleteAudio, Boolean deleteText) {
-        baseMapper.deleteAudioByAgentId(agentId);
+        if (deleteAudio) {
-        baseMapper.deleteHistoryByAgentId(agentId);
+            baseMapper.deleteAudioByAgentId(agentId);
+        }
+        if (deleteAudio && !deleteText) {
+            baseMapper.deleteAudioIdByAgentId(agentId);
+        }
+        if (deleteText) {
+            baseMapper.deleteHistoryByAgentId(agentId);
+        }
+
     }
 }

main/manager-api/src/main/java/xiaozhi/modules/agent/service/impl/AgentServiceImpl.java

@@ -13,6 +13,7 @@ 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;
@@ -46,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
@@ -93,6 +102,9 @@ public class AgentServiceImpl extends BaseServiceImpl<AgentDao, AgentEntity> imp
             // 获取 LLM 模型名称
             dto.setLlmModelName(modelConfigService.getModelNameById(agent.getLlmModelId()));
 
+            // 获取记忆模型名称
+            dto.setMemModelId(agent.getMemModelId());
+
             // 获取 TTS 音色名称
             dto.setTtsVoiceName(timbreModelService.getTimbreNameById(agent.getTtsVoiceId()));
 

main/manager-api/src/main/java/xiaozhi/modules/config/service/impl/ConfigServiceImpl.java

@@ -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;
@@ -64,6 +65,7 @@ public class ConfigServiceImpl implements ConfigService {
                 null,
                 null,
                 null,
+                null,
                 agent.getVadModelId(),
                 agent.getAsrModelId(),
                 null,
@@ -108,6 +110,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())) {
@@ -122,6 +135,7 @@ public class ConfigServiceImpl implements ConfigService {
         buildModuleConfig(
                 agent.getAgentName(),
                 agent.getSystemPrompt(),
+                agent.getSummaryMemory(),
                 voice,
                 agent.getVadModelId(),
                 agent.getAsrModelId(),
@@ -222,6 +236,7 @@ public class ConfigServiceImpl implements ConfigService {
     private void buildModuleConfig(
             String assistantName,
             String prompt,
+            String summaryMemory,
             String voice,
             String vadModelId,
             String asrModelId,
@@ -236,6 +251,7 @@ public class ConfigServiceImpl implements ConfigService {
         String[] modelTypes = { "VAD", "ASR", "TTS", "Memory", "Intent", "LLM" };
         String[] modelIds = { vadModelId, asrModelId, ttsModelId, memModelId, intentModelId, llmModelId };
         String intentLLMModelId = null;
+        String memLocalShortLLMModelId = null;
 
         for (int i = 0; i < modelIds.length; i++) {
             if (modelIds[i] == null) {
@@ -254,7 +270,7 @@ 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;
                         }
                     }
@@ -266,10 +282,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);
@@ -282,5 +319,6 @@ public class ConfigServiceImpl implements ConfigService {
             prompt = prompt.replace("{{assistant_name}}", StringUtils.isBlank(assistantName) ? "小智" : assistantName);
         }
         result.put("prompt", prompt);
+        result.put("summaryMemory", summaryMemory);
     }
 }

main/manager-api/src/main/java/xiaozhi/modules/device/service/impl/DeviceServiceImpl.java

@@ -9,6 +9,8 @@ import java.util.TimeZone;
 import java.util.UUID;
 
 import org.apache.commons.lang3.StringUtils;
+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;
@@ -54,6 +56,24 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
     private final RedisUtils redisUtils;
     private final OtaService otaService;
 
+    @Async
+    public void updateDeviceConnectionInfo(String agentId, String deviceId, String appVersion) {
+        try {
+            DeviceEntity device = new DeviceEntity();
+            device.setId(deviceId);
+            device.setLastConnectedAt(new Date());
+            if (StringUtils.isNotBlank(appVersion)) {
+                device.setAppVersion(appVersion);
+            }
+            deviceDao.updateById(device);
+            if (StringUtils.isNotBlank(agentId)) {
+                redisUtils.set(RedisKeys.getAgentDeviceLastConnectedAtById(agentId), new Date());
+            }
+        } catch (Exception e) {
+            log.error("异步更新设备连接信息失败", e);
+        }
+    }
+
     @Override
     public Boolean deviceActivation(String agentId, String activationCode) {
         if (StringUtils.isBlank(activationCode)) {
@@ -118,14 +138,20 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
 
         DeviceEntity deviceById = getDeviceByMacAddress(macAddress);
 
-        // 只有在设备已绑定且autoUpdate不为0的情况下才返回固件升级信息
+        // 设备未绑定，则返回当前上传的固件信息（不更新）以此兼容旧固件版本
-        if (deviceById != null && deviceById.getAutoUpdate() != 0) {
+        if (deviceById == null) {
-            String type = deviceReport.getBoard() == null ? null : deviceReport.getBoard().getType();
+            DeviceReportRespDTO.Firmware firmware = new DeviceReportRespDTO.Firmware();
-            DeviceReportRespDTO.Firmware firmware = buildFirmwareInfo(type,
+            firmware.setVersion(deviceReport.getApplication().getVersion());
-                    deviceReport.getApplication() == null ? null : deviceReport.getApplication().getVersion());
+            firmware.setUrl(Constant.INVALID_FIRMWARE_URL);
             response.setFirmware(firmware);
         } else {
-            response.setFirmware(null);
+            // 只有在设备已绑定且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配置
@@ -150,13 +176,12 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
         response.setWebsocket(websocket);
 
         if (deviceById != null) {
-            // 如果设备存在，则更新上次连接时间
+            // 如果设备存在，则异步更新上次连接时间和版本信息
-            deviceById.setLastConnectedAt(new Date());
+            String appVersion = deviceReport.getApplication() != null ? deviceReport.getApplication().getVersion()
-            if (deviceReport.getApplication() != null
+                    : null;
-                    && StringUtils.isNotBlank(deviceReport.getApplication().getVersion())) {
+            // 通过Spring代理调用异步方法
-                deviceById.setAppVersion(deviceReport.getApplication().getVersion());
+            ((DeviceServiceImpl) AopContext.currentProxy()).updateDeviceConnectionInfo(deviceById.getAgentId(),
-            }
+                    deviceById.getId(), appVersion);
-            deviceDao.updateById(deviceById);
         } else {
             // 如果设备不存在，则生成激活码
             DeviceReportRespDTO.Activation code = buildActivation(macAddress, deviceReport);
@@ -353,7 +378,7 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
         }
 
         firmware.setVersion(ota == null ? currentVersion : ota.getVersion());
-        firmware.setUrl(downloadUrl == null ? "" : downloadUrl);
+        firmware.setUrl(downloadUrl == null ? Constant.INVALID_FIRMWARE_URL : downloadUrl);
         return firmware;
     }
 
@@ -385,4 +410,4 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
         }
         return 0;
     }
-}
+}

main/manager-api/src/main/java/xiaozhi/modules/model/controller/ModelProviderController.java

@@ -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<>();
+    }
+
+}

main/manager-api/src/main/java/xiaozhi/modules/model/dto/ModelProviderDTO.java

@@ -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 = "更新者")

main/manager-api/src/main/java/xiaozhi/modules/model/entity/ModelProviderEntity.java

@@ -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 = "排序")

main/manager-api/src/main/java/xiaozhi/modules/model/service/ModelProviderService.java

@@ -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);
 }

main/manager-api/src/main/java/xiaozhi/modules/model/service/impl/ModelProviderServiceImpl.java

@@ -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

main/manager-api/src/main/java/xiaozhi/modules/security/config/ShiroConfig.java

@@ -80,12 +80,15 @@ public class ShiroConfig {
         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("/user/retrieve-password", "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);

main/manager-api/src/main/java/xiaozhi/modules/security/controller/LoginController.java

@@ -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);
     }
 }

main/manager-api/src/main/java/xiaozhi/modules/security/dto/LoginDTO.java

@@ -25,6 +25,9 @@ public class LoginDTO implements Serializable {
     @NotBlank(message = "{sysuser.captcha.require}")
     private String captcha;
 
+    @Schema(description = "手机验证码")
+    private String mobileCaptcha;
+
     @Schema(description = "唯一标识")
     @NotBlank(message = "{sysuser.uuid.require}")
     private String captchaId;

main/manager-api/src/main/java/xiaozhi/modules/security/dto/SmsVerificationDTO.java

@@ -0,0 +1,28 @@
+package xiaozhi.modules.security.dto;
+
+import java.io.Serializable;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+/**
+ * 短信验证码请求DTO
+ */
+@Data
+@Schema(description = "短信验证码请求")
+public class SmsVerificationDTO implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "手机号码")
+    @NotBlank(message = "{sysuser.username.require}")
+    private String phone;
+
+    @Schema(description = "验证码")
+    @NotBlank(message = "{sysuser.captcha.require}")
+    private String captcha;
+
+    @Schema(description = "唯一标识")
+    @NotBlank(message = "{sysuser.uuid.require}")
+    private String captchaId;
+}

main/manager-api/src/main/java/xiaozhi/modules/security/service/CaptchaService.java

@@ -18,10 +18,28 @@ public interface CaptchaService {
 
     /**
      * 验证码效验
-     *
+     * 
-     * @param uuid uuid
+     * @param uuid   uuid
-     * @param code 验证码
+     * @param code   验证码
+     * @param delete 是否删除验证码
      * @return true：成功 false：失败
      */
-    boolean validate(String uuid, String code);
+    boolean validate(String uuid, String code, Boolean delete);
+
+    /**
+     * 发送短信验证码
+     * 
+     * @param phone 手机
+     */
+    void sendSMSValidateCode(String phone);
+
+    /**
+     * 验证短信验证码
+     * 
+     * @param phone  手机
+     * @param code   验证码
+     * @param delete 是否删除验证码
+     * @return true：成功 false：失败
+     */
+    boolean validateSMSValidateCode(String phone, String code, Boolean delete);
 }

main/manager-api/src/main/java/xiaozhi/modules/security/service/impl/CaptchaServiceImpl.java

@@ -1,6 +1,7 @@
 package xiaozhi.modules.security.service.impl;
 
 import java.io.IOException;
+import java.util.Random;
 import java.util.concurrent.TimeUnit;
 
 import org.apache.commons.lang3.StringUtils;
@@ -14,9 +15,13 @@ import com.wf.captcha.base.Captcha;
 
 import jakarta.annotation.Resource;
 import jakarta.servlet.http.HttpServletResponse;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.exception.RenException;
 import xiaozhi.common.redis.RedisKeys;
 import xiaozhi.common.redis.RedisUtils;
 import xiaozhi.modules.security.service.CaptchaService;
+import xiaozhi.modules.sms.service.SmsService;
+import xiaozhi.modules.sys.service.SysParamsService;
 
 /**
  * 验证码
@@ -25,6 +30,10 @@ import xiaozhi.modules.security.service.CaptchaService;
 public class CaptchaServiceImpl implements CaptchaService {
     @Resource
     private RedisUtils redisUtils;
+    @Resource
+    private SmsService smsService;
+    @Resource
+    private SysParamsService sysParamsService;
     @Value("${renren.redis.open}")
     private boolean open;
     /**
@@ -51,12 +60,12 @@ public class CaptchaServiceImpl implements CaptchaService {
     }
 
     @Override
-    public boolean validate(String uuid, String code) {
+    public boolean validate(String uuid, String code, Boolean delete) {
         if (StringUtils.isBlank(code)) {
             return false;
         }
         // 获取验证码
-        String captcha = getCache(uuid);
+        String captcha = getCache(uuid, delete);
 
         // 效验成功
         if (code.equalsIgnoreCase(captcha)) {
@@ -66,21 +75,97 @@ public class CaptchaServiceImpl implements CaptchaService {
         return false;
     }
 
+    @Override
+    public void sendSMSValidateCode(String phone) {
+        // 检查发送间隔
+        String lastSendTimeKey = RedisKeys.getSMSLastSendTimeKey(phone);
+        // 获取是否发送过，如果没有设置最后发送时间（60秒）
+        String lastSendTime = redisUtils
+                .getKeyOrCreate(lastSendTimeKey,
+                        String.valueOf(System.currentTimeMillis()), 60L);
+        if (lastSendTime != null) {
+            long lastSendTimeLong = Long.parseLong(lastSendTime);
+            long currentTime = System.currentTimeMillis();
+            long timeDiff = currentTime - lastSendTimeLong;
+            if (timeDiff < 60000) {
+                throw new RenException("发送太频繁,请" + (60000 - timeDiff) / 1000 + "秒后再试");
+            }
+        }
+
+        // 检查今日发送次数
+        String todayCountKey = RedisKeys.getSMSTodayCountKey(phone);
+        Integer todayCount = (Integer) redisUtils.get(todayCountKey);
+        if (todayCount == null) {
+            todayCount = 0;
+        }
+
+        // 获取最大发送次数限制
+        Integer maxSendCount = sysParamsService.getValueObject(
+                Constant.SysMSMParam.SERVER_SMS_MAX_SEND_COUNT.getValue(),
+                Integer.class);
+        if (maxSendCount == null) {
+            maxSendCount = 5; // 默认值
+        }
+
+        if (todayCount >= maxSendCount) {
+            throw new RenException("今日发送次数已达上限");
+        }
+
+        String key = RedisKeys.getSMSValidateCodeKey(phone);
+        String validateCodes = generateValidateCode(6);
+
+        // 设置验证码
+        setCache(key, validateCodes);
+
+        // 更新今日发送次数
+        if (todayCount == 0) {
+            redisUtils.increment(todayCountKey, RedisUtils.DEFAULT_EXPIRE);
+        } else {
+            redisUtils.increment(todayCountKey);
+        }
+
+        // 发送验证码短信
+        smsService.sendVerificationCodeSms(phone, validateCodes);
+    }
+
+    @Override
+    public boolean validateSMSValidateCode(String phone, String code, Boolean delete) {
+        String key = RedisKeys.getSMSValidateCodeKey(phone);
+        return validate(key, code, delete);
+    }
+
+    /**
+     * 生成指定数量的随机数验证码
+     * 
+     * @param length 数量
+     * @return 随机码
+     */
+    private String generateValidateCode(Integer length) {
+        String chars = "0123456789"; // 字符范围可以自定义：数字
+        Random random = new Random();
+        StringBuilder code = new StringBuilder();
+        for (int i = 0; i < length; i++) {
+            code.append(chars.charAt(random.nextInt(chars.length())));
+        }
+        return code.toString();
+    }
+
     private void setCache(String key, String value) {
         if (open) {
             key = RedisKeys.getCaptchaKey(key);
+            // 设置5分钟过期
             redisUtils.set(key, value, 300);
         } else {
             localCache.put(key, value);
         }
     }
 
-    private String getCache(String key) {
+    private String getCache(String key, Boolean delete) {
         if (open) {
             key = RedisKeys.getCaptchaKey(key);
             String captcha = (String) redisUtils.get(key);
             // 删除验证码
-            if (captcha != null) {
+            if (captcha != null && delete) {
                 redisUtils.delete(key);
             }
 

main/manager-api/src/main/java/xiaozhi/modules/sms/service/SmsService.java

@@ -0,0 +1,17 @@
+package xiaozhi.modules.sms.service;
+
+/**
+ * 短信服务的方法定义接口
+ *
+ * @author zjy
+ * @since 2025-05-12
+ */
+public interface SmsService {
+
+    /**
+     * 发送验证码短信
+     * @param phone 手机号码
+     * @param VerificationCode 验证码
+     */
+    void sendVerificationCodeSms(String phone, String VerificationCode) ;
+}

main/manager-api/src/main/java/xiaozhi/modules/sms/service/imp/ALiYunSmsService.java

@@ -0,0 +1,76 @@
+package xiaozhi.modules.sms.service.imp;
+
+import com.aliyun.dysmsapi20170525.Client;
+import com.aliyun.dysmsapi20170525.models.SendSmsRequest;
+import com.aliyun.dysmsapi20170525.models.SendSmsResponse;
+import com.aliyun.teaopenapi.models.Config;
+import com.aliyun.teautil.models.RuntimeOptions;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.exception.RenException;
+import xiaozhi.common.redis.RedisKeys;
+import xiaozhi.common.redis.RedisUtils;
+import xiaozhi.modules.sms.service.SmsService;
+import xiaozhi.modules.sys.service.SysParamsService;
+
+@Service
+@AllArgsConstructor
+@Slf4j
+public class ALiYunSmsService implements SmsService {
+    private final SysParamsService  sysParamsService;
+    private final RedisUtils redisUtils;
+
+    @Override
+    public void sendVerificationCodeSms(String phone, String VerificationCode) {
+        Client client = createClient();
+        String SignName = sysParamsService.getValue(Constant.SysMSMParam
+                .ALIYUN_SMS_SIGN_NAME.getValue(),true);
+        String TemplateCode = sysParamsService.getValue(Constant.SysMSMParam
+                .ALIYUN_SMS_SMS_CODE_TEMPLATE_CODE.getValue(),true);
+        try {
+            SendSmsRequest sendSmsRequest = new SendSmsRequest()
+                    .setSignName(SignName)
+                    .setTemplateCode(TemplateCode)
+                    .setPhoneNumbers(phone)
+                    .setTemplateParam(String.format("{\"code\":\"%s\"}", VerificationCode));
+            RuntimeOptions runtime = new RuntimeOptions();
+            // 复制代码运行请自行打印 API 的返回值
+            SendSmsResponse sendSmsResponse = client.sendSmsWithOptions(sendSmsRequest, runtime);
+            log.info("发送短信响应的requestID: {}", sendSmsResponse.getBody().getRequestId());
+        } catch (Exception e) {
+            // 如果发送失败了退还这次发送数
+            String todayCountKey = RedisKeys.getSMSTodayCountKey(phone);
+            redisUtils.delete(todayCountKey);
+            // 错误 message
+            log.error(e.getMessage());
+            throw new RenException("短信发送失败");
+        }
+
+    }
+
+
+    /**
+     * 创建阿里云连接
+     * @return 返回连接对象
+     */
+    private Client createClient(){
+        String ACCESS_KEY_ID = sysParamsService.getValue(Constant.SysMSMParam
+                .ALIYUN_SMS_ACCESS_KEY_ID.getValue(),true);
+        String ACCESS_KEY_SECRET = sysParamsService.getValue(Constant.SysMSMParam
+                .ALIYUN_SMS_ACCESS_KEY_SECRET.getValue(),true);
+        try {
+            Config config = new Config()
+                    .setAccessKeyId(ACCESS_KEY_ID)
+                    .setAccessKeySecret(ACCESS_KEY_SECRET);
+            // 配置 Endpoint。中国站请使用dysmsapi.aliyuncs.com
+            config.endpoint = "dysmsapi.aliyuncs.com";
+            return new Client(config);
+        }catch (Exception e){
+            // 错误 message
+            log.error(e.getMessage());
+            throw new RenException("短信连接建立失败");
+        }
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/controller/ServerSideManageController.java

@@ -0,0 +1,121 @@
+package xiaozhi.modules.sys.controller;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.springframework.web.bind.annotation.GetMapping;
+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 org.springframework.web.socket.WebSocketHttpHeaders;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+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.annotation.LogOperation;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.exception.RenException;
+import xiaozhi.common.utils.Result;
+import xiaozhi.modules.sys.dto.EmitSeverActionDTO;
+import xiaozhi.modules.sys.dto.ServerActionPayloadDTO;
+import xiaozhi.modules.sys.dto.ServerActionResponseDTO;
+import xiaozhi.modules.sys.enums.ServerActionEnum;
+import xiaozhi.modules.sys.service.SysParamsService;
+import xiaozhi.modules.sys.utils.WebSocketClientManager;
+
+/**
+ * 服务端管理控制器
+ */
+@RestController
+@RequestMapping("/admin/server")
+@Tag(name = "服务端管理")
+@AllArgsConstructor
+public class ServerSideManageController {
+    private final SysParamsService sysParamsService;
+    private static final ObjectMapper objectMapper;
+    static {
+        objectMapper = new ObjectMapper();
+        // 忽略json字符串中存在，但pojo中不存在对应字段的情况
+        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+    }
+
+    @Operation(summary = "获取Ws服务端列表")
+    @GetMapping("/server-list")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<List<String>> getWsServerList() {
+        String wsText = sysParamsService.getValue(Constant.SERVER_WEBSOCKET, true);
+        if (StringUtils.isBlank(wsText)) {
+            return new Result<List<String>>().ok(Collections.emptyList());
+        }
+        return new Result<List<String>>().ok(Arrays.asList(wsText.split(";")));
+    }
+
+    @Operation(summary = "通知python服务端更新配置")
+    @PostMapping("/emit-action")
+    @LogOperation("通知python服务端更新配置")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Boolean> emitServerAction(@RequestBody @Valid EmitSeverActionDTO emitSeverActionDTO) {
+        if (emitSeverActionDTO.getAction() == null) {
+            throw new RenException("无效服务端操作");
+        }
+        String wsText = sysParamsService.getValue(Constant.SERVER_WEBSOCKET, true);
+        if (StringUtils.isBlank(wsText)) {
+            throw new RenException("未配置服务端WebSocket地址");
+        }
+        String targetWs = emitSeverActionDTO.getTargetWs();
+        String[] wsList = wsText.split(";");
+        // 找到需要发起的
+        if (StringUtils.isBlank(targetWs) || !Arrays.asList(wsList).contains(targetWs)) {
+            throw new RenException("目标WebSocket地址不存在");
+        }
+        return new Result<Boolean>().ok(emitServerActionByWs(targetWs, emitSeverActionDTO.getAction()));
+    }
+
+    private Boolean emitServerActionByWs(String targetWsUri, ServerActionEnum actionEnum) {
+        if (StringUtils.isBlank(targetWsUri) || actionEnum == null) {
+            return false;
+        }
+        String serverSK = sysParamsService.getValue(Constant.SERVER_SECRET, true);
+        WebSocketHttpHeaders headers = new WebSocketHttpHeaders();
+        headers.add("device-id", UUID.randomUUID().toString());
+        headers.add("client-id", UUID.randomUUID().toString());
+
+        try (WebSocketClientManager client = new WebSocketClientManager.Builder()
+                .connectTimeout(3, TimeUnit.SECONDS)
+                .maxSessionDuration(120, TimeUnit.SECONDS)
+                .uri(targetWsUri)
+                .headers(headers)
+                .build()) {
+            // 如果连接成功则发送一个json数据包并等待服务端响应
+            client.sendJson(
+                    ServerActionPayloadDTO.build(
+                            actionEnum,
+                            Map.of("secret", serverSK)));
+            // 等待服务端响应并持续监听信息
+            client.listener((jsonText) -> {
+                if (StringUtils.isBlank(jsonText)) {
+                    return false;
+                }
+                try {
+                    ServerActionResponseDTO response = objectMapper.readValue(jsonText, ServerActionResponseDTO.class);
+                    Boolean isSuccess = ServerActionResponseDTO.isSuccess(response);
+                    return isSuccess;
+                } catch (JsonProcessingException e) {
+                    return false;
+                }
+            });
+        } catch (Exception e) {
+            // 捕获全部错误，由全局异常处理器返回
+            throw new RenException("WebSocket连接失败或连接超时");
+        }
+        return true;
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/controller/SysParamsController.java

@@ -59,7 +59,7 @@ public class SysParamsController {
             @Parameter(name = Constant.LIMIT, description = "每页显示记录数", in = ParameterIn.QUERY, required = true, ref = "int"),
             @Parameter(name = Constant.ORDER_FIELD, description = "排序字段", in = ParameterIn.QUERY, ref = "String"),
             @Parameter(name = Constant.ORDER, description = "排序方式，可选值(asc、desc)", in = ParameterIn.QUERY, ref = "String"),
-            @Parameter(name = "paramCode", description = "参数编码", in = ParameterIn.QUERY, ref = "String")
+            @Parameter(name = "paramCode", description = "参数编码或参数备注", in = ParameterIn.QUERY, ref = "String")
     })
     @RequiresPermissions("sys:role:superAdmin")
     public Result<PageData<SysParamsDTO>> page(@Parameter(hidden = true) @RequestParam Map<String, Object> params) {
@@ -111,7 +111,7 @@ public class SysParamsController {
 
     /**
      * 验证WebSocket地址列表
-     * 
+     *
      * @param urls WebSocket地址列表，以分号分隔
      * @return 验证结果
      */
@@ -143,6 +143,19 @@ public class SysParamsController {
         }
     }
 
+    @PostMapping("/delete")
+    @Operation(summary = "删除")
+    @LogOperation("删除")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> delete(@RequestBody String[] ids) {
+        // 效验数据
+        AssertUtils.isArrayEmpty(ids, "id");
+
+        sysParamsService.delete(ids);
+        configService.getConfig(false);
+        return new Result<Void>();
+    }
+
     /**
      * 验证OTA地址
      */
@@ -182,17 +195,4 @@ public class SysParamsController {
             throw new RenException("OTA接口验证失败：" + e.getMessage());
         }
     }
-
-    @PostMapping("/delete")
-    @Operation(summary = "删除")
-    @LogOperation("删除")
-    @RequiresPermissions("sys:role:superAdmin")
-    public Result<Void> delete(@RequestBody String[] ids) {
-        // 效验数据
-        AssertUtils.isArrayEmpty(ids, "id");
-
-        sysParamsService.delete(ids);
-        configService.getConfig(false);
-        return new Result<Void>();
-    }
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/dto/EmitSeverActionDTO.java

@@ -0,0 +1,26 @@
+package xiaozhi.modules.sys.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import xiaozhi.modules.sys.enums.ServerActionEnum;
+
+/**
+ * 发送python服务端操作DTO
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class EmitSeverActionDTO
+{
+    @Schema(description = "目标ws地址")
+    @NotEmpty(message = "目标ws地址不能为空")
+    private String targetWs;
+
+    @Schema(description = "指定操作")
+    @NotNull(message = "操作不能为空")
+    private ServerActionEnum action;
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/dto/RetrievePasswordDTO.java

@@ -0,0 +1,30 @@
+package xiaozhi.modules.sys.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * 找回密码DTO
+ */
+@Data
+@Schema(description = "找回密码")
+public class RetrievePasswordDTO implements Serializable {
+
+    @Schema(description = "手机号码")
+    @NotBlank(message = "{sysuser.password.require}")
+    private String phone;
+
+    @Schema(description = "验证码")
+    @NotBlank(message = "{sysuser.password.require}")
+    private String code;
+
+    @Schema(description = "新密码")
+    @NotBlank(message = "{sysuser.password.require}")
+    private String password;
+
+
+
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/dto/ServerActionPayloadDTO.java

@@ -0,0 +1,36 @@
+package xiaozhi.modules.sys.dto;
+
+import lombok.Data;
+import xiaozhi.modules.sys.enums.ServerActionEnum;
+
+import java.util.Map;
+
+/**
+ * 服务端动作DTO
+ */
+@Data
+public class ServerActionPayloadDTO
+{
+    /**
+    * 类型（智控台发往服务端的都是server）
+    */
+    private String type;
+    /**
+    * 动作
+    */
+    private ServerActionEnum action;
+    /**
+    * 内容
+    */
+    private Map<String, Object> content;
+
+    public static ServerActionPayloadDTO build(ServerActionEnum action, Map<String, Object> content) {
+        ServerActionPayloadDTO serverActionPayloadDTO = new ServerActionPayloadDTO();
+        serverActionPayloadDTO.setAction(action);
+        serverActionPayloadDTO.setContent(content);
+        serverActionPayloadDTO.setType("server");
+        return serverActionPayloadDTO;
+    }
+    // 私有化
+    private ServerActionPayloadDTO() {}
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/dto/ServerActionResponseDTO.java

@@ -0,0 +1,34 @@
+package xiaozhi.modules.sys.dto;
+
+import lombok.Data;
+import xiaozhi.modules.sys.enums.ServerActionResponseEnum;
+
+import java.util.Map;
+
+/**
+ * 服务端动作响应体
+ */
+@Data
+public class ServerActionResponseDTO
+{
+    private ServerActionResponseEnum status;
+    private String message;
+    private String type;
+    private Map<String, Object> content; // 后续这个字段可以移除，并把这个类作为基类，针对业务写自己的content类型
+    public static final String DEFAULT_TYPE_FORM_SERVER = "server";
+
+    public static Boolean isSuccess(ServerActionResponseDTO actionResponseDTO) {
+        System.out.println(actionResponseDTO);
+        if (actionResponseDTO == null) {
+            return false;
+        }
+        if (actionResponseDTO.getStatus() == null || !actionResponseDTO.getStatus().equals(ServerActionResponseEnum.SUCCESS)) {
+            return false;
+        }
+        Object actionType = actionResponseDTO.getContent().get("action");
+        if (actionType == null) {
+            return false;
+        }
+        return actionResponseDTO.getType() != null && actionResponseDTO.getType().equals(DEFAULT_TYPE_FORM_SERVER);
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/enums/ServerActionEnum.java

@@ -0,0 +1,40 @@
+package xiaozhi.modules.sys.enums;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+import xiaozhi.common.exception.RenException;
+
+/**
+ * 服务端动作枚举
+ */
+public enum ServerActionEnum
+{
+    RESTART("restart"),
+    UPDATE_CONFIG("update_config");
+
+    private final String value;
+
+    ServerActionEnum(String value)
+    {
+        this.value = value;
+    }
+
+    @JsonValue
+    public String getValue()
+    {
+        return value;
+    }
+
+    @JsonCreator
+    public static ServerActionEnum fromValue(String value)
+    {
+        for (ServerActionEnum action : ServerActionEnum.values())
+        {
+            if (action.value.equalsIgnoreCase(value))
+            {
+                return action;
+            }
+        }
+        return null;
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/enums/ServerActionResponseEnum.java

@@ -0,0 +1,46 @@
+package xiaozhi.modules.sys.enums;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+import lombok.Getter;
+import org.apache.commons.lang3.StringUtils;
+
+/**
+ * 服务端调用响应枚举
+ */
+public enum ServerActionResponseEnum
+{
+    SUCCESS("success"), FAIL("fail");
+    private final String value;
+
+    ServerActionResponseEnum(String value) {
+        this.value = value;
+    }
+
+    @JsonValue
+    public String getValue()
+    {
+        return value;
+    }
+
+    @JsonCreator
+    public static ServerActionResponseEnum fromValue(String value) {
+        ServerActionResponseEnum byValue = getByValue(value);
+        if (byValue == null) {
+            throw new IllegalArgumentException("Unknown enum value: " + value);
+        }
+        return byValue;
+    }
+
+    public static ServerActionResponseEnum getByValue(String value) {
+        if (StringUtils.isBlank(value)) {
+            return null;
+        }
+        for (ServerActionResponseEnum action : ServerActionResponseEnum.values()) {
+            if (action.value.equals(value)) {
+                return action;
+            }
+        }
+        return null;
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/service/impl/SysParamsServiceImpl.java

@@ -1,5 +1,6 @@
 package xiaozhi.modules.sys.service.impl;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
@@ -55,7 +56,9 @@ public class SysParamsServiceImpl extends BaseServiceImpl<SysParamsDao, SysParam
 
         QueryWrapper<SysParamsEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("param_type", 1);
-        wrapper.like(StringUtils.isNotBlank(paramCode), "param_code", paramCode);
+        wrapper.nested(StringUtils.isNotBlank(paramCode), i -> i.like("param_code", paramCode)
+                .or()
+                .like("remark", paramCode));
 
         return wrapper;
     }
@@ -82,7 +85,7 @@ public class SysParamsServiceImpl extends BaseServiceImpl<SysParamsDao, SysParam
     @Transactional(rollbackFor = Exception.class)
     public void update(SysParamsDTO dto) {
         validateParamValue(dto);
-
+        detectingSMSParameters(dto.getParamCode(), dto.getParamValue());
         SysParamsEntity entity = ConvertUtils.sourceToTarget(dto, SysParamsEntity.class);
         updateById(entity);
 
@@ -204,4 +207,41 @@ public class SysParamsServiceImpl extends BaseServiceImpl<SysParamsDao, SysParam
             updateValueByCode(Constant.SERVER_SECRET, newSecret);
         }
     }
+
+    /**
+     * 检测短信参数是否符合要求
+     * 
+     * @param paramCode  参数编码
+     * @param paramValue 参数值
+     * @return 是否通过
+     */
+    private boolean detectingSMSParameters(String paramCode, String paramValue) {
+        // 判断是否是开启手机注册的参数编码，如果不是参数编码，着不需要检测其他短信参数，直接返回true
+        if (!Constant.SysMSMParam.SERVER_ENABLE_MOBILE_REGISTER.getValue().equals(paramCode)) {
+            return true;
+        }
+        // 判断是否为关闭，如果是关闭短信注册，着不需要检测其他短信参数，直接返回true
+        if ("false".equalsIgnoreCase(paramValue)) {
+            return true;
+        }
+        // 检测短信关联参数是否为空
+        ArrayList<String> list = new ArrayList<String>();
+        list.add(Constant.SysMSMParam.SERVER_SMS_MAX_SEND_COUNT.getValue());
+        list.add(Constant.SysMSMParam.ALIYUN_SMS_ACCESS_KEY_ID.getValue());
+        list.add(Constant.SysMSMParam.ALIYUN_SMS_ACCESS_KEY_SECRET.getValue());
+        list.add(Constant.SysMSMParam.ALIYUN_SMS_SIGN_NAME.getValue());
+        list.add(Constant.SysMSMParam.ALIYUN_SMS_SMS_CODE_TEMPLATE_CODE.getValue());
+        StringBuilder str = new StringBuilder();
+        list.forEach(item -> {
+            if (!StringUtils.isNoneBlank(item)) {
+                str.append(",").append(item);
+            }
+        });
+        if (!str.isEmpty()) {
+            String promptStr = "%s这些参数不可以为空";
+            String substring = str.substring(1, str.length());
+            throw new RenException(promptStr.formatted(substring));
+        }
+        return true;
+    }
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/service/impl/SysUserServiceImpl.java

@@ -133,6 +133,10 @@ public class SysUserServiceImpl extends BaseServiceImpl<SysUserDao, SysUserEntit
     @Override
     @Transactional(rollbackFor = Exception.class)
     public void changePasswordDirectly(Long userId, String password) {
+        // 新密码强度
+        if (!isStrongPassword(password)) {
+            throw new RenException(ErrorCode.PASSWORD_WEAK_ERROR);
+        }
         SysUserEntity sysUserEntity = new SysUserEntity();
         sysUserEntity.setId(userId);
         sysUserEntity.setPassword(PasswordUtils.encode(password));
@@ -159,7 +163,7 @@ public class SysUserServiceImpl extends BaseServiceImpl<SysUserDao, SysUserEntit
         params.put(Constant.LIMIT, dto.getLimit());
         IPage<SysUserEntity> page = baseDao.selectPage(
                 getPage(params, "id", true),
-                new QueryWrapper<SysUserEntity>().eq(StringUtils.isNotBlank(dto.getMobile()), "username",
+                new QueryWrapper<SysUserEntity>().like(StringUtils.isNotBlank(dto.getMobile()), "username",
                         dto.getMobile()));
         // 循环处理page获取回来的数据，返回需要的字段
         List<AdminPageUserVO> list = page.getRecords().stream().map(user -> {

main/manager-api/src/main/java/xiaozhi/modules/sys/utils/WebSocketClientManager.java

@@ -0,0 +1,315 @@
+package xiaozhi.modules.sys.utils;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.util.StopWatch;
+import org.springframework.web.socket.*;
+import org.springframework.web.socket.client.standard.StandardWebSocketClient;
+import org.springframework.web.socket.handler.AbstractWebSocketHandler;
+import xiaozhi.common.utils.DateUtils;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.net.URI;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+/**
+ * WebSocketClientResource：支持 try-with-resources 模式
+ */
+@Slf4j
+public class WebSocketClientManager implements Closeable
+{
+    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+
+    // 全局回调线程池
+    private static final ExecutorService CALLBACK_EXECUTOR = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors(), new ThreadFactory() {
+        private final AtomicInteger cnt = new AtomicInteger();
+
+        public Thread newThread(Runnable r)
+        {
+            Thread t = new Thread(r, "ws-callback-" + cnt.getAndIncrement());
+            t.setDaemon(true);
+            return t;
+        }
+    });
+
+    private volatile WebSocketSession session;
+    private final BlockingQueue<String> textMessageQueue;
+    private final BlockingQueue<byte[]> binaryMessageQueue;
+    private final CompletableFuture<Void> errorFuture;
+    private final long maxSessionDuration;
+    private final TimeUnit maxSessionDurationUnit;
+
+    private volatile Consumer<String> onText;
+    private volatile Consumer<byte[]> onBinary;
+    private volatile Consumer<Throwable> onError;
+
+    private final String uri;
+    private final WebSocketHttpHeaders headers;
+    private final long connectTimeout;
+    private final TimeUnit connectUnit;
+    private final int queueCapacity;
+
+    // 私有构造，仅由 Builder 调用
+    private WebSocketClientManager(Builder b) {
+        this.uri = b.uri;
+        this.headers = b.headers != null ? b.headers : new WebSocketHttpHeaders();
+        this.connectTimeout = b.connectTimeout;
+        this.connectUnit = b.connectUnit;
+        this.maxSessionDuration = b.maxSessionDuration;
+        this.maxSessionDurationUnit = b.maxSessionDurationUnit;
+        this.queueCapacity = b.queueCapacity;
+        this.textMessageQueue = new LinkedBlockingQueue<>(queueCapacity);
+        this.binaryMessageQueue = new LinkedBlockingQueue<>(queueCapacity);
+        this.errorFuture = new CompletableFuture<>();
+    }
+
+    public static WebSocketClientManager build(Builder b) throws InterruptedException, ExecutionException, TimeoutException, IOException {
+        WebSocketClientManager ws = new WebSocketClientManager(b);
+        StandardWebSocketClient client = new StandardWebSocketClient();
+        CompletableFuture<WebSocketSession> future = client.execute(ws.new InternalHandler(b.uri), b.headers, URI.create(b.uri));
+        WebSocketSession sess = future.get(b.connectTimeout, b.connectUnit);
+        if (sess == null || !sess.isOpen())
+        {
+            throw new IOException("握手失败或会话未打开");
+        }
+        ws.session = sess;
+        return ws;
+    }
+
+    /**
+     * 发送 Text
+     */
+    public void sendText(String text) throws IOException {
+        session.sendMessage(new TextMessage(text));
+    }
+
+    public void sendBinary(byte[] data) throws IOException {
+        session.sendMessage(new BinaryMessage(data));
+    }
+
+    public void sendJson(Object payload) throws IOException {
+        String json = OBJECT_MAPPER.writeValueAsString(payload);
+        session.sendMessage(new TextMessage(json));
+    }
+
+
+
+    private <T> List<T> listenerCustom(
+            BlockingQueue<T> queue,
+            Predicate<T> predicate)
+            throws InterruptedException, TimeoutException, ExecutionException
+    {
+        List<T> collected = new ArrayList<>();
+        long deadline = System.currentTimeMillis() + maxSessionDurationUnit.toMillis(maxSessionDuration);
+
+        while (true) {
+            if (errorFuture.isDone()) {
+                errorFuture.get();
+            }
+
+            long remaining = deadline - System.currentTimeMillis();
+            if (remaining <= 0) {
+                throw new TimeoutException("等待批量消息超时");
+            }
+
+            T msg = queue.poll(remaining, TimeUnit.MILLISECONDS);
+            if (msg == null) {
+                throw new TimeoutException("等待批量消息超时");
+            }
+
+            collected.add(msg);
+            if (predicate.test(msg)) {
+                break;
+            }
+        }
+        close();
+        return collected;
+    }
+
+    /**
+     * 同步接收多条消息，直到 predicate 为 true 或超时抛异常；
+     * @return 返回监听期间的所有消息列表
+     */
+    public List<String> listener(Predicate<String> predicate)
+            throws InterruptedException, TimeoutException, ExecutionException
+    {
+        return listenerCustom(textMessageQueue, predicate);
+    }
+
+    public List<byte[]> listenerBinary(Predicate<byte[]> predicate)
+            throws InterruptedException, TimeoutException, ExecutionException
+    {
+        return listenerCustom(binaryMessageQueue, predicate);
+    }
+
+    /**
+     * 注册文本回调
+     */
+    public WebSocketClientManager onText(Consumer<String> c) {
+        this.onText = c;
+        return this;
+    }
+
+    /**
+     * 注册二进制回调
+     */
+    public WebSocketClientManager onBinary(Consumer<byte[]> c) {
+        this.onBinary = c;
+        return this;
+    }
+
+    /**
+     * 注册错误回调
+     */
+    public WebSocketClientManager onError(Consumer<Throwable> c) {
+        this.onError = c;
+        return this;
+    }
+
+    /**
+     * 关闭会话，try-with-resources / finally 自动调用
+     */
+    @Override
+    public void close() {
+        try {
+            if (session != null && session.isOpen()) {
+                session.close(CloseStatus.NORMAL);
+            }
+        }
+        catch (IOException ignored) {}
+        textMessageQueue.clear();
+        binaryMessageQueue.clear();
+        errorFuture.completeExceptionally(new IOException("WebSocket 已关闭"));
+    }
+
+    private class InternalHandler extends AbstractWebSocketHandler {
+        private final String targetUri;
+        private final StopWatch stopWatch;
+
+        InternalHandler(String targetUri) {
+            this.targetUri = targetUri;
+            this.stopWatch = new StopWatch();
+        }
+
+        /**
+         * 连接建立时回调
+         */
+        @Override
+        public void afterConnectionEstablished(WebSocketSession session) {
+            // 保存会话
+            WebSocketClientManager.this.session = session;
+            this.stopWatch.start();
+            log.info("ws连接成功, 目标URI: {}, 连接时间: {}", targetUri, DateUtils.getDateTimeNow(DateUtils.DATE_TIME_MILLIS_PATTERN));
+        }
+
+        /**
+         * 处理文本消息
+         */
+        @Override
+        protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
+            String payload = message.getPayload();
+            // 入队
+            textMessageQueue.offer(payload);
+            // 回调用户注册的 onText
+            if (onText != null) {
+                CALLBACK_EXECUTOR.submit(() -> onText.accept(payload));
+            }
+        }
+
+        /**
+         * 处理二进制消息
+         */
+        @Override
+        protected void handleBinaryMessage(WebSocketSession session, BinaryMessage message) throws Exception {
+            ByteBuffer buf = message.getPayload();
+            byte[] data = new byte[buf.remaining()];
+            buf.get(data);
+            // 入队
+            binaryMessageQueue.offer(data);
+            // 回调用户注册的 onBinary
+            if (onBinary != null) {
+                CALLBACK_EXECUTOR.submit(() -> onBinary.accept(data));
+            }
+        }
+
+        /**
+         * 传输错误时回调
+         */
+        @Override
+        public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
+            super.handleTransportError(session, exception);
+            // 保持原有逻辑：完成 errorFuture、回调 onError、关闭会话、异步通知连接失败
+            errorFuture.completeExceptionally(exception);
+            if (onError != null) {
+                CALLBACK_EXECUTOR.submit(() -> onError.accept(exception));
+            }
+            session.close(CloseStatus.SERVER_ERROR);
+        }
+
+        /**
+         * 连接关闭时回调
+         */
+        @Override
+        public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
+            super.afterConnectionClosed(session, status);
+            if (stopWatch.isRunning()) {
+                stopWatch.stop();
+            }
+            log.info("ws连接关闭, 目标URI: {}, 关闭时间: {}, 连接总时长: {}s",
+                    targetUri, DateUtils.getDateTimeNow(DateUtils.DATE_TIME_MILLIS_PATTERN), DateUtils.millsToSecond(stopWatch.getTotalTimeMillis()));
+        }
+    }
+
+    public static class Builder {
+        private String uri;                                         // 目标 WS URI
+        private long connectTimeout = 3;                            // 请求连接等待时间
+        private TimeUnit connectUnit = TimeUnit.SECONDS;            // 请求连接等待时间单位
+        private long maxSessionDuration = 5;                        // 最大连线时间，默认5秒
+        private TimeUnit maxSessionDurationUnit = TimeUnit.SECONDS; // 最大连线时间单位
+        private int queueCapacity = 100;                            // 消息队列容量
+        private WebSocketHttpHeaders headers;                       // 请求头
+
+        /**
+         * 目标 WS URI
+         */
+        public Builder uri(String uri) {
+            this.uri = Objects.requireNonNull(uri);
+            return this;
+        }
+
+        public Builder headers(WebSocketHttpHeaders h) {
+            this.headers = h;
+            return this;
+        }
+
+        public Builder connectTimeout(long t, TimeUnit u) {
+            this.connectTimeout = t;
+            this.connectUnit = u;
+            return this;
+        }
+
+        public Builder maxSessionDuration(long t, TimeUnit u) {
+            this.maxSessionDuration = t;
+            this.maxSessionDurationUnit = u;
+            return this;
+        }
+
+        public Builder queueCapacity(int c) {
+            this.queueCapacity = c;
+            return this;
+        }
+
+        public WebSocketClientManager build() throws InterruptedException, ExecutionException, TimeoutException, IOException {
+            return WebSocketClientManager.build(this);
+        }
+
+    }
+}

main/manager-api/src/main/resources/application-dev.yml

@@ -48,4 +48,4 @@ spring:
           max-active: 8      # 连接池最大连接数（使用负值表示没有限制）
           max-idle: 8        # 连接池中的最大空闲连接
           min-idle: 0        # 连接池中的最小空闲连接
-        shutdown-timeout: 100ms  # 客户端优雅关闭的等待时间
+        shutdown-timeout: 100ms  # 客户端优雅关闭的等待时间

main/manager-api/src/main/resources/db/changelog/202505091555.sql

@@ -0,0 +1,25 @@
+-- 更新模型供应器表
+UPDATE `ai_model_provider` SET fields = '[{"key": "host", "type": "string", "label": "服务地址"}, {"key": "port", "type": "number", "label": "端口号"}, {"key": "type", "type": "string", "label": "服务类型"}, {"key": "is_ssl", "type": "boolean", "label": "是否使用SSL"}, {"key": "api_key", "type": "string", "label": "API密钥"}, {"key": "output_dir", "type": "string", "label": "输出目录"}]' WHERE id = 'SYSTEM_ASR_FunASRServer';
+
+-- 更新模型配置表
+UPDATE `ai_model_config` SET 
+config_json = '{"host": "127.0.0.1", "port": 10096, "type": "fun_server", "is_ssl": true, "api_key": "none", "output_dir": "tmp/"}',
+`doc_link` = 'https://github.com/modelscope/FunASR/blob/main/runtime/docs/SDK_advanced_guide_online_zh.md',
+`remark` = '独立部署FunASR，使用FunASR的API服务，只需要五句话
+第一句：mkdir -p ./funasr-runtime-resources/models
+第二句：sudo docker run -p 10096:10095 -it --privileged=true -v $PWD/funasr-runtime-resources/models:/workspace/models registry.cn-hangzhou.aliyuncs.com/funasr_repo/funasr:funasr-runtime-sdk-online-cpu-0.1.12
+上一句话执行后会进入到容器，继续第三句：cd FunASR/runtime
+不要退出容器，继续在容器中执行第四句：nohup bash run_server_2pass.sh --download-model-dir /workspace/models --vad-dir damo/speech_fsmn_vad_zh-cn-16k-common-onnx --model-dir damo/speech_paraformer-large-vad-punc_asr_nat-zh-cn-16k-common-vocab8404-onnx  --online-model-dir damo/speech_paraformer-large_asr_nat-zh-cn-16k-common-vocab8404-online-onnx  --punc-dir damo/punc_ct-transformer_zh-cn-common-vad_realtime-vocab272727-onnx --lm-dir damo/speech_ngram_lm_zh-cn-ai-wesp-fst --itn-dir thuduj12/fst_itn_zh --hotword /workspace/models/hotwords.txt > log.txt 2>&1 &
+上一句话执行后会进入到容器，继续第五句：tail -f log.txt
+第五句话执行完后，会看到模型下载日志，下载完后就可以连接使用了
+以上是使用CPU推理，如果有GPU，详细参考：https://github.com/modelscope/FunASR/blob/main/runtime/docs/SDK_advanced_guide_online_zh.md' WHERE `id` = 'ASR_FunASRServer';
+
+-- FishSpeech配置说明
+UPDATE `ai_model_config` SET 
+`doc_link` = 'https://github.com/xinnan-tech/xiaozhi-esp32-server/blob/main/docs/fish-speech-integration.md',
+`remark` = 'FishSpeech配置说明：
+1. 需要本地部署FishSpeech服务
+2. 支持自定义音色
+3. 本地推理，无需网络连接
+4. 输出文件保存在tmp/目录
+5. 可参照教程https://github.com/xinnan-tech/xiaozhi-esp32-server/blob/main/docs/fish-speech-integration.md' WHERE `id` = 'TTS_FishSpeech';

main/manager-api/src/main/resources/db/changelog/202505111914.sql

@@ -0,0 +1,6 @@
+-- 添加聊天记录配置字段
+ALTER TABLE `ai_agent` 
+ADD COLUMN `chat_history_conf` tinyint NOT NULL DEFAULT 0 COMMENT '聊天记录配置（0不记录 1仅记录文本 2记录文本和语音）' AFTER `system_prompt`;
+
+ALTER TABLE `ai_agent_template` 
+ADD COLUMN `chat_history_conf` tinyint NOT NULL DEFAULT 0 COMMENT '聊天记录配置（0不记录 1仅记录文本 2记录文本和语音）' AFTER `system_prompt`;

main/manager-api/src/main/resources/db/changelog/202505122348.sql

@@ -0,0 +1,6 @@
+-- 添加总结记忆字段
+ALTER TABLE `ai_agent`
+ADD COLUMN `summary_memory` text COMMENT '总结记忆' AFTER `system_prompt`;
+
+ALTER TABLE `ai_agent_template`
+ADD COLUMN `summary_memory` text COMMENT '总结记忆' AFTER `system_prompt`;

main/manager-api/src/main/resources/db/changelog/202505142037.sql

@@ -0,0 +1,7 @@
+update ai_agent_template set system_prompt = replace(system_prompt, '我是', '你是');
+
+delete from sys_params where id in (500,501,402);
+INSERT INTO `sys_params` (id, param_code, param_value, value_type, param_type, remark) VALUES (500, 'end_prompt.enable', 'true', 'boolean', 1, '是否开启结束语');
+INSERT INTO `sys_params` (id, param_code, param_value, value_type, param_type, remark) VALUES (501, 'end_prompt.prompt', '请你以“时间过得真快”未来头，用富有感情、依依不舍的话来结束这场对话吧！', 'string', 1, '结束提示词');
+
+INSERT INTO `sys_params` (id, param_code, param_value, value_type, param_type, remark) VALUES (402, 'plugins.get_weather.api_host', 'mj7p3y7naa.re.qweatherapi.com', 'string', 1, '开发者apihost');

main/manager-api/src/main/resources/db/changelog/202505151451.sql

@@ -0,0 +1,18 @@
+-- 修改自定义TTS接口请求定义
+update `ai_model_provider` set `fields` =
+'[{"key":"url","label":"服务地址","type":"string"},{"key":"method","label":"请求方式","type":"string"},{"key":"params","label":"请求参数","type":"dict","dict_name":"params"},{"key":"headers","label":"请求头","type":"dict","dict_name":"headers"},{"key":"format","label":"音频格式","type":"string"},{"key":"output_dir","label":"输出目录","type":"string"}]'
+where `id` = 'SYSTEM_TTS_custom';
+
+-- 修改自定义TTS配置说明
+UPDATE `ai_model_config` SET
+`doc_link` = NULL,
+`remark` = '自定义TTS配置说明：
+1. 自定义的TTS接口服务，请求参数可自定义，可接入众多TTS服务
+2. 以本地部署的KokoroTTS为例
+3. 如果只有cpu运行：docker run -p 8880:8880 ghcr.io/remsky/kokoro-fastapi-cpu:latest
+4. 如果只有gpu运行：docker run --gpus all -p 8880:8880 ghcr.io/remsky/kokoro-fastapi-gpu:latest
+配置说明：
+1. 在params中配置请求参数,使用JSON格式
+   例如KokoroTTS：{ "input": "{prompt_text}", "speed": 1, "voice": "zm_yunxi", "stream": true, "download_format": "mp3", "response_format": "mp3", "return_download_link": true }
+2. 在headers中配置请求头
+3. 设置返回音频格式' WHERE `id` = 'TTS_CustomTTS';

main/manager-api/src/main/resources/db/changelog/202505182234.sql

@@ -0,0 +1,65 @@
+-- 添加手机短信注册功能的需要的参数
+delete from sys_params where id in (108, 109, 110, 111, 112, 113, 114, 115);
+delete from sys_params where id in (610, 611, 612, 613);
+INSERT INTO sys_params
+(id, param_code, param_value, value_type, param_type, remark, creator, create_date, updater, update_date)
+    VALUES
+(108, 'server.name', 'xiaozhi-esp32-server', 'string', 1, '系统名称', NULL, NULL, NULL, NULL),
+(109, 'server.beian_icp_num', 'null', 'string', 1, 'icp备案号，填写null则不设置', NULL, NULL, NULL, NULL),
+(110, 'server.beian_ga_num', 'null', 'string', 1, '公安备案号，填写null则不设置', NULL, NULL, NULL, NULL),
+(111, 'server.enable_mobile_register', 'false', 'boolean', 1, '是否开启手机注册', NULL, NULL, NULL, NULL),
+(112, 'server.sms_max_send_count', '10', 'number', 1, '单号码单日最大短信发送条数', NULL, NULL, NULL, NULL),
+(610, 'aliyun.sms.access_key_id', '', 'string', 1, '阿里云平台access_key', NULL, NULL, NULL, NULL),
+(611, 'aliyun.sms.access_key_secret', '', 'string', 1, '阿里云平台access_key_secret', NULL, NULL, NULL, NULL),
+(612, 'aliyun.sms.sign_name', '', 'string', 1, '阿里云短信签名', NULL, NULL, NULL, NULL),
+(613, 'aliyun.sms.sms_code_template_code', '', 'string', 1, '阿里云短信模板', NULL, NULL, NULL, NULL);
+
+update sys_params set remark = '是否允许管理员以外的人注册' where param_code = 'server.allow_user_register';
+
+-- 增加手机区域字典
+-- 插入固件类型字典类型
+delete from `sys_dict_type` where `id` = 102;
+INSERT INTO `sys_dict_type` (`id`, `dict_type`, `dict_name`, `remark`, `sort`, `creator`, `create_date`, `updater`, `update_date`) VALUES 
+(102, 'MOBILE_AREA', '手机区域', '手机区域字典', 0, 1, NOW(), 1, NOW());
+
+-- 插入固件类型字典数据
+delete from `sys_dict_data` where `dict_type_id` = 102;
+INSERT INTO `sys_dict_data` (`id`, `dict_type_id`, `dict_label`, `dict_value`, `remark`, `sort`, `creator`, `create_date`, `updater`, `update_date`) VALUES 
+(102001, 102, '中国大陆', '+86', '中国大陆', 1, 1, NOW(), 1, NOW()),
+(102002, 102, '中国香港', '+852', '中国香港', 2, 1, NOW(), 1, NOW()),
+(102003, 102, '中国澳门', '+853', '中国澳门', 3, 1, NOW(), 1, NOW()),
+(102004, 102, '中国台湾', '+886', '中国台湾', 4, 1, NOW(), 1, NOW()),
+(102005, 102, '美国/加拿大', '+1', '美国/加拿大', 5, 1, NOW(), 1, NOW()),
+(102006, 102, '英国', '+44', '英国', 6, 1, NOW(), 1, NOW()),
+(102007, 102, '法国', '+33', '法国', 7, 1, NOW(), 1, NOW()),
+(102008, 102, '意大利', '+39', '意大利', 8, 1, NOW(), 1, NOW()),
+(102009, 102, '德国', '+49', '德国', 9, 1, NOW(), 1, NOW()),
+(102010, 102, '波兰', '+48', '波兰', 10, 1, NOW(), 1, NOW()),
+(102011, 102, '瑞士', '+41', '瑞士', 11, 1, NOW(), 1, NOW()),
+(102012, 102, '西班牙', '+34', '西班牙', 12, 1, NOW(), 1, NOW()),
+(102013, 102, '丹麦', '+45', '丹麦', 13, 1, NOW(), 1, NOW()),
+(102014, 102, '马来西亚', '+60', '马来西亚', 14, 1, NOW(), 1, NOW()),
+(102015, 102, '澳大利亚', '+61', '澳大利亚', 15, 1, NOW(), 1, NOW()),
+(102016, 102, '印度尼西亚', '+62', '印度尼西亚', 16, 1, NOW(), 1, NOW()),
+(102017, 102, '菲律宾', '+63', '菲律宾', 17, 1, NOW(), 1, NOW()),
+(102018, 102, '新西兰', '+64', '新西兰', 18, 1, NOW(), 1, NOW()),
+(102019, 102, '新加坡', '+65', '新加坡', 19, 1, NOW(), 1, NOW()),
+(102020, 102, '泰国', '+66', '泰国', 20, 1, NOW(), 1, NOW()),
+(102021, 102, '日本', '+81', '日本', 21, 1, NOW(), 1, NOW()),
+(102022, 102, '韩国', '+82', '韩国', 22, 1, NOW(), 1, NOW()),
+(102023, 102, '越南', '+84', '越南', 23, 1, NOW(), 1, NOW()),
+(102024, 102, '印度', '+91', '印度', 24, 1, NOW(), 1, NOW()),
+(102025, 102, '巴基斯坦', '+92', '巴基斯坦', 25, 1, NOW(), 1, NOW()),
+(102026, 102, '尼日利亚', '+234', '尼日利亚', 26, 1, NOW(), 1, NOW()),
+(102027, 102, '孟加拉国', '+880', '孟加拉国', 27, 1, NOW(), 1, NOW()),
+(102028, 102, '沙特阿拉伯', '+966', '沙特阿拉伯', 28, 1, NOW(), 1, NOW()),
+(102029, 102, '阿联酋', '+971', '阿联酋', 29, 1, NOW(), 1, NOW()),
+(102030, 102, '巴西', '+55', '巴西', 30, 1, NOW(), 1, NOW()),
+(102031, 102, '墨西哥', '+52', '墨西哥', 31, 1, NOW(), 1, NOW()),
+(102032, 102, '智利', '+56', '智利', 32, 1, NOW(), 1, NOW()),
+(102033, 102, '阿根廷', '+54', '阿根廷', 33, 1, NOW(), 1, NOW()),
+(102034, 102, '埃及', '+20', '埃及', 34, 1, NOW(), 1, NOW()),
+(102035, 102, '南非', '+27', '南非', 35, 1, NOW(), 1, NOW()),
+(102036, 102, '肯尼亚', '+254', '肯尼亚', 36, 1, NOW(), 1, NOW()),
+(102037, 102, '坦桑尼亚', '+255', '坦桑尼亚', 37, 1, NOW(), 1, NOW()),
+(102038, 102, '哈萨克斯坦', '+7', '哈萨克斯坦', 38, 1, NOW(), 1, NOW());

main/manager-api/src/main/resources/db/changelog/202505201744.sql

@@ -0,0 +1,3 @@
+-- 更新ai_model_provider的fields字段，将type为dict的改为string
+update ai_model_provider set fields = replace(fields, '"type": "dict"', '"type": "string"') where id not in ('SYSTEM_LLM_fastgpt', 'SYSTEM_TTS_custom');
+update ai_model_provider set fields = replace(fields, '"type":"dict"', '"type": "string"') where id not in ('SYSTEM_LLM_fastgpt', 'SYSTEM_TTS_custom');

main/manager-api/src/main/resources/db/changelog/202505271414.sql

@@ -0,0 +1,51 @@
+-- 本地短期记忆配置可以设置独立的LLM
+update `ai_model_provider` set fields =  '[{"key":"llm","label":"LLM模型","type":"string"}]' where  id = 'SYSTEM_Memory_mem_local_short';
+update `ai_model_config` set config_json =  '{\"type\": \"mem_local_short\", \"llm\": \"LLM_ChatGLMLLM\"}' where  id = 'Memory_mem_local_short';
+
+-- 增加火山双流式TTS供应器和模型配置
+delete from `ai_model_provider` where id = 'SYSTEM_TTS_HSDSTTS';
+INSERT INTO `ai_model_provider` (`id`, `model_type`, `provider_code`, `name`, `fields`, `sort`, `creator`, `create_date`, `updater`, `update_date`) VALUES
+('SYSTEM_TTS_HSDSTTS', 'TTS', 'huoshan_double_stream', '火山双流式语音合成', '[{"key":"ws_url","label":"WebSocket地址","type":"string"},{"key":"appid","label":"应用ID","type":"string"},{"key":"access_token","label":"访问令牌","type":"string"},{"key":"resource_id","label":"资源ID","type":"string"},{"key":"speaker","label":"默认音色","type":"string"}]', 13, 1, NOW(), 1, NOW());
+
+delete from `ai_model_config` where id = 'TTS_HuoshanDoubleStreamTTS';
+INSERT INTO `ai_model_config` VALUES ('TTS_HuoshanDoubleStreamTTS', 'TTS', 'HuoshanDoubleStreamTTS', '火山双流式语音合成', 0, 1, '{\"type\": \"huoshan_double_stream\", \"ws_url\": \"wss://openspeech.bytedance.com/api/v3/tts/bidirection\", \"appid\": \"你的火山引擎语音合成服务appid\", \"access_token\": \"你的火山引擎语音合成服务access_token\", \"resource_id\": \"volc.service_type.10029\", \"speaker\": \"zh_female_wanwanxiaohe_moon_bigtts\"}', NULL, NULL, 16, NULL, NULL, NULL, NULL);
+
+-- 火山双流式TT模型配置说明文档
+UPDATE `ai_model_config` SET 
+`doc_link` = 'https://console.volcengine.com/speech/service/10007',
+`remark` = '火山引擎语音合成服务配置说明：
+1. 访问 https://www.volcengine.com/ 注册并开通火山引擎账号
+2. 访问 https://console.volcengine.com/speech/service/10007 开通语音合成大模型，购买音色
+3. 在页面底部获取appid和access_token
+5. 资源ID固定为：volc.service_type.10029（大模型语音合成及混音）
+6. 填入配置文件中' WHERE `id` = 'TTS_HuoshanDoubleStreamTTS';
+
+
+-- 添加火山双流式TTS音色
+delete from `ai_tts_voice` where tts_model_id = 'TTS_HuoshanDoubleStreamTTS';
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0001', 'TTS_HuoshanDoubleStreamTTS', '爽快思思/Skye', 'zh_female_shuangkuaisisi_moon_bigtts', '中文、英文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/Skye.mp3', NULL, 1, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0002', 'TTS_HuoshanDoubleStreamTTS', '温暖阿虎/Alvin', 'zh_male_wennuanahu_moon_bigtts', '中文、英文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/Alvin.mp3', NULL, 2, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0003', 'TTS_HuoshanDoubleStreamTTS', '少年梓辛/Brayan', 'zh_male_shaonianzixin_moon_bigtts', '中文、英文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/Brayan.mp3', NULL, 3, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0004', 'TTS_HuoshanDoubleStreamTTS', '邻家女孩', 'zh_female_linjianvhai_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E9%82%BB%E5%AE%B6%E5%A5%B3%E5%AD%A9.mp3', NULL, 4, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0005', 'TTS_HuoshanDoubleStreamTTS', '渊博小叔', 'zh_male_yuanboxiaoshu_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E6%B8%8A%E5%8D%9A%E5%B0%8F%E5%8F%94.mp3', NULL, 5, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0006', 'TTS_HuoshanDoubleStreamTTS', '阳光青年', 'zh_male_yangguangqingnian_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E9%98%B3%E5%85%89%E9%9D%92%E5%B9%B4.mp3', NULL, 6, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0007', 'TTS_HuoshanDoubleStreamTTS', '京腔侃爷/Harmony', 'zh_male_jingqiangkanye_moon_bigtts', '中文、英文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/Harmony.mp3', NULL, 7, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0008', 'TTS_HuoshanDoubleStreamTTS', '湾湾小何', 'zh_female_wanwanxiaohe_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E6%B9%BE%E6%B9%BE%E5%B0%8F%E4%BD%95.mp3', NULL, 8, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0009', 'TTS_HuoshanDoubleStreamTTS', '湾区大叔', 'zh_female_wanqudashu_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E6%B9%BE%E5%8C%BA%E5%A4%A7%E5%8F%94.mp3', NULL, 9, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0010', 'TTS_HuoshanDoubleStreamTTS', '呆萌川妹', 'zh_female_daimengchuanmei_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E5%91%86%E8%90%8C%E5%B7%9D%E5%A6%B9.mp3', NULL, 10, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0011', 'TTS_HuoshanDoubleStreamTTS', '广州德哥', 'zh_male_guozhoudege_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E5%B9%BF%E5%B7%9E%E5%BE%B7%E5%93%A5.mp3', NULL, 11, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0012', 'TTS_HuoshanDoubleStreamTTS', '北京小爷', 'zh_male_beijingxiaoye_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E5%8C%97%E4%BA%AC%E5%B0%8F%E7%88%B7.mp3', NULL, 12, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0013', 'TTS_HuoshanDoubleStreamTTS', '浩宇小哥', 'zh_male_haoyuxiaoge_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E6%B5%A9%E5%AE%87%E5%B0%8F%E5%93%A5.mp3', NULL, 13, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0014', 'TTS_HuoshanDoubleStreamTTS', '广西远舟', 'zh_male_guangxiyuanzhou_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E5%B9%BF%E8%A5%BF%E8%BF%9C%E8%88%9F.mp3', NULL, 14, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0015', 'TTS_HuoshanDoubleStreamTTS', '妹坨洁儿', 'zh_female_meituojieer_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E5%A6%B9%E5%9D%A8%E6%B4%81%E5%84%BF.mp3', NULL, 15, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0016', 'TTS_HuoshanDoubleStreamTTS', '豫州子轩', 'zh_male_yuzhouzixuan_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E8%B1%AB%E5%B7%9E%E5%AD%90%E8%BD%A9.mp3', NULL, 16, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0017', 'TTS_HuoshanDoubleStreamTTS', '高冷御姐', 'zh_female_gaolengyujie_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E9%AB%98%E5%86%B7%E5%BE%A1%E5%A7%90.mp3', NULL, 17, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0018', 'TTS_HuoshanDoubleStreamTTS', '傲娇霸总', 'zh_male_aojiaobazong_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E5%82%B2%E5%A8%87%E9%9C%B8%E6%80%BB.mp3', NULL, 18, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0019', 'TTS_HuoshanDoubleStreamTTS', '魅力女友', 'zh_female_meilinvyou_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E9%AD%85%E5%8A%9B%E5%A5%B3%E5%8F%8B.mp3', NULL, 19, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0020', 'TTS_HuoshanDoubleStreamTTS', '深夜播客', 'zh_male_shenyeboke_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E6%B7%B1%E5%A4%9C%E6%92%AD%E5%AE%A2.mp3', NULL, 20, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0021', 'TTS_HuoshanDoubleStreamTTS', '柔美女友', 'zh_female_sajiaonvyou_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E6%9F%94%E7%BE%8E%E5%A5%B3%E5%8F%8B.mp3', NULL, 21, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0022', 'TTS_HuoshanDoubleStreamTTS', '撒娇学妹', 'zh_female_yuanqinvyou_moon_bigtts', '中文', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E6%92%92%E5%A8%87%E5%AD%A6%E5%A6%B9.mp3', NULL, 22, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0023', 'TTS_HuoshanDoubleStreamTTS', 'かずね（和音）', 'multi_male_jingqiangkanye_moon_bigtts', '日语、西语', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/Javier.wav', NULL, 23, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0024', 'TTS_HuoshanDoubleStreamTTS', 'はるこ（晴子）', 'multi_female_shuangkuaisisi_moon_bigtts', '日语、西语', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/Esmeralda.mp3', NULL, 24, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0025', 'TTS_HuoshanDoubleStreamTTS', 'あけみ（朱美）', 'multi_female_gaolengyujie_moon_bigtts', '日语', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/%E6%9C%B1%E7%BE%8E.mp3', NULL, 25, NULL, NULL, NULL, NULL);
+INSERT INTO `ai_tts_voice` VALUES ('TTS_HuoshanDoubleStreamTTS_0026', 'TTS_HuoshanDoubleStreamTTS', 'ひろし（広志）', 'multi_male_wanqudashu_moon_bigtts', '日语、西语', 'https://lf3-static.bytednsdoc.com/obj/eden-cn/lm_hz_ihsph/ljhwZthlaukjlkulzlp/portal/bigtts/Roberto.wav', NULL, 26, NULL, NULL, NULL, NULL);

main/manager-api/src/main/resources/db/changelog/db.changelog-master.yaml

@@ -113,4 +113,60 @@ databaseChangeLog:
       changes:
         - sqlFile:
             encoding: utf8
-            path: classpath:db/changelog/202505091409.sql
+            path: classpath:db/changelog/202505091409.sql
+  - changeSet:
+      id: 202505091555
+      author: whosmyqueen
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202505091555.sql
+  - changeSet:
+      id: 202505111914
+      author: hrz
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202505111914.sql
+  - changeSet:
+      id: 202505122348
+      author: ljwwd2
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202505122348.sql
+  - changeSet:
+      id: 202505142037
+      author: hrz
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202505142037.sql
+  - changeSet:
+      id: 202505182234
+      author: amen
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202505182234.sql
+  - changeSet:
+      id: 202505201744
+      author: hrz
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202505201744.sql
+  - changeSet:
+      id: 202505151451
+      author: hsoftxl
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202505151451.sql
+  - changeSet:
+      id: 202505271414
+      author: hrz
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202505271414.sql

main/manager-api/src/main/resources/i18n/messages.properties

@@ -9,6 +9,7 @@
 10005=\u8D26\u53F7\u5DF2\u88AB\u505C\u7528
 10006=\u552F\u4E00\u6807\u8BC6\u4E0D\u80FD\u4E3A\u7A7A
 10007=\u9A8C\u8BC1\u7801\u4E0D\u6B63\u786E
+10008=\u624B\u673A\u53F7\u7801\u4E0D\u53EF\u4EE5\u4E3A\u7A7A
 10009=\u539F\u5BC6\u7801\u4E0D\u6B63\u786E
 10010=\u8D26\u53F7\u6216\u5BC6\u7801\u4E0D\u6B63\u786E,\u60A8\u8FD8\u6709\u53EF\u4EE5\u5C1D\u8BD5{0}\u6B21
 10011=\u4E0A\u7EA7\u90E8\u95E8\u9009\u62E9\u9519\u8BEF

main/manager-api/src/main/resources/lua/emptyAll.lua

@@ -0,0 +1 @@
+redis.call('FLUSHALL')

main/manager-api/src/main/resources/lua/getKeyOrCreate.lua

@@ -0,0 +1,11 @@
+local value = redis.call('GET', KEYS[1])
+-- value 如果为空着设置值
+if not value then
+    local result = redis.call('SET', KEYS[1], ARGV[1]) 
+    -- 检查 ARGV[2] 是否存在且大于 0
+    local expireTime = tonumber(ARGV[2])
+    if expireTime and expireTime > 0 then
+        redis.call('EXPIRE', KEYS[1], expireTime)
+    end
+end
+return value

main/manager-api/src/main/resources/mapper/agent/AiAgentChatHistoryDao.xml

@@ -28,11 +28,17 @@
       SELECT audio_id 
       FROM ai_agent_chat_history 
       WHERE agent_id = #{agentId}
-    );
+    )
   </delete>
+  
+  <update id="deleteAudioIdByAgentId">
+    UPDATE ai_agent_chat_history
+    SET audio_id = NULL
+    WHERE agent_id = #{agentId}
+  </update>
 
   <delete id="deleteHistoryByAgentId">
     DELETE FROM ai_agent_chat_history 
-    WHERE agent_id = #{agentId};
+    WHERE agent_id = #{agentId}
   </delete>
 </mapper>

main/manager-api/src/test/java/xiaozhi/modules/sys/loginControllerTest.java

@@ -0,0 +1,58 @@
+package xiaozhi.modules.sys;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+
+import lombok.extern.slf4j.Slf4j;
+import xiaozhi.modules.security.controller.LoginController;
+import xiaozhi.modules.security.dto.LoginDTO;
+import xiaozhi.modules.security.dto.SmsVerificationDTO;
+import xiaozhi.modules.sys.dto.RetrievePasswordDTO;
+
+@Slf4j
+@SpringBootTest
+@ActiveProfiles("dev")
+class loginControllerTest {
+
+    @Autowired
+    LoginController loginController;
+
+    @Test
+    public void testRegister() {
+        LoginDTO loginDTO = new LoginDTO();
+        loginDTO.setUsername("手机号码");
+        loginDTO.setPassword("密码");
+        loginDTO.setCaptcha("123456");
+        loginController.register(loginDTO);
+    }
+
+    @Test
+    public void testSmsVerification() {
+        try {
+            SmsVerificationDTO smsVerificationDTO = new SmsVerificationDTO();
+            smsVerificationDTO.setPhone("手机号码");
+            smsVerificationDTO.setCaptchaId("123456");
+            smsVerificationDTO.setCaptcha("123456");
+            loginController.smsVerification(smsVerificationDTO);
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
+        }
+    }
+
+    @Test
+    public void testRetrievePassword() {
+        try {
+            RetrievePasswordDTO retrievePasswordDTO = new RetrievePasswordDTO();
+            retrievePasswordDTO.setCode("123456");
+            retrievePasswordDTO.setPhone("手机号码");
+            retrievePasswordDTO.setPassword("密码");
+            loginController.retrievePassword(retrievePasswordDTO);
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
+        }
+
+    }
+
+}

main/manager-web/src/apis/httpRequest.js

@@ -20,6 +20,7 @@ function sendRequest() {
     return {
         _sucCallback: null,
         _failCallback: null,
+        _networkFailCallback: null,
         _method: 'GET',
         _data: {},
         _header: { 'content-type': 'application/json; charset=utf-8' },
@@ -36,7 +37,7 @@ function sendRequest() {
                 headers: this._header,
                 responseType: this._responseType
             }).then((res) => {
-                const error = httpHandlerError(res, this._failCallback);
+                const error = httpHandlerError(res, this._failCallback, this._networkFailCallback);
                 if (error) {
                     return
                 }
@@ -47,7 +48,7 @@ function sendRequest() {
             }).catch((res) => {
                 // 打印失败响应
                 console.log('catch', res)
-                httpHandlerError(res, this._failCallback)
+                httpHandlerError(res, this._failCallback, this._networkFailCallback)
             })
             return this
         },
@@ -59,6 +60,10 @@ function sendRequest() {
             this._failCallback = callback
             return this
         },
+        'networkFail'(callback) {
+            this._networkFailCallback = callback
+            return this
+        },
         'url'(url) {
             if (url) {
                 url = url.replaceAll('$', '/')
@@ -95,11 +100,11 @@ function sendRequest() {
 
 /**
  * Info 请求完成后返回信息
- * callBack 回调函数
+ * failCallback 回调函数
- * errTip 自定义错误信息
+ * networkFailCallback 回调函数
  */
 // 在错误处理函数中添加日志
-function httpHandlerError(info, callBack) {
+function httpHandlerError(info, failCallback, networkFailCallback) {
 
     /** 请求成功，退出该函数 可以根据项目需求来判断是否请求成功。这里判断的是status为200的时候是成功 */
     let networkError = false
@@ -111,12 +116,16 @@ function httpHandlerError(info, callBack) {
             goToPage(Constant.PAGE.LOGIN, true);
             return true
         } else {
-            showDanger(info.data.msg)
+            if (failCallback) {
+                failCallback(info)
+            } else {
+                showDanger(info.data.msg)
+            }
             return true
         }
     }
-    if (callBack) {
+    if (networkFailCallback) {
-        callBack(info)
+        networkFailCallback(info)
     } else {
         showDanger(`网络请求出现了错误【${info.status}】`)
     }

main/manager-web/src/apis/module/admin.js

@@ -18,7 +18,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('请求失败:', err)
                 RequestService.reAjaxFun(() => {
                     this.getUserList(callback)
@@ -34,7 +34,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('删除失败:', err)
                 RequestService.reAjaxFun(() => {
                     this.deleteUser(id, callback)
@@ -50,7 +50,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('重置密码失败:', err)
                 RequestService.reAjaxFun(() => {
                     this.resetUserPassword(id, callback)
@@ -72,7 +72,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('获取参数列表失败:', err)
                 RequestService.reAjaxFun(() => {
                     this.getParamsList(params, callback)
@@ -89,7 +89,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('添加参数失败:', err)
                 RequestService.reAjaxFun(() => {
                     this.addParam(data, callback)
@@ -106,7 +106,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('更新参数失败:', err)
                 RequestService.reAjaxFun(() => {
                     this.updateParam(data, callback)
@@ -123,12 +123,44 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('删除参数失败:', err)
                 RequestService.reAjaxFun(() => {
                     this.deleteParam(ids, callback)
                 })
             }).send()
     },
+    // 获取ws服务端列表
+    getWsServerList(params, callback) {
+        RequestService.sendRequest()
+            .url(`${getServiceUrl()}/admin/server/server-list`)
+            .method('GET')
+            .success((res) => {
+                RequestService.clearRequestTime()
+                callback(res)
+            })
+            .networkFail((err) => {
+                console.error('获取ws服务端列表失败:', err)
+                RequestService.reAjaxFun(() => {
+                    this.getWsServerList(params, callback)
+                })
+            }).send();
+    },
+    // 发送ws服务器动作指令
+    sendWsServerAction(data, callback) {
+        RequestService.sendRequest()
+            .url(`${getServiceUrl()}/admin/server/emit-action`)
+            .method('POST')
+            .data(data)
+            .success((res) => {
+                RequestService.clearRequestTime()
+                callback(res)
+            })
+            .networkFail((err) => {
+                RequestService.reAjaxFun(() => {
+                    this.sendWsServerAction(data, callback)
+                })
+            }).send();
+    }
 
 }

main/manager-web/src/apis/module/agent.js

@@ -12,7 +12,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail(() => {
+            .networkFail(() => {
                 RequestService.reAjaxFun(() => {
                     this.getAgentList(callback);
                 });
@@ -28,7 +28,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail(() => {
+            .networkFail(() => {
                 RequestService.reAjaxFun(() => {
                     this.addAgent(agentName, callback);
                 });
@@ -43,25 +43,25 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail(() => {
+            .networkFail(() => {
                 RequestService.reAjaxFun(() => {
                     this.deleteAgent(agentId, callback);
                 });
             }).send();
     },
     // 获取智能体配置
-    getDeviceConfig(deviceId, callback) {
+    getDeviceConfig(agentId, callback) {
         RequestService.sendRequest()
-            .url(`${getServiceUrl()}/agent/${deviceId}`)
+            .url(`${getServiceUrl()}/agent/${agentId}`)
             .method('GET')
             .success((res) => {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('获取配置失败:', err);
                 RequestService.reAjaxFun(() => {
-                    this.getDeviceConfig(deviceId, callback);
+                    this.getDeviceConfig(agentId, callback);
                 });
             }).send();
     },
@@ -75,7 +75,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail(() => {
+            .networkFail(() => {
                 RequestService.reAjaxFun(() => {
                     this.updateAgentConfig(agentId, configData, callback);
                 });
@@ -90,7 +90,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('获取模板失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.getAgentTemplate(callback);
@@ -107,7 +107,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail(() => {
+            .networkFail(() => {
                 RequestService.reAjaxFun(() => {
                     this.getAgentSessions(agentId, params, callback);
                 });
@@ -122,7 +122,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail(() => {
+            .networkFail(() => {
                 RequestService.reAjaxFun(() => {
                     this.getAgentChatHistory(agentId, sessionId, callback);
                 });
@@ -137,7 +137,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail(() => {
+            .networkFail(() => {
                 RequestService.reAjaxFun(() => {
                     this.getAudioId(audioId, callback);
                 });

main/manager-web/src/apis/module/device.js

@@ -11,7 +11,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('获取设备列表失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.getAgentBindDevices(agentId, callback);
@@ -28,7 +28,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('解绑设备失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.unbindDevice(device_id, callback);
@@ -44,7 +44,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('绑定设备失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.bindDevice(agentId, deviceCode, callback);
@@ -59,7 +59,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('更新OTA状态失败:', err)
                 this.$message.error(err.msg || '更新OTA状态失败')
                 RequestService.reAjaxFun(() => {

main/manager-web/src/apis/module/dict.js

@@ -18,7 +18,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('获取字典类型列表失败:', err)
                 this.$message.error(err.msg || '获取字典类型列表失败')
                 RequestService.reAjaxFun(() => {
@@ -36,7 +36,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('获取字典类型详情失败:', err)
                 this.$message.error(err.msg || '获取字典类型详情失败')
                 RequestService.reAjaxFun(() => {
@@ -55,7 +55,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('新增字典类型失败:', err)
                 this.$message.error(err.msg || '新增字典类型失败')
                 RequestService.reAjaxFun(() => {
@@ -74,7 +74,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('更新字典类型失败:', err)
                 this.$message.error(err.msg || '更新字典类型失败')
                 RequestService.reAjaxFun(() => {
@@ -93,7 +93,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('删除字典类型失败:', err)
                 this.$message.error(err.msg || '删除字典类型失败')
                 RequestService.reAjaxFun(() => {
@@ -119,7 +119,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('获取字典数据列表失败:', err)
                 this.$message.error(err.msg || '获取字典数据列表失败')
                 RequestService.reAjaxFun(() => {
@@ -137,7 +137,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('获取字典数据详情失败:', err)
                 this.$message.error(err.msg || '获取字典数据详情失败')
                 RequestService.reAjaxFun(() => {
@@ -156,7 +156,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('新增字典数据失败:', err)
                 this.$message.error(err.msg || '新增字典数据失败')
                 RequestService.reAjaxFun(() => {
@@ -175,7 +175,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('更新字典数据失败:', err)
                 this.$message.error(err.msg || '更新字典数据失败')
                 RequestService.reAjaxFun(() => {
@@ -194,7 +194,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res)
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('删除字典数据失败:', err)
                 this.$message.error(err.msg || '删除字典数据失败')
                 RequestService.reAjaxFun(() => {
@@ -217,7 +217,7 @@ export default {
                         reject(new Error(res.data?.msg || '获取字典数据列表失败'))
                     }
                 })
-                .fail((err) => {
+                .networkFail((err) => {
                     console.error('获取字典数据列表失败:', err)
                     reject(err)
                 }).send()

main/manager-web/src/apis/module/model.js

@@ -18,7 +18,7 @@ export default {
         RequestService.clearRequestTime()
         callback(res)
       })
-      .fail((err) => {
+      .networkFail((err) => {
         console.error('获取模型列表失败:', err)
         RequestService.reAjaxFun(() => {
           this.getModelList(params, callback)
@@ -34,7 +34,7 @@ export default {
         RequestService.clearRequestTime()
         callback(res.data?.data || [])
       })
-      .fail((err) => {
+      .networkFail((err) => {
         console.error('获取供应器列表失败:', err)
         this.$message.error('获取供应器列表失败')
         RequestService.reAjaxFun(() => {
@@ -65,7 +65,7 @@ export default {
         RequestService.clearRequestTime()
         callback(res)
       })
-      .fail((err) => {
+      .networkFail((err) => {
         console.error('新增模型失败:', err)
         this.$message.error(err.msg || '新增模型失败')
         RequestService.reAjaxFun(() => {
@@ -82,7 +82,7 @@ export default {
         RequestService.clearRequestTime()
         callback(res)
       })
-      .fail((err) => {
+      .networkFail((err) => {
         console.error('删除模型失败:', err)
         this.$message.error(err.msg || '删除模型失败')
         RequestService.reAjaxFun(() => {
@@ -100,7 +100,7 @@ export default {
         RequestService.clearRequestTime();
         callback(res);
       })
-      .fail(() => {
+      .networkFail(() => {
         RequestService.reAjaxFun(() => {
           this.getModelNames(modelType, modelName, callback);
         });
@@ -118,7 +118,7 @@ export default {
         RequestService.clearRequestTime();
         callback(res);
       })
-      .fail(() => {
+      .networkFail(() => {
         RequestService.reAjaxFun(() => {
           this.getModelVoices(modelId, voiceName, callback);
         });
@@ -133,7 +133,7 @@ export default {
         RequestService.clearRequestTime()
         callback(res)
       })
-      .fail((err) => {
+      .networkFail((err) => {
         console.error('获取模型配置失败:', err)
         this.$message.error(err.msg || '获取模型配置失败')
         RequestService.reAjaxFun(() => {
@@ -150,7 +150,7 @@ export default {
         RequestService.clearRequestTime()
         callback(res)
       })
-      .fail((err) => {
+      .networkFail((err) => {
         console.error('更新模型状态失败:', err)
         this.$message.error(err.msg || '更新模型状态失败')
         RequestService.reAjaxFun(() => {
@@ -166,20 +166,20 @@ export default {
       configJson: formData.configJson
     };
     RequestService.sendRequest()
-        .url(`${getServiceUrl()}/models/${modelType}/${provideCode}/${id}`)
+      .url(`${getServiceUrl()}/models/${modelType}/${provideCode}/${id}`)
-        .method('PUT')
+      .method('PUT')
-        .data(payload)
+      .data(payload)
-        .success((res) => {
+      .success((res) => {
-            RequestService.clearRequestTime();
+        RequestService.clearRequestTime();
-            callback(res);
+        callback(res);
-        })
+      })
-        .fail((err) => {
+      .networkFail((err) => {
-            console.error('更新模型失败:', err);
+        console.error('更新模型失败:', err);
-            this.$message.error(err.msg || '更新模型失败');
+        this.$message.error(err.msg || '更新模型失败');
-            RequestService.reAjaxFun(() => {
+        RequestService.reAjaxFun(() => {
-                this.updateModel(params, callback);
+          this.updateModel(params, callback);
-            });
+        });
-        }).send();
+      }).send();
   },
   // 设置默认模型
   setDefaultModel(id, callback) {
@@ -190,12 +190,119 @@ export default {
         RequestService.clearRequestTime()
         callback(res)
       })
-      .fail((err) => {
+      .networkFail((err) => {
         console.error('设置默认模型失败:', err)
         this.$message.error(err.msg || '设置默认模型失败')
         RequestService.reAjaxFun(() => {
           this.setDefaultModel(id, callback)
         })
       }).send()
-  }
+  },
+
+  /**
+   * 获取模型配置列表（支持查询参数）
+   * @param {Object} params - 查询参数对象，例如 { name: 'test', modelType: 1 }
+   * @param {Function} callback - 回调函数
+   */
+  getModelProvidersPage(params, callback) {
+    // 构建查询参数
+    const queryParams = new URLSearchParams();
+    if (params.name) queryParams.append('name', params.name);
+    if (params.modelType !== undefined) queryParams.append('modelType', params.modelType);
+    if (params.page !== undefined) queryParams.append('page', params.page);
+    if (params.limit !== undefined) queryParams.append('limit', params.limit);
+
+    RequestService.sendRequest()
+      .url(`${getServiceUrl()}/models/provider?${queryParams.toString()}`)
+      .method('GET')
+      .success((res) => {
+        RequestService.clearRequestTime();
+        callback(res);
+      })
+      .networkFail((err) => {
+        this.$message.error(err.msg || '获取供应器列表失败');
+        RequestService.reAjaxFun(() => {
+          this.getModelProviders(params, callback);
+        });
+      }).send();
+  },
+
+  /**
+   * 新增模型供应器配置
+   * @param {Object} params - 请求参数对象，例如 { modelType: '1', providerCode: '1', name: '1', fields: '1', sort: 1 }
+   * @param {Function} callback - 成功回调函数
+   */
+  addModelProvider(params, callback) {
+    const postData = {
+      modelType: params.modelType || '',
+      providerCode: params.providerCode || '',
+      name: params.name || '',
+      fields: JSON.stringify(params.fields || []),
+      sort: params.sort || 0
+    };
+
+    RequestService.sendRequest()
+      .url(`${getServiceUrl()}/models/provider`)
+      .method('POST')
+      .data(postData)
+      .success((res) => {
+        RequestService.clearRequestTime();
+        callback(res);
+      })
+      .networkFail((err) => {
+        console.error('新增模型供应器失败:', err)
+        this.$message.error(err.msg || '新增模型供应器失败')
+        RequestService.reAjaxFun(() => {
+          this.addModelProvider(params, callback);
+        });
+      }).send();
+  },
+
+  /**
+   * 更新模型供应器配置
+   * @param {Object} params - 请求参数对象，例如 { id: '111', modelType: '1', providerCode: '1', name: '1', fields: '1', sort: 1 }
+   * @param {Function} callback - 成功回调函数
+   */
+  updateModelProvider(params, callback) {
+    const putData = {
+      id: params.id || '',
+      modelType: params.modelType || '',
+      providerCode: params.providerCode || '',
+      name: params.name || '',
+      fields: JSON.stringify(params.fields || []),
+      sort: params.sort || 0
+    };
+
+    RequestService.sendRequest()
+      .url(`${getServiceUrl()}/models/provider`)
+      .method('PUT')
+      .data(putData)
+      .success((res) => {
+        RequestService.clearRequestTime();
+        callback(res);
+      })
+      .networkFail((err) => {
+        this.$message.error(err.msg || '更新模型供应器失败')
+        RequestService.reAjaxFun(() => {
+          this.updateModelProvider(params, callback);
+        });
+      }).send();
+  },
+  // 删除
+  deleteModelProviderByIds(ids, callback) {
+    RequestService.sendRequest()
+      .url(`${getServiceUrl()}/models/provider/delete`)
+      .method('POST')
+      .data(ids)
+      .success((res) => {
+        RequestService.clearRequestTime()
+        callback(res);
+      })
+      .networkFail((err) => {
+        this.$message.error(err.msg || '删除模型供应器失败')
+        RequestService.reAjaxFun(() => {
+          this.deleteModelProviderByIds(ids, callback)
+        })
+      }).send()
+  },
 }

main/manager-web/src/apis/module/ota.js

@@ -12,7 +12,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('获取OTA固件列表失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.getOtaList(params, callback);
@@ -28,7 +28,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('获取OTA固件信息失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.getOtaInfo(id, callback);
@@ -45,7 +45,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('保存OTA固件信息失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.saveOta(entity, callback);
@@ -62,7 +62,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('更新OTA固件信息失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.updateOta(id, entity, callback);
@@ -78,7 +78,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('删除OTA固件失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.deleteOta(id, callback);
@@ -97,7 +97,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('上传固件文件失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.uploadFirmware(file, callback);
@@ -113,7 +113,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('获取下载链接失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.getDownloadUrl(id, callback);

main/manager-web/src/apis/module/timbre.js

@@ -1,4 +1,4 @@
-import {getServiceUrl} from '../api';
+import { getServiceUrl } from '../api';
 import RequestService from '../httpRequest';
 
 export default {
@@ -18,7 +18,7 @@ export default {
                 RequestService.clearRequestTime();
                 callback(res.data || []);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('获取音色列表失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.getVoiceList(params, callback);
@@ -42,7 +42,7 @@ export default {
             .success((res) => {
                 callback(res.data);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('保存音色失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.saveVoice(params, callback);
@@ -59,7 +59,7 @@ export default {
                 RequestService.clearRequestTime()
                 callback(res);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('删除音色失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.deleteVoice(ids, callback);
@@ -82,7 +82,7 @@ export default {
             .success((res) => {
                 callback(res.data);
             })
-            .fail((err) => {
+            .networkFail((err) => {
                 console.error('修改音色失败:', err);
                 RequestService.reAjaxFun(() => {
                     this.updateVoice(params, callback);