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

.github/copilot-instructions.md

@@ -15,6 +15,7 @@ Always reference these instructions first and fallback to search or bash command
 ### Running the Application
 - Run main application: `uv run main.py` -- starts in ~3 seconds
 - Application creates WebUI on http://localhost:6185 (default credentials: `astrbot`/`astrbot`)
+- Application loads plugins automatically from `packages/` and `data/plugins/` directories
 
 ### Dashboard Build (Vue.js/Node.js)
 - **Prerequisites**: Node.js 20+ and npm 10+ required
@@ -34,7 +35,7 @@ Always reference these instructions first and fallback to search or bash command
 - **ALWAYS** run `uv run ruff check .` and `uv run ruff format .` before committing changes
 
 ### Plugin Development
-- Plugins load from `astrbot/builtin_stars/` (built-in) and `data/plugins/` (user-installed)
+- Plugins load from `packages/` (built-in) and `data/plugins/` (user-installed)
 - Plugin system supports function tools and message handlers
 - Key plugins: python_interpreter, web_searcher, astrbot, reminder, session_controller
 

.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/stale.yml

@@ -1,63 +1,27 @@
-# 本工作流用于标记并关闭长期不活跃的 Issue。
-# 目前仅针对带 `bug` 标签的 Issue 生效，不会处理 PR。
+# This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time.
 #
-# 文档: https://github.com/actions/stale
-name: Mark stale bug issues
+# You can adjust the behavior by modifying this file.
+# For more information, see:
+# https://github.com/actions/stale
+name: Mark stale issues and pull requests
 
 on:
   schedule:
-    # 每天 UTC 08:30 执行 (北京时间 16:30)
-    - cron: '30 8 * * *'
-  workflow_dispatch:
-    inputs:
-      dry-run:
-        description: '仅预览, 不实际执行 (Dry run mode)'
-        required: false
-        default: true
-        type: boolean
+  - cron: '21 23 * * *'
 
 jobs:
   stale:
+
     runs-on: ubuntu-latest
     permissions:
       issues: write
+      pull-requests: write
 
     steps:
-      - uses: actions/stale@v10
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-
-          # 只处理带 bug 标签的 Issue
-          any-of-labels: 'bug'
-
-          # 不处理 PR
-          days-before-pr-stale: -1
-          days-before-pr-close: -1
-
-          # 不活跃判定与关闭策略: 先标记 stale, 再延迟关闭
-          days-before-issue-stale: 60
-          days-before-issue-close: 30
-
-          stale-issue-label: 'stale'
-          stale-issue-message: |
-            This issue has been automatically marked as **stale** because it has not had any activity.
-            It will be closed in a certain period of time if no further activity occurs.
-            If this issue is still relevant, please leave a comment.
-
-            ---
-
-            该 Issue 已较长时间无活动, 已被标记为 `stale`。
-            如无后续活动, 将在一段时间后自动关闭。
-            如仍需跟进, 请回复评论。
-          close-issue-message: |
-            This issue has been automatically closed due to inactivity.
-            If the problem still exists, feel free to reopen or create a new issue with updated information.
-
-            ---
-
-            该 Issue 因长期无活动已自动关闭。
-            如问题仍存在, 欢迎补充复现信息并重新打开或新建 Issue。
-
-          remove-stale-when-updated: true
-
-          debug-only: ${{ github.event_name == 'workflow_dispatch' && inputs.dry-run }}
+    - uses: actions/stale@v10
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-issue-message: 'Stale issue message'
+        stale-pr-message: 'Stale pull request message'
+        stale-issue-label: 'no-issue-activity'
+        stale-pr-label: 'no-pr-activity'

.gitignore

@@ -24,14 +24,15 @@ configs/session
 configs/config.yaml
 cmd_config.json
 
-# Plugins
+# Plugins and packages
 addons/plugins
-astrbot/builtin_stars/python_interpreter/workplace
+packages/python_interpreter/workplace
 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)

astrbot/cli/__init__.py

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

astrbot/core/agent/message.py

@@ -12,7 +12,7 @@ class ContentPart(BaseModel):
 
     __content_part_registry: ClassVar[dict[str, type["ContentPart"]]] = {}
 
-    type: Literal["text", "think", "image_url", "audio_url"]
+    type: str
 
     def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
@@ -63,28 +63,6 @@ class TextPart(ContentPart):
     text: str
 
 
