v3.4.16

fix: 修复webui无法从本地上传插件的问题
Update README.md
2025-02-01 19:31:59 +08:00 · 2025-02-01 19:31:29 +08:00 · 2025-02-01 16:19:01 +08:00 · 2025-02-01 14:36:41 +08:00 · 2025-02-01 14:29:39 +08:00 · 2025-02-01 12:11:58 +08:00
70 changed files with 1682 additions and 699 deletions
--- a/README.md
+++ b/README.md
@@ -1,14 +1,12 @@
-
 <p align="center">
+    
+![logo](https://github.com/user-attachments/assets/07649e07-3b8e-4feb-9aa9-bf13af4f3476)

-<img src="https://github.com/user-attachments/assets/de10f24d-cd64-433a-90b8-16c0a60de24a" width=500>

 </p>

 <div align="center">

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

 [![GitHub release (latest by date)](https://img.shields.io/github/v/release/Soulter/AstrBot)](https://github.com/Soulter/AstrBot/releases/latest)
@@ -16,9 +14,8 @@ _✨ 易上手的多平台 LLM 聊天机器人及开发框架 ✨_
 <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)
-[<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==)
-</a>

 <a href="https://astrbot.app/">查看文档</a> ｜
 <a href="https://github.com/Soulter/AstrBot/issues">问题提交</a>
@@ -38,7 +35,7 @@ AstrBot 是一个松耦合、异步、支持多消息平台部署、具有易用
 > [!TIP]
 > 管理面板在线体验 Demo: [https://demo.astrbot.app/](https://demo.astrbot.app/)
 > 
-> 用户名: `astrbot`, 密码: `astrbot`。此 Demo 未配置 LLM，因此无法在聊天页使用大模型。
+> 用户名: `astrbot`, 密码: `astrbot`。未配置 LLM，无法在聊天页使用大模型。（不要再修改 demo 的登录密码了 😭）

 ## ✨ 使用方式

@@ -67,19 +64,31 @@ AstrBot 是一个松耦合、异步、支持多消息平台部署、具有易用

 ## ⚡ 消息平台支持情况

-
 | 平台    | 支持性 | 详情 | 消息类型 |
 | -------- | ------- | ------- | ------ |
-| QQ      | ✔    | 私聊、群聊 | 文字、图片、语音 |
-| QQ 官方API | ✔    | 私聊、群聊，QQ 频道私聊、群聊 | 文字、图片 |
-| 微信    | ✔    | [Gewechat](https://github.com/Devo919/Gewechat)。微信个人号私聊、群聊 | 文字 |
+| QQ(官方机器人接口) | ✔    | 私聊、群聊，QQ 频道私聊、群聊 | 文字、图片 |
+| QQ(OneBot)      | ✔    | 私聊、群聊 | 文字、图片、语音 |
+| 微信(个人号)    | ✔    | 微信个人号私聊、群聊 | 文字、图片、语音 |
 | [Telegram](https://github.com/Soulter/astrbot_plugin_telegram)   | ✔    | 私聊、群聊 | 文字、图片 |
+| 微信(企业微信)    | 🚧    | 计划内 | - |
 | 微信对话开放平台 | 🚧    | 计划内 | - |
 | 飞书   | 🚧    | 计划内 | - |
 | Discord   | 🚧    | 计划内 | - |
 | WhatsApp   | 🚧    | 计划内 | - |
 | 小爱音响   | 🚧    | 计划内 | - |

+# 🦌 接下来的路线图
+
+> [!TIP]
+> 欢迎在 Issue 提出更多建议 <3
+
+- [ ] 完善并保证目前所有平台适配器的功能一致性
+- [ ] 优化插件接口
+- [ ] 默认支持更多 TTS 服务，如 GPT-Sovits
+- [ ] 完善“聊天增强”部分，支持持久化记忆
+- [ ] 规划 i18n
+
+
 ## ❤️ 贡献

 欢迎任何 Issues/Pull Requests！只需要将你的更改提交到此项目 ：)
@@ -126,6 +135,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 测试]

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

-_アトリは、高性能ですから!_
+
+_私は、高性能ですから!_

--- 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/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.9"
+VERSION = "3.4.16"
 DB_PATH = "data/data_v3.db"

 # 默认配置
@@ -24,6 +24,13 @@ DEFAULT_CONFIG = {
        "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": ".*?[。？！~…]+|.+$"
+        }
    },
    "provider": [],
    "provider_settings": {
@@ -39,6 +46,16 @@ DEFAULT_CONFIG = {
        "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_prompt": "Please describe the image using Chinese.",
+    },
    "content_safety": {
        "internal_keywords": {"enable": True, "extra_keywords": []},
        "baidu_aip": {"enable": False, "app_id": "", "api_key": "", "secret_key": ""},
@@ -177,6 +194,31 @@ CONFIG_METADATA_2 = {
                            },
                        },
                    },
+                    "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",
@@ -194,8 +236,8 @@ CONFIG_METADATA_2 = {
                    "id_whitelist": {
                        "description": "ID 白名单",
                        "type": "list",
-                        "items": {"type": "int"},
-                        "hint": "填写后，将只处理所填写的 ID 发来的消息事件。为空时表示不启用白名单过滤。可以使用 /myid 指令获取在某个平台上的会话 ID。也可在 AstrBot 日志内获取会话 ID，当一条消息没通过白名单时，会输出 INFO 级别的日志。会话 ID 类似 aiocqhttp:GroupMessage:547540978",
+                        "items": {"type": "string"},
+                        "hint": "AstrBot 只处理所填写的 ID 发来的消息事件。为空时不启用白名单过滤。可以使用 /myid 指令获取在某个平台上的会话 ID。也可在 AstrBot 日志内获取会话 ID，当一条消息没通过白名单时，会输出 INFO 级别的日志。会话 ID 类似 aiocqhttp:GroupMessage:547540978",
                    },
                    "id_whitelist_log": {
                        "description": "打印白名单日志",
@@ -220,6 +262,13 @@ CONFIG_METADATA_2 = {
                        "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": {
@@ -285,7 +334,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",
                        },
@@ -364,6 +413,14 @@ CONFIG_METADATA_2 = {
                        "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",
+                    },
                },
                "items": {
                    "whisper_hint": {
@@ -396,7 +453,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": "基座模型路径",
@@ -532,14 +590,14 @@ CONFIG_METADATA_2 = {
                    "begin_dialogs": {
                        "description": "预设对话",
                        "type": "list",
-                        "items": {},
+                        "items": {"type": "string"},
                        "hint": "可选。在每个对话前会插入这些预设对话。格式要求：第一句为用户，第二句为助手，以此类推。",
                        "obvious_hint": True,
                    },
                    "mood_imitation_dialogs": {
                        "description": "对话风格模仿",
                        "type": "list",
-                        "items": {},
+                        "items": {"type": "string"},
                        "hint": "旨在让模型尽可能模仿学习到所填写的对话的语气风格。格式和 `预设对话` 一样。",
                        "obvious_hint": True,
                    },
@@ -562,6 +620,51 @@ 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_prompt": {
+                        "description": "图像转述提示词",
+                        "type": "string"
+                    },
+                },
+            },
        },
    },
    "misc_config_group": {
@@ -571,7 +674,8 @@ CONFIG_METADATA_2 = {
                "description": "机器人唤醒前缀",
                "type": "list",
                "items": {"type": "string"},
-                "hint": "在不 @ 机器人的情况下，可以通过外加消息前缀来唤醒机器人。",
+                "obvious_hint": True,
+                "hint": "在不 @ 机器人的情况下，可以通过外加消息前缀来唤醒机器人。更改此配置将影响整个 Bot 的功能唤醒，包括所有指令。如果您不保留 `/`，则内置指令（help等）将需要通过您的唤醒前缀来触发。",
            },
            "t2i": {
                "description": "文本转图像",
@@ -581,7 +685,7 @@ CONFIG_METADATA_2 = {
            "admins_id": {
                "description": "管理员 ID",
                "type": "list",
-                "items": {"type": "int"},
+                "items": {"type": "string"},
                "hint": "管理员 ID 列表，管理员可以使用一些特权命令，如 `update`, `plugin` 等。ID 可以通过 `/myid` 指令获得。回车添加，可添加多个。",
            },
            "http_proxy": {
--- 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
@@ -81,12 +81,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/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/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,26 +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.url:
-                        
-                        path = component.url
-                        
-                        path.removeprefix("file:///")
-                        
+                        path = component.url.removeprefix("file://")
                        retry = 5
-                        
                        for i in range(retry):
                            try:
                                result = await stt_provider.get_text(audio_url=path)
@@ -48,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/llm_request.py
+++ b/astrbot/core/pipeline/process_stage/method/llm_request.py
@@ -51,7 +51,7 @@ class LLMRequestSubStage(Stage):
            session_provider_context = provider.session_memory.get(event.session_id)
            req.contexts = session_provider_context if session_provider_context else []
            
-        if not req.prompt:
+        if not req.prompt and not req.image_urls:
            return
            
        # 执行请求 LLM 前事件。
@@ -105,5 +105,5 @@ class LLMRequestSubStage(Stage):

        except BaseException as e:
            logger.error(traceback.format_exc())
-            event.set_result(MessageEventResult().message("AstrBot 请求 LLM 资源失败：" + str(e)))
+            event.set_result(MessageEventResult().message(f"AstrBot 请求失败。\n错误类型: {type(e).__name__}\n错误信息: {str(e)}"))
            return
--- 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/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,11 +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, At, Reply
+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

@@ -16,7 +18,12 @@ class ResultDecorateStage:
        self.reply_prefix = ctx.astrbot_config['platform_settings']['reply_prefix']
        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.t2i = ctx.astrbot_config['t2i']
+        self.use_tts = ctx.astrbot_config['provider_tts_settings']['enable']
+        
+        # 分段回复
+        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()
@@ -31,10 +38,53 @@ 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(r".*?[。？！~…]+|.+$", comp.text)
+                            if not split_response:
+                                new_chain.append(comp)
+                                continue
+                            for seg in split_response:
+                                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):
@@ -54,7 +104,7 @@ class ResultDecorateStage:
                        result.chain = [Image.fromURL(url)]
            
            if self.reply_with_mention and event.get_message_type() != MessageType.FRIEND_MESSAGE:
-                result.chain.insert(0, At(qq=event.get_sender_id()))
+                result.chain.insert(0, At(qq=event.get_sender_id(), name=event.get_sender_name()))
            
            if self.reply_with_quote:
                result.chain.insert(0, Reply(id=event.message_obj.message_id))
--- 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
@@ -179,6 +179,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]):
        '''设置消息事件的结果。
        
--- a/astrbot/core/platform/register.py
+++ b/astrbot/core/platform/register.py
@@ -27,6 +27,8 @@ def register_platform_adapter(
                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,
--- 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/gewechat/client.py
+++ b/astrbot/core/platform/sources/gewechat/client.py
@@ -2,10 +2,14 @@ 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
+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 的简单实现。
@@ -17,9 +21,15 @@ class SimpleGewechatClient():
        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)
            
@@ -27,15 +37,19 @@ class SimpleGewechatClient():
        self.headers = {}
        self.nickname = nickname
        self.appid = sp.get(f"gewechat-appid-{nickname}", "")
-        self.callback_url = None
        
        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/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:
@@ -52,56 +66,87 @@ class SimpleGewechatClient():
        if type_name == "Offline":
            logger.critical("收到 gewechat 下线通知。")
            return
+        
        abm = AstrBotMessage()
        d = data['Data']
-        msg_type = d['MsgType']
+    
+        from_user_name = d['FromUserName']['string'] # 消息来源
+        d['to_wxid'] = from_user_name # 用于发信息
        
-        match msg_type:
+        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
+        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:
-                from_user_name = d['FromUserName']['string'] # 消息来源
-                d['to_wxid'] = from_user_name # 用于发信息
-                
-                user_id = "" # 发送人 wxid
-                content = d['Content']['string'] # 消息内容
-                user_real_name = d['PushContent'].split(' : ')[0] # 真实昵称
-                user_real_name.replace('在群聊中@了你', '') # trick
-                abm.self_id = data['Wxid'] # 机器人的 wxid
-                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:
-                        at_me = True
-                    
-                else:
-                    abm.type = MessageType.FRIEND_MESSAGE
-                    user_id = from_user_name
-                abm.session_id = from_user_name
-                abm.sender = MessageMember(user_id, user_real_name)
-                abm.message = [Plain(content)]
-                
-                if at_me:
-                    abm.message.insert(0, At(qq=abm.self_id))
-                
-                abm.message_id = str(d['MsgId'])
-                abm.raw_message = d
+                # 文本消息
+                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))
                
-                logger.info(f"abm: {abm}")
-                return abm
            case _:
-                logger.error(f"未实现的消息类型: {msg_type}")
-                
+                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}")
@@ -109,40 +154,43 @@ class SimpleGewechatClient():
        if data.get('testMsg', None):
            return quart.jsonify({"r": "AstrBot ACK"})
        
-        abm = await self._convert(data)
-        
+        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)
-        callback_url = f"http://{self.host}:{self.port}/astrbot-gewechat/callback"
        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{self.base_url}/tools/setCallback",
                headers=self.headers,
                json={
                    "token": self.token,
-                    "callbackUrl": callback_url
+                    "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"将在 {callback_url} 上接收 gewechat 下发的消息。")
+                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=self.host, 
            port=self.port, 
@@ -166,10 +214,27 @@ class SimpleGewechatClient():
            ) 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)
@@ -228,8 +293,8 @@ class SimpleGewechatClient():
                        logger.warning(f"未知状态: {status}")
            await asyncio.sleep(5)
            
-        if not self.appid and appid:
-            sp.put(f"gewechat-appid-{nickname}", appid)
+        if appid:
+            sp.put(f"gewechat-appid-{self.nickname}", appid)
            self.appid = appid
            logger.info(f"已保存 APPID: {appid}")
    
@@ -247,4 +312,39 @@ class SimpleGewechatClient():
                json=payload
            ) as resp:
                json_blob = await resp.json()
-                logger.info(f"发送消息结果: {json_blob}")
+                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
@@ -1,12 +1,24 @@
-import random
-import asyncio
-from astrbot.core.utils.io import download_image_by_url
+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
+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, 
@@ -34,5 +46,57 @@ class GewechatPlatformEvent(AstrMessageEvent):
        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
@@ -68,6 +68,9 @@ class GewechatPlatformAdapter(Platform):
        
        return self._run()
    
+    async def logout(self):
+        await self.client.logout()
+    
    async def _run(self):
        await self.client.login()
        
--- 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_event.py
+++ b/astrbot/core/platform/sources/webchat/webchat_event.py
@@ -32,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)
+                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/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, Personality
+from .provider import Provider, STTProvider, TTSProvider, Personality
 from .entites import ProviderType
 from typing import List
 from astrbot.core.db import BaseDatabase
@@ -13,6 +14,7 @@ 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')
@@ -64,11 +66,15 @@ class ProviderManager():
        '''加载的 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
        
@@ -78,12 +84,16 @@ class ProviderManager():
        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:
@@ -103,25 +113,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:
@@ -138,6 +160,18 @@ 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:
                    # 文本生成任务
@@ -167,11 +201,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
@@ -24,9 +24,32 @@ class ProviderMeta():
    id: str
    model: str
    type: str
+    
+    
+class AbstractProvider(abc.ABC):
+    def __init__(self, provider_config: dict) -> None:
+        super().__init__()
+        self.model_name = ""
+        self.provider_config = provider_config
+
+    def set_model(self, model_name: str):
+        '''设置当前使用的模型名称'''
+        self.model_name = model_name
+    
+    def get_model(self) -> str:
+        '''获得当前使用的模型名称'''
+        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(abc.ABC):
+class Provider(AbstractProvider):
    def __init__(
        self, 
        provider_config: dict,
@@ -35,14 +58,11 @@ class Provider(abc.ABC):
        db_helper: BaseDatabase = None,
        default_persona: Personality = None
    ) -> None:
-        self.model_name = ""
-        '''当前使用的模型名称'''
+        super().__init__(provider_config)
        
        self.session_memory = defaultdict(list)
        '''维护了 session_id 的上下文，**不包含 system 指令**。'''
        
-        self.provider_config = provider_config
-        
        self.provider_settings = provider_settings
        
        self.curr_personality: Personality = default_persona
@@ -58,14 +78,6 @@ class Provider(abc.ABC):
                    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):
-        '''设置当前使用的模型名称'''
-        self.model_name = model_name
-    
-    def get_model(self) -> str:
-        '''获得当前使用的模型名称'''
-        return self.model_name
    
    @abc.abstractmethod
    def get_current_key(self) -> str:
@@ -133,17 +145,11 @@ class Provider(abc.ABC):
        '''重置某一个 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']
-        )
+
        
-        
-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
    
@@ -151,19 +157,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
@@ -28,6 +28,8 @@ def register_provider_adapter(
                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,
--- a/astrbot/core/provider/sources/gemini_source.py
+++ b/astrbot/core/provider/sources/gemini_source.py
@@ -18,7 +18,7 @@ class SimpleGoogleGenAIClient():
            self.api_base = api_base[:-1]
        else:
            self.api_base = api_base
-        self.client = aiohttp.ClientSession()
+        self.client = aiohttp.ClientSession(trust_env=True)
        
    async def models_list(self) -> List[str]:
        request_url = f"{self.api_base}/v1beta/models?key={self.api_key}"
@@ -224,15 +224,24 @@ class ProviderGoogleGenAI(Provider):

        try:
            llm_response = await self._query(payloads, func_tool)
+            await self.save_history(contexts, new_record, session_id, llm_response)
+            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
    
    async def save_history(self, contexts: List, new_record: dict, session_id: str, llm_response: LLMResponse):
        if llm_response.role == "assistant" and session_id:
--- a/astrbot/core/provider/sources/openai_source.py
+++ b/astrbot/core/provider/sources/openai_source.py
@@ -1,6 +1,6 @@
-import traceback
 import base64
 import json
+import re

 from openai import AsyncOpenAI, NOT_GIVEN
 from openai.types.chat.chat_completion import ChatCompletion
@@ -104,13 +104,23 @@ class ProviderOpenAIOfficial(Provider):
            if tool_list:
                payloads['tools'] = tool_list
        
-        completion = await self.client.chat.completions.create(
-            **payloads,
-            stream=False
-        )
+        try:
+            completion = await self.client.chat.completions.create(
+                **payloads,
+                stream=False
+            )
+        except BaseException as e:
+            if 'does not support Function Calling' \
+                or 'does not support tools' in e: # ollama 
+                    del payloads['tools']
+                    logger.debug(f"模型 {self.model_name} 不支持 tools，已自动移除")
+                    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 为空。")
@@ -119,6 +129,13 @@ class ProviderOpenAIOfficial(Provider):
        if choice.message.content:
            # text completion
            completion_text = str(choice.message.content).strip()
+            
+            # 适配 deepseek-r1 模型
+            if r'<think>' in completion_text:
+                completion_text = re.sub(r'<think>.*?</think>', '', completion_text, flags=re.DOTALL).strip()
+                # 可能有单标签情况
+                completion_text = completion_text.replace(r'<think>', '').replace(r'</think>', '').strip()
+            
            return LLMResponse("assistant", completion_text)
        elif choice.message.tool_calls:
            # tools call (function calling)
@@ -164,15 +181,26 @@ class ProviderOpenAIOfficial(Provider):

        try:
            llm_response = await self._query(payloads, func_tool)
+            if kwargs.get("persist", True):
+                await self.save_history(contexts, new_record, session_id, llm_response)
+            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)
+                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

-        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:
--- 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("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:
@@ -91,8 +63,9 @@ class ProviderOpenAIWhisperAPI(STTProvider):
            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:
@@ -93,7 +64,9 @@ class ProviderOpenAIWhisperSelfHost(STTProvider):
            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
@@ -60,15 +60,23 @@ class ProviderZhipu(ProviderOpenAIOfficial):
            "messages": context_query,
            **model_cfgs
        }
-        llm_response = None
        try:
            llm_response = await self._query(payloads, func_tool)
+            await self.save_history(contexts, new_record, session_id, llm_response)
+            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,7 +10,7 @@ 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
@@ -54,46 +54,19 @@ class Context:
        self.knowledge_db_manager = knowledge_db_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 +75,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 +107,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 +235,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/permission.py
+++ b/astrbot/core/star/filter/permission.py
@@ -20,6 +20,6 @@ class PermissionTypeFilter(HandlerFilter):
        if self.permission_type == PermissionType.ADMIN:
            if not event.is_admin():
                event.stop_event()
-                raise ValueError("您没有权限执行此操作。")
+                raise ValueError(f"您 (ID: {event.get_sender_id()}) 没有权限执行此操作。")

        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/star.py
+++ b/astrbot/core/star/star.py
@@ -3,6 +3,7 @@ from __future__ import annotations
 from types import ModuleType
 from typing import List, Dict
 from dataclasses import dataclass
+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,24 @@ 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
+    '''插件配置'''

    def __str__(self) -> str:
        return f"StarMetadata({self.name}, {self.desc}, {self.version}, {self.repo})"
--- a/astrbot/core/star/star_manager.py
+++ b/astrbot/core/star/star_manager.py
@@ -2,12 +2,14 @@ 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 astrbot.core.config.astrbot_config import AstrBotConfig
+from astrbot.core.config.default import DEFAULT_VALUE_MAP
 from astrbot.core import logger, sp, pip_installer
 from .context import Context
 from . import StarMetadata
@@ -26,13 +28,20 @@ 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 文件名'''

    def _get_classes(self, arg: ModuleType):
+        '''获取指定模块（可以理解为一个 python 文件）下所有的类'''
        classes = []
        clsmembers = inspect.getmembers(arg, inspect.isclass)
        for (name, _) in clsmembers:
@@ -128,7 +137,7 @@ 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__"):
@@ -150,13 +159,13 @@ class PluginManager:
        inactivated_plugins: list = sp.get("inactivated_plugins", [])
        inactivated_llm_tools: list = sp.get("inactivated_llm_tools", [])
        
-        # 导入 Star 模块，并尝试实例化 Star 类
+        # 导入插件模块，并尝试实例化插件类
        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/ 目录下的都是保留插件。保留插件不可以卸载。
                
                logger.info(f"正在载入插件 {root_dir_name} ...")
                
@@ -173,11 +182,33 @@ 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)
+                    
+                    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
@@ -199,16 +230,20 @@ 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.star_cls = obj
+                    metadata.config = plugin_config
                    metadata.module = module
                    metadata.root_dir_name = root_dir_name
                    metadata.reserved = reserved
@@ -221,7 +256,7 @@ class PluginManager:
                if metadata.module_path in inactivated_plugins:
                    metadata.activated = False
                    
-                # 执行 initialize 函数
+                # 执行 initialize() 方法
                if hasattr(metadata.star_cls, "initialize"):
                    await metadata.star_cls.initialize()
                    
@@ -292,13 +327,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)
@@ -323,8 +359,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
@@ -332,6 +369,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/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:
@@ -91,7 +93,7 @@ async def download_image_by_url(url: str, post: bool = False, post_data: dict =
        # 关闭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())
@@ -106,8 +108,8 @@ 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=300) as resp:
+        async with aiohttp.ClientSession(trust_env=True) as session:
+            async with session.get(url, timeout=120) as resp:
                if resp.status != 200:
                    raise Exception(f"下载文件失败: {resp.status}")
                total_size = int(resp.headers.get('content-length', 0))
@@ -130,8 +132,8 @@ async def download_file(url: str, path: str, show_progress: bool = False):
        # 关闭SSL验证
        ssl_context = ssl.create_default_context()
        ssl_context.set_ciphers('DEFAULT')
-        async with aiohttp.ClientSession(trust_env=False) as session:
-            async with session.get(url, ssl=ssl_context, timeout=300) as resp:
+        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()
@@ -170,6 +172,14 @@ 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.soulter.top/download/astrbot-dashboard/latest/dist.zip"
--- 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/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
@@ -33,7 +33,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/config.py
+++ b/astrbot/dashboard/routes/config.py
@@ -1,14 +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():
@@ -19,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
@@ -56,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)
@@ -92,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
@@ -110,14 +106,15 @@ 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__
            
@@ -141,28 +138,48 @@ class ConfigRoute(Route):
            "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
@@ -27,7 +27,7 @@ class PluginRoute(Route):
    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 aiohttp.ClientSession(trust_env=True) as session:
                async with session.get(url) as response:
                    result = await response.json()
            return Response().ok(result).__dict__
@@ -67,9 +67,9 @@ 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)
            logger.info(f"安装插件 {file.filename} 成功")
            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/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)
--- 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/dashboard/src/components/shared/ConfigDetailCard.vue
+++ b/dashboard/src/components/shared/ConfigDetailCard.vue
@@ -1,41 +0,0 @@
-<script setup>
-import UiParentCard from '@/components/shared/UiParentCard.vue';
-
-const props = defineProps({
-  config: Array
-});
-</script>
-
-<template>
-  <a v-show="config.length === 0">该插件没有配置</a>
-  <UiParentCard v-for="group in config" :key="group.name" :title="group.name" style="margin-bottom: 16px;">
-    <template v-for="item in group.body">
-      <template v-if="item.config_type === 'item'">
-        <template v-if="item.val_type === 'bool'">
-          <v-switch v-model="item.value" :label="item.name" :hint="item.description" color="primary" inset></v-switch>
-        </template>
-        <template v-else-if="item.val_type === 'str'">
-          <v-text-field v-model="item.value" :label="item.name" :hint="item.description" style="margin-bottom: 8px;"
-            variant="outlined"></v-text-field>
-        </template>
-        <template v-else-if="item.val_type === 'int'">
-          <v-text-field v-model="item.value" :label="item.name" :hint="item.description" style="margin-bottom: 8px;"
-            variant="outlined"></v-text-field>
-        </template>
-        <template v-else-if="item.val_type === 'list'">
-          <span>{{ item.name }}</span>
-          <v-combobox v-model="item.value" chips clearable label="请添加" multiple prepend-icon="mdi-tag-multiple-outline">
-            <template v-slot:selection="{ attrs, item, select, selected }">
-              <v-chip v-bind="attrs" :model-value="selected" closable @click="select" @click:close="remove(item)">
-                <strong>{{ item }}</strong>
-              </v-chip>
-            </template>
-          </v-combobox>
-        </template>
-      </template>
-      <template v-else-if="item.config_type === 'divider'">
-        <v-divider style="margin-top: 8px; margin-bottom: 8px;"></v-divider>
-      </template>
-    </template>
-  </UiParentCard>
-</template>
--- a/dashboard/src/layouts/full/vertical-header/VerticalHeader.vue
+++ b/dashboard/src/layouts/full/vertical-header/VerticalHeader.vue
@@ -15,6 +15,9 @@ let newUsername = ref('');
 let status = ref('');
 let updateStatus = ref('')
 let hasNewVersion = ref(false);
+let botCurrVersion = ref('');
+let dashboardHasNewVersion = ref(false);
+let dashboardCurrentVersion = ref('');
 let version = ref('');

 const open = (link: string) => {
@@ -64,6 +67,9 @@ function checkUpdate() {
    .then((res) => {
      hasNewVersion.value = res.data.data.has_new_version;
      updateStatus.value = res.data.message;
+      botCurrVersion.value = res.data.data.version;
+      dashboardCurrentVersion.value = res.data.data.dashboard_version;
+      dashboardHasNewVersion.value = res.data.data.dashboard_has_new_version;
    })
    .catch((err) => {
      if (err.response.status == 401) {
@@ -84,7 +90,24 @@ function switchVersion(version: string) {
  })
    .then((res) => {
      updateStatus.value = res.data.message;
-      if (res.data.status == 'success') {
+      if (res.data.status == 'ok') {
+        setTimeout(() => {
+          window.location.reload();
+        }, 1000);
+      }
+    })
+    .catch((err) => {
+      console.log(err);
+      updateStatus.value = err
+    });
+}
+
+function updateDashboard() {
+  updateStatus.value = '正在更新...';
+  axios.post('/api/update/dashboard')
+    .then((res) => {
+      updateStatus.value = res.data.message;
+      if (res.data.status == 'ok') {
        setTimeout(() => {
          window.location.reload();
        }, 1000);
@@ -106,8 +129,8 @@ commonStore.getStartTime();
 <template>
  <v-app-bar elevation="0" height="70">

-    <v-btn style="margin-left: 22px;" class="hidden-md-and-down text-secondary" color="lightsecondary" icon rounded="sm" variant="flat"
-      @click.stop="customizer.SET_MINI_SIDEBAR(!customizer.mini_sidebar)" size="small">
+    <v-btn style="margin-left: 22px;" class="hidden-md-and-down text-secondary" color="lightsecondary" icon rounded="sm"
+      variant="flat" @click.stop="customizer.SET_MINI_SIDEBAR(!customizer.mini_sidebar)" size="small">
      <v-icon>mdi-menu</v-icon>
    </v-btn>
    <v-btn class="hidden-lg-and-up text-secondary ms-3" color="lightsecondary" icon rounded="sm" variant="flat"
@@ -136,11 +159,16 @@ commonStore.getStartTime();
      </template>
      <v-card>
        <v-card-title>
-          <span class="text-h5">更新项目</span>
+          <span class="text-h5">更新 AstrBot</span>
        </v-card-title>
        <v-card-text>
          <v-container>
-            <h3 class="mb-4">升级到最新版本</h3>
+            <h3 class="mb-4">升级到项目最新版本</h3>
+            <small>当前版本 {{ botCurrVersion }}</small>
+            <div class="mb-4">
+              <small>会同时尝试更新机器人主程序和管理面板。如果您正在使用 Docker 部署，也可以重新拉取镜像或者使用 <a
+                  href="https://containrrr.dev/watchtower/usage-overview/">watchtower</a> 来自动监控拉取。</small>
+            </div>
            <p>{{ updateStatus }}</p>
            <v-btn class="mt-4 mb-4" @click="switchVersion('latest')" color="primary" style="border-radius: 10px;"
              :disabled="!hasNewVersion">
@@ -148,7 +176,11 @@ commonStore.getStartTime();
            </v-btn>
            <v-divider></v-divider>
            <div style="margin-top: 16px;">
-              <h3 class="mb-4">切换到指定版本或指定提交</h3>
+              <h3 class="mb-4">切换到项目指定版本或指定提交</h3>
+              <div class="mb-4">
+                <small>跳到旧版本不会重新下载管理面板文件，这可能会造成部分数据显示错误。您可在 <a href="https://github.com/Soulter/AstrBot/releases">此处</a>
+                  找到对应的面板文件 dist.zip，解压后替换 data/dist 文件夹即可。</small>
+              </div>
              <v-text-field label="输入版本号或 master 分支下的 commit hash。" v-model="version" required
                variant="outlined"></v-text-field>
              <div class="mb-4">
@@ -160,7 +192,29 @@ commonStore.getStartTime();
              <v-btn color="error" style="border-radius: 10px;" @click="switchVersion(version)">
                确定切换
              </v-btn>
+            </div>

+            <v-divider></v-divider>
+            <div style="margin-top: 16px;">
+              <h3 class="mb-4">更新管理面板到最新版本</h3>
+              <div class="mb-4">
+                <small>当前版本 {{ dashboardCurrentVersion }}</small>
+                <br>
+
+              </div>
+
+              <div class="mb-4">
+                <p v-if="dashboardHasNewVersion">
+                  有新版本！
+                </p>
+                <p v-else="dashboardHasNewVersion">
+                  已经是最新版本了。
+                </p>
+              </div>
+
+              <v-btn color="primary" style="border-radius: 10px;" @click="updateDashboard()">
+                下载并更新
+              </v-btn>
            </div>
          </v-container>
        </v-card-text>
@@ -190,8 +244,7 @@ commonStore.getStartTime();
                <v-text-field label="原密码*" type="password" v-model="password" required
                  variant="outlined"></v-text-field>

-                <v-text-field label="新用户名" v-model="newUsername" required
-                  variant="outlined"></v-text-field>
+                <v-text-field label="新用户名" v-model="newUsername" required variant="outlined"></v-text-field>

                <v-text-field label="新密码" type="password" v-model="newPassword" required
                  variant="outlined"></v-text-field>
--- a/dashboard/src/layouts/full/vertical-sidebar/VerticalSidebar.vue
+++ b/dashboard/src/layouts/full/vertical-sidebar/VerticalSidebar.vue
@@ -27,10 +27,10 @@ const sidebarMenu = shallowRef(sidebarItems);
        </v-btn>
      </v-list-item>
      <small style="display: block;" v-if="buildVer">构建: {{ buildVer }}</small>
-      <small style="display: block;" v-else="buildVer">构建: embedded</small>
+      <small style="display: block;" v-else>构建: embedded</small>
      <v-tooltip text="使用 /dashbord_update 指令更新管理面板">
        <template v-slot:activator="{ props }">
-          <small v-bind="props" v-if="buildVer != version" style="display: block; margin-top: 4px;">面板有更新</small>
+          <small v-bind="props" v-if="hasWebUIUpdate" style="display: block; margin-top: 4px;">面板有更新</small>
        </template>
      </v-tooltip>

@@ -50,19 +50,12 @@ export default {
  },
  data: () => ({
    version: "",
-    buildVer: ""
+    buildVer: "",
+    hasWebUIUpdate: false,
  }),
  mounted() {
    this.get_version()
-    fetch('/assets/version').then((res) => {
-      return res.text()
-    }).then((res) => {
-      if (res.length > 10) {
-        // 不是版本，不显示 😎
-        return
-      }
-      this.buildVer = res.replace(/\s+/g, '')
-    })
+    this.check_webui_update()
  },
  methods: {
    get_version() {
@@ -73,6 +66,16 @@ export default {
        .catch((err) => {
          console.log(err);
        });
+    },
+    check_webui_update() {
+      axios.get('/api/update/check?type=dashboard')
+        .then((res) => {
+          this.hasWebUIUpdate = res.data.data.has_new_version;
+          this.buildVer = res.data.data.current_version;
+        })
+        .catch((err) => {
+          console.log(err);
+        });
    }
  },
 };
--- a/dashboard/src/views/ExtensionPage.vue
+++ b/dashboard/src/views/ExtensionPage.vue
@@ -1,7 +1,7 @@
 <script setup>
 import ExtensionCard from '@/components/shared/ExtensionCard.vue';
-import ConfigDetailCard from '@/components/shared/ConfigDetailCard.vue';
 import WaitingForRestart from '@/components/shared/WaitingForRestart.vue';
+import AstrBotConfig from '@/components/shared/AstrBotConfig.vue';
 import ConsoleDisplayer from '@/components/shared/ConsoleDisplayer.vue';
 import axios from 'axios';

@@ -52,11 +52,17 @@ import axios from 'axios';
          <v-btn v-else variant="plain" disabled>已安装</v-btn>
        </div>
      </ExtensionCard>
+      
+    </v-col>
+
+    <v-col style="margin-bottom: 16px;" cols="12" md="12">
+      <small ><a href="https://astrbot.app/dev/plugin.html">插件开发文档</a></small> |
+      <small> <a href="https://github.com/Soulter/AstrBot_Plugins_Collection">提交插件仓库</a></small>
    </v-col>

  </v-row>

-  <v-dialog v-model="configDialog" width="750">
+  <v-dialog v-model="configDialog" width="1000">
    <template v-slot:activator="{ props }">
    </template>
    <v-card>
@@ -65,7 +71,8 @@ import axios from 'axios';
      </v-card-title>
      <v-card-text>
        <v-container>
-          <ConfigDetailCard :config="extension_config"></ConfigDetailCard>
+          <AstrBotConfig v-if="extension_config.metadata" :metadata="extension_config.metadata" :iterable="extension_config.config" :metadataKey=curr_namespace></AstrBotConfig>
+          <p v-else>这个插件没有配置</p>
        </v-container>
      </v-card-text>
      <v-card-actions>
@@ -172,9 +179,9 @@ export default {
  name: 'ExtensionPage',
  components: {
    ExtensionCard,
-    ConfigDetailCard,
    WaitingForRestart,
-    ConsoleDisplayer
+    ConsoleDisplayer,
+    AstrBotConfig
  },
  data() {
    return {
@@ -189,7 +196,10 @@ export default {
      snack_success: "success",
      loading_: false,
      configDialog: false,
-      extension_config: {},
+      extension_config: {
+        "metadata": {},
+        "config": {}
+      },
      upload_file: null,
      pluginMarketData: {},
      loadingDialog: {
@@ -364,7 +374,7 @@ export default {
    openExtensionConfig(extension_name) {
      this.curr_namespace = extension_name;
      this.configDialog = true;
-      axios.get('/api/config/get?namespace=' + extension_name).then((res) => {
+      axios.get('/api/config/get?plugin_name=' + extension_name).then((res) => {
        this.extension_config = res.data.data;
        console.log(this.extension_config);
      }).catch((err) => {
@@ -372,10 +382,7 @@ export default {
      });
    },
    updateConfig() {
-      axios.post('/api/config/plugin/update', {
-        "config": this.extension_config,
-        "namespace": this.curr_namespace
-      }).then((res) => {
+      axios.post('/api/config/plugin/update?plugin_name='+this.curr_namespace, this.extension_config.config).then((res) => {
        if (res.data.status === "ok") {
          this.toast(res.data.message, "success");
          this.$refs.wfr.check();
--- a/dashboard/src/views/dashboards/default/DefaultDashboard.vue
+++ b/dashboard/src/views/dashboards/default/DefaultDashboard.vue
@@ -1,4 +1,13 @@
 <template>
+  <v-row style="margin: 2px;">
+    <v-alert
+      :type="noticeType"
+      :text="noticeContent"
+      :title="noticeTitle"
+      v-if="noticeTitle && noticeContent"
+      closable
+    ></v-alert>
+  </v-row>
  <v-row>
    <v-col cols="12" md="4">
      <TotalMessage :stat="stat" />
@@ -38,13 +47,26 @@ export default {
  },
  data: () => ({
    stat: {},
+    noticeTitle: '',
+    noticeContent: '',
+    noticeType: '',
  }),

  mounted() {
    axios.get('/api/stat/get').then((res) => {
      this.stat = res.data.data;
    });
-  }
+
+    axios.get('https://api.soulter.top/astrbot-announcement').then((res) => {
+      let data = res.data.data;
+      // 如果 dashboard-notice 在其中
+      if (data['dashboard-notice']) {
+        this.noticeTitle = data['dashboard-notice'].title;
+        this.noticeContent = data['dashboard-notice'].content;
+        this.noticeType = data['dashboard-notice'].type;
+      }
+    });
+  },
 };

 </script>
--- a/main.py
+++ b/main.py
@@ -6,7 +6,7 @@ from astrbot.dashboard import AstrBotDashBoardLifecycle
 from astrbot.core import db_helper
 from astrbot.core import logger, LogManager, LogBroker
 from astrbot.core.config.default import VERSION
-from astrbot.core.utils.io import download_dashboard
+from astrbot.core.utils.io import download_dashboard, get_dashboard_version

 # add parent path to sys.path
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
@@ -37,14 +37,14 @@ def check_env():
    
 async def check_dashboard_files():
    '''下载管理面板文件'''
-    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()
-                if v != f"v{VERSION}":
-                    logger.warning("检测到管理面板有更新。可以使用 /dashboard_update 命令更新。")
-                else:
-                    logger.info("管理面板文件已是最新。")
+
+    v = await get_dashboard_version()
+    if v is not None:
+        # has file
+        if v == f"v{VERSION}":
+            logger.info("管理面板文件已是最新。")
+        else:
+            logger.warning("检测到管理面板有更新。可以使用 /dashboard_update 命令更新。")
        return
    
    logger.info("开始下载管理面板文件...高峰期（晚上）可能导致较慢的速度。如多次下载失败，请前往 https://github.com/Soulter/AstrBot/releases/latest 下载 dist.zip，并将其中的 dist 文件夹解压至 data 目录下。")
--- a/packages/astrbot/long_term_memory.py
+++ b/packages/astrbot/long_term_memory.py
@@ -0,0 +1,88 @@
+import datetime
+import uuid
+import astrbot.api.star as star
+from astrbot.api.event import AstrMessageEvent
+from astrbot.api.platform import MessageType
+from astrbot.api.provider import ProviderRequest
+from astrbot.api.message_components import Plain, Image
+from astrbot import logger
+from collections import defaultdict
+
+
+class LongTermMemory:
+    def __init__(self, config: dict, context: star.Context):
+        self.config = config
+        self.context = context
+        self.session_chats = defaultdict(list)
+        """记录群成员的群聊记录"""
+        try:
+            self.max_cnt = int(self.config["group_message_max_cnt"])
+        except BaseException as e:
+            logger.error(e)
+            self.max_cnt = 300
+        self.image_caption = self.config["image_caption"]
+        self.image_caption_prompt = self.config["image_caption_prompt"]
+        
+    async def remove_session(self, event: AstrMessageEvent) -> int:
+        cnt = 0
+        if event.unified_msg_origin in self.session_chats:
+            cnt = len(self.session_chats[event.unified_msg_origin])
+            del self.session_chats[event.unified_msg_origin]
+        return cnt
+
+    async def get_image_caption(self, image_url: str) -> str:
+        provider = self.context.get_using_provider()
+        response = await provider.text_chat(
+            prompt=self.image_caption_prompt,
+            session_id=uuid.uuid4().hex,
+            image_urls=[image_url],
+            persist=False,
+        )
+        return response.completion_text
+
+    async def handle_message(self, event: AstrMessageEvent):
+        if event.get_message_type() == MessageType.GROUP_MESSAGE:
+            datetime_str = datetime.datetime.now().strftime("%H:%M:%S")
+
+            final_message = f"[{event.message_obj.sender.nickname}/{datetime_str}]: "
+
+            for comp in event.get_messages():
+                if isinstance(comp, Plain):
+                    final_message += f" {comp.text}"
+                elif isinstance(comp, Image):
+                    # image_urls.append(comp.url if comp.url else comp.file)
+                    if self.image_caption:
+                        try:
+                            caption = await self.get_image_caption(
+                                comp.url if comp.url else comp.file
+                            )
+                            final_message += f" [Image: {caption}]"
+                        except Exception as e:
+                            logger.error(f"获取图片描述失败: {e}")
+            logger.debug(f"ltm | {event.unified_msg_origin} | {final_message}")
+            self.session_chats[event.unified_msg_origin].append(final_message)
+            if len(self.session_chats[event.unified_msg_origin]) > self.max_cnt:
+                self.session_chats[event.unified_msg_origin].pop(0)
+
+    async def on_req_llm(self, event: AstrMessageEvent, req: ProviderRequest):
+        if event.unified_msg_origin not in self.session_chats:
+            return
+        
+        chats_str = '\n---\n'.join(self.session_chats[event.unified_msg_origin])
+        req.system_prompt += "You are now in a chatroom. The chat history is as follows: \n"
+        req.system_prompt += chats_str
+        if self.image_caption:
+            req.system_prompt += (
+                "The images sent by the members are displayed in text form above."
+            )
+
+    async def after_req_llm(self, event: AstrMessageEvent):
+        if event.unified_msg_origin not in self.session_chats:
+            return
+
+        if event.get_result() and event.get_result().is_llm_result():
+            final_message = f"[AstrBot/{datetime.datetime.now().strftime('%H:%M:%S')}]: {event.get_result().get_plain_text()}"
+            logger.debug(f"ltm | {event.unified_msg_origin} | {final_message}")
+            self.session_chats[event.unified_msg_origin].append(final_message)
+            if len(self.session_chats[event.unified_msg_origin]) > self.max_cnt:
+                self.session_chats[event.unified_msg_origin].pop(0)
--- a/packages/astrbot/main.py
+++ b/packages/astrbot/main.py
@@ -6,11 +6,16 @@ import astrbot.api.event.filter as filter
 from astrbot.api.event import AstrMessageEvent, MessageEventResult
 from astrbot.api import sp
 from astrbot.api.provider import Personality, ProviderRequest
-from astrbot.core.utils.io import download_dashboard
+from astrbot.api.platform import MessageType
+from astrbot.core.utils.io import download_dashboard, get_dashboard_version
+from astrbot.core.config.default import VERSION
+from collections import defaultdict
+from .long_term_memory import LongTermMemory
+from astrbot.core import logger

 from typing import Union

-@star.register(name="astrbot", desc="AstrBot 基础指令集合", author="Soulter", version="4.0.0")
+@star.register(name="astrbot", desc="AstrBot 基础指令结合 + 拓展功能", author="Soulter", version="4.0.0")
 class Main(star.Star):
    def __init__(self, context: star.Context) -> None:
        self.context = context
@@ -19,11 +24,16 @@ class Main(star.Star):
        self.identifier = cfg['provider_settings']['identifier']
        self.enable_datetime = cfg['provider_settings']["datetime_system_prompt"]
        
-        self.kdb_enabled = False
+        self.ltm = None
+        if self.context.get_config()['provider_ltm_settings']['group_icl_enable']:
+            try:
+                self.ltm = LongTermMemory(self.context.get_config()['provider_ltm_settings'], self.context)
+            except BaseException as e:
+                logger.error(f"聊天增强 err: {e}")
    
    async def _query_astrbot_notice(self):
        try:
-            async with aiohttp.ClientSession() as session:
+            async with aiohttp.ClientSession(trust_env=True) as session:
                async with session.get("https://astrbot.soulter.top/notice.json", timeout=2) as resp:
                    return (await resp.json())["notice"]
        except BaseException:
@@ -36,9 +46,12 @@ class Main(star.Star):
            notice = await self._query_astrbot_notice()
        except BaseException:
            pass
+        
+        dashboard_version = await get_dashboard_version()

-        msg = "已注册的 AstrBot 内置指令:\n"
-        msg += f"""[System]
+        msg = f"""AstrBot v{VERSION}(WebUI: {dashboard_version})
+已注册的 AstrBot 内置指令:
+[System]
 /plugin: 查看注册的插件、插件帮助
 /t2i: 开启/关闭文本转图片模式
 /sid: 获取当前会话的 ID
@@ -215,7 +228,12 @@ UID: {user_id} 此 ID 可用于设置管理员。/op <UID> 授权管理员, /deo
    @filter.command("reset")
    async def reset(self, message: AstrMessageEvent):
        await self.context.get_using_provider().forget(message.session_id)
-        message.set_result(MessageEventResult().message("重置成功"))
+        ret = "清除会话 LLM 聊天历史成功。"
+        if self.ltm:
+            cnt = await self.ltm.remove_session(event=message)
+            ret += f"\n聊天增强: 已清除 {cnt} 条聊天记录。"
+        
+        message.set_result(MessageEventResult().message(ret))

    @filter.command("model")
    async def model_ls(self, message: AstrMessageEvent, idx_or_name: Union[int, str] = None):
@@ -351,9 +369,9 @@ UID: {user_id} 此 ID 可用于设置管理员。/op <UID> 授权管理员, /deo
                self.context.provider_manager.personas
            ), None):
                self.context.get_using_provider().curr_personality = persona
-                message.set_result(MessageEventResult().message(f"设置成功。如果您正在切换到不同的人格，请注意使用 /reset 来清空上下文，防止原人格对话影响现人格。"))
+                message.set_result(MessageEventResult().message("设置成功。如果您正在切换到不同的人格，请注意使用 /reset 来清空上下文，防止原人格对话影响现人格。"))
            else:
-                message.set_result(MessageEventResult().message(f"不存在该人格情景。使用 /persona list 查看所有。"))
+                message.set_result(MessageEventResult().message("不存在该人格情景。使用 /persona list 查看所有。"))
    
    @filter.permission_type(filter.PermissionType.ADMIN)
    @filter.command("dashboard_update")
@@ -362,31 +380,6 @@ UID: {user_id} 此 ID 可用于设置管理员。/op <UID> 授权管理员, /deo
        await download_dashboard()
        yield event.plain_result("管理面板更新完成。")

-    @filter.on_llm_request()
-    async def decorate_llm_req(self, event: AstrMessageEvent, req: ProviderRequest):
-        provider = self.context.get_using_provider()
-        if self.prompt_prefix:
-            req.prompt = self.prompt_prefix + req.prompt
-        if self.identifier:
-            user_id = event.message_obj.sender.user_id
-            user_nickname = event.message_obj.sender.nickname
-            user_info = f"\n[User ID: {user_id}, Nickname: {user_nickname}]\n"
-            req.prompt = user_info + req.prompt
-        if self.enable_datetime:
-            req.system_prompt += f"\nCurrent datetime: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
-        
-        if persona := provider.curr_personality:
-            if prompt := persona['prompt']:
-                req.system_prompt += prompt
-            if mood_dialogs := persona['_mood_imitation_dialogs_processed']:
-                req.system_prompt += "\nHere are few shots of dialogs, you need to imitate the tone of 'B' in the following dialogs to respond:\n"
-                req.system_prompt += mood_dialogs
-            if begin_dialogs := persona["_begin_dialogs_processed"]:
-                req.contexts[:0] = begin_dialogs
-
-        # if provider.curr_personality['prompt']:
-        #     req.system_prompt += f"\n{provider.curr_personality['prompt']}"
-        
    @filter.command("set")
    async def set_variable(self, event: AstrMessageEvent, key: str, value: str):
        session_id = event.get_session_id()
@@ -414,32 +407,94 @@ UID: {user_id} 此 ID 可用于设置管理员。/op <UID> 授权管理员, /deo
            del session_var[key]
            sp.put("session_variables", session_vars)
            yield event.plain_result(f"会话 {session_id} 变量 {key} 移除成功。")
-                
-    @filter.command_group("kdb")
-    def kdb(self):
-        pass
-        
-    @kdb.command("on")
-    async def on_kdb(self, event: AstrMessageEvent):
-        self.kdb_enabled = True
-        curr_kdb_name = self.context.provider_manager.curr_kdb_name
-        if not curr_kdb_name:
-            yield event.plain_result("未载入任何知识库")
-        else:
-            yield event.plain_result(f"知识库已打开。当前载入的知识库: {curr_kdb_name}")
-        
-    @kdb.command("off")
-    async def off_kdb(self, event: AstrMessageEvent):
-        self.kdb_enabled = False
-        yield event.plain_result("知识库已关闭")
-        
+            
+    @filter.command("gewe_logout")
+    async def gewe_logout(self, event: AstrMessageEvent):
+        platforms = self.context.platform_manager.platform_insts
+        for platform in platforms:
+            if platform.meta().name == "gewechat":
+                yield event.plain_result("正在登出 gewechat")
+                await platform.logout()
+                yield event.plain_result("已登出 gewechat")
+                return
+            
+            
+    @filter.platform_adapter_type(filter.PlatformAdapterType.ALL)
+    async def on_message(self, event: AstrMessageEvent):
+        '''长期记忆'''
+        if self.ltm:
+            try:
+                await self.ltm.handle_message(event)
+            except BaseException as e:
+                logger.error(e)
+    
+    
    @filter.on_llm_request()
-    async def on_llm_response(self, event: AstrMessageEvent, req: ProviderRequest):
-        curr_kdb_name = self.context.provider_manager.curr_kdb_name
-        if self.kdb_enabled and curr_kdb_name:
-            mgr = self.context.knowledge_db_manager
-            results = await mgr.retrive_records(curr_kdb_name, req.prompt)
-            if results:
-                req.system_prompt += "\nHere are documents that related to user's query: \n"
-                for result in results:
-                    req.system_prompt += f"- {result}\n"
+    async def decorate_llm_req(self, event: AstrMessageEvent, req: ProviderRequest):
+        '''在请求 LLM 前注入人格信息、Identifier、时间等 System Prompt'''
+        provider = self.context.get_using_provider()
+        if self.prompt_prefix:
+            req.prompt = self.prompt_prefix + req.prompt
+            
+        if self.identifier:
+            user_id = event.message_obj.sender.user_id
+            user_nickname = event.message_obj.sender.nickname
+            user_info = f"\n[User ID: {user_id}, Nickname: {user_nickname}]\n"
+            req.prompt = user_info + req.prompt
+            
+        if self.enable_datetime:
+            req.system_prompt += f"\nCurrent datetime: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
+        
+        if persona := provider.curr_personality:
+            if prompt := persona['prompt']:
+                req.system_prompt += prompt
+            if mood_dialogs := persona['_mood_imitation_dialogs_processed']:
+                req.system_prompt += "\nHere are few shots of dialogs, you need to imitate the tone of 'B' in the following dialogs to respond:\n"
+                req.system_prompt += mood_dialogs
+            if begin_dialogs := persona["_begin_dialogs_processed"]:
+                req.contexts[:0] = begin_dialogs
+                
+        if self.ltm:
+            try:
+                await self.ltm.on_req_llm(event, req)
+            except BaseException as e:
+                logger.error(f"ltm: {e}")
+
+    
+    @filter.after_message_sent()
+    async def after_llm_req(self, event: AstrMessageEvent):
+        '''在 LLM 请求后记录对话'''
+        if self.ltm:
+            try:
+                await self.ltm.after_req_llm(event)
+            except BaseException as e:
+                logger.error(f"ltm: {e}")
+
+    # @filter.command_group("kdb")
+    # def kdb(self):
+    #     pass
+        
+    # @kdb.command("on")
+    # async def on_kdb(self, event: AstrMessageEvent):
+    #     self.kdb_enabled = True
+    #     curr_kdb_name = self.context.provider_manager.curr_kdb_name
+    #     if not curr_kdb_name:
+    #         yield event.plain_result("未载入任何知识库")
+    #     else:
+    #         yield event.plain_result(f"知识库已打开。当前载入的知识库: {curr_kdb_name}")
+        
+    # @kdb.command("off")
+    # async def off_kdb(self, event: AstrMessageEvent):
+    #     self.kdb_enabled = False
+    #     yield event.plain_result("知识库已关闭")
+        
+    # @filter.on_llm_request()
+    # async def on_llm_response(self, event: AstrMessageEvent, req: ProviderRequest):
+    #     curr_kdb_name = self.context.provider_manager.curr_kdb_name
+    #     if self.kdb_enabled and curr_kdb_name:
+    #         mgr = self.context.knowledge_db_manager
+    #         results = await mgr.retrive_records(curr_kdb_name, req.prompt)
+    #         if results:
+    #             req.system_prompt += "\nHere are documents that related to user's query: \n"
+    #             for result in results:
+    #                 req.system_prompt += f"- {result}\n"
--- a/packages/python_interpreter/main.py
+++ b/packages/python_interpreter/main.py
@@ -127,7 +127,7 @@ class Main(star.Star):
        
        s3_file_url = f"{S3_URL}/{uuid.uuid4().hex}{ext}"

-        async with aiohttp.ClientSession(headers = {"Accept": "application/json"}) as session:
+        async with aiohttp.ClientSession(headers = {"Accept": "application/json"}, trust_env=True) as session:
            async with session.put(s3_file_url, data=file) as resp:
                if resp.status != 200:
                    raise Exception(f"Failed to upload image: {resp.status}")
@@ -159,7 +159,7 @@ class Main(star.Star):
    
    async def download_image(self, image_url: str, workplace_path: str, filename: str) -> str:
        '''Download image from url to workplace_path'''
-        async with aiohttp.ClientSession() as session:
+        async with aiohttp.ClientSession(trust_env=True) as session:
            async with session.get(image_url) as resp:
                if resp.status != 200:
                    return ""
--- a/packages/web_searcher/main.py
+++ b/packages/web_searcher/main.py
@@ -39,7 +39,7 @@ class Main(star.Star):
        '''获取网页内容'''
        header = HEADERS
        header.update({'User-Agent': random.choice(USER_AGENTS)})
-        async with aiohttp.ClientSession() as session:
+        async with aiohttp.ClientSession(trust_env=True) as session:
            async with session.get(url, headers=header, timeout=6) as response:
                html = await response.text(encoding="utf-8")
                doc = Document(html)
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,5 +1,4 @@
 pydantic~=2.10.3
-vchat
 aiohttp
 openai
 qq-botpy
--- a/stt.py
+++ b/stt.py
@@ -1,33 +0,0 @@
-import torch
-from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor, pipeline
-from datasets import load_dataset
-
-
-device = "cuda:0" if torch.cuda.is_available() else "cpu"
-torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32
-
-model_id = "openai/whisper-large-v3"
-
-model = AutoModelForSpeechSeq2Seq.from_pretrained(
-    model_id, torch_dtype=torch_dtype, low_cpu_mem_usage=True
-)
-model.to(device)
-
-processor = AutoProcessor.from_pretrained(model_id)
-
-pipe = pipeline(
-    "automatic-speech-recognition",
-    model=model,
-    tokenizer=processor.tokenizer,
-    feature_extractor=processor.feature_extractor,
-    chunk_length_s=30,
-    batch_size=16,  # batch size for inference - set based on your device
-    torch_dtype=torch_dtype,
-    device=device,
-)
-
-dataset = load_dataset("distil-whisper/librispeech_long", "clean", split="validation")
-sample = dataset[0]["audio"]
-
-result = pipe(sample)
-print(result["text"])
--- a/tests/test_pipeline.py
+++ b/tests/test_pipeline.py
@@ -5,6 +5,7 @@ import asyncio
 from astrbot.core.pipeline.scheduler import PipelineScheduler, PipelineContext
 from astrbot.core.star import PluginManager
 from astrbot.core.config.astrbot_config import AstrBotConfig
+from astrbot.core.config.default import CONFIG_METADATA_2
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.platform.astrbot_message import AstrBotMessage, MessageMember, MessageType
 from astrbot.core.message.message_event_result import MessageChain, ResultContentType
Author	SHA1	Message	Date
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