Merge remote-tracking branch 'origin/master' into feat/tauri-app

* feat: supports thinking level of google gemini

- Updated google-genai version to >=1.56.0 in pyproject.toml and requirements.txt.
- Changed model configuration from "gemini-1.5-flash" to "gemini-3-flash-preview" in default.py.
- Enhanced thinking configuration handling in gemini_source.py to support new parameters for Gemini 3 models.

* fix: standardize thinking level configuration in default.py and gemini_source.py

- Updated the thinking level values in default.py to uppercase for consistency.
- Enhanced gemini_source.py to validate the thinking level and default to "HIGH" if an invalid value is provided.

.github/workflows/build-app.yml

@@ -0,0 +1,79 @@
+name: Build Desktop App
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [macos-latest, ubuntu-latest, windows-latest]
+
+    runs-on: ${{ matrix.platform }}
+    
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install dependencies (Ubuntu)
+        if: matrix.platform == 'ubuntu-latest'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev libappindicator3-dev librsvg2-dev patchelf
+
+      - name: Install Python dependencies
+        run: |
+          pip install uv
+          uv sync
+
+      - name: Build Python backend with Nuitka
+        run: |
+          pip install nuitka
+          python build_nuitka.py
+
+      - name: Install Node dependencies
+        working-directory: ./dashboard
+        run: npm install
+
+      - name: Build Tauri app
+        working-directory: ./dashboard
+        run: npm run tauri:build
+
+      - name: Upload artifacts (macOS)
+        if: matrix.platform == 'macos-latest'
+        uses: actions/upload-artifact@v4
+        with:
+          name: astrbot-macos
+          path: dashboard/src-tauri/target/release/bundle/dmg/*.dmg
+
+      - name: Upload artifacts (Windows)
+        if: matrix.platform == 'windows-latest'
+        uses: actions/upload-artifact@v4
+        with:
+          name: astrbot-windows
+          path: dashboard/src-tauri/target/release/bundle/msi/*.msi
+
+      - name: Upload artifacts (Linux)
+        if: matrix.platform == 'ubuntu-latest'
+        uses: actions/upload-artifact@v4
+        with:
+          name: astrbot-linux
+          path: |
+            dashboard/src-tauri/target/release/bundle/deb/*.deb
+            dashboard/src-tauri/target/release/bundle/appimage/*.AppImage

.github/workflows/dashboard_ci.yml

@@ -36,7 +36,7 @@ jobs:
           zip -r dist.zip dist
 
       - name: Archive production artifacts
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: dist-without-markdown
           path: |

.github/workflows/smoke_test.yml

@@ -0,0 +1,58 @@
+name: Smoke Test
+
+on:
+  push:
+    branches:
+      - master
+    paths-ignore:
+      - 'README*.md'
+      - 'changelogs/**'
+      - 'dashboard/**'
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  smoke-test:
+    name: Run smoke tests
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.12'
+      
+      - name: Install UV package manager
+        run: |
+          pip install uv
+
+      - name: Install dependencies
+        run: |
+          uv sync
+        timeout-minutes: 15
+
+      - name: Run smoke tests
+        run: |
+          uv run main.py &
+          APP_PID=$!
+
+          echo "Waiting for application to start..."
+          for i in {1..60}; do
+            if curl -f http://localhost:6185 > /dev/null 2>&1; then
+              echo "Application started successfully!"
+              kill $APP_PID
+              exit 0
+            fi
+            sleep 1
+          done
+
+          echo "Application failed to start within 30 seconds"
+          kill $APP_PID 2>/dev/null || true
+          exit 1
+        timeout-minutes: 2

.gitignore

@@ -32,6 +32,7 @@ tests/astrbot_plugin_openai
 # Dashboard
 dashboard/node_modules/
 dashboard/dist/
+dashboard/src-tauri/target
 package-lock.json
 package.json
 yarn.lock
@@ -48,5 +49,6 @@ astrbot.lock
 chroma
 venv/*
 pytest.ini
+build/
 AGENTS.md
 IFLOW.md

BUILD_INSTRUCTIONS.md

@@ -0,0 +1,287 @@
+# AstrBot 桌面应用构建指南
+
+本指南介绍如何使用 Nuitka 将 Python 后端打包并集成到 Tauri 桌面应用中。
+
+## 前置要求
+
+### 系统要求
+- Python 3.10+
+- Node.js 20+
+- Rust (通过 rustup 安装)
+- UV 包管理器
+
+### macOS 额外要求
+- Xcode Command Line Tools: `xcode-select --install`
+
+### Linux 额外要求
+```bash
+sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev \
+  libappindicator3-dev librsvg2-dev patchelf
+```
+
+### Windows 额外要求
+- Visual Studio 2019+ with C++ build tools
+- Windows 10 SDK
+
+## 构建步骤
+
+### 1. 安装 Python 依赖
+```bash
+pip install uv
+uv sync
+```
+
+### 2. 安装 Nuitka
+```bash
+pip install nuitka
+```
+
+### 3. 构建 Python 后端
+```bash
+python build_nuitka.py
+```
+
+这会使用 Nuitka 将 `main.py` 编译为独立可执行文件，输出到 `build/nuitka/` 目录。
+
+**注意**: Nuitka 编译过程可能需要 10-30 分钟，取决于您的系统性能。
+
+### 4. 安装前端依赖
+```bash
+cd dashboard
+npm install
+```
+
+### 5. 构建 Tauri 应用
+```bash
+npm run tauri:build
+```
+
+构建脚本会自动:
+1. 运行 `build_nuitka.py` 编译 Python 后端
+2. 将编译好的可执行文件复制到 `src-tauri/resources/` 目录
+3. 构建 Tauri 应用并打包所有资源
+
+### 6. 查找构建产物
+
+构建完成后，您可以在以下位置找到安装包:
+
+- **macOS**: `dashboard/src-tauri/target/release/bundle/dmg/AstrBot_*.dmg`
+- **Windows**: `dashboard/src-tauri/target/release/bundle/msi/AstrBot_*.msi`
+- **Linux**: 
+  - `dashboard/src-tauri/target/release/bundle/deb/astrbot_*.deb`
+  - `dashboard/src-tauri/target/release/bundle/appimage/astrbot_*.AppImage`
+
+## 开发模式
+
+在开发时，您可能不想每次都完整编译 Python 后端。
+
+### 仅开发 Tauri + Vue
+```bash
+cd dashboard
+npm run tauri:dev
+```
+
+这会启动开发服务器，但不会自动启动 Python 后端。您需要手动运行:
+```bash
+uv run main.py
+```
+
+### 测试完整集成
+如果您想测试 Tauri 自动启动 Python 后端的功能:
+
+1. 先编译一次 Python 后端:
+```bash
+python build_nuitka.py
+```
+
+2. 手动复制到资源目录:
+```bash
+# macOS
+cp -r build/nuitka/main.app dashboard/src-tauri/resources/astrbot-backend.app
+
+# Windows
+copy build\nuitka\main.exe dashboard\src-tauri\resources\astrbot-backend.exe
+
+# Linux
+cp build/nuitka/main.bin dashboard/src-tauri/resources/astrbot-backend
+```
+
+3. 运行开发模式:
+```bash
+cd dashboard
+npm run tauri:dev
+```
+
+## Nuitka 构建选项说明
+
+`build_nuitka.py` 脚本使用以下关键选项:
+
+- `--standalone`: 创建包含所有依赖的独立目录
+- `--onefile`: 将所有内容打包到单个可执行文件
+- `--follow-imports`: 自动跟踪所有 Python 导入
+- `--include-package`: 明确包含特定包
+- `--include-data-dir`: 包含数据目录（插件、配置等）
+
+### 自定义构建
+
+如果您需要修改构建选项，编辑 `build_nuitka.py`:
+
+```python
+# 添加更多要包含的包
+include_packages = [
+    "astrbot",
+    "your_custom_package",
+    # ...
+]
+
+# 添加更多数据目录
+data_includes = [
+    "data/config",
+    "your_custom_data",
+    # ...
+]
+```
+
+## 常见问题
+
+### 1. Nuitka 编译失败
+**问题**: 编译时出现 "module not found" 错误
+
+**解决方案**: 在 `build_nuitka.py` 中添加缺失的包到 `include_packages` 列表
+
+### 2. 运行时找不到资源文件
+**问题**: 应用启动后提示找不到配置文件或插件
+
+**解决方案**: 确保在 `build_nuitka.py` 中使用 `--include-data-dir` 包含了所有必要的数据目录
+
+### 3. macOS 安全警告
+**问题**: macOS 提示"应用来自未知开发者"
+
+**解决方案**: 
+```bash
+# 临时解除限制
+sudo spctl --master-disable
+
+# 或者为特定应用授权
+xattr -cr /Applications/AstrBot.app
+```
+
+对于生产发布，您需要:
+1. 注册 Apple Developer 账号
+2. 对应用进行代码签名
+3. 提交公证 (Notarization)
+
+### 4. Windows Defender 报毒
+**问题**: Windows Defender 或其他杀毒软件报毒
+
+**解决方案**: 
+- 这是 Nuitka 打包程序的常见问题
+- 可以使用 `--windows-company-name` 和 `--windows-product-name` 添加元数据
+- 对于生产发布，需要购买代码签名证书
+
+### 5. Linux 依赖问题
+**问题**: 在某些 Linux 发行版上缺少共享库
+
+**解决方案**: 使用 AppImage 格式，它包含所有依赖:
+```bash
+# 构建时会自动生成 AppImage
+npm run tauri:build
+```
+
+## 优化构建大小
+
+默认的 `--onefile` 模式会生成较大的可执行文件。如果需要减小体积:
+
+1. 移除不需要的包
+2. 使用 `--standalone` 而不是 `--onefile`
+3. 排除不必要的数据文件
+
+修改 `build_nuitka.py`:
+```python
+# 移除 --onefile，使用 --standalone
+nuitka_cmd = [
+    sys.executable,
+    "-m", "nuitka",
+    "--standalone",  # 只使用 standalone
+    # "--onefile",   # 注释掉 onefile
+    # ...
+]
+```
+
+## CI/CD 集成
+
+项目已配置 GitHub Actions 工作流 (`.github/workflows/build-app.yml`)，可以自动为所有平台构建应用。
+
+推送标签时自动触发:
+```bash
+git tag v4.5.7
+git push origin v4.5.7
+```
+
+或手动触发:
+在 GitHub Actions 页面选择 "Build Desktop App" 工作流并点击 "Run workflow"
+
+## 发布清单
+
+在发布新版本前:
+
+- [ ] 更新版本号
+  - `pyproject.toml` - Python 项目版本
+  - `dashboard/package.json` - Node 项目版本
+  - `dashboard/src-tauri/Cargo.toml` - Rust 项目版本
+  - `dashboard/src-tauri/tauri.conf.json` - Tauri 配置版本
+
+- [ ] 运行代码检查
+  ```bash
+  uv run ruff check .
+  uv run ruff format .
+  ```
+
+- [ ] 本地测试构建
+  ```bash
+  python build_nuitka.py
+  cd dashboard && npm run tauri:build
+  ```
+
+- [ ] 测试安装包
+  - 安装生成的安装包
+  - 验证应用启动
+  - 验证 Python 后端自动启动
+  - 测试核心功能
+
+- [ ] 创建发布标签
+  ```bash
+  git tag -a v4.5.7 -m "Release v4.5.7"
+  git push origin v4.5.7
+  ```
+
+## 技术架构
+
+```
+┌─────────────────────────────────────┐
+│         Tauri Desktop App           │
+│  (Rust + WebView)                   │
+│                                     │
+│  ┌─────────────────────────────┐   │
+│  │   Vue.js Dashboard          │   │
+│  │   (Frontend UI)             │   │
+│  └─────────────────────────────┘   │
+│                                     │
+│  ┌─────────────────────────────┐   │
+│  │   Python Backend            │   │
+│  │   (Nuitka Compiled)         │   │
+│  │   - AstrBot Core            │   │
+│  │   - Plugins                 │   │
+│  │   - API Server              │   │
+│  └─────────────────────────────┘   │
+│                                     │
+│         HTTP/WebSocket              │
+│      localhost:6185                 │
+└─────────────────────────────────────┘
+```
+
+## 参考资源
+
+- [Nuitka 文档](https://nuitka.net/doc/user-manual.html)
+- [Tauri 文档](https://tauri.app/v1/guides/)
+- [AstrBot 文档](https://astrbot.fun)

CONTRIBUTING.md

@@ -33,6 +33,20 @@
 - 请使用英文描述您的 PR。
 - 标题请使用 `fix: `, `feat: `, `docs: `, `style: `, `refactor: `, `test: `, `chore: ` 等语义化前缀，并简要描述更改内容。如：`fix: correct login page typo`。
 
+#### 代码规范
+
+##### Core
+
+我们使用 Ruff 作为代码格式化和静态分析工具。在提交代码之前，请运行以下命令以确保代码符合规范：
+
+```bash
+ruff format .
+ruff check .
+```
+
+如果您使用 VSCode，可以安装 `Ruff` 插件。
+
+
 ## Contributing Guide
 
 First off, thanks for taking the time to contribute! ❤️
@@ -62,4 +76,15 @@ We use the `fix/` prefix for bug fixes and the `feat/` prefix for new features.
 
 #### PR Description
 - Please use English to describe your PR.
-- Use semantic prefixes like `fix: `, `feat: `, `docs: `, `style: `, `refactor: `, `test: `, `chore: ` in the title, followed by a brief description of the changes, e.g., `fix: correct login page typo`.
+- Use semantic prefixes like `fix: `, `feat: `, `docs: `, `style: `, `refactor: `, `test: `, `chore: ` in the title, followed by a brief description of the changes, e.g., `fix: correct login page typo`.
+
+#### Code Style
+
+##### Core
+
+We use Ruff as our code formatter and static analysis tool. Before submitting your code, please run the following commands to ensure your code adheres to the style guidelines:
+
+```bash
+ruff format .
+ruff check .
+```

README.md

@@ -20,6 +20,7 @@
 <img src="https://img.shields.io/github/v/release/AstrBotDevs/AstrBot?color=76bad9" href="https://github.com/AstrBotDevs/AstrBot/releases/latest">
 <img src="https://img.shields.io/badge/python-3.10+-blue.svg" alt="python">
 <img src="https://deepwiki.com/badge.svg" href="https://deepwiki.com/AstrBotDevs/AstrBot">
+<a href="https://zread.ai/AstrBotDevs/AstrBot" target="_blank"><img src="https://img.shields.io/badge/Ask_Zread-_.svg?style=flat&color=00b0aa&labelColor=000000&logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHZpZXdCb3g9IjAgMCAxNiAxNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTQuOTYxNTYgMS42MDAxSDIuMjQxNTZDMS44ODgxIDEuNjAwMSAxLjYwMTU2IDEuODg2NjQgMS42MDE1NiAyLjI0MDFWNC45NjAxQzEuNjAxNTYgNS4zMTM1NiAxLjg4ODEgNS42MDAxIDIuMjQxNTYgNS42MDAxSDQuOTYxNTZDNS4zMTUwMiA1LjYwMDEgNS42MDE1NiA1LjMxMzU2IDUuNjAxNTYgNC45NjAxVjIuMjQwMUM1LjYwMTU2IDEuODg2NjQgNS4zMTUwMiAxLjYwMDEgNC45NjE1NiAxLjYwMDFaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik00Ljk2MTU2IDEwLjM5OTlIMi4yNDE1NkMxLjg4ODEgMTAuMzk5OSAxLjYwMTU2IDEwLjY4NjQgMS42MDE1NiAxMS4wMzk5VjEzLjc1OTlDMS42MDE1NiAxNC4xMTM0IDEuODg4MSAxNC4zOTk5IDIuMjQxNTYgMTQuMzk5OUg0Ljk2MTU2QzUuMzE1MDIgMTQuMzk5OSA1LjYwMTU2IDE0LjExMzQgNS42MDE1NiAxMy43NTk5VjExLjAzOTlDNS42MDE1NiAxMC42ODY0IDUuMzE1MDIgMTAuMzk5OSA0Ljk2MTU2IDEwLjM5OTlaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik0xMy43NTg0IDEuNjAwMUgxMS4wMzg0QzEwLjY4NSAxLjYwMDEgMTAuMzk4NCAxLjg4NjY0IDEwLjM5ODQgMi4yNDAxVjQuOTYwMUMxMC4zOTg0IDUuMzEzNTYgMTAuNjg1IDUuNjAwMSAxMS4wMzg0IDUuNjAwMUgxMy43NTg0QzE0LjExMTkgNS42MDAxIDE0LjM5ODQgNS4zMTM1NiAxNC4zOTg0IDQuOTYwMVYyLjI0MDFDMTQuMzk4NCAxLjg4NjY0IDE0LjExMTkgMS42MDAxIDEzLjc1ODQgMS42MDAxWiIgZmlsbD0iI2ZmZiIvPgo8cGF0aCBkPSJNNCAxMkwxMiA0TDQgMTJaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik00IDEyTDEyIDQiIHN0cm9rZT0iI2ZmZiIgc3Ryb2tlLXdpZHRoPSIxLjUiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIvPgo8L3N2Zz4K&logoColor=ffffff" alt="zread"/></a>
 <a href="https://hub.docker.com/r/soulter/astrbot"><img alt="Docker pull" src="https://img.shields.io/docker/pulls/soulter/astrbot.svg?color=76bad9"/></a>
 <img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.soulter.top%2Fastrbot%2Fplugin-num&query=%24.result&suffix=%E4%B8%AA&label=%E6%8F%92%E4%BB%B6%E5%B8%82%E5%9C%BA&cacheSeconds=3600">
 <img src="https://gitcode.com/Soulter/AstrBot/star/badge.svg" href="https://gitcode.com/Soulter/AstrBot">
@@ -206,6 +207,7 @@ pre-commit install
 - 3 群：630166526
 - 5 群：822130018
 - 6 群：753075035
+- 7 群：743746109
 - 开发者群：975206796
 
 ### Telegram 群组
@@ -241,4 +243,10 @@ pre-commit install
 
 </details>
 
+<div align="center">
+
 _私は、高性能ですから!_
+
+<img src="https://files.astrbot.app/watashiwa-koseino-desukara.gif" width="100"/>
+</div
+

astrbot/cli/__init__.py

@@ -1 +1 @@
-__version__ = "4.8.0"
+__version__ = "4.9.2"

astrbot/core/agent/message.py

@@ -3,7 +3,7 @@
 
 from typing import Any, ClassVar, Literal, cast
 
-from pydantic import BaseModel, GetCoreSchemaHandler, model_validator
+from pydantic import BaseModel, GetCoreSchemaHandler, model_serializer, model_validator
 from pydantic_core import core_schema
 
 
@@ -122,10 +122,12 @@ class ToolCall(BaseModel):
     extra_content: dict[str, Any] | None = None
     """Extra metadata for the tool call."""
 
-    def model_dump(self, **kwargs: Any) -> dict[str, Any]:
+    @model_serializer(mode="wrap")
+    def serialize(self, handler):
+        data = handler(self)
         if self.extra_content is None:
-            kwargs.setdefault("exclude", set()).add("extra_content")
-        return super().model_dump(**kwargs)
+            data.pop("extra_content", None)
+        return data
 
 
 class ToolCallPart(BaseModel):

astrbot/core/agent/response.py

@@ -1,7 +1,8 @@
 import typing as T
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 from astrbot.core.message.message_event_result import MessageChain
+from astrbot.core.provider.entities import TokenUsage
 
 
 class AgentResponseData(T.TypedDict):
@@ -12,3 +13,23 @@ class AgentResponseData(T.TypedDict):
 class AgentResponse:
     type: str
     data: AgentResponseData
+
+
+@dataclass
+class AgentStats:
+    token_usage: TokenUsage = field(default_factory=TokenUsage)
+    start_time: float = 0.0
+    end_time: float = 0.0
+    time_to_first_token: float = 0.0
+
+    @property
+    def duration(self) -> float:
+        return self.end_time - self.start_time
+
+    def to_dict(self) -> dict:
+        return {
+            "token_usage": self.token_usage.__dict__,
+            "start_time": self.start_time,
+            "end_time": self.end_time,
+            "time_to_first_token": self.time_to_first_token,
+        }

astrbot/core/agent/run_context.py

@@ -9,7 +9,7 @@ from .message import Message
 TContext = TypeVar("TContext", default=Any)
 
 
-@dataclass(config={"arbitrary_types_allowed": True})
+@dataclass
 class ContextWrapper(Generic[TContext]):
     """A context for running an agent, which can be used to pass additional data or state."""
 

astrbot/core/agent/runners/tool_loop_agent_runner.py

@@ -1,4 +1,5 @@
 import sys
+import time
 import traceback
 import typing as T
 
@@ -12,6 +13,7 @@ from mcp.types import (
 )
 
 from astrbot import logger
+from astrbot.core.message.components import Json
 from astrbot.core.message.message_event_result import (
     MessageChain,
 )
@@ -24,7 +26,7 @@ from astrbot.core.provider.provider import Provider
 
 from ..hooks import BaseAgentRunHooks
 from ..message import AssistantMessageSegment, Message, ToolCallMessageSegment
-from ..response import AgentResponseData
+from ..response import AgentResponseData, AgentStats
 from ..run_context import ContextWrapper, TContext
 from ..tool_executor import BaseFunctionToolExecutor
 from .base import AgentResponse, AgentState, BaseAgentRunner
@@ -69,6 +71,9 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
             )
         self.run_context.messages = messages
 
+        self.stats = AgentStats()
+        self.stats.start_time = time.time()
+
     async def _iter_llm_responses(self) -> T.AsyncGenerator[LLMResponse, None]:
         """Yields chunks *and* a final LLMResponse."""
         if self.streaming:
@@ -97,8 +102,11 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
         llm_resp_result = None
 
         async for llm_response in self._iter_llm_responses():
-            assert isinstance(llm_response, LLMResponse)
             if llm_response.is_chunk:
+                # update ttft
+                if self.stats.time_to_first_token == 0:
+                    self.stats.time_to_first_token = time.time() - self.stats.start_time
+
                 if llm_response.result_chain:
                     yield AgentResponse(
                         type="streaming_delta",
@@ -122,6 +130,10 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                     )
                 continue
             llm_resp_result = llm_response
+
+            if not llm_response.is_chunk and llm_response.usage:
+                # only count the token usage of the final response for computation purpose
+                self.stats.token_usage += llm_response.usage
             break  # got final response
 
         if not llm_resp_result:
@@ -133,6 +145,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
         if llm_resp.role == "err":
             # 如果 LLM 响应错误，转换到错误状态
             self.final_llm_resp = llm_resp
+            self.stats.end_time = time.time()
             self._transition_state(AgentState.ERROR)
             yield AgentResponse(
                 type="err",
@@ -147,6 +160,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
             # 如果没有工具调用，转换到完成状态
             self.final_llm_resp = llm_resp
             self._transition_state(AgentState.DONE)
+            self.stats.end_time = time.time()
             # record the final assistant message
             self.run_context.messages.append(
                 Message(
@@ -176,22 +190,19 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
         # 如果有工具调用，还需处理工具调用
         if llm_resp.tools_call_name:
             tool_call_result_blocks = []
-            for tool_call_name in llm_resp.tools_call_name:
-                yield AgentResponse(
-                    type="tool_call",
-                    data=AgentResponseData(
-                        chain=MessageChain(type="tool_call").message(
-                            f"🔨 调用工具: {tool_call_name}"
-                        ),
-                    ),
-                )
             async for result in self._handle_function_tools(self.req, llm_resp):
                 if isinstance(result, list):
                     tool_call_result_blocks = result
                 elif isinstance(result, MessageChain):
-                    result.type = "tool_call_result"
+                    if result.type is None:
+                        # should not happen
+                        continue
+                    if result.type == "tool_direct_result":
+                        ar_type = "tool_call_result"
+                    else:
+                        ar_type = result.type
                     yield AgentResponse(
-                        type="tool_call_result",
+                        type=ar_type,
                         data=AgentResponseData(chain=result),
                     )
             # 将结果添加到上下文中
@@ -234,6 +245,19 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
             llm_response.tools_call_args,
             llm_response.tools_call_ids,
         ):
+            yield MessageChain(
+                type="tool_call",
+                chain=[
+                    Json(
+                        data={
+                            "id": func_tool_id,
+                            "name": func_tool_name,
+                            "args": func_tool_args,
+                            "ts": time.time(),
+                        }
+                    )
+                ],
+            )
             try:
                 if not req.func_tool:
                     return
@@ -307,7 +331,6 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                                     content=res.content[0].text,
                                 ),
                             )
-                            yield MessageChain().message(res.content[0].text)
                         elif isinstance(res.content[0], ImageContent):
                             tool_call_result_blocks.append(
                                 ToolCallMessageSegment(
@@ -329,7 +352,6 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                                         content=resource.text,
                                     ),
                                 )
-                                yield MessageChain().message(resource.text)
                             elif (
                                 isinstance(resource, BlobResourceContents)
                                 and resource.mimeType
@@ -353,7 +375,22 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                                         content="返回的数据类型不受支持",
                                     ),
                                 )
-                                yield MessageChain().message("返回的数据类型不受支持。")
+
+                        # yield the last tool call result
+                        if tool_call_result_blocks:
+                            last_tcr_content = str(tool_call_result_blocks[-1].content)
+                            yield MessageChain(
+                                type="tool_call_result",
+                                chain=[
+                                    Json(
+                                        data={
+                                            "id": func_tool_id,
+                                            "ts": time.time(),
+                                            "result": last_tcr_content,
+                                        }
+                                    )
+                                ],
+                            )
 
                     elif resp is None:
                         # Tool 直接请求发送消息给用户
@@ -363,6 +400,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                             f"{func_tool_name} 没有没有返回值或者将结果直接发送给用户，此工具调用不会被记录到历史中。"
                         )
                         self._transition_state(AgentState.DONE)
+                        self.stats.end_time = time.time()
                     else:
                         # 不应该出现其他类型
                         logger.warning(

astrbot/core/agent/tool.py

@@ -1,4 +1,4 @@
-from collections.abc import Awaitable, Callable
+from collections.abc import AsyncGenerator, Awaitable, Callable
 from typing import Any, Generic
 
 import jsonschema
@@ -7,6 +7,8 @@ from deprecated import deprecated
 from pydantic import Field, model_validator
 from pydantic.dataclasses import dataclass
 
+from astrbot.core.message.message_event_result import MessageEventResult
+
 from .run_context import ContextWrapper, TContext
 
 ParametersType = dict[str, Any]
@@ -38,7 +40,10 @@ class ToolSchema:
 class FunctionTool(ToolSchema, Generic[TContext]):
     """A callable tool, for function calling."""
 
-    handler: Callable[..., Awaitable[Any]] | None = None
+    handler: (
+        Callable[..., Awaitable[str | None] | AsyncGenerator[MessageEventResult, None]]
+        | None
+    ) = None
     """a callable that implements the tool's functionality. It should be an async function."""
 
     handler_module_path: str | None = None

astrbot/core/astr_agent_context.py

@@ -6,8 +6,10 @@ from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.star.context import Context
 
 
-@dataclass(config={"arbitrary_types_allowed": True})
+@dataclass
 class AstrAgentContext:
+    __pydantic_config__ = {"arbitrary_types_allowed": True}
+
     context: Context
     """The star context instance"""
     event: AstrMessageEvent

astrbot/core/astr_agent_run_util.py

@@ -4,6 +4,7 @@ from collections.abc import AsyncGenerator
 from astrbot.core import logger
 from astrbot.core.agent.runners.tool_loop_agent_runner import ToolLoopAgentRunner
 from astrbot.core.astr_agent_context import AstrAgentContext
+from astrbot.core.message.components import Json
 from astrbot.core.message.message_event_result import (
     MessageChain,
     MessageEventResult,
@@ -33,16 +34,27 @@ async def run_agent(
                     msg_chain = resp.data["chain"]
                     if msg_chain.type == "tool_direct_result":
                         # tool_direct_result 用于标记 llm tool 需要直接发送给用户的内容
-                        await astr_event.send(resp.data["chain"])
+                        await astr_event.send(msg_chain)
                         continue
+                    if astr_event.get_platform_id() == "webchat":
+                        await astr_event.send(msg_chain)
                     # 对于其他情况，暂时先不处理
                     continue
                 elif resp.type == "tool_call":
                     if agent_runner.streaming:
                         # 用来标记流式响应需要分节
                         yield MessageChain(chain=[], type="break")
-                    if show_tool_use:
+
+                    if astr_event.get_platform_name() == "webchat":
                         await astr_event.send(resp.data["chain"])
+                    elif show_tool_use:
+                        json_comp = resp.data["chain"].chain[0]
+                        if isinstance(json_comp, Json):
+                            m = f"🔨 调用工具: {json_comp.data.get('name')}"
+                        else:
+                            m = "🔨 调用工具..."
+                        chain = MessageChain(type="tool_call").message(m)
+                        await astr_event.send(chain)
                     continue
 
                 if stream_to_general and resp.type == "streaming_delta":
@@ -69,6 +81,15 @@ async def run_agent(
                         continue
                     yield resp.data["chain"]  # MessageChain
             if agent_runner.done():
+                # send agent stats to webchat
+                if astr_event.get_platform_name() == "webchat":
+                    await astr_event.send(
+                        MessageChain(
+                            type="agent_stats",
+                            chain=[Json(data=agent_runner.stats.to_dict())],
+                        )
+                    )
+
                 break
 
         except Exception as e:

astrbot/core/astr_agent_tool_exec.py

@@ -185,7 +185,11 @@ class FunctionToolExecutor(BaseFunctionToolExecutor[AstrAgentContext]):
 
 async def call_local_llm_tool(
     context: ContextWrapper[AstrAgentContext],
-    handler: T.Callable[..., T.Awaitable[T.Any]],
+    handler: T.Callable[
+        ...,
+        T.Awaitable[MessageEventResult | mcp.types.CallToolResult | str | None]
+        | T.AsyncGenerator[MessageEventResult | CommandResult | str | None, None],
+    ],
     method_name: str,
     *args,
     **kwargs,

astrbot/core/config/astrbot_config.py

@@ -24,6 +24,10 @@ class AstrBotConfig(dict):
     - 如果传入了 schema，将会通过 schema 解析出 default_config，此时传入的 default_config 会被忽略。
     """
 
+    config_path: str
+    default_config: dict
+    schema: dict | None
+
     def __init__(
         self,
         config_path: str = ASTRBOT_CONFIG_PATH,

astrbot/core/config/default.py

@@ -4,7 +4,7 @@ import os
 
 from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 
-VERSION = "4.8.0"
+VERSION = "4.9.2"
 DB_PATH = os.path.join(get_astrbot_data_path(), "data_v4.db")
 
 WEBHOOK_SUPPORTED_PLATFORMS = [
@@ -13,6 +13,7 @@ WEBHOOK_SUPPORTED_PLATFORMS = [
     "wecom",
     "wecom_ai_bot",
     "slack",
+    "lark",
 ]
 
 # 默认配置
@@ -42,7 +43,15 @@ DEFAULT_CONFIG = {
             "interval": "1.5,3.5",
             "log_base": 2.6,
             "words_count_threshold": 150,
+            "split_mode": "regex",  # regex 或 words
             "regex": ".*?[。？！~…]+|.+$",
+            "split_words": [
+                "。",
+                "？",
+                "！",
+                "~",
+                "…",
+            ],  # 当 split_mode 为 words 时使用
             "content_cleanup_rule": "",
         },
         "no_permission_reply": True,
@@ -99,6 +108,7 @@ DEFAULT_CONFIG = {
         "provider_id": "",
         "dual_output": False,
         "use_file_service": False,
+        "trigger_probability": 1.0,
     },
     "provider_ltm_settings": {
         "group_icl_enable": False,
@@ -157,6 +167,7 @@ DEFAULT_CONFIG = {
     "kb_fusion_top_k": 20,  # 知识库检索融合阶段返回结果数量
     "kb_final_top_k": 5,  # 知识库检索最终返回结果数量
     "kb_agentic_mode": False,
+    "disable_builtin_commands": False,
 }
 
 
@@ -198,7 +209,7 @@ CONFIG_METADATA_2 = {
                         "callback_server_host": "0.0.0.0",
                         "port": 6196,
                     },
-                    "QQ 个人号(OneBot v11)": {
+                    "OneBot v11": {
                         "id": "default",
                         "type": "aiocqhttp",
                         "enable": False,
@@ -268,6 +279,10 @@ CONFIG_METADATA_2 = {
                         "app_id": "",
                         "app_secret": "",
                         "domain": "https://open.feishu.cn",
+                        "lark_connection_mode": "socket",  # webhook, socket
+                        "webhook_uuid": "",
+                        "lark_encrypt_key": "",
+                        "lark_verification_token": "",
                     },
                     "钉钉(DingTalk)": {
                         "id": "dingtalk",
@@ -361,6 +376,28 @@ CONFIG_METADATA_2 = {
                     #     "type": "string",
                     #     "options": ["fullscreen", "embedded"],
                     # },
+                    "lark_connection_mode": {
+                        "description": "订阅方式",
+                        "type": "string",
+                        "options": ["socket", "webhook"],
+                        "labels": ["长连接模式", "推送至服务器模式"],
+                    },
+                    "lark_encrypt_key": {
+                        "description": "Encrypt Key",
+                        "type": "string",
+                        "hint": "用于解密飞书回调数据的加密密钥",
+                        "condition": {
+                            "lark_connection_mode": "webhook",
+                        },
+                    },
+                    "lark_verification_token": {
+                        "description": "Verification Token",
+                        "type": "string",
+                        "hint": "用于验证飞书回调请求的令牌",
+                        "condition": {
+                            "lark_connection_mode": "webhook",
+                        },
+                    },
                     "is_sandbox": {
                         "description": "沙箱模式",
                         "type": "bool",
@@ -909,7 +946,7 @@ CONFIG_METADATA_2 = {
                         "api_base": "https://generativelanguage.googleapis.com/v1beta/openai/",
                         "timeout": 120,
                         "model_config": {
-                            "model": "gemini-1.5-flash",
+                            "model": "gemini-3-flash-preview",
                             "temperature": 0.4,
                         },
                         "custom_headers": {},
@@ -926,7 +963,7 @@ CONFIG_METADATA_2 = {
                         "api_base": "https://generativelanguage.googleapis.com/",
                         "timeout": 120,
                         "model_config": {
-                            "model": "gemini-2.0-flash-exp",
+                            "model": "gemini-3-flash-preview",
                             "temperature": 0.4,
                         },
                         "gm_resp_image_modal": False,
@@ -939,9 +976,7 @@ CONFIG_METADATA_2 = {
                             "sexually_explicit": "BLOCK_MEDIUM_AND_ABOVE",
                             "dangerous_content": "BLOCK_MEDIUM_AND_ABOVE",
                         },
-                        "gm_thinking_config": {
-                            "budget": 0,
-                        },
+                        "gm_thinking_config": {"budget": 0, "level": "HIGH"},
                         "modalities": ["text", "image", "tool_use"],
                     },
                     "DeepSeek": {
@@ -1782,13 +1817,24 @@ CONFIG_METADATA_2 = {
                         },
                     },
                     "gm_thinking_config": {
-                        "description": "Gemini思考设置",
+                        "description": "Thinking Config",
                         "type": "object",
                         "items": {
                             "budget": {
-                                "description": "思考预算",
+                                "description": "Thinking Budget",
                                 "type": "int",
-                                "hint": "模型应该生成的思考Token的数量，设为0关闭思考。除gemini-2.5-flash外的模型会静默忽略此参数。",
+                                "hint": "Guides the model on the specific number of thinking tokens to use for reasoning. See: https://ai.google.dev/gemini-api/docs/thinking#set-budget",
+                            },
+                            "level": {
+                                "description": "Thinking Level",
+                                "type": "string",
+                                "hint": "Recommended for Gemini 3 models and onwards, lets you control reasoning behavior.See: https://ai.google.dev/gemini-api/docs/thinking#thinking-levels",
+                                "options": [
+                                    "MINIMAL",
+                                    "LOW",
+                                    "MEDIUM",
+                                    "HIGH",
+                                ],
                             },
                         },
                     },
@@ -2173,6 +2219,9 @@ CONFIG_METADATA_2 = {
                     "use_file_service": {
                         "type": "bool",
                     },
+                    "trigger_probability": {
+                        "type": "float",
+                    },
                 },
             },
             "provider_ltm_settings": {
@@ -2383,6 +2432,14 @@ CONFIG_METADATA_3 = {
                             "provider_tts_settings.enable": True,
                         },
                     },
+                    "provider_tts_settings.trigger_probability": {
+                        "description": "TTS 触发概率",
+                        "type": "float",
+                        "slider": {"min": 0, "max": 1, "step": 0.05},
+                        "condition": {
+                            "provider_tts_settings.enable": True,
+                        },
+                    },
                     "provider_settings.image_caption_prompt": {
                         "description": "图片转述提示词",
                         "type": "text",
@@ -2661,6 +2718,11 @@ CONFIG_METADATA_3 = {
                         "description": "只 @ 机器人是否触发等待",
                         "type": "bool",
                     },
+                    "disable_builtin_commands": {
+                        "description": "禁用自带指令",
+                        "type": "bool",
+                        "hint": "禁用所有 AstrBot 的自带指令，如 help, provider, model 等。",
+                    },
                 },
             },
             "whitelist": {
@@ -2875,9 +2937,26 @@ CONFIG_METADATA_3 = {
                         "description": "分段回复字数阈值",
                         "type": "int",
                     },
+                    "platform_settings.segmented_reply.split_mode": {
+                        "description": "分段模式",
+                        "type": "string",
+                        "options": ["regex", "words"],
+                        "labels": ["正则表达式", "分段词列表"],
+                    },
                     "platform_settings.segmented_reply.regex": {
                         "description": "分段正则表达式",
                         "type": "string",
+                        "condition": {
+                            "platform_settings.segmented_reply.split_mode": "regex",
+                        },
+                    },
+                    "platform_settings.segmented_reply.split_words": {
+                        "description": "分段词列表",
+                        "type": "list",
+                        "hint": "检测到列表中的任意词时进行分段，如：。、？、！等",
+                        "condition": {
+                            "platform_settings.segmented_reply.split_mode": "words",
+                        },
                     },
                     "platform_settings.segmented_reply.content_cleanup_rule": {
                         "description": "内容过滤正则表达式",
@@ -2928,6 +3007,7 @@ CONFIG_METADATA_3 = {
                         "description": "回复概率",
                         "type": "float",
                         "hint": "0.0-1.0 之间的数值",
+                        "slider": {"min": 0, "max": 1, "step": 0.05},
                         "condition": {
                             "provider_ltm_settings.active_reply.enable": True,
                         },

astrbot/core/config/i18n_utils.py

@@ -79,6 +79,7 @@ class ConfigMetadataI18n:
                             "_special",
                             "invisible",
                             "options",
+                            "slider",
                         ]:
                             if attr in field_data:
                                 field_result[attr] = field_data[attr]

astrbot/core/core_lifecycle.py

@@ -197,7 +197,7 @@ class AstrBotCoreLifecycle:
         # 把插件中注册的所有协程函数注册到事件总线中并执行
         extra_tasks = []
         for task in self.star_context._register_tasks:
-            extra_tasks.append(asyncio.create_task(task, name=task.__name__))
+            extra_tasks.append(asyncio.create_task(task, name=task.__name__))  # type: ignore
 
         tasks_ = [event_bus_task, *extra_tasks]
         for task in tasks_:

astrbot/core/db/__init__.py

@@ -5,11 +5,12 @@ from contextlib import asynccontextmanager
 from dataclasses import dataclass
 
 from deprecated import deprecated
-from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
 
 from astrbot.core.db.po import (
     Attachment,
+    CommandConfig,
+    CommandConflict,
     ConversationV2,
     Persona,
     PlatformMessageHistory,
@@ -32,7 +33,7 @@ class BaseDatabase(abc.ABC):
             echo=False,
             future=True,
         )
-        self.AsyncSessionLocal = sessionmaker(
+        self.AsyncSessionLocal = async_sessionmaker(
             self.engine,
             class_=AsyncSession,
             expire_on_commit=False,
@@ -315,6 +316,76 @@ class BaseDatabase(abc.ABC):
         """Clear all preferences for a specific scope ID."""
         ...
 
+    @abc.abstractmethod
+    async def get_command_configs(self) -> list[CommandConfig]:
+        """Get all stored command configurations."""
+        ...
+
+    @abc.abstractmethod
+    async def get_command_config(self, handler_full_name: str) -> CommandConfig | None:
+        """Fetch a single command configuration by handler."""
+        ...
+
+    @abc.abstractmethod
+    async def upsert_command_config(
+        self,
+        handler_full_name: str,
+        plugin_name: str,
+        module_path: str,
+        original_command: str,
+        *,
+        resolved_command: str | None = None,
+        enabled: bool | None = None,
+        keep_original_alias: bool | None = None,
+        conflict_key: str | None = None,
+        resolution_strategy: str | None = None,
+        note: str | None = None,
+        extra_data: dict | None = None,
+        auto_managed: bool | None = None,
+    ) -> CommandConfig:
+        """Create or update a command configuration."""
+        ...
+
+    @abc.abstractmethod
+    async def delete_command_config(self, handler_full_name: str) -> None:
+        """Delete a single command configuration."""
+        ...
+
+    @abc.abstractmethod
+    async def delete_command_configs(self, handler_full_names: list[str]) -> None:
+        """Bulk delete command configurations."""
+        ...
+
+    @abc.abstractmethod
+    async def list_command_conflicts(
+        self,
+        status: str | None = None,
+    ) -> list[CommandConflict]:
+        """List recorded command conflict entries."""
+        ...
+
+    @abc.abstractmethod
+    async def upsert_command_conflict(
+        self,
+        conflict_key: str,
+        handler_full_name: str,
+        plugin_name: str,
+        *,
+        status: str | None = None,
+        resolution: str | None = None,
+        resolved_command: str | None = None,
+        note: str | None = None,
+        extra_data: dict | None = None,
+        auto_generated: bool | None = None,
+    ) -> CommandConflict:
+        """Create or update a conflict record."""
+        ...
+
+    @abc.abstractmethod
+    async def delete_command_conflicts(self, ids: list[int]) -> None:
+        """Delete conflict records."""
+        ...
+
     # @abc.abstractmethod
     # async def insert_llm_message(
     #     self,

astrbot/core/db/migration/migra_3_to_4.py

@@ -70,6 +70,7 @@ async def migration_conversation_table(
                         logger.info(
                             f"未找到该条旧会话对应的具体数据: {conversation}, 跳过。",
                         )
+                        continue
                     if ":" not in conv.user_id:
                         continue
                     session = MessageSesion.from_str(session_str=conv.user_id)
@@ -207,6 +208,7 @@ async def migration_webchat_data(
                         logger.info(
                             f"未找到该条旧会话对应的具体数据: {conversation}, 跳过。",
                         )
+                        continue
                     if ":" in conv.user_id:
                         continue
                     platform_id = "webchat"

astrbot/core/db/migration/sqlite_v3.py

@@ -127,7 +127,7 @@ class SQLiteDatabase:
         conn.text_factory = str
         return conn
 
-    def _exec_sql(self, sql: str, params: tuple = None):
+    def _exec_sql(self, sql: str, params: tuple | None = None):
         conn = self.conn
         try:
             c = self.conn.cursor()
@@ -224,9 +224,11 @@ class SQLiteDatabase:
 
         c.close()
 
-        return Stats(platform, [], [])
+        return Stats(platform)
 
-    def get_conversation_by_user_id(self, user_id: str, cid: str) -> Conversation:
+    def get_conversation_by_user_id(
+        self, user_id: str, cid: str
+    ) -> Conversation | None:
         try:
             c = self.conn.cursor()
         except sqlite3.ProgrammingError:
@@ -258,7 +260,7 @@ class SQLiteDatabase:
             (user_id, cid, history, updated_at, created_at),
         )
 
-    def get_conversations(self, user_id: str) -> tuple:
+    def get_conversations(self, user_id: str) -> list[Conversation]:
         try:
             c = self.conn.cursor()
         except sqlite3.ProgrammingError:

astrbot/core/db/po.py

@@ -12,7 +12,7 @@ class PlatformStat(SQLModel, table=True):
     Note: In astrbot v4, we moved `platform` table to here.
     """
 
-    __tablename__ = "platform_stats"  # type: ignore
+    __tablename__: str = "platform_stats"
 
     id: int = Field(primary_key=True, sa_column_kwargs={"autoincrement": True})
     timestamp: datetime = Field(nullable=False)
@@ -31,9 +31,10 @@ class PlatformStat(SQLModel, table=True):
 
 
 class ConversationV2(SQLModel, table=True):
-    __tablename__ = "conversations"  # type: ignore
+    __tablename__: str = "conversations"
 
-    inner_conversation_id: int = Field(
+    inner_conversation_id: int | None = Field(
+        default=None,
         primary_key=True,
         sa_column_kwargs={"autoincrement": True},
     )
@@ -68,7 +69,7 @@ class Persona(SQLModel, table=True):
     It can be used to customize the behavior of LLMs.
     """
 
-    __tablename__ = "personas"  # type: ignore
+    __tablename__: str = "personas"
 
     id: int | None = Field(
         primary_key=True,
@@ -98,7 +99,7 @@ class Persona(SQLModel, table=True):
 class Preference(SQLModel, table=True):
     """This class represents preferences for bots."""
 
-    __tablename__ = "preferences"  # type: ignore
+    __tablename__: str = "preferences"
 
     id: int | None = Field(
         default=None,
@@ -134,7 +135,7 @@ class PlatformMessageHistory(SQLModel, table=True):
     or platform-specific messages.
     """
 
-    __tablename__ = "platform_message_history"  # type: ignore
+    __tablename__: str = "platform_message_history"
 
     id: int | None = Field(
         primary_key=True,
@@ -162,7 +163,7 @@ class PlatformSession(SQLModel, table=True):
     Each session can have multiple conversations (对话) associated with it.
     """
 
-    __tablename__ = "platform_sessions"  # type: ignore
+    __tablename__: str = "platform_sessions"
 
     inner_id: int | None = Field(
         primary_key=True,
@@ -203,7 +204,7 @@ class Attachment(SQLModel, table=True):
     Attachments can be images, files, or other media types.
     """
 
-    __tablename__ = "attachments"  # type: ignore
+    __tablename__: str = "attachments"
 
     inner_attachment_id: int | None = Field(
         primary_key=True,
@@ -233,6 +234,65 @@ class Attachment(SQLModel, table=True):
     )
 
 
+class CommandConfig(SQLModel, table=True):
+    """Per-command configuration overrides for dashboard management."""
+
+    __tablename__ = "command_configs"  # type: ignore
+
+    handler_full_name: str = Field(
+        primary_key=True,
+        max_length=512,
+    )
+    plugin_name: str = Field(nullable=False, max_length=255)
+    module_path: str = Field(nullable=False, max_length=255)
+    original_command: str = Field(nullable=False, max_length=255)
+    resolved_command: str | None = Field(default=None, max_length=255)
+    enabled: bool = Field(default=True, nullable=False)
+    keep_original_alias: bool = Field(default=False, nullable=False)
+    conflict_key: str | None = Field(default=None, max_length=255)
+    resolution_strategy: str | None = Field(default=None, max_length=64)
+    note: str | None = Field(default=None, sa_type=Text)
+    extra_data: dict | None = Field(default=None, sa_type=JSON)
+    auto_managed: bool = Field(default=False, nullable=False)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    updated_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        sa_column_kwargs={"onupdate": datetime.now(timezone.utc)},
+    )
+
+
+class CommandConflict(SQLModel, table=True):
+    """Conflict tracking for duplicated command names."""
+
+    __tablename__ = "command_conflicts"  # type: ignore
+
+    id: int | None = Field(
+        default=None, primary_key=True, sa_column_kwargs={"autoincrement": True}
+    )
+    conflict_key: str = Field(nullable=False, max_length=255)
+    handler_full_name: str = Field(nullable=False, max_length=512)
+    plugin_name: str = Field(nullable=False, max_length=255)
+    status: str = Field(default="pending", max_length=32)
+    resolution: str | None = Field(default=None, max_length=64)
+    resolved_command: str | None = Field(default=None, max_length=255)
+    note: str | None = Field(default=None, sa_type=Text)
+    extra_data: dict | None = Field(default=None, sa_type=JSON)
+    auto_generated: bool = Field(default=False, nullable=False)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    updated_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        sa_column_kwargs={"onupdate": datetime.now(timezone.utc)},
+    )
+
+    __table_args__ = (
+        UniqueConstraint(
+            "conflict_key",
+            "handler_full_name",
+            name="uix_conflict_handler",
+        ),
+    )
+
+
 @dataclass
 class Conversation:
     """LLM 对话类
@@ -261,17 +321,17 @@ class Personality(TypedDict):
     在 v4.0.0 版本及之后，推荐使用上面的 Persona 类。并且， mood_imitation_dialogs 字段已被废弃。
     """
 
-    prompt: str = ""
-    name: str = ""
-    begin_dialogs: list[str] = []
-    mood_imitation_dialogs: list[str] = []
+    prompt: str
+    name: str
+    begin_dialogs: list[str]
+    mood_imitation_dialogs: list[str]
     """情感模拟对话预设。在 v4.0.0 版本及之后，已被废弃。"""
-    tools: list[str] | None = None
+    tools: list[str] | None
     """工具列表。None 表示使用所有工具，空列表表示不使用任何工具"""
 
     # cache
-    _begin_dialogs_processed: list[dict] = []
-    _mood_imitation_dialogs_processed: str = ""
+    _begin_dialogs_processed: list[dict]
+    _mood_imitation_dialogs_processed: str
 
 
 # ====

astrbot/core/db/sqlite.py

@@ -1,14 +1,18 @@
 import asyncio
 import threading
 import typing as T
+from collections.abc import Awaitable, Callable
 from datetime import datetime, timedelta, timezone
 
+from sqlalchemy import CursorResult
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlmodel import col, delete, desc, func, or_, select, text, update
 
 from astrbot.core.db import BaseDatabase
 from astrbot.core.db.po import (
     Attachment,
+    CommandConfig,
+    CommandConflict,
     ConversationV2,
     Persona,
     PlatformMessageHistory,
@@ -25,6 +29,7 @@ from astrbot.core.db.po import (
 )
 
 NOT_GIVEN = T.TypeVar("NOT_GIVEN")
+TxResult = T.TypeVar("TxResult")
 
 
 class SQLiteDatabase(BaseDatabase):
@@ -489,7 +494,7 @@ class SQLiteDatabase(BaseDatabase):
         async with self.get_db() as session:
             session: AsyncSession
             query = select(Attachment).where(
-                Attachment.attachment_id.in_(attachment_ids)
+                col(Attachment.attachment_id).in_(attachment_ids)
             )
             result = await session.execute(query)
             return list(result.scalars().all())
@@ -505,7 +510,7 @@ class SQLiteDatabase(BaseDatabase):
                 query = delete(Attachment).where(
                     col(Attachment.attachment_id) == attachment_id
                 )
-                result = await session.execute(query)
+                result = T.cast(CursorResult, await session.execute(query))
                 return result.rowcount > 0
 
     async def delete_attachments(self, attachment_ids: list[str]) -> int:
@@ -521,7 +526,7 @@ class SQLiteDatabase(BaseDatabase):
                 query = delete(Attachment).where(
                     col(Attachment.attachment_id).in_(attachment_ids)
                 )
-                result = await session.execute(query)
+                result = T.cast(CursorResult, await session.execute(query))
                 return result.rowcount
 
     async def insert_persona(
@@ -669,6 +674,242 @@ class SQLiteDatabase(BaseDatabase):
                 )
             await session.commit()
 
+    # ====
+    # Command Configuration & Conflict Tracking
+    # ====
+
+    async def _run_in_tx(
+        self,
+        fn: Callable[[AsyncSession], Awaitable[TxResult]],
+    ) -> TxResult:
+        async with self.get_db() as session:
+            session: AsyncSession
+            async with session.begin():
+                return await fn(session)
+
+    @staticmethod
+    def _apply_updates(model, **updates) -> None:
+        for field, value in updates.items():
+            if value is not None:
+                setattr(model, field, value)
+
+    @staticmethod
+    def _new_command_config(
+        handler_full_name: str,
+        plugin_name: str,
+        module_path: str,
+        original_command: str,
+        *,
+        resolved_command: str | None = None,
+        enabled: bool | None = None,
+        keep_original_alias: bool | None = None,
+        conflict_key: str | None = None,
+        resolution_strategy: str | None = None,
+        note: str | None = None,
+        extra_data: dict | None = None,
+        auto_managed: bool | None = None,
+    ) -> CommandConfig:
+        return CommandConfig(
+            handler_full_name=handler_full_name,
+            plugin_name=plugin_name,
+            module_path=module_path,
+            original_command=original_command,
+            resolved_command=resolved_command,
+            enabled=True if enabled is None else enabled,
+            keep_original_alias=False
+            if keep_original_alias is None
+            else keep_original_alias,
+            conflict_key=conflict_key or original_command,
+            resolution_strategy=resolution_strategy,
+            note=note,
+            extra_data=extra_data,
+            auto_managed=bool(auto_managed),
+        )
+
+    @staticmethod
+    def _new_command_conflict(
+        conflict_key: str,
+        handler_full_name: str,
+        plugin_name: str,
+        *,
+        status: str | None = None,
+        resolution: str | None = None,
+        resolved_command: str | None = None,
+        note: str | None = None,
+        extra_data: dict | None = None,
+        auto_generated: bool | None = None,
+    ) -> CommandConflict:
+        return CommandConflict(
+            conflict_key=conflict_key,
+            handler_full_name=handler_full_name,
+            plugin_name=plugin_name,
+            status=status or "pending",
+            resolution=resolution,
+            resolved_command=resolved_command,
+            note=note,
+            extra_data=extra_data,
+            auto_generated=bool(auto_generated),
+        )
+
+    async def get_command_configs(self) -> list[CommandConfig]:
+        async with self.get_db() as session:
+            session: AsyncSession
+            result = await session.execute(select(CommandConfig))
+            return list(result.scalars().all())
+
+    async def get_command_config(
+        self,
+        handler_full_name: str,
+    ) -> CommandConfig | None:
+        async with self.get_db() as session:
+            session: AsyncSession
+            return await session.get(CommandConfig, handler_full_name)
+
+    async def upsert_command_config(
+        self,
+        handler_full_name: str,
+        plugin_name: str,
+        module_path: str,
+        original_command: str,
+        *,
+        resolved_command: str | None = None,
+        enabled: bool | None = None,
+        keep_original_alias: bool | None = None,
+        conflict_key: str | None = None,
+        resolution_strategy: str | None = None,
+        note: str | None = None,
+        extra_data: dict | None = None,
+        auto_managed: bool | None = None,
+    ) -> CommandConfig:
+        async def _op(session: AsyncSession) -> CommandConfig:
+            config = await session.get(CommandConfig, handler_full_name)
+            if not config:
+                config = self._new_command_config(
+                    handler_full_name,
+                    plugin_name,
+                    module_path,
+                    original_command,
+                    resolved_command=resolved_command,
+                    enabled=enabled,
+                    keep_original_alias=keep_original_alias,
+                    conflict_key=conflict_key,
+                    resolution_strategy=resolution_strategy,
+                    note=note,
+                    extra_data=extra_data,
+                    auto_managed=auto_managed,
+                )
+                session.add(config)
+            else:
+                self._apply_updates(
+                    config,
+                    plugin_name=plugin_name,
+                    module_path=module_path,
+                    original_command=original_command,
+                    resolved_command=resolved_command,
+                    enabled=enabled,
+                    keep_original_alias=keep_original_alias,
+                    conflict_key=conflict_key,
+                    resolution_strategy=resolution_strategy,
+                    note=note,
+                    extra_data=extra_data,
+                    auto_managed=auto_managed,
+                )
+            await session.flush()
+            await session.refresh(config)
+            return config
+
+        return await self._run_in_tx(_op)
+
+    async def delete_command_config(self, handler_full_name: str) -> None:
+        await self.delete_command_configs([handler_full_name])
+
+    async def delete_command_configs(self, handler_full_names: list[str]) -> None:
+        if not handler_full_names:
+            return
+
+        async def _op(session: AsyncSession) -> None:
+            await session.execute(
+                delete(CommandConfig).where(
+                    col(CommandConfig.handler_full_name).in_(handler_full_names),
+                ),
+            )
+
+        await self._run_in_tx(_op)
+
+    async def list_command_conflicts(
+        self,
+        status: str | None = None,
+    ) -> list[CommandConflict]:
+        async with self.get_db() as session:
+            session: AsyncSession
+            query = select(CommandConflict)
+            if status:
+                query = query.where(CommandConflict.status == status)
+            result = await session.execute(query)
+            return list(result.scalars().all())
+
+    async def upsert_command_conflict(
+        self,
+        conflict_key: str,
+        handler_full_name: str,
+        plugin_name: str,
+        *,
+        status: str | None = None,
+        resolution: str | None = None,
+        resolved_command: str | None = None,
+        note: str | None = None,
+        extra_data: dict | None = None,
+        auto_generated: bool | None = None,
+    ) -> CommandConflict:
+        async def _op(session: AsyncSession) -> CommandConflict:
+            result = await session.execute(
+                select(CommandConflict).where(
+                    CommandConflict.conflict_key == conflict_key,
+                    CommandConflict.handler_full_name == handler_full_name,
+                ),
+            )
+            record = result.scalar_one_or_none()
+            if not record:
+                record = self._new_command_conflict(
+                    conflict_key,
+                    handler_full_name,
+                    plugin_name,
+                    status=status,
+                    resolution=resolution,
+                    resolved_command=resolved_command,
+                    note=note,
+                    extra_data=extra_data,
+                    auto_generated=auto_generated,
+                )
+                session.add(record)
+            else:
+                self._apply_updates(
+                    record,
+                    plugin_name=plugin_name,
+                    status=status,
+                    resolution=resolution,
+                    resolved_command=resolved_command,
+                    note=note,
+                    extra_data=extra_data,
+                    auto_generated=auto_generated,
+                )
+            await session.flush()
+            await session.refresh(record)
+            return record
+
+        return await self._run_in_tx(_op)
+
+    async def delete_command_conflicts(self, ids: list[int]) -> None:
+        if not ids:
+            return
+
+        async def _op(session: AsyncSession) -> None:
+            await session.execute(
+                delete(CommandConflict).where(col(CommandConflict.id).in_(ids)),
+            )
+
+        await self._run_in_tx(_op)
+
     # ====
     # Deprecated Methods
     # ====

astrbot/core/db/vec_db/faiss_impl/embedding_storage.py

@@ -90,4 +90,6 @@ class EmbeddingStorage:
             path (str): 保存索引的路径
 
         """
+        if self.index is None:
+            return
         faiss.write_index(self.index, self.path)

astrbot/core/event_bus.py

@@ -27,7 +27,7 @@ class EventBus:
         self,
         event_queue: Queue,
         pipeline_scheduler_mapping: dict[str, PipelineScheduler],
-        astrbot_config_mgr: AstrBotConfigManager = None,
+        astrbot_config_mgr: AstrBotConfigManager,
     ):
         self.event_queue = event_queue  # 事件队列
         # abconf uuid -> scheduler
@@ -40,6 +40,11 @@ class EventBus:
             conf_info = self.astrbot_config_mgr.get_conf_info(event.unified_msg_origin)
             self._print_event(event, conf_info["name"])
             scheduler = self.pipeline_scheduler_mapping.get(conf_info["id"])
+            if not scheduler:
+                logger.error(
+                    f"PipelineScheduler not found for id: {conf_info['id']}, event ignored."
+                )
+                continue
             asyncio.create_task(scheduler.execute(event))
 
     def _print_event(self, event: AstrMessageEvent, conf_name: str):

astrbot/core/knowledge_base/retrieval/manager.py

@@ -166,7 +166,11 @@ class RetrievalManager:
         # 5. Rerank
         first_rerank = None
         for kb_id in kb_ids:
-            vec_db: FaissVecDB = kb_options[kb_id]["vec_db"]
+            vec_db = kb_options[kb_id]["vec_db"]
+            if not isinstance(vec_db, FaissVecDB):
+                logger.warning(f"vec_db for kb_id {kb_id} is not FaissVecDB")
+                continue
+
             rerank_pi = kb_options[kb_id]["rerank_provider_id"]
             if (
                 vec_db

astrbot/core/log.py

@@ -24,6 +24,7 @@ import asyncio
 import logging
 import os
 import sys
+import time
 from asyncio import Queue
 from collections import deque
 
@@ -148,7 +149,7 @@ class LogQueueHandler(logging.Handler):
         self.log_broker.publish(
             {
                 "level": record.levelname,
-                "time": record.asctime,
+                "time": time.time(),
                 "data": log_entry,
             },
         )

astrbot/core/message/components.py

@@ -66,6 +66,9 @@ class ComponentType(str, Enum):
 class BaseMessageComponent(BaseModel):
     type: ComponentType
 
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
     def toDict(self):
         data = {}
         for k, v in self.__dict__.items():
@@ -551,7 +554,7 @@ class Node(BaseMessageComponent):
     id: int | None = 0  # 忽略
     name: str | None = ""  # qq昵称
     uin: str | None = "0"  # qq号
-    content: list[BaseMessageComponent] | None = []
+    content: list[BaseMessageComponent] = []
     seq: str | list | None = ""  # 忽略
     time: int | None = 0  # 忽略
 
@@ -615,7 +618,7 @@ class Nodes(BaseMessageComponent):
             ret["messages"].append(d)
         return ret
 
-    async def to_dict(self):
+    async def to_dict(self) -> dict:
         """将 Nodes 转换为字典格式，适用于 OneBot JSON 格式"""
         ret = {"messages": []}
         for node in self.nodes:
@@ -626,12 +629,11 @@ class Nodes(BaseMessageComponent):
 
 class Json(BaseMessageComponent):
     type = ComponentType.Json
-    data: str | dict
-    resid: int | None = 0
+    data: dict
 
-    def __init__(self, data, **_):
-        if isinstance(data, dict):
-            data = json.dumps(data)
+    def __init__(self, data: str | dict, **_):
+        if isinstance(data, str):
+            data = json.loads(data)
         super().__init__(data=data, **_)
 
 
@@ -714,12 +716,15 @@ class File(BaseMessageComponent):
 
         if self.url:
             await self._download_file()
-            return os.path.abspath(self.file_)
+            if self.file_:
+                return os.path.abspath(self.file_)
 
         return ""
 
     async def _download_file(self):
         """下载文件"""
+        if not self.url:
+            raise ValueError("Download failed: No URL provided in File component.")
         download_dir = os.path.join(get_astrbot_data_path(), "temp")
         os.makedirs(download_dir, exist_ok=True)
         if self.name:

astrbot/core/persona_mgr.py

@@ -98,8 +98,8 @@ class PersonaManager:
         self,
         persona_id: str,
         system_prompt: str,
-        begin_dialogs: list[str] = None,
-        tools: list[str] = None,
+        begin_dialogs: list[str] | None = None,
+        tools: list[str] | None = None,
     ) -> Persona:
         """创建新的 persona。tools 参数为 None 时表示使用所有工具，空列表表示不使用任何工具"""
         if await self.db.get_persona_by_id(persona_id):

astrbot/core/pipeline/content_safety_check/stage.py

@@ -24,7 +24,7 @@ class ContentSafetyCheckStage(Stage):
         self,
         event: AstrMessageEvent,
         check_text: str | None = None,
-    ) -> None | AsyncGenerator[None, None]:
+    ) -> AsyncGenerator[None, None]:
         """检查内容安全"""
         text = check_text if check_text else event.get_message_str()
         ok, info = self.strategy_selector.check(text)

astrbot/core/pipeline/context_utils.py

@@ -11,7 +11,7 @@ from astrbot.core.star.star_handler import EventType, star_handlers_registry
 
 async def call_handler(
     event: AstrMessageEvent,
-    handler: T.Callable[..., T.Awaitable[T.Any]],
+    handler: T.Callable[..., T.Awaitable[T.Any] | T.AsyncGenerator[T.Any, None]],
     *args,
     **kwargs,
 ) -> T.AsyncGenerator[T.Any, None]:
@@ -91,6 +91,7 @@ async def call_event_hook(
     )
     for handler in handlers:
         try:
+            assert inspect.iscoroutinefunction(handler.handler)
             logger.debug(
                 f"hook({hook_type.name}) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}",
             )

astrbot/core/pipeline/process_stage/method/star_request.py

@@ -16,7 +16,6 @@ from ..stage import Stage
 
 class StarRequestSubStage(Stage):
     async def initialize(self, ctx: PipelineContext) -> None:
-        self.curr_provider = ctx.plugin_manager.context.get_using_provider()
         self.prompt_prefix = ctx.astrbot_config["provider_settings"]["prompt_prefix"]
         self.identifier = ctx.astrbot_config["provider_settings"]["identifier"]
         self.ctx = ctx
@@ -24,7 +23,7 @@ class StarRequestSubStage(Stage):
     async def process(
         self,
         event: AstrMessageEvent,
-    ) -> AsyncGenerator[None, None]:
+    ) -> AsyncGenerator[Any, None]:
         activated_handlers: list[StarHandlerMetadata] = event.get_extra(
             "activated_handlers",
         )

astrbot/core/pipeline/process_stage/stage.py

@@ -60,7 +60,7 @@ class ProcessStage(Stage):
         ):
             # 是否有过发送操作 and 是否是被 @ 或者通过唤醒前缀
             if (
-                event.get_result() and not event.get_result().is_stopped()
+                event.get_result() and not event.is_stopped()
             ) or not event.get_result():
                 async for _ in self.agent_sub_stage.process(event):
                     yield

astrbot/core/pipeline/respond/stage.py

@@ -117,7 +117,9 @@ class RespondStage(Stage):
         if not self.enable_seg:
             return False
 
-        if self.only_llm_result and not event.get_result().is_llm_result():
+        if (result := event.get_result()) is None:
+            return False
+        if self.only_llm_result and not result.is_llm_result():
             return False
 
         if event.get_platform_name() in [
@@ -156,7 +158,11 @@ class RespondStage(Stage):
         result = event.get_result()
         if result is None:
             return
+        if event.get_extra("_streaming_finished", False):
+            # prevent some plugin make result content type to LLM_RESULT after streaming finished, lead to send again
+            return
         if result.result_content_type == ResultContentType.STREAMING_FINISH:
+            event.set_extra("_streaming_finished", True)
             return
 
         logger.info(
@@ -185,7 +191,7 @@ class RespondStage(Stage):
                     if isinstance(component, Comp.File) and component.file:
                         # 支持 File 消息段的路径映射。
                         component.file = path_Mapping(mappings, component.file)
-                        event.get_result().chain[idx] = component
+                        result.chain[idx] = component
 
             # 检查消息链是否为空
             try:

astrbot/core/pipeline/result_decorate/stage.py

@@ -1,3 +1,4 @@
+import random
 import re
 import time
 import traceback
@@ -6,6 +7,7 @@ from collections.abc import AsyncGenerator
 from astrbot.core import file_token_service, html_renderer, logger
 from astrbot.core.message.components import At, File, Image, Node, Plain, Record, Reply
 from astrbot.core.message.message_event_result import ResultContentType
+from astrbot.core.pipeline.content_safety_check.stage import ContentSafetyCheckStage
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.platform.message_type import MessageType
 from astrbot.core.star.session_llm_manager import SessionServiceManager
@@ -41,6 +43,18 @@ class ResultDecorateStage(Stage):
             "forward_threshold"
         ]
 
+        trigger_probability = ctx.astrbot_config["provider_tts_settings"].get(
+            "trigger_probability",
+            1,
+        )
+        try:
+            self.tts_trigger_probability = max(
+                0.0,
+                min(float(trigger_probability), 1.0),
+            )
+        except (TypeError, ValueError):
+            self.tts_trigger_probability = 1.0
+
         # 分段回复
         self.words_count_threshold = int(
             ctx.astrbot_config["platform_settings"]["segmented_reply"][
@@ -53,7 +67,22 @@ class ResultDecorateStage(Stage):
         self.only_llm_result = ctx.astrbot_config["platform_settings"][
             "segmented_reply"
         ]["only_llm_result"]
+        self.split_mode = ctx.astrbot_config["platform_settings"][
+            "segmented_reply"
+        ].get("split_mode", "regex")
         self.regex = ctx.astrbot_config["platform_settings"]["segmented_reply"]["regex"]
+        self.split_words = ctx.astrbot_config["platform_settings"][
+            "segmented_reply"
+        ].get("split_words", ["。", "？", "！", "~", "…"])
+        if self.split_words:
+            escaped_words = sorted(
+                [re.escape(word) for word in self.split_words], key=len, reverse=True
+            )
+            self.split_words_pattern = re.compile(
+                f"(.*?({'|'.join(escaped_words)})|.+$)", re.DOTALL
+            )
+        else:
+            self.split_words_pattern = None
         self.content_cleanup_rule = ctx.astrbot_config["platform_settings"][
             "segmented_reply"
         ]["content_cleanup_rule"]
@@ -69,6 +98,28 @@ class ResultDecorateStage(Stage):
                     self.content_safe_check_stage = stage_cls()
                     await self.content_safe_check_stage.initialize(ctx)
 
+    def _split_text_by_words(self, text: str) -> list[str]:
+        """使用分段词列表分段文本"""
+        if not self.split_words_pattern:
+            return [text]
+
+        segments = self.split_words_pattern.findall(text)
+        result = []
+        for seg in segments:
+            if isinstance(seg, tuple):
+                content = seg[0]
+                if not isinstance(content, str):
+                    continue
+                for word in self.split_words:
+                    if content.endswith(word):
+                        content = content[: -len(word)]
+                        break
+                if content.strip():
+                    result.append(content)
+            elif seg and seg.strip():
+                result.append(seg)
+        return result if result else [text]
+
     async def process(
         self,
         event: AstrMessageEvent,
@@ -93,11 +144,13 @@ class ResultDecorateStage(Stage):
             for comp in result.chain:
                 if isinstance(comp, Plain):
                     text += comp.text
-            async for _ in self.content_safe_check_stage.process(
-                event,
-                check_text=text,
-            ):
-                yield
+
+            if isinstance(self.content_safe_check_stage, ContentSafetyCheckStage):
+                async for _ in self.content_safe_check_stage.process(
+                    event,
+                    check_text=text,
+                ):
+                    yield
 
         # 发送消息前事件钩子
         handlers = star_handlers_registry.get_handlers_by_event_type(
@@ -114,7 +167,8 @@ class ResultDecorateStage(Stage):
                         "启用流式输出时，依赖发送消息前事件钩子的插件可能无法正常工作",
                     )
                 await handler.handler(event)
-                if event.get_result() is None or not event.get_result().chain:
+
+                if (result := event.get_result()) is None or not result.chain:
                     logger.debug(
                         f"hook(on_decorating_result) -> {star_map[handler.handler_module_path].name} - {handler.handler_name} 将消息结果清空。",
                     )
@@ -161,21 +215,27 @@ class ResultDecorateStage(Stage):
                                 # 不分段回复
                                 new_chain.append(comp)
                                 continue
-                            try:
-                                split_response = re.findall(
-                                    self.regex,
-                                    comp.text,
-                                    re.DOTALL | re.MULTILINE,
-                                )
-                            except re.error:
-                                logger.error(
-                                    f"分段回复正则表达式错误，使用默认分段方式: {traceback.format_exc()}",
-                                )
-                                split_response = re.findall(
-                                    r".*?[。？！~…]+|.+$",
-                                    comp.text,
-                                    re.DOTALL | re.MULTILINE,
-                                )
+
+                            # 根据 split_mode 选择分段方式
+                            if self.split_mode == "words":
+                                split_response = self._split_text_by_words(comp.text)
+                            else:  # regex 模式
+                                try:
+                                    split_response = re.findall(
+                                        self.regex,
+                                        comp.text,
+                                        re.DOTALL | re.MULTILINE,
+                                    )
+                                except re.error:
+                                    logger.error(
+                                        f"分段回复正则表达式错误，使用默认分段方式: {traceback.format_exc()}",
+                                    )
+                                    split_response = re.findall(
+                                        r".*?[。？！~…]+|.+$",
+                                        comp.text,
+                                        re.DOTALL | re.MULTILINE,
+                                    )
+
                             if not split_response:
                                 new_chain.append(comp)
                                 continue
@@ -199,7 +259,14 @@ class ResultDecorateStage(Stage):
                 and result.is_llm_result()
                 and SessionServiceManager.should_process_tts_request(event)
             ):
-                if not tts_provider:
+                should_tts = self.tts_trigger_probability >= 1.0 or (
+                    self.tts_trigger_probability > 0.0
+                    and random.random() <= self.tts_trigger_probability
+                )
+
+                if not should_tts:
+                    logger.debug("跳过 TTS：触发概率未命中。")
+                elif not tts_provider:
                     logger.warning(
                         f"会话 {event.unified_msg_origin} 未配置文本转语音模型。",
                     )

astrbot/core/pipeline/scheduler.py

@@ -2,6 +2,10 @@ from collections.abc import AsyncGenerator
 
 from astrbot.core import logger
 from astrbot.core.platform import AstrMessageEvent
+from astrbot.core.platform.sources.webchat.webchat_event import WebChatMessageEvent
+from astrbot.core.platform.sources.wecom_ai_bot.wecomai_event import (
+    WecomAIBotMessageEvent,
+)
 
 from . import STAGES_ORDER
 from .context import PipelineContext
@@ -78,7 +82,7 @@ class PipelineScheduler:
         await self._process_stages(event)
 
         # 如果没有发送操作, 则发送一个空消息, 以便于后续的处理
-        if event.get_platform_name() in ["webchat", "wecom_ai_bot"]:
+        if isinstance(event, (WebChatMessageEvent, WecomAIBotMessageEvent)):
             await event.send(None)
 
         logger.debug("pipeline 执行完毕。")

astrbot/core/pipeline/waking_check/stage.py

@@ -50,6 +50,9 @@ class WakingCheckStage(Stage):
             "ignore_at_all",
             False,
         )
+        self.disable_builtin_commands = self.ctx.astrbot_config.get(
+            "disable_builtin_commands", False
+        )
 
     async def process(
         self,
@@ -131,6 +134,13 @@ class WakingCheckStage(Stage):
             EventType.AdapterMessageEvent,
             plugins_name=event.plugins_name,
         ):
+            if (
+                self.disable_builtin_commands
+                and handler.handler_module_path == "packages.builtin_commands.main"
+            ):
+                logger.debug("skipping builtin command")
+                continue
+
             # filter 需满足 AND 逻辑关系
             passed = True
             permission_not_pass = False

astrbot/core/platform/astr_message_event.py

@@ -153,7 +153,9 @@ class AstrMessageEvent(abc.ABC):
 
     def get_sender_name(self) -> str:
         """获取消息发送者的名称。(可能会返回空字符串)"""
-        return self.message_obj.sender.nickname
+        if isinstance(self.message_obj.sender.nickname, str):
+            return self.message_obj.sender.nickname
+        return ""
 
     def set_extra(self, key, value):
         """设置额外的信息。"""
@@ -270,7 +272,7 @@ class AstrMessageEvent(abc.ABC):
         """
         self.call_llm = call_llm
 
-    def get_result(self) -> MessageEventResult:
+    def get_result(self) -> MessageEventResult | None:
         """获取消息事件的结果。"""
         return self._result
 
@@ -320,7 +322,7 @@ class AstrMessageEvent(abc.ABC):
         self,
         prompt: str,
         func_tool_manager=None,
-        session_id: str = None,
+        session_id: str = "",
         image_urls: list[str] | None = None,
         contexts: list | None = None,
         system_prompt: str = "",

astrbot/core/platform/astrbot_message.py

@@ -54,7 +54,7 @@ class AstrBotMessage:
     self_id: str  # 机器人的识别id
     session_id: str  # 会话id。取决于 unique_session 的设置。
     message_id: str  # 消息id
-    group: Group  # 群组
+    group: Group | None  # 群组
     sender: MessageMember  # 发送者
     message: list[BaseMessageComponent]  # 消息链使用 Nakuru 的消息链格式
     message_str: str  # 最直观的纯文本消息字符串
@@ -78,7 +78,7 @@ class AstrBotMessage:
         return ""
 
     @group_id.setter
-    def group_id(self, value: str):
+    def group_id(self, value: str | None):
         """设置 group_id"""
         if value:
             if self.group:

astrbot/core/platform/manager.py

@@ -5,6 +5,7 @@ from asyncio import Queue
 from astrbot.core import logger
 from astrbot.core.config.astrbot_config import AstrBotConfig
 from astrbot.core.star.star_handler import EventType, star_handlers_registry, star_map
+from astrbot.core.utils.webhook_utils import ensure_platform_webhook_config
 
 from .platform import Platform, PlatformStatus
 from .register import platform_cls_map
@@ -18,6 +19,7 @@ class PlatformManager:
 
         self._inst_map: dict[str, dict] = {}
 
+        self.astrbot_config = config
         self.platforms_config = config["platform"]
         self.settings = config["platform_settings"]
         """NOTE: 这里是 default 的配置文件，以保证最大的兼容性；
@@ -29,6 +31,8 @@ class PlatformManager:
         """初始化所有平台适配器"""
         for platform in self.platforms_config:
             try:
+                if ensure_platform_webhook_config(platform):
+                    self.astrbot_config.save_config()
                 await self.load_platform(platform)
             except Exception as e:
                 logger.error(f"初始化 {platform} 平台适配器失败: {e}")

astrbot/core/platform/platform.py

@@ -1,7 +1,7 @@
 import abc
 import uuid
 from asyncio import Queue
-from collections.abc import Awaitable
+from collections.abc import Coroutine
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
@@ -80,6 +80,13 @@ class Platform(abc.ABC):
         if self._status == PlatformStatus.ERROR:
             self._status = PlatformStatus.RUNNING
 
+    def unified_webhook(self) -> bool:
+        """是否正在使用统一 Webhook 模式"""
+        return bool(
+            self.config.get("unified_webhook_mode", False)
+            and self.config.get("webhook_uuid")
+        )
+
     def get_stats(self) -> dict:
         """获取平台统计信息"""
         meta = self.meta()
@@ -97,10 +104,11 @@ class Platform(abc.ABC):
             }
             if self.last_error
             else None,
+            "unified_webhook": self.unified_webhook(),
         }
 
     @abc.abstractmethod
-    def run(self) -> Awaitable[Any]:
+    def run(self) -> Coroutine[Any, Any, None]:
         """得到一个平台的运行实例，需要返回一个协程对象。"""
         raise NotImplementedError
 
@@ -116,7 +124,7 @@ class Platform(abc.ABC):
         self,
         session: MessageSesion,
         message_chain: MessageChain,
-    ):
+    ) -> None:
         """通过会话发送消息。该方法旨在让插件能够直接通过**可持久化的会话数据**发送消息，而不需要保存 event 对象。
 
         异步方法。

astrbot/core/platform/platform_metadata.py

@@ -7,7 +7,7 @@ class PlatformMetadata:
     """平台的名称，即平台的类型，如 aiocqhttp, discord, slack"""
     description: str
     """平台的描述"""
-    id: str | None = None
+    id: str
     """平台的唯一标识符，用于配置中识别特定平台"""
 
     default_config_tmpl: dict | None = None

astrbot/core/platform/register.py

@@ -40,6 +40,7 @@ def register_platform_adapter(
         pm = PlatformMetadata(
             name=adapter_name,
             description=desc,
+            id=adapter_name,
             default_config_tmpl=default_config_tmpl,
             adapter_display_name=adapter_display_name,
             logo_path=logo_path,

astrbot/core/platform/sources/aiocqhttp/aiocqhttp_message_event.py

@@ -70,16 +70,18 @@ class AiocqhttpMessageEvent(AstrMessageEvent):
         bot: CQHttp,
         event: Event | None,
         is_group: bool,
-        session_id: str,
+        session_id: str | None,
         messages: list[dict],
     ):
         # session_id 必须是纯数字字符串
-        session_id = int(session_id) if session_id.isdigit() else None
+        session_id_int = (
+            int(session_id) if session_id and session_id.isdigit() else None
+        )
 
-        if is_group and isinstance(session_id, int):
-            await bot.send_group_msg(group_id=session_id, message=messages)
-        elif not is_group and isinstance(session_id, int):
-            await bot.send_private_msg(user_id=session_id, message=messages)
+        if is_group and isinstance(session_id_int, int):
+            await bot.send_group_msg(group_id=session_id_int, message=messages)
+        elif not is_group and isinstance(session_id_int, int):
+            await bot.send_private_msg(user_id=session_id_int, message=messages)
         elif isinstance(event, Event):  # 最后兜底
             await bot.send(event=event, message=messages)
         else:

astrbot/core/platform/sources/aiocqhttp/aiocqhttp_platform_adapter.py

@@ -4,7 +4,7 @@ import logging
 import time
 import uuid
 from collections.abc import Awaitable
-from typing import Any
+from typing import Any, cast
 
 from aiocqhttp import CQHttp, Event
 from aiocqhttp.exceptions import ActionFailed
@@ -48,7 +48,7 @@ class AiocqhttpAdapter(Platform):
         self.metadata = PlatformMetadata(
             name="aiocqhttp",
             description="适用于 OneBot 标准的消息平台适配器，支持反向 WebSockets。",
-            id=self.config.get("id"),
+            id=cast(str, self.config.get("id")),
             support_streaming_message=False,
         )
 
@@ -127,7 +127,9 @@ class AiocqhttpAdapter(Platform):
         """OneBot V11 请求类事件"""
         abm = AstrBotMessage()
         abm.self_id = str(event.self_id)
-        abm.sender = MessageMember(user_id=str(event.user_id), nickname=event.user_id)
+        abm.sender = MessageMember(
+            user_id=str(event.user_id), nickname=str(event.user_id)
+        )
         abm.type = MessageType.OTHER_MESSAGE
         if event.get("group_id"):
             abm.type = MessageType.GROUP_MESSAGE
@@ -194,6 +196,7 @@ class AiocqhttpAdapter(Platform):
         @param event: 事件对象
         @param get_reply: 是否获取回复消息。这个参数是为了防止多个回复嵌套。
         """
+        assert event.sender is not None
         abm = AstrBotMessage()
         abm.self_id = str(event.self_id)
         abm.sender = MessageMember(
@@ -203,6 +206,7 @@ class AiocqhttpAdapter(Platform):
         if event["message_type"] == "group":
             abm.type = MessageType.GROUP_MESSAGE
             abm.group_id = str(event.group_id)
+            abm.group = Group(str(event.group_id))
             abm.group.group_name = event.get("group_name", "N/A")
         elif event["message_type"] == "private":
             abm.type = MessageType.FRIEND_MESSAGE
@@ -228,7 +232,7 @@ class AiocqhttpAdapter(Platform):
                 await self.bot.send(event, err)
             except BaseException as e:
                 logger.error(f"回复消息失败: {e}")
-            return None
+            raise ValueError(err)
 
         # 按消息段类型类型适配
         for t, m_group in itertools.groupby(event.message, key=lambda x: x["type"]):
@@ -417,7 +421,7 @@ class AiocqhttpAdapter(Platform):
 
     async def shutdown_trigger_placeholder(self):
         await self.shutdown_event.wait()
-        logger.info("aiocqhttp 适配器已被优雅地关闭")
+        logger.info("aiocqhttp 适配器已被关闭")
 
     def meta(self) -> PlatformMetadata:
         return self.metadata

astrbot/core/platform/sources/dingtalk/dingtalk_adapter.py

@@ -2,6 +2,7 @@ import asyncio
 import os
 import threading
 import uuid
+from typing import cast
 
 import aiohttp
 import dingtalk_stream
@@ -54,12 +55,14 @@ class DingtalkPlatformAdapter(Platform):
         self.client_id = platform_config["client_id"]
         self.client_secret = platform_config["client_secret"]
 
+        outer_self = self
+
         class AstrCallbackClient(dingtalk_stream.ChatbotHandler):
-            async def process(self_, message: dingtalk_stream.CallbackMessage):
+            async def process(self, message: dingtalk_stream.CallbackMessage):
                 logger.debug(f"dingtalk: {message.data}")
                 im = dingtalk_stream.ChatbotMessage.from_dict(message.data)
-                abm = await self.convert_msg(im)
-                await self.handle_msg(abm)
+                abm = await outer_self.convert_msg(im)
+                await outer_self.handle_msg(abm)
 
                 return AckMessage.STATUS_OK, "OK"
 
@@ -73,6 +76,7 @@ class DingtalkPlatformAdapter(Platform):
             self.client,
         )
         self.client_ = client  # 用于 websockets 的 client
+        self._shutdown_event: threading.Event | None = None
 
     def _id_to_sid(self, dingtalk_id: str | None) -> str:
         if not dingtalk_id:
@@ -93,7 +97,7 @@ class DingtalkPlatformAdapter(Platform):
         return PlatformMetadata(
             name="dingtalk",
             description="钉钉机器人官方 API 适配器",
-            id=self.config.get("id"),
+            id=cast(str, self.config.get("id")),
             support_streaming_message=False,
         )
 
@@ -104,7 +108,7 @@ class DingtalkPlatformAdapter(Platform):
         abm = AstrBotMessage()
         abm.message = []
         abm.message_str = ""
-        abm.timestamp = int(message.create_at / 1000)
+        abm.timestamp = int(cast(int, message.create_at) / 1000)
         abm.type = (
             MessageType.GROUP_MESSAGE
             if message.conversation_type == "2"
@@ -115,7 +119,7 @@ class DingtalkPlatformAdapter(Platform):
             nickname=message.sender_nick,
         )
         abm.self_id = self._id_to_sid(message.chatbot_user_id)
-        abm.message_id = message.message_id
+        abm.message_id = cast(str, message.message_id)
         abm.raw_message = message
 
         if abm.type == MessageType.GROUP_MESSAGE:
@@ -132,14 +136,16 @@ class DingtalkPlatformAdapter(Platform):
         else:
             abm.session_id = abm.sender.user_id
 
-        message_type: str = message.message_type
+        message_type: str = cast(str, message.message_type)
         match message_type:
             case "text":
                 abm.message_str = message.text.content.strip()
                 abm.message.append(Plain(abm.message_str))
             case "richText":
-                rtc: dingtalk_stream.RichTextContent = message.rich_text_content
-                contents: list[dict] = rtc.rich_text_list
+                rtc: dingtalk_stream.RichTextContent = cast(
+                    dingtalk_stream.RichTextContent, message.rich_text_content
+                )
+                contents: list[dict] = cast(list[dict], rtc.rich_text_list)
                 for content in contents:
                     plains = ""
                     if "text" in content:
@@ -148,7 +154,7 @@ class DingtalkPlatformAdapter(Platform):
                     elif "type" in content and content["type"] == "picture":
                         f_path = await self.download_ding_file(
                             content["downloadCode"],
-                            message.robot_code,
+                            cast(str, message.robot_code),
                             "jpg",
                         )
                         abm.message.append(Image.fromFileSystem(f_path))
@@ -193,7 +199,7 @@ class DingtalkPlatformAdapter(Platform):
                 logger.error(
                     f"下载钉钉文件失败: {resp.status}, {await resp.text()}",
                 )
-                return None
+                return ""
             resp_data = await resp.json()
             download_url = resp_data["data"]["downloadUrl"]
             await download_file(download_url, f_path)
@@ -213,7 +219,7 @@ class DingtalkPlatformAdapter(Platform):
                     logger.error(
                         f"获取钉钉机器人 access_token 失败: {resp.status}, {await resp.text()}",
                     )
-                    return None
+                    return ""
                 return (await resp.json())["data"]["accessToken"]
 
     async def handle_msg(self, abm: AstrBotMessage):
@@ -239,7 +245,7 @@ class DingtalkPlatformAdapter(Platform):
                     task.result()
             except Exception as e:
                 if "Graceful shutdown" in str(e):
-                    logger.info("钉钉适配器已被优雅地关闭")
+                    logger.info("钉钉适配器已被关闭")
                     return
                 logger.error(f"钉钉机器人启动失败: {e}")
 
@@ -250,9 +256,11 @@ class DingtalkPlatformAdapter(Platform):
         def monkey_patch_close():
             raise KeyboardInterrupt("Graceful shutdown")
 
-        self.client_.open_connection = monkey_patch_close
-        await self.client_.websocket.close(code=1000, reason="Graceful shutdown")
-        self._shutdown_event.set()
+        if self.client_.websocket is not None:
+            self.client_.open_connection = monkey_patch_close
+            await self.client_.websocket.close(code=1000, reason="Graceful shutdown")
+        if self._shutdown_event is not None:
+            self._shutdown_event.set()
 
     def get_client(self):
         return self.client

astrbot/core/platform/sources/dingtalk/dingtalk_event.py

@@ -1,4 +1,5 @@
 import asyncio
+from typing import cast
 
 import dingtalk_stream
 
@@ -32,7 +33,7 @@ class DingtalkMessageEvent(AstrMessageEvent):
                     client.reply_markdown,
                     segment.text,
                     segment.text,
-                    self.message_obj.raw_message,
+                    cast(dingtalk_stream.ChatbotMessage, self.message_obj.raw_message),
                 )
             elif isinstance(segment, Comp.Image):
                 markdown_str = ""
@@ -53,7 +54,9 @@ class DingtalkMessageEvent(AstrMessageEvent):
                         client.reply_markdown,
                         "😄",
                         markdown_str,
-                        self.message_obj.raw_message,
+                        cast(
+                            dingtalk_stream.ChatbotMessage, self.message_obj.raw_message
+                        ),
                     )
                     logger.debug(f"send image: {ret}")
 

astrbot/core/platform/sources/discord/client.py

@@ -1,4 +1,5 @@
 import sys
+from collections.abc import Awaitable, Callable
 
 import discord
 
@@ -27,13 +28,16 @@ class DiscordBotClient(discord.Bot):
         super().__init__(intents=intents, proxy=proxy)
 
         # 回调函数
-        self.on_message_received = None
-        self.on_ready_once_callback = None
+        self.on_message_received: Callable[[dict], Awaitable[None]] | None = None
+        self.on_ready_once_callback: Callable[[], Awaitable[None]] | None = None
         self._ready_once_fired = False
 
-    @override
     async def on_ready(self):
         """当机器人成功连接并准备就绪时触发"""
+        if self.user is None:
+            logger.error("[Discord] 客户端未正确加载用户信息 (self.user is None)")
+            return
+
         logger.info(f"[Discord] 已作为 {self.user} (ID: {self.user.id}) 登录")
         logger.info("[Discord] 客户端已准备就绪。")
 
@@ -49,6 +53,9 @@ class DiscordBotClient(discord.Bot):
 
     def _create_message_data(self, message: discord.Message) -> dict:
         """从 discord.Message 创建数据字典"""
+        if self.user is None:
+            raise RuntimeError("Bot is not ready: self.user is None")
+
         is_mentioned = self.user in message.mentions
         return {
             "message": message,
@@ -66,6 +73,12 @@ class DiscordBotClient(discord.Bot):
 
     def _create_interaction_data(self, interaction: discord.Interaction) -> dict:
         """从 discord.Interaction 创建数据字典"""
+        if self.user is None:
+            raise RuntimeError("Bot is not ready: self.user is None")
+
+        if interaction.user is None:
+            raise ValueError("Interaction received without a valid user")
+
         return {
             "interaction": interaction,
             "bot_id": str(self.user.id),
@@ -80,7 +93,6 @@ class DiscordBotClient(discord.Bot):
             "type": "interaction",
         }
 
-    @override
     async def on_message(self, message: discord.Message):
         """当接收到消息时触发"""
         if message.author.bot:

astrbot/core/platform/sources/discord/components.py

@@ -97,8 +97,8 @@ class DiscordView(BaseMessageComponent):
 
     def __init__(
         self,
-        components: list[BaseMessageComponent] = None,
-        timeout: float = None,
+        components: list[BaseMessageComponent] | None = None,
+        timeout: float | None = None,
     ):
         self.components = components or []
         self.timeout = timeout

astrbot/core/platform/sources/discord/discord_platform_adapter.py

@@ -1,10 +1,10 @@
 import asyncio
 import re
 import sys
-from typing import Any
+from typing import Any, cast
 
 import discord
-from discord.abc import Messageable
+from discord.abc import GuildChannel, Messageable, PrivateChannel
 from discord.channel import DMChannel
 
 from astrbot import logger
@@ -46,7 +46,7 @@ class DiscordPlatformAdapter(Platform):
     ) -> None:
         super().__init__(platform_config, event_queue)
         self.settings = platform_settings
-        self.client_self_id = None
+        self.client_self_id: str | None = None
         self.registered_handlers = []
         # 指令注册相关
         self.enable_command_register = self.config.get("discord_command_register", True)
@@ -62,6 +62,12 @@ class DiscordPlatformAdapter(Platform):
         message_chain: MessageChain,
     ):
         """通过会话发送消息"""
+        if self.client.user is None:
+            logger.error(
+                "[Discord] 客户端未就绪 (self.client.user is None)，无法发送消息"
+            )
+            return
+
         # 创建一个 message_obj 以便在 event 中使用
         message_obj = AstrBotMessage()
         if "_" in session.session_id:
@@ -89,7 +95,7 @@ class DiscordPlatformAdapter(Platform):
             user_id=str(self.client_self_id),
             nickname=self.client.user.display_name,
         )
-        message_obj.self_id = self.client_self_id
+        message_obj.self_id = cast(str, self.client_self_id)
         message_obj.session_id = session.session_id
         message_obj.message = message_chain.chain
 
@@ -110,7 +116,7 @@ class DiscordPlatformAdapter(Platform):
         return PlatformMetadata(
             "discord",
             "Discord 适配器",
-            id=self.config.get("id"),
+            id=cast(str, self.config.get("id")),
             default_config_tmpl=self.config,
             support_streaming_message=False,
         )
@@ -160,7 +166,7 @@ class DiscordPlatformAdapter(Platform):
 
     def _get_message_type(
         self,
-        channel: Messageable,
+        channel: Messageable | GuildChannel | PrivateChannel,
         guild_id: int | None = None,
     ) -> MessageType:
         """根据 channel 对象和 guild_id 判断消息类型"""
@@ -170,13 +176,15 @@ class DiscordPlatformAdapter(Platform):
             return MessageType.FRIEND_MESSAGE
         return MessageType.GROUP_MESSAGE
 
-    def _get_channel_id(self, channel: Messageable) -> str:
+    def _get_channel_id(
+        self, channel: Messageable | GuildChannel | PrivateChannel
+    ) -> str:
         """根据 channel 对象获取ID"""
         return str(getattr(channel, "id", None))
 
     def _convert_message_to_abm(self, data: dict) -> AstrBotMessage:
         """将普通消息转换为 AstrBotMessage"""
-        message: discord.Message = data["message"]
+        message = data["message"]
 
         content = message.content
 
@@ -233,7 +241,7 @@ class DiscordPlatformAdapter(Platform):
                     )
         abm.message = message_chain
         abm.raw_message = message
-        abm.self_id = self.client_self_id
+        abm.self_id = cast(str, self.client_self_id)
         abm.session_id = str(message.channel.id)
         abm.message_id = str(message.id)
         return abm
@@ -254,32 +262,52 @@ class DiscordPlatformAdapter(Platform):
             interaction_followup_webhook=followup_webhook,
         )
 
+        if self.client.user is None:
+            logger.error(
+                "[Discord] 客户端未就绪 (self.client.user is None)，无法处理消息"
+            )
+            return
+
         # 检查是否为斜杠指令
         is_slash_command = message_event.interaction_followup_webhook is not None
 
+        # 1. 优先处理斜杠指令
+        if is_slash_command:
+            message_event.is_wake = True
+            message_event.is_at_or_wake_command = True
+            self.commit_event(message_event)
+            return
+
+        # 2. 处理普通消息（提及检测）
+        # 确保 raw_message 是 discord.Message 类型，以便静态检查通过
+        raw_message = message.raw_message
+        if not isinstance(raw_message, discord.Message):
+            logger.warning(
+                f"[Discord] 收到非 Message 类型的消息: {type(raw_message)}，已忽略。"
+            )
+            return
+
         # 检查是否被@（User Mention 或 Bot 拥有的 Role Mention）
         is_mention = False
+
         # User Mention
-        if (
-            self.client
-            and self.client.user
-            and hasattr(message.raw_message, "mentions")
-        ):
-            if self.client.user in message.raw_message.mentions:
-                is_mention = True
+        # 此时 Pylance 知道 raw_message 是 discord.Message，具有 mentions 属性
+        if self.client.user in raw_message.mentions:
+            is_mention = True
+
         # Role Mention（Bot 拥有的角色被提及）
-        if not is_mention and hasattr(message.raw_message, "role_mentions"):
+        if not is_mention and raw_message.role_mentions:
             bot_member = None
-            if hasattr(message.raw_message, "guild") and message.raw_message.guild:
+            if raw_message.guild:
                 try:
-                    bot_member = message.raw_message.guild.get_member(
+                    bot_member = raw_message.guild.get_member(
                         self.client.user.id,
                     )
                 except Exception:
                     bot_member = None
             if bot_member and hasattr(bot_member, "roles"):
                 bot_roles = set(bot_member.roles)
-                mentioned_roles = set(message.raw_message.role_mentions)
+                mentioned_roles = set(raw_message.role_mentions)
                 if (
                     bot_roles
                     and mentioned_roles
@@ -287,8 +315,8 @@ class DiscordPlatformAdapter(Platform):
                 ):
                     is_mention = True
 
-        # 如果是斜杠指令或被@的消息，设置为唤醒状态
-        if is_slash_command or is_mention:
+        # 如果是被@的消息，设置为唤醒状态
+        if is_mention:
             message_event.is_wake = True
             message_event.is_at_or_wake_command = True
 
@@ -424,7 +452,7 @@ class DiscordPlatformAdapter(Platform):
             )
             abm.message = [Plain(text=message_str_for_filter)]
             abm.raw_message = ctx.interaction
-            abm.self_id = self.client_self_id
+            abm.self_id = cast(str, self.client_self_id)
             abm.session_id = str(ctx.channel_id)
             abm.message_id = str(ctx.interaction.id)
 
@@ -437,7 +465,7 @@ class DiscordPlatformAdapter(Platform):
     def _extract_command_info(
         event_filter: Any,
         handler_metadata: StarHandlerMetadata,
-    ) -> tuple[str, str, CommandFilter] | None:
+    ) -> tuple[str, str, CommandFilter | None] | None:
         """从事件过滤器中提取指令信息"""
         cmd_name = None
         # is_group = False

astrbot/core/platform/sources/discord/discord_platform_event.py

@@ -4,8 +4,10 @@ import binascii
 from collections.abc import AsyncGenerator
 from io import BytesIO
 from pathlib import Path
+from typing import cast
 
 import discord
+from discord.types.interactions import ComponentInteractionData
 
 from astrbot import logger
 from astrbot.api.event import AstrMessageEvent, MessageChain
@@ -85,6 +87,9 @@ class DiscordPlatformEvent(AstrMessageEvent):
                 channel = await self._get_channel()
                 if not channel:
                     return
+                if not isinstance(channel, discord.abc.Messageable):
+                    logger.error(f"[Discord] 频道 {channel.id} 不是可发送消息的类型")
+                    return
                 await channel.send(**kwargs)
 
         except Exception as e:
@@ -107,7 +112,9 @@ class DiscordPlatformEvent(AstrMessageEvent):
         await self.send(buffer)
         return await super().send_streaming(generator, use_fallback)
 
-    async def _get_channel(self) -> discord.abc.Messageable | None:
+    async def _get_channel(
+        self,
+    ) -> discord.Thread | discord.abc.GuildChannel | discord.abc.PrivateChannel | None:
         """获取当前事件对应的频道对象"""
         try:
             channel_id = int(self.session_id)
@@ -121,7 +128,13 @@ class DiscordPlatformEvent(AstrMessageEvent):
     async def _parse_to_discord(
         self,
         message: MessageChain,
-    ) -> tuple[str, list[discord.File], discord.ui.View | None, list[discord.Embed]]:
+    ) -> tuple[
+        str,
+        list[discord.File],
+        discord.ui.View | None,
+        list[discord.Embed],
+        str | int | None,
+    ]:
         """将 MessageChain 解析为 Discord 发送所需的内容"""
         content_parts = []
         files = []
@@ -261,7 +274,9 @@ class DiscordPlatformEvent(AstrMessageEvent):
                 self.message_obj.raw_message,
                 "add_reaction",
             ):
-                await self.message_obj.raw_message.add_reaction(emoji)
+                await cast(discord.Message, self.message_obj.raw_message).add_reaction(
+                    emoji
+                )
         except Exception as e:
             logger.error(f"[Discord] 添加反应失败: {e}")
 
@@ -270,7 +285,7 @@ class DiscordPlatformEvent(AstrMessageEvent):
         return (
             hasattr(self.message_obj, "raw_message")
             and hasattr(self.message_obj.raw_message, "type")
-            and self.message_obj.raw_message.type
+            and cast(discord.Interaction, self.message_obj.raw_message).type
             == discord.InteractionType.application_command
         )
 
@@ -279,14 +294,18 @@ class DiscordPlatformEvent(AstrMessageEvent):
         return (
             hasattr(self.message_obj, "raw_message")
             and hasattr(self.message_obj.raw_message, "type")
-            and self.message_obj.raw_message.type == discord.InteractionType.component
+            and cast(discord.Interaction, self.message_obj.raw_message).type
+            == discord.InteractionType.component
         )
 
     def get_interaction_custom_id(self) -> str:
         """获取交互组件的custom_id"""
         if self.is_button_interaction():
             try:
-                return self.message_obj.raw_message.data.get("custom_id", "")
+                return cast(
+                    ComponentInteractionData,
+                    cast(discord.Interaction, self.message_obj.raw_message).data,
+                ).get("custom_id", "")
             except Exception:
                 pass
         return ""
@@ -299,7 +318,9 @@ class DiscordPlatformEvent(AstrMessageEvent):
         ):
             return any(
                 mention.id == int(self.message_obj.self_id)
-                for mention in self.message_obj.raw_message.mentions
+                for mention in cast(
+                    discord.Message, self.message_obj.raw_message
+                ).mentions
             )
         return False
 
@@ -309,5 +330,5 @@ class DiscordPlatformEvent(AstrMessageEvent):
             self.message_obj.raw_message,
             "clean_content",
         ):
-            return self.message_obj.raw_message.clean_content
+            return cast(discord.Message, self.message_obj.raw_message).clean_content
         return self.message_str

astrbot/core/platform/sources/lark/lark_adapter.py

@@ -2,10 +2,17 @@ import asyncio
 import base64
 import json
 import re
+import time
 import uuid
+from typing import Any, cast
 
 import lark_oapi as lark
-from lark_oapi.api.im.v1 import *
+from lark_oapi.api.im.v1 import (
+    CreateMessageRequest,
+    CreateMessageRequestBody,
+    GetMessageResourceRequest,
+)
+from lark_oapi.api.im.v1.processor import P2ImMessageReceiveV1Processor
 
 import astrbot.api.message_components as Comp
 from astrbot import logger
@@ -18,9 +25,11 @@ from astrbot.api.platform import (
     PlatformMetadata,
 )
 from astrbot.core.platform.astr_message_event import MessageSesion
+from astrbot.core.utils.webhook_utils import log_webhook_info
 
 from ...register import register_platform_adapter
 from .lark_event import LarkMessageEvent
+from .server import LarkWebhookServer
 
 
 @register_platform_adapter(
@@ -42,9 +51,13 @@ class LarkPlatformAdapter(Platform):
         self.domain = platform_config.get("domain", lark.FEISHU_DOMAIN)
         self.bot_name = platform_config.get("lark_bot_name", "astrbot")
 
+        # socket or webhook
+        self.connection_mode = platform_config.get("lark_connection_mode", "socket")
+
         if not self.bot_name:
             logger.warning("未设置飞书机器人名称，@ 机器人可能得不到回复。")
 
+        # 初始化 WebSocket 长连接相关配置
         async def on_msg_event_recv(event: lark.im.v1.P2ImMessageReceiveV1):
             await self.convert_msg(event)
 
@@ -57,6 +70,8 @@ class LarkPlatformAdapter(Platform):
             .build()
         )
 
+        self.do_v2_msg_event = do_v2_msg_event
+
         self.client = lark.ws.Client(
             app_id=self.appid,
             app_secret=self.appsecret,
@@ -66,14 +81,56 @@ class LarkPlatformAdapter(Platform):
         )
 
         self.lark_api = (
-            lark.Client.builder().app_id(self.appid).app_secret(self.appsecret).build()
+            lark.Client.builder()
+            .app_id(self.appid)
+            .app_secret(self.appsecret)
+            .log_level(lark.LogLevel.ERROR)
+            .domain(self.domain)
+            .build()
         )
 
+        self.webhook_server = None
+        if self.connection_mode == "webhook":
+            self.webhook_server = LarkWebhookServer(platform_config, event_queue)
+            self.webhook_server.set_callback(self.handle_webhook_event)
+
+        self.event_id_timestamps: dict[str, float] = {}
+
+    def _clean_expired_events(self):
+        """清理超过 30 分钟的事件记录"""
+        current_time = time.time()
+        expired_keys = [
+            event_id
+            for event_id, timestamp in self.event_id_timestamps.items()
+            if current_time - timestamp > 1800
+        ]
+        for event_id in expired_keys:
+            del self.event_id_timestamps[event_id]
+
+    def _is_duplicate_event(self, event_id: str) -> bool:
+        """检查事件是否重复
+
+        Args:
+            event_id: 事件ID
+
+        Returns:
+            True 表示重复事件，False 表示新事件
+        """
+        self._clean_expired_events()
+        if event_id in self.event_id_timestamps:
+            return True
+        self.event_id_timestamps[event_id] = time.time()
+        return False
+
     async def send_by_session(
         self,
         session: MessageSesion,
         message_chain: MessageChain,
     ):
+        if self.lark_api.im is None:
+            logger.error("[Lark] API Client im 模块未初始化，无法发送消息")
+            return
+
         res = await LarkMessageEvent._convert_to_lark(message_chain, self.lark_api)
         wrapped = {
             "zh_cn": {
@@ -114,14 +171,25 @@ class LarkPlatformAdapter(Platform):
         return PlatformMetadata(
             name="lark",
             description="飞书机器人官方 API 适配器",
-            id=self.config.get("id"),
+            id=cast(str, self.config.get("id")),
             support_streaming_message=False,
         )
 
     async def convert_msg(self, event: lark.im.v1.P2ImMessageReceiveV1):
+        if event.event is None:
+            logger.debug("[Lark] 收到空事件(event.event is None)")
+            return
         message = event.event.message
+        if message is None:
+            logger.debug("[Lark] 事件中没有消息体(message is None)")
+            return
+
         abm = AstrBotMessage()
-        abm.timestamp = int(message.create_time) / 1000
+
+        if message.create_time:
+            abm.timestamp = int(message.create_time) // 1000
+        else:
+            abm.timestamp = int(time.time())
         abm.message = []
         abm.type = (
             MessageType.GROUP_MESSAGE
@@ -136,14 +204,28 @@ class LarkPlatformAdapter(Platform):
         at_list = {}
         if message.mentions:
             for m in message.mentions:
-                at_list[m.key] = Comp.At(qq=m.id.open_id, name=m.name)
-                if m.name == self.bot_name:
-                    abm.self_id = m.id.open_id
+                if m.id is None:
+                    continue
+                # 飞书 open_id 可能是 None，这里做个防护
+                open_id = m.id.open_id if m.id.open_id else ""
+                at_list[m.key] = Comp.At(qq=open_id, name=m.name)
 
-        content_json_b = json.loads(message.content)
+                if m.name == self.bot_name:
+                    if m.id.open_id is not None:
+                        abm.self_id = m.id.open_id
+
+        if message.content is None:
+            logger.warning("[Lark] 消息内容为空")
+            return
+
+        try:
+            content_json_b = json.loads(message.content)
+        except json.JSONDecodeError:
+            logger.error(f"[Lark] 解析消息内容失败: {message.content}")
+            return
 
         if message.message_type == "text":
-            message_str_raw = content_json_b["text"]  # 带有 @ 的消息
+            message_str_raw = content_json_b.get("text", "")  # 带有 @ 的消息
             at_pattern = r"(@_user_\d+)"  # 可以根据需求修改正则
             # at_users = re.findall(at_pattern, message_str_raw)
             # 拆分文本，去掉AT符号部分
@@ -168,27 +250,47 @@ class LarkPlatformAdapter(Platform):
             content_json_b = _ls
         elif message.message_type == "image":
             content_json_b = [
-                {"tag": "img", "image_key": content_json_b["image_key"], "style": []},
+                {
+                    "tag": "img",
+                    "image_key": content_json_b.get("image_key"),
+                    "style": [],
+                },
             ]
 
         if message.message_type in ("post", "image"):
             for comp in content_json_b:
-                if comp["tag"] == "at":
-                    abm.message.append(at_list[comp["user_id"]])
-                elif comp["tag"] == "text" and comp["text"].strip():
+                if comp.get("tag") == "at":
+                    user_id = comp.get("user_id")
+                    if user_id in at_list:
+                        abm.message.append(at_list[user_id])
+                elif comp.get("tag") == "text" and comp.get("text", "").strip():
                     abm.message.append(Comp.Plain(comp["text"].strip()))
-                elif comp["tag"] == "img":
-                    image_key = comp["image_key"]
+                elif comp.get("tag") == "img":
+                    image_key = comp.get("image_key")
+                    if not image_key:
+                        continue
+
                     request = (
                         GetMessageResourceRequest.builder()
-                        .message_id(message.message_id)
+                        .message_id(cast(str, message.message_id))
                         .file_key(image_key)
                         .type("image")
                         .build()
                     )
+
+                    if self.lark_api.im is None:
+                        logger.error("[Lark] API Client im 模块未初始化")
+                        continue
+
                     response = await self.lark_api.im.v1.message_resource.aget(request)
                     if not response.success():
                         logger.error(f"无法下载飞书图片: {image_key}")
+                        continue
+
+                    if response.file is None:
+                        logger.error(f"飞书图片响应中不包含文件流: {image_key}")
+                        continue
+
                     image_bytes = response.file.read()
                     image_base64 = base64.b64encode(image_bytes).decode()
                     abm.message.append(Comp.Image.fromBase64(image_base64))
@@ -196,6 +298,19 @@ class LarkPlatformAdapter(Platform):
         for comp in abm.message:
             if isinstance(comp, Comp.Plain):
                 abm.message_str += comp.text
+
+        if message.message_id is None:
+            logger.error("[Lark] 消息缺少 message_id")
+            return
+
+        if (
+            event.event.sender is None
+            or event.event.sender.sender_id is None
+            or event.event.sender.sender_id.open_id is None
+        ):
+            logger.error("[Lark] 消息发送者信息不完整")
+            return
+
         abm.message_id = message.message_id
         abm.raw_message = message
         abm.sender = MessageMember(
@@ -227,13 +342,61 @@ class LarkPlatformAdapter(Platform):
 
         self._event_queue.put_nowait(event)
 
+    async def handle_webhook_event(self, event_data: dict):
+        """处理 Webhook 事件
+
+        Args:
+            event_data: Webhook 事件数据
+        """
+        try:
+            header = event_data.get("header", {})
+            event_id = header.get("event_id", "")
+            if event_id and self._is_duplicate_event(event_id):
+                logger.debug(f"[Lark Webhook] 跳过重复事件: {event_id}")
+                return
+            event_type = header.get("event_type", "")
+            if event_type == "im.message.receive_v1":
+                processor = P2ImMessageReceiveV1Processor(self.do_v2_msg_event)
+                data = (processor.type())(event_data)
+                processor.do(data)
+            else:
+                logger.debug(f"[Lark Webhook] 未处理的事件类型: {event_type}")
+        except Exception as e:
+            logger.error(f"[Lark Webhook] 处理事件失败: {e}", exc_info=True)
+
     async def run(self):
-        # self.client.start()
-        await self.client._connect()
+        if self.connection_mode == "webhook":
+            # Webhook 模式
+            if self.webhook_server is None:
+                logger.error("[Lark] Webhook 模式已启用，但 webhook_server 未初始化")
+                return
+
+            webhook_uuid = self.config.get("webhook_uuid")
+            if webhook_uuid:
+                log_webhook_info(f"{self.meta().id}(飞书 Webhook)", webhook_uuid)
+            else:
+                logger.warning("[Lark] Webhook 模式已启用，但未配置 webhook_uuid")
+        else:
+            # 长连接模式
+            await self.client._connect()
+
+    async def webhook_callback(self, request: Any) -> Any:
+        """统一 Webhook 回调入口"""
+        if not self.webhook_server:
+            return {"error": "Webhook server not initialized"}, 500
+
+        return await self.webhook_server.handle_callback(request)
 
     async def terminate(self):
-        await self.client._disconnect()
-        logger.info("飞书(Lark) 适配器已被优雅地关闭")
+        if self.connection_mode == "socket":
+            await self.client._disconnect()
+        logger.info("飞书(Lark) 适配器已关闭")
 
-    def get_client(self) -> lark.Client:
+    def get_client(self) -> lark.ws.Client:
         return self.client
+
+    def unified_webhook(self) -> bool:
+        return bool(
+            self.config.get("lark_connection_mode", "") == "webhook"
+            and self.config.get("webhook_uuid")
+        )

astrbot/core/platform/sources/lark/lark_event.py

@@ -5,7 +5,15 @@ import uuid
 from io import BytesIO
 
 import lark_oapi as lark
-from lark_oapi.api.im.v1 import *
+from lark_oapi.api.im.v1 import (
+    CreateImageRequest,
+    CreateImageRequestBody,
+    CreateMessageReactionRequest,
+    CreateMessageReactionRequestBody,
+    Emoji,
+    ReplyMessageRequest,
+    ReplyMessageRequestBody,
+)
 
 from astrbot import logger
 from astrbot.api.event import AstrMessageEvent, MessageChain
@@ -44,7 +52,7 @@ class LarkMessageEvent(AstrMessageEvent):
                     file_path = comp.file.replace("file:///", "")
                 elif comp.file and comp.file.startswith("http"):
                     image_file_path = await download_image_by_url(comp.file)
-                    file_path = image_file_path
+                    file_path = image_file_path if image_file_path else ""
                 elif comp.file and comp.file.startswith("base64://"):
                     base64_str = comp.file.removeprefix("base64://")
                     image_data = base64.b64decode(base64_str)
@@ -54,10 +62,17 @@ class LarkMessageEvent(AstrMessageEvent):
                     with open(file_path, "wb") as f:
                         f.write(BytesIO(image_data).getvalue())
                 else:
-                    file_path = comp.file
+                    file_path = comp.file if comp.file else ""
 
                 if image_file is None:
-                    image_file = open(file_path, "rb")
+                    if not file_path:
+                        logger.error("[Lark] 图片路径为空，无法上传")
+                        continue
+                    try:
+                        image_file = open(file_path, "rb")
+                    except Exception as e:
+                        logger.error(f"[Lark] 无法打开图片文件: {e}")
+                        continue
 
                 request = (
                     CreateImageRequest.builder()
@@ -69,9 +84,20 @@ class LarkMessageEvent(AstrMessageEvent):
                     )
                     .build()
                 )
+
+                if lark_client.im is None:
+                    logger.error("[Lark] API Client im 模块未初始化，无法上传图片")
+                    continue
+
                 response = await lark_client.im.v1.image.acreate(request)
                 if not response.success():
                     logger.error(f"无法上传飞书图片({response.code}): {response.msg}")
+                    continue
+
+                if response.data is None:
+                    logger.error("[Lark] 上传图片成功但未返回数据(data is None)")
+                    continue
+
                 image_key = response.data.image_key
                 logger.debug(image_key)
                 ret.append(_stage)
@@ -107,6 +133,10 @@ class LarkMessageEvent(AstrMessageEvent):
             .build()
         )
 
+        if self.bot.im is None:
+            logger.error("[Lark] API Client im 模块未初始化，无法回复消息")
+            return
+
         response = await self.bot.im.v1.message.areply(request)
 
         if not response.success():
@@ -115,6 +145,10 @@ class LarkMessageEvent(AstrMessageEvent):
         await super().send(message)
 
     async def react(self, emoji: str):
+        if self.bot.im is None:
+            logger.error("[Lark] API Client im 模块未初始化，无法发送表情")
+            return
+
         request = (
             CreateMessageReactionRequest.builder()
             .message_id(self.message_obj.message_id)
@@ -125,6 +159,7 @@ class LarkMessageEvent(AstrMessageEvent):
             )
             .build()
         )
+
         response = await self.bot.im.v1.message_reaction.acreate(request)
         if not response.success():
             logger.error(f"发送飞书表情回应失败({response.code}): {response.msg}")

astrbot/core/platform/sources/lark/server.py

@@ -0,0 +1,206 @@
+"""飞书(Lark) Webhook 服务器实现
+
+实现飞书事件订阅的 Webhook 模式，支持:
+1. 请求 URL 验证 (challenge 验证)
+2. 事件加密/解密 (AES-256-CBC)
+3. 签名校验 (SHA256)
+4. 事件接收和处理
+"""
+
+import asyncio
+import base64
+import hashlib
+import json
+from collections.abc import Awaitable, Callable
+
+from Crypto.Cipher import AES
+
+from astrbot.api import logger
+
+
+class AESCipher:
+    """AES 加密/解密工具类"""
+
+    def __init__(self, key: str):
+        self.bs = AES.block_size
+        self.key = hashlib.sha256(self.str_to_bytes(key)).digest()
+
+    @staticmethod
+    def str_to_bytes(data):
+        u_type = type(b"".decode("utf8"))
+        if isinstance(data, u_type):
+            return data.encode("utf8")
+        return data
+
+    @staticmethod
+    def _unpad(s):
+        return s[: -ord(s[len(s) - 1 :])]
+
+    def decrypt(self, enc):
+        iv = enc[: AES.block_size]
+        cipher = AES.new(self.key, AES.MODE_CBC, iv)
+        return self._unpad(cipher.decrypt(enc[AES.block_size :]))
+
+    def decrypt_string(self, enc):
+        enc = base64.b64decode(enc)
+        return self.decrypt(enc).decode("utf8")
+
+
+class LarkWebhookServer:
+    """飞书 Webhook 服务器
+
+    仅支持统一 Webhook 模式
+    """
+
+    def __init__(self, config: dict, event_queue: asyncio.Queue):
+        """初始化 Webhook 服务器
+
+        Args:
+            config: 飞书配置
+            event_queue: 事件队列
+        """
+        self.app_id = config["app_id"]
+        self.app_secret = config["app_secret"]
+        self.encrypt_key = config.get("lark_encrypt_key", "")
+        self.verification_token = config.get("lark_verification_token", "")
+
+        self.event_queue = event_queue
+        self.callback: Callable[[dict], Awaitable[None]] | None = None
+
+        # 初始化加密工具
+        self.cipher = None
+        if self.encrypt_key:
+            self.cipher = AESCipher(self.encrypt_key)
+
+    def verify_signature(
+        self,
+        timestamp: str,
+        nonce: str,
+        encrypt_key: str,
+        body: bytes,
+        signature: str,
+    ) -> bool:
+        """验证签名
+
+        Args:
+            timestamp: 请求时间戳
+            nonce: 随机数
+            encrypt_key: 加密密钥
+            body: 请求体
+            signature: 签名
+
+        Returns:
+            签名是否有效
+        """
+        # 拼接字符串: timestamp + nonce + encrypt_key + body
+        bytes_b1 = (timestamp + nonce + encrypt_key).encode("utf-8")
+        bytes_b = bytes_b1 + body
+        h = hashlib.sha256(bytes_b)
+        calculated_signature = h.hexdigest()
+        return calculated_signature == signature
+
+    def decrypt_event(self, encrypted_data: str) -> dict:
+        """解密事件数据
+
+        Args:
+            encrypted_data: 加密的事件数据
+
+        Returns:
+            解密后的事件字典
+        """
+        if not self.cipher:
+            raise ValueError("未配置 encrypt_key，无法解密事件")
+
+        decrypted_str = self.cipher.decrypt_string(encrypted_data)
+        return json.loads(decrypted_str)
+
+    async def handle_challenge(self, event_data: dict) -> dict:
+        """处理 challenge 验证请求
+
+        Args:
+            event_data: 事件数据
+
+        Returns:
+            包含 challenge 的响应
+        """
+        challenge = event_data.get("challenge", "")
+        logger.info(f"[Lark Webhook] 收到 challenge 验证请求: {challenge}")
+
+        return {"challenge": challenge}
+
+    async def handle_callback(self, request) -> tuple[dict, int] | dict:
+        """处理 webhook 回调，可被统一 webhook 入口复用
+
+        Args:
+            request: Quart 请求对象
+
+        Returns:
+            响应数据
+        """
+        # 获取原始请求体
+        body = await request.get_data()
+
+        try:
+            event_data = await request.json
+        except Exception as e:
+            logger.error(f"[Lark Webhook] 解析请求体失败: {e}")
+            return {"error": "Invalid JSON"}, 400
+
+        if not event_data:
+            logger.error("[Lark Webhook] 请求体为空")
+            return {"error": "Empty request body"}, 400
+
+        # 如果配置了 encrypt_key，进行签名验证
+        if self.encrypt_key:
+            timestamp = request.headers.get("X-Lark-Request-Timestamp", "")
+            nonce = request.headers.get("X-Lark-Request-Nonce", "")
+            signature = request.headers.get("X-Lark-Signature", "")
+
+            if timestamp and nonce and signature:
+                if not self.verify_signature(
+                    timestamp, nonce, self.encrypt_key, body, signature
+                ):
+                    logger.error("[Lark Webhook] 签名验证失败")
+                    return {"error": "Invalid signature"}, 401
+
+        # 检查是否是加密事件
+        if "encrypt" in event_data:
+            try:
+                event_data = self.decrypt_event(event_data["encrypt"])
+                logger.debug(f"[Lark Webhook] 解密后的事件: {event_data}")
+            except Exception as e:
+                logger.error(f"[Lark Webhook] 解密事件失败: {e}")
+                return {"error": "Decryption failed"}, 400
+
+        # 验证 token
+        if self.verification_token:
+            header = event_data.get("header", {})
+            if header:
+                token = header.get("token", "")
+            else:
+                token = event_data.get("token", "")
+            if token != self.verification_token:
+                logger.error("[Lark Webhook] Verification Token 不匹配。")
+                return {"error": "Invalid verification token"}, 401
+
+        # 处理 URL 验证 (challenge)
+        if event_data.get("type") == "url_verification":
+            return await self.handle_challenge(event_data)
+
+        # 调用回调函数处理事件
+        if self.callback:
+            try:
+                await self.callback(event_data)
+            except Exception as e:
+                logger.error(f"[Lark Webhook] 处理事件回调失败: {e}", exc_info=True)
+                return {"error": "Event processing failed"}, 500
+
+        return {}
+
+    def set_callback(self, callback: Callable[[dict], Awaitable[None]]):
+        """设置事件回调函数
+
+        Args:
+            callback: 处理事件的异步函数
+        """
+        self.callback = callback

astrbot/core/platform/sources/misskey/misskey_adapter.py

@@ -1,7 +1,6 @@
 import asyncio
 import os
 import random
-from collections.abc import Awaitable
 from typing import Any
 
 import astrbot.api.message_components as Comp
@@ -203,7 +202,7 @@ class MisskeyPlatformAdapter(Platform):
             if not isinstance(message.raw_message, dict):
                 message.raw_message = {}
             message.raw_message["poll"] = poll
-            message.poll = poll
+            message.__setattr__("poll", poll)
         except Exception:
             pass
 
@@ -372,7 +371,7 @@ class MisskeyPlatformAdapter(Platform):
         self,
         session: MessageSession,
         message_chain: MessageChain,
-    ) -> Awaitable[Any]:
+    ) -> None:
         if not self.api:
             logger.error("[Misskey] API 客户端未初始化")
             return await super().send_by_session(session, message_chain)

astrbot/core/platform/sources/qqofficial/qqofficial_message_event.py

@@ -3,6 +3,7 @@ import base64
 import os
 import random
 import uuid
+from typing import cast
 
 import aiofiles
 import botpy
@@ -60,7 +61,10 @@ class QQOfficialMessageEvent(AstrMessageEvent):
                     time_since_last_edit = current_time - last_edit_time
 
                     if time_since_last_edit >= throttle_interval:
-                        ret = await self._post_send(stream=stream_payload)
+                        ret = cast(
+                            message.Message,
+                            await self._post_send(stream=stream_payload),
+                        )
                         stream_payload["index"] += 1
                         stream_payload["id"] = ret["id"]
                         last_edit_time = asyncio.get_event_loop().time()
@@ -83,7 +87,8 @@ class QQOfficialMessageEvent(AstrMessageEvent):
             return None
 
         source = self.message_obj.raw_message
-        assert isinstance(
+
+        if not isinstance(
             source,
             (
                 botpy.message.Message,
@@ -91,7 +96,9 @@ class QQOfficialMessageEvent(AstrMessageEvent):
                 botpy.message.DirectMessage,
                 botpy.message.C2CMessage,
             ),
-        )
+        ):
+            logger.warning(f"[QQOfficial] 不支持的消息源类型: {type(source)}")
+            return None
 
         (
             plain_text,
@@ -108,7 +115,7 @@ class QQOfficialMessageEvent(AstrMessageEvent):
         ):
             return None
 
-        payload = {
+        payload: dict = {
             "content": plain_text,
             "msg_id": self.message_obj.message_id,
         }
@@ -118,8 +125,12 @@ class QQOfficialMessageEvent(AstrMessageEvent):
 
         ret = None
 
-        match type(source):
-            case botpy.message.GroupMessage:
+        match source:
+            case botpy.message.GroupMessage():
+                if not source.group_openid:
+                    logger.error("[QQOfficial] GroupMessage 缺少 group_openid")
+                    return None
+
                 if image_base64:
                     media = await self.upload_group_and_c2c_image(
                         image_base64,
@@ -140,7 +151,8 @@ class QQOfficialMessageEvent(AstrMessageEvent):
                     group_openid=source.group_openid,
                     **payload,
                 )
-            case botpy.message.C2CMessage:
+
+            case botpy.message.C2CMessage():
                 if image_base64:
                     media = await self.upload_group_and_c2c_image(
                         image_base64,
@@ -169,18 +181,23 @@ class QQOfficialMessageEvent(AstrMessageEvent):
                         **payload,
                     )
                 logger.debug(f"Message sent to C2C: {ret}")
-            case botpy.message.Message:
+
+            case botpy.message.Message():
                 if image_path:
                     payload["file_image"] = image_path
                 ret = await self.bot.api.post_message(
                     channel_id=source.channel_id,
                     **payload,
                 )
-            case botpy.message.DirectMessage:
+
+            case botpy.message.DirectMessage():
                 if image_path:
                     payload["file_image"] = image_path
                 ret = await self.bot.api.post_dms(guild_id=source.guild_id, **payload)
 
+            case _:
+                pass
+
         await super().send(self.send_buffer)
 
         self.send_buffer = None
@@ -198,18 +215,33 @@ class QQOfficialMessageEvent(AstrMessageEvent):
             "file_type": file_type,
             "srv_send_msg": False,
         }
+
+        result = None
         if "openid" in kwargs:
             payload["openid"] = kwargs["openid"]
             route = Route("POST", "/v2/users/{openid}/files", openid=kwargs["openid"])
-            return await self.bot.api._http.request(route, json=payload)
-        if "group_openid" in kwargs:
+            result = await self.bot.api._http.request(route, json=payload)
+        elif "group_openid" in kwargs:
             payload["group_openid"] = kwargs["group_openid"]
             route = Route(
                 "POST",
                 "/v2/groups/{group_openid}/files",
                 group_openid=kwargs["group_openid"],
             )
-            return await self.bot.api._http.request(route, json=payload)
+            result = await self.bot.api._http.request(route, json=payload)
+        else:
+            raise ValueError("Invalid upload parameters")
+
+        if not isinstance(result, dict):
+            raise RuntimeError(
+                f"Failed to upload image, response is not dict: {result}"
+            )
+
+        return Media(
+            file_uuid=result["file_uuid"],
+            file_info=result["file_info"],
+            ttl=result.get("ttl", 0),
+        )
 
     async def upload_group_and_c2c_record(
         self,
@@ -252,11 +284,14 @@ class QQOfficialMessageEvent(AstrMessageEvent):
             result = await self.bot.api._http.request(route, json=payload)
 
             if result:
+                if not isinstance(result, dict):
+                    logger.error(f"上传文件响应格式错误: {result}")
+                    return None
+
                 return Media(
-                    file_uuid=result.get("file_uuid"),
-                    file_info=result.get("file_info"),
+                    file_uuid=result["file_uuid"],
+                    file_info=result["file_info"],
                     ttl=result.get("ttl", 0),
-                    file_id=result.get("id", ""),
                 )
         except Exception as e:
             logger.error(f"上传请求错误: {e}")
@@ -273,7 +308,7 @@ class QQOfficialMessageEvent(AstrMessageEvent):
         message_reference: message.Reference | None = None,
         media: message.Media | None = None,
         msg_id: str | None = None,
-        msg_seq: str = 1,
+        msg_seq: int | None = 1,
         event_id: str | None = None,
         markdown: message.MarkdownPayload | None = None,
         keyboard: message.Keyboard | None = None,
@@ -282,7 +317,14 @@ class QQOfficialMessageEvent(AstrMessageEvent):
         payload = locals()
         payload.pop("self", None)
         route = Route("POST", "/v2/users/{openid}/messages", openid=openid)
-        return await self.bot.api._http.request(route, json=payload)
+        result = await self.bot.api._http.request(route, json=payload)
+
+        if not isinstance(result, dict):
+            raise RuntimeError(
+                f"Failed to post c2c message, response is not dict: {result}"
+            )
+
+        return message.Message(**result)
 
     @staticmethod
     async def _parse_to_qqofficial(message: MessageChain):
@@ -302,8 +344,10 @@ class QQOfficialMessageEvent(AstrMessageEvent):
                     image_base64 = file_to_base64(image_file_path)
                 elif i.file and i.file.startswith("base64://"):
                     image_base64 = i.file
-                else:
+                elif i.file:
                     image_base64 = file_to_base64(i.file)
+                else:
+                    raise ValueError("Unsupported image file format")
                 image_base64 = image_base64.removeprefix("base64://")
             elif isinstance(i, Record):
                 if i.file:

astrbot/core/platform/sources/qqofficial/qqofficial_platform_adapter.py

@@ -4,6 +4,7 @@ import asyncio
 import logging
 import os
 import time
+from typing import cast
 
 import botpy
 import botpy.message
@@ -44,7 +45,9 @@ class botClient(Client):
             MessageType.GROUP_MESSAGE,
         )
         abm.session_id = (
-            abm.sender.user_id if self.platform.unique_session else message.group_openid
+            abm.sender.user_id
+            if self.platform.unique_session
+            else cast(str, message.group_openid)
         )
         self._commit(abm)
 
@@ -101,7 +104,7 @@ class QQOfficialPlatformAdapter(Platform):
 
         self.appid = platform_config["appid"]
         self.secret = platform_config["secret"]
-        self.unique_session = platform_settings["unique_session"]
+        self.unique_session: bool = platform_settings["unique_session"]
         qq_group = platform_config["enable_group_c2c"]
         guild_dm = platform_config["enable_guild_direct_message"]
 
@@ -137,12 +140,15 @@ class QQOfficialPlatformAdapter(Platform):
         return PlatformMetadata(
             name="qq_official",
             description="QQ 机器人官方 API 适配器",
-            id=self.config.get("id"),
+            id=cast(str, self.config.get("id")),
         )
 
     @staticmethod
     def _parse_from_qqofficial(
-        message: botpy.message.Message | botpy.message.GroupMessage,
+        message: botpy.message.Message
+        | botpy.message.GroupMessage
+        | botpy.message.DirectMessage
+        | botpy.message.C2CMessage,
         message_type: MessageType,
     ):
         abm = AstrBotMessage()
@@ -150,7 +156,7 @@ class QQOfficialPlatformAdapter(Platform):
         abm.timestamp = int(time.time())
         abm.raw_message = message
         abm.message_id = message.id
-        abm.tag = "qq_official"
+        # abm.tag = "qq_official"
         msg: list[BaseMessageComponent] = []
 
         if isinstance(message, botpy.message.GroupMessage) or isinstance(
@@ -180,9 +186,9 @@ class QQOfficialPlatformAdapter(Platform):
             message,
             botpy.message.DirectMessage,
         ):
-            try:
+            if isinstance(message, botpy.message.Message):
                 abm.self_id = str(message.mentions[0].id)
-            except BaseException as _:
+            else:
                 abm.self_id = ""
 
             plain_content = message.content.replace(

astrbot/core/platform/sources/qqofficial_webhook/qo_webhook_adapter.py

@@ -1,6 +1,6 @@
 import asyncio
 import logging
-from typing import Any
+from typing import Any, cast
 
 import botpy
 import botpy.message
@@ -36,7 +36,9 @@ class botClient(Client):
             MessageType.GROUP_MESSAGE,
         )
         abm.session_id = (
-            abm.sender.user_id if self.platform.unique_session else message.group_openid
+            abm.sender.user_id
+            if self.platform.unique_session
+            else cast(str, message.group_openid)
         )
         self._commit(abm)
 
@@ -120,7 +122,7 @@ class QQOfficialWebhookPlatformAdapter(Platform):
         return PlatformMetadata(
             name="qq_official_webhook",
             description="QQ 机器人官方 API 适配器",
-            id=self.config.get("id"),
+            id=cast(str, self.config.get("id")),
         )
 
     async def run(self):

astrbot/core/platform/sources/qqofficial_webhook/qo_webhook_server.py

@@ -1,5 +1,6 @@
 import asyncio
 import logging
+from typing import cast
 
 import quart
 from botpy import BotAPI, BotHttp, BotWebSocket, Client, ConnectionSession, Token
@@ -99,7 +100,7 @@ class QQOfficialWebhook:
 
         if opcode == 13:
             # validation
-            signed = await self.webhook_validation(data)
+            signed = await self.webhook_validation(cast(dict, data))
             print(signed)
             return signed
 

astrbot/core/platform/sources/slack/client.py

@@ -4,9 +4,11 @@ import hmac
 import json
 import logging
 from collections.abc import Callable
+from typing import cast
 
 from quart import Quart, Response, request
 from slack_sdk.socket_mode.aiohttp import SocketModeClient
+from slack_sdk.socket_mode.async_client import AsyncBaseSocketModeClient
 from slack_sdk.socket_mode.request import SocketModeRequest
 from slack_sdk.socket_mode.response import SocketModeResponse
 from slack_sdk.web.async_client import AsyncWebClient
@@ -66,7 +68,7 @@ class SlackWebhookClient:
         """
         try:
             # 获取请求体和头部
-            body = await req.get_data()
+            body = cast(bytes, await req.get_data())
             event_data = json.loads(body.decode("utf-8"))
 
             # Verify Slack request signature
@@ -139,9 +141,14 @@ class SlackSocketClient:
         self.event_handler = event_handler
         self.socket_client = None
 
-    async def _handle_events(self, _: SocketModeClient, req: SocketModeRequest):
+    async def _handle_events(
+        self, _: AsyncBaseSocketModeClient, req: SocketModeRequest
+    ):
         """处理 Socket Mode 事件"""
         try:
+            if self.socket_client is None:
+                raise RuntimeError("Socket client is not initialized")
+
             # 确认收到事件
             response = SocketModeResponse(envelope_id=req.envelope_id)
             await self.socket_client.send_socket_mode_response(response)

astrbot/core/platform/sources/slack/slack_adapter.py

@@ -3,8 +3,7 @@ import base64
 import re
 import time
 import uuid
-from collections.abc import Awaitable
-from typing import Any
+from typing import Any, cast
 
 import aiohttp
 from slack_sdk.socket_mode.request import SocketModeRequest
@@ -68,7 +67,7 @@ class SlackAdapter(Platform):
         self.metadata = PlatformMetadata(
             name="slack",
             description="适用于 Slack 的消息平台适配器，支持 Socket Mode 和 Webhook Mode。",
-            id=self.config.get("id"),
+            id=cast(str, self.config.get("id")),
             support_streaming_message=False,
         )
 
@@ -118,13 +117,13 @@ class SlackAdapter(Platform):
         logger.debug(f"[slack] RawMessage {event}")
 
         abm = AstrBotMessage()
-        abm.self_id = self.bot_self_id
+        abm.self_id = cast(str, self.bot_self_id)
 
         # 获取用户信息
         user_id = event.get("user", "")
         try:
             user_info = await self.web_client.users_info(user=user_id)
-            user_data = user_info["user"]
+            user_data = cast(dict, user_info["user"])
             user_name = user_data.get("real_name") or user_data.get("name", user_id)
         except Exception:
             user_name = user_id
@@ -135,7 +134,7 @@ class SlackAdapter(Platform):
         channel_id = event.get("channel", "")
         try:
             channel_info = await self.web_client.conversations_info(channel=channel_id)
-            is_im = channel_info["channel"]["is_im"]
+            is_im = cast(dict, channel_info["channel"])["is_im"]
 
             if is_im:
                 abm.type = MessageType.FRIEND_MESSAGE
@@ -178,7 +177,7 @@ class SlackAdapter(Platform):
                 for mention in mentions:
                     try:
                         mentioned_user = await self.web_client.users_info(user=mention)
-                        user_data = mentioned_user["user"]
+                        user_data = cast(dict, mentioned_user["user"])
                         user_name = user_data.get("real_name") or user_data.get(
                             "name",
                             mention,
@@ -329,7 +328,7 @@ class SlackAdapter(Platform):
                 )
                 raise Exception(f"下载文件失败: {resp.status}")
 
-    async def run(self) -> Awaitable[Any]:
+    async def run(self) -> None:
         self.bot_self_id = await self.get_bot_user_id()
         logger.info(f"Slack auth test OK. Bot ID: {self.bot_self_id}")
 
@@ -410,7 +409,7 @@ class SlackAdapter(Platform):
             await self.socket_client.stop()
         if self.webhook_client:
             await self.webhook_client.stop()
-        logger.info("Slack 适配器已被优雅地关闭")
+        logger.info("Slack 适配器已被关闭")
 
     def meta(self) -> PlatformMetadata:
         return self.metadata
@@ -428,3 +427,10 @@ class SlackAdapter(Platform):
 
     def get_client(self):
         return self.web_client
+
+    def unified_webhook(self) -> bool:
+        return bool(
+            self.config.get("unified_webhook_mode", False)
+            and self.config.get("slack_connection_mode", "") == "webhook"
+            and self.config.get("webhook_uuid")
+        )

astrbot/core/platform/sources/slack/slack_event.py

@@ -1,6 +1,7 @@
 import asyncio
 import re
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Iterable
+from typing import cast
 
 from slack_sdk.web.async_client import AsyncWebClient
 
@@ -38,7 +39,7 @@ class SlackMessageEvent(AstrMessageEvent):
         if isinstance(segment, Image):
             # upload file
             url = segment.url or segment.file
-            if url.startswith("http"):
+            if url and url.startswith("http"):
                 return {
                     "type": "image",
                     "image_url": url,
@@ -55,7 +56,7 @@ class SlackMessageEvent(AstrMessageEvent):
                     "type": "section",
                     "text": {"type": "mrkdwn", "text": "图片上传失败"},
                 }
-            image_url = response["files"][0]["url_private"]
+            image_url = cast(list, response["files"])[0]["url_private"]
             logger.debug(f"Slack file upload response: {response}")
             return {
                 "type": "image",
@@ -77,7 +78,7 @@ class SlackMessageEvent(AstrMessageEvent):
                     "type": "section",
                     "text": {"type": "mrkdwn", "text": "文件上传失败"},
                 }
-            file_url = response["files"][0]["permalink"]
+            file_url = cast(list, response["files"])[0]["permalink"]
             return {
                 "type": "section",
                 "text": {
@@ -225,10 +226,10 @@ class SlackMessageEvent(AstrMessageEvent):
             )
 
             members = []
-            for member_id in members_response["members"]:
+            for member_id in cast(Iterable, members_response["members"]):
                 try:
                     user_info = await self.web_client.users_info(user=member_id)
-                    user_data = user_info["user"]
+                    user_data = cast(dict, user_info["user"])
                     members.append(
                         MessageMember(
                             user_id=member_id,
@@ -240,7 +241,7 @@ class SlackMessageEvent(AstrMessageEvent):
                     # 如果获取用户信息失败，使用默认信息
                     members.append(MessageMember(user_id=member_id, nickname=member_id))
 
-            channel_data = channel_info["channel"]
+            channel_data = cast(dict, channel_info["channel"])
             return Group(
                 group_id=channel_id,
                 group_name=channel_data.get("name", ""),

astrbot/core/platform/sources/telegram/tg_adapter.py

@@ -424,6 +424,6 @@ class TelegramPlatformAdapter(Platform):
             if self.application.updater is not None:
                 await self.application.updater.stop()
 
-            logger.info("Telegram 适配器已被优雅地关闭")
+            logger.info("Telegram 适配器已被关闭")
         except Exception as e:
             logger.error(f"Telegram 适配器关闭时出错: {e}")

astrbot/core/platform/sources/telegram/tg_event.py

@@ -1,6 +1,7 @@
 import asyncio
 import os
 import re
+from typing import Any, cast
 
 import telegramify_markdown
 from telegram import ReactionTypeCustomEmoji, ReactionTypeEmoji
@@ -17,8 +18,6 @@ from astrbot.api.message_components import (
     Reply,
 )
 from astrbot.api.platform import AstrBotMessage, MessageType, PlatformMetadata
-from astrbot.core.utils.astrbot_path import get_astrbot_data_path
-from astrbot.core.utils.io import download_file
 
 
 class TelegramPlatformEvent(AstrMessageEvent):
@@ -97,7 +96,7 @@ class TelegramPlatformEvent(AstrMessageEvent):
                 "chat_id": user_name,
             }
             if has_reply:
-                payload["reply_to_message_id"] = reply_message_id
+                payload["reply_to_message_id"] = str(reply_message_id)
             if message_thread_id:
                 payload["message_thread_id"] = message_thread_id
 
@@ -110,33 +109,30 @@ class TelegramPlatformEvent(AstrMessageEvent):
                     try:
                         md_text = telegramify_markdown.markdownify(
                             chunk,
-                            max_line_length=None,
                             normalize_whitespace=False,
                         )
                         await client.send_message(
                             text=md_text,
                             parse_mode="MarkdownV2",
-                            **payload,
+                            **cast(Any, payload),
                         )
                     except Exception as e:
                         logger.warning(
                             f"MarkdownV2 send failed: {e}. Using plain text instead.",
                         )
-                        await client.send_message(text=chunk, **payload)
+                        await client.send_message(text=chunk, **cast(Any, payload))
             elif isinstance(i, Image):
                 image_path = await i.convert_to_file_path()
-                await client.send_photo(photo=image_path, **payload)
+                await client.send_photo(photo=image_path, **cast(Any, payload))
             elif isinstance(i, File):
-                if i.file.startswith("https://"):
-                    temp_dir = os.path.join(get_astrbot_data_path(), "temp")
-                    path = os.path.join(temp_dir, i.name)
-                    await download_file(i.file, path)
-                    i.file = path
-
-                await client.send_document(document=i.file, filename=i.name, **payload)
+                path = await i.get_file()
+                name = i.name or os.path.basename(path)
+                await client.send_document(
+                    document=path, filename=name, **cast(Any, payload)
+                )
             elif isinstance(i, Record):
                 path = await i.convert_to_file_path()
-                await client.send_voice(voice=path, **payload)
+                await client.send_voice(voice=path, **cast(Any, payload))
 
     async def send(self, message: MessageChain):
         if self.get_message_type() == MessageType.GROUP_MESSAGE:
@@ -204,6 +200,15 @@ class TelegramPlatformEvent(AstrMessageEvent):
             if isinstance(chain, MessageChain):
                 if chain.type == "break":
                     # 分割符
+                    if message_id:
+                        try:
+                            await self.client.edit_message_text(
+                                text=delta,
+                                chat_id=payload["chat_id"],
+                                message_id=message_id,
+                            )
+                        except Exception as e:
+                            logger.warning(f"编辑消息失败(streaming-break): {e!s}")
                     message_id = None  # 重置消息 ID
                     delta = ""  # 重置 delta
                     continue
@@ -214,24 +219,23 @@ class TelegramPlatformEvent(AstrMessageEvent):
                         delta += i.text
                     elif isinstance(i, Image):
                         image_path = await i.convert_to_file_path()
-                        await self.client.send_photo(photo=image_path, **payload)
+                        await self.client.send_photo(
+                            photo=image_path, **cast(Any, payload)
+                        )
                         continue
                     elif isinstance(i, File):
-                        if i.file.startswith("https://"):
-                            temp_dir = os.path.join(get_astrbot_data_path(), "temp")
-                            path = os.path.join(temp_dir, i.name)
-                            await download_file(i.file, path)
-                            i.file = path
+                        path = await i.get_file()
+                        name = i.name or os.path.basename(path)
 
                         await self.client.send_document(
-                            document=i.file,
-                            filename=i.name,
-                            **payload,
+                            document=path,
+                            filename=name,
+                            **cast(Any, payload),
                         )
                         continue
                     elif isinstance(i, Record):
                         path = await i.convert_to_file_path()
-                        await self.client.send_voice(voice=path, **payload)
+                        await self.client.send_voice(voice=path, **cast(Any, payload))
                         continue
                     else:
                         logger.warning(f"不支持的消息类型: {type(i)}")
@@ -260,7 +264,9 @@ class TelegramPlatformEvent(AstrMessageEvent):
                 else:
                     # delta 长度一般不会大于 4096，因此这里直接发送
                     try:
-                        msg = await self.client.send_message(text=delta, **payload)
+                        msg = await self.client.send_message(
+                            text=delta, **cast(Any, payload)
+                        )
                         current_content = delta
                     except Exception as e:
                         logger.warning(f"发送消息失败(streaming): {e!s}")
@@ -274,7 +280,6 @@ class TelegramPlatformEvent(AstrMessageEvent):
                 try:
                     markdown_text = telegramify_markdown.markdownify(
                         delta,
-                        max_line_length=None,
                         normalize_whitespace=False,
                     )
                     await self.client.edit_message_text(

astrbot/core/platform/sources/webchat/webchat_adapter.py

@@ -2,7 +2,7 @@ import asyncio
 import os
 import time
 import uuid
-from collections.abc import Awaitable, Callable
+from collections.abc import Callable, Coroutine
 from typing import Any
 
 from astrbot import logger
@@ -207,7 +207,7 @@ class WebChatAdapter(Platform):
         abm.raw_message = data
         return abm
 
-    def run(self) -> Awaitable[Any]:
+    def run(self) -> Coroutine[Any, Any, None]:
         async def callback(data: tuple):
             abm = await self.convert_message(data)
             await self.handle_msg(abm)

astrbot/core/platform/sources/webchat/webchat_event.py

@@ -1,11 +1,12 @@
 import base64
+import json
 import os
 import shutil
 import uuid
 
 from astrbot.api import logger
 from astrbot.api.event import AstrMessageEvent, MessageChain
-from astrbot.api.message_components import File, Image, Plain, Record
+from astrbot.api.message_components import File, Image, Json, Plain, Record
 from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 
 from .webchat_queue_mgr import webchat_queue_mgr
@@ -41,12 +42,20 @@ class WebChatMessageEvent(AstrMessageEvent):
                 await web_chat_back_queue.put(
                     {
                         "type": "plain",
-                        "cid": cid,
                         "data": data,
                         "streaming": streaming,
                         "chain_type": message.type,
                     },
                 )
+            elif isinstance(comp, Json):
+                await web_chat_back_queue.put(
+                    {
+                        "type": "plain",
+                        "data": json.dumps(comp.data, ensure_ascii=False),
+                        "streaming": streaming,
+                        "chain_type": message.type,
+                    },
+                )
             elif isinstance(comp, Image):
                 # save image to local
                 filename = f"{str(uuid.uuid4())}.jpg"
@@ -58,7 +67,6 @@ class WebChatMessageEvent(AstrMessageEvent):
                 await web_chat_back_queue.put(
                     {
                         "type": "image",
-                        "cid": cid,
                         "data": data,
                         "streaming": streaming,
                     },
@@ -74,7 +82,6 @@ class WebChatMessageEvent(AstrMessageEvent):
                 await web_chat_back_queue.put(
                     {
                         "type": "record",
-                        "cid": cid,
                         "data": data,
                         "streaming": streaming,
                     },
@@ -91,7 +98,6 @@ class WebChatMessageEvent(AstrMessageEvent):
                 await web_chat_back_queue.put(
                     {
                         "type": "file",
-                        "cid": cid,
                         "data": data,
                         "streaming": streaming,
                     },
@@ -101,9 +107,9 @@ class WebChatMessageEvent(AstrMessageEvent):
 
         return data
 
-    async def send(self, message: MessageChain):
+    async def send(self, message: MessageChain | None):
         await WebChatMessageEvent._send(message, session_id=self.session_id)
-        await super().send(message)
+        await super().send(MessageChain([]))
 
     async def send_streaming(self, generator, use_fallback: bool = False):
         final_data = ""
@@ -111,18 +117,17 @@ class WebChatMessageEvent(AstrMessageEvent):
         cid = self.session_id.split("!")[-1]
         web_chat_back_queue = webchat_queue_mgr.get_or_create_back_queue(cid)
         async for chain in generator:
-            if chain.type == "break" and final_data:
-                # 分割符
-                await web_chat_back_queue.put(
-                    {
-                        "type": "break",  # break means a segment end
-                        "data": final_data,
-                        "streaming": True,
-                        "cid": cid,
-                    },
-                )
-                final_data = ""
-                continue
+            # if chain.type == "break" and final_data:
+            #     # 分割符
+            #     await web_chat_back_queue.put(
+            #         {
+            #             "type": "break",  # break means a segment end
+            #             "data": final_data,
+            #             "streaming": True,
+            #         },
+            #     )
+            #     final_data = ""
+            #     continue
 
             r = await WebChatMessageEvent._send(
                 chain,
@@ -142,7 +147,6 @@ class WebChatMessageEvent(AstrMessageEvent):
                 "data": final_data,
                 "reasoning": reasoning_content,
                 "streaming": True,
-                "cid": cid,
             },
         )
         await super().send_streaming(generator, use_fallback)

astrbot/core/platform/sources/wechatpadpro/wechatpadpro_adapter.py

@@ -4,6 +4,7 @@ import json
 import os
 import time
 import traceback
+from typing import cast
 
 import aiohttp
 import anyio
@@ -69,7 +70,7 @@ class WeChatPadProAdapter(Platform):
         )
         self.base_url = f"http://{self.host}:{self.port}"
         self.auth_key = None  # 用于保存生成的授权码
-        self.wxid = None  # 用于保存登录成功后的 wxid
+        self.wxid: str | None = None  # 用于保存登录成功后的 wxid
         self.credentials_file = os.path.join(
             get_astrbot_data_path(),
             "wechatpadpro_credentials.json",
@@ -398,7 +399,7 @@ class WeChatPadProAdapter(Platform):
                 )
                 await asyncio.sleep(5)
 
-    async def handle_websocket_message(self, message: str):
+    async def handle_websocket_message(self, message: str | bytes):
         """处理从 WebSocket 接收到的消息。"""
         logger.debug(f"收到 WebSocket 消息: {message}")
         try:
@@ -430,10 +431,13 @@ class WeChatPadProAdapter(Platform):
 
     async def convert_message(self, raw_message: dict) -> AstrBotMessage | None:
         """将 WeChatPadPro 原始消息转换为 AstrBotMessage。"""
+        if self.wxid is None:
+            logger.error("WeChatPadPro 适配器未登录或未获取到 wxid，无法处理消息。")
+            return None
         abm = AstrBotMessage()
         abm.raw_message = raw_message
         abm.message_id = str(raw_message.get("msg_id"))
-        abm.timestamp = raw_message.get("create_time")
+        abm.timestamp = cast(int, raw_message.get("create_time"))
         abm.self_id = self.wxid
 
         if int(time.time()) - abm.timestamp > 180:
@@ -446,7 +450,7 @@ class WeChatPadProAdapter(Platform):
         to_user_name = raw_message.get("to_user_name", {}).get("str", "")
         content = raw_message.get("content", {}).get("str", "")
         push_content = raw_message.get("push_content", "")
-        msg_type = raw_message.get("msg_type")
+        msg_type = cast(int, raw_message.get("msg_type"))
 
         abm.message_str = ""
         abm.message = []
@@ -574,7 +578,7 @@ class WeChatPadProAdapter(Platform):
         from_user_name: str,
         to_user_name: str,
         msg_id: int,
-    ):
+    ) -> dict | None:
         """下载原始图片。"""
         url = f"{self.base_url}/message/GetMsgBigImg"
         params = {"key": self.auth_key}
@@ -725,12 +729,15 @@ class WeChatPadProAdapter(Platform):
             # 图片消息
             from_user_name = raw_message.get("from_user_name", {}).get("str", "")
             to_user_name = raw_message.get("to_user_name", {}).get("str", "")
-            msg_id = raw_message.get("msg_id")
+            msg_id = cast(int, raw_message.get("msg_id"))
             image_resp = await self._download_raw_image(
                 from_user_name,
                 to_user_name,
                 msg_id,
             )
+            if image_resp is None:
+                logger.error(f"下载图片失败: msg_id={msg_id}")
+                return
             image_bs64_data = (
                 image_resp.get("Data", {}).get("Data", {}).get("Buffer", None)
             )
@@ -771,6 +778,9 @@ class WeChatPadProAdapter(Platform):
             bufid = 0
             to_user_name = raw_message.get("to_user_name", {}).get("str", "")
             new_msg_id = raw_message.get("new_msg_id")
+            if new_msg_id is None:
+                logger.error("语音消息缺少 new_msg_id")
+                return
             data_parser = GeweDataParser(
                 content=content,
                 is_private_chat=(abm.type != MessageType.GROUP_MESSAGE),
@@ -778,6 +788,9 @@ class WeChatPadProAdapter(Platform):
             )
 
             voicemsg = data_parser._format_to_xml().find("voicemsg")
+            if voicemsg is None:
+                logger.error("无法从 XML 解析 voicemsg 节点")
+                return
             bufid = voicemsg.get("bufid") or "0"
             length = int(voicemsg.get("length") or 0)
             voice_resp = await self.download_voice(
@@ -786,6 +799,9 @@ class WeChatPadProAdapter(Platform):
                 bufid=bufid,
                 length=length,
             )
+            if voice_resp is None:
+                logger.error(f"下载语音失败: new_msg_id={new_msg_id}")
+                return
             voice_bs64_data = voice_resp.get("Data", {}).get("Base64", None)
             if voice_bs64_data:
                 voice_bs64_data = base64.b64decode(voice_bs64_data)
@@ -827,7 +843,8 @@ class WeChatPadProAdapter(Platform):
         try:
             if self.ws_handle_task:
                 self.ws_handle_task.cancel()
-            self._shutdown_event.set()
+            if self._shutdown_event is not None:
+                self._shutdown_event.set()
         except Exception:
             pass
 
@@ -894,8 +911,8 @@ class WeChatPadProAdapter(Platform):
 
     async def get_contact_details_list(
         self,
-        room_wx_id_list: list[str] = None,
-        user_names: list[str] = None,
+        room_wx_id_list: list[str] | None = None,
+        user_names: list[str] | None = None,
     ) -> dict | None:
         """获取联系人详情列表。"""
         if room_wx_id_list is None:

astrbot/core/platform/sources/wecom/wecom_adapter.py

@@ -2,7 +2,8 @@ import asyncio
 import os
 import sys
 import uuid
-from typing import Any
+from collections.abc import Awaitable, Callable
+from typing import Any, cast
 
 import quart
 from requests import Response
@@ -40,7 +41,7 @@ else:
 class WecomServer:
     def __init__(self, event_queue: asyncio.Queue, config: dict):
         self.server = quart.Quart(__name__)
-        self.port = int(config.get("port"))
+        self.port = int(cast(str, config.get("port")))
         self.callback_server_host = config.get("callback_server_host", "0.0.0.0")
         self.server.add_url_rule(
             "/callback/command",
@@ -60,7 +61,7 @@ class WecomServer:
             config["corpid"].strip(),
         )
 
-        self.callback = None
+        self.callback: Callable[[BaseMessage], Awaitable[None]] | None = None
         self.shutdown_event = asyncio.Event()
 
     async def verify(self):
@@ -114,7 +115,7 @@ class WecomServer:
             logger.error("解密失败，签名异常，请检查配置。")
             raise
         else:
-            msg = parse_message(xml)
+            msg = cast(BaseMessage, parse_message(xml))
             logger.info(f"解析成功: {msg}")
 
             if self.callback:
@@ -176,10 +177,10 @@ class WecomPlatformAdapter(Platform):
             # inject
             self.wechat_kf_api = WeChatKF(client=self.client)
             self.wechat_kf_message_api = WeChatKFMessage(self.client)
-            self.client.kf = self.wechat_kf_api
-            self.client.kf_message = self.wechat_kf_message_api
+            self.client.__setattr__("kf", self.wechat_kf_api)
+            self.client.__setattr__("kf_message", self.wechat_kf_message_api)
 
-        self.client.API_BASE_URL = self.api_base_url
+        self.client.__setattr__("API_BASE_URL", self.api_base_url)
 
         async def callback(msg: BaseMessage):
             if msg.type == "unknown" and msg._data["Event"] == "kf_msg_or_event":
@@ -278,37 +279,33 @@ class WecomPlatformAdapter(Platform):
 
     async def convert_message(self, msg: BaseMessage) -> AstrBotMessage | None:
         abm = AstrBotMessage()
-        if msg.type == "text":
-            assert isinstance(msg, TextMessage)
+        if isinstance(msg, TextMessage):
             abm.message_str = msg.content
             abm.self_id = str(msg.agent)
             abm.message = [Plain(msg.content)]
             abm.type = MessageType.FRIEND_MESSAGE
             abm.sender = MessageMember(
-                msg.source,
-                msg.source,
+                cast(str, msg.source),
+                cast(str, msg.source),
             )
-            abm.message_id = msg.id
-            abm.timestamp = msg.time
+            abm.message_id = str(msg.id)
+            abm.timestamp = int(cast(int | str, msg.time))
             abm.session_id = abm.sender.user_id
             abm.raw_message = msg
-        elif msg.type == "image":
-            assert isinstance(msg, ImageMessage)
+        elif isinstance(msg, ImageMessage):
             abm.message_str = "[图片]"
             abm.self_id = str(msg.agent)
             abm.message = [Image(file=msg.image, url=msg.image)]
             abm.type = MessageType.FRIEND_MESSAGE
             abm.sender = MessageMember(
-                msg.source,
-                msg.source,
+                cast(str, msg.source),
+                cast(str, msg.source),
             )
-            abm.message_id = msg.id
-            abm.timestamp = msg.time
+            abm.message_id = str(msg.id)
+            abm.timestamp = int(cast(int | str, msg.time))
             abm.session_id = abm.sender.user_id
             abm.raw_message = msg
-        elif msg.type == "voice":
-            assert isinstance(msg, VoiceMessage)
-
+        elif isinstance(msg, VoiceMessage):
             resp: Response = await asyncio.get_event_loop().run_in_executor(
                 None,
                 self.client.media.download,
@@ -335,11 +332,11 @@ class WecomPlatformAdapter(Platform):
             abm.message = [Record(file=path_wav, url=path_wav)]
             abm.type = MessageType.FRIEND_MESSAGE
             abm.sender = MessageMember(
-                msg.source,
-                msg.source,
+                cast(str, msg.source),
+                cast(str, msg.source),
             )
-            abm.message_id = msg.id
-            abm.timestamp = msg.time
+            abm.message_id = str(msg.id)
+            abm.timestamp = int(cast(int | str, msg.time))
             abm.session_id = abm.sender.user_id
             abm.raw_message = msg
         else:
@@ -351,7 +348,7 @@ class WecomPlatformAdapter(Platform):
 
     async def convert_wechat_kf_message(self, msg: dict) -> AstrBotMessage | None:
         msgtype = msg.get("msgtype")
-        external_userid = msg.get("external_userid")
+        external_userid = cast(str, msg.get("external_userid"))
         abm = AstrBotMessage()
         abm.raw_message = msg
         abm.raw_message["_wechat_kf_flag"] = None  # 方便处理
@@ -425,4 +422,4 @@ class WecomPlatformAdapter(Platform):
             await self.server.server.shutdown()
         except Exception as _:
             pass
-        logger.info("企业微信 适配器已被优雅地关闭")
+        logger.info("企业微信 适配器已被关闭")

astrbot/core/platform/sources/wecom/wecom_event.py

@@ -93,10 +93,10 @@ class WecomPlatformEvent(AstrMessageEvent):
         if is_wechat_kf:
             # 微信客服
             kf_message_api = getattr(self.client, "kf_message", None)
-            if not kf_message_api:
+            if not isinstance(kf_message_api, WeChatKFMessage):
                 logger.warning("未找到微信客服发送消息方法。")
                 return
-            assert isinstance(kf_message_api, WeChatKFMessage)
+
             user_id = self.get_sender_id()
             for comp in message.chain:
                 if isinstance(comp, Plain):

astrbot/core/platform/sources/wecom_ai_bot/wecomai_event.py

@@ -39,7 +39,7 @@ class WecomAIBotMessageEvent(AstrMessageEvent):
 
     @staticmethod
     async def _send(
-        message_chain: MessageChain,
+        message_chain: MessageChain | None,
         stream_id: str,
         queue_mgr: WecomAIQueueMgr,
         streaming: bool = False,
@@ -90,7 +90,7 @@ class WecomAIBotMessageEvent(AstrMessageEvent):
 
         return data
 
-    async def send(self, message: MessageChain):
+    async def send(self, message: MessageChain | None):
         """发送消息"""
         raw = self.message_obj.raw_message
         assert isinstance(raw, dict), (
@@ -98,7 +98,7 @@ class WecomAIBotMessageEvent(AstrMessageEvent):
         )
         stream_id = raw.get("stream_id", self.session_id)
         await WecomAIBotMessageEvent._send(message, stream_id, self.queue_mgr)
-        await super().send(message)
+        await super().send(MessageChain([]))
 
     async def send_streaming(self, generator, use_fallback=False):
         """流式发送消息，参考webchat的send_streaming设计"""

astrbot/core/platform/sources/weixin_official_account/weixin_offacc_adapter.py

@@ -1,7 +1,8 @@
 import asyncio
 import sys
 import uuid
-from typing import Any
+from collections.abc import Awaitable, Callable
+from typing import Any, cast
 
 import quart
 from requests import Response
@@ -36,7 +37,7 @@ else:
 class WeixinOfficialAccountServer:
     def __init__(self, event_queue: asyncio.Queue, config: dict):
         self.server = quart.Quart(__name__)
-        self.port = int(config.get("port"))
+        self.port = int(cast(int | str, config.get("port")))
         self.callback_server_host = config.get("callback_server_host", "0.0.0.0")
         self.token = config.get("token")
         self.encoding_aes_key = config.get("encoding_aes_key")
@@ -55,7 +56,7 @@ class WeixinOfficialAccountServer:
 
         self.event_queue = event_queue
 
-        self.callback = None
+        self.callback: Callable[[BaseMessage], Awaitable[None]] | None = None
         self.shutdown_event = asyncio.Event()
 
     async def verify(self):
@@ -114,6 +115,9 @@ class WeixinOfficialAccountServer:
             raise
         else:
             msg = parse_message(xml)
+            if not msg:
+                logger.error("解析失败。msg为None。")
+                raise
             logger.info(f"解析成功: {msg}")
 
             if self.callback:
@@ -176,7 +180,7 @@ class WeixinOfficialAccountPlatformAdapter(Platform):
             self.config["secret"].strip(),
         )
 
-        self.client.API_BASE_URL = self.api_base_url
+        self.client.__setattr__("API_BASE_URL", self.api_base_url)
 
         # 微信公众号必须 5 秒内进行回复，否则会重试 3 次，我们需要对其进行消息排重
         # msgid -> Future
@@ -188,11 +192,11 @@ class WeixinOfficialAccountPlatformAdapter(Platform):
                     await self.convert_message(msg, None)
                 else:
                     if msg.id in self.wexin_event_workers:
-                        future = self.wexin_event_workers[msg.id]
+                        future = self.wexin_event_workers[str(cast(str | int, msg.id))]
                         logger.debug(f"duplicate message id checked: {msg.id}")
                     else:
                         future = asyncio.get_event_loop().create_future()
-                        self.wexin_event_workers[msg.id] = future
+                        self.wexin_event_workers[str(cast(str | int, msg.id))] = future
                         await self.convert_message(msg, future)
                     # I love shield so much!
                     result = await asyncio.wait_for(
@@ -200,7 +204,7 @@ class WeixinOfficialAccountPlatformAdapter(Platform):
                         60,
                     )  # wait for 60s
                     logger.debug(f"Got future result: {result}")
-                    self.wexin_event_workers.pop(msg.id, None)
+                    self.wexin_event_workers.pop(str(cast(str | int, msg.id)), None)
                     return result  # xml. see weixin_offacc_event.py
             except asyncio.TimeoutError:
                 pass
@@ -248,33 +252,33 @@ class WeixinOfficialAccountPlatformAdapter(Platform):
     async def convert_message(
         self,
         msg,
-        future: asyncio.Future = None,
+        future: asyncio.Future | None = None,
     ) -> AstrBotMessage | None:
         abm = AstrBotMessage()
         if isinstance(msg, TextMessage):
-            abm.message_str = msg.content
+            abm.message_str = cast(str, msg.content)
             abm.self_id = str(msg.target)
-            abm.message = [Plain(msg.content)]
+            abm.message = [Plain(cast(str, msg.content))]
             abm.type = MessageType.FRIEND_MESSAGE
             abm.sender = MessageMember(
-                msg.source,
-                msg.source,
+                cast(str, msg.source),
+                cast(str, msg.source),
             )
-            abm.message_id = msg.id
-            abm.timestamp = msg.time
+            abm.message_id = str(cast(str | int, msg.id))
+            abm.timestamp = cast(int, msg.time)
             abm.session_id = abm.sender.user_id
         elif msg.type == "image":
             assert isinstance(msg, ImageMessage)
             abm.message_str = "[图片]"
             abm.self_id = str(msg.target)
-            abm.message = [Image(file=msg.image, url=msg.image)]
+            abm.message = [Image(file=cast(str, msg.image), url=cast(str, msg.image))]
             abm.type = MessageType.FRIEND_MESSAGE
             abm.sender = MessageMember(
-                msg.source,
-                msg.source,
+                cast(str, msg.source),
+                cast(str, msg.source),
             )
-            abm.message_id = msg.id
-            abm.timestamp = msg.time
+            abm.message_id = str(cast(str | int, msg.id))
+            abm.timestamp = cast(int, msg.time)
             abm.session_id = abm.sender.user_id
         elif msg.type == "voice":
             assert isinstance(msg, VoiceMessage)
@@ -306,15 +310,16 @@ class WeixinOfficialAccountPlatformAdapter(Platform):
             abm.message = [Record(file=path_wav, url=path_wav)]
             abm.type = MessageType.FRIEND_MESSAGE
             abm.sender = MessageMember(
-                msg.source,
-                msg.source,
+                cast(str, msg.source),
+                cast(str, msg.source),
             )
-            abm.message_id = msg.id
-            abm.timestamp = msg.time
+            abm.message_id = str(cast(str | int, msg.id))
+            abm.timestamp = cast(int, msg.time)
             abm.session_id = abm.sender.user_id
         else:
             logger.warning(f"暂未实现的事件: {msg.type}")
-            future.set_result(None)
+            if future:
+                future.set_result(None)
             return
         # 很不优雅 :(
         abm.raw_message = {
@@ -344,4 +349,4 @@ class WeixinOfficialAccountPlatformAdapter(Platform):
             await self.server.server.shutdown()
         except Exception as _:
             pass
-        logger.info("微信公众平台 适配器已被优雅地关闭")
+        logger.info("微信公众平台 适配器已被关闭")

astrbot/core/platform/sources/weixin_official_account/weixin_offacc_event.py

@@ -1,5 +1,6 @@
 import asyncio
 import uuid
+from typing import cast
 
 from wechatpy import WeChatClient
 from wechatpy.replies import ImageReply, TextReply, VoiceReply
@@ -85,7 +86,9 @@ class WeixinOfficialAccountPlatformEvent(AstrMessageEvent):
 
     async def send(self, message: MessageChain):
         message_obj = self.message_obj
-        active_send_mode = message_obj.raw_message.get("active_send_mode", False)
+        active_send_mode = cast(dict, message_obj.raw_message).get(
+            "active_send_mode", False
+        )
         for comp in message.chain:
             if isinstance(comp, Plain):
                 # Split long text messages if needed
@@ -96,10 +99,10 @@ class WeixinOfficialAccountPlatformEvent(AstrMessageEvent):
                     else:
                         reply = TextReply(
                             content=chunk,
-                            message=self.message_obj.raw_message["message"],
+                            message=cast(dict, self.message_obj.raw_message)["message"],
                         )
                         xml = reply.render()
-                        future = self.message_obj.raw_message["future"]
+                        future = cast(dict, self.message_obj.raw_message)["future"]
                         assert isinstance(future, asyncio.Future)
                         future.set_result(xml)
                     await asyncio.sleep(0.5)  # Avoid sending too fast
@@ -125,10 +128,10 @@ class WeixinOfficialAccountPlatformEvent(AstrMessageEvent):
                     else:
                         reply = ImageReply(
                             media_id=response["media_id"],
-                            message=self.message_obj.raw_message["message"],
+                            message=cast(dict, self.message_obj.raw_message)["message"],
                         )
                         xml = reply.render()
-                        future = self.message_obj.raw_message["future"]
+                        future = cast(dict, self.message_obj.raw_message)["future"]
                         assert isinstance(future, asyncio.Future)
                         future.set_result(xml)
 
@@ -160,10 +163,10 @@ class WeixinOfficialAccountPlatformEvent(AstrMessageEvent):
                     else:
                         reply = VoiceReply(
                             media_id=response["media_id"],
-                            message=self.message_obj.raw_message["message"],
+                            message=cast(dict, self.message_obj.raw_message)["message"],
                         )
                         xml = reply.render()
-                        future = self.message_obj.raw_message["future"]
+                        future = cast(dict, self.message_obj.raw_message)["future"]
                         assert isinstance(future, asyncio.Future)
                         future.set_result(xml)
 

astrbot/core/provider/entities.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import base64
 import enum
 import json
@@ -199,6 +201,38 @@ class ProviderRequest:
         return ""
 
 
+@dataclass
+class TokenUsage:
+    input_other: int = 0
+    """The number of input tokens, excluding cached tokens."""
+    input_cached: int = 0
+    """The number of input cached tokens."""
+    output: int = 0
+    """The number of output tokens."""
+
+    @property
+    def total(self) -> int:
+        return self.input_other + self.input_cached + self.output
+
+    @property
+    def input(self) -> int:
+        return self.input_other + self.input_cached
+
+    def __add__(self, other: TokenUsage) -> TokenUsage:
+        return TokenUsage(
+            input_other=self.input_other + other.input_other,
+            input_cached=self.input_cached + other.input_cached,
+            output=self.output + other.output,
+        )
+
+    def __sub__(self, other: TokenUsage) -> TokenUsage:
+        return TokenUsage(
+            input_other=self.input_other - other.input_other,
+            input_cached=self.input_cached - other.input_cached,
+            output=self.output - other.output,
+        )
+
+
 @dataclass
 class LLMResponse:
     role: str
@@ -227,6 +261,11 @@ class LLMResponse:
     is_chunk: bool = False
     """Indicates if the response is a chunked response."""
 
+    id: str | None = None
+    """The ID of the response. For chunked responses, it's the ID of the chunk; for non-chunked responses, it's the ID of the response."""
+    usage: TokenUsage | None = None
+    """The usage of the response. For chunked responses, it's the usage of the chunk; for non-chunked responses, it's the usage of the response."""
+
     def __init__(
         self,
         role: str,
@@ -241,6 +280,8 @@ class LLMResponse:
         | AnthropicMessage
         | None = None,
         is_chunk: bool = False,
+        id: str | None = None,
+        usage: TokenUsage | None = None,
     ):
         """初始化 LLMResponse
 

astrbot/core/provider/func_tool_manager.py

@@ -4,7 +4,7 @@ import asyncio
 import copy
 import json
 import os
-from collections.abc import Awaitable, Callable
+from collections.abc import AsyncGenerator, Awaitable, Callable
 from typing import Any
 
 import aiohttp
@@ -118,7 +118,7 @@ class FunctionToolManager:
         name: str,
         func_args: list[dict],
         desc: str,
-        handler: Callable[..., Awaitable[Any]],
+        handler: Callable[..., Awaitable[Any] | AsyncGenerator[Any]],
     ) -> FuncTool:
         params = {
             "type": "object",  # hard-coded here
@@ -140,7 +140,7 @@ class FunctionToolManager:
         name: str,
         func_args: list,
         desc: str,
-        handler: Callable[..., Awaitable[Any]],
+        handler: Callable[..., Awaitable[Any] | AsyncGenerator[Any]],
     ) -> None:
         """添加函数调用工具
 

astrbot/core/provider/manager.py

@@ -1,5 +1,6 @@
 import asyncio
 import traceback
+from typing import Protocol, runtime_checkable
 
 from astrbot.core import astrbot_config, logger, sp
 from astrbot.core.astrbot_config_mgr import AstrBotConfigManager
@@ -10,6 +11,7 @@ from .entities import ProviderType
 from .provider import (
     EmbeddingProvider,
     Provider,
+    Providers,
     RerankProvider,
     STTProvider,
     TTSProvider,
@@ -17,6 +19,11 @@ from .provider import (
 from .register import llm_tools, provider_cls_map
 
 
+@runtime_checkable
+class HasInitialize(Protocol):
+    async def initialize(self) -> None: ...
+
+
 class ProviderManager:
     def __init__(
         self,
@@ -48,7 +55,7 @@ class ProviderManager:
         """加载的 Rerank Provider 的实例"""
         self.inst_map: dict[
             str,
-            Provider | STTProvider | TTSProvider | EmbeddingProvider | RerankProvider,
+            Providers,
         ] = {}
         """Provider 实例映射. key: provider_id, value: Provider 实例"""
         self.llm_tools = llm_tools
@@ -123,15 +130,13 @@ class ProviderManager:
             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:
+    async def get_provider_by_id(self, provider_id: str) -> Providers | None:
         """根据提供商 ID 获取提供商实例"""
         return self.inst_map.get(provider_id)
 
     def get_using_provider(
-        self,
-        provider_type: ProviderType,
-        umo=None,
-    ) -> Provider | STTProvider | TTSProvider | None:
+        self, provider_type: ProviderType, umo=None
+    ) -> Providers | None:
         """获取正在使用的提供商实例。
 
         Args:
@@ -191,7 +196,6 @@ class ProviderManager:
                 logger.error(traceback.format_exc())
                 logger.error(e)
 
-        # 设置默认提供商
         selected_provider_id = sp.get(
             "curr_provider",
             self.provider_settings.get("default_provider_id"),
@@ -210,15 +214,37 @@ class ProviderManager:
             scope="global",
             scope_id="global",
         )
-        self.curr_provider_inst = self.inst_map.get(selected_provider_id)
+
+        temp_provider = (
+            self.inst_map.get(selected_provider_id)
+            if isinstance(selected_provider_id, str)
+            else None
+        )
+        self.curr_provider_inst = (
+            temp_provider if isinstance(temp_provider, Provider) else None
+        )
         if not self.curr_provider_inst and self.provider_insts:
             self.curr_provider_inst = self.provider_insts[0]
 
-        self.curr_stt_provider_inst = self.inst_map.get(selected_stt_provider_id)
+        temp_stt = (
+            self.inst_map.get(selected_stt_provider_id)
+            if isinstance(selected_stt_provider_id, str)
+            else None
+        )
+        self.curr_stt_provider_inst = (
+            temp_stt if isinstance(temp_stt, STTProvider) else None
+        )
         if not self.curr_stt_provider_inst and self.stt_provider_insts:
             self.curr_stt_provider_inst = self.stt_provider_insts[0]
 
-        self.curr_tts_provider_inst = self.inst_map.get(selected_tts_provider_id)
+        temp_tts = (
+            self.inst_map.get(selected_tts_provider_id)
+            if isinstance(selected_tts_provider_id, str)
+            else None
+        )
+        self.curr_tts_provider_inst = (
+            temp_tts if isinstance(temp_tts, TTSProvider) else None
+        )
         if not self.curr_tts_provider_inst and self.tts_provider_insts:
             self.curr_tts_provider_inst = self.tts_provider_insts[0]
 
@@ -358,73 +384,103 @@ class ProviderManager:
 
             provider_metadata.id = provider_config["id"]
 
-            if provider_metadata.provider_type == ProviderType.SPEECH_TO_TEXT:
-                # STT 任务
-                inst = cls_type(provider_config, self.provider_settings)
+            match provider_metadata.provider_type:
+                case ProviderType.SPEECH_TO_TEXT:
+                    # STT 任务
+                    if not issubclass(cls_type, STTProvider):
+                        raise TypeError(
+                            f"Provider class {cls_type} is not a subclass of STTProvider"
+                        )
+                    inst = cls_type(provider_config, self.provider_settings)
 
-                if getattr(inst, "initialize", None):
-                    await inst.initialize()
+                    if isinstance(inst, HasInitialize):
+                        await inst.initialize()
 
-                self.stt_provider_insts.append(inst)
-                if (
-                    self.provider_stt_settings.get("provider_id")
-                    == provider_config["id"]
-                ):
-                    self.curr_stt_provider_inst = inst
-                    logger.info(
-                        f"已选择 {provider_config['type']}({provider_config['id']}) 作为当前语音转文本提供商适配器。",
+                    self.stt_provider_insts.append(inst)
+                    if (
+                        self.provider_stt_settings.get("provider_id")
+                        == provider_config["id"]
+                    ):
+                        self.curr_stt_provider_inst = inst
+                        logger.info(
+                            f"已选择 {provider_config['type']}({provider_config['id']}) 作为当前语音转文本提供商适配器。",
+                        )
+                    if not self.curr_stt_provider_inst:
+                        self.curr_stt_provider_inst = inst
+
+                case ProviderType.TEXT_TO_SPEECH:
+                    # TTS 任务
+                    if not issubclass(cls_type, TTSProvider):
+                        raise TypeError(
+                            f"Provider class {cls_type} is not a subclass of TTSProvider"
+                        )
+                    inst = cls_type(provider_config, self.provider_settings)
+
+                    if isinstance(inst, HasInitialize):
+                        await inst.initialize()
+
+                    self.tts_provider_insts.append(inst)
+                    if (
+                        self.provider_settings.get("provider_id")
+                        == provider_config["id"]
+                    ):
+                        self.curr_tts_provider_inst = inst
+                        logger.info(
+                            f"已选择 {provider_config['type']}({provider_config['id']}) 作为当前文本转语音提供商适配器。",
+                        )
+                    if not self.curr_tts_provider_inst:
+                        self.curr_tts_provider_inst = inst
+
+                case ProviderType.CHAT_COMPLETION:
+                    # 文本生成任务
+                    if not issubclass(cls_type, Provider):
+                        raise TypeError(
+                            f"Provider class {cls_type} is not a subclass of Provider"
+                        )
+                    inst = cls_type(
+                        provider_config,
+                        self.provider_settings,
                     )
-                if not self.curr_stt_provider_inst:
-                    self.curr_stt_provider_inst = inst
 
-            elif provider_metadata.provider_type == ProviderType.TEXT_TO_SPEECH:
-                # TTS 任务
-                inst = cls_type(provider_config, self.provider_settings)
+                    if isinstance(inst, HasInitialize):
+                        await inst.initialize()
 
-                if getattr(inst, "initialize", None):
-                    await inst.initialize()
+                    self.provider_insts.append(inst)
+                    if (
+                        self.provider_settings.get("default_provider_id")
+                        == provider_config["id"]
+                    ):
+                        self.curr_provider_inst = inst
+                        logger.info(
+                            f"已选择 {provider_config['type']}({provider_config['id']}) 作为当前提供商适配器。",
+                        )
+                    if not self.curr_provider_inst:
+                        self.curr_provider_inst = inst
 
-                self.tts_provider_insts.append(inst)
-                if self.provider_settings.get("provider_id") == provider_config["id"]:
-                    self.curr_tts_provider_inst = inst
-                    logger.info(
-                        f"已选择 {provider_config['type']}({provider_config['id']}) 作为当前文本转语音提供商适配器。",
+                case ProviderType.EMBEDDING:
+                    if not issubclass(cls_type, EmbeddingProvider):
+                        raise TypeError(
+                            f"Provider class {cls_type} is not a subclass of EmbeddingProvider"
+                        )
+                    inst = cls_type(provider_config, self.provider_settings)
+                    if isinstance(inst, HasInitialize):
+                        await inst.initialize()
+                    self.embedding_provider_insts.append(inst)
+                case ProviderType.RERANK:
+                    if not issubclass(cls_type, RerankProvider):
+                        raise TypeError(
+                            f"Provider class {cls_type} is not a subclass of RerankProvider"
+                        )
+                    inst = cls_type(provider_config, self.provider_settings)
+                    if isinstance(inst, HasInitialize):
+                        await inst.initialize()
+                    self.rerank_provider_insts.append(inst)
+                case _:
+                    # 未知供应商抛出异常，确保inst初始化
+                    # Should be unreachable
+                    raise Exception(
+                        f"未知的提供商类型：{provider_metadata.provider_type}"
                     )
-                if not self.curr_tts_provider_inst:
-                    self.curr_tts_provider_inst = inst
-
-            elif provider_metadata.provider_type == ProviderType.CHAT_COMPLETION:
-                # 文本生成任务
-                inst = cls_type(
-                    provider_config,
-                    self.provider_settings,
-                )
-
-                if getattr(inst, "initialize", None):
-                    await inst.initialize()
-
-                self.provider_insts.append(inst)
-                if (
-                    self.provider_settings.get("default_provider_id")
-                    == provider_config["id"]
-                ):
-                    self.curr_provider_inst = inst
-                    logger.info(
-                        f"已选择 {provider_config['type']}({provider_config['id']}) 作为当前提供商适配器。",
-                    )
-                if not self.curr_provider_inst:
-                    self.curr_provider_inst = inst
-
-            elif provider_metadata.provider_type == ProviderType.EMBEDDING:
-                inst = cls_type(provider_config, self.provider_settings)
-                if getattr(inst, "initialize", None):
-                    await inst.initialize()
-                self.embedding_provider_insts.append(inst)
-            elif provider_metadata.provider_type == ProviderType.RERANK:
-                inst = cls_type(provider_config, self.provider_settings)
-                if getattr(inst, "initialize", None):
-                    await inst.initialize()
-                self.rerank_provider_insts.append(inst)
 
             self.inst_map[provider_config["id"]] = inst
         except Exception as e:

astrbot/core/provider/provider.py

@@ -2,6 +2,7 @@ import abc
 import asyncio
 import os
 from collections.abc import AsyncGenerator
+from typing import TypeAlias, Union
 
 from astrbot.core.agent.message import Message
 from astrbot.core.agent.tool import ToolSet
@@ -14,6 +15,14 @@ from astrbot.core.provider.entities import (
 from astrbot.core.provider.register import provider_cls_map
 from astrbot.core.utils.astrbot_path import get_astrbot_path
 
+Providers: TypeAlias = Union[
+    "Provider",
+    "STTProvider",
+    "TTSProvider",
+    "EmbeddingProvider",
+    "RerankProvider",
+]
+
 
 class AbstractProvider(abc.ABC):
     """Provider Abstract Class"""
@@ -142,7 +151,9 @@ class Provider(AbstractProvider):
             - 如果传入了 tools，将会使用 tools 进行 Function-calling。如果模型不支持 Function-calling，将会抛出错误。
 
         """
-        ...
+        if False:  # pragma: no cover - make this an async generator for typing
+            yield None  # type: ignore
+        raise NotImplementedError()
 
     async def pop_record(self, context: list):
         """弹出 context 第一条非系统提示词对话记录"""

astrbot/core/provider/sources/anthropic_source.py

@@ -6,10 +6,12 @@ from mimetypes import guess_type
 import anthropic
 from anthropic import AsyncAnthropic
 from anthropic.types import Message
+from anthropic.types.message_delta_usage import MessageDeltaUsage
+from anthropic.types.usage import Usage
 
 from astrbot import logger
 from astrbot.api.provider import Provider
-from astrbot.core.provider.entities import LLMResponse
+from astrbot.core.provider.entities import LLMResponse, TokenUsage
 from astrbot.core.provider.func_tool_manager import ToolSet
 from astrbot.core.utils.io import download_image_by_url
 
@@ -107,6 +109,22 @@ class ProviderAnthropic(Provider):
 
         return system_prompt, new_messages
 
+    def _extract_usage(self, usage: Usage) -> TokenUsage:
+        # https://docs.claude.com/en/docs/build-with-claude/prompt-caching#tracking-cache-performance
+        return TokenUsage(
+            input_other=usage.input_tokens or 0,
+            input_cached=usage.cache_read_input_tokens or 0,
+            output=usage.output_tokens,
+        )
+
+    def _update_usage(self, token_usage: TokenUsage, usage: MessageDeltaUsage) -> None:
+        if usage.input_tokens is not None:
+            token_usage.input_other = usage.input_tokens
+        if usage.cache_read_input_tokens is not None:
+            token_usage.input_cached = usage.cache_read_input_tokens
+        if usage.output_tokens is not None:
+            token_usage.output = usage.output_tokens
+
     async def _query(self, payloads: dict, tools: ToolSet | None) -> LLMResponse:
         if tools:
             if tool_list := tools.get_func_desc_anthropic_style():
@@ -131,6 +149,10 @@ class ProviderAnthropic(Provider):
                 llm_response.tools_call_args.append(content_block.input)
                 llm_response.tools_call_name.append(content_block.name)
                 llm_response.tools_call_ids.append(content_block.id)
+
+        llm_response.id = completion.id
+        llm_response.usage = self._extract_usage(completion.usage)
+
         # TODO(Soulter): 处理 end_turn 情况
         if not llm_response.completion_text and not llm_response.tools_call_args:
             raise Exception(f"Anthropic API 返回的 completion 无法解析：{completion}。")
@@ -152,9 +174,16 @@ class ProviderAnthropic(Provider):
         final_text = ""
         final_tool_calls = []
 
+        id = None
+        usage = TokenUsage()
+
         async with self.client.messages.stream(**payloads) as stream:
             assert isinstance(stream, anthropic.AsyncMessageStream)
             async for event in stream:
+                if event.type == "message_start":
+                    # the usage contains input token usage
+                    id = event.message.id
+                    usage = self._extract_usage(event.message.usage)
                 if event.type == "content_block_start":
                     if event.content_block.type == "text":
                         # 文本块开始
@@ -162,6 +191,8 @@ class ProviderAnthropic(Provider):
                             role="assistant",
                             completion_text="",
                             is_chunk=True,
+                            usage=usage,
+                            id=id,
                         )
                     elif event.content_block.type == "tool_use":
                         # 工具使用块开始，初始化缓冲区
@@ -179,6 +210,8 @@ class ProviderAnthropic(Provider):
                             role="assistant",
                             completion_text=event.delta.text,
                             is_chunk=True,
+                            usage=usage,
+                            id=id,
                         )
                     elif event.delta.type == "input_json_delta":
                         # 工具调用参数增量
@@ -215,6 +248,8 @@ class ProviderAnthropic(Provider):
                                 tools_call_name=[tool_info["name"]],
                                 tools_call_ids=[tool_info["id"]],
                                 is_chunk=True,
+                                usage=usage,
+                                id=id,
                             )
                         except json.JSONDecodeError:
                             # JSON 解析失败，跳过这个工具调用
@@ -223,11 +258,17 @@ class ProviderAnthropic(Provider):
                         # 清理缓冲区
                         del tool_use_buffer[event.index]
 
+                elif event.type == "message_delta":
+                    if event.usage:
+                        self._update_usage(usage, event.usage)
+
         # 返回最终的完整结果
         final_response = LLMResponse(
             role="assistant",
             completion_text=final_text,
             is_chunk=False,
+            usage=usage,
+            id=id,
         )
 
         if final_tool_calls:

astrbot/core/provider/sources/azure_tts_source.py

@@ -29,15 +29,24 @@ class OTTSProvider:
         self.last_sync_time = 0
         self.timeout = Timeout(10.0)
         self.retry_count = 3
-        self.client = None
+        self._client: AsyncClient | None = None
+
+    @property
+    def client(self) -> AsyncClient:
+        if self._client is None:
+            raise RuntimeError(
+                "Client not initialized. Please use 'async with' context."
+            )
+        return self._client
 
     async def __aenter__(self):
-        self.client = AsyncClient(timeout=self.timeout)
+        self._client = AsyncClient(timeout=self.timeout)
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        if self.client:
-            await self.client.aclose()
+        if self._client:
+            await self._client.aclose()
+            self._client = None
 
     async def _sync_time(self):
         try:
@@ -90,6 +99,7 @@ class OTTSProvider:
                 if attempt == self.retry_count - 1:
                     raise RuntimeError(f"OTTS请求失败: {e!s}") from e
                 await asyncio.sleep(0.5 * (attempt + 1))
+        raise RuntimeError("OTTS未返回音频文件")
 
 
 class AzureNativeProvider(TTSProvider):
@@ -105,7 +115,7 @@ class AzureNativeProvider(TTSProvider):
         self.endpoint = (
             f"https://{self.region}.tts.speech.microsoft.com/cognitiveservices/v1"
         )
-        self.client = None
+        self._client: AsyncClient | None = None
         self.token = None
         self.token_expire = 0
         self.voice_params = {
@@ -116,8 +126,16 @@ class AzureNativeProvider(TTSProvider):
             "volume": provider_config.get("azure_tts_volume", "100"),
         }
 
+    @property
+    def client(self) -> AsyncClient:
+        if self._client is None:
+            raise RuntimeError(
+                "Client not initialized. Please use 'async with' context."
+            )
+        return self._client
+
     async def __aenter__(self):
-        self.client = AsyncClient(
+        self._client = AsyncClient(
             headers={
                 "User-Agent": f"AstrBot/{VERSION}",
                 "Content-Type": "application/ssml+xml",
@@ -127,8 +145,9 @@ class AzureNativeProvider(TTSProvider):
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        if self.client:
-            await self.client.aclose()
+        if self._client:
+            await self._client.aclose()
+            self._client = None
 
     async def _refresh_token(self):
         token_url = (
@@ -181,8 +200,11 @@ class AzureTTSProvider(TTSProvider):
         key_value = provider_config.get("azure_tts_subscription_key", "")
         self.provider = self._parse_provider(key_value, provider_config)
 
-    def _parse_provider(self, key_value: str, config: dict) -> TTSProvider:
+    def _parse_provider(
+        self, key_value: str, config: dict
+    ) -> OTTSProvider | AzureNativeProvider:
         if key_value.lower().startswith("other["):
+            json_str = ""
             try:
                 match = re.match(r"other\[(.*)\]", key_value, re.DOTALL)
                 if not match:

astrbot/core/provider/sources/bailian_rerank_source.py

@@ -177,6 +177,10 @@ class BailianRerankProvider(RerankProvider):
         Returns:
             重排序结果列表
         """
+        if not self.client:
+            logger.error("百炼 Rerank 客户端会话已关闭，返回空结果")
+            return []
+
         if not documents:
             logger.warning("文档列表为空，返回空结果")
             return []

astrbot/core/provider/sources/dashscope_tts.py

@@ -36,7 +36,7 @@ class ProviderDashscopeTTSAPI(TTSProvider):
         super().__init__(provider_config, provider_settings)
         self.chosen_api_key: str = provider_config.get("api_key", "")
         self.voice: str = provider_config.get("dashscope_tts_voice", "loongstella")
-        self.set_model(provider_config.get("model"))
+        self.set_model(provider_config["model"])
         self.timeout_ms = float(provider_config.get("timeout", 20)) * 1000
         dashscope.api_key = self.chosen_api_key
 
@@ -71,9 +71,10 @@ class ProviderDashscopeTTSAPI(TTSProvider):
 
         kwargs = {
             "model": model,
-            "text": text,
+            "messages": None,
             "api_key": self.chosen_api_key,
             "voice": self.voice or "Cherry",
+            "text": text,
         }
         if not self.voice:
             logging.warning(

astrbot/core/provider/sources/edge_tts_source.py

@@ -67,7 +67,7 @@ class ProviderEdgeTTS(TTSProvider):
                 from pyffmpeg import FFmpeg
 
                 ff = FFmpeg()
-                ff.convert(input=mp3_path, output=wav_path)
+                ff.convert(input_file=mp3_path, output_file=wav_path)
             except Exception as e:
                 logger.debug(f"pyffmpeg 转换失败: {e}, 尝试使用 ffmpeg 命令行进行转换")
                 # use ffmpeg command line

astrbot/core/provider/sources/fishaudio_tts_api_source.py

@@ -59,9 +59,9 @@ class ProviderFishAudioTTSAPI(TTSProvider):
         self.headers = {
             "Authorization": f"Bearer {self.chosen_api_key}",
         }
-        self.set_model(provider_config.get("model"))
+        self.set_model(provider_config["model"])
 
-    async def _get_reference_id_by_character(self, character: str) -> str:
+    async def _get_reference_id_by_character(self, character: str) -> str | None:
         """获取角色的reference_id
 
         Args:
@@ -109,7 +109,7 @@ class ProviderFishAudioTTSAPI(TTSProvider):
         pattern = r"^[a-fA-F0-9]{32}$"
         return bool(re.match(pattern, reference_id.strip()))
 
-    async def _generate_request(self, text: str) -> dict:
+    async def _generate_request(self, text: str) -> ServeTTSRequest:
         # 向前兼容逻辑：优先使用reference_id，如果没有则使用角色名称查询
         if self.reference_id and self.reference_id.strip():
             # 验证reference_id格式
@@ -146,5 +146,6 @@ class ProviderFishAudioTTSAPI(TTSProvider):
                     async for chunk in response.aiter_bytes():
                         f.write(chunk)
                 return path
-            text = await response.aread()
+            body = await response.aread()
+            text = body.decode("utf-8", errors="replace")
             raise Exception(f"Fish Audio API请求失败: {text}")

astrbot/core/provider/sources/gemini_embedding_source.py

@@ -1,3 +1,5 @@
+from typing import cast
+
 from google import genai
 from google.genai import types
 from google.genai.errors import APIError
@@ -18,8 +20,8 @@ class GeminiEmbeddingProvider(EmbeddingProvider):
         self.provider_config = provider_config
         self.provider_settings = provider_settings
 
-        api_key: str = provider_config.get("embedding_api_key")
-        api_base: str = provider_config.get("embedding_api_base")
+        api_key: str = provider_config["embedding_api_key"]
+        api_base: str = provider_config["embedding_api_base"]
         timeout: int = int(provider_config.get("timeout", 20))
 
         http_options = types.HttpOptions(timeout=timeout * 1000)
@@ -41,18 +43,26 @@ class GeminiEmbeddingProvider(EmbeddingProvider):
                 model=self.model,
                 contents=text,
             )
+            assert result.embeddings is not None
+            assert result.embeddings[0].values is not None
             return result.embeddings[0].values
         except APIError as e:
             raise Exception(f"Gemini Embedding API请求失败: {e.message}")
 
-    async def get_embeddings(self, texts: list[str]) -> list[list[float]]:
+    async def get_embeddings(self, text: list[str]) -> list[list[float]]:
         """批量获取文本的嵌入"""
         try:
             result = await self.client.models.embed_content(
                 model=self.model,
-                contents=texts,
+                contents=cast(types.ContentListUnion, text),
             )
-            return [embedding.values for embedding in result.embeddings]
+            assert result.embeddings is not None
+
+            embeddings: list[list[float]] = []
+            for embedding in result.embeddings:
+                assert embedding.values is not None
+                embeddings.append(embedding.values)
+            return embeddings
         except APIError as e:
             raise Exception(f"Gemini Embedding API批量请求失败: {e.message}")
 

astrbot/core/provider/sources/gemini_source.py

@@ -4,6 +4,7 @@ import json
 import logging
 import random
 from collections.abc import AsyncGenerator
+from typing import cast
 
 from google import genai
 from google.genai import types
@@ -13,7 +14,7 @@ import astrbot.core.message.components as Comp
 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.entities import LLMResponse, TokenUsage
 from astrbot.core.provider.func_tool_manager import ToolSet
 from astrbot.core.utils.io import download_image_by_url
 
@@ -126,18 +127,18 @@ class ProviderGoogleGenAI(Provider):
     ) -> types.GenerateContentConfig:
         """准备查询配置"""
         if not modalities:
-            modalities = ["Text"]
+            modalities = ["TEXT"]
 
         # 流式输出不支持图片模态
         if (
             self.provider_settings.get("streaming_response", False)
-            and "Image" in modalities
+            and "IMAGE" in modalities
         ):
             logger.warning("流式输出不支持图片模态，已自动降级为文本模态")
-            modalities = ["Text"]
+            modalities = ["TEXT"]
 
-        tool_list = []
-        model_name = self.get_model()
+        tool_list: list[types.Tool] | None = []
+        model_name = payloads.get("model", self.get_model())
         native_coderunner = self.provider_config.get("gm_native_coderunner", False)
         native_search = self.provider_config.get("gm_native_search", False)
         url_context = self.provider_config.get("gm_url_context", False)
@@ -196,6 +197,37 @@ class ProviderGoogleGenAI(Provider):
                 types.Tool(function_declarations=func_desc["function_declarations"]),
             ]
 
+        # oper thinking config
+        thinking_config = None
+        if model_name.startswith("gemini-2.5"):
+            # The thinkingBudget parameter, introduced with the Gemini 2.5 series
+            thinking_budget = self.provider_config.get("gm_thinking_config", {}).get(
+                "budget", 0
+            )
+            if thinking_budget is not None:
+                thinking_config = types.ThinkingConfig(
+                    thinking_budget=thinking_budget,
+                )
+        elif model_name.startswith("gemini-3"):
+            # The thinkingLevel parameter, recommended for Gemini 3 models and onwards
+            # Gemini 2.5 series models don't support thinkingLevel; use thinkingBudget instead.
+            thinking_level = self.provider_config.get("gm_thinking_config", {}).get(
+                "level", "HIGH"
+            )
+            if thinking_level and isinstance(thinking_level, str):
+                thinking_level = thinking_level.upper()
+                if thinking_level not in ["MINIMAL", "LOW", "MEDIUM", "HIGH"]:
+                    logger.warning(
+                        f"Invalid thinking level: {thinking_level}, using HIGH"
+                    )
+                    thinking_level = "HIGH"
+                level = types.ThinkingLevel(thinking_level)
+                thinking_config = types.ThinkingConfig()
+                if not hasattr(types.ThinkingConfig, "thinking_level"):
+                    setattr(types.ThinkingConfig, "thinking_level", level)
+                else:
+                    thinking_config.thinking_level = level
+
         return types.GenerateContentConfig(
             system_instruction=system_instruction,
             temperature=temperature,
@@ -213,24 +245,9 @@ class ProviderGoogleGenAI(Provider):
             logprobs=payloads.get("logprobs"),
             seed=payloads.get("seed"),
             response_modalities=modalities,
-            tools=tool_list,
+            tools=cast(types.ToolListUnion | None, tool_list),
             safety_settings=self.safety_settings if self.safety_settings else None,
-            thinking_config=(
-                types.ThinkingConfig(
-                    thinking_budget=min(
-                        int(
-                            self.provider_config.get("gm_thinking_config", {}).get(
-                                "budget",
-                                0,
-                            ),
-                        ),
-                        24576,
-                    ),
-                )
-                if "gemini-2.5-flash" in self.get_model()
-                and hasattr(types.ThinkingConfig, "thinking_budget")
-                else None
-            ),
+            thinking_config=thinking_config,
             automatic_function_calling=types.AutomaticFunctionCallingConfig(
                 disable=True,
             ),
@@ -257,6 +274,7 @@ class ProviderGoogleGenAI(Provider):
             content_cls: type[types.Content],
         ) -> None:
             if contents and isinstance(contents[-1], content_cls):
+                assert contents[-1].parts is not None
                 contents[-1].parts.extend(part)
             else:
                 contents.append(content_cls(parts=part))
@@ -345,6 +363,16 @@ class ProviderGoogleGenAI(Provider):
         ]
         return "".join(thought_buf).strip()
 
+    def _extract_usage(
+        self, usage_metadata: types.GenerateContentResponseUsageMetadata
+    ) -> TokenUsage:
+        """Extract usage from candidate"""
+        return TokenUsage(
+            input_other=usage_metadata.prompt_token_count or 0,
+            input_cached=usage_metadata.cached_content_token_count or 0,
+            output=usage_metadata.candidates_token_count or 0,
+        )
+
     def _process_content_parts(
         self,
         candidate: types.Candidate,
@@ -429,9 +457,11 @@ class ProviderGoogleGenAI(Provider):
             None,
         )
 
-        modalities = ["Text"]
+        model = payloads.get("model", self.get_model())
+
+        modalities = ["TEXT"]
         if self.provider_config.get("gm_resp_image_modal", False):
-            modalities.append("Image")
+            modalities.append("IMAGE")
 
         conversation = self._prepare_conversation(payloads)
         temperature = payloads.get("temperature", 0.7)
@@ -447,8 +477,8 @@ class ProviderGoogleGenAI(Provider):
                     temperature,
                 )
                 result = await self.client.models.generate_content(
-                    model=self.get_model(),
-                    contents=conversation,
+                    model=model,
+                    contents=cast(types.ContentListUnion, conversation),
                     config=config,
                 )
                 logger.debug(f"genai result: {result}")
@@ -473,11 +503,11 @@ class ProviderGoogleGenAI(Provider):
                     e.message = ""
                 if "Developer instruction is not enabled" in e.message:
                     logger.warning(
-                        f"{self.get_model()} 不支持 system prompt，已自动去除(影响人格设置)",
+                        f"{model} 不支持 system prompt，已自动去除(影响人格设置)",
                     )
                     system_instruction = None
                 elif "Function calling is not enabled" in e.message:
-                    logger.warning(f"{self.get_model()} 不支持函数调用，已自动去除")
+                    logger.warning(f"{model} 不支持函数调用，已自动去除")
                     tools = None
                 elif (
                     "Multi-modal output is not supported" in e.message
@@ -486,9 +516,9 @@ class ProviderGoogleGenAI(Provider):
                     or "only supports text output" in e.message
                 ):
                     logger.warning(
-                        f"{self.get_model()} 不支持多模态输出，降级为文本模态",
+                        f"{model} 不支持多模态输出，降级为文本模态",
                     )
-                    modalities = ["Text"]
+                    modalities = ["TEXT"]
                 else:
                     raise
                 continue
@@ -499,6 +529,9 @@ class ProviderGoogleGenAI(Provider):
             result.candidates[0],
             llm_response,
         )
+        llm_response.id = result.response_id
+        if result.usage_metadata:
+            llm_response.usage = self._extract_usage(result.usage_metadata)
         return llm_response
 
     async def _query_stream(
@@ -511,7 +544,7 @@ class ProviderGoogleGenAI(Provider):
             (msg["content"] for msg in payloads["messages"] if msg["role"] == "system"),
             None,
         )
-
+        model = payloads.get("model", self.get_model())
         conversation = self._prepare_conversation(payloads)
 
         result = None
@@ -523,8 +556,8 @@ class ProviderGoogleGenAI(Provider):
                     system_instruction,
                 )
                 result = await self.client.models.generate_content_stream(
-                    model=self.get_model(),
-                    contents=conversation,
+                    model=model,
+                    contents=cast(types.ContentListUnion, conversation),
                     config=config,
                 )
                 break
@@ -533,11 +566,11 @@ class ProviderGoogleGenAI(Provider):
                     e.message = ""
                 if "Developer instruction is not enabled" in e.message:
                     logger.warning(
-                        f"{self.get_model()} 不支持 system prompt，已自动去除(影响人格设置)",
+                        f"{model} 不支持 system prompt，已自动去除(影响人格设置)",
                     )
                     system_instruction = None
                 elif "Function calling is not enabled" in e.message:
-                    logger.warning(f"{self.get_model()} 不支持函数调用，已自动去除")
+                    logger.warning(f"{model} 不支持函数调用，已自动去除")
                     tools = None
                 else:
                     raise
@@ -567,6 +600,9 @@ class ProviderGoogleGenAI(Provider):
                     chunk.candidates[0],
                     llm_response,
                 )
+                llm_response.id = chunk.response_id
+                if chunk.usage_metadata:
+                    llm_response.usage = self._extract_usage(chunk.usage_metadata)
                 yield llm_response
                 return
 
@@ -594,6 +630,9 @@ class ProviderGoogleGenAI(Provider):
                         chunk.candidates[0],
                         final_response,
                     )
+                    final_response.id = chunk.response_id
+                    if chunk.usage_metadata:
+                        final_response.usage = self._extract_usage(chunk.usage_metadata)
                 break
 
         # Yield final complete response with accumulated text

astrbot/core/provider/sources/minimax_tts_api_source.py

@@ -87,7 +87,7 @@ class ProviderMiniMaxTTSAPI(TTSProvider):
 
         return json.dumps(dict_body)
 
-    async def _call_tts_stream(self, text: str) -> AsyncIterator[bytes]:
+    async def _call_tts_stream(self, text: str) -> AsyncIterator[str]:
         """进行流式请求"""
         try:
             async with (
@@ -117,7 +117,9 @@ class ProviderMiniMaxTTSAPI(TTSProvider):
                                     data = json.loads(message[6:])
                                     if "extra_info" in data:
                                         continue
-                                    audio = data.get("data", {}).get("audio")
+                                    audio: str | None = data.get("data", {}).get(
+                                        "audio"
+                                    )
                                     if audio is not None:
                                         yield audio
                                 except json.JSONDecodeError:

astrbot/core/provider/sources/openai_embedding_source.py

@@ -30,9 +30,9 @@ class OpenAIEmbeddingProvider(EmbeddingProvider):
         embedding = await self.client.embeddings.create(input=text, model=self.model)
         return embedding.data[0].embedding
 
-    async def get_embeddings(self, texts: list[str]) -> list[list[float]]:
+    async def get_embeddings(self, text: list[str]) -> list[list[float]]:
         """批量获取文本的嵌入"""
-        embeddings = await self.client.embeddings.create(input=texts, model=self.model)
+        embeddings = await self.client.embeddings.create(input=text, model=self.model)
         return [item.embedding for item in embeddings.data]
 
     def get_dim(self) -> int:

astrbot/core/provider/sources/openai_source.py

@@ -12,6 +12,7 @@ from openai._exceptions import NotFoundError
 from openai.lib.streaming.chat._completions import ChatCompletionStreamState
 from openai.types.chat.chat_completion import ChatCompletion
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
+from openai.types.completion_usage import CompletionUsage
 
 import astrbot.core.message.components as Comp
 from astrbot import logger
@@ -19,7 +20,7 @@ from astrbot.api.provider import Provider
 from astrbot.core.agent.message import Message
 from astrbot.core.agent.tool import ToolSet
 from astrbot.core.message.message_event_result import MessageChain
-from astrbot.core.provider.entities import LLMResponse, ToolCallsResult
+from astrbot.core.provider.entities import LLMResponse, TokenUsage, ToolCallsResult
 from astrbot.core.utils.io import download_image_by_url
 
 from ..register import register_provider_adapter
@@ -208,6 +209,7 @@ class ProviderOpenAIOfficial(Provider):
             # handle the content delta
             reasoning = self._extract_reasoning_content(chunk)
             _y = False
+            llm_response.id = chunk.id
             if reasoning:
                 llm_response.reasoning_content = reasoning
                 _y = True
@@ -217,6 +219,8 @@ class ProviderOpenAIOfficial(Provider):
                     chain=[Comp.Plain(completion_text)],
                 )
                 _y = True
+            if chunk.usage:
+                llm_response.usage = self._extract_usage(chunk.usage)
             if _y:
                 yield llm_response
 
@@ -245,6 +249,15 @@ class ProviderOpenAIOfficial(Provider):
                 reasoning_text = str(reasoning_attr)
         return reasoning_text
 
+    def _extract_usage(self, usage: CompletionUsage) -> TokenUsage:
+        ptd = usage.prompt_tokens_details
+        cached = ptd.cached_tokens if ptd and ptd.cached_tokens else 0
+        return TokenUsage(
+            input_other=usage.prompt_tokens - cached,
+            input_cached=ptd.cached_tokens if ptd and ptd.cached_tokens else 0,
+            output=usage.completion_tokens,
+        )
+
     async def _parse_openai_completion(
         self, completion: ChatCompletion, tools: ToolSet | None
     ) -> LLMResponse:
@@ -284,6 +297,10 @@ class ProviderOpenAIOfficial(Provider):
                 if isinstance(tool_call, str):
                     # workaround for #1359
                     tool_call = json.loads(tool_call)
+                if tools is None:
+                    # 工具集未提供
+                    # Should be unreachable
+                    raise Exception("工具集未提供")
                 for tool in tools.func_list:
                     if (
                         tool_call.type == "function"
@@ -317,6 +334,10 @@ class ProviderOpenAIOfficial(Provider):
             raise Exception(f"API 返回的 completion 无法解析：{completion}。")
 
         llm_response.raw_completion = completion
+        llm_response.id = completion.id
+
+        if completion.usage:
+            llm_response.usage = self._extract_usage(completion.usage)
 
         return llm_response
 

astrbot/core/provider/sources/sensevoice_selfhosted_source.py

@@ -7,6 +7,7 @@ import asyncio
 import os
 import re
 from datetime import datetime
+from typing import cast
 
 from funasr_onnx import SenseVoiceSmall
 from funasr_onnx.utils.postprocess_utils import rich_transcription_postprocess
@@ -32,7 +33,7 @@ class ProviderSenseVoiceSTTSelfHost(STTProvider):
         provider_settings: dict,
     ) -> None:
         super().__init__(provider_config, provider_settings)
-        self.set_model(provider_config.get("stt_model"))
+        self.set_model(provider_config["stt_model"])
         self.model = None
         self.is_emotion = provider_config.get("is_emotion", False)
 
@@ -86,7 +87,9 @@ class ProviderSenseVoiceSTTSelfHost(STTProvider):
             loop = asyncio.get_event_loop()
             res = await loop.run_in_executor(
                 None,  # 使用默认的线程池
-                lambda: self.model(audio_url, language="auto", use_itn=True),
+                lambda: cast(SenseVoiceSmall, self.model)(
+                    audio_url, language="auto", use_itn=True
+                ),
             )
 
             # res = self.model(audio_url, language="auto", use_itn=True)

astrbot/core/provider/sources/vllm_rerank_source.py

@@ -44,6 +44,7 @@ class VLLMRerankProvider(RerankProvider):
         }
         if top_n is not None:
             payload["top_n"] = top_n
+        assert self.client is not None
         async with self.client.post(
             f"{self.base_url}/v1/rerank",
             json=payload,

astrbot/core/provider/sources/whisper_api_source.py

@@ -36,7 +36,7 @@ class ProviderOpenAIWhisperAPI(STTProvider):
             timeout=provider_config.get("timeout", NOT_GIVEN),
         )
 
-        self.set_model(provider_config.get("model"))
+        self.set_model(provider_config["model"])
 
     async def _get_audio_format(self, file_path):
         # 定义要检测的头部字节

astrbot/core/provider/sources/whisper_selfhosted_source.py

@@ -1,6 +1,7 @@
 import asyncio
 import os
 import uuid
+from typing import cast
 
 import whisper
 
@@ -26,7 +27,7 @@ class ProviderOpenAIWhisperSelfHost(STTProvider):
         provider_settings: dict,
     ) -> None:
         super().__init__(provider_config, provider_settings)
-        self.set_model(provider_config.get("model"))
+        self.set_model(provider_config["model"])
         self.model = None
 
     async def initialize(self):
@@ -75,5 +76,8 @@ class ProviderOpenAIWhisperSelfHost(STTProvider):
                 await tencent_silk_to_wav(audio_url, output_path)
                 audio_url = output_path
 
+        if not self.model:
+            raise RuntimeError("Whisper 模型未初始化")
+
         result = await loop.run_in_executor(None, self.model.transcribe, audio_url)
-        return result["text"]
+        return cast(str, result["text"])

astrbot/core/provider/sources/xinference_rerank_source.py

@@ -1,6 +1,11 @@
+from typing import cast
+
 from xinference_client.client.restful.async_restful_client import (
     AsyncClient as Client,
 )
+from xinference_client.client.restful.async_restful_client import (
+    AsyncRESTfulRerankModelHandle,
+)
 
 from astrbot import logger
 
@@ -29,7 +34,7 @@ class XinferenceRerankProvider(RerankProvider):
             False,
         )
         self.client = None
-        self.model = None
+        self.model: AsyncRESTfulRerankModelHandle | None = None
         self.model_uid = None
 
     async def initialize(self):
@@ -65,7 +70,10 @@ class XinferenceRerankProvider(RerankProvider):
                     return
 
             if self.model_uid:
-                self.model = await self.client.get_model(self.model_uid)
+                self.model = cast(
+                    AsyncRESTfulRerankModelHandle,
+                    await self.client.get_model(self.model_uid),
+                )
 
         except Exception as e:
             logger.error(f"Failed to initialize Xinference model: {e}")

astrbot/core/star/__init__.py

@@ -2,15 +2,19 @@ from astrbot.core import html_renderer
 from astrbot.core.provider import Provider
 from astrbot.core.star.star_tools import StarTools
 from astrbot.core.utils.command_parser import CommandParserMixin
+from astrbot.core.utils.plugin_kv_store import PluginKVStoreMixin
 
 from .context import Context
 from .star import StarMetadata, star_map, star_registry
 from .star_manager import PluginManager
 
 
-class Star(CommandParserMixin):
+class Star(CommandParserMixin, PluginKVStoreMixin):
     """所有插件（Star）的父类，所有插件都应该继承于这个类"""
 
+    author: str
+    name: str
+
     def __init__(self, context: Context, config: dict | None = None):
         StarTools.initialize(context)
         self.context = context

astrbot/core/star/command_management.py

@@ -0,0 +1,449 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Any
+
+from astrbot.core import db_helper
+from astrbot.core.db.po import CommandConfig
+from astrbot.core.star.filter.command import CommandFilter
+from astrbot.core.star.filter.command_group import CommandGroupFilter
+from astrbot.core.star.filter.permission import PermissionType, PermissionTypeFilter
+from astrbot.core.star.star import star_map
+from astrbot.core.star.star_handler import StarHandlerMetadata, star_handlers_registry
+
+
+@dataclass
+class CommandDescriptor:
+    handler: StarHandlerMetadata = field(repr=False)
+    filter_ref: CommandFilter | CommandGroupFilter | None = field(
+        default=None,
+        repr=False,
+    )
+    handler_full_name: str = ""
+    handler_name: str = ""
+    plugin_name: str = ""
+    plugin_display_name: str | None = None
+    module_path: str = ""
+    description: str = ""
+    command_type: str = "command"  # "command" | "group" | "sub_command"
+    raw_command_name: str | None = None
+    current_fragment: str | None = None
+    parent_signature: str = ""
+    parent_group_handler: str = ""
+    original_command: str | None = None
+    effective_command: str | None = None
+    aliases: list[str] = field(default_factory=list)
+    permission: str = "everyone"
+    enabled: bool = True
+    is_group: bool = False
+    is_sub_command: bool = False
+    reserved: bool = False
+    config: CommandConfig | None = None
+    has_conflict: bool = False
+    sub_commands: list[CommandDescriptor] = field(default_factory=list)
+
+
+async def sync_command_configs() -> None:
+    """同步指令配置，清理过期配置。"""
+    descriptors = _collect_descriptors(include_sub_commands=False)
+    config_records = await db_helper.get_command_configs()
+    config_map = _bind_configs_to_descriptors(descriptors, config_records)
+    live_handlers = {desc.handler_full_name for desc in descriptors}
+
+    stale_configs = [key for key in config_map if key not in live_handlers]
+    if stale_configs:
+        await db_helper.delete_command_configs(stale_configs)
+
+
+async def toggle_command(handler_full_name: str, enabled: bool) -> CommandDescriptor:
+    descriptor = _build_descriptor_by_full_name(handler_full_name)
+    if not descriptor:
+        raise ValueError("指定的处理函数不存在或不是指令。")
+
+    existing_cfg = await db_helper.get_command_config(handler_full_name)
+    config = await db_helper.upsert_command_config(
+        handler_full_name=handler_full_name,
+        plugin_name=descriptor.plugin_name or "",
+        module_path=descriptor.module_path,
+        original_command=descriptor.original_command or descriptor.handler_name,
+        resolved_command=(
+            existing_cfg.resolved_command
+            if existing_cfg
+            else descriptor.current_fragment
+        ),
+        enabled=enabled,
+        keep_original_alias=False,
+        conflict_key=existing_cfg.conflict_key
+        if existing_cfg and existing_cfg.conflict_key
+        else descriptor.original_command,
+        resolution_strategy=existing_cfg.resolution_strategy if existing_cfg else None,
+        note=existing_cfg.note if existing_cfg else None,
+        extra_data=existing_cfg.extra_data if existing_cfg else None,
+        auto_managed=False,
+    )
+    _bind_descriptor_with_config(descriptor, config)
+    await sync_command_configs()
+    return descriptor
+
+
+async def rename_command(
+    handler_full_name: str,
+    new_fragment: str,
+) -> CommandDescriptor:
+    descriptor = _build_descriptor_by_full_name(handler_full_name)
+    if not descriptor:
+        raise ValueError("指定的处理函数不存在或不是指令。")
+
+    new_fragment = new_fragment.strip()
+    if not new_fragment:
+        raise ValueError("指令名不能为空。")
+
+    candidate_full = _compose_command(descriptor.parent_signature, new_fragment)
+    if _is_command_in_use(handler_full_name, candidate_full):
+        raise ValueError("新的指令名已被其他指令占用，请换一个名称。")
+
+    config = await db_helper.upsert_command_config(
+        handler_full_name=handler_full_name,
+        plugin_name=descriptor.plugin_name or "",
+        module_path=descriptor.module_path,
+        original_command=descriptor.original_command or descriptor.handler_name,
+        resolved_command=new_fragment,
+        enabled=True if descriptor.enabled else False,
+        keep_original_alias=False,
+        conflict_key=descriptor.original_command,
+        resolution_strategy="manual_rename",
+        note=None,
+        extra_data=None,
+        auto_managed=False,
+    )
+    _bind_descriptor_with_config(descriptor, config)
+
+    await sync_command_configs()
+    return descriptor
+
+
+async def list_commands() -> list[dict[str, Any]]:
+    descriptors = _collect_descriptors(include_sub_commands=True)
+    config_records = await db_helper.get_command_configs()
+    _bind_configs_to_descriptors(descriptors, config_records)
+
+    conflict_groups = _group_conflicts(descriptors)
+    conflict_handler_names: set[str] = {
+        d.handler_full_name for group in conflict_groups.values() for d in group
+    }
+
+    # 分类，设置冲突标志，将子指令挂载到父指令组
+    group_map: dict[str, CommandDescriptor] = {}
+    sub_commands: list[CommandDescriptor] = []
+    root_commands: list[CommandDescriptor] = []
+
+    for desc in descriptors:
+        desc.has_conflict = desc.handler_full_name in conflict_handler_names
+        if desc.is_group:
+            group_map[desc.handler_full_name] = desc
+        elif desc.is_sub_command:
+            sub_commands.append(desc)
+        else:
+            root_commands.append(desc)
+
+    for sub in sub_commands:
+        if sub.parent_group_handler and sub.parent_group_handler in group_map:
+            group_map[sub.parent_group_handler].sub_commands.append(sub)
+        else:
+            root_commands.append(sub)
+
+    # 指令组 + 普通指令，按 effective_command 字母排序
+    all_commands = list(group_map.values()) + root_commands
+    all_commands.sort(key=lambda d: (d.effective_command or "").lower())
+
+    result = [_descriptor_to_dict(desc) for desc in all_commands]
+    return result
+
+
+async def list_command_conflicts() -> list[dict[str, Any]]:
+    """列出所有冲突的指令组。"""
+    descriptors = _collect_descriptors(include_sub_commands=False)
+    config_records = await db_helper.get_command_configs()
+    _bind_configs_to_descriptors(descriptors, config_records)
+
+    conflict_groups = _group_conflicts(descriptors)
+    details = [
+        {
+            "conflict_key": key,
+            "handlers": [
+                {
+                    "handler_full_name": item.handler_full_name,
+                    "plugin": item.plugin_name,
+                    "current_name": item.effective_command,
+                }
+                for item in group
+            ],
+        }
+        for key, group in conflict_groups.items()
+    ]
+    return details
+
+
+# Internal helpers ----------------------------------------------------------
+
+
+def _collect_descriptors(include_sub_commands: bool) -> list[CommandDescriptor]:
+    """收集指令，按需包含子指令。"""
+    descriptors: list[CommandDescriptor] = []
+    for handler in star_handlers_registry:
+        desc = _build_descriptor(handler)
+        if not desc:
+            continue
+        if not include_sub_commands and desc.is_sub_command:
+            continue
+        descriptors.append(desc)
+    return descriptors
+
+
+def _build_descriptor(handler: StarHandlerMetadata) -> CommandDescriptor | None:
+    filter_ref = _locate_primary_filter(handler)
+    if filter_ref is None:
+        return None
+
+    plugin_meta = star_map.get(handler.handler_module_path)
+    plugin_name = (
+        plugin_meta.name if plugin_meta else None
+    ) or handler.handler_module_path
+    plugin_display = plugin_meta.display_name if plugin_meta else None
+
+    is_sub_command = bool(handler.extras_configs.get("sub_command"))
+    parent_group_handler = ""
+
+    if isinstance(filter_ref, CommandFilter):
+        raw_fragment = getattr(
+            filter_ref, "_original_command_name", filter_ref.command_name
+        )
+        current_fragment = filter_ref.command_name
+        parent_signature = (filter_ref.parent_command_names or [""])[0].strip()
+        # 如果是子指令，尝试找到父指令组的 handler_full_name
+        if is_sub_command and parent_signature:
+            parent_group_handler = _find_parent_group_handler(
+                handler.handler_module_path, parent_signature
+            )
+    else:
+        raw_fragment = getattr(
+            filter_ref, "_original_group_name", filter_ref.group_name
+        )
+        current_fragment = filter_ref.group_name
+        parent_signature = _resolve_group_parent_signature(filter_ref)
+
+    original_command = _compose_command(parent_signature, raw_fragment)
+    effective_command = _compose_command(parent_signature, current_fragment)
+
+    # 确定 command_type
+    if isinstance(filter_ref, CommandGroupFilter):
+        command_type = "group"
+    elif is_sub_command:
+        command_type = "sub_command"
+    else:
+        command_type = "command"
+
+    descriptor = CommandDescriptor(
+        handler=handler,
+        filter_ref=filter_ref,
+        handler_full_name=handler.handler_full_name,
+        handler_name=handler.handler_name,
+        plugin_name=plugin_name,
+        plugin_display_name=plugin_display,
+        module_path=handler.handler_module_path,
+        description=handler.desc or "",
+        command_type=command_type,
+        raw_command_name=raw_fragment,
+        current_fragment=current_fragment,
+        parent_signature=parent_signature,
+        parent_group_handler=parent_group_handler,
+        original_command=original_command,
+        effective_command=effective_command,
+        aliases=sorted(getattr(filter_ref, "alias", set())),
+        permission=_determine_permission(handler),
+        enabled=handler.enabled,
+        is_group=isinstance(filter_ref, CommandGroupFilter),
+        is_sub_command=is_sub_command,
+        reserved=plugin_meta.reserved if plugin_meta else False,
+    )
+    return descriptor
+
+
+def _build_descriptor_by_full_name(full_name: str) -> CommandDescriptor | None:
+    handler = star_handlers_registry.get_handler_by_full_name(full_name)
+    if not handler:
+        return None
+    return _build_descriptor(handler)
+
+
+def _locate_primary_filter(
+    handler: StarHandlerMetadata,
+) -> CommandFilter | CommandGroupFilter | None:
+    for filter_ref in handler.event_filters:
+        if isinstance(filter_ref, (CommandFilter, CommandGroupFilter)):
+            return filter_ref
+    return None
+
+
+def _determine_permission(handler: StarHandlerMetadata) -> str:
+    for filter_ref in handler.event_filters:
+        if isinstance(filter_ref, PermissionTypeFilter):
+            return (
+                "admin"
+                if filter_ref.permission_type == PermissionType.ADMIN
+                else "member"
+            )
+    return "everyone"
+
+
+def _resolve_group_parent_signature(group_filter: CommandGroupFilter) -> str:
+    signatures: list[str] = []
+    parent = group_filter.parent_group
+    while parent:
+        signatures.append(getattr(parent, "_original_group_name", parent.group_name))
+        parent = parent.parent_group
+    return " ".join(reversed(signatures)).strip()
+
+
+def _find_parent_group_handler(module_path: str, parent_signature: str) -> str:
+    """根据模块路径和父级签名，找到对应的指令组 handler_full_name。"""
+    parent_sig_normalized = parent_signature.strip()
+    for handler in star_handlers_registry:
+        if handler.handler_module_path != module_path:
+            continue
+        filter_ref = _locate_primary_filter(handler)
+        if not isinstance(filter_ref, CommandGroupFilter):
+            continue
+        # 检查该指令组的完整指令名是否匹配 parent_signature
+        group_names = filter_ref.get_complete_command_names()
+        if parent_sig_normalized in group_names:
+            return handler.handler_full_name
+    return ""
+
+
+def _compose_command(parent_signature: str, fragment: str | None) -> str:
+    fragment = (fragment or "").strip()
+    parent_signature = parent_signature.strip()
+    if not parent_signature:
+        return fragment
+    if not fragment:
+        return parent_signature
+    return f"{parent_signature} {fragment}"
+
+
+def _bind_descriptor_with_config(
+    descriptor: CommandDescriptor,
+    config: CommandConfig,
+) -> None:
+    _apply_config_to_descriptor(descriptor, config)
+    _apply_config_to_runtime(descriptor, config)
+
+
+def _apply_config_to_descriptor(
+    descriptor: CommandDescriptor,
+    config: CommandConfig,
+) -> None:
+    descriptor.config = config
+    descriptor.enabled = config.enabled
+
+    if config.original_command:
+        descriptor.original_command = config.original_command
+
+    new_fragment = config.resolved_command or descriptor.current_fragment
+    descriptor.current_fragment = new_fragment
+    descriptor.effective_command = _compose_command(
+        descriptor.parent_signature,
+        new_fragment,
+    )
+
+
+def _apply_config_to_runtime(
+    descriptor: CommandDescriptor,
+    config: CommandConfig,
+) -> None:
+    descriptor.handler.enabled = config.enabled
+    if descriptor.filter_ref and descriptor.current_fragment:
+        _set_filter_fragment(descriptor.filter_ref, descriptor.current_fragment)
+
+
+def _bind_configs_to_descriptors(
+    descriptors: list[CommandDescriptor],
+    config_records: list[CommandConfig],
+) -> dict[str, CommandConfig]:
+    config_map = {cfg.handler_full_name: cfg for cfg in config_records}
+    for desc in descriptors:
+        if cfg := config_map.get(desc.handler_full_name):
+            _bind_descriptor_with_config(desc, cfg)
+    return config_map
+
+
+def _group_conflicts(
+    descriptors: list[CommandDescriptor],
+) -> dict[str, list[CommandDescriptor]]:
+    conflicts: dict[str, list[CommandDescriptor]] = defaultdict(list)
+    for desc in descriptors:
+        if desc.effective_command and desc.enabled:
+            conflicts[desc.effective_command].append(desc)
+    return {k: v for k, v in conflicts.items() if len(v) > 1}
+
+
+def _set_filter_fragment(
+    filter_ref: CommandFilter | CommandGroupFilter,
+    fragment: str,
+) -> None:
+    attr = (
+        "group_name" if isinstance(filter_ref, CommandGroupFilter) else "command_name"
+    )
+    current_value = getattr(filter_ref, attr)
+    if fragment == current_value:
+        return
+    setattr(filter_ref, attr, fragment)
+    if hasattr(filter_ref, "_cmpl_cmd_names"):
+        filter_ref._cmpl_cmd_names = None
+
+
+def _is_command_in_use(
+    target_handler_full_name: str,
+    candidate_full_command: str,
+) -> bool:
+    candidate = candidate_full_command.strip()
+    for handler in star_handlers_registry:
+        if handler.handler_full_name == target_handler_full_name:
+            continue
+        filter_ref = _locate_primary_filter(handler)
+        if not filter_ref:
+            continue
+        names = {name.strip() for name in filter_ref.get_complete_command_names()}
+        if candidate in names:
+            return True
+    return False
+
+
+def _descriptor_to_dict(desc: CommandDescriptor) -> dict[str, Any]:
+    result = {
+        "handler_full_name": desc.handler_full_name,
+        "handler_name": desc.handler_name,
+        "plugin": desc.plugin_name,
+        "plugin_display_name": desc.plugin_display_name,
+        "module_path": desc.module_path,
+        "description": desc.description,
+        "type": desc.command_type,
+        "parent_signature": desc.parent_signature,
+        "parent_group_handler": desc.parent_group_handler,
+        "original_command": desc.original_command,
+        "current_fragment": desc.current_fragment,
+        "effective_command": desc.effective_command,
+        "aliases": desc.aliases,
+        "permission": desc.permission,
+        "enabled": desc.enabled,
+        "is_group": desc.is_group,
+        "has_conflict": desc.has_conflict,
+        "reserved": desc.reserved,
+    }
+    # 如果是指令组，包含子指令列表
+    if desc.is_group and desc.sub_commands:
+        result["sub_commands"] = [_descriptor_to_dict(sub) for sub in desc.sub_commands]
+    else:
+        result["sub_commands"] = []
+    return result

astrbot/core/star/context.py

@@ -285,7 +285,7 @@ class Context:
         """获取所有用于 Embedding 任务的 Provider。"""
         return self.provider_manager.embedding_provider_insts
 
-    def get_using_provider(self, umo: str | None = None) -> Provider | None:
+    def get_using_provider(self, umo: str | None = None) -> Provider:
         """获取当前使用的用于文本生成任务的 LLM Provider(Chat_Completion 类型)。通过 /provider 指令切换。
 
         Args:
@@ -296,7 +296,11 @@ class Context:
             provider_type=ProviderType.CHAT_COMPLETION,
             umo=umo,
         )
-        if prov and not isinstance(prov, Provider):
+        if prov is None:
+            raise ProviderNotFoundError(
+                "provider not found, please choose provider first"
+            )
+        if not isinstance(prov, Provider):
             raise ValueError("返回的 Provider 不是 Provider 类型")
         return prov
 

astrbot/core/star/filter/command.py

@@ -40,6 +40,7 @@ class CommandFilter(HandlerFilter):
     ):
         self.command_name = command_name
         self.alias = alias if alias else set()
+        self._original_command_name = command_name
         self.parent_command_names = (
             parent_command_names if parent_command_names is not None else [""]
         )

astrbot/core/star/filter/command_group.py

@@ -18,6 +18,7 @@ class CommandGroupFilter(HandlerFilter):
     ):
         self.group_name = group_name
         self.alias = alias if alias else set()
+        self._original_group_name = group_name
         self.sub_command_filters: list[CommandFilter | CommandGroupFilter] = []
         self.custom_filter_list: list[CustomFilter] = []
         self.parent_group = parent_group

astrbot/core/star/register/star_handler.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from collections.abc import Awaitable, Callable
+from collections.abc import AsyncGenerator, Awaitable, Callable
 from typing import Any
 
 import docstring_parser
@@ -12,6 +12,7 @@ from astrbot.core.agent.handoff import HandoffTool
 from astrbot.core.agent.hooks import BaseAgentRunHooks
 from astrbot.core.agent.tool import FunctionTool
 from astrbot.core.astr_agent_context import AstrAgentContext
+from astrbot.core.message.message_event_result import MessageEventResult
 from astrbot.core.provider.func_tool_manager import PY_TO_JSON_TYPE, SUPPORTED_TYPES
 from astrbot.core.provider.register import llm_tools
 
@@ -28,13 +29,19 @@ from ..filter.regex import RegexFilter
 from ..star_handler import EventType, StarHandlerMetadata, star_handlers_registry
 
 
-def get_handler_full_name(awaitable: Callable[..., Awaitable[Any]]) -> str:
+def get_handler_full_name(
+    awaitable: Callable[..., Awaitable[Any] | AsyncGenerator[Any]],
+) -> str:
     """获取 Handler 的全名"""
     return f"{awaitable.__module__}_{awaitable.__name__}"
 
 
 def get_handler_or_create(
-    handler: Callable[..., Awaitable[Any]],
+    handler: Callable[
+        ...,
+        Awaitable[MessageEventResult | str | None]
+        | AsyncGenerator[MessageEventResult | str | None],
+    ],
     event_type: EventType,
     dont_add=False,
     **kwargs,
@@ -169,6 +176,8 @@ def register_custom_filter(custom_type_filter, *args, **kwargs):
                 for (
                     sub_handle
                 ) in parent_register_commandable.parent_group.sub_command_filters:
+                    if isinstance(sub_handle, CommandGroupFilter):
+                        continue
                     # 所有符合fullname一致的子指令handle添加自定义过滤器。
                     # 不确定是否会有多个子指令有一样的fullname，比如一个方法添加多个command装饰器？
                     sub_handle_md = sub_handle.get_handler_md()
@@ -180,6 +189,8 @@ def register_custom_filter(custom_type_filter, *args, **kwargs):
 
             else:
                 # 裸指令
+                # 确保运行时是可调用的 handler，针对类型检查器添加忽略
+                assert isinstance(awaitable, Callable)
                 handler_md = get_handler_or_create(
                     awaitable,
                     EventType.AdapterMessageEvent,
@@ -237,7 +248,7 @@ class RegisteringCommandable:
 
     group: Callable[..., Callable[..., RegisteringCommandable]] = register_command_group
     command: Callable[..., Callable[..., None]] = register_command
-    custom_filter: Callable[..., Callable[..., None]] = register_custom_filter
+    custom_filter: Callable[..., Callable[..., Any]] = register_custom_filter
 
     def __init__(self, parent_group: CommandGroupFilter):
         self.parent_group = parent_group
@@ -412,7 +423,13 @@ def register_llm_tool(name: str | None = None, **kwargs):
     if kwargs.get("registering_agent"):
         registering_agent = kwargs["registering_agent"]
 
-    def decorator(awaitable: Callable[..., Awaitable[Any]]):
+    def decorator(
+        awaitable: Callable[
+            ...,
+            AsyncGenerator[MessageEventResult | str | None]
+            | Awaitable[MessageEventResult | str | None],
+        ],
+    ):
         llm_tool_name = name_ if name_ else awaitable.__name__
         func_doc = awaitable.__doc__ or ""
         docstring = docstring_parser.parse(func_doc)