-class ThinkPart(ContentPart):
-    """
-    >>> ThinkPart(think="I think I need to think about this.").model_dump()
-    {'type': 'think', 'think': 'I think I need to think about this.', 'encrypted': None}
-    """
-
-    type: str = "think"
-    think: str
-    encrypted: str | None = None
-    """Encrypted thinking content, or signature."""
-
-    def merge_in_place(self, other: Any) -> bool:
-        if not isinstance(other, ThinkPart):
-            return False
-        if self.encrypted:
-            return False
-        self.think += other.think
-        if other.encrypted:
-            self.encrypted = other.encrypted
-        return True
-
-
 class ImageURLPart(ContentPart):
     """
     >>> ImageURLPart(image_url="http://example.com/image.jpg").model_dump()
@@ -191,15 +169,6 @@ class Message(BaseModel):
             )
         return self
 
-    @model_serializer(mode="wrap")
-    def serialize(self, handler):
-        data = handler(self)
-        if self.tool_calls is None:
-            data.pop("tool_calls", None)
-        if self.tool_call_id is None:
-            data.pop("tool_call_id", None)
-        return data
-
 
 class AssistantMessageSegment(Message):
     """A message segment from the assistant."""

astrbot/core/agent/runners/tool_loop_agent_runner.py

@@ -13,7 +13,6 @@ from mcp.types import (
 )
 
 from astrbot import logger
-from astrbot.core.agent.message import TextPart, ThinkPart
 from astrbot.core.message.components import Json
 from astrbot.core.message.message_event_result import (
     MessageChain,
@@ -77,20 +76,12 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
 
     async def _iter_llm_responses(self) -> T.AsyncGenerator[LLMResponse, None]:
         """Yields chunks *and* a final LLMResponse."""
-        payload = {
-            "contexts": self.run_context.messages,  # list[Message]
-            "func_tool": self.req.func_tool,
-            "model": self.req.model,  # NOTE: in fact, this arg is None in most cases
-            "session_id": self.req.session_id,
-            "extra_user_content_parts": self.req.extra_user_content_parts,  # list[ContentPart]
-        }
-
         if self.streaming:
-            stream = self.provider.text_chat_stream(**payload)
+            stream = self.provider.text_chat_stream(**self.req.__dict__)
             async for resp in stream:  # type: ignore
                 yield resp
         else:
-            yield await self.provider.text_chat(**payload)
+            yield await self.provider.text_chat(**self.req.__dict__)
 
     @override
     async def step(self):
@@ -170,20 +161,13 @@ 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
-            parts = []
-            if llm_resp.reasoning_content or llm_resp.reasoning_signature:
-                parts.append(
-                    ThinkPart(
-                        think=llm_resp.reasoning_content,
-                        encrypted=llm_resp.reasoning_signature,
-                    )
-                )
-            parts.append(TextPart(text=llm_resp.completion_text or "*No response*"))
-            self.run_context.messages.append(Message(role="assistant", content=parts))
-
-            # call the on_agent_done hook
+            self.run_context.messages.append(
+                Message(
+                    role="assistant",
+                    content=llm_resp.completion_text or "",
+                ),
+            )
             try:
                 await self.agent_hooks.on_agent_done(self.run_context, llm_resp)
             except Exception as e:
@@ -222,19 +206,10 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                         data=AgentResponseData(chain=result),
                     )
             # 将结果添加到上下文中
-            parts = []
-            if llm_resp.reasoning_content or llm_resp.reasoning_signature:
-                parts.append(
-                    ThinkPart(
-                        think=llm_resp.reasoning_content,
-                        encrypted=llm_resp.reasoning_signature,
-                    )
-                )
-            parts.append(TextPart(text=llm_resp.completion_text or "*No response*"))
             tool_calls_result = ToolCallsResult(
                 tool_calls_info=AssistantMessageSegment(
                     tool_calls=llm_resp.to_openai_to_calls_model(),
-                    content=parts,
+                    content=llm_resp.completion_text,
                 ),
                 tool_calls_result=tool_call_result_blocks,
             )
@@ -255,25 +230,6 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
             async for resp in self.step():
                 yield resp
 
-        #  如果循环结束了但是 agent 还没有完成，说明是达到了 max_step
-        if not self.done():
-            logger.warning(
-                f"Agent reached max steps ({max_step}), forcing a final response."
-            )
-            # 拔掉所有工具
-            if self.req:
-                self.req.func_tool = None
-            # 注入提示词
-            self.run_context.messages.append(
-                Message(
-                    role="user",
-                    content="工具调用次数已达到上限，请停止使用工具，并根据已经收集到的信息，对你的任务和发现进行总结，然后直接回复用户。",
-                )
-            )
-            # 再执行最后一步
-            async for resp in self.step():
-                yield resp
-
     async def _handle_function_tools(
         self,
         req: ProviderRequest,
@@ -420,33 +376,35 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                                     ),
                                 )
 
+                        # 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 直接请求发送消息给用户
                         # 这里我们将直接结束 Agent Loop。
                         # 发送消息逻辑在 ToolExecutor 中处理了。
                         logger.warning(
-                            f"{func_tool_name} 没有没有返回值或者将结果直接发送给用户。"
+                            f"{func_tool_name} 没有没有返回值或者将结果直接发送给用户，此工具调用不会被记录到历史中。"
                         )
                         self._transition_state(AgentState.DONE)
                         self.stats.end_time = time.time()
-                        tool_call_result_blocks.append(
-                            ToolCallMessageSegment(
-                                role="tool",
-                                tool_call_id=func_tool_id,
-                                content="*工具没有返回值或者将结果直接发送给了用户*",
-                            ),
-                        )
                     else:
                         # 不应该出现其他类型
                         logger.warning(
-                            f"Tool 返回了不支持的类型: {type(resp)}。",
-                        )
-                        tool_call_result_blocks.append(
-                            ToolCallMessageSegment(
-                                role="tool",
-                                tool_call_id=func_tool_id,
-                                content="*工具返回了不支持的类型，请告诉用户检查这个工具的定义和实现。*",
-                            ),
+                            f"Tool 返回了不支持的类型: {type(resp)}，将忽略。",
                         )
 
                 try:
@@ -468,22 +426,6 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                     ),
                 )
 
-        # 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,
-                        }
-                    )
-                ],
-            )
-
         # 处理函数调用响应
         if tool_call_result_blocks:
             yield tool_call_result_blocks

astrbot/core/astr_agent_hooks.py

@@ -13,12 +13,6 @@ from astrbot.core.star.star_handler import EventType
 class MainAgentHooks(BaseAgentRunHooks[AstrAgentContext]):
     async def on_agent_done(self, run_context, llm_response):
         # 执行事件钩子
-        if llm_response and llm_response.reasoning_content:
-            # we will use this in result_decorate stage to inject reasoning content to chain
-            run_context.context.event.set_extra(
-                "_llm_reasoning_content", llm_response.reasoning_content
-            )
-
         await call_event_hook(
             run_context.context.event,
             EventType.OnLLMResponseEvent,

astrbot/core/astr_agent_run_util.py

@@ -2,7 +2,6 @@ import traceback
 from collections.abc import AsyncGenerator
 
 from astrbot.core import logger
-from astrbot.core.agent.message import Message
 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
@@ -25,25 +24,8 @@ async def run_agent(
 ) -> AsyncGenerator[MessageChain | None, None]:
     step_idx = 0
     astr_event = agent_runner.run_context.context.event
-    while step_idx < max_step + 1:
+    while step_idx < max_step:
         step_idx += 1
-
-        if step_idx == max_step + 1:
-            logger.warning(
-                f"Agent reached max steps ({max_step}), forcing a final response."
-            )
-            if not agent_runner.done():
-                # 拔掉所有工具
-                if agent_runner.req:
-                    agent_runner.req.func_tool = None
-                # 注入提示词
-                agent_runner.run_context.messages.append(
-                    Message(
-                        role="user",
-                        content="工具调用次数已达到上限，请停止使用工具，并根据已经收集到的信息，对你的任务和发现进行总结，然后直接回复用户。",
-                    )
-                )
-
         try:
             async for resp in agent_runner.step():
                 if astr_event.is_stopped():

astrbot/core/astr_agent_tool_exec.py

@@ -209,42 +209,12 @@ async def call_local_llm_tool(
         else:
             raise ValueError(f"未知的方法名: {method_name}")
     except ValueError as e:
-        raise Exception(f"Tool execution ValueError: {e}") from e
-    except TypeError as e:
-        # 获取函数的签名（包括类型），除了第一个 event/context 参数。
-        try:
-            sig = inspect.signature(handler)
-            params = list(sig.parameters.values())
-            # 跳过第一个参数（event 或 context）
-            if params:
-                params = params[1:]
-
-            param_strs = []
-            for param in params:
-                param_str = param.name
-                if param.annotation != inspect.Parameter.empty:
-                    # 获取类型注解的字符串表示
-                    if isinstance(param.annotation, type):
-                        type_str = param.annotation.__name__
-                    else:
-                        type_str = str(param.annotation)
-                    param_str += f": {type_str}"
-                if param.default != inspect.Parameter.empty:
-                    param_str += f" = {param.default!r}"
-                param_strs.append(param_str)
-
-            handler_param_str = (
-                ", ".join(param_strs) if param_strs else "(no additional parameters)"
-            )
-        except Exception:
-            handler_param_str = "(unable to inspect signature)"
-
-        raise Exception(
-            f"Tool handler parameter mismatch, please check the handler definition. Handler parameters: {handler_param_str}"
-        ) from e
+        logger.error(f"调用本地 LLM 工具时出错: {e}", exc_info=True)
+    except TypeError:
+        logger.error("处理函数参数不匹配，请检查 handler 的定义。", exc_info=True)
     except Exception as e:
         trace_ = traceback.format_exc()
-        raise Exception(f"Tool execution error: {e}. Traceback: {trace_}") from e
+        logger.error(f"调用本地 LLM 工具时出错: {e}\n{trace_}")
 
     if not ready_to_call:
         return

astrbot/core/backup/__init__.py

@@ -1,26 +0,0 @@
-"""AstrBot 备份与恢复模块
-
-提供数据导出和导入功能，支持用户在服务器迁移时一键备份和恢复所有数据。
-"""
-
-# 从 constants 模块导入共享常量
-from .constants import (
-    BACKUP_MANIFEST_VERSION,
-    KB_METADATA_MODELS,
-    MAIN_DB_MODELS,
-    get_backup_directories,
-)
-
-# 导入导出器和导入器
-from .exporter import AstrBotExporter
-from .importer import AstrBotImporter, ImportPreCheckResult
-
-__all__ = [
-    "AstrBotExporter",
-    "AstrBotImporter",
-    "ImportPreCheckResult",
-    "MAIN_DB_MODELS",
-    "KB_METADATA_MODELS",
-    "get_backup_directories",
-    "BACKUP_MANIFEST_VERSION",
-]

astrbot/core/backup/constants.py

@@ -1,77 +0,0 @@
-"""AstrBot 备份模块共享常量
-
-此文件定义了导出器和导入器共享的常量，确保两端配置一致。
-"""
-
-from sqlmodel import SQLModel
-
-from astrbot.core.db.po import (
-    Attachment,
-    CommandConfig,
-    CommandConflict,
-    ConversationV2,
-    Persona,
-    PlatformMessageHistory,
-    PlatformSession,
-    PlatformStat,
-    Preference,
-)
-from astrbot.core.knowledge_base.models import (
-    KBDocument,
-    KBMedia,
-    KnowledgeBase,
-)
-from astrbot.core.utils.astrbot_path import (
-    get_astrbot_config_path,
-    get_astrbot_plugin_data_path,
-    get_astrbot_plugin_path,
-    get_astrbot_t2i_templates_path,
-    get_astrbot_temp_path,
-    get_astrbot_webchat_path,
-)
-
-# ============================================================
-# 共享常量 - 确保导出和导入端配置一致
-# ============================================================
-
-# 主数据库模型类映射
-MAIN_DB_MODELS: dict[str, type[SQLModel]] = {
-    "platform_stats": PlatformStat,
-    "conversations": ConversationV2,
-    "personas": Persona,
-    "preferences": Preference,
-    "platform_message_history": PlatformMessageHistory,
-    "platform_sessions": PlatformSession,
-    "attachments": Attachment,
-    "command_configs": CommandConfig,
-    "command_conflicts": CommandConflict,
-}
-
-# 知识库元数据模型类映射
-KB_METADATA_MODELS: dict[str, type[SQLModel]] = {
-    "knowledge_bases": KnowledgeBase,
-    "kb_documents": KBDocument,
-    "kb_media": KBMedia,
-}
-
-
-def get_backup_directories() -> dict[str, str]:
-    """获取需要备份的目录列表
-
-    使用 astrbot_path 模块动态获取路径，支持通过环境变量 ASTRBOT_ROOT 自定义根目录。
-
-    Returns:
-        dict: 键为备份文件中的目录名称，值为目录的绝对路径
-    """
-    return {
-        "plugins": get_astrbot_plugin_path(),  # 插件本体
-        "plugin_data": get_astrbot_plugin_data_path(),  # 插件数据
-        "config": get_astrbot_config_path(),  # 配置目录
-        "t2i_templates": get_astrbot_t2i_templates_path(),  # T2I 模板
-        "webchat": get_astrbot_webchat_path(),  # WebChat 数据
-        "temp": get_astrbot_temp_path(),  # 临时文件
-    }
-
-
-# 备份清单版本号
-BACKUP_MANIFEST_VERSION = "1.1"

astrbot/core/backup/exporter.py

@@ -1,477 +0,0 @@
-"""AstrBot 数据导出器
-
-负责将所有数据导出为 ZIP 备份文件。
-导出格式为 JSON，这是数据库无关的方案，支持未来向 MySQL/PostgreSQL 迁移。
-"""
-
-import hashlib
-import json
-import os
-import zipfile
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-from sqlalchemy import select
-
-from astrbot.core import logger
-from astrbot.core.config.default import VERSION
-from astrbot.core.db import BaseDatabase
-from astrbot.core.utils.astrbot_path import (
-    get_astrbot_backups_path,
-    get_astrbot_data_path,
-)
-
-# 从共享常量模块导入
-from .constants import (
-    BACKUP_MANIFEST_VERSION,
-    KB_METADATA_MODELS,
-    MAIN_DB_MODELS,
-    get_backup_directories,
-)
-
-if TYPE_CHECKING:
-    from astrbot.core.knowledge_base.kb_mgr import KnowledgeBaseManager
-
-CMD_CONFIG_FILE_PATH = os.path.join(get_astrbot_data_path(), "cmd_config.json")
-
-
-class AstrBotExporter:
-    """AstrBot 数据导出器
-
-    导出内容：
-    - 主数据库所有表（data/data_v4.db）
-    - 知识库元数据（data/knowledge_base/kb.db）
-    - 每个知识库的向量文档数据
-    - 配置文件（data/cmd_config.json）
-    - 附件文件
-    - 知识库多媒体文件
-    - 插件目录（data/plugins）
-    - 插件数据目录（data/plugin_data）
-    - 配置目录（data/config）
-    - T2I 模板目录（data/t2i_templates）
-    - WebChat 数据目录（data/webchat）
-    - 临时文件目录（data/temp）
-    """
-
-    def __init__(
-        self,
-        main_db: BaseDatabase,
-        kb_manager: "KnowledgeBaseManager | None" = None,
-        config_path: str = CMD_CONFIG_FILE_PATH,
-    ):
-        self.main_db = main_db
-        self.kb_manager = kb_manager
-        self.config_path = config_path
-        self._checksums: dict[str, str] = {}
-
-    async def export_all(
-        self,
-        output_dir: str | None = None,
-        progress_callback: Any | None = None,
-    ) -> str:
-        """导出所有数据到 ZIP 文件
-
-        Args:
-            output_dir: 输出目录
-            progress_callback: 进度回调函数，接收参数 (stage, current, total, message)
-
-        Returns:
-            str: 生成的 ZIP 文件路径
-        """
-        if output_dir is None:
-            output_dir = get_astrbot_backups_path()
-
-        # 确保输出目录存在
-        Path(output_dir).mkdir(parents=True, exist_ok=True)
-
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        zip_filename = f"astrbot_backup_{timestamp}.zip"
-        zip_path = os.path.join(output_dir, zip_filename)
-
-        logger.info(f"开始导出备份到 {zip_path}")
-
-        try:
-            with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
-                # 1. 导出主数据库
-                if progress_callback:
-                    await progress_callback("main_db", 0, 100, "正在导出主数据库...")
-                main_data = await self._export_main_database()
-                main_db_json = json.dumps(
-                    main_data, ensure_ascii=False, indent=2, default=str
-                )
-                zf.writestr("databases/main_db.json", main_db_json)
-                self._add_checksum("databases/main_db.json", main_db_json)
-                if progress_callback:
-                    await progress_callback("main_db", 100, 100, "主数据库导出完成")
-
-                # 2. 导出知识库数据
-                kb_meta_data: dict[str, Any] = {
-                    "knowledge_bases": [],
-                    "kb_documents": [],
-                    "kb_media": [],
-                }
-                if self.kb_manager:
-                    if progress_callback:
-                        await progress_callback(
-                            "kb_metadata", 0, 100, "正在导出知识库元数据..."
-                        )
-                    kb_meta_data = await self._export_kb_metadata()
-                    kb_meta_json = json.dumps(
-                        kb_meta_data, ensure_ascii=False, indent=2, default=str
-                    )
-                    zf.writestr("databases/kb_metadata.json", kb_meta_json)
-                    self._add_checksum("databases/kb_metadata.json", kb_meta_json)
-                    if progress_callback:
-                        await progress_callback(
-                            "kb_metadata", 100, 100, "知识库元数据导出完成"
-                        )
-
-                    # 导出每个知识库的文档数据
-                    kb_insts = self.kb_manager.kb_insts
-                    total_kbs = len(kb_insts)
-                    for idx, (kb_id, kb_helper) in enumerate(kb_insts.items()):
-                        if progress_callback:
-                            await progress_callback(
-                                "kb_documents",
-                                idx,
-                                total_kbs,
-                                f"正在导出知识库 {kb_helper.kb.kb_name} 的文档数据...",
-                            )
-                        doc_data = await self._export_kb_documents(kb_helper)
-                        doc_json = json.dumps(
-                            doc_data, ensure_ascii=False, indent=2, default=str
-                        )
-                        doc_path = f"databases/kb_{kb_id}/documents.json"
-                        zf.writestr(doc_path, doc_json)
-                        self._add_checksum(doc_path, doc_json)
-
-                        # 导出 FAISS 索引文件
-                        await self._export_faiss_index(zf, kb_helper, kb_id)
-
-                        # 导出知识库多媒体文件
-                        await self._export_kb_media_files(zf, kb_helper, kb_id)
-
-                    if progress_callback:
-                        await progress_callback(
-                            "kb_documents", total_kbs, total_kbs, "知识库文档导出完成"
-                        )
-
-                # 3. 导出配置文件
-                if progress_callback:
-                    await progress_callback("config", 0, 100, "正在导出配置文件...")
-                if os.path.exists(self.config_path):
-                    with open(self.config_path, encoding="utf-8") as f:
-                        config_content = f.read()
-                    zf.writestr("config/cmd_config.json", config_content)
-                    self._add_checksum("config/cmd_config.json", config_content)
-                if progress_callback:
-                    await progress_callback("config", 100, 100, "配置文件导出完成")
-
-                # 4. 导出附件文件
-                if progress_callback:
-                    await progress_callback("attachments", 0, 100, "正在导出附件...")
-                await self._export_attachments(zf, main_data.get("attachments", []))
-                if progress_callback:
-                    await progress_callback("attachments", 100, 100, "附件导出完成")
-
-                # 5. 导出插件和其他目录
-                if progress_callback:
-                    await progress_callback(
-                        "directories", 0, 100, "正在导出插件和数据目录..."
-                    )
-                dir_stats = await self._export_directories(zf)
-                if progress_callback:
-                    await progress_callback("directories", 100, 100, "目录导出完成")
-
-                # 6. 生成 manifest
-                if progress_callback:
-                    await progress_callback("manifest", 0, 100, "正在生成清单...")
-                manifest = self._generate_manifest(main_data, kb_meta_data, dir_stats)
-                manifest_json = json.dumps(manifest, ensure_ascii=False, indent=2)
-                zf.writestr("manifest.json", manifest_json)
-                if progress_callback:
-                    await progress_callback("manifest", 100, 100, "清单生成完成")
-
-            logger.info(f"备份导出完成: {zip_path}")
-            return zip_path
-
-        except Exception as e:
-            logger.error(f"备份导出失败: {e}")
-            # 清理失败的文件
-            if os.path.exists(zip_path):
-                os.remove(zip_path)
-            raise
-
-    async def _export_main_database(self) -> dict[str, list[dict]]:
-        """导出主数据库所有表"""
-        export_data: dict[str, list[dict]] = {}
-
-        async with self.main_db.get_db() as session:
-            for table_name, model_class in MAIN_DB_MODELS.items():
-                try:
-                    result = await session.execute(select(model_class))
-                    records = result.scalars().all()
-                    export_data[table_name] = [
-                        self._model_to_dict(record) for record in records
-                    ]
-                    logger.debug(
-                        f"导出表 {table_name}: {len(export_data[table_name])} 条记录"
-                    )
-                except Exception as e:
-                    logger.warning(f"导出表 {table_name} 失败: {e}")
-                    export_data[table_name] = []
-
-        return export_data
-
-    async def _export_kb_metadata(self) -> dict[str, list[dict]]:
-        """导出知识库元数据库"""
-        if not self.kb_manager:
-            return {"knowledge_bases": [], "kb_documents": [], "kb_media": []}
-
-        export_data: dict[str, list[dict]] = {}
-
-        async with self.kb_manager.kb_db.get_db() as session:
-            for table_name, model_class in KB_METADATA_MODELS.items():
-                try:
-                    result = await session.execute(select(model_class))
-                    records = result.scalars().all()
-                    export_data[table_name] = [
-                        self._model_to_dict(record) for record in records
-                    ]
-                    logger.debug(
-                        f"导出知识库表 {table_name}: {len(export_data[table_name])} 条记录"
-                    )
-                except Exception as e:
-                    logger.warning(f"导出知识库表 {table_name} 失败: {e}")
-                    export_data[table_name] = []
-
-        return export_data
-
-    async def _export_kb_documents(self, kb_helper: Any) -> dict[str, Any]:
-        """导出知识库的文档块数据"""
-        try:
-            from astrbot.core.db.vec_db.faiss_impl.vec_db import FaissVecDB
-
-            vec_db: FaissVecDB = kb_helper.vec_db
-            if not vec_db or not vec_db.document_storage:
-                return {"documents": []}
-
-            # 获取所有文档
-            docs = await vec_db.document_storage.get_documents(
-                metadata_filters={},
-                offset=0,
-                limit=None,  # 获取全部
-            )
-
-            return {"documents": docs}
-        except Exception as e:
-            logger.warning(f"导出知识库文档失败: {e}")
-            return {"documents": []}
-
-    async def _export_faiss_index(
-        self,
-        zf: zipfile.ZipFile,
-        kb_helper: Any,
-        kb_id: str,
-    ) -> None:
-        """导出 FAISS 索引文件"""
-        try:
-            index_path = kb_helper.kb_dir / "index.faiss"
-            if index_path.exists():
-                archive_path = f"databases/kb_{kb_id}/index.faiss"
-                zf.write(str(index_path), archive_path)
-                logger.debug(f"导出 FAISS 索引: {archive_path}")
-        except Exception as e:
-            logger.warning(f"导出 FAISS 索引失败: {e}")
-
-    async def _export_kb_media_files(
-        self, zf: zipfile.ZipFile, kb_helper: Any, kb_id: str
-    ) -> None:
-        """导出知识库的多媒体文件"""
-        try:
-            media_dir = kb_helper.kb_medias_dir
-            if not media_dir.exists():
-                return
-
-            for root, _, files in os.walk(media_dir):
-                for file in files:
-                    file_path = Path(root) / file
-                    # 计算相对路径
-                    rel_path = file_path.relative_to(kb_helper.kb_dir)
-                    archive_path = f"files/kb_media/{kb_id}/{rel_path}"
-                    zf.write(str(file_path), archive_path)
-        except Exception as e:
-            logger.warning(f"导出知识库媒体文件失败: {e}")
-
-    async def _export_directories(
-        self, zf: zipfile.ZipFile
-    ) -> dict[str, dict[str, int]]:
-        """导出插件和其他数据目录
-
-        Returns:
-            dict: 每个目录的统计信息 {dir_name: {"files": count, "size": bytes}}
-        """
-        stats: dict[str, dict[str, int]] = {}
-        backup_directories = get_backup_directories()
-
-        for dir_name, dir_path in backup_directories.items():
-            full_path = Path(dir_path)
-            if not full_path.exists():
-                logger.debug(f"目录不存在，跳过: {full_path}")
-                continue
-
-            file_count = 0
-            total_size = 0
-
-            try:
-                for root, dirs, files in os.walk(full_path):
-                    # 跳过 __pycache__ 目录
-                    dirs[:] = [d for d in dirs if d != "__pycache__"]
-
-                    for file in files:
-                        # 跳过 .pyc 文件
-                        if file.endswith(".pyc"):
-                            continue
-
-                        file_path = Path(root) / file
-                        try:
-                            # 计算相对路径
-                            rel_path = file_path.relative_to(full_path)
-                            archive_path = f"directories/{dir_name}/{rel_path}"
-                            zf.write(str(file_path), archive_path)
-                            file_count += 1
-                            total_size += file_path.stat().st_size
-                        except Exception as e:
-                            logger.warning(f"导出文件 {file_path} 失败: {e}")
-
-                stats[dir_name] = {"files": file_count, "size": total_size}
-                logger.debug(
-                    f"导出目录 {dir_name}: {file_count} 个文件, {total_size} 字节"
-                )
-            except Exception as e:
-                logger.warning(f"导出目录 {dir_path} 失败: {e}")
-                stats[dir_name] = {"files": 0, "size": 0}
-
-        return stats
-
-    async def _export_attachments(
-        self, zf: zipfile.ZipFile, attachments: list[dict]
-    ) -> None:
-        """导出附件文件"""
-        for attachment in attachments:
-            try:
-                file_path = attachment.get("path", "")
-                if file_path and os.path.exists(file_path):
-                    # 使用 attachment_id 作为文件名
-                    attachment_id = attachment.get("attachment_id", "")
-                    ext = os.path.splitext(file_path)[1]
-                    archive_path = f"files/attachments/{attachment_id}{ext}"
-                    zf.write(file_path, archive_path)
-            except Exception as e:
-                logger.warning(f"导出附件失败: {e}")
-
-    def _model_to_dict(self, record: Any) -> dict:
-        """将 SQLModel 实例转换为字典
-
-        这是数据库无关的序列化方式，支持未来迁移到其他数据库。
-        """
-        # 使用 SQLModel 内置的 model_dump 方法（如果可用）
-        if hasattr(record, "model_dump"):
-            data = record.model_dump(mode="python")
-            # 处理 datetime 类型
-            for key, value in data.items():
-                if isinstance(value, datetime):
-                    data[key] = value.isoformat()
-            return data
-
-        # 回退到手动提取
-        data = {}
-        # 使用 inspect 获取表信息
-        from sqlalchemy import inspect as sa_inspect
-
-        mapper = sa_inspect(record.__class__)
-        for column in mapper.columns:
-            value = getattr(record, column.name)
-            # 处理 datetime 类型 - 统一转为 ISO 格式字符串
-            if isinstance(value, datetime):
-                value = value.isoformat()
-            data[column.name] = value
-        return data
-
-    def _add_checksum(self, path: str, content: str | bytes) -> None:
-        """计算并添加文件校验和"""
-        if isinstance(content, str):
-            content = content.encode("utf-8")
-        checksum = hashlib.sha256(content).hexdigest()
-        self._checksums[path] = f"sha256:{checksum}"
-
-    def _generate_manifest(
-        self,
-        main_data: dict[str, list[dict]],
-        kb_meta_data: dict[str, list[dict]],
-        dir_stats: dict[str, dict[str, int]] | None = None,
-    ) -> dict:
-        """生成备份清单"""
-        if dir_stats is None:
-            dir_stats = {}
-        # 收集知识库 ID
-        kb_document_tables = {}
-        if self.kb_manager:
-            for kb_id in self.kb_manager.kb_insts.keys():
-                kb_document_tables[kb_id] = "documents"
-
-        # 收集附件文件列表
-        attachment_files = []
-        for attachment in main_data.get("attachments", []):
-            attachment_id = attachment.get("attachment_id", "")
-            path = attachment.get("path", "")
-            if attachment_id and path:
-                ext = os.path.splitext(path)[1]
-                attachment_files.append(f"{attachment_id}{ext}")
-
-        # 收集知识库媒体文件
-        kb_media_files: dict[str, list[str]] = {}
-        if self.kb_manager:
-            for kb_id, kb_helper in self.kb_manager.kb_insts.items():
-                media_files: list[str] = []
-                media_dir = kb_helper.kb_medias_dir
-                if media_dir.exists():
-                    for root, _, files in os.walk(media_dir):
-                        for file in files:
-                            media_files.append(file)
-                if media_files:
-                    kb_media_files[kb_id] = media_files
-
-        manifest = {
-            "version": BACKUP_MANIFEST_VERSION,
-            "astrbot_version": VERSION,
-            "exported_at": datetime.now(timezone.utc).isoformat(),
-            "origin": "exported",  # 标记备份来源：exported=本实例导出, uploaded=用户上传
-            "schema_version": {
-                "main_db": "v4",
-                "kb_db": "v1",
-            },
-            "tables": {
-                "main_db": list(main_data.keys()),
-                "kb_metadata": list(kb_meta_data.keys()),
-                "kb_documents": kb_document_tables,
-            },
-            "files": {
-                "attachments": attachment_files,
-                "kb_media": kb_media_files,
-            },
-            "directories": list(dir_stats.keys()),
-            "checksums": self._checksums,
-            "statistics": {
-                "main_db": {
-                    table: len(records) for table, records in main_data.items()
-                },
-                "kb_metadata": {
-                    table: len(records) for table, records in kb_meta_data.items()
-                },
-                "directories": dir_stats,
-            },
-        }
-
-        return manifest

astrbot/core/backup/importer.py

@@ -1,761 +0,0 @@
-"""AstrBot 数据导入器
-
-负责从 ZIP 备份文件恢复所有数据。
-导入时进行版本校验：
-- 主版本（前两位）不同时直接拒绝导入
-- 小版本（第三位）不同时提示警告，用户可选择强制导入
-- 版本匹配时也需要用户确认
-"""
-
-import json
-import os
-import shutil
-import zipfile
-from dataclasses import dataclass, field
-from datetime import datetime
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-from sqlalchemy import delete
-
-from astrbot.core import logger
-from astrbot.core.config.default import VERSION
-from astrbot.core.db import BaseDatabase
-from astrbot.core.utils.astrbot_path import (
-    get_astrbot_data_path,
-    get_astrbot_knowledge_base_path,
-)
-from astrbot.core.utils.version_comparator import VersionComparator
-
-# 从共享常量模块导入
-from .constants import (
-    KB_METADATA_MODELS,
-    MAIN_DB_MODELS,
-    get_backup_directories,
-)
-
-if TYPE_CHECKING:
-    from astrbot.core.knowledge_base.kb_mgr import KnowledgeBaseManager
-
-
-def _get_major_version(version_str: str) -> str:
-    """提取版本的主版本部分（前两位）
-
-    Args:
-        version_str: 版本字符串，如 "4.9.1", "4.10.0-beta"
-
-    Returns:
-        主版本字符串，如 "4.9", "4.10"
-    """
-    if not version_str:
-        return "0.0"
-    # 移除 v 前缀和预发布标签
-    version = version_str.lower().replace("v", "").split("-")[0].split("+")[0]
-    parts = [p for p in version.split(".") if p]  # 过滤空字符串
-    if len(parts) >= 2:
-        return f"{parts[0]}.{parts[1]}"
-    elif len(parts) == 1 and parts[0]:
-        return f"{parts[0]}.0"
-    return "0.0"
-
-
-CMD_CONFIG_FILE_PATH = os.path.join(get_astrbot_data_path(), "cmd_config.json")
-KB_PATH = get_astrbot_knowledge_base_path()
-
-
-@dataclass
-class ImportPreCheckResult:
-    """导入预检查结果
-
-    用于在实际导入前检查备份文件的版本兼容性，
-    并返回确认信息让用户决定是否继续导入。
-    """
-
-    # 检查是否通过（文件有效且版本可导入）
-    valid: bool = False
-    # 是否可以导入（版本兼容）
-    can_import: bool = False
-    # 版本状态: match（完全匹配）, minor_diff（小版本差异）, major_diff（主版本不同，拒绝）
-    version_status: str = ""
-    # 备份文件中的 AstrBot 版本
-    backup_version: str = ""
-    # 当前运行的 AstrBot 版本
-    current_version: str = VERSION
-    # 备份创建时间
-    backup_time: str = ""
-    # 确认消息（显示给用户）
-    confirm_message: str = ""
-    # 警告消息列表
-    warnings: list[str] = field(default_factory=list)
-    # 错误消息（如果检查失败）
-    error: str = ""
-    # 备份包含的内容摘要
-    backup_summary: dict = field(default_factory=dict)
-
-    def to_dict(self) -> dict:
-        return {
-            "valid": self.valid,
-            "can_import": self.can_import,
-            "version_status": self.version_status,
-            "backup_version": self.backup_version,
-            "current_version": self.current_version,
-            "backup_time": self.backup_time,
-            "confirm_message": self.confirm_message,
-            "warnings": self.warnings,
-            "error": self.error,
-            "backup_summary": self.backup_summary,
-        }
-
-
-class ImportResult:
-    """导入结果"""
-
-    def __init__(self):
-        self.success = True
-        self.imported_tables: dict[str, int] = {}
-        self.imported_files: dict[str, int] = {}
-        self.imported_directories: dict[str, int] = {}
-        self.warnings: list[str] = []
-        self.errors: list[str] = []
-
-    def add_warning(self, msg: str) -> None:
-        self.warnings.append(msg)
-        logger.warning(msg)
-
-    def add_error(self, msg: str) -> None:
-        self.errors.append(msg)
-        self.success = False
-        logger.error(msg)
-
-    def to_dict(self) -> dict:
-        return {
-            "success": self.success,
-            "imported_tables": self.imported_tables,
-            "imported_files": self.imported_files,
-            "imported_directories": self.imported_directories,
-            "warnings": self.warnings,
-            "errors": self.errors,
-        }
-
-
-class AstrBotImporter:
-    """AstrBot 数据导入器
-
-    导入备份文件中的所有数据，包括：
-    - 主数据库所有表
-    - 知识库元数据和文档
-    - 配置文件
-    - 附件文件
-    - 知识库多媒体文件
-    - 插件目录（data/plugins）
-    - 插件数据目录（data/plugin_data）
-    - 配置目录（data/config）
-    - T2I 模板目录（data/t2i_templates）
-    - WebChat 数据目录（data/webchat）
-    - 临时文件目录（data/temp）
-    """
-
-    def __init__(
-        self,
-        main_db: BaseDatabase,
-        kb_manager: "KnowledgeBaseManager | None" = None,
-        config_path: str = CMD_CONFIG_FILE_PATH,
-        kb_root_dir: str = KB_PATH,
-    ):
-        self.main_db = main_db
-        self.kb_manager = kb_manager
-        self.config_path = config_path
-        self.kb_root_dir = kb_root_dir
-
-    def pre_check(self, zip_path: str) -> ImportPreCheckResult:
-        """预检查备份文件
-
-        在实际导入前检查备份文件的有效性和版本兼容性。
-        返回检查结果供前端显示确认对话框。
-
-        Args:
-            zip_path: ZIP 备份文件路径
-
-        Returns:
-            ImportPreCheckResult: 预检查结果
-        """
-        result = ImportPreCheckResult()
-        result.current_version = VERSION
-
-        if not os.path.exists(zip_path):
-            result.error = f"备份文件不存在: {zip_path}"
-            return result
-
-        try:
-            with zipfile.ZipFile(zip_path, "r") as zf:
-                # 读取 manifest
-                try:
-                    manifest_data = zf.read("manifest.json")
-                    manifest = json.loads(manifest_data)
-                except KeyError:
-                    result.error = "备份文件缺少 manifest.json，不是有效的 AstrBot 备份"
-                    return result
-                except json.JSONDecodeError as e:
-                    result.error = f"manifest.json 格式错误: {e}"
-                    return result
-
-                # 提取基本信息
-                result.backup_version = manifest.get("astrbot_version", "未知")
-                result.backup_time = manifest.get("exported_at", "未知")
-                result.valid = True
-
-                # 构建备份摘要
-                result.backup_summary = {
-                    "tables": list(manifest.get("tables", {}).keys()),
-                    "has_knowledge_bases": manifest.get("has_knowledge_bases", False),
-                    "has_config": manifest.get("has_config", False),
-                    "directories": manifest.get("directories", []),
-                }
-
-                # 检查版本兼容性
-                version_check = self._check_version_compatibility(result.backup_version)
-                result.version_status = version_check["status"]
-                result.can_import = version_check["can_import"]
-
-                # 版本信息由前端根据 version_status 和 i18n 生成显示
-                # 不再将版本消息添加到 warnings 列表中，避免中文硬编码
-                # warnings 列表保留用于其他非版本相关的警告
-
-                return result
-
-        except zipfile.BadZipFile:
-            result.error = "无效的 ZIP 文件"
-            return result
-        except Exception as e:
-            result.error = f"检查备份文件失败: {e}"
-            return result
-
-    def _check_version_compatibility(self, backup_version: str) -> dict:
-        """检查版本兼容性
-
-        规则：
-        - 主版本（前两位，如 4.9）必须一致，否则拒绝
-        - 小版本（第三位，如 4.9.1 vs 4.9.2）不同时，警告但允许导入
-
-        Returns:
-            dict: {status, can_import, message}
-        """
-        if not backup_version:
-            return {
-                "status": "major_diff",
-                "can_import": False,
-                "message": "备份文件缺少版本信息",
-            }
-
-        # 提取主版本（前两位）进行比较
-        backup_major = _get_major_version(backup_version)
-        current_major = _get_major_version(VERSION)
-
-        # 比较主版本
-        if VersionComparator.compare_version(backup_major, current_major) != 0:
-            return {
-                "status": "major_diff",
-                "can_import": False,
-                "message": (
-                    f"主版本不兼容: 备份版本 {backup_version}, 当前版本 {VERSION}。"
-                    f"跨主版本导入可能导致数据损坏，请使用相同主版本的 AstrBot。"
-                ),
-            }
-
-        # 比较完整版本
-        version_cmp = VersionComparator.compare_version(backup_version, VERSION)
-        if version_cmp != 0:
-            return {
-                "status": "minor_diff",
-                "can_import": True,
-                "message": (
-                    f"小版本差异: 备份版本 {backup_version}, 当前版本 {VERSION}。"
-                ),
-            }
-
-        return {
-            "status": "match",
-            "can_import": True,
-            "message": "版本匹配",
-        }
-
-    async def import_all(
-        self,
-        zip_path: str,
-        mode: str = "replace",  # "replace" 清空后导入
-        progress_callback: Any | None = None,
-    ) -> ImportResult:
-        """从 ZIP 文件导入所有数据
-
-        Args:
-            zip_path: ZIP 备份文件路径
-            mode: 导入模式，目前仅支持 "replace"（清空后导入）
-            progress_callback: 进度回调函数，接收参数 (stage, current, total, message)
-
-        Returns:
-            ImportResult: 导入结果
-        """
-        result = ImportResult()
-
-        if not os.path.exists(zip_path):
-            result.add_error(f"备份文件不存在: {zip_path}")
-            return result
-
-        logger.info(f"开始从 {zip_path} 导入备份")
-
-        try:
-            with zipfile.ZipFile(zip_path, "r") as zf:
-                # 1. 读取并验证 manifest
-                if progress_callback:
-                    await progress_callback("validate", 0, 100, "正在验证备份文件...")
-
-                try:
-                    manifest_data = zf.read("manifest.json")
-                    manifest = json.loads(manifest_data)
-                except KeyError:
-                    result.add_error("备份文件缺少 manifest.json")
-                    return result
-                except json.JSONDecodeError as e:
-                    result.add_error(f"manifest.json 格式错误: {e}")
-                    return result
-
-                # 版本校验
-                try:
-                    self._validate_version(manifest)
-                except ValueError as e:
-                    result.add_error(str(e))
-                    return result
-
-                if progress_callback:
-                    await progress_callback("validate", 100, 100, "验证完成")
-
-                # 2. 导入主数据库
-                if progress_callback:
-                    await progress_callback("main_db", 0, 100, "正在导入主数据库...")
-
-                try:
-                    main_data_content = zf.read("databases/main_db.json")
-                    main_data = json.loads(main_data_content)
-
-                    if mode == "replace":
-                        await self._clear_main_db()
-
-                    imported = await self._import_main_database(main_data)
-                    result.imported_tables.update(imported)
-                except Exception as e:
-                    result.add_error(f"导入主数据库失败: {e}")
-                    return result
-
-                if progress_callback:
-                    await progress_callback("main_db", 100, 100, "主数据库导入完成")
-
-                # 3. 导入知识库
-                if self.kb_manager and "databases/kb_metadata.json" in zf.namelist():
-                    if progress_callback:
-                        await progress_callback("kb", 0, 100, "正在导入知识库...")
-
-                    try:
-                        kb_meta_content = zf.read("databases/kb_metadata.json")
-                        kb_meta_data = json.loads(kb_meta_content)
-
-                        if mode == "replace":
-                            await self._clear_kb_data()
-
-                        await self._import_knowledge_bases(zf, kb_meta_data, result)
-                    except Exception as e:
-                        result.add_warning(f"导入知识库失败: {e}")
-
-                    if progress_callback:
-                        await progress_callback("kb", 100, 100, "知识库导入完成")
-
-                # 4. 导入配置文件
-                if progress_callback:
-                    await progress_callback("config", 0, 100, "正在导入配置文件...")
-
-                if "config/cmd_config.json" in zf.namelist():
-                    try:
-                        config_content = zf.read("config/cmd_config.json")
-                        # 备份现有配置
-                        if os.path.exists(self.config_path):
-                            backup_path = f"{self.config_path}.bak"
-                            shutil.copy2(self.config_path, backup_path)
-
-                        with open(self.config_path, "wb") as f:
-                            f.write(config_content)
-                        result.imported_files["config"] = 1
-                    except Exception as e:
-                        result.add_warning(f"导入配置文件失败: {e}")
-
-                if progress_callback:
-                    await progress_callback("config", 100, 100, "配置文件导入完成")
-
-                # 5. 导入附件文件
-                if progress_callback:
-                    await progress_callback("attachments", 0, 100, "正在导入附件...")
-
-                attachment_count = await self._import_attachments(
-                    zf, main_data.get("attachments", [])
-                )
-                result.imported_files["attachments"] = attachment_count
-
-                if progress_callback:
-                    await progress_callback("attachments", 100, 100, "附件导入完成")
-
-                # 6. 导入插件和其他目录
-                if progress_callback:
-                    await progress_callback(
-                        "directories", 0, 100, "正在导入插件和数据目录..."
-                    )
-
-                dir_stats = await self._import_directories(zf, manifest, result)
-                result.imported_directories = dir_stats
-
-                if progress_callback:
-                    await progress_callback("directories", 100, 100, "目录导入完成")
-
-            logger.info(f"备份导入完成: {result.to_dict()}")
-            return result
-
-        except zipfile.BadZipFile:
-            result.add_error("无效的 ZIP 文件")
-            return result
-        except Exception as e:
-            result.add_error(f"导入失败: {e}")
-            return result
-
-    def _validate_version(self, manifest: dict) -> None:
-        """验证版本兼容性 - 仅允许相同主版本导入
-
-        注意：此方法仅在 import_all 中调用，用于双重校验。
-        前端应先调用 pre_check 获取详细的版本信息并让用户确认。
-        """
-        backup_version = manifest.get("astrbot_version")
-        if not backup_version:
-            raise ValueError("备份文件缺少版本信息")
-
-        # 使用新的版本兼容性检查
-        version_check = self._check_version_compatibility(backup_version)
-
-        if version_check["status"] == "major_diff":
-            raise ValueError(version_check["message"])
-
-        # minor_diff 和 match 都允许导入
-        if version_check["status"] == "minor_diff":
-            logger.warning(f"版本差异警告: {version_check['message']}")
-
-    async def _clear_main_db(self) -> None:
-        """清空主数据库所有表"""
-        async with self.main_db.get_db() as session:
-            async with session.begin():
-                for table_name, model_class in MAIN_DB_MODELS.items():
-                    try:
-                        await session.execute(delete(model_class))
-                        logger.debug(f"已清空表 {table_name}")
-                    except Exception as e:
-                        logger.warning(f"清空表 {table_name} 失败: {e}")
-
-    async def _clear_kb_data(self) -> None:
-        """清空知识库数据"""
-        if not self.kb_manager:
-            return
-
-        # 清空知识库元数据表
-        async with self.kb_manager.kb_db.get_db() as session:
-            async with session.begin():
-                for table_name, model_class in KB_METADATA_MODELS.items():
-                    try:
-                        await session.execute(delete(model_class))
-                        logger.debug(f"已清空知识库表 {table_name}")
-                    except Exception as e:
-                        logger.warning(f"清空知识库表 {table_name} 失败: {e}")
-
-        # 删除知识库文件目录
-        for kb_id in list(self.kb_manager.kb_insts.keys()):
-            try:
-                kb_helper = self.kb_manager.kb_insts[kb_id]
-                await kb_helper.terminate()
-                if kb_helper.kb_dir.exists():
-                    shutil.rmtree(kb_helper.kb_dir)
-            except Exception as e:
-                logger.warning(f"清理知识库 {kb_id} 失败: {e}")
-
-        self.kb_manager.kb_insts.clear()
-
-    async def _import_main_database(
-        self, data: dict[str, list[dict]]
-    ) -> dict[str, int]:
-        """导入主数据库数据"""
-        imported: dict[str, int] = {}
-
-        async with self.main_db.get_db() as session:
-            async with session.begin():
-                for table_name, rows in data.items():
-                    model_class = MAIN_DB_MODELS.get(table_name)
-                    if not model_class:
-                        logger.warning(f"未知的表: {table_name}")
-                        continue
-
-                    count = 0
-                    for row in rows:
-                        try:
-                            # 转换 datetime 字符串为 datetime 对象
-                            row = self._convert_datetime_fields(row, model_class)
-                            obj = model_class(**row)
-                            session.add(obj)
-                            count += 1
-                        except Exception as e:
-                            logger.warning(f"导入记录到 {table_name} 失败: {e}")
-
-                    imported[table_name] = count
-                    logger.debug(f"导入表 {table_name}: {count} 条记录")
-
-        return imported
-
-    async def _import_knowledge_bases(
-        self,
-        zf: zipfile.ZipFile,
-        kb_meta_data: dict[str, list[dict]],
-        result: ImportResult,
-    ) -> None:
-        """导入知识库数据"""
-        if not self.kb_manager:
-            return
-
-        # 1. 导入知识库元数据
-        async with self.kb_manager.kb_db.get_db() as session:
-            async with session.begin():
-                for table_name, rows in kb_meta_data.items():
-                    model_class = KB_METADATA_MODELS.get(table_name)
-                    if not model_class:
-                        continue
-
-                    count = 0
-                    for row in rows:
-                        try:
-                            row = self._convert_datetime_fields(row, model_class)
-                            obj = model_class(**row)
-                            session.add(obj)
-                            count += 1
-                        except Exception as e:
-                            logger.warning(f"导入知识库记录到 {table_name} 失败: {e}")
-
-                    result.imported_tables[f"kb_{table_name}"] = count
-
-        # 2. 导入每个知识库的文档和文件
-        for kb_data in kb_meta_data.get("knowledge_bases", []):
-            kb_id = kb_data.get("kb_id")
-            if not kb_id:
-                continue
-
-            # 创建知识库目录
-            kb_dir = Path(self.kb_root_dir) / kb_id
-            kb_dir.mkdir(parents=True, exist_ok=True)
-
-            # 导入文档数据
-            doc_path = f"databases/kb_{kb_id}/documents.json"
-            if doc_path in zf.namelist():
-                try:
-                    doc_content = zf.read(doc_path)
-                    doc_data = json.loads(doc_content)
-
-                    # 导入到文档存储数据库
-                    await self._import_kb_documents(kb_id, doc_data)
-                except Exception as e:
-                    result.add_warning(f"导入知识库 {kb_id} 的文档失败: {e}")
-
-            # 导入 FAISS 索引
-            faiss_path = f"databases/kb_{kb_id}/index.faiss"
-            if faiss_path in zf.namelist():
-                try:
-                    target_path = kb_dir / "index.faiss"
-                    with zf.open(faiss_path) as src, open(target_path, "wb") as dst:
-                        dst.write(src.read())
-                except Exception as e:
-                    result.add_warning(f"导入知识库 {kb_id} 的 FAISS 索引失败: {e}")
-
-            # 导入媒体文件
-            media_prefix = f"files/kb_media/{kb_id}/"
-            for name in zf.namelist():
-                if name.startswith(media_prefix):
-                    try:
-                        rel_path = name[len(media_prefix) :]
-                        target_path = kb_dir / rel_path
-                        target_path.parent.mkdir(parents=True, exist_ok=True)
-                        with zf.open(name) as src, open(target_path, "wb") as dst:
-                            dst.write(src.read())
-                    except Exception as e:
-                        result.add_warning(f"导入媒体文件 {name} 失败: {e}")
-
-        # 3. 重新加载知识库实例
-        await self.kb_manager.load_kbs()
-
-    async def _import_kb_documents(self, kb_id: str, doc_data: dict) -> None:
-        """导入知识库文档到向量数据库"""
-        from astrbot.core.db.vec_db.faiss_impl.document_storage import DocumentStorage
-
-        kb_dir = Path(self.kb_root_dir) / kb_id
-        doc_db_path = kb_dir / "doc.db"
-
-        # 初始化文档存储
-        doc_storage = DocumentStorage(str(doc_db_path))
-        await doc_storage.initialize()
-
-        try:
-            documents = doc_data.get("documents", [])
-            for doc in documents:
-                try:
-                    await doc_storage.insert_document(
-                        doc_id=doc.get("doc_id", ""),
-                        text=doc.get("text", ""),
-                        metadata=json.loads(doc.get("metadata", "{}")),
-                    )
-                except Exception as e:
-                    logger.warning(f"导入文档块失败: {e}")
-        finally:
-            await doc_storage.close()
-
-    async def _import_attachments(
-        self,
-        zf: zipfile.ZipFile,
-        attachments: list[dict],
-    ) -> int:
-        """导入附件文件"""
-        count = 0
-
-        attachments_dir = Path(self.config_path).parent / "attachments"
-        attachments_dir.mkdir(parents=True, exist_ok=True)
-
-        attachment_prefix = "files/attachments/"
-        for name in zf.namelist():
-            if name.startswith(attachment_prefix) and name != attachment_prefix:
-                try:
-                    # 从附件记录中找到原始路径
-                    attachment_id = os.path.splitext(os.path.basename(name))[0]
-                    original_path = None
-                    for att in attachments:
-                        if att.get("attachment_id") == attachment_id:
-                            original_path = att.get("path")
-                            break
-
-                    if original_path:
-                        target_path = Path(original_path)
-                    else:
-                        target_path = attachments_dir / os.path.basename(name)
-
-                    target_path.parent.mkdir(parents=True, exist_ok=True)
-                    with zf.open(name) as src, open(target_path, "wb") as dst:
-                        dst.write(src.read())
-                    count += 1
-                except Exception as e:
-                    logger.warning(f"导入附件 {name} 失败: {e}")
-
-        return count
-
-    async def _import_directories(
-        self,
-        zf: zipfile.ZipFile,
-        manifest: dict,
-        result: ImportResult,
-    ) -> dict[str, int]:
-        """导入插件和其他数据目录
-
-        Args:
-            zf: ZIP 文件对象
-            manifest: 备份清单
-            result: 导入结果对象
-
-        Returns:
-            dict: 每个目录导入的文件数量
-        """
-        dir_stats: dict[str, int] = {}
-
-        # 检查备份版本是否支持目录备份（需要版本 >= 1.1）
-        backup_version = manifest.get("version", "1.0")
-        if VersionComparator.compare_version(backup_version, "1.1") < 0:
-            logger.info("备份版本不支持目录备份，跳过目录导入")
-            return dir_stats
-
-        backed_up_dirs = manifest.get("directories", [])
-        backup_directories = get_backup_directories()
-
-        for dir_name in backed_up_dirs:
-            if dir_name not in backup_directories:
-                result.add_warning(f"未知的目录类型: {dir_name}")
-                continue
-
-            target_dir = Path(backup_directories[dir_name])
-            archive_prefix = f"directories/{dir_name}/"
-
-            file_count = 0
-
-            try:
-                # 获取该目录下的所有文件
-                dir_files = [
-                    name
-                    for name in zf.namelist()
-                    if name.startswith(archive_prefix) and name != archive_prefix
-                ]
-
-                if not dir_files:
-                    continue
-
-                # 备份现有目录（如果存在）
-                if target_dir.exists():
-                    backup_path = Path(f"{target_dir}.bak")
-                    if backup_path.exists():
-                        shutil.rmtree(backup_path)
-                    shutil.move(str(target_dir), str(backup_path))
-                    logger.debug(f"已备份现有目录 {target_dir} 到 {backup_path}")
-
-                # 创建目标目录
-                target_dir.mkdir(parents=True, exist_ok=True)
-
-                # 解压文件
-                for name in dir_files:
-                    try:
-                        # 计算相对路径
-                        rel_path = name[len(archive_prefix) :]
-                        if not rel_path:  # 跳过目录条目
-                            continue
-
-                        target_path = target_dir / rel_path
-                        target_path.parent.mkdir(parents=True, exist_ok=True)
-
-                        with zf.open(name) as src, open(target_path, "wb") as dst:
-                            dst.write(src.read())
-                        file_count += 1
-                    except Exception as e:
-                        result.add_warning(f"导入文件 {name} 失败: {e}")
-
-                dir_stats[dir_name] = file_count
-                logger.debug(f"导入目录 {dir_name}: {file_count} 个文件")
-
-            except Exception as e:
-                result.add_warning(f"导入目录 {dir_name} 失败: {e}")
-                dir_stats[dir_name] = 0
-
-        return dir_stats
-
-    def _convert_datetime_fields(self, row: dict, model_class: type) -> dict:
-        """转换 datetime 字符串字段为 datetime 对象"""
-        result = row.copy()
-
-        # 获取模型的 datetime 字段
-        from sqlalchemy import inspect as sa_inspect
-
-        try:
-            mapper = sa_inspect(model_class)
-            for column in mapper.columns:
-                if column.name in result and result[column.name] is not None:
-                    # 检查是否是 datetime 类型的列
-                    from sqlalchemy import DateTime
-
-                    if isinstance(column.type, DateTime):
-                        value = result[column.name]
-                        if isinstance(value, str):
-                            # 解析 ISO 格式的日期时间字符串
-                            result[column.name] = datetime.fromisoformat(value)
-        except Exception:
-            pass
-
-        return result

astrbot/core/config/astrbot_config.py

@@ -80,8 +80,6 @@ class AstrBotConfig(dict):
                 if v["type"] == "object":
                     conf[k] = {}
                     _parse_schema(v["items"], conf[k])
-                elif v["type"] == "template_list":
-                    conf[k] = default
                 else:
                     conf[k] = default
 

astrbot/core/config/default.py

@@ -1,11 +1,10 @@
 """如需修改配置，请在 `data/cmd_config.json` 中修改或者在管理面板中可视化修改。"""
 
 import os
-from typing import Any, TypedDict
 
 from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 
-VERSION = "4.10.3"
+VERSION = "4.9.2"
 DB_PATH = os.path.join(get_astrbot_data_path(), "data_v4.db")
 
 WEBHOOK_SUPPORTED_PLATFORMS = [
@@ -62,8 +61,7 @@ DEFAULT_CONFIG = {
         "ignore_bot_self_message": False,
         "ignore_at_all": False,
     },
-    "provider_sources": [],  # provider sources
-    "provider": [],  # models from provider_sources
+    "provider": [],
     "provider_settings": {
         "enable": True,
         "default_provider_id": "",
@@ -173,22 +171,6 @@ DEFAULT_CONFIG = {
 }
 
 
-class ChatProviderTemplate(TypedDict):
-    id: str
-    provider_source_id: str
-    model: str
-    modalities: list
-    custom_extra_body: dict[str, Any]
-
-
-CHAT_PROVIDER_TEMPLATE = {
-    "id": "",
-    "provide_source_id": "",
-    "model": "",
-    "modalities": [],
-    "custom_extra_body": {},
-}
-
 """
 AstrBot v3 时代的配置元数据，目前仅承担以下功能：
 
@@ -862,7 +844,6 @@ CONFIG_METADATA_2 = {
         "metadata": {
             "provider": {
                 "type": "list",
-                # provider sources templates
                 "config_template": {
                     "OpenAI": {
                         "id": "openai",
@@ -873,10 +854,107 @@ CONFIG_METADATA_2 = {
                         "key": [],
                         "api_base": "https://api.openai.com/v1",
                         "timeout": 120,
+                        "model_config": {"model": "gpt-4o-mini", "temperature": 0.4},
                         "custom_headers": {},
+                        "custom_extra_body": {},
+                        "modalities": ["text", "image", "tool_use"],
+                        "hint": "也兼容所有与 OpenAI API 兼容的服务。",
                     },
-                    "Google Gemini": {
-                        "id": "google_gemini",
+                    "Azure OpenAI": {
+                        "id": "azure",
+                        "provider": "azure",
+                        "type": "openai_chat_completion",
+                        "provider_type": "chat_completion",
+                        "enable": True,
+                        "api_version": "2024-05-01-preview",
+                        "key": [],
+                        "api_base": "",
+                        "timeout": 120,
+                        "model_config": {"model": "gpt-4o-mini", "temperature": 0.4},
+                        "custom_headers": {},
+                        "custom_extra_body": {},
+                        "modalities": ["text", "image", "tool_use"],
+                    },
+                    "xAI": {
+                        "id": "xai",
+                        "provider": "xai",
+                        "type": "openai_chat_completion",
+                        "provider_type": "chat_completion",
+                        "enable": True,
+                        "key": [],
+                        "api_base": "https://api.x.ai/v1",
+                        "timeout": 120,
+                        "model_config": {"model": "grok-2-latest", "temperature": 0.4},
+                        "custom_headers": {},
+                        "custom_extra_body": {},
+                        "xai_native_search": False,
+                        "modalities": ["text", "image", "tool_use"],
+                    },
+                    "Anthropic": {
+                        "hint": "注意Claude系列模型的温度调节范围为0到1.0，超出可能导致报错",
+                        "id": "claude",
+                        "provider": "anthropic",
+                        "type": "anthropic_chat_completion",
+                        "provider_type": "chat_completion",
+                        "enable": True,
+                        "key": [],
+                        "api_base": "https://api.anthropic.com/v1",
+                        "timeout": 120,
+                        "model_config": {
+                            "model": "claude-3-5-sonnet-latest",
+                            "max_tokens": 4096,
+                            "temperature": 0.2,
+                        },
+                        "modalities": ["text", "image", "tool_use"],
+                    },
+                    "Ollama": {
+                        "hint": "启用前请确保已正确安装并运行 Ollama 服务端，Ollama默认不带鉴权，无需修改key",
+                        "id": "ollama_default",
+                        "provider": "ollama",
+                        "type": "openai_chat_completion",
+                        "provider_type": "chat_completion",
+                        "enable": True,
+                        "key": ["ollama"],  # ollama 的 key 默认是 ollama
+                        "api_base": "http://localhost:11434/v1",
+                        "model_config": {"model": "llama3.1-8b", "temperature": 0.4},
+                        "custom_headers": {},
+                        "custom_extra_body": {},
+                        "modalities": ["text", "image", "tool_use"],
+                    },
+                    "LM Studio": {
+                        "id": "lm_studio",
+                        "provider": "lm_studio",
+                        "type": "openai_chat_completion",
+                        "provider_type": "chat_completion",
+                        "enable": True,
+                        "key": ["lmstudio"],
+                        "api_base": "http://localhost:1234/v1",
+                        "model_config": {
+                            "model": "llama-3.1-8b",
+                        },
+                        "custom_headers": {},
+                        "custom_extra_body": {},
+                        "modalities": ["text", "image", "tool_use"],
+                    },
+                    "Gemini(OpenAI兼容)": {
+                        "id": "gemini_default",
+                        "provider": "google",
+                        "type": "openai_chat_completion",
+                        "provider_type": "chat_completion",
+                        "enable": True,
+                        "key": [],
+                        "api_base": "https://generativelanguage.googleapis.com/v1beta/openai/",
+                        "timeout": 120,
+                        "model_config": {
+                            "model": "gemini-3-flash-preview",
+                            "temperature": 0.4,
+                        },
+                        "custom_headers": {},
+                        "custom_extra_body": {},
+                        "modalities": ["text", "image", "tool_use"],
+                    },
+                    "Gemini": {
+                        "id": "gemini_default",
                         "provider": "google",
                         "type": "googlegenai_chat_completion",
                         "provider_type": "chat_completion",
@@ -884,6 +962,10 @@ CONFIG_METADATA_2 = {
                         "key": [],
                         "api_base": "https://generativelanguage.googleapis.com/",
                         "timeout": 120,
+                        "model_config": {
+                            "model": "gemini-3-flash-preview",
+                            "temperature": 0.4,
+                        },
                         "gm_resp_image_modal": False,
                         "gm_native_search": False,
                         "gm_native_coderunner": False,
@@ -895,43 +977,10 @@ CONFIG_METADATA_2 = {
                             "dangerous_content": "BLOCK_MEDIUM_AND_ABOVE",
                         },
                         "gm_thinking_config": {"budget": 0, "level": "HIGH"},
-                    },
-                    "Anthropic": {
-                        "id": "anthropic",
-                        "provider": "anthropic",
-                        "type": "anthropic_chat_completion",
-                        "provider_type": "chat_completion",
-                        "enable": True,
-                        "key": [],
-                        "api_base": "https://api.anthropic.com/v1",
-                        "timeout": 120,
-                        "anth_thinking_config": {"budget": 0},
-                    },
-                    "Moonshot": {
-                        "id": "moonshot",
-                        "provider": "moonshot",
-                        "type": "openai_chat_completion",
-                        "provider_type": "chat_completion",
-                        "enable": True,
-                        "key": [],
-                        "timeout": 120,
-                        "api_base": "https://api.moonshot.cn/v1",
-                        "custom_headers": {},
-                    },
-                    "xAI": {
-                        "id": "xai",
-                        "provider": "xai",
-                        "type": "xai_chat_completion",
-                        "provider_type": "chat_completion",
-                        "enable": True,
-                        "key": [],
-                        "api_base": "https://api.x.ai/v1",
-                        "timeout": 120,
-                        "custom_headers": {},
-                        "xai_native_search": False,
+                        "modalities": ["text", "image", "tool_use"],
                     },
                     "DeepSeek": {
-                        "id": "deepseek",
+                        "id": "deepseek_default",
                         "provider": "deepseek",
                         "type": "openai_chat_completion",
                         "provider_type": "chat_completion",
@@ -939,75 +988,13 @@ CONFIG_METADATA_2 = {
                         "key": [],
                         "api_base": "https://api.deepseek.com/v1",
                         "timeout": 120,
+                        "model_config": {"model": "deepseek-chat", "temperature": 0.4},
                         "custom_headers": {},
-                    },
-                    "Zhipu": {
-                        "id": "zhipu",
-                        "provider": "zhipu",
-                        "type": "zhipu_chat_completion",
-                        "provider_type": "chat_completion",
-                        "enable": True,
-                        "key": [],
-                        "timeout": 120,
-                        "api_base": "https://open.bigmodel.cn/api/paas/v4/",
-                        "custom_headers": {},
-                    },
-                    "Azure OpenAI": {
-                        "id": "azure_openai",
-                        "provider": "azure",
-                        "type": "openai_chat_completion",
-                        "provider_type": "chat_completion",
-                        "enable": True,
-                        "api_version": "2024-05-01-preview",
-                        "key": [],
-                        "api_base": "",
-                        "timeout": 120,
-                        "custom_headers": {},
-                    },
-                    "Ollama": {
-                        "id": "ollama",
-                        "provider": "ollama",
-                        "type": "openai_chat_completion",
-                        "provider_type": "chat_completion",
-                        "enable": True,
-                        "key": ["ollama"],  # ollama 的 key 默认是 ollama
-                        "api_base": "http://127.0.0.1:11434/v1",
-                        "custom_headers": {},
-                    },
-                    "LM Studio": {
-                        "id": "lm_studio",
-                        "provider": "lm_studio",
-                        "type": "openai_chat_completion",
-                        "provider_type": "chat_completion",
-                        "enable": True,
-                        "key": ["lmstudio"],
-                        "api_base": "http://127.0.0.1:1234/v1",
-                        "custom_headers": {},
-                    },
-                    "ModelStack": {
-                        "id": "modelstack",
-                        "provider": "modelstack",
-                        "type": "openai_chat_completion",
-                        "provider_type": "chat_completion",
-                        "enable": True,
-                        "key": [],
-                        "api_base": "https://modelstack.app/v1",
-                        "timeout": 120,
-                        "custom_headers": {},
-                    },
-                    "Gemini_OpenAI_API": {
-                        "id": "google_gemini_openai",
-                        "provider": "google",
-                        "type": "openai_chat_completion",
-                        "provider_type": "chat_completion",
-                        "enable": True,
-                        "key": [],
-                        "api_base": "https://generativelanguage.googleapis.com/v1beta/openai/",
-                        "timeout": 120,
-                        "custom_headers": {},
+                        "custom_extra_body": {},
+                        "modalities": ["text", "tool_use"],
                     },
                     "Groq": {
-                        "id": "groq",
+                        "id": "groq_default",
                         "provider": "groq",
                         "type": "groq_chat_completion",
                         "provider_type": "chat_completion",
@@ -1015,7 +1002,13 @@ CONFIG_METADATA_2 = {
                         "key": [],
                         "api_base": "https://api.groq.com/openai/v1",
                         "timeout": 120,
+                        "model_config": {
+                            "model": "openai/gpt-oss-20b",
+                            "temperature": 0.4,
+                        },
                         "custom_headers": {},
+                        "custom_extra_body": {},
+                        "modalities": ["text", "tool_use"],
                     },
                     "302.AI": {
                         "id": "302ai",
@@ -1026,9 +1019,12 @@ CONFIG_METADATA_2 = {
                         "key": [],
                         "api_base": "https://api.302.ai/v1",
                         "timeout": 120,
+                        "model_config": {"model": "gpt-4.1-mini", "temperature": 0.4},
                         "custom_headers": {},
+                        "custom_extra_body": {},
+                        "modalities": ["text", "image", "tool_use"],
                     },
-                    "SiliconFlow": {
+                    "硅基流动": {
                         "id": "siliconflow",
                         "provider": "siliconflow",
                         "type": "openai_chat_completion",
@@ -1037,9 +1033,15 @@ CONFIG_METADATA_2 = {
                         "key": [],
                         "timeout": 120,
                         "api_base": "https://api.siliconflow.cn/v1",
+                        "model_config": {
+                            "model": "deepseek-ai/DeepSeek-V3",
+                            "temperature": 0.4,
+                        },
                         "custom_headers": {},
+                        "custom_extra_body": {},
+                        "modalities": ["text", "image", "tool_use"],
                     },
-                    "PPIO": {
+                    "PPIO派欧云": {
                         "id": "ppio",
                         "provider": "ppio",
                         "type": "openai_chat_completion",
@@ -1048,9 +1050,14 @@ CONFIG_METADATA_2 = {
                         "key": [],
                         "api_base": "https://api.ppinfra.com/v3/openai",
                         "timeout": 120,
+                        "model_config": {
+                            "model": "deepseek/deepseek-r1",
+                            "temperature": 0.4,
+                        },
                         "custom_headers": {},
+                        "custom_extra_body": {},
                     },
-                    "TokenPony": {
+                    "小马算力": {
                         "id": "tokenpony",
                         "provider": "tokenpony",
                         "type": "openai_chat_completion",
@@ -1059,9 +1066,14 @@ CONFIG_METADATA_2 = {
                         "key": [],
                         "api_base": "https://api.tokenpony.cn/v1",
                         "timeout": 120,
+                        "model_config": {
+                            "model": "kimi-k2-instruct-0905",
+                            "temperature": 0.7,
+                        },
                         "custom_headers": {},
+                        "custom_extra_body": {},
                     },
-                    "Compshare": {
+                    "优云智算": {
                         "id": "compshare",
                         "provider": "compshare",
                         "type": "openai_chat_completion",
@@ -1070,18 +1082,42 @@ CONFIG_METADATA_2 = {
                         "key": [],
                         "api_base": "https://api.modelverse.cn/v1",
                         "timeout": 120,
+                        "model_config": {
+                            "model": "moonshotai/Kimi-K2-Instruct",
+                        },
                         "custom_headers": {},
+                        "custom_extra_body": {},
+                        "modalities": ["text", "image", "tool_use"],
                     },
-                    "ModelScope": {
-                        "id": "modelscope",
-                        "provider": "modelscope",
+                    "Kimi": {
+                        "id": "moonshot",
+                        "provider": "moonshot",
                         "type": "openai_chat_completion",
                         "provider_type": "chat_completion",
                         "enable": True,
                         "key": [],
                         "timeout": 120,
-                        "api_base": "https://api-inference.modelscope.cn/v1",
+                        "api_base": "https://api.moonshot.cn/v1",
+                        "model_config": {"model": "moonshot-v1-8k", "temperature": 0.4},
                         "custom_headers": {},
+                        "custom_extra_body": {},
+                        "modalities": ["text", "image", "tool_use"],
+                    },
+                    "智谱 AI": {
+                        "id": "zhipu_default",
+                        "provider": "zhipu",
+                        "type": "zhipu_chat_completion",
+                        "provider_type": "chat_completion",
+                        "enable": True,
+                        "key": [],
+                        "timeout": 120,
+                        "api_base": "https://open.bigmodel.cn/api/paas/v4/",
+                        "model_config": {
+                            "model": "glm-4-flash",
+                        },
+                        "custom_headers": {},
+                        "custom_extra_body": {},
+                        "modalities": ["text", "image", "tool_use"],
                     },
                     "Dify": {
                         "id": "dify_app_default",
@@ -1096,6 +1132,7 @@ CONFIG_METADATA_2 = {
                         "dify_query_input_key": "astrbot_text_query",
                         "variables": {},
                         "timeout": 60,
+                        "hint": "请确保你在 AstrBot 里设置的 APP 类型和 Dify 里面创建的应用的类型一致！",
                     },
                     "Coze": {
                         "id": "coze",
@@ -1126,6 +1163,20 @@ CONFIG_METADATA_2 = {
                         "variables": {},
                         "timeout": 60,
                     },
+                    "ModelScope": {
+                        "id": "modelscope",
+                        "provider": "modelscope",
+                        "type": "openai_chat_completion",
+                        "provider_type": "chat_completion",
+                        "enable": True,
+                        "key": [],
+                        "timeout": 120,
+                        "api_base": "https://api-inference.modelscope.cn/v1",
+                        "model_config": {"model": "Qwen/Qwen3-32B", "temperature": 0.4},
+                        "custom_headers": {},
+                        "custom_extra_body": {},
+                        "modalities": ["text", "image", "tool_use"],
+                    },
                     "FastGPT": {
                         "id": "fastgpt",
                         "provider": "fastgpt",
@@ -1149,6 +1200,7 @@ CONFIG_METADATA_2 = {
                         "model": "whisper-1",
                     },
                     "Whisper(Local)": {
+                        "hint": "启用前请 pip 安装 openai-whisper 库（N卡用户大约下载 2GB，主要是 torch 和 cuda，CPU 用户大约下载 1 GB），并且安装 ffmpeg。否则将无法正常转文字。",
                         "provider": "openai",
                         "type": "openai_whisper_selfhost",
                         "provider_type": "speech_to_text",
@@ -1157,6 +1209,7 @@ CONFIG_METADATA_2 = {
                         "model": "tiny",
                     },
                     "SenseVoice(Local)": {
+                        "hint": "启用前请 pip 安装 funasr、funasr_onnx、torchaudio、torch、modelscope、jieba 库（默认使用CPU，大约下载 1 GB），并且安装 ffmpeg。否则将无法正常转文字。",
                         "type": "sensevoice_stt_selfhost",
                         "provider": "sensevoice",
                         "provider_type": "speech_to_text",
@@ -1178,6 +1231,7 @@ CONFIG_METADATA_2 = {
                         "timeout": "20",
                     },
                     "Edge TTS": {
+                        "hint": "提示：使用这个服务前需要安装有 ffmpeg，并且可以直接在终端调用 ffmpeg 指令。",
                         "id": "edge_tts",
                         "provider": "microsoft",
                         "type": "edge_tts",
@@ -1287,7 +1341,7 @@ CONFIG_METADATA_2 = {
                         "minimax-is-timber-weight": False,
                         "minimax-voice-id": "female-shaonv",
                         "minimax-timber-weight": '[\n    {\n        "voice_id": "Chinese (Mandarin)_Warm_Girl",\n        "weight": 25\n    },\n    {\n        "voice_id": "Chinese (Mandarin)_BashfulGirl",\n        "weight": 50\n    }\n]',
-                        "minimax-voice-emotion": "auto",
+                        "minimax-voice-emotion": "neutral",
                         "minimax-voice-latex": False,
                         "minimax-voice-english-normalization": False,
                         "timeout": 20,
@@ -1393,10 +1447,6 @@ CONFIG_METADATA_2 = {
                     },
                 },
                 "items": {
-                    "provider_source_id": {
-                        "invisible": True,
-                        "type": "string",
-                    },
                     "xai_native_search": {
                         "description": "启用原生搜索功能",
                         "type": "bool",
@@ -1788,17 +1838,6 @@ CONFIG_METADATA_2 = {
                             },
                         },
                     },
-                    "anth_thinking_config": {
-                        "description": "Thinking Config",
-                        "type": "object",
-                        "items": {
-                            "budget": {
-                                "description": "Thinking Budget",
-                                "type": "int",
-                                "hint": "Anthropic thinking.budget_tokens param. Must >= 1024. See: https://platform.claude.com/docs/en/build-with-claude/extended-thinking",
-                            },
-                        },
-                    },
                     "minimax-group-id": {
                         "type": "string",
                         "description": "用户组",
@@ -1870,18 +1909,15 @@ CONFIG_METADATA_2 = {
                     "minimax-voice-emotion": {
                         "type": "string",
                         "description": "情绪",
-                        "hint": "控制合成语音的情绪。当为 auto 时，将根据文本内容自动选择情绪。",
+                        "hint": "控制合成语音的情绪",
                         "options": [
-                            "auto",
                             "happy",
                             "sad",
                             "angry",
                             "fearful",
                             "disgusted",
                             "surprised",
-                            "calm",
-                            "fluent",
-                            "whisper",
+                            "neutral",
                         ],
                     },
                     "minimax-voice-latex": {
@@ -1979,6 +2015,7 @@ CONFIG_METADATA_2 = {
                     "id": {
                         "description": "ID",
                         "type": "string",
+                        "hint": "模型提供商名字。",
                     },
                     "type": {
                         "description": "模型提供商种类",
@@ -1998,15 +2035,29 @@ CONFIG_METADATA_2 = {
                         "description": "API Key",
                         "type": "list",
                         "items": {"type": "string"},
+                        "hint": "提供商 API Key。",
                     },
                     "api_base": {
                         "description": "API Base URL",
                         "type": "string",
+                        "hint": "API Base URL 请在模型提供商处获得。如出现 404 报错，尝试在地址末尾加上 /v1",
                     },
-                    "model": {
-                        "description": "模型 ID",
-                        "type": "string",
-                        "hint": "模型名称，如 gpt-4o-mini, deepseek-chat。",
+                    "model_config": {
+                        "description": "模型配置",
+                        "type": "object",
+                        "items": {
+                            "model": {
+                                "description": "模型名称",
+                                "type": "string",
+                                "hint": "模型名称，如 gpt-4o-mini, deepseek-chat。",
+                            },
+                            "max_tokens": {
+                                "description": "模型最大输出长度（tokens）",
+                                "type": "int",
+                            },
+                            "temperature": {"description": "温度", "type": "float"},
+                            "top_p": {"description": "Top P值", "type": "float"},
+                        },
                     },
                     "dify_api_key": {
                         "description": "API Key",
@@ -3064,5 +3115,4 @@ DEFAULT_VALUE_MAP = {
     "text": "",
     "list": [],
     "object": {},
-    "template_list": [],
 }

astrbot/core/core_lifecycle.py

@@ -33,7 +33,6 @@ from astrbot.core.star.context import Context
 from astrbot.core.star.star_handler import EventType, star_handlers_registry, star_map
 from astrbot.core.umop_config_router import UmopConfigRouter
 from astrbot.core.updator import AstrBotUpdator
-from astrbot.core.utils.llm_metadata import update_llm_metadata
 from astrbot.core.utils.migra_helper import migra
 
 from . import astrbot_config, html_renderer
@@ -186,8 +185,6 @@ class AstrBotCoreLifecycle:
         # 初始化关闭控制面板的事件
         self.dashboard_shutdown_event = asyncio.Event()
 
-        asyncio.create_task(update_llm_metadata())
-
     def _load(self) -> None:
         """加载事件总线和任务并初始化."""
         # 创建一个异步任务来执行事件总线的 dispatch() 方法

astrbot/core/log.py

@@ -58,7 +58,7 @@ def is_plugin_path(pathname):
         return False
 
     norm_path = os.path.normpath(pathname)
-    return ("data/plugins" in norm_path) or ("astrbot/builtin_stars/" in norm_path)
+    return ("data/plugins" in norm_path) or ("packages/" in norm_path)
 
 
 def get_short_level_name(level_name):

astrbot/core/pipeline/process_stage/method/agent_sub_stages/internal.py

@@ -6,7 +6,6 @@ import json
 from collections.abc import AsyncGenerator
 
 from astrbot.core import logger
-from astrbot.core.agent.message import Message
 from astrbot.core.agent.tool import ToolSet
 from astrbot.core.astr_agent_context import AstrAgentContext
 from astrbot.core.conversation_mgr import Conversation
@@ -295,7 +294,6 @@ class InternalAgentSubStage(Stage):
         event: AstrMessageEvent,
         req: ProviderRequest,
         llm_response: LLMResponse | None,
-        all_messages: list[Message],
     ):
         if (
             not req
@@ -309,23 +307,26 @@ class InternalAgentSubStage(Stage):
             logger.debug("LLM 响应为空，不保存记录。")
             return
 
-        # using agent context messages to save to history
-        message_to_save = []
-        for message in all_messages:
-            if message.role == "system":
-                # we do not save system messages to history
-                continue
-            if message.role in ["assistant", "user"] and getattr(
-                message, "_no_save", None
-            ):
-                # we do not save user and assistant messages that are marked as _no_save
-                continue
-            message_to_save.append(message.model_dump())
+        if req.contexts is None:
+            req.contexts = []
 
+        # 历史上下文
+        messages = copy.deepcopy(req.contexts)
+        # 这一轮对话请求的用户输入
+        messages.append(await req.assemble_context())
+        # 这一轮对话的 LLM 响应
+        if req.tool_calls_result:
+            if not isinstance(req.tool_calls_result, list):
+                messages.extend(req.tool_calls_result.to_openai_messages())
+            elif isinstance(req.tool_calls_result, list):
+                for tcr in req.tool_calls_result:
+                    messages.extend(tcr.to_openai_messages())
+        messages.append({"role": "assistant", "content": llm_response.completion_text})
+        messages = list(filter(lambda item: "_no_save" not in item, messages))
         await self.conv_manager.update_conversation(
             event.unified_msg_origin,
             req.conversation.cid,
-            history=message_to_save,
+            history=messages,
         )
 
     def _fix_messages(self, messages: list[dict]) -> list[dict]:
@@ -349,190 +350,174 @@ class InternalAgentSubStage(Stage):
     ) -> AsyncGenerator[None, None]:
         req: ProviderRequest | None = None
 
-        try:
-            provider = self._select_provider(event)
-            if provider is None:
-                return
-            if not isinstance(provider, Provider):
-                logger.error(
-                    f"选择的提供商类型无效({type(provider)})，跳过 LLM 请求处理。"
+        provider = self._select_provider(event)
+        if provider is None:
+            return
+        if not isinstance(provider, Provider):
+            logger.error(f"选择的提供商类型无效({type(provider)})，跳过 LLM 请求处理。")
+            return
+
+        streaming_response = self.streaming_response
+        if (enable_streaming := event.get_extra("enable_streaming")) is not None:
+            streaming_response = bool(enable_streaming)
+
+        logger.debug("ready to request llm provider")
+        async with session_lock_manager.acquire_lock(event.unified_msg_origin):
+            logger.debug("acquired session lock for llm request")
+            if event.get_extra("provider_request"):
+                req = event.get_extra("provider_request")
+                assert isinstance(req, ProviderRequest), (
+                    "provider_request 必须是 ProviderRequest 类型。"
                 )
-                return
 
-            streaming_response = self.streaming_response
-            if (enable_streaming := event.get_extra("enable_streaming")) is not None:
-                streaming_response = bool(enable_streaming)
+                if req.conversation:
+                    req.contexts = json.loads(req.conversation.history)
 
-            logger.debug("ready to request llm provider")
-            async with session_lock_manager.acquire_lock(event.unified_msg_origin):
-                logger.debug("acquired session lock for llm request")
-                if event.get_extra("provider_request"):
-                    req = event.get_extra("provider_request")
-                    assert isinstance(req, ProviderRequest), (
-                        "provider_request 必须是 ProviderRequest 类型。"
-                    )
-
-                    if req.conversation:
-                        req.contexts = json.loads(req.conversation.history)
-
-                else:
-                    req = ProviderRequest()
-                    req.prompt = ""
-                    req.image_urls = []
-                    if sel_model := event.get_extra("selected_model"):
-                        req.model = sel_model
-                    if provider_wake_prefix and not event.message_str.startswith(
-                        provider_wake_prefix
-                    ):
-                        return
-
-                    req.prompt = event.message_str[len(provider_wake_prefix) :]
-                    # func_tool selection 现在已经转移到 astrbot/builtin_stars/astrbot 插件中进行选择。
-                    # req.func_tool = self.ctx.plugin_manager.context.get_llm_tool_manager()
-                    for comp in event.message_obj.message:
-                        if isinstance(comp, Image):
-                            image_path = await comp.convert_to_file_path()
-                            req.image_urls.append(image_path)
-
-                    conversation = await self._get_session_conv(event)
-                    req.conversation = conversation
-                    req.contexts = json.loads(conversation.history)
-
-                    event.set_extra("provider_request", req)
-
-                # fix contexts json str
-                if isinstance(req.contexts, str):
-                    req.contexts = json.loads(req.contexts)
-
-                # apply file extract
-                if self.file_extract_enabled:
-                    try:
-                        await self._apply_file_extract(event, req)
-                    except Exception as e:
-                        logger.error(f"Error occurred while applying file extract: {e}")
-
-                if not req.prompt and not req.image_urls:
+            else:
+                req = ProviderRequest()
+                req.prompt = ""
+                req.image_urls = []
+                if sel_model := event.get_extra("selected_model"):
+                    req.model = sel_model
+                if provider_wake_prefix and not event.message_str.startswith(
+                    provider_wake_prefix
+                ):
                     return
 
-                # call event hook
-                if await call_event_hook(event, EventType.OnLLMRequestEvent, req):
-                    return
+                req.prompt = event.message_str[len(provider_wake_prefix) :]
+                # func_tool selection 现在已经转移到 packages/astrbot 插件中进行选择。
+                # req.func_tool = self.ctx.plugin_manager.context.get_llm_tool_manager()
+                for comp in event.message_obj.message:
+                    if isinstance(comp, Image):
+                        image_path = await comp.convert_to_file_path()
+                        req.image_urls.append(image_path)
 
-                # apply knowledge base feature
-                await self._apply_kb(event, req)
+                conversation = await self._get_session_conv(event)
+                req.conversation = conversation
+                req.contexts = json.loads(conversation.history)
 
-                # truncate contexts to fit max length
-                if req.contexts:
-                    req.contexts = self._truncate_contexts(req.contexts)
-                    self._fix_messages(req.contexts)
+                event.set_extra("provider_request", req)
 
-                # session_id
-                if not req.session_id:
-                    req.session_id = event.unified_msg_origin
+            # fix contexts json str
+            if isinstance(req.contexts, str):
+                req.contexts = json.loads(req.contexts)
 
-                # check provider modalities, if provider does not support image/tool_use, clear them in request.
-                self._modalities_fix(provider, req)
+            # apply file extract
+            if self.file_extract_enabled:
+                try:
+                    await self._apply_file_extract(event, req)
+                except Exception as e:
+                    logger.error(f"Error occurred while applying file extract: {e}")
 
-                # filter tools, only keep tools from this pipeline's selected plugins
-                self._plugin_tool_fix(event, req)
+            if not req.prompt and not req.image_urls:
+                return
 
-                stream_to_general = (
-                    self.unsupported_streaming_strategy == "turn_off"
-                    and not event.platform_meta.support_streaming_message
-                )
-                # 备份 req.contexts
-                backup_contexts = copy.deepcopy(req.contexts)
+            # call event hook
+            if await call_event_hook(event, EventType.OnLLMRequestEvent, req):
+                return
 
-                # run agent
-                agent_runner = AgentRunner()
-                logger.debug(
-                    f"handle provider[id: {provider.provider_config['id']}] request: {req}",
-                )
-                astr_agent_ctx = AstrAgentContext(
-                    context=self.ctx.plugin_manager.context,
-                    event=event,
-                )
-                await agent_runner.reset(
-                    provider=provider,
-                    request=req,
-                    run_context=AgentContextWrapper(
-                        context=astr_agent_ctx,
-                        tool_call_timeout=self.tool_call_timeout,
-                    ),
-                    tool_executor=FunctionToolExecutor(),
-                    agent_hooks=MAIN_AGENT_HOOKS,
-                    streaming=streaming_response,
-                )
+            # apply knowledge base feature
+            await self._apply_kb(event, req)
 
-                if streaming_response and not stream_to_general:
-                    # 流式响应
-                    event.set_result(
-                        MessageEventResult()
-                        .set_result_content_type(ResultContentType.STREAMING_RESULT)
-                        .set_async_stream(
-                            run_agent(
-                                agent_runner,
-                                self.max_step,
-                                self.show_tool_use,
-                                show_reasoning=self.show_reasoning,
-                            ),
-                        ),
-                    )
-                    yield
-                    if agent_runner.done():
-                        if final_llm_resp := agent_runner.get_final_llm_resp():
-                            if final_llm_resp.completion_text:
-                                chain = (
-                                    MessageChain()
-                                    .message(final_llm_resp.completion_text)
-                                    .chain
-                                )
-                            elif final_llm_resp.result_chain:
-                                chain = final_llm_resp.result_chain.chain
-                            else:
-                                chain = MessageChain().chain
-                            event.set_result(
-                                MessageEventResult(
-                                    chain=chain,
-                                    result_content_type=ResultContentType.STREAMING_FINISH,
-                                ),
-                            )
-                else:
-                    async for _ in run_agent(
-                        agent_runner,
-                        self.max_step,
-                        self.show_tool_use,
-                        stream_to_general,
-                        show_reasoning=self.show_reasoning,
-                    ):
-                        yield
+            # truncate contexts to fit max length
+            if req.contexts:
+                req.contexts = self._truncate_contexts(req.contexts)
+                self._fix_messages(req.contexts)
 
-                # 恢复备份的 contexts
-                req.contexts = backup_contexts
+            # session_id
+            if not req.session_id:
+                req.session_id = event.unified_msg_origin
 
-                await self._save_to_history(
-                    event,
-                    req,
-                    agent_runner.get_final_llm_resp(),
-                    agent_runner.run_context.messages,
-                )
+            # check provider modalities, if provider does not support image/tool_use, clear them in request.
+            self._modalities_fix(provider, req)
 
-            # 异步处理 WebChat 特殊情况
-            if event.get_platform_name() == "webchat":
-                asyncio.create_task(self._handle_webchat(event, req, provider))
+            # filter tools, only keep tools from this pipeline's selected plugins
+            self._plugin_tool_fix(event, req)
 
-            asyncio.create_task(
-                Metric.upload(
-                    llm_tick=1,
-                    model_name=agent_runner.provider.get_model(),
-                    provider_type=agent_runner.provider.meta().type,
+            stream_to_general = (
+                self.unsupported_streaming_strategy == "turn_off"
+                and not event.platform_meta.support_streaming_message
+            )
+            # 备份 req.contexts
+            backup_contexts = copy.deepcopy(req.contexts)
+
+            # run agent
+            agent_runner = AgentRunner()
+            logger.debug(
+                f"handle provider[id: {provider.provider_config['id']}] request: {req}",
+            )
+            astr_agent_ctx = AstrAgentContext(
+                context=self.ctx.plugin_manager.context,
+                event=event,
+            )
+            await agent_runner.reset(
+                provider=provider,
+                request=req,
+                run_context=AgentContextWrapper(
+                    context=astr_agent_ctx,
+                    tool_call_timeout=self.tool_call_timeout,
                 ),
+                tool_executor=FunctionToolExecutor(),
+                agent_hooks=MAIN_AGENT_HOOKS,
+                streaming=streaming_response,
             )
 
-        except Exception as e:
-            logger.error(f"Error occurred while processing agent: {e}")
-            await event.send(
-                MessageChain().message(
-                    f"Error occurred while processing agent request: {e}"
+            if streaming_response and not stream_to_general:
+                # 流式响应
+                event.set_result(
+                    MessageEventResult()
+                    .set_result_content_type(ResultContentType.STREAMING_RESULT)
+                    .set_async_stream(
+                        run_agent(
+                            agent_runner,
+                            self.max_step,
+                            self.show_tool_use,
+                            show_reasoning=self.show_reasoning,
+                        ),
+                    ),
                 )
-            )
+                yield
+                if agent_runner.done():
+                    if final_llm_resp := agent_runner.get_final_llm_resp():
+                        if final_llm_resp.completion_text:
+                            chain = (
+                                MessageChain()
+                                .message(final_llm_resp.completion_text)
+                                .chain
+                            )
+                        elif final_llm_resp.result_chain:
+                            chain = final_llm_resp.result_chain.chain
+                        else:
+                            chain = MessageChain().chain
+                        event.set_result(
+                            MessageEventResult(
+                                chain=chain,
+                                result_content_type=ResultContentType.STREAMING_FINISH,
+                            ),
+                        )
+            else:
+                async for _ in run_agent(
+                    agent_runner,
+                    self.max_step,
+                    self.show_tool_use,
+                    stream_to_general,
+                    show_reasoning=self.show_reasoning,
+                ):
+                    yield
+
+            # 恢复备份的 contexts
+            req.contexts = backup_contexts
+
+            await self._save_to_history(event, req, agent_runner.get_final_llm_resp())
+
+        # 异步处理 WebChat 特殊情况
+        if event.get_platform_name() == "webchat":
+            asyncio.create_task(self._handle_webchat(event, req, provider))
+
+        asyncio.create_task(
+            Metric.upload(
+                llm_tick=1,
+                model_name=agent_runner.provider.get_model(),
+                provider_type=agent_runner.provider.meta().type,
+            ),
+        )

astrbot/core/pipeline/result_decorate/stage.py

@@ -98,9 +98,6 @@ class ResultDecorateStage(Stage):
                     self.content_safe_check_stage = stage_cls()
                     await self.content_safe_check_stage.initialize(ctx)
 
-        provider_cfg = ctx.astrbot_config.get("provider_settings", {})
-        self.show_reasoning = provider_cfg.get("display_reasoning_text", False)
-
     def _split_text_by_words(self, text: str) -> list[str]:
         """使用分段词列表分段文本"""
         if not self.split_words_pattern:
@@ -257,75 +254,70 @@ class ResultDecorateStage(Stage):
                 event.unified_msg_origin,
             )
 
-            should_tts = (
-                bool(self.ctx.astrbot_config["provider_tts_settings"]["enable"])
+            if (
+                self.ctx.astrbot_config["provider_tts_settings"]["enable"]
                 and result.is_llm_result()
                 and SessionServiceManager.should_process_tts_request(event)
-                and random.random() <= self.tts_trigger_probability
-                and tts_provider
-            )
-            if should_tts and not tts_provider:
-                logger.warning(
-                    f"会话 {event.unified_msg_origin} 未配置文本转语音模型。",
+            ):
+                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
-                and self.show_reasoning
-                and event.get_extra("_llm_reasoning_content")
-            ):
-                # inject reasoning content to chain
-                reasoning_content = event.get_extra("_llm_reasoning_content")
-                result.chain.insert(0, Plain(f"🤔 思考: {reasoning_content}\n"))
+                if not should_tts:
+                    logger.debug("跳过 TTS：触发概率未命中。")
+                elif not tts_provider:
+                    logger.warning(
+                        f"会话 {event.unified_msg_origin} 未配置文本转语音模型。",
+                    )
+                else:
+                    new_chain = []
+                    for comp in result.chain:
+                        if isinstance(comp, Plain) and len(comp.text) > 1:
+                            try:
+                                logger.info(f"TTS 请求: {comp.text}")
+                                audio_path = await tts_provider.get_audio(comp.text)
+                                logger.info(f"TTS 结果: {audio_path}")
+                                if not audio_path:
+                                    logger.error(
+                                        f"由于 TTS 音频文件未找到，消息段转语音失败: {comp.text}",
+                                    )
+                                    new_chain.append(comp)
+                                    continue
 
-            if should_tts and tts_provider:
-                new_chain = []
-                for comp in result.chain:
-                    if isinstance(comp, Plain) and len(comp.text) > 1:
-                        try:
-                            logger.info(f"TTS 请求: {comp.text}")
-                            audio_path = await tts_provider.get_audio(comp.text)
-                            logger.info(f"TTS 结果: {audio_path}")
-                            if not audio_path:
-                                logger.error(
-                                    f"由于 TTS 音频文件未找到，消息段转语音失败: {comp.text}",
+                                use_file_service = self.ctx.astrbot_config[
+                                    "provider_tts_settings"
+                                ]["use_file_service"]
+                                callback_api_base = self.ctx.astrbot_config[
+                                    "callback_api_base"
+                                ]
+                                dual_output = self.ctx.astrbot_config[
+                                    "provider_tts_settings"
+                                ]["dual_output"]
+
+                                url = None
+                                if use_file_service and callback_api_base:
+                                    token = await file_token_service.register_file(
+                                        audio_path,
+                                    )
+                                    url = f"{callback_api_base}/api/file/{token}"
+                                    logger.debug(f"已注册：{url}")
+
+                                new_chain.append(
+                                    Record(
+                                        file=url or audio_path,
+                                        url=url or audio_path,
+                                    ),
                                 )
+                                if dual_output:
+                                    new_chain.append(comp)
+                            except Exception:
+                                logger.error(traceback.format_exc())
+                                logger.error("TTS 失败，使用文本发送。")
                                 new_chain.append(comp)
-                                continue
-
-                            use_file_service = self.ctx.astrbot_config[
-                                "provider_tts_settings"
-                            ]["use_file_service"]
-                            callback_api_base = self.ctx.astrbot_config[
-                                "callback_api_base"
-                            ]
-                            dual_output = self.ctx.astrbot_config[
-                                "provider_tts_settings"
-                            ]["dual_output"]
-
-                            url = None
-                            if use_file_service and callback_api_base:
-                                token = await file_token_service.register_file(
-                                    audio_path,
-                                )
-                                url = f"{callback_api_base}/api/file/{token}"
-                                logger.debug(f"已注册：{url}")
-
-                            new_chain.append(
-                                Record(
-                                    file=url or audio_path,
-                                    url=url or audio_path,
-                                ),
-                            )
-                            if dual_output:
-                                new_chain.append(comp)
-                        except Exception:
-                            logger.error(traceback.format_exc())
-                            logger.error("TTS 失败，使用文本发送。")
+                        else:
                             new_chain.append(comp)
-                    else:
-                        new_chain.append(comp)
-                result.chain = new_chain
+                    result.chain = new_chain
 
             # 文本转图片
             elif (

astrbot/core/pipeline/waking_check/stage.py

@@ -1,10 +1,9 @@
-from collections.abc import AsyncGenerator, Callable
+from collections.abc import AsyncGenerator
 
 from astrbot import logger
 from astrbot.core.message.components import At, AtAll, Reply
 from astrbot.core.message.message_event_result import MessageChain, MessageEventResult
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
-from astrbot.core.platform.message_type import MessageType
 from astrbot.core.star.filter.command_group import CommandGroupFilter
 from astrbot.core.star.filter.permission import PermissionTypeFilter
 from astrbot.core.star.session_plugin_manager import SessionPluginManager
@@ -14,23 +13,6 @@ from astrbot.core.star.star_handler import EventType, star_handlers_registry
 from ..context import PipelineContext
 from ..stage import Stage, register_stage
 
-UNIQUE_SESSION_ID_BUILDERS: dict[str, Callable[[AstrMessageEvent], str | None]] = {
-    "aiocqhttp": lambda e: f"{e.get_sender_id()}_{e.get_group_id()}",
-    "slack": lambda e: f"{e.get_sender_id()}_{e.get_group_id()}",
-    "dingtalk": lambda e: e.get_sender_id(),
-    "qq_official": lambda e: e.get_sender_id(),
-    "qq_official_webhook": lambda e: e.get_sender_id(),
-    "lark": lambda e: f"{e.get_sender_id()}%{e.get_group_id()}",
-    "misskey": lambda e: f"{e.get_session_id()}_{e.get_sender_id()}",
-    "wechatpadpro": lambda e: f"{e.get_group_id()}#{e.get_sender_id()}",
-}
-
-
-def build_unique_session_id(event: AstrMessageEvent) -> str | None:
-    platform = event.get_platform_name()
-    builder = UNIQUE_SESSION_ID_BUILDERS.get(platform)
-    return builder(event) if builder else None
-
 
 @register_stage
 class WakingCheckStage(Stage):
@@ -71,27 +53,18 @@ class WakingCheckStage(Stage):
         self.disable_builtin_commands = self.ctx.astrbot_config.get(
             "disable_builtin_commands", False
         )
-        platform_settings = self.ctx.astrbot_config.get("platform_settings", {})
-        self.unique_session = platform_settings.get("unique_session", False)
 
     async def process(
         self,
         event: AstrMessageEvent,
     ) -> None | AsyncGenerator[None, None]:
-        # apply unique session
-        if self.unique_session and event.message_obj.type == MessageType.GROUP_MESSAGE:
-            sid = build_unique_session_id(event)
-            if sid:
-                event.session_id = sid
-
-        # ignore bot self message
         if (
             self.ignore_bot_self_message
             and event.get_self_id() == event.get_sender_id()
         ):
+            # 忽略机器人自己发送的消息
             event.stop_event()
             return
-
         # 设置 sender 身份
         event.message_str = event.message_str.strip()
         for admin_id in self.ctx.astrbot_config["admins_id"]:
@@ -163,8 +136,7 @@ class WakingCheckStage(Stage):
         ):
             if (
                 self.disable_builtin_commands
-                and handler.handler_module_path
-                == "astrbot.builtin_stars.builtin_commands.main"
+                and handler.handler_module_path == "packages.builtin_commands.main"
             ):
                 logger.debug("skipping builtin command")
                 continue

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

@@ -41,6 +41,7 @@ class AiocqhttpAdapter(Platform):
         super().__init__(platform_config, event_queue)
 
         self.settings = platform_settings
+        self.unique_session = platform_settings["unique_session"]
         self.host = platform_config["ws_reverse_host"]
         self.port = platform_config["ws_reverse_port"]
 
@@ -135,11 +136,14 @@ class AiocqhttpAdapter(Platform):
             abm.group_id = str(event.group_id)
         else:
             abm.type = MessageType.FRIEND_MESSAGE
-        abm.session_id = (
-            str(event.group_id)
-            if abm.type == MessageType.GROUP_MESSAGE
-            else abm.sender.user_id
-        )
+        if self.unique_session and abm.type == MessageType.GROUP_MESSAGE:
+            abm.session_id = str(abm.sender.user_id) + "_" + str(event.group_id)
+        else:
+            abm.session_id = (
+                str(event.group_id)
+                if abm.type == MessageType.GROUP_MESSAGE
+                else abm.sender.user_id
+            )
         abm.message_str = ""
         abm.message = []
         abm.timestamp = int(time.time())
@@ -160,11 +164,16 @@ class AiocqhttpAdapter(Platform):
             abm.type = MessageType.GROUP_MESSAGE
         else:
             abm.type = MessageType.FRIEND_MESSAGE
-        abm.session_id = (
-            str(event.group_id)
-            if abm.type == MessageType.GROUP_MESSAGE
-            else abm.sender.user_id
-        )
+        if self.unique_session and abm.type == MessageType.GROUP_MESSAGE:
+            abm.session_id = (
+                str(abm.sender.user_id) + "_" + str(event.group_id)
+            )  # 也保留群组 id
+        else:
+            abm.session_id = (
+                str(event.group_id)
+                if abm.type == MessageType.GROUP_MESSAGE
+                else abm.sender.user_id
+            )
         abm.message_str = ""
         abm.message = []
         abm.raw_message = event
@@ -201,11 +210,16 @@ class AiocqhttpAdapter(Platform):
             abm.group.group_name = event.get("group_name", "N/A")
         elif event["message_type"] == "private":
             abm.type = MessageType.FRIEND_MESSAGE
-        abm.session_id = (
-            str(event.group_id)
-            if abm.type == MessageType.GROUP_MESSAGE
-            else abm.sender.user_id
-        )
+        if self.unique_session and abm.type == MessageType.GROUP_MESSAGE:
+            abm.session_id = (
+                abm.sender.user_id + "_" + str(event.group_id)
+            )  # 也保留群组 id
+        else:
+            abm.session_id = (
+                str(event.group_id)
+                if abm.type == MessageType.GROUP_MESSAGE
+                else abm.sender.user_id
+            )
 
         abm.message_id = str(event.message_id)
         abm.message = []
@@ -371,25 +385,10 @@ class AiocqhttpAdapter(Platform):
                         logger.error(f"获取 @ 用户信息失败: {e}，此消息段将被忽略。")
 
                 message_str += "".join(at_parts)
-            elif t == "markdown":
-                text = m["data"].get("markdown") or m["data"].get("content", "")
-                abm.message.append(Plain(text=text))
-                message_str += text
             else:
                 for m in m_group:
-                    try:
-                        if t not in ComponentTypes:
-                            logger.warning(
-                                f"不支持的消息段类型，已忽略: {t}, data={m['data']}"
-                            )
-                            continue
-                        a = ComponentTypes[t](**m["data"])
-                        abm.message.append(a)
-                    except Exception as e:
-                        logger.exception(
-                            f"消息段解析失败: type={t}, data={m['data']}. {e}"
-                        )
-                        continue
+                    a = ComponentTypes[t](**m["data"])
+                    abm.message.append(a)
 
         abm.timestamp = int(time.time())
         abm.message_str = message_str

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

@@ -50,6 +50,8 @@ class DingtalkPlatformAdapter(Platform):
     ) -> None:
         super().__init__(platform_config, event_queue)
 
+        self.unique_session = platform_settings["unique_session"]
+
         self.client_id = platform_config["client_id"]
         self.client_secret = platform_config["client_secret"]
 
@@ -127,7 +129,10 @@ class DingtalkPlatformAdapter(Platform):
                     if id := self._id_to_sid(user.dingtalk_id):
                         abm.message.append(At(qq=id))
             abm.group_id = message.conversation_id
-            abm.session_id = abm.group_id
+            if self.unique_session:
+                abm.session_id = abm.sender.user_id
+            else:
+                abm.session_id = abm.group_id
         else:
             abm.session_id = abm.sender.user_id
 

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

@@ -25,20 +25,6 @@ class DingtalkMessageEvent(AstrMessageEvent):
         client: dingtalk_stream.ChatbotHandler,
         message: MessageChain,
     ):
-        icm = cast(dingtalk_stream.ChatbotMessage, self.message_obj.raw_message)
-        ats = []
-        # fixes: #4218
-        # 钉钉 at 机器人需要使用 sender_staff_id 而不是 sender_id
-        for i in message.chain:
-            if isinstance(i, Comp.At):
-                print(i.qq, icm.sender_id, icm.sender_staff_id)
-                if str(i.qq) in str(icm.sender_id or ""):
-                    # 适配器会将开头的 $:LWCP_v1:$ 去掉，因此我们用 in 判断
-                    ats.append(f"@{icm.sender_staff_id}")
-                else:
-                    ats.append(f"@{i.qq}")
-        at_str = " ".join(ats)
-
         for segment in message.chain:
             if isinstance(segment, Comp.Plain):
                 segment.text = segment.text.strip()
@@ -46,7 +32,7 @@ class DingtalkMessageEvent(AstrMessageEvent):
                     None,
                     client.reply_markdown,
                     segment.text,
-                    f"{at_str} {segment.text}".strip(),
+                    segment.text,
                     cast(dingtalk_stream.ChatbotMessage, self.message_obj.raw_message),
                 )
             elif isinstance(segment, Comp.Image):

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

@@ -44,6 +44,8 @@ class LarkPlatformAdapter(Platform):
     ) -> None:
         super().__init__(platform_config, event_queue)
 
+        self.unique_session = platform_settings["unique_session"]
+
         self.appid = platform_config["app_id"]
         self.appsecret = platform_config["app_secret"]
         self.domain = platform_config.get("domain", lark.FEISHU_DOMAIN)
@@ -315,8 +317,14 @@ class LarkPlatformAdapter(Platform):
             user_id=event.event.sender.sender_id.open_id,
             nickname=event.event.sender.sender_id.open_id[:8],
         )
-        if abm.type == MessageType.GROUP_MESSAGE:
-            abm.session_id = abm.group_id
+        # 独立会话
+        if not self.unique_session:
+            if abm.type == MessageType.GROUP_MESSAGE:
+                abm.session_id = abm.group_id
+            else:
+                abm.session_id = abm.sender.user_id
+        elif abm.type == MessageType.GROUP_MESSAGE:
+            abm.session_id = f"{abm.sender.user_id}%{abm.group_id}"  # 也保留群组id
         else:
             abm.session_id = abm.sender.user_id
 

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

@@ -91,6 +91,8 @@ class MisskeyPlatformAdapter(Platform):
         except Exception:
             self.max_download_bytes = None
 
+        self.unique_session = platform_settings["unique_session"]
+
         self.api: MisskeyAPI | None = None
         self._running = False
         self.client_self_id = ""
@@ -639,6 +641,7 @@ class MisskeyPlatformAdapter(Platform):
             sender_info,
             self.client_self_id,
             is_chat=False,
+            unique_session=self.unique_session,
         )
         cache_user_info(
             self._user_cache,
@@ -687,6 +690,7 @@ class MisskeyPlatformAdapter(Platform):
             sender_info,
             self.client_self_id,
             is_chat=True,
+            unique_session=self.unique_session,
         )
         cache_user_info(
             self._user_cache,
@@ -716,6 +720,7 @@ class MisskeyPlatformAdapter(Platform):
             self.client_self_id,
             is_chat=False,
             room_id=room_id,
+            unique_session=self.unique_session,
         )
 
         cache_user_info(

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

@@ -338,6 +338,7 @@ def create_base_message(
     client_self_id: str,
     is_chat: bool = False,
     room_id: str | None = None,
+    unique_session: bool = False,
 ) -> AstrBotMessage:
     """创建基础消息对象"""
     message = AstrBotMessage()
@@ -352,6 +353,8 @@ def create_base_message(
     if room_id:
         session_prefix = "room"
         session_id = f"{session_prefix}%{room_id}"
+        if unique_session:
+            session_id += f"_{sender_info['sender_id']}"
         message.type = MessageType.GROUP_MESSAGE
         message.group_id = room_id
     elif is_chat:

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

@@ -44,8 +44,11 @@ class botClient(Client):
             message,
             MessageType.GROUP_MESSAGE,
         )
-        abm.group_id = cast(str, message.group_openid)
-        abm.session_id = abm.group_id
+        abm.session_id = (
+            abm.sender.user_id
+            if self.platform.unique_session
+            else cast(str, message.group_openid)
+        )
         self._commit(abm)
 
     # 收到频道消息
@@ -54,8 +57,9 @@ class botClient(Client):
             message,
             MessageType.GROUP_MESSAGE,
         )
-        abm.group_id = message.channel_id
-        abm.session_id = abm.group_id
+        abm.session_id = (
+            abm.sender.user_id if self.platform.unique_session else message.channel_id
+        )
         self._commit(abm)
 
     # 收到私聊消息
@@ -100,6 +104,7 @@ class QQOfficialPlatformAdapter(Platform):
 
         self.appid = platform_config["appid"]
         self.secret = platform_config["secret"]
+        self.unique_session: bool = platform_settings["unique_session"]
         qq_group = platform_config["enable_group_c2c"]
         guild_dm = platform_config["enable_guild_direct_message"]
 

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

@@ -35,8 +35,11 @@ class botClient(Client):
             message,
             MessageType.GROUP_MESSAGE,
         )
-        abm.group_id = cast(str, message.group_openid)
-        abm.session_id = abm.group_id
+        abm.session_id = (
+            abm.sender.user_id
+            if self.platform.unique_session
+            else cast(str, message.group_openid)
+        )
         self._commit(abm)
 
     # 收到频道消息
@@ -45,8 +48,9 @@ class botClient(Client):
             message,
             MessageType.GROUP_MESSAGE,
         )
-        abm.group_id = message.channel_id
-        abm.session_id = abm.group_id
+        abm.session_id = (
+            abm.sender.user_id if self.platform.unique_session else message.channel_id
+        )
         self._commit(abm)
 
     # 收到私聊消息
@@ -91,6 +95,7 @@ class QQOfficialWebhookPlatformAdapter(Platform):
 
         self.appid = platform_config["appid"]
         self.secret = platform_config["secret"]
+        self.unique_session = platform_settings["unique_session"]
         self.unified_webhook_mode = platform_config.get("unified_webhook_mode", False)
 
         intents = botpy.Intents(

astrbot/core/platform/sources/satori/satori_adapter.py

@@ -142,12 +142,7 @@ class SatoriPlatformAdapter(Platform):
             raise ValueError(f"WebSocket URL必须以ws://或wss://开头: {self.endpoint}")
 
         try:
-            websocket = await connect(
-                self.endpoint,
-                additional_headers={},
-                max_size=10 * 1024 * 1024,  # 10MB
-            )
-
+            websocket = await connect(self.endpoint, additional_headers={})
             self.ws = websocket
 
             await asyncio.sleep(0.1)

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

@@ -41,6 +41,7 @@ class SlackAdapter(Platform):
     ) -> None:
         super().__init__(platform_config, event_queue)
         self.settings = platform_settings
+        self.unique_session = platform_settings.get("unique_session", False)
 
         self.bot_token = platform_config.get("bot_token")
         self.app_token = platform_config.get("app_token")
@@ -146,10 +147,12 @@ class SlackAdapter(Platform):
             abm.group_id = channel_id
 
         # 设置会话ID
-        if abm.type == MessageType.GROUP_MESSAGE:
-            abm.session_id = abm.group_id
+        if self.unique_session and abm.type == MessageType.GROUP_MESSAGE:
+            abm.session_id = f"{user_id}_{channel_id}"
         else:
-            abm.session_id = user_id
+            abm.session_id = (
+                channel_id if abm.type == MessageType.GROUP_MESSAGE else user_id
+            )
 
         abm.message_id = event.get("client_msg_id", uuid.uuid4().hex)
         abm.timestamp = int(float(event.get("ts", time.time())))

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

@@ -79,6 +79,7 @@ class WebChatAdapter(Platform):
         super().__init__(platform_config, event_queue)
 
         self.settings = platform_settings
+        self.unique_session = platform_settings["unique_session"]
         self.imgs_dir = os.path.join(get_astrbot_data_path(), "webchat", "imgs")
         os.makedirs(self.imgs_dir, exist_ok=True)
 

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

@@ -47,6 +47,7 @@ class WeChatPadProAdapter(Platform):
         self._shutdown_event = None
         self.wxnewpass = None
         self.settings = platform_settings
+        self.unique_session = platform_settings.get("unique_session", False)
 
         self.metadata = PlatformMetadata(
             name="wechatpadpro",
@@ -508,10 +509,11 @@ class WeChatPadProAdapter(Platform):
                 if accurate_nickname:
                     abm.sender.nickname = accurate_nickname
 
-            if abm.type == MessageType.GROUP_MESSAGE:
-                abm.session_id = abm.group_id
+            # 对于群聊，session_id 可以是群聊 ID 或发送者 ID + 群聊 ID (如果 unique_session 为 True)
+            if self.unique_session:
+                abm.session_id = f"{from_user_name}#{abm.sender.user_id}"
             else:
-                abm.session_id = abm.sender.user_id
+                abm.session_id = from_user_name
 
             msg_source = raw_message.get("msg_source", "")
             if self.wxid in msg_source:

astrbot/core/provider/entities.py

@@ -14,7 +14,6 @@ import astrbot.core.message.components as Comp
 from astrbot import logger
 from astrbot.core.agent.message import (
     AssistantMessageSegment,
-    ContentPart,
     ToolCall,
     ToolCallMessageSegment,
 )
@@ -93,8 +92,6 @@ class ProviderRequest:
     """会话 ID"""
     image_urls: list[str] = field(default_factory=list)
     """图片 URL 列表"""
-    extra_user_content_parts: list[ContentPart] = field(default_factory=list)
-    """额外的用户消息内容部分列表，用于在用户消息后添加额外的内容块（如系统提醒、指令等）。支持 dict 或 ContentPart 对象"""
     func_tool: ToolSet | None = None
     """可用的函数工具"""
     contexts: list[dict] = field(default_factory=list)
@@ -169,23 +166,13 @@ class ProviderRequest:
 
     async def assemble_context(self) -> dict:
         """将请求(prompt 和 image_urls)包装成 OpenAI 的消息格式。"""
-        # 构建内容块列表
-        content_blocks = []
-
-        # 1. 用户原始发言（OpenAI 建议：用户发言在前）
-        if self.prompt and self.prompt.strip():
-            content_blocks.append({"type": "text", "text": self.prompt})
-        elif self.image_urls:
-            # 如果没有文本但有图片，添加占位文本
-            content_blocks.append({"type": "text", "text": "[图片]"})
-
-        # 2. 额外的内容块（系统提醒、指令等）
-        if self.extra_user_content_parts:
-            for part in self.extra_user_content_parts:
-                content_blocks.append(part.model_dump())
-
-        # 3. 图片内容
         if self.image_urls:
+            user_content = {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": self.prompt if self.prompt else "[图片]"},
+                ],
+            }
             for image_url in self.image_urls:
                 if image_url.startswith("http"):
                     image_path = await download_image_by_url(image_url)
@@ -198,21 +185,11 @@ class ProviderRequest:
                 if not image_data:
                     logger.warning(f"图片 {image_url} 得到的结果为空，将忽略。")
                     continue
-                content_blocks.append(
+                user_content["content"].append(
                     {"type": "image_url", "image_url": {"url": image_data}},
                 )
-
-        # 只有当只有一个来自 prompt 的文本块且没有额外内容块时，才降级为简单格式以保持向后兼容
-        if (
-            len(content_blocks) == 1
-            and content_blocks[0]["type"] == "text"
-            and not self.extra_user_content_parts
-            and not self.image_urls
-        ):
-            return {"role": "user", "content": content_blocks[0]["text"]}
-
-        # 否则返回多模态格式
-        return {"role": "user", "content": content_blocks}
+            return user_content
+        return {"role": "user", "content": self.prompt}
 
     async def _encode_image_bs64(self, image_url: str) -> str:
         """将图片转换为 base64"""
@@ -272,8 +249,6 @@ class LLMResponse:
     """Tool call extra content. tool_call_id -> extra_content dict"""
     reasoning_content: str = ""
     """The reasoning content extracted from the LLM, if any."""
-    reasoning_signature: str | None = None
-    """The signature of the reasoning content, if any."""
 
     raw_completion: (
         ChatCompletion | GenerateContentResponse | AnthropicMessage | None
@@ -294,14 +269,12 @@ class LLMResponse:
     def __init__(
         self,
         role: str,
-        completion_text: str | None = None,
+        completion_text: str = "",
         result_chain: MessageChain | None = None,
         tools_call_args: list[dict[str, Any]] | None = None,
         tools_call_name: list[str] | None = None,
         tools_call_ids: list[str] | None = None,
         tools_call_extra_content: dict[str, dict[str, Any]] | None = None,
-        reasoning_content: str | None = None,
-        reasoning_signature: str | None = None,
         raw_completion: ChatCompletion
         | GenerateContentResponse
         | AnthropicMessage
@@ -321,8 +294,6 @@ class LLMResponse:
             raw_completion (ChatCompletion, optional): 原始响应, OpenAI 格式. Defaults to None.
 
         """
-        if reasoning_content is None:
-            reasoning_content = ""
         if tools_call_args is None:
             tools_call_args = []
         if tools_call_name is None:
@@ -339,8 +310,6 @@ class LLMResponse:
         self.tools_call_name = tools_call_name
         self.tools_call_ids = tools_call_ids
         self.tools_call_extra_content = tools_call_extra_content
-        self.reasoning_content = reasoning_content
-        self.reasoning_signature = reasoning_signature
         self.raw_completion = raw_completion
         self.is_chunk = is_chunk
 

astrbot/core/provider/manager.py

@@ -1,5 +1,4 @@
 import asyncio
-import copy
 import traceback
 from typing import Protocol, runtime_checkable
 
@@ -33,12 +32,10 @@ class ProviderManager:
         persona_mgr: PersonaManager,
     ):
         self.reload_lock = asyncio.Lock()
-        self.resource_lock = asyncio.Lock()
         self.persona_mgr = persona_mgr
         self.acm = acm
         config = acm.confs["default"]
         self.providers_config: list = config["provider"]
-        self.provider_sources_config: list = config.get("provider_sources", [])
         self.provider_settings: dict = config["provider_settings"]
         self.provider_stt_settings: dict = config.get("provider_stt_settings", {})
         self.provider_tts_settings: dict = config.get("provider_tts_settings", {})
@@ -151,7 +148,6 @@ class ProviderManager:
 
         """
         provider = None
-        provider_id = None
         if umo:
             provider_id = sp.get(
                 f"provider_perf_{provider_type.value}",
@@ -189,12 +185,6 @@ class ProviderManager:
                     )
             else:
                 raise ValueError(f"Unknown provider type: {provider_type}")
-
-        if not provider and provider_id:
-            logger.warning(
-                f"没有找到 ID 为 {provider_id} 的提供商，这可能是由于您修改了提供商（模型）ID 导致的。"
-            )
-
         return provider
 
     async def initialize(self):
@@ -261,136 +251,7 @@ class ProviderManager:
         # 初始化 MCP Client 连接
         asyncio.create_task(self.llm_tools.init_mcp_clients(), name="init_mcp_clients")
 
-    def dynamic_import_provider(self, type: str):
-        """动态导入提供商适配器模块
-
-        Args:
-            type (str): 提供商请求类型。
-
-        Raises:
-            ImportError: 如果提供商类型未知或无法导入对应模块，则抛出异常。
-        """
-        match type:
-            case "openai_chat_completion":
-                from .sources.openai_source import (
-                    ProviderOpenAIOfficial as ProviderOpenAIOfficial,
-                )
-            case "zhipu_chat_completion":
-                from .sources.zhipu_source import ProviderZhipu as ProviderZhipu
-            case "groq_chat_completion":
-                from .sources.groq_source import ProviderGroq as ProviderGroq
-            case "anthropic_chat_completion":
-                from .sources.anthropic_source import (
-                    ProviderAnthropic as ProviderAnthropic,
-                )
-            case "googlegenai_chat_completion":
-                from .sources.gemini_source import (
-                    ProviderGoogleGenAI as ProviderGoogleGenAI,
-                )
-            case "sensevoice_stt_selfhost":
-                from .sources.sensevoice_selfhosted_source import (
-                    ProviderSenseVoiceSTTSelfHost as ProviderSenseVoiceSTTSelfHost,
-                )
-            case "openai_whisper_api":
-                from .sources.whisper_api_source import (
-                    ProviderOpenAIWhisperAPI as ProviderOpenAIWhisperAPI,
-                )
-            case "openai_whisper_selfhost":
-                from .sources.whisper_selfhosted_source import (
-                    ProviderOpenAIWhisperSelfHost as ProviderOpenAIWhisperSelfHost,
-                )
-            case "xinference_stt":
-                from .sources.xinference_stt_provider import (
-                    ProviderXinferenceSTT as ProviderXinferenceSTT,
-                )
-            case "openai_tts_api":
-                from .sources.openai_tts_api_source import (
-                    ProviderOpenAITTSAPI as ProviderOpenAITTSAPI,
-                )
-            case "edge_tts":
-                from .sources.edge_tts_source import (
-                    ProviderEdgeTTS as ProviderEdgeTTS,
-                )
-            case "gsv_tts_selfhost":
-                from .sources.gsv_selfhosted_source import (
-                    ProviderGSVTTS as ProviderGSVTTS,
-                )
-            case "gsvi_tts_api":
-                from .sources.gsvi_tts_source import (
-                    ProviderGSVITTS as ProviderGSVITTS,
-                )
-            case "fishaudio_tts_api":
-                from .sources.fishaudio_tts_api_source import (
-                    ProviderFishAudioTTSAPI as ProviderFishAudioTTSAPI,
-                )
-            case "dashscope_tts":
-                from .sources.dashscope_tts import (
-                    ProviderDashscopeTTSAPI as ProviderDashscopeTTSAPI,
-                )
-            case "azure_tts":
-                from .sources.azure_tts_source import (
-                    AzureTTSProvider as AzureTTSProvider,
-                )
-            case "minimax_tts_api":
-                from .sources.minimax_tts_api_source import (
-                    ProviderMiniMaxTTSAPI as ProviderMiniMaxTTSAPI,
-                )
-            case "volcengine_tts":
-                from .sources.volcengine_tts import (
-                    ProviderVolcengineTTS as ProviderVolcengineTTS,
-                )
-            case "gemini_tts":
-                from .sources.gemini_tts_source import (
-                    ProviderGeminiTTSAPI as ProviderGeminiTTSAPI,
-                )
-            case "openai_embedding":
-                from .sources.openai_embedding_source import (
-                    OpenAIEmbeddingProvider as OpenAIEmbeddingProvider,
-                )
-            case "gemini_embedding":
-                from .sources.gemini_embedding_source import (
-                    GeminiEmbeddingProvider as GeminiEmbeddingProvider,
-                )
-            case "vllm_rerank":
-                from .sources.vllm_rerank_source import (
-                    VLLMRerankProvider as VLLMRerankProvider,
-                )
-            case "xinference_rerank":
-                from .sources.xinference_rerank_source import (
-                    XinferenceRerankProvider as XinferenceRerankProvider,
-                )
-            case "bailian_rerank":
-                from .sources.bailian_rerank_source import (
-                    BailianRerankProvider as BailianRerankProvider,
-                )
-
-    def get_merged_provider_config(self, provider_config: dict) -> dict:
-        """获取 provider 配置和 provider_source 配置合并后的结果
-
-        Returns:
-            dict: 合并后的 provider 配置，key 为 provider id，value 为合并后的配置字典
-        """
-        pc = copy.deepcopy(provider_config)
-        provider_source_id = pc.get("provider_source_id", "")
-        if provider_source_id:
-            provider_source = None
-            for ps in self.provider_sources_config:
-                if ps.get("id") == provider_source_id:
-                    provider_source = ps
-                    break
-
-            if provider_source:
-                # 合并配置，provider 的配置优先级更高
-                merged_config = {**provider_source, **pc}
-                # 保持 id 为 provider 的 id，而不是 source 的 id
-                merged_config["id"] = pc["id"]
-                pc = merged_config
-        return pc
-
     async def load_provider(self, provider_config: dict):
-        # 如果 provider_source_id 存在且不为空，则从 provider_sources 中找到对应的配置并合并
-        provider_config = self.get_merged_provider_config(provider_config)
-
         if not provider_config["enable"]:
             logger.info(f"Provider {provider_config['id']} is disabled, skipping")
             return
@@ -403,7 +264,99 @@ class ProviderManager:
 
         # 动态导入
         try:
-            self.dynamic_import_provider(provider_config["type"])
+            match provider_config["type"]:
+                case "openai_chat_completion":
+                    from .sources.openai_source import (
+                        ProviderOpenAIOfficial as ProviderOpenAIOfficial,
+                    )
+                case "zhipu_chat_completion":
+                    from .sources.zhipu_source import ProviderZhipu as ProviderZhipu
+                case "groq_chat_completion":
+                    from .sources.groq_source import ProviderGroq as ProviderGroq
+                case "anthropic_chat_completion":
+                    from .sources.anthropic_source import (
+                        ProviderAnthropic as ProviderAnthropic,
+                    )
+                case "googlegenai_chat_completion":
+                    from .sources.gemini_source import (
+                        ProviderGoogleGenAI as ProviderGoogleGenAI,
+                    )
+                case "sensevoice_stt_selfhost":
+                    from .sources.sensevoice_selfhosted_source import (
+                        ProviderSenseVoiceSTTSelfHost as ProviderSenseVoiceSTTSelfHost,
+                    )
+                case "openai_whisper_api":
+                    from .sources.whisper_api_source import (
+                        ProviderOpenAIWhisperAPI as ProviderOpenAIWhisperAPI,
+                    )
+                case "openai_whisper_selfhost":
+                    from .sources.whisper_selfhosted_source import (
+                        ProviderOpenAIWhisperSelfHost as ProviderOpenAIWhisperSelfHost,
+                    )
+                case "xinference_stt":
+                    from .sources.xinference_stt_provider import (
+                        ProviderXinferenceSTT as ProviderXinferenceSTT,
+                    )
+                case "openai_tts_api":
+                    from .sources.openai_tts_api_source import (
+                        ProviderOpenAITTSAPI as ProviderOpenAITTSAPI,
+                    )
+                case "edge_tts":
+                    from .sources.edge_tts_source import (
+                        ProviderEdgeTTS as ProviderEdgeTTS,
+                    )
+                case "gsv_tts_selfhost":
+                    from .sources.gsv_selfhosted_source import (
+                        ProviderGSVTTS as ProviderGSVTTS,
+                    )
+                case "gsvi_tts_api":
+                    from .sources.gsvi_tts_source import (
+                        ProviderGSVITTS as ProviderGSVITTS,
+                    )
+                case "fishaudio_tts_api":
+                    from .sources.fishaudio_tts_api_source import (
+                        ProviderFishAudioTTSAPI as ProviderFishAudioTTSAPI,
+                    )
+                case "dashscope_tts":
+                    from .sources.dashscope_tts import (
+                        ProviderDashscopeTTSAPI as ProviderDashscopeTTSAPI,
+                    )
+                case "azure_tts":
+                    from .sources.azure_tts_source import (
+                        AzureTTSProvider as AzureTTSProvider,
+                    )
+                case "minimax_tts_api":
+                    from .sources.minimax_tts_api_source import (
+                        ProviderMiniMaxTTSAPI as ProviderMiniMaxTTSAPI,
+                    )
+                case "volcengine_tts":
+                    from .sources.volcengine_tts import (
+                        ProviderVolcengineTTS as ProviderVolcengineTTS,
+                    )
+                case "gemini_tts":
+                    from .sources.gemini_tts_source import (
+                        ProviderGeminiTTSAPI as ProviderGeminiTTSAPI,
+                    )
+                case "openai_embedding":
+                    from .sources.openai_embedding_source import (
+                        OpenAIEmbeddingProvider as OpenAIEmbeddingProvider,
+                    )
+                case "gemini_embedding":
+                    from .sources.gemini_embedding_source import (
+                        GeminiEmbeddingProvider as GeminiEmbeddingProvider,
+                    )
+                case "vllm_rerank":
+                    from .sources.vllm_rerank_source import (
+                        VLLMRerankProvider as VLLMRerankProvider,
+                    )
+                case "xinference_rerank":
+                    from .sources.xinference_rerank_source import (
+                        XinferenceRerankProvider as XinferenceRerankProvider,
+                    )
+                case "bailian_rerank":
+                    from .sources.bailian_rerank_source import (
+                        BailianRerankProvider as BailianRerankProvider,
+                    )
         except (ImportError, ModuleNotFoundError) as e:
             logger.critical(
                 f"加载 {provider_config['type']}({provider_config['id']}) 提供商适配器失败：{e}。可能是因为有未安装的依赖。",
@@ -546,7 +499,6 @@ class ProviderManager:
 
             # 和配置文件保持同步
             self.providers_config = astrbot_config["provider"]
-            self.provider_sources_config = astrbot_config.get("provider_sources", [])
             config_ids = [provider["id"] for provider in self.providers_config]
             logger.info(f"providers in user's config: {config_ids}")
             for key in list(self.inst_map.keys()):
@@ -618,68 +570,6 @@ class ProviderManager:
             )
             del self.inst_map[provider_id]
 
-    async def delete_provider(
-        self, provider_id: str | None = None, provider_source_id: str | None = None
-    ):
-        """Delete provider and/or provider source from config and terminate the instances. Config will be saved after deletion."""
-        async with self.resource_lock:
-            # delete from config
-            target_prov_ids = []
-            if provider_id:
-                target_prov_ids.append(provider_id)
-            else:
-                for prov in self.providers_config:
-                    if prov.get("provider_source_id") == provider_source_id:
-                        target_prov_ids.append(prov.get("id"))
-            config = self.acm.default_conf
-            for tpid in target_prov_ids:
-                await self.terminate_provider(tpid)
-                config["provider"] = [
-                    prov for prov in config["provider"] if prov.get("id") != tpid
-                ]
-            config.save_config()
-            logger.info(f"Provider {target_prov_ids} 已从配置中删除。")
-
-    async def update_provider(self, origin_provider_id: str, new_config: dict):
-        """Update provider config and reload the instance. Config will be saved after update."""
-        async with self.resource_lock:
-            npid = new_config.get("id", None)
-            if not npid:
-                raise ValueError("New provider config must have an 'id' field")
-            config = self.acm.default_conf
-            for provider in config["provider"]:
-                if (
-                    provider.get("id", None) == npid
-                    and provider.get("id", None) != origin_provider_id
-                ):
-                    raise ValueError(f"Provider ID {npid} already exists")
-            # update config
-            for idx, provider in enumerate(config["provider"]):
-                if provider.get("id", None) == origin_provider_id:
-                    config["provider"][idx] = new_config
-                    break
-            else:
-                raise ValueError(f"Provider ID {origin_provider_id} not found")
-            config.save_config()
-            # reload instance
-            await self.reload(new_config)
-
-    async def create_provider(self, new_config: dict):
-        """Add new provider config and load the instance. Config will be saved after addition."""
-        async with self.resource_lock:
-            npid = new_config.get("id", None)
-            if not npid:
-                raise ValueError("New provider config must have an 'id' field")
-            config = self.acm.default_conf
-            for provider in config["provider"]:
-                if provider.get("id", None) == npid:
-                    raise ValueError(f"Provider ID {npid} already exists")
-            # add to config
-            config["provider"].append(new_config)
-            config.save_config()
-            # load instance
-            await self.load_provider(new_config)
-
     async def terminate(self):
         for provider_inst in self.provider_insts:
             if hasattr(provider_inst, "terminate"):

astrbot/core/provider/provider.py

@@ -4,7 +4,7 @@ import os
 from collections.abc import AsyncGenerator
 from typing import TypeAlias, Union
 
-from astrbot.core.agent.message import ContentPart, Message
+from astrbot.core.agent.message import Message
 from astrbot.core.agent.tool import ToolSet
 from astrbot.core.provider.entities import (
     LLMResponse,
@@ -103,7 +103,6 @@ class Provider(AbstractProvider):
         system_prompt: str | None = None,
         tool_calls_result: ToolCallsResult | list[ToolCallsResult] | None = None,
         model: str | None = None,
-        extra_user_content_parts: list[ContentPart] | None = None,
         **kwargs,
     ) -> LLMResponse:
         """获得 LLM 的文本对话结果。会使用当前的模型进行对话。
@@ -115,7 +114,6 @@ class Provider(AbstractProvider):
             tools: tool set
             contexts: 上下文，和 prompt 二选一使用
             tool_calls_result: 回传给 LLM 的工具调用结果。参考: https://platform.openai.com/docs/guides/function-calling
-            extra_user_content_parts: 额外的内容块列表，用于在用户消息后添加额外的文本块（如系统提醒、指令等）
             kwargs: 其他参数
 
         Notes:

astrbot/core/provider/sources/anthropic_source.py

@@ -11,7 +11,6 @@ from anthropic.types.usage import Usage
 
 from astrbot import logger
 from astrbot.api.provider import Provider
-from astrbot.core.agent.message import ContentPart, ImageURLPart, TextPart
 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
@@ -48,9 +47,7 @@ class ProviderAnthropic(Provider):
             base_url=self.base_url,
         )
 
-        self.thinking_config = provider_config.get("anth_thinking_config", {})
-
-        self.set_model(provider_config.get("model", "unknown"))
+        self.set_model(provider_config["model_config"]["model"])
 
     def _prepare_payload(self, messages: list[dict]):
         """准备 Anthropic API 的请求 payload
@@ -66,33 +63,12 @@ class ProviderAnthropic(Provider):
         new_messages = []
         for message in messages:
             if message["role"] == "system":
-                system_prompt = message["content"] or "<empty system prompt>"
+                system_prompt = message["content"]
             elif message["role"] == "assistant":
                 blocks = []
-                reasoning_content = ""
-                thinking_signature = ""
-                if isinstance(message["content"], str) and message["content"].strip():
+                if isinstance(message["content"], str):
                     blocks.append({"type": "text", "text": message["content"]})
-                elif isinstance(message["content"], list):
-                    for part in message["content"]:
-                        if part.get("type") == "think":
-                            # only pick the last think part for now
-                            reasoning_content = part.get("think")
-                            thinking_signature = part.get("encrypted")
-                        else:
-                            blocks.append(part)
-
-                if reasoning_content and thinking_signature:
-                    blocks.insert(
-                        0,
-                        {
-                            "type": "thinking",
-                            "thinking": reasoning_content,
-                            "signature": thinking_signature,
-                        },
-                    )
-
-                if "tool_calls" in message and isinstance(message["tool_calls"], list):
+                if "tool_calls" in message:
                     for tool_call in message["tool_calls"]:
                         blocks.append(  # noqa: PERF401
                             {
@@ -123,7 +99,7 @@ class ProviderAnthropic(Provider):
                             {
                                 "type": "tool_result",
                                 "tool_use_id": message["tool_call_id"],
-                                "content": message["content"] or "<empty response>",
+                                "content": message["content"],
                             },
                         ],
                     },
@@ -154,19 +130,7 @@ class ProviderAnthropic(Provider):
             if tool_list := tools.get_func_desc_anthropic_style():
                 payloads["tools"] = tool_list
 
-        extra_body = self.provider_config.get("custom_extra_body", {})
-
-        if "max_tokens" not in payloads:
-            payloads["max_tokens"] = 1024
-        if self.thinking_config.get("budget"):
-            payloads["thinking"] = {
-                "budget_tokens": self.thinking_config.get("budget"),
-                "type": "enabled",
-            }
-
-        completion = await self.client.messages.create(
-            **payloads, stream=False, extra_body=extra_body
-        )
+        completion = await self.client.messages.create(**payloads, stream=False)
 
         assert isinstance(completion, Message)
         logger.debug(f"completion: {completion}")
@@ -181,11 +145,6 @@ class ProviderAnthropic(Provider):
                 completion_text = str(content_block.text).strip()
                 llm_response.completion_text = completion_text
 
-            if content_block.type == "thinking":
-                reasoning_content = str(content_block.thinking).strip()
-                llm_response.reasoning_content = reasoning_content
-                llm_response.reasoning_signature = content_block.signature
-
             if content_block.type == "tool_use":
                 llm_response.tools_call_args.append(content_block.input)
                 llm_response.tools_call_name.append(content_block.name)
@@ -214,23 +173,11 @@ class ProviderAnthropic(Provider):
         # 用于累积最终结果
         final_text = ""
         final_tool_calls = []
+
         id = None
         usage = TokenUsage()
-        extra_body = self.provider_config.get("custom_extra_body", {})
-        reasoning_content = ""
-        reasoning_signature = ""
 
-        if "max_tokens" not in payloads:
-            payloads["max_tokens"] = 1024
-        if self.thinking_config.get("budget"):
-            payloads["thinking"] = {
-                "budget_tokens": self.thinking_config.get("budget"),
-                "type": "enabled",
-            }
-
-        async with self.client.messages.stream(
-            **payloads, extra_body=extra_body
-        ) as stream:
+        async with self.client.messages.stream(**payloads) as stream:
             assert isinstance(stream, anthropic.AsyncMessageStream)
             async for event in stream:
                 if event.type == "message_start":
@@ -266,21 +213,6 @@ class ProviderAnthropic(Provider):
                             usage=usage,
                             id=id,
                         )
-                    elif event.delta.type == "thinking_delta":
-                        # 思考增量
-                        reasoning = event.delta.thinking
-                        if reasoning:
-                            yield LLMResponse(
-                                role="assistant",
-                                reasoning_content=reasoning,
-                                is_chunk=True,
-                                usage=usage,
-                                id=id,
-                                reasoning_signature=reasoning_signature or None,
-                            )
-                            reasoning_content += reasoning
-                    elif event.delta.type == "signature_delta":
-                        reasoning_signature = event.delta.signature
                     elif event.delta.type == "input_json_delta":
                         # 工具调用参数增量
                         if event.index in tool_use_buffer:
@@ -337,8 +269,6 @@ class ProviderAnthropic(Provider):
             is_chunk=False,
             usage=usage,
             id=id,
-            reasoning_content=reasoning_content,
-            reasoning_signature=reasoning_signature or None,
         )
 
         if final_tool_calls:
@@ -360,16 +290,13 @@ class ProviderAnthropic(Provider):
         system_prompt=None,
         tool_calls_result=None,
         model=None,
-        extra_user_content_parts=None,
         **kwargs,
     ) -> LLMResponse:
         if contexts is None:
             contexts = []
         new_record = None
         if prompt is not None:
-            new_record = await self.assemble_context(
-                prompt, image_urls, extra_user_content_parts
-            )
+            new_record = await self.assemble_context(prompt, image_urls)
         context_query = self._ensure_message_to_dicts(contexts)
         if new_record:
             context_query.append(new_record)
@@ -391,9 +318,10 @@ class ProviderAnthropic(Provider):
 
         system_prompt, new_messages = self._prepare_payload(context_query)
 
-        model = model or self.get_model()
+        model_config = self.provider_config.get("model_config", {})
+        model_config["model"] = model or self.get_model()
 
-        payloads = {"messages": new_messages, "model": model}
+        payloads = {"messages": new_messages, **model_config}
 
         # Anthropic has a different way of handling system prompts
         if system_prompt:
@@ -403,30 +331,28 @@ class ProviderAnthropic(Provider):
         try:
             llm_response = await self._query(payloads, func_tool)
         except Exception as e:
+            # logger.error(f"发生了错误。Provider 配置如下: {model_config}")
             raise e
 
         return llm_response
 
     async def text_chat_stream(
         self,
-        prompt=None,
+        prompt,
         session_id=None,
-        image_urls=None,
+        image_urls=...,
         func_tool=None,
-        contexts=None,
+        contexts=...,
         system_prompt=None,
         tool_calls_result=None,
         model=None,
-        extra_user_content_parts=None,
         **kwargs,
     ):
         if contexts is None:
             contexts = []
         new_record = None
         if prompt is not None:
-            new_record = await self.assemble_context(
-                prompt, image_urls, extra_user_content_parts
-            )
+            new_record = await self.assemble_context(prompt, image_urls)
         context_query = self._ensure_message_to_dicts(contexts)
         if new_record:
             context_query.append(new_record)
@@ -447,9 +373,10 @@ class ProviderAnthropic(Provider):
 
         system_prompt, new_messages = self._prepare_payload(context_query)
 
-        model = model or self.get_model()
+        model_config = self.provider_config.get("model_config", {})
+        model_config["model"] = model or self.get_model()
 
-        payloads = {"messages": new_messages, "model": model}
+        payloads = {"messages": new_messages, **model_config}
 
         # Anthropic has a different way of handling system prompts
         if system_prompt:
@@ -458,15 +385,15 @@ class ProviderAnthropic(Provider):
         async for llm_response in self._query_stream(payloads, func_tool):
             yield llm_response
 
-    async def assemble_context(
-        self,
-        text: str,
-        image_urls: list[str] | None = None,
-        extra_user_content_parts: list[ContentPart] | None = None,
-    ):
+    async def assemble_context(self, text: str, image_urls: list[str] | None = None):
         """组装上下文，支持文本和图片"""
+        if not image_urls:
+            return {"role": "user", "content": text}
 
-        async def resolve_image_url(image_url: str) -> dict | None:
+        content = []
+        content.append({"type": "text", "text": text})
+
+        for image_url in image_urls:
             if image_url.startswith("http"):
                 image_path = await download_image_by_url(image_url)
                 image_data = await self.encode_image_bs64(image_path)
@@ -478,68 +405,28 @@ class ProviderAnthropic(Provider):
 
             if not image_data:
                 logger.warning(f"图片 {image_url} 得到的结果为空，将忽略。")
-                return None
+                continue
 
             # Get mime type for the image
             mime_type, _ = guess_type(image_url)
             if not mime_type:
                 mime_type = "image/jpeg"  # Default to JPEG if can't determine
 
-            return {
-                "type": "image",
-                "source": {
-                    "type": "base64",
-                    "media_type": mime_type,
-                    "data": (
-                        image_data.split("base64,")[1]
-                        if "base64," in image_data
-                        else image_data
-                    ),
+            content.append(
+                {
+                    "type": "image",
+                    "source": {
+                        "type": "base64",
+                        "media_type": mime_type,
+                        "data": (
+                            image_data.split("base64,")[1]
+                            if "base64," in image_data
+                            else image_data
+                        ),
+                    },
                 },
-            }
+            )
 
-        content = []
-
-        # 1. 用户原始发言（OpenAI 建议：用户发言在前）
-        if text:
-            content.append({"type": "text", "text": text})
-        elif image_urls:
-            # 如果没有文本但有图片，添加占位文本
-            content.append({"type": "text", "text": "[图片]"})
-        elif extra_user_content_parts:
-            # 如果只有额外内容块，也需要添加占位文本
-            content.append({"type": "text", "text": " "})
-
-        # 2. 额外的内容块（系统提醒、指令等）
-        if extra_user_content_parts:
-            for block in extra_user_content_parts:
-                if isinstance(block, TextPart):
-                    content.append({"type": "text", "text": block.text})
-                elif isinstance(block, ImageURLPart):
-                    image_dict = await resolve_image_url(block.image_url.url)
-                    if image_dict:
-                        content.append(image_dict)
-                else:
-                    raise ValueError(f"不支持的额外内容块类型: {type(block)}")
-
-        # 3. 图片内容
-        if image_urls:
-            for image_url in image_urls:
-                image_dict = await resolve_image_url(image_url)
-                if image_dict:
-                    content.append(image_dict)
-
-        # 如果只有主文本且没有额外内容块和图片，返回简单格式以保持向后兼容
-        if (
-            text
-            and not extra_user_content_parts
-            and not image_urls
-            and len(content) == 1
-            and content[0]["type"] == "text"
-        ):
-            return {"role": "user", "content": content[0]["text"]}
-
-        # 否则返回多模态格式
         return {"role": "user", "content": content}
 
     async def encode_image_bs64(self, image_url: str) -> str:

astrbot/core/provider/sources/fishaudio_tts_api_source.py

@@ -56,14 +56,10 @@ class ProviderFishAudioTTSAPI(TTSProvider):
             "api_base",
             "https://api.fish-audio.cn/v1",
         )
-        try:
-            self.timeout: int = int(provider_config.get("timeout", 20))
-        except ValueError:
-            self.timeout = 20
         self.headers = {
             "Authorization": f"Bearer {self.chosen_api_key}",
         }
-        self.set_model(provider_config.get("model", None))
+        self.set_model(provider_config["model"])
 
     async def _get_reference_id_by_character(self, character: str) -> str | None:
         """获取角色的reference_id
@@ -139,21 +135,17 @@ class ProviderFishAudioTTSAPI(TTSProvider):
         path = os.path.join(temp_dir, f"fishaudio_tts_api_{uuid.uuid4()}.wav")
         self.headers["content-type"] = "application/msgpack"
         request = await self._generate_request(text)
-        async with AsyncClient(base_url=self.api_base, timeout=self.timeout).stream(
+        async with AsyncClient(base_url=self.api_base).stream(
             "POST",
             "/tts",
             headers=self.headers,
             content=ormsgpack.packb(request, option=ormsgpack.OPT_SERIALIZE_PYDANTIC),
         ) as response:
-            if response.status_code == 200 and response.headers.get(
-                "content-type", ""
-            ).startswith("audio/"):
+            if response.headers["content-type"] == "audio/wav":
                 with open(path, "wb") as f:
                     async for chunk in response.aiter_bytes():
                         f.write(chunk)
                 return path
-            error_bytes = await response.aread()
-            error_text = error_bytes.decode("utf-8", errors="replace")[:1024]
-            raise Exception(
-                f"Fish Audio API请求失败: 状态码 {response.status_code}, 响应内容: {error_text}"
-            )
+            body = await response.aread()
+            text = body.decode("utf-8", errors="replace")
+            raise Exception(f"Fish Audio API请求失败: {text}")

astrbot/core/provider/sources/gemini_source.py

@@ -13,7 +13,6 @@ from google.genai.errors import APIError
 import astrbot.core.message.components as Comp
 from astrbot import logger
 from astrbot.api.provider import Provider
-from astrbot.core.agent.message import ContentPart, ImageURLPart, TextPart
 from astrbot.core.message.message_event_result import MessageChain
 from astrbot.core.provider.entities import LLMResponse, TokenUsage
 from astrbot.core.provider.func_tool_manager import ToolSet
@@ -69,7 +68,7 @@ class ProviderGoogleGenAI(Provider):
             self.api_base = self.api_base[:-1]
 
         self._init_client()
-        self.set_model(provider_config.get("model", "unknown"))
+        self.set_model(provider_config["model_config"]["model"])
         self._init_safety_settings()
 
     def _init_client(self) -> None:
@@ -139,7 +138,7 @@ class ProviderGoogleGenAI(Provider):
             modalities = ["TEXT"]
 
         tool_list: list[types.Tool] | None = []
-        model_name = cast(str, payloads.get("model", self.get_model()))
+        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)
@@ -200,16 +199,7 @@ class ProviderGoogleGenAI(Provider):
 
         # oper thinking config
         thinking_config = None
-        if model_name in [
-            "gemini-2.5-pro",
-            "gemini-2.5-pro-preview",
-            "gemini-2.5-flash",
-            "gemini-2.5-flash-preview",
-            "gemini-2.5-flash-lite",
-            "gemini-2.5-flash-lite-preview",
-            "gemini-robotics-er-1.5-preview",
-            "gemini-live-2.5-flash-preview-native-audio-09-2025",
-        ]:
+        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
@@ -218,14 +208,7 @@ class ProviderGoogleGenAI(Provider):
                 thinking_config = types.ThinkingConfig(
                     thinking_budget=thinking_budget,
                 )
-        elif model_name in [
-            "gemini-3-pro",
-            "gemini-3-pro-preview",
-            "gemini-3-flash",
-            "gemini-3-flash-preview",
-            "gemini-3-flash-lite",
-            "gemini-3-flash-lite-preview",
-        ]:
+        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(
@@ -321,37 +304,9 @@ class ProviderGoogleGenAI(Provider):
                 append_or_extend(gemini_contents, parts, types.UserContent)
 
             elif role == "assistant":
-                if isinstance(content, str):
+                if content:
                     parts = [types.Part.from_text(text=content)]
                     append_or_extend(gemini_contents, parts, types.ModelContent)
-                elif isinstance(content, list):
-                    parts = []
-                    thinking_signature = None
-                    text = ""
-                    for part in content:
-                        # for most cases, assistant content only contains two parts: think and text
-                        if part.get("type") == "think":
-                            thinking_signature = part.get("encrypted") or None
-                        else:
-                            text += str(part.get("text"))
-
-                    if thinking_signature and isinstance(thinking_signature, str):
-                        try:
-                            thinking_signature = base64.b64decode(thinking_signature)
-                        except Exception as e:
-                            logger.warning(
-                                f"Failed to decode google gemini thinking signature: {e}",
-                                exc_info=True,
-                            )
-                            thinking_signature = None
-                    parts.append(
-                        types.Part(
-                            text=text,
-                            thought_signature=thinking_signature,
-                        )
-                    )
-                    append_or_extend(gemini_contents, parts, types.ModelContent)
-
                 elif not native_tool_enabled and "tool_calls" in message:
                     parts = []
                     for tool in message["tool_calls"]:
@@ -469,8 +424,7 @@ class ProviderGoogleGenAI(Provider):
         for part in result_parts:
             if part.text:
                 chain.append(Comp.Plain(part.text))
-
-            if (
+            elif (
                 part.function_call
                 and part.function_call.name is not None
                 and part.function_call.args is not None
@@ -487,18 +441,13 @@ class ProviderGoogleGenAI(Provider):
                     llm_response.tools_call_extra_content[tool_call_id] = {
                         "google": {"thought_signature": ts_bs64}
                     }
-
-            if (
+            elif (
                 part.inline_data
                 and part.inline_data.mime_type
                 and part.inline_data.mime_type.startswith("image/")
                 and part.inline_data.data
             ):
                 chain.append(Comp.Image.fromBytes(part.inline_data.data))
-
-            if ts := part.thought_signature:
-                # only keep the last thinking signature
-                llm_response.reasoning_signature = base64.b64encode(ts).decode("utf-8")
         return MessageChain(chain=chain)
 
     async def _query(self, payloads: dict, tools: ToolSet | None) -> LLMResponse:
@@ -715,16 +664,13 @@ class ProviderGoogleGenAI(Provider):
         system_prompt=None,
         tool_calls_result=None,
         model=None,
-        extra_user_content_parts=None,
         **kwargs,
     ) -> LLMResponse:
         if contexts is None:
             contexts = []
         new_record = None
         if prompt is not None:
-            new_record = await self.assemble_context(
-                prompt, image_urls, extra_user_content_parts
-            )
+            new_record = await self.assemble_context(prompt, image_urls)
         context_query = self._ensure_message_to_dicts(contexts)
         if new_record:
             context_query.append(new_record)
@@ -743,9 +689,10 @@ class ProviderGoogleGenAI(Provider):
                 for tcr in tool_calls_result:
                     context_query.extend(tcr.to_openai_messages())
 
-        model = model or self.get_model()
+        model_config = self.provider_config.get("model_config", {})
+        model_config["model"] = model or self.get_model()
 
-        payloads = {"messages": context_query, "model": model}
+        payloads = {"messages": context_query, **model_config}
 
         retry = 10
         keys = self.api_keys.copy()
@@ -770,16 +717,13 @@ class ProviderGoogleGenAI(Provider):
         system_prompt=None,
         tool_calls_result=None,
         model=None,
-        extra_user_content_parts=None,
         **kwargs,
     ) -> AsyncGenerator[LLMResponse, None]:
         if contexts is None:
             contexts = []
         new_record = None
         if prompt is not None:
-            new_record = await self.assemble_context(
-                prompt, image_urls, extra_user_content_parts
-            )
+            new_record = await self.assemble_context(prompt, image_urls)
         context_query = self._ensure_message_to_dicts(contexts)
         if new_record:
             context_query.append(new_record)
@@ -798,9 +742,10 @@ class ProviderGoogleGenAI(Provider):
                 for tcr in tool_calls_result:
                     context_query.extend(tcr.to_openai_messages())
 
-        model = model or self.get_model()
+        model_config = self.provider_config.get("model_config", {})
+        model_config["model"] = model or self.get_model()
 
-        payloads = {"messages": context_query, "model": model}
+        payloads = {"messages": context_query, **model_config}
 
         retry = 10
         keys = self.api_keys.copy()
@@ -838,75 +783,33 @@ class ProviderGoogleGenAI(Provider):
         self.chosen_api_key = key
         self._init_client()
 
-    async def assemble_context(
-        self,
-        text: str,
-        image_urls: list[str] | None = None,
-        extra_user_content_parts: list[ContentPart] | None = None,
-    ):
+    async def assemble_context(self, text: str, image_urls: list[str] | None = None):
         """组装上下文。"""
-
-        async def resolve_image_part(image_url: str) -> dict | None:
-            if image_url.startswith("http"):
-                image_path = await download_image_by_url(image_url)
-                image_data = await self.encode_image_bs64(image_path)
-            elif image_url.startswith("file:///"):
-                image_path = image_url.replace("file:///", "")
-                image_data = await self.encode_image_bs64(image_path)
-            else:
-                image_data = await self.encode_image_bs64(image_url)
-            if not image_data:
-                logger.warning(f"图片 {image_url} 得到的结果为空，将忽略。")
-                return None
-            return {
-                "type": "image_url",
-                "image_url": {"url": image_data},
-            }
-
-        # 构建内容块列表
-        content_blocks = []
-
-        # 1. 用户原始发言（OpenAI 建议：用户发言在前）
-        if text:
-            content_blocks.append({"type": "text", "text": text})
-        elif image_urls:
-            # 如果没有文本但有图片，添加占位文本
-            content_blocks.append({"type": "text", "text": "[图片]"})
-        elif extra_user_content_parts:
-            # 如果只有额外内容块，也需要添加占位文本
-            content_blocks.append({"type": "text", "text": " "})
-
-        # 2. 额外的内容块（系统提醒、指令等）
-        if extra_user_content_parts:
-            for part in extra_user_content_parts:
-                if isinstance(part, TextPart):
-                    content_blocks.append({"type": "text", "text": part.text})
-                elif isinstance(part, ImageURLPart):
-                    image_part = await resolve_image_part(part.image_url.url)
-                    if image_part:
-                        content_blocks.append(image_part)
-                else:
-                    raise ValueError(f"不支持的额外内容块类型: {type(part)}")
-
-        # 3. 图片内容
         if image_urls:
+            user_content = {
+                "role": "user",
+                "content": [{"type": "text", "text": text if text else "[图片]"}],
+            }
             for image_url in image_urls:
-                image_part = await resolve_image_part(image_url)
-                if image_part:
-                    content_blocks.append(image_part)
-
-        # 如果只有主文本且没有额外内容块和图片，返回简单格式以保持向后兼容
-        if (
-            text
-            and not extra_user_content_parts
-            and not image_urls
-            and len(content_blocks) == 1
-            and content_blocks[0]["type"] == "text"
-        ):
-            return {"role": "user", "content": content_blocks[0]["text"]}
-
-        # 否则返回多模态格式
-        return {"role": "user", "content": content_blocks}
+                if image_url.startswith("http"):
+                    image_path = await download_image_by_url(image_url)
+                    image_data = await self.encode_image_bs64(image_path)
+                elif image_url.startswith("file:///"):
+                    image_path = image_url.replace("file:///", "")
+                    image_data = await self.encode_image_bs64(image_path)
+                else:
+                    image_data = await self.encode_image_bs64(image_url)
+                if not image_data:
+                    logger.warning(f"图片 {image_url} 得到的结果为空，将忽略。")
+                    continue
+                user_content["content"].append(
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": image_data},
+                    },
+                )
+            return user_content
+        return {"role": "user", "content": text}
 
     async def encode_image_bs64(self, image_url: str) -> str:
         """将图片转换为 base64"""

astrbot/core/provider/sources/minimax_tts_api_source.py

@@ -51,7 +51,7 @@ class ProviderMiniMaxTTSAPI(TTSProvider):
             "voice_id": ""
             if self.is_timber_weight
             else provider_config.get("minimax-voice-id", ""),
-            "emotion": provider_config.get("minimax-voice-emotion", "auto"),
+            "emotion": provider_config.get("minimax-voice-emotion", "neutral"),
             "latex_read": provider_config.get("minimax-voice-latex", False),
             "english_normalization": provider_config.get(
                 "minimax-voice-english-normalization",
@@ -59,9 +59,6 @@ class ProviderMiniMaxTTSAPI(TTSProvider):
             ),
         }
 
-        if self.voice_setting["emotion"] == "auto":
-            self.voice_setting.pop("emotion", None)
-
         self.audio_setting: dict = {
             "sample_rate": 32000,
             "bitrate": 128000,

astrbot/core/provider/sources/openai_source.py

@@ -17,7 +17,7 @@ from openai.types.completion_usage import CompletionUsage
 import astrbot.core.message.components as Comp
 from astrbot import logger
 from astrbot.api.provider import Provider
-from astrbot.core.agent.message import ContentPart, ImageURLPart, Message, TextPart
+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, TokenUsage, ToolCallsResult
@@ -69,11 +69,34 @@ class ProviderOpenAIOfficial(Provider):
             self.client.chat.completions.create,
         ).parameters.keys()
 
-        model = provider_config.get("model", "unknown")
+        model_config = provider_config.get("model_config", {})
+        model = model_config.get("model", "unknown")
         self.set_model(model)
 
         self.reasoning_key = "reasoning_content"
 
+    def _maybe_inject_xai_search(self, payloads: dict, **kwargs):
+        """当开启 xAI 原生搜索时，向请求体注入 Live Search 参数。
+
+        - 仅在 provider_config.xai_native_search 为 True 时生效
+        - 默认注入 {"mode": "auto"}
+        - 允许通过 kwargs 使用 xai_search_mode 覆盖（on/auto/off）
+        """
+        if not bool(self.provider_config.get("xai_native_search", False)):
+            return
+
+        mode = kwargs.get("xai_search_mode", "auto")
+        mode = str(mode).lower()
+        if mode not in ("auto", "on", "off"):
+            mode = "auto"
+
+        # off 时不注入，保持与未开启一致
+        if mode == "off":
+            return
+
+        # OpenAI SDK 不识别的字段会在 _query/_query_stream 中放入 extra_body
+        payloads["search_parameters"] = {"mode": mode}
+
     async def get_models(self):
         try:
             models_str = []
@@ -112,6 +135,10 @@ class ProviderOpenAIOfficial(Provider):
 
         model = payloads.get("model", "").lower()
 
+        # 针对 deepseek 模型的特殊处理：deepseek-reasoner调用必须移除 tools ，否则将被切换至 deepseek-chat
+        if model == "deepseek-reasoner" and "tools" in payloads:
+            del payloads["tools"]
+
         completion = await self.client.chat.completions.create(
             **payloads,
             stream=False,
@@ -225,14 +252,10 @@ class ProviderOpenAIOfficial(Provider):
     def _extract_usage(self, usage: CompletionUsage) -> TokenUsage:
         ptd = usage.prompt_tokens_details
         cached = ptd.cached_tokens if ptd and ptd.cached_tokens else 0
-        prompt_tokens = 0 if usage.prompt_tokens is None else usage.prompt_tokens
-        completion_tokens = (
-            0 if usage.completion_tokens is None else usage.completion_tokens
-        )
         return TokenUsage(
-            input_other=prompt_tokens - cached,
-            input_cached=cached,
-            output=completion_tokens,
+            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(
@@ -326,7 +349,6 @@ class ProviderOpenAIOfficial(Provider):
         system_prompt: str | None = None,
         tool_calls_result: ToolCallsResult | list[ToolCallsResult] | None = None,
         model: str | None = None,
-        extra_user_content_parts: list[ContentPart] | None = None,
         **kwargs,
     ) -> tuple:
         """准备聊天所需的有效载荷和上下文"""
@@ -334,9 +356,7 @@ class ProviderOpenAIOfficial(Provider):
             contexts = []
         new_record = None
         if prompt is not None:
-            new_record = await self.assemble_context(
-                prompt, image_urls, extra_user_content_parts
-            )
+            new_record = await self.assemble_context(prompt, image_urls)
         context_query = self._ensure_message_to_dicts(contexts)
         if new_record:
             context_query.append(new_record)
@@ -355,31 +375,16 @@ class ProviderOpenAIOfficial(Provider):
                 for tcr in tool_calls_result:
                     context_query.extend(tcr.to_openai_messages())
 
-        model = model or self.get_model()
+        model_config = self.provider_config.get("model_config", {})
+        model_config["model"] = model or self.get_model()
 
-        payloads = {"messages": context_query, "model": model}
+        payloads = {"messages": context_query, **model_config}
 
-        self._finally_convert_payload(payloads)
+        # xAI origin search tool inject
+        self._maybe_inject_xai_search(payloads, **kwargs)
 
         return payloads, context_query
 
-    def _finally_convert_payload(self, payloads: dict):
-        """Finally convert the payload. Such as think part conversion, tool inject."""
-        for message in payloads.get("messages", []):
-            if message.get("role") == "assistant" and isinstance(
-                message.get("content"), list
-            ):
-                reasoning_content = ""
-                new_content = []  # not including think part
-                for part in message["content"]:
-                    if part.get("type") == "think":
-                        reasoning_content += str(part.get("think"))
-                    else:
-                        new_content.append(part)
-                message["content"] = new_content
-                # reasoning key is "reasoning_content"
-                message["reasoning_content"] = reasoning_content
-
     async def _handle_api_error(
         self,
         e: Exception,
@@ -473,7 +478,6 @@ class ProviderOpenAIOfficial(Provider):
         system_prompt=None,
         tool_calls_result=None,
         model=None,
-        extra_user_content_parts=None,
         **kwargs,
     ) -> LLMResponse:
         payloads, context_query = await self._prepare_chat_payload(
@@ -483,7 +487,6 @@ class ProviderOpenAIOfficial(Provider):
             system_prompt,
             tool_calls_result,
             model=model,
-            extra_user_content_parts=extra_user_content_parts,
             **kwargs,
         )
 
@@ -623,71 +626,33 @@ class ProviderOpenAIOfficial(Provider):
         self,
         text: str,
         image_urls: list[str] | None = None,
-        extra_user_content_parts: list[ContentPart] | None = None,
     ) -> dict:
         """组装成符合 OpenAI 格式的 role 为 user 的消息段"""
-
-        async def resolve_image_part(image_url: str) -> dict | None:
-            if image_url.startswith("http"):
-                image_path = await download_image_by_url(image_url)
-                image_data = await self.encode_image_bs64(image_path)
-            elif image_url.startswith("file:///"):
-                image_path = image_url.replace("file:///", "")
-                image_data = await self.encode_image_bs64(image_path)
-            else:
-                image_data = await self.encode_image_bs64(image_url)
-            if not image_data:
-                logger.warning(f"图片 {image_url} 得到的结果为空，将忽略。")
-                return None
-            return {
-                "type": "image_url",
-                "image_url": {"url": image_data},
-            }
-
-        # 构建内容块列表
-        content_blocks = []
-
-        # 1. 用户原始发言（OpenAI 建议：用户发言在前）
-        if text:
-            content_blocks.append({"type": "text", "text": text})
-        elif image_urls:
-            # 如果没有文本但有图片，添加占位文本
-            content_blocks.append({"type": "text", "text": "[图片]"})
-        elif extra_user_content_parts:
-            # 如果只有额外内容块，也需要添加占位文本
-            content_blocks.append({"type": "text", "text": " "})
-
-        # 2. 额外的内容块（系统提醒、指令等）
-        if extra_user_content_parts:
-            for part in extra_user_content_parts:
-                if isinstance(part, TextPart):
-                    content_blocks.append({"type": "text", "text": part.text})
-                elif isinstance(part, ImageURLPart):
-                    image_part = await resolve_image_part(part.image_url.url)
-                    if image_part:
-                        content_blocks.append(image_part)
-                else:
-                    raise ValueError(f"不支持的额外内容块类型: {type(part)}")
-
-        # 3. 图片内容
         if image_urls:
+            user_content = {
+                "role": "user",
+                "content": [{"type": "text", "text": text if text else "[图片]"}],
+            }
             for image_url in image_urls:
-                image_part = await resolve_image_part(image_url)
-                if image_part:
-                    content_blocks.append(image_part)
-
-        # 如果只有主文本且没有额外内容块和图片，返回简单格式以保持向后兼容
-        if (
-            text
-            and not extra_user_content_parts
-            and not image_urls
-            and len(content_blocks) == 1
-            and content_blocks[0]["type"] == "text"
-        ):
-            return {"role": "user", "content": content_blocks[0]["text"]}
-
-        # 否则返回多模态格式
-        return {"role": "user", "content": content_blocks}
+                if image_url.startswith("http"):
+                    image_path = await download_image_by_url(image_url)
+                    image_data = await self.encode_image_bs64(image_path)
+                elif image_url.startswith("file:///"):
+                    image_path = image_url.replace("file:///", "")
+                    image_data = await self.encode_image_bs64(image_path)
+                else:
+                    image_data = await self.encode_image_bs64(image_url)
+                if not image_data:
+                    logger.warning(f"图片 {image_url} 得到的结果为空，将忽略。")
+                    continue
+                user_content["content"].append(
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": image_data},
+                    },
+                )
+            return user_content
+        return {"role": "user", "content": text}
 
     async def encode_image_bs64(self, image_url: str) -> str:
         """将图片转换为 base64"""

astrbot/core/provider/sources/xai_source.py

@@ -1,29 +0,0 @@
-from ..register import register_provider_adapter
-from .openai_source import ProviderOpenAIOfficial
-
-
-@register_provider_adapter(
-    "xai_chat_completion", "xAI Chat Completion Provider Adapter"
-)
-class ProviderXAI(ProviderOpenAIOfficial):
-    def __init__(
-        self,
-        provider_config: dict,
-        provider_settings: dict,
-    ) -> None:
-        super().__init__(provider_config, provider_settings)
-
-    def _maybe_inject_xai_search(self, payloads: dict):
-        """当开启 xAI 原生搜索时，向请求体注入 Live Search 参数。
-
-        - 仅在 provider_config.xai_native_search 为 True 时生效
-        - 默认注入 {"mode": "auto"}
-        """
-        if not bool(self.provider_config.get("xai_native_search", False)):
-            return
-        # OpenAI SDK 不识别的字段会在 _query/_query_stream 中放入 extra_body
-        payloads["search_parameters"] = {"mode": "auto"}
-
-    def _finally_convert_payload(self, payloads: dict):
-        self._maybe_inject_xai_search(payloads)
-        super()._finally_convert_payload(payloads)

astrbot/core/provider/sources/xinference_stt_provider.py

@@ -8,10 +8,7 @@ from xinference_client.client.restful.async_restful_client import (
 
 from astrbot.core import logger
 from astrbot.core.utils.astrbot_path import get_astrbot_data_path
-from astrbot.core.utils.tencent_record_helper import (
-    convert_to_pcm_wav,
-    tencent_silk_to_wav,
-)
+from astrbot.core.utils.tencent_record_helper import tencent_silk_to_wav
 
 from ..entities import ProviderType
 from ..provider import STTProvider
@@ -114,22 +111,17 @@ class ProviderXinferenceSTT(STTProvider):
                 return ""
 
             # 2. Check for conversion
-            conversion_type = None
-
-            if b"SILK" in audio_bytes[:8]:
-                conversion_type = "silk"
-            elif b"#!AMR" in audio_bytes[:6]:
-                conversion_type = "amr"
-            elif audio_url.endswith(".silk") or is_tencent:
-                conversion_type = "silk"
-            elif audio_url.endswith(".amr"):
-                conversion_type = "amr"
+            needs_conversion = False
+            if (
+                audio_url.endswith((".amr", ".silk"))
+                or is_tencent
+                or b"SILK" in audio_bytes[:8]
+            ):
+                needs_conversion = True
 
             # 3. Perform conversion if needed
-            if conversion_type:
-                logger.info(
-                    f"Audio requires conversion ({conversion_type}), using temporary files..."
-                )
+            if needs_conversion:
+                logger.info("Audio requires conversion, using temporary files...")
                 temp_dir = os.path.join(get_astrbot_data_path(), "temp")
                 os.makedirs(temp_dir, exist_ok=True)
 
@@ -140,12 +132,8 @@ class ProviderXinferenceSTT(STTProvider):
                 with open(input_path, "wb") as f:
                     f.write(audio_bytes)
 
-                if conversion_type == "silk":
-                    logger.info("Converting silk to wav ...")
-                    await tencent_silk_to_wav(input_path, output_path)
-                elif conversion_type == "amr":
-                    logger.info("Converting amr to wav ...")
-                    await convert_to_pcm_wav(input_path, output_path)
+                logger.info("Converting silk/amr file to wav ...")
+                await tencent_silk_to_wav(input_path, output_path)
 
                 with open(output_path, "rb") as f:
                     audio_bytes = f.read()

astrbot/core/star/command_management.py

@@ -4,7 +4,7 @@ from collections import defaultdict
 from dataclasses import dataclass, field
 from typing import Any
 
-from astrbot.core import db_helper, logger
+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
@@ -90,7 +90,6 @@ async def toggle_command(handler_full_name: str, enabled: bool) -> CommandDescri
 async def rename_command(
     handler_full_name: str,
     new_fragment: str,
-    aliases: list[str] | None = None,
 ) -> CommandDescriptor:
     descriptor = _build_descriptor_by_full_name(handler_full_name)
     if not descriptor:
@@ -100,24 +99,9 @@ async def rename_command(
     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(f"指令名 '{candidate_full}' 已被其他指令占用。")
-
-    # 校验别名
-    if aliases:
-        for alias in aliases:
-            alias = alias.strip()
-            if not alias:
-                continue
-            alias_full = _compose_command(descriptor.parent_signature, alias)
-            if _is_command_in_use(handler_full_name, alias_full):
-                raise ValueError(f"别名 '{alias_full}' 已被其他指令占用。")
-
-    existing_cfg = await db_helper.get_command_config(handler_full_name)
-    merged_extra = dict(existing_cfg.extra_data or {}) if existing_cfg else {}
-    merged_extra["resolved_aliases"] = aliases or []
+        raise ValueError("新的指令名已被其他指令占用，请换一个名称。")
 
     config = await db_helper.upsert_command_config(
         handler_full_name=handler_full_name,
@@ -130,7 +114,7 @@ async def rename_command(
         conflict_key=descriptor.original_command,
         resolution_strategy="manual_rename",
         note=None,
-        extra_data=merged_extra,
+        extra_data=None,
         auto_managed=False,
     )
     _bind_descriptor_with_config(descriptor, config)
@@ -208,18 +192,12 @@ def _collect_descriptors(include_sub_commands: bool) -> list[CommandDescriptor]:
     """收集指令，按需包含子指令。"""
     descriptors: list[CommandDescriptor] = []
     for handler in star_handlers_registry:
-        try:
-            desc = _build_descriptor(handler)
-            if not desc:
-                continue
-            if not include_sub_commands and desc.is_sub_command:
-                continue
-            descriptors.append(desc)
-        except Exception as e:
-            logger.warning(
-                f"解析指令处理函数 {handler.handler_full_name} 失败，跳过该指令。原因: {e!s}"
-            )
+        desc = _build_descriptor(handler)
+        if not desc:
             continue
+        if not include_sub_commands and desc.is_sub_command:
+            continue
+        descriptors.append(desc)
     return descriptors
 
 
@@ -379,27 +357,14 @@ def _apply_config_to_descriptor(
         new_fragment,
     )
 
-    extra = config.extra_data or {}
-    resolved_aliases = extra.get("resolved_aliases")
-    if isinstance(resolved_aliases, list):
-        descriptor.aliases = [str(x) for x in resolved_aliases if str(x).strip()]
-
 
 def _apply_config_to_runtime(
     descriptor: CommandDescriptor,
     config: CommandConfig,
 ) -> None:
     descriptor.handler.enabled = config.enabled
-    if descriptor.filter_ref:
-        if descriptor.current_fragment:
-            _set_filter_fragment(descriptor.filter_ref, descriptor.current_fragment)
-        extra = config.extra_data or {}
-        resolved_aliases = extra.get("resolved_aliases")
-        if isinstance(resolved_aliases, list):
-            _set_filter_aliases(
-                descriptor.filter_ref,
-                [str(x) for x in resolved_aliases if str(x).strip()],
-            )
+    if descriptor.filter_ref and descriptor.current_fragment:
+        _set_filter_fragment(descriptor.filter_ref, descriptor.current_fragment)
 
 
 def _bind_configs_to_descriptors(
@@ -438,18 +403,6 @@ def _set_filter_fragment(
         filter_ref._cmpl_cmd_names = None
 
 
-def _set_filter_aliases(
-    filter_ref: CommandFilter | CommandGroupFilter,
-    aliases: list[str],
-) -> None:
-    current_aliases = getattr(filter_ref, "alias", set())
-    if set(aliases) == current_aliases:
-        return
-    setattr(filter_ref, "alias", set(aliases))
-    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,

astrbot/core/star/context.py

@@ -267,10 +267,6 @@ class Context:
     ):
         """通过 ID 获取对应的 LLM Provider。"""
         prov = self.provider_manager.inst_map.get(provider_id)
-        if provider_id and not prov:
-            logger.warning(
-                f"没有找到 ID 为 {provider_id} 的提供商，这可能是由于您修改了提供商（模型）ID 导致的。"
-            )
         return prov
 
     def get_all_providers(self) -> list[Provider]:
@@ -300,6 +296,10 @@ class Context:
             provider_type=ProviderType.CHAT_COMPLETION,
             umo=umo,
         )
+        if prov is None:
+            raise ProviderNotFoundError(
+                "provider not found, please choose provider first"
+            )
         if not isinstance(prov, Provider):
             raise ValueError("返回的 Provider 不是 Provider 类型")
         return prov
@@ -377,7 +377,7 @@ class Context:
             if not module_path:
                 _parts = []
                 module_part = tool.__module__.split(".")
-                flags = ["builtin_stars", "plugins"]
+                flags = ["packages", "plugins"]
                 for i, part in enumerate(module_part):
                     _parts.append(part)
                     if part in flags and i + 1 < len(module_part):

astrbot/core/star/star_manager.py

@@ -18,7 +18,6 @@ from astrbot.core.config.astrbot_config import AstrBotConfig
 from astrbot.core.provider.register import llm_tools
 from astrbot.core.utils.astrbot_path import (
     get_astrbot_config_path,
-    get_astrbot_path,
     get_astrbot_plugin_path,
 )
 from astrbot.core.utils.io import remove_dir
@@ -50,10 +49,13 @@ class PluginManager:
         """存储插件的路径。即 data/plugins"""
         self.plugin_config_path = get_astrbot_config_path()
         """存储插件配置的路径。data/config"""
-        self.reserved_plugin_path = os.path.join(
-            get_astrbot_path(), "astrbot", "builtin_stars"
+        self.reserved_plugin_path = os.path.abspath(
+            os.path.join(
+                os.path.dirname(os.path.abspath(__file__)),
+                "../../../packages",
+            ),
         )
-        """保留插件的路径。在 astrbot/builtin_stars 目录下"""
+        """保留插件的路径。在 packages 目录下"""
         self.conf_schema_fname = "_conf_schema.json"
         self.logo_fname = "logo.png"
         """插件配置 Schema 文件名"""
@@ -250,7 +252,7 @@ class PluginManager:
             list[str]: 与该插件相关的模块名列表
 
         """
-        prefix = "astrbot.builtin_stars." if is_reserved else "data.plugins."
+        prefix = "packages." if is_reserved else "data.plugins."
         return [
             key
             for key in list(sys.modules.keys())
@@ -268,7 +270,7 @@ class PluginManager:
         可以基于模块名模式或插件目录名移除模块，用于清理插件相关的模块缓存
 
         Args:
-            module_patterns: 要移除的模块名模式列表（例如 ["data.plugins", "astrbot.builtin_stars"]）
+            module_patterns: 要移除的模块名模式列表（例如 ["data.plugins", "packages"]）
             root_dir_name: 插件根目录名，用于移除与该插件相关的所有模块
             is_reserved: 插件是否为保留插件（影响模块路径前缀）
 
@@ -380,9 +382,9 @@ class PluginManager:
                 reserved = plugin_module.get(
                     "reserved",
                     False,
-                )  # 是否是保留插件。目前在 astrbot/builtin_stars 目录下的都是保留插件。保留插件不可以卸载。
+                )  # 是否是保留插件。目前在 packages/ 目录下的都是保留插件。保留插件不可以卸载。
 
-                path = "data.plugins." if not reserved else "astrbot.builtin_stars."
+                path = "data.plugins." if not reserved else "packages."
                 path += root_dir_name + "." + module_str
 
                 # 检查是否需要载入指定的插件
@@ -629,11 +631,7 @@ class PluginManager:
         # 清除 pip.main 导致的多余的 logging handlers
         for handler in logging.root.handlers[:]:
             logging.root.removeHandler(handler)
-        try:
-            await sync_command_configs()
-        except Exception as e:
-            logger.error(f"同步指令配置失败: {e!s}")
-            logger.error(traceback.format_exc())
+        await sync_command_configs()
 
         if not fail_rec:
             return True, None
@@ -827,7 +825,7 @@ class PluginManager:
             if (
                 mp
                 and mp.startswith(plugin_module_path)
-                and not mp.endswith(("astrbot.builtin_stars", "data.plugins"))
+                and not mp.endswith(("packages", "data.plugins"))
             ):
                 to_remove.append(func_tool)
         for func_tool in to_remove:
@@ -882,7 +880,7 @@ class PluginManager:
                     plugin.module_path
                     and mp
                     and plugin.module_path.startswith(mp)
-                    and not mp.endswith(("astrbot.builtin_stars", "data.plugins"))
+                    and not mp.endswith(("packages", "data.plugins"))
                 ):
                     func_tool.active = False
                     if func_tool.name not in inactivated_llm_tools:
@@ -931,7 +929,7 @@ class PluginManager:
                 plugin.module_path
                 and mp
                 and plugin.module_path.startswith(mp)
-                and not mp.endswith(("astrbot.builtin_stars", "data.plugins"))
+                and not mp.endswith(("packages", "data.plugins"))
                 and func_tool.name in inactivated_llm_tools
             ):
                 inactivated_llm_tools.remove(func_tool.name)
@@ -944,49 +942,8 @@ class PluginManager:
         dir_name = os.path.basename(zip_file_path).replace(".zip", "")
         dir_name = dir_name.removesuffix("-master").removesuffix("-main").lower()
         desti_dir = os.path.join(self.plugin_store_path, dir_name)
-
-        # 第一步：检查是否已安装同目录名的插件，先终止旧插件
-        existing_plugin = None
-        for star in self.context.get_all_stars():
-            if star.root_dir_name == dir_name:
-                existing_plugin = star
-                break
-
-        if existing_plugin:
-            logger.info(f"检测到插件 {existing_plugin.name} 已安装，正在终止旧插件...")
-            try:
-                await self._terminate_plugin(existing_plugin)
-            except Exception:
-                logger.warning(traceback.format_exc())
-            if existing_plugin.name and existing_plugin.module_path:
-                await self._unbind_plugin(
-                    existing_plugin.name, existing_plugin.module_path
-                )
-
         self.updator.unzip_file(zip_file_path, desti_dir)
 
-        # 第二步：解压后，读取新插件的 metadata.yaml，检查是否存在同名但不同目录的插件
-        try:
-            new_metadata = self._load_plugin_metadata(desti_dir)
-            if new_metadata and new_metadata.name:
-                for star in self.context.get_all_stars():
-                    if (
-                        star.name == new_metadata.name
-                        and star.root_dir_name != dir_name
-                    ):
-                        logger.warning(
-                            f"检测到同名插件 {star.name} 存在于不同目录 {star.root_dir_name}，正在终止..."
-                        )
-                        try:
-                            await self._terminate_plugin(star)
-                        except Exception:
-                            logger.warning(traceback.format_exc())
-                        if star.name and star.module_path:
-                            await self._unbind_plugin(star.name, star.module_path)
-                        break  # 只处理第一个匹配的
-        except Exception as e:
-            logger.debug(f"读取新插件 metadata.yaml 失败，跳过同名检查: {e!s}")
-
         # remove the zip
         try:
             os.remove(zip_file_path)

astrbot/core/utils/astrbot_path.py

@@ -5,10 +5,6 @@
 数据目录路径：固定为根目录下的 data 目录
 配置文件路径：固定为数据目录下的 config 目录
 插件目录路径：固定为数据目录下的 plugins 目录
-插件数据目录路径：固定为数据目录下的 plugin_data 目录
-T2I 模板目录路径：固定为数据目录下的 t2i_templates 目录
-WebChat 数据目录路径：固定为数据目录下的 webchat 目录
-临时文件目录路径：固定为数据目录下的 temp 目录
 """
 
 import os
@@ -41,33 +37,3 @@ def get_astrbot_config_path() -> str:
 def get_astrbot_plugin_path() -> str:
     """获取Astrbot插件目录路径"""
     return os.path.realpath(os.path.join(get_astrbot_data_path(), "plugins"))
-
-
-def get_astrbot_plugin_data_path() -> str:
-    """获取Astrbot插件数据目录路径"""
-    return os.path.realpath(os.path.join(get_astrbot_data_path(), "plugin_data"))
-
-
-def get_astrbot_t2i_templates_path() -> str:
-    """获取Astrbot T2I 模板目录路径"""
-    return os.path.realpath(os.path.join(get_astrbot_data_path(), "t2i_templates"))
-
-
-def get_astrbot_webchat_path() -> str:
-    """获取Astrbot WebChat 数据目录路径"""
-    return os.path.realpath(os.path.join(get_astrbot_data_path(), "webchat"))
-
-
-def get_astrbot_temp_path() -> str:
-    """获取Astrbot临时文件目录路径"""
-    return os.path.realpath(os.path.join(get_astrbot_data_path(), "temp"))
-
-
-def get_astrbot_knowledge_base_path() -> str:
-    """获取Astrbot知识库根目录路径"""
-    return os.path.realpath(os.path.join(get_astrbot_data_path(), "knowledge_base"))
-
-
-def get_astrbot_backups_path() -> str:
-    """获取Astrbot备份目录路径"""
-    return os.path.realpath(os.path.join(get_astrbot_data_path(), "backups"))

astrbot/core/utils/llm_metadata.py

@@ -1,63 +0,0 @@
-from typing import Literal, TypedDict
-
-import aiohttp
-
-from astrbot.core import logger
-
-
-class LLMModalities(TypedDict):
-    input: list[Literal["text", "image", "audio", "video"]]
-    output: list[Literal["text", "image", "audio", "video"]]
-
-
-class LLMLimit(TypedDict):
-    context: int
-    output: int
-
-
-class LLMMetadata(TypedDict):
-    id: str
-    reasoning: bool
-    tool_call: bool
-    knowledge: str
-    release_date: str
-    modalities: LLMModalities
-    open_weights: bool
-    limit: LLMLimit
-
-
-LLM_METADATAS: dict[str, LLMMetadata] = {}
-
-
-async def update_llm_metadata():
-    url = "https://models.dev/api.json"
-    try:
-        async with aiohttp.ClientSession() as session:
-            async with session.get(url) as response:
-                data = await response.json()
-                global LLM_METADATAS
-                models = {}
-                for info in data.values():
-                    for model in info.get("models", {}).values():
-                        model_id = model.get("id")
-                        if not model_id:
-                            continue
-                        models[model_id] = LLMMetadata(
-                            id=model_id,
-                            reasoning=model.get("reasoning", False),
-                            tool_call=model.get("tool_call", False),
-                            knowledge=model.get("knowledge", "none"),
-                            release_date=model.get("release_date", ""),
-                            modalities=model.get(
-                                "modalities", {"input": [], "output": []}
-                            ),
-                            open_weights=model.get("open_weights", False),
-                            limit=model.get("limit", {"context": 0, "output": 0}),
-                        )
-                # Replace the global cache in-place so references remain valid
-                LLM_METADATAS.clear()
-                LLM_METADATAS.update(models)
-                logger.info(f"Successfully fetched metadata for {len(models)} LLMs.")
-    except Exception as e:
-        logger.error(f"Failed to fetch LLM metadata: {e}")
-        return

astrbot/core/utils/migra_helper.py

@@ -32,92 +32,6 @@ def _migra_agent_runner_configs(conf: AstrBotConfig, ids_map: dict) -> None:
         logger.error(traceback.format_exc())
 
 
-def _migra_provider_to_source_structure(conf: AstrBotConfig) -> None:
-    """
-    Migrate old provider structure to new provider-source separation.
-    Provider only keeps: id, provider_source_id, model, modalities, custom_extra_body
-    All other fields move to provider_sources.
-    """
-    providers = conf.get("provider", [])
-    provider_sources = conf.get("provider_sources", [])
-
-    # Track if any migration happened
-    migrated = False
-
-    # Provider-only fields that should stay in provider
-    provider_only_fields = {
-        "id",
-        "provider_source_id",
-        "model",
-        "modalities",
-        "custom_extra_body",
-        "enable",
-    }
-
-    # Fields that should not go to source
-    source_exclude_fields = provider_only_fields | {"model_config"}
-
-    for provider in providers:
-        # Skip if already has provider_source_id
-        if provider.get("provider_source_id"):
-            continue
-
-        # Skip non-chat-completion types (they don't need source separation)
-        provider_type = provider.get("provider_type", "")
-        if provider_type != "chat_completion":
-            # For old types without provider_type, check type field
-            old_type = provider.get("type", "")
-            if "chat_completion" not in old_type:
-                continue
-
-        migrated = True
-        logger.info(f"Migrating provider {provider.get('id')} to new structure")
-
-        # Extract source fields from provider
-        source_fields = {}
-        for key, value in list(provider.items()):
-            if key not in source_exclude_fields:
-                source_fields[key] = value
-
-        # Create new provider_source
-        source_id = provider.get("id", "") + "_source"
-        new_source = {"id": source_id, **source_fields}
-
-        # Update provider to only keep necessary fields
-        provider["provider_source_id"] = source_id
-
-        # Extract model from model_config if exists
-        if "model_config" in provider and isinstance(provider["model_config"], dict):
-            model_config = provider["model_config"]
-            provider["model"] = model_config.get("model", "")
-
-            # Put other model_config fields into custom_extra_body
-            extra_body_fields = {k: v for k, v in model_config.items() if k != "model"}
-            if extra_body_fields:
-                if "custom_extra_body" not in provider:
-                    provider["custom_extra_body"] = {}
-                provider["custom_extra_body"].update(extra_body_fields)
-
-        # Initialize new fields if not present
-        if "modalities" not in provider:
-            provider["modalities"] = []
-        if "custom_extra_body" not in provider:
-            provider["custom_extra_body"] = {}
-
-        # Remove fields that should be in source
-        keys_to_remove = [k for k in provider.keys() if k not in provider_only_fields]
-        for key in keys_to_remove:
-            del provider[key]
-
-        # Add source to provider_sources
-        provider_sources.append(new_source)
-
-    if migrated:
-        conf["provider_sources"] = provider_sources
-        conf.save_config()
-        logger.info("Provider-source structure migration completed")
-
-
 async def migra(
     db, astrbot_config_mgr, umop_config_router, acm: AstrBotConfigManager
 ) -> None:
@@ -157,10 +71,3 @@ async def migra(
 
     for conf in acm.confs.values():
         _migra_agent_runner_configs(conf, ids_map)
-
-    # Migrate providers to new structure: extract source fields to provider_sources
-    try:
-        _migra_provider_to_source_structure(astrbot_config)
-    except Exception as e:
-        logger.error(f"Migration for provider-source structure failed: {e!s}")
-        logger.error(traceback.format_exc())

astrbot/core/utils/pip_installer.py

@@ -1,29 +1,10 @@
 import asyncio
-import locale
 import logging
 import sys
 
 logger = logging.getLogger("astrbot")
 
 
-def _robust_decode(line: bytes) -> str:
-    """解码字节流，兼容不同平台的编码"""
-    try:
-        return line.decode("utf-8").strip()
-    except UnicodeDecodeError:
-        pass
-    try:
-        return line.decode(locale.getpreferredencoding(False)).strip()
-    except UnicodeDecodeError:
-        pass
-    if sys.platform.startswith("win"):
-        try:
-            return line.decode("gbk").strip()
-        except UnicodeDecodeError:
-            pass
-    return line.decode("utf-8", errors="replace").strip()
-
-
 class PipInstaller:
     def __init__(self, pip_install_arg: str, pypi_index_url: str | None = None):
         self.pip_install_arg = pip_install_arg
@@ -61,7 +42,7 @@ class PipInstaller:
 
             assert process.stdout is not None
             async for line in process.stdout:
-                logger.info(_robust_decode(line))
+                logger.info(line.decode().strip())
 
             await process.wait()
 

astrbot/dashboard/routes/__init__.py

@@ -1,5 +1,4 @@
 from .auth import AuthRoute
-from .backup import BackupRoute
 from .chat import ChatRoute
 from .command import CommandRoute
 from .config import ConfigRoute
@@ -18,7 +17,6 @@ from .update import UpdateRoute
 
 __all__ = [
     "AuthRoute",
-    "BackupRoute",
     "ChatRoute",
     "CommandRoute",
     "ConfigRoute",

astrbot/dashboard/routes/chat.py

@@ -436,7 +436,7 @@ class ChatRoute(Route):
                             accumulated_parts = []
                             accumulated_text = ""
                             accumulated_reasoning = ""
-                            # tool_calls = {}
+                            tool_calls = {}
                             agent_stats = {}
             except BaseException as e:
                 logger.exception(f"WebChat stream unexpected error: {e}", exc_info=True)

astrbot/dashboard/routes/command.py

@@ -61,13 +61,12 @@ class CommandRoute(Route):
         data = await request.get_json()
         handler_full_name = data.get("handler_full_name")
         new_name = data.get("new_name")
-        aliases = data.get("aliases")
 
         if not handler_full_name or not new_name:
             return Response().error("handler_full_name 与 new_name 均为必填。").__dict__
 
         try:
-            await rename_command_service(handler_full_name, new_name, aliases=aliases)
+            await rename_command_service(handler_full_name, new_name)
         except ValueError as exc:
             return Response().error(str(exc)).__dict__
 

astrbot/dashboard/routes/config.py

@@ -6,7 +6,7 @@ from typing import Any
 
 from quart import request
 
-from astrbot.core import astrbot_config, file_token_service, logger
+from astrbot.core import file_token_service, logger
 from astrbot.core.config.astrbot_config import AstrBotConfig
 from astrbot.core.config.default import (
     CONFIG_METADATA_2,
@@ -21,7 +21,6 @@ from astrbot.core.platform.register import platform_cls_map, platform_registry
 from astrbot.core.provider import Provider
 from astrbot.core.provider.register import provider_registry
 from astrbot.core.star.star import star_registry
-from astrbot.core.utils.llm_metadata import LLM_METADATAS
 from astrbot.core.utils.webhook_utils import ensure_platform_webhook_config
 
 from .route import Response, Route, RouteContext
@@ -46,46 +45,6 @@ def try_cast(value: Any, type_: str):
             return None
 
 
-def _expect_type(value, expected_type, path_key, errors, expected_name=None):
-    if not isinstance(value, expected_type):
-        errors.append(
-            f"错误的类型 {path_key}: 期望是 {expected_name or expected_type.__name__}, "
-            f"得到了 {type(value).__name__}"
-        )
-        return False
-    return True
-
-
-def _validate_template_list(value, meta, path_key, errors, validate_fn):
-    if not _expect_type(value, list, path_key, errors, "list"):
-        return
-
-    templates = meta.get("templates")
-    if not isinstance(templates, dict):
-        templates = {}
-
-    for idx, item in enumerate(value):
-        item_path = f"{path_key}[{idx}]"
-        if not _expect_type(item, dict, item_path, errors, "dict"):
-            continue
-
-        template_key = item.get("__template_key") or item.get("template")
-        if not template_key:
-            errors.append(f"缺少模板选择 {item_path}: 需要 __template_key")
-            continue
-
-        template_meta = templates.get(template_key)
-        if not template_meta:
-            errors.append(f"未知模板 {item_path}: {template_key}")
-            continue
-
-        validate_fn(
-            item,
-            template_meta.get("items", {}),
-            path=f"{item_path}.",
-        )
-
-
 def validate_config(data, schema: dict, is_core: bool) -> tuple[list[str], dict]:
     errors = []
 
@@ -101,11 +60,6 @@ def validate_config(data, schema: dict, is_core: bool) -> tuple[list[str], dict]
             if value is None:
                 data[key] = DEFAULT_VALUE_MAP[meta["type"]]
                 continue
-
-            if meta["type"] == "template_list":
-                _validate_template_list(value, meta, f"{path}{key}", errors, validate)
-                continue
-
             if meta["type"] == "list" and not isinstance(value, list):
                 errors.append(
                     f"错误的类型 {path}{key}: 期望是 list, 得到了 {type(value).__name__}",
@@ -225,157 +179,13 @@ class ConfigRoute(Route):
             "/config/provider/new": ("POST", self.post_new_provider),
             "/config/provider/update": ("POST", self.post_update_provider),
             "/config/provider/delete": ("POST", self.post_delete_provider),
-            "/config/provider/template": ("GET", self.get_provider_template),
             "/config/provider/check_one": ("GET", self.check_one_provider_status),
             "/config/provider/list": ("GET", self.get_provider_config_list),
             "/config/provider/model_list": ("GET", self.get_provider_model_list),
             "/config/provider/get_embedding_dim": ("POST", self.get_embedding_dim),
-            "/config/provider_sources/models": (
-                "GET",
-                self.get_provider_source_models,
-            ),
-            "/config/provider_sources/update": (
-                "POST",
-                self.update_provider_source,
-            ),
-            "/config/provider_sources/delete": (
-                "POST",
-                self.delete_provider_source,
-            ),
         }
         self.register_routes()
 
-    async def delete_provider_source(self):
-        """删除 provider_source，并更新关联的 providers"""
-        post_data = await request.json
-        if not post_data:
-            return Response().error("缺少配置数据").__dict__
-
-        provider_source_id = post_data.get("id")
-        if not provider_source_id:
-            return Response().error("缺少 provider_source_id").__dict__
-
-        provider_sources = self.config.get("provider_sources", [])
-        target_idx = next(
-            (
-                i
-                for i, ps in enumerate(provider_sources)
-                if ps.get("id") == provider_source_id
-            ),
-            -1,
-        )
-
-        if target_idx == -1:
-            return Response().error("未找到对应的 provider source").__dict__
-
-        # 删除 provider_source
-        del provider_sources[target_idx]
-
-        # 写回配置
-        self.config["provider_sources"] = provider_sources
-
-        # 删除引用了该 provider_source 的 providers
-        await self.core_lifecycle.provider_manager.delete_provider(
-            provider_source_id=provider_source_id
-        )
-
-        try:
-            save_config(self.config, self.config, is_core=True)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response().error(str(e)).__dict__
-
-        return Response().ok(message="删除 provider source 成功").__dict__
-
-    async def update_provider_source(self):
-        """更新或新增 provider_source，并重载关联的 providers"""
-        post_data = await request.json
-        if not post_data:
-            return Response().error("缺少配置数据").__dict__
-
-        new_source_config = post_data.get("config") or post_data
-        original_id = post_data.get("original_id")
-        if not original_id:
-            return Response().error("缺少 original_id").__dict__
-
-        if not isinstance(new_source_config, dict):
-            return Response().error("缺少或错误的配置数据").__dict__
-
-        # 确保配置中有 id 字段
-        if not new_source_config.get("id"):
-            new_source_config["id"] = original_id
-
-        provider_sources = self.config.get("provider_sources", [])
-
-        for ps in provider_sources:
-            if ps.get("id") == new_source_config["id"] and ps.get("id") != original_id:
-                return (
-                    Response()
-                    .error(
-                        f"Provider source ID '{new_source_config['id']}' exists already, please try another ID.",
-                    )
-                    .__dict__
-                )
-
-        # 查找旧的 provider_source，若不存在则追加为新配置
-        target_idx = next(
-            (i for i, ps in enumerate(provider_sources) if ps.get("id") == original_id),
-            -1,
-        )
-
-        old_id = original_id
-        if target_idx == -1:
-            provider_sources.append(new_source_config)
-        else:
-            old_id = provider_sources[target_idx].get("id")
-            provider_sources[target_idx] = new_source_config
-
-        # 更新引用了该 provider_source 的 providers
-        affected_providers = []
-        for provider in self.config.get("provider", []):
-            if provider.get("provider_source_id") == old_id:
-                provider["provider_source_id"] = new_source_config["id"]
-                affected_providers.append(provider)
-
-        # 写回配置
-        self.config["provider_sources"] = provider_sources
-
-        try:
-            save_config(self.config, self.config, is_core=True)
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response().error(str(e)).__dict__
-
-        # 重载受影响的 providers，使新的 source 配置生效
-        reload_errors = []
-        prov_mgr = self.core_lifecycle.provider_manager
-        for provider in affected_providers:
-            try:
-                await prov_mgr.reload(provider)
-            except Exception as e:
-                logger.error(traceback.format_exc())
-                reload_errors.append(f"{provider.get('id')}: {e}")
-
-        if reload_errors:
-            return (
-                Response()
-                .error("更新成功，但部分提供商重载失败: " + ", ".join(reload_errors))
-                .__dict__
-            )
-
-        return Response().ok(message="更新 provider source 成功").__dict__
-
-    async def get_provider_template(self):
-        config_schema = {
-            "provider": CONFIG_METADATA_2["provider_group"]["metadata"]["provider"]
-        }
-        data = {
-            "config_schema": config_schema,
-            "providers": astrbot_config["provider"],
-            "provider_sources": astrbot_config["provider_sources"],
-        }
-        return Response().ok(data=data).__dict__
-
     async def get_uc_table(self):
         """获取 UMOP 配置路由表"""
         return Response().ok({"routing": self.ucr.umop_to_conf_id}).__dict__
@@ -623,25 +433,9 @@ class ConfigRoute(Route):
             return Response().error("缺少参数 provider_type").__dict__
         provider_type_ls = provider_type.split(",")
         provider_list = []
-        ps = self.core_lifecycle.provider_manager.providers_config
-        p_source_pt = {
-            psrc["id"]: psrc["provider_type"]
-            for psrc in self.core_lifecycle.provider_manager.provider_sources_config
-        }
-        for provider in ps:
-            ps_id = provider.get("provider_source_id", None)
-            if (
-                ps_id
-                and ps_id in p_source_pt
-                and p_source_pt[ps_id] in provider_type_ls
-            ):
-                # chat
-                prov = self.core_lifecycle.provider_manager.get_merged_provider_config(
-                    provider
-                )
-                provider_list.append(prov)
-            elif not ps_id and provider.get("provider_type", None) in provider_type_ls:
-                # agent runner, embedding, etc
+        astrbot_config = self.core_lifecycle.astrbot_config
+        for provider in astrbot_config["provider"]:
+            if provider.get("provider_type", None) in provider_type_ls:
                 provider_list.append(provider)
         return Response().ok(provider_list).__dict__
 
@@ -664,18 +458,9 @@ class ConfigRoute(Route):
 
         try:
             models = await provider.get_models()
-            models = models or []
-
-            metadata_map = {}
-            for model_id in models:
-                meta = LLM_METADATAS.get(model_id)
-                if meta:
-                    metadata_map[model_id] = meta
-
             ret = {
                 "models": models,
                 "provider_id": provider_id,
-                "model_metadata": metadata_map,
             }
             return Response().ok(ret).__dict__
         except Exception as e:
@@ -737,104 +522,6 @@ class ConfigRoute(Route):
             logger.error(traceback.format_exc())
             return Response().error(f"获取嵌入维度失败: {e!s}").__dict__
 
-    async def get_provider_source_models(self):
-        """获取指定 provider_source 支持的模型列表
-
-        本质上会临时初始化一个 Provider 实例，调用 get_models() 获取模型列表，然后销毁实例
-        """
-        provider_source_id = request.args.get("source_id")
-        if not provider_source_id:
-            return Response().error("缺少参数 source_id").__dict__
-
-        try:
-            from astrbot.core.provider.register import provider_cls_map
-
-            # 从配置中查找对应的 provider_source
-            provider_sources = self.config.get("provider_sources", [])
-            provider_source = None
-            for ps in provider_sources:
-                if ps.get("id") == provider_source_id:
-                    provider_source = ps
-                    break
-
-            if not provider_source:
-                return (
-                    Response()
-                    .error(f"未找到 ID 为 {provider_source_id} 的 provider_source")
-                    .__dict__
-                )
-
-            # 获取 provider 类型
-            provider_type = provider_source.get("type", None)
-            if not provider_type:
-                return Response().error("provider_source 缺少 type 字段").__dict__
-
-            try:
-                self.core_lifecycle.provider_manager.dynamic_import_provider(
-                    provider_type
-                )
-            except ImportError as e:
-                logger.error(traceback.format_exc())
-                return Response().error(f"动态导入提供商适配器失败: {e!s}").__dict__
-
-            # 获取对应的 provider 类
-            if provider_type not in provider_cls_map:
-                return (
-                    Response()
-                    .error(f"未找到适用于 {provider_type} 的提供商适配器")
-                    .__dict__
-                )
-
-            provider_metadata = provider_cls_map[provider_type]
-            cls_type = provider_metadata.cls_type
-
-            if not cls_type:
-                return Response().error(f"无法找到 {provider_type} 的类").__dict__
-
-            # 检查是否是 Provider 类型
-            if not issubclass(cls_type, Provider):
-                return (
-                    Response()
-                    .error(f"提供商 {provider_type} 不支持获取模型列表")
-                    .__dict__
-                )
-
-            # 临时实例化 provider
-            inst = cls_type(provider_source, {})
-
-            # 如果有 initialize 方法，调用它
-            init_fn = getattr(inst, "initialize", None)
-            if inspect.iscoroutinefunction(init_fn):
-                await init_fn()
-
-            # 获取模型列表
-            models = await inst.get_models()
-            models = models or []
-
-            metadata_map = {}
-            for model_id in models:
-                meta = LLM_METADATAS.get(model_id)
-                if meta:
-                    metadata_map[model_id] = meta
-
-            # 销毁实例（如果有 terminate 方法）
-            terminate_fn = getattr(inst, "terminate", None)
-            if inspect.iscoroutinefunction(terminate_fn):
-                await terminate_fn()
-
-            logger.info(
-                f"获取到 provider_source {provider_source_id} 的模型列表: {models}",
-            )
-
-            return (
-                Response()
-                .ok({"models": models, "model_metadata": metadata_map})
-                .__dict__
-            )
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response().error(f"获取模型列表失败: {e!s}").__dict__
-
     async def get_platform_list(self):
         """获取所有平台的列表"""
         platform_list = []
@@ -846,15 +533,7 @@ class ConfigRoute(Route):
         data = await request.json
         config = data.get("config", None)
         conf_id = data.get("conf_id", None)
-
         try:
-            # 不更新 provider_sources, provider, platform
-            # 这些配置有单独的接口进行更新
-            if conf_id == "default":
-                no_update_keys = ["provider_sources", "provider", "platform"]
-                for key in no_update_keys:
-                    config[key] = self.acm.default_conf[key]
-
             await self._save_astrbot_configs(config, conf_id)
             await self.core_lifecycle.reload_pipeline_scheduler(conf_id)
             return Response().ok(None, "保存成功~").__dict__
@@ -894,30 +573,28 @@ class ConfigRoute(Route):
 
     async def post_new_provider(self):
         new_provider_config = await request.json
-
+        self.config["provider"].append(new_provider_config)
         try:
-            await self.core_lifecycle.provider_manager.create_provider(
-                new_provider_config
+            save_config(self.config, self.config, is_core=True)
+            await self.core_lifecycle.provider_manager.load_provider(
+                new_provider_config,
             )
         except Exception as e:
             return Response().error(str(e)).__dict__
-        return Response().ok(None, "新增服务提供商配置成功").__dict__
+        return Response().ok(None, "新增服务提供商配置成功~").__dict__
 
     async def post_update_platform(self):
         update_platform_config = await request.json
-        origin_platform_id = update_platform_config.get("id", None)
+        platform_id = update_platform_config.get("id", None)
         new_config = update_platform_config.get("config", None)
-        if not origin_platform_id or not new_config:
+        if not platform_id or not new_config:
             return Response().error("参数错误").__dict__
 
-        if origin_platform_id != new_config.get("id", None):
-            return Response().error("机器人名称不允许修改").__dict__
-
         # 如果是支持统一 webhook 模式的平台，且启用了统一 webhook 模式，确保有 webhook_uuid
         ensure_platform_webhook_config(new_config)
 
         for i, platform in enumerate(self.config["platform"]):
-            if platform["id"] == origin_platform_id:
+            if platform["id"] == platform_id:
                 self.config["platform"][i] = new_config
                 break
         else:
@@ -932,15 +609,21 @@ class ConfigRoute(Route):
 
     async def post_update_provider(self):
         update_provider_config = await request.json
-        origin_provider_id = update_provider_config.get("id", None)
+        provider_id = update_provider_config.get("id", None)
         new_config = update_provider_config.get("config", None)
-        if not origin_provider_id or not new_config:
+        if not provider_id or not new_config:
             return Response().error("参数错误").__dict__
 
+        for i, provider in enumerate(self.config["provider"]):
+            if provider["id"] == provider_id:
+                self.config["provider"][i] = new_config
+                break
+        else:
+            return Response().error("未找到对应服务提供商").__dict__
+
         try:
-            await self.core_lifecycle.provider_manager.update_provider(
-                origin_provider_id, new_config
-            )
+            save_config(self.config, self.config, is_core=True)
+            await self.core_lifecycle.provider_manager.reload(new_config)
         except Exception as e:
             return Response().error(str(e)).__dict__
         return Response().ok(None, "更新成功，已经实时生效~").__dict__
@@ -963,17 +646,19 @@ class ConfigRoute(Route):
 
     async def post_delete_provider(self):
         provider_id = await request.json
-        provider_id = provider_id.get("id", "")
-        if not provider_id:
-            return Response().error("缺少参数 id").__dict__
-
+        provider_id = provider_id.get("id")
+        for i, provider in enumerate(self.config["provider"]):
+            if provider["id"] == provider_id:
+                del self.config["provider"][i]
+                break
+        else:
+            return Response().error("未找到对应服务提供商").__dict__
         try:
-            await self.core_lifecycle.provider_manager.delete_provider(
-                provider_id=provider_id
-            )
+            save_config(self.config, self.config, is_core=True)
+            await self.core_lifecycle.provider_manager.terminate_provider(provider_id)
         except Exception as e:
             return Response().error(str(e)).__dict__
-        return Response().ok(None, "删除成功，已经实时生效。").__dict__
+        return Response().ok(None, "删除成功，已经实时生效~").__dict__
 
     async def get_llm_tools(self):
         """获取函数调用工具。包含了本地加载的以及 MCP 服务的工具"""

astrbot/dashboard/routes/log.py

@@ -1,26 +1,15 @@
 import asyncio
 import json
-import time
-from collections.abc import AsyncGenerator
 from typing import cast
 
 from quart import Response as QuartResponse
-from quart import make_response, request
+from quart import make_response
 
 from astrbot.core import LogBroker, logger
 
 from .route import Response, Route, RouteContext
 
 
-def _format_log_sse(log: dict, ts: float) -> str:
-    """辅助函数：格式化 SSE 消息"""
-    payload = {
-        "type": "log",
-        **log,
-    }
-    return f"id: {ts}\ndata: {json.dumps(payload, ensure_ascii=False)}\n\n"
-
-
 class LogRoute(Route):
     def __init__(self, context: RouteContext, log_broker: LogBroker) -> None:
         super().__init__(context)
@@ -32,44 +21,21 @@ class LogRoute(Route):
             methods=["GET"],
         )
 
-    async def _replay_cached_logs(
-        self, last_event_id: str
-    ) -> AsyncGenerator[str, None]:
-        """辅助生成器：重放缓存的日志"""
-        try:
-            last_ts = float(last_event_id)
-            cached_logs = list(self.log_broker.log_cache)
-
-            for log_item in cached_logs:
-                log_ts = float(log_item.get("time", 0))
-
-                if log_ts > last_ts:
-                    yield _format_log_sse(log_item, log_ts)
-
-        except ValueError:
-            pass
-        except Exception as e:
-            logger.error(f"Log SSE 补发历史错误: {e}")
-
-    async def log(self) -> QuartResponse:
-        last_event_id = request.headers.get("Last-Event-ID")
-
+    async def log(self):
         async def stream():
             queue = None
             try:
-                if last_event_id:
-                    async for event in self._replay_cached_logs(last_event_id):
-                        yield event
-
                 queue = self.log_broker.register()
                 while True:
                     message = await queue.get()
-                    current_ts = message.get("time", time.time())
-                    yield _format_log_sse(message, current_ts)
-
+                    payload = {
+                        "type": "log",
+                        **message,  # see astrbot/core/log.py
+                    }
+                    yield f"data: {json.dumps(payload, ensure_ascii=False)}\n\n"
             except asyncio.CancelledError:
                 pass
-            except Exception as e:
+            except BaseException as e:
                 logger.error(f"Log SSE 连接错误: {e}")
             finally:
                 if queue:
@@ -87,7 +53,7 @@ class LogRoute(Route):
                 },
             ),
         )
-        response.timeout = None  # type: ignore
+        response.timeout = None
         return response
 
     async def log_history(self):
@@ -103,6 +69,6 @@ class LogRoute(Route):
                 )
                 .__dict__
             )
-        except Exception as e:
+        except BaseException as e:
             logger.error(f"获取日志历史失败: {e}")
             return Response().error(f"获取日志历史失败: {e}").__dict__

astrbot/dashboard/routes/stat.py

@@ -1,9 +1,6 @@
-import os
-import re
 import threading
 import time
 import traceback
-from functools import cmp_to_key
 
 import aiohttp
 import psutil
@@ -14,9 +11,7 @@ from astrbot.core.config import VERSION
 from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
 from astrbot.core.db import BaseDatabase
 from astrbot.core.db.migration.helper import check_migration_needed_v4
-from astrbot.core.utils.astrbot_path import get_astrbot_path
 from astrbot.core.utils.io import get_dashboard_version
-from astrbot.core.utils.version_comparator import VersionComparator
 
 from .route import Response, Route, RouteContext
 
@@ -35,8 +30,6 @@ class StatRoute(Route):
             "/stat/start-time": ("GET", self.get_start_time),
             "/stat/restart-core": ("POST", self.restart_core),
             "/stat/test-ghproxy-connection": ("POST", self.test_ghproxy_connection),
-            "/stat/changelog": ("GET", self.get_changelog),
-            "/stat/changelog/list": ("GET", self.list_changelog_versions),
         }
         self.db_helper = db_helper
         self.register_routes()
@@ -190,92 +183,3 @@ class StatRoute(Route):
         except Exception as e:
             logger.error(traceback.format_exc())
             return Response().error(f"Error: {e!s}").__dict__
-
-    async def get_changelog(self):
-        """获取指定版本的更新日志"""
-        try:
-            version = request.args.get("version")
-            if not version:
-                return Response().error("version parameter is required").__dict__
-
-            version = version.lstrip("v")
-
-            # 防止路径遍历攻击
-            if not re.match(r"^[a-zA-Z0-9._-]+$", version):
-                return Response().error("Invalid version format").__dict__
-            if ".." in version or "/" in version or "\\" in version:
-                return Response().error("Invalid version format").__dict__
-
-            filename = f"v{version}.md"
-            project_path = get_astrbot_path()
-            changelogs_dir = os.path.join(project_path, "changelogs")
-            changelog_path = os.path.join(changelogs_dir, filename)
-
-            # 规范化路径，防止符号链接攻击
-            changelog_path = os.path.realpath(changelog_path)
-            changelogs_dir = os.path.realpath(changelogs_dir)
-
-            # 验证最终路径在预期的 changelogs 目录内（防止路径遍历）
-            # 确保规范化后的路径以 changelogs_dir 开头，且是目录内的文件
-            changelog_path_normalized = os.path.normpath(changelog_path)
-            changelogs_dir_normalized = os.path.normpath(changelogs_dir)
-
-            # 检查路径是否在预期目录内（必须是目录的子文件，不能是目录本身）
-            expected_prefix = changelogs_dir_normalized + os.sep
-            if not changelog_path_normalized.startswith(expected_prefix):
-                logger.warning(
-                    f"Path traversal attempt detected: {version} -> {changelog_path}",
-                )
-                return Response().error("Invalid version format").__dict__
-
-            if not os.path.exists(changelog_path):
-                return (
-                    Response()
-                    .error(f"Changelog for version {version} not found")
-                    .__dict__
-                )
-            if not os.path.isfile(changelog_path):
-                return (
-                    Response()
-                    .error(f"Changelog for version {version} not found")
-                    .__dict__
-                )
-
-            with open(changelog_path, encoding="utf-8") as f:
-                content = f.read()
-
-            return Response().ok({"content": content, "version": version}).__dict__
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response().error(f"Error: {e!s}").__dict__
-
-    async def list_changelog_versions(self):
-        """获取所有可用的更新日志版本列表"""
-        try:
-            project_path = get_astrbot_path()
-            changelogs_dir = os.path.join(project_path, "changelogs")
-
-            if not os.path.exists(changelogs_dir):
-                return Response().ok({"versions": []}).__dict__
-
-            versions = []
-            for filename in os.listdir(changelogs_dir):
-                if filename.endswith(".md") and filename.startswith("v"):
-                    # 提取版本号（去除 v 前缀和 .md 后缀）
-                    version = filename[1:-3]  # 去掉 "v" 和 ".md"
-                    # 验证版本号格式
-                    if re.match(r"^[a-zA-Z0-9._-]+$", version):
-                        versions.append(version)
-
-            # 按版本号排序（降序，最新的在前）
-            # 使用项目中的 VersionComparator 进行语义化版本号排序
-            versions.sort(
-                key=cmp_to_key(
-                    lambda v1, v2: VersionComparator.compare_version(v2, v1),
-                ),
-            )
-
-            return Response().ok({"versions": versions}).__dict__
-        except Exception as e:
-            logger.error(traceback.format_exc())
-            return Response().error(f"Error: {e!s}").__dict__

astrbot/dashboard/server.py

@@ -19,7 +19,6 @@ from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 from astrbot.core.utils.io import get_local_ip_addresses
 
 from .routes import *
-from .routes.backup import BackupRoute
 from .routes.platform import PlatformRoute
 from .routes.route import Response, RouteContext
 from .routes.session_management import SessionManagementRoute
@@ -86,7 +85,6 @@ class AstrBotDashboard:
         self.t2i_route = T2iRoute(self.context, core_lifecycle)
         self.kb_route = KnowledgeBaseRoute(self.context, core_lifecycle)
         self.platform_route = PlatformRoute(self.context, core_lifecycle)
-        self.backup_route = BackupRoute(self.context, db, core_lifecycle)
 
         self.app.add_url_rule(
             "/api/plug/<path:subpath>",
@@ -110,13 +108,7 @@ class AstrBotDashboard:
     async def auth_middleware(self):
         if not request.path.startswith("/api"):
             return None
-        allowed_endpoints = [
-            "/api/auth/login",
-            "/api/file",
-            "/api/platform/webhook",
-            "/api/stat/start-time",
-            "/api/backup/download",  # 备份下载使用 URL 参数传递 token
-        ]
+        allowed_endpoints = ["/api/auth/login", "/api/file", "/api/platform/webhook"]
         if any(request.path.startswith(prefix) for prefix in allowed_endpoints):
             return None
         # 声明 JWT

build_nuitka.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""
+Use Nuitka to build the AstrBot project into standalone executables
+"""
+
+import os
+import platform
+import subprocess
+import sys
+from pathlib import Path
+
+
+def get_platform_info():
+    """fetch the current platform information"""
+    system = platform.system()
+    machine = platform.machine()
+    return system, machine
+
+
+def build_with_nuitka():
+    """use Nuitka to build the project"""
+    system, machine = get_platform_info()
+
+    print(f"🚀 Starting build for {system} ({machine}) platform...")
+
+    # Output directory
+    output_dir = Path("build/nuitka")
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Base Nuitka command
+    nuitka_cmd = [
+        sys.executable,
+        "-m",
+        "nuitka",
+        "--standalone",  # Create standalone directory
+        "--onefile",  # Single file mode
+        "--follow-imports",  # Follow all imports
+        "--enable-plugin=multiprocessing",  # Enable multiprocessing support
+        "--output-dir=build/nuitka",  # Output directory
+        "--quiet",  # Reduce output verbosity
+        "--assume-yes-for-downloads",  # Automatically download dependencies
+        "--jobs=4",  # Use multiple CPU cores
+    ]
+
+    # include specific packages
+    include_packages = [
+        "astrbot",
+    ]
+
+    for pkg in include_packages:
+        nuitka_cmd.extend([f"--include-package={pkg}"])
+
+    # include data directories
+    # data_includes = [
+    #     "data/config",
+    #     "data/plugins",
+    #     "data/temp",
+    # ]
+
+    # for data_dir in data_includes:
+    #     if os.path.exists(data_dir):
+    #         nuitka_cmd.extend([f"--include-data-dir={data_dir}={data_dir}"])
+
+    # include packages directory (built-in plugins)
+    # if os.path.exists("packages"):
+    #     nuitka_cmd.extend(["--include-data-dir=packages=packages"])
+
+    # Platform specific settings
+    if system == "Darwin":  # macOS
+        nuitka_cmd.extend(
+            [
+                "--macos-create-app-bundle",  # Create .app bundle
+                "--macos-app-name=AstrBot",
+            ]
+        )
+        # macOS icon (if exists)
+        icon_path = "dashboard/src-tauri/icons/icon.icns"
+        if os.path.exists(icon_path):
+            nuitka_cmd.extend([f"--macos-app-icon={icon_path}"])
+    elif system == "Windows":
+        nuitka_cmd.extend(
+            [
+                "--windows-console-mode=disable",  # 无控制台窗口
+            ]
+        )
+        # Windows icon (if exists)
+        icon_path = "dashboard/src-tauri/icons/icon.ico"
+        if os.path.exists(icon_path):
+            nuitka_cmd.extend([f"--windows-icon-from-ico={icon_path}"])
+
+    # Main file to compile
+    nuitka_cmd.append("main.py")
+
+    print(f"📦 Executing command: {' '.join(nuitka_cmd)}")
+
+    try:
+        subprocess.run(nuitka_cmd, check=True)
+        print("✅ Nuitka build successful!")
+
+        # Find the generated executable
+        if system == "Darwin":
+            built_file = list(output_dir.glob("*.app"))
+            if built_file:
+                print(f"Generated macOS app: {built_file[0]}")
+        elif system == "Windows":
+            built_file = list(output_dir.glob("*.exe"))
+            if built_file:
+                print(f"Generated Windows executable: {built_file[0]}")
+        else:  # Linux
+            built_file = list(output_dir.glob("main.bin"))
+            if built_file:
+                print(f"Generated Linux executable: {built_file[0]}")
+
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Nuitka build failed: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("AstrBot Nuitka Builder")
+    print("=" * 60)
+
+    # 构建
+    if build_with_nuitka():
+        print("\n" + "=" * 60)
+        print("🎉 Build Complete!")
+        print("=" * 60)
+    else:
+        print("\n" + "=" * 60)
+        print("❌ Build Failed")
+        print("=" * 60)
+        sys.exit(1)

build_pyinstaller.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""
+Use PyInstaller to build the AstrBot project into standalone executables
+"""
+
+import platform
+import subprocess
+import sys
+from pathlib import Path
+
+
+def get_platform_info():
+    """fetch the current platform information"""
+    system = platform.system()
+    machine = platform.machine()
+    return system, machine
+
+
+def build_with_pyinstaller():
+    """use PyInstaller to build the project"""
+    system, machine = get_platform_info()
+
+    print(f"🚀 Starting build for {system} ({machine}) platform...")
+
+    # Output directory
+    output_dir = Path("build/pyinstaller")
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Base PyInstaller command
+    pyinstaller_cmd = [
+        sys.executable,
+        "-m",
+        "PyInstaller",
+        "--clean",  # Clean cache before build
+        "--noconfirm",  # Replace output directory without asking
+        "--onefile",  # Single file mode
+        "--distpath=build/pyinstaller/dist",  # Distribution directory
+        "--workpath=build/pyinstaller/build",  # Work directory
+        "--specpath=build/pyinstaller",  # Spec file directory
+        "--name=AstrBot",  # Output executable name
+    ]
+    # Platform specific settings
+    # if system == "Darwin":  # macOS
+    #     # macOS icon (if exists)
+    #     icon_path = "dashboard/src-tauri/icons/icon.icns"
+    #     if os.path.exists(icon_path):
+    #         pyinstaller_cmd.extend([f"--icon={icon_path}"])
+    #     # Create .app bundle
+    #     pyinstaller_cmd.extend(["--windowed"])
+    # elif system == "Windows":
+    #     # Windows icon (if exists)
+    #     icon_path = "dashboard/src-tauri/icons/icon.ico"
+    #     if os.path.exists(icon_path):
+    #         pyinstaller_cmd.extend([f"--icon={icon_path}"])
+    #     # No console window
+    #     pyinstaller_cmd.extend(["--windowed"])
+    # else:  # Linux
+    #     pyinstaller_cmd.extend(["--console"])
+
+    # Main file to compile
+    pyinstaller_cmd.append("main.py")
+
+    print(f"📦 Executing command: {' '.join(pyinstaller_cmd)}")
+
+    try:
+        subprocess.run(pyinstaller_cmd, check=True)
+        print("✅ PyInstaller build successful!")
+
+        # Find the generated executable
+        dist_dir = output_dir / "dist"
+        if system == "Darwin":
+            built_file = list(dist_dir.glob("AstrBot.app"))
+            if not built_file:
+                built_file = list(dist_dir.glob("AstrBot"))
+            if built_file:
+                print(f"📱 Generated macOS app: {built_file[0]}")
+        elif system == "Windows":
+            built_file = list(dist_dir.glob("AstrBot.exe"))
+            if built_file:
+                print(f"💻 Generated Windows executable: {built_file[0]}")
+        else:  # Linux
+            built_file = list(dist_dir.glob("AstrBot"))
+            if built_file:
+                print(f"🐧 Generated Linux executable: {built_file[0]}")
+
+        print(f"\n📁 Output directory: {dist_dir.absolute()}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ PyInstaller build failed: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ Unexpected error: {e}")
+        return False
+
+
+def install_pyinstaller():
+    """Install PyInstaller if not already installed"""
+    try:
+        import PyInstaller
+
+        print(f"✅ PyInstaller already installed (version {PyInstaller.__version__})")
+        return True
+    except ImportError:
+        print("📥 PyInstaller not found, installing...")
+        try:
+            subprocess.run(
+                [sys.executable, "-m", "pip", "install", "pyinstaller"], check=True
+            )
+            print("✅ PyInstaller installed successfully!")
+            return True
+        except subprocess.CalledProcessError as e:
+            print(f"❌ Failed to install PyInstaller: {e}")
+            return False
+
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("AstrBot PyInstaller Builder")
+    print("=" * 60)
+
+    # Check and install PyInstaller
+    if not install_pyinstaller():
+        sys.exit(1)
+
+    # Build
+    if build_with_pyinstaller():
+        print("\n" + "=" * 60)
+        print("🎉 Build Complete!")
+        print("=" * 60)
+    else:
+        print("\n" + "=" * 60)
+        print("❌ Build Failed")
+        print("=" * 60)
+        sys.exit(1)

changelogs/v4.10.0-alpha.1.md

@@ -1,34 +0,0 @@
-## What's Changed
-
-> 📢 在升级前，请**完整阅读**本次更新日志。
-> 
-> **特别提醒：**
-> 1. 该版本为 alpha.1 预览版本。
-> 2. 本次升级**如果再降级**，会由于提供商配置的变更，导致提供商配置错乱，需要手动删除后重新添加。
-> 3. 此版本 WebUI 包体相较上一个版本增加约 **193%**，共约 **9.8 MB**，升级可能会需要一些时间。
-
-### 重构与优化
-
-- 重构 Provider 页面和提供商的配置结构，将 Chat Provider 配置拆分为 Provider Source（提供商源）和 Provider（代表提供商源的各个模型），引入了提供商模型自动发现、模型元数据自动发现的功能，**提供更加便捷的模型添加体验**。
-- ⚠️ 将 “MCP” 页面移动到了 “插件” 页面中
-- ⚠️ 将 “MCP” 页面中的工具管理移动到了 “插件” -> “管理行为” 中。
-- ⚠️ 将 “QQ 个人号（OneBot v11）” 机器人适配器类型更名为 “OneBot v11”，并将其 Logo 更改为 OneBot 的 Logo。
-- ⚠️ AstrBot WebChat 升级为 **AstrBot ChatUI**，入口从边栏修改为顶部（右上角）切换按钮。
-- 优化引用消息的逻辑，减少对模型输入缓存的破坏。
-
-### 修复
-
-- ‼️ 修复部分情况下，分段回复无法正常分段的问题。
-- 修复处理工具返回结果的过程中，导致一些直接发送图片的工具（如生图工具）无法正确发送到用户的问题。
-- 修复 WebChat 部分情况下，上一条消息文字内容增量到下一条消息的问题。
-
-### 新增
-
-- 支持**指令管理**，设置指令别名、解决指令冲突、查看指令详情等。入口：“插件” -> “管理行为”。
-- 支持 Google Gemini 3 系列引入的 [Thinking Level](https://ai.google.dev/gemini-api/docs/thinking#thinking-levels) 配置。
-- 支持记录每条 LLM 消息的耗时、Token 使用量、TTFT 数据，以及每次 Agent Loop 的各种统计数据。
-- AstrBot ChatUI 支持查看每条消息的 TTFT、Token 使用量数据。
-- AstrBot ChatUI 支持显示每次工具调用的耗时、参数和响应。
-- AstrBot ChatUI 支持渲染 Mermaid、LateX 内容，优化了 Code Block 的显示效果（使用 Monaco Editor），并减少 DOM 更新于内存占用。（Powered by [Simon-He95/markstream-vue](https://github.com/Simon-He95/markstream-vue)）
-- 支持查看 Changelog 历史版本更新日志。
-- 🎄

changelogs/v4.10.0-alpha.2.md

@@ -1,44 +0,0 @@
-## What's Changed
-
-> 📢 在升级前，请**完整阅读**本次更新日志。
-> 
-> **特别提醒：**
-> 1. 该版本为 alpha.2 预览版本。
-> 2. 本次升级**如果再降级**，会由于提供商配置的变更，导致提供商配置错乱，需要手动删除后重新添加。
-> 3. 此版本 WebUI 包体相较上一个版本增加约 **193%**，共约 **9.8 MB**，升级可能会需要一些时间。
-
-## alpha.1 -> alpha.2
-
-- 修复：“对话数据”页对话轨迹详情显示异常的问题
-- 优化：当 Agent 达到最大步数时的处理。在达到最大步数后，会移除所有请求中的 tools 并告知模型根据上下文进行最终总结。
-- 优化：LLM tools 执行的错误处理，减少工具调用无限循环的问题。
-- 优化：ChatUI 打开模型选择菜单时，会重新获取提供商配置。
-- 优化：ChatUI 新建对话并发送消息后，对话列表页自动选中该对话。
-
-## 4.10.0 变化
-
-### 重构与优化
-
-- 重构 Provider 页面和提供商的配置结构，将 Chat Provider 配置拆分为 Provider Source（提供商源）和 Provider（代表提供商源的各个模型），引入了提供商模型自动发现、模型元数据自动发现的功能，**提供更加便捷的模型添加体验**。
-- ⚠️ 将 “MCP” 页面移动到了 “插件” 页面中
-- ⚠️ 将 “MCP” 页面中的工具管理移动到了 “插件” -> “管理行为” 中。
-- ⚠️ 将 “QQ 个人号（OneBot v11）” 机器人适配器类型更名为 “OneBot v11”，并将其 Logo 更改为 OneBot 的 Logo。
-- ⚠️ AstrBot WebChat 升级为 **AstrBot ChatUI**，入口从边栏修改为顶部（右上角）切换按钮。
-- 优化引用消息的逻辑，减少对模型输入缓存的破坏。
-
-### 修复
-
-- ‼️ 修复部分情况下，分段回复无法正常分段的问题。
-- 修复处理工具返回结果的过程中，导致一些直接发送图片的工具（如生图工具）无法正确发送到用户的问题。
-- 修复 WebChat 部分情况下，上一条消息文字内容增量到下一条消息的问题。
-
-### 新增
-
-- 支持**指令管理**，设置指令别名、解决指令冲突、查看指令详情等。入口：“插件” -> “管理行为”。
-- 支持 Google Gemini 3 系列引入的 [Thinking Level](https://ai.google.dev/gemini-api/docs/thinking#thinking-levels) 配置。
-- 支持记录每条 LLM 消息的耗时、Token 使用量、TTFT 数据，以及每次 Agent Loop 的各种统计数据。
-- AstrBot ChatUI 支持查看每条消息的 TTFT、Token 使用量数据。
-- AstrBot ChatUI 支持显示每次工具调用的耗时、参数和响应。
-- AstrBot ChatUI 支持渲染 Mermaid、LateX 内容，优化了 Code Block 的显示效果（使用 Monaco Editor），并减少 DOM 更新于内存占用。（Powered by [Simon-He95/markstream-vue](https://github.com/Simon-He95/markstream-vue)）
-- 支持查看 Changelog 历史版本更新日志。
-- 🎄

changelogs/v4.10.0.md

@@ -1,40 +0,0 @@
-## What's Changed
-
-> 📢 在升级前，请**完整阅读**本次更新日志。
-> 
-> **特别提醒：**
-> 1. 本次升级**如果再降级**，会由于提供商配置的变更，导致提供商配置错乱，需要手动删除后重新添加。
-> 2. 此版本 WebUI 包体相较上一个版本增加约 **193%**，共约 **9.8 MB**，升级可能会需要一些时间。
-> 3. **升级后请务必确保 WebUI 和 AstrBot Core 版本一致**，否则会产生预期之外的情况。（判断方法：日志中出现 `WebUI 版本已是最新。` 即为一致的版本，`检测到 WebUI 版本 (xxx) 与当前 AstrBot 版本 (xxx) 不符。` 即为不一致的版本。此版本的判断方法也可通查看 WebUI 右上角是否出现 Bot / Chat 的切换按钮控件来判断是否是新版本的 WebUI）。
-> 4. 如果有任何问题请提交 [Issue](https://github.com/AstrBotDevs/AstrBot/issues) 并附带 `v4.10.0` tag。
-
-### 重构与优化
-
-- 重构 Provider 页面和提供商的配置结构，将 Chat Provider 配置拆分为 Provider Source（提供商源）和 Provider（代表提供商源的各个模型），引入了提供商模型自动发现、模型元数据自动发现的功能，**提供更加便捷的模型添加体验**。
-- ⚠️ 将 “MCP” 页面移动到了 “插件” 页面中
-- ⚠️ 将 “MCP” 页面中的工具管理移动到了 “插件” -> “管理行为” 中。
-- ⚠️ 将 “QQ 个人号（OneBot v11）” 机器人适配器类型更名为 “OneBot v11”，并将其 Logo 更改为 OneBot 的 Logo。
-- ⚠️ AstrBot WebChat 升级为 **AstrBot ChatUI**，入口从边栏修改为顶部（右上角）切换按钮。
-- 优化引用消息的逻辑，减少对模型输入缓存的破坏。
-- 优化当 Agent 达到最大步数时的处理。在达到最大步数后，会移除所有请求中的 tools 并告知模型根据上下文进行最终总结。
-- 优化 LLM tools 执行的错误处理，减少工具调用无限循环的问题。
-
-
-### 修复
-
-- ‼️ 修复部分情况下，分段回复无法正常分段的问题。
-- 修复处理工具返回结果的过程中，导致一些直接发送图片的工具（如生图工具）无法正确发送到用户的问题。
-- 修复 WebChat 部分情况下，上一条消息文字内容增量到下一条消息的问题。
-
-### 新增
-
-- 支持**指令管理**，设置指令别名、解决指令冲突、查看指令详情等。入口：“插件” -> “管理行为”。
-- 支持 Google Gemini 3 系列引入的 [Thinking Level](https://ai.google.dev/gemini-api/docs/thinking#thinking-levels) 配置。
-- 支持记录每条 LLM 消息的耗时、Token 使用量、TTFT 数据，以及每次 Agent Loop 的各种统计数据。
-- AstrBot ChatUI 支持查看每条消息的 TTFT、Token 使用量数据。
-- AstrBot ChatUI 支持显示每次工具调用的耗时、参数和响应。
-- AstrBot ChatUI 支持渲染 Mermaid、LateX 内容，优化了 Code Block 的显示效果（使用 Monaco Editor），并减少 DOM 更新于内存占用。（Powered by [Simon-He95/markstream-vue](https://github.com/Simon-He95/markstream-vue)）
-- 支持查看 Changelog 历史版本更新日志。
-- 🎄
-
-Merry Christmas! 

changelogs/v4.10.1.md

@@ -1,46 +0,0 @@
-## What's Changed
-
-> 📢 在升级前，请**完整阅读**本次更新日志。
-> 
-> **特别提醒：**
-> 1. 本次升级**如果再降级**，会由于提供商配置的变更，导致提供商配置错乱，需要手动删除后重新添加。
-> 2. 此版本 WebUI 包体相较上一个版本增加约 **193%**，共约 **9.8 MB**，升级可能会需要一些时间。
-> 3. **升级后请务必确保 WebUI 和 AstrBot Core 版本一致**，否则会产生预期之外的情况。（判断方法：日志中出现 `WebUI 版本已是最新。` 即为一致的版本，`检测到 WebUI 版本 (xxx) 与当前 AstrBot 版本 (xxx) 不符。` 即为不一致的版本。此版本的判断方法也可通查看 WebUI 右上角是否出现 Bot / Chat 的切换按钮控件来判断是否是新版本的 WebUI）。
-> 4. 如果有任何问题请提交 [Issue](https://github.com/AstrBotDevs/AstrBot/issues) 并附带 `v4.10.0` tag。
-
-## 4.10.0 -> 4.10.1
-
-- fix(core): 修复极少数情况下由于指令管理导致的 AstrBot 启动失败的问题
-- fix(core): 修复当提供商源带有斜杠（“/”）时，无法删除 / 更新提供商源的问题（报错 405）
-- perf(core): 优化 OneBot 适配器的消息段解析逻辑，修复部分情况下无法正确解析消息段的问题
-
-### 重构与优化
-
-- 重构 Provider 页面和提供商的配置结构，将 Chat Provider 配置拆分为 Provider Source（提供商源）和 Provider（代表提供商源的各个模型），引入了提供商模型自动发现、模型元数据自动发现的功能，**提供更加便捷的模型添加体验**。
-- ⚠️ 将 “MCP” 页面移动到了 “插件” 页面中
-- ⚠️ 将 “MCP” 页面中的工具管理移动到了 “插件” -> “管理行为” 中。
-- ⚠️ 将 “QQ 个人号（OneBot v11）” 机器人适配器类型更名为 “OneBot v11”，并将其 Logo 更改为 OneBot 的 Logo。
-- ⚠️ AstrBot WebChat 升级为 **AstrBot ChatUI**，入口从边栏修改为顶部（右上角）切换按钮。
-- 优化引用消息的逻辑，减少对模型输入缓存的破坏。
-- 优化当 Agent 达到最大步数时的处理。在达到最大步数后，会移除所有请求中的 tools 并告知模型根据上下文进行最终总结。
-- 优化 LLM tools 执行的错误处理，减少工具调用无限循环的问题。
-
-
-### 修复
-
-- ‼️ 修复部分情况下，分段回复无法正常分段的问题。
-- 修复处理工具返回结果的过程中，导致一些直接发送图片的工具（如生图工具）无法正确发送到用户的问题。
-- 修复 WebChat 部分情况下，上一条消息文字内容增量到下一条消息的问题。
-
-### 新增
-
-- 支持**指令管理**，设置指令别名、解决指令冲突、查看指令详情等。入口：“插件” -> “管理行为”。
-- 支持 Google Gemini 3 系列引入的 [Thinking Level](https://ai.google.dev/gemini-api/docs/thinking#thinking-levels) 配置。
-- 支持记录每条 LLM 消息的耗时、Token 使用量、TTFT 数据，以及每次 Agent Loop 的各种统计数据。
-- AstrBot ChatUI 支持查看每条消息的 TTFT、Token 使用量数据。
-- AstrBot ChatUI 支持显示每次工具调用的耗时、参数和响应。
-- AstrBot ChatUI 支持渲染 Mermaid、LateX 内容，优化了 Code Block 的显示效果（使用 Monaco Editor），并减少 DOM 更新于内存占用。（Powered by [Simon-He95/markstream-vue](https://github.com/Simon-He95/markstream-vue)）
-- 支持查看 Changelog 历史版本更新日志。
-- 🎄
-
-Merry Christmas! 

changelogs/v4.10.2.md

@@ -1,9 +0,0 @@
-## What's Changed
-
-### 修复
-
-1. ‼️‼️ 修复了由 `psutil` 新版本导致的启动时报错的问题。
-
-### 新增
-
-1. 插件指令管理支持管理别名。

changelogs/v4.10.3.md

@@ -1,18 +0,0 @@
-## What's Changed
-
-### 修复
-
-1. 修复 FishAudio TTS 不可用的问题；
-2. 修复 Anthropic API Chat Provider 部分情况下请求报错的问题；
-3. 修复部分情况下 WebUI 日志重建连接之后丢失日志的问题；
-4. 修复部分情况下 /provider 指令报错 index out of range 的问题；
-5. 修复通过 `uv` 或者 cli 方式启动 AstrBot，缺少所有内置插件的问题。
-
-### 优化
-
-1. 丢弃值为 None 的 `tool_call_id` 和 `tool_calls` 字段，提高接口兼容性。
-
-### 新增
-
-1. 支持备份 AstrBot 数据和导入数据功能（Beta）。入口：WebUi -> 设置 -> 备份。
-2. text_chat 和 text_chat_stream 接口支持额外用户内容块参数 `extra_user_content_parts`，用于在用户消息后添加额外的内容块（如系统提醒、指令等）。

dashboard/TAURI_README.md

@@ -0,0 +1,225 @@
+# AstrBot Dashboard - Tauri 桌面应用
+
+本项目现已支持通过 Tauri 构建为桌面应用，同时保持与 Web 版本的兼容性。
+
+## 环境要求
+
+### 系统依赖
+
+**macOS:**
+```bash
+# 安装 Xcode Command Line Tools
+xcode-select --install
+```
+
+**Windows:**
+- 安装 [Microsoft Visual Studio C++ Build Tools](https://visualstudio.microsoft.com/visual-cpp-build-tools/)
+- 安装 [WebView2](https://developer.microsoft.com/en-us/microsoft-edge/webview2/)
+
+**Linux (Ubuntu/Debian):**
+```bash
+sudo apt update
+sudo apt install libwebkit2gtk-4.0-dev \
+    build-essential \
+    curl \
+    wget \
+    file \
+    libssl-dev \
+    libgtk-3-dev \
+    libayatana-appindicator3-dev \
+    librsvg2-dev
+```
+
+### Rust 环境
+
+```bash
+# 安装 Rust
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+# 验证安装
+rustc --version
+cargo --version
+```
+
+## 安装依赖
+
+```bash
+cd dashboard
+npm install
+```
+
+## 开发模式
+
+### Web 端开发（不变）
+
+```bash
+npm run dev
+```
+
+访问 http://localhost:3000
+
+### 桌面端开发
+
+```bash
+npm run tauri:dev
+```
+
+这会同时启动：
+1. Vite 开发服务器（端口 3000）
+2. Tauri 桌面应用窗口
+
+热重载功能正常工作，修改代码后会自动刷新。
+
+## 构建
+
+### Web 端构建（不变）
+
+```bash
+npm run build
+```
+
+输出目录：`dist/`
+
+### 桌面端构建
+
+```bash
+npm run tauri:build
+```
+
+构建产物位置：
+- **macOS**: `src-tauri/target/release/bundle/dmg/`
+- **Windows**: `src-tauri/target/release/bundle/msi/`
+- **Linux**: `src-tauri/target/release/bundle/deb/` 或 `appimage/`
+
+## 图标设置
+
+### 自动生成图标
+
+准备一个至少 512x512 像素的 PNG 图标，然后运行：
+
+```bash
+npm run tauri icon path/to/your/icon.png
+```
+
+### 手动设置图标
+
+将以下图标放入 `src-tauri/icons/` 目录：
+- `32x32.png`
+- `128x128.png`
+- `128x128@2x.png`
+- `icon.icns` (macOS)
+- `icon.ico` (Windows)
+
+## 代码兼容性
+
+项目已配置为同时支持 Web 和桌面端，使用相同的代码库。
+
+### 环境检测工具
+
+在 `src/utils/tauri.ts` 中提供了环境检测工具：
+
+```typescript
+import { isTauri, isWeb, PlatformAPI } from '@/utils/tauri';
+
+// 检测运行环境
+if (isTauri()) {
+  console.log('运行在桌面应用中');
+} else {
+  console.log('运行在浏览器中');
+}
+
+// 获取正确的 API 端点
+const baseURL = PlatformAPI.getBaseURL();
+```
+
+### API 调用注意事项
+
+- **Web 端**: 使用 Vite 代理，API 路径为 `/api/*`
+- **桌面端**: 直接连接到 `http://127.0.0.1:6185`
+
+已在 `PlatformAPI.getBaseURL()` 中处理，使用 axios 时：
+
+```typescript
+import axios from 'axios';
+import { PlatformAPI } from '@/utils/tauri';
+
+const api = axios.create({
+  baseURL: PlatformAPI.getBaseURL()
+});
+```
+
+## 配置说明
+
+### tauri.conf.json
+
+主要配置项：
+- `build.devPath`: 开发服务器地址（http://localhost:3000）
+- `build.distDir`: 构建输出目录（../dist）
+- `tauri.allowlist`: API 权限配置
+- `tauri.windows`: 窗口配置（大小、标题等）
+
+### 安全性
+
+默认配置已启用必要的权限：
+- 文件系统访问（限定在 APPDATA 目录）
+- HTTP 请求（限定到本地后端）
+- 窗口控制
+- 对话框（打开/保存文件）
+
+可在 `tauri.conf.json` 的 `allowlist` 部分调整权限。
+
+## 后端连接
+
+桌面应用需要后端服务运行在 `http://127.0.0.1:6185`。
+
+### 启动流程
+
+1. 启动 AstrBot 后端:
+   ```bash
+   cd /path/to/AstrBot
+   uv run main.py
+   ```
+
+2. 启动桌面应用:
+   ```bash
+   cd dashboard
+   npm run tauri:dev
+   ```
+
+或直接运行打包后的应用（后端需要已启动）。
+
+## 常见问题
+
+### Q: 桌面应用无法连接到后端？
+
+确保：
+1. AstrBot 后端正在运行（`uv run main.py`）
+2. 后端监听在 `127.0.0.1:6185`
+3. 防火墙未阻止连接
+
+### Q: 图标未显示？
+
+检查 `src-tauri/icons/` 目录中是否有所需的图标文件，或使用 `npm run tauri icon` 命令生成。
+
+### Q: 构建失败？
+
+- 确保已安装 Rust 和系统依赖
+- 运行 `cargo clean` 清理缓存后重试
+- 检查 Rust 版本（需要 1.60+）
+
+### Q: Web 端功能是否受影响？
+
+不受影响。`npm run dev` 和 `npm run build` 的行为完全不变。
+
+## 开发建议
+
+1. **优先使用 Web 端开发**: 更快的热重载，更好的调试体验
+2. **定期测试桌面端**: 确保跨平台兼容性
+3. **使用环境检测**: 针对不同平台提供最佳体验
+4. **注意 API 差异**: Web 和桌面端的某些 API 可能有差异
+
+## 更多资源
+
+- [Tauri 官方文档](https://tauri.app/)
+- [Tauri API 参考](https://tauri.app/v1/api/js/)
+- [Tauri Discord 社区](https://discord.com/invite/tauri)

dashboard/index.html

@@ -8,7 +8,7 @@
     <meta name="description" content="AstrBot Dashboard" />
     <link
       rel="stylesheet"
-      href="https://fonts.googleapis.com/css2?family=Outfit&family=Poppins:wght@400;500;600;700&family=Roboto:wght@400;500;700&display=swap"
+      href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Poppins:wght@400;500;600;700&family=Roboto:wght@400;500;700&display=swap"
     />
     <title>AstrBot - 仪表盘</title>
   </head>

dashboard/package.json

@@ -10,31 +10,30 @@
     "build-prod": "vue-tsc --noEmit && vite build --base=/vue/free/",
     "preview": "vite preview --port 5050",
     "typecheck": "vue-tsc --noEmit",
-    "lint": "eslint . --ext .vue,.js,.jsx,.cjs,.mjs,.ts,.tsx,.cts,.mts --fix --ignore-path .gitignore"
+    "lint": "eslint . --ext .vue,.js,.jsx,.cjs,.mjs,.ts,.tsx,.cts,.mts --fix --ignore-path .gitignore",
+    "tauri": "tauri",
+    "tauri:dev": "tauri dev",
+    "tauri:build": "tauri build"
   },
   "dependencies": {
     "@guolao/vue-monaco-editor": "^1.5.4",
-    "@mdit/plugin-katex": "^0.24.1",
+    "@tauri-apps/api": "^2.9.0",
     "@tiptap/starter-kit": "2.1.7",
     "@tiptap/vue-3": "2.1.7",
     "apexcharts": "3.42.0",
     "axios": ">=1.6.2 <1.10.0 || >1.10.0 <2.0.0",
     "axios-mock-adapter": "^1.22.0",
     "chance": "1.1.11",
+    "d3": "^7.9.0",
     "date-fns": "2.30.0",
-    "event-source-polyfill": "^1.0.31",
     "highlight.js": "^11.11.1",
     "js-md5": "^0.8.3",
-    "katex": "^0.16.27",
     "lodash": "4.17.21",
-    "markstream-vue": "0.0.3-beta.7",
-    "mermaid": "^11.12.2",
-    "pinia": "2.1.6",
+    "marked": "^15.0.7",
+    "markdown-it": "^14.1.0",
     "pinyin-pro": "^3.26.0",
+    "pinia": "2.1.6",
     "remixicon": "3.5.0",
-    "shiki": "^3.20.0",
-    "stream-markdown": "^0.0.11",
-    "stream-monaco": "^0.0.8",
     "vee-validate": "4.11.3",
     "vite-plugin-vuetify": "1.0.2",
     "vue": "3.3.4",
@@ -48,7 +47,9 @@
   "devDependencies": {
     "@mdi/font": "7.2.96",
     "@rushstack/eslint-patch": "1.3.3",
+    "@tauri-apps/cli": "^2.9.4",
     "@types/chance": "1.1.3",
+    "@types/markdown-it": "^14.1.2",
     "@types/node": "^20.5.7",
     "@vitejs/plugin-vue": "4.3.3",
     "@vue/eslint-config-prettier": "8.0.0",

dashboard/src-tauri/.gitignore

@@ -0,0 +1,3 @@
+# Tauri specific
+src-tauri/target/
+src-tauri/WixTools/

dashboard/src-tauri/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "astrbot-dashboard"
+version = "4.5.6"
+description = "AstrBot"
+authors = ["AstrBot Team"]
+license = "AGPL-3.0"
+repository = "https://github.com/AstrBotDevs/AstrBot"
+default-run = "astrbot-dashboard"
+edition = "2021"
+rust-version = "1.91.0"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+
+[dependencies]
+serde_json = "1.0"
+serde = { version = "1.0", features = ["derive"] }
+tauri = { version = "2.9.2", features = ["macos-private-api", "protocol-asset"] }
+tauri-plugin-opener = "2"
+
+[features]
+# this feature is used for production builds or when `devPath` points to the filesystem and the built-in dev server is disabled.
+# If you use cargo directly instead of tauri's cli you can use this feature flag to switch between tauri's `dev` and `build` modes.
+# DO NOT REMOVE!!
+custom-protocol = [ "tauri/custom-protocol" ]

dashboard/src-tauri/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}

dashboard/src-tauri/gen/schemas/capabilities.json

@@ -0,0 +1 @@
+{}

dashboard/src-tauri/icons/android/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+  <background android:drawable="@color/ic_launcher_background"/>
+</adaptive-icon>