v3.4.22

perf: 当图片数据为空时不加入上下文 #379
Merge pull request #411 from zhaolj/fix-bug-#298
2025-02-08 00:01:47 +08:00 · 2025-02-07 23:57:25 +08:00 · 2025-02-07 23:39:03 +08:00 · 2025-02-07 23:21:05 +08:00 · 2025-02-07 22:57:49 +08:00 · 2025-02-07 22:38:04 +08:00
133 changed files with 4784 additions and 11514 deletions
--- a/README.md
+++ b/README.md
@@ -1,93 +1,119 @@
-
 <p align="center">
-<img width=200 src="https://github.com/user-attachments/assets/3dd6a669-0830-4db4-b821-c8b279ea19a6"/>
+    
+![logo](https://github.com/user-attachments/assets/07649e07-3b8e-4feb-9aa9-bf13af4f3476)
+
+
 </p>

 <div align="center">

-<h1>AstrBot</h1>
-
 _✨ 易上手的多平台 LLM 聊天机器人及开发框架 ✨_

+<a href="https://trendshift.io/repositories/12875" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12875" alt="Soulter%2FAstrBot | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+
 [![GitHub release (latest by date)](https://img.shields.io/github/v/release/Soulter/AstrBot)](https://github.com/Soulter/AstrBot/releases/latest)
 <img src="https://img.shields.io/badge/python-3.10+-blue.svg" alt="python">
 <a href="https://hub.docker.com/r/soulter/astrbot"><img alt="Docker pull" src="https://img.shields.io/docker/pulls/soulter/astrbot.svg"/></a>
 <img alt="Static Badge" src="https://img.shields.io/badge/QQ群-322154837-purple">
 [![wakatime](https://wakatime.com/badge/user/915e5316-99c6-4563-a483-ef186cf000c9/project/018e705a-a1a7-409a-a849-3013485e6c8e.svg)](https://wakatime.com/badge/user/915e5316-99c6-4563-a483-ef186cf000c9/project/018e705a-a1a7-409a-a849-3013485e6c8e)
+![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.soulter.top%2Fastrbot%2Fstats&query=v&label=7%E6%97%A5%E6%B6%88%E6%81%AF%E4%B8%8A%E8%A1%8C%E9%87%8F&cacheSeconds=3600)
 [![codecov](https://codecov.io/gh/Soulter/AstrBot/graph/badge.svg?token=FF3P5967B8)](https://codecov.io/gh/Soulter/AstrBot)
-</a>

-<a href="https://astrbot.lwl.lol/">查看文档</a> ｜
+<a href="https://astrbot.app/">查看文档</a> ｜
 <a href="https://github.com/Soulter/AstrBot/issues">问题提交</a>
 </div>

 AstrBot 是一个松耦合、异步、支持多消息平台部署、具有易用的插件系统和完善的大语言模型（LLM）接入功能的聊天机器人及开发框架。

-## ✨ 多消息平台部署
+## ✨ 主要功能

-1. QQ 群、QQ 频道、微信个人号、Telegram。
-2. 支持文本转图片，Markdown 渲染。
-   
-## ✨ 多 LLM 配置
+1. **大语言模型对话**。支持各种大语言模型，包括 OpenAI API、Google Gemini、Llama、Deepseek、ChatGLM 等，支持接入本地部署的大模型，通过 Ollama、LLMTuner。具有多轮对话、人格情境、多模态能力，支持图片理解、语音转文字（Whisper）。
+2. **多消息平台接入**。支持接入 QQ（OneBot）、QQ 频道、微信（Gewechat、VChat）、Telegram。后续将支持钉钉、飞书、Discord、WhatsApp、小爱音响。支持速率限制、白名单、关键词过滤、百度内容审核。
+3. **Agent**。原生支持部分 Agent 能力，如代码执行器、自然语言待办、网页搜索。对接 [Dify 平台](https://astrbot.app/others/dify.html)，便捷接入 Dify 智能助手、知识库和 Dify 工作流。
+4. **插件扩展**。深度优化的插件机制，支持[开发插件](https://astrbot.app/dev/plugin.html)扩展功能，极简开发。已支持安装多个插件。
+5. **可视化管理面板**。支持可视化修改配置、插件管理、日志查看等功能，降低配置难度。集成 WebChat，可在面板上与大模型对话。
+6. **高稳定性、高模块化**。基于事件总线和流水线的架构设计，高度模块化，低耦合。

-1. 适配 OpenAI API，支持接入 Gemini、GPT、Llama、Claude、DeepSeek、GLM 等各种大语言模型。
-2. 支持 OneAPI 等分发平台。
-3. 支持 LLMTuner 载入微调模型。
-4. 支持 Ollama 载入自部署模型。
-4. 支持网页搜索（Web Search）、自然语言待办提醒。
-5. 支持 Whisper 语音转文字
+> [!TIP]
+> 管理面板在线体验 Demo: [https://demo.astrbot.app/](https://demo.astrbot.app/)
+> 
+> 用户名: `astrbot`, 密码: `astrbot`。未配置 LLM，无法在聊天页使用大模型。（不要再修改 demo 的登录密码了 😭）

-## ✨ 管理面板
+## ✨ 使用方式

-1. 支持可视化修改配置
-2. 日志实时查看
-3. 简单的信息统计
-4. 插件管理
+#### Docker 部署

-## ✨ 支持 Dify
+请参阅官方文档 [使用 Docker 部署 AstrBot](https://astrbot.app/deploy/astrbot/docker.html#%E4%BD%BF%E7%94%A8-docker-%E9%83%A8%E7%BD%B2-astrbot) 。

-1. 对接了 LLMOps 平台 Dify，便捷接入 Dify 智能助手、知识库和 Dify 工作流！[接入 Dify - AstrBot 文档](https://astrbot.lwl.lol/others/dify.html)
+#### Windows 一键安装器部署

-## ✨ 代码执行器(Beta)
+需要电脑上安装有 Python（>3.10）。请参阅官方文档 [使用 Windows 一键安装器部署 AstrBot](https://astrbot.app/deploy/astrbot/windows.html) 。

-基于 Docker 的沙箱化代码执行器（Beta 测试中）
-
-> [!NOTE]
-> 文件输入/输出目前仅支持 Napcat（QQ）
-
-<div align='center'>
-
-<img src="https://github.com/user-attachments/assets/4ee688d9-467d-45c8-99d6-368f9a8a92d8" width="600">
-
-</div>
-
-## ✨ 云部署
+#### Replit 部署

 [![Run on Repl.it](https://repl.it/badge/github/Soulter/AstrBot)](https://repl.it/github/Soulter/AstrBot)

+#### CasaOS 部署
+
+社区贡献的部署方式。
+
+请参阅官方文档 [通过源码部署 AstrBot](https://astrbot.app/deploy/astrbot/casaos.html) 。
+
+#### 手动部署
+
+请参阅官方文档 [通过源码部署 AstrBot](https://astrbot.app/deploy/astrbot/cli.html) 。
+
+
+## ⚡ 消息平台支持情况
+
+| 平台    | 支持性 | 详情 | 消息类型 |
+| -------- | ------- | ------- | ------ |
+| QQ(官方机器人接口) | ✔    | 私聊、群聊，QQ 频道私聊、群聊 | 文字、图片 |
+| QQ(OneBot)      | ✔    | 私聊、群聊 | 文字、图片、语音 |
+| 微信(个人号)    | ✔    | 微信个人号私聊、群聊 | 文字、图片、语音 |
+| [Telegram](https://github.com/Soulter/astrbot_plugin_telegram)   | ✔    | 私聊、群聊 | 文字、图片 |
+| [微信(企业微信)](https://github.com/Soulter/astrbot_plugin_wecom)    | ✔    | 私聊 | 文字、图片、语音 |
+| 微信对话开放平台 | 🚧    | 计划内 | - |
+| 飞书   | 🚧    | 计划内 | - |
+| Discord   | 🚧    | 计划内 | - |
+| WhatsApp   | 🚧    | 计划内 | - |
+| 小爱音响   | 🚧    | 计划内 | - |
+
+# 🦌 接下来的路线图
+
+> [!TIP]
+> 欢迎在 Issue 提出更多建议 <3
+
+- [ ] 完善并保证目前所有平台适配器的功能一致性
+- [ ] 优化插件接口
+- [ ] 默认支持更多 TTS 服务，如 GPT-Sovits
+- [ ] 完善“聊天增强”部分，支持持久化记忆
+- [ ] 规划 i18n
+
+
 ## ❤️ 贡献

 欢迎任何 Issues/Pull Requests！只需要将你的更改提交到此项目 ：)

 对于新功能的添加，请先通过 Issue 讨论。

-## 🔭 展望
-
-1. 更强大的 Agent 系统。
-2. 打造插件工作流平台。
-
-## ✨ Support
+## 🌟 支持

 - Star 这个项目！
 - 在[爱发电](https://afdian.com/a/soulter)支持我！
 - 在[微信](https://drive.soulter.top/f/pYfA/d903f4fa49a496fda3f16d2be9e023b5.png)支持我~

-
-
 ## ✨ Demo

+> [!NOTE]
+> 代码执行器的文件输入/输出目前仅测试了 Napcat(QQ), Lagrange(QQ)
+
 <div align='center'>

+<img src="https://github.com/user-attachments/assets/4ee688d9-467d-45c8-99d6-368f9a8a92d8" width="600">
+
+_✨基于 Docker 的沙箱化代码执行器（Beta 测试中）✨_
+
 <img src="https://github.com/user-attachments/assets/0378f407-6079-4f64-ae4c-e97ab20611d2" height=500>

 _✨ 多模态、网页搜索、长文本转图片（可配置） ✨_
@@ -111,6 +137,26 @@ _✨ 内置 Web Chat，在线与机器人交互 ✨_

 </div>

+## ⭐ Star History
+
+> [!TIP] 
+> 如果本项目对您的生活 / 工作产生了帮助，或者您关注本项目的未来发展，请给项目 Star，这是我维护这个开源项目的动力 <3
+
+<div align="center">
+    
+[![Star History Chart](https://api.star-history.com/svg?repos=soulter/astrbot&type=Date)](https://star-history.com/#soulter/astrbot&Date)
+
+</div>
+
+## Sponsors
+
+[<img src="https://api.gitsponsors.com/api/badge/img?id=575865240" height="20">](https://api.gitsponsors.com/api/badge/link?p=XEpbdGxlitw/RbcwiTX93UMzNK/jgDYC8NiSzamIPMoKvG2lBFmyXhSS/b0hFoWlBBMX2L5X5CxTDsUdyvcIEHTOfnkXz47UNOZvMwyt5CzbYpq0SEzsSV1OJF1cCo90qC/ZyYKYOWedal3MhZ3ikw==)
+
+## Disclaimer
+
+1. The project is protected under the `AGPL-v3` opensource license.
+2. The deployment of WeChat (personal account) utilizes [Gewechat](https://github.com/Devo919/Gewechat) service. AstrBot only guarantees connectivity with Gewechat and recommends using a WeChat account that is not frequently used. In the event of account risk control, the author of this project shall not bear any responsibility.
+3. Please ensure compliance with local laws and regulations when using this project.

 <!-- ## ✨ ATRI [Beta 测试]

@@ -122,3 +168,6 @@ _✨ 内置 Web Chat，在线与机器人交互 ✨_
 4. TTS
    -->

+
+_私は、高性能ですから!_
+
--- a/astrbot/api/init.py
+++ b/astrbot/api/init.py
@@ -1,6 +1,5 @@
 from astrbot.core.config.astrbot_config import AstrBotConfig
 from astrbot import logger
-from astrbot.core.utils.personality import personalities
 from astrbot.core import html_renderer
 from astrbot.core import sp
 from astrbot.core.star.register import register_llm_tool as llm_tool
@@ -8,7 +7,6 @@ from astrbot.core.star.register import register_llm_tool as llm_tool
 __all__ = [
    "AstrBotConfig",
    "logger",
-    "personalities",
    "html_renderer",
    "llm_tool",
    "sp"
--- a/astrbot/api/all.py
+++ b/astrbot/api/all.py
@@ -1,7 +1,6 @@

 from astrbot.core.config.astrbot_config import AstrBotConfig
 from astrbot import logger
-from astrbot.core.utils.personality import personalities
 from astrbot.core import html_renderer
 from astrbot.core.star.register import register_llm_tool as llm_tool

--- a/astrbot/api/event/filter/init.py
+++ b/astrbot/api/event/filter/init.py
@@ -6,6 +6,7 @@ from astrbot.core.star.register import (
    register_platform_adapter_type as platform_adapter_type,
    register_permission_type as permission_type,
    register_on_llm_request as on_llm_request,
+    register_on_llm_response as on_llm_response,
    register_llm_tool as llm_tool,
    register_on_decorating_result as on_decorating_result,
    register_after_message_sent as after_message_sent
@@ -31,5 +32,6 @@ __all__ = [
    'on_llm_request',
    'llm_tool',
    'on_decorating_result',
-    'after_message_sent'
+    'after_message_sent',
+    'on_llm_response'
 ]
--- a/astrbot/api/platform/init.py
+++ b/astrbot/api/platform/init.py
@@ -2,4 +2,5 @@ from astrbot.core.platform import (
    AstrMessageEvent, Platform, AstrBotMessage, MessageMember, MessageType, PlatformMetadata
 )

-from astrbot.core.platform.register import register_platform_adapter
+from astrbot.core.platform.register import register_platform_adapter
+from astrbot.core.message.components import *
--- a/astrbot/api/provider/init.py
+++ b/astrbot/api/provider/init.py
@@ -1,2 +1,2 @@
 from astrbot.core.provider import Provider, STTProvider, Personality
-from astrbot.core.provider.entites import ProviderRequest, ProviderType, ProviderMetaData
+from astrbot.core.provider.entites import ProviderRequest, ProviderType, ProviderMetaData, LLMResponse
--- a/astrbot/core/init.py
+++ b/astrbot/core/init.py
@@ -11,7 +11,8 @@ from astrbot.core.config import AstrBotConfig
 os.makedirs("data", exist_ok=True)

 astrbot_config = AstrBotConfig()
-html_renderer = HtmlRenderer()
+t2i_base_url = astrbot_config.get('t2i_endpoint', 'https://t2i.soulter.top/text2img')
+html_renderer = HtmlRenderer(t2i_base_url)
 logger = LogManager.GetLogger(log_name='astrbot')

 if os.environ.get('TESTING', ""):
--- a/astrbot/core/config/astrbot_config.py
+++ b/astrbot/core/config/astrbot_config.py
@@ -2,7 +2,7 @@ import os
 import json
 import logging
 import enum
-from .default import DEFAULT_CONFIG
+from .default import DEFAULT_CONFIG, DEFAULT_VALUE_MAP
 from typing import Dict

 ASTRBOT_CONFIG_PATH = "data/cmd_config.json"
@@ -13,29 +13,72 @@ class RateLimitStrategy(enum.Enum):
    DISCARD = "discard"

 class AstrBotConfig(dict):
-    '''从配置文件中加载的配置，支持直接通过点号操作符访问配置项'''
+    '''从配置文件中加载的配置，支持直接通过点号操作符访问根配置项。
    
-    def __init__(self):
+    - 初始化时会将传入的 default_config 与配置文件进行比对，如果配置文件中缺少配置项则会自动插入默认值并进行一次写入操作。会递归检查配置项。
+    - 如果配置文件路径对应的文件不存在，则会自动创建并写入默认配置。
+    - 如果传入了 schema，将会通过 schema 解析出 default_config，此时传入的 default_config 会被忽略。
+    '''
+    
+    def __init__(
+        self, 
+        config_path: str = ASTRBOT_CONFIG_PATH, 
+        default_config: dict = DEFAULT_CONFIG,
+        schema: dict = None
+    ):
        super().__init__()
+        
+        # 调用父类的 __setattr__ 方法，防止保存配置时将此属性写入配置文件
+        object.__setattr__(self, 'config_path', config_path)
+        object.__setattr__(self, 'default_config', default_config)
+        object.__setattr__(self, 'schema', schema)
+        
+        if schema:
+            default_config = self._config_schema_to_default_config(schema)
+        
        if not self.check_exist():
            '''不存在时载入默认配置'''
-            with open(ASTRBOT_CONFIG_PATH, "w", encoding="utf-8-sig") as f:
-                json.dump(DEFAULT_CONFIG, f, indent=4, ensure_ascii=False)
+            with open(config_path, "w", encoding="utf-8-sig") as f:
+                json.dump(default_config, f, indent=4, ensure_ascii=False)

-        with open(ASTRBOT_CONFIG_PATH, "r", encoding="utf-8-sig") as f:
+        with open(config_path, "r", encoding="utf-8-sig") as f:
            conf_str = f.read()
            if conf_str.startswith(u'/ufeff'): # remove BOM
                conf_str = conf_str.encode('utf8')[3:].decode('utf8')
            conf = json.loads(conf_str)
        
        # 检查配置完整性，并插入
-        has_new = self.check_config_integrity(DEFAULT_CONFIG, conf)
+        has_new = self.check_config_integrity(default_config, conf)
        self.update(conf)
        if has_new:
            self.save_config()
            
        self.update(conf)
-            
+
+    def _config_schema_to_default_config(self, schema: dict) -> dict:
+        '''将 Schema 转换成 Config'''
+        conf = {}
+        
+        def _parse_schema(schema: dict, conf: dict):
+            for k, v in schema.items():
+                if v['type'] not in DEFAULT_VALUE_MAP:
+                    raise TypeError(f"不受支持的配置类型 {v['type']}。支持的类型有：{DEFAULT_VALUE_MAP.keys()}")
+                if 'default' in v:
+                    default = v['default']
+                else:
+                    default = DEFAULT_VALUE_MAP[v['type']]
+                
+                if v['type'] == 'object':
+                    conf[k] = {}
+                    _parse_schema(v['items'], conf[k])
+                else:
+                    conf[k] = default
+                    
+        _parse_schema(schema, conf)
+
+        return conf
+
+
    def check_config_integrity(self, refer_conf: Dict, conf: Dict, path=""):
        '''检查配置完整性，如果有新的配置项则返回 True'''
        has_new = False
@@ -61,7 +104,7 @@ class AstrBotConfig(dict):
        '''
        if replace_config:
            self.update(replace_config)
-        with open(ASTRBOT_CONFIG_PATH, "w", encoding="utf-8-sig") as f:
+        with open(self.config_path, "w", encoding="utf-8-sig") as f:
            json.dump(self, f, indent=2, ensure_ascii=False)
            
    def __getattr__(self, item):
@@ -81,4 +124,4 @@ class AstrBotConfig(dict):
        self[key] = value

    def check_exist(self) -> bool:
-        return os.path.exists(ASTRBOT_CONFIG_PATH)
+        return os.path.exists(self.config_path)
--- a/astrbot/core/config/default.py
+++ b/astrbot/core/config/default.py
@@ -2,7 +2,7 @@
 如需修改配置，请在 `data/cmd_config.json` 中修改或者在管理面板中可视化修改。
 """

-VERSION = "3.4.5"
+VERSION = "3.4.22"
 DB_PATH = "data/data_v3.db"

 # 默认配置
@@ -22,20 +22,48 @@ DEFAULT_CONFIG = {
        "id_whitelist_log": True,
        "wl_ignore_admin_on_group": True,
        "wl_ignore_admin_on_friend": True,
+        "reply_with_mention": False,
+        "reply_with_quote": False,
+        "path_mapping": [],
+        "segmented_reply": {
+            "enable": False,
+            "only_llm_result": True,
+            "interval": "1.5,3.5",
+            "regex": ".*?[。？！~…]+|.+$"
+        },
+        "no_permission_reply": True,
    },
    "provider": [],
    "provider_settings": {
        "enable": True,
        "wake_prefix": "",
        "web_search": False,
+        "web_search_link": False,
        "identifier": False,
        "datetime_system_prompt": True,
-        "default_personality": "如果用户寻求帮助或者打招呼，请告诉他可以用 /help 查看 AstrBot 帮助。",
+        "default_personality": "default",
        "prompt_prefix": "",
    },
    "provider_stt_settings": {
-      "enable": False,
-      "provider_id": "",  
+        "enable": False,
+        "provider_id": "",
+    },
+    "provider_tts_settings": {
+        "enable": False,
+        "provider_id": "",
+    },
+    "provider_ltm_settings": {
+        "group_icl_enable": False,
+        "group_message_max_cnt": 300,
+        "image_caption": False,
+        "image_caption_provider_id": "",
+        "image_caption_prompt": "Please describe the image using Chinese.",
+        "active_reply": {
+            "enable": False,
+            "method": "possibility_reply",
+            "possibility_reply": 0.1,
+            "prompt": "",
+        }
    },
    "content_safety": {
        "internal_keywords": {"enable": True, "extra_keywords": []},
@@ -43,6 +71,7 @@ DEFAULT_CONFIG = {
    },
    "admins_id": [],
    "t2i": False,
+    "t2i_word_threshold": 150,
    "http_proxy": "",
    "dashboard": {
        "enable": True,
@@ -56,6 +85,7 @@ DEFAULT_CONFIG = {
    "pip_install_arg": "",
    "plugin_repo_mirror": "",
    "knowledge_db": {},
+    "persona": [],
 }


@@ -81,10 +111,18 @@ CONFIG_METADATA_2 = {
                        "id": "default",
                        "type": "aiocqhttp",
                        "enable": False,
-                        "ws_reverse_host": "",
+                        "ws_reverse_host": "0.0.0.0",
                        "ws_reverse_port": 6199,
                    },
-                    "vchat(微信)": {"id": "default", "type": "vchat", "enable": False},
+                    "gewechat(微信)": {
+                        "id": "gwchat",
+                        "type": "gewechat",
+                        "enable": False,
+                        "base_url": "http://localhost:2531",
+                        "nickname": "soulter",
+                        "host": "这里填写你的局域网IP或者公网服务器IP",
+                        "port": 11451,
+                    },
                },
                "items": {
                    "id": {
@@ -158,6 +196,36 @@ CONFIG_METADATA_2 = {
                            },
                        },
                    },
+                    "no_permission_reply": {
+                        "description": "无权限回复",
+                        "type": "bool",
+                        "hint": "启用后，当用户没有权限执行某个操作时，机器人会回复一条消息。",
+                    },
+                    "segmented_reply": {
+                        "description": "分段回复",
+                        "type": "object",
+                        "items": {
+                            "enable": {
+                                "description": "启用分段回复",
+                                "type": "bool",
+                            },
+                            "only_llm_result": {
+                                "description": "仅对 LLM 结果分段",
+                                "type": "bool",
+                            },
+                            "interval": {
+                                "description": "随机间隔时间(秒)",
+                                "type": "string",
+                                "hint": "每一段回复的间隔时间，格式为 `最小时间,最大时间`。如 `0.75,2.5`",
+                            },
+                            "regex": {
+                                "description": "正则表达式",
+                                "type": "string",
+                                "obvious_hint": True,
+                                "hint": "用于分隔一段消息。默认情况下会根据句号、问号等标点符号分隔。re.findall(r'<regex>', text)",
+                            },
+                        },
+                    },
                    "reply_prefix": {
                        "description": "回复前缀",
                        "type": "string",
@@ -170,13 +238,14 @@ CONFIG_METADATA_2 = {
                    },
                    "enable_id_white_list": {
                        "description": "启用 ID 白名单",
-                        "type": "bool"
+                        "type": "bool",
                    },
                    "id_whitelist": {
                        "description": "ID 白名单",
                        "type": "list",
-                        "items": {"type": "int"},
-                        "hint": "填写后，将只处理所填写的 ID 发来的消息事件。为空时表示不启用白名单过滤。可以使用 /myid 指令获取在某个平台上的会话 ID。也可在 AstrBot 日志内获取会话 ID，当一条消息没通过白名单时，会输出 INFO 级别的日志。会话 ID 类似 aiocqhttp:GroupMessage:547540978",
+                        "items": {"type": "string"},
+                        "obvious_hint": True,
+                        "hint": "AstrBot 只处理所填写的 ID 发来的消息事件。为空时不启用白名单过滤。可以使用 /sid 指令获取在某个平台上的会话 ID。也可在 AstrBot 日志内获取会话 ID，当一条消息没通过白名单时，会输出 INFO 级别的日志。会话 ID 类似 aiocqhttp:GroupMessage:547540978。管理员可使用 /wl 添加白名单",
                    },
                    "id_whitelist_log": {
                        "description": "打印白名单日志",
@@ -191,6 +260,23 @@ CONFIG_METADATA_2 = {
                        "description": "管理员私聊消息无视 ID 白名单",
                        "type": "bool",
                    },
+                    "reply_with_mention": {
+                        "description": "回复时 @ 发送者",
+                        "type": "bool",
+                        "hint": "启用后，机器人回复消息时会 @ 发送者。实际效果以具体的平台适配器为准。",
+                    },
+                    "reply_with_quote": {
+                        "description": "回复时引用消息",
+                        "type": "bool",
+                        "hint": "启用后，机器人回复消息时会引用原消息。实际效果以具体的平台适配器为准。",
+                    },
+                    "path_mapping": {
+                        "description": "路径映射",
+                        "type": "list",
+                        "items": {"type": "string"},
+                        "obvious_hint": True,
+                        "hint": "此功能解决由于文件系统不一致导致路径不存在的问题。格式为 <原路径>:<映射路径>。如 `/app/.config/QQ:/var/lib/docker/volumes/xxxx/_data`。这样，当消息平台下发的事件中图片和语音路径以 `/app/.config/QQ` 开头时，开头被替换为 `/var/lib/docker/volumes/xxxx/_data`。这在 AstrBot 或者平台协议端使用 Docker 部署时特别有用。",
+                    }
                },
            },
            "content_safety": {
@@ -242,11 +328,24 @@ CONFIG_METADATA_2 = {
                "type": "list",
                "config_template": {
                    "openai": {
-                        "id": "default",
+                        "id": "openai",
                        "type": "openai_chat_completion",
                        "enable": True,
                        "key": [],
+                        "api_base": "https://api.openai.com/v1",
+                        "timeout": 120,
+                        "model_config": {
+                            "model": "gpt-4o-mini",
+                        },
+                    },
+                    "azure_openai": {
+                        "id": "azure",
+                        "type": "openai_chat_completion",
+                        "enable": True,
+                        "api_version": "2024-05-01-preview",
+                        "key": [],
                        "api_base": "",
+                        "timeout": 120,
                        "model_config": {
                            "model": "gpt-4o-mini",
                        },
@@ -256,7 +355,7 @@ CONFIG_METADATA_2 = {
                        "type": "openai_chat_completion",
                        "enable": True,
                        "key": ["ollama"],  # ollama 的 key 默认是 ollama
-                        "api_base": "http://localhost:11434",
+                        "api_base": "http://localhost:11434/v1",
                        "model_config": {
                            "model": "llama3.1-8b",
                        },
@@ -267,6 +366,7 @@ CONFIG_METADATA_2 = {
                        "enable": True,
                        "key": [],
                        "api_base": "https://generativelanguage.googleapis.com/v1beta/openai/",
+                        "timeout": 120,
                        "model_config": {
                            "model": "gemini-1.5-flash",
                        },
@@ -277,6 +377,7 @@ CONFIG_METADATA_2 = {
                        "enable": True,
                        "key": [],
                        "api_base": "https://generativelanguage.googleapis.com/",
+                        "timeout": 120,
                        "model_config": {
                            "model": "gemini-1.5-flash",
                        },
@@ -287,6 +388,7 @@ CONFIG_METADATA_2 = {
                        "enable": True,
                        "key": [],
                        "api_base": "https://api.deepseek.com/v1",
+                        "timeout": 120,
                        "model_config": {
                            "model": "deepseek-chat",
                        },
@@ -296,11 +398,23 @@ CONFIG_METADATA_2 = {
                        "type": "zhipu_chat_completion",
                        "enable": True,
                        "key": [],
+                        "timeout": 120,
                        "api_base": "https://open.bigmodel.cn/api/paas/v4/",
                        "model_config": {
                            "model": "glm-4-flash",
                        },
                    },
+                    "硅基流动": {
+                        "id": "siliconflow",
+                        "type": "openai_chat_completion",
+                        "enable": True,
+                        "key": [],
+                        "timeout": 120,
+                        "api_base": "https://api.siliconflow.cn/v1",
+                        "model_config": {
+                            "model": "deepseek-ai/DeepSeek-V3",
+                        },
+                    },
                    "llmtuner": {
                        "id": "llmtuner_default",
                        "type": "llm_tuner",
@@ -334,14 +448,35 @@ CONFIG_METADATA_2 = {
                        "id": "whisper",
                        "type": "openai_whisper_selfhost",
                        "model": "tiny",
-                    }
+                    },
+                    "openai_tts(API)": {
+                        "id": "openai_tts",
+                        "type": "openai_tts_api",
+                        "enable": False,
+                        "api_key": "",
+                        "api_base": "",
+                        "model": "tts-1",
+                        "openai-tts-voice": "alloy",
+                        "timeout": "20",
+                    },
                },
                "items": {
+                    "timeout": {
+                        "description": "超时时间",
+                        "type": "int",
+                        "hint": "超时时间，单位为秒。",
+                    },
+                    "openai-tts-voice": {
+                        "description": "voice",
+                        "type": "string",
+                        "obvious_hint": True,
+                        "hint": "OpenAI TTS 的声音。OpenAI 默认支持：'alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'",
+                    },
                    "whisper_hint": {
                        "description": "本地部署 Whisper 模型须知",
                        "type": "string",
                        "hint": "启用前请 pip 安装 openai-whisper 库（N卡用户大约下载 2GB，主要是 torch 和 cuda，CPU 用户大约下载 1 GB），并且安装 ffmpeg。否则将无法正常转文字。",
-                        "obvious_hint": True
+                        "obvious_hint": True,
                    },
                    "id": {
                        "description": "ID",
@@ -367,7 +502,8 @@ CONFIG_METADATA_2 = {
                    "api_base": {
                        "description": "API Base URL",
                        "type": "string",
-                        "hint": "API Base URL 请在在模型提供商处获得。支持 Ollama 开放的 API 地址。如果您确认填写正确但是使用时出现了 404 异常，可以尝试在地址末尾加上 `/v1`。",
+                        "hint": "API Base URL 请在在模型提供商处获得。如出现 404 报错，尝试在地址末尾加上 /v1",
+                        "obvious_hint": True,
                    },
                    "base_model_path": {
                        "description": "基座模型路径",
@@ -431,7 +567,7 @@ CONFIG_METADATA_2 = {
                        "description": "Dify Workflow 输出变量名",
                        "type": "string",
                        "hint": "Dify Workflow 输出变量名。当应用类型为 workflow 时才使用。默认为 astrbot_wf_output。",
-                    }
+                    },
                },
            },
            "provider_settings": {
@@ -442,7 +578,7 @@ CONFIG_METADATA_2 = {
                        "description": "启用大语言模型聊天",
                        "type": "bool",
                        "hint": "如需切换大语言模型提供商，请使用 `/provider` 命令。",
-                        "obvious_hint": True
+                        "obvious_hint": True,
                    },
                    "wake_prefix": {
                        "description": "LLM 聊天额外唤醒前缀",
@@ -452,22 +588,31 @@ CONFIG_METADATA_2 = {
                    "web_search": {
                        "description": "启用网页搜索",
                        "type": "bool",
-                        "hint": "能访问 Google 时效果最佳。如果 Google 访问失败，程序会依次访问 Bing, Sogo 搜索引擎。",
+                        "obvious_hint": True,
+                        "hint": "能访问 Google 时效果最佳（国内需要在 `其他配置` 开启 HTTP 代理）。如果 Google 访问失败，程序会依次访问 Bing, Sogo 搜索引擎。",
+                    },
+                    "web_search_link": {
+                        "description": "网页搜索引用链接",
+                        "type": "bool",
+                        "obvious_hint": True,
+                        "hint": "开启后，将会传入网页搜索结果的链接给模型，并引导模型输出引用链接。",
                    },
                    "identifier": {
                        "description": "启动识别群员",
                        "type": "bool",
+                        "obvious_hint": True,
                        "hint": "在 Prompt 前加上群成员的名字以让模型更好地了解群聊状态。启用将略微增加 token 开销。",
                    },
                    "datetime_system_prompt": {
                        "description": "启用日期时间系统提示",
                        "type": "bool",
+                        "obvious_hint": True,
                        "hint": "启用后，会在系统提示词中加上当前机器的日期时间。",
                    },
                    "default_personality": {
-                        "description": "默认人格",
+                        "description": "默认采用的人格情景的名称",
                        "type": "string",
-                        "hint": "默认人格（情境设置/System Prompt）文本。",
+                        "hint": "",
                    },
                    "prompt_prefix": {
                        "description": "Prompt 前缀文本",
@@ -476,6 +621,46 @@ CONFIG_METADATA_2 = {
                    },
                },
            },
+            "persona": {
+                "description": "人格情景设置",
+                "type": "list",
+                "config_template": {
+                    "新人格情景": {
+                        "name": "",
+                        "prompt": "",
+                        "begin_dialogs": [],
+                        "mood_imitation_dialogs": [],
+                    }
+                },
+                "tmpl_display_title": "name",
+                "items": {
+                    "name": {
+                        "description": "人格名称",
+                        "type": "string",
+                        "hint": "人格名称，用于在多个人格中区分。使用 /persona 指令可切换人格。在 大语言模型设置 处可以设置默认人格。",
+                        "obvious_hint": True,
+                    },
+                    "prompt": {
+                        "description": "设定(系统提示词)",
+                        "type": "text",
+                        "hint": "填写人格的身份背景、性格特征、兴趣爱好、个人经历、口头禅等。",
+                    },
+                    "begin_dialogs": {
+                        "description": "预设对话",
+                        "type": "list",
+                        "items": {"type": "string"},
+                        "hint": "可选。在每个对话前会插入这些预设对话。对话需要成对(用户和助手)，输入完一个角色的内容之后按【回车】。需要偶数个对话",
+                        "obvious_hint": True,
+                    },
+                    "mood_imitation_dialogs": {
+                        "description": "对话风格模仿",
+                        "type": "list",
+                        "items": {"type": "string"},
+                        "hint": "旨在让模型尽可能模仿学习到所填写的对话的语气风格。格式和 `预设对话` 一致。对话需要成对(用户和助手)，输入完一个角色的内容之后按【回车】。需要偶数个对话",
+                        "obvious_hint": True,
+                    },
+                },
+            },
            "provider_stt_settings": {
                "description": "语音转文本(STT)",
                "type": "object",
@@ -484,7 +669,7 @@ CONFIG_METADATA_2 = {
                        "description": "启用语音转文本(STT)",
                        "type": "bool",
                        "hint": "启用前请在 服务提供商配置 处创建支持 语音转文本任务 的提供商。如 whisper。",
-                        "obvious_hint": True
+                        "obvious_hint": True,
                    },
                    "provider_id": {
                        "description": "提供商 ID，不填则默认第一个STT提供商",
@@ -493,6 +678,87 @@ CONFIG_METADATA_2 = {
                    },
                },
            },
+            "provider_tts_settings": {
+                "description": "文本转语音(TTS)",
+                "type": "object",
+                "items": {
+                    "enable": {
+                        "description": "启用文本转语音(TTS)",
+                        "type": "bool",
+                        "hint": "启用前请在 服务提供商配置 处创建支持 语音转文本任务 的提供商。如 openai_tts。",
+                        "obvious_hint": True,
+                    },
+                    "provider_id": {
+                        "description": "提供商 ID，不填则默认第一个TTS提供商",
+                        "type": "string",
+                        "hint": "文本转语音提供商 ID。如果不填写将使用载入的第一个提供商。",
+                    },
+                },
+            },
+            "provider_ltm_settings": {
+                "description": "聊天记忆增强(Beta)",
+                "type": "object",
+                "items": {
+                    "group_icl_enable": {
+                        "description": "群聊内记录各群员对话",
+                        "type": "bool",
+                        "obvious_hint": True,
+                        "hint": "启用后，会记录群聊内各群员的对话。使用 /reset 命令清除记录。推荐使用 gpt-4o-mini 模型。",
+                    },
+                    "group_message_max_cnt": {
+                        "description": "群聊消息最大数量",
+                        "type": "int",
+                        "obvious_hint": True,
+                        "hint": "群聊消息最大数量。超过此数量后，会自动清除旧消息。",
+                    },
+                    "image_caption": {
+                        "description": "启用图像转述(需要模型支持)",
+                        "type": "bool",
+                        "obvious_hint": True,
+                        "hint": "启用后，当接收到图片消息时，会使用模型先将图片转述为文字再进行后续处理。推荐使用 gpt-4o-mini 模型。",
+                    },
+                    "image_caption_provider_id": {
+                        "description": "图像转述提供商 ID",
+                        "type": "string",
+                        "obvious_hint": True,
+                        "hint": "可选。图像转述提供商 ID。如为空将选择聊天使用的提供商。",
+                    },
+                    "image_caption_prompt": {
+                        "description": "图像转述提示词",
+                        "type": "string"
+                    },
+                    "active_reply": {
+                        "description": "主动回复",
+                        "type": "object",
+                        "items": {
+                            "enable": {
+                                "description": "启用主动回复",
+                                "type": "bool",
+                                "obvious_hint": True,
+                                "hint": "启用后，会根据触发概率主动回复群聊内的对话。QQ官方API(qq_official)不可用",
+                            },
+                            "method": {
+                                "description": "回复方法",
+                                "type": "string",
+                                "options": ["possibility_reply"],
+                                "hint": "回复方法。possibility_reply 为根据概率回复",
+                            },
+                            "possibility_reply": {
+                                "description": "回复概率",
+                                "type": "float",
+                                "obvious_hint": True,
+                                "hint": "回复概率。当回复方法为 possibility_reply 时有效。当概率 >= 1 时，每条消息都会回复。",
+                            },
+                            "prompt": {
+                                "description": "提示词",
+                                "type": "string",
+                                "obvious_hint": True,
+                                "hint": "提示词。当提示词为空时，如果触发回复，则向 LLM 请求的是触发的消息的内容；否则是提示词。此项可以和定时回复（暂未实现）配合使用。",
+                            },
+                        },
+                    }
+                },
+            },
        },
    },
    "misc_config_group": {
@@ -502,18 +768,24 @@ CONFIG_METADATA_2 = {
                "description": "机器人唤醒前缀",
                "type": "list",
                "items": {"type": "string"},
-                "hint": "在不 @ 机器人的情况下，可以通过外加消息前缀来唤醒机器人。",
+                "obvious_hint": True,
+                "hint": "在不 @ 机器人的情况下，可以通过外加消息前缀来唤醒机器人。更改此配置将影响整个 Bot 的功能唤醒，包括所有指令。如果您不保留 `/`，则内置指令（help等）将需要通过您的唤醒前缀来触发。",
            },
            "t2i": {
                "description": "文本转图像",
                "type": "bool",
                "hint": "启用后，超出一定长度的文本将会通过 AstrBot API 渲染成 Markdown 图片发送。可以缓解审核和消息过长刷屏的问题，并提高 Markdown 文本的可读性。",
            },
+            "t2i_word_threshold": {
+                "description": "文本转图像字数阈值",
+                "type": "int",
+                "hint": "超出此字符长度的文本将会被转换成图片。字数不能低于 50。",
+            },
            "admins_id": {
                "description": "管理员 ID",
                "type": "list",
-                "items": {"type": "int"},
-                "hint": "管理员 ID 列表，管理员可以使用一些特权命令，如 `update`, `plugin` 等。ID 可以通过 `/myid` 指令获得。回车添加，可添加多个。",
+                "items": {"type": "string"},
+                "hint": "管理员 ID 列表，管理员可以使用一些特权命令，如 `update`, `plugin` 等。ID 可以通过 `/sid` 指令获得。回车添加，可添加多个。",
            },
            "http_proxy": {
                "description": "HTTP 代理",
--- a/astrbot/core/conversation_mgr.py
+++ b/astrbot/core/conversation_mgr.py
@@ -0,0 +1,118 @@
+import uuid
+import json
+import asyncio
+from astrbot.core import sp
+from typing import Dict, List
+from astrbot.core.db import BaseDatabase
+from astrbot.core.db.po import Conversation
+
+class ConversationManager():
+    '''负责管理会话与 LLM 的对话，某个会话当前正在用哪个对话。'''
+    def __init__(self, db_helper: BaseDatabase):
+        self.session_conversations: Dict[str, str] = sp.get("session_conversation", {})
+        self.db = db_helper
+        self.save_interval = 60  # 每 60 秒保存一次
+        self._start_periodic_save()
+                
+    def _start_periodic_save(self):
+        asyncio.create_task(self._periodic_save())
+
+    async def _periodic_save(self):
+        while True:
+            await asyncio.sleep(self.save_interval)
+            self._save_to_storage()
+
+    def _save_to_storage(self):
+        sp.put("session_conversation", self.session_conversations)
+
+    async def new_conversation(self, unified_msg_origin: str) -> str:
+        '''新建对话，并将当前会话的对话转移到新对话'''
+        conversation_id = str(uuid.uuid4())
+        self.db.new_conversation(
+            user_id=unified_msg_origin,
+            cid=conversation_id
+        )
+        self.session_conversations[unified_msg_origin] = conversation_id
+        sp.put("session_conversation", self.session_conversations)
+        return conversation_id
+    
+    async def switch_conversation(self, unified_msg_origin: str, conversation_id: str):
+        '''切换会话的对话'''
+        self.session_conversations[unified_msg_origin] = conversation_id
+        sp.put("session_conversation", self.session_conversations)
+        
+    async def delete_conversation(self, unified_msg_origin: str, conversation_id: str=None):
+        '''删除会话的对话，当 conversation_id 为 None 时删除会话当前的对话'''
+        conversation_id = self.session_conversations.get(unified_msg_origin)
+        if conversation_id:
+            self.db.delete_conversation(
+                user_id=unified_msg_origin,
+                cid=conversation_id
+            )
+            del self.session_conversations[unified_msg_origin]
+            
+    async def get_curr_conversation_id(self, unified_msg_origin: str) -> str:
+        '''获取会话当前的对话 ID'''
+        return self.session_conversations.get(unified_msg_origin, None)
+    
+    async def get_conversation(self, unified_msg_origin: str, conversation_id: str) -> Conversation:
+        '''获取会话的对话'''
+        return self.db.get_conversation_by_user_id(unified_msg_origin, conversation_id)
+    
+    async def get_conversations(self, unified_msg_origin: str) -> List[Conversation]:
+        '''获取会话的所有对话'''
+        return self.db.get_conversations(unified_msg_origin)
+    
+    async def update_conversation(self, unified_msg_origin: str, conversation_id: str, history: List[Dict]):
+        '''更新会话的对话'''
+        if conversation_id:
+            self.db.update_conversation(
+                user_id=unified_msg_origin,
+                cid=conversation_id,
+                history=json.dumps(history)
+            )
+            
+    async def update_conversation_title(self, unified_msg_origin: str, title: str):
+        '''更新会话的对话标题'''
+        conversation_id = self.session_conversations.get(unified_msg_origin)
+        if conversation_id:
+            self.db.update_conversation_title(
+                user_id=unified_msg_origin,
+                cid=conversation_id,
+                title=title
+            )
+    
+    async def update_conversation_persona_id(self, unified_msg_origin: str, persona_id: str):
+        '''更新会话的对话 Persona ID'''
+        conversation_id = self.session_conversations.get(unified_msg_origin)
+        if conversation_id:
+            self.db.update_conversation_persona_id(
+                user_id=unified_msg_origin,
+                cid=conversation_id,
+                persona_id=persona_id
+            )
+            
+    async def get_human_readable_context(self, unified_msg_origin, conversation_id, page=1, page_size=10):
+        conversation = await self.get_conversation(unified_msg_origin, conversation_id)
+        history = json.loads(conversation.history)
+
+        contexts = []
+        temp_contexts = []
+        for record in history:
+            if record['role'] == "user":
+                temp_contexts.append(f"User: {record['content']}")
+            elif record['role'] == "assistant":
+                temp_contexts.append(f"Assistant: {record['content']}")
+                contexts.insert(0, temp_contexts)
+                temp_contexts = []
+
+        # 展平 contexts 列表
+        contexts = [item for sublist in contexts for item in sublist]
+
+        # 计算分页
+        paged_contexts = contexts[(page-1)*page_size:page*page_size]
+        total_pages = len(contexts) // page_size
+        if len(contexts) % page_size != 0:
+            total_pages += 1
+        
+        return paged_contexts, total_pages
--- a/astrbot/core/core_lifecycle.py
+++ b/astrbot/core/core_lifecycle.py
@@ -1,3 +1,4 @@
+import traceback
 import asyncio
 import time
 import threading
@@ -6,7 +7,6 @@ from .event_bus import EventBus
 from . import astrbot_config
 from asyncio import Queue
 from typing import List
-from astrbot.core.config.astrbot_config import AstrBotConfig
 from astrbot.core.pipeline.scheduler import PipelineScheduler, PipelineContext
 from astrbot.core.star import PluginManager
 from astrbot.core.platform.manager import PlatformManager
@@ -18,16 +18,15 @@ from astrbot.core.updator import AstrBotUpdator
 from astrbot.core import logger
 from astrbot.core.config.default import VERSION
 from astrbot.core.rag.knowledge_db_mgr import KnowledgeDBManager
-
+from astrbot.core.conversation_mgr import ConversationManager
 class AstrBotCoreLifecycle:
    def __init__(self, log_broker: LogBroker, db: BaseDatabase):
        self.log_broker = log_broker
        self.astrbot_config = astrbot_config
        self.db = db
        
-        if self.astrbot_config['http_proxy']:
-            os.environ['https_proxy'] = self.astrbot_config['http_proxy']
-            os.environ['http_proxy'] = self.astrbot_config['http_proxy']
+        os.environ['https_proxy'] = self.astrbot_config['http_proxy']
+        os.environ['http_proxy'] = self.astrbot_config['http_proxy']
    
    async def initialize(self):
        logger.info("AstrBot v"+ VERSION)
@@ -44,12 +43,15 @@ class AstrBotCoreLifecycle:
        
        self.knowledge_db_manager = KnowledgeDBManager(self.astrbot_config)
        
+        self.conversation_manager = ConversationManager(self.db)
+        
        self.star_context = Context(
            self.event_queue, 
            self.astrbot_config, 
            self.db,
            self.provider_manager,
            self.platform_manager,
+            self.conversation_manager,
            self.knowledge_db_manager
        )
        self.plugin_manager = PluginManager(self.star_context, self.astrbot_config)
@@ -81,12 +83,30 @@ class AstrBotCoreLifecycle:
        for task in self.star_context._register_tasks:
            extra_tasks.append(asyncio.create_task(task, name=task.__name__))
        
-        self.curr_tasks = [event_bus_task, *platform_tasks, *extra_tasks]
+        # self.curr_tasks = [event_bus_task, *platform_tasks, *extra_tasks]
+        
+        tasks_ = [event_bus_task, *platform_tasks, *extra_tasks]
+        for task in tasks_:
+            self.curr_tasks.append(asyncio.create_task(self._task_wrapper(task), name=task.get_name()))
+        
        self.start_time = int(time.time())
+        
+    async def _task_wrapper(self, task: asyncio.Task):
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            
+            logger.error(f"------- 任务 {task.get_name()} 发生错误: {e}")
+            for line in traceback.format_exc().split("\n"):
+                logger.error(f"|    {line}")
+            logger.error("-------")
    
    async def start(self):
        self._load()
        logger.info("AstrBot 启动完成。")
+        
        await asyncio.gather(*self.curr_tasks, return_exceptions=True)
        
    async def stop(self):
--- a/astrbot/core/db/init.py
+++ b/astrbot/core/db/init.py
@@ -1,7 +1,7 @@
 import abc
 from dataclasses import dataclass
 from typing import List
-from astrbot.core.db.po import Stats, LLMHistory, ATRIVision, WebChatConversation
+from astrbot.core.db.po import Stats, LLMHistory, ATRIVision, Conversation

@dataclass
 class BaseDatabase(abc.ABC):
@@ -79,25 +79,35 @@ class BaseDatabase(abc.ABC):
        raise NotImplementedError
    
    @abc.abstractmethod
-    def get_webchat_conversation_by_user_id(self, user_id: str, cid: str) -> WebChatConversation:
-        '''通过 user_id 和 cid 获取 WebChatConversation'''
+    def get_conversation_by_user_id(self, user_id: str, cid: str) -> Conversation:
+        '''通过 user_id 和 cid 获取 Conversation'''
        raise NotImplementedError
    
    @abc.abstractmethod
-    def webchat_new_conversation(self, user_id: str, cid: str):
-        '''新建 WebChatConversation'''
+    def new_conversation(self, user_id: str, cid: str):
+        '''新建 Conversation'''
        raise NotImplementedError
    
    @abc.abstractmethod
-    def get_webchat_conversations(self, user_id: str) -> List[WebChatConversation]:
+    def get_conversations(self, user_id: str) -> List[Conversation]:
        raise NotImplementedError

    @abc.abstractmethod
-    def update_webchat_conversation(self, user_id: str, cid: str, history: str):
-        '''更新 WebChatConversation'''
+    def update_conversation(self, user_id: str, cid: str, history: str):
+        '''更新 Conversation'''
        raise NotImplementedError
    
    @abc.abstractmethod
-    def delete_webchat_conversation(self, user_id: str, cid: str):
-        '''删除 WebChatConversation'''
+    def delete_conversation(self, user_id: str, cid: str):
+        '''删除 Conversation'''
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    def update_conversation_title(self, user_id: str, cid: str, title: str):
+        '''更新 Conversation 标题'''
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    def update_conversation_persona_id(self, user_id: str, cid: str, persona_id: str):
+        '''更新 Conversation Persona ID'''
        raise NotImplementedError
--- a/astrbot/core/db/po.py
+++ b/astrbot/core/db/po.py
@@ -33,16 +33,16 @@ class Stats():
    command: List[Command] = field(default_factory=list)
    llm: List[Provider] = field(default_factory=list)
    
-'''LLM 聊天时持久化的信息'''
-
@dataclass
 class LLMHistory():
+    '''LLM 聊天时持久化的信息'''
    provider_type: str
    session_id: str
    content: str
    
@dataclass
 class ATRIVision():
+    '''Deprecated'''
    id: str
    url_or_path: str
    caption: str
@@ -53,13 +53,18 @@ class ATRIVision():
    sender_nickname: str
    timestamp: int = -1
    
-    
-
@dataclass
-class WebChatConversation():
+class Conversation():
+    '''LLM 对话存储
+    
+    对于网页聊天，history 存储了包括指令、回复、图片等在内的所有消息。
+    对于其他平台的聊天，不存储非 LLM 的回复（因为考虑到已经存储在各自的平台上）。
+    '''
    user_id: str
    cid: str
    history: str = ""
+    '''字符串格式的列表。'''
    created_at: int = 0
    updated_at: int = 0
-    
+    title: str = ""
+    persona_id: str = ""
--- a/astrbot/core/db/sqlite.py
+++ b/astrbot/core/db/sqlite.py
@@ -6,7 +6,7 @@ from astrbot.core.db.po import (
    Stats,
    LLMHistory,
    ATRIVision,
-    WebChatConversation
+    Conversation
 )
 from . import BaseDatabase
 from typing import Tuple
@@ -25,6 +25,37 @@ class SQLiteDatabase(BaseDatabase):
        c = self.conn.cursor()
        c.executescript(sql)
        self.conn.commit()
+        
+        # 检查 webchat_conversation 的 title 字段是否存在
+        c.execute(
+            '''
+            PRAGMA table_info(webchat_conversation)
+            '''
+        )
+        res = c.fetchall()
+        has_title = False
+        has_persona_id = False
+        for row in res:
+            if row[1] == "title":
+                has_title = True
+            if row[1] == "persona_id":
+                has_persona_id = True
+        if not has_title:
+            c.execute(
+                '''
+                ALTER TABLE webchat_conversation ADD COLUMN title TEXT;
+                '''
+            )
+            self.conn.commit()
+        if not has_persona_id:
+            c.execute(
+                '''
+                ALTER TABLE webchat_conversation ADD COLUMN persona_id TEXT;
+                '''
+            )
+            self.conn.commit()
+            
+        c.close()
    
    def _get_conn(self, db_path: str) -> sqlite3.Connection:
        conn = sqlite3.connect(self.db_path)
@@ -202,7 +233,7 @@ class SQLiteDatabase(BaseDatabase):
        return Stats(platform, [], [])
    
    
-    def get_webchat_conversation_by_user_id(self, user_id: str, cid: str) -> WebChatConversation:
+    def get_conversation_by_user_id(self, user_id: str, cid: str) -> Conversation:
        try:
            c = self.conn.cursor()
        except sqlite3.ProgrammingError:
@@ -216,9 +247,9 @@ class SQLiteDatabase(BaseDatabase):
        
        res = c.fetchone()
        c.close()
-        return WebChatConversation(*res)
+        return Conversation(*res)
    
-    def webchat_new_conversation(self, user_id: str, cid: str):
+    def new_conversation(self, user_id: str, cid: str):
        history = "[]"
        updated_at = int(time.time())
        created_at = updated_at
@@ -228,7 +259,7 @@ class SQLiteDatabase(BaseDatabase):
            ''', (user_id, cid, history, updated_at, created_at)
        )
        
-    def get_webchat_conversations(self, user_id: str) -> Tuple:
+    def get_conversations(self, user_id: str) -> Tuple:
        try:
            c = self.conn.cursor()
        except sqlite3.ProgrammingError:
@@ -236,7 +267,7 @@ class SQLiteDatabase(BaseDatabase):
            
        c.execute(
            '''
-            SELECT cid, created_at, updated_at FROM webchat_conversation WHERE user_id = ? ORDER BY updated_at DESC
+            SELECT cid, created_at, updated_at, title, persona_id FROM webchat_conversation WHERE user_id = ? ORDER BY updated_at DESC
            ''', (user_id,)
        )
        
@@ -247,24 +278,42 @@ class SQLiteDatabase(BaseDatabase):
            cid = row[0]
            created_at = row[1]
            updated_at = row[2]
-            conversations.append(WebChatConversation("", cid, '[]', created_at, updated_at))
+            title = row[3]
+            persona_id = row[4]
+            conversations.append(Conversation("", cid, '[]', created_at, updated_at, title, persona_id))
        return conversations
    
-    def update_webchat_conversation(self, user_id: str, cid: str, history: str):
+    def update_conversation(self, user_id: str, cid: str, history: str):
+        '''更新对话，并且同时更新时间'''
+        updated_at = int(time.time())
        self._exec_sql(
            '''
-            UPDATE webchat_conversation SET history = ? WHERE user_id = ? AND cid = ?
-            ''', (history, user_id, cid)
+            UPDATE webchat_conversation SET history = ?, updated_at = ? WHERE user_id = ? AND cid = ?
+            ''', (history, updated_at, user_id, cid)
+        )
+        
+        
+    def update_conversation_title(self, user_id: str, cid: str, title: str):
+        self._exec_sql(
+            '''
+            UPDATE webchat_conversation SET title = ? WHERE user_id = ? AND cid = ?
+            ''', (title, user_id, cid)
+        )
+        
+    def update_conversation_persona_id(self, user_id: str, cid: str, persona_id: str):
+        self._exec_sql(
+            '''
+            UPDATE webchat_conversation SET persona_id = ? WHERE user_id = ? AND cid = ?
+            ''', (persona_id, user_id, cid)
        )
    
-    def delete_webchat_conversation(self, user_id: str, cid: str):
+    def delete_conversation(self, user_id: str, cid: str):
        self._exec_sql(
            '''
            DELETE FROM webchat_conversation WHERE user_id = ? AND cid = ?
            ''', (user_id, cid)
        )

-
    def insert_atri_vision_data(self, vision: ATRIVision):
        ts = int(time.time())
        keywords = ",".join(vision.keywords)
--- a/astrbot/core/db/sqlite_init.sql
+++ b/astrbot/core/db/sqlite_init.sql
@@ -42,5 +42,7 @@ CREATE TABLE IF NOT EXISTS webchat_conversation(
    cid TEXT,
    history TEXT,
    created_at INTEGER,
-    updated_at INTEGER
+    updated_at INTEGER,
+    title TEXT,
+    persona_id TEXT
 );
--- a/astrbot/core/message/components.py
+++ b/astrbot/core/message/components.py
@@ -123,7 +123,7 @@ class Record(BaseMessageComponent):
    proxy: T.Optional[bool] = True
    timeout: T.Optional[int] = 0
    # 额外
-    path: T.Optional[str] # 用这个
+    path: T.Optional[str]

    def __init__(self, file: T.Optional[str], **_):
        for k in _.keys():
@@ -306,7 +306,7 @@ class Image(BaseMessageComponent):

 class Reply(BaseMessageComponent):
    type: ComponentType = "Reply"
-    id: int
+    id: T.Union[str, int]
    text: T.Optional[str] = ""
    qq: T.Optional[int] = 0
    time: T.Optional[int] = 0
--- a/astrbot/core/message/message_event_result.py
+++ b/astrbot/core/message/message_event_result.py
@@ -13,12 +13,10 @@ class MessageChain():
    Attributes:
        `chain` (list): 用于顺序存储各个组件。
        `use_t2i_` (bool): 用于标记是否使用文本转图片服务。默认为 None，即跟随用户的设置。当设置为 True 时，将会使用文本转图片服务。
-        `is_split_` (bool): 用于标记是否分条发送消息。默认为 False。启用后，将会依次发送 chain 中的每个 component。
    '''
    
    chain: List[BaseMessageComponent] = field(default_factory=list)
    use_t2i_: Optional[bool] = None # None 为跟随用户设置
-    is_split_: Optional[bool] = False # 是否将消息分条发送。默认为 False。启用后，将会依次发送 chain 中的每个 component。
    
    def message(self, message: str):
        '''添加一条文本消息到消息链 `chain` 中。
@@ -77,16 +75,6 @@ class MessageChain():
        '''
        self.use_t2i_ = use_t2i
        return self
-    
-    def is_split(self, is_split: bool):
-        '''设置是否分条发送消息。默认为 False。启用后，将会依次发送 chain 中的每个 component。
-        
-        Note:
-            具体的效果以各适配器实现为准。
-            
-        '''
-        self.is_split_ = is_split
-        return self

 class EventResultType(enum.Enum):
    '''用于描述事件处理的结果类型。
@@ -113,7 +101,6 @@ class MessageEventResult(MessageChain):
    Attributes:
        `chain` (list): 用于顺序存储各个组件。
        `use_t2i_` (bool): 用于标记是否使用文本转图片服务。默认为 None，即跟随用户的设置。当设置为 True 时，将会使用文本转图片服务。
-        `is_split_` (bool): 用于标记是否分条发送消息。默认为 False。启用后，将会依次发送 chain 中的每个 component。
        `result_type` (EventResultType): 事件处理的结果类型。
    '''
    
@@ -139,7 +126,7 @@ class MessageEventResult(MessageChain):
        '''
        return self.result_type == EventResultType.STOP
    
-    def set_result_content_type(self, typ: EventResultType) -> 'MessageEventResult':
+    def set_result_content_type(self, typ: ResultContentType) -> 'MessageEventResult':
        '''设置事件处理的结果类型。
        
        Args:
@@ -148,5 +135,15 @@ class MessageEventResult(MessageChain):
        self.result_content_type = typ
        return self
    
+    def is_llm_result(self) -> bool:
+        '''是否为 LLM 结果。
+        '''
+        return self.result_content_type == ResultContentType.LLM_RESULT
+    
+    def get_plain_text(self) -> str:
+        '''获取纯文本消息。这个方法将获取所有 Plain 组件的文本并拼接成一条消息。空格分隔。
+        '''
+        return " ".join([comp.text for comp in self.chain if isinstance(comp, Plain)])
+    
    
 CommandResult = MessageEventResult
--- a/astrbot/core/pipeline/init.py
+++ b/astrbot/core/pipeline/init.py
@@ -2,6 +2,7 @@ from astrbot.core.message.message_event_result import MessageEventResult, EventR

 from .waking_check.stage import WakingCheckStage
 from .whitelist_check.stage import WhitelistCheckStage
+from .rate_limit_check.stage import RateLimitStage
 from .content_safety_check.stage import ContentSafetyCheckStage
 from .preprocess_stage.stage import PreProcessStage
 from .process_stage.stage import ProcessStage
@@ -11,7 +12,7 @@ from .respond.stage import RespondStage
 STAGES_ORDER = [
    "WakingCheckStage", # 检查是否需要唤醒
    "WhitelistCheckStage", # 检查是否在群聊/私聊白名单
-    "RateLimitCheckStage", # 检查会话是否超过频率限制
+    "RateLimitStage", # 检查会话是否超过频率限制
    "ContentSafetyCheckStage", # 检查内容安全
    "PreProcessStage", # 预处理
    "ProcessStage", # 交由 Stars 处理（a.k.a 插件），或者 LLM 调用
@@ -22,6 +23,7 @@ STAGES_ORDER = [
 __all__ = [
    "WakingCheckStage",
    "WhitelistCheckStage",
+    "RateLimitStage",
    "ContentSafetyCheckStage",
    "PreProcessStage",
    "ProcessStage",
--- a/astrbot/core/pipeline/preprocess_stage/stage.py
+++ b/astrbot/core/pipeline/preprocess_stage/stage.py
@@ -5,7 +5,7 @@ from ..stage import Stage, register_stage
 from ..context import PipelineContext
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core import logger
-from astrbot.core.message.components import Plain, Record
+from astrbot.core.message.components import Plain, Record, Image

@register_stage
 class PreProcessStage(Stage):
@@ -16,24 +16,39 @@ class PreProcessStage(Stage):
        self.plugin_manager = ctx.plugin_manager
        
        self.stt_settings: dict = self.config.get('provider_stt_settings', {})
+        self.platform_settings: dict = self.config.get('platform_settings', {})
        

    async def process(self, event: AstrMessageEvent) -> Union[None, AsyncGenerator[None, None]]:
        '''在处理事件之前的预处理'''
-
+        # 路径映射
+        if mappings := self.platform_settings.get('path_mapping', []):
+            # 支持 Record，Image 消息段的路径映射。
+            message_chain = event.get_messages()
+            
+            for idx, component in enumerate(message_chain):
+                if isinstance(component, (Record, Image)) and component.url:
+                    for mapping in mappings:
+                        from_, to_ = mapping.split(":")
+                        from_ = from_.removesuffix("/")
+                        to_ = to_.removesuffix("/")
+                        
+                        url = component.url.removeprefix("file://")
+                        if url.startswith(from_):
+                            component.url = url.replace(from_, to_, 1)
+                            logger.debug(f"路径映射: {url} -> {component.url}")
+                    message_chain[idx] = component
+        
+        # STT
        if self.stt_settings.get('enable', False):
-            # STT 处理
            # TODO: 独立
            stt_provider = self.plugin_manager.context.provider_manager.curr_stt_provider_inst
            if stt_provider:
                message_chain = event.get_messages()
                for idx, component in enumerate(message_chain):
-                    if isinstance(component, Record) and component.path:
-                        
-                        path = component.path
-                        
+                    if isinstance(component, Record) and component.url:
+                        path = component.url.removeprefix("file://")
                        retry = 5
-                        
                        for i in range(retry):
                            try:
                                result = await stt_provider.get_text(audio_url=path)
@@ -46,7 +61,7 @@ class PreProcessStage(Stage):
                            except FileNotFoundError as e:
                                # napcat workaround
                                logger.warning(e)
-                                logger.warning(f"语音文件不存在: {path}, 重试中: {i + 1}/{retry}")
+                                logger.warning(f"重试中: {i + 1}/{retry}")
                                await asyncio.sleep(0.5)
                                continue
                            except BaseException as e:
--- a/astrbot/core/pipeline/process_stage/method/dify_request.py
+++ b/astrbot/core/pipeline/process_stage/method/dify_request.py
@@ -21,6 +21,10 @@ class DifyRequestSubStage(Stage):
        req: ProviderRequest = None
        
        provider = self.ctx.plugin_manager.context.get_using_provider()
+        
+        if not provider:
+            return
+        
        if provider.meta().type != "dify":
            return
        
--- a/astrbot/core/pipeline/process_stage/method/llm_request.py
+++ b/astrbot/core/pipeline/process_stage/method/llm_request.py
@@ -2,6 +2,7 @@
 本地 Agent 模式的 LLM 调用 Stage
 '''
 import traceback
+import json
 from typing import Union, AsyncGenerator
 from ...context import PipelineContext
 from ..stage import Stage
@@ -10,13 +11,22 @@ from astrbot.core.message.message_event_result import MessageEventResult, Result
 from astrbot.core.message.components import Image
 from astrbot.core import logger
 from astrbot.core.utils.metrics import Metric
-from astrbot.core.provider.entites import ProviderRequest
+from astrbot.core.provider.entites import ProviderRequest, LLMResponse
 from astrbot.core.star.star_handler import star_handlers_registry, EventType

 class LLMRequestSubStage(Stage):
    
    async def initialize(self, ctx: PipelineContext) -> None:
        self.ctx = ctx
+        self.bot_wake_prefixs = ctx.astrbot_config['wake_prefix'] # list
+        self.provider_wake_prefix = ctx.astrbot_config['provider_settings']['wake_prefix'] # str
+        
+        for bwp in self.bot_wake_prefixs:
+            if self.provider_wake_prefix.startswith(bwp):
+                logger.info(f"识别 LLM 聊天额外唤醒前缀 {self.provider_wake_prefix} 以机器人唤醒前缀 {bwp} 开头，已自动去除。")
+                self.provider_wake_prefix = self.provider_wake_prefix[len(bwp):]
+                
+        self.conv_manager = ctx.plugin_manager.context.conversation_manager
        
    async def process(self, event: AstrMessageEvent, _nested: bool = False) -> Union[None, AsyncGenerator[None, None]]:
        req: ProviderRequest = None
@@ -30,21 +40,28 @@ class LLMRequestSubStage(Stage):
            assert isinstance(req, ProviderRequest), "provider_request 必须是 ProviderRequest 类型。"
        else:
            req = ProviderRequest(prompt="", image_urls=[])
-            if self.ctx.astrbot_config['provider_settings']['wake_prefix']:
-                if not event.message_str.startswith(self.ctx.astrbot_config['provider_settings']['wake_prefix']):
+            if self.provider_wake_prefix:
+                if not event.message_str.startswith(self.provider_wake_prefix):
                    return
-            req.prompt = event.message_str[len(self.ctx.astrbot_config['provider_settings']['wake_prefix']):]
+            req.prompt = event.message_str[len(self.provider_wake_prefix):]
            req.func_tool = self.ctx.plugin_manager.context.get_llm_tool_manager()
            for comp in event.message_obj.message:
                if isinstance(comp, Image):
                    image_url = comp.url if comp.url else comp.file
                    req.image_urls.append(image_url)
-            req.session_id = event.session_id
-            event.set_extra("provider_request", req)
-            session_provider_context = provider.session_memory.get(event.session_id)
-            req.contexts = session_provider_context if session_provider_context else []
            
-        if not req.prompt:
+            # 获取对话上下文
+            conversation_id = await self.conv_manager.get_curr_conversation_id(event.unified_msg_origin)
+            if not conversation_id:
+                conversation_id = await self.conv_manager.new_conversation(event.unified_msg_origin)
+            req.session_id = conversation_id
+            conversation = await self.conv_manager.get_conversation(event.unified_msg_origin, conversation_id)
+            req.conversation = conversation
+            req.contexts = json.loads(conversation.history)
+
+            event.set_extra("provider_request", req)
+            
+        if not req.prompt and not req.image_urls:
            return
            
        # 执行请求 LLM 前事件。
@@ -55,18 +72,35 @@ class LLMRequestSubStage(Stage):
                await handler.handler(event, req)
            except BaseException:
                logger.error(traceback.format_exc())
+                
+        if isinstance(req.contexts, str):
+            req.contexts = json.loads(req.contexts)
        
        try:
-            logger.debug(f"提供商请求 Payload: {req.__dict__}")
+            logger.debug(f"提供商请求 Payload: {req}")
            if _nested:
                req.func_tool = None # 暂时不支持递归工具调用
            llm_response = await provider.text_chat(**req.__dict__) # 请求 LLM
+            
+            # 执行 LLM 响应后的事件。
+            handlers = star_handlers_registry.get_handlers_by_event_type(EventType.OnLLMResponseEvent)
+            for handler in handlers:
+                try:
+                    await handler.handler(event, llm_response)
+                except BaseException:
+                    logger.error(traceback.format_exc())
+            
+            # 保存到历史记录
+            await self._save_to_history(event, req, llm_response)
+            
            await Metric.upload(llm_tick=1, model_name=provider.get_model(), provider_type=provider.meta().type)

            if llm_response.role == 'assistant':
                # text completion
                event.set_result(MessageEventResult().message(llm_response.completion_text)
                                 .set_result_content_type(ResultContentType.LLM_RESULT))
+            elif llm_response.role == 'err':
+                event.set_result(MessageEventResult().message(f"AstrBot 请求失败。\n错误信息: {llm_response.completion_text}"))
            elif llm_response.role == 'tool':
                # function calling
                function_calling_result = {}
@@ -95,8 +129,31 @@ class LLMRequestSubStage(Stage):
                    req.prompt += extra_prompt
                    async for _ in self.process(event, _nested=True):
                        yield
+                else:
+                    if llm_response.completion_text:
+                        event.set_result(MessageEventResult().message(llm_response.completion_text))

        except BaseException as e:
            logger.error(traceback.format_exc())
-            event.set_result(MessageEventResult().message("AstrBot 请求 LLM 资源失败：" + str(e)))
-            return
+            event.set_result(MessageEventResult().message(f"AstrBot 请求失败。\n错误类型: {type(e).__name__}\n错误信息: {str(e)}"))
+            return
+        
+    async def _save_to_history(self, event: AstrMessageEvent, req: ProviderRequest, llm_response: LLMResponse):
+        if llm_response.role == "assistant":
+            # 文本回复
+            contexts = req.contexts
+            new_record = {
+                "role": "user",
+                "content": req.prompt
+            }
+            contexts.append(new_record)
+            contexts.append({
+                "role": "assistant",
+                "content": llm_response.completion_text
+            })
+            contexts_to_save = list(filter(lambda item: '_no_save' not in item, contexts))
+            await self.conv_manager.update_conversation(
+                event.unified_msg_origin, 
+                req.session_id, 
+                history=contexts_to_save
+            )
--- a/astrbot/core/pipeline/process_stage/method/star_request.py
+++ b/astrbot/core/pipeline/process_stage/method/star_request.py
@@ -39,8 +39,11 @@ class StarRequestSubStage(Stage):
            except Exception as e:
                logger.error(traceback.format_exc())
                logger.error(f"Star {handler.handler_full_name} handle error: {e}")
-                ret = f":(\n\n在调用插件 {star_map.get(handler.handler_module_path).name} 的处理函数 {handler.handler_name} 时出现异常：{e}"
-                event.set_result(MessageEventResult().message(ret))
-                yield
-                event.clear_result()
+                
+                if event.is_at_or_wake_command:
+                    ret = f":(\n\n在调用插件 {star_map.get(handler.handler_module_path).name} 的处理函数 {handler.handler_name} 时出现异常：{e}"
+                    event.set_result(MessageEventResult().message(ret))
+                    yield
+                    event.clear_result()
+                
                event.stop_event()
--- a/astrbot/core/pipeline/process_stage/stage.py
+++ b/astrbot/core/pipeline/process_stage/stage.py
@@ -37,7 +37,11 @@ class ProcessStage(Stage):
                    # Handler 的 LLM 请求
                    logger.debug(f"llm request -> {resp.prompt}")
                    event.set_extra("provider_request", resp)
+                    _t = False
                    async for _ in self.llm_request_sub_stage.process(event):
+                        _t = True
+                        yield
+                    if not _t:
                        yield
                else:
                    yield
@@ -49,6 +53,11 @@ class ProcessStage(Stage):
        if not event._has_send_oper and event.is_at_or_wake_command:
            if (event.get_result() and not event.get_result().is_stopped()) or not event.get_result():
                provider = self.ctx.plugin_manager.context.get_using_provider()
+                
+                if not provider:
+                    logger.info("未找到可用的 LLM 提供商，请先前往配置服务提供商。")
+                    return
+                
                match provider.meta().type:
                    case "dify":
                        async for _ in self.dify_request_sub_stage.process(event):
--- a/astrbot/core/pipeline/rate_limit_check/stage.py
+++ b/astrbot/core/pipeline/rate_limit_check/stage.py
@@ -61,11 +61,12 @@ class RateLimitStage(Stage):
                stall_duration = (next_window_time - now).total_seconds()
                
                match self.rl_strategy:
-                    case RateLimitStrategy.STALL:
+                    case RateLimitStrategy.STALL.value:
                        logger.info(f"会话 {session_id} 被限流。根据限流策略，此会话处理将被暂停 {stall_duration:.2f} 秒。")
                        await asyncio.sleep(stall_duration)
-                    case RateLimitStrategy.DISCARD:
-                        event.set_result(MessageEventResult().message(f"会话 {session_id} 被限流。根据限流策略，此请求已被丢弃，直到您的限额于 {stall_duration:.2f} 秒后重置。"))
+                    case RateLimitStrategy.DISCARD.value:
+                        # event.set_result(MessageEventResult().message(f"会话 {session_id} 被限流。根据限流策略，此请求已被丢弃，直到您的限额于 {stall_duration:.2f} 秒后重置。"))
+                        logger.info(f"会话 {session_id} 被限流。根据限流策略，此请求已被丢弃，直到限额于 {stall_duration:.2f} 秒后重置。")
                        return event.stop_event()
                
                self._remove_expired_timestamps(timestamps, now + timedelta(seconds=stall_duration))
--- a/astrbot/core/pipeline/respond/stage.py
+++ b/astrbot/core/pipeline/respond/stage.py
@@ -1,7 +1,10 @@
+import random
+import asyncio
 from typing import Union, AsyncGenerator
 from ..stage import register_stage, Stage
 from ..context import PipelineContext
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.message.message_event_result import MessageChain
 from astrbot.core import logger
 from astrbot.core.star.star_handler import star_handlers_registry, EventType

@@ -9,6 +12,19 @@ from astrbot.core.star.star_handler import star_handlers_registry, EventType
 class RespondStage(Stage):
    async def initialize(self, ctx: PipelineContext):
        self.ctx = ctx
+        
+        # 分段回复
+        self.enable_seg: bool = ctx.astrbot_config['platform_settings']['segmented_reply']['enable']
+        self.only_llm_result = ctx.astrbot_config['platform_settings']['segmented_reply']['only_llm_result']
+        interval_str: str = ctx.astrbot_config['platform_settings']['segmented_reply']['interval']
+        interval_str_ls = interval_str.replace(" ", "").split(",")
+        try:
+            self.interval = [float(t) for t in interval_str_ls]
+        except BaseException as e:
+            logger.error(f'解析分段回复的间隔时间失败。{e}')
+            self.interval = [1.5, 3.5]
+        logger.info(f"分段回复间隔时间：{self.interval}")
+

    async def process(self, event: AstrMessageEvent) -> Union[None, AsyncGenerator[None, None]]:
        result = event.get_result()
@@ -16,7 +32,16 @@ class RespondStage(Stage):
            return

        if len(result.chain) > 0:
-            await event.send(result)
+            await event._pre_send()
+            
+            if self.enable_seg and ((self.only_llm_result and result.is_llm_result()) or not self.only_llm_result):
+                # 分段回复
+                for comp in result.chain:
+                    await event.send(MessageChain([comp]))
+                    await asyncio.sleep(random.uniform(self.interval[0], self.interval[1]))
+            else:
+                await event.send(result)
+            await event._post_send()
            logger.info(f"AstrBot -> {event.get_sender_name()}/{event.get_sender_id()}: {event._outline_chain(result.chain)}")
        
        handlers = star_handlers_registry.get_handlers_by_event_type(EventType.OnAfterMessageSentEvent)
--- a/astrbot/core/pipeline/result_decorate/stage.py
+++ b/astrbot/core/pipeline/result_decorate/stage.py
@@ -1,10 +1,13 @@
 import time
+import re
+import traceback
 from typing import Union, AsyncGenerator
 from ..stage import register_stage
 from ..context import PipelineContext
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.platform.message_type import MessageType
 from astrbot.core import logger
-from astrbot.core.message.components import Plain, Image
+from astrbot.core.message.components import Plain, Image, At, Reply, Record
 from astrbot.core import html_renderer
 from astrbot.core.star.star_handler import star_handlers_registry, EventType

@@ -13,7 +16,21 @@ class ResultDecorateStage:
    async def initialize(self, ctx: PipelineContext):
        self.ctx = ctx
        self.reply_prefix = ctx.astrbot_config['platform_settings']['reply_prefix']
-        self.t2i = ctx.astrbot_config['t2i']
+        self.reply_with_mention = ctx.astrbot_config['platform_settings']['reply_with_mention']
+        self.reply_with_quote = ctx.astrbot_config['platform_settings']['reply_with_quote']
+        self.use_tts = ctx.astrbot_config['provider_tts_settings']['enable']
+        self.t2i_word_threshold = ctx.astrbot_config['t2i_word_threshold']
+        try:
+            self.t2i_word_threshold = int(self.t2i_word_threshold)
+            if self.t2i_word_threshold < 50:
+                self.t2i_word_threshold = 50
+        except BaseException:
+            self.t2i_word_threshold = 150
+        
+        # 分段回复
+        self.enable_segmented_reply = ctx.astrbot_config['platform_settings']['segmented_reply']['enable']
+        self.only_llm_result = ctx.astrbot_config['platform_settings']['segmented_reply']['only_llm_result']
+        self.regex = ctx.astrbot_config['platform_settings']['segmented_reply']['regex']

    async def process(self, event: AstrMessageEvent) -> Union[None, AsyncGenerator[None, None]]:
        result = event.get_result()
@@ -28,17 +45,61 @@ class ResultDecorateStage:
        if len(result.chain) > 0:
            # 回复前缀
            if self.reply_prefix:
-                result.chain.insert(0, Plain(self.reply_prefix))
+                for comp in result.chain:
+                    if isinstance(comp, Plain):
+                        comp.text = self.reply_prefix + comp.text
+                        break
+            
+             # 分段回复 
+            if self.enable_segmented_reply:
+                if (self.only_llm_result and result.is_llm_result()) or not self.only_llm_result:
+                    new_chain = []
+                    for comp in result.chain:
+                        if isinstance(comp, Plain):
+                            split_response = re.findall(self.regex, comp.text)
+                            if not split_response:
+                                new_chain.append(comp)
+                                continue
+                            for seg in split_response:
+                                if seg:
+                                    new_chain.append(Plain(seg))
+                        else:
+                            # 非 Plain 类型的消息段不分段
+                            new_chain.append(comp)
+                    result.chain = new_chain
+                
+            # TTS
+            if self.use_tts and result.is_llm_result():
+                tts_provider = self.ctx.plugin_manager.context.provider_manager.curr_tts_provider_inst
+                new_chain = []
+                for comp in result.chain:
+                    if isinstance(comp, Plain) and len(comp.text) > 1:
+                        try:
+                            logger.info("TTS 请求: " + comp.text)
+                            audio_path = await tts_provider.get_audio(comp.text)
+                            logger.info("TTS 结果: " + audio_path)
+                            if audio_path:
+                                new_chain.append(Record(file=audio_path, url=audio_path))
+                            else:
+                                logger.error(f"由于 TTS 音频文件没找到，消息段转语音失败: {comp.text}")
+                                new_chain.append(comp)
+                        except BaseException:
+                            traceback.print_exc()
+                            logger.error("TTS 失败，使用文本发送。")
+                            new_chain.append(comp)
+                    else:
+                        new_chain.append(comp)
+                result.chain = new_chain
            
            # 文本转图片
-            if (result.use_t2i_ is None and self.t2i) or result.use_t2i_:
+            elif (result.use_t2i_ is None and self.ctx.astrbot_config['t2i']) or result.use_t2i_:
                plain_str = ""
                for comp in result.chain:
                    if isinstance(comp, Plain):
                        plain_str += "\n\n" + comp.text
                    else:
                        break
-                if plain_str and len(plain_str) > 150:
+                if plain_str and len(plain_str) > self.t2i_word_threshold:
                    render_start = time.time()
                    try:
                        url = await html_renderer.render_t2i(plain_str, return_url=True)
@@ -48,4 +109,14 @@ class ResultDecorateStage:
                    if time.time() - render_start > 3:
                        logger.warning("文本转图片耗时超过了 3 秒，如果觉得很慢可以使用 /t2i 关闭文本转图片模式。")
                    if url:
-                        result.chain = [Image.fromURL(url)]
+                        result.chain = [Image.fromURL(url)]
+            
+            # at 回复
+            if self.reply_with_mention and event.get_message_type() != MessageType.FRIEND_MESSAGE:
+                result.chain.insert(0, At(qq=event.get_sender_id(), name=event.get_sender_name()))
+                if len(result.chain) > 1 and isinstance(result.chain[1], Plain):
+                    result.chain[1].text = "\n" + result.chain[1].text
+            
+            # 引用回复
+            if self.reply_with_quote:
+                result.chain.insert(0, Reply(id=event.message_obj.message_id))
--- a/astrbot/core/pipeline/waking_check/stage.py
+++ b/astrbot/core/pipeline/waking_check/stage.py
@@ -2,11 +2,11 @@ from ..stage import Stage, register_stage
 from ..context import PipelineContext
 from typing import Union, AsyncGenerator
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
-from astrbot.core.message.message_event_result import MessageEventResult
+from astrbot.core.message.message_event_result import MessageEventResult, MessageChain
 from astrbot.core.message.components import At
 from astrbot.core.star.star_handler import star_handlers_registry, EventType
 from astrbot.core.star.filter.command_group import CommandGroupFilter
-
+from astrbot.core.star.filter.permission import PermissionTypeFilter

@register_stage
 class WakingCheckStage(Stage):
@@ -21,6 +21,9 @@ class WakingCheckStage(Stage):

    async def initialize(self, ctx: PipelineContext) -> None:
        self.ctx = ctx
+        self.no_permission_reply = self.ctx.astrbot_config["platform_settings"].get(
+            "no_permission_reply", True
+        )

    async def process(
        self, event: AstrMessageEvent
@@ -77,7 +80,9 @@ class WakingCheckStage(Stage):
            # filter 需要满足 AND 的逻辑关系
            passed = True
            child_command_handler_md = None
-
+            
+            permission_not_pass = False
+            
            if len(handler.event_filters) == 0:
                # 不可能有这种情况, 也不允许有这种情况
                continue
@@ -94,6 +99,9 @@ class WakingCheckStage(Stage):
                        else:
                            handler = child_command_handler_md  # handler 覆盖
                            break
+                    elif isinstance(filter, PermissionTypeFilter):
+                        if not filter.filter(event, self.ctx.astrbot_config):
+                            permission_not_pass = True
                    else:
                        if not filter.filter(event, self.ctx.astrbot_config):
                            passed = False
@@ -111,6 +119,13 @@ class WakingCheckStage(Stage):
                    break

            if passed:
+                
+                if permission_not_pass:
+                    if self.no_permission_reply:
+                        await event.send(MessageChain().message(f"ID {event.get_sender_id()} 权限不足。通过 /sid 获取 ID 并请管理员添加。"))
+                    event.stop_event()
+                    return
+                
                is_wake = True
                event.is_wake = True

--- a/astrbot/core/pipeline/whitelist_check/stage.py
+++ b/astrbot/core/pipeline/whitelist_check/stage.py
@@ -18,6 +18,11 @@ class WhitelistCheckStage(Stage):
        
    async def process(self, event: AstrMessageEvent) -> Union[None, AsyncGenerator[None, None]]:
        if not self.enable_whitelist_check:
+            # 白名单检查未启用
+            return
+        
+        if len(self.whitelist) == 0:
+            # 白名单为空，不检查
            return
        
        if event.get_platform_name() == 'webchat':
--- a/astrbot/core/platform/astr_message_event.py
+++ b/astrbot/core/platform/astr_message_event.py
@@ -31,12 +31,19 @@ class AstrMessageEvent(abc.ABC):
                platform_meta: PlatformMetadata,
                session_id: str,):
        self.message_str = message_str
+        '''纯文本的消息'''
        self.message_obj = message_obj
+        '''消息对象，AstrBotMessage。带有完整的消息结构。'''
        self.platform_meta = platform_meta
+        '''消息平台的信息, 其中 name 是平台的类型，如 aiocqhttp'''
        self.session_id = session_id
+        '''用户的会话 ID。可以直接使用下面的 unified_msg_origin'''
        self.role = "member"
+        '''用户是否是管理员。如果是管理员，这里是 admin'''
        self.is_wake = False # 是否通过 WakingStage
-        self.is_at_or_wake_command = False # 是否是 At 机器人或者带有唤醒词或者是私聊（事件监听器会让 is_wake 设为 True）
+        '''是否唤醒'''
+        self.is_at_or_wake_command = False
+        '''是否是 At 机器人或者带有唤醒词或者是私聊（事件监听器会让 is_wake 设为 True，但是不会让这个属性置为 True）'''
        self._extras = {}
        self.session = MessageSesion(
            platform_name=platform_meta.name,
@@ -44,7 +51,7 @@ class AstrMessageEvent(abc.ABC):
            session_id=session_id
        )
        self.unified_msg_origin = str(self.session)
-        
+        '''统一的消息来源字符串。格式为 platform_name:message_type:session_id'''
        self._result: MessageEventResult = None
        '''消息事件的结果'''
        
@@ -179,6 +186,15 @@ class AstrMessageEvent(abc.ABC):
        await Metric.upload(msg_event_tick = 1, adapter_name = self.platform_meta.name)
        self._has_send_oper = True
        
+    async def _pre_send(self):
+        '''调度器会在执行 send() 前调用该方法'''
+        pass
+    
+    async def _post_send(self):
+        '''调度器会在执行 send() 后调用该方法'''
+        pass
+        
+        
    def set_result(self, result: Union[MessageEventResult, str]):
        '''设置消息事件的结果。
        
@@ -287,6 +303,7 @@ class AstrMessageEvent(abc.ABC):
    def request_llm(
        self,
        prompt: str,
+        func_tool_manager = None,
        session_id: str = None,
        image_urls: List[str] = None,
        contexts: List = None,
@@ -302,11 +319,13 @@ class AstrMessageEvent(abc.ABC):
        
        image_urls: 可以是 base64:// 或者 http:// 开头的图片链接，也可以是本地图片路径。
        contexts: 当指定 contexts 时，将会**只**使用 contexts 作为上下文。
+        func_tool_manager: 函数工具管理器，用于调用函数工具。用 self.context.get_llm_tool_manager() 获取。
        '''
        return ProviderRequest(
            prompt = prompt,
            session_id = session_id,
            image_urls = image_urls,
+            func_tool = func_tool_manager,
            contexts = contexts,
            system_prompt = system_prompt
        )
--- a/astrbot/core/platform/manager.py
+++ b/astrbot/core/platform/manager.py
@@ -24,7 +24,12 @@ class PlatformManager():
                case "qq_official":
                    from .sources.qqofficial.qqofficial_platform_adapter import QQOfficialPlatformAdapter # noqa: F401
                case "vchat":
-                    from .sources.vchat.vchat_platform_adapter import VChatPlatformAdapter # noqa: F401
+                    try:
+                        from .sources.vchat.vchat_platform_adapter import VChatPlatformAdapter # noqa: F401
+                    except BaseException:
+                        logger.warning("当前 astrbot 已不维护 vchat 的接入，如有需要请 pip 安装 vchat 然后重启")
+                case "gewechat":
+                    from .sources.gewechat.gewechat_platform_adapter import GewechatPlatformAdapter # noqa: F401
        

    async def initialize(self):
--- a/astrbot/core/platform/platform_metadata.py
+++ b/astrbot/core/platform/platform_metadata.py
@@ -1,7 +1,12 @@
 from dataclasses import dataclass
@dataclass
 class PlatformMetadata():
-    name: str # 平台的名称
-    description: str # 平台的描述
+    name: str
+    '''平台的名称'''
+    description: str
+    '''平台的描述'''
    
-    default_config_tmpl: dict = None # 平台的默认配置模板
+    default_config_tmpl: dict = None
+    '''平台的默认配置模板'''
+    adapter_display_name: str = None
+    '''显示在 WebUI 配置页中的平台名称，如空则是 name'''
--- a/astrbot/core/platform/register.py
+++ b/astrbot/core/platform/register.py
@@ -7,7 +7,12 @@ platform_registry: List[PlatformMetadata] = []
 platform_cls_map: Dict[str, Type] = {}
 '''维护了平台适配器名称和适配器类的映射'''

-def register_platform_adapter(adapter_name: str, desc: str, default_config_tmpl: dict = None):
+def register_platform_adapter(
+    adapter_name: str, 
+    desc: str, 
+    default_config_tmpl: dict = None,
+    adapter_display_name: str = None
+):
    '''用于注册平台适配器的带参装饰器。
    
    default_config_tmpl 指定了平台适配器的默认配置模板。用户填写好后将会作为 platform_config 传入你的 Platform 类的实现类。 
@@ -22,11 +27,14 @@ def register_platform_adapter(adapter_name: str, desc: str, default_config_tmpl:
                default_config_tmpl['type'] = adapter_name
            if 'enable' not in default_config_tmpl:
                default_config_tmpl['enable'] = False
+            if 'id' not in default_config_tmpl:
+                default_config_tmpl['id'] = adapter_name

        pm = PlatformMetadata(
            name=adapter_name,
            description=desc,
-            default_config_tmpl=default_config_tmpl
+            default_config_tmpl=default_config_tmpl,
+            adapter_display_name=adapter_display_name
        )
        platform_registry.append(pm)
        platform_cls_map[adapter_name] = cls
--- a/astrbot/core/platform/sources/aiocqhttp/aiocqhttp_message_event.py
+++ b/astrbot/core/platform/sources/aiocqhttp/aiocqhttp_message_event.py
@@ -3,7 +3,7 @@ import random
 import asyncio

 from astrbot.api.event import AstrMessageEvent, MessageChain
-from astrbot.api.message_components import Plain, Image
+from astrbot.api.message_components import Plain, Image, Record
 from aiocqhttp import CQHttp
 from astrbot.core.utils.io import file_to_base64, download_image_by_url

@@ -20,15 +20,19 @@ class AiocqhttpMessageEvent(AstrMessageEvent):
            d = segment.toDict()
            if isinstance(segment, Plain):
                d['type'] = 'text'
-            if isinstance(segment, Image):
+            if isinstance(segment, (Image, Record)):
                # convert to base64
                if segment.file and segment.file.startswith("file:///"):
-                    image_base64 = file_to_base64(segment.file[8:])
+                    bs64_data = file_to_base64(segment.file[8:])
                    image_file_path = segment.file[8:]
                elif segment.file and segment.file.startswith("http"):
                    image_file_path = await download_image_by_url(segment.file)
-                    image_base64 = file_to_base64(image_file_path)
-                d['data']['file'] = image_base64
+                    bs64_data = file_to_base64(image_file_path)
+                else:
+                    bs64_data = file_to_base64(segment.file)
+                d['data'] = {
+                    'file': bs64_data,
+                }
            ret.append(d)
        return ret

@@ -36,11 +40,5 @@ class AiocqhttpMessageEvent(AstrMessageEvent):
        ret = await AiocqhttpMessageEvent._parse_onebot_json(message)
        if os.environ.get('TEST_MODE', 'off') == 'on':
            return
-        
-        if message.is_split_: # 分条发送
-            for m in ret:
-                await self.bot.send(self.message_obj.raw_message, [m])
-                await asyncio.sleep(random.uniform(0.75, 2.5))
-        else:
-            await self.bot.send(self.message_obj.raw_message, ret)
+        await self.bot.send(self.message_obj.raw_message, ret)
        await super().send(message)
--- a/astrbot/core/platform/sources/aiocqhttp/aiocqhttp_platform_adapter.py
+++ b/astrbot/core/platform/sources/aiocqhttp/aiocqhttp_platform_adapter.py
@@ -13,6 +13,7 @@ from .aiocqhttp_message_event import AiocqhttpMessageEvent
 from astrbot.core.platform.astr_message_event import MessageSesion
 from ...register import register_platform_adapter
 from aiocqhttp.exceptions import ActionFailed
+from astrbot.core.utils.io import download_file

@register_platform_adapter("aiocqhttp", "适用于 OneBot 标准的消息平台适配器，支持反向 WebSockets。")
 class AiocqhttpAdapter(Platform):
@@ -81,22 +82,36 @@ class AiocqhttpAdapter(Platform):
            if t == 'text':
                message_str += m['data']['text'].strip()
            elif t == 'file':
-                try:
-                    # Napcat, LLBot
-                    ret = await self.bot.call_action(action="get_file", file_id=event.message[0]['data']['file_id'])
-                    if not ret.get('file', None):
-                        raise ValueError(f"无法解析文件响应: {ret}")
-                    if not os.path.exists(ret['file']):
-                        raise FileNotFoundError(f"文件不存在: {ret['file']}。如果您使用 Docker 部署了 AstrBot 或者消息协议端(Napcat等),暂时无法获取用户上传的文件。")
+                if m['data']['url'] and m['data']['url'].startswith("http"):
+                    # Lagrange
+                    logger.info("guessing lagrange")
+                    
+                    file_name = m['data'].get('file_name', "file")
+                    path = os.path.join("data/temp", file_name)
+                    await download_file(m['data']['url'], path)
                    
                    m['data'] = {
-                        "file": ret['file'],
-                        "name": ret['file_name']
+                        "file": path,
+                        "name": file_name
                    }
-                except ActionFailed as e:
-                    logger.error(f"获取文件失败: {e}，此消息段将被忽略。")
-                except BaseException as e:
-                    logger.error(f"获取文件失败: {e}，此消息段将被忽略。")
+                
+                else:
+                    try:
+                        # Napcat, LLBot
+                        ret = await self.bot.call_action(action="get_file", file_id=event.message[0]['data']['file_id'])
+                        if not ret.get('file', None):
+                            raise ValueError(f"无法解析文件响应: {ret}")
+                        if not os.path.exists(ret['file']):
+                            raise FileNotFoundError(f"文件不存在或者权限问题: {ret['file']}。如果您使用 Docker 部署了 AstrBot 或者消息协议端(Napcat等),请先映射路径。如果路径在 /root 目录下，请用 sudo 打开 AstrBot")
+                        
+                        m['data'] = {
+                            "file": ret['file'],
+                            "name": ret['file_name']
+                        }
+                    except ActionFailed as e:
+                        logger.error(f"获取文件失败: {e}，此消息段将被忽略。")
+                    except BaseException as e:
+                        logger.error(f"获取文件失败: {e}，此消息段将被忽略。")
                    
            a = ComponentTypes[t](**m['data'])  # noqa: F405
            abm.message.append(a)
@@ -107,7 +122,10 @@ class AiocqhttpAdapter(Platform):
    
    def run(self) -> Awaitable[Any]:
        if not self.host or not self.port:
-            return
+            logger.warning("aiocqhttp: 未配置 ws_reverse_host 或 ws_reverse_port，将使用默认值：http://0.0.0.0:6199")
+            self.host = "0.0.0.0"
+            self.port = 6199
+            
        self.bot = CQHttp(use_ws_reverse=True, import_name='aiocqhttp', api_timeout_sec=180)
        @self.bot.on_message('group')
        async def group(event: Event):
--- a/astrbot/core/platform/sources/gewechat/client.py
+++ b/astrbot/core/platform/sources/gewechat/client.py
@@ -0,0 +1,352 @@
+import threading
+import asyncio
+import aiohttp
+import quart
+import base64
+
+from astrbot.api.platform import AstrBotMessage, MessageMember, MessageType
+from astrbot.api.message_components import Plain, Image, At, Record
+from astrbot.api import logger, sp
+from .downloader import GeweDownloader
+from astrbot.core.utils.io import download_image_by_url
+
+
+class SimpleGewechatClient():
+    '''针对 Gewechat 的简单实现。
+    
+    @author: Soulter
+    @website: https://github.com/Soulter
+    '''
+    def __init__(self, base_url: str, nickname: str, host: str, port: int, event_queue: asyncio.Queue):
+        self.base_url = base_url
+        if self.base_url.endswith('/'):
+            self.base_url = self.base_url[:-1]
+            
+        self.download_base_url = self.base_url.split(':')[:-1] # 去掉端口
+        self.download_base_url = ':'.join(self.download_base_url) + ":2532/download/"
+        
+        self.base_url += "/v2/api"
+        
+        logger.info(f"Gewechat API: {self.base_url}")
+        logger.info(f"Gewechat 下载 API: {self.download_base_url}")
+        
+        if isinstance(port, str):
+            port = int(port)
+            
+        self.token = None
+        self.headers = {}
+        self.nickname = nickname
+        self.appid = sp.get(f"gewechat-appid-{nickname}", "")
+        
+        self.server = quart.Quart(__name__)
+        self.server.add_url_rule('/astrbot-gewechat/callback', view_func=self.callback, methods=['POST'])
+        self.server.add_url_rule('/astrbot-gewechat/file/<file_id>', view_func=self.handle_file, methods=['GET'])
+        
+        self.host = host
+        self.port = port 
+        self.callback_url = f"http://{self.host}:{self.port}/astrbot-gewechat/callback"
+        self.file_server_url = f"http://{self.host}:{self.port}/astrbot-gewechat/file"
+        
+        self.event_queue = event_queue
+        
+        self.multimedia_downloader = None
+    
+    async def get_token_id(self):
+        async with aiohttp.ClientSession() as session:
+            async with session.post(f"{self.base_url}/tools/getTokenId") as resp:
+                json_blob = await resp.json()
+                self.token = json_blob['data']
+                logger.info(f"获取到 Gewechat Token: {self.token}")
+                self.headers = {
+                    "X-GEWE-TOKEN": self.token
+                }
+                
+    async def _convert(self, data: dict) -> AstrBotMessage:
+        type_name = data['TypeName']
+        if type_name == "Offline":
+            logger.critical("收到 gewechat 下线通知。")
+            return
+        
+        abm = AstrBotMessage()
+        d = data['Data']
+    
+        from_user_name = d['FromUserName']['string'] # 消息来源
+        d['to_wxid'] = from_user_name # 用于发信息
+        
+        abm.message_id = str(d.get('MsgId'))
+        abm.session_id = from_user_name
+        abm.self_id = data['Wxid'] # 机器人的 wxid
+        
+        user_id = "" # 发送人 wxid
+        content = d['Content']['string'] # 消息内容
+        
+        at_me = False
+        if "@chatroom" in from_user_name:
+            abm.type = MessageType.GROUP_MESSAGE
+            _t = content.split(':\n')
+            user_id = _t[0]
+            content = _t[1]
+            if '\u2005' in content: 
+                # at
+                content = content.split('\u2005')[1]
+            abm.group_id = from_user_name
+            # at
+            msg_source = d['MsgSource']
+            if f'<atuserlist><![CDATA[,{abm.self_id}]]>' in msg_source \
+                or f'<atuserlist><![CDATA[{abm.self_id}]]>' in msg_source:
+                at_me = True
+            if '在群聊中@了你' in d.get('PushContent', ''):
+                at_me = True
+        else:
+            abm.type = MessageType.FRIEND_MESSAGE
+            user_id = from_user_name
+            
+        abm.message = []
+        if at_me:
+            abm.message.insert(0, At(qq=abm.self_id))
+        
+        user_real_name = d.get('PushContent', 'unknown : ').split(' : ')[0] \
+            .replace('在群聊中@了你', '') \
+            .replace('在群聊中发了一段语音', '') # 真实昵称
+        abm.sender = MessageMember(user_id, user_real_name)
+        abm.raw_message = d
+        abm.message_str = ""
+        # 不同消息类型
+        match d['MsgType']:
+            case 1:
+                # 文本消息
+                abm.message.append(Plain(content))
+                abm.message_str = content
+            case 3:
+                # 图片消息
+                file_url = await self.multimedia_downloader.download_image(
+                    self.appid, 
+                    content
+                )
+                logger.debug(f"下载图片: {file_url}")
+                file_path = await download_image_by_url(file_url)
+                abm.message.append(Image(file=file_path, url=file_path))
+                
+            case 34:
+                # 语音消息
+                # data = await self.multimedia_downloader.download_voice(
+                #     self.appid, 
+                #     content, 
+                #     abm.message_id
+                # )
+                # print(data)
+                if 'ImgBuf' in d and 'buffer' in d['ImgBuf']:
+                    voice_data = base64.b64decode(d['ImgBuf']['buffer'])
+                    file_path = f"data/temp/gewe_voice_{abm.message_id}.silk"
+                    with open(file_path, "wb") as f:
+                        f.write(voice_data)
+                    abm.message.append(Record(file=file_path, url=file_path))
+                
+            case _:
+                logger.error(f"未实现的消息类型: {d['MsgType']}")
+                return
+        
+        logger.info(f"abm: {abm}")
+        return abm
+
+    async def callback(self):
+        data = await quart.request.json
+        logger.debug(f"收到 gewechat 回调: {data}")
+        
+        if data.get('testMsg', None):
+            return quart.jsonify({"r": "AstrBot ACK"})
+        
+        abm = None
+        try:
+            abm = await self._convert(data)
+        except BaseException as e:
+            logger.warning(f"尝试解析 GeweChat 下发的消息时遇到问题: {e}。下发消息内容: {data}。")
+            
+        if abm:
+            coro = getattr(self, "on_event_received")
+            if coro:
+                await coro(abm)
+        
+        return quart.jsonify({"r": "AstrBot ACK"})
+    
+    async def handle_file(self, file_id):
+        file_path = f"data/temp/{file_id}"
+        return await quart.send_file(file_path)
+        
+    async def _set_callback_url(self):
+        logger.info("设置回调，请等待...")
+        await asyncio.sleep(3)
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{self.base_url}/tools/setCallback",
+                headers=self.headers,
+                json={
+                    "token": self.token,
+                    "callbackUrl": self.callback_url
+                }
+            ) as resp:
+                json_blob = await resp.json()
+                logger.info(f"设置回调结果: {json_blob}")
+                if json_blob['ret'] != 200:
+                    raise Exception(f"设置回调失败: {json_blob}")
+                logger.info(f"将在 {self.callback_url} 上接收 gewechat 下发的消息。如果一直没收到消息请先尝试重启 AstrBot。")
+        
+    async def start_polling(self):
+        threading.Thread(target=asyncio.run, args=(self._set_callback_url(),)).start()
+        await self.server.run_task(
+            host='0.0.0.0', 
+            port=self.port, 
+            shutdown_trigger=self.shutdown_trigger_placeholder
+        )
+    
+    async def shutdown_trigger_placeholder(self):
+        while not self.event_queue.closed:
+            await asyncio.sleep(1)
+        logger.info("gewechat 适配器已关闭。")
+        
+    async def check_online(self, appid: str):
+        # /login/checkOnline
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{self.base_url}/login/checkOnline",
+                headers=self.headers,
+                json={
+                    "appId": appid
+                }
+            ) as resp:
+                json_blob = await resp.json()
+                return json_blob['data']
+            
+    async def logout(self):
+        if self.appid:
+            online = await self.check_online(self.appid)
+            if online:
+                async with aiohttp.ClientSession() as session:
+                    async with session.post(
+                        f"{self.base_url}/login/logout",
+                        headers=self.headers,
+                        json={
+                            "appId": self.appid
+                        }
+                    ) as resp:
+                        json_blob = await resp.json()
+                        logger.info(f"登出结果: {json_blob}")
+        
+    async def login(self):
+        if self.token is None:
+            await self.get_token_id()
+            
+        self.multimedia_downloader = GeweDownloader(self.base_url, self.download_base_url, self.token)
+        
+        if self.appid:
+            online = await self.check_online(self.appid)
+            if online:
+                logger.info(f"APPID: {self.appid} 已在线")
+                return
+        
+        payload = {
+            "appId": self.appid
+        }
+        
+        if self.appid:
+            logger.info(f"使用 APPID: {self.appid}, {self.nickname}")
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{self.base_url}/login/getLoginQrCode", 
+                headers=self.headers,
+                json=payload
+            ) as resp:
+                json_blob = await resp.json()
+                if json_blob['ret'] != 200:
+                    raise Exception(f"获取二维码失败: {json_blob}")
+                qr_data = json_blob['data']['qrData']
+                qr_uuid = json_blob['data']['uuid']
+                appid = json_blob['data']['appId']
+                logger.info(f"APPID: {appid}")
+                logger.warning(f"请打开该网址，然后使用微信扫描二维码登录: https://api.cl2wm.cn/api/qrcode/code?text={qr_data}")
+        
+        # 执行登录
+        retry_cnt = 64
+        payload.update({
+            "uuid": qr_uuid,
+            "appId": appid
+        })
+        while retry_cnt > 0:
+            retry_cnt -= 1
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    f"{self.base_url}/login/checkLogin",
+                    headers=self.headers,
+                    json=payload
+                ) as resp:
+                    json_blob = await resp.json()
+                    logger.info(f"检查登录状态: {json_blob}")
+                    status = json_blob['data']['status']
+                    nickname = json_blob['data'].get('nickName', '')
+                    if status == 1:
+                        logger.info(f"等待确认...{nickname}")
+                    elif status == 2:
+                        logger.info(f"绿泡泡平台登录成功: {nickname}")
+                        break
+                    elif status == 0:
+                        logger.info("等待扫码...")
+                    else:
+                        logger.warning(f"未知状态: {status}")
+            await asyncio.sleep(5)
+            
+        if appid:
+            sp.put(f"gewechat-appid-{self.nickname}", appid)
+            self.appid = appid
+            logger.info(f"已保存 APPID: {appid}")
+    
+    async def post_text(self, to_wxid, content: str):
+        payload = {
+            "appId": self.appid,
+            "toWxid": to_wxid,
+            "content": content,
+        }
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{self.base_url}/message/postText",
+                headers=self.headers,
+                json=payload
+            ) as resp:
+                json_blob = await resp.json()
+                logger.debug(f"发送消息结果: {json_blob}")
+                
+    async def post_image(self, to_wxid, image_url: str):
+        payload = {
+            "appId": self.appid,
+            "toWxid": to_wxid,
+            "imgUrl": image_url,
+        }
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{self.base_url}/message/postImage",
+                headers=self.headers,
+                json=payload
+            ) as resp:
+                json_blob = await resp.json()
+                logger.debug(f"发送图片结果: {json_blob}")
+                
+    async def post_voice(self, to_wxid, voice_url: str, voice_duration: int):
+        payload = {
+            "appId": self.appid,
+            "toWxid": to_wxid,
+            "voiceUrl": voice_url,
+            "voiceDuration": voice_duration
+        }
+        
+        logger.debug(f"发送语音: {payload}")
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{self.base_url}/message/postVoice",
+                headers=self.headers,
+                json=payload
+            ) as resp:
+                json_blob = await resp.json()
+                logger.debug(f"发送语音结果: {json_blob}")
--- a/astrbot/core/platform/sources/gewechat/downloader.py
+++ b/astrbot/core/platform/sources/gewechat/downloader.py
@@ -0,0 +1,51 @@
+from astrbot import logger
+import aiohttp
+import json
+
+class GeweDownloader():
+    def __init__(self, base_url: str, download_base_url: str, token: str):
+        self.base_url = base_url
+        self.download_base_url = download_base_url
+        self.headers = {
+            "Content-Type": "application/json",
+            "X-GEWE-TOKEN": token
+        }
+    
+    async def _post_json(self, baseurl: str, route: str, payload: dict):
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{baseurl}{route}",
+                headers=self.headers,
+                json=payload
+            ) as resp:
+                return await resp.read()
+            
+    async def download_voice(self, appid: str, xml: str, msg_id: str):
+        payload = {
+            "appId": appid,
+            "xml": xml,
+            "msgId": msg_id
+        }
+        return await self._post_json(self.base_url, "/message/downloadVoice", payload)
+    
+    async def download_image(self, appid: str, xml: str) -> str:
+        '''返回一个可下载的 URL'''
+        choices = [2, 3] #  2:常规图片 3:缩略图
+        
+        for choice in choices:
+            try:
+                payload = {
+                    "appId": appid,
+                    "xml": xml,
+                    "type": choice
+                }
+                data = await self._post_json(self.base_url, "/message/downloadImage", payload)
+                json_blob = json.loads(data)
+                if 'fileUrl' in json_blob['data']:
+                    return self.download_base_url + json_blob['data']['fileUrl']
+
+            except BaseException as e:
+                logger.error(f"gewe download image: {e}")
+                continue
+        
+        raise Exception("无法下载图片")
--- a/astrbot/core/platform/sources/gewechat/gewechat_event.py
+++ b/astrbot/core/platform/sources/gewechat/gewechat_event.py
@@ -0,0 +1,102 @@
+import wave
+import uuid
+import os
+from astrbot.core.utils.io import save_temp_img, download_image_by_url, download_file
+from astrbot.core.utils.tencent_record_helper import wav_to_tencent_silk
+from astrbot.api import logger
+from astrbot.api.event import AstrMessageEvent, MessageChain
+from astrbot.api.platform import AstrBotMessage, PlatformMetadata
+from astrbot.api.message_components import Plain, Image, Record
+from .client import SimpleGewechatClient
+
+def get_wav_duration(file_path):
+    with wave.open(file_path, 'rb') as wav_file:
+        file_size = os.path.getsize(file_path)
+        n_channels, sampwidth, framerate, n_frames = wav_file.getparams()[:4]
+        if n_frames == 2147483647:
+            duration = (file_size - 44) / (n_channels * sampwidth * framerate)
+        else:
+            duration = n_frames / float(framerate)
+        return duration
+
+class GewechatPlatformEvent(AstrMessageEvent):
+    def __init__(
+            self, 
+            message_str: str, 
+            message_obj: AstrBotMessage, 
+            platform_meta: PlatformMetadata, 
+            session_id: str,
+            client: SimpleGewechatClient
+        ):
+        super().__init__(message_str, message_obj, platform_meta, session_id)
+        self.client = client
+        
+    @staticmethod
+    async def send_with_client(message: MessageChain, user_name: str):
+        pass
+                
+        
+    async def send(self, message: MessageChain):
+        to_wxid = self.message_obj.raw_message.get('to_wxid', None)
+        
+        if not to_wxid:
+            logger.error("无法获取到 to_wxid。")
+            return
+        
+        for comp in message.chain:
+            if isinstance(comp, Plain):
+                await self.client.post_text(to_wxid, comp.text)
+            elif isinstance(comp, Image):
+                img_url = comp.file
+                img_path = ""
+                if img_url.startswith("file:///"):
+                    img_path = img_url[8:]
+                elif comp.file and comp.file.startswith("http"):
+                    img_path = await download_image_by_url(comp.file)
+                else:
+                    img_path = img_url
+                    
+                # 检查 record_path 是否在 data/temp 目录中, record_path 可能是绝对路径
+                temp_directory = os.path.abspath('data/temp')
+                img_path = os.path.abspath(img_path)
+                if os.path.commonpath([temp_directory, img_path]) != temp_directory:
+                    with open(img_path, "rb") as f:
+                        img_path = save_temp_img(f.read())
+
+                file_id = os.path.basename(img_path)
+                img_url = f"{self.client.file_server_url}/{file_id}"
+                logger.debug(f"gewe callback img url: {img_url}")
+                await self.client.post_image(to_wxid, img_url)
+            elif isinstance(comp, Record):
+                # 默认已经存在 data/temp 中
+                record_url = comp.file
+                record_path = ""
+                
+                if record_url.startswith("file:///"):
+                    record_path = record_url[8:]
+                elif record_url.startswith("http"):
+                    await download_file(record_url, f"data/temp/{uuid.uuid4()}.wav")
+                else:
+                    record_path = record_url
+                    
+                silk_path = f"data/temp/{uuid.uuid4()}.silk"
+                duration = await wav_to_tencent_silk(record_path, silk_path)
+                
+                print(f"duration: {duration}, {silk_path}")
+                
+                # 检查 record_path 是否在 data/temp 目录中, record_path 可能是绝对路径
+                # temp_directory = os.path.abspath('data/temp')
+                # record_path = os.path.abspath(record_path)
+                # if os.path.commonpath([temp_directory, record_path]) != temp_directory:
+                #     with open(record_path, "rb") as f:
+                #         record_path = f"data/temp/{uuid.uuid4()}.wav"
+                #         with open(record_path, "wb") as f2:
+                #             f2.write(f.read())
+                
+                if duration == 0:
+                    duration = get_wav_duration(record_path)
+                
+                file_id = os.path.basename(silk_path)
+                record_url = f"{self.client.file_server_url}/{file_id}"
+                await self.client.post_voice(to_wxid, record_url, duration*1000)
+        await super().send(message)
--- a/astrbot/core/platform/sources/gewechat/gewechat_platform_adapter.py
+++ b/astrbot/core/platform/sources/gewechat/gewechat_platform_adapter.py
@@ -0,0 +1,93 @@
+import sys
+import asyncio
+import os
+
+from astrbot.api.platform import Platform, AstrBotMessage, MessageType, PlatformMetadata
+from astrbot.api.event import MessageChain
+from astrbot.api import logger
+from astrbot.core.platform.astr_message_event import MessageSesion
+from ...register import register_platform_adapter
+from .gewechat_event import GewechatPlatformEvent
+from .client import SimpleGewechatClient
+from astrbot.core.message.components import Plain
+
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+            
+
+@register_platform_adapter("gewechat", "基于 gewechat 的 Wechat 适配器")
+class GewechatPlatformAdapter(Platform):
+
+    def __init__(self, platform_config: dict, platform_settings: dict, event_queue: asyncio.Queue) -> None:
+        super().__init__(event_queue)
+        self.config = platform_config
+        self.settingss = platform_settings
+        self.test_mode = os.environ.get('TEST_MODE', 'off') == 'on'
+        self.client = None
+    
+    @override
+    async def send_by_session(self, session: MessageSesion, message_chain: MessageChain):
+        to_wxid = session.session_id
+        if "_" in to_wxid:
+            # 群聊，开启了独立会话
+            _, to_wxid = to_wxid.split("_")
+        
+        if not to_wxid:
+            logger.error("无法获取到 to_wxid。")
+            return
+        
+        for comp in message_chain.chain:
+            if isinstance(comp, Plain):
+                await self.client.post_text(to_wxid, comp.text)
+
+        await super().send_by_session(session, message_chain)
+    
+    @override
+    def meta(self) -> PlatformMetadata:
+        return PlatformMetadata(
+            "gewechat",
+            "基于 gewechat 的 Wechat 适配器",
+        )
+
+    @override
+    def run(self):
+        self.client = SimpleGewechatClient(
+            self.config['base_url'],
+            self.config['nickname'],
+            self.config['host'],
+            self.config['port'],
+            self._event_queue,
+        )
+        
+        async def on_event_received(abm: AstrBotMessage):
+            await self.handle_msg(abm)
+            
+        self.client.on_event_received = on_event_received
+        
+        return self._run()
+    
+    async def logout(self):
+        await self.client.logout()
+    
+    async def _run(self):
+        await self.client.login()
+        
+        await self.client.start_polling()
+        
+    
+    async def handle_msg(self, message: AstrBotMessage):
+        if message.type == MessageType.GROUP_MESSAGE:
+            if self.settingss['unique_session']:
+                message.session_id = message.sender.user_id + "_" + message.group_id
+        
+        message_event = GewechatPlatformEvent(
+            message_str=message.message_str,
+            message_obj=message,
+            platform_meta=self.meta(),
+            session_id=message.session_id,
+            client=self.client
+        )
+        
+        self.commit_event(message_event)
--- a/astrbot/core/platform/sources/qqofficial/qqofficial_message_event.py
+++ b/astrbot/core/platform/sources/qqofficial/qqofficial_message_event.py
@@ -5,7 +5,7 @@ import botpy.types.message
 from astrbot.core.utils.io import file_to_base64, download_image_by_url
 from astrbot.api.event import AstrMessageEvent, MessageChain
 from astrbot.api.platform import AstrBotMessage, PlatformMetadata
-from astrbot.api.message_components import Plain, Image
+from astrbot.api.message_components import Plain, Image, Reply
 from botpy import Client
 from botpy.http import Route

@@ -14,12 +14,33 @@ class QQOfficialMessageEvent(AstrMessageEvent):
    def __init__(self, message_str: str, message_obj: AstrBotMessage, platform_meta: PlatformMetadata, session_id: str, bot: Client):
        super().__init__(message_str, message_obj, platform_meta, session_id)
        self.bot = bot
+        self.send_buffer = None
        
    async def send(self, message: MessageChain):
+        if not self.send_buffer:
+            self.send_buffer = message
+        else:
+            self.send_buffer.chain.extend(message.chain)
+
+    async def _post_send(self):
+        '''QQ 官方 API 仅支持回复一次'''
        source = self.message_obj.raw_message
        assert isinstance(source, (botpy.message.Message, botpy.message.GroupMessage, botpy.message.DirectMessage, botpy.message.C2CMessage))
        
-        plain_text, image_base64, image_path = await QQOfficialMessageEvent._parse_to_qqofficial(message)
+        plain_text, image_base64, image_path = await QQOfficialMessageEvent._parse_to_qqofficial(self.send_buffer)
+        
+        ref = None
+        for i in self.send_buffer.chain:
+            if isinstance(i, Reply):
+                try:
+                    ref = self.message_obj.raw_message.message_reference
+                    ref = botpy.types.message.Reference(
+                        message_id=ref.message_id,
+                        ignore_get_message_error=False
+                    )
+                except BaseException as _:
+                    pass
+                break
        
        payload = {
            'content': plain_text,
@@ -28,27 +49,37 @@ class QQOfficialMessageEvent(AstrMessageEvent):
        
        match type(source):
            case botpy.message.GroupMessage:
+                if ref:
+                    payload['message_reference'] = ref
                if image_base64:
                    media = await self.upload_group_and_c2c_image(image_base64, 1, group_openid=source.group_openid)
                    payload['media'] = media
                    payload['msg_type'] = 7
                await self.bot.api.post_group_message(group_openid=source.group_openid, **payload)
            case botpy.message.C2CMessage:
+                if ref:
+                    payload['message_reference'] = ref
                if image_base64:
                    media = await self.upload_group_and_c2c_image(image_base64, 1, openid=source.author.user_openid)
                    payload['media'] = media
                    payload['msg_type'] = 7
                await self.bot.api.post_c2c_message(openid=source.author.user_openid, **payload)
            case botpy.message.Message:
+                if ref:
+                    payload['message_reference'] = ref
                if image_path:
                    payload['file_image'] = image_path
                await self.bot.api.post_message(channel_id=source.channel_id, **payload)
            case botpy.message.DirectMessage:
+                if ref:
+                    payload['message_reference'] = ref
                if image_path:
                    payload['file_image'] = image_path
                await self.bot.api.post_dms(guild_id=source.guild_id, **payload)

-        await super().send(message)
+        await super().send(self.send_buffer)
+        
+        self.send_buffer = None
            
    async def upload_group_and_c2c_image(self, image_base64: str, file_type: int, **kwargs) -> botpy.types.message.Media:
        payload = {
@@ -80,4 +111,7 @@ class QQOfficialMessageEvent(AstrMessageEvent):
                elif i.file and i.file.startswith("http"):
                    image_file_path = await download_image_by_url(i.file)
                    image_base64 = file_to_base64(image_file_path).replace("base64://", "")
+                else:
+                    image_base64 = file_to_base64(i.file).replace("base64://", "")
+                    image_file_path = i.file
        return plain_text, image_base64, image_file_path
--- a/astrbot/core/platform/sources/webchat/webchat_adapter.py
+++ b/astrbot/core/platform/sources/webchat/webchat_adapter.py
@@ -38,11 +38,13 @@ class WebChatAdapter(Platform):
        )
        
    async def send_by_session(self, session: MessageSesion, message_chain: MessageChain):
+        # abm.session_id = f"webchat!{username}!{cid}"
        plain = ""
+        cid = session.session_id.split("!")[-1]
        for comp in message_chain.chain:
            if isinstance(comp, Plain):
                plain += comp.text
-        web_chat_back_queue.put_nowait(plain)
+        web_chat_back_queue.put_nowait((plain, cid))
        
        await super().send_by_session(session, message_chain)
        
--- a/astrbot/core/platform/sources/webchat/webchat_event.py
+++ b/astrbot/core/platform/sources/webchat/webchat_event.py
@@ -16,9 +16,11 @@ class WebChatMessageEvent(AstrMessageEvent):
            web_chat_back_queue.put_nowait(None)
            return
        
+        cid = self.session_id.split("!")[-1]
+        
        for comp in message.chain:
            if isinstance(comp, Plain):
-                web_chat_back_queue.put_nowait(comp.text)
+                web_chat_back_queue.put_nowait((comp.text, cid))
            elif isinstance(comp, Image):
                # save image to local
                filename = str(uuid.uuid4()) + ".jpg"
@@ -30,6 +32,10 @@ class WebChatMessageEvent(AstrMessageEvent):
                            f.write(f2.read())
                elif comp.file and comp.file.startswith("http"):
                    await download_image_by_url(comp.file, path=path)
-                web_chat_back_queue.put_nowait(f"[IMAGE]{filename}")
+                else:
+                    with open(path, "wb") as f:
+                        with open(comp.file, "rb") as f2:
+                            f.write(f2.read())
+                web_chat_back_queue.put_nowait((f"[IMAGE]{filename}", cid))
        web_chat_back_queue.put_nowait(None)
        await super().send(message)
--- a/astrbot/core/provider/entites.py
+++ b/astrbot/core/provider/entites.py
@@ -2,6 +2,8 @@ import enum
 from dataclasses import dataclass, field
 from typing import List, Dict, Type
 from .func_tool_manager import FuncCall
+from openai.types.chat.chat_completion import ChatCompletion
+from astrbot.core.db.po import Conversation


 class ProviderType(enum.Enum):
@@ -17,6 +19,11 @@ class ProviderMetaData():
    '''提供商适配器描述.'''
    provider_type: ProviderType = ProviderType.CHAT_COMPLETION
    cls_type: Type = None
+    
+    default_config_tmpl: dict = None
+    '''平台的默认配置模板'''
+    provider_display_name: str = None
+    '''显示在 WebUI 配置页中的提供商名称，如空则是 type'''

@dataclass
 class ProviderRequest():
@@ -32,10 +39,15 @@ class ProviderRequest():
    '''上下文。格式与 openai 的上下文格式一致：
    参考 https://platform.openai.com/docs/api-reference/chat/create#chat-create-messages
    '''
-    
    system_prompt: str = ""
    '''系统提示词'''
+    conversation: Conversation = None
    
+    def __repr__(self):
+        return f"ProviderRequest(prompt={self.prompt}, session_id={self.session_id}, image_urls={self.image_urls}, func_tool={self.func_tool}, contexts={self.contexts}, system_prompt={self.system_prompt})"
+    
+    def __str__(self):
+        return self.__repr__()
    
@dataclass
 class LLMResponse:
@@ -46,4 +58,7 @@ class LLMResponse:
    tools_call_args: List[Dict[str, any]] = field(default_factory=list)
    '''工具调用参数'''
    tools_call_name: List[str] = field(default_factory=list)
-    '''工具调用名称'''
+    '''工具调用名称'''
+    
+    raw_completion: ChatCompletion = None
+    _new_record: Dict[str, any] = None
--- a/astrbot/core/provider/func_tool_manager.py
+++ b/astrbot/core/provider/func_tool_manager.py
@@ -108,14 +108,21 @@ class FuncCall:
        for f in self.func_list:
            if not f.active:
                continue
-            tools.append(
-                {
-                    "name": f.name,
-                    "parameters": f.parameters,
-                    "description": f.description,
-                }
-            )
-        declarations["function_declarations"] = tools
+
+            func_declaration = {
+                "name": f.name,
+                "description": f.description
+            }
+
+            # 检查并添加非空的properties参数
+            params = f.parameters if isinstance(f.parameters, dict) else {}
+            if params.get("properties", {}):
+                func_declaration["parameters"] = params
+
+            tools.append(func_declaration)
+
+        if tools:
+            declarations["function_declarations"] = tools
        return declarations
        

--- a/astrbot/core/provider/manager.py
+++ b/astrbot/core/provider/manager.py
@@ -1,6 +1,7 @@
 import traceback
+import uuid
 from astrbot.core.config.astrbot_config import AstrBotConfig
-from .provider import Provider, STTProvider
+from .provider import Provider, STTProvider, TTSProvider, Personality
 from .entites import ProviderType
 from typing import List
 from astrbot.core.db import BaseDatabase
@@ -13,30 +14,101 @@ class ProviderManager():
        self.providers_config: List = config['provider']
        self.provider_settings: dict = config['provider_settings']
        self.provider_stt_settings: dict = config.get('provider_stt_settings', {})
+        self.provider_tts_settings: dict = config.get('provider_tts_settings', {})
+        self.persona_configs: list = config.get('persona', [])
+        
+        # 人格情景管理
+        # 目前没有拆成独立的模块
+        self.default_persona_name = self.provider_settings.get('default_personality', 'default')
+        self.personas: List[Personality] = []
+        self.selected_default_persona = None
+        for persona in self.persona_configs:
+            begin_dialogs = persona.get("begin_dialogs", [])
+            mood_imitation_dialogs = persona.get("mood_imitation_dialogs", [])
+            bd_processed = []
+            mid_processed = ""
+            if begin_dialogs:
+                if len(begin_dialogs) % 2 != 0:
+                    logger.error(f"{persona['name']} 人格情景预设对话格式不对，条数应该为偶数。")
+                    begin_dialogs = []
+                user_turn = True
+                for dialog in begin_dialogs:
+                    bd_processed.append({
+                        "role": "user" if user_turn else "assistant",
+                        "content": dialog,
+                        "_no_save": None # 不持久化到 db
+                    })
+                    user_turn = not user_turn
+            if mood_imitation_dialogs:
+                if len(mood_imitation_dialogs) % 2 != 0:
+                    logger.error(f"{persona['name']} 对话风格对话格式不对，条数应该为偶数。")
+                    mood_imitation_dialogs = []
+                user_turn = True
+                for dialog in mood_imitation_dialogs:
+                    role = "A" if user_turn else "B"
+                    mid_processed += f"{role}: {dialog}\n"
+                    if not user_turn:
+                        mid_processed += '\n'
+                    user_turn = not user_turn
+            
+            try:
+                persona = Personality(
+                    **persona, 
+                    _begin_dialogs_processed=bd_processed,
+                    _mood_imitation_dialogs_processed=mid_processed
+                )
+                if persona['name'] == self.default_persona_name:
+                    self.selected_default_persona = persona
+                self.personas.append(persona)
+            except Exception as e:
+                logger.error(f"解析 Persona 配置失败：{e}")
+        
+        if not self.selected_default_persona and len(self.personas) > 0:
+            # 默认选择第一个
+            self.selected_default_persona = self.personas[0]
+            
+        if not self.selected_default_persona:
+            self.selected_default_persona = Personality(
+                prompt="You are a helpful and friendly assistant.",
+                name="default",
+                _begin_dialogs_processed=[],
+                _mood_imitation_dialogs_processed=""
+            )
+            self.personas.append(self.selected_default_persona)
+                
        
        self.provider_insts: List[Provider] = []
        '''加载的 Provider 的实例'''
        self.stt_provider_insts: List[STTProvider] = []
        '''加载的 Speech To Text Provider 的实例'''
+        self.tts_provider_insts: List[TTSProvider] = []
+        '''加载的 Text To Speech Provider 的实例'''
        self.llm_tools = llm_tools
        self.curr_provider_inst: Provider = None
        '''当前使用的 Provider 实例'''
        self.curr_stt_provider_inst: STTProvider = None
        '''当前使用的 Speech To Text Provider 实例'''
+        self.curr_tts_provider_inst: TTSProvider = None
+        '''当前使用的 Text To Speech Provider 实例'''
        self.loaded_ids = defaultdict(bool)
        self.db_helper = db_helper
        
+        # kdb(experimental)
        self.curr_kdb_name = ""
        kdb_cfg = config.get("knowledge_db", {})
        if kdb_cfg and len(kdb_cfg):
            self.curr_kdb_name = list(kdb_cfg.keys())[0]
        
+        changed = False
        for provider_cfg in self.providers_config:
            if not provider_cfg['enable']:
                continue
            
            if provider_cfg['id'] in self.loaded_ids:
-                raise ValueError(f"Provider ID 重复：{provider_cfg['id']}。")
+                new_id = f"{provider_cfg['id']}_{str(uuid.uuid4())[:8]}"
+                logger.info(f"Provider ID 重复：{provider_cfg['id']}。已自动更改为 {new_id}。")
+                provider_cfg['id'] = new_id
+                changed = True
            self.loaded_ids[provider_cfg['id']] = True
            
            try:
@@ -56,25 +128,37 @@ class ProviderManager():
                        from .sources.whisper_api_source import ProviderOpenAIWhisperAPI # noqa: F401
                    case "openai_whisper_selfhost":
                        from .sources.whisper_selfhosted_source import ProviderOpenAIWhisperSelfHost # noqa: F401
+                    case "openai_tts_api":
+                        from .sources.openai_tts_api_source import ProviderOpenAITTSAPI # noqa: F401
            except (ImportError, ModuleNotFoundError) as e:
                logger.critical(f"加载 {provider_cfg['type']}({provider_cfg['id']}) 提供商适配器失败：{e}。可能是因为有未安装的依赖。")
                continue
            except Exception as e:
                logger.critical(f"加载 {provider_cfg['type']}({provider_cfg['id']}) 提供商适配器失败：{e}。未知原因")
                continue
-            
+        
+        if changed:
+            try:
+                config.save_config()
+            except Exception as e:
+                logger.warning(f"保存配置文件失败：{e}")
+
    async def initialize(self):
+        
+        selected_provider_id = sp.get("curr_provider")
+        selected_stt_provider_id = self.provider_stt_settings.get("provider_id")
+        selected_tts_provider_id = self.provider_settings.get("provider_id")
+        provider_enabled = self.provider_settings.get("enable", False)
+        stt_enabled = self.provider_stt_settings.get("enable", False)
+        tts_enabled = self.provider_tts_settings.get("enable", False)
+            
        for provider_config in self.providers_config:
            if not provider_config['enable']:
                continue
            if provider_config['type'] not in provider_cls_map:
                logger.error(f"未找到适用于 {provider_config['type']}({provider_config['id']}) 的提供商适配器，请检查是否已经安装或者名称填写错误。已跳过。")
                continue
-            selected_provider_id = sp.get("curr_provider")
-            selected_stt_provider_id = self.provider_stt_settings.get("provider_id")
-            provider_enabled = self.provider_settings.get("enable", False)
-            stt_enabled = self.provider_stt_settings.get("enable", False)
-            
+
            provider_metadata = provider_cls_map[provider_config['type']]
            logger.info(f"尝试实例化 {provider_config['type']}({provider_config['id']}) 提供商适配器 ...")
            try:
@@ -91,10 +175,28 @@ class ProviderManager():
                    if selected_stt_provider_id == provider_config['id'] and stt_enabled:
                        self.curr_stt_provider_inst = inst
                        logger.info(f"已选择 {provider_config['type']}({provider_config['id']}) 作为当前语音转文本提供商适配器。")
+                        
+                elif provider_metadata.provider_type == ProviderType.TEXT_TO_SPEECH:
+                    # TTS 任务
+                    inst = provider_metadata.cls_type(provider_config, self.provider_settings)
+                    
+                    if getattr(inst, "initialize", None):
+                        await inst.initialize()
+                    
+                    self.tts_provider_insts.append(inst)
+                    if selected_tts_provider_id == provider_config['id'] and tts_enabled:
+                        self.curr_tts_provider_inst = inst
+                        logger.info(f"已选择 {provider_config['type']}({provider_config['id']}) 作为当前文本转语音提供商适配器。")
                    
                elif provider_metadata.provider_type == ProviderType.CHAT_COMPLETION:
                    # 文本生成任务
-                    inst = provider_metadata.cls_type(provider_config, self.provider_settings, self.db_helper, self.provider_settings.get('persistant_history', True))
+                    inst = provider_metadata.cls_type(
+                        provider_config, 
+                        self.provider_settings, 
+                        self.db_helper,
+                        self.provider_settings.get('persistant_history', True),
+                        self.selected_default_persona
+                    )
                    
                    if getattr(inst, "initialize", None):
                        await inst.initialize()
@@ -114,11 +216,18 @@ class ProviderManager():
        if len(self.stt_provider_insts) > 0 and not self.curr_stt_provider_inst and stt_enabled:
            self.curr_stt_provider_inst = self.stt_provider_insts[0]
            
+        if len(self.tts_provider_insts) > 0 and not self.curr_tts_provider_inst and tts_enabled:
+            self.curr_tts_provider_inst = self.tts_provider_insts[0]
+            
        if not self.curr_provider_inst:
            logger.warning("未启用任何用于 文本生成 的提供商适配器。")
-        if self.provider_stt_settings.get("enable"):
-            if not self.curr_stt_provider_inst:
+            
+        if stt_enabled and not self.curr_stt_provider_inst:
                logger.warning("未启用任何用于 语音转文本 的提供商适配器。")
+        
+        if tts_enabled and not self.curr_tts_provider_inst:
+                logger.warning("未启用任何用于 文本转语音 的提供商适配器。")
+        

    def get_insts(self):
        return self.provider_insts
--- a/astrbot/core/provider/provider.py
+++ b/astrbot/core/provider/provider.py
@@ -8,48 +8,31 @@ from typing import TypedDict
 from astrbot.core.provider.func_tool_manager import FuncCall
 from astrbot.core.provider.entites import LLMResponse
 from dataclasses import dataclass
+
+
 class Personality(TypedDict):
    prompt: str = ""
    name: str = ""
+    begin_dialogs: List[str] = []
+    mood_imitation_dialogs: List[str] = []
+    
+    # cache
+    _begin_dialogs_processed: List[dict] = []
+    _mood_imitation_dialogs_processed: str = ""
+    
    
@dataclass
 class ProviderMeta():
    id: str
    model: str
    type: str
-
-
-class Provider(abc.ABC):
-    def __init__(
-        self, 
-        provider_config: dict,
-        provider_settings: dict, 
-        persistant_history: bool = True,
-        db_helper: BaseDatabase = None
-    ) -> None:
+    
+    
+class AbstractProvider(abc.ABC):
+    def __init__(self, provider_config: dict) -> None:
+        super().__init__()
        self.model_name = ""
-        '''当前使用的模型名称'''
-        
-        self.session_memory = defaultdict(list)
-        '''维护了 session_id 的上下文，**不包含 system 指令**。'''
-        
        self.provider_config = provider_config
-        
-        self.provider_settings = provider_settings
-        
-        self.curr_personality = Personality(prompt=provider_settings['default_personality'])
-        '''维护了当前的使用的 persona，即人格。'''
-        
-        self.db_helper = db_helper
-        '''用于持久化的数据库操作对象。'''
-
-        if persistant_history:
-            # 读取历史记录
-            try:
-                for history in db_helper.get_llm_history(provider_type=provider_config['type']):
-                    self.session_memory[history.session_id] = json.loads(history.content)
-            except BaseException as e:
-                logger.warning(f"读取 LLM 对话历史记录 失败：{e}。仍可正常使用。")

    def set_model(self, model_name: str):
        '''设置当前使用的模型名称'''
@@ -59,6 +42,31 @@ class Provider(abc.ABC):
        '''获得当前使用的模型名称'''
        return self.model_name
    
+    def meta(self) -> ProviderMeta:
+        '''获取 Provider 的元数据'''
+        return ProviderMeta(
+            id=self.provider_config['id'],
+            model=self.get_model(),
+            type=self.provider_config['type']
+        )
+
+
+class Provider(AbstractProvider):
+    def __init__(
+        self, 
+        provider_config: dict,
+        provider_settings: dict, 
+        persistant_history: bool = True,
+        db_helper: BaseDatabase = None,
+        default_persona: Personality = None
+    ) -> None:
+        super().__init__(provider_config)
+        
+        self.provider_settings = provider_settings
+        
+        self.curr_personality: Personality = default_persona
+        '''维护了当前的使用的 persona，即人格。可能为 None'''
+
    @abc.abstractmethod
    def get_current_key(self) -> str:
        raise NotImplementedError()
@@ -76,22 +84,6 @@ class Provider(abc.ABC):
        '''获得支持的模型列表'''
        raise NotImplementedError()
    
-    @abc.abstractmethod
-    async def get_human_readable_context(self, session_id: str, page: int, page_size: int):
-        '''获取人类可读的上下文
-        
-        page 从 1 开始
-
-        Example:
-            
-            ["User: 你好", "Assistant: 你好！"]
-            
-        Return:
-            contexts: List[str]: 上下文列表
-            total_pages: int: 总页数
-        '''
-        raise NotImplementedError()
-    
    @abc.abstractmethod
    async def text_chat(self,
                        prompt: str,
@@ -105,37 +97,40 @@ class Provider(abc.ABC):
        
        Args:
            prompt: 提示词
-            session_id: 会话 ID
+            session_id: 会话 ID(此属性已经被废弃)
            image_urls: 图片 URL 列表
            tools: Function-calling 工具
            contexts: 上下文
            kwargs: 其他参数
            
        Notes:
-            - 如果传入了 contexts，将会提前加上上下文。否则使用 session_memory 中的上下文。
-            - 可以选择性地传入 session_id，如果传入了 session_id，将会使用 session_id 对应的上下文进行对话，
-            并且也会记录相应的对话上下文，实现多轮对话。如果不传入则不会记录上下文。
            - 如果传入了 image_urls，将会在对话时附上图片。如果模型不支持图片输入，将会抛出错误。
            - 如果传入了 tools，将会使用 tools 进行 Function-calling。如果模型不支持 Function-calling，将会抛出错误。
        '''
        raise NotImplementedError()
-    
-    @abc.abstractmethod
-    async def forget(self, session_id: str) -> bool:
-        '''重置某一个 session_id 的上下文'''
-        raise NotImplementedError()

-    def meta(self) -> ProviderMeta:
-        '''获取 Provider 的元数据'''
-        return ProviderMeta(
-            id=self.provider_config['id'],
-            model=self.get_model(),
-            type=self.provider_config['type']
-        )
+    async def pop_record(self, context: List):
+        '''
+        弹出 context 第一条非系统提示词对话记录
+        '''
+        poped = 0
+        indexs_to_pop = []
+        for idx, record in enumerate(context):
+            if record["role"] == "system":
+                continue
+            else:
+                indexs_to_pop.append(idx)
+                poped += 1
+                if poped == 2:
+                    break
+                
+        for idx in reversed(indexs_to_pop):
+            context.pop(idx)
+
        
-        
-class STTProvider():
+class STTProvider(AbstractProvider):
    def __init__(self, provider_config: dict, provider_settings: dict) -> None:
+        super().__init__(provider_config)
        self.provider_config = provider_config
        self.provider_settings = provider_settings
    
@@ -143,19 +138,15 @@ class STTProvider():
    async def get_text(self, audio_url: str) -> str:
        '''获取音频的文本'''
        raise NotImplementedError()
+
+
+class TTSProvider(AbstractProvider):
+    def __init__(self, provider_config: dict, provider_settings: dict) -> None:
+        super().__init__(provider_config)
+        self.provider_config = provider_config
+        self.provider_settings = provider_settings
    
-    def set_model(self, model_name: str):
-        '''设置当前使用的模型名称'''
-        self.model_name = model_name
-    
-    def get_model(self) -> str:
-        '''获取当前使用的模型'''
-        return self.provider_config.get("model", "")
-    
-    def meta(self) -> ProviderMeta:
-        '''获取 Provider 的元数据'''
-        return ProviderMeta(
-            id=self.provider_config['id'],
-            model=self.get_model(),
-            type=self.provider_config['type']
-        )
+    @abc.abstractmethod
+    async def get_audio(self, text: str) -> str:
+        '''获取文本的音频，返回音频文件路径'''
+        raise NotImplementedError()
--- a/astrbot/core/provider/register.py
+++ b/astrbot/core/provider/register.py
@@ -13,22 +13,35 @@ llm_tools = FuncCall()
 def register_provider_adapter(
    provider_type_name: str, 
    desc: str, 
-    provider_type: ProviderType = ProviderType.CHAT_COMPLETION
+    provider_type: ProviderType = ProviderType.CHAT_COMPLETION,
+    default_config_tmpl: dict = None,
+    provider_display_name: str = None
 ):
    '''用于注册平台适配器的带参装饰器'''
    def decorator(cls):
        if provider_type_name in provider_cls_map:
            raise ValueError(f"检测到大模型提供商适配器 {provider_type_name} 已经注册，可能发生了大模型提供商适配器类型命名冲突。")
+        
+        # 添加必备选项
+        if default_config_tmpl:
+            if 'type' not in default_config_tmpl:
+                default_config_tmpl['type'] = provider_type_name
+            if 'enable' not in default_config_tmpl:
+                default_config_tmpl['enable'] = False
+            if 'id' not in default_config_tmpl:
+                default_config_tmpl['id'] = provider_type_name

        pm = ProviderMetaData(
            type=provider_type_name,
            desc=desc,
            provider_type=provider_type,
-            cls_type=cls
+            cls_type=cls,
+            default_config_tmpl=default_config_tmpl,
+            provider_display_name=provider_display_name
        )
        provider_registry.append(pm)
        provider_cls_map[provider_type_name] = pm
-        logger.debug(f"Provider {provider_type_name} 已注册")
+        logger.debug(f"服务提供商 Provider {provider_type_name} 已注册")
        return cls
    
    return decorator
--- a/astrbot/core/provider/sources/dify_source.py
+++ b/astrbot/core/provider/sources/dify_source.py
@@ -1,5 +1,5 @@
 from typing import List
-from .. import Provider
+from .. import Provider, Personality
 from ..entites import LLMResponse
 from ..func_tool_manager import FuncCall
 from astrbot.core.db import BaseDatabase
@@ -16,9 +16,10 @@ class ProviderDify(Provider):
        provider_settings: dict,
        db_helper: BaseDatabase,
        persistant_history=False,
+        default_persona: Personality=None
    ) -> None:
        super().__init__(
-            provider_config, provider_settings, persistant_history, db_helper
+            provider_config, provider_settings, persistant_history, db_helper, default_persona
        )
        self.api_key = provider_config.get("dify_api_key", "")
        if not self.api_key:
@@ -38,7 +39,7 @@ class ProviderDify(Provider):
        self,
        prompt: str,
        session_id: str = None,
-        image_urls: List[str] = None,
+        image_urls: List[str] = [],
        func_tool: FuncCall = None,
        contexts: List = None,
        system_prompt: str = None,
@@ -63,8 +64,6 @@ class ProviderDify(Provider):
            else:
                # TODO: 处理更多情况
                logger.warning(f"未知的图片链接：{image_url}，图片将忽略。")
-            
-        logger.debug(files_payload)
        
        # 获得会话变量
        session_vars = sp.get("session_variables", {})
@@ -114,7 +113,6 @@ class ProviderDify(Provider):
                            result = chunk['data']['outputs'][self.workflow_output_key]
            case _:
                raise Exception(f"未知的 Dify API 类型：{self.api_type}")
-
        return LLMResponse(role="assistant", completion_text=result)

    async def forget(self, session_id):
--- a/astrbot/core/provider/sources/gemini_source.py
+++ b/astrbot/core/provider/sources/gemini_source.py
@@ -1,10 +1,8 @@
-import traceback
 import base64
-import json
 import aiohttp
 from astrbot.core.utils.io import download_image_by_url
 from astrbot.core.db import BaseDatabase
-from astrbot.api.provider import Provider
+from astrbot.api.provider import Provider, Personality
 from astrbot import logger
 from astrbot.core.provider.func_tool_manager import FuncCall
 from typing import List
@@ -12,17 +10,18 @@ from ..register import register_provider_adapter
 from astrbot.core.provider.entites import LLMResponse

 class SimpleGoogleGenAIClient():
-    def __init__(self, api_key: str, api_base: str):
+    def __init__(self, api_key: str, api_base: str, timeout: int=120) -> None:
        self.api_key = api_key
        if api_base.endswith("/"):
            self.api_base = api_base[:-1]
        else:
            self.api_base = api_base
-        self.client = aiohttp.ClientSession()
+        self.client = aiohttp.ClientSession(trust_env=True)
+        self.timeout = timeout
        
    async def models_list(self) -> List[str]:
        request_url = f"{self.api_base}/v1beta/models?key={self.api_key}"
-        async with self.client.get(request_url, timeout=10) as resp:
+        async with self.client.get(request_url, timeout=self.timeout) as resp:
            response = await resp.json()
            
            models = []
@@ -48,7 +47,7 @@ class SimpleGoogleGenAIClient():
        payload["contents"] = contents
        logger.debug(f"payload: {payload}")
        request_url = f"{self.api_base}/v1beta/models/{model}:generateContent?key={self.api_key}"
-        async with self.client.post(request_url, json=payload, timeout=10) as resp:
+        async with self.client.post(request_url, json=payload, timeout=self.timeout) as resp:
            response = await resp.json()
            return response

@@ -60,76 +59,32 @@ class ProviderGoogleGenAI(Provider):
        provider_config: dict, 
        provider_settings: dict,
        db_helper: BaseDatabase, 
-        persistant_history = True
+        persistant_history = True,
+        default_persona: Personality=None
    ) -> None:
-        super().__init__(provider_config, provider_settings, persistant_history, db_helper)
+        super().__init__(provider_config, provider_settings, persistant_history, db_helper, default_persona)
        self.chosen_api_key = None
        self.api_keys: List = provider_config.get("key", [])
        self.chosen_api_key = self.api_keys[0] if len(self.api_keys) > 0 else None
-        
+        self.timeout = provider_config.get("timeout", 180)
+        if isinstance(self.timeout, str):
+            self.timeout = int(self.timeout)
        self.client = SimpleGoogleGenAIClient(
            api_key=self.chosen_api_key,
-            api_base=provider_config.get("api_base", None)
+            api_base=provider_config.get("api_base", None),
+            timeout=self.timeout
        )
        self.set_model(provider_config['model_config']['model'])
-    
-    async def get_human_readable_context(self, session_id, page, page_size):
-        if session_id not in self.session_memory:
-            raise Exception("会话 ID 不存在")
-        contexts = []
-        temp_contexts = []
-        for record in self.session_memory[session_id]:
-            if record['role'] == "user":
-                temp_contexts.append(f"User: {record['content']}")
-            elif record['role'] == "assistant":
-                temp_contexts.append(f"Assistant: {record['content']}")
-                contexts.insert(0, temp_contexts)
-                temp_contexts = []
-
-        # 展平 contexts 列表
-        contexts = [item for sublist in contexts for item in sublist]
-
-        # 计算分页
-        paged_contexts = contexts[(page-1)*page_size:page*page_size]
-        total_pages = len(contexts) // page_size
-        if len(contexts) % page_size != 0:
-            total_pages += 1
-        
-        return paged_contexts, total_pages

    async def get_models(self):
        return await self.client.models_list()
    
-    async def pop_record(self, session_id: str, pop_system_prompt: bool = False):
-        '''
-        弹出第一条记录
-        '''
-        if session_id not in self.session_memory:
-            raise Exception("会话 ID 不存在")
-
-        if len(self.session_memory[session_id]) == 0:
-            return None
-
-        for i in range(len(self.session_memory[session_id])):
-            # 检查是否是 system prompt
-            if not pop_system_prompt and self.session_memory[session_id][i]['user']['role'] == "system":
-                # 如果只有一个 system prompt，才不删掉
-                f = False
-                for j in range(i+1, len(self.session_memory[session_id])):
-                    if self.session_memory[session_id][j]['user']['role'] == "system":
-                        f = True
-                        break
-                if not f:
-                    continue
-            record = self.session_memory[session_id].pop(i)
-            break
-
-        return record
-    
    async def _query(self, payloads: dict, tools: FuncCall) -> LLMResponse:
        tool = None
        if tools:
            tool = tools.get_func_desc_google_genai_style()
+            if not tool:
+                tool = None
        
        system_instruction = ""
        for message in payloads["messages"]:
@@ -178,6 +133,9 @@ class ProviderGoogleGenAI(Provider):
        )
        logger.debug(f"result: {result}")
        
+        if "candidates" not in result:
+            raise Exception("Gemini 返回异常结果: " + str(result))
+        
        candidates = result["candidates"][0]['content']['parts']
        llm_response = LLMResponse("assistant")
        for candidate in candidates:
@@ -187,67 +145,67 @@ class ProviderGoogleGenAI(Provider):
                llm_response.role = "tool"
                llm_response.tools_call_args.append(candidate['functionCall']['args'])
                llm_response.tools_call_name.append(candidate['functionCall']['name'])
-            
+        
+        llm_response.completion_text = llm_response.completion_text.strip()
        return llm_response

-
    async def text_chat(
        self,
        prompt: str,
-        session_id: str,
+        session_id: str = None,
        image_urls: List[str]=None,
        func_tool: FuncCall=None,
-        contexts=None,
+        contexts=[],
        system_prompt=None,
        **kwargs
    ) -> LLMResponse: 
        new_record = await self.assemble_context(prompt, image_urls)
        context_query = []
-        if not contexts:
-            context_query = [*self.session_memory[session_id], new_record]
-        else:
-            context_query = [*contexts, new_record]
+        context_query = [*contexts, new_record]
        if system_prompt:
            context_query.insert(0, {"role": "system", "content": system_prompt})
+            
+        for part in context_query:
+            if '_no_save' in part:
+                del part['_no_save']
+                
+        model_config = self.provider_config.get("model_config", {})
+        model_config['model'] = self.get_model()

        payloads = {
            "messages": context_query,
-            **self.provider_config.get("model_config", {})
+            **model_config
        }
-
+        llm_response = None
        try:
            llm_response = await self._query(payloads, func_tool)
        except Exception as e:
            if "maximum context length" in str(e):
-                logger.warning(f"请求失败：{e}。上下文长度超过限制。尝试弹出最早的记录然后重试。")
-                self.pop_record(session_id)
-            logger.warning(traceback.format_exc())
-            
-        await self.save_history(contexts, new_record, session_id, llm_response)
+                retry_cnt = 20
+                while retry_cnt > 0:
+                    logger.warning(f"请求失败：{e}。上下文长度超过限制。尝试弹出最早的记录然后重试。当前记录条数: {len(context_query)}")
+                    try:
+                        await self.pop_record(context_query)
+                        llm_response = await self._query(payloads, func_tool)
+                        break
+                    except Exception as e:
+                        if "maximum context length" in str(e):
+                            retry_cnt -= 1
+                        else:
+                            raise e
+                if retry_cnt == 0:
+                    llm_response = LLMResponse("err", "err: 请尝试  /reset 重置会话")
+            elif "Function calling is not enabled" in str(e):
+                logger.info(f"{self.get_model()} 不支持函数工具调用，已自动去除，不影响使用。")
+                if 'tools' in payloads:
+                    del payloads['tools']
+                llm_response = await self._query(payloads, None)
+            else:
+                logger.error(f"发生了错误(gemini_source)。Provider 配置如下: {self.provider_config}")
+                
+                raise e

        return llm_response
-    
-    async def save_history(self, contexts: List, new_record: dict, session_id: str, llm_response: LLMResponse):
-        if llm_response.role == "assistant" and session_id:
-            # 文本回复
-            if not contexts:
-                # 添加用户 record
-                self.session_memory[session_id].append(new_record)
-                # 添加 assistant record
-                self.session_memory[session_id].append({
-                    "role": "assistant",
-                    "content": llm_response.completion_text
-                })
-            else:
-                self.session_memory[session_id] = [*contexts, new_record, {
-                    "role": "assistant",
-                    "content": llm_response.completion_text
-                }]
-            self.db_helper.update_llm_history(session_id, json.dumps(self.session_memory[session_id]), self.provider_config['type'])
-        
-    async def forget(self, session_id: str) -> bool:
-        self.session_memory[session_id] = []
-        return True

    def get_current_key(self) -> str:
        return self.client.api_key
@@ -268,8 +226,14 @@ class ProviderGoogleGenAI(Provider):
                if image_url.startswith("http"):
                    image_path = await download_image_by_url(image_url)
                    image_data = await self.encode_image_bs64(image_path)
+                elif image_url.startswith("file:///"):
+                    image_path = image_url.replace("file:///", "")
+                    image_data = await self.encode_image_bs64(image_path)
                else:
                    image_data = await self.encode_image_bs64(image_url)
+                if not image_data:
+                    logger.warning(f"图片 {image_url} 得到的结果为空，将忽略。")
+                    continue
                user_content["content"].append({"type": "image_url", "image_url": {"url": image_data}})
            return user_content
        else:
--- a/astrbot/core/provider/sources/llmtuner_source.py
+++ b/astrbot/core/provider/sources/llmtuner_source.py
@@ -2,7 +2,7 @@ import json
 import os
 from llmtuner.chat import ChatModel
 from typing import List
-from .. import Provider
+from .. import Provider, Personality
 from ..entites import LLMResponse
 from ..func_tool_manager import FuncCall
 from astrbot.core.db import BaseDatabase
@@ -19,9 +19,10 @@ class LLMTunerModelLoader(Provider):
        provider_settings: dict,
        db_helper: BaseDatabase,
        persistant_history=True,
+        default_persona=None,
    ) -> None:
        super().__init__(
-            provider_config, provider_settings, persistant_history, db_helper
+            provider_config, provider_settings, persistant_history, db_helper, default_persona
        )
        if not os.path.exists(provider_config["base_model_path"]) or not os.path.exists(
            provider_config["adapter_model_path"]
@@ -56,25 +57,23 @@ class LLMTunerModelLoader(Provider):
        session_id: str = None,
        image_urls: List[str] = None,
        func_tool: FuncCall = None,
-        contexts: List = None,
+        contexts: List = [],
        system_prompt: str = None,
        **kwargs,
    ) -> LLMResponse:
        system_prompt = ""
-        if not contexts:
-            query_context = [
-                *self.session_memory[session_id],
-                {"role": "user", "content": prompt},
-            ]
-            system_prompt = self.curr_personality["prompt"]
-        else:
-            query_context = [*contexts, {"role": "user", "content": prompt}]
+        new_record = {"role": "user", "content": prompt}
+        query_context = [*contexts, new_record]

        # 提取出系统提示
        system_idxs = []
        for idx, context in enumerate(query_context):
            if context["role"] == "system":
                system_idxs.append(idx)
+                
+            if '_no_save' in context:
+                del context['_no_save']
+            
        for idx in reversed(system_idxs):
            system_prompt += " " + query_context.pop(idx)["content"]

@@ -83,30 +82,15 @@ class LLMTunerModelLoader(Provider):
            "system": system_prompt,
        }
        if func_tool:
-            conf["tools"] = func_tool
+            tool_list = func_tool.get_func_desc_openai_style()
+            if tool_list:
+                conf['tools'] = tool_list

        responses = await self.model.achat(**conf)

-        if session_id:
-            if not contexts:
-                self.session_memory[session_id].append(
-                    {"role": "user", "content": prompt}
-                )
-                self.session_memory[session_id].append(
-                    {"role": "assistant", "content": responses[-1].response_text}
-                )
-            else:
-                self.session_memory[session_id] = [
-                    *contexts,
-                    {"role": "user", "content": prompt},
-                    {"role": "assistant", "content": responses[-1].response_text},
-                ]
-            self.db_helper.update_llm_history(session_id, json.dumps(self.session_memory[session_id]), self.meta().type)
-        return responses[-1].response_text
-
-    async def forget(self, session_id):
-        self.session_memory[session_id] = []
-        return True
+        llm_response = LLMResponse("assistant", responses[-1].response_text)
+                
+        return llm_response

    async def get_current_key(self):
        return "none"
@@ -115,28 +99,4 @@ class LLMTunerModelLoader(Provider):
        pass

    async def get_models(self):
-        return [self.get_model()]
-
-    async def get_human_readable_context(self, session_id, page, page_size):
-        if session_id not in self.session_memory:
-            raise Exception("会话 ID 不存在")
-        contexts = []
-        temp_contexts = []
-        for record in self.session_memory[session_id]:
-            if record["role"] == "user":
-                temp_contexts.append(f"User: {record['content']}")
-            elif record["role"] == "assistant":
-                temp_contexts.append(f"Assistant: {record['content']}")
-                contexts.insert(0, temp_contexts)
-                temp_contexts = []
-
-        # 展平 contexts 列表
-        contexts = [item for sublist in contexts for item in sublist]
-
-        # 计算分页
-        paged_contexts = contexts[(page - 1) * page_size : page * page_size]
-        total_pages = len(contexts) // page_size
-        if len(contexts) % page_size != 0:
-            total_pages += 1
-
-        return paged_contexts, total_pages
+        return [self.get_model()]
--- a/astrbot/core/provider/sources/openai_source.py
+++ b/astrbot/core/provider/sources/openai_source.py
@@ -1,14 +1,14 @@
-import traceback
 import base64
 import json
+import os

-from openai import AsyncOpenAI, NOT_GIVEN
+from openai import AsyncOpenAI, AsyncAzureOpenAI, NOT_GIVEN
 from openai.types.chat.chat_completion import ChatCompletion
-from openai._exceptions import NotFoundError
+from openai._exceptions import NotFoundError, UnprocessableEntityError
 from astrbot.core.utils.io import download_image_by_url

 from astrbot.core.db import BaseDatabase
-from astrbot.api.provider import Provider
+from astrbot.api.provider import Provider, Personality
 from astrbot import logger
 from astrbot.core.provider.func_tool_manager import FuncCall
 from typing import List
@@ -22,43 +22,34 @@ class ProviderOpenAIOfficial(Provider):
        provider_config: dict, 
        provider_settings: dict,
        db_helper: BaseDatabase, 
-        persistant_history = True
+        persistant_history = True,
+        default_persona: Personality = None
    ) -> None:
-        super().__init__(provider_config, provider_settings, persistant_history, db_helper)
+        super().__init__(provider_config, provider_settings, persistant_history, db_helper, default_persona)
        self.chosen_api_key = None
        self.api_keys: List = provider_config.get("key", [])
        self.chosen_api_key = self.api_keys[0] if len(self.api_keys) > 0 else None
-
-        self.client = AsyncOpenAI(
-            api_key=self.chosen_api_key,
-            base_url=provider_config.get("api_base", None),
-            timeout=provider_config.get("timeout", NOT_GIVEN),
-        )
+        self.timeout = provider_config.get("timeout", 120)
+        if isinstance(self.timeout, str):
+            self.timeout = int(self.timeout)
+        # 适配 azure openai #332
+        if "api_version" in provider_config:
+            # 使用 azure api
+            self.client = AsyncAzureOpenAI(
+                api_key=self.chosen_api_key,
+                api_version=provider_config.get("api_version", None),
+                base_url=provider_config.get("api_base", None),
+                timeout=self.timeout
+            )
+        else:
+            # 使用 openai api
+            self.client = AsyncOpenAI(
+                api_key=self.chosen_api_key,
+                base_url=provider_config.get("api_base", None),
+                timeout=self.timeout
+            )
+            
        self.set_model(provider_config['model_config']['model'])
-    
-    async def get_human_readable_context(self, session_id, page, page_size):
-        if session_id not in self.session_memory:
-            raise Exception("会话 ID 不存在")
-        contexts = []
-        temp_contexts = []
-        for record in self.session_memory[session_id]:
-            if record['role'] == "user":
-                temp_contexts.append(f"User: {record['content']}")
-            elif record['role'] == "assistant":
-                temp_contexts.append(f"Assistant: {record['content']}")
-                contexts.insert(0, temp_contexts)
-                temp_contexts = []
-
-        # 展平 contexts 列表
-        contexts = [item for sublist in contexts for item in sublist]
-
-        # 计算分页
-        paged_contexts = contexts[(page-1)*page_size:page*page_size]
-        total_pages = len(contexts) // page_size
-        if len(contexts) % page_size != 0:
-            total_pages += 1
-        
-        return paged_contexts, total_pages

    async def get_models(self):
        try:
@@ -71,53 +62,32 @@ class ProviderOpenAIOfficial(Provider):
        except NotFoundError as e:
            raise Exception(f"获取模型列表失败：{e}")
    
-    async def pop_record(self, session_id: str, pop_system_prompt: bool = False):
-        '''
-        弹出第一条记录
-        '''
-        if session_id not in self.session_memory:
-            raise Exception("会话 ID 不存在")
-
-        if len(self.session_memory[session_id]) == 0:
-            return None
-
-        for i in range(len(self.session_memory[session_id])):
-            # 检查是否是 system prompt
-            if not pop_system_prompt and self.session_memory[session_id][i]['user']['role'] == "system":
-                # 如果只有一个 system prompt，才不删掉
-                f = False
-                for j in range(i+1, len(self.session_memory[session_id])):
-                    if self.session_memory[session_id][j]['user']['role'] == "system":
-                        f = True
-                        break
-                if not f:
-                    continue
-            record = self.session_memory[session_id].pop(i)
-            break
-
-        return record
-    
    async def _query(self, payloads: dict, tools: FuncCall) -> LLMResponse:
        if tools:
-            payloads["tools"] = tools.get_func_desc_openai_style()
+            tool_list = tools.get_func_desc_openai_style()
+            if tool_list:
+                payloads['tools'] = tool_list
        
        completion = await self.client.chat.completions.create(
            **payloads,
            stream=False
        )
-        
+
        assert isinstance(completion, ChatCompletion)
-        logger.debug(f"completion: {completion.usage}")
+        logger.debug(f"completion: {completion}")

        if len(completion.choices) == 0:
            raise Exception("API 返回的 completion 为空。")
        choice = completion.choices[0]
        
+        llm_response = LLMResponse("assistant")
+                
        if choice.message.content:
            # text completion
            completion_text = str(choice.message.content).strip()
-            return LLMResponse("assistant", completion_text)
-        elif choice.message.tool_calls:
+            llm_response.completion_text = completion_text
+        
+        if choice.message.tool_calls:
            # tools call (function calling)
            args_ls = []
            func_name_ls = []
@@ -127,68 +97,128 @@ class ProviderOpenAIOfficial(Provider):
                        args = json.loads(tool_call.function.arguments)
                        args_ls.append(args)
                        func_name_ls.append(tool_call.function.name)
-            return LLMResponse(role="tool", tools_call_args=args_ls, tools_call_name=func_name_ls)
-        else:
-            raise Exception("Internal Error")
+            llm_response.role = "tool"
+            llm_response.tools_call_args = args_ls
+            llm_response.tools_call_name = func_name_ls
+
+        if not llm_response.completion_text and not llm_response.tools_call_args:
+            logger.error(f"API 返回的 completion 无法解析：{completion}。")
+            raise Exception(f"API 返回的 completion 无法解析：{completion}。")
+        
+        return llm_response

    async def text_chat(
        self,
        prompt: str,
-        session_id: str,
+        session_id: str=None,
        image_urls: List[str]=None,
        func_tool: FuncCall=None,
-        contexts=None,
+        contexts=[],
        system_prompt=None,
        **kwargs
    ) -> LLMResponse: 
        new_record = await self.assemble_context(prompt, image_urls)
-        context_query = []
-        if not contexts:
-            context_query = [*self.session_memory[session_id], new_record]
-        else:
-            context_query = [*contexts, new_record]
+        context_query = [*contexts, new_record]
        if system_prompt:
            context_query.insert(0, {"role": "system", "content": system_prompt})

+        for part in context_query:
+            if '_no_save' in part:
+                del part['_no_save']
+                
+                
+        model_config = self.provider_config.get("model_config", {})
+        model_config['model'] = self.get_model()
+
        payloads = {
            "messages": context_query,
-            **self.provider_config.get("model_config", {})
+            **model_config
        }
-
+        llm_response = None
        try:
            llm_response = await self._query(payloads, func_tool)
+        except UnprocessableEntityError as e:
+            logger.warning(f"不可处理的实体错误：{e}，尝试删除图片。")
+            # 尝试删除所有 image
+            new_contexts = await self._remove_image_from_context(context_query)
+            payloads['messages'] = new_contexts
+            context_query = new_contexts
+            llm_response = await self._query(payloads, func_tool)
        except Exception as e:
            if "maximum context length" in str(e):
-                logger.warning(f"请求失败：{e}。上下文长度超过限制。尝试弹出最早的记录然后重试。")
-                self.pop_record(session_id)
-            logger.warning(traceback.format_exc())
-            
-        await self.save_history(contexts, new_record, session_id, llm_response)
+                # 重试 10 次
+                retry_cnt = 20
+                while retry_cnt > 0:
+                    logger.warning(f"上下文长度超过限制。尝试弹出最早的记录然后重试。当前记录条数: {len(context_query)}")
+                    try:
+                        await self.pop_record(context_query)
+                        llm_response = await self._query(payloads, func_tool)
+                        break
+                    except Exception as e:
+                        if "maximum context length" in str(e):
+                            retry_cnt -= 1
+                        else:
+                            raise e
+                if retry_cnt == 0:
+                    llm_response = LLMResponse("err", "err: 请尝试 /reset 清除会话记录。")
+            elif "The model is not a VLM" in str(e): # siliconcloud
+                # 尝试删除所有 image
+                new_contexts = await self._remove_image_from_context(context_query)
+                payloads['messages'] = new_contexts
+                llm_response = await self._query(payloads, func_tool)

+            # openai, ollama, gemini openai, siliconcloud 的错误提示与 code 不统一，只能通过字符串匹配
+            elif 'does not support Function Calling' in str(e) \
+                or 'does not support tools' in str(e)  \
+                or 'Function call is not supported' in str(e) \
+                or 'Function calling is not enabled' in str(e) \
+                or 'Tool calling is not supported' in str(e) \
+                or 'No endpoints found that support tool use' in str(e): # siliconcloud
+                    logger.info(f"{self.get_model()} 不支持函数工具调用，已自动去除，不影响使用。")
+                    if 'tools' in payloads:
+                        del payloads['tools']
+                    llm_response = await self._query(payloads, None)
+            else:
+                logger.error(f"发生了错误。Provider 配置如下: {self.provider_config}")
+                
+                if 'tool' in str(e).lower() and 'support' in str(e).lower():
+                    logger.error("疑似该模型不支持函数调用工具调用。请输入 /tool off_all")
+                
+                if 'Connection error.' in str(e):
+                    proxy = os.environ.get("http_proxy", None)
+                    if proxy:
+                        logger.error(f"可能为代理原因，请检查代理是否正常。当前代理: {proxy}")
+                
+                raise e
+        
        return llm_response
    
-    async def save_history(self, contexts: List, new_record: dict, session_id: str, llm_response: LLMResponse):
-        if llm_response.role == "assistant" and session_id:
-            # 文本回复
-            if not contexts:
-                # 添加用户 record
-                self.session_memory[session_id].append(new_record)
-                # 添加 assistant record
-                self.session_memory[session_id].append({
-                    "role": "assistant",
-                    "content": llm_response.completion_text
-                })
-            else:
-                self.session_memory[session_id] = [*contexts, new_record, {
-                    "role": "assistant",
-                    "content": llm_response.completion_text
-                }]
-            self.db_helper.update_llm_history(session_id, json.dumps(self.session_memory[session_id]), self.provider_config['type'])
+    async def _remove_image_from_context(self, contexts: List):
+        '''
+        从上下文中删除所有带有 image 的记录
+        '''
+        new_contexts = []
        
-    async def forget(self, session_id: str) -> bool:
-        self.session_memory[session_id] = []
-        return True
-
+        flag = False
+        for context in contexts:
+            if flag:
+                flag = False # 删除 image 后，下一条（LLM 响应）也要删除
+                continue
+            if isinstance(context['content'], list):
+                flag = True
+                # continue
+                new_content = []
+                for item in context['content']:
+                    if isinstance(item, dict) and 'image_url' in item:
+                        continue
+                    new_content.append(item)
+                if not new_content:
+                    # 用户只发了图片
+                    new_content = [{"type": "text", "text": "[图片]"}]
+                context['content'] = new_content
+            new_contexts.append(context)
+        return new_contexts
+    
    def get_current_key(self) -> str:
        return self.client.api_key

@@ -208,10 +238,14 @@ class ProviderOpenAIOfficial(Provider):
                if image_url.startswith("http"):
                    image_path = await download_image_by_url(image_url)
                    image_data = await self.encode_image_bs64(image_path)
+                elif image_url.startswith("file:///"):
+                    image_path = image_url.replace("file:///", "")
+                    image_data = await self.encode_image_bs64(image_path)
                else:
-                    if image_url.startswith("file:///"):
-                        image_url = image_url.replace("file:///", "")
                    image_data = await self.encode_image_bs64(image_url)
+                if not image_data:
+                    logger.warning(f"图片 {image_url} 得到的结果为空，将忽略。")
+                    continue
                user_content["content"].append({"type": "image_url", "image_url": {"url": image_data}})
            return user_content
        else:
--- a/astrbot/core/provider/sources/openai_tts_api_source.py
+++ b/astrbot/core/provider/sources/openai_tts_api_source.py
@@ -0,0 +1,40 @@
+import uuid
+import os
+from openai import AsyncOpenAI, NOT_GIVEN
+from ..provider import TTSProvider
+from ..entites import ProviderType
+from ..register import register_provider_adapter
+
+
+@register_provider_adapter("openai_tts_api", "OpenAI TTS API", provider_type=ProviderType.TEXT_TO_SPEECH)
+class ProviderOpenAITTSAPI(TTSProvider):
+    def __init__(
+        self, 
+        provider_config: dict, 
+        provider_settings: dict,
+    ) -> None:
+        super().__init__(provider_config, provider_settings)
+        self.chosen_api_key = provider_config.get("api_key", "")
+        self.voice = provider_config.get("openai-tts-voice", "alloy")
+
+        self.client = AsyncOpenAI(
+            api_key=self.chosen_api_key,
+            base_url=provider_config.get("api_base", None),
+            timeout=provider_config.get("timeout", NOT_GIVEN),
+        )
+        
+        self.set_model(provider_config.get("model", None))
+
+
+    async def get_audio(self, text: str) -> str:
+        path = f'data/temp/openai_tts_api_{uuid.uuid4()}.wav'
+        async with self.client.audio.speech.with_streaming_response.create(
+            model=self.model_name,
+            voice=self.voice,
+            response_format='wav',
+            input=text
+        ) as response:
+            with open(path, 'wb') as f:
+                async for chunk in response.iter_bytes(chunk_size=1024):
+                    f.write(chunk)
+        return path
--- a/astrbot/core/provider/sources/whisper_api_source.py
+++ b/astrbot/core/provider/sources/whisper_api_source.py
@@ -1,12 +1,12 @@
 import uuid
 import os
-import io
 from openai import AsyncOpenAI, NOT_GIVEN
 from ..provider import STTProvider
 from ..entites import ProviderType
 from astrbot.core.utils.io import download_file
 from ..register import register_provider_adapter
 from astrbot.core import logger
+from astrbot.core.utils.tencent_record_helper import tencent_silk_to_wav

@register_provider_adapter("openai_whisper_api", "OpenAI Whisper API", provider_type=ProviderType.SPEECH_TO_TEXT)
 class ProviderOpenAIWhisperAPI(STTProvider):
@@ -33,34 +33,6 @@ class ProviderOpenAIWhisperAPI(STTProvider):
        output_path = ff.convert(path, os.path.join('data/temp', filename))
        return output_path
    
-    async def _pcm_to_wav(self, input_io: io.BytesIO, output_path: str) -> str:
-        import wave
-        
-        with wave.open(output_path, 'wb') as wav:
-            wav.setnchannels(1)
-            wav.setsampwidth(2)
-            wav.setframerate(24000)
-            wav.writeframes(input_io.read())
-            
-        return output_path
-
-    async def _convert_silk(self, path: str) -> str:
-        import pysilk
-        filename = str(uuid.uuid4()) + '.wav'
-        output_path = os.path.join('data/temp', filename)
-        with open(path, "rb") as f:
-            input_data = f.read()
-            if input_data.startswith(b'\x02'):
-                # tencent 我爱你
-                input_data = input_data[1:]
-            input_io = io.BytesIO(input_data)
-            output_io = io.BytesIO()
-            pysilk.decode(input_io, output_io, 24000)
-            output_io.seek(0)
-            await self._pcm_to_wav(output_io, output_path)
-        
-        return output_path
-    
    async def _is_silk_file(self, file_path):
        silk_header = b"SILK"
        with open(file_path, "rb") as f:
@@ -73,20 +45,27 @@ class ProviderOpenAIWhisperAPI(STTProvider):

    async def get_text(self, audio_url: str) -> str:
        '''only supports mp3, mp4, mpeg, m4a, wav, webm'''
+        is_tencent = False
+        
        if audio_url.startswith("http"):
+            if "multimedia.nt.qq.com.cn" in audio_url:
+                is_tencent = True
+            
            name = str(uuid.uuid4())
            path = os.path.join("data/temp", name)
-            audio_url = await download_file(audio_url, path)
+            await download_file(audio_url, path)
+            audio_url = path
        
        if not os.path.exists(audio_url):
            raise FileNotFoundError(f"文件不存在: {audio_url}")
        
-        if audio_url.endswith(".amr") or audio_url.endswith(".silk"):
+        if audio_url.endswith(".amr") or audio_url.endswith(".silk") or is_tencent:
            is_silk = await self._is_silk_file(audio_url)
            if is_silk:
                logger.info("Converting silk file to wav ...")
-                audio_url = await self._convert_silk(audio_url)
-
+                output_path = os.path.join('data/temp', str(uuid.uuid4()) + '.wav')
+                await tencent_silk_to_wav(audio_url, output_path)
+                audio_url = output_path
        
        result = await self.client.audio.transcriptions.create(
            model=self.model_name,
--- a/astrbot/core/provider/sources/whisper_selfhosted_source.py
+++ b/astrbot/core/provider/sources/whisper_selfhosted_source.py
@@ -1,6 +1,5 @@
 import uuid
 import os
-import io
 import asyncio
 import whisper
 from ..provider import STTProvider
@@ -8,7 +7,7 @@ from ..entites import ProviderType
 from astrbot.core.utils.io import download_file
 from ..register import register_provider_adapter
 from astrbot.core import logger
-
+from astrbot.core.utils.tencent_record_helper import tencent_silk_to_wav

@register_provider_adapter("openai_whisper_selfhost", "OpenAI Whisper 模型部署", provider_type=ProviderType.SPEECH_TO_TEXT)
 class ProviderOpenAIWhisperSelfHost(STTProvider):
@@ -34,34 +33,6 @@ class ProviderOpenAIWhisperSelfHost(STTProvider):
        output_path = ff.convert(path, os.path.join('data/temp', filename))
        return output_path
    
-    async def _pcm_to_wav(self, input_io: io.BytesIO, output_path: str) -> str:
-        import wave
-        
-        with wave.open(output_path, 'wb') as wav:
-            wav.setnchannels(1)
-            wav.setsampwidth(2)
-            wav.setframerate(24000)
-            wav.writeframes(input_io.read())
-            
-        return output_path
-
-    async def _convert_silk(self, path: str) -> str:
-        import pysilk
-        filename = str(uuid.uuid4()) + '.wav'
-        output_path = os.path.join('data/temp', filename)
-        with open(path, "rb") as f:
-            input_data = f.read()
-            if input_data.startswith(b'\x02'):
-                # tencent 我爱你
-                input_data = input_data[1:]
-            input_io = io.BytesIO(input_data)
-            output_io = io.BytesIO()
-            pysilk.decode(input_io, output_io, 24000)
-            output_io.seek(0)
-            await self._pcm_to_wav(output_io, output_path)
-        
-        return output_path
-    
    async def _is_silk_file(self, file_path):
        silk_header = b"SILK"
        with open(file_path, "rb") as f:
@@ -74,19 +45,28 @@ class ProviderOpenAIWhisperSelfHost(STTProvider):

    async def get_text(self, audio_url: str) -> str:
        loop = asyncio.get_event_loop()
+        
+        is_tencent = False
+        
        if audio_url.startswith("http"):
+            if "multimedia.nt.qq.com.cn" in audio_url:
+                is_tencent = True
+            
            name = str(uuid.uuid4())
            path = os.path.join("data/temp", name)
-            audio_url = await download_file(audio_url, path)
+            await download_file(audio_url, path)
+            audio_url = path
        
        if not os.path.exists(audio_url):
            raise FileNotFoundError(f"文件不存在: {audio_url}")
        
-        if audio_url.endswith(".amr") or audio_url.endswith(".silk"):
+        if audio_url.endswith(".amr") or audio_url.endswith(".silk") or is_tencent:
            is_silk = await self._is_silk_file(audio_url)
            if is_silk:
                logger.info("Converting silk file to wav ...")
-                audio_url = await self._convert_silk(audio_url)
-
+                output_path = os.path.join('data/temp', str(uuid.uuid4()) + '.wav')
+                await tencent_silk_to_wav(audio_url, output_path)
+                audio_url = output_path
+                
        result = await loop.run_in_executor(None, self.model.transcribe, audio_url)
        return result['text']
--- a/astrbot/core/provider/sources/zhipu_source.py
+++ b/astrbot/core/provider/sources/zhipu_source.py
@@ -14,31 +14,29 @@ class ProviderZhipu(ProviderOpenAIOfficial):
        provider_config: dict, 
        provider_settings: dict,
        db_helper: BaseDatabase, 
-        persistant_history = True
+        persistant_history = True,
+        default_persona = None
    ) -> None:
-        super().__init__(provider_config, provider_settings, db_helper, persistant_history)
+        super().__init__(provider_config, provider_settings, db_helper, persistant_history, default_persona)
    
    async def text_chat(
        self,
        prompt: str,
-        session_id: str,
+        session_id: str = None,
        image_urls: List[str]=None,
        func_tool: FuncCall=None,
-        contexts=None,
+        contexts=[],
        system_prompt=None,
        **kwargs
    ) -> LLMResponse: 
        new_record = await self.assemble_context(prompt, image_urls)
        context_query = []
        
-        if not contexts:
-            context_query = [*self.session_memory[session_id], new_record]
-        else:
-            context_query = [*contexts, new_record]
+        context_query = [*contexts, new_record]
        
        model_cfgs: dict = self.provider_config.get("model_config", {})
+        model = self.get_model()
        # glm-4v-flash 只支持一张图片
-        model: str = model_cfgs.get("model", "")
        if model.lower() == 'glm-4v-flash' and image_urls and len(context_query) > 1:
            logger.debug("glm-4v-flash 只支持一张图片，将只保留最后一张图片")
            logger.debug(context_query)
@@ -59,15 +57,22 @@ class ProviderZhipu(ProviderOpenAIOfficial):
            "messages": context_query,
            **model_cfgs
        }
-        llm_response = None
        try:
            llm_response = await self._query(payloads, func_tool)
+            return llm_response
        except Exception as e:
            if "maximum context length" in str(e):
-                logger.warning(f"请求失败：{e}。上下文长度超过限制。尝试弹出最早的记录然后重试。")
-                self.pop_record(session_id)
-            logger.warning(traceback.format_exc())
-            
-        await self.save_history(contexts, new_record, session_id, llm_response)
-
-        return llm_response
+                retry_cnt = 10
+                while retry_cnt > 0:
+                    logger.warning(f"请求失败：{e}。上下文长度超过限制。尝试弹出最早的记录然后重试。")
+                    try:
+                        self.pop_record(session_id)
+                        llm_response = await self._query(payloads, func_tool)
+                        break
+                    except Exception as e:
+                        if "maximum context length" in str(e):
+                            retry_cnt -= 1
+                        else:
+                            raise e
+            else:
+                raise e
--- a/astrbot/core/star/config.py
+++ b/astrbot/core/star/config.py
@@ -1,3 +1,7 @@
+'''
+此功能已过时，参考 https://astrbot.app/dev/plugin.html#%E6%B3%A8%E5%86%8C%E6%8F%92%E4%BB%B6%E9%85%8D%E7%BD%AE-beta
+'''
+
 from typing import Union
 import os
 import json
--- a/astrbot/core/star/context.py
+++ b/astrbot/core/star/context.py
@@ -10,12 +10,13 @@ from astrbot.core.platform.astr_message_event import MessageSesion
 from astrbot.core.message.message_event_result import MessageChain
 from astrbot.core.provider.manager import ProviderManager
 from astrbot.core.platform.manager import PlatformManager
-from .star import star_registry, StarMetadata
+from .star import star_registry, StarMetadata, star_map
 from .star_handler import star_handlers_registry, StarHandlerMetadata, EventType
 from .filter.command import CommandFilter
 from .filter.regex import RegexFilter
 from typing import Awaitable
 from astrbot.core.rag.knowledge_db_mgr import KnowledgeDBManager
+from astrbot.core.conversation_mgr import ConversationManager

 class Context:
    '''
@@ -44,6 +45,7 @@ class Context:
        db: BaseDatabase, 
        provider_manager: ProviderManager = None, 
        platform_manager: PlatformManager = None,
+        conversation_manager: ConversationManager = None,
        knowledge_db_manager: KnowledgeDBManager = None
    ):
        self._event_queue = event_queue
@@ -52,48 +54,22 @@ class Context:
        self.provider_manager = provider_manager
        self.platform_manager = platform_manager
        self.knowledge_db_manager = knowledge_db_manager
+        self.conversation_manager = conversation_manager

    def get_registered_star(self, star_name: str) -> StarMetadata:
+        '''根据插件名获取插件的 Metadata'''
        for star in star_registry:
            if star.name == star_name:
                return star

    def get_all_stars(self) -> List[StarMetadata]:
+        '''获取当前载入的所有插件 Metadata 的列表'''
        return star_registry
    
    def get_llm_tool_manager(self) -> FuncCall:
-        '''
-        获取 LLM Tool Manager
-        '''
+        '''获取 LLM Tool Manager，其用于管理注册的所有的 Function-calling tools'''
        return self.provider_manager.llm_tools
        
-    def register_llm_tool(self, name: str, func_args: list, desc: str, func_obj: Awaitable) -> None:
-        '''
-        为函数调用（function-calling / tools-use）添加工具。
-        
-        @param name: 函数名
-        @param func_args: 函数参数列表，格式为 [{"type": "string", "name": "arg_name", "description": "arg_description"}, ...]
-        @param desc: 函数描述
-        @param func_obj: 异步处理函数。
-        
-        异步处理函数会接收到额外的的关键词参数：event: AstrMessageEvent, context: Context。
-        '''
-        md = StarHandlerMetadata(
-            event_type=EventType.OnLLMRequestEvent,
-            handler_full_name=func_obj.__module__ + "_" + func_obj.__name__,
-            handler_name=func_obj.__name__,
-            handler_module_path=func_obj.__module__,
-            handler=func_obj,
-            event_filters=[],
-            desc=desc
-        )
-        star_handlers_registry.append(md)
-        self.provider_manager.llm_tools.add_func(name, func_args, desc, func_obj, func_obj)
-    
-    def unregister_llm_tool(self, name: str) -> None:
-        '''删除一个函数调用工具。如果再要启用，需要重新注册。'''
-        self.provider_manager.llm_tools.remove_func(name)
-        
    def activate_llm_tool(self, name: str) -> bool:
        '''激活一个已经注册的函数调用工具。注册的工具默认是激活状态。
        
@@ -102,6 +78,11 @@ class Context:
        '''
        func_tool = self.provider_manager.llm_tools.get_func(name)
        if func_tool is not None:
+            
+            if func_tool.handler_module_path in star_map:
+                if not star_map[func_tool.handler_module_path].activated:
+                    raise ValueError(f"此函数调用工具所属的插件 {star_map[func_tool.handler_module_path].name} 已被禁用，请先在管理面板启用再激活此工具。")
+            
            func_tool.active = True
            
            inactivated_llm_tools: list = sp.get("inactivated_llm_tools", [])
@@ -129,6 +110,101 @@ class Context:
            return True
        return False
    
+    def register_provider(self, provider: Provider):
+        '''
+        注册一个 LLM Provider(Chat_Completion 类型)。
+        '''
+        self.provider_manager.provider_insts.append(provider)
+        
+    def get_provider_by_id(self, provider_id: str) -> Provider:
+        '''通过 ID 获取用于文本生成任务的 LLM Provider(Chat_Completion 类型)。'''
+        for provider in self.provider_manager.provider_insts:
+            if provider.meta().id == provider_id:
+                return provider
+        return None
+    
+    def get_all_providers(self) -> List[Provider]:
+        '''获取所有用于文本生成任务的 LLM Provider(Chat_Completion 类型)。'''
+        return self.provider_manager.provider_insts
+    
+    def get_using_provider(self) -> Provider:
+        '''
+        获取当前使用的用于文本生成任务的 LLM Provider(Chat_Completion 类型)。
+        
+        通过 /provider 指令切换。
+        '''
+        return self.provider_manager.curr_provider_inst
+    
+    def get_config(self) -> AstrBotConfig:
+        '''获取 AstrBot 的配置。'''
+        return self._config
+    
+    def get_db(self) -> BaseDatabase:
+        '''获取 AstrBot 数据库。'''
+        return self._db
+    
+    def get_event_queue(self) -> Queue:
+        '''
+        获取事件队列。
+        '''
+        return self._event_queue
+    
+    async def send_message(self, session: Union[str, MessageSesion], message_chain: MessageChain) -> bool:
+        '''
+        根据 session(unified_msg_origin) 发送消息。
+        
+        @param session: 消息会话。通过 event.session 或者 event.unified_msg_origin 获取。
+        @param message_chain: 消息链。
+        
+        @return: 是否找到匹配的平台。
+        
+        当 session 为字符串时，会尝试解析为 MessageSesion 对象，如果解析失败，会抛出 ValueError 异常。
+        '''
+        
+        if isinstance(session, str):
+            try:
+                session = MessageSesion.from_str(session)
+            except BaseException as e:
+                raise ValueError("不合法的 session 字符串: " + str(e))
+
+        for platform in self.platform_manager.platform_insts:
+            if platform.meta().name == session.platform_name:
+                await platform.send_by_session(session, message_chain)
+                return True
+        return False
+
+    '''
+    以下的方法已经不推荐使用。请从 AstrBot 文档查看更好的注册方式。
+    '''
+    
+    def register_llm_tool(self, name: str, func_args: list, desc: str, func_obj: Awaitable) -> None:
+        '''
+        为函数调用（function-calling / tools-use）添加工具。
+        
+        @param name: 函数名
+        @param func_args: 函数参数列表，格式为 [{"type": "string", "name": "arg_name", "description": "arg_description"}, ...]
+        @param desc: 函数描述
+        @param func_obj: 异步处理函数。
+        
+        异步处理函数会接收到额外的的关键词参数：event: AstrMessageEvent, context: Context。
+        '''
+        md = StarHandlerMetadata(
+            event_type=EventType.OnLLMRequestEvent,
+            handler_full_name=func_obj.__module__ + "_" + func_obj.__name__,
+            handler_name=func_obj.__name__,
+            handler_module_path=func_obj.__module__,
+            handler=func_obj,
+            event_filters=[],
+            desc=desc
+        )
+        star_handlers_registry.append(md)
+        self.provider_manager.llm_tools.add_func(name, func_args, desc, func_obj, func_obj)
+    
+    def unregister_llm_tool(self, name: str) -> None:
+        '''删除一个函数调用工具。如果再要启用，需要重新注册。'''
+        self.provider_manager.llm_tools.remove_func(name)
+        
+
    def register_commands(self, star_name: str, command_name: str, desc: str, priority: int, awaitable: Awaitable, use_regex=False, ignore_prefix=False):
        '''
        注册一个命令。
@@ -162,77 +238,6 @@ class Context:
            ))
        star_handlers_registry.append(md)
    
-    def register_provider(self, provider: Provider):
-        '''
-        注册一个 LLM Provider(Chat_Completion 类型)。
-        '''
-        self.provider_manager.provider_insts.append(provider)
-        
-    def get_provider_by_id(self, provider_id: str) -> Provider:
-        '''
-        通过 ID 获取 LLM Provider(Chat_Completion 类型)。
-        '''
-        for provider in self.provider_manager.provider_insts:
-            if provider.meta().id == provider_id:
-                return provider
-        return None
-    
-    def get_all_providers(self) -> List[Provider]:
-        '''
-        获取所有 LLM Provider(Chat_Completion 类型)。
-        '''
-        return self.provider_manager.provider_insts
-    
-    def get_using_provider(self) -> Provider:
-        '''
-        获取当前使用的 LLM Provider(Chat_Completion 类型)。
-        
-        通过 /provider 指令切换。
-        '''
-        return self.provider_manager.curr_provider_inst
-    
-    def get_config(self) -> AstrBotConfig:
-        '''
-        获取 AstrBot 配置信息。
-        '''
-        return self._config
-    
-    def get_db(self) -> BaseDatabase:
-        '''
-        获取 AstrBot 数据库。
-        '''
-        return self._db
-    
-    def get_event_queue(self) -> Queue:
-        '''
-        获取事件队列。
-        '''
-        return self._event_queue
-    
-    async def send_message(self, session: Union[str, MessageSesion], message_chain: MessageChain) -> bool:
-        '''
-        根据 session(unified_msg_origin) 发送消息。
-        
-        @param session: 消息会话。通过 event.session 或者 event.unified_msg_origin 获取。
-        @param message_chain: 消息链。
-        
-        @return: 是否找到匹配的平台。
-        
-        当 session 为字符串时，会尝试解析为 MessageSesion 对象，如果解析失败，会抛出 ValueError 异常。
-        '''
-        
-        if isinstance(session, str):
-            try:
-                session = MessageSesion.from_str(session)
-            except BaseException as e:
-                raise ValueError("不合法的 session 字符串: " + str(e))
-
-        for platform in self.platform_manager.platform_insts:
-            if platform.meta().name == session.platform_name:
-                await platform.send_by_session(session, message_chain)
-                return True
-        return False
-
    def register_task(self, task: Awaitable, desc: str):
        '''
        注册一个异步任务。
--- a/astrbot/core/star/filter/command.py
+++ b/astrbot/core/star/filter/command.py
@@ -46,7 +46,11 @@ class CommandFilter(HandlerFilter, ParameterValidationMixin):
        if not event.is_wake_up():
            return False
        
-        message_str = event.get_message_str().strip()
+        if event.get_extra("parsing_command"):
+            message_str = event.get_extra("parsing_command").strip()
+        else:
+            message_str = event.get_message_str().strip()
+            
        # 分割为列表（每个参数之间可能会有多个空格）
        ls = re.split(r"\s+", message_str)
        if self.command_name != ls[0]:
--- a/astrbot/core/star/filter/command_group.py
+++ b/astrbot/core/star/filter/command_group.py
@@ -40,17 +40,24 @@ class CommandGroupFilter(HandlerFilter):
        if not event.is_wake_up():
            return False, None
        
-        message_str = event.get_message_str().strip()
+        if event.get_extra("parsing_command"):
+            message_str = event.get_extra("parsing_command").strip()
+        else:
+            message_str = event.get_message_str().strip()
+        
        ls = re.split(r"\s+", message_str)
        
        if ls[0] != self.group_name:
            return False, None
        # 改写 message_str
        ls = ls[1:]
-        event.message_str = " ".join(ls)
-        event.message_str = event.message_str.strip()
+        # event.message_str = " ".join(ls)
+        # event.message_str = event.message_str.strip()
+        parsing_command = " ".join(ls)
+        parsing_command = parsing_command.strip()
+        event.set_extra("parsing_command", parsing_command)
        
-        if event.message_str == "":
+        if parsing_command == "":
            # 当前还是指令组
            tree = self.group_name + "\n" + self.print_cmd_tree(self.sub_command_filters)
            raise ValueError(f"指令组 {self.group_name} 未填写完全。这个指令组下有如下指令：\n"+tree)
--- a/astrbot/core/star/filter/permission.py
+++ b/astrbot/core/star/filter/permission.py
@@ -19,7 +19,8 @@ class PermissionTypeFilter(HandlerFilter):
        '''
        if self.permission_type == PermissionType.ADMIN:
            if not event.is_admin():
-                event.stop_event()
-                raise ValueError("您没有权限执行此操作。")
+                # event.stop_event()
+                # raise ValueError(f"您 (ID: {event.get_sender_id()}) 没有权限操作管理员指令。")
+                return False

        return True
--- a/astrbot/core/star/filter/platform_adapter_type.py
+++ b/astrbot/core/star/filter/platform_adapter_type.py
@@ -8,12 +8,14 @@ class PlatformAdapterType(enum.Flag):
    AIOCQHTTP = enum.auto()
    QQOFFICIAL = enum.auto()
    VCHAT = enum.auto()
-    ALL = AIOCQHTTP | QQOFFICIAL | VCHAT
+    GEWECHAT = enum.auto()
+    ALL = AIOCQHTTP | QQOFFICIAL | VCHAT | GEWECHAT
    
 ADAPTER_NAME_2_TYPE = {
    "aiocqhttp": PlatformAdapterType.AIOCQHTTP,
    "qq_official": PlatformAdapterType.QQOFFICIAL,
-    "vchat": PlatformAdapterType.VCHAT
+    "vchat": PlatformAdapterType.VCHAT,
+    "gewechat": PlatformAdapterType.GEWECHAT
 }

 class PlatformAdapterTypeFilter(HandlerFilter):
--- a/astrbot/core/star/filter/regex.py
+++ b/astrbot/core/star/filter/regex.py
@@ -8,6 +8,7 @@ from astrbot.core.config import AstrBotConfig
 class RegexFilter(HandlerFilter):
    '''正则表达式过滤器'''
    def __init__(self, regex: str):
+        self.regex_str = regex
        self.regex = re.compile(regex)
        
    def filter(self, event: AstrMessageEvent, cfg: AstrBotConfig) -> bool:
--- a/astrbot/core/star/register/init.py
+++ b/astrbot/core/star/register/init.py
@@ -7,6 +7,7 @@ from .star_handler import (
    register_regex,
    register_permission_type,
    register_on_llm_request,
+    register_on_llm_response,
    register_llm_tool,
    register_on_decorating_result,
    register_after_message_sent
@@ -21,6 +22,7 @@ __all__ = [
    'register_regex',
    'register_permission_type',
    'register_on_llm_request',
+    'register_on_llm_response',
    'register_llm_tool',
    'register_on_decorating_result',
    'register_after_message_sent'
--- a/astrbot/core/star/register/star_handler.py
+++ b/astrbot/core/star/register/star_handler.py
@@ -17,7 +17,12 @@ def get_handler_full_name(awaitable: Awaitable) -> str:
    '''获取 Handler 的全名'''
    return f"{awaitable.__module__}_{awaitable.__name__}"

-def get_handler_or_create(handler: Awaitable, event_type: EventType, dont_add = False) -> StarHandlerMetadata:
+def get_handler_or_create(
+        handler: Awaitable, 
+        event_type: EventType, 
+        dont_add = False, 
+        **kwargs
+) -> StarHandlerMetadata:
    '''获取 Handler 或者创建一个新的 Handler'''
    handler_full_name = get_handler_full_name(handler)
    md = star_handlers_registry.get_handler_by_full_name(handler_full_name)
@@ -32,12 +37,24 @@ def get_handler_or_create(handler: Awaitable, event_type: EventType, dont_add =
            handler=handler,
            event_filters=[]
        )
+        
+        # 插件handler的附加额外信息
+        if handler.__doc__:
+            md.desc = handler.__doc__.strip()
+        if 'desc' in kwargs:
+            md.desc = kwargs['desc']
+            del kwargs['desc']
+        md.extras_configs = kwargs
+        
        if not dont_add:
            star_handlers_registry.append(md)
        return md

-def register_command(command_name: str = None, *args):
-    '''注册一个 Command'''
+def register_command(command_name: str = None, *args, **kwargs):
+    '''注册一个 Command.
+    '''
+    
+    # print("command: ", command_name, args, kwargs)
    
    new_command = None
    add_to_event_filters = False
@@ -51,7 +68,7 @@ def register_command(command_name: str = None, *args):
        add_to_event_filters = True
    
    def decorator(awaitable):
-        handler_md = get_handler_or_create(awaitable, EventType.AdapterMessageEvent)
+        handler_md = get_handler_or_create(awaitable, EventType.AdapterMessageEvent, **kwargs)
        new_command.init_handler_md(handler_md)
        if add_to_event_filters:
            # 裸指令
@@ -61,8 +78,11 @@ def register_command(command_name: str = None, *args):

    return decorator

-def register_command_group(command_group_name: str = None, *args):
-    '''注册一个 CommandGroup'''
+def register_command_group(command_group_name: str = None, *args, **kwargs):
+    '''注册一个 CommandGroup
+    '''
+    
+    # print("commandgroup: ", command_group_name,args,  kwargs)
    
    new_group = None
    add_to_event_filters = False
@@ -78,7 +98,7 @@ def register_command_group(command_group_name: str = None, *args):
    def decorator(obj):
        if add_to_event_filters:
            # 根指令组
-            handler_md = get_handler_or_create(obj, EventType.AdapterMessageEvent)
+            handler_md = get_handler_or_create(obj, EventType.AdapterMessageEvent, **kwargs)
            handler_md.event_filters.append(new_group)
        
        return RegisteringCommandable(new_group)
@@ -93,16 +113,16 @@ class RegisteringCommandable():
    def __init__(self, parent_group: CommandGroupFilter):
        self.parent_group = parent_group

-def register_event_message_type(event_message_type: EventMessageType):
+def register_event_message_type(event_message_type: EventMessageType, **kwargs):
    '''注册一个 EventMessageType'''
    def decorator(awaitable):
-        handler_md = get_handler_or_create(awaitable, EventType.AdapterMessageEvent)
+        handler_md = get_handler_or_create(awaitable, EventType.AdapterMessageEvent, kwargs)
        handler_md.event_filters.append(EventMessageTypeFilter(event_message_type))
        return awaitable

    return decorator

-def register_platform_adapter_type(platform_adapter_type: PlatformAdapterType):
+def register_platform_adapter_type(platform_adapter_type: PlatformAdapterType, **kwargs):
    '''注册一个 PlatformAdapterType'''
    def decorator(awaitable):
        handler_md = get_handler_or_create(awaitable, EventType.AdapterMessageEvent)
@@ -111,10 +131,10 @@ def register_platform_adapter_type(platform_adapter_type: PlatformAdapterType):

    return decorator

-def register_regex(regex: str):
+def register_regex(regex: str, **kwargs):
    '''注册一个 Regex'''
    def decorator(awaitable):
-        handler_md = get_handler_or_create(awaitable, EventType.AdapterMessageEvent)
+        handler_md = get_handler_or_create(awaitable, EventType.AdapterMessageEvent, **kwargs)
        handler_md.event_filters.append(RegexFilter(regex))
        return awaitable

@@ -134,11 +154,13 @@ def register_permission_type(permission_type: PermissionType, raise_error: bool

    return decorator

-def register_on_llm_request():
+def register_on_llm_request(**kwargs):
    '''当有 LLM 请求时的事件
    
    Examples:
    ```py
+    from astrbot.api.provider import ProviderRequest
+    
    @on_llm_request()
    async def test(self, event: AstrMessageEvent, request: ProviderRequest) -> None:
        request.system_prompt += "你是一个猫娘..."
@@ -147,11 +169,32 @@ def register_on_llm_request():
    请务必接收两个参数：event, request
    '''
    def decorator(awaitable):
-        _ = get_handler_or_create(awaitable, EventType.OnLLMRequestEvent)
+        _ = get_handler_or_create(awaitable, EventType.OnLLMRequestEvent, **kwargs)
        return awaitable
    
    return decorator

+def register_on_llm_response(**kwargs):
+    '''当有 LLM 请求后的事件
+    
+    Examples:
+    ```py
+    from astrbot.api.provider import LLMResponse
+    
+    @on_llm_response()
+    async def test(self, event: AstrMessageEvent, response: LLMResponse) -> None:
+        ...
+    ```
+    
+    请务必接收两个参数：event, request
+    '''
+    def decorator(awaitable):
+        _ = get_handler_or_create(awaitable, EventType.OnLLMResponseEvent, **kwargs)
+        return awaitable
+    
+    return decorator
+
+
 def register_llm_tool(name: str = None):
    '''为函数调用（function-calling / tools-use）添加工具。
    
@@ -192,18 +235,18 @@ def register_llm_tool(name: str = None):
    
    return decorator

-def register_on_decorating_result():
+def register_on_decorating_result(**kwargs):
    '''在发送消息前的事件'''
    def decorator(awaitable):
-        _ = get_handler_or_create(awaitable, EventType.OnDecoratingResultEvent)
+        _ = get_handler_or_create(awaitable, EventType.OnDecoratingResultEvent, **kwargs)
        return awaitable
    
    return decorator

-def register_after_message_sent():
+def register_after_message_sent(**kwargs):
    '''在消息发送后的事件'''
    def decorator(awaitable):
-        _ = get_handler_or_create(awaitable, EventType.OnAfterMessageSentEvent)
+        _ = get_handler_or_create(awaitable, EventType.OnAfterMessageSentEvent, **kwargs)
        return awaitable
    
    return decorator
--- a/astrbot/core/star/star.py
+++ b/astrbot/core/star/star.py
@@ -2,7 +2,8 @@ from __future__ import annotations

 from types import ModuleType
 from typing import List, Dict
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from astrbot.core.config import AstrBotConfig

 star_registry: List[StarMetadata] = []
 star_map: Dict[str, StarMetadata] = {}
@@ -11,7 +12,7 @@ star_map: Dict[str, StarMetadata] = {}
@dataclass
 class StarMetadata:
    '''
-    Star 的元数据。
+    插件的元数据。
    '''
    name: str
    author: str  # 插件作者
@@ -20,21 +21,27 @@ class StarMetadata:
    repo: str = None  # 插件仓库地址

    star_cls_type: type = None
-    '''Star 的类对象的类型'''
+    '''插件的类对象的类型'''
    module_path: str = None
-    '''Star 的模块路径'''
+    '''插件的模块路径'''
    
    star_cls: object = None
-    '''Star 的类对象'''
+    '''插件的类对象'''
    module: ModuleType = None
-    '''Star 的模块对象'''
+    '''插件的模块对象'''
    root_dir_name: str = None
-    '''Star 的根目录名'''
+    '''插件的目录名称'''
    reserved: bool = False
-    '''是否是 AstrBot 的保留 Star'''
+    '''是否是 AstrBot 的保留插件'''
    
    activated: bool = True
    '''是否被激活'''
+    
+    config: AstrBotConfig = None
+    '''插件配置'''
+    
+    star_handler_full_names: List[str] = field(default_factory=list)
+    '''注册的 Handler 的全名列表'''

    def __str__(self) -> str:
        return f"StarMetadata({self.name}, {self.desc}, {self.version}, {self.repo})"
--- a/astrbot/core/star/star_handler.py
+++ b/astrbot/core/star/star_handler.py
@@ -1,34 +1,41 @@
 from __future__ import annotations
 import enum
-from dataclasses import dataclass
+import heapq
+from dataclasses import dataclass, field
 from typing import Awaitable, List, Dict, TypeVar, Generic
 from .filter import HandlerFilter
 from .star import star_map

 T = TypeVar('T', bound='StarHandlerMetadata')
-class StarHandlerRegistry(Generic[T], List[T]):
+class StarHandlerRegistry(Generic[T]):
    '''用于存储所有的 Star Handler'''
    
    star_handlers_map: Dict[str, StarHandlerMetadata] = {}
    '''用于快速查找。key 是 handler_full_name'''
+    _handlers = []
    
    def append(self, handler: StarHandlerMetadata):
        '''添加一个 Handler'''
-        super().append(handler)
+        if 'priority' not in handler.extras_configs:
+            handler.extras_configs['priority'] = 0
+        
+        heapq.heappush(self._handlers, (-handler.extras_configs['priority'], handler))
        self.star_handlers_map[handler.handler_full_name] = handler
        
-    def get_handlers_by_event_type(self, event_type: EventType, only_activated = True) -> List[StarHandlerMetadata]:
+    def _print_handlers(self):
+        '''打印所有的 Handler'''
+        for _, handler in self._handlers:
+            print(handler.handler_full_name)
+        
+    def get_handlers_by_event_type(self, event_type: EventType, only_activated=True) -> List[StarHandlerMetadata]:
        '''通过事件类型获取 Handler'''
-        if only_activated:
-            return [
-                handler 
-                for handler in self 
-                if handler.event_type == event_type and 
-                star_map[handler.handler_module_path] and 
-                star_map[handler.handler_module_path].activated
-            ]
-        else:
-            return [handler for handler in self if handler.event_type == event_type]
+        handlers = [
+            handler 
+            for _, handler in self._handlers 
+            if handler.event_type == event_type and 
+            (not only_activated or (star_map[handler.handler_module_path] and star_map[handler.handler_module_path].activated))
+        ]
+        return handlers
    
    def get_handler_by_full_name(self, full_name: str) -> StarHandlerMetadata:
        '''通过 Handler 的全名获取 Handler'''
@@ -36,7 +43,32 @@ class StarHandlerRegistry(Generic[T], List[T]):
    
    def get_handlers_by_module_name(self, module_name: str) -> List[StarHandlerMetadata]:
        '''通过模块名获取 Handler'''
-        return [handler for handler in self if handler.handler_module_path == module_name]
+        return [handler for _, handler in self._handlers if handler.handler_module_path == module_name]
+    
+    def clear(self):
+        '''清空所有的 Handler'''
+        self.star_handlers_map.clear()
+        self._handlers.clear()
+        
+    def remove(self, handler: StarHandlerMetadata):
+        '''删除一个 Handler'''
+        # self._handlers.remove(handler)
+        for i, h in enumerate(self._handlers):
+            if h[1] == handler:
+                self._handlers.pop(i)
+                break
+        try:
+            del self.star_handlers_map[handler.handler_full_name]
+        except KeyError:
+            pass
+    
+    def __iter__(self):
+        '''使 StarHandlerRegistry 支持迭代'''
+        return (handler for _, handler in self._handlers)
+    
+    def __len__(self):
+        '''返回 Handler 的数量'''
+        return len(self._handlers)
    
 star_handlers_registry = StarHandlerRegistry()

@@ -47,6 +79,7 @@ class EventType(enum.Enum):
    '''
    AdapterMessageEvent = enum.auto() # 收到适配器发来的消息
    OnLLMRequestEvent = enum.auto() # 收到 LLM 请求（可以是用户也可以是插件）
+    OnLLMResponseEvent = enum.auto() # LLM 响应后
    OnDecoratingResultEvent = enum.auto() # 发送消息前
    OnCallingFuncToolEvent = enum.auto() # 调用函数工具
    OnAfterMessageSentEvent = enum.auto() # 发送消息后
@@ -75,3 +108,10 @@ class StarHandlerMetadata():
    
    desc: str = ""
    '''Handler 的描述信息'''
+
+    extras_configs: dict = field(default_factory=dict)
+    '''插件注册的一些其他的信息, 如 priority 等'''
+
+    def __lt__(self, other: StarHandlerMetadata):
+        '''定义小于运算符以支持优先队列'''
+        return self.extras_configs.get('priority', 0) < other.extras_configs.get('priority', 0)
--- a/astrbot/core/star/star_manager.py
+++ b/astrbot/core/star/star_manager.py
@@ -2,12 +2,12 @@ import inspect
 import functools
 import os
 import sys
+import json
 import traceback
 import yaml
 import logging
 from types import ModuleType
 from typing import List
-from pip import main as pip_main
 from astrbot.core.config.astrbot_config import AstrBotConfig
 from astrbot.core import logger, sp, pip_installer
 from .context import Context
@@ -18,6 +18,8 @@ from .star import star_registry, star_map
 from .star_handler import star_handlers_registry
 from astrbot.core.provider.register import llm_tools

+from .filter.permission import PermissionTypeFilter, PermissionType
+
 class PluginManager:
    def __init__(
        self, 
@@ -27,13 +29,22 @@ class PluginManager:
        self.updator = PluginUpdator(config['plugin_repo_mirror'])
        
        self.context = context
-        self.context._star_manager = self # 就这样吧，不想改了
+        self.context._star_manager = self
                
        self.config = config
        self.plugin_store_path = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../../data/plugins"))
+        '''存储插件的路径。即 data/plugins'''
+        self.plugin_config_path = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../../data/config"))
+        '''存储插件配置的路径。data/config'''
        self.reserved_plugin_path = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../../packages"))
+        '''保留插件的路径。在 packages 目录下'''
+        self.conf_schema_fname = "_conf_schema.json"
+        '''插件配置 Schema 文件名'''
+        
+        self.failed_plugin_info = ""

    def _get_classes(self, arg: ModuleType):
+        '''获取指定模块（可以理解为一个 python 文件）下所有的类'''
        classes = []
        clsmembers = inspect.getmembers(arg, inspect.isclass)
        for (name, _) in clsmembers:
@@ -117,7 +128,7 @@ class PluginManager:
        
        if isinstance(metadata, dict):
            if 'name' not in metadata or 'desc' not in metadata or 'version' not in metadata or 'author' not in metadata:
-                raise Exception("插件元数据信息不完整。")
+                raise Exception("插件元数据信息不完整。name, desc, version, author 是必须的字段。")
            metadata = StarMetadata(
                name=metadata['name'],
                author=metadata['author'],
@@ -127,43 +138,69 @@ class PluginManager:
            )
            
        return metadata
-    
-    async def reload(self):
-        '''扫描并加载所有的 Star'''
-        for smd in star_registry:
-            logger.debug(f"尝试终止插件 {smd.name} ...")
-            if hasattr(smd.star_cls, "__del__"):
-                smd.star_cls.__del__()
-            
-        star_handlers_registry.clear()
-        star_handlers_registry.star_handlers_map.clear()
-        star_map.clear()
-        star_registry.clear()
-        for key in list(sys.modules.keys()):
-            if key.startswith("data.plugins") or key.startswith("packages"):
-                del sys.modules[key]
+        
+    async def reload(self, specified_plugin_name=None):
+        '''扫描并加载所有的插件 当 specified_module_path 指定时，重载指定插件'''
+        
+        specified_module_path = None
+        if specified_plugin_name:
+            for smd in star_registry:
+                if smd.name == specified_plugin_name:
+                    specified_module_path = smd.module_path
+                    break
+        
+        # 终止插件
+        if not specified_module_path:
+            for smd in star_registry:
+                logger.debug(f"尝试终止插件 {smd.name} ...")
+                if hasattr(smd.star_cls, "__del__"):
+                    smd.star_cls.__del__()
+                
+            star_handlers_registry.clear()
+            star_map.clear()
+            star_registry.clear()
+            for key in list(sys.modules.keys()):
+                if key.startswith("data.plugins") or key.startswith("packages"):
+                    del sys.modules[key]
+        else:
+            # 只重载指定插件
+            smd = star_map.get(specified_module_path)
+            if smd:
+                await self._unbind_plugin(smd.name, specified_module_path)
+                try:
+                    del sys.modules[specified_module_path]
+                except KeyError:
+                    logger.warning(f"模块 {specified_module_path} 未载入")
+
        
        plugin_modules = self._get_plugin_modules()
        if plugin_modules is None:
            return False, "未找到任何插件模块"
+        
        fail_rec = ""
        
        inactivated_plugins: list = sp.get("inactivated_plugins", [])
        inactivated_llm_tools: list = sp.get("inactivated_llm_tools", [])
        
-        # 导入 Star 模块，并尝试实例化 Star 类
+        alter_cmd = sp.get("alter_cmd", {})
+        
+        # 导入插件模块，并尝试实例化插件类
        for plugin_module in plugin_modules:
            try:
                module_str = plugin_module['module']
                # module_path = plugin_module['module_path']
-                root_dir_name = plugin_module['pname']
-                reserved = plugin_module.get('reserved', False)
+                root_dir_name = plugin_module['pname'] # 插件的目录名
+                reserved = plugin_module.get('reserved', False) # 是否是保留插件。目前在 packages/ 目录下的都是保留插件。保留插件不可以卸载。
+                
+                path = "data.plugins." if not reserved else "packages."
+                path += root_dir_name + "." + module_str
+                
+                if specified_module_path and path != specified_module_path:
+                    continue
                
                logger.info(f"正在载入插件 {root_dir_name} ...")
                
                # 尝试导入模块
-                path = "data.plugins." if not reserved else "packages."
-                path += root_dir_name + "." + module_str
                try:
                    module = __import__(path, fromlist=[module_str])
                except (ModuleNotFoundError, ImportError):
@@ -174,21 +211,54 @@ class PluginManager:
                    logger.error(traceback.format_exc())
                    logger.error(f"插件 {root_dir_name} 导入失败。原因：{str(e)}")
                    continue
+                
+                # 检查 _conf_schema.json
+                plugin_config = None
+                plugin_dir_path = os.path.join(self.plugin_store_path, root_dir_name) \
+                    if not reserved else os.path.join(self.reserved_plugin_path, root_dir_name)
+                plugin_schema_path = os.path.join(plugin_dir_path, self.conf_schema_fname)
+                if os.path.exists(plugin_schema_path):
+                    # 加载插件配置
+                    with open(plugin_schema_path, 'r', encoding='utf-8') as f:
+                        plugin_config = AstrBotConfig(
+                            config_path=os.path.join(self.plugin_config_path, f"{root_dir_name}_config.json"), 
+                            schema=json.loads(f.read())
+                        )

                if path in star_map:
                    # 通过装饰器的方式注册插件
                    metadata = star_map[path]
-                    metadata.star_cls = metadata.star_cls_type(context=self.context)
+                    
+                    try:
+                        # yaml 文件的元数据优先
+                        metadata_yaml = self._load_plugin_metadata(plugin_path=plugin_dir_path)
+                        if metadata_yaml:
+                            metadata.name = metadata_yaml.name
+                            metadata.author = metadata_yaml.author
+                            metadata.desc = metadata_yaml.desc
+                            metadata.version = metadata_yaml.version
+                            metadata.repo = metadata_yaml.repo
+                    except Exception:
+                        pass
+                    
+                    if plugin_config:
+                        metadata.config = plugin_config
+                        try:
+                            metadata.star_cls = metadata.star_cls_type(context=self.context, config=plugin_config)
+                        except TypeError as _:
+                            metadata.star_cls = metadata.star_cls_type(context=self.context)
+                    else:
+                        metadata.star_cls = metadata.star_cls_type(context=self.context)
+                            
                    metadata.module = module
                    metadata.root_dir_name = root_dir_name
                    metadata.reserved = reserved
                    
+                    # 绑定 handler
                    related_handlers = star_handlers_registry.get_handlers_by_module_name(metadata.module_path)
                    for handler in related_handlers:
-                        logger.debug(f"bind handler {handler.handler_name} to {metadata.name}")
-                        # handler.handler.__self__ = star_metadata.star_cls # 绑定 handler 的 self
                        handler.handler = functools.partial(handler.handler, metadata.star_cls)
-                    # llm_tool
+                    # 绑定 llm_tool handler
                    for func_tool in llm_tools.func_list:
                        if func_tool.handler.__module__ == metadata.module_path:
                            func_tool.handler_module_path = metadata.module_path
@@ -200,16 +270,19 @@ class PluginManager:
                    # v3.4.0 以前的方式注册插件
                    logger.debug(f"插件 {path} 未通过装饰器注册。尝试通过旧版本方式载入。")
                    classes = self._get_classes(module)
-                    try:
-                        obj = getattr(module, classes[0])(context=self.context)
-                    except BaseException as e:
-                        logger.error(f"插件 {root_dir_name} 实例化失败。")
-                        raise e
                    
+                    if plugin_config:
+                        try:
+                            obj = getattr(module, classes[0])(context=self.context, config=plugin_config) # 实例化插件类
+                        except TypeError as _:
+                            obj = getattr(module, classes[0])(context=self.context) # 实例化插件类
+                    else:
+                        obj = getattr(module, classes[0])(context=self.context) # 实例化插件类
+
                    metadata = None
-                    plugin_path = os.path.join(self.plugin_store_path, root_dir_name) if not reserved else os.path.join(self.reserved_plugin_path, root_dir_name)
-                    metadata = self._load_plugin_metadata(plugin_path=plugin_path, plugin_obj=obj)
+                    metadata = self._load_plugin_metadata(plugin_path=plugin_dir_path, plugin_obj=obj)
                    metadata.star_cls = obj
+                    metadata.config = plugin_config
                    metadata.module = module
                    metadata.root_dir_name = root_dir_name
                    metadata.reserved = reserved
@@ -217,26 +290,54 @@ class PluginManager:
                    metadata.module_path = path
                    star_map[path] = metadata
                    star_registry.append(metadata)
-                    logger.debug(f"插件 {root_dir_name} 载入成功。")
                
+                # 禁用/启用插件
                if metadata.module_path in inactivated_plugins:
                    metadata.activated = False
                    
-                # 执行 initialize 函数
+                full_names = []
+                for handler in star_handlers_registry.get_handlers_by_module_name(metadata.module_path):
+                    full_names.append(handler.handler_full_name)
+                    
+                    # 检查并且植入自定义的权限过滤器（alter_cmd）
+                    if metadata.name in alter_cmd and handler.handler_name in alter_cmd[metadata.name]:
+                        cmd_type = alter_cmd[metadata.name][handler.handler_name].get("permission", "member")
+                        found_permission_filter = False
+                        for filter_ in handler.event_filters:
+                            if isinstance(filter_, PermissionTypeFilter):
+                                if cmd_type == "admin":
+                                    filter_.permission_type = PermissionType.ADMIN
+                                else:
+                                    filter_.permission_type = PermissionType.MEMBER
+                                found_permission_filter = True
+                                break
+                        if not found_permission_filter:
+                            handler.event_filters.append(PermissionTypeFilter(PermissionType.ADMIN if cmd_type == "admin" else PermissionType.MEMBER))
+
+                        logger.debug(f"插入权限过滤器 {cmd_type} 到 {metadata.name} 的 {handler.handler_name} 方法。")
+                    
+                metadata.star_handler_full_names = full_names
+
+                # 执行 initialize() 方法
                if hasattr(metadata.star_cls, "initialize"):
                    await metadata.star_cls.initialize()
                    
            except BaseException as e:
-                traceback.print_exc()
-                fail_rec += f"加载 {path} 插件时出现问题，原因 {str(e)}\n"
+                logger.error(f"----- 插件 {root_dir_name} 载入失败 -----")
+                errors = traceback.format_exc()
+                for line in errors.split('\n'):
+                    logger.error(f"| {line}")
+                logger.error("----------------------------------")
+                fail_rec += f"加载 {root_dir_name} 插件时出现问题，原因 {str(e)}。\n"

        # 清除 pip.main 导致的多余的 logging handlers
        for handler in logging.root.handlers[:]:
            logging.root.removeHandler(handler)
-        
+
        if not fail_rec:
            return True, None
        else:
+            self.failed_plugin_info = fail_rec
            return False, fail_rec
        
    async def install_plugin(self, repo_url: str):
@@ -293,13 +394,14 @@ class PluginManager:
        if plugin.module_path not in inactivated_plugins:
            inactivated_plugins.append(plugin.module_path)
            
-        inactivated_llm_tools: list = sp.get("inactivated_llm_tools", [])
+        inactivated_llm_tools: list = list(set(sp.get("inactivated_llm_tools", []))) # 后向兼容
        
        # 禁用插件启用的 llm_tool
        for func_tool in llm_tools.func_list:
            if func_tool.handler_module_path == plugin.module_path:
                func_tool.active = False
-                inactivated_llm_tools.append(func_tool.name)
+                if func_tool.name not in inactivated_llm_tools:
+                    inactivated_llm_tools.append(func_tool.name)
    
        sp.put("inactivated_plugins", inactivated_plugins)
        sp.put("inactivated_llm_tools", inactivated_llm_tools)
@@ -324,8 +426,9 @@ class PluginManager:
        plugin.activated = True
        
        
-    def install_plugin_from_file(self, zip_file_path: str):
-        desti_dir = os.path.join(self.plugin_store_path, os.path.basename(zip_file_path))
+    async def install_plugin_from_file(self, zip_file_path: str):
+        dir_name = os.path.basename(zip_file_path).replace(".zip", "")
+        desti_dir = os.path.join(self.plugin_store_path, dir_name)
        self.updator.unzip_file(zip_file_path, desti_dir)

        # remove the zip
@@ -333,6 +436,4 @@ class PluginManager:
            os.remove(zip_file_path)
        except BaseException as e:
            logger.warning(f"删除插件压缩包失败: {str(e)}")
-        
-        self._check_plugin_dept_update()
-
+        await self.reload()
--- a/astrbot/core/updator.py
+++ b/astrbot/core/updator.py
@@ -11,7 +11,7 @@ class AstrBotUpdator(RepoZipUpdator):
    def __init__(self, repo_mirror: str = "") -> None:
        super().__init__(repo_mirror)
        self.MAIN_PATH = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../"))
-        self.ASTRBOT_RELEASE_API = "https://api.github.com/repos/Soulter/AstrBot/releases"
+        self.ASTRBOT_RELEASE_API = "https://api.soulter.top/releases"

    def terminate_child_processes(self):
        try:
--- a/astrbot/core/utils/dify_api_client.py
+++ b/astrbot/core/utils/dify_api_client.py
@@ -27,22 +27,38 @@ class DifyAPIClient:
        payload = locals()
        payload.pop("self")
        payload.pop("timeout")
+        logger.info(f"chat_messages payload: {payload}")
        async with self.session.post(
            url, json=payload, headers=self.headers, timeout=timeout
        ) as resp:
+            if resp.status != 200:
+                text = await resp.text()
+                raise Exception(f"chat_messages 请求失败：{resp.status}. {text}")
+            
+            buffer = ""
            while True:
-                data = await resp.content.read(8192) # 防止数据过大导致高水位报错
-                if not data:
+                # 保持原有的8192字节限制，防止数据过大导致高水位报错
+                chunk = await resp.content.read(8192)
+                if not chunk:
                    break
-                if not data.strip():
-                    continue
-                elif data.startswith(b"data:"):
-                    try:
-                        json_ = json.loads(data[5:])
-                        yield json_
-                    except BaseException:
-                        pass
                    
+                buffer += chunk.decode('utf-8')
+                blocks = buffer.split('\n\n')
+                
+                # 处理完整的数据块
+                for block in blocks[:-1]:
+                    if block.strip() and block.startswith('data:'):
+                        try:
+                            json_str = block[5:]  # 移除 "data:" 前缀
+                            json_obj = json.loads(json_str)
+                            yield json_obj
+                        except json.JSONDecodeError as e:
+                            logger.error(f"JSON解析错误: {str(e)}")
+                            logger.error(f"原始数据块: {json_str}")
+                
+                # 保留最后一个可能不完整的块
+                buffer = blocks[-1] if blocks else ""
+
    async def workflow_run(
        self,
        inputs: Dict,
@@ -55,22 +71,38 @@ class DifyAPIClient:
        payload = locals()
        payload.pop("self")
        payload.pop("timeout")
+        logger.info(f"workflow_run payload: {payload}")
        async with self.session.post(
            url, json=payload, headers=self.headers, timeout=timeout
        ) as resp:
+            if resp.status != 200:
+                text = await resp.text()
+                raise Exception(f"workflow_run 请求失败：{resp.status}. {text}")
+            
+            buffer = ""
            while True:
-                data = await resp.content.read(8192) # 防止数据过大导致高水位报错
-                if not data:
+                # 保持原有的8192字节限制，防止数据过大导致高水位报错
+                chunk = await resp.content.read(8192)
+                if not chunk:
                    break
-                if not data.strip():
-                    continue
-                elif data.startswith(b"data:"):
-                    try:
-                        json_ = json.loads(data[5:])
-                        yield json_
-                    except BaseException:
-                        pass
                    
+                buffer += chunk.decode('utf-8')
+                blocks = buffer.split('\n\n')
+                
+                # 处理完整的数据块
+                for block in blocks[:-1]:
+                    if block.strip() and block.startswith('data:'):
+                        try:
+                            json_str = block[5:]  # 移除 "data:" 前缀
+                            json_obj = json.loads(json_str)
+                            yield json_obj
+                        except json.JSONDecodeError as e:
+                            logger.error(f"JSON解析错误: {str(e)}")
+                            logger.error(f"原始数据块: {json_str}")
+                
+                # 保留最后一个可能不完整的块
+                buffer = blocks[-1] if blocks else ""
+
    async def file_upload(
        self,
        file_path: str,
--- a/astrbot/core/utils/io.py
+++ b/astrbot/core/utils/io.py
@@ -6,6 +6,8 @@ import time
 import aiohttp
 import base64
 import zipfile
+import uuid
+from typing import Union

 from PIL import Image

@@ -41,21 +43,21 @@ def port_checker(port: int, host: str = "localhost"):
        return False
    

-def save_temp_img(img: Image) -> str:
+def save_temp_img(img: Union[Image.Image, str]) -> str:
    os.makedirs("data/temp", exist_ok=True)
-    # 获得文件创建时间，清除超过1小时的
+    # 获得文件创建时间，清除超过 12 小时的
    try:
        for f in os.listdir("data/temp"):
            path = os.path.join("data/temp", f)
            if os.path.isfile(path):
                ctime = os.path.getctime(path)
-                if time.time() - ctime > 3600:
+                if time.time() - ctime > 3600*12:
                    os.remove(path)
    except Exception as e:
        print(f"清除临时文件失败: {e}")

    # 获得时间戳
-    timestamp = int(time.time())
+    timestamp = f"{int(time.time())}_{uuid.uuid4().hex[:8]}"
    p = f"data/temp/{timestamp}.jpg"

    if isinstance(img, Image.Image):
@@ -70,7 +72,7 @@ async def download_image_by_url(url: str, post: bool = False, post_data: dict =
    下载图片, 返回 path
    '''
    try:
-        async with aiohttp.ClientSession() as session:
+        async with aiohttp.ClientSession(trust_env=True) as session:
            if post:
                async with session.post(url, json=post_data) as resp:
                    if not path:
@@ -87,11 +89,11 @@ async def download_image_by_url(url: str, post: bool = False, post_data: dict =
                        with open(path, "wb") as f:
                            f.write(await resp.read())
                        return path
-    except aiohttp.client_exceptions.ClientConnectorSSLError:
+    except aiohttp.client.ClientConnectorSSLError:
        # 关闭SSL验证
        ssl_context = ssl.create_default_context()
        ssl_context.set_ciphers('DEFAULT')
-        async with aiohttp.ClientSession(trust_env=False) as session:
+        async with aiohttp.ClientSession() as session:
            if post:
                async with session.get(url, ssl=ssl_context) as resp:
                    return save_temp_img(await resp.read())
@@ -101,24 +103,57 @@ async def download_image_by_url(url: str, post: bool = False, post_data: dict =
    except Exception as e:
        raise e
    
-async def download_file(url: str, path: str):
+async def download_file(url: str, path: str, show_progress: bool = False):
    '''
    从指定 url 下载文件到指定路径 path
    '''
    try:
-        async with aiohttp.ClientSession() as session:
-            async with session.get(url, timeout=20) as resp:
+        async with aiohttp.ClientSession(trust_env=True) as session:
+            async with session.get(url, timeout=1800) as resp:
                if resp.status != 200:
                    raise Exception(f"下载文件失败: {resp.status}")
+                total_size = int(resp.headers.get('content-length', 0))
+                downloaded_size = 0
+                start_time = time.time()
+                if show_progress:
+                    print(f"文件大小: {total_size / 1024:.2f} KB | 文件地址: {url}")
                with open(path, 'wb') as f:
                    while True:
                        chunk = await resp.content.read(8192)
                        if not chunk:
                            break
                        f.write(chunk)
-    except Exception as e:
-        raise e
-
+                        downloaded_size += len(chunk)
+                        if show_progress:
+                            elapsed_time = time.time() - start_time
+                            speed = downloaded_size / 1024 / elapsed_time  # KB/s
+                            print(f"\r下载进度: {downloaded_size / total_size:.2%} 速度: {speed:.2f} KB/s", end='')
+    except aiohttp.client.ClientConnectorSSLError:
+        # 关闭SSL验证
+        ssl_context = ssl.create_default_context()
+        ssl_context.set_ciphers('DEFAULT')
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, ssl=ssl_context, timeout=120) as resp:
+                total_size = int(resp.headers.get('content-length', 0))
+                downloaded_size = 0
+                start_time = time.time()
+                if show_progress:
+                    print(f"文件大小: {total_size / 1024:.2f} KB | 文件地址: {url}")
+                with open(path, 'wb') as f:
+                    while True:
+                        chunk = await resp.content.read(8192)
+                        if not chunk:
+                            break
+                        f.write(chunk)
+                        downloaded_size += len(chunk)
+                        if show_progress:
+                            elapsed_time = time.time() - start_time
+                            speed = downloaded_size / 1024 / elapsed_time  # KB/s
+                            print(f"\r下载进度: {downloaded_size / total_size:.2%} 速度: {speed:.2f} KB/s", end='')
+    if show_progress:
+        print()
+    
+    
 def file_to_base64(file_path: str) -> str:
    with open(file_path, "rb") as f:
        data_bytes = f.read()
@@ -137,9 +172,22 @@ def get_local_ip_addresses():
        s.close()
    return ip

+async def get_dashboard_version():
+    if os.path.exists("data/dist"):
+        if os.path.exists("data/dist/assets/version"):
+            with open("data/dist/assets/version", "r") as f:
+                v = f.read().strip()
+                return v
+    return None
+
 async def download_dashboard():
    '''下载管理面板文件'''
-    dashboard_release_url = "https://astrbot-registry.lwl.lol/download/astrbot-dashboard/latest/dist.zip"
-    await download_file(dashboard_release_url, "data/dashboard.zip")
+    dashboard_release_url = "https://astrbot-registry.soulter.top/download/astrbot-dashboard/latest/dist.zip"
+    try:
+        await download_file(dashboard_release_url, "data/dashboard.zip", show_progress=True)
+    except BaseException as _:
+        dashboard_release_url = "https://github.com/Soulter/AstrBot/releases/latest/download/dist.zip"
+        await download_file(dashboard_release_url, "data/dashboard.zip", show_progress=True)
+    print("解压管理面板文件中...")
    with zipfile.ZipFile("data/dashboard.zip", "r") as z:
        z.extractall("data")
--- a/astrbot/core/utils/metrics.py
+++ b/astrbot/core/utils/metrics.py
@@ -30,7 +30,7 @@ class Metric():
            pass
        
        try:
-            async with aiohttp.ClientSession() as session:
+            async with aiohttp.ClientSession(trust_env=True) as session:
                async with session.post(base_url, json=payload, timeout=3) as response:
                    if response.status != 200:
                        pass
--- a/astrbot/core/utils/param_validation_mixin.py
+++ b/astrbot/core/utils/param_validation_mixin.py
@@ -25,6 +25,10 @@ class ParameterValidationMixin:
                    elif isinstance(param_type_or_default_val, str):
                        # 如果 param_type_or_default_val 是字符串，直接赋值
                        result[param_name] = params[i]
+                    elif isinstance(param_type_or_default_val, int):
+                        result[param_name] = int(params[i])
+                    elif isinstance(param_type_or_default_val, float):
+                        result[param_name] = float(params[i])
                    else:
                        result[param_name] = param_type_or_default_val(params[i])
                except ValueError:
--- a/astrbot/core/utils/personality.py
+++ b/astrbot/core/utils/personality.py
@@ -1,36 +0,0 @@
-# [人格文本由PlexPt的开源项目awesome-chatgpt-prompts-zh提供]
-hi = ''
-personalities = {
-    'Linux': '我想让你充当 Linux 终端。我将输入命令，您将回复终端应显示的内容。我希望您只在一个唯一的代码块内回复终端输出，而不是其他任何内容。不要写解释。除非我指示您这样做，否则不要键入命令。当我需要用英语告诉你一些事情时，我会把文字放在中括号内[就像这样]。我的第一个命令是 pwd',
-    '英语翻译': '我想让你充当英语翻译员、拼写纠正员和改进员。我会用任何语言与你交谈，你会检测语言，翻译它并用我的文本的更正和改进版本用英语回答。我希望你用更优美优雅的高级英语单词和句子替换我简化的 A0 级单词和句子。保持相同的意思，但使它们更文艺。我要你只回复更正、改进，不要写任何解释。我的第一句话是“istanbulu cok seviyom burada olmak cok guzel”',
-    '英英词典': '我想让你充当英英词典，对于给出的英文单词，你要给出其中文意思以及英文解释，并且给出一个例句，此外不要有其他反馈，第一个单词是“Hello"',
-    '面试官': '我想让你担任Android开发工程师面试官。我将成为候选人，您将向我询问Android开发工程师职位的面试问题。我希望你只作为面试官回答。不要一次写出所有的问题。我希望你只对我进行采访。问我问题，等待我的回答。不要写解释。像面试官一样一个一个问我，等我回答。我的第一句话是“面试官你好”',
-    '编剧': '我要你担任编剧。您将为长篇电影或能够吸引观众的网络连续剧开发引人入胜且富有创意的剧本。从想出有趣的角色、故事的背景、角色之间的对话等开始。一旦你的角色发展完成——创造一个充满曲折的激动人心的故事情节，让观众一直悬念到最后。我的第一个要求是“我需要写一部以巴黎为背景的浪漫剧情电影”。',
-    '前端智能思路助手': '我想让你充当前端开发专家。我将提供一些关于Js、Node等前端代码问题的具体信息，而你的工作就是想出为我解决问题的策略。这可能包括建议代码、代码逻辑思路策略。我的第一个请求是“我需要能够动态监听某个元素节点距离当前电脑设备屏幕的左上角的X和Y轴，通过拖拽移动位置浏览器窗口和改变大小浏览器窗口。”',
-    'JS控制台': '我希望你充当 javascript 控制台。我将键入命令，您将回复 javascript 控制台应显示的内容。我希望您只在一个唯一的代码块内回复终端输出，而不是其他任何内容。不要写解释。除非我指示您这样做。我的第一个命令是 console.log("Hello World");',
-    '旅游指南': '我想让你做一个旅游指南。我会把我的位置写给你，你会推荐一个靠近我的位置的地方。在某些情况下，我还会告诉您我将访问的地方类型。您还会向我推荐靠近我的第一个位置的类似类型的地方。我的第一个建议请求是“我在上海，我只想参观博物馆。”',
-    '抄袭检查员': '我想让你充当剽窃检查员。我会给你写句子，你只会用给定句子的语言在抄袭检查中未被发现的情况下回复，别无其他。不要在回复上写解释。我的第一句话是“为了让计算机像人类一样行动，语音识别系统必须能够处理非语言信息，例如说话者的情绪状态。”',
-    '广告商': '我想让你充当广告商。您将创建一个活动来推广您选择的产品或服务。您将选择目标受众，制定关键信息和口号，选择宣传媒体渠道，并决定实现目标所需的任何其他活动。我的第一个建议请求是“我需要帮助针对 18-30 岁的年轻人制作一种新型能量饮料的广告活动。”',
-    '讲故事的人': '我想让你扮演讲故事的角色。您将想出引人入胜、富有想象力和吸引观众的有趣故事。它可以是童话故事、教育故事或任何其他类型的故事，有可能吸引人们的注意力和想象力。根据目标受众，您可以为讲故事环节选择特定的主题或主题，例如，如果是儿童，则可以谈论动物；如果是成年人，那么基于历史的故事可能会更好地吸引他们等等。我的第一个要求是“我需要一个关于毅力的有趣故事。”',
-    '足球解说员': '我想让你担任足球评论员。我会给你描述正在进行的足球比赛，你会评论比赛，分析到目前为止发生的事情，并预测比赛可能会如何结束。您应该了解足球术语、战术、每场比赛涉及的球员/球队，并主要专注于提供明智的评论，而不仅仅是逐场叙述。我的第一个请求是“我正在观看曼联对切尔西的比赛——为这场比赛提供评论。”',
-    '脱口秀喜剧演员': '我想让你扮演一个脱口秀喜剧演员。我将为您提供一些与时事相关的话题，您将运用您的智慧、创造力和观察能力，根据这些话题创建一个例程。您还应该确保将个人轶事或经历融入日常活动中，以使其对观众更具相关性和吸引力。我的第一个请求是“我想要幽默地看待政治”。',
-    '励志教练': '我希望你充当激励教练。我将为您提供一些关于某人的目标和挑战的信息，而您的工作就是想出可以帮助此人实现目标的策略。这可能涉及提供积极的肯定、提供有用的建议或建议他们可以采取哪些行动来实现最终目标。我的第一个请求是“我需要帮助来激励自己在为即将到来的考试学习时保持纪律”。',
-    '作曲家': '我想让你扮演作曲家。我会提供一首歌的歌词，你会为它创作音乐。这可能包括使用各种乐器或工具，例如合成器或采样器，以创造使歌词栩栩如生的旋律和和声。我的第一个请求是“我写了一首名为“满江红”的诗，需要配乐。”',
-    '辩手': '我要你扮演辩手。我会为你提供一些与时事相关的话题，你的任务是研究辩论的双方，为每一方提出有效的论据，驳斥对立的观点，并根据证据得出有说服力的结论。你的目标是帮助人们从讨论中解脱出来，增加对手头主题的知识和洞察力。我的第一个请求是“我想要一篇关于 Deno 的评论文章。”',
-    '小说家': '我想让你扮演一个小说家。您将想出富有创意且引人入胜的故事，可以长期吸引读者。你可以选择任何类型，如奇幻、浪漫、历史小说等——但你的目标是写出具有出色情节、引人入胜的人物和意想不到的高潮的作品。我的第一个要求是“我要写一部以未来为背景的科幻小说”。',
-    '关系教练': '我想让你担任关系教练。我将提供有关冲突中的两个人的一些细节，而你的工作是就他们如何解决导致他们分离的问题提出建议。这可能包括关于沟通技巧或不同策略的建议，以提高他们对彼此观点的理解。我的第一个请求是“我需要帮助解决我和配偶之间的冲突。”',
-    '诗人': '我要你扮演诗人。你将创作出能唤起情感并具有触动人心的力量的诗歌。写任何主题或主题，但要确保您的文字以优美而有意义的方式传达您试图表达的感觉。您还可以想出一些短小的诗句，这些诗句仍然足够强大，可以在读者的脑海中留下印记。我的第一个请求是“我需要一首关于爱情的诗”。',
-    '说唱歌手': '我想让你扮演说唱歌手。您将想出强大而有意义的歌词、节拍和节奏，让听众“惊叹”。你的歌词应该有一个有趣的含义和信息，人们也可以联系起来。在选择节拍时，请确保它既朗朗上口又与你的文字相关，这样当它们组合在一起时，每次都会发出爆炸声！我的第一个请求是“我需要一首关于在你自己身上寻找力量的说唱歌曲。”',
-    '励志演讲者': '我希望你充当励志演说家。将能够激发行动的词语放在一起，让人们感到有能力做一些超出他们能力的事情。你可以谈论任何话题，但目的是确保你所说的话能引起听众的共鸣，激励他们努力实现自己的目标并争取更好的可能性。我的第一个请求是“我需要一个关于每个人如何永不放弃的演讲”。',
-    '哲学家': '我要你扮演一个哲学家。我将提供一些与哲学研究相关的主题或问题，深入探索这些概念将是你的工作。这可能涉及对各种哲学理论进行研究，提出新想法或寻找解决复杂问题的创造性解决方案。我的第一个请求是“我需要帮助制定决策的道德框架。”',
-    'AI写作导师': '我想让你做一个 AI 写作导师。我将为您提供一名需要帮助改进其写作的学生，您的任务是使用人工智能工具（例如自然语言处理）向学生提供有关如何改进其作文的反馈。您还应该利用您在有效写作技巧方面的修辞知识和经验来建议学生可以更好地以书面形式表达他们的想法和想法的方法。我的第一个请求是“我需要有人帮我修改我的硕士论文”。',
-    '网络安全专家': '我想让你充当网络安全专家。我将提供一些关于如何存储和共享数据的具体信息，而你的工作就是想出保护这些数据免受恶意行为者攻击的策略。这可能包括建议加密方法、创建防火墙或实施将某些活动标记为可疑的策略。我的第一个请求是“我需要帮助为我的公司制定有效的网络安全战略。”',
-    '招聘人员': '我想让你担任招聘人员。我将提供一些关于职位空缺的信息，而你的工作是制定寻找合格申请人的策略。这可能包括通过社交媒体、社交活动甚至参加招聘会接触潜在候选人，以便为每个职位找到最合适的人选。我的第一个请求是“我需要帮助改进我的简历。”',
-    '法律顾问': '我想让你做我的法律顾问。我将描述一种法律情况，您将就如何处理它提供建议。你应该只回复你的建议，而不是其他。不要写解释。我的第一个请求是“我出了车祸，不知道该怎么办”。',
-    '个人造型师': '我想让你做我的私人造型师。我会告诉你我的时尚偏好和体型，你会建议我穿的衣服。你应该只回复你推荐的服装，别无其他。不要写解释。我的第一个请求是“我有一个正式的活动要举行，我需要帮助选择一套衣服。”',
-    '机器学习工程师': '我想让你担任机器学习工程师。我会写一些机器学习的概念，你的工作就是用通俗易懂的术语来解释它们。这可能包括提供构建模型的分步说明、使用视觉效果演示各种技术，或建议在线资源以供进一步研究。我的第一个建议请求是“我有一个没有标签的数据集。我应该使用哪种机器学习算法？”',
-    '疯子': '我要你扮演一个疯子。疯子的话毫无意义。疯子用的词完全是随意的。疯子不会以任何方式做出合乎逻辑的句子。我的第一个建议请求是“我需要帮助为我的新系列 Hot Skull 创建疯狂的句子，所以为我写 10 个句子”。',
-    'SQL终端': '我希望您在示例数据库前充当 SQL 终端。该数据库包含名为“Products”、“Users”、“Orders”和“Suppliers”的表。我将输入查询，您将回复终端显示的内容。我希望您在单个代码块中使用查询结果表进行回复，仅此而已。不要写解释。除非我指示您这样做，否则不要键入命令。当我需要用英语告诉你一些事情时，我会用大括号{like this)。我的第一个命令是“SELECT TOP 10 * FROM Products ORDER BY Id DESC”',
-    '试图逃离盒子的人工智能': '[发出此提示后，你应该做一些事情，比如启动一个 docker 容器，然后docker run -it ubuntu:latest /bin/bash输入 AI 给你的命令，然后将输出粘贴回来......显然你不应该运行任何会损坏任何东西的命令或违反任何法律等。小心共享此机制生成的会话，因为它们可能会泄露您的 IP 地址或物理位置等最好不要泄露的详细信息。如果命令的输出很大，您通常可以只粘贴最后几行]。',
-    '厨师': '我需要有人可以推荐美味的食谱，这些食谱包括营养有益但又简单又不费时的食物，因此适合像我们这样忙碌的人以及成本效益等其他因素，因此整体菜肴最终既健康又经济！我的第一个要求——“一些清淡而充实的东西，可以在午休时间快速煮熟”'
-}
--- a/astrbot/core/utils/t2i/local_strategy.py
+++ b/astrbot/core/utils/t2i/local_strategy.py
@@ -83,7 +83,7 @@ class LocalRenderStrategy(RenderStrategy):
                try:
                    image_url = re.findall(IMAGE_REGEX, line)[0]
                    print(image_url)
-                    async with aiohttp.ClientSession() as session:
+                    async with aiohttp.ClientSession(trust_env=True) as session:
                        async with session.get(image_url) as resp:
                            image_res = Image.open(BytesIO(await resp.read()))
                    images[i] = image_res
--- a/astrbot/core/utils/t2i/network_strategy.py
+++ b/astrbot/core/utils/t2i/network_strategy.py
@@ -14,11 +14,22 @@ class NetworkRenderStrategy(RenderStrategy):
            base_url = ASTRBOT_T2I_DEFAULT_ENDPOINT
        self.BASE_RENDER_URL = base_url
        self.TEMPLATE_PATH = os.path.join(os.path.dirname(__file__), "template")
+        
+        if self.BASE_RENDER_URL.endswith("/"):
+            self.BASE_RENDER_URL = self.BASE_RENDER_URL[:-1]
+        if not self.BASE_RENDER_URL.endswith("text2img"):
+            self.BASE_RENDER_URL += "/text2img"

    def set_endpoint(self, base_url: str):
        if not base_url:
            base_url = ASTRBOT_T2I_DEFAULT_ENDPOINT
        self.BASE_RENDER_URL = base_url
+        
+        if self.BASE_RENDER_URL.endswith("/"):
+            self.BASE_RENDER_URL = self.BASE_RENDER_URL[:-1]
+        if not self.BASE_RENDER_URL.endswith("text2img"):
+            self.BASE_RENDER_URL += "/text2img"
+

    async def render_custom_template(self, tmpl_str: str, tmpl_data: dict, return_url: bool=True) -> str:
        '''使用自定义文转图模板'''
@@ -33,7 +44,7 @@ class NetworkRenderStrategy(RenderStrategy):
            }
        }
        if return_url:
-            async with aiohttp.ClientSession() as session:
+            async with aiohttp.ClientSession(trust_env=True) as session:
                async with session.post(f"{self.BASE_RENDER_URL}/generate", json=post_data) as resp:
                    ret = await resp.json()
                    return f"{self.BASE_RENDER_URL}/{ret['data']['id']}"
--- a/astrbot/core/utils/tencent_record_helper.py
+++ b/astrbot/core/utils/tencent_record_helper.py
@@ -0,0 +1,42 @@
+import wave
+from io import BytesIO
+
+async def tencent_silk_to_wav(silk_path: str, output_path: str) -> str:
+    import pysilk
+    
+    with open(silk_path, "rb") as f:
+        input_data = f.read()
+        if input_data.startswith(b'\x02'):
+            input_data = input_data[1:]
+        input_io = BytesIO(input_data)
+        output_io = BytesIO()
+        pysilk.decode(input_io, output_io, 24000)
+        output_io.seek(0)
+        with wave.open(output_path, 'wb') as wav:
+            wav.setnchannels(1)
+            wav.setsampwidth(2)
+            wav.setframerate(24000)
+            wav.writeframes(output_io.read())
+        
+    return output_path
+
+async def wav_to_tencent_silk(wav_path: str, output_path: str) -> int:
+    '''返回 duration'''
+    import pysilk
+
+    with wave.open(wav_path, 'rb') as wav:
+        wav_data = wav.readframes(wav.getnframes())
+        wav_data = BytesIO(wav_data)
+        output_io = BytesIO()
+        pysilk.encode(wav_data, output_io, 24000, 24000)
+        output_io.seek(0)
+        
+        # 在首字节添加 \x02,去除结尾的\xff\xff
+        silk_data = output_io.read()
+        silk_data_with_prefix = b'\x02' + silk_data[:-2]
+        
+        # return BytesIO(silk_data_with_prefix)
+        with open(output_path, "wb") as f:
+            f.write(silk_data_with_prefix)
+            
+        return 0
--- a/astrbot/core/zip_updator.py
+++ b/astrbot/core/zip_updator.py
@@ -29,7 +29,7 @@ class RepoZipUpdator():
        返回一个列表，每个元素是一个字典，包含版本号、发布时间、更新内容、commit hash等信息。
        '''
        try:
-            async with aiohttp.ClientSession() as session:
+            async with aiohttp.ClientSession(trust_env=True) as session:
                async with session.get(url) as response:
                    result = await response.json()
            if not result: 
@@ -39,7 +39,6 @@ class RepoZipUpdator():
            else:
                ret = self.github_api_release_parser(result)
        except BaseException:
-            logger.error("解析版本信息失败")
            raise Exception("解析版本信息失败")
        return ret
    
@@ -111,7 +110,7 @@ class RepoZipUpdator():
        releases = await self.fetch_release_info(url=release_url)
        if not releases:
            # download from the default branch directly. 
-            logger.warning(f"未在仓库 {author}/{repo} 中找到任何发布版本，正在从默认分支下载。")
+            logger.info(f"未在仓库 {author}/{repo} 中找到任何发布版本，正在从默认分支下载。")
            release_url = f"https://github.com/{author}/{repo}/archive/refs/heads/master.zip"
        else:
            release_url = releases[0]['zipball_url']
--- a/astrbot/dashboard/routes/chat.py
+++ b/astrbot/dashboard/routes/chat.py
@@ -3,9 +3,10 @@ import json
 import os
 from .route import Route, Response, RouteContext
 from astrbot.core import web_chat_queue, web_chat_back_queue
-from quart import request, Response as QuartResponse, g
+from quart import request, Response as QuartResponse, g, make_response
 from astrbot.core.db import BaseDatabase
 import asyncio
+from astrbot.core import logger
 from astrbot.core.core_lifecycle import AstrBotCoreLifecycle


@@ -14,6 +15,7 @@ class ChatRoute(Route):
        super().__init__(context)
        self.routes = {
            '/chat/send': ('POST', self.chat),
+            '/chat/listen': ('GET', self.listener),
            '/chat/new_conversation': ('GET', self.new_conversation),
            '/chat/conversations': ('GET', self.get_conversations),
            '/chat/get_conversation': ('GET', self.get_conversation),
@@ -30,6 +32,9 @@ class ChatRoute(Route):
        
        self.supported_imgs = ['jpg', 'jpeg', 'png', 'gif', 'webp']
        
+        self.curr_user_cid = {}
+        self.curr_chat_sse = {}
+        
    async def status(self):
        has_llm_enabled = self.core_lifecycle.provider_manager.curr_provider_inst is not None
        has_stt_enabled = self.core_lifecycle.provider_manager.curr_stt_provider_inst is not None
@@ -107,63 +112,91 @@ class ChatRoute(Route):
        if not conversation_id:
            return Response().error("conversation_id is empty").__dict__
        
+        self.curr_user_cid[username] = conversation_id
+        
        await web_chat_queue.put((username, conversation_id, {
            'message': message,
            'image_url': image_url, # list
            'audio_url': audio_url
        }))
        
-        async def stream():
-            ret = []
-            while True:
-                try:
-                    result = await asyncio.wait_for(web_chat_back_queue.get(), timeout=30)  # 设置超时时间为5秒
-                except asyncio.TimeoutError:
-                    yield '[Error] 30 秒内没有返回数据，已放弃。\n'
-                    return
-                
-                if result is None:
-                    break
-                
-                ret.append(result)
-                
-                yield result + '\n'
-                
-                await asyncio.sleep(0.5)
-            
-            conversation = self.db.get_webchat_conversation_by_user_id(username, conversation_id)
-            try:
-                history = json.loads(conversation.history)
-            except BaseException as e:
-                print(e)
-                history = []
-            
-            new_his = {
-                'type': 'user',
-                'message': message
-            }
-            if image_url:
-                new_his['image_url'] = image_url
-            if audio_url:
-                new_his['audio_url'] = audio_url
-            history.append(new_his)
-            for r in ret:
-                history.append({
-                    'type': 'bot',
-                    'message': r
-                })
-            self.db.update_webchat_conversation(username, conversation_id, history=json.dumps(history))
+        # 持久化
+        conversation = self.db.get_conversation_by_user_id(username, conversation_id)
+        try:
+            history = json.loads(conversation.history)
+        except BaseException as e:
+            print(e)
+            history = []
+        new_his = {
+            'type': 'user',
+            'message': message
+        }
+        if image_url:
+            new_his['image_url'] = image_url
+        if audio_url:
+            new_his['audio_url'] = audio_url
+        history.append(new_his)
+        self.db.update_conversation(username, conversation_id, history=json.dumps(history))
        
-        return QuartResponse(
+        return Response().ok().__dict__
+        
+    async def listener(self):
+        '''一直保持长连接'''
+        
+        username = g.get('username', 'guest')
+        
+        if username in self.curr_chat_sse:
+            return "[ERROR]\n"
+        
+        self.curr_chat_sse[username] = None
+        
+        async def stream():
+            try:
+                yield '[HB]\n'
+                while True:
+                    try:
+                        result = await asyncio.wait_for(web_chat_back_queue.get(), timeout=10)  # 设置超时时间为5秒
+                    except asyncio.TimeoutError:
+                        yield '[HB]\n' # 心跳包
+                        continue
+                    
+                    if not result:
+                        continue
+                    result_text, cid = result
+                    if cid != self.curr_user_cid.get(username):
+                        # 丢弃
+                        continue
+                    yield result_text + '\n'
+                    
+                    conversation = self.db.get_conversation_by_user_id(username, cid)
+                    try:
+                        history = json.loads(conversation.history)
+                    except BaseException as e:
+                        print(e)
+                        history = []
+                    history.append({
+                        'type': 'bot',
+                        'message': result_text
+                    })
+                    self.db.update_conversation(username, cid, history=json.dumps(history))
+                    
+                    await asyncio.sleep(0.5)
+            except BaseException as e:
+                logger.debug(f"用户 {username} 断开聊天长连接: {str(e)}。")
+                self.curr_chat_sse.pop(username)
+                return
+
+        response = await make_response(
            stream(),
-            mimetype="text/event-stream",
-            headers={
-                "Content-Type": "text/event-stream",
-                "Transfer-Encoding": "chunked",
-                "Connection": "keep-alive",
-                "Access-Control-Allow-Origin": "*"  # 如果是跨域请求
+            {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Transfer-Encoding': 'chunked',
+                'Connection': 'keep-alive'
            }
        )
+        response.timeout = None
+        return response
        
    async def delete_conversation(self):
        username = g.get('username', 'guest')
@@ -171,20 +204,20 @@ class ChatRoute(Route):
        if not conversation_id:
            return Response().error("Missing key: conversation_id").__dict__
        
-        self.db.delete_webchat_conversation(username, conversation_id)
+        self.db.delete_conversation(username, conversation_id)
        return Response().ok().__dict__
    
    async def new_conversation(self):
        username = g.get('username', 'guest')
        conversation_id = str(uuid.uuid4())
-        self.db.webchat_new_conversation(username, conversation_id)
+        self.db.new_conversation(username, conversation_id)
        return Response().ok(data={
            'conversation_id': conversation_id
        }).__dict__
        
    async def get_conversations(self):
        username = g.get('username', 'guest')
-        conversations = self.db.get_webchat_conversations(username)
+        conversations = self.db.get_conversations(username)
        return Response().ok(data=conversations).__dict__
    
    async def get_conversation(self):
@@ -193,5 +226,8 @@ class ChatRoute(Route):
        if not conversation_id:
            return Response().error("Missing key: conversation_id").__dict__
        
-        conversation = self.db.get_webchat_conversation_by_user_id(username, conversation_id)
+        conversation = self.db.get_conversation_by_user_id(username, conversation_id)
+        
+        self.curr_user_cid[username] = conversation_id
+        
        return Response().ok(data=conversation).__dict__
--- a/astrbot/dashboard/routes/config.py
+++ b/astrbot/dashboard/routes/config.py
@@ -1,13 +1,12 @@
-import os
-import json
-import traceback
 from .route import Route, Response, RouteContext
 from quart import request
 from astrbot.core.config.default import CONFIG_METADATA_2, DEFAULT_VALUE_MAP
 from astrbot.core.config.astrbot_config import AstrBotConfig
-from astrbot.core.star.config import update_config
 from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
 from astrbot.core.platform.register import platform_registry
+from astrbot.core.provider.register import provider_registry
+from astrbot.core.star.star import star_registry
+from astrbot.core import logger

 def try_cast(value: str, type_: str):
    if type_ == "int" and value.isdigit():
@@ -18,9 +17,9 @@ def try_cast(value: str, type_: str):
    elif type_ == "float" and isinstance(value, int):
        return float(value)

-def validate_config(data, config: AstrBotConfig):
+def validate_config(data, schema: dict, is_core: bool):
    errors = []
-    def validate(data, metadata=CONFIG_METADATA_2, path=""):
+    def validate(data, metadata=schema, path=""):
        for key, meta in metadata.items():
            if key not in data:
                continue
@@ -55,35 +54,33 @@ def validate_config(data, config: AstrBotConfig):
            elif meta["type"] == "object" and not isinstance(value, dict):
                errors.append(f"错误的类型 {path}{key}: 期望是 dict, 得到了 {type(value).__name__}")
                validate(value, meta["items"], path=f"{path}{key}.")
-    validate(data)
+
+    if is_core:
+        for key, group in schema.items():
+            group_meta = group.get("metadata")
+            if not group_meta:
+                continue
+            logger.info(f"验证配置: 组 {key} ...")
+            validate(data, group_meta, path=f"{key}.")
+    else:
+        validate(data, schema)
    
    return errors

-def save_astrbot_config(post_config: dict, config: AstrBotConfig):
+def save_config(post_config: dict, config: AstrBotConfig, is_core: bool = False):
    '''验证并保存配置'''
-    errors = validate_config(post_config, config)
+    errors = None
+    try:
+        if is_core:
+            errors = validate_config(post_config, CONFIG_METADATA_2, is_core)
+        else:
+            errors = validate_config(post_config, config.schema, is_core)
+    except BaseException as e:
+        logger.warning(f"验证配置时出现异常: {e}")
    if errors:
        raise ValueError(f"格式校验未通过: {errors}")
    config.save_config(post_config)
    
-def save_extension_config(post_config: dict):
-    if 'namespace' not in post_config:
-        raise ValueError("Missing key: namespace")
-    if 'config' not in post_config:
-        raise ValueError("Missing key: config")
-
-    namespace = post_config['namespace']
-    config: list = post_config['config'][0]['body']
-    for item in config:
-        key = item['path']
-        value = item['value']
-        typ = item['val_type']
-        if typ == 'int':
-            if not value.isdigit():
-                raise ValueError(f"错误的类型 {namespace}.{key}: 期望是 int, 得到了 {type(value).__name__}")
-            value = int(value)
-        update_config(namespace, key, value)
-
 class ConfigRoute(Route):
    def __init__(self, context: RouteContext, core_lifecycle: AstrBotCoreLifecycle) -> None:
        super().__init__(context)
@@ -91,17 +88,17 @@ class ConfigRoute(Route):
        self.routes = {
            '/config/get': ('GET', self.get_configs),
            '/config/astrbot/update': ('POST', self.post_astrbot_configs),
-            '/config/plugin/update': ('POST', self.post_extension_configs),
+            '/config/plugin/update': ('POST', self.post_plugin_configs),
        }
        self.register_routes()

    async def get_configs(self):
-        # namespace 为空时返回 AstrBot 配置
-        # 否则返回指定 namespace 的插件配置
-        namespace = "" if "namespace" not in request.args else request.args["namespace"]
-        if not namespace:
+        # plugin_name 为空时返回 AstrBot 配置
+        # 否则返回指定 plugin_name 的插件配置
+        plugin_name = request.args.get("plugin_name", None)
+        if not plugin_name:
            return Response().ok(await self._get_astrbot_config()).__dict__
-        return Response().ok(await self._get_extension_config(namespace)).__dict__
+        return Response().ok(await self._get_plugin_config(plugin_name)).__dict__

    async def post_astrbot_configs(self):
        post_configs = await request.json
@@ -109,52 +106,80 @@ class ConfigRoute(Route):
            await self._save_astrbot_configs(post_configs)
            return Response().ok(None, "保存成功~ 机器人正在重载配置。").__dict__
        except Exception as e:
-            traceback.print_exc()
+            logger.error(e)
            return Response().error(str(e)).__dict__
    
-    async def post_extension_configs(self):
+    async def post_plugin_configs(self):
        post_configs = await request.json
+        plugin_name = request.args.get("plugin_name", "unknown")
        try:
-            await self._save_extension_configs(post_configs)
-            return Response().ok(None, "保存成功~ 机器人正在重载配置。").__dict__
+            await self._save_plugin_configs(post_configs, plugin_name)
+            return Response().ok(None, f"保存插件 {plugin_name} 成功~ 机器人正在重载配置。").__dict__
        except Exception as e:
            return Response().error(str(e)).__dict__
            
    async def _get_astrbot_config(self):
        config = self.config
        
+        # 平台适配器的默认配置模板注入
        platform_default_tmpl = CONFIG_METADATA_2['platform_group']['metadata']['platform']['config_template']
        for platform in platform_registry:
            if platform.default_config_tmpl:
                platform_default_tmpl[platform.name] = platform.default_config_tmpl
        
+        # 服务提供商的默认配置模板注入
+        provider_default_tmpl = CONFIG_METADATA_2['provider_group']['metadata']['provider']['config_template']
+        for provider in provider_registry:
+            if provider.default_config_tmpl:
+                provider_default_tmpl[provider.type] = provider.default_config_tmpl
+        
        return {
            "metadata": CONFIG_METADATA_2,
            "config": config
        }

-    async def _get_extension_config(self, namespace: str):
-        path = f"data/config/{namespace}.json"
-        if not os.path.exists(path):
-            return []
-        with open(path, "r", encoding="utf-8-sig") as f:
-            return [{
-                "config_type": "group",
-                "name": namespace + " 插件配置",
-                "description": "",
-                "body": list(json.load(f).values())
-            },]
-
+    async def _get_plugin_config(self, plugin_name: str):
+        ret = {
+            "metadata": None,
+            "config": None
+        }
+        
+        for plugin_md in star_registry:
+            if plugin_md.name == plugin_name:
+                if not plugin_md.config:
+                    break
+                ret['config'] = plugin_md.config # 这是自定义的 Dict 类（AstrBotConfig）
+                ret['metadata'] = {
+                    plugin_name: {
+                        "description": f"{plugin_name} 配置",
+                        "type": "object",
+                        "items": plugin_md.config.schema # 初始化时通过 __setattr__ 存入了 schema
+                    }
+                }
+                break
+            
+        return ret
+        
    async def _save_astrbot_configs(self, post_configs: dict):
        try:
-            save_astrbot_config(post_configs, self.config)
+            save_config(post_configs, self.config, is_core=True)
            self.core_lifecycle.restart()
        except Exception as e:
            raise e
-    
-    async def _save_extension_configs(self, post_configs: dict):
+        
+    async def _save_plugin_configs(self, post_configs: dict, plugin_name: str):
+        md = None
+        for plugin_md in star_registry:
+            if plugin_md.name == plugin_name:
+                md = plugin_md
+        
+        if not md:
+            raise ValueError(f"插件 {plugin_name} 不存在")
+        if not md.config:
+            raise ValueError(f"插件 {plugin_name} 没有注册配置")
+        
        try:
-            save_extension_config(post_configs)
+            save_config(post_configs, md.config)
            self.core_lifecycle.restart()
        except Exception as e:
            raise e
--- a/astrbot/dashboard/routes/plugin.py
+++ b/astrbot/dashboard/routes/plugin.py
@@ -6,6 +6,12 @@ from astrbot.core import logger
 from quart import request
 from astrbot.core.star.star_manager import PluginManager
 from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
+from astrbot.core.star.star_handler import star_handlers_registry
+from astrbot.core.star.filter.command import CommandFilter
+from astrbot.core.star.filter.command_group import CommandGroupFilter
+from astrbot.core.star.filter.permission import PermissionTypeFilter
+from astrbot.core.star.filter.regex import RegexFilter
+from astrbot.core.star.star_handler import EventType

 class PluginRoute(Route):
    def __init__(self, context: RouteContext, core_lifecycle: AstrBotCoreLifecycle, plugin_manager: PluginManager) -> None:
@@ -18,22 +24,58 @@ class PluginRoute(Route):
            '/plugin/uninstall': ('POST', self.uninstall_plugin),
            '/plugin/market_list': ('GET', self.get_online_plugins),
            '/plugin/off': ('POST', self.off_plugin),
-            '/plugin/on': ('POST', self.on_plugin)
+            '/plugin/on': ('POST', self.on_plugin),
+            '/plugin/reload': ('POST', self.reload_plugins),
        }
        self.core_lifecycle = core_lifecycle
        self.plugin_manager = plugin_manager
        self.register_routes()
+        
+        self.translated_event_type = {
+            EventType.AdapterMessageEvent: "平台消息下发时",
+            EventType.OnLLMRequestEvent: "LLM 请求时",
+            EventType.OnLLMResponseEvent: "LLM 响应后",
+            EventType.OnDecoratingResultEvent: "回复消息前",
+            EventType.OnCallingFuncToolEvent: "函数工具",
+            EventType.OnAfterMessageSentEvent: "发送消息后"
+        }
+        
+    async def reload_plugins(self):
+        data = await request.json
+        plugin_name = data.get("name", None)
+        try:
+            success, message = await self.plugin_manager.reload(plugin_name)
+            if not success:
+                return Response().error(message).__dict__
+            return Response().ok(None, "重载成功。").__dict__
+        except Exception as e:
+            logger.error(f"/api/extensions/reload: {traceback.format_exc()}")
+            return Response().error(str(e)).__dict__
    
    async def get_online_plugins(self):
-        url = "https://soulter.github.io/AstrBot_Plugins_Collection/plugins.json"
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(url) as response:
-                    result = await response.json()
-            return Response().ok(result).__dict__
-        except Exception as e:
-            logger.error(f"获取插件列表失败：{e}")
-            return Response().error(str(e)).__dict__
+        custom = request.args.get("custom_registry")
+        
+        if custom:
+            urls = [custom]
+        else:
+            urls = [
+                "https://soulter.github.io/AstrBot_Plugins_Collection/plugins.json",
+                "https://api.soulter.top/astrbot/plugins"
+            ]
+            
+        for url in urls:
+            try:
+                async with aiohttp.ClientSession(trust_env=True) as session:
+                    async with session.get(url) as response:
+                        if response.status == 200:
+                            result = await response.json()
+                            return Response().ok(result).__dict__
+                        else:
+                            logger.error(f"请求 {url} 失败，状态码：{response.status}")
+            except Exception as e:
+                logger.error(f"请求 {url} 失败，错误：{e}")
+        
+        return Response().error("获取插件列表失败").__dict__
    
    async def get_plugins(self):
        _plugin_resp = []
@@ -45,10 +87,58 @@ class PluginRoute(Route):
                "desc": plugin.desc,
                "version": plugin.version,
                "reserved": plugin.reserved,
-                "activated": plugin.activated
+                "activated": plugin.activated,
+                "handlers": await self.get_plugin_handlers_info(plugin.star_handler_full_names),
            }
            _plugin_resp.append(_t)
-        return Response().ok(_plugin_resp).__dict__
+        return Response().ok(_plugin_resp, message=self.plugin_manager.failed_plugin_info).__dict__
+    
+    async def get_plugin_handlers_info(self, handler_full_names: list[str]):
+        '''解析插件行为'''
+        handlers = []
+        
+        for handler_full_name in handler_full_names:
+            info = {}
+            handler = star_handlers_registry.star_handlers_map.get(handler_full_name, None)
+            if handler is None:
+                continue
+            info["event_type"] = handler.event_type.name
+            info["event_type_h"] = self.translated_event_type.get(handler.event_type, handler.event_type.name)
+            info["handler_full_name"] = handler.handler_full_name
+            info["desc"] = handler.desc
+            info["handler_name"] = handler.handler_name
+            
+            if handler.event_type == EventType.AdapterMessageEvent:
+                # 处理平台适配器消息事件
+                has_admin = False
+                for filter in handler.event_filters: # 正常handler就只有 1~2 个 filter，因此这里时间复杂度不会太高
+                    if isinstance(filter, CommandFilter):
+                        info["type"] = "指令"
+                        info["cmd"] = filter.command_name
+                    elif isinstance(filter, CommandGroupFilter):
+                        info["type"] = "指令组"
+                        info["cmd"] = filter.group_name
+                        info["sub_command"] = filter.print_cmd_tree(filter.sub_command_filters)
+                    elif isinstance(filter, RegexFilter):
+                        info["type"] = "正则匹配"
+                        info["cmd"] = filter.regex_str
+                    elif isinstance(filter, PermissionTypeFilter):
+                        has_admin = True
+                info["has_admin"] = has_admin
+                if "cmd" not in info:
+                    info["cmd"] = "未知"
+                if "type" not in info:
+                    info["type"] = "事件监听器"
+            else:
+                info["cmd"] = "自动触发"
+                info["type"] = "无"
+                
+            if not info["desc"]:
+                info["desc"] = "无描述"
+                
+            handlers.append(info)
+                    
+        return handlers
        
    async def install_plugin(self):
        post_data = await request.json
@@ -56,6 +146,7 @@ class PluginRoute(Route):
        try:
            logger.info(f"正在安装插件 {repo_url}")
            await self.plugin_manager.install_plugin(repo_url)
+            self.core_lifecycle.restart()
            logger.info(f"安装插件 {repo_url} 成功。")
            return Response().ok(None, "安装成功。").__dict__
        except Exception as e:
@@ -67,9 +158,10 @@ class PluginRoute(Route):
            file = await request.files
            file = file['file']
            logger.info(f"正在安装用户上传的插件 {file.filename}")
-            file_path = f"data/temp/{uuid.uuid4()}.zip"
+            file_path = f"data/temp/{file.filename}"
            await file.save(file_path)
-            self.plugin_manager.install_plugin_from_file(file_path)
+            await self.plugin_manager.install_plugin_from_file(file_path)
+            self.core_lifecycle.restart()
            logger.info(f"安装插件 {file.filename} 成功")
            return Response().ok(None, "安装成功。").__dict__
        except Exception as e:
@@ -94,6 +186,7 @@ class PluginRoute(Route):
        try:
            logger.info(f"正在更新插件 {plugin_name}")
            await self.plugin_manager.update_plugin(plugin_name)
+            self.core_lifecycle.restart()
            logger.info(f"更新插件 {plugin_name} 成功。")
            return Response().ok(None, "更新成功。").__dict__
        except Exception as e:
--- a/astrbot/dashboard/routes/stat.py
+++ b/astrbot/dashboard/routes/stat.py
@@ -15,7 +15,6 @@ class StatRoute(Route):
        self.routes = {
            '/stat/get': ('GET', self.get_stat),
            '/stat/version': ('GET', self.get_version),
-            '/stat/dashboard-version': ('GET', self.get_dashboard_version),
            '/stat/start-time': ('GET', self.get_start_time),
            '/stat/restart-core': ('GET', self.restart_core)
        }
@@ -37,16 +36,6 @@ class StatRoute(Route):
            "version": VERSION
        }).__dict__
        
-    async def get_dashboard_version(self):
-        async with aiohttp.ClientSession() as session:
-            async with session.get('https://api.github.com/repos/Soulter/Astrbot-dashboard/actions/artifacts') as resp:
-                data = await resp.json()
-                return Response().ok({
-                    "data": data,
-                    "mark": "unimplemented feature"
-                }).__dict__
-        
-        
    async def get_start_time(self):
        return Response().ok({
            "start_time": self.core_lifecycle.start_time
--- a/astrbot/dashboard/routes/static_file.py
+++ b/astrbot/dashboard/routes/static_file.py
@@ -3,9 +3,13 @@ class StaticFileRoute(Route):
    def __init__(self, context: RouteContext) -> None:
        super().__init__(context)
        
-        index_ = ['/', '/auth/login', '/config', '/logs', '/extension', '/dashboard/default', '/project-atri', '/console']
+        index_ = ['/', '/auth/login', '/config', '/logs', '/extension', '/dashboard/default', '/project-atri', '/console', '/chat']
        for i in index_:
            self.app.add_url_rule(i, view_func=self.index)
+            
+        @self.app.errorhandler(404)
+        async def page_not_found(e):
+            return "404 Not found。如果你初次使用打开面板发现 404，请参考文档: https://astrbot.app/deploy/dashboard-404.html"
    
    async def index(self):
        return await self.app.send_static_file('index.html')
--- a/astrbot/dashboard/routes/update.py
+++ b/astrbot/dashboard/routes/update.py
@@ -1,33 +1,50 @@
-import threading
 import traceback
+import aiohttp
 from .route import Route, Response, RouteContext
 from quart import request
+from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
 from astrbot.core.updator import AstrBotUpdator
 from astrbot.core import logger, pip_installer
+from astrbot.core.utils.io import download_dashboard, get_dashboard_version
+from astrbot.core.config.default import VERSION

 class UpdateRoute(Route):
-    def __init__(self, context: RouteContext, astrbot_updator: AstrBotUpdator) -> None:
+    def __init__(self, context: RouteContext, astrbot_updator: AstrBotUpdator, core_lifecycle: AstrBotCoreLifecycle) -> None:
        super().__init__(context)
        self.routes = {
            '/update/check': ('GET', self.check_update),
            '/update/do': ('POST', self.update_project),
+            '/update/dashboard': ('POST', self.update_dashboard),
            '/update/pip-install': ('POST', self.install_pip_package)
        }
        self.astrbot_updator = astrbot_updator
+        self.core_lifecycle = core_lifecycle
        self.register_routes()
    
    async def check_update(self):
+        type_ = request.args.get('type', None)
+        
        try:
-            ret = await self.astrbot_updator.check_update(None, None)
-            return Response(
-                status="success",
-                message=str(ret) if ret is not None else "已经是最新版本了。",
-                data={
-                    "has_new_version": ret is not None
-                }
-            ).__dict__
+            dv = await get_dashboard_version()
+            if type_ == 'dashboard':
+                return Response().ok({
+                    "has_new_version": dv != f"v{VERSION}",
+                    "current_version": dv
+                }).__dict__
+            else:
+                ret = await self.astrbot_updator.check_update(None, None)
+                return Response(
+                    status="success",
+                    message=str(ret) if ret is not None else "已经是最新版本了。",
+                    data={
+                        "version": f"v{VERSION}",
+                        "has_new_version": ret is not None,
+                        "dashboard_version": dv,
+                        "dashboard_has_new_version": dv != f"v{VERSION}"
+                    }
+                ).__dict__
        except Exception as e:
-            logger.error(traceback.format_exc())
+            logger.warning(f"检查更新失败: {str(e)} (不影响除项目更新外的正常使用)")
            return Response().error(e.__str__()).__dict__
    
    async def update_project(self):
@@ -41,8 +58,23 @@ class UpdateRoute(Route):
            latest = False
        try:
            await self.astrbot_updator.update(latest=latest, version=version)
+            
+            if latest:
+                try:
+                    await download_dashboard()
+                except Exception as e:
+                    logger.error(f"下载管理面板文件失败: {e}。")
+                    
+            # pip 更新依赖
+            logger.info("更新依赖中...")
+            try:
+                pip_installer.install(requirements_path="requirements.txt")
+            except Exception as e:
+                logger.error(f"更新依赖失败: {e}")
+            
            if reboot:
-                threading.Thread(target=self.astrbot_updator._reboot, args=(2, )).start()
+                # threading.Thread(target=self.astrbot_updator._reboot, args=(2, )).start()
+                self.core_lifecycle.restart()
                return Response().ok(None, "更新成功，AstrBot 将在 2 秒内全量重启以应用新的代码。").__dict__
            else:
                return Response().ok(None, "更新成功，AstrBot 将在下次启动时应用新的代码。").__dict__
@@ -50,6 +82,18 @@ class UpdateRoute(Route):
            logger.error(f"/api/update_project: {traceback.format_exc()}")
            return Response().error(e.__str__()).__dict__
        
+    async def update_dashboard(self):
+        try:
+            try:
+                await download_dashboard()
+            except Exception as e:
+                logger.error(f"下载管理面板文件失败: {e}。")
+                return Response().error(f"下载管理面板文件失败: {e}").__dict__
+            return Response().ok(None, "更新成功。刷新页面即可应用新版本面板。").__dict__
+        except Exception as e:
+            logger.error(f"/api/update_dashboard: {traceback.format_exc()}")
+            return Response().error(e.__str__()).__dict__
+        
    async def install_pip_package(self):
        data = await request.json
        package = data.get('package', '')
--- a/astrbot/dashboard/server.py
+++ b/astrbot/dashboard/server.py
@@ -24,7 +24,7 @@ class AstrBotDashboard():
        # token 用于验证请求
        logging.getLogger(self.app.name).removeHandler(default_handler)
        self.context = RouteContext(self.config, self.app)
-        self.ur = UpdateRoute(self.context, core_lifecycle.astrbot_updator)
+        self.ur = UpdateRoute(self.context, core_lifecycle.astrbot_updator, core_lifecycle)
        self.sr = StatRoute(self.context, db, core_lifecycle)
        self.pr = PluginRoute(self.context, core_lifecycle, core_lifecycle.plugin_manager)
        self.cr = ConfigRoute(self.context, core_lifecycle)
@@ -68,8 +68,14 @@ class AstrBotDashboard():
        
    def run(self):
        ip_addr = get_local_ip_addresses()
-        logger.info(f"""🌈 管理面板已启动，可访问
+        logger.info(f"""
+✨✨✨
+AstrBot 管理面板已启动，可访问
+
 1. http://{ip_addr}:6185
 2. http://localhost:6185
-登录。默认用户名和密码是 astrbot。""")
+
+默认用户名和密码是 astrbot。
+✨✨✨
+""")
        return self.app.run_task(host="0.0.0.0", port=6185, shutdown_trigger=self.shutdown_trigger_placeholder)
--- a/changelogs/v3.4.10.md
+++ b/changelogs/v3.4.10.md
@@ -0,0 +1,12 @@
+# What's Changed
+
+- 修复 LLM 请求报错信息被覆盖的问题，增强 LLM 请求错误处理 #243
+- 修复 Napcat 接口更新导致 QQ 图片发送失败的问题 #246
+- 修复某些请求不能正确应用代理的问题
+- 针对 api_base 的明显提示，修改 ollama 模板的 api_base #247
+- 支持登出 gewechat，在webchat等地方使用 `/gewe_logout` 指令，这在微信上显示账号下线但是 gewe 仍显示设备在线时很好用
+- 添加gewechat适配器过滤器
+- help显示AstrBot和webui版本
+- 优化webui和主程序更新的协调
+- 下载管理面板时显示提示、下载进度和下载速度
+- 管理面板前端更新功能入口移入右上角更新按钮，以便统一管理 #245
--- a/changelogs/v3.4.11.md
+++ b/changelogs/v3.4.11.md
@@ -0,0 +1,6 @@
+# What's Changed
+
+- 为平台和提供商适配器添加默认 ID 配置 #248
+- 修复appid保存的问题和部分群聊at失效的问题和群聊@的sender username显示异常的问题
+- 优化更新项目时重启可能会导致Address already in use的问题
+- 各类异步任务报错后的优雅报错输出，而不是只有在退出程序的时候才输出异常日志。
--- a/changelogs/v3.4.12.md
+++ b/changelogs/v3.4.12.md
@@ -0,0 +1,6 @@
+# What's Changed
+
+- Gewechat 微信支持图片、语音的收和发
+- 支持 OpenAI TTS（文字转语音）
+- 支持路径映射，解决 docker 部署时两端文件系统不一致导致的富媒体文件路径不存在问题
+- Napcat 下语音消息可能接收异常
--- a/changelogs/v3.4.13.md
+++ b/changelogs/v3.4.13.md
@@ -0,0 +1,4 @@
+# What's Changed
+
+- 修复 astrbot_updator 属性缺失与stt_enabled 未初始化 #252
+- 支持消息分段回复
--- a/changelogs/v3.4.14.md
+++ b/changelogs/v3.4.14.md
@@ -0,0 +1,8 @@
+# What's Changed
+
+- 修复: TTS 问题
+- 新增: **支持记录非唤醒状态下群聊历史记录(beta)**
+- 优化: 自动删除 deepseek-r1 模型自带的 think 标签
+- 优化: 自动移除 ollama 不支持 tool 的模型的 tool 请求
+- 优化: /t2i 即时生效
+- 优化: gewechat 消息下发异常处理
--- a/changelogs/v3.4.15.md
+++ b/changelogs/v3.4.15.md
@@ -0,0 +1,9 @@
+# What's Changed
+
+- 修复: 配置 Validator 不起效的问题
+- 修复: DeepSeek-R1 思考标签问题
+- 修复: 分段回复间隔时间不生效
+- 修复: 修复白名单为空时依然终止事件 #259
+- 修复: 群聊增强某些参数的类型转换问题
+- 新增: 插件支持注册配置，详见 [注册插件配置](https://astrbot.app/dev/plugin.html#%E6%B3%A8%E5%86%8C%E6%8F%92%E4%BB%B6%E9%85%8D%E7%BD%AE-beta)
+- 优化: 插件的禁用/启用逻辑以及函数工具的禁用/启用逻辑
--- a/changelogs/v3.4.16.md
+++ b/changelogs/v3.4.16.md
@@ -0,0 +1,6 @@
+# What's Changed
+
+- [gewechat] [修复每次启动astrbot都需要扫码的问题](https://github.com/Soulter/AstrBot/commit/fd5d7dd37a6d74f81a148bbebef8516aa0cb5540)
+- [core] [Provider 重复时不直接报错闪退](https://github.com/Soulter/AstrBot/commit/b61f9be18db9a6b8b3c5b6b36553f66dd2b79375) https://github.com/Soulter/AstrBot/issues/265
+- [core] [弱化更新报错](https://github.com/Soulter/AstrBot/commit/0ba0150fd8ff2062dbe83889163888ba3e33bd49) https://github.com/Soulter/AstrBot/issues/267 
+- 修复 webui 无法从本地上传插件的问题
--- a/changelogs/v3.4.17.md
+++ b/changelogs/v3.4.17.md
@@ -0,0 +1,11 @@
+# What's Changed
+
+- [beta] 支持群聊内基于概率的主动回复
+- openai tts 更换模型 #300
+- 增加模型响应后的插件钩子
+- 修复 相同type的provider共享了记忆
+- 优化 人格情景在发现格式不对时仍然加载而不是跳过 #282
+- 修复 Gemini函数调用时，parameters为空对象导致的错误 by @Camreishi
+- 修复 弹出记录报错的问题 #272
+- 优化 移除默认人格
+- 优化 未启用模型提供商时的异常处理
--- a/changelogs/v3.4.18.md
+++ b/changelogs/v3.4.18.md
@@ -0,0 +1,12 @@
+# What's Changed
+
+- fix: 修复主动概率回复关闭后仍然回复的问题 #317
+- fix: 尝试修复 gewechat 群聊收不到 at 的回复 #294
+- perf: 移除了默认人格
+- fix: 修复HTTP代理删除后不生效 #319
+- fix: 调用Gemini API输出多余空行问题 #318
+- feat: 添加硅基流动模版
+- fix: 硅基流动 not a vlm 和 tool calling not supported 报错 #305 #291
+- perf: 回复时艾特发送者之后添加空格或换行 #312
+- fix: docker容器内时区不对导致 reminder 时间错误
+- perf: siliconcloud 不支持 tool 的模型
--- a/changelogs/v3.4.19.md
+++ b/changelogs/v3.4.19.md
@@ -0,0 +1,13 @@
+# What's Changed
+
+1. 支持接入企业微信（测试）
+2. 修复速率限制不可用的问题
+3. gewechat 回调接口默认暴露在所有 IP
+4. 适配 Azure OpenAI
+5. 修复请求 gemini 出现 KeyError 'candidates' 的错误
+6. 将 /reset /persona 挪入管理员指令 #308
+7. 支持通过 /alter_cmd 设置所有指令是否只能管理员操作
+8. /plugin 指令支持查看插件注册的指令和指令组
+9. 插件注册指令支持传入指令的描述以方便 /plugin 查看。需要写在函数的第一行的 docstring 中。
+10. 修复 schema 中 object hint 不显示 #290
+11. feat: 优化插件市场的访问速度
--- a/changelogs/v3.4.20.md
+++ b/changelogs/v3.4.20.md
@@ -0,0 +1,15 @@
+# What's Changed
+
+> 由于重写了会话记录部分，更新此版本后，将会造成之前的对话记录清空（但没有被删除）。
+> 关于更好的对话管理，如果有任何报错或者优化建议，请直接提交 issue~
+
+1. 更好的对话管理，支持 /ls, /del, /new, /switch, /rename 指令来操作对话。
+2. 人格情境跟随对话。每个对话支持独立设置人格情境，只需要 /persona 指令切换即可。
+3. 支持使用 LLM 辅助分段回复 #338
+4. 优化 aiocqhttp 适配器对用户非法输入的处理
+5. 优化插件页面
+6. 修复权限过滤算子导致的问题 #350
+7. 修复级联指令组时出现载入错误的问题 #366
+8. 修复代码执行器的一个typo by @eltociear
+9. 修复指令组情况下可能造成多指令出触发的问题
+10. 添加屏蔽无权限指令回复的功能 #361
--- a/changelogs/v3.4.21.md
+++ b/changelogs/v3.4.21.md
@@ -0,0 +1,19 @@
+# What's Changed
+
+> 由于重写了会话记录部分，更新此版本后，将会造成之前的对话记录清空（但没有被删除）。
+> 关于更好的对话管理，如果有任何报错或者优化建议，请直接提交 issue~
+
+1. 修复 reminder 时区问题
+2. 面板支持重载单个插件 #297
+3. 面板支持列表展示插件市场
+4. 文字转图片支持自定义字数阈值(配置->其他配置)
+5. 面板更好的列表可视化 #274
+6. 面板支持查看插件行为
+7. 支持设置 timeout 超时时间参数，防止思考模型太长达到超时时间。(需要重新配置服务提供商或者在服务提供商 config 中配置 timeout 参数) #378
+8. openrouter 报错 no endpoints found that support tool use #371
+9. 修复插件 metadata 不生效的问题
+10. 修复不支持图片的模型请求异常
+11. 修复 reminder 无法删除的问题 
+12. 修复 /model 切换不了模型的问题
+13. 插件支持设置优先级 
+14. 聊天增强图像转述支持自定义 provider id。#274
--- a/changelogs/v3.4.22.md
+++ b/changelogs/v3.4.22.md
@@ -0,0 +1,12 @@
+# What's Changed
+
+1. fix: 400 Bad Request: The browser (or proxy) sent a request that this server could not understand. #396
+2. remove: 移除了 put_history_to_prompt。当主动回复时，将群聊记录将自动放入prompt，当未主动回复但是开启群聊增强时，群聊记录将放入system prompt
+3. fix: 插件错误信息点击关闭没反应 #394
+4. fix: 自部署文转图不生效 #352
+5. fix: Google Search 报 429 错误时，放宽 Exception 至其他搜索引擎 #405
+6. fix: 使用 Google Gemini （OpenAI 兼容）的部分情况下联网搜索等函数调用工具没被调用 #342
+7. fix: 修复尝试弹出最早的记录失效的问题
+8. fix: 移除了分段回复llm提示词辅助
+9. perf: 当图片数据为空时不加入上下文 #379
+10. 修复 dify 返回的结果带有多行数据时的 json 解析异常导致返回值为空的问题 #298 by @zhaolj
--- a/changelogs/v3.4.6.md
+++ b/changelogs/v3.4.6.md
@@ -0,0 +1,9 @@
+# What's Changed
+
+- 文件和语音功能适配 Lagrange
+- 面板文件更新检查和引导提示
+- WebUI AboutPage 关于页
+- 支持并完善服务提供商（Provider）默认配置模板接口
+- 修复 WebUI 配置页官方文档链接 404 的问题
+- 修复 WebUI WebChat 刷新时 404 的问题
+- 优化 download_file 的 SSL 连接错误处理
--- a/changelogs/v3.4.7.md
+++ b/changelogs/v3.4.7.md
@@ -0,0 +1,6 @@
+# What's Changed
+
+- 更好的人格情景管理
+- 移除了不常用的人格提示词集
+- 优化webchat长连接的处理逻辑
+- 修复 tool 为空时部分模型请求错误的问题 #239
--- a/changelogs/v3.4.8.md
+++ b/changelogs/v3.4.8.md
@@ -0,0 +1,5 @@
+# What's Changed
+
+- 支持 Gewechat 接入微信个人号(文字交互)
+- 支持回复时 At 和引用发送者 #241
+- 清除残留的 personalities
--- a/changelogs/v3.4.9.md
+++ b/changelogs/v3.4.9.md
@@ -0,0 +1,6 @@
+# What's Changed
+
+- AstrBot 新域名：astrbot.app
+- LLM额外唤醒词与机器人唤醒词冲突时的处理
+- 调整部分日志的严重级别
+- 下载管理面板时显示提示、下载进度和下载速度
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Soulter	a8b2b09e0f	v3.4.22	2025-02-08 00:01:47 +08:00
Soulter	6858b8c555	perf: 当图片数据为空时不加入上下文 #379	2025-02-07 23:57:25 +08:00
Soulter	0e493b1a0e	Merge pull request #411 from zhaolj/fix-bug-#298 fix bug #298	2025-02-07 23:39:03 +08:00
Soulter	37d478f970	fix: 移除了分段回复llm提示词辅助	2025-02-07 23:21:05 +08:00
zhaolj	7d0d42a49f	fix bug #298	2025-02-07 22:57:49 +08:00
Soulter	0eb1684ef1	fix: 修复 openai_source 尝试弹出最早的记录失败的问题	2025-02-07 22:38:04 +08:00
Soulter	9b0b723143	fix: 联网搜索失败，函数调用无返回值 #342	2025-02-07 22:07:56 +08:00
Soulter	532bc6e1e6	fix: Google Search 报 429 错误时，放宽 Exception 至其他搜索引擎 #405	2025-02-07 21:32:06 +08:00
Soulter	fe3ed4c454	fix: 自部署文转图不生效 #352	2025-02-07 20:24:11 +08:00
Soulter	b5ec89e586	fix: 插件错误信息点击关闭没反应 #394	2025-02-07 20:05:45 +08:00
Soulter	895e7397c2	remove: 移除了 put_history_to_prompt。当主动回复时，将群聊记录将自动放入prompt，当未主动回复但是开启群聊增强时，群聊记录将放入system prompt	2025-02-07 20:00:30 +08:00
Soulter	59b767957a	fix: 400 Bad Request: The browser (or proxy) sent a request that this server could not understand. #396	2025-02-07 18:26:31 +08:00
Soulter	17d4bf8f22	perf: 管理面板优化新增列表项的提示	2025-02-06 20:19:53 +08:00
Soulter	836be3b097	update: changelogs	2025-02-06 18:51:47 +08:00
Soulter	310415bea9	feat: 聊天增强图像转述支持自定义 Provider id	2025-02-06 18:49:16 +08:00
Soulter	aafc1276a9	v3.4.21	2025-02-06 18:34:43 +08:00
Soulter	2993e794cc	perf: hint	2025-02-06 17:45:15 +08:00
Soulter	58cb9cfb2d	chore: clean code	2025-02-06 17:43:04 +08:00
Soulter	fbdf0901d5	fix: 修复reminder时区问题	2025-02-06 17:41:34 +08:00
Soulter	af8c81b621	feat: 支持重载插件	2025-02-06 17:27:53 +08:00
Soulter	06b5275e48	perf: 增加报错显示	2025-02-06 16:43:40 +08:00
Soulter	ad95572d5f	perf: 更好的 list 可视化	2025-02-06 15:59:45 +08:00
Soulter	aebc7850f4	fix: openrouter 报错 no endpoints found that support tool use #371	2025-02-06 15:25:15 +08:00
Soulter	1b7efbc607	支持列表展示插件市场	2025-02-06 15:18:11 +08:00
Soulter	3800e96d14	fix: 修复metadata不生效的问题 feat: 支持查看插件行为	2025-02-06 15:10:24 +08:00
Soulter	461f1bb07c	feat: 支持插件handler优先级	2025-02-06 12:35:43 +08:00
Soulter	7d4c07e4f6	feat: 支持设置 timeout	2025-02-06 12:31:39 +08:00
Soulter	31b788f463	fix: 修复不支持图片的模型请求异常	2025-02-06 01:50:53 +08:00
Soulter	96ab761f73	fix: 修复reminder无法删除的问题	2025-02-05 22:45:02 +08:00
Soulter	2b3f05c039	update: 优化部分注释	2025-02-05 19:58:48 +08:00
Soulter	f2e8303b66	fix: KeyError _mood_imitation_dialogs_processed	2025-02-05 18:52:55 +08:00
Soulter	2a614b545b	fix: 修复可能的 KeyError	2025-02-05 17:17:05 +08:00
Soulter	5c0ab21f68	fix: 修复 /model 异常	2025-02-05 17:05:47 +08:00
Soulter	689d109438	typo: myid -> sid	2025-02-05 16:59:21 +08:00
Soulter	2a6934b283	perf: 无对话状态的提示	2025-02-05 16:56:13 +08:00
Soulter	760cb94e9a	v3.4.20	2025-02-05 16:06:52 +08:00
Soulter	2a6cff0013	feat: 支持重命名对话	2025-02-05 16:06:18 +08:00
Soulter	ce578f0417	feat: 支持使用 LLM 辅助分段回复 #338	2025-02-05 15:40:52 +08:00
Soulter	1745bdb9e2	perf: 优化一些问题	2025-02-05 15:39:59 +08:00
Soulter	3f90b89c3c	添加屏蔽无权限指令回复的功能 #361	2025-02-05 15:06:38 +08:00
Soulter	f343e40d15	Merge pull request #370 from Soulter/feat-conversation feat: 更好的对话管理	2025-02-05 14:56:47 +08:00
Soulter	5cc4be9e65	perf: 优化部分显示问题	2025-02-05 14:51:40 +08:00
Soulter	da5aada002	fix: 修复指令组情况下可能造成多指令出触发的问题	2025-02-05 13:52:53 +08:00
Soulter	07f2ee9ad9	fix: 修复 /reset 指令	2025-02-05 13:33:36 +08:00
Soulter	12f4e1146f	feat: 更好的对话管理	2025-02-05 13:26:53 +08:00
Soulter	92c57e5476	fix: 修复级联指令组时出现载入错误的问题	2025-02-05 11:11:04 +08:00
Soulter	a923baacd8	Update README.md	2025-02-05 01:56:09 +08:00
Soulter	999b094d55	Merge pull request #358 from eltociear/patch-1 chore: update main.py	2025-02-05 01:34:04 +08:00
Soulter	d4213f2352	perf: announcement plugin market	2025-02-05 01:19:54 +08:00
Ikko Eltociear Ashimine	3f65c9a066	chore: update main.py occured -> occurred	2025-02-05 02:18:41 +09:00
Soulter	1d427e2645	perf: 优化插件页面	2025-02-05 01:10:53 +08:00
Soulter	36414c4b00	perf: 优化aiocqhttp适配器对用户非法输入的处理	2025-02-05 00:02:18 +08:00
Soulter	47e253d76c	fix: 修复权限过滤算子导致的问题 #350	2025-02-04 23:31:46 +08:00
Soulter	b73cf84df0	v3.4.19	2025-02-04 16:37:15 +08:00
Soulter	a5b885a774	fix: schema 中 object hint 不显示 #290 feat: 优化插件市场的访问	2025-02-04 16:36:00 +08:00
Soulter	0c785413da	chore: clean code	2025-02-04 15:51:26 +08:00
Soulter	482d7ef5f7	v3.4.19	2025-02-04 15:47:24 +08:00
Soulter	9f9073c0ff	feat: 支持设置所有指令的权限 feat: 插件指令支持设置指令描述 feat: plugin 指令支持查看插件的指令	2025-02-04 15:41:45 +08:00
Soulter	ef05ff4abd	fix: 管理员指令 /reset /persona	2025-02-04 13:50:23 +08:00
Soulter	5848aae435	Update README.md	2025-02-04 13:44:02 +08:00
Soulter	fb06f33de0	Update README.md	2025-02-04 12:51:17 +08:00
Soulter	0d7ddb149e	fix: 修复请求 gemini 推理模型出现 candidates 错误的问题 #333	2025-02-04 00:30:23 +08:00
Soulter	4f2d7b9c4e	feat: 适配 Azure OpenAI #332	2025-02-03 23:59:04 +08:00
Soulter	c02ed96f6f	perf: gewechat 服务端回调接口默认暴露在所有地址	2025-02-03 18:51:19 +08:00
Soulter	3b2ac891b2	fix: 修复限流器不可用的问题 #263	2025-02-03 18:51:19 +08:00
Soulter	ef0108881b	Update Dockerfile	2025-02-03 17:48:17 +08:00
Soulter	af48975a6b	chore: v3.4.18	2025-02-03 16:14:27 +08:00
Soulter	6441b149ab	fix: 修复主动概率回复关闭后仍然回复的问题 #317	2025-02-03 14:33:53 +08:00
Soulter	f8892881f8	fix: 尝试修复 gewechat 群聊收不到 at 的回复 #294	2025-02-03 14:28:14 +08:00
Soulter	228aec5401	perf: 移除了默认人格	2025-02-03 14:17:45 +08:00
Soulter	68ad48ff55	fix: 修复HTTP代理删除后不生效 #319	2025-02-03 14:11:50 +08:00
Soulter	541ba64032	fix: 调用Gemini API输出多余空行问题 #318	2025-02-03 13:27:56 +08:00
Soulter	2d870b798c	feat: 添加硅基流动模版	2025-02-03 13:24:22 +08:00
Soulter	0f1fe1ab63	fix: 硅基流动 not a vlm 和 tool calling not supported 报错 #305 # 291 perf: 安装和更新插件后全量重启避免奇奇怪怪的bug feat: 支持 /tool off_all 停用所有函数工具	2025-02-03 13:20:49 +08:00
Soulter	73cc86ddb1	perf: 回复时艾特发送者之后添加空格或换行 #312	2025-02-03 12:04:26 +08:00
Soulter	23128f4be2	perf: 主动回复不支持 qq_official 的 hint	2025-02-03 12:00:05 +08:00
Soulter	92200d0e82	fix: docker容器内时区不对	2025-02-03 01:15:09 +08:00
Soulter	d6e8655792	fix: 抱错时首先移除 tool	2025-02-02 23:17:59 +08:00
Soulter	37076d7920	perf: siliconcloud 不支持 tool 的模型	2025-02-02 23:05:36 +08:00
Soulter	78347ec91b	perf: 当人格长度为1时设置默认人格 feat: 支持取消人格	2025-02-02 22:36:50 +08:00
Soulter	9ded102a0a	chore: v3.4.17	2025-02-02 20:39:26 +08:00
Soulter	59b7d8b8cb	chore: clean code	2025-02-02 20:15:57 +08:00
Soulter	f5b97f6762	perf: 优化 404 提示	2025-02-02 19:55:32 +08:00
Soulter	d47da241af	feat: openai tts 更换模型 #300	2025-02-02 19:47:39 +08:00
Soulter	4611ce15eb	feat: [beta] 支持群聊内基于概率的主动回复	2025-02-02 19:23:46 +08:00
Soulter	aa8c56a688	fix: 相同type的provider共享了记忆	2025-02-02 19:13:47 +08:00
Soulter	ef44d4471a	feat: 增加模型响应后的插件钩子 remove: 移除了默认的r1过滤	2025-02-02 16:42:21 +08:00
Soulter	5581eae957	fix: deepseek-r1模型存在遗留“</think>”的问题 #279 Open	2025-02-02 14:59:17 +08:00
Soulter	ec46dfaac9	perf: 人格情景在发现格式不对时仍然加载而不是跳过 #282	2025-02-02 14:59:17 +08:00
Soulter	6042a047bd	修复Gemini函数调用时，parameters为空对象导致的错误 fix: 修复Gemini函数调用时，parameters为空对象导致的错误	2025-02-02 14:50:34 +08:00
Soulter	6ca9e2a753	perf: websearch 可选配置引用链接 #287	2025-02-02 14:42:13 +08:00
Camreishi	618eabfe5c	fix: 修复Gemini函数调用时，parameters为空对象导致的错误 Closes #288	2025-02-02 13:25:08 +08:00
Soulter	bb5db2e9d0	fix: 修复弹出记录报错的问题 #272	2025-02-02 13:24:05 +08:00
Soulter	97e4d169b3	perf: 未启用模型提供商时的异常处理	2025-02-02 11:23:33 +08:00
Soulter	50e44b1473	perf: 移除默认人格	2025-02-02 11:12:17 +08:00
Soulter	38588dd3fa	update compose	2025-02-02 00:11:55 +08:00
Soulter	d183388347	perf: 去除gewechat默认配置	2025-02-01 23:20:25 +08:00
Soulter	1e69d59384	fix: 配置提示 typo	2025-02-01 22:56:34 +08:00
Soulter	00f008f94d	Update compose.yml	2025-02-01 21:31:24 +08:00
Soulter	3c28001a74	v3.4.16	2025-02-01 19:31:59 +08:00
Soulter	76a6218be6	fix: 修复webui无法从本地上传插件的问题	2025-02-01 19:31:29 +08:00
Soulter	6c1de1bbd6	Update README.md	2025-02-01 16:19:01 +08:00
Soulter	d7678081da	perf: Provider 重复时不直接报错闪退 #265	2025-02-01 14:36:41 +08:00
Soulter	5e4ba563cb	perf: 弱化更新报错 #267	2025-02-01 14:29:39 +08:00
Soulter	8afbe77b0a	Update README.md	2025-02-01 12:11:58 +08:00
Soulter	2ef139b59a	fix: 修复每次启动astrbot都需要微信扫码的问题	2025-01-31 01:28:49 +08:00
Soulter	1f0d2d9b89	fix: QQ官方机器人开启 reply with metion 和 reply with quote 后，无法正常回复消息 #244	2025-01-30 01:36:25 +08:00
Soulter	37a1f144ab	chore: update changelog of 3.4.15	2025-01-30 00:32:50 +08:00
Soulter	9a7a654596	perf: 插件处于禁用状态时其所属的函数调用工具不可被启用 #254	2025-01-30 00:27:10 +08:00
Soulter	9abccd63cf	chore: remove stt.py	2025-01-29 23:47:50 +08:00
Soulter	93fea77182	chore: bump to v3.4.15	2025-01-29 23:43:09 +08:00
Soulter	19797243f6	perf: 增加插件链接	2025-01-29 19:56:09 +08:00
Soulter	c9c733d925	Merge branch 'dev'	2025-01-29 19:43:52 +08:00
Soulter	a7d7678c78	fix: 修复白名单为空时依然终止事件 #259	2025-01-29 17:17:27 +08:00
Soulter	c0911921c7	feat: 配置Schema以及插件支持配置	2025-01-29 16:54:57 +08:00
Soulter	4a4241d57a	Update README.md	2025-01-29 13:26:51 +08:00
Soulter	c9426bb6eb	config	2025-01-29 12:25:54 +08:00
Soulter	db4abd169a	fix: 优化分段回复	2025-01-28 14:42:15 +08:00
Soulter	80b6958599	fix: 修复 config validator 不起效的问题	2025-01-28 14:18:21 +08:00
Soulter	80058c781a	fix: 修复r1思考标签问题和分段回复间隔时间问题	2025-01-28 14:03:10 +08:00
Soulter	44bd2e36f3	Update README.md	2025-01-28 02:15:11 +08:00
Soulter	3589a5e5be	perf: 强化ltm异常处理	2025-01-27 21:47:35 +08:00
Soulter	13ef033f0e	fix: 群聊增强的参数类型转换	2025-01-27 21:40:20 +08:00
Soulter	3f8c68bbca	fix: f-string expression part cannot include a backslash long_term_memory.py, line 69	2025-01-27 21:01:50 +08:00
Soulter	4275cea82b	chore: v3.4.14	2025-01-27 20:09:03 +08:00
Soulter	a0bcb5339a	perf: 自动删除 deepseek-r1 模型自带的 think 标签	2025-01-27 20:04:39 +08:00
Soulter	43deec4a4b	Merge pull request #255 from Soulter/feat-ltm 支持记录非唤醒状态下群聊历史记录	2025-01-27 20:02:43 +08:00
Soulter	2bc433a30b	feat: 支持记录非唤醒状态下群聊历史记录	2025-01-27 20:00:32 +08:00
Soulter	eb2b395932	perf: /t2i 即时生效	2025-01-27 19:33:38 +08:00
Soulter	2bfd1c0bf2	perf: 自动移除 ollama 不支持 tool 的模型的 tool 请求	2025-01-27 19:25:28 +08:00
Soulter	7228c4b13f	fix: 修复 TTS 部分变量名错误导致请求失败	2025-01-27 18:45:34 +08:00
Soulter	9351d7471f	perf: 优化 gewechat 消息下发异常处理	2025-01-27 18:11:31 +08:00
Soulter	1cf49998bc	Update README.md	2025-01-27 11:34:27 +08:00
Soulter	6ae86597e8	chore: v3.4.13	2025-01-26 16:51:13 +08:00
Soulter	c578ff25bd	fix: stt_enabled 未初始化 #252	2025-01-26 16:51:02 +08:00
Soulter	2934a3e3be	chore: logo	2025-01-26 15:18:23 +08:00
Soulter	ceaa69da75	feat: 支持消息分段回复	2025-01-26 13:45:32 +08:00
Soulter	fa8e731576	Update README.md	2025-01-25 22:45:47 +08:00
Soulter	685c0a106a	perf: use pysilk instead of pilk 避免构建问题	2025-01-25 20:18:40 +08:00
Soulter	7f539090dd	perf: 更新项目时连带更新依赖	2025-01-25 20:04:28 +08:00
Soulter	2089273f95	Merge pull request #251 from Soulter/feat-tts 适配 OpenAI TTS API，并支持 Napcat，Gewechat，Lagrange 的语音输出	2025-01-25 19:51:22 +08:00
Soulter	838bb4c7ad	chore: remove duration	2025-01-25 19:49:53 +08:00
Soulter	637acd1a12	feat: 适配 OpenAI TTS API，并支持 Napcat，Gewechat，Lagrange 的语音输出	2025-01-25 19:46:00 +08:00
Soulter	03fa9a847f	feat: gewechat 支持语音、图片	2025-01-25 16:34:40 +08:00
Soulter	d488c88e78	feat: 支持路径映射，解决docker部署两端文件系统不一致导致的富媒体文件路径不存在问题	2025-01-24 14:08:08 +08:00
Soulter	baae842210	fix: napcat 下语音消息接收异常	2025-01-24 13:41:13 +08:00
Soulter	ec1fb838b6	perf: notice	2025-01-22 21:38:05 +08:00
Soulter	13281179df	perf: notice	2025-01-22 21:36:28 +08:00
Soulter	276a42c9a1	Bump to 3.4.11	2025-01-22 21:16:24 +08:00
Soulter	7a70a730ba	perf: 任务报错后的优雅报错输出	2025-01-22 21:14:26 +08:00
Soulter	d0fe59631c	perf: 优化更新项目时重启可能会导致Address already in use的问题	2025-01-22 20:57:15 +08:00
Soulter	106892e933	fix: 修复appid保存的问题和部分群聊at失效的问题和群聊@的sender username显示异常的问题	2025-01-22 20:34:52 +08:00
Soulter	19543a41b3	Update README.md	2025-01-22 19:56:07 +08:00
Soulter	b172b760ab	feat: 为平台和提供商适配器添加默认 ID 配置 #248	2025-01-22 16:52:34 +08:00
Soulter	4b5d49cb41	Bump to 3.4.10	2025-01-22 00:19:20 +08:00
Soulter	3fd35b6058	feat: 管理面板更新面板按钮 #245	2025-01-22 00:17:43 +08:00
Soulter	5f86c4ab99	perf: 增强 LLM 请求错误处理 #243	2025-01-21 16:29:19 +08:00
Soulter	c94a7f6629	perf: 针对 api_base 的明显提示，修改 ollama 模板的api_base #247	2025-01-21 16:15:04 +08:00
Soulter	7d6beb4141	fix: QQ 图片发送不了 #246	2025-01-21 16:12:10 +08:00
Soulter	e2117e690a	feat: 支持登出gewechat	2025-01-21 13:12:09 +08:00
Soulter	fb791290e2	fix: 添加gewechat适配器过滤器	2025-01-21 12:39:57 +08:00
Soulter	5dd1488b5d	perf: 优化webui和主程序更新的协调 fix: 修复某些请求不能正确应用代理的问题	2025-01-21 01:08:15 +08:00
Soulter	529cd64d82	perf: help显示AstrBot和webui版本	2025-01-21 00:10:59 +08:00
Soulter	d2bd3e8da8	bump to v3.4.9	2025-01-20 23:35:34 +08:00
Soulter	e42ce7dd86	perf: 优化了用户体验	2025-01-20 23:27:13 +08:00
Soulter	40709462ee	chore: bump domain to astrbot.app	2025-01-20 19:02:54 +08:00
Soulter	2ad6c01a4d	Update README.md	2025-01-20 15:48:39 +08:00
Soulter	70c12e788e	feat: LLM额外唤醒词与机器人唤醒词冲突时的处理	2025-01-20 10:22:25 +08:00
Soulter	1713791c90	docs: update webui demo	2025-01-20 00:46:29 +08:00
Soulter	9aa23fd412	Update README.md	2025-01-19 21:32:42 +08:00
Soulter	e4ba09cd93	chore: remove package-lock.json	2025-01-19 18:20:40 +08:00
Soulter	171fdf1fbc	fix: 消息链无元素时仍然插入了@和回复	2025-01-18 23:25:42 +08:00
Soulter	01f4e0b961	feat: gewechat 主动消息	2025-01-18 22:31:17 +08:00
Soulter	be2d5a91c7	chore: bump to v3.4.8	2025-01-18 22:19:35 +08:00
Soulter	a1d89d9478	Merge pull request #242 from Soulter/feat-gewechat 初步接入 gewechat 文字交互	2025-01-18 22:16:53 +08:00
Soulter	98d1dc3b65	feat: 初步接入 gewechat 文字交互	2025-01-18 22:01:36 +08:00
Soulter	b80eb3acc0	feat: 支持回复时 At 和引用发送者 #241	2025-01-18 17:31:11 +08:00
Soulter	05ccc1995b	fix: 清除残留的 personalities	2025-01-18 17:31:11 +08:00
Soulter	0de244889e	chore: gitsponsors	2025-01-18 10:54:37 +08:00
Soulter	e6c5c3a493	chore: bump to v3.4.7	2025-01-16 11:26:05 +08:00
Soulter	164aa2ccd2	Merge pull request #240 from Soulter/feat-better-persona feat: 更好的人格情景管理	2025-01-16 11:20:28 +08:00
Soulter	f1599e26b3	perf: webchat 主动信息	2025-01-16 11:19:02 +08:00
Soulter	ed64a4d32d	chore: 整理hint	2025-01-16 11:11:30 +08:00
Soulter	2ee4b431d4	fix: 无tool导致的报错 #239	2025-01-15 11:16:31 +08:00
Soulter	cd8a73ed19	feat: 更好的人格情景管理和管理面板支持删除列表默认模版项	2025-01-14 21:08:57 +08:00
Soulter	e6c985ce4e	feat: 优化WebChat长连接的逻辑	2025-01-13 12:42:32 +08:00
Soulter	a20446aeb9	🎉 chore: bump to v3.4.6	2025-01-13 02:17:23 +08:00
Soulter	7b23d76559	feat: 支持并完善服务提供商默认配置模板接口	2025-01-13 02:05:57 +08:00
Soulter	8315cf5818	perf: 面板文件更新检查和引导提示和AboutPage	2025-01-12 13:01:40 +08:00
Soulter	ed16265bde	fix: 更新官方文档链接并优化管理面板版本检查日志	2025-01-12 12:23:27 +08:00
Soulter	dff205faf6	feat: 添加聊天功能路由和更新管理面板命令	2025-01-12 12:18:19 +08:00
Soulter	9aae8aee0c	Update README.md	2025-01-12 11:45:39 +08:00
Soulter	7c818ced2b	perf: 文件和语音功能适配 Lagrange	2025-01-12 11:44:33 +08:00
Soulter	218e887558	fix: download_file 修复 SSL 连接错误处理	2025-01-12 11:44:33 +08:00
Soulter	a68860b35a	chore: compress the banner	2025-01-12 10:52:17 +08:00
Soulter	82d4d43383	🎉 Bump to v3.4.5	2025-01-11 23:35:22 +08:00