feat: add user_id search capability in get_filtered_conversations

chore: bump version to v4.1.5
chore: remove uv.lock file
2025-09-21 22:45:55 +08:00 · 2025-09-21 21:47:14 +08:00 · 2025-09-21 21:47:06 +08:00 · 2025-09-21 21:45:35 +08:00 · 2025-09-21 21:24:47 +08:00 · 2025-09-21 21:10:03 +08:00
143 changed files with 5833 additions and 4437 deletions
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,19 +1,46 @@
-<!-- 如果有的话，指定这个 PR 要解决的 ISSUE -->
-解决了 #XYZ
+<!-- 如果有的话，请指定此 PR 旨在解决的 ISSUE 编号。 -->
+<!-- If applicable, please specify the ISSUE number this PR aims to resolve. -->

-### Motivation
+fixes #XYZ

-<!--解释为什么要改动-->
+---

-### Modifications
+### Motivation / 动机

-<!--简单解释你的改动-->
+<!--请描述此项更改的动机：它解决了什么问题？（例如：修复了 XX 错误，添加了 YY 功能）-->
+<!--Please describe the motivation for this change: What problem does it solve? (e.g., Fixes XX bug, adds YY feature)-->

-### Check
+### Modifications / 改动点

-<!--如果分支被合并，您的代码将服务于数万名用户！在提交前，请核查一下几点内容-->
+<!--请总结你的改动：哪些核心文件被修改了？实现了什么功能？-->
+<!--Please summarize your changes: What core files were modified? What functionality was implemented?-->

- [ ] 😊 我的 Commit Message 符合良好的[规范](https://www.conventionalcommits.org/en/v1.0.0/#summary)
- [ ] 👀 我的更改经过良好的测试
- [ ] 🤓 我确保没有引入新依赖库，或者引入了新依赖库的同时将其添加到了 `requirements.txt` 和 `pyproject.toml` 文件相应位置。
- [ ] 😮 我的更改没有引入恶意代码
+### Verification Steps / 验证步骤
+
+<!--请为审查者 (Reviewer) 提供清晰、可复现的验证步骤（例如：1. 导航到... 2. 点击...）。-->
+<!--Please provide clear and reproducible verification steps for the Reviewer (e.g., 1. Navigate to... 2. Click...).-->
+
+### Screenshots or Test Results / 运行截图或测试结果
+
+<!--请粘贴截图、GIF 或测试日志，作为执行“验证步骤”的证据，证明此改动有效。-->
+<!--Please paste screenshots, GIFs, or test logs here as evidence of executing the "Verification Steps" to prove this change is effective.-->
+
+### Compatibility & Breaking Changes / 兼容性与破坏性变更
+
+<!--请说明此变更的兼容性：哪些是破坏性变更？哪些地方做了向后兼容处理？是否提供了数据迁移方法？-->
+<!--Please explain the compatibility of this change: What are the breaking changes? What backward-compatible measures were taken? Are data migration paths provided?-->
+
+- [ ] 这是一个破坏性变更 (Breaking Change)。/ This is a breaking change.
+- [ ] 这不是一个破坏性变更。/ This is NOT a breaking change.
+
+---
+
+### Checklist / 检查清单
+
+<!--如果分支被合并，您的代码将服务于数万名用户！在提交前，请核查一下几点内容。-->
+<!--If merged, your code will serve tens of thousands of users! Please double-check the following items before submitting.-->
+
+- [ ] 😊 如果 PR 中有新加入的功能，已经通过 Issue / 邮件等方式和作者讨论过。/ If there are new features added in the PR, I have discussed it with the authors through issues/emails, etc.
+- [ ] 👀 我的更改经过了良好的测试，**并已在上方提供了“验证步骤”和“运行截图”**。/ My changes have been well-tested, **and "Verification Steps" and "Screenshots" have been provided above**.
+- [ ] 🤓 我确保没有引入新依赖库，或者引入了新依赖库的同时将其添加到了 `requirements.txt` 和 `pyproject.toml` 文件相应位置。/ I have ensured that no new dependencies are introduced, OR if new dependencies are introduced, they have been added to the appropriate locations in `requirements.txt` and `pyproject.toml`.
+- [ ] 😮 我的更改没有引入恶意代码。/ My changes do not introduce malicious code.
--- a/.github/auto_assign.yml
+++ b/.github/auto_assign.yml
@@ -0,0 +1,36 @@
+# Set to true to add reviewers to pull requests
+addReviewers: true
+
+# Set to true to add assignees to pull requests
+addAssignees: false
+
+# A list of reviewers to be added to pull requests (GitHub user name)
+reviewers:
+  - Soulter
+  - Raven95676
+  - Larch-C
+  - anka-afk
+  - advent259141
+  # - zouyonghe
+
+# A number of reviewers added to the pull request
+# Set 0 to add all the reviewers (default: 0)
+numberOfReviewers: 2
+
+# A list of assignees, overrides reviewers if set
+# assignees:
+#   - assigneeA
+
+# A number of assignees to add to the pull request
+# Set to 0 to add all of the assignees.
+# Uses numberOfReviewers if unset.
+# numberOfAssignees: 2
+
+# A list of keywords to be skipped the process that add reviewers if pull requests include it
+skipKeywords:
+  - wip
+  - draft
+
+# A list of users to be skipped by both the add reviewers and add assignees processes
+# skipUsers:
+#   - dependabot[bot]
--- a/.github/workflows/auto_release.yml
+++ b/.github/workflows/auto_release.yml
@@ -73,7 +73,7 @@ jobs:
        uses: actions/checkout@v5

      - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
        with:
          python-version: '3.10'

--- a/.github/workflows/code-format.yml
+++ b/.github/workflows/code-format.yml
@@ -0,0 +1,34 @@
+name: Code Format Check
+
+on:
+  pull_request:
+    branches: [ master ]
+  push:
+    branches: [ master ]
+
+jobs:
+  format-check:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v5
+      
+    - name: Set up Python
+      uses: actions/setup-python@v6
+      with:
+        python-version: '3.10'
+        
+    - name: Install UV
+      run: pip install uv
+      
+    - name: Install dependencies
+      run: uv sync
+      
+    - name: Check code formatting with ruff
+      run: |
+        uv run ruff format --check .
+        
+    - name: Check code style with ruff
+      run: |
+        uv run ruff check .
--- a/.github/workflows/coverage_test.yml
+++ b/.github/workflows/coverage_test.yml
@@ -22,7 +22,7 @@ jobs:
          fetch-depth: 0

      - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
      
      - name: Install dependencies
        run: |
--- a/.github/workflows/dashboard_ci.yml
+++ b/.github/workflows/dashboard_ci.yml
@@ -37,6 +37,7 @@ jobs:
            !dist/**/*.md

      - name: Create GitHub Release
+        if: github.event_name == 'push'
        uses: ncipollo/release-action@v1
        with:
          tag: release-${{ github.sha }}
--- a/.github/workflows/docker-image.yml
+++ b/.github/workflows/docker-image.yml
@@ -27,6 +27,33 @@ jobs:
        if: github.event_name == 'workflow_dispatch'
        run: git checkout ${{ steps.get-latest-tag.outputs.latest_tag }}

+      - name: Check if version is pre-release
+        id: check-prerelease
+        run: |
+          if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
+            version="${{ steps.get-latest-tag.outputs.latest_tag }}"
+          else
+            version="${{ github.ref_name }}"
+          fi
+          if [[ "$version" == *"beta"* ]] || [[ "$version" == *"alpha"* ]]; then
+            echo "is_prerelease=true" >> $GITHUB_OUTPUT
+            echo "Version $version is a pre-release, will not push latest tag"
+          else
+            echo "is_prerelease=false" >> $GITHUB_OUTPUT
+            echo "Version $version is a stable release, will push latest tag"
+          fi
+
+      - name: Build Dashboard
+        run: |
+          cd dashboard
+          npm install
+          npm run build
+          mkdir -p dist/assets
+          echo $(git rev-parse HEAD) > dist/assets/version
+          cd ..
+          mkdir -p data
+          cp -r dashboard/dist data/
+
      - name: Set QEMU
        uses: docker/setup-qemu-action@v3

@@ -53,9 +80,9 @@ jobs:
          platforms: linux/amd64,linux/arm64
          push: true
          tags: |
-            ${{ secrets.DOCKER_HUB_USERNAME }}/astrbot:latest
+            ${{ steps.check-prerelease.outputs.is_prerelease == 'false' && format('{0}/astrbot:latest', secrets.DOCKER_HUB_USERNAME) || '' }}
            ${{ secrets.DOCKER_HUB_USERNAME }}/astrbot:${{ github.event_name == 'workflow_dispatch' && steps.get-latest-tag.outputs.latest_tag || github.ref_name }}
-            ghcr.io/soulter/astrbot:latest
+            ${{ steps.check-prerelease.outputs.is_prerelease == 'false' && 'ghcr.io/soulter/astrbot:latest' || '' }}
            ghcr.io/soulter/astrbot:${{ github.event_name == 'workflow_dispatch' && steps.get-latest-tag.outputs.latest_tag || github.ref_name }}

      - name: Post build notifications
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@@ -18,7 +18,7 @@ jobs:
      pull-requests: write

    steps:
-    - uses: actions/stale@v9
+    - uses: actions/stale@v10
      with:
        repo-token: ${{ secrets.GITHUB_TOKEN }}
        stale-issue-message: 'Stale issue message'
--- a/README.md
+++ b/README.md
@@ -6,8 +6,6 @@

 <div align="center">

-_✨ 易上手的多平台 LLM 聊天机器人及开发框架 ✨_
-
 <a href="https://trendshift.io/repositories/12875" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12875" alt="Soulter%2FAstrBot | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>

 [![GitHub release (latest by date)](https://img.shields.io/github/v/release/Soulter/AstrBot?style=for-the-badge&color=76bad9)](https://github.com/Soulter/AstrBot/releases/latest)
@@ -16,7 +14,6 @@ _✨ 易上手的多平台 LLM 聊天机器人及开发框架 ✨_
 <a  href="https://qm.qq.com/cgi-bin/qm/qr?k=wtbaNx7EioxeaqS9z7RQWVXPIxg2zYr7&jump_from=webapi&authKey=vlqnv/AV2DbJEvGIcxdlNSpfxVy+8vVqijgreRdnVKOaydpc+YSw4MctmEbr0k5"><img alt="QQ_community" src="https://img.shields.io/badge/QQ群-775869627-purple?style=for-the-badge&color=76bad9"></a>
 <a  href="https://t.me/+hAsD2Ebl5as3NmY1"><img alt="Telegram_community" src="https://img.shields.io/badge/Telegram-AstrBot-purple?style=for-the-badge&color=76bad9"></a>
 [![wakatime](https://wakatime.com/badge/user/915e5316-99c6-4563-a483-ef186cf000c9/project/018e705a-a1a7-409a-a849-3013485e6c8e.svg?style=for-the-badge&color=76bad9)](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日消息量&cacheSeconds=3600&style=for-the-badge&color=3b618e)
 ![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.soulter.top%2Fastrbot%2Fplugin-num&query=%24.result&suffix=%E4%B8%AA&style=for-the-badge&label=%E6%8F%92%E4%BB%B6%E5%B8%82%E5%9C%BA&cacheSeconds=3600)

 <a href="https://github.com/Soulter/AstrBot/blob/master/README_en.md">English</a> ｜
@@ -27,7 +24,7 @@ _✨ 易上手的多平台 LLM 聊天机器人及开发框架 ✨_

 AstrBot 是一个开源的一站式 Agentic 聊天机器人平台及开发框架。

-## ✨ 主要功能
+## 主要功能

 1. **大模型对话**。支持接入多种大模型服务。支持多模态、工具调用、MCP、原生知识库、人设等功能。
 2. **多消息平台支持**。支持接入 QQ、企业微信、微信公众号、飞书、Telegram、钉钉、Discord、KOOK 等平台。支持速率限制、白名单、百度内容审核。
@@ -35,7 +32,7 @@ AstrBot 是一个开源的一站式 Agentic 聊天机器人平台及开发框架
 4. **插件扩展**。深度优化的插件机制，支持[开发插件](https://astrbot.app/dev/plugin.html)扩展功能，社区插件生态丰富。
 5. **WebUI**。可视化配置和管理机器人，功能齐全。

-## ✨ 使用方式
+## 部署方式

 #### Docker 部署

@@ -79,9 +76,7 @@ AstrBot 已由雨云官方上架至云应用平台，可一键部署。

 #### 手动部署

-> 推荐使用 `uv`。
-
-首先，安装 uv：
+首先安装 uv：

 ```bash
 pip install uv
@@ -96,6 +91,25 @@ uv run main.py

 或者请参阅官方文档 [通过源码部署 AstrBot](https://astrbot.app/deploy/astrbot/cli.html) 。

+## 🌍 社区
+
+### QQ 群组
+
+- 1 群：322154837
+- 3 群：630166526
+- 5 群：822130018
+- 6 群：753075035
+- 开发者群：975206796
+- 开发者群（备份）：295657329
+
+### Telegram 群组
+
+<a href="https://t.me/+hAsD2Ebl5as3NmY1"><img alt="Telegram_community" src="https://img.shields.io/badge/Telegram-AstrBot-purple?style=for-the-badge&color=76bad9"></a>
+
+### Discord 群组
+
+<a href="https://discord.gg/hAVk6tgV36"><img alt="Discord_community" src="https://img.shields.io/badge/Discord-AstrBot-purple?style=for-the-badge&color=76bad9"></a>
+
 ## ⚡ 消息平台支持情况

 | 平台    | 支持性 |
@@ -112,22 +126,20 @@ uv run main.py
 | Discord   | ✔    |
 | [KOOK](https://github.com/wuyan1003/astrbot_plugin_kook_adapter)   | ✔    |
 | [VoceChat](https://github.com/HikariFroya/astrbot_plugin_vocechat)   | ✔    |
-| 微信对话开放平台 | 🚧    |
-| WhatsApp   | 🚧    |
-| 小爱音响   | 🚧    |
+| Satori   | ✔    |
+| Misskey   | ✔    |

 ## ⚡ 提供商支持情况

 | 名称    | 支持性 | 类型 | 备注 |
 | -------- | ------- | ------- | ------- |
-| OpenAI API | ✔    | 文本生成 | 也支持 DeepSeek、Gemini、Kimi、xAI 等兼容 OpenAI API 的服务 |
-| Claude API | ✔    | 文本生成 |  |
-| Google Gemini API | ✔    | 文本生成 |  |
+| OpenAI | ✔    | 文本生成 | 支持任何兼容 OpenAI API 的服务 |
+| Anthropic | ✔    | 文本生成 |  |
+| Google Gemini | ✔    | 文本生成 |  |
 | Dify | ✔    | LLMOps |  |
 | 阿里云百炼应用 | ✔    | LLMOps |  |
 | Ollama | ✔    | 模型加载器 | 本地部署 DeepSeek、Llama 等开源语言模型 |
 | LM Studio | ✔    | 模型加载器 | 本地部署 DeepSeek、Llama 等开源语言模型 |
-| LLMTuner | ✔    | 模型加载器 | 本地加载 lora 等微调模型 |
 | [优云智算](https://www.compshare.cn/?ytag=GPU_YY-gh_astrbot&referral_code=FV7DcGowN4hB5UuXKgpE74) | ✔    | 模型 API 及算力服务平台 |  |
 | [302.AI](https://share.302.ai/rr1M3l) | ✔    | 模型 API 服务平台 |  |
 | 硅基流动 | ✔    | 模型 API 服务平台 |  |
@@ -143,7 +155,6 @@ uv run main.py
 | 阿里云百炼 TTS | ✔    | 文本转语音 |  |
 | Azure TTS | ✔    | 文本转语音 | Microsoft Azure TTS |

-
 ## ❤️ 贡献

 欢迎任何 Issues/Pull Requests！只需要将你的更改提交到此项目 ：)
@@ -162,39 +173,6 @@ pip install pre-commit
 pre-commit install
 ```

-## 🌟 支持
-
- Star 这个项目！
- 在[爱发电](https://afdian.com/a/soulter)支持我！
-
-## ✨ Demo
-
-<details><summary>👉 点击展开多张 Demo 截图 👈</summary>
-
-<div align='center'>
-
-<img src="https://github.com/user-attachments/assets/4ee688d9-467d-45c8-99d6-368f9a8a92d8" width="600">
-
-_✨基于 Docker 的沙箱化代码执行器（Beta 测试）✨_
-
-<img src="https://github.com/user-attachments/assets/0378f407-6079-4f64-ae4c-e97ab20611d2" height=500>
-
-_✨ 多模态、网页搜索、长文本转图片（可配置） ✨_
-
-<img src="https://github.com/user-attachments/assets/e137a9e1-340a-4bf2-bb2b-771132780735" height=150>
-<img src="https://github.com/user-attachments/assets/480f5e82-cf6a-4955-a869-0d73137aa6e1" height=150>
-
-_✨ 插件系统——部分插件展示 ✨_
-
-<img src="https://github.com/user-attachments/assets/0cdbf564-2f59-4da5-b524-ce0e7ef3d978" width=600>
-
-_✨ WebUI ✨_
-
-</div>
-
-</details>
-
-
 ## ❤️ Special Thanks

 特别感谢所有 Contributors 和插件开发者对 AstrBot 的贡献 ❤️
@@ -203,10 +181,18 @@ _✨ WebUI ✨_
  <img src="https://contrib.rocks/image?repo=AstrBotDevs/AstrBot" />
 </a>

-此外，本项目的诞生离不开以下开源项目：
+此外，本项目的诞生离不开以下开源项目的帮助：

 - [NapNeko/NapCatQQ](https://github.com/NapNeko/NapCatQQ) - 伟大的猫猫框架
- [wechatpy/wechatpy](https://github.com/wechatpy/wechatpy)
+
+另外，一些同类型其他的活跃开源 Bot 项目：
+
+- [nonebot/nonebot2](https://github.com/nonebot/nonebot2) - 扩展性极强的 Bot 框架
+- [koishijs/koishi](https://github.com/koishijs/koishi) - 扩展性极强的 Bot 框架
+- [MaiM-with-u/MaiBot](https://github.com/MaiM-with-u/MaiBot) - 注重拟人功能的 ChatBot
+- [langbot-app/LangBot](https://github.com/langbot-app/LangBot) - 功能丰富的 Bot 平台
+- [LroMiose/nekro-agent](https://github.com/KroMiose/nekro-agent) - 注重 Agent 的 ChatBot
+- [zhenxun-org/zhenxun_bot](https://github.com/zhenxun-org/zhenxun_bot) - 功能完善的 ChatBot

 ## ⭐ Star History

@@ -214,13 +200,11 @@ _✨ WebUI ✨_
 > 如果本项目对您的生活 / 工作产生了帮助，或者您关注本项目的未来发展，请给项目 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>

-![10k-star-banner-credit-by-kevin](https://github.com/user-attachments/assets/c97fc5fb-20b9-4bc8-9998-c20b930ab097)
-
+</details>

 _私は、高性能ですから!_
-
--- a/astrbot/api/event/filter/init.py
+++ b/astrbot/api/event/filter/init.py
@@ -7,6 +7,7 @@ from astrbot.core.star.register import (
    register_permission_type as permission_type,
    register_custom_filter as custom_filter,
    register_on_astrbot_loaded as on_astrbot_loaded,
+    register_on_platform_loaded as on_platform_loaded,
    register_on_llm_request as on_llm_request,
    register_on_llm_response as on_llm_response,
    register_llm_tool as llm_tool,
@@ -41,6 +42,7 @@ __all__ = [
    "custom_filter",
    "PermissionType",
    "on_astrbot_loaded",
+    "on_platform_loaded",
    "on_llm_request",
    "llm_tool",
    "on_decorating_result",
--- a/astrbot/cli/utils/basic.py
+++ b/astrbot/cli/utils/basic.py
@@ -37,7 +37,10 @@ async def check_dashboard(astrbot_root: Path) -> None:
                ):
                    click.echo("正在安装管理面板...")
                    await download_dashboard(
-                        path="data/dashboard.zip", extract_path=str(astrbot_root)
+                        path="data/dashboard.zip",
+                        extract_path=str(astrbot_root),
+                        version=f"v{VERSION}",
+                        latest=False,
                    )
                    click.echo("管理面板安装完成")

@@ -50,7 +53,10 @@ async def check_dashboard(astrbot_root: Path) -> None:
                        version = dashboard_version.split("v")[1]
                        click.echo(f"管理面板版本: {version}")
                        await download_dashboard(
-                            path="data/dashboard.zip", extract_path=str(astrbot_root)
+                            path="data/dashboard.zip",
+                            extract_path=str(astrbot_root),
+                            version=f"v{VERSION}",
+                            latest=False,
                        )
                    except Exception as e:
                        click.echo(f"下载管理面板失败: {e}")
@@ -59,7 +65,10 @@ async def check_dashboard(astrbot_root: Path) -> None:
        click.echo("初始化管理面板目录...")
        try:
            await download_dashboard(
-                path=str(astrbot_root / "dashboard.zip"), extract_path=str(astrbot_root)
+                path=str(astrbot_root / "dashboard.zip"),
+                extract_path=str(astrbot_root),
+                version=f"v{VERSION}",
+                latest=False,
            )
            click.echo("管理面板初始化完成")
        except Exception as e:
--- a/astrbot/cli/utils/plugin.py
+++ b/astrbot/cli/utils/plugin.py
@@ -124,15 +124,17 @@ def build_plug_list(plugins_dir: Path) -> list:
            if metadata and all(
                k in metadata for k in ["name", "desc", "version", "author", "repo"]
            ):
-                result.append({
-                    "name": str(metadata.get("name", "")),
-                    "desc": str(metadata.get("desc", "")),
-                    "version": str(metadata.get("version", "")),
-                    "author": str(metadata.get("author", "")),
-                    "repo": str(metadata.get("repo", "")),
-                    "status": PluginStatus.INSTALLED,
-                    "local_path": str(plugin_dir),
-                })
+                result.append(
+                    {
+                        "name": str(metadata.get("name", "")),
+                        "desc": str(metadata.get("desc", "")),
+                        "version": str(metadata.get("version", "")),
+                        "author": str(metadata.get("author", "")),
+                        "repo": str(metadata.get("repo", "")),
+                        "status": PluginStatus.INSTALLED,
+                        "local_path": str(plugin_dir),
+                    }
+                )

    # 获取在线插件列表
    online_plugins = []
@@ -142,15 +144,17 @@ def build_plug_list(plugins_dir: Path) -> list:
            resp.raise_for_status()
            data = resp.json()
            for plugin_id, plugin_info in data.items():
-                online_plugins.append({
-                    "name": str(plugin_id),
-                    "desc": str(plugin_info.get("desc", "")),
-                    "version": str(plugin_info.get("version", "")),
-                    "author": str(plugin_info.get("author", "")),
-                    "repo": str(plugin_info.get("repo", "")),
-                    "status": PluginStatus.NOT_INSTALLED,
-                    "local_path": None,
-                })
+                online_plugins.append(
+                    {
+                        "name": str(plugin_id),
+                        "desc": str(plugin_info.get("desc", "")),
+                        "version": str(plugin_info.get("version", "")),
+                        "author": str(plugin_info.get("author", "")),
+                        "repo": str(plugin_info.get("repo", "")),
+                        "status": PluginStatus.NOT_INSTALLED,
+                        "local_path": None,
+                    }
+                )
    except Exception as e:
        click.echo(f"获取在线插件列表失败: {e}", err=True)

--- a/astrbot/core/agent/agent.py
+++ b/astrbot/core/agent/agent.py
@@ -9,5 +9,5 @@ from .hooks import BaseAgentRunHooks
 class Agent(Generic[TContext]):
    name: str
    instructions: str | None = None
-    tools: list[str, FunctionTool] | None = None
+    tools: list[str | FunctionTool] | None = None
    run_hooks: BaseAgentRunHooks[TContext] | None = None
--- a/astrbot/core/agent/mcp_client.py
+++ b/astrbot/core/agent/mcp_client.py
@@ -92,7 +92,7 @@ class MCPClient:
        self.session: Optional[mcp.ClientSession] = None
        self.exit_stack = AsyncExitStack()

-        self.name = None
+        self.name: str | None = None
        self.active: bool = True
        self.tools: list[mcp.Tool] = []
        self.server_errlogs: list[str] = []
@@ -198,6 +198,8 @@ class MCPClient:

    async def list_tools_and_save(self) -> mcp.ListToolsResult:
        """List all tools from the server and save them to self.tools"""
+        if not self.session:
+            raise Exception("MCP Client is not initialized")
        response = await self.session.list_tools()
        self.tools = response.tools
        return response
--- a/astrbot/core/agent/response.py
+++ b/astrbot/core/agent/response.py
@@ -2,6 +2,7 @@ from dataclasses import dataclass
 import typing as T
 from astrbot.core.message.message_event_result import MessageChain

+
 class AgentResponseData(T.TypedDict):
    chain: MessageChain

--- a/astrbot/core/agent/run_context.py
+++ b/astrbot/core/agent/run_context.py
@@ -14,4 +14,5 @@ class ContextWrapper(Generic[TContext]):
    context: TContext
    event: AstrMessageEvent

+
 NoContext = ContextWrapper[None]
--- a/astrbot/core/agent/runners/tool_loop_agent_runner.py
+++ b/astrbot/core/agent/runners/tool_loop_agent_runner.py
@@ -258,7 +258,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                                )
                                yield MessageChain(
                                    type="tool_direct_result"
-                                ).base64_image(res.content[0].data)
+                                ).base64_image(resource.blob)
                            else:
                                tool_call_result_blocks.append(
                                    ToolCallMessageSegment(
@@ -269,17 +269,6 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                                )
                                yield MessageChain().message("返回的数据类型不受支持。")

-                            try:
-                                await self.agent_hooks.on_tool_end(
-                                    self.run_context,
-                                    func_tool_name,
-                                    func_tool_args,
-                                    resp,
-                                )
-                            except Exception as e:
-                                logger.error(
-                                    f"Error in on_tool_end hook: {e}", exc_info=True
-                                )
                    elif resp is None:
                        # Tool 直接请求发送消息给用户
                        # 这里我们将直接结束 Agent Loop。
@@ -289,27 +278,17 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                                yield MessageChain(
                                    chain=res.chain, type="tool_direct_result"
                                )
-                        try:
-                            await self.agent_hooks.on_tool_end(
-                                self.run_context, func_tool_name, func_tool_args, None
-                            )
-                        except Exception as e:
-                            logger.error(
-                                f"Error in on_tool_end hook: {e}", exc_info=True
-                            )
                    else:
                        logger.warning(
                            f"Tool 返回了不支持的类型: {type(resp)}，将忽略。"
                        )

-                        try:
-                            await self.agent_hooks.on_tool_end(
-                                self.run_context, func_tool_name, func_tool_args, None
-                            )
-                        except Exception as e:
-                            logger.error(
-                                f"Error in on_tool_end hook: {e}", exc_info=True
-                            )
+                try:
+                    await self.agent_hooks.on_tool_end(
+                        self.run_context, func_tool, func_tool_args, None
+                    )
+                except Exception as e:
+                    logger.error(f"Error in on_tool_end hook: {e}", exc_info=True)

                self.run_context.event.clear_result()
            except Exception as e:
--- a/astrbot/core/agent/tool.py
+++ b/astrbot/core/agent/tool.py
@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from deprecated import deprecated
-from typing import Awaitable, Literal, Any, Optional
+from typing import Awaitable, Callable, Literal, Any, Optional
 from .mcp_client import MCPClient


@@ -8,10 +8,10 @@ from .mcp_client import MCPClient
 class FunctionTool:
    """A class representing a function tool that can be used in function calling."""

-    name: str | None = None
+    name: str
    parameters: dict | None = None
    description: str | None = None
-    handler: Awaitable | None = None
+    handler: Callable[..., Awaitable[Any]] | None = None
    """处理函数, 当 origin 为 mcp 时，这个为空"""
    handler_module_path: str | None = None
    """处理函数的模块路径，当 origin 为 mcp 时，这个为空
@@ -51,7 +51,7 @@ class ToolSet:
    This class provides methods to add, remove, and retrieve tools, as well as
    convert the tools to different API formats (OpenAI, Anthropic, Google GenAI)."""

-    def __init__(self, tools: list[FunctionTool] = None):
+    def __init__(self, tools: list[FunctionTool] | None = None):
        self.tools: list[FunctionTool] = tools or []

    def empty(self) -> bool:
@@ -79,7 +79,13 @@ class ToolSet:
        return None

    @deprecated(reason="Use add_tool() instead", version="4.0.0")
-    def add_func(self, name: str, func_args: list, desc: str, handler: Awaitable):
+    def add_func(
+        self,
+        name: str,
+        func_args: list,
+        desc: str,
+        handler: Callable[..., Awaitable[Any]],
+    ):
        """Add a function tool to the set."""
        params = {
            "type": "object",  # hard-coded here
@@ -104,7 +110,7 @@ class ToolSet:
        self.remove_tool(name)

    @deprecated(reason="Use get_tool() instead", version="4.0.0")
-    def get_func(self, name: str) -> list[FunctionTool]:
+    def get_func(self, name: str) -> FunctionTool | None:
        """Get all function tools."""
        return self.get_tool(name)

@@ -125,7 +131,11 @@ class ToolSet:
                },
            }

-            if tool.parameters.get("properties") or not omit_empty_parameter_field:
+            if (
+                tool.parameters
+                and tool.parameters.get("properties")
+                or not omit_empty_parameter_field
+            ):
                func_def["function"]["parameters"] = tool.parameters

            result.append(func_def)
@@ -135,14 +145,14 @@ class ToolSet:
        """Convert tools to Anthropic API format."""
        result = []
        for tool in self.tools:
+            input_schema = {"type": "object"}
+            if tool.parameters:
+                input_schema["properties"] = tool.parameters.get("properties", {})
+                input_schema["required"] = tool.parameters.get("required", [])
            tool_def = {
                "name": tool.name,
                "description": tool.description,
-                "input_schema": {
-                    "type": "object",
-                    "properties": tool.parameters.get("properties", {}),
-                    "required": tool.parameters.get("required", []),
-                },
+                "input_schema": input_schema,
            }
            result.append(tool_def)
        return result
@@ -210,14 +220,15 @@ class ToolSet:

            return result

-        tools = [
-            {
+        tools = []
+        for tool in self.tools:
+            d = {
                "name": tool.name,
                "description": tool.description,
-                "parameters": convert_schema(tool.parameters),
            }
-            for tool in self.tools
-        ]
+            if tool.parameters:
+                d["parameters"] = convert_schema(tool.parameters)
+            tools.append(d)

        declarations = {}
        if tools:
--- a/astrbot/core/astrbot_config_mgr.py
+++ b/astrbot/core/astrbot_config_mgr.py
@@ -36,13 +36,21 @@ class AstrBotConfigManager:
        self.confs: dict[str, AstrBotConfig] = {}
        """uuid / "default" -> AstrBotConfig"""
        self.confs["default"] = default_config
+        self.abconf_data = None
        self._load_all_configs()

+    def _get_abconf_data(self) -> dict:
+        """获取所有的 abconf 数据"""
+        if self.abconf_data is None:
+            self.abconf_data = self.sp.get(
+                "abconf_mapping", {}, scope="global", scope_id="global"
+            )
+        return self.abconf_data
+
    def _load_all_configs(self):
        """Load all configurations from the shared preferences."""
-        abconf_data = self.sp.get(
-            "abconf_mapping", {}, scope="global", scope_id="global"
-        )
+        abconf_data = self._get_abconf_data()
+        self.abconf_data = abconf_data
        for uuid_, meta in abconf_data.items():
            filename = meta["path"]
            conf_path = os.path.join(get_astrbot_config_path(), filename)
@@ -72,9 +80,7 @@ class AstrBotConfigManager:
            ConfInfo: 包含配置文件的 uuid, 路径和名称等信息, 是一个 dict 类型
        """
        # uuid -> { "umop": list, "path": str, "name": str }
-        abconf_data = self.sp.get(
-            "abconf_mapping", {}, scope="global", scope_id="global"
-        )
+        abconf_data = self._get_abconf_data()
        if isinstance(umo, MessageSession):
            umo = str(umo)
        else:
@@ -115,6 +121,7 @@ class AstrBotConfigManager:
            "name": random_word,
        }
        self.sp.put("abconf_mapping", abconf_data, scope="global", scope_id="global")
+        self.abconf_data = abconf_data

    def get_conf(self, umo: str | MessageSession | None) -> AstrBotConfig:
        """获取指定 umo 的配置文件。如果不存在，则 fallback 到默认配置文件。"""
@@ -147,9 +154,7 @@ class AstrBotConfigManager:
        """获取所有配置文件的元数据列表"""
        conf_list = []
        conf_list.append(DEFAULT_CONFIG_CONF_INFO)
-        abconf_mapping = self.sp.get(
-            "abconf_mapping", {}, scope="global", scope_id="global"
-        )
+        abconf_mapping = self._get_abconf_data()
        for uuid_, meta in abconf_mapping.items():
            conf_list.append(ConfInfo(**meta, id=uuid_))
        return conf_list
@@ -218,6 +223,7 @@ class AstrBotConfigManager:
        # 从映射中移除
        del abconf_data[conf_id]
        self.sp.put("abconf_mapping", abconf_data, scope="global", scope_id="global")
+        self.abconf_data = abconf_data

        logger.info(f"成功删除配置文件 {conf_id}")
        return True
@@ -263,6 +269,7 @@ class AstrBotConfigManager:

        # 保存更新
        self.sp.put("abconf_mapping", abconf_data, scope="global", scope_id="global")
+        self.abconf_data = abconf_data
        logger.info(f"成功更新配置文件 {conf_id} 的信息")
        return True

--- a/astrbot/core/config/default.py
+++ b/astrbot/core/config/default.py
@@ -6,7 +6,7 @@ import os

 from astrbot.core.utils.astrbot_path import get_astrbot_data_path

-VERSION = "4.0.0"
+VERSION = "4.1.5"
 DB_PATH = os.path.join(get_astrbot_data_path(), "data_v4.db")

 # 默认配置
@@ -56,10 +56,11 @@ DEFAULT_CONFIG = {
        "wake_prefix": "",
        "web_search": False,
        "websearch_provider": "default",
-        "websearch_tavily_key": "",
+        "websearch_tavily_key": [],
        "web_search_link": False,
        "display_reasoning_text": False,
        "identifier": False,
+        "group_name_display": False,
        "datetime_system_prompt": True,
        "default_personality": "default",
        "persona_pool": ["*"],
@@ -103,6 +104,7 @@ DEFAULT_CONFIG = {
    "t2i_strategy": "remote",
    "t2i_endpoint": "",
    "t2i_use_file_service": False,
+    "t2i_active_template": "base",
    "http_proxy": "",
    "no_proxy": ["localhost", "127.0.0.1", "::1"],
    "dashboard": {
@@ -234,6 +236,16 @@ CONFIG_METADATA_2 = {
                        "discord_guild_id_for_debug": "",
                        "discord_activity_name": "",
                    },
+                    "Misskey": {
+                        "id": "misskey",
+                        "type": "misskey",
+                        "enable": False,
+                        "misskey_instance_url": "https://misskey.example",
+                        "misskey_token": "",
+                        "misskey_default_visibility": "public",
+                        "misskey_local_only": False,
+                        "misskey_enable_chat": True,
+                    },
                    "Slack": {
                        "id": "slack",
                        "type": "slack",
@@ -246,8 +258,49 @@ CONFIG_METADATA_2 = {
                        "slack_webhook_port": 6197,
                        "slack_webhook_path": "/astrbot-slack-webhook/callback",
                    },
+                    "Satori": {
+                        "id": "satori",
+                        "type": "satori",
+                        "enable": False,
+                        "satori_api_base_url": "http://localhost:5140/satori/v1",
+                        "satori_endpoint": "ws://localhost:5140/satori/v1/events",
+                        "satori_token": "",
+                        "satori_auto_reconnect": True,
+                        "satori_heartbeat_interval": 10,
+                        "satori_reconnect_delay": 5,
+                    },
                },
                "items": {
+                    "satori_api_base_url": {
+                        "description": "Satori API 终结点",
+                        "type": "string",
+                        "hint": "Satori API 的基础地址。",
+                    },
+                    "satori_endpoint": {
+                        "description": "Satori WebSocket 终结点",
+                        "type": "string",
+                        "hint": "Satori 事件的 WebSocket 端点。",
+                    },
+                    "satori_token": {
+                        "description": "Satori 令牌",
+                        "type": "string",
+                        "hint": "用于 Satori API 身份验证的令牌。",
+                    },
+                    "satori_auto_reconnect": {
+                        "description": "启用自动重连",
+                        "type": "bool",
+                        "hint": "断开连接时是否自动重新连接 WebSocket。",
+                    },
+                    "satori_heartbeat_interval": {
+                        "description": "Satori 心跳间隔",
+                        "type": "int",
+                        "hint": "发送心跳消息的间隔（秒）。",
+                    },
+                    "satori_reconnect_delay": {
+                        "description": "Satori 重连延迟",
+                        "type": "int",
+                        "hint": "尝试重新连接前的延迟时间（秒）。",
+                    },
                    "slack_connection_mode": {
                        "description": "Slack Connection Mode",
                        "type": "string",
@@ -294,6 +347,32 @@ CONFIG_METADATA_2 = {
                        "type": "string",
                        "hint": "如果你的网络环境为中国大陆，请在 `其他配置` 处设置代理或更改 api_base。",
                    },
+                    "misskey_instance_url": {
+                        "description": "Misskey 实例 URL",
+                        "type": "string",
+                        "hint": "例如 https://misskey.example，填写 Bot 账号所在的 Misskey 实例地址",
+                    },
+                    "misskey_token": {
+                        "description": "Misskey Access Token",
+                        "type": "string",
+                        "hint": "连接服务设置生成的 API 鉴权访问令牌（Access token）",
+                    },
+                    "misskey_default_visibility": {
+                        "description": "默认帖子可见性",
+                        "type": "string",
+                        "options": ["public", "home", "followers"],
+                        "hint": "机器人发帖时的默认可见性设置。public：公开，home：主页时间线，followers：仅关注者。",
+                    },
+                    "misskey_local_only": {
+                        "description": "仅限本站（不参与联合）",
+                        "type": "bool",
+                        "hint": "启用后，机器人发出的帖子将仅在本实例可见，不会联合到其他实例",
+                    },
+                    "misskey_enable_chat": {
+                        "description": "启用聊天消息响应",
+                        "type": "bool",
+                        "hint": "启用后，机器人将会监听和响应私信聊天消息",
+                    },
                    "telegram_command_register": {
                        "description": "Telegram 命令注册",
                        "type": "bool",
@@ -557,6 +636,7 @@ CONFIG_METADATA_2 = {
                        "api_base": "https://api.openai.com/v1",
                        "timeout": 120,
                        "model_config": {"model": "gpt-4o-mini", "temperature": 0.4},
+                        "custom_extra_body": {},
                        "modalities": ["text", "image", "tool_use"],
                        "hint": "也兼容所有与 OpenAI API 兼容的服务。",
                    },
@@ -571,6 +651,7 @@ CONFIG_METADATA_2 = {
                        "api_base": "",
                        "timeout": 120,
                        "model_config": {"model": "gpt-4o-mini", "temperature": 0.4},
+                        "custom_extra_body": {},
                        "modalities": ["text", "image", "tool_use"],
                    },
                    "xAI": {
@@ -583,6 +664,7 @@ CONFIG_METADATA_2 = {
                        "api_base": "https://api.x.ai/v1",
                        "timeout": 120,
                        "model_config": {"model": "grok-2-latest", "temperature": 0.4},
+                        "custom_extra_body": {},
                        "modalities": ["text", "image", "tool_use"],
                    },
                    "Anthropic": {
@@ -612,6 +694,7 @@ CONFIG_METADATA_2 = {
                        "key": ["ollama"],  # ollama 的 key 默认是 ollama
                        "api_base": "http://localhost:11434/v1",
                        "model_config": {"model": "llama3.1-8b", "temperature": 0.4},
+                        "custom_extra_body": {},
                        "modalities": ["text", "image", "tool_use"],
                    },
                    "LM Studio": {
@@ -625,6 +708,7 @@ CONFIG_METADATA_2 = {
                        "model_config": {
                            "model": "llama-3.1-8b",
                        },
+                        "custom_extra_body": {},
                        "modalities": ["text", "image", "tool_use"],
                    },
                    "Gemini(OpenAI兼容)": {
@@ -640,6 +724,7 @@ CONFIG_METADATA_2 = {
                            "model": "gemini-1.5-flash",
                            "temperature": 0.4,
                        },
+                        "custom_extra_body": {},
                        "modalities": ["text", "image", "tool_use"],
                    },
                    "Gemini": {
@@ -680,6 +765,7 @@ CONFIG_METADATA_2 = {
                        "api_base": "https://api.deepseek.com/v1",
                        "timeout": 120,
                        "model_config": {"model": "deepseek-chat", "temperature": 0.4},
+                        "custom_extra_body": {},
                        "modalities": ["text", "image", "tool_use"],
                    },
                    "302.AI": {
@@ -692,6 +778,7 @@ CONFIG_METADATA_2 = {
                        "api_base": "https://api.302.ai/v1",
                        "timeout": 120,
                        "model_config": {"model": "gpt-4.1-mini", "temperature": 0.4},
+                        "custom_extra_body": {},
                        "modalities": ["text", "image", "tool_use"],
                    },
                    "硅基流动": {
@@ -707,6 +794,7 @@ CONFIG_METADATA_2 = {
                            "model": "deepseek-ai/DeepSeek-V3",
                            "temperature": 0.4,
                        },
+                        "custom_extra_body": {},
                        "modalities": ["text", "image", "tool_use"],
                    },
                    "PPIO派欧云": {
@@ -722,6 +810,7 @@ CONFIG_METADATA_2 = {
                            "model": "deepseek/deepseek-r1",
                            "temperature": 0.4,
                        },
+                        "custom_extra_body": {},
                    },
                    "优云智算": {
                        "id": "compshare",
@@ -735,6 +824,7 @@ CONFIG_METADATA_2 = {
                        "model_config": {
                            "model": "moonshotai/Kimi-K2-Instruct",
                        },
+                        "custom_extra_body": {},
                        "modalities": ["text", "image", "tool_use"],
                    },
                    "Kimi": {
@@ -747,6 +837,7 @@ CONFIG_METADATA_2 = {
                        "timeout": 120,
                        "api_base": "https://api.moonshot.cn/v1",
                        "model_config": {"model": "moonshot-v1-8k", "temperature": 0.4},
+                        "custom_extra_body": {},
                        "modalities": ["text", "image", "tool_use"],
                    },
                    "智谱 AI": {
@@ -805,6 +896,7 @@ CONFIG_METADATA_2 = {
                        "timeout": 120,
                        "api_base": "https://api-inference.modelscope.cn/v1",
                        "model_config": {"model": "Qwen/Qwen3-32B", "temperature": 0.4},
+                        "custom_extra_body": {},
                        "modalities": ["text", "image", "tool_use"],
                    },
                    "FastGPT": {
@@ -816,6 +908,7 @@ CONFIG_METADATA_2 = {
                        "key": [],
                        "api_base": "https://api.fastgpt.in/api/v1",
                        "timeout": 60,
+                        "custom_extra_body": {},
                    },
                    "Whisper(API)": {
                        "id": "whisper",
@@ -866,6 +959,9 @@ CONFIG_METADATA_2 = {
                        "provider_type": "text_to_speech",
                        "enable": False,
                        "edge-tts-voice": "zh-CN-XiaoxiaoNeural",
+                        "rate": "+0%",
+                        "volume": "+0%",
+                        "pitch": "+0Hz",
                        "timeout": 20,
                    },
                    "GSV TTS(本地加载)": {
@@ -1057,6 +1153,12 @@ CONFIG_METADATA_2 = {
                        "render_type": "checkbox",
                        "hint": "模型支持的模态。如所填写的模型不支持图像，请取消勾选图像。",
                    },
+                    "custom_extra_body": {
+                        "description": "自定义请求体参数",
+                        "type": "dict",
+                        "items": {},
+                        "hint": "此处添加的键值对将被合并到发送给 API 的 extra_body 中。值可以是字符串、数字或布尔值。",
+                    },
                    "provider": {
                        "type": "string",
                        "invisible": True,
@@ -1659,6 +1761,9 @@ CONFIG_METADATA_2 = {
                    "identifier": {
                        "type": "bool",
                    },
+                    "group_name_display": {
+                        "type": "bool",
+                    },
                    "datetime_system_prompt": {
                        "type": "bool",
                    },
@@ -1838,17 +1943,31 @@ CONFIG_METADATA_3 = {
                        "_special": "select_provider",
                        "hint": "留空代表不使用。可用于不支持视觉模态的聊天模型。",
                    },
+                    "provider_stt_settings.enable": {
+                        "description": "默认启用语音转文本",
+                        "type": "bool",
+                    },
                    "provider_stt_settings.provider_id": {
                        "description": "语音转文本模型",
                        "type": "string",
                        "hint": "留空代表不使用。",
                        "_special": "select_provider_stt",
+                        "condition": {
+                            "provider_stt_settings.enable": True,
+                        },
+                    },
+                    "provider_tts_settings.enable": {
+                        "description": "默认启用文本转语音",
+                        "type": "bool",
                    },
                    "provider_tts_settings.provider_id": {
                        "description": "文本转语音模型",
                        "type": "string",
                        "hint": "留空代表不使用。",
                        "_special": "select_provider_tts",
+                        "condition": {
+                            "provider_tts_settings.enable": True,
+                        },
                    },
                    "provider_settings.image_caption_prompt": {
                        "description": "图片转述提示词",
@@ -1893,7 +2012,9 @@ CONFIG_METADATA_3 = {
                    },
                    "provider_settings.websearch_tavily_key": {
                        "description": "Tavily API Key",
-                        "type": "string",
+                        "type": "list",
+                        "items": {"type": "string"},
+                        "hint": "可添加多个 Key 进行轮询。",
                        "condition": {
                            "provider_settings.websearch_provider": "tavily",
                        },
@@ -1913,9 +2034,14 @@ CONFIG_METADATA_3 = {
                        "type": "bool",
                    },
                    "provider_settings.identifier": {
-                        "description": "用户感知",
+                        "description": "用户识别",
                        "type": "bool",
                    },
+                    "provider_settings.group_name_display": {
+                        "description": "显示群名称",
+                        "type": "bool",
+                        "hint": "启用后，在支持的平台(aiocqhttp)上会在 prompt 中包含群名称信息。",
+                    },
                    "provider_settings.datetime_system_prompt": {
                        "description": "现实世界时间感知",
                        "type": "bool",
@@ -1926,7 +2052,7 @@ CONFIG_METADATA_3 = {
                    },
                    "provider_settings.max_agent_step": {
                        "description": "工具调用轮数上限",
-                        "type": "bool",
+                        "type": "int",
                    },
                    "provider_settings.streaming_response": {
                        "description": "流式回复",
@@ -2063,41 +2189,41 @@ CONFIG_METADATA_3 = {
                "description": "内容安全",
                "type": "object",
                "items": {
-                    "platform_settings.content_safety.also_use_in_response": {
+                    "content_safety.also_use_in_response": {
                        "description": "同时检查模型的响应内容",
                        "type": "bool",
                    },
-                    "platform_settings.content_safety.baidu_aip.enable": {
+                    "content_safety.baidu_aip.enable": {
                        "description": "使用百度内容安全审核",
                        "type": "bool",
                        "hint": "您需要手动安装 baidu-aip 库。",
                    },
-                    "platform_settings.content_safety.baidu_aip.app_id": {
+                    "content_safety.baidu_aip.app_id": {
                        "description": "App ID",
                        "type": "string",
                        "condition": {
-                            "platform_settings.content_safety.baidu_aip.enable": True,
+                            "content_safety.baidu_aip.enable": True,
                        },
                    },
-                    "platform_settings.content_safety.baidu_aip.api_key": {
+                    "content_safety.baidu_aip.api_key": {
                        "description": "API Key",
                        "type": "string",
                        "condition": {
-                            "platform_settings.content_safety.baidu_aip.enable": True,
+                            "content_safety.baidu_aip.enable": True,
                        },
                    },
-                    "platform_settings.content_safety.baidu_aip.secret_key": {
+                    "content_safety.baidu_aip.secret_key": {
                        "description": "Secret Key",
                        "type": "string",
                        "condition": {
-                            "platform_settings.content_safety.baidu_aip.enable": True,
+                            "content_safety.baidu_aip.enable": True,
                        },
                    },
-                    "platform_settings.content_safety.internal_keywords.enable": {
+                    "content_safety.internal_keywords.enable": {
                        "description": "关键词检查",
                        "type": "bool",
                    },
-                    "platform_settings.content_safety.internal_keywords.extra_keywords": {
+                    "content_safety.internal_keywords.extra_keywords": {
                        "description": "额外关键词",
                        "type": "list",
                        "items": {"type": "string"},
@@ -2288,7 +2414,13 @@ CONFIG_METADATA_3_SYSTEM = {
                        "condition": {
                            "t2i_strategy": "remote",
                        },
-                        "_special": "t2i_template"
+                        "_special": "t2i_template",
+                    },
+                    "t2i_active_template": {
+                        "description": "当前应用的文转图渲染模板",
+                        "type": "string",
+                        "hint": "此处的值由文转图模板管理页面进行维护。",
+                        "invisible": True,
                    },
                    "log_level": {
                        "description": "控制台日志级别",
@@ -2321,6 +2453,11 @@ CONFIG_METADATA_3_SYSTEM = {
                        "type": "string",
                        "hint": "启用后，会以添加环境变量的方式设置代理。格式为 `http://ip:port`",
                    },
+                    "no_proxy": {
+                        "description": "直连地址列表",
+                        "type": "list",
+                        "items": {"type": "string"},
+                    },
                },
            }
        },
--- a/astrbot/core/db/migration/helper.py
+++ b/astrbot/core/db/migration/helper.py
@@ -53,7 +53,7 @@ async def do_migration_v4(
    await migration_webchat_data(db_helper, platform_id_map)

    # 执行偏好设置迁移
-    await migration_preferences(db_helper,platform_id_map)
+    await migration_preferences(db_helper, platform_id_map)

    # 执行平台统计表迁移
    await migration_platform_table(db_helper, platform_id_map)
--- a/astrbot/core/db/migration/shared_preferences_v3.py
+++ b/astrbot/core/db/migration/shared_preferences_v3.py
@@ -5,6 +5,7 @@ from astrbot.core.utils.astrbot_path import get_astrbot_data_path

 _VT = TypeVar("_VT")

+
 class SharedPreferences:
    def __init__(self, path=None):
        if path is None:
@@ -42,4 +43,5 @@ class SharedPreferences:
        self._data.clear()
        self._save_preferences()

+
 sp = SharedPreferences()
--- a/astrbot/core/db/migration/sqlite_v3.py
+++ b/astrbot/core/db/migration/sqlite_v3.py
@@ -4,6 +4,7 @@ from astrbot.core.db.po import Platform, Stats
 from typing import Tuple, List, Dict, Any
 from dataclasses import dataclass

+
@dataclass
 class Conversation:
    """LLM 对话存储
@@ -76,7 +77,7 @@ PRAGMA encoding = 'UTF-8';
 """


-class SQLiteDatabase():
+class SQLiteDatabase:
    def __init__(self, db_path: str) -> None:
        super().__init__()
        self.db_path = db_path
--- a/astrbot/core/db/sqlite.py
+++ b/astrbot/core/db/sqlite.py
@@ -18,6 +18,7 @@ from astrbot.core.db.po import (
 from sqlalchemy import select, update, delete, text
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.sql import func
+from sqlalchemy import or_

 NOT_GIVEN = T.TypeVar("NOT_GIVEN")

@@ -153,8 +154,22 @@ class SQLiteDatabase(BaseDatabase):
                    ConversationV2.platform_id.in_(platform_ids)
                )
            if search_query:
+                search_query = search_query.encode("unicode_escape").decode("utf-8")
                base_query = base_query.where(
-                    ConversationV2.title.ilike(f"%{search_query}%")
+                    or_(
+                        ConversationV2.title.ilike(f"%{search_query}%"),
+                        ConversationV2.content.ilike(f"%{search_query}%"),
+                        ConversationV2.user_id.ilike(f"%{search_query}%"),
+                    )
+                )
+            if "message_types" in kwargs and len(kwargs["message_types"]) > 0:
+                for msg_type in kwargs["message_types"]:
+                    base_query = base_query.where(
+                        ConversationV2.user_id.ilike(f"%:{msg_type}:%")
+                    )
+            if "platforms" in kwargs and len(kwargs["platforms"]) > 0:
+                base_query = base_query.where(
+                    ConversationV2.platform_id.in_(kwargs["platforms"])
                )

            # Get total count matching the filters
--- a/astrbot/core/db/vec_db/faiss_impl/init.py
+++ b/astrbot/core/db/vec_db/faiss_impl/init.py
@@ -1,3 +1,3 @@
 from .vec_db import FaissVecDB

-__all__ = ["FaissVecDB"]
+__all__ = ["FaissVecDB"]
--- a/astrbot/core/db/vec_db/faiss_impl/vec_db.py
+++ b/astrbot/core/db/vec_db/faiss_impl/vec_db.py
@@ -113,7 +113,8 @@ class FaissVecDB(BaseVecDB):
                reranked_results, key=lambda x: x.relevance_score, reverse=True
            )
            top_k_results = [
-                top_k_results[reranked_result.index] for reranked_result in reranked_results
+                top_k_results[reranked_result.index]
+                for reranked_result in reranked_results
            ]

        return top_k_results
--- a/astrbot/core/initial_loader.py
+++ b/astrbot/core/initial_loader.py
@@ -22,6 +22,7 @@ class InitialLoader:
        self.db = db
        self.logger = logger
        self.log_broker = log_broker
+        self.webui_dir: str | None = None

    async def start(self):
        core_lifecycle = AstrBotCoreLifecycle(self.log_broker, self.db)
@@ -35,8 +36,10 @@ class InitialLoader:

        core_task = core_lifecycle.start()

+        webui_dir = self.webui_dir
+
        self.dashboard_server = AstrBotDashboard(
-            core_lifecycle, self.db, core_lifecycle.dashboard_shutdown_event
+            core_lifecycle, self.db, core_lifecycle.dashboard_shutdown_event, webui_dir
        )
        task = asyncio.gather(
            core_task, self.dashboard_server.run()
--- a/astrbot/core/message/components.py
+++ b/astrbot/core/message/components.py
@@ -37,7 +37,7 @@ from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 from astrbot.core.utils.io import download_file, download_image_by_url, file_to_base64


-class ComponentType(Enum):
+class ComponentType(str, Enum):
    Plain = "Plain"  # 纯文本消息
    Face = "Face"  # QQ表情
    Record = "Record"  # 语音
@@ -108,7 +108,7 @@ class BaseMessageComponent(BaseModel):


 class Plain(BaseMessageComponent):
-    type: ComponentType = "Plain"
+    type = ComponentType.Plain
    text: str
    convert: T.Optional[bool] = True  # 若为 False 则直接发送未转换 CQ 码的消息

@@ -128,8 +128,9 @@ class Plain(BaseMessageComponent):
    async def to_dict(self):
        return {"type": "text", "data": {"text": self.text}}

+
 class Face(BaseMessageComponent):
-    type: ComponentType = "Face"
+    type = ComponentType.Face
    id: int

    def __init__(self, **_):
@@ -137,7 +138,7 @@ class Face(BaseMessageComponent):


 class Record(BaseMessageComponent):
-    type: ComponentType = "Record"
+    type = ComponentType.Record
    file: T.Optional[str] = ""
    magic: T.Optional[bool] = False
    url: T.Optional[str] = ""
@@ -164,19 +165,24 @@ class Record(BaseMessageComponent):
            return Record(file=url, **_)
        raise Exception("not a valid url")

+    @staticmethod
+    def fromBase64(bs64_data: str, **_):
+        return Record(file=f"base64://{bs64_data}", **_)
+
    async def convert_to_file_path(self) -> str:
        """将这个语音统一转换为本地文件路径。这个方法避免了手动判断语音数据类型，直接返回语音数据的本地路径（如果是网络 URL, 则会自动进行下载）。

        Returns:
            str: 语音的本地路径，以绝对路径表示。
        """
-        if self.file and self.file.startswith("file:///"):
-            file_path = self.file[8:]
-            return file_path
-        elif self.file and self.file.startswith("http"):
+        if not self.file:
+            raise Exception(f"not a valid file: {self.file}")
+        if self.file.startswith("file:///"):
+            return self.file[8:]
+        elif self.file.startswith("http"):
            file_path = await download_image_by_url(self.file)
            return os.path.abspath(file_path)
-        elif self.file and self.file.startswith("base64://"):
+        elif self.file.startswith("base64://"):
            bs64_data = self.file.removeprefix("base64://")
            image_bytes = base64.b64decode(bs64_data)
            temp_dir = os.path.join(get_astrbot_data_path(), "temp")
@@ -185,8 +191,7 @@ class Record(BaseMessageComponent):
                f.write(image_bytes)
            return os.path.abspath(file_path)
        elif os.path.exists(self.file):
-            file_path = self.file
-            return os.path.abspath(file_path)
+            return os.path.abspath(self.file)
        else:
            raise Exception(f"not a valid file: {self.file}")

@@ -197,12 +202,14 @@ class Record(BaseMessageComponent):
            str: 语音的 base64 编码，不以 base64:// 或者 data:image/jpeg;base64, 开头。
        """
        # convert to base64
-        if self.file and self.file.startswith("file:///"):
+        if not self.file:
+            raise Exception(f"not a valid file: {self.file}")
+        if self.file.startswith("file:///"):
            bs64_data = file_to_base64(self.file[8:])
-        elif self.file and self.file.startswith("http"):
+        elif self.file.startswith("http"):
            file_path = await download_image_by_url(self.file)
            bs64_data = file_to_base64(file_path)
-        elif self.file and self.file.startswith("base64://"):
+        elif self.file.startswith("base64://"):
            bs64_data = self.file
        elif os.path.exists(self.file):
            bs64_data = file_to_base64(self.file)
@@ -236,7 +243,7 @@ class Record(BaseMessageComponent):


 class Video(BaseMessageComponent):
-    type: ComponentType = "Video"
+    type = ComponentType.Video
    file: str
    cover: T.Optional[str] = ""
    c: T.Optional[int] = 2
@@ -322,7 +329,7 @@ class Video(BaseMessageComponent):


 class At(BaseMessageComponent):
-    type: ComponentType = "At"
+    type = ComponentType.At
    qq: T.Union[int, str]  # 此处str为all时代表所有人
    name: T.Optional[str] = ""

@@ -344,28 +351,28 @@ class AtAll(At):


 class RPS(BaseMessageComponent):  # TODO
-    type: ComponentType = "RPS"
+    type = ComponentType.RPS

    def __init__(self, **_):
        super().__init__(**_)


 class Dice(BaseMessageComponent):  # TODO
-    type: ComponentType = "Dice"
+    type = ComponentType.Dice

    def __init__(self, **_):
        super().__init__(**_)


 class Shake(BaseMessageComponent):  # TODO
-    type: ComponentType = "Shake"
+    type = ComponentType.Shake

    def __init__(self, **_):
        super().__init__(**_)


 class Anonymous(BaseMessageComponent):  # TODO
-    type: ComponentType = "Anonymous"
+    type = ComponentType.Anonymous
    ignore: T.Optional[bool] = False

    def __init__(self, **_):
@@ -373,7 +380,7 @@ class Anonymous(BaseMessageComponent):  # TODO


 class Share(BaseMessageComponent):
-    type: ComponentType = "Share"
+    type = ComponentType.Share
    url: str
    title: str
    content: T.Optional[str] = ""
@@ -384,7 +391,7 @@ class Share(BaseMessageComponent):


 class Contact(BaseMessageComponent):  # TODO
-    type: ComponentType = "Contact"
+    type = ComponentType.Contact
    _type: str  # type 字段冲突
    id: T.Optional[int] = 0

@@ -393,7 +400,7 @@ class Contact(BaseMessageComponent):  # TODO


 class Location(BaseMessageComponent):  # TODO
-    type: ComponentType = "Location"
+    type = ComponentType.Location
    lat: float
    lon: float
    title: T.Optional[str] = ""
@@ -404,7 +411,7 @@ class Location(BaseMessageComponent):  # TODO


 class Music(BaseMessageComponent):
-    type: ComponentType = "Music"
+    type = ComponentType.Music
    _type: str
    id: T.Optional[int] = 0
    url: T.Optional[str] = ""
@@ -421,7 +428,7 @@ class Music(BaseMessageComponent):


 class Image(BaseMessageComponent):
-    type: ComponentType = "Image"
+    type = ComponentType.Image
    file: T.Optional[str] = ""
    _type: T.Optional[str] = ""
    subType: T.Optional[int] = 0
@@ -464,14 +471,15 @@ class Image(BaseMessageComponent):
        Returns:
            str: 图片的本地路径，以绝对路径表示。
        """
-        url = self.url if self.url else self.file
-        if url and url.startswith("file:///"):
-            image_file_path = url[8:]
-            return image_file_path
-        elif url and url.startswith("http"):
+        url = self.url or self.file
+        if not url:
+            raise ValueError("No valid file or URL provided")
+        if url.startswith("file:///"):
+            return url[8:]
+        elif url.startswith("http"):
            image_file_path = await download_image_by_url(url)
            return os.path.abspath(image_file_path)
-        elif url and url.startswith("base64://"):
+        elif url.startswith("base64://"):
            bs64_data = url.removeprefix("base64://")
            image_bytes = base64.b64decode(bs64_data)
            temp_dir = os.path.join(get_astrbot_data_path(), "temp")
@@ -480,8 +488,7 @@ class Image(BaseMessageComponent):
                f.write(image_bytes)
            return os.path.abspath(image_file_path)
        elif os.path.exists(url):
-            image_file_path = url
-            return os.path.abspath(image_file_path)
+            return os.path.abspath(url)
        else:
            raise Exception(f"not a valid file: {url}")

@@ -492,13 +499,15 @@ class Image(BaseMessageComponent):
            str: 图片的 base64 编码，不以 base64:// 或者 data:image/jpeg;base64, 开头。
        """
        # convert to base64
-        url = self.url if self.url else self.file
-        if url and url.startswith("file:///"):
+        url = self.url or self.file
+        if not url:
+            raise ValueError("No valid file or URL provided")
+        if url.startswith("file:///"):
            bs64_data = file_to_base64(url[8:])
-        elif url and url.startswith("http"):
+        elif url.startswith("http"):
            image_file_path = await download_image_by_url(url)
            bs64_data = file_to_base64(image_file_path)
-        elif url and url.startswith("base64://"):
+        elif url.startswith("base64://"):
            bs64_data = url
        elif os.path.exists(url):
            bs64_data = file_to_base64(url)
@@ -532,7 +541,7 @@ class Image(BaseMessageComponent):


 class Reply(BaseMessageComponent):
-    type: ComponentType = "Reply"
+    type = ComponentType.Reply
    id: T.Union[str, int]
    """所引用的消息 ID"""
    chain: T.Optional[T.List["BaseMessageComponent"]] = []
@@ -558,7 +567,7 @@ class Reply(BaseMessageComponent):


 class RedBag(BaseMessageComponent):
-    type: ComponentType = "RedBag"
+    type = ComponentType.RedBag
    title: str

    def __init__(self, **_):
@@ -566,7 +575,7 @@ class RedBag(BaseMessageComponent):


 class Poke(BaseMessageComponent):
-    type: str = ""
+    type: str = ComponentType.Poke
    id: T.Optional[int] = 0
    qq: T.Optional[int] = 0

@@ -576,7 +585,7 @@ class Poke(BaseMessageComponent):


 class Forward(BaseMessageComponent):
-    type: ComponentType = "Forward"
+    type = ComponentType.Forward
    id: str

    def __init__(self, **_):
@@ -586,7 +595,7 @@ class Forward(BaseMessageComponent):
 class Node(BaseMessageComponent):
    """群合并转发消息"""

-    type: ComponentType = "Node"
+    type = ComponentType.Node
    id: T.Optional[int] = 0  # 忽略
    name: T.Optional[str] = ""  # qq昵称
    uin: T.Optional[str] = "0"  # qq号
@@ -638,7 +647,7 @@ class Node(BaseMessageComponent):


 class Nodes(BaseMessageComponent):
-    type: ComponentType = "Nodes"
+    type = ComponentType.Nodes
    nodes: T.List[Node]

    def __init__(self, nodes: T.List[Node], **_):
@@ -664,7 +673,7 @@ class Nodes(BaseMessageComponent):


 class Xml(BaseMessageComponent):
-    type: ComponentType = "Xml"
+    type = ComponentType.Xml
    data: str
    resid: T.Optional[int] = 0

@@ -673,7 +682,7 @@ class Xml(BaseMessageComponent):


 class Json(BaseMessageComponent):
-    type: ComponentType = "Json"
+    type = ComponentType.Json
    data: T.Union[str, dict]
    resid: T.Optional[int] = 0

@@ -684,7 +693,7 @@ class Json(BaseMessageComponent):


 class CardImage(BaseMessageComponent):
-    type: ComponentType = "CardImage"
+    type = ComponentType.CardImage
    file: str
    cache: T.Optional[bool] = True
    minwidth: T.Optional[int] = 400
@@ -703,7 +712,7 @@ class CardImage(BaseMessageComponent):


 class TTS(BaseMessageComponent):
-    type: ComponentType = "TTS"
+    type = ComponentType.TTS
    text: str

    def __init__(self, **_):
@@ -711,7 +720,7 @@ class TTS(BaseMessageComponent):


 class Unknown(BaseMessageComponent):
-    type: ComponentType = "Unknown"
+    type = ComponentType.Unknown
    text: str

    def toString(self):
@@ -723,7 +732,7 @@ class File(BaseMessageComponent):
    文件消息段
    """

-    type: ComponentType = "File"
+    type = ComponentType.File
    name: T.Optional[str] = ""  # 名字
    file_: T.Optional[str] = ""  # 本地路径
    url: T.Optional[str] = ""  # url
@@ -853,7 +862,7 @@ class File(BaseMessageComponent):


 class WechatEmoji(BaseMessageComponent):
-    type: ComponentType = "WechatEmoji"
+    type = ComponentType.WechatEmoji
    md5: T.Optional[str] = ""
    md5_len: T.Optional[int] = 0
    cdnurl: T.Optional[str] = ""
--- a/astrbot/core/pipeline/content_safety_check/stage.py
+++ b/astrbot/core/pipeline/content_safety_check/stage.py
@@ -19,7 +19,7 @@ class ContentSafetyCheckStage(Stage):
        self.strategy_selector = StrategySelector(config)

    async def process(
-        self, event: AstrMessageEvent, check_text: str = None
+        self, event: AstrMessageEvent, check_text: str | None = None
    ) -> Union[None, AsyncGenerator[None, None]]:
        """检查内容安全"""
        text = check_text if check_text else event.get_message_str()
--- a/astrbot/core/pipeline/content_safety_check/strategies/baidu_aip.py
+++ b/astrbot/core/pipeline/content_safety_check/strategies/baidu_aip.py
@@ -13,7 +13,7 @@ class BaiduAipStrategy(ContentSafetyStrategy):
        self.secret_key = sk
        self.client = AipContentCensor(self.app_id, self.api_key, self.secret_key)

-    def check(self, content: str):
+    def check(self, content: str) -> tuple[bool, str]:
        res = self.client.textCensorUserDefined(content)
        if "conclusionType" not in res:
            return False, ""
--- a/astrbot/core/pipeline/content_safety_check/strategies/keywords.py
+++ b/astrbot/core/pipeline/content_safety_check/strategies/keywords.py
@@ -16,7 +16,7 @@ class KeywordsStrategy(ContentSafetyStrategy):
        #             json.loads(base64.b64decode(f.read()).decode("utf-8"))["keywords"]
        #         )

-    def check(self, content: str) -> bool:
+    def check(self, content: str) -> tuple[bool, str]:
        for keyword in self.keywords:
            if re.search(keyword, content):
                return False, "内容安全检查不通过，匹配到敏感词。"
--- a/astrbot/core/pipeline/context_utils.py
+++ b/astrbot/core/pipeline/context_utils.py
@@ -10,7 +10,7 @@ from astrbot.core.platform.astr_message_event import AstrMessageEvent

 async def call_handler(
    event: AstrMessageEvent,
-    handler: T.Awaitable,
+    handler: T.Callable[..., T.Awaitable[T.Any]],
    *args,
    **kwargs,
 ) -> T.AsyncGenerator[T.Any, None]:
@@ -36,6 +36,9 @@ async def call_handler(
    except TypeError:
        logger.error("处理函数参数不匹配，请检查 handler 的定义。", exc_info=True)

+    if not ready_to_call:
+        return
+
    if inspect.isasyncgen(ready_to_call):
        _has_yielded = False
        try:
@@ -77,7 +80,7 @@ async def call_event_hook(

    Returns:
        bool: 如果事件被终止，返回 True
-    # """
+    #"""
    handlers = star_handlers_registry.get_handlers_by_event_type(
        hook_type, plugins_name=event.plugins_name
    )
--- a/astrbot/core/pipeline/process_stage/method/llm_request.py
+++ b/astrbot/core/pipeline/process_stage/method/llm_request.py
@@ -7,6 +7,7 @@ import copy
 import json
 import traceback
 from typing import AsyncGenerator, Union
+from astrbot.core.conversation_mgr import Conversation
 from astrbot.core import logger
 from astrbot.core.message.components import Image
 from astrbot.core.message.message_event_result import (
@@ -133,6 +134,15 @@ class FunctionToolExecutor(BaseFunctionToolExecutor[AstrAgentContext]):

        if agent_runner.done():
            llm_response = agent_runner.get_final_llm_resp()
+
+            if not llm_response:
+                text_content = mcp.types.TextContent(
+                    type="text",
+                    text=f"error when deligate task to {tool.agent.name}",
+                )
+                yield mcp.types.CallToolResult(content=[text_content])
+                return
+
            logger.debug(
                f"Agent  {tool.agent.name} 任务完成, response: {llm_response.completion_text}"
            )
@@ -148,7 +158,7 @@ class FunctionToolExecutor(BaseFunctionToolExecutor[AstrAgentContext]):
            )
            yield mcp.types.CallToolResult(content=[text_content])
        else:
-            yield mcp.types.TextContent(
+            text_content = mcp.types.TextContent(
                type="text",
                text=f"error when deligate task to {tool.agent.name}",
            )
@@ -200,7 +210,11 @@ class FunctionToolExecutor(BaseFunctionToolExecutor[AstrAgentContext]):
    ):
        if not tool.mcp_client:
            raise ValueError("MCP client is not available for MCP function tools.")
-        res = await tool.mcp_client.session.call_tool(
+
+        session = tool.mcp_client.session
+        if not session:
+            raise ValueError("MCP session is not available for MCP function tools.")
+        res = await session.call_tool(
            name=tool.name,
            arguments=tool_args,
        )
@@ -299,7 +313,9 @@ class LLMRequestSubStage(Stage):
            self.max_context_length - 1,
        )
        self.streaming_response: bool = settings["streaming_response"]
-        self.max_step: int = settings.get("max_agent_step", 10)
+        self.max_step: int = settings.get("max_agent_step", 30)
+        if isinstance(self.max_step, bool):  # workaround: #2622
+            self.max_step = 30
        self.show_tool_use: bool = settings.get("show_tool_use_status", True)

        for bwp in self.bot_wake_prefixs:
@@ -323,7 +339,7 @@ class LLMRequestSubStage(Stage):

        return _ctx.get_using_provider(umo=event.unified_msg_origin)

-    async def _get_session_conv(self, event: AstrMessageEvent):
+    async def _get_session_conv(self, event: AstrMessageEvent) -> Conversation:
        umo = event.unified_msg_origin
        conv_mgr = self.conv_manager

@@ -335,6 +351,8 @@ class LLMRequestSubStage(Stage):
        if not conversation:
            cid = await conv_mgr.new_conversation(umo, event.get_platform_id())
            conversation = await conv_mgr.get_conversation(umo, cid)
+        if not conversation:
+            raise RuntimeError("无法创建新的对话。")
        return conversation

    async def process(
@@ -434,13 +452,18 @@ class LLMRequestSubStage(Stage):
            provider_cfg = provider.provider_config.get("modalities", ["tool_use"])
            # 如果模型不支持工具使用，但请求中包含工具列表，则清空。
            if "tool_use" not in provider_cfg:
-                logger.debug(f"用户设置提供商 {provider} 不支持工具使用，清空工具列表。")
+                logger.debug(
+                    f"用户设置提供商 {provider} 不支持工具使用，清空工具列表。"
+                )
                req.func_tool = None
        # 插件可用性设置
        if event.plugins_name is not None and req.func_tool:
            new_tool_set = ToolSet()
            for tool in req.func_tool.tools:
-                plugin = star_map.get(tool.handler_module_path)
+                mp = tool.handler_module_path
+                if not mp:
+                    continue
+                plugin = star_map.get(mp)
                if not plugin:
                    continue
                if plugin.name in event.plugins_name or plugin.reserved:
--- a/astrbot/core/pipeline/process_stage/method/star_request.py
+++ b/astrbot/core/pipeline/process_stage/method/star_request.py
@@ -34,12 +34,14 @@ class StarRequestSubStage(Stage):

        for handler in activated_handlers:
            params = handlers_parsed_params.get(handler.handler_full_name, {})
-            try:
-                if handler.handler_module_path not in star_map:
-                    continue
-                logger.debug(
-                    f"plugin -> {star_map.get(handler.handler_module_path).name} - {handler.handler_name}"
+            md = star_map.get(handler.handler_module_path)
+            if not md:
+                logger.warning(
+                    f"Cannot find plugin for given handler module path: {handler.handler_module_path}"
                )
+                continue
+            logger.debug(f"plugin -> {md.name} - {handler.handler_name}")
+            try:
                wrapper = call_handler(event, handler.handler, **params)
                async for ret in wrapper:
                    yield ret
@@ -49,7 +51,7 @@ class StarRequestSubStage(Stage):
                logger.error(f"Star {handler.handler_full_name} handle error: {e}")

                if event.is_at_or_wake_command:
-                    ret = f":(\n\n在调用插件 {star_map.get(handler.handler_module_path).name} 的处理函数 {handler.handler_name} 时出现异常：{e}"
+                    ret = f":(\n\n在调用插件 {md.name} 的处理函数 {handler.handler_name} 时出现异常：{e}"
                    event.set_result(MessageEventResult().message(ret))
                    yield
                    event.clear_result()
--- a/astrbot/core/pipeline/respond/stage.py
+++ b/astrbot/core/pipeline/respond/stage.py
@@ -1,17 +1,15 @@
 import random
 import asyncio
 import math
-import traceback
 import astrbot.core.message.components as Comp
 from typing import Union, AsyncGenerator
 from ..stage import register_stage, Stage
-from ..context import PipelineContext
+from ..context import PipelineContext, call_event_hook
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.message.message_event_result import MessageChain, ResultContentType
 from astrbot.core import logger
-from astrbot.core.message.message_event_result import BaseMessageComponent
-from astrbot.core.star.star_handler import star_handlers_registry, EventType
-from astrbot.core.star.star import star_map
+from astrbot.core.message.components import BaseMessageComponent, ComponentType
+from astrbot.core.star.star_handler import EventType
 from astrbot.core.utils.path_util import path_Mapping
 from astrbot.core.utils.session_lock import session_lock_manager

@@ -114,6 +112,43 @@ class RespondStage(Stage):
        # 如果所有组件都为空
        return True

+    def is_seg_reply_required(self, event: AstrMessageEvent) -> bool:
+        """检查是否需要分段回复"""
+        if not self.enable_seg:
+            return False
+
+        if self.only_llm_result and not event.get_result().is_llm_result():
+            return False
+
+        if event.get_platform_name() in [
+            "qq_official",
+            "weixin_official_account",
+            "dingtalk",
+        ]:
+            return False
+
+        return True
+
+    def _extract_comp(
+        self,
+        raw_chain: list[BaseMessageComponent],
+        extract_types: set[ComponentType],
+        modify_raw_chain: bool = True,
+    ):
+        extracted = []
+        if modify_raw_chain:
+            remaining = []
+            for comp in raw_chain:
+                if comp.type in extract_types:
+                    extracted.append(comp)
+                else:
+                    remaining.append(comp)
+            raw_chain[:] = remaining
+        else:
+            extracted = [comp for comp in raw_chain if comp.type in extract_types]
+
+        return extracted
+
    async def process(
        self, event: AstrMessageEvent
    ) -> Union[None, AsyncGenerator[None, None]]:
@@ -123,7 +158,14 @@ class RespondStage(Stage):
        if result.result_content_type == ResultContentType.STREAMING_FINISH:
            return

+        logger.info(
+            f"Prepare to send - {event.get_sender_name()}/{event.get_sender_id()}: {event._outline_chain(result.chain)}"
+        )
+
        if result.result_content_type == ResultContentType.STREAMING_RESULT:
+            if result.async_stream is None:
+                logger.warning("async_stream 为空，跳过发送。")
+                return
            # 流式结果直接交付平台适配器处理
            use_fallback = self.config.get("provider_settings", {}).get(
                "streaming_segmented", False
@@ -148,87 +190,71 @@ class RespondStage(Stage):
            except Exception as e:
                logger.warning(f"空内容检查异常: {e}")

-            record_comps = [c for c in result.chain if isinstance(c, Comp.Record)]
-            non_record_comps = [
-                c for c in result.chain if not isinstance(c, Comp.Record)
-            ]
-
-            if (
-                self.enable_seg
-                and (
-                    (self.only_llm_result and result.is_llm_result())
-                    or not self.only_llm_result
+            # 发送消息链
+            # Record 需要强制单独发送
+            need_separately = {ComponentType.Record}
+            if self.is_seg_reply_required(event):
+                header_comps = self._extract_comp(
+                    result.chain,
+                    {ComponentType.Reply, ComponentType.At},
+                    modify_raw_chain=True,
                )
-                and event.get_platform_name()
-                not in ["qq_official", "weixin_official_account", "dingtalk"]
-            ):
-                decorated_comps = []
-                if self.reply_with_mention:
-                    for comp in result.chain:
-                        if isinstance(comp, Comp.At):
-                            decorated_comps.append(comp)
-                            result.chain.remove(comp)
-                            break
-                if self.reply_with_quote:
-                    for comp in result.chain:
-                        if isinstance(comp, Comp.Reply):
-                            decorated_comps.append(comp)
-                            result.chain.remove(comp)
-                            break
-
-                # leverage lock to guarentee the order of message sending among different events
+                if not result.chain or len(result.chain) == 0:
+                    # may fix #2670
+                    logger.warning(
+                        f"实际消息链为空, 跳过发送阶段。header_chain: {header_comps}, actual_chain: {result.chain}"
+                    )
+                    return
                async with session_lock_manager.acquire_lock(event.unified_msg_origin):
-                    for rcomp in record_comps:
-                        i = await self._calc_comp_interval(rcomp)
-                        await asyncio.sleep(i)
-                        try:
-                            await event.send(MessageChain([rcomp]))
-                        except Exception as e:
-                            logger.error(f"发送消息失败: {e} chain: {result.chain}")
-                            break
-                    # 分段回复
-                    for comp in non_record_comps:
+                    for comp in result.chain:
                        i = await self._calc_comp_interval(comp)
                        await asyncio.sleep(i)
                        try:
-                            await event.send(MessageChain([*decorated_comps, comp]))
-                            decorated_comps = []  # 清空已发送的装饰组件
+                            if comp.type in need_separately:
+                                await event.send(MessageChain([comp]))
+                            else:
+                                await event.send(MessageChain([*header_comps, comp]))
+                                header_comps.clear()
                        except Exception as e:
-                            logger.error(f"发送消息失败: {e} chain: {result.chain}")
-                            break
+                            logger.error(
+                                f"发送消息链失败: chain = {MessageChain([comp])}, error = {e}",
+                                exc_info=True,
+                            )
            else:
-                for rcomp in record_comps:
+                if all(
+                    comp.type in {ComponentType.Reply, ComponentType.At}
+                    for comp in result.chain
+                ):
+                    # may fix #2670
+                    logger.warning(
+                        f"消息链全为 Reply 和 At 消息段, 跳过发送阶段。chain: {result.chain}"
+                    )
+                    return
+                sep_comps = self._extract_comp(
+                    result.chain,
+                    need_separately,
+                    modify_raw_chain=True,
+                )
+                for comp in sep_comps:
+                    chain = MessageChain([comp])
                    try:
-                        await event.send(MessageChain([rcomp]))
+                        await event.send(chain)
                    except Exception as e:
-                        logger.error(f"发送消息失败: {e} chain: {result.chain}")
+                        logger.error(
+                            f"发送消息链失败: chain = {chain}, error = {e}",
+                            exc_info=True,
+                        )
+                chain = MessageChain(result.chain)
+                if result.chain and len(result.chain) > 0:
+                    try:
+                        await event.send(chain)
+                    except Exception as e:
+                        logger.error(
+                            f"发送消息链失败: chain = {chain}, error = {e}",
+                            exc_info=True,
+                        )

-                try:
-                    await event.send(MessageChain(non_record_comps))
-                except Exception as e:
-                    logger.error(traceback.format_exc())
-                    logger.error(f"发送消息失败: {e} chain: {result.chain}")
-
-            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, plugins_name=event.plugins_name
-        )
-        for handler in handlers:
-            try:
-                logger.debug(
-                    f"hook(on_after_message_sent) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}"
-                )
-                await handler.handler(event)
-            except BaseException:
-                logger.error(traceback.format_exc())
-
-            if event.is_stopped():
-                logger.info(
-                    f"{star_map[handler.handler_module_path].name} - {handler.handler_name} 终止了事件传播。"
-                )
-                return
+        if await call_event_hook(event, EventType.OnAfterMessageSentEvent):
+            return

        event.clear_result()
--- a/astrbot/core/pipeline/result_decorate/stage.py
+++ b/astrbot/core/pipeline/result_decorate/stage.py
@@ -36,6 +36,7 @@ class ResultDecorateStage(Stage):
            self.t2i_word_threshold = 150
        self.t2i_strategy = ctx.astrbot_config["t2i_strategy"]
        self.t2i_use_network = self.t2i_strategy == "remote"
+        self.t2i_active_template = ctx.astrbot_config["t2i_active_template"]

        self.forward_threshold = ctx.astrbot_config["platform_settings"][
            "forward_threshold"
@@ -247,7 +248,10 @@ class ResultDecorateStage(Stage):
                    render_start = time.time()
                    try:
                        url = await html_renderer.render_t2i(
-                            plain_str, return_url=True, use_network=self.t2i_use_network
+                            plain_str,
+                            return_url=True,
+                            use_network=self.t2i_use_network,
+                            template_name=self.t2i_active_template,
                        )
                    except BaseException:
                        logger.error("文本转图片失败，使用文本发送。")
--- a/astrbot/core/platform/astr_message_event.py
+++ b/astrbot/core/platform/astr_message_event.py
@@ -24,7 +24,7 @@ from astrbot.core.provider.entities import ProviderRequest
 from astrbot.core.utils.metrics import Metric
 from .astrbot_message import AstrBotMessage, Group
 from .platform_metadata import PlatformMetadata
-from .message_session import MessageSession, MessageSesion # noqa
+from .message_session import MessageSession, MessageSesion  # noqa


 class AstrMessageEvent(abc.ABC):
--- a/astrbot/core/platform/astrbot_message.py
+++ b/astrbot/core/platform/astrbot_message.py
@@ -55,7 +55,7 @@ class AstrBotMessage:
    self_id: str  # 机器人的识别id
    session_id: str  # 会话id。取决于 unique_session 的设置。
    message_id: str  # 消息id
-    group_id: str = ""  # 群组id，如果为私聊，则为空
+    group: Group  # 群组
    sender: MessageMember  # 发送者
    message: List[BaseMessageComponent]  # 消息链使用 Nakuru 的消息链格式
    message_str: str  # 最直观的纯文本消息字符串
@@ -64,6 +64,28 @@ class AstrBotMessage:

    def __init__(self) -> None:
        self.timestamp = int(time.time())
+        self.group = None

    def __str__(self) -> str:
        return str(self.__dict__)
+
+    @property
+    def group_id(self) -> str:
+        """
+        向后兼容的 group_id 属性
+        群组id，如果为私聊，则为空
+        """
+        if self.group:
+            return self.group.group_id
+        return ""
+
+    @group_id.setter
+    def group_id(self, value: str):
+        """设置 group_id"""
+        if value:
+            if self.group:
+                self.group.group_id = value
+            else:
+                self.group = Group(group_id=value)
+        else:
+            self.group = None
--- a/astrbot/core/platform/manager.py
+++ b/astrbot/core/platform/manager.py
@@ -6,6 +6,7 @@ from typing import List
 from asyncio import Queue
 from .register import platform_cls_map
 from astrbot.core import logger
+from astrbot.core.star.star_handler import star_handlers_registry, star_map, EventType
 from .sources.webchat.webchat_adapter import WebChatAdapter


@@ -66,25 +67,39 @@ class PlatformManager:
                        WeChatPadProAdapter,  # noqa: F401
                    )
                case "lark":
-                    from .sources.lark.lark_adapter import LarkPlatformAdapter  # noqa: F401
+                    from .sources.lark.lark_adapter import (
+                        LarkPlatformAdapter,  # noqa: F401
+                    )
                case "dingtalk":
                    from .sources.dingtalk.dingtalk_adapter import (
                        DingtalkPlatformAdapter,  # noqa: F401
                    )
                case "telegram":
-                    from .sources.telegram.tg_adapter import TelegramPlatformAdapter  # noqa: F401
+                    from .sources.telegram.tg_adapter import (
+                        TelegramPlatformAdapter,  # noqa: F401
+                    )
                case "wecom":
-                    from .sources.wecom.wecom_adapter import WecomPlatformAdapter  # noqa: F401
+                    from .sources.wecom.wecom_adapter import (
+                        WecomPlatformAdapter,  # noqa: F401
+                    )
                case "weixin_official_account":
                    from .sources.weixin_official_account.weixin_offacc_adapter import (
-                        WeixinOfficialAccountPlatformAdapter,  # noqa
+                        WeixinOfficialAccountPlatformAdapter,  # noqa: F401
                    )
                case "discord":
                    from .sources.discord.discord_platform_adapter import (
                        DiscordPlatformAdapter,  # noqa: F401
                    )
+                case "misskey":
+                    from .sources.misskey.misskey_adapter import (
+                        MisskeyPlatformAdapter,  # noqa: F401
+                    )
                case "slack":
                    from .sources.slack.slack_adapter import SlackAdapter  # noqa: F401
+                case "satori":
+                    from .sources.satori.satori_adapter import (
+                        SatoriPlatformAdapter,  # noqa: F401
+                    )
        except (ImportError, ModuleNotFoundError) as e:
            logger.error(
                f"加载平台适配器 {platform_config['type']} 失败，原因：{e}。请检查依赖库是否安装。提示：可以在 管理面板->控制台->安装Pip库 中安装依赖库。"
@@ -113,6 +128,17 @@ class PlatformManager:
                )
            )
        )
+        handlers = star_handlers_registry.get_handlers_by_event_type(
+            EventType.OnPlatformLoadedEvent
+        )
+        for handler in handlers:
+            try:
+                logger.info(
+                    f"hook(on_platform_loaded) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}"
+                )
+                await handler.handler()
+            except Exception:
+                logger.error(traceback.format_exc())

    async def _task_wrapper(self, task: asyncio.Task):
        try:
--- a/astrbot/core/platform/sources/aiocqhttp/aiocqhttp_message_event.py
+++ b/astrbot/core/platform/sources/aiocqhttp/aiocqhttp_message_event.py
@@ -67,12 +67,19 @@ class AiocqhttpMessageEvent(AstrMessageEvent):
        session_id: str,
        messages: list[dict],
    ):
-        if event:
-            await bot.send(event=event, message=messages)
-        elif is_group:
+        # session_id 必须是纯数字字符串
+        session_id = int(session_id) if session_id.isdigit() else None
+
+        if is_group and isinstance(session_id, int):
            await bot.send_group_msg(group_id=session_id, message=messages)
-        else:
+        elif not is_group and isinstance(session_id, int):
            await bot.send_private_msg(user_id=session_id, message=messages)
+        elif isinstance(event, Event):  # 最后兜底
+            await bot.send(event=event, message=messages)
+        else:
+            raise ValueError(
+                f"无法发送消息：缺少有效的数字 session_id({session_id}) 或 event({event})"
+            )

    @classmethod
    async def send_message(
@@ -83,7 +90,15 @@ class AiocqhttpMessageEvent(AstrMessageEvent):
        is_group: bool = False,
        session_id: str = None,
    ):
-        """发送消息"""
+        """发送消息至 QQ 协议端（aiocqhttp）。
+
+        Args:
+            bot (CQHttp): aiocqhttp 机器人实例
+            message_chain (MessageChain): 要发送的消息链
+            event (Event | None, optional): aiocqhttp 事件对象.
+            is_group (bool, optional): 是否为群消息.
+            session_id (str | None, optional): 会话 ID（群号或 QQ 号
+        """

        # 转发消息、文件消息不能和普通消息混在一起发送
        send_one_by_one = any(
@@ -122,18 +137,15 @@ class AiocqhttpMessageEvent(AstrMessageEvent):

    async def send(self, message: MessageChain):
        """发送消息"""
-        event = self.message_obj.raw_message
-        assert isinstance(event, Event), "Event must be an instance of aiocqhttp.Event"
-        is_group = False
-        if self.get_group_id():
-            is_group = True
-            session_id = self.get_group_id()
-        else:
-            session_id = self.get_sender_id()
+        event = getattr(self.message_obj, "raw_message", None)
+
+        is_group = bool(self.get_group_id())
+        session_id = self.get_group_id() if is_group else self.get_sender_id()
+
        await self.send_message(
            bot=self.bot,
            message_chain=message,
-            event=event,
+            event=event,  # 不强制要求一定是 Event
            is_group=is_group,
            session_id=session_id,
        )
--- a/astrbot/core/platform/sources/aiocqhttp/aiocqhttp_platform_adapter.py
+++ b/astrbot/core/platform/sources/aiocqhttp/aiocqhttp_platform_adapter.py
@@ -182,11 +182,13 @@ class AiocqhttpAdapter(Platform):
        abm = AstrBotMessage()
        abm.self_id = str(event.self_id)
        abm.sender = MessageMember(
-            str(event.sender["user_id"]), event.sender["nickname"]
+            str(event.sender["user_id"]),
+            event.sender.get("card") or event.sender.get("nickname", "N/A"),
        )
        if event["message_type"] == "group":
            abm.type = MessageType.GROUP_MESSAGE
            abm.group_id = str(event.group_id)
+            abm.group.group_name = event.get("group_name", "N/A")
        elif event["message_type"] == "private":
            abm.type = MessageType.FRIEND_MESSAGE
        if self.unique_session and abm.type == MessageType.GROUP_MESSAGE:
@@ -308,13 +310,22 @@ class AiocqhttpAdapter(Platform):
                            continue

                        at_info = await self.bot.call_action(
-                            action="get_stranger_info",
+                            action="get_group_member_info",
+                            group_id=event.group_id,
                            user_id=int(m["data"]["qq"]),
+                            no_cache=False,
                        )
                        if at_info:
-                            nickname = at_info.get("nick", "") or at_info.get(
-                                "nickname", ""
-                            )
+                            nickname = at_info.get("card", "")
+                            if nickname == "":
+                                at_info = await self.bot.call_action(
+                                    action="get_stranger_info",
+                                    user_id=int(m["data"]["qq"]),
+                                    no_cache=False,
+                                )
+                                nickname = at_info.get("nick", "") or at_info.get(
+                                    "nickname", ""
+                                )
                            is_at_self = str(m["data"]["qq"]) in {abm.self_id, "all"}

                            abm.message.append(
--- a/astrbot/core/platform/sources/dingtalk/dingtalk_event.py
+++ b/astrbot/core/platform/sources/dingtalk/dingtalk_event.py
@@ -54,9 +54,9 @@ class DingtalkMessageEvent(AstrMessageEvent):
                    logger.debug(f"send image: {ret}")

                except Exception as e:
-                    logger.error(f"钉钉图片处理失败: {e}")
-                    logger.warning(f"跳过图片发送: {image_path}")
+                    logger.warning(f"钉钉图片处理失败: {e}, 跳过图片发送")
                    continue
+
    async def send(self, message: MessageChain):
        await self.send_with_client(self.client, message)
        await super().send(message)
--- a/astrbot/core/platform/sources/discord/client.py
+++ b/astrbot/core/platform/sources/discord/client.py
@@ -41,7 +41,8 @@ class DiscordBotClient(discord.Bot):
                await self.on_ready_once_callback()
            except Exception as e:
                logger.error(
-                    f"[Discord] on_ready_once_callback 执行失败: {e}", exc_info=True)
+                    f"[Discord] on_ready_once_callback 执行失败: {e}", exc_info=True
+                )

    def _create_message_data(self, message: discord.Message) -> dict:
        """从 discord.Message 创建数据字典"""
@@ -90,7 +91,6 @@ class DiscordBotClient(discord.Bot):
            message_data = self._create_message_data(message)
            await self.on_message_received(message_data)

-
    def _extract_interaction_content(self, interaction: discord.Interaction) -> str:
        """从交互中提取内容"""
        interaction_type = interaction.type
--- a/astrbot/core/platform/sources/discord/components.py
+++ b/astrbot/core/platform/sources/discord/components.py
@@ -79,9 +79,12 @@ class DiscordButton(BaseMessageComponent):
        self.url = url
        self.disabled = disabled

+
 class DiscordReference(BaseMessageComponent):
    """Discord引用组件"""
+
    type: str = "discord_reference"
+
    def __init__(self, message_id: str, channel_id: str):
        self.message_id = message_id
        self.channel_id = channel_id
@@ -98,7 +101,6 @@ class DiscordView(BaseMessageComponent):
        self.components = components or []
        self.timeout = timeout

-
    def to_discord_view(self) -> discord.ui.View:
        """转换为Discord View对象"""
        view = discord.ui.View(timeout=self.timeout)
--- a/astrbot/core/platform/sources/discord/discord_platform_event.py
+++ b/astrbot/core/platform/sources/discord/discord_platform_event.py
@@ -53,7 +53,13 @@ class DiscordPlatformEvent(AstrMessageEvent):

        # 解析消息链为 Discord 所需的对象
        try:
-            content, files, view, embeds, reference_message_id = await self._parse_to_discord(message)
+            (
+                content,
+                files,
+                view,
+                embeds,
+                reference_message_id,
+            ) = await self._parse_to_discord(message)
        except Exception as e:
            logger.error(f"[Discord] 解析消息链时失败: {e}", exc_info=True)
            return
@@ -206,8 +212,7 @@ class DiscordPlatformEvent(AstrMessageEvent):
                        if await asyncio.to_thread(path.exists):
                            file_bytes = await asyncio.to_thread(path.read_bytes)
                            files.append(
-                                discord.File(BytesIO(file_bytes),
-                                             filename=i.name)
+                                discord.File(BytesIO(file_bytes), filename=i.name)
                            )
                        else:
                            logger.warning(
--- a/astrbot/core/platform/sources/misskey/misskey_adapter.py
+++ b/astrbot/core/platform/sources/misskey/misskey_adapter.py
@@ -0,0 +1,391 @@
+import asyncio
+import json
+from typing import Dict, Any, Optional, Awaitable
+
+from astrbot.api import logger
+from astrbot.api.event import MessageChain
+from astrbot.api.platform import (
+    AstrBotMessage,
+    Platform,
+    PlatformMetadata,
+    register_platform_adapter,
+)
+from astrbot.core.platform.astr_message_event import MessageSession
+import astrbot.api.message_components as Comp
+
+from .misskey_api import MisskeyAPI
+from .misskey_event import MisskeyPlatformEvent
+from .misskey_utils import (
+    serialize_message_chain,
+    resolve_message_visibility,
+    is_valid_user_session_id,
+    is_valid_room_session_id,
+    add_at_mention_if_needed,
+    process_files,
+    extract_sender_info,
+    create_base_message,
+    process_at_mention,
+    cache_user_info,
+    cache_room_info,
+)
+
+
+@register_platform_adapter("misskey", "Misskey 平台适配器")
+class MisskeyPlatformAdapter(Platform):
+    def __init__(
+        self, platform_config: dict, platform_settings: dict, event_queue: asyncio.Queue
+    ) -> None:
+        super().__init__(event_queue)
+        self.config = platform_config or {}
+        self.settings = platform_settings or {}
+        self.instance_url = self.config.get("misskey_instance_url", "")
+        self.access_token = self.config.get("misskey_token", "")
+        self.max_message_length = self.config.get("max_message_length", 3000)
+        self.default_visibility = self.config.get(
+            "misskey_default_visibility", "public"
+        )
+        self.local_only = self.config.get("misskey_local_only", False)
+        self.enable_chat = self.config.get("misskey_enable_chat", True)
+
+        self.unique_session = platform_settings["unique_session"]
+
+        self.api: Optional[MisskeyAPI] = None
+        self._running = False
+        self.client_self_id = ""
+        self._bot_username = ""
+        self._user_cache = {}
+
+    def meta(self) -> PlatformMetadata:
+        default_config = {
+            "misskey_instance_url": "",
+            "misskey_token": "",
+            "max_message_length": 3000,
+            "misskey_default_visibility": "public",
+            "misskey_local_only": False,
+            "misskey_enable_chat": True,
+        }
+        default_config.update(self.config)
+
+        return PlatformMetadata(
+            name="misskey",
+            description="Misskey 平台适配器",
+            id=self.config.get("id", "misskey"),
+            default_config_tmpl=default_config,
+        )
+
+    async def run(self):
+        if not self.instance_url or not self.access_token:
+            logger.error("[Misskey] 配置不完整，无法启动")
+            return
+
+        self.api = MisskeyAPI(self.instance_url, self.access_token)
+        self._running = True
+
+        try:
+            user_info = await self.api.get_current_user()
+            self.client_self_id = str(user_info.get("id", ""))
+            self._bot_username = user_info.get("username", "")
+            logger.info(
+                f"[Misskey] 已连接用户: {self._bot_username} (ID: {self.client_self_id})"
+            )
+        except Exception as e:
+            logger.error(f"[Misskey] 获取用户信息失败: {e}")
+            self._running = False
+            return
+
+        await self._start_websocket_connection()
+
+    async def _start_websocket_connection(self):
+        backoff_delay = 1.0
+        max_backoff = 300.0
+        backoff_multiplier = 1.5
+        connection_attempts = 0
+
+        while self._running:
+            try:
+                connection_attempts += 1
+                if not self.api:
+                    logger.error("[Misskey] API 客户端未初始化")
+                    break
+
+                streaming = self.api.get_streaming_client()
+                streaming.add_message_handler("notification", self._handle_notification)
+                if self.enable_chat:
+                    streaming.add_message_handler(
+                        "newChatMessage", self._handle_chat_message
+                    )
+                    streaming.add_message_handler("_debug", self._debug_handler)
+
+                if await streaming.connect():
+                    logger.info(
+                        f"[Misskey] WebSocket 已连接 (尝试 #{connection_attempts})"
+                    )
+                    connection_attempts = 0  # 重置计数器
+                    await streaming.subscribe_channel("main")
+                    if self.enable_chat:
+                        await streaming.subscribe_channel("messaging")
+                        await streaming.subscribe_channel("messagingIndex")
+                        logger.info("[Misskey] 聊天频道已订阅")
+
+                    backoff_delay = 1.0  # 重置延迟
+                    await streaming.listen()
+                else:
+                    logger.error(
+                        f"[Misskey] WebSocket 连接失败 (尝试 #{connection_attempts})"
+                    )
+
+            except Exception as e:
+                logger.error(
+                    f"[Misskey] WebSocket 异常 (尝试 #{connection_attempts}): {e}"
+                )
+
+            if self._running:
+                logger.info(
+                    f"[Misskey] {backoff_delay:.1f}秒后重连 (下次尝试 #{connection_attempts + 1})"
+                )
+                await asyncio.sleep(backoff_delay)
+                backoff_delay = min(backoff_delay * backoff_multiplier, max_backoff)
+
+    async def _handle_notification(self, data: Dict[str, Any]):
+        try:
+            logger.debug(
+                f"[Misskey] 收到通知事件:\n{json.dumps(data, indent=2, ensure_ascii=False)}"
+            )
+            notification_type = data.get("type")
+            if notification_type in ["mention", "reply", "quote"]:
+                note = data.get("note")
+                if note and self._is_bot_mentioned(note):
+                    logger.info(
+                        f"[Misskey] 处理贴文提及: {note.get('text', '')[:50]}..."
+                    )
+                    message = await self.convert_message(note)
+                    event = MisskeyPlatformEvent(
+                        message_str=message.message_str,
+                        message_obj=message,
+                        platform_meta=self.meta(),
+                        session_id=message.session_id,
+                        client=self.api,
+                    )
+                    self.commit_event(event)
+        except Exception as e:
+            logger.error(f"[Misskey] 处理通知失败: {e}")
+
+    async def _handle_chat_message(self, data: Dict[str, Any]):
+        try:
+            logger.debug(
+                f"[Misskey] 收到聊天事件数据:\n{json.dumps(data, indent=2, ensure_ascii=False)}"
+            )
+
+            sender_id = str(
+                data.get("fromUserId", "") or data.get("fromUser", {}).get("id", "")
+            )
+            if sender_id == self.client_self_id:
+                return
+
+            room_id = data.get("toRoomId")
+            if room_id:
+                raw_text = data.get("text", "")
+                logger.debug(
+                    f"[Misskey] 检查群聊消息: '{raw_text}', 机器人用户名: '{self._bot_username}'"
+                )
+
+                message = await self.convert_room_message(data)
+                logger.info(f"[Misskey] 处理群聊消息: {message.message_str[:50]}...")
+            else:
+                message = await self.convert_chat_message(data)
+                logger.info(f"[Misskey] 处理私聊消息: {message.message_str[:50]}...")
+
+            event = MisskeyPlatformEvent(
+                message_str=message.message_str,
+                message_obj=message,
+                platform_meta=self.meta(),
+                session_id=message.session_id,
+                client=self.api,
+            )
+            self.commit_event(event)
+        except Exception as e:
+            logger.error(f"[Misskey] 处理聊天消息失败: {e}")
+
+    async def _debug_handler(self, data: Dict[str, Any]):
+        logger.debug(
+            f"[Misskey] 收到未处理事件:\n{json.dumps(data, indent=2, ensure_ascii=False)}"
+        )
+
+    def _is_bot_mentioned(self, note: Dict[str, Any]) -> bool:
+        text = note.get("text", "")
+        if not text:
+            return False
+
+        mentions = note.get("mentions", [])
+        if self._bot_username and f"@{self._bot_username}" in text:
+            return True
+        if self.client_self_id in [str(uid) for uid in mentions]:
+            return True
+
+        reply = note.get("reply")
+        if reply and isinstance(reply, dict):
+            reply_user_id = str(reply.get("user", {}).get("id", ""))
+            if reply_user_id == self.client_self_id:
+                return bool(self._bot_username and f"@{self._bot_username}" in text)
+
+        return False
+
+    async def send_by_session(
+        self, session: MessageSession, message_chain: MessageChain
+    ) -> Awaitable[Any]:
+        if not self.api:
+            logger.error("[Misskey] API 客户端未初始化")
+            return await super().send_by_session(session, message_chain)
+
+        try:
+            session_id = session.session_id
+            text, has_at_user = serialize_message_chain(message_chain.chain)
+
+            if not has_at_user and session_id:
+                user_info = self._user_cache.get(session_id)
+                text = add_at_mention_if_needed(text, user_info, has_at_user)
+
+            if not text or not text.strip():
+                logger.warning("[Misskey] 消息内容为空，跳过发送")
+                return await super().send_by_session(session, message_chain)
+
+            if len(text) > self.max_message_length:
+                text = text[: self.max_message_length] + "..."
+
+            if session_id and is_valid_user_session_id(session_id):
+                from .misskey_utils import extract_user_id_from_session_id
+
+                user_id = extract_user_id_from_session_id(session_id)
+                await self.api.send_message(user_id, text)
+            elif session_id and is_valid_room_session_id(session_id):
+                from .misskey_utils import extract_room_id_from_session_id
+
+                room_id = extract_room_id_from_session_id(session_id)
+                await self.api.send_room_message(room_id, text)
+            else:
+                visibility, visible_user_ids = resolve_message_visibility(
+                    user_id=session_id,
+                    user_cache=self._user_cache,
+                    self_id=self.client_self_id,
+                    default_visibility=self.default_visibility,
+                )
+
+                await self.api.create_note(
+                    text,
+                    visibility=visibility,
+                    visible_user_ids=visible_user_ids,
+                    local_only=self.local_only,
+                )
+
+        except Exception as e:
+            logger.error(f"[Misskey] 发送消息失败: {e}")
+
+        return await super().send_by_session(session, message_chain)
+
+    async def convert_message(self, raw_data: Dict[str, Any]) -> AstrBotMessage:
+        """将 Misskey 贴文数据转换为 AstrBotMessage 对象"""
+        sender_info = extract_sender_info(raw_data, is_chat=False)
+        message = create_base_message(
+            raw_data,
+            sender_info,
+            self.client_self_id,
+            is_chat=False,
+            unique_session=self.unique_session,
+        )
+        cache_user_info(
+            self._user_cache, sender_info, raw_data, self.client_self_id, is_chat=False
+        )
+
+        message_parts = []
+        raw_text = raw_data.get("text", "")
+
+        if raw_text:
+            text_parts, processed_text = process_at_mention(
+                message, raw_text, self._bot_username, self.client_self_id
+            )
+            message_parts.extend(text_parts)
+
+        files = raw_data.get("files", [])
+        file_parts = process_files(message, files)
+        message_parts.extend(file_parts)
+
+        message.message_str = (
+            " ".join(part for part in message_parts if part.strip())
+            if message_parts
+            else ""
+        )
+        return message
+
+    async def convert_chat_message(self, raw_data: Dict[str, Any]) -> AstrBotMessage:
+        """将 Misskey 聊天消息数据转换为 AstrBotMessage 对象"""
+        sender_info = extract_sender_info(raw_data, is_chat=True)
+        message = create_base_message(
+            raw_data,
+            sender_info,
+            self.client_self_id,
+            is_chat=True,
+            unique_session=self.unique_session,
+        )
+        cache_user_info(
+            self._user_cache, sender_info, raw_data, self.client_self_id, is_chat=True
+        )
+
+        raw_text = raw_data.get("text", "")
+        if raw_text:
+            message.message.append(Comp.Plain(raw_text))
+
+        files = raw_data.get("files", [])
+        process_files(message, files, include_text_parts=False)
+
+        message.message_str = raw_text if raw_text else ""
+        return message
+
+    async def convert_room_message(self, raw_data: Dict[str, Any]) -> AstrBotMessage:
+        """将 Misskey 群聊消息数据转换为 AstrBotMessage 对象"""
+        sender_info = extract_sender_info(raw_data, is_chat=True)
+        room_id = raw_data.get("toRoomId", "")
+        message = create_base_message(
+            raw_data,
+            sender_info,
+            self.client_self_id,
+            is_chat=False,
+            room_id=room_id,
+            unique_session=self.unique_session,
+        )
+
+        cache_user_info(
+            self._user_cache, sender_info, raw_data, self.client_self_id, is_chat=False
+        )
+        cache_room_info(self._user_cache, raw_data, self.client_self_id)
+
+        raw_text = raw_data.get("text", "")
+        message_parts = []
+
+        if raw_text:
+            if self._bot_username and f"@{self._bot_username}" in raw_text:
+                text_parts, processed_text = process_at_mention(
+                    message, raw_text, self._bot_username, self.client_self_id
+                )
+                message_parts.extend(text_parts)
+            else:
+                message.message.append(Comp.Plain(raw_text))
+                message_parts.append(raw_text)
+
+        files = raw_data.get("files", [])
+        file_parts = process_files(message, files)
+        message_parts.extend(file_parts)
+
+        message.message_str = (
+            " ".join(part for part in message_parts if part.strip())
+            if message_parts
+            else ""
+        )
+        return message
+
+    async def terminate(self):
+        self._running = False
+        if self.api:
+            await self.api.close()
+
+    def get_client(self) -> Any:
+        return self.api
--- a/astrbot/core/platform/sources/misskey/misskey_api.py
+++ b/astrbot/core/platform/sources/misskey/misskey_api.py
@@ -0,0 +1,404 @@
+import json
+from typing import Any, Optional, Dict, List, Callable, Awaitable
+import uuid
+
+try:
+    import aiohttp
+    import websockets
+except ImportError as e:
+    raise ImportError(
+        "aiohttp and websockets are required for Misskey API. Please install them with: pip install aiohttp websockets"
+    ) from e
+
+from astrbot.api import logger
+
+# Constants
+API_MAX_RETRIES = 3
+HTTP_OK = 200
+
+
+class APIError(Exception):
+    """Misskey API 基础异常"""
+
+    pass
+
+
+class APIConnectionError(APIError):
+    """网络连接异常"""
+
+    pass
+
+
+class APIRateLimitError(APIError):
+    """API 频率限制异常"""
+
+    pass
+
+
+class AuthenticationError(APIError):
+    """认证失败异常"""
+
+    pass
+
+
+class WebSocketError(APIError):
+    """WebSocket 连接异常"""
+
+    pass
+
+
+class StreamingClient:
+    def __init__(self, instance_url: str, access_token: str):
+        self.instance_url = instance_url.rstrip("/")
+        self.access_token = access_token
+        self.websocket: Optional[Any] = None
+        self.is_connected = False
+        self.message_handlers: Dict[str, Callable] = {}
+        self.channels: Dict[str, str] = {}
+        self._running = False
+        self._last_pong = None
+
+    async def connect(self) -> bool:
+        try:
+            ws_url = self.instance_url.replace("https://", "wss://").replace(
+                "http://", "ws://"
+            )
+            ws_url += f"/streaming?i={self.access_token}"
+
+            self.websocket = await websockets.connect(
+                ws_url, ping_interval=30, ping_timeout=10
+            )
+            self.is_connected = True
+            self._running = True
+
+            logger.info("[Misskey WebSocket] 已连接")
+            return True
+
+        except Exception as e:
+            logger.error(f"[Misskey WebSocket] 连接失败: {e}")
+            self.is_connected = False
+            return False
+
+    async def disconnect(self):
+        self._running = False
+        if self.websocket:
+            await self.websocket.close()
+            self.websocket = None
+        self.is_connected = False
+        logger.info("[Misskey WebSocket] 连接已断开")
+
+    async def subscribe_channel(
+        self, channel_type: str, params: Optional[Dict] = None
+    ) -> str:
+        if not self.is_connected or not self.websocket:
+            raise WebSocketError("WebSocket 未连接")
+
+        channel_id = str(uuid.uuid4())
+        message = {
+            "type": "connect",
+            "body": {"channel": channel_type, "id": channel_id, "params": params or {}},
+        }
+
+        await self.websocket.send(json.dumps(message))
+        self.channels[channel_id] = channel_type
+        return channel_id
+
+    async def unsubscribe_channel(self, channel_id: str):
+        if (
+            not self.is_connected
+            or not self.websocket
+            or channel_id not in self.channels
+        ):
+            return
+
+        message = {"type": "disconnect", "body": {"id": channel_id}}
+
+        await self.websocket.send(json.dumps(message))
+        del self.channels[channel_id]
+
+    def add_message_handler(
+        self, event_type: str, handler: Callable[[Dict], Awaitable[None]]
+    ):
+        self.message_handlers[event_type] = handler
+
+    async def listen(self):
+        if not self.is_connected or not self.websocket:
+            raise WebSocketError("WebSocket 未连接")
+
+        try:
+            async for message in self.websocket:
+                if not self._running:
+                    break
+
+                try:
+                    data = json.loads(message)
+                    await self._handle_message(data)
+                except json.JSONDecodeError as e:
+                    logger.warning(f"[Misskey WebSocket] 无法解析消息: {e}")
+                except Exception as e:
+                    logger.error(f"[Misskey WebSocket] 处理消息失败: {e}")
+
+        except websockets.exceptions.ConnectionClosedError as e:
+            logger.warning(f"[Misskey WebSocket] 连接意外关闭: {e}")
+            self.is_connected = False
+        except websockets.exceptions.ConnectionClosed as e:
+            logger.warning(
+                f"[Misskey WebSocket] 连接已关闭 (代码: {e.code}, 原因: {e.reason})"
+            )
+            self.is_connected = False
+        except websockets.exceptions.InvalidHandshake as e:
+            logger.error(f"[Misskey WebSocket] 握手失败: {e}")
+            self.is_connected = False
+        except Exception as e:
+            logger.error(f"[Misskey WebSocket] 监听消息失败: {e}")
+            self.is_connected = False
+
+    async def _handle_message(self, data: Dict[str, Any]):
+        message_type = data.get("type")
+        body = data.get("body", {})
+
+        logger.debug(
+            f"[Misskey WebSocket] 收到消息类型: {message_type}\n数据: {json.dumps(data, indent=2, ensure_ascii=False)}"
+        )
+
+        if message_type == "channel":
+            channel_id = body.get("id")
+            event_type = body.get("type")
+            event_body = body.get("body", {})
+
+            logger.debug(
+                f"[Misskey WebSocket] 频道消息: {channel_id}, 事件类型: {event_type}"
+            )
+
+            if channel_id in self.channels:
+                channel_type = self.channels[channel_id]
+                handler_key = f"{channel_type}:{event_type}"
+
+                if handler_key in self.message_handlers:
+                    logger.debug(f"[Misskey WebSocket] 使用处理器: {handler_key}")
+                    await self.message_handlers[handler_key](event_body)
+                elif event_type in self.message_handlers:
+                    logger.debug(f"[Misskey WebSocket] 使用事件处理器: {event_type}")
+                    await self.message_handlers[event_type](event_body)
+                else:
+                    logger.debug(
+                        f"[Misskey WebSocket] 未找到处理器: {handler_key} 或 {event_type}"
+                    )
+                    if "_debug" in self.message_handlers:
+                        await self.message_handlers["_debug"](
+                            {
+                                "type": event_type,
+                                "body": event_body,
+                                "channel": channel_type,
+                            }
+                        )
+
+        elif message_type in self.message_handlers:
+            logger.debug(f"[Misskey WebSocket] 直接消息处理器: {message_type}")
+            await self.message_handlers[message_type](body)
+        else:
+            logger.debug(f"[Misskey WebSocket] 未处理的消息类型: {message_type}")
+            if "_debug" in self.message_handlers:
+                await self.message_handlers["_debug"](data)
+
+
+def retry_async(max_retries: int = 3, retryable_exceptions: tuple = ()):
+    def decorator(func):
+        async def wrapper(*args, **kwargs):
+            last_exc = None
+            for _ in range(max_retries):
+                try:
+                    return await func(*args, **kwargs)
+                except retryable_exceptions as e:
+                    last_exc = e
+                    continue
+            if last_exc:
+                raise last_exc
+
+        return wrapper
+
+    return decorator
+
+
+class MisskeyAPI:
+    def __init__(self, instance_url: str, access_token: str):
+        self.instance_url = instance_url.rstrip("/")
+        self.access_token = access_token
+        self._session: Optional[aiohttp.ClientSession] = None
+        self.streaming: Optional[StreamingClient] = None
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+        return False
+
+    async def close(self) -> None:
+        if self.streaming:
+            await self.streaming.disconnect()
+            self.streaming = None
+        if self._session:
+            await self._session.close()
+            self._session = None
+        logger.debug("[Misskey API] 客户端已关闭")
+
+    def get_streaming_client(self) -> StreamingClient:
+        if not self.streaming:
+            self.streaming = StreamingClient(self.instance_url, self.access_token)
+        return self.streaming
+
+    @property
+    def session(self) -> aiohttp.ClientSession:
+        if self._session is None or self._session.closed:
+            headers = {"Authorization": f"Bearer {self.access_token}"}
+            self._session = aiohttp.ClientSession(headers=headers)
+        return self._session
+
+    def _handle_response_status(self, status: int, endpoint: str):
+        """处理 HTTP 响应状态码"""
+        if status == 400:
+            logger.error(f"API 请求错误: {endpoint} (状态码: {status})")
+            raise APIError(f"Bad request for {endpoint}")
+        elif status in (401, 403):
+            logger.error(f"API 认证失败: {endpoint} (状态码: {status})")
+            raise AuthenticationError(f"Authentication failed for {endpoint}")
+        elif status == 429:
+            logger.warning(f"API 频率限制: {endpoint} (状态码: {status})")
+            raise APIRateLimitError(f"Rate limit exceeded for {endpoint}")
+        else:
+            logger.error(f"API 请求失败: {endpoint} (状态码: {status})")
+            raise APIConnectionError(f"HTTP {status} for {endpoint}")
+
+    async def _process_response(
+        self, response: aiohttp.ClientResponse, endpoint: str
+    ) -> Any:
+        """处理 API 响应"""
+        if response.status == HTTP_OK:
+            try:
+                result = await response.json()
+                if endpoint == "i/notifications":
+                    notifications_data = (
+                        result
+                        if isinstance(result, list)
+                        else result.get("notifications", [])
+                        if isinstance(result, dict)
+                        else []
+                    )
+                    if notifications_data:
+                        logger.debug(f"获取到 {len(notifications_data)} 条新通知")
+                else:
+                    logger.debug(f"API 请求成功: {endpoint}")
+                return result
+            except json.JSONDecodeError as e:
+                logger.error(f"响应不是有效的 JSON 格式: {e}")
+                raise APIConnectionError("Invalid JSON response") from e
+        else:
+            try:
+                error_text = await response.text()
+                logger.error(
+                    f"API 请求失败: {endpoint} - 状态码: {response.status}, 响应: {error_text}"
+                )
+            except Exception:
+                logger.error(f"API 请求失败: {endpoint} - 状态码: {response.status}")
+
+            self._handle_response_status(response.status, endpoint)
+            raise APIConnectionError(f"Request failed for {endpoint}")
+
+    @retry_async(
+        max_retries=API_MAX_RETRIES,
+        retryable_exceptions=(APIConnectionError, APIRateLimitError),
+    )
+    async def _make_request(
+        self, endpoint: str, data: Optional[Dict[str, Any]] = None
+    ) -> Any:
+        url = f"{self.instance_url}/api/{endpoint}"
+        payload = {"i": self.access_token}
+        if data:
+            payload.update(data)
+
+        try:
+            async with self.session.post(url, json=payload) as response:
+                return await self._process_response(response, endpoint)
+        except aiohttp.ClientError as e:
+            logger.error(f"HTTP 请求错误: {e}")
+            raise APIConnectionError(f"HTTP request failed: {e}") from e
+
+    async def create_note(
+        self,
+        text: str,
+        visibility: str = "public",
+        reply_id: Optional[str] = None,
+        visible_user_ids: Optional[List[str]] = None,
+        local_only: bool = False,
+    ) -> Dict[str, Any]:
+        """创建新贴文"""
+        data: Dict[str, Any] = {
+            "text": text,
+            "visibility": visibility,
+            "localOnly": local_only,
+        }
+        if reply_id:
+            data["replyId"] = reply_id
+        if visible_user_ids and visibility == "specified":
+            data["visibleUserIds"] = visible_user_ids
+
+        result = await self._make_request("notes/create", data)
+        note_id = result.get("createdNote", {}).get("id", "unknown")
+        logger.debug(f"发帖成功，note_id: {note_id}")
+        return result
+
+    async def get_current_user(self) -> Dict[str, Any]:
+        """获取当前用户信息"""
+        return await self._make_request("i", {})
+
+    async def send_message(self, user_id: str, text: str) -> Dict[str, Any]:
+        """发送聊天消息"""
+        result = await self._make_request(
+            "chat/messages/create-to-user", {"toUserId": user_id, "text": text}
+        )
+        message_id = result.get("id", "unknown")
+        logger.debug(f"聊天发送成功，message_id: {message_id}")
+        return result
+
+    async def send_room_message(self, room_id: str, text: str) -> Dict[str, Any]:
+        """发送房间消息"""
+        result = await self._make_request(
+            "chat/messages/create-to-room", {"toRoomId": room_id, "text": text}
+        )
+        message_id = result.get("id", "unknown")
+        logger.debug(f"房间消息发送成功，message_id: {message_id}")
+        return result
+
+    async def get_messages(
+        self, user_id: str, limit: int = 10, since_id: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """获取聊天消息历史"""
+        data: Dict[str, Any] = {"userId": user_id, "limit": limit}
+        if since_id:
+            data["sinceId"] = since_id
+
+        result = await self._make_request("chat/messages/user-timeline", data)
+        if isinstance(result, list):
+            return result
+        else:
+            logger.warning(f"获取聊天消息响应格式异常: {type(result)}")
+            return []
+
+    async def get_mentions(
+        self, limit: int = 10, since_id: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """获取提及通知"""
+        data: Dict[str, Any] = {"limit": limit}
+        if since_id:
+            data["sinceId"] = since_id
+        data["includeTypes"] = ["mention", "reply", "quote"]
+
+        result = await self._make_request("i/notifications", data)
+        if isinstance(result, list):
+            return result
+        elif isinstance(result, dict) and "notifications" in result:
+            return result["notifications"]
+        else:
+            logger.warning(f"获取提及通知响应格式异常: {type(result)}")
+            return []
--- a/astrbot/core/platform/sources/misskey/misskey_event.py
+++ b/astrbot/core/platform/sources/misskey/misskey_event.py
@@ -0,0 +1,123 @@
+import asyncio
+import re
+from typing import AsyncGenerator
+from astrbot.api import logger
+from astrbot.api.event import AstrMessageEvent, MessageChain
+from astrbot.api.platform import PlatformMetadata, AstrBotMessage
+from astrbot.api.message_components import Plain
+
+from .misskey_utils import (
+    serialize_message_chain,
+    resolve_visibility_from_raw_message,
+    is_valid_user_session_id,
+    is_valid_room_session_id,
+    add_at_mention_if_needed,
+    extract_user_id_from_session_id,
+    extract_room_id_from_session_id,
+)
+
+
+class MisskeyPlatformEvent(AstrMessageEvent):
+    def __init__(
+        self,
+        message_str: str,
+        message_obj: AstrBotMessage,
+        platform_meta: PlatformMetadata,
+        session_id: str,
+        client,
+    ):
+        super().__init__(message_str, message_obj, platform_meta, session_id)
+        self.client = client
+
+    def _is_system_command(self, message_str: str) -> bool:
+        """检测是否为系统指令"""
+        if not message_str or not message_str.strip():
+            return False
+
+        system_prefixes = ["/", "!", "#", ".", "^"]
+        message_trimmed = message_str.strip()
+
+        return any(message_trimmed.startswith(prefix) for prefix in system_prefixes)
+
+    async def send(self, message: MessageChain):
+        content, has_at = serialize_message_chain(message.chain)
+
+        if not content:
+            logger.debug("[MisskeyEvent] 内容为空，跳过发送")
+            return
+
+        try:
+            original_message_id = getattr(self.message_obj, "message_id", None)
+            raw_message = getattr(self.message_obj, "raw_message", {})
+
+            if raw_message and not has_at:
+                user_data = raw_message.get("user", {})
+                user_info = {
+                    "username": user_data.get("username", ""),
+                    "nickname": user_data.get("name", user_data.get("username", "")),
+                }
+                content = add_at_mention_if_needed(content, user_info, has_at)
+
+            # 根据会话类型选择发送方式
+            if hasattr(self.client, "send_message") and is_valid_user_session_id(
+                self.session_id
+            ):
+                user_id = extract_user_id_from_session_id(self.session_id)
+                await self.client.send_message(user_id, content)
+            elif hasattr(self.client, "send_room_message") and is_valid_room_session_id(
+                self.session_id
+            ):
+                room_id = extract_room_id_from_session_id(self.session_id)
+                await self.client.send_room_message(room_id, content)
+            elif original_message_id and hasattr(self.client, "create_note"):
+                visibility, visible_user_ids = resolve_visibility_from_raw_message(
+                    raw_message
+                )
+                await self.client.create_note(
+                    content,
+                    reply_id=original_message_id,
+                    visibility=visibility,
+                    visible_user_ids=visible_user_ids,
+                )
+            elif hasattr(self.client, "create_note"):
+                logger.debug("[MisskeyEvent] 创建新帖子")
+                await self.client.create_note(content)
+
+            await super().send(message)
+
+        except Exception as e:
+            logger.error(f"[MisskeyEvent] 发送失败: {e}")
+
+    async def send_streaming(
+        self, generator: AsyncGenerator[MessageChain, None], use_fallback: bool = False
+    ):
+        if not use_fallback:
+            buffer = None
+            async for chain in generator:
+                if not buffer:
+                    buffer = chain
+                else:
+                    buffer.chain.extend(chain.chain)
+            if not buffer:
+                return
+            buffer.squash_plain()
+            await self.send(buffer)
+            return await super().send_streaming(generator, use_fallback)
+
+        buffer = ""
+        pattern = re.compile(r"[^。？！~…]+[。？！~…]+")
+
+        async for chain in generator:
+            if isinstance(chain, MessageChain):
+                for comp in chain.chain:
+                    if isinstance(comp, Plain):
+                        buffer += comp.text
+                        if any(p in buffer for p in "。？！~…"):
+                            buffer = await self.process_buffer(buffer, pattern)
+                    else:
+                        await self.send(MessageChain(chain=[comp]))
+                        await asyncio.sleep(1.5)  # 限速
+
+        if buffer.strip():
+            await self.send(MessageChain([Plain(buffer)]))
+        return await super().send_streaming(generator, use_fallback)
--- a/astrbot/core/platform/sources/misskey/misskey_utils.py
+++ b/astrbot/core/platform/sources/misskey/misskey_utils.py
@@ -0,0 +1,327 @@
+"""Misskey 平台适配器通用工具函数"""
+
+from typing import Dict, Any, List, Tuple, Optional, Union
+import astrbot.api.message_components as Comp
+from astrbot.api.platform import AstrBotMessage, MessageMember, MessageType
+
+
+def serialize_message_chain(chain: List[Any]) -> Tuple[str, bool]:
+    """将消息链序列化为文本字符串"""
+    text_parts = []
+    has_at = False
+
+    def process_component(component):
+        nonlocal has_at
+        if isinstance(component, Comp.Plain):
+            return component.text
+        elif isinstance(component, Comp.File):
+            file_name = getattr(component, "name", "文件")
+            return f"[文件: {file_name}]"
+        elif isinstance(component, Comp.At):
+            has_at = True
+            return f"@{component.qq}"
+        elif hasattr(component, "text"):
+            text = getattr(component, "text", "")
+            if "@" in text:
+                has_at = True
+            return text
+        else:
+            return str(component)
+
+    for component in chain:
+        if isinstance(component, Comp.Node) and component.content:
+            for node_comp in component.content:
+                result = process_component(node_comp)
+                if result:
+                    text_parts.append(result)
+        else:
+            result = process_component(component)
+            if result:
+                text_parts.append(result)
+
+    return "".join(text_parts), has_at
+
+
+def resolve_message_visibility(
+    user_id: Optional[str],
+    user_cache: Dict[str, Any],
+    self_id: Optional[str],
+    default_visibility: str = "public",
+) -> Tuple[str, Optional[List[str]]]:
+    """解析 Misskey 消息的可见性设置"""
+    visibility = default_visibility
+    visible_user_ids = None
+
+    if user_id and user_cache:
+        user_info = user_cache.get(user_id)
+        if user_info:
+            original_visibility = user_info.get("visibility", default_visibility)
+            if original_visibility == "specified":
+                visibility = "specified"
+                original_visible_users = user_info.get("visible_user_ids", [])
+                users_to_include = [user_id]
+                if self_id:
+                    users_to_include.append(self_id)
+                visible_user_ids = list(set(original_visible_users + users_to_include))
+                visible_user_ids = [uid for uid in visible_user_ids if uid]
+            else:
+                visibility = original_visibility
+
+    return visibility, visible_user_ids
+
+
+def resolve_visibility_from_raw_message(
+    raw_message: Dict[str, Any], self_id: Optional[str] = None
+) -> Tuple[str, Optional[List[str]]]:
+    """从原始消息数据中解析可见性设置"""
+    visibility = "public"
+    visible_user_ids = None
+
+    if not raw_message:
+        return visibility, visible_user_ids
+
+    original_visibility = raw_message.get("visibility", "public")
+    if original_visibility == "specified":
+        visibility = "specified"
+        original_visible_users = raw_message.get("visibleUserIds", [])
+        sender_id = raw_message.get("userId", "")
+
+        users_to_include = []
+        if sender_id:
+            users_to_include.append(sender_id)
+        if self_id:
+            users_to_include.append(self_id)
+
+        visible_user_ids = list(set(original_visible_users + users_to_include))
+        visible_user_ids = [uid for uid in visible_user_ids if uid]
+    else:
+        visibility = original_visibility
+
+    return visibility, visible_user_ids
+
+
+def is_valid_user_session_id(session_id: Union[str, Any]) -> bool:
+    """检查 session_id 是否是有效的聊天用户 session_id (仅限chat%前缀)"""
+    if not isinstance(session_id, str) or "%" not in session_id:
+        return False
+
+    parts = session_id.split("%")
+    return (
+        len(parts) == 2
+        and parts[0] == "chat"
+        and bool(parts[1])
+        and parts[1] != "unknown"
+    )
+
+
+def is_valid_room_session_id(session_id: Union[str, Any]) -> bool:
+    """检查 session_id 是否是有效的房间 session_id (仅限room%前缀)"""
+    if not isinstance(session_id, str) or "%" not in session_id:
+        return False
+
+    parts = session_id.split("%")
+    return (
+        len(parts) == 2
+        and parts[0] == "room"
+        and bool(parts[1])
+        and parts[1] != "unknown"
+    )
+
+
+def extract_user_id_from_session_id(session_id: str) -> str:
+    """从 session_id 中提取用户 ID"""
+    if "%" in session_id:
+        parts = session_id.split("%")
+        if len(parts) >= 2:
+            return parts[1]
+    return session_id
+
+
+def extract_room_id_from_session_id(session_id: str) -> str:
+    """从 session_id 中提取房间 ID"""
+    if "%" in session_id:
+        parts = session_id.split("%")
+        if len(parts) >= 2 and parts[0] == "room":
+            return parts[1]
+    return session_id
+
+
+def add_at_mention_if_needed(
+    text: str, user_info: Optional[Dict[str, Any]], has_at: bool = False
+) -> str:
+    """如果需要且没有@用户，则添加@用户"""
+    if has_at or not user_info:
+        return text
+
+    username = user_info.get("username")
+    nickname = user_info.get("nickname")
+
+    if username:
+        mention = f"@{username}"
+        if not text.startswith(mention):
+            text = f"{mention}\n{text}".strip()
+    elif nickname:
+        mention = f"@{nickname}"
+        if not text.startswith(mention):
+            text = f"{mention}\n{text}".strip()
+
+    return text
+
+
+def create_file_component(file_info: Dict[str, Any]) -> Tuple[Any, str]:
+    """创建文件组件和描述文本"""
+    file_url = file_info.get("url", "")
+    file_name = file_info.get("name", "未知文件")
+    file_type = file_info.get("type", "")
+
+    if file_type.startswith("image/"):
+        return Comp.Image(url=file_url, file=file_name), f"图片[{file_name}]"
+    elif file_type.startswith("audio/"):
+        return Comp.Record(url=file_url, file=file_name), f"音频[{file_name}]"
+    elif file_type.startswith("video/"):
+        return Comp.Video(url=file_url, file=file_name), f"视频[{file_name}]"
+    else:
+        return Comp.File(name=file_name, url=file_url), f"文件[{file_name}]"
+
+
+def process_files(
+    message: AstrBotMessage, files: list, include_text_parts: bool = True
+) -> list:
+    """处理文件列表，添加到消息组件中并返回文本描述"""
+    file_parts = []
+    for file_info in files:
+        component, part_text = create_file_component(file_info)
+        message.message.append(component)
+        if include_text_parts:
+            file_parts.append(part_text)
+    return file_parts
+
+
+def extract_sender_info(
+    raw_data: Dict[str, Any], is_chat: bool = False
+) -> Dict[str, Any]:
+    """提取发送者信息"""
+    if is_chat:
+        sender = raw_data.get("fromUser", {})
+        sender_id = str(sender.get("id", "") or raw_data.get("fromUserId", ""))
+    else:
+        sender = raw_data.get("user", {})
+        sender_id = str(sender.get("id", ""))
+
+    return {
+        "sender": sender,
+        "sender_id": sender_id,
+        "nickname": sender.get("name", sender.get("username", "")),
+        "username": sender.get("username", ""),
+    }
+
+
+def create_base_message(
+    raw_data: Dict[str, Any],
+    sender_info: Dict[str, Any],
+    client_self_id: str,
+    is_chat: bool = False,
+    room_id: Optional[str] = None,
+    unique_session: bool = False,
+) -> AstrBotMessage:
+    """创建基础消息对象"""
+    message = AstrBotMessage()
+    message.raw_message = raw_data
+    message.message = []
+
+    message.sender = MessageMember(
+        user_id=sender_info["sender_id"],
+        nickname=sender_info["nickname"],
+    )
+
+    if room_id:
+        session_prefix = "room"
+        session_id = f"{session_prefix}%{room_id}"
+        if unique_session:
+            session_id += f"_{sender_info['sender_id']}"
+        message.type = MessageType.GROUP_MESSAGE
+        message.group_id = room_id
+    elif is_chat:
+        session_prefix = "chat"
+        session_id = f"{session_prefix}%{sender_info['sender_id']}"
+        message.type = MessageType.FRIEND_MESSAGE
+    else:
+        session_prefix = "note"
+        session_id = f"{session_prefix}%{sender_info['sender_id']}"
+        message.type = MessageType.FRIEND_MESSAGE
+
+    message.session_id = (
+        session_id if sender_info["sender_id"] else f"{session_prefix}%unknown"
+    )
+    message.message_id = str(raw_data.get("id", ""))
+    message.self_id = client_self_id
+
+    return message
+
+
+def process_at_mention(
+    message: AstrBotMessage, raw_text: str, bot_username: str, client_self_id: str
+) -> Tuple[List[str], str]:
+    """处理@提及逻辑，返回消息部分列表和处理后的文本"""
+    message_parts = []
+
+    if not raw_text:
+        return message_parts, ""
+
+    if bot_username and raw_text.startswith(f"@{bot_username}"):
+        at_mention = f"@{bot_username}"
+        message.message.append(Comp.At(qq=client_self_id))
+        remaining_text = raw_text[len(at_mention) :].strip()
+        if remaining_text:
+            message.message.append(Comp.Plain(remaining_text))
+            message_parts.append(remaining_text)
+        return message_parts, remaining_text
+    else:
+        message.message.append(Comp.Plain(raw_text))
+        message_parts.append(raw_text)
+        return message_parts, raw_text
+
+
+def cache_user_info(
+    user_cache: Dict[str, Any],
+    sender_info: Dict[str, Any],
+    raw_data: Dict[str, Any],
+    client_self_id: str,
+    is_chat: bool = False,
+):
+    """缓存用户信息"""
+    if is_chat:
+        user_cache_data = {
+            "username": sender_info["username"],
+            "nickname": sender_info["nickname"],
+            "visibility": "specified",
+            "visible_user_ids": [client_self_id, sender_info["sender_id"]],
+        }
+    else:
+        user_cache_data = {
+            "username": sender_info["username"],
+            "nickname": sender_info["nickname"],
+            "visibility": raw_data.get("visibility", "public"),
+            "visible_user_ids": raw_data.get("visibleUserIds", []),
+        }
+
+    user_cache[sender_info["sender_id"]] = user_cache_data
+
+
+def cache_room_info(
+    user_cache: Dict[str, Any], raw_data: Dict[str, Any], client_self_id: str
+):
+    """缓存房间信息"""
+    room_data = raw_data.get("toRoom")
+    room_id = raw_data.get("toRoomId")
+
+    if room_data and room_id:
+        room_cache_key = f"room:{room_id}"
+        user_cache[room_cache_key] = {
+            "room_id": room_id,
+            "room_name": room_data.get("name", ""),
+            "room_description": room_data.get("description", ""),
+            "owner_id": room_data.get("ownerId", ""),
+            "visibility": "specified",
+            "visible_user_ids": [client_self_id],
+        }
--- a/astrbot/core/platform/sources/qqofficial/qqofficial_message_event.py
+++ b/astrbot/core/platform/sources/qqofficial/qqofficial_message_event.py
@@ -94,10 +94,15 @@ class QQOfficialMessageEvent(AstrMessageEvent):
            plain_text,
            image_base64,
            image_path,
-            record_file_path
+            record_file_path,
        ) = await QQOfficialMessageEvent._parse_to_qqofficial(self.send_buffer)

-        if not plain_text and not image_base64 and not image_path and not record_file_path:
+        if (
+            not plain_text
+            and not image_base64
+            and not image_path
+            and not record_file_path
+        ):
            return

        payload = {
@@ -118,7 +123,7 @@ class QQOfficialMessageEvent(AstrMessageEvent):
                    )
                    payload["media"] = media
                    payload["msg_type"] = 7
-                if record_file_path: # group record msg
+                if record_file_path:  # group record msg
                    media = await self.upload_group_and_c2c_record(
                        record_file_path, 3, group_openid=source.group_openid
                    )
@@ -134,9 +139,9 @@ class QQOfficialMessageEvent(AstrMessageEvent):
                    )
                    payload["media"] = media
                    payload["msg_type"] = 7
-                if record_file_path: # c2c record
+                if record_file_path:  # c2c record
                    media = await self.upload_group_and_c2c_record(
-                        record_file_path, 3, openid = source.author.user_openid
+                        record_file_path, 3, openid=source.author.user_openid
                    )
                    payload["media"] = media
                    payload["msg_type"] = 7
@@ -190,58 +195,55 @@ class QQOfficialMessageEvent(AstrMessageEvent):
            return await self.bot.api._http.request(route, json=payload)

    async def upload_group_and_c2c_record(
-        self, 
-        file_source: str, 
-        file_type: int, 
-        srv_send_msg: bool = False,
-        **kwargs
+        self, file_source: str, file_type: int, srv_send_msg: bool = False, **kwargs
    ) -> Optional[Media]:
        """
        上传媒体文件
        """
        # 构建基础payload
-        payload = {
-            "file_type": file_type,
-            "srv_send_msg": srv_send_msg
-        }
-        
+        payload = {"file_type": file_type, "srv_send_msg": srv_send_msg}
+
        # 处理文件数据
        if os.path.exists(file_source):
            # 读取本地文件
-            async with aiofiles.open(file_source, 'rb') as f:
+            async with aiofiles.open(file_source, "rb") as f:
                file_content = await f.read()
                # use base64 encode
-                payload["file_data"] = base64.b64encode(file_content).decode('utf-8')
+                payload["file_data"] = base64.b64encode(file_content).decode("utf-8")
        else:
            # 使用URL
            payload["url"] = file_source
-        
+
        # 添加接收者信息和确定路由
        if "openid" in kwargs:
            payload["openid"] = kwargs["openid"]
            route = Route("POST", "/v2/users/{openid}/files", openid=kwargs["openid"])
        elif "group_openid" in kwargs:
-            payload["group_openid"] =kwargs["group_openid"]
-            route = Route("POST", "/v2/groups/{group_openid}/files", group_openid=kwargs["group_openid"])
+            payload["group_openid"] = kwargs["group_openid"]
+            route = Route(
+                "POST",
+                "/v2/groups/{group_openid}/files",
+                group_openid=kwargs["group_openid"],
+            )
        else:
            return None
-        
+
        try:
            # 使用底层HTTP请求
            result = await self.bot.api._http.request(route, json=payload)
-            
+
            if result:
                return Media(
                    file_uuid=result.get("file_uuid"),
                    file_info=result.get("file_info"),
                    ttl=result.get("ttl", 0),
-                    file_id=result.get("id", "")
+                    file_id=result.get("id", ""),
                )
        except Exception as e:
            logger.error(f"上传请求错误: {e}")
-        
+
        return None
-    
+
    async def post_c2c_message(
        self,
        openid: str,
@@ -286,19 +288,23 @@ class QQOfficialMessageEvent(AstrMessageEvent):
                image_base64 = image_base64.removeprefix("base64://")
            elif isinstance(i, Record):
                if i.file:
-                    record_wav_path = await i.convert_to_file_path() # wav 路径
+                    record_wav_path = await i.convert_to_file_path()  # wav 路径
                    temp_dir = os.path.join(get_astrbot_data_path(), "temp")
-                    record_tecent_silk_path = os.path.join(temp_dir, f"{uuid.uuid4()}.silk")
+                    record_tecent_silk_path = os.path.join(
+                        temp_dir, f"{uuid.uuid4()}.silk"
+                    )
                    try:
-                        duration = await wav_to_tencent_silk(record_wav_path, record_tecent_silk_path)
+                        duration = await wav_to_tencent_silk(
+                            record_wav_path, record_tecent_silk_path
+                        )
                        if duration > 0:
                            record_file_path = record_tecent_silk_path
                        else:
-                            record_file_path = None                                 
+                            record_file_path = None
                            logger.error("转换音频格式时出错：音频时长不大于0")
                    except Exception as e:
                        logger.error(f"处理语音时出错: {e}")
-                        record_file_path = None                                     
+                        record_file_path = None
            else:
                logger.debug(f"qq_official 忽略 {i.type}")
        return plain_text, image_base64, image_file_path, record_file_path
--- a/astrbot/core/platform/sources/satori/satori_adapter.py
+++ b/astrbot/core/platform/sources/satori/satori_adapter.py
@@ -0,0 +1,748 @@
+import asyncio
+import json
+import time
+import websockets
+from websockets.asyncio.client import connect
+from typing import Optional
+from aiohttp import ClientSession, ClientTimeout
+from websockets.asyncio.client import ClientConnection
+from astrbot.api import logger
+from astrbot.api.event import MessageChain
+from astrbot.api.platform import (
+    AstrBotMessage,
+    MessageMember,
+    MessageType,
+    Platform,
+    PlatformMetadata,
+    register_platform_adapter,
+)
+from astrbot.core.platform.astr_message_event import MessageSession
+from astrbot.api.message_components import (
+    Plain,
+    Image,
+    At,
+    File,
+    Record,
+    Reply,
+)
+from xml.etree import ElementTree as ET
+
+
+@register_platform_adapter(
+    "satori",
+    "Satori 协议适配器",
+)
+class SatoriPlatformAdapter(Platform):
+    def __init__(
+        self, platform_config: dict, platform_settings: dict, event_queue: asyncio.Queue
+    ) -> None:
+        super().__init__(event_queue)
+        self.config = platform_config
+        self.settings = platform_settings
+
+        self.api_base_url = self.config.get(
+            "satori_api_base_url", "http://localhost:5140/satori/v1"
+        )
+        self.token = self.config.get("satori_token", "")
+        self.endpoint = self.config.get(
+            "satori_endpoint", "ws://localhost:5140/satori/v1/events"
+        )
+        self.auto_reconnect = self.config.get("satori_auto_reconnect", True)
+        self.heartbeat_interval = self.config.get("satori_heartbeat_interval", 10)
+        self.reconnect_delay = self.config.get("satori_reconnect_delay", 5)
+
+        self.metadata = PlatformMetadata(
+            name="satori",
+            description="Satori 通用协议适配器",
+            id=self.config["id"],
+        )
+
+        self.ws: Optional[ClientConnection] = None
+        self.session: Optional[ClientSession] = None
+        self.sequence = 0
+        self.logins = []
+        self.running = False
+        self.heartbeat_task: Optional[asyncio.Task] = None
+        self.ready_received = False
+
+    async def send_by_session(
+        self, session: MessageSession, message_chain: MessageChain
+    ):
+        from .satori_event import SatoriPlatformEvent
+
+        await SatoriPlatformEvent.send_with_adapter(
+            self, message_chain, session.session_id
+        )
+        await super().send_by_session(session, message_chain)
+
+    def meta(self) -> PlatformMetadata:
+        return self.metadata
+
+    def _is_websocket_closed(self, ws) -> bool:
+        """检查WebSocket连接是否已关闭"""
+        if not ws:
+            return True
+        try:
+            if hasattr(ws, "closed"):
+                return ws.closed
+            elif hasattr(ws, "close_code"):
+                return ws.close_code is not None
+            else:
+                return False
+        except AttributeError:
+            return False
+
+    async def run(self):
+        self.running = True
+        self.session = ClientSession(timeout=ClientTimeout(total=30))
+
+        retry_count = 0
+        max_retries = 10
+
+        while self.running:
+            try:
+                await self.connect_websocket()
+                retry_count = 0
+            except websockets.exceptions.ConnectionClosed as e:
+                logger.warning(f"Satori WebSocket 连接关闭: {e}")
+                retry_count += 1
+            except Exception as e:
+                logger.error(f"Satori WebSocket 连接失败: {e}")
+                retry_count += 1
+
+            if not self.running:
+                break
+
+            if retry_count >= max_retries:
+                logger.error(f"达到最大重试次数 ({max_retries})，停止重试")
+                break
+
+            if not self.auto_reconnect:
+                break
+
+            delay = min(self.reconnect_delay * (2 ** (retry_count - 1)), 60)
+            await asyncio.sleep(delay)
+
+        if self.session:
+            await self.session.close()
+
+    async def connect_websocket(self):
+        logger.info(f"Satori 适配器正在连接到 WebSocket: {self.endpoint}")
+        logger.info(f"Satori 适配器 HTTP API 地址: {self.api_base_url}")
+
+        if not self.endpoint.startswith(("ws://", "wss://")):
+            logger.error(f"无效的WebSocket URL: {self.endpoint}")
+            raise ValueError(f"WebSocket URL必须以ws://或wss://开头: {self.endpoint}")
+
+        try:
+            websocket = await connect(self.endpoint, additional_headers={})
+            self.ws = websocket
+
+            await asyncio.sleep(0.1)
+
+            await self.send_identify()
+
+            self.heartbeat_task = asyncio.create_task(self.heartbeat_loop())
+
+            async for message in websocket:
+                try:
+                    await self.handle_message(message)  # type: ignore
+                except Exception as e:
+                    logger.error(f"Satori 处理消息异常: {e}")
+
+        except websockets.exceptions.ConnectionClosed as e:
+            logger.warning(f"Satori WebSocket 连接关闭: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Satori WebSocket 连接异常: {e}")
+            raise
+        finally:
+            if self.heartbeat_task:
+                self.heartbeat_task.cancel()
+                try:
+                    await self.heartbeat_task
+                except asyncio.CancelledError:
+                    pass
+            if self.ws:
+                try:
+                    await self.ws.close()
+                except Exception as e:
+                    logger.error(f"Satori WebSocket 关闭异常: {e}")
+
+    async def send_identify(self):
+        if not self.ws:
+            raise Exception("WebSocket连接未建立")
+
+        if self._is_websocket_closed(self.ws):
+            raise Exception("WebSocket连接已关闭")
+
+        identify_payload = {
+            "op": 3,  # IDENTIFY
+            "body": {
+                "token": str(self.token) if self.token else "",  # 字符串
+            },
+        }
+
+        # 只有在有序列号时才添加sn字段
+        if self.sequence > 0:
+            identify_payload["body"]["sn"] = self.sequence
+
+        try:
+            message_str = json.dumps(identify_payload, ensure_ascii=False)
+            await self.ws.send(message_str)
+        except websockets.exceptions.ConnectionClosed as e:
+            logger.error(f"发送 IDENTIFY 信令时连接关闭: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"发送 IDENTIFY 信令失败: {e}")
+            raise
+
+    async def heartbeat_loop(self):
+        try:
+            while self.running and self.ws:
+                await asyncio.sleep(self.heartbeat_interval)
+
+                if self.ws and not self._is_websocket_closed(self.ws):
+                    try:
+                        ping_payload = {
+                            "op": 1,  # PING
+                            "body": {},
+                        }
+                        await self.ws.send(json.dumps(ping_payload, ensure_ascii=False))
+                    except websockets.exceptions.ConnectionClosed as e:
+                        logger.error(f"Satori WebSocket 连接关闭: {e}")
+                        break
+                    except Exception as e:
+                        logger.error(f"Satori WebSocket 发送心跳失败: {e}")
+                        break
+                else:
+                    break
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logger.error(f"心跳任务异常: {e}")
+
+    async def handle_message(self, message: str):
+        try:
+            data = json.loads(message)
+            op = data.get("op")
+            body = data.get("body", {})
+
+            if op == 4:  # READY
+                self.logins = body.get("logins", [])
+                self.ready_received = True
+
+                # 输出连接成功的bot信息
+                if self.logins:
+                    for i, login in enumerate(self.logins):
+                        platform = login.get("platform", "")
+                        user = login.get("user", {})
+                        user_id = user.get("id", "")
+                        user_name = user.get("name", "")
+                        logger.info(
+                            f"Satori 连接成功 - Bot {i + 1}: platform={platform}, user_id={user_id}, user_name={user_name}"
+                        )
+
+                if "sn" in body:
+                    self.sequence = body["sn"]
+
+            elif op == 2:  # PONG
+                pass
+
+            elif op == 0:  # EVENT
+                await self.handle_event(body)
+                if "sn" in body:
+                    self.sequence = body["sn"]
+
+            elif op == 5:  # META
+                if "sn" in body:
+                    self.sequence = body["sn"]
+
+        except json.JSONDecodeError as e:
+            logger.error(f"解析 WebSocket 消息失败: {e}, 消息内容: {message}")
+        except Exception as e:
+            logger.error(f"处理 WebSocket 消息异常: {e}")
+
+    async def handle_event(self, event_data: dict):
+        try:
+            event_type = event_data.get("type")
+            sn = event_data.get("sn")
+            if sn:
+                self.sequence = sn
+
+            if event_type == "message-created":
+                message = event_data.get("message", {})
+                user = event_data.get("user", {})
+                channel = event_data.get("channel", {})
+                guild = event_data.get("guild")
+                login = event_data.get("login", {})
+                timestamp = event_data.get("timestamp")
+
+                if user.get("id") == login.get("user", {}).get("id"):
+                    return
+
+                abm = await self.convert_satori_message(
+                    message, user, channel, guild, login, timestamp
+                )
+                if abm:
+                    await self.handle_msg(abm)
+
+        except Exception as e:
+            logger.error(f"处理事件失败: {e}")
+
+    async def convert_satori_message(
+        self,
+        message: dict,
+        user: dict,
+        channel: dict,
+        guild: Optional[dict],
+        login: dict,
+        timestamp: Optional[int] = None,
+    ) -> Optional[AstrBotMessage]:
+        try:
+            abm = AstrBotMessage()
+            abm.message_id = message.get("id", "")
+            abm.raw_message = {
+                "message": message,
+                "user": user,
+                "channel": channel,
+                "guild": guild,
+                "login": login,
+            }
+
+            if guild and guild.get("id"):
+                abm.type = MessageType.GROUP_MESSAGE
+                abm.group_id = guild.get("id", "")
+                abm.session_id = channel.get("id", "")
+            else:
+                abm.type = MessageType.FRIEND_MESSAGE
+                abm.session_id = channel.get("id", "")
+
+            abm.sender = MessageMember(
+                user_id=user.get("id", ""),
+                nickname=user.get("nick", user.get("name", "")),
+            )
+
+            abm.self_id = login.get("user", {}).get("id", "")
+
+            # 消息链
+            abm.message = []
+
+            content = message.get("content", "")
+
+            quote = message.get("quote")
+            content_for_parsing = content  # 副本
+
+            # 提取<quote>标签
+            if "<quote" in content:
+                try:
+                    quote_info = await self._extract_quote_element(content)
+                    if quote_info:
+                        quote = quote_info["quote"]
+                        content_for_parsing = quote_info["content_without_quote"]
+                except Exception as e:
+                    logger.error(f"解析<quote>标签时发生错误: {e}, 错误内容: {content}")
+
+            if quote:
+                # 引用消息
+                quote_abm = await self._convert_quote_message(quote)
+                if quote_abm:
+                    sender_id = quote_abm.sender.user_id
+                    if isinstance(sender_id, str) and sender_id.isdigit():
+                        sender_id = int(sender_id)
+                    elif not isinstance(sender_id, int):
+                        sender_id = 0  # 默认值
+
+                    reply_component = Reply(
+                        id=quote_abm.message_id,
+                        chain=quote_abm.message,
+                        sender_id=quote_abm.sender.user_id,
+                        sender_nickname=quote_abm.sender.nickname,
+                        time=quote_abm.timestamp,
+                        message_str=quote_abm.message_str,
+                        text=quote_abm.message_str,
+                        qq=sender_id,
+                    )
+                    abm.message.append(reply_component)
+
+            # 解析消息内容
+            content_elements = await self.parse_satori_elements(content_for_parsing)
+            abm.message.extend(content_elements)
+
+            abm.message_str = ""
+            for comp in content_elements:
+                if isinstance(comp, Plain):
+                    abm.message_str += comp.text
+
+            # 优先使用Satori事件中的时间戳
+            if timestamp is not None:
+                abm.timestamp = timestamp
+            else:
+                abm.timestamp = int(time.time())
+
+            return abm
+
+        except Exception as e:
+            logger.error(f"转换 Satori 消息失败: {e}")
+            return None
+
+    def _extract_namespace_prefixes(self, content: str) -> set:
+        """提取XML内容中的命名空间前缀"""
+        prefixes = set()
+
+        # 查找所有标签
+        i = 0
+        while i < len(content):
+            # 查找开始标签
+            if content[i] == "<" and i + 1 < len(content) and content[i + 1] != "/":
+                # 找到标签结束位置
+                tag_end = content.find(">", i)
+                if tag_end != -1:
+                    # 提取标签内容
+                    tag_content = content[i + 1 : tag_end]
+                    # 检查是否有命名空间前缀
+                    if ":" in tag_content and "xmlns:" not in tag_content:
+                        # 分割标签名
+                        parts = tag_content.split()
+                        if parts:
+                            tag_name = parts[0]
+                            if ":" in tag_name:
+                                prefix = tag_name.split(":")[0]
+                                # 确保是有效的命名空间前缀
+                                if (
+                                    prefix.isalnum()
+                                    or prefix.replace("_", "").isalnum()
+                                ):
+                                    prefixes.add(prefix)
+                    i = tag_end + 1
+                else:
+                    i += 1
+            # 查找结束标签
+            elif content[i] == "<" and i + 1 < len(content) and content[i + 1] == "/":
+                # 找到标签结束位置
+                tag_end = content.find(">", i)
+                if tag_end != -1:
+                    # 提取标签内容
+                    tag_content = content[i + 2 : tag_end]
+                    # 检查是否有命名空间前缀
+                    if ":" in tag_content:
+                        prefix = tag_content.split(":")[0]
+                        # 确保是有效的命名空间前缀
+                        if prefix.isalnum() or prefix.replace("_", "").isalnum():
+                            prefixes.add(prefix)
+                    i = tag_end + 1
+                else:
+                    i += 1
+            else:
+                i += 1
+
+        return prefixes
+
+    async def _extract_quote_element(self, content: str) -> Optional[dict]:
+        """提取<quote>标签信息"""
+        try:
+            # 处理命名空间前缀问题
+            processed_content = content
+            if ":" in content and not content.startswith("<root"):
+                prefixes = self._extract_namespace_prefixes(content)
+
+                # 构建命名空间声明
+                ns_declarations = " ".join(
+                    [
+                        f'xmlns:{prefix}="http://temp.uri/{prefix}"'
+                        for prefix in prefixes
+                    ]
+                )
+
+                # 包装内容
+                processed_content = f"<root {ns_declarations}>{content}</root>"
+            elif not content.startswith("<root"):
+                processed_content = f"<root>{content}</root>"
+            else:
+                processed_content = content
+
+            root = ET.fromstring(processed_content)
+
+            # 查找<quote>标签
+            quote_element = None
+            for elem in root.iter():
+                tag_name = elem.tag
+                if "}" in tag_name:
+                    tag_name = tag_name.split("}")[1]
+                if tag_name.lower() == "quote":
+                    quote_element = elem
+                    break
+
+            if quote_element is not None:
+                # 提取quote标签的属性
+                quote_id = quote_element.get("id", "")
+
+                # 提取<quote>标签内部的内容
+                inner_content = ""
+                if quote_element.text:
+                    inner_content += quote_element.text
+                for child in quote_element:
+                    inner_content += ET.tostring(
+                        child, encoding="unicode", method="xml"
+                    )
+                    if child.tail:
+                        inner_content += child.tail
+
+                # 构造移除了<quote>标签的内容
+                content_without_quote = content.replace(
+                    ET.tostring(quote_element, encoding="unicode", method="xml"), ""
+                )
+
+                return {
+                    "quote": {"id": quote_id, "content": inner_content},
+                    "content_without_quote": content_without_quote,
+                }
+
+            return None
+        except Exception as e:
+            logger.error(f"提取<quote>标签时发生错误: {e}")
+            return None
+
+    async def _convert_quote_message(self, quote: dict) -> Optional[AstrBotMessage]:
+        """转换引用消息"""
+        try:
+            quote_abm = AstrBotMessage()
+            quote_abm.message_id = quote.get("id", "")
+
+            # 解析引用消息的发送者
+            quote_author = quote.get("author", {})
+            if quote_author:
+                quote_abm.sender = MessageMember(
+                    user_id=quote_author.get("id", ""),
+                    nickname=quote_author.get("nick", quote_author.get("name", "")),
+                )
+            else:
+                # 如果没有作者信息，使用默认值
+                quote_abm.sender = MessageMember(
+                    user_id=quote.get("user_id", ""),
+                    nickname="内容",
+                )
+
+            # 解析引用消息内容
+            quote_content = quote.get("content", "")
+            quote_abm.message = await self.parse_satori_elements(quote_content)
+
+            quote_abm.message_str = ""
+            for comp in quote_abm.message:
+                if isinstance(comp, Plain):
+                    quote_abm.message_str += comp.text
+
+            quote_abm.timestamp = int(quote.get("timestamp", time.time()))
+
+            # 如果没有任何内容，使用默认文本
+            if not quote_abm.message_str.strip():
+                quote_abm.message_str = "[引用消息]"
+
+            return quote_abm
+        except Exception as e:
+            logger.error(f"转换引用消息失败: {e}")
+            return None
+
+    async def parse_satori_elements(self, content: str) -> list:
+        """解析 Satori 消息元素"""
+        elements = []
+
+        if not content:
+            return elements
+
+        try:
+            # 处理命名空间前缀问题
+            processed_content = content
+            if ":" in content and not content.startswith("<root"):
+                prefixes = self._extract_namespace_prefixes(content)
+
+                # 构建命名空间声明
+                ns_declarations = " ".join(
+                    [
+                        f'xmlns:{prefix}="http://temp.uri/{prefix}"'
+                        for prefix in prefixes
+                    ]
+                )
+
+                # 包装内容
+                processed_content = f"<root {ns_declarations}>{content}</root>"
+            elif not content.startswith("<root"):
+                processed_content = f"<root>{content}</root>"
+            else:
+                processed_content = content
+
+            root = ET.fromstring(processed_content)
+            await self._parse_xml_node(root, elements)
+        except ET.ParseError as e:
+            logger.error(f"解析 Satori 元素时发生解析错误: {e}, 错误内容: {content}")
+            # 如果解析失败，将整个内容当作纯文本
+            if content.strip():
+                elements.append(Plain(text=content))
+        except Exception as e:
+            logger.error(f"解析 Satori 元素时发生未知错误: {e}")
+            raise e
+
+        # 如果没有解析到任何元素，将整个内容当作纯文本
+        if not elements and content.strip():
+            elements.append(Plain(text=content))
+
+        return elements
+
+    async def _parse_xml_node(self, node: ET.Element, elements: list) -> None:
+        """递归解析 XML 节点"""
+        if node.text and node.text.strip():
+            elements.append(Plain(text=node.text))
+
+        for child in node:
+            # 获取标签名，去除命名空间前缀
+            tag_name = child.tag
+            if "}" in tag_name:
+                tag_name = tag_name.split("}")[1]
+            tag_name = tag_name.lower()
+
+            attrs = child.attrib
+
+            if tag_name == "at":
+                user_id = attrs.get("id") or attrs.get("name", "")
+                elements.append(At(qq=user_id, name=user_id))
+
+            elif tag_name in ("img", "image"):
+                src = attrs.get("src", "")
+                if not src:
+                    continue
+                elements.append(Image(file=src))
+
+            elif tag_name == "file":
+                src = attrs.get("src", "")
+                name = attrs.get("name", "文件")
+                if src:
+                    elements.append(File(name=name, file=src))
+
+            elif tag_name in ("audio", "record"):
+                src = attrs.get("src", "")
+                if not src:
+                    continue
+                elements.append(Record(file=src))
+
+            elif tag_name == "quote":
+                # quote标签已经被特殊处理
+                pass
+
+            elif tag_name == "face":
+                face_id = attrs.get("id", "")
+                face_name = attrs.get("name", "")
+                face_type = attrs.get("type", "")
+
+                if face_name:
+                    elements.append(Plain(text=f"[表情:{face_name}]"))
+                elif face_id and face_type:
+                    elements.append(Plain(text=f"[表情ID:{face_id},类型:{face_type}]"))
+                elif face_id:
+                    elements.append(Plain(text=f"[表情ID:{face_id}]"))
+                else:
+                    elements.append(Plain(text="[表情]"))
+
+            elif tag_name == "ark":
+                # 作为纯文本添加到消息链中
+                data = attrs.get("data", "")
+                if data:
+                    import html
+
+                    decoded_data = html.unescape(data)
+                    elements.append(Plain(text=f"[ARK卡片数据: {decoded_data}]"))
+                else:
+                    elements.append(Plain(text="[ARK卡片]"))
+
+            elif tag_name == "json":
+                # JSON标签 视为ARK卡片消息
+                data = attrs.get("data", "")
+                if data:
+                    import html
+
+                    decoded_data = html.unescape(data)
+                    elements.append(Plain(text=f"[ARK卡片数据: {decoded_data}]"))
+                else:
+                    elements.append(Plain(text="[JSON卡片]"))
+
+            else:
+                # 未知标签，递归处理其内容
+                if child.text and child.text.strip():
+                    elements.append(Plain(text=child.text))
+                await self._parse_xml_node(child, elements)
+
+            # 处理标签后的文本
+            if child.tail and child.tail.strip():
+                elements.append(Plain(text=child.tail))
+
+    async def handle_msg(self, message: AstrBotMessage):
+        from .satori_event import SatoriPlatformEvent
+
+        message_event = SatoriPlatformEvent(
+            message_str=message.message_str,
+            message_obj=message,
+            platform_meta=self.meta(),
+            session_id=message.session_id,
+            adapter=self,
+        )
+        self.commit_event(message_event)
+
+    async def send_http_request(
+        self,
+        method: str,
+        path: str,
+        data: dict | None = None,
+        platform: str | None = None,
+        user_id: str | None = None,
+    ) -> dict:
+        if not self.session:
+            raise Exception("HTTP session 未初始化")
+
+        headers = {
+            "Content-Type": "application/json",
+        }
+
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+
+        if platform and user_id:
+            headers["satori-platform"] = platform
+            headers["satori-user-id"] = user_id
+        elif self.logins:
+            current_login = self.logins[0]
+            headers["satori-platform"] = current_login.get("platform", "")
+            user = current_login.get("user", {})
+            headers["satori-user-id"] = user.get("id", "") if user else ""
+
+        if not path.startswith("/"):
+            path = "/" + path
+
+        # 使用新的API地址配置
+        url = f"{self.api_base_url.rstrip('/')}{path}"
+
+        try:
+            async with self.session.request(
+                method, url, json=data, headers=headers
+            ) as response:
+                if response.status == 200:
+                    result = await response.json()
+                    return result
+                else:
+                    return {}
+        except Exception as e:
+            logger.error(f"Satori HTTP 请求异常: {e}")
+            return {}
+
+    async def terminate(self):
+        self.running = False
+
+        if self.heartbeat_task:
+            self.heartbeat_task.cancel()
+
+        if self.ws:
+            try:
+                await self.ws.close()
+            except Exception as e:
+                logger.error(f"Satori WebSocket 关闭异常: {e}")
+
+        if self.session:
+            await self.session.close()
--- a/astrbot/core/platform/sources/satori/satori_event.py
+++ b/astrbot/core/platform/sources/satori/satori_event.py
@@ -0,0 +1,230 @@
+from typing import TYPE_CHECKING
+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, At, File, Record
+
+if TYPE_CHECKING:
+    from .satori_adapter import SatoriPlatformAdapter
+
+
+class SatoriPlatformEvent(AstrMessageEvent):
+    def __init__(
+        self,
+        message_str: str,
+        message_obj: AstrBotMessage,
+        platform_meta: PlatformMetadata,
+        session_id: str,
+        adapter: "SatoriPlatformAdapter",
+    ):
+        # 更新平台元数据
+        if adapter and hasattr(adapter, "logins") and adapter.logins:
+            current_login = adapter.logins[0]
+            platform_name = current_login.get("platform", "satori")
+            user = current_login.get("user", {})
+            user_id = user.get("id", "") if user else ""
+            if not platform_meta.id and user_id:
+                platform_meta.id = f"{platform_name}({user_id})"
+
+        super().__init__(message_str, message_obj, platform_meta, session_id)
+        self.adapter = adapter
+        self.platform = None
+        self.user_id = None
+        if (
+            hasattr(message_obj, "raw_message")
+            and message_obj.raw_message
+            and isinstance(message_obj.raw_message, dict)
+        ):
+            login = message_obj.raw_message.get("login", {})
+            self.platform = login.get("platform")
+            user = login.get("user", {})
+            self.user_id = user.get("id") if user else None
+
+    @classmethod
+    async def send_with_adapter(
+        cls, adapter: "SatoriPlatformAdapter", message: MessageChain, session_id: str
+    ):
+        try:
+            content_parts = []
+
+            for component in message.chain:
+                if isinstance(component, Plain):
+                    text = (
+                        component.text.replace("&", "&amp;")
+                        .replace("<", "&lt;")
+                        .replace(">", "&gt;")
+                    )
+                    content_parts.append(text)
+
+                elif isinstance(component, At):
+                    if component.qq:
+                        content_parts.append(f'<at id="{component.qq}"/>')
+                    elif component.name:
+                        content_parts.append(f'<at name="{component.name}"/>')
+
+                elif isinstance(component, Image):
+                    try:
+                        image_base64 = await component.convert_to_base64()
+                        if image_base64:
+                            content_parts.append(
+                                f'<img src="data:image/jpeg;base64,{image_base64}"/>'
+                            )
+                    except Exception as e:
+                        logger.error(f"图片转换为base64失败: {e}")
+
+                elif isinstance(component, File):
+                    content_parts.append(
+                        f'<file src="{component.file}" name="{component.name or "文件"}"/>'
+                    )
+
+                elif isinstance(component, Record):
+                    try:
+                        record_base64 = await component.convert_to_base64()
+                        if record_base64:
+                            content_parts.append(
+                                f'<audio src="data:audio/wav;base64,{record_base64}"/>'
+                            )
+                    except Exception as e:
+                        logger.error(f"语音转换为base64失败: {e}")
+
+            content = "".join(content_parts)
+            channel_id = session_id
+            data = {"channel_id": channel_id, "content": content}
+
+            platform = None
+            user_id = None
+
+            if hasattr(adapter, "logins") and adapter.logins:
+                current_login = adapter.logins[0]
+                platform = current_login.get("platform", "")
+                user = current_login.get("user", {})
+                user_id = user.get("id", "") if user else ""
+
+            result = await adapter.send_http_request(
+                "POST", "/message.create", data, platform, user_id
+            )
+            if result:
+                return result
+            else:
+                return None
+
+        except Exception as e:
+            logger.error(f"Satori 消息发送异常: {e}")
+            return None
+
+    async def send(self, message: MessageChain):
+        platform = getattr(self, "platform", None)
+        user_id = getattr(self, "user_id", None)
+
+        if not platform or not user_id:
+            if hasattr(self.adapter, "logins") and self.adapter.logins:
+                current_login = self.adapter.logins[0]
+                platform = current_login.get("platform", "")
+                user = current_login.get("user", {})
+                user_id = user.get("id", "") if user else ""
+
+        try:
+            content_parts = []
+
+            for component in message.chain:
+                if isinstance(component, Plain):
+                    text = (
+                        component.text.replace("&", "&amp;")
+                        .replace("<", "&lt;")
+                        .replace(">", "&gt;")
+                    )
+                    content_parts.append(text)
+
+                elif isinstance(component, At):
+                    if component.qq:
+                        content_parts.append(f'<at id="{component.qq}"/>')
+                    elif component.name:
+                        content_parts.append(f'<at name="{component.name}"/>')
+
+                elif isinstance(component, Image):
+                    try:
+                        image_base64 = await component.convert_to_base64()
+                        if image_base64:
+                            content_parts.append(
+                                f'<img src="data:image/jpeg;base64,{image_base64}"/>'
+                            )
+                    except Exception as e:
+                        logger.error(f"图片转换为base64失败: {e}")
+
+                elif isinstance(component, File):
+                    content_parts.append(
+                        f'<file src="{component.file}" name="{component.name or "文件"}"/>'
+                    )
+
+                elif isinstance(component, Record):
+                    try:
+                        record_base64 = await component.convert_to_base64()
+                        if record_base64:
+                            content_parts.append(
+                                f'<audio src="data:audio/wav;base64,{record_base64}"/>'
+                            )
+                    except Exception as e:
+                        logger.error(f"语音转换为base64失败: {e}")
+
+            content = "".join(content_parts)
+            channel_id = self.session_id
+            data = {"channel_id": channel_id, "content": content}
+
+            result = await self.adapter.send_http_request(
+                "POST", "/message.create", data, platform, user_id
+            )
+            if not result:
+                logger.error("Satori 消息发送失败")
+        except Exception as e:
+            logger.error(f"Satori 消息发送异常: {e}")
+
+        await super().send(message)
+
+    async def send_streaming(self, generator, use_fallback: bool = False):
+        try:
+            content_parts = []
+
+            async for chain in generator:
+                if isinstance(chain, MessageChain):
+                    if chain.type == "break":
+                        if content_parts:
+                            content = "".join(content_parts)
+                            temp_chain = MessageChain([Plain(text=content)])
+                            await self.send(temp_chain)
+                            content_parts = []
+                        continue
+
+                    for component in chain.chain:
+                        if isinstance(component, Plain):
+                            content_parts.append(component.text)
+                        elif isinstance(component, Image):
+                            if content_parts:
+                                content = "".join(content_parts)
+                                temp_chain = MessageChain([Plain(text=content)])
+                                await self.send(temp_chain)
+                                content_parts = []
+                            try:
+                                image_base64 = await component.convert_to_base64()
+                                if image_base64:
+                                    img_chain = MessageChain(
+                                        [
+                                            Plain(
+                                                text=f'<img src="data:image/jpeg;base64,{image_base64}"/>'
+                                            )
+                                        ]
+                                    )
+                                    await self.send(img_chain)
+                            except Exception as e:
+                                logger.error(f"图片转换为base64失败: {e}")
+                        else:
+                            content_parts.append(str(component))
+
+            if content_parts:
+                content = "".join(content_parts)
+                temp_chain = MessageChain([Plain(text=content)])
+                await self.send(temp_chain)
+
+        except Exception as e:
+            logger.error(f"Satori 流式消息发送异常: {e}")
+
+        return await super().send_streaming(generator, use_fallback)
--- a/astrbot/core/platform/sources/slack/slack_adapter.py
+++ b/astrbot/core/platform/sources/slack/slack_adapter.py
@@ -308,7 +308,9 @@ class SlackAdapter(Platform):
                    base64_content = base64.b64encode(content).decode("utf-8")
                    return base64_content
                else:
-                    logger.error(f"Failed to download slack file: {resp.status} {await resp.text()}")
+                    logger.error(
+                        f"Failed to download slack file: {resp.status} {await resp.text()}"
+                    )
                    raise Exception(f"下载文件失败: {resp.status}")

    async def run(self) -> Awaitable[Any]:
--- a/astrbot/core/platform/sources/slack/slack_event.py
+++ b/astrbot/core/platform/sources/slack/slack_event.py
@@ -75,7 +75,13 @@ class SlackMessageEvent(AstrMessageEvent):
                    "text": {"type": "mrkdwn", "text": "文件上传失败"},
                }
            file_url = response["files"][0]["permalink"]
-            return {"type": "section", "text": {"type": "mrkdwn", "text": f"文件: <{file_url}|{segment.name or '文件'}>"}}
+            return {
+                "type": "section",
+                "text": {
+                    "type": "mrkdwn",
+                    "text": f"文件: <{file_url}|{segment.name or '文件'}>",
+                },
+            }
        else:
            return {"type": "section", "text": {"type": "mrkdwn", "text": str(segment)}}

--- a/astrbot/core/platform/sources/telegram/tg_adapter.py
+++ b/astrbot/core/platform/sources/telegram/tg_adapter.py
@@ -183,7 +183,6 @@ class TelegramPlatformAdapter(Platform):
            return None

        if not re.match(r"^[a-z0-9_]+$", cmd_name) or len(cmd_name) > 32:
-            logger.debug(f"跳过无法注册的命令: {cmd_name}")
            return None

        # Build description.
--- a/astrbot/core/platform/sources/telegram/tg_event.py
+++ b/astrbot/core/platform/sources/telegram/tg_event.py
@@ -66,7 +66,9 @@ class TelegramPlatformEvent(AstrMessageEvent):
        return chunks

    @classmethod
-    async def send_with_client(cls, client: ExtBot, message: MessageChain, user_name: str):
+    async def send_with_client(
+        cls, client: ExtBot, message: MessageChain, user_name: str
+    ):
        image_path = None

        has_reply = False
@@ -216,7 +218,6 @@ class TelegramPlatformEvent(AstrMessageEvent):
                    try:
                        msg = await self.client.send_message(text=delta, **payload)
                        current_content = delta
-                        delta = ""
                    except Exception as e:
                        logger.warning(f"发送消息失败(streaming): {e!s}")
                    message_id = msg.message_id
--- a/astrbot/core/platform/sources/webchat/webchat_queue_mgr.py
+++ b/astrbot/core/platform/sources/webchat/webchat_queue_mgr.py
@@ -1,5 +1,6 @@
 import asyncio

+
 class WebChatQueueMgr:
    def __init__(self) -> None:
        self.queues = {}
@@ -30,4 +31,5 @@ class WebChatQueueMgr:
        """Check if a queue exists for the given conversation ID"""
        return conversation_id in self.queues

+
 webchat_queue_mgr = WebChatQueueMgr()
--- a/astrbot/core/platform/sources/wechatpadpro/wechatpadpro_adapter.py
+++ b/astrbot/core/platform/sources/wechatpadpro/wechatpadpro_adapter.py
@@ -213,10 +213,10 @@ class WeChatPadProAdapter(Platform):
    def _extract_auth_key(self, data):
        """Helper method to extract auth_key from response data."""
        if isinstance(data, dict):
-            auth_keys = data.get("authKeys") # 新接口
+            auth_keys = data.get("authKeys")  # 新接口
            if isinstance(auth_keys, list) and auth_keys:
                return auth_keys[0]
-        elif isinstance(data, list) and data: # 旧接口
+        elif isinstance(data, list) and data:  # 旧接口
            return data[0]
        return None

@@ -234,7 +234,9 @@ class WeChatPadProAdapter(Platform):
            try:
                async with session.post(url, params=params, json=payload) as response:
                    if response.status != 200:
-                        logger.error(f"生成授权码失败: {response.status}, {await response.text()}")
+                        logger.error(
+                            f"生成授权码失败: {response.status}, {await response.text()}"
+                        )
                        return

                    response_data = await response.json()
@@ -245,7 +247,9 @@ class WeChatPadProAdapter(Platform):
                        if self.auth_key:
                            logger.info("成功获取授权码")
                        else:
-                            logger.error(f"生成授权码成功但未找到授权码: {response_data}")
+                            logger.error(
+                                f"生成授权码成功但未找到授权码: {response_data}"
+                            )
                    else:
                        logger.error(f"生成授权码失败: {response_data}")
            except aiohttp.ClientConnectorError as e:
--- a/astrbot/core/platform/sources/wecom/wecom_kf.py
+++ b/astrbot/core/platform/sources/wecom/wecom_kf.py
@@ -48,7 +48,12 @@ class WeChatKF(BaseWeChatAPI):
        注意：可能会出现返回条数少于limit的情况，需结合返回的has_more字段判断是否继续请求。
        :return: 接口调用结果
        """
-        data = {"token": token, "cursor": cursor, "limit": limit, "open_kfid": open_kfid}
+        data = {
+            "token": token,
+            "cursor": cursor,
+            "limit": limit,
+            "open_kfid": open_kfid,
+        }
        return self._post("kf/sync_msg", data=data)

    def get_service_state(self, open_kfid, external_userid):
@@ -72,7 +77,9 @@ class WeChatKF(BaseWeChatAPI):
        }
        return self._post("kf/service_state/get", data=data)

-    def trans_service_state(self, open_kfid, external_userid, service_state, servicer_userid=""):
+    def trans_service_state(
+        self, open_kfid, external_userid, service_state, servicer_userid=""
+    ):
        """
        变更会话状态

@@ -180,7 +187,9 @@ class WeChatKF(BaseWeChatAPI):
        """
        return self._get("kf/customer/get_upgrade_service_config")

-    def upgrade_service(self, open_kfid, external_userid, service_type, member=None, groupchat=None):
+    def upgrade_service(
+        self, open_kfid, external_userid, service_type, member=None, groupchat=None
+    ):
        """
        为客户升级为专员或客户群服务

@@ -246,7 +255,9 @@ class WeChatKF(BaseWeChatAPI):
        data = {"open_kfid": open_kfid, "start_time": start_time, "end_time": end_time}
        return self._post("kf/get_corp_statistic", data=data)

-    def get_servicer_statistic(self, start_time, end_time, open_kfid=None, servicer_userid=None):
+    def get_servicer_statistic(
+        self, start_time, end_time, open_kfid=None, servicer_userid=None
+    ):
        """
        获取「客户数据统计」接待人员明细数据

--- a/astrbot/core/platform/sources/wecom/wecom_kf_message.py
+++ b/astrbot/core/platform/sources/wecom/wecom_kf_message.py
@@ -26,6 +26,7 @@ from optionaldict import optionaldict

 from wechatpy.client.api.base import BaseWeChatAPI

+
 class WeChatKFMessage(BaseWeChatAPI):
    """
    发送微信客服消息
@@ -125,35 +126,55 @@ class WeChatKFMessage(BaseWeChatAPI):
            msg={"msgtype": "news", "link": {"link": articles_data}},
        )

-    def send_msgmenu(self, user_id, open_kfid, head_content, menu_list, tail_content, msgid=""):
+    def send_msgmenu(
+        self, user_id, open_kfid, head_content, menu_list, tail_content, msgid=""
+    ):
        return self.send(
            user_id,
            open_kfid,
            msgid,
            msg={
                "msgtype": "msgmenu",
-                "msgmenu": {"head_content": head_content, "list": menu_list, "tail_content": tail_content},
+                "msgmenu": {
+                    "head_content": head_content,
+                    "list": menu_list,
+                    "tail_content": tail_content,
+                },
            },
        )

-    def send_location(self, user_id, open_kfid, name, address, latitude, longitude, msgid=""):
+    def send_location(
+        self, user_id, open_kfid, name, address, latitude, longitude, msgid=""
+    ):
        return self.send(
            user_id,
            open_kfid,
            msgid,
            msg={
                "msgtype": "location",
-                "msgmenu": {"name": name, "address": address, "latitude": latitude, "longitude": longitude},
+                "msgmenu": {
+                    "name": name,
+                    "address": address,
+                    "latitude": latitude,
+                    "longitude": longitude,
+                },
            },
        )

-    def send_miniprogram(self, user_id, open_kfid, appid, title, thumb_media_id, pagepath, msgid=""):
+    def send_miniprogram(
+        self, user_id, open_kfid, appid, title, thumb_media_id, pagepath, msgid=""
+    ):
        return self.send(
            user_id,
            open_kfid,
            msgid,
            msg={
                "msgtype": "miniprogram",
-                "msgmenu": {"appid": appid, "title": title, "thumb_media_id": thumb_media_id, "pagepath": pagepath},
+                "msgmenu": {
+                    "appid": appid,
+                    "title": title,
+                    "thumb_media_id": thumb_media_id,
+                    "pagepath": pagepath,
+                },
            },
        )
--- a/astrbot/core/platform/sources/weixin_official_account/weixin_offacc_adapter.py
+++ b/astrbot/core/platform/sources/weixin_official_account/weixin_offacc_adapter.py
@@ -160,7 +160,9 @@ class WeixinOfficialAccountPlatformAdapter(Platform):
                        self.wexin_event_workers[msg.id] = future
                        await self.convert_message(msg, future)
                    # I love shield so much!
-                    result = await asyncio.wait_for(asyncio.shield(future), 60)  # wait for 60s
+                    result = await asyncio.wait_for(
+                        asyncio.shield(future), 60
+                    )  # wait for 60s
                    logger.debug(f"Got future result: {result}")
                    self.wexin_event_workers.pop(msg.id, None)
                    return result  # xml. see weixin_offacc_event.py
--- a/astrbot/core/platform/sources/weixin_official_account/weixin_offacc_event.py
+++ b/astrbot/core/platform/sources/weixin_official_account/weixin_offacc_event.py
@@ -150,7 +150,6 @@ class WeixinOfficialAccountPlatformEvent(AstrMessageEvent):
                        return
                    logger.info(f"微信公众平台上传语音返回: {response}")

-
                    if active_send_mode:
                        self.client.message.send_voice(
                            message_obj.sender.user_id,
--- a/astrbot/core/provider/entities.py
+++ b/astrbot/core/provider/entities.py
@@ -4,9 +4,11 @@ import json
 from astrbot.core.utils.io import download_image_by_url
 from astrbot import logger
 from dataclasses import dataclass, field
-from typing import List, Dict, Type
+from typing import List, Dict, Type, Any
 from astrbot.core.agent.tool import ToolSet
 from openai.types.chat.chat_completion import ChatCompletion
+from google.genai.types import GenerateContentResponse
+from anthropic.types import Message
 from openai.types.chat.chat_completion_message_tool_call import (
    ChatCompletionMessageToolCall,
 )
@@ -30,11 +32,11 @@ class ProviderMetaData:
    desc: str = ""
    """提供商适配器描述."""
    provider_type: ProviderType = ProviderType.CHAT_COMPLETION
-    cls_type: Type = None
+    cls_type: Type | None = None

-    default_config_tmpl: dict = None
+    default_config_tmpl: dict | None = None
    """平台的默认配置模板"""
-    provider_display_name: str = None
+    provider_display_name: str | None = None
    """显示在 WebUI 配置页中的提供商名称，如空则是 type"""


@@ -58,18 +60,21 @@ class ToolCallMessageSegment:
 class AssistantMessageSegment:
    """OpenAI 格式的上下文中 role 为 assistant 的消息段。参考: https://platform.openai.com/docs/guides/function-calling"""

-    content: str = None
+    content: str | None = None
    tool_calls: List[ChatCompletionMessageToolCall | Dict] = field(default_factory=list)
    role: str = "assistant"

    def to_dict(self):
-        ret = {
+        ret: dict[str, str | list[dict]] = {
            "role": self.role,
        }
        if self.content:
            ret["content"] = self.content
        if self.tool_calls:
-            ret["tool_calls"] = self.tool_calls
+            tool_calls_dict = [
+                tc if isinstance(tc, dict) else tc.to_dict() for tc in self.tool_calls
+            ]
+            ret["tool_calls"] = tool_calls_dict
        return ret


@@ -115,7 +120,14 @@ class ProviderRequest:
    """模型名称，为 None 时使用提供商的默认模型"""

    def __repr__(self):
-        return f"ProviderRequest(prompt={self.prompt}, session_id={self.session_id}, image_urls={self.image_urls}, func_tool={self.func_tool}, contexts={self._print_friendly_context()}, system_prompt={self.system_prompt.strip()}, tool_calls_result={self.tool_calls_result})"
+        return (
+            f"ProviderRequest(prompt={self.prompt}, session_id={self.session_id}, "
+            f"image_count={len(self.image_urls or [])}, "
+            f"func_tool={self.func_tool}, "
+            f"contexts={self._print_friendly_context()}, "
+            f"system_prompt={self.system_prompt}, "
+            f"conversation_id={self.conversation.cid if self.conversation else 'N/A'}, "
+        )

    def __str__(self):
        return self.__repr__()
@@ -205,17 +217,17 @@ class ProviderRequest:
 class LLMResponse:
    role: str
    """角色, assistant, tool, err"""
-    result_chain: MessageChain = None
+    result_chain: MessageChain | None = None
    """返回的消息链"""
-    tools_call_args: List[Dict[str, any]] = field(default_factory=list)
+    tools_call_args: List[Dict[str, Any]] = field(default_factory=list)
    """工具调用参数"""
    tools_call_name: List[str] = field(default_factory=list)
    """工具调用名称"""
    tools_call_ids: List[str] = field(default_factory=list)
    """工具调用 ID"""

-    raw_completion: ChatCompletion = None
-    _new_record: Dict[str, any] = None
+    raw_completion: ChatCompletion | GenerateContentResponse | Message | None = None
+    _new_record: Dict[str, Any] | None = None

    _completion_text: str = ""

@@ -226,12 +238,12 @@ class LLMResponse:
        self,
        role: str,
        completion_text: str = "",
-        result_chain: MessageChain = None,
-        tools_call_args: List[Dict[str, any]] = None,
-        tools_call_name: List[str] = None,
-        tools_call_ids: List[str] = None,
-        raw_completion: ChatCompletion = None,
-        _new_record: Dict[str, any] = None,
+        result_chain: MessageChain | None = None,
+        tools_call_args: List[Dict[str, Any]] | None = None,
+        tools_call_name: List[str] | None = None,
+        tools_call_ids: List[str] | None = None,
+        raw_completion: ChatCompletion | None = None,
+        _new_record: Dict[str, Any] | None = None,
        is_chunk: bool = False,
    ):
        """初始化 LLMResponse
@@ -295,6 +307,7 @@ class LLMResponse:
            )
        return ret

+
@dataclass
 class RerankResult:
    index: int
--- a/astrbot/core/provider/func_tool_manager.py
+++ b/astrbot/core/provider/func_tool_manager.py
@@ -4,7 +4,7 @@ import os
 import asyncio
 import aiohttp

-from typing import Dict, List, Awaitable
+from typing import Dict, List, Awaitable, Callable, Any
 from astrbot import logger
 from astrbot.core import sp

@@ -109,7 +109,7 @@ class FunctionToolManager:
        name: str,
        func_args: list,
        desc: str,
-        handler: Awaitable,
+        handler: Callable[..., Awaitable[Any]],
    ) -> FuncTool:
        params = {
            "type": "object",  # hard-coded here
@@ -132,7 +132,7 @@ class FunctionToolManager:
        name: str,
        func_args: list,
        desc: str,
-        handler: Awaitable,
+        handler: Callable[..., Awaitable[Any]],
    ) -> None:
        """添加函数调用工具

@@ -220,7 +220,7 @@ class FunctionToolManager:
        name: str,
        cfg: dict,
        event: asyncio.Event,
-        ready_future: asyncio.Future = None,
+        ready_future: asyncio.Future | None = None,
    ) -> None:
        """初始化 MCP 客户端的包装函数，用于捕获异常"""
        try:
--- a/astrbot/core/provider/manager.py
+++ b/astrbot/core/provider/manager.py
@@ -38,7 +38,7 @@ class ProviderManager:
        """加载的 Text To Speech Provider 的实例"""
        self.embedding_provider_insts: List[EmbeddingProvider] = []
        """加载的 Embedding Provider 的实例"""
-        self.inst_map: dict[str, Provider] = {}
+        self.inst_map: dict[str, Provider | STTProvider | TTSProvider] = {}
        """Provider 实例映射. key: provider_id, value: Provider 实例"""
        self.llm_tools = llm_tools

@@ -87,19 +87,31 @@ class ProviderManager:
            )
            return
        # 不启用提供商会话隔离模式的情况
-        self.curr_provider_inst = self.inst_map[provider_id]
-        if provider_type == ProviderType.TEXT_TO_SPEECH:
+
+        prov = self.inst_map[provider_id]
+        if provider_type == ProviderType.TEXT_TO_SPEECH and isinstance(
+            prov, TTSProvider
+        ):
+            self.curr_tts_provider_inst = prov
            sp.put("curr_provider_tts", provider_id, scope="global", scope_id="global")
-        elif provider_type == ProviderType.SPEECH_TO_TEXT:
+        elif provider_type == ProviderType.SPEECH_TO_TEXT and isinstance(
+            prov, STTProvider
+        ):
+            self.curr_stt_provider_inst = prov
            sp.put("curr_provider_stt", provider_id, scope="global", scope_id="global")
-        elif provider_type == ProviderType.CHAT_COMPLETION:
+        elif provider_type == ProviderType.CHAT_COMPLETION and isinstance(
+            prov, Provider
+        ):
+            self.curr_provider_inst = prov
            sp.put("curr_provider", provider_id, scope="global", scope_id="global")

    async def get_provider_by_id(self, provider_id: str) -> Provider | None:
        """根据提供商 ID 获取提供商实例"""
        return self.inst_map.get(provider_id)

-    def get_using_provider(self, provider_type: ProviderType, umo=None):
+    def get_using_provider(
+        self, provider_type: ProviderType, umo=None
+    ) -> Provider | STTProvider | TTSProvider | None:
        """获取正在使用的提供商实例。

        Args:
@@ -303,12 +315,14 @@ class ProviderManager:
        provider_metadata = provider_cls_map[provider_config["type"]]
        try:
            # 按任务实例化提供商
+            cls_type = provider_metadata.cls_type
+            if not cls_type:
+                logger.error(f"无法找到 {provider_metadata.type} 的类")
+                return

            if provider_metadata.provider_type == ProviderType.SPEECH_TO_TEXT:
                # STT 任务
-                inst = provider_metadata.cls_type(
-                    provider_config, self.provider_settings
-                )
+                inst = cls_type(provider_config, self.provider_settings)

                if getattr(inst, "initialize", None):
                    await inst.initialize()
@@ -327,9 +341,7 @@ class ProviderManager:

            elif provider_metadata.provider_type == ProviderType.TEXT_TO_SPEECH:
                # TTS 任务
-                inst = provider_metadata.cls_type(
-                    provider_config, self.provider_settings
-                )
+                inst = cls_type(provider_config, self.provider_settings)

                if getattr(inst, "initialize", None):
                    await inst.initialize()
@@ -345,7 +357,7 @@ class ProviderManager:

            elif provider_metadata.provider_type == ProviderType.CHAT_COMPLETION:
                # 文本生成任务
-                inst = provider_metadata.cls_type(
+                inst = cls_type(
                    provider_config,
                    self.provider_settings,
                    self.selected_default_persona,
@@ -366,10 +378,11 @@ class ProviderManager:
                if not self.curr_provider_inst:
                    self.curr_provider_inst = inst

-            elif provider_metadata.provider_type in [ProviderType.EMBEDDING, ProviderType.RERANK]:
-                inst = provider_metadata.cls_type(
-                    provider_config, self.provider_settings
-                )
+            elif provider_metadata.provider_type in [
+                ProviderType.EMBEDDING,
+                ProviderType.RERANK,
+            ]:
+                inst = cls_type(provider_config, self.provider_settings)
                if getattr(inst, "initialize", None):
                    await inst.initialize()
                self.embedding_provider_insts.append(inst)
@@ -388,6 +401,7 @@ class ProviderManager:

        # 和配置文件保持同步
        config_ids = [provider["id"] for provider in self.providers_config]
+        logger.debug(f"providers in user's config: {config_ids}")
        for key in list(self.inst_map.keys()):
            if key not in config_ids:
                await self.terminate_provider(key)
@@ -426,11 +440,17 @@ class ProviderManager:
            )

            if self.inst_map[provider_id] in self.provider_insts:
-                self.provider_insts.remove(self.inst_map[provider_id])
+                prov_inst = self.inst_map[provider_id]
+                if isinstance(prov_inst, Provider):
+                    self.provider_insts.remove(prov_inst)
            if self.inst_map[provider_id] in self.stt_provider_insts:
-                self.stt_provider_insts.remove(self.inst_map[provider_id])
+                prov_inst = self.inst_map[provider_id]
+                if isinstance(prov_inst, STTProvider):
+                    self.stt_provider_insts.remove(prov_inst)
            if self.inst_map[provider_id] in self.tts_provider_insts:
-                self.tts_provider_insts.remove(self.inst_map[provider_id])
+                prov_inst = self.inst_map[provider_id]
+                if isinstance(prov_inst, TTSProvider):
+                    self.tts_provider_insts.remove(prov_inst)

            if self.inst_map[provider_id] == self.curr_provider_inst:
                self.curr_provider_inst = None
--- a/astrbot/core/provider/sources/fishaudio_tts_api_source.py
+++ b/astrbot/core/provider/sources/fishaudio_tts_api_source.py
@@ -98,7 +98,7 @@ class ProviderFishAudioTTSAPI(TTSProvider):

        # FishAudio的reference_id通常是32位十六进制字符串
        # 例如: 626bb6d3f3364c9cbc3aa6a67300a664
-        pattern = r'^[a-fA-F0-9]{32}$'
+        pattern = r"^[a-fA-F0-9]{32}$"
        return bool(re.match(pattern, reference_id.strip()))

    async def _generate_request(self, text: str) -> dict:
--- a/astrbot/core/provider/sources/gemini_source.py
+++ b/astrbot/core/provider/sources/gemini_source.py
@@ -15,7 +15,7 @@ from astrbot import logger
 from astrbot.api.provider import Provider
 from astrbot.core.message.message_event_result import MessageChain
 from astrbot.core.provider.entities import LLMResponse
-from astrbot.core.provider.func_tool_manager import FuncCall
+from astrbot.core.provider.func_tool_manager import ToolSet
 from astrbot.core.utils.io import download_image_by_url

 from ..register import register_provider_adapter
@@ -61,7 +61,7 @@ class ProviderGoogleGenAI(Provider):
            default_persona,
        )
        self.api_keys: list = provider_config.get("key", [])
-        self.chosen_api_key: str = self.api_keys[0] if len(self.api_keys) > 0 else None
+        self.chosen_api_key: str = self.api_keys[0] if len(self.api_keys) > 0 else ""
        self.timeout: int = int(provider_config.get("timeout", 180))

        self.api_base: Optional[str] = provider_config.get("api_base", None)
@@ -96,6 +96,9 @@ class ProviderGoogleGenAI(Provider):

    async def _handle_api_error(self, e: APIError, keys: list[str]) -> bool:
        """处理API错误，返回是否需要重试"""
+        if e.message is None:
+            e.message = ""
+
        if e.code == 429 or "API key not valid" in e.message:
            keys.remove(self.chosen_api_key)
            if len(keys) > 0:
@@ -119,7 +122,7 @@ class ProviderGoogleGenAI(Provider):
    async def _prepare_query_config(
        self,
        payloads: dict,
-        tools: Optional[FuncCall] = None,
+        tools: Optional[ToolSet] = None,
        system_instruction: Optional[str] = None,
        modalities: Optional[list[str]] = None,
        temperature: float = 0.7,
@@ -321,11 +324,15 @@ class ProviderGoogleGenAI(Provider):

    @staticmethod
    def _process_content_parts(
-        result: types.GenerateContentResponse, llm_response: LLMResponse
+        candidate: types.Candidate, llm_response: LLMResponse
    ) -> MessageChain:
        """处理内容部分并构建消息链"""
-        finish_reason = result.candidates[0].finish_reason
-        result_parts: Optional[types.Part] = result.candidates[0].content.parts
+        if not candidate.content:
+            logger.warning(f"收到的 candidate.content 为空: {candidate}")
+            raise Exception("API 返回的 candidate.content 为空。")
+
+        finish_reason = candidate.finish_reason
+        result_parts: list[types.Part] | None = candidate.content.parts

        if finish_reason == types.FinishReason.SAFETY:
            raise Exception("模型生成内容未通过 Gemini 平台的安全检查")
@@ -343,22 +350,28 @@ class ProviderGoogleGenAI(Provider):
                raise Exception("模型生成内容违反 Gemini 平台政策")

        if not result_parts:
-            logger.debug(result.candidates)
-            raise Exception("API 返回的内容为空。")
+            logger.warning(f"收到的 candidate.content.parts 为空: {candidate}")
+            raise Exception("API 返回的 candidate.content.parts 为空。")

        chain = []
        part: types.Part

        # 暂时这样Fallback
        if all(
-            part.inline_data and part.inline_data.mime_type.startswith("image/")
+            part.inline_data
+            and part.inline_data.mime_type
+            and part.inline_data.mime_type.startswith("image/")
            for part in result_parts
        ):
            chain.append(Comp.Plain("这是图片"))
        for part in result_parts:
            if part.text:
                chain.append(Comp.Plain(part.text))
-            elif part.function_call:
+            elif (
+                part.function_call
+                and part.function_call.name is not None
+                and part.function_call.args is not None
+            ):
                llm_response.role = "tool"
                llm_response.tools_call_name.append(part.function_call.name)
                llm_response.tools_call_args.append(part.function_call.args)
@@ -366,11 +379,16 @@ class ProviderGoogleGenAI(Provider):
                llm_response.tools_call_ids.append(
                    part.function_call.id or part.function_call.name
                )
-            elif part.inline_data and part.inline_data.mime_type.startswith("image/"):
+            elif (
+                part.inline_data
+                and part.inline_data.mime_type
+                and part.inline_data.mime_type.startswith("image/")
+                and part.inline_data.data
+            ):
                chain.append(Comp.Image.fromBytes(part.inline_data.data))
        return MessageChain(chain=chain)

-    async def _query(self, payloads: dict, tools: FuncCall) -> LLMResponse:
+    async def _query(self, payloads: dict, tools: ToolSet | None) -> LLMResponse:
        """非流式请求 Gemini API"""
        system_instruction = next(
            (msg["content"] for msg in payloads["messages"] if msg["role"] == "system"),
@@ -396,6 +414,10 @@ class ProviderGoogleGenAI(Provider):
                    config=config,
                )

+                if not result.candidates:
+                    logger.error(f"请求失败, 返回的 candidates 为空: {result}")
+                    raise Exception("请求失败, 返回的 candidates 为空。")
+
                if result.candidates[0].finish_reason == types.FinishReason.RECITATION:
                    if temperature > 2:
                        raise Exception("温度参数已超过最大值2，仍然发生recitation")
@@ -408,6 +430,8 @@ class ProviderGoogleGenAI(Provider):
                break

            except APIError as e:
+                if e.message is None:
+                    e.message = ""
                if "Developer instruction is not enabled" in e.message:
                    logger.warning(
                        f"{self.get_model()} 不支持 system prompt，已自动去除(影响人格设置)"
@@ -432,11 +456,13 @@ class ProviderGoogleGenAI(Provider):

        llm_response = LLMResponse("assistant")
        llm_response.raw_completion = result
-        llm_response.result_chain = self._process_content_parts(result, llm_response)
+        llm_response.result_chain = self._process_content_parts(
+            result.candidates[0], llm_response
+        )
        return llm_response

    async def _query_stream(
-        self, payloads: dict, tools: FuncCall
+        self, payloads: dict, tools: ToolSet | None
    ) -> AsyncGenerator[LLMResponse, None]:
        """流式请求 Gemini API"""
        system_instruction = next(
@@ -459,6 +485,8 @@ class ProviderGoogleGenAI(Provider):
                )
                break
            except APIError as e:
+                if e.message is None:
+                    e.message = ""
                if "Developer instruction is not enabled" in e.message:
                    logger.warning(
                        f"{self.get_model()} 不支持 system prompt，已自动去除(影响人格设置)"
@@ -478,13 +506,20 @@ class ProviderGoogleGenAI(Provider):
        async for chunk in result:
            llm_response = LLMResponse("assistant", is_chunk=True)

+            if not chunk.candidates:
+                logger.warning(f"收到的 chunk 中 candidates 为空: {chunk}")
+                continue
+            if not chunk.candidates[0].content:
+                logger.warning(f"收到的 chunk 中 content 为空: {chunk}")
+                continue
+
            if chunk.candidates[0].content.parts and any(
                part.function_call for part in chunk.candidates[0].content.parts
            ):
                llm_response = LLMResponse("assistant", is_chunk=False)
                llm_response.raw_completion = chunk
                llm_response.result_chain = self._process_content_parts(
-                    chunk, llm_response
+                    chunk.candidates[0], llm_response
                )
                yield llm_response
                return
@@ -500,7 +535,7 @@ class ProviderGoogleGenAI(Provider):
                    final_response = LLMResponse("assistant", is_chunk=False)
                    final_response.raw_completion = chunk
                    final_response.result_chain = self._process_content_parts(
-                        chunk, final_response
+                        chunk.candidates[0], final_response
                    )
                break

@@ -566,6 +601,8 @@ class ProviderGoogleGenAI(Provider):
                    continue
                break

+        raise Exception("请求失败。")
+
    async def text_chat_stream(
        self,
        prompt,
@@ -621,7 +658,9 @@ class ProviderGoogleGenAI(Provider):
            return [
                m.name.replace("models/", "")
                for m in models
-                if "generateContent" in m.supported_actions
+                if m.supported_actions
+                and "generateContent" in m.supported_actions
+                and m.name
            ]
        except APIError as e:
            raise Exception(f"获取模型列表失败: {e.message}")
@@ -636,7 +675,7 @@ class ProviderGoogleGenAI(Provider):
        self.chosen_api_key = key
        self._init_client()

-    async def assemble_context(self, text: str, image_urls: list[str] = None):
+    async def assemble_context(self, text: str, image_urls: list[str] | None = None):
        """
        组装上下文。
        """
--- a/astrbot/core/provider/sources/openai_source.py
+++ b/astrbot/core/provider/sources/openai_source.py
@@ -99,12 +99,15 @@ class ProviderOpenAIOfficial(Provider):
        for key in to_del:
            del payloads[key]

-        model = payloads.get("model", "")
-        # 针对 qwen3 模型的特殊处理：非流式调用必须设置 enable_thinking=false
-        if "qwen3" in model.lower():
-            extra_body["enable_thinking"] = False 
+        # 读取并合并 custom_extra_body 配置
+        custom_extra_body = self.provider_config.get("custom_extra_body", {})
+        if isinstance(custom_extra_body, dict):
+            extra_body.update(custom_extra_body)
+
+        model = payloads.get("model", "").lower()
+
        # 针对 deepseek 模型的特殊处理：deepseek-reasoner调用必须移除 tools ，否则将被切换至 deepseek-chat
-        elif model == "deepseek-reasoner" and "tools" in payloads:
+        if model == "deepseek-reasoner" and "tools" in payloads:
            del payloads["tools"]

        completion = await self.client.chat.completions.create(
@@ -137,6 +140,12 @@ class ProviderOpenAIOfficial(Provider):

        # 不在默认参数中的参数放在 extra_body 中
        extra_body = {}
+
+        # 读取并合并 custom_extra_body 配置
+        custom_extra_body = self.provider_config.get("custom_extra_body", {})
+        if isinstance(custom_extra_body, dict):
+            extra_body.update(custom_extra_body)
+
        to_del = []
        for key in payloads.keys():
            if key not in self.default_params:
--- a/astrbot/core/provider/sources/vllm_rerank_source.py
+++ b/astrbot/core/provider/sources/vllm_rerank_source.py
@@ -1,4 +1,5 @@
 import aiohttp
+from astrbot import logger
 from ..provider import RerankProvider
 from ..register import register_provider_adapter
 from ..entities import ProviderType, RerankResult
@@ -44,6 +45,11 @@ class VLLMRerankProvider(RerankProvider):
            response_data = await response.json()
            results = response_data.get("results", [])

+            if not results:
+                logger.warning(
+                    f"Rerank API 返回了空的列表数据。原始响应: {response_data}"
+                )
+
            return [
                RerankResult(
                    index=result["index"],
--- a/astrbot/core/star/init.py
+++ b/astrbot/core/star/init.py
@@ -27,14 +27,16 @@ class Star(CommandParserMixin):
            star_map[cls.__module__].star_cls_type = cls
            star_map[cls.__module__].module_path = cls.__module__

-    @staticmethod
-    async def text_to_image(text: str, return_url=True) -> str:
+    async def text_to_image(self, text: str, return_url=True) -> str:
        """将文本转换为图片"""
-        return await html_renderer.render_t2i(text, return_url=return_url)
+        return await html_renderer.render_t2i(
+            text,
+            return_url=return_url,
+            template_name=self.context._config.get("t2i_active_template"),
+        )

-    @staticmethod
    async def html_render(
-        tmpl: str, data: dict, return_url=True, options: dict | None = None
+        self, tmpl: str, data: dict, return_url=True, options: dict | None = None
    ) -> str:
        """渲染 HTML"""
        return await html_renderer.render_custom_template(
--- a/astrbot/core/star/context.py
+++ b/astrbot/core/star/context.py
@@ -23,7 +23,7 @@ from .star import star_registry, StarMetadata, star_map
 from .star_handler import star_handlers_registry, StarHandlerMetadata, EventType
 from .filter.command import CommandFilter
 from .filter.regex import RegexFilter
-from typing import Awaitable
+from typing import Awaitable, Any, Callable
 from astrbot.core.conversation_mgr import ConversationManager
 from astrbot.core.star.filter.platform_adapter_type import (
    PlatformAdapterType,
@@ -105,7 +105,10 @@ class Context:

    def get_provider_by_id(self, provider_id: str) -> Provider | None:
        """通过 ID 获取对应的 LLM Provider(Chat_Completion 类型)。"""
-        return self.provider_manager.inst_map.get(provider_id)
+        prov = self.provider_manager.inst_map.get(provider_id)
+        if prov and not isinstance(prov, Provider):
+            raise ValueError("返回的 Provider 不是 Provider 类型")
+        return prov

    def get_all_providers(self) -> List[Provider]:
        """获取所有用于文本生成任务的 LLM Provider(Chat_Completion 类型)。"""
@@ -130,34 +133,43 @@ class Context:
        Args:
            umo(str): unified_message_origin 值，如果传入并且用户启用了提供商会话隔离，则使用该会话偏好的提供商。
        """
-        return self.provider_manager.get_using_provider(
+        prov = self.provider_manager.get_using_provider(
            provider_type=ProviderType.CHAT_COMPLETION,
            umo=umo,
        )
+        if prov and not isinstance(prov, Provider):
+            raise ValueError("返回的 Provider 不是 Provider 类型")
+        return prov

-    def get_using_tts_provider(self, umo: str | None = None) -> TTSProvider:
+    def get_using_tts_provider(self, umo: str | None = None) -> TTSProvider | None:
        """
        获取当前使用的用于 TTS 任务的 Provider。

        Args:
            umo(str): unified_message_origin 值，如果传入，则使用该会话偏好的提供商。
        """
-        return self.provider_manager.get_using_provider(
+        prov = self.provider_manager.get_using_provider(
            provider_type=ProviderType.TEXT_TO_SPEECH,
            umo=umo,
        )
+        if prov and not isinstance(prov, TTSProvider):
+            raise ValueError("返回的 Provider 不是 TTSProvider 类型")
+        return prov

-    def get_using_stt_provider(self, umo: str | None = None) -> STTProvider:
+    def get_using_stt_provider(self, umo: str | None = None) -> STTProvider | None:
        """
        获取当前使用的用于 STT 任务的 Provider。

        Args:
            umo(str): unified_message_origin 值，如果传入，则使用该会话偏好的提供商。
        """
-        return self.provider_manager.get_using_provider(
+        prov = self.provider_manager.get_using_provider(
            provider_type=ProviderType.SPEECH_TO_TEXT,
            umo=umo,
        )
+        if prov and not isinstance(prov, STTProvider):
+            raise ValueError("返回的 Provider 不是 STTProvider 类型")
+        return prov

    def get_config(self, umo: str | None = None) -> AstrBotConfig:
        """获取 AstrBot 的配置。"""
@@ -245,7 +257,11 @@ class Context:
    """

    def register_llm_tool(
-        self, name: str, func_args: list, desc: str, func_obj: Awaitable
+        self,
+        name: str,
+        func_args: list,
+        desc: str,
+        func_obj: Callable[..., Awaitable[Any]],
    ) -> None:
        """
        为函数调用（function-calling / tools-use）添加工具。
@@ -267,9 +283,7 @@ class Context:
            desc=desc,
        )
        star_handlers_registry.append(md)
-        self.provider_manager.llm_tools.add_func(
-            name, func_args, desc, func_obj, func_obj
-        )
+        self.provider_manager.llm_tools.add_func(name, func_args, desc, func_obj)

    def unregister_llm_tool(self, name: str) -> None:
        """删除一个函数调用工具。如果再要启用，需要重新注册。"""
@@ -281,7 +295,7 @@ class Context:
        command_name: str,
        desc: str,
        priority: int,
-        awaitable: Awaitable,
+        awaitable: Callable[..., Awaitable[Any]],
        use_regex=False,
        ignore_prefix=False,
    ):
--- a/astrbot/core/star/filter/command_group.py
+++ b/astrbot/core/star/filter/command_group.py
@@ -13,8 +13,8 @@ class CommandGroupFilter(HandlerFilter):
    def __init__(
        self,
        group_name: str,
-        alias: set = None,
-        parent_group: CommandGroupFilter = None,
+        alias: set | None = None,
+        parent_group: CommandGroupFilter | None = None,
    ):
        self.group_name = group_name
        self.alias = alias if alias else set()
@@ -54,8 +54,8 @@ class CommandGroupFilter(HandlerFilter):
        self,
        sub_command_filters: List[Union[CommandFilter, CommandGroupFilter]],
        prefix: str = "",
-        event: AstrMessageEvent = None,
-        cfg: AstrBotConfig = None,
+        event: AstrMessageEvent | None = None,
+        cfg: AstrBotConfig | None = None,
    ) -> str:
        result = ""
        for sub_filter in sub_command_filters:
@@ -113,8 +113,7 @@ class CommandGroupFilter(HandlerFilter):
                + self.print_cmd_tree(self.sub_command_filters, event=event, cfg=cfg)
            )
            raise ValueError(
-                f"参数不足。{self.group_name} 指令组下有如下指令，请参考：\n"
-                + tree
+                f"参数不足。{self.group_name} 指令组下有如下指令，请参考：\n" + tree
            )

        # complete_command_names = [name + " " for name in complete_command_names]
--- a/astrbot/core/star/filter/platform_adapter_type.py
+++ b/astrbot/core/star/filter/platform_adapter_type.py
@@ -2,7 +2,6 @@ import enum
 from . import HandlerFilter
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.config import AstrBotConfig
-from typing import Union


 class PlatformAdapterType(enum.Flag):
@@ -18,6 +17,8 @@ class PlatformAdapterType(enum.Flag):
    KOOK = enum.auto()
    VOCECHAT = enum.auto()
    WEIXIN_OFFICIAL_ACCOUNT = enum.auto()
+    SATORI = enum.auto()
+    MISSKEY = enum.auto()
    ALL = (
        AIOCQHTTP
        | QQOFFICIAL
@@ -31,6 +32,8 @@ class PlatformAdapterType(enum.Flag):
        | KOOK
        | VOCECHAT
        | WEIXIN_OFFICIAL_ACCOUNT
+        | SATORI
+        | MISSKEY
    )


@@ -47,15 +50,20 @@ ADAPTER_NAME_2_TYPE = {
    "wechatpadpro": PlatformAdapterType.WECHATPADPRO,
    "vocechat": PlatformAdapterType.VOCECHAT,
    "weixin_official_account": PlatformAdapterType.WEIXIN_OFFICIAL_ACCOUNT,
+    "satori": PlatformAdapterType.SATORI,
+    "misskey": PlatformAdapterType.MISSKEY,
 }


 class PlatformAdapterTypeFilter(HandlerFilter):
-    def __init__(self, platform_adapter_type_or_str: Union[PlatformAdapterType, str]):
-        self.type_or_str = platform_adapter_type_or_str
+    def __init__(self, platform_adapter_type_or_str: PlatformAdapterType | str):
+        if isinstance(platform_adapter_type_or_str, str):
+            self.platform_type = ADAPTER_NAME_2_TYPE.get(platform_adapter_type_or_str)
+        else:
+            self.platform_type = platform_adapter_type_or_str

    def filter(self, event: AstrMessageEvent, cfg: AstrBotConfig) -> bool:
        adapter_name = event.get_platform_name()
-        if adapter_name in ADAPTER_NAME_2_TYPE:
-            return ADAPTER_NAME_2_TYPE[adapter_name] & self.type_or_str
+        if adapter_name in ADAPTER_NAME_2_TYPE and self.platform_type is not None:
+            return bool(ADAPTER_NAME_2_TYPE[adapter_name] & self.platform_type)
        return False
--- a/astrbot/core/star/register/init.py
+++ b/astrbot/core/star/register/init.py
@@ -8,6 +8,7 @@ from .star_handler import (
    register_permission_type,
    register_custom_filter,
    register_on_astrbot_loaded,
+    register_on_platform_loaded,
    register_on_llm_request,
    register_on_llm_response,
    register_llm_tool,
@@ -26,6 +27,7 @@ __all__ = [
    "register_permission_type",
    "register_custom_filter",
    "register_on_astrbot_loaded",
+    "register_on_platform_loaded",
    "register_on_llm_request",
    "register_on_llm_response",
    "register_llm_tool",
--- a/astrbot/core/star/register/star.py
+++ b/astrbot/core/star/register/star.py
@@ -5,7 +5,9 @@ from astrbot.core.star import StarMetadata, star_map
 _warned_register_star = False


-def register_star(name: str, author: str, desc: str, version: str, repo: str = None):
+def register_star(
+    name: str, author: str, desc: str, version: str, repo: str | None = None
+):
    """注册一个插件(Star)。

    [DEPRECATED] 该装饰器已废弃，将在未来版本中移除。
--- a/astrbot/core/star/register/star_handler.py
+++ b/astrbot/core/star/register/star_handler.py
@@ -12,7 +12,7 @@ from ..filter.platform_adapter_type import (
 from ..filter.permission import PermissionTypeFilter, PermissionType
 from ..filter.custom_filter import CustomFilterAnd, CustomFilterOr
 from ..filter.regex import RegexFilter
-from typing import Awaitable
+from typing import Awaitable, Any, Callable
 from astrbot.core.provider.func_tool_manager import SUPPORTED_TYPES
 from astrbot.core.provider.register import llm_tools
 from astrbot.core.agent.agent import Agent
@@ -20,15 +20,19 @@ from astrbot.core.agent.tool import FunctionTool
 from astrbot.core.agent.handoff import HandoffTool
 from astrbot.core.agent.hooks import BaseAgentRunHooks
 from astrbot.core.astr_agent_context import AstrAgentContext
+from astrbot.core import logger


-def get_handler_full_name(awaitable: Awaitable) -> str:
+def get_handler_full_name(awaitable: Callable[..., Awaitable[Any]]) -> str:
    """获取 Handler 的全名"""
    return f"{awaitable.__module__}_{awaitable.__name__}"


 def get_handler_or_create(
-    handler: Awaitable, event_type: EventType, dont_add=False, **kwargs
+    handler: Callable[..., Awaitable[Any]],
+    event_type: EventType,
+    dont_add=False,
+    **kwargs,
 ) -> StarHandlerMetadata:
    """获取 Handler 或者创建一个新的 Handler"""
    handler_full_name = get_handler_full_name(handler)
@@ -59,22 +63,35 @@ def get_handler_or_create(


 def register_command(
-    command_name: str = None, sub_command: str = None, alias: set = None, **kwargs
+    command_name: str | None = None,
+    sub_command: str | None = None,
+    alias: set | None = None,
+    **kwargs,
 ):
    """注册一个 Command."""
    new_command = None
    add_to_event_filters = False
    if isinstance(command_name, RegisteringCommandable):
        # 子指令
-        parent_command_names = command_name.parent_group.get_complete_command_names()
-        new_command = CommandFilter(
-            sub_command, alias, None, parent_command_names=parent_command_names
-        )
-        command_name.parent_group.add_sub_command_filter(new_command)
+        if sub_command is not None:
+            parent_command_names = (
+                command_name.parent_group.get_complete_command_names()
+            )
+            new_command = CommandFilter(
+                sub_command, alias, None, parent_command_names=parent_command_names
+            )
+            command_name.parent_group.add_sub_command_filter(new_command)
+        else:
+            logger.warning(
+                f"注册指令{command_name} 的子指令时未提供 sub_command 参数。"
+            )
    else:
        # 裸指令
-        new_command = CommandFilter(command_name, alias, None)
-        add_to_event_filters = True
+        if command_name is None:
+            logger.warning("注册裸指令时未提供 command_name 参数。")
+        else:
+            new_command = CommandFilter(command_name, alias, None)
+            add_to_event_filters = True

    def decorator(awaitable):
        if not add_to_event_filters:
@@ -84,8 +101,9 @@ def register_command(
        handler_md = get_handler_or_create(
            awaitable, EventType.AdapterMessageEvent, **kwargs
        )
-        new_command.init_handler_md(handler_md)
-        handler_md.event_filters.append(new_command)
+        if new_command:
+            new_command.init_handler_md(handler_md)
+            handler_md.event_filters.append(new_command)
        return awaitable

    return decorator
@@ -163,26 +181,38 @@ def register_custom_filter(custom_type_filter, *args, **kwargs):


 def register_command_group(
-    command_group_name: str = None, sub_command: str = None, alias: set = None, **kwargs
+    command_group_name: str | None = None,
+    sub_command: str | None = None,
+    alias: set | None = None,
+    **kwargs,
 ):
    """注册一个 CommandGroup"""
    new_group = None
    if isinstance(command_group_name, RegisteringCommandable):
        # 子指令组
-        new_group = CommandGroupFilter(
-            sub_command, alias, parent_group=command_group_name.parent_group
-        )
-        command_group_name.parent_group.add_sub_command_filter(new_group)
+        if sub_command is None:
+            logger.warning(f"{command_group_name} 指令组的子指令组 sub_command 未指定")
+        else:
+            new_group = CommandGroupFilter(
+                sub_command, alias, parent_group=command_group_name.parent_group
+            )
+            command_group_name.parent_group.add_sub_command_filter(new_group)
    else:
        # 根指令组
-        new_group = CommandGroupFilter(command_group_name, alias)
+        if command_group_name is None:
+            logger.warning("根指令组的名称未指定")
+        else:
+            new_group = CommandGroupFilter(command_group_name, alias)

    def decorator(obj):
        # 根指令组
-        handler_md = get_handler_or_create(obj, EventType.AdapterMessageEvent, **kwargs)
-        handler_md.event_filters.append(new_group)
+        if new_group:
+            handler_md = get_handler_or_create(
+                obj, EventType.AdapterMessageEvent, **kwargs
+            )
+            handler_md.event_filters.append(new_group)

-        return RegisteringCommandable(new_group)
+            return RegisteringCommandable(new_group)

    return decorator

@@ -267,6 +297,18 @@ def register_on_astrbot_loaded(**kwargs):
    return decorator


+def register_on_platform_loaded(**kwargs):
+    """
+    当平台加载完成时
+    """
+
+    def decorator(awaitable):
+        _ = get_handler_or_create(awaitable, EventType.OnPlatformLoadedEvent, **kwargs)
+        return awaitable
+
+    return decorator
+
+
 def register_on_llm_request(**kwargs):
    """当有 LLM 请求时的事件

@@ -311,7 +353,7 @@ def register_on_llm_response(**kwargs):
    return decorator


-def register_llm_tool(name: str = None, **kwargs):
+def register_llm_tool(name: str | None = None, **kwargs):
    """为函数调用（function-calling / tools-use）添加工具。

    请务必按照以下格式编写一个工具（包括函数注释，AstrBot 会尝试解析该函数注释）
@@ -349,9 +391,10 @@ def register_llm_tool(name: str = None, **kwargs):
    if kwargs.get("registering_agent"):
        registering_agent = kwargs["registering_agent"]

-    def decorator(awaitable: Awaitable):
+    def decorator(awaitable: Callable[..., Awaitable[Any]]):
        llm_tool_name = name_ if name_ else awaitable.__name__
-        docstring = docstring_parser.parse(awaitable.__doc__)
+        func_doc = awaitable.__doc__ or ""
+        docstring = docstring_parser.parse(func_doc)
        args = []
        for arg in docstring.params:
            if arg.type_name not in SUPPORTED_TYPES:
@@ -367,18 +410,18 @@ def register_llm_tool(name: str = None, **kwargs):
            )
        # print(llm_tool_name, registering_agent)
        if not registering_agent:
+            doc_desc = docstring.description.strip() if docstring.description else ""
            md = get_handler_or_create(awaitable, EventType.OnCallingFuncToolEvent)
-            llm_tools.add_func(
-                llm_tool_name, args, docstring.description.strip(), md.handler
-            )
+            llm_tools.add_func(llm_tool_name, args, doc_desc, md.handler)
        else:
            assert isinstance(registering_agent, RegisteringAgent)
            # print(f"Registering tool {llm_tool_name} for agent", registering_agent._agent.name)
            if registering_agent._agent.tools is None:
                registering_agent._agent.tools = []
-            registering_agent._agent.tools.append(llm_tools.spec_to_func(
-                llm_tool_name, args, docstring.description.strip(), awaitable
-            ))
+
+            desc = docstring.description.strip() if docstring.description else ""
+            tool = llm_tools.spec_to_func(llm_tool_name, args, desc, awaitable)
+            registering_agent._agent.tools.append(tool)

        return awaitable

@@ -399,8 +442,8 @@ class RegisteringAgent:
 def register_agent(
    name: str,
    instruction: str,
-    tools: list[str | FunctionTool] = None,
-    run_hooks: BaseAgentRunHooks[AstrAgentContext] = None,
+    tools: list[str | FunctionTool] | None = None,
+    run_hooks: BaseAgentRunHooks[AstrAgentContext] | None = None,
 ):
    """注册一个 Agent

@@ -412,7 +455,7 @@ def register_agent(
    """
    tools_ = tools or []

-    def decorator(awaitable: Awaitable):
+    def decorator(awaitable: Callable[..., Awaitable[Any]]):
        AstrAgent = Agent[AstrAgentContext]
        agent = AstrAgent(
            name=name,
@@ -421,7 +464,7 @@ def register_agent(
            run_hooks=run_hooks or BaseAgentRunHooks[AstrAgentContext](),
        )
        handoff_tool = HandoffTool(agent=agent)
-        handoff_tool.handler=awaitable
+        handoff_tool.handler = awaitable
        llm_tools.func_list.append(handoff_tool)
        return RegisteringAgent(agent)

--- a/astrbot/core/star/session_plugin_manager.py
+++ b/astrbot/core/star/session_plugin_manager.py
@@ -84,7 +84,10 @@ class SessionPluginManager:
        session_config["disabled_plugins"] = disabled_plugins
        session_plugin_config[session_id] = session_config
        sp.put(
-            "session_plugin_config", session_plugin_config, scope="umo", scope_id=session_id
+            "session_plugin_config",
+            session_plugin_config,
+            scope="umo",
+            scope_id=session_id,
        )

        logger.info(
@@ -137,6 +140,9 @@ class SessionPluginManager:
                filtered_handlers.append(handler)
                continue

+            if plugin.name is None:
+                continue
+
            # 检查插件是否在当前会话中启用
            if SessionPluginManager.is_plugin_enabled_for_session(
                session_id, plugin.name
--- a/astrbot/core/star/star_handler.py
+++ b/astrbot/core/star/star_handler.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 import enum
 from dataclasses import dataclass, field
-from typing import Awaitable, List, Dict, TypeVar, Generic
+from typing import Callable, Awaitable, Any, List, Dict, TypeVar, Generic
 from .filter import HandlerFilter
 from .star import star_map

@@ -34,26 +34,33 @@ class StarHandlerRegistry(Generic[T]):
    ) -> List[StarHandlerMetadata]:
        handlers = []
        for handler in self._handlers:
+            # 过滤事件类型
            if handler.event_type != event_type:
                continue
+            # 过滤启用状态
            if only_activated:
                plugin = star_map.get(handler.handler_module_path)
                if not (plugin and plugin.activated):
                    continue
+            # 过滤插件白名单
            if plugins_name is not None and plugins_name != ["*"]:
                plugin = star_map.get(handler.handler_module_path)
                if not plugin:
                    continue
                if (
                    plugin.name not in plugins_name
-                    and event_type != EventType.OnAstrBotLoadedEvent
+                    and event_type
+                    not in (
+                        EventType.OnAstrBotLoadedEvent,
+                        EventType.OnPlatformLoadedEvent,
+                    )
                    and not plugin.reserved
                ):
                    continue
            handlers.append(handler)
        return handlers

-    def get_handler_by_full_name(self, full_name: str) -> StarHandlerMetadata:
+    def get_handler_by_full_name(self, full_name: str) -> StarHandlerMetadata | None:
        return self.star_handlers_map.get(full_name, None)

    def get_handlers_by_module_name(
@@ -80,7 +87,7 @@ class StarHandlerRegistry(Generic[T]):
        return len(self._handlers)


-star_handlers_registry = StarHandlerRegistry()
+star_handlers_registry = StarHandlerRegistry()  # type: ignore


 class EventType(enum.Enum):
@@ -90,6 +97,7 @@ class EventType(enum.Enum):
    """

    OnAstrBotLoadedEvent = enum.auto()  # AstrBot 加载完成
+    OnPlatformLoadedEvent = enum.auto()  # 平台加载完成

    AdapterMessageEvent = enum.auto()  # 收到适配器发来的消息
    OnLLMRequestEvent = enum.auto()  # 收到 LLM 请求（可以是用户也可以是插件）
@@ -115,7 +123,7 @@ class StarHandlerMetadata:
    handler_module_path: str
    """Handler 所在的模块路径。"""

-    handler: Awaitable
+    handler: Callable[..., Awaitable[Any]]
    """Handler 的函数对象，应当是一个异步函数"""

    event_filters: List[HandlerFilter]
--- a/astrbot/core/star/star_manager.py
+++ b/astrbot/core/star/star_manager.py
@@ -43,7 +43,7 @@ class PluginManager:
        self.updator = PluginUpdator()

        self.context = context
-        self.context._star_manager = self
+        self.context._star_manager = self  # type: ignore

        self.config = config
        self.plugin_store_path = get_astrbot_plugin_path()
@@ -478,9 +478,10 @@ class PluginManager:
                        if isinstance(func_tool, HandoffTool):
                            need_apply = []
                            sub_tools = func_tool.agent.tools
-                            for sub_tool in sub_tools:
-                                if isinstance(sub_tool, FunctionTool):
-                                    need_apply.append(sub_tool)
+                            if sub_tools:
+                                for sub_tool in sub_tools:
+                                    if isinstance(sub_tool, FunctionTool):
+                                        need_apply.append(sub_tool)
                        else:
                            need_apply = [func_tool]

@@ -686,6 +687,9 @@ class PluginManager:
                )

            # 从 star_registry 和 star_map 中删除
+            if plugin.module_path is None or root_dir_name is None:
+                raise Exception(f"插件 {plugin_name} 数据不完整，无法卸载。")
+
            await self._unbind_plugin(plugin_name, plugin.module_path)

            try:
@@ -791,15 +795,17 @@ class PluginManager:
        if star_metadata.star_cls is None:
            return

-        if '__del__' in star_metadata.star_cls_type.__dict__:
+        if "__del__" in star_metadata.star_cls_type.__dict__:
            asyncio.get_event_loop().run_in_executor(
                None, star_metadata.star_cls.__del__
            )
-        elif 'terminate' in star_metadata.star_cls_type.__dict__:
+        elif "terminate" in star_metadata.star_cls_type.__dict__:
            await star_metadata.star_cls.terminate()

    async def turn_on_plugin(self, plugin_name: str):
        plugin = self.context.get_registered_star(plugin_name)
+        if plugin is None:
+            raise Exception(f"插件 {plugin_name} 不存在。")
        inactivated_plugins: list = await sp.global_get("inactivated_plugins", [])
        inactivated_llm_tools: list = await sp.global_get("inactivated_llm_tools", [])
        if plugin.module_path in inactivated_plugins:
--- a/astrbot/core/star/star_tools.py
+++ b/astrbot/core/star/star_tools.py
@@ -1,14 +1,41 @@
+"""
+插件开发工具集
+封装了许多常用的操作，方便插件开发者使用
+
+说明:
+
+主动发送消息: send_message(session, message_chain)
+    根据 session (unified_msg_origin) 主动发送消息, 前提是需要提前获得或构造 session
+
+根据id直接主动发送消息: send_message_by_id(type, id, message_chain, platform="aiocqhttp")
+    根据 id (例如 qq 号, 群号等) 直接, 主动地发送消息
+
+以上两种方式需要构造消息链, 也就是消息组件的列表
+
+构造事件:
+
+首先需要构造一个 AstrBotMessage 对象, 使用 create_message 方法
+然后使用 create_event 方法提交事件到指定平台
+"""
+
 import inspect
 import os
+import uuid
 from pathlib import Path
-from typing import Union, Awaitable, List, Optional, ClassVar
+from typing import Union, Awaitable, Callable, Any, List, Optional, ClassVar
 from astrbot.core.message.components import BaseMessageComponent
 from astrbot.core.message.message_event_result import MessageChain
-from astrbot.api.platform import MessageMember, AstrBotMessage
+from astrbot.api.platform import MessageMember, AstrBotMessage, MessageType
 from astrbot.core.platform.astr_message_event import MessageSesion
 from astrbot.core.star.context import Context
 from astrbot.core.star.star import star_map
 from astrbot.core.utils.astrbot_path import get_astrbot_data_path
+from astrbot.core.platform.sources.aiocqhttp.aiocqhttp_message_event import (
+    AiocqhttpMessageEvent,
+)
+from astrbot.core.platform.sources.aiocqhttp.aiocqhttp_platform_adapter import (
+    AiocqhttpAdapter,
+)


 class StarTools:
@@ -49,42 +76,82 @@ class StarTools:
        Note:
            qq_official(QQ官方API平台)不支持此方法
        """
+        if cls._context is None:
+            raise ValueError("StarTools not initialized")
        return await cls._context.send_message(session, message_chain)

+    @classmethod
+    async def send_message_by_id(
+        cls,
+        type: str,
+        id: str,
+        message_chain: MessageChain,
+        platform: str = "aiocqhttp",
+    ):
+        """
+        根据 id(例如qq号, 群号等) 直接, 主动地发送消息
+
+        Args:
+            type (str): 消息类型, 可选: PrivateMessage, GroupMessage
+            id (str): 目标ID, 例如QQ号, 群号等
+            message_chain (MessageChain): 消息链
+            platform (str): 可选的平台名称，默认平台(aiocqhttp), 目前只支持 aiocqhttp
+        """
+        if cls._context is None:
+            raise ValueError("StarTools not initialized")
+        platforms = cls._context.platform_manager.get_insts()
+        if platform == "aiocqhttp":
+            adapter = next(
+                (p for p in platforms if isinstance(p, AiocqhttpAdapter)), None
+            )
+            if adapter is None:
+                raise ValueError("未找到适配器: AiocqhttpAdapter")
+            await AiocqhttpMessageEvent.send_message(
+                bot=adapter.bot,
+                message_chain=message_chain,
+                is_group=(type == "GroupMessage"),
+                session_id=id,
+            )
+        else:
+            raise ValueError(f"不支持的平台: {platform}")
+
    @classmethod
    async def create_message(
        cls,
        type: str,
        self_id: str,
        session_id: str,
-        message_id: str,
        sender: MessageMember,
        message: List[BaseMessageComponent],
        message_str: str,
-        raw_message: object,
+        message_id: str = "",
+        raw_message: object = None,
        group_id: str = "",
-    ):
+    ) -> AstrBotMessage:
        """
        创建一个AstrBot消息对象

        Args:
-            type (str): 消息类型
+            type (str): 消息类型, 例如 "GroupMessage" "FriendMessage" "OtherMessage"
            self_id (str): 机器人自身ID
            session_id (str): 会话ID(通常为用户ID)(QQ号, 群号等)
-            message_id (str): 消息ID
-            sender (MessageMember): 发送者信息
-            message (List[BaseMessageComponent]): 消息组件列表
-            message_str (str): 消息字符串
-            raw_message (object): 原始消息对象
+            sender (MessageMember): 发送者信息, 例如 MessageMember(user_id="123456", nickname="昵称")
+            message (List[BaseMessageComponent]): 消息组件列表, 也就是消息链, 这个不会发给 llm, 但是会经过其他处理
+            message_str (str): 消息字符串, 也就是纯文本消息, 也就是发送给 llm 的消息, 与消息链一致
+
+            message_id (str): 消息ID, 构造消息时可以随意填写也可不填
+            raw_message (object): 原始消息对象, 可以随意填写也可不填
            group_id (str, optional): 群组ID, 如果为私聊则为空. Defaults to "".

        Returns:
            AstrBotMessage: 创建的消息对象
        """
        abm = AstrBotMessage()
-        abm.type = type
+        abm.type = MessageType(type)
        abm.self_id = self_id
        abm.session_id = session_id
+        if message_id == "":
+            message_id = uuid.uuid4().hex
        abm.message_id = message_id
        abm.sender = sender
        abm.message = message
@@ -93,13 +160,39 @@ class StarTools:
        abm.group_id = group_id
        return abm

-    # todo: 添加构造事件的方法
-    # async def create_event(
-    #     self, platform: str, umo: str, sender_id: str, session_id: str
-    # ):
-    #     platform = self._context.get_platform(platform)
+    @classmethod
+    async def create_event(
+        cls, abm: AstrBotMessage, platform: str = "aiocqhttp", is_wake: bool = True
+    ) -> None:
+        """
+        创建并提交事件到指定平台
+        当有需要创建一个事件, 触发某些处理流程时, 使用该方法

-    # todo: 添加找到对应平台并提交对应事件的方法
+        Args:
+            abm (AstrBotMessage): 要提交的消息对象, 请先使用 create_message 创建
+            platform (str): 可选的平台名称，默认平台(aiocqhttp), 目前只支持 aiocqhttp
+            is_wake (bool): 是否标记为唤醒事件, 默认为 True, 只有唤醒事件才会被 llm 响应
+        """
+        if cls._context is None:
+            raise ValueError("StarTools not initialized")
+        platforms = cls._context.platform_manager.get_insts()
+        if platform == "aiocqhttp":
+            adapter = next(
+                (p for p in platforms if isinstance(p, AiocqhttpAdapter)), None
+            )
+            if adapter is None:
+                raise ValueError("未找到适配器: AiocqhttpAdapter")
+            event = AiocqhttpMessageEvent(
+                message_str=abm.message_str,
+                message_obj=abm,
+                platform_meta=adapter.metadata,
+                session_id=abm.session_id,
+                bot=adapter.bot,
+            )
+            event.is_wake = is_wake
+            adapter.commit_event(event)
+        else:
+            raise ValueError(f"不支持的平台: {platform}")

    @classmethod
    def activate_llm_tool(cls, name: str) -> bool:
@@ -110,6 +203,8 @@ class StarTools:
        Args:
            name (str): 工具名称
        """
+        if cls._context is None:
+            raise ValueError("StarTools not initialized")
        return cls._context.activate_llm_tool(name)

    @classmethod
@@ -120,11 +215,17 @@ class StarTools:
        Args:
            name (str): 工具名称
        """
+        if cls._context is None:
+            raise ValueError("StarTools not initialized")
        return cls._context.deactivate_llm_tool(name)

    @classmethod
    def register_llm_tool(
-        cls, name: str, func_args: list, desc: str, func_obj: Awaitable
+        cls,
+        name: str,
+        func_args: list,
+        desc: str,
+        func_obj: Callable[..., Awaitable[Any]],
    ) -> None:
        """
        为函数调用（function-calling/tools-use）添加工具
@@ -135,6 +236,8 @@ class StarTools:
            desc (str): 工具描述
            func_obj (Awaitable): 函数对象，必须是异步函数
        """
+        if cls._context is None:
+            raise ValueError("StarTools not initialized")
        cls._context.register_llm_tool(name, func_args, desc, func_obj)

    @classmethod
@@ -146,6 +249,8 @@ class StarTools:
        Args:
            name (str): 工具名称
        """
+        if cls._context is None:
+            raise ValueError("StarTools not initialized")
        cls._context.unregister_llm_tool(name)

    @classmethod
@@ -169,8 +274,11 @@ class StarTools:
                - 创建目录失败（权限不足或其他IO错误）
        """
        if not plugin_name:
-            frame = inspect.currentframe().f_back
-            module = inspect.getmodule(frame)
+            frame = inspect.currentframe()
+            module = None
+            if frame:
+                frame = frame.f_back
+                module = inspect.getmodule(frame)

            if not module:
                raise RuntimeError("无法获取调用者模块信息")
@@ -182,7 +290,12 @@ class StarTools:

            plugin_name = metadata.name

-        data_dir = Path(os.path.join(get_astrbot_data_path(), "plugin_data", plugin_name))
+        if not plugin_name:
+            raise ValueError("无法获取插件名称")
+
+        data_dir = Path(
+            os.path.join(get_astrbot_data_path(), "plugin_data", plugin_name)
+        )

        try:
            data_dir.mkdir(parents=True, exist_ok=True)
--- a/astrbot/core/star/updator.py
+++ b/astrbot/core/star/updator.py
@@ -32,6 +32,9 @@ class PluginUpdator(RepoZipUpdator):
        if not repo_url:
            raise Exception(f"插件 {plugin.name} 没有指定仓库地址。")

+        if not plugin.root_dir_name:
+            raise Exception(f"插件 {plugin.name} 的根目录名未指定。")
+
        plugin_path = os.path.join(self.plugin_store_path, plugin.root_dir_name)

        logger.info(f"正在更新插件，路径: {plugin_path}，仓库地址: {repo_url}")
--- a/astrbot/core/updator.py
+++ b/astrbot/core/updator.py
@@ -56,9 +56,7 @@ class AstrBotUpdator(RepoZipUpdator):
        try:
            if "astrbot" in os.path.basename(sys.argv[0]):  # 兼容cli
                if os.name == "nt":
-                    args = [
-                        f'"{arg}"' if " " in arg else arg for arg in sys.argv[1:]
-                    ]
+                    args = [f'"{arg}"' if " " in arg else arg for arg in sys.argv[1:]]
                else:
                    args = sys.argv[1:]
                os.execl(sys.executable, py, "-m", "astrbot.cli.__main__", *args)
@@ -68,9 +66,13 @@ class AstrBotUpdator(RepoZipUpdator):
            logger.error(f"重启失败（{py}, {e}），请尝试手动重启。")
            raise e

-    async def check_update(self, url: str, current_version: str) -> ReleaseInfo:
+    async def check_update(
+        self, url: str, current_version: str, consider_prerelease: bool = True
+    ) -> ReleaseInfo:
        """检查更新"""
-        return await super().check_update(self.ASTRBOT_RELEASE_API, VERSION)
+        return await super().check_update(
+            self.ASTRBOT_RELEASE_API, VERSION, consider_prerelease
+        )

    async def get_releases(self) -> list:
        return await self.fetch_release_info(self.ASTRBOT_RELEASE_API)
--- a/astrbot/core/utils/io.py
+++ b/astrbot/core/utils/io.py
@@ -227,7 +227,7 @@ async def download_dashboard(
        path = os.path.join(get_astrbot_data_path(), "dashboard.zip")

    if latest or len(str(version)) != 40:
-        logger.info("准备下载最新发行版本的 AstrBot WebUI")
+        logger.info(f"准备下载 {version} 发行版本的 AstrBot WebUI 文件")
        ver_name = "latest" if latest else version
        dashboard_release_url = f"https://astrbot-registry.soulter.top/download/astrbot-dashboard/{ver_name}/dist.zip"
        try:
--- a/astrbot/core/utils/t2i/network_strategy.py
+++ b/astrbot/core/utils/t2i/network_strategy.py
@@ -1,6 +1,5 @@
 import aiohttp
 import asyncio
-import os
 import ssl
 import certifi
 import logging
@@ -8,10 +7,9 @@ import random
 from . import RenderStrategy
 from astrbot.core.config import VERSION
 from astrbot.core.utils.io import download_image_by_url
-from astrbot.core.utils.astrbot_path import get_astrbot_data_path
+from astrbot.core.utils.t2i.template_manager import TemplateManager

 ASTRBOT_T2I_DEFAULT_ENDPOINT = "https://t2i.soulter.top/text2img"
-CUSTOM_T2I_TEMPLATE_PATH = os.path.join(get_astrbot_data_path(), "t2i_template.html")

 logger = logging.getLogger("astrbot")

@@ -23,26 +21,17 @@ class NetworkRenderStrategy(RenderStrategy):
            self.BASE_RENDER_URL = ASTRBOT_T2I_DEFAULT_ENDPOINT
        else:
            self.BASE_RENDER_URL = self._clean_url(base_url)
-        self.TEMPLATE_PATH = os.path.join(os.path.dirname(__file__), "template", "base.html")
-        with open(self.TEMPLATE_PATH, "r", encoding="utf-8") as f:
-            self.DEFAULT_TEMPLATE = f.read()

        self.endpoints = [self.BASE_RENDER_URL]
+        self.template_manager = TemplateManager()

    async def initialize(self):
        if self.BASE_RENDER_URL == ASTRBOT_T2I_DEFAULT_ENDPOINT:
            asyncio.create_task(self.get_official_endpoints())

-    async def get_template(self) -> str:
-        """获取文转图 HTML 模板
-
-        Returns:
-            str: 文转图 HTML 模板字符串
-        """
-        if os.path.exists(CUSTOM_T2I_TEMPLATE_PATH):
-            with open(CUSTOM_T2I_TEMPLATE_PATH, "r", encoding="utf-8") as f:
-                return f.read()
-        return self.DEFAULT_TEMPLATE
+    async def get_template(self, name: str = "base") -> str:
+        """通过名称获取文转图 HTML 模板"""
+        return self.template_manager.get_template(name)

    async def get_official_endpoints(self):
        """获取官方的 t2i 端点列表。"""
@@ -124,11 +113,15 @@ class NetworkRenderStrategy(RenderStrategy):
        logger.error(f"All endpoints failed: {last_exception}")
        raise RuntimeError(f"All endpoints failed: {last_exception}")

-    async def render(self, text: str, return_url: bool = False) -> str:
+    async def render(
+        self, text: str, return_url: bool = False, template_name: str | None = "base"
+    ) -> str:
        """
        返回图像的文件路径
        """
-        tmpl_str = await self.get_template()
+        if not template_name:
+            template_name = "base"
+        tmpl_str = await self.get_template(name=template_name)
        text = text.replace("`", "\\`")
        return await self.render_custom_template(
            tmpl_str, {"text": text, "version": f"v{VERSION}"}, return_url
--- a/astrbot/core/utils/t2i/renderer.py
+++ b/astrbot/core/utils/t2i/renderer.py
@@ -34,12 +34,18 @@ class HtmlRenderer:
        )

    async def render_t2i(
-        self, text: str, use_network: bool = True, return_url: bool = False
+        self,
+        text: str,
+        use_network: bool = True,
+        return_url: bool = False,
+        template_name: str | None = None,
    ):
        """使用默认文转图模板。"""
        if use_network:
            try:
-                return await self.network_strategy.render(text, return_url=return_url)
+                return await self.network_strategy.render(
+                    text, return_url=return_url, template_name=template_name
+                )
            except BaseException as e:
                logger.error(
                    f"Failed to render image via AstrBot API: {e}. Falling back to local rendering."
--- a/astrbot/core/utils/t2i/template/astrbot_powershell.html
+++ b/astrbot/core/utils/t2i/template/astrbot_powershell.html
@@ -0,0 +1,184 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8"/>
+  <title>Astrbot PowerShell {{ version }} </title>
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.css" integrity="sha384-wcIxkf4k558AjM3Yz3BBFQUbk/zgIYC2R0QpeeYb+TwlBVMrlgLqwRjRtGZiK7ww" crossorigin="anonymous">
+  <script src="https://cdn.jsdelivr.net/npm/highlight.js@11.9.0/lib/common.min.js"></script>
+  <script>hljs.highlightAll();</script>
+  <script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.js" integrity="sha384-hIoBPJpTUs74ddyc4bFZSM1TVlQDA60VBbJS0oA934VSz82sBx1X7kSx2ATBDIyd" crossorigin="anonymous"></script>
+  <script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/contrib/auto-render.min.js" integrity="sha384-43gviWU0YVjaDtb/GhzOouOXtZMP/7XUzwPTstBeZFe/+rCMvRwr4yROQP43s0Xk" crossorigin="anonymous"
+      onload="renderMathInElement(document.getElementById('content'),{delimiters: [{left: '$$', right: '$$', display: true},{left: '$', right: '$', display: false}]});"></script>
+  <style>
+    :root {
+        --bg-color: #010409;
+        --text-color: #e6edf3;
+        --title-bar-color: #161b22;
+        --title-text-color: #e6edf3;
+        --font-family: 'Consolas', 'Microsoft YaHei Mono', 'Dengxian Mono', 'Courier New', monospace;
+        --glow-color: rgba(200, 220, 255, 0.7);
+    }
+
+    @keyframes scanline {
+        0% {
+            background-position: 0 0;
+        }
+        100% {
+            background-position: 0 100%;
+        }
+    }
+
+    body {
+        background-color: var(--bg-color);
+        color: var(--text-color);
+        font-family: var(--font-family);
+        margin: 0;
+        padding: 0;
+        line-height: 1.6;
+        font-size: 18px;
+        /* The CRT glow effect from the image */
+        text-shadow: 0 0 15px var(--glow-color), 0 0 7px rgba(255, 255, 255, 1);
+        position: relative;
+        overflow: hidden;
+    }
+
+    body::after {
+        content: " ";
+        display: block;
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        background: linear-gradient(to bottom, transparent 50%, rgba(0, 0, 0, 0.3) 50%);
+        background-size: 100% 4px;
+        z-index: 2;
+        pointer-events: none;
+        animation: scanline 8s linear infinite;
+    }
+
+    .header {
+        background-color: var(--title-bar-color);
+        padding: 12px 18px;
+        color: var(--title-text-color);
+        font-size: 16px;
+        border-bottom: 1px solid #30363d;
+        text-shadow: none; /* No glow for title bar */
+    }
+    
+    .header .title {
+        font-weight: bold;
+        font-size: 28px;
+    }
+
+    .header .version {
+        opacity: 0.8;
+        margin-left: 1rem;
+    }
+
+    main {
+        padding: 1rem 1.5rem;
+    }
+
+    #content {
+        /* min-width and max-width removed as per request */
+    }
+
+    /* --- Markdown Styles adjusted for terminal look --- */
+    h1, h2, h3, h4, h5, h6 {
+        line-height: 1.4;
+        margin-top: 20px;
+        margin-bottom: 10px;
+        padding-bottom: 5px;
+        border-bottom: 1px solid #30363d;
+        color: var(--text-color);
+    }
+    h1 { font-size: 2rem; }
+    h2 { font-size: 1.7rem; }
+    h3 { font-size: 1.4rem; }
+
+    p {
+        margin-top: 1rem;
+        margin-bottom: 1rem;
+    }
+
+    strong {
+      color: var(--text-color);
+      font-weight: bold;
+    }
+
+    img {
+        max-width: 100%;
+        border: 1px solid #30363d;
+        display: block;
+        margin: 1rem auto;
+    }
+
+    hr {
+        border: 0;
+        border-top: 1px dashed #30363d;
+        margin: 2rem 0;
+    }
+
+    code {
+        font-family: var(--font-family);
+        padding: 0.2em 0.4em;
+        margin: 0;
+        font-size: 90%;
+        background-color: #161b22;
+        border-radius: 4px;
+    }
+
+    pre {
+        font-family: var(--font-family);
+        border-radius: 4px;
+        background: #0d1117;
+        padding: 1rem;
+        overflow-x: auto;
+        border: 1px solid #30363d;
+    }
+
+    pre > code {
+        padding: 0;
+        margin: 0;
+        font-size: 100%;
+        background-color: transparent;
+        border-radius: 0;
+        text-shadow: none; /* Disable glow inside code blocks for clarity */
+    }
+
+    a {
+        color: #58a6ff;
+        text-decoration: underline;
+    }
+    a:hover {
+        text-decoration: underline;
+    }
+
+    blockquote {
+        border-left: 4px solid #30363d;
+        padding: 0.5rem 1rem;
+        margin: 1.5rem 0;
+        color: #8b949e;
+        background-color: #161b22;
+    }
+  </style>
+</head>
+<body>
+
+  <div class="header">
+    <span class="title">> Astrbot PowerShell</span>
+    <span class="version">{{ version }}</span>
+  </div>
+
+  <main>
+    <div id="content"></div>
+  </main>
+
+  <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+  <script>
+    document.getElementById('content').innerHTML = marked.parse(`{{ text | safe }}`);
+  </script>
+
+</body>
+</html>
--- a/astrbot/core/utils/t2i/template_manager.py
+++ b/astrbot/core/utils/t2i/template_manager.py
@@ -0,0 +1,112 @@
+# astrbot/core/utils/t2i/template_manager.py
+
+import os
+import shutil
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path, get_astrbot_path
+
+
+class TemplateManager:
+    """
+    负责管理 t2i HTML 模板的 CRUD 和重置操作。
+    采用“用户覆盖内置”策略：用户模板存储在 data 目录中，并优先于内置模板加载。
+    所有创建、更新、删除操作仅影响用户目录，以确保更新框架时用户数据安全。
+    """
+
+    CORE_TEMPLATES = ["base.html", "astrbot_powershell.html"]
+
+    def __init__(self):
+        self.builtin_template_dir = os.path.join(
+            get_astrbot_path(), "astrbot", "core", "utils", "t2i", "template"
+        )
+        self.user_template_dir = os.path.join(get_astrbot_data_path(), "t2i_templates")
+
+        os.makedirs(self.user_template_dir, exist_ok=True)
+        self._initialize_user_templates()
+
+    def _copy_core_templates(self, overwrite: bool = False):
+        """从内置目录复制核心模板到用户目录。"""
+        for filename in self.CORE_TEMPLATES:
+            src = os.path.join(self.builtin_template_dir, filename)
+            dst = os.path.join(self.user_template_dir, filename)
+            if os.path.exists(src) and (overwrite or not os.path.exists(dst)):
+                shutil.copyfile(src, dst)
+
+    def _initialize_user_templates(self):
+        """如果用户目录下缺少核心模板，则进行复制。"""
+        self._copy_core_templates(overwrite=False)
+
+    def _get_user_template_path(self, name: str) -> str:
+        """获取用户模板的完整路径，防止路径遍历漏洞。"""
+        if ".." in name or "/" in name or "\\" in name:
+            raise ValueError("模板名称包含非法字符。")
+        return os.path.join(self.user_template_dir, f"{name}.html")
+
+    def _read_file(self, path: str) -> str:
+        """读取文件内容。"""
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read()
+
+    def list_templates(self) -> list[dict]:
+        """
+        列出所有可用模板。
+        该列表是内置模板和用户模板的合并视图，用户模板将覆盖同名的内置模板。
+        """
+        dirs_to_scan = [self.builtin_template_dir, self.user_template_dir]
+        all_names = {
+            os.path.splitext(f)[0]
+            for d in dirs_to_scan
+            for f in os.listdir(d)
+            if f.endswith(".html")
+        }
+        return [
+            {"name": name, "is_default": name == "base"} for name in sorted(all_names)
+        ]
+
+    def get_template(self, name: str) -> str:
+        """
+        获取指定模板的内容。
+        优先从用户目录加载，如果不存在则回退到内置目录。
+        """
+        user_path = self._get_user_template_path(name)
+        if os.path.exists(user_path):
+            return self._read_file(user_path)
+
+        builtin_path = os.path.join(self.builtin_template_dir, f"{name}.html")
+        if os.path.exists(builtin_path):
+            return self._read_file(builtin_path)
+
+        raise FileNotFoundError("模板不存在。")
+
+    def create_template(self, name: str, content: str):
+        """在用户目录中创建一个新的模板文件。"""
+        path = self._get_user_template_path(name)
+        if os.path.exists(path):
+            raise FileExistsError("同名模板已存在。")
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+    def update_template(self, name: str, content: str):
+        """
+        更新一个模板。此操作始终写入用户目录。
+        如果更新的是一个内置模板，此操作实际上会在用户目录中创建一个修改后的副本，
+        从而实现对内置模板的“覆盖”。
+        """
+        path = self._get_user_template_path(name)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+    def delete_template(self, name: str):
+        """
+        仅删除用户目录中的模板文件。
+        如果删除的是一个覆盖了内置模板的用户模板，这将有效地“恢复”到内置版本。
+        """
+        path = self._get_user_template_path(name)
+        if not os.path.exists(path):
+            raise FileNotFoundError("用户模板不存在，无法删除。")
+        os.remove(path)
+
+    def reset_default_template(self):
+        """
+        将核心模板从内置目录强制重置到用户目录。
+        """
+        self._copy_core_templates(overwrite=True)
--- a/astrbot/core/zip_updator.py
+++ b/astrbot/core/zip_updator.py
@@ -107,16 +107,38 @@ class RepoZipUpdator:
        """Semver 版本比较"""
        return VersionComparator.compare_version(v1, v2)

-    async def check_update(self, url: str, current_version: str) -> ReleaseInfo | None:
+    async def check_update(
+        self, url: str, current_version: str, consider_prerelease: bool = True
+    ) -> ReleaseInfo | None:
        update_data = await self.fetch_release_info(url)
-        tag_name = update_data[0]["tag_name"]
+
+        sel_release_data = None
+        if consider_prerelease:
+            tag_name = update_data[0]["tag_name"]
+            sel_release_data = update_data[0]
+        else:
+            for data in update_data:
+                # 跳过带有 alpha、beta 等预发布标签的版本
+                if re.search(
+                    r"[\-_.]?(alpha|beta|rc|dev)[\-_.]?\d*$",
+                    data["tag_name"],
+                    re.IGNORECASE,
+                ):
+                    continue
+                tag_name = data["tag_name"]
+                sel_release_data = data
+                break
+
+        if not sel_release_data or not tag_name:
+            logger.error("未找到合适的发布版本")
+            return None

        if self.compare_version(current_version, tag_name) >= 0:
            return None
        return ReleaseInfo(
            version=tag_name,
-            published_at=update_data[0]["published_at"],
-            body=update_data[0]["body"],
+            published_at=sel_release_data["published_at"],
+            body=f"{tag_name}\n\n{sel_release_data['body']}",
        )

    async def download_from_repo_url(self, target_path: str, repo_url: str, proxy=""):
--- a/astrbot/dashboard/routes/chat.py
+++ b/astrbot/dashboard/routes/chat.py
@@ -157,7 +157,11 @@ class ChatRoute(Route):

                    if type == "end":
                        break
-                    elif (streaming and type == "complete") or not streaming:
+                    elif (
+                        (streaming and type == "complete")
+                        or not streaming
+                        or type == "break"
+                    ):
                        # append bot message
                        new_his = {"type": "bot", "message": result_text}
                        await self.platform_history_mgr.insert(
@@ -197,6 +201,7 @@ class ChatRoute(Route):
                "Connection": "keep-alive",
            },
        )
+        response.timeout = None  # fix SSE auto disconnect issue
        return response

    async def _get_webchat_conv_id_from_conv_id(self, conversation_id: str) -> str:
--- a/astrbot/dashboard/routes/config.py
+++ b/astrbot/dashboard/routes/config.py
@@ -16,10 +16,10 @@ 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, html_renderer
+from astrbot.core import logger
 from astrbot.core.provider import Provider
+from astrbot.core.provider.provider import RerankProvider
 import asyncio
-from astrbot.core.utils.t2i.network_strategy import CUSTOM_T2I_TEMPLATE_PATH


 def try_cast(value: str, type_: str):
@@ -155,6 +155,7 @@ def save_config(post_config: dict, config: AstrBotConfig, is_core: bool = False)
        raise ValueError(f"验证配置时出现异常: {e}")
    if errors:
        raise ValueError(f"格式校验未通过: {errors}")
+
    config.save_config(post_config)


@@ -185,56 +186,9 @@ class ConfigRoute(Route):
            "/config/provider/check_one": ("GET", self.check_one_provider_status),
            "/config/provider/list": ("GET", self.get_provider_config_list),
            "/config/provider/model_list": ("GET", self.get_provider_model_list),
-            "/config/astrbot/t2i-template/get": ("GET", self.get_t2i_template),
-            "/config/astrbot/t2i-template/save": ("POST", self.post_t2i_template),
-            "/config/astrbot/t2i-template/delete": ("DELETE", self.delete_t2i_template),
        }
        self.register_routes()

-    async def get_t2i_template(self):
-        """获取 T2I 模板"""
-        try:
-            template = await html_renderer.network_strategy.get_template()
-            has_custom_template = os.path.exists(CUSTOM_T2I_TEMPLATE_PATH)
-            return (
-                Response()
-                .ok({"template": template, "has_custom_template": has_custom_template})
-                .__dict__
-            )
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response().error(f"获取模板失败: {str(e)}").__dict__
-
-    async def post_t2i_template(self):
-        """保存 T2I 模板"""
-        try:
-            post_data = await request.json
-            if not post_data or "template" not in post_data:
-                return Response().error("缺少模板内容").__dict__
-
-            template_content = post_data["template"]
-
-            # 保存自定义模板到文件
-            with open(CUSTOM_T2I_TEMPLATE_PATH, "w", encoding="utf-8") as f:
-                f.write(template_content)
-
-            return Response().ok(message="模板保存成功").__dict__
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response().error(f"保存模板失败: {str(e)}").__dict__
-
-    async def delete_t2i_template(self):
-        """删除自定义 T2I 模板，恢复默认模板"""
-        try:
-            if os.path.exists(CUSTOM_T2I_TEMPLATE_PATH):
-                os.remove(CUSTOM_T2I_TEMPLATE_PATH)
-                return Response().ok(message="已恢复默认模板").__dict__
-            else:
-                return Response().ok(message="未找到自定义模板文件").__dict__
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response().error(f"删除模板失败: {str(e)}").__dict__
-
    async def get_abconf_list(self):
        """获取所有 AstrBot 配置文件的列表"""
        abconf_list = self.acm.get_conf_list()
@@ -481,6 +435,19 @@ class ConfigRoute(Route):
                )
                status_info["status"] = "unavailable"
                status_info["error"] = f"STT test failed: {str(e)}"
+        elif provider_capability_type == ProviderType.RERANK:
+            try:
+                assert isinstance(provider, RerankProvider)
+                await provider.rerank("Apple", documents=["apple", "banana"])
+                status_info["status"] = "available"
+            except Exception as e:
+                logger.error(
+                    f"Error testing rerank provider {provider_name}: {e}",
+                    exc_info=True,
+                )
+                status_info["status"] = "unavailable"
+                status_info["error"] = f"Rerank test failed: {str(e)}"
+
        else:
            logger.debug(
                f"Provider {provider_name} is not a Chat Completion or Embedding provider. Marking as available without test. Meta: {meta}"
@@ -752,6 +719,13 @@ class ConfigRoute(Route):
            if conf_id not in self.acm.confs:
                raise ValueError(f"配置文件 {conf_id} 不存在")
            astrbot_config = self.acm.confs[conf_id]
+
+            # 保留服务端的 t2i_active_template 值
+            if "t2i_active_template" in astrbot_config:
+                post_configs["t2i_active_template"] = astrbot_config[
+                    "t2i_active_template"
+                ]
+
            save_config(post_configs, astrbot_config, is_core=True)
        except Exception as e:
            raise e
--- a/astrbot/dashboard/routes/log.py
+++ b/astrbot/dashboard/routes/log.py
@@ -10,7 +10,9 @@ class LogRoute(Route):
        super().__init__(context)
        self.log_broker = log_broker
        self.app.add_url_rule("/api/live-log", view_func=self.log, methods=["GET"])
-        self.app.add_url_rule("/api/log-history", view_func=self.log_history, methods=["GET"])
+        self.app.add_url_rule(
+            "/api/log-history", view_func=self.log_history, methods=["GET"]
+        )

    async def log(self):
        async def stream():
@@ -48,9 +50,15 @@ class LogRoute(Route):
        """获取日志历史"""
        try:
            logs = list(self.log_broker.log_cache)
-            return Response().ok(data={
-                "logs": logs,
-            }).__dict__
+            return (
+                Response()
+                .ok(
+                    data={
+                        "logs": logs,
+                    }
+                )
+                .__dict__
+            )
        except BaseException as e:
            logger.error(f"获取日志历史失败: {e}")
            return Response().error(f"获取日志历史失败: {e}").__dict__
--- a/astrbot/dashboard/routes/route.py
+++ b/astrbot/dashboard/routes/route.py
@@ -15,8 +15,24 @@ class Route:
        self.config = context.config

    def register_routes(self):
-        for route, (method, func) in self.routes.items():
-            self.app.add_url_rule(f"/api{route}", view_func=func, methods=[method])
+        def _add_rule(path, method, func):
+            # 统一添加 /api 前缀
+            full_path = f"/api{path}"
+            self.app.add_url_rule(full_path, view_func=func, methods=[method])
+
+        # 兼容字典和列表两种格式
+        routes_to_register = (
+            self.routes.items() if isinstance(self.routes, dict) else self.routes
+        )
+
+        for route, definition in routes_to_register:
+            # 兼容一个路由多个方法
+            if isinstance(definition, list):
+                for method, func in definition:
+                    _add_rule(route, method, func)
+            else:
+                method, func = definition
+                _add_rule(route, method, func)


@dataclass
--- a/astrbot/dashboard/routes/t2i.py
+++ b/astrbot/dashboard/routes/t2i.py
@@ -0,0 +1,230 @@
+# astrbot/dashboard/routes/t2i.py
+
+from dataclasses import asdict
+from quart import jsonify, request
+
+from astrbot.core import logger
+from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
+from astrbot.core.utils.t2i.template_manager import TemplateManager
+from .route import Response, Route, RouteContext
+
+
+class T2iRoute(Route):
+    def __init__(self, context: RouteContext, core_lifecycle: AstrBotCoreLifecycle):
+        super().__init__(context)
+        self.core_lifecycle = core_lifecycle
+        self.config = core_lifecycle.astrbot_config
+        self.manager = TemplateManager()
+        # 使用列表保证路由注册顺序，避免 /<name> 路由优先匹配 /reset_default
+        self.routes = [
+            ("/t2i/templates", ("GET", self.list_templates)),
+            ("/t2i/templates/active", ("GET", self.get_active_template)),
+            ("/t2i/templates/create", ("POST", self.create_template)),
+            ("/t2i/templates/reset_default", ("POST", self.reset_default_template)),
+            ("/t2i/templates/set_active", ("POST", self.set_active_template)),
+            # 动态路由应该在静态路由之后注册
+            (
+                "/t2i/templates/<name>",
+                [
+                    ("GET", self.get_template),
+                    ("PUT", self.update_template),
+                    ("DELETE", self.delete_template),
+                ],
+            ),
+        ]
+        self.register_routes()
+
+    async def list_templates(self):
+        """获取所有T2I模板列表"""
+        try:
+            templates = self.manager.list_templates()
+            return jsonify(asdict(Response().ok(data=templates)))
+        except Exception as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
+
+    async def get_active_template(self):
+        """获取当前激活的T2I模板"""
+        try:
+            active_template = self.config.get("t2i_active_template", "base")
+            return jsonify(
+                asdict(Response().ok(data={"active_template": active_template}))
+            )
+        except Exception as e:
+            logger.error("Error in get_active_template", exc_info=True)
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
+
+    async def get_template(self, name: str):
+        """获取指定名称的T2I模板内容"""
+        try:
+            content = self.manager.get_template(name)
+            return jsonify(
+                asdict(Response().ok(data={"name": name, "content": content}))
+            )
+        except FileNotFoundError:
+            response = jsonify(asdict(Response().error("Template not found")))
+            response.status_code = 404
+            return response
+        except Exception as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
+
+    async def create_template(self):
+        """创建一个新的T2I模板"""
+        try:
+            data = await request.json
+            name = data.get("name")
+            content = data.get("content")
+            if not name or not content:
+                response = jsonify(
+                    asdict(Response().error("Name and content are required."))
+                )
+                response.status_code = 400
+                return response
+            name = name.strip()
+
+            self.manager.create_template(name, content)
+            response = jsonify(
+                asdict(
+                    Response().ok(
+                        data={"name": name}, message="Template created successfully."
+                    )
+                )
+            )
+            response.status_code = 201
+            return response
+        except FileExistsError:
+            response = jsonify(
+                asdict(Response().error("Template with this name already exists."))
+            )
+            response.status_code = 409
+            return response
+        except ValueError as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 400
+            return response
+        except Exception as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
+
+    async def update_template(self, name: str):
+        """更新一个已存在的T2I模板"""
+        try:
+            name = name.strip()
+            data = await request.json
+            content = data.get("content")
+            if content is None:
+                response = jsonify(asdict(Response().error("Content is required.")))
+                response.status_code = 400
+                return response
+
+            self.manager.update_template(name, content)
+
+            # 检查更新的是否为当前激活的模板，如果是，则热重载
+            active_template = self.config.get("t2i_active_template", "base")
+            if name == active_template:
+                await self.core_lifecycle.reload_pipeline_scheduler("default")
+                message = f"模板 '{name}' 已更新并重新加载。"
+            else:
+                message = f"模板 '{name}' 已更新。"
+
+            return jsonify(asdict(Response().ok(data={"name": name}, message=message)))
+        except ValueError as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 400
+            return response
+        except Exception as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
+
+    async def delete_template(self, name: str):
+        """删除一个T2I模板"""
+        try:
+            name = name.strip()
+            self.manager.delete_template(name)
+            return jsonify(
+                asdict(Response().ok(message="Template deleted successfully."))
+            )
+        except FileNotFoundError:
+            response = jsonify(asdict(Response().error("Template not found.")))
+            response.status_code = 404
+            return response
+        except ValueError as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 400
+            return response
+        except Exception as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
+
+    async def set_active_template(self):
+        """设置当前活动的T2I模板"""
+        try:
+            data = await request.json
+            name = data.get("name")
+            if not name:
+                response = jsonify(asdict(Response().error("模板名称(name)不能为空。")))
+                response.status_code = 400
+                return response
+
+            # 验证模板文件是否存在
+            self.manager.get_template(name)
+
+            # 更新配置
+            config = self.config
+            config["t2i_active_template"] = name
+            config.save_config(config)
+
+            # 热重载以应用更改
+            await self.core_lifecycle.reload_pipeline_scheduler("default")
+
+            return jsonify(asdict(Response().ok(message=f"模板 '{name}' 已成功应用。")))
+
+        except FileNotFoundError:
+            response = jsonify(
+                asdict(Response().error(f"模板 '{name}' 不存在，无法应用。"))
+            )
+            response.status_code = 404
+            return response
+        except Exception as e:
+            logger.error("Error in set_active_template", exc_info=True)
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
+
+    async def reset_default_template(self):
+        """重置默认的'base'模板"""
+        try:
+            self.manager.reset_default_template()
+
+            # 更新配置，将激活模板也重置为'base'
+            config = self.config
+            config["t2i_active_template"] = "base"
+            config.save_config(config)
+
+            # 热重载以应用更改
+            await self.core_lifecycle.reload_pipeline_scheduler("default")
+
+            return jsonify(
+                asdict(
+                    Response().ok(
+                        message="Default template has been reset and activated."
+                    )
+                )
+            )
+        except FileNotFoundError as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 404
+            return response
+        except Exception as e:
+            logger.error("Error in reset_default_template", exc_info=True)
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
--- a/astrbot/dashboard/routes/tools.py
+++ b/astrbot/dashboard/routes/tools.py
@@ -1,6 +1,5 @@
 import traceback

-import aiohttp
 from quart import request

 from astrbot.core import logger
--- a/astrbot/dashboard/routes/update.py
+++ b/astrbot/dashboard/routes/update.py
@@ -57,7 +57,7 @@ class UpdateRoute(Route):
                    .__dict__
                )
            else:
-                ret = await self.astrbot_updator.check_update(None, None)
+                ret = await self.astrbot_updator.check_update(None, None, False)
                return Response(
                    status="success",
                    message=str(ret) if ret is not None else "已经是最新版本了。",
@@ -100,9 +100,7 @@ class UpdateRoute(Route):
            )

            try:
-                await download_dashboard(
-                    latest=latest, version=version, proxy=proxy
-                )
+                await download_dashboard(latest=latest, version=version, proxy=proxy)
            except Exception as e:
                logger.error(f"下载管理面板文件失败: {e}。")

@@ -133,7 +131,7 @@ class UpdateRoute(Route):
    async def update_dashboard(self):
        try:
            try:
-                await download_dashboard()
+                await download_dashboard(version=f"v{VERSION}", latest=False)
            except Exception as e:
                logger.error(f"下载管理面板文件失败: {e}。")
                return Response().error(f"下载管理面板文件失败: {e}").__dict__
--- a/astrbot/dashboard/server.py
+++ b/astrbot/dashboard/server.py
@@ -18,6 +18,7 @@ from astrbot.core.utils.io import get_local_ip_addresses
 from .routes import *
 from .routes.route import Response, RouteContext
 from .routes.session_management import SessionManagementRoute
+from .routes.t2i import T2iRoute

 APP: Quart = None

@@ -28,10 +29,19 @@ class AstrBotDashboard:
        core_lifecycle: AstrBotCoreLifecycle,
        db: BaseDatabase,
        shutdown_event: asyncio.Event,
+        webui_dir: str | None = None,
    ) -> None:
        self.core_lifecycle = core_lifecycle
        self.config = core_lifecycle.astrbot_config
-        self.data_path = os.path.abspath(os.path.join(get_astrbot_data_path(), "dist"))
+
+        # 参数指定webui目录
+        if webui_dir and os.path.exists(webui_dir):
+            self.data_path = os.path.abspath(webui_dir)
+        else:
+            self.data_path = os.path.abspath(
+                os.path.join(get_astrbot_data_path(), "dist")
+            )
+
        self.app = Quart("dashboard", static_folder=self.data_path, static_url_path="/")
        APP = self.app  # noqa
        self.app.config["MAX_CONTENT_LENGTH"] = (
@@ -60,9 +70,8 @@ class AstrBotDashboard:
        self.session_management_route = SessionManagementRoute(
            self.context, db, core_lifecycle
        )
-        self.persona_route = PersonaRoute(
-            self.context, db, core_lifecycle
-        )
+        self.persona_route = PersonaRoute(self.context, db, core_lifecycle)
+        self.t2i_route = T2iRoute(self.context, core_lifecycle)

        self.app.add_url_rule(
            "/api/plug/<path:subpath>",
--- a/changelogs/v3.5.27.md
+++ b/changelogs/v3.5.27.md
@@ -0,0 +1,5 @@
+# What's Changed
+
+1. 修复：构建 docker 镜像时同时构建 webui，并放入镜像中。
+2. 修复：下载 WebUI 文件时，明确版本号，以防止 latest 不一致导致下载的 WebUI 文件版本号与实际所需不符的问题。
+3. 优化：优化版本检测，考虑预发布版本，移除 `更新到最新版本` 按钮
--- a/changelogs/v4.0.0-beta.3.md
+++ b/changelogs/v4.0.0-beta.3.md
@@ -0,0 +1,3 @@
+# What's Changed
+
+> 请仔细阅读：**这是 v4.0.0 的测试版本（beta.3），功能尚未完全稳定和加入**。v4.0.0 被设计为向前兼容，如有任何插件兼容性问题或者其他异常请在 GitHub 提交 [Issue](https://github.com/AstrBotDevs/AstrBot/issues)。在测试版本期间，您可以无缝回退到旧版本的 AstrBot，并且数据不受影响。新版本文档请[从此](https://docs-v4.astrbot.app/)访问，直到第一个 v4.0.0 稳定版本发布。
--- a/changelogs/v4.0.0-beta.4.md
+++ b/changelogs/v4.0.0-beta.4.md
@@ -0,0 +1,8 @@
+# What's Changed
+
+> 请仔细阅读：**这是 v4.0.0 的测试版本（beta.4），功能尚未完全稳定和加入**。v4.0.0 被设计为向前兼容，如有任何插件兼容性问题或者其他异常请在 GitHub 提交 [Issue](https://github.com/AstrBotDevs/AstrBot/issues)。在测试版本期间，您可以无缝回退到旧版本的 AstrBot，并且数据不受影响。新版本文档请[从此](https://docs-v4.astrbot.app/)访问，直到第一个 v4.0.0 稳定版本发布。
+
+相较于 beta.3：
+
+1. 修复了主动回复时报错的问题
+2. 数据迁移完毕之后引导重启程序
--- a/changelogs/v4.0.0-beta.5.md
+++ b/changelogs/v4.0.0-beta.5.md
@@ -0,0 +1,15 @@
+# What's Changed
+
+> 请仔细阅读：**这是 v4.0.0 的测试版本（beta.4），功能尚未完全稳定和加入**。v4.0.0 被设计为向前兼容，如有任何插件兼容性问题或者其他异常请在 GitHub 提交 [Issue](https://github.com/AstrBotDevs/AstrBot/issues)。在测试版本期间，您可以无缝回退到旧版本的 AstrBot，并且数据不受影响。新版本文档请[从此](https://docs-v4.astrbot.app/)访问，直到第一个 v4.0.0 稳定版本发布。
+
+相较于 beta.4：
+
+1. ‼️修复：新版本在初次保存配置之后，调用 LLM 无法获得响应，但插件指令仍可以使用的问题
+2. 修复：部分情况下，Dashboard 内修改配置保存后报错 UnicodeDecodeError
+3. 修复：构建 docker 镜像时同时构建 webui，并放入镜像中。
+4. 修复：下载 WebUI 文件时，明确版本号，以防止 latest 不一致导致下载的 WebUI 文件版本号与实际所需不符的问题。
+5. 优化：优化版本检测，考虑预发布版本，移除 `更新到最新版本` 按钮
+6. 优化：增加 abconf_data 缓存，优化性能
+7. 优化: 适配 qwen3 的 thinking 类模型
+8. 优化: 完善对 rerank model 的可用性检测
+9. 新增: 给添加 edge_tts 新增 rate, volume, pitch 参数 ([#2625](https://github.com/Soulter/AstrBot/issues/2625))
--- a/Show More
+++ b/Show More