Initial plan

* fix(#4188): 从文件安装插件时先终止并解绑已存在的同名插件

* feat(star): 优化从文件安装插件的处理同名冲突逻辑，增加边缘检查

.github/copilot-instructions.md

@@ -15,7 +15,6 @@ 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
@@ -35,7 +34,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 `packages/` (built-in) and `data/plugins/` (user-installed)
+- Plugins load from `astrbot/builtin_stars/` (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/stale.yml

@@ -1,27 +1,63 @@
-# This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time.
+# 本工作流用于标记并关闭长期不活跃的 Issue。
+# 目前仅针对带 `bug` 标签的 Issue 生效，不会处理 PR。
 #
-# 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
+# 文档: https://github.com/actions/stale
+name: Mark stale bug issues
 
 on:
   schedule:
-  - cron: '21 23 * * *'
+    # 每天 UTC 08:30 执行 (北京时间 16:30)
+    - cron: '30 8 * * *'
+  workflow_dispatch:
+    inputs:
+      dry-run:
+        description: '仅预览, 不实际执行 (Dry run mode)'
+        required: false
+        default: true
+        type: boolean
 
 jobs:
   stale:
-
     runs-on: ubuntu-latest
     permissions:
       issues: write
-      pull-requests: write
 
     steps:
-    - 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'
+      - 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 }}

.gitignore

@@ -24,9 +24,9 @@ configs/session
 configs/config.yaml
 cmd_config.json
 
-# Plugins and packages
+# Plugins
 addons/plugins
-packages/python_interpreter/workplace
+astrbot/builtin_stars/python_interpreter/workplace
 tests/astrbot_plugin_openai
 
 # Dashboard

astrbot/builtin_stars/astrbot/main.py

@@ -100,16 +100,8 @@ class Main(star.Star):
                 logger.error(f"ltm: {e}")
 
     @filter.on_llm_response()
-    async def inject_reasoning(self, event: AstrMessageEvent, resp: LLMResponse):
-        """在 LLM 响应后基于配置注入思考过程文本 / 在 LLM 响应后记录对话"""
-        umo = event.unified_msg_origin
-        cfg = self.context.get_config(umo).get("provider_settings", {})
-        show_reasoning = cfg.get("display_reasoning_text", False)
-        if show_reasoning and resp.reasoning_content:
-            resp.completion_text = (
-                f"🤔 思考: {resp.reasoning_content}\n\n{resp.completion_text}"
-            )
-
+    async def record_llm_resp_to_ltm(self, event: AstrMessageEvent, resp: LLMResponse):
+        """在 LLM 响应后记录对话"""
         if self.ltm and self.ltm_enabled(event):
             try:
                 await self.ltm.after_req_llm(event, resp)

astrbot/builtin_stars/astrbot/process_llm_request.py

@@ -7,6 +7,7 @@ from astrbot.api import logger, sp, star
 from astrbot.api.event import AstrMessageEvent
 from astrbot.api.message_components import Image, Reply
 from astrbot.api.provider import Provider, ProviderRequest
+from astrbot.core.agent.message import TextPart
 from astrbot.core.provider.func_tool_manager import ToolSet
 
 
@@ -85,7 +86,9 @@ class ProcessLLMRequest:
                 req.image_urls,
             )
             if caption:
-                req.prompt = f"(Image Caption: {caption})\n\n{req.prompt}"
+                req.extra_user_content_parts.append(
+                    TextPart(text=f"<image_caption>{caption}</image_caption>")
+                )
                 req.image_urls = []
         except Exception as e:
             logger.error(f"处理图片描述失败: {e}")
@@ -129,13 +132,14 @@ class ProcessLLMRequest:
             else:
                 req.prompt = prefix + req.prompt
 
+        # 收集系统提醒信息
+        system_parts = []
+
         # user identifier
         if cfg.get("identifier"):
             user_id = event.message_obj.sender.user_id
             user_nickname = event.message_obj.sender.nickname
-            req.prompt = (
-                f"\n[User ID: {user_id}, Nickname: {user_nickname}]\n{req.prompt}"
-            )
+            system_parts.append(f"User ID: {user_id}, Nickname: {user_nickname}")
 
         # group name identifier
         if cfg.get("group_name_display") and event.message_obj.group_id:
@@ -146,7 +150,7 @@ class ProcessLLMRequest:
                 return
             group_name = event.message_obj.group.group_name
             if group_name:
-                req.system_prompt += f"\nGroup name: {group_name}\n"
+                system_parts.append(f"Group name: {group_name}")
 
         # time info
         if cfg.get("datetime_system_prompt"):
@@ -162,7 +166,7 @@ class ProcessLLMRequest:
                 current_time = (
                     datetime.datetime.now().astimezone().strftime("%Y-%m-%d %H:%M (%Z)")
                 )
-            req.system_prompt += f"\nCurrent datetime: {current_time}\n"
+            system_parts.append(f"Current datetime: {current_time}")
 
         img_cap_prov_id: str = cfg.get("default_image_caption_provider_id") or ""
         if req.conversation:
@@ -225,10 +229,17 @@ class ProcessLLMRequest:
                 except BaseException as e:
                     logger.error(f"处理引用图片失败: {e}")
 
-            # 3. 将所有部分组合成文本并直接注入到当前消息中
+            # 3. 将所有部分组合成文本并添加到 extra_user_content_parts 中
             # 确保引用内容被正确的标签包裹
             quoted_content = "\n".join(content_parts)
             # 确保所有内容都在<Quoted Message>标签内
             quoted_text = f"<Quoted Message>\n{quoted_content}\n</Quoted Message>"
 
-            req.prompt = f"{quoted_text}\n\n{req.prompt}"
+            req.extra_user_content_parts.append(TextPart(text=quoted_text))
+
+        # 统一包裹所有系统提醒
+        if system_parts:
+            system_content = (
+                "<system_reminder>" + "\n".join(system_parts) + "</system_reminder>"
+            )
+            req.extra_user_content_parts.append(TextPart(text=system_content))

astrbot/builtin_stars/builtin_commands/commands/provider.py

@@ -184,7 +184,8 @@ class ProviderCommands:
                 event.set_result(MessageEventResult().message("请输入序号。"))
                 return
             if idx2 > len(self.context.get_all_tts_providers()) or idx2 < 1:
-                event.set_result(MessageEventResult().message("无效的序号。"))
+                event.set_result(MessageEventResult().message("无效的提供商序号。"))
+                return
             provider = self.context.get_all_tts_providers()[idx2 - 1]
             id_ = provider.meta().id
             await self.context.provider_manager.set_provider(
@@ -198,7 +199,8 @@ class ProviderCommands:
                 event.set_result(MessageEventResult().message("请输入序号。"))
                 return
             if idx2 > len(self.context.get_all_stt_providers()) or idx2 < 1:
-                event.set_result(MessageEventResult().message("无效的序号。"))
+                event.set_result(MessageEventResult().message("无效的提供商序号。"))
+                return
             provider = self.context.get_all_stt_providers()[idx2 - 1]
             id_ = provider.meta().id
             await self.context.provider_manager.set_provider(
@@ -209,8 +211,8 @@ class ProviderCommands:
             event.set_result(MessageEventResult().message(f"成功切换到 {id_}。"))
         elif isinstance(idx, int):
             if idx > len(self.context.get_all_providers()) or idx < 1:
-                event.set_result(MessageEventResult().message("无效的序号。"))
-
+                event.set_result(MessageEventResult().message("无效的提供商序号。"))
+                return
             provider = self.context.get_all_providers()[idx - 1]
             id_ = provider.meta().id
             await self.context.provider_manager.set_provider(

astrbot/builtin_stars/python_interpreter/main.py

@@ -157,9 +157,8 @@ class Main(star.Star):
     async def is_docker_available(self) -> bool:
         """Check if docker is available"""
         try:
-            docker = aiodocker.Docker()
-            await docker.version()
-            await docker.close()
+            async with aiodocker.Docker() as docker:
+                await docker.version()
             return True
         except BaseException as e:
             logger.info(f"检查 Docker 可用性: {e}")
@@ -279,14 +278,14 @@ class Main(star.Star):
     @pi.command("repull")
     async def pi_repull(self, event: AstrMessageEvent):
         """重新拉取沙箱镜像"""
-        docker = aiodocker.Docker()
-        image_name = await self.get_image_name()
-        try:
-            await docker.images.get(image_name)
-            await docker.images.delete(image_name, force=True)
-        except aiodocker.exceptions.DockerError:
-            pass
-        await docker.images.pull(image_name)
+        async with aiodocker.Docker() as docker:
+            image_name = await self.get_image_name()
+            try:
+                await docker.images.get(image_name)
+                await docker.images.delete(image_name, force=True)
+            except aiodocker.exceptions.DockerError:
+                pass
+            await docker.images.pull(image_name)
         yield event.plain_result("重新拉取沙箱镜像成功。")
 
     @pi.command("file")
@@ -371,137 +370,137 @@ class Main(star.Star):
         obs = ""
         n = 5
 
-        for i in range(n):
-            if i > 0:
-                logger.info(f"Try {i + 1}/{n}")
+        async with aiodocker.Docker() as docker:
+            for i in range(n):
+                if i > 0:
+                    logger.info(f"Try {i + 1}/{n}")
 
-            PROMPT_ = PROMPT.format(
-                prompt=plain_text,
-                extra_input=extra_inputs,
-                extra_prompt=obs,
-            )
-            provider = self.context.get_using_provider()
-            llm_response = await provider.text_chat(
-                prompt=PROMPT_,
-                session_id=f"{event.session_id}_{magic_code}_{i!s}",
-            )
-
-            logger.debug(
-                "code interpreter llm gened code:" + llm_response.completion_text,
-            )
-
-            # 整理代码并保存
-            code_clean = await self.tidy_code(llm_response.completion_text)
-            with open(os.path.join(workplace_path, "exec.py"), "w") as f:
-                f.write(code_clean)
-
-            # 启动容器
-            docker = aiodocker.Docker()
-
-            # 检查有没有image
-            image_name = await self.get_image_name()
-            try:
-                await docker.images.get(image_name)
-            except aiodocker.exceptions.DockerError:
-                # 拉取镜像
-                logger.info(f"未找到沙箱镜像，正在尝试拉取 {image_name}...")
-                await docker.images.pull(image_name)
-
-            yield event.plain_result(
-                f"使用沙箱执行代码中，请稍等...(尝试次数: {i + 1}/{n})",
-            )
-
-            self.docker_host_astrbot_abs_path = self.config.get(
-                "docker_host_astrbot_abs_path",
-                "",
-            )
-            if self.docker_host_astrbot_abs_path:
-                host_shared = os.path.join(
-                    self.docker_host_astrbot_abs_path,
-                    self.shared_path,
+                PROMPT_ = PROMPT.format(
+                    prompt=plain_text,
+                    extra_input=extra_inputs,
+                    extra_prompt=obs,
                 )
-                host_output = os.path.join(
-                    self.docker_host_astrbot_abs_path,
-                    output_path,
-                )
-                host_workplace = os.path.join(
-                    self.docker_host_astrbot_abs_path,
-                    workplace_path,
+                provider = self.context.get_using_provider()
+                llm_response = await provider.text_chat(
+                    prompt=PROMPT_,
+                    session_id=f"{event.session_id}_{magic_code}_{i!s}",
                 )
 
-            else:
-                host_shared = os.path.abspath(self.shared_path)
-                host_output = os.path.abspath(output_path)
-                host_workplace = os.path.abspath(workplace_path)
+                logger.debug(
+                    "code interpreter llm gened code:" + llm_response.completion_text,
+                )
 
-            logger.debug(
-                f"host_shared: {host_shared}, host_output: {host_output}, host_workplace: {host_workplace}",
-            )
+                # 整理代码并保存
+                code_clean = await self.tidy_code(llm_response.completion_text)
+                with open(os.path.join(workplace_path, "exec.py"), "w") as f:
+                    f.write(code_clean)
 
-            container = await docker.containers.run(
-                {
-                    "Image": image_name,
-                    "Cmd": ["python", "exec.py"],
-                    "Memory": 512 * 1024 * 1024,
-                    "NanoCPUs": 1000000000,
-                    "HostConfig": {
-                        "Binds": [
-                            f"{host_shared}:/astrbot_sandbox/shared:ro",
-                            f"{host_output}:/astrbot_sandbox/output:rw",
-                            f"{host_workplace}:/astrbot_sandbox:rw",
-                        ],
-                    },
-                    "Env": [f"MAGIC_CODE={magic_code}"],
-                    "AutoRemove": True,
-                },
-            )
+                # 检查有没有image
+                image_name = await self.get_image_name()
+                try:
+                    await docker.images.get(image_name)
+                except aiodocker.exceptions.DockerError:
+                    # 拉取镜像
+                    logger.info(f"未找到沙箱镜像，正在尝试拉取 {image_name}...")
+                    await docker.images.pull(image_name)
 
-            logger.debug(f"Container {container.id} created.")
-            logs = await self.run_container(container)
+                yield event.plain_result(
+                    f"使用沙箱执行代码中，请稍等...(尝试次数: {i + 1}/{n})",
+                )
 
-            logger.debug(f"Container {container.id} finished.")
-            logger.debug(f"Container {container.id} logs: {logs}")
-
-            # 发送结果
-            pattern = r"\[ASTRBOT_(TEXT|IMAGE|FILE)_OUTPUT#\w+\]: (.*)"
-            ok = False
-            traceback = ""
-            for idx, log in enumerate(logs):
-                match = re.match(pattern, log)
-                if match:
-                    ok = True
-                    if match.group(1) == "TEXT":
-                        yield event.plain_result(match.group(2))
-                    elif match.group(1) == "IMAGE":
-                        image_path = os.path.join(workplace_path, match.group(2))
-                        logger.debug(f"Sending image: {image_path}")
-                        yield event.image_result(image_path)
-                    elif match.group(1) == "FILE":
-                        file_path = os.path.join(workplace_path, match.group(2))
-                        # logger.debug(f"Sending file: {file_path}")
-                        # file_s3_url = await self.file_upload(file_path)
-                        # logger.info(f"文件上传到 AstrBot 云节点: {file_s3_url}")
-                        file_name = os.path.basename(file_path)
-                        chain: list[BaseMessageComponent] = [
-                            File(name=file_name, file=file_path)
-                        ]
-                        yield event.set_result(MessageEventResult(chain=chain))
-
-                elif "Traceback (most recent call last)" in log or "[Error]: " in log:
-                    traceback = "\n".join(logs[idx:])
-
-            if not ok:
-                if traceback:
-                    obs = f"## Observation \n When execute the code: ```python\n{code_clean}\n```\n\n Error occurred:\n\n{traceback}\n Need to improve/fix the code."
-                else:
-                    logger.warning(
-                        f"未从沙箱输出中捕获到合法的输出。沙箱输出日志: {logs}",
+                self.docker_host_astrbot_abs_path = self.config.get(
+                    "docker_host_astrbot_abs_path",
+                    "",
+                )
+                if self.docker_host_astrbot_abs_path:
+                    host_shared = os.path.join(
+                        self.docker_host_astrbot_abs_path,
+                        self.shared_path,
                     )
-                    break
-            else:
-                # 成功了
-                self.user_file_msg_buffer.pop(event.get_session_id())
-                return
+                    host_output = os.path.join(
+                        self.docker_host_astrbot_abs_path,
+                        output_path,
+                    )
+                    host_workplace = os.path.join(
+                        self.docker_host_astrbot_abs_path,
+                        workplace_path,
+                    )
+
+                else:
+                    host_shared = os.path.abspath(self.shared_path)
+                    host_output = os.path.abspath(output_path)
+                    host_workplace = os.path.abspath(workplace_path)
+
+                logger.debug(
+                    f"host_shared: {host_shared}, host_output: {host_output}, host_workplace: {host_workplace}",
+                )
+
+                container = await docker.containers.run(
+                    {
+                        "Image": image_name,
+                        "Cmd": ["python", "exec.py"],
+                        "Memory": 512 * 1024 * 1024,
+                        "NanoCPUs": 1000000000,
+                        "HostConfig": {
+                            "Binds": [
+                                f"{host_shared}:/astrbot_sandbox/shared:ro",
+                                f"{host_output}:/astrbot_sandbox/output:rw",
+                                f"{host_workplace}:/astrbot_sandbox:rw",
+                            ],
+                        },
+                        "Env": [f"MAGIC_CODE={magic_code}"],
+                        "AutoRemove": True,
+                    },
+                )
+
+                logger.debug(f"Container {container.id} created.")
+                logs = await self.run_container(container)
+
+                logger.debug(f"Container {container.id} finished.")
+                logger.debug(f"Container {container.id} logs: {logs}")
+
+                # 发送结果
+                pattern = r"\[ASTRBOT_(TEXT|IMAGE|FILE)_OUTPUT#\w+\]: (.*)"
+                ok = False
+                traceback = ""
+                for idx, log in enumerate(logs):
+                    match = re.match(pattern, log)
+                    if match:
+                        ok = True
+                        if match.group(1) == "TEXT":
+                            yield event.plain_result(match.group(2))
+                        elif match.group(1) == "IMAGE":
+                            image_path = os.path.join(workplace_path, match.group(2))
+                            logger.debug(f"Sending image: {image_path}")
+                            yield event.image_result(image_path)
+                        elif match.group(1) == "FILE":
+                            file_path = os.path.join(workplace_path, match.group(2))
+                            # logger.debug(f"Sending file: {file_path}")
+                            # file_s3_url = await self.file_upload(file_path)
+                            # logger.info(f"文件上传到 AstrBot 云节点: {file_s3_url}")
+                            file_name = os.path.basename(file_path)
+                            chain: list[BaseMessageComponent] = [
+                                File(name=file_name, file=file_path)
+                            ]
+                            yield event.set_result(MessageEventResult(chain=chain))
+
+                    elif (
+                        "Traceback (most recent call last)" in log or "[Error]: " in log
+                    ):
+                        traceback = "\n".join(logs[idx:])
+
+                if not ok:
+                    if traceback:
+                        obs = f"## Observation \n When execute the code: ```python\n{code_clean}\n```\n\n Error occurred:\n\n{traceback}\n Need to improve/fix the code."
+                    else:
+                        logger.warning(
+                            f"未从沙箱输出中捕获到合法的输出。沙箱输出日志: {logs}",
+                        )
+                        break
+                else:
+                    # 成功了
+                    self.user_file_msg_buffer.pop(event.get_session_id())
+                    return
 
         yield event.plain_result(
             "经过多次尝试后，未从沙箱输出中捕获到合法的输出，请更换问法或者查看日志。",

astrbot/cli/__init__.py

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

astrbot/core/agent/message.py

@@ -12,7 +12,7 @@ class ContentPart(BaseModel):
 
     __content_part_registry: ClassVar[dict[str, type["ContentPart"]]] = {}
 
-    type: str
+    type: Literal["text", "think", "image_url", "audio_url"]
 
     def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
@@ -63,6 +63,28 @@ 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()
@@ -169,6 +191,15 @@ 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,6 +13,7 @@ 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,10 +78,11 @@ 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,
+            "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:
@@ -168,13 +170,20 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
             self.final_llm_resp = llm_resp
             self._transition_state(AgentState.DONE)
             self.stats.end_time = time.time()
+
             # record the final assistant message
-            self.run_context.messages.append(
-                Message(
-                    role="assistant",
-                    content=llm_resp.completion_text or "*No response*",
-                ),
-            )
+            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
             try:
                 await self.agent_hooks.on_agent_done(self.run_context, llm_resp)
             except Exception as e:
@@ -213,10 +222,19 @@ 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=llm_resp.completion_text,
+                    content=parts,
                 ),
                 tool_calls_result=tool_call_result_blocks,
             )

astrbot/core/astr_agent_hooks.py

@@ -13,6 +13,12 @@ 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/backup/__init__.py

@@ -0,0 +1,26 @@
+"""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

@@ -0,0 +1,77 @@
+"""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

@@ -0,0 +1,477 @@
+"""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

@@ -0,0 +1,761 @@
+"""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,6 +80,8 @@ 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

@@ -5,7 +5,7 @@ from typing import Any, TypedDict
 
 from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 
-VERSION = "4.10.0"
+VERSION = "4.10.3"
 DB_PATH = os.path.join(get_astrbot_data_path(), "data_v4.db")
 
 WEBHOOK_SUPPORTED_PLATFORMS = [
@@ -905,6 +905,7 @@ CONFIG_METADATA_2 = {
                         "key": [],
                         "api_base": "https://api.anthropic.com/v1",
                         "timeout": 120,
+                        "anth_thinking_config": {"budget": 0},
                     },
                     "Moonshot": {
                         "id": "moonshot",
@@ -920,7 +921,7 @@ CONFIG_METADATA_2 = {
                     "xAI": {
                         "id": "xai",
                         "provider": "xai",
-                        "type": "openai_chat_completion",
+                        "type": "xai_chat_completion",
                         "provider_type": "chat_completion",
                         "enable": True,
                         "key": [],
@@ -1286,7 +1287,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": "neutral",
+                        "minimax-voice-emotion": "auto",
                         "minimax-voice-latex": False,
                         "minimax-voice-english-normalization": False,
                         "timeout": 20,
@@ -1787,6 +1788,17 @@ 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": "用户组",
@@ -1858,15 +1870,18 @@ CONFIG_METADATA_2 = {
                     "minimax-voice-emotion": {
                         "type": "string",
                         "description": "情绪",
-                        "hint": "控制合成语音的情绪",
+                        "hint": "控制合成语音的情绪。当为 auto 时，将根据文本内容自动选择情绪。",
                         "options": [
+                            "auto",
                             "happy",
                             "sad",
                             "angry",
                             "fearful",
                             "disgusted",
                             "surprised",
-                            "neutral",
+                            "calm",
+                            "fluent",
+                            "whisper",
                         ],
                     },
                     "minimax-voice-latex": {
@@ -3049,4 +3064,5 @@ DEFAULT_VALUE_MAP = {
     "text": "",
     "list": [],
     "object": {},
+    "template_list": [],
 }

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 ("packages/" in norm_path)
+    return ("data/plugins" in norm_path) or ("astrbot/builtin_stars/" in norm_path)
 
 
 def get_short_level_name(level_name):

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

@@ -6,6 +6,7 @@ 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
@@ -294,6 +295,7 @@ class InternalAgentSubStage(Stage):
         event: AstrMessageEvent,
         req: ProviderRequest,
         llm_response: LLMResponse | None,
+        all_messages: list[Message],
     ):
         if (
             not req
@@ -307,31 +309,23 @@ class InternalAgentSubStage(Stage):
             logger.debug("LLM 响应为空，不保存记录。")
             return
 
-        if req.contexts is None:
-            req.contexts = []
+        # 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())
 
-        # 历史上下文
-        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 or "*No response*",
-            }
-        )
-        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=messages,
+            history=message_to_save,
         )
 
     def _fix_messages(self, messages: list[dict]) -> list[dict]:
@@ -355,174 +349,190 @@ class InternalAgentSubStage(Stage):
     ) -> AsyncGenerator[None, None]:
         req: ProviderRequest | None = None
 
-        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 类型。"
+        try:
+            provider = self._select_provider(event)
+            if provider is None:
+                return
+            if not isinstance(provider, Provider):
+                logger.error(
+                    f"选择的提供商类型无效({type(provider)})，跳过 LLM 请求处理。"
                 )
+                return
 
-                if req.conversation:
-                    req.contexts = json.loads(req.conversation.history)
+            streaming_response = self.streaming_response
+            if (enable_streaming := event.get_extra("enable_streaming")) is not None:
+                streaming_response = bool(enable_streaming)
 
-            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
-                ):
+            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:
                     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)
+                # call event hook
+                if await call_event_hook(event, EventType.OnLLMRequestEvent, req):
+                    return
 
-                conversation = await self._get_session_conv(event)
-                req.conversation = conversation
-                req.contexts = json.loads(conversation.history)
+                # apply knowledge base feature
+                await self._apply_kb(event, req)
 
-                event.set_extra("provider_request", req)
+                # truncate contexts to fit max length
+                if req.contexts:
+                    req.contexts = self._truncate_contexts(req.contexts)
+                    self._fix_messages(req.contexts)
 
-            # fix contexts json str
-            if isinstance(req.contexts, str):
-                req.contexts = json.loads(req.contexts)
+                # session_id
+                if not req.session_id:
+                    req.session_id = event.unified_msg_origin
 
-            # 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}")
+                # check provider modalities, if provider does not support image/tool_use, clear them in request.
+                self._modalities_fix(provider, req)
 
-            if not req.prompt and not req.image_urls:
-                return
+                # filter tools, only keep tools from this pipeline's selected plugins
+                self._plugin_tool_fix(event, req)
 
-            # call event hook
-            if await call_event_hook(event, EventType.OnLLMRequestEvent, req):
-                return
-
-            # apply knowledge base feature
-            await self._apply_kb(event, req)
-
-            # truncate contexts to fit max length
-            if req.contexts:
-                req.contexts = self._truncate_contexts(req.contexts)
-                self._fix_messages(req.contexts)
-
-            # session_id
-            if not req.session_id:
-                req.session_id = event.unified_msg_origin
-
-            # check provider modalities, if provider does not support image/tool_use, clear them in request.
-            self._modalities_fix(provider, req)
-
-            # filter tools, only keep tools from this pipeline's selected plugins
-            self._plugin_tool_fix(event, req)
-
-            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,
-            )
-
-            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,
-                        ),
-                    ),
+                stream_to_general = (
+                    self.unsupported_streaming_strategy == "turn_off"
+                    and not event.platform_meta.support_streaming_message
                 )
-                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,
+                # 备份 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,
+                )
+
+                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,
                             ),
-                        )
-            else:
-                async for _ in run_agent(
-                    agent_runner,
-                    self.max_step,
-                    self.show_tool_use,
-                    stream_to_general,
-                    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
+                # 恢复备份的 contexts
+                req.contexts = backup_contexts
 
-            await self._save_to_history(event, req, agent_runner.get_final_llm_resp())
+                await self._save_to_history(
+                    event,
+                    req,
+                    agent_runner.get_final_llm_resp(),
+                    agent_runner.run_context.messages,
+                )
 
-        # 异步处理 WebChat 特殊情况
-        if event.get_platform_name() == "webchat":
-            asyncio.create_task(self._handle_webchat(event, req, provider))
+            # 异步处理 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,
-            ),
-        )
+            asyncio.create_task(
+                Metric.upload(
+                    llm_tick=1,
+                    model_name=agent_runner.provider.get_model(),
+                    provider_type=agent_runner.provider.meta().type,
+                ),
+            )
+
+        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}"
+                )
+            )

astrbot/core/pipeline/result_decorate/stage.py

@@ -98,6 +98,9 @@ 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:
@@ -254,70 +257,75 @@ class ResultDecorateStage(Stage):
                 event.unified_msg_origin,
             )
 
-            if (
-                self.ctx.astrbot_config["provider_tts_settings"]["enable"]
+            should_tts = (
+                bool(self.ctx.astrbot_config["provider_tts_settings"]["enable"])
                 and result.is_llm_result()
                 and SessionServiceManager.should_process_tts_request(event)
-            ):
-                should_tts = self.tts_trigger_probability >= 1.0 or (
-                    self.tts_trigger_probability > 0.0
-                    and random.random() <= self.tts_trigger_probability
+                and random.random() <= self.tts_trigger_probability
+                and tts_provider
+            )
+            if should_tts and not tts_provider:
+                logger.warning(
+                    f"会话 {event.unified_msg_origin} 未配置文本转语音模型。",
                 )
 
-                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 (
+                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"))
 
-                                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 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}",
                                 )
-                                if dual_output:
-                                    new_chain.append(comp)
-                            except Exception:
-                                logger.error(traceback.format_exc())
-                                logger.error("TTS 失败，使用文本发送。")
                                 new_chain.append(comp)
-                        else:
+                                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 失败，使用文本发送。")
                             new_chain.append(comp)
-                    result.chain = new_chain
+                    else:
+                        new_chain.append(comp)
+                result.chain = new_chain
 
             # 文本转图片
             elif (

astrbot/core/pipeline/waking_check/stage.py

@@ -1,9 +1,10 @@
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Callable
 
 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
@@ -13,6 +14,23 @@ 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):
@@ -53,18 +71,27 @@ 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"]:
@@ -136,7 +163,8 @@ class WakingCheckStage(Stage):
         ):
             if (
                 self.disable_builtin_commands
-                and handler.handler_module_path == "packages.builtin_commands.main"
+                and handler.handler_module_path
+                == "astrbot.builtin_stars.builtin_commands.main"
             ):
                 logger.debug("skipping builtin command")
                 continue

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

@@ -41,7 +41,6 @@ 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"]
 
@@ -136,14 +135,11 @@ class AiocqhttpAdapter(Platform):
             abm.group_id = str(event.group_id)
         else:
             abm.type = MessageType.FRIEND_MESSAGE
-        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.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())
@@ -164,16 +160,11 @@ class AiocqhttpAdapter(Platform):
             abm.type = MessageType.GROUP_MESSAGE
         else:
             abm.type = MessageType.FRIEND_MESSAGE
-        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.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
@@ -210,16 +201,11 @@ class AiocqhttpAdapter(Platform):
             abm.group.group_name = event.get("group_name", "N/A")
         elif event["message_type"] == "private":
             abm.type = MessageType.FRIEND_MESSAGE
-        if self.unique_session and abm.type == MessageType.GROUP_MESSAGE:
-            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.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 = []
@@ -385,10 +371,25 @@ 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:
-                    a = ComponentTypes[t](**m["data"])
-                    abm.message.append(a)
+                    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
 
         abm.timestamp = int(time.time())
         abm.message_str = message_str

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

@@ -50,8 +50,6 @@ 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"]
 
@@ -129,10 +127,7 @@ class DingtalkPlatformAdapter(Platform):
                     if id := self._id_to_sid(user.dingtalk_id):
                         abm.message.append(At(qq=id))
             abm.group_id = message.conversation_id
-            if self.unique_session:
-                abm.session_id = abm.sender.user_id
-            else:
-                abm.session_id = abm.group_id
+            abm.session_id = abm.group_id
         else:
             abm.session_id = abm.sender.user_id
 

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

@@ -25,6 +25,20 @@ 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()
@@ -32,7 +46,7 @@ class DingtalkMessageEvent(AstrMessageEvent):
                     None,
                     client.reply_markdown,
                     segment.text,
-                    segment.text,
+                    f"{at_str} {segment.text}".strip(),
                     cast(dingtalk_stream.ChatbotMessage, self.message_obj.raw_message),
                 )
             elif isinstance(segment, Comp.Image):

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

@@ -44,8 +44,6 @@ 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)
@@ -317,14 +315,8 @@ class LarkPlatformAdapter(Platform):
             user_id=event.event.sender.sender_id.open_id,
             nickname=event.event.sender.sender_id.open_id[:8],
         )
-        # 独立会话
-        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
+        if abm.type == MessageType.GROUP_MESSAGE:
+            abm.session_id = abm.group_id
         else:
             abm.session_id = abm.sender.user_id
 

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

@@ -91,8 +91,6 @@ 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 = ""
@@ -641,7 +639,6 @@ class MisskeyPlatformAdapter(Platform):
             sender_info,
             self.client_self_id,
             is_chat=False,
-            unique_session=self.unique_session,
         )
         cache_user_info(
             self._user_cache,
@@ -690,7 +687,6 @@ class MisskeyPlatformAdapter(Platform):
             sender_info,
             self.client_self_id,
             is_chat=True,
-            unique_session=self.unique_session,
         )
         cache_user_info(
             self._user_cache,
@@ -720,7 +716,6 @@ 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,7 +338,6 @@ def create_base_message(
     client_self_id: str,
     is_chat: bool = False,
     room_id: str | None = None,
-    unique_session: bool = False,
 ) -> AstrBotMessage:
     """创建基础消息对象"""
     message = AstrBotMessage()
@@ -353,8 +352,6 @@ 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,11 +44,8 @@ class botClient(Client):
             message,
             MessageType.GROUP_MESSAGE,
         )
-        abm.session_id = (
-            abm.sender.user_id
-            if self.platform.unique_session
-            else cast(str, message.group_openid)
-        )
+        abm.group_id = cast(str, message.group_openid)
+        abm.session_id = abm.group_id
         self._commit(abm)
 
     # 收到频道消息
@@ -57,9 +54,8 @@ class botClient(Client):
             message,
             MessageType.GROUP_MESSAGE,
         )
-        abm.session_id = (
-            abm.sender.user_id if self.platform.unique_session else message.channel_id
-        )
+        abm.group_id = message.channel_id
+        abm.session_id = abm.group_id
         self._commit(abm)
 
     # 收到私聊消息
@@ -104,7 +100,6 @@ 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,11 +35,8 @@ class botClient(Client):
             message,
             MessageType.GROUP_MESSAGE,
         )
-        abm.session_id = (
-            abm.sender.user_id
-            if self.platform.unique_session
-            else cast(str, message.group_openid)
-        )
+        abm.group_id = cast(str, message.group_openid)
+        abm.session_id = abm.group_id
         self._commit(abm)
 
     # 收到频道消息
@@ -48,9 +45,8 @@ class botClient(Client):
             message,
             MessageType.GROUP_MESSAGE,
         )
-        abm.session_id = (
-            abm.sender.user_id if self.platform.unique_session else message.channel_id
-        )
+        abm.group_id = message.channel_id
+        abm.session_id = abm.group_id
         self._commit(abm)
 
     # 收到私聊消息
@@ -95,7 +91,6 @@ 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,7 +142,12 @@ class SatoriPlatformAdapter(Platform):
             raise ValueError(f"WebSocket URL必须以ws://或wss://开头: {self.endpoint}")
 
         try:
-            websocket = await connect(self.endpoint, additional_headers={})
+            websocket = await connect(
+                self.endpoint,
+                additional_headers={},
+                max_size=10 * 1024 * 1024,  # 10MB
+            )
+
             self.ws = websocket
 
             await asyncio.sleep(0.1)

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

@@ -41,7 +41,6 @@ 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")
@@ -147,12 +146,10 @@ class SlackAdapter(Platform):
             abm.group_id = channel_id
 
         # 设置会话ID
-        if self.unique_session and abm.type == MessageType.GROUP_MESSAGE:
-            abm.session_id = f"{user_id}_{channel_id}"
+        if abm.type == MessageType.GROUP_MESSAGE:
+            abm.session_id = abm.group_id
         else:
-            abm.session_id = (
-                channel_id if abm.type == MessageType.GROUP_MESSAGE else user_id
-            )
+            abm.session_id = 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,7 +79,6 @@ 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,7 +47,6 @@ 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",
@@ -509,11 +508,10 @@ class WeChatPadProAdapter(Platform):
                 if accurate_nickname:
                     abm.sender.nickname = accurate_nickname
 
-            # 对于群聊，session_id 可以是群聊 ID 或发送者 ID + 群聊 ID (如果 unique_session 为 True)
-            if self.unique_session:
-                abm.session_id = f"{from_user_name}#{abm.sender.user_id}"
+            if abm.type == MessageType.GROUP_MESSAGE:
+                abm.session_id = abm.group_id
             else:
-                abm.session_id = from_user_name
+                abm.session_id = abm.sender.user_id
 
             msg_source = raw_message.get("msg_source", "")
             if self.wxid in msg_source:

astrbot/core/provider/entities.py

@@ -14,6 +14,7 @@ import astrbot.core.message.components as Comp
 from astrbot import logger
 from astrbot.core.agent.message import (
     AssistantMessageSegment,
+    ContentPart,
     ToolCall,
     ToolCallMessageSegment,
 )
@@ -92,6 +93,8 @@ 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)
@@ -166,13 +169,23 @@ 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)
@@ -185,11 +198,21 @@ class ProviderRequest:
                 if not image_data:
                     logger.warning(f"图片 {image_url} 得到的结果为空，将忽略。")
                     continue
-                user_content["content"].append(
+                content_blocks.append(
                     {"type": "image_url", "image_url": {"url": image_data}},
                 )
-            return user_content
-        return {"role": "user", "content": self.prompt}
+
+        # 只有当只有一个来自 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}
 
     async def _encode_image_bs64(self, image_url: str) -> str:
         """将图片转换为 base64"""
@@ -249,6 +272,8 @@ 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
@@ -269,12 +294,14 @@ class LLMResponse:
     def __init__(
         self,
         role: str,
-        completion_text: str = "",
+        completion_text: str | None = None,
         result_chain: MessageChain | None = None,
         tools_call_args: list[dict[str, Any]] | None = None,
         tools_call_name: list[str] | None = None,
         tools_call_ids: list[str] | None = None,
         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
@@ -294,6 +321,8 @@ 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:
@@ -310,6 +339,8 @@ 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/provider.py

@@ -4,7 +4,7 @@ import os
 from collections.abc import AsyncGenerator
 from typing import TypeAlias, Union
 
-from astrbot.core.agent.message import Message
+from astrbot.core.agent.message import ContentPart, Message
 from astrbot.core.agent.tool import ToolSet
 from astrbot.core.provider.entities import (
     LLMResponse,
@@ -103,6 +103,7 @@ 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 的文本对话结果。会使用当前的模型进行对话。
@@ -114,6 +115,7 @@ 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,6 +11,7 @@ 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
@@ -47,6 +48,8 @@ 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"))
 
     def _prepare_payload(self, messages: list[dict]):
@@ -63,12 +66,33 @@ class ProviderAnthropic(Provider):
         new_messages = []
         for message in messages:
             if message["role"] == "system":
-                system_prompt = message["content"]
+                system_prompt = message["content"] or "<empty system prompt>"
             elif message["role"] == "assistant":
                 blocks = []
-                if isinstance(message["content"], str):
+                reasoning_content = ""
+                thinking_signature = ""
+                if isinstance(message["content"], str) and message["content"].strip():
                     blocks.append({"type": "text", "text": message["content"]})
-                if "tool_calls" in message:
+                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):
                     for tool_call in message["tool_calls"]:
                         blocks.append(  # noqa: PERF401
                             {
@@ -99,7 +123,7 @@ class ProviderAnthropic(Provider):
                             {
                                 "type": "tool_result",
                                 "tool_use_id": message["tool_call_id"],
-                                "content": message["content"],
+                                "content": message["content"] or "<empty response>",
                             },
                         ],
                     },
@@ -132,6 +156,14 @@ class ProviderAnthropic(Provider):
 
         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
         )
@@ -149,6 +181,11 @@ 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)
@@ -180,6 +217,16 @@ class ProviderAnthropic(Provider):
         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
@@ -219,6 +266,21 @@ 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:
@@ -275,6 +337,8 @@ class ProviderAnthropic(Provider):
             is_chunk=False,
             usage=usage,
             id=id,
+            reasoning_content=reasoning_content,
+            reasoning_signature=reasoning_signature or None,
         )
 
         if final_tool_calls:
@@ -296,13 +360,16 @@ 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)
+            new_record = await self.assemble_context(
+                prompt, image_urls, extra_user_content_parts
+            )
         context_query = self._ensure_message_to_dicts(contexts)
         if new_record:
             context_query.append(new_record)
@@ -342,21 +409,24 @@ class ProviderAnthropic(Provider):
 
     async def text_chat_stream(
         self,
-        prompt,
+        prompt=None,
         session_id=None,
-        image_urls=...,
+        image_urls=None,
         func_tool=None,
-        contexts=...,
+        contexts=None,
         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)
+            new_record = await self.assemble_context(
+                prompt, image_urls, extra_user_content_parts
+            )
         context_query = self._ensure_message_to_dicts(contexts)
         if new_record:
             context_query.append(new_record)
@@ -388,15 +458,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):
+    async def assemble_context(
+        self,
+        text: str,
+        image_urls: list[str] | None = None,
+        extra_user_content_parts: list[ContentPart] | None = None,
+    ):
         """组装上下文，支持文本和图片"""
-        if not image_urls:
-            return {"role": "user", "content": text}
 
-        content = []
-        content.append({"type": "text", "text": text})
-
-        for image_url in image_urls:
+        async def resolve_image_url(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)
@@ -408,28 +478,68 @@ class ProviderAnthropic(Provider):
 
             if not image_data:
                 logger.warning(f"图片 {image_url} 得到的结果为空，将忽略。")
-                continue
+                return None
 
             # 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
 
-            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
-                        ),
-                    },
+            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 = []
+
+        # 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,10 +56,14 @@ 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["model"])
+        self.set_model(provider_config.get("model", None))
 
     async def _get_reference_id_by_character(self, character: str) -> str | None:
         """获取角色的reference_id
@@ -135,17 +139,21 @@ 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).stream(
+        async with AsyncClient(base_url=self.api_base, timeout=self.timeout).stream(
             "POST",
             "/tts",
             headers=self.headers,
             content=ormsgpack.packb(request, option=ormsgpack.OPT_SERIALIZE_PYDANTIC),
         ) as response:
-            if response.headers["content-type"] == "audio/wav":
+            if response.status_code == 200 and response.headers.get(
+                "content-type", ""
+            ).startswith("audio/"):
                 with open(path, "wb") as f:
                     async for chunk in response.aiter_bytes():
                         f.write(chunk)
                 return path
-            body = await response.aread()
-            text = body.decode("utf-8", errors="replace")
-            raise Exception(f"Fish Audio API请求失败: {text}")
+            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}"
+            )

astrbot/core/provider/sources/gemini_source.py

@@ -13,6 +13,7 @@ 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
@@ -320,9 +321,37 @@ class ProviderGoogleGenAI(Provider):
                 append_or_extend(gemini_contents, parts, types.UserContent)
 
             elif role == "assistant":
-                if content:
+                if isinstance(content, str):
                     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"]:
@@ -440,7 +469,8 @@ class ProviderGoogleGenAI(Provider):
         for part in result_parts:
             if part.text:
                 chain.append(Comp.Plain(part.text))
-            elif (
+
+            if (
                 part.function_call
                 and part.function_call.name is not None
                 and part.function_call.args is not None
@@ -457,13 +487,18 @@ class ProviderGoogleGenAI(Provider):
                     llm_response.tools_call_extra_content[tool_call_id] = {
                         "google": {"thought_signature": ts_bs64}
                     }
-            elif (
+
+            if (
                 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:
@@ -680,13 +715,16 @@ 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)
+            new_record = await self.assemble_context(
+                prompt, image_urls, extra_user_content_parts
+            )
         context_query = self._ensure_message_to_dicts(contexts)
         if new_record:
             context_query.append(new_record)
@@ -732,13 +770,16 @@ 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)
+            new_record = await self.assemble_context(
+                prompt, image_urls, extra_user_content_parts
+            )
         context_query = self._ensure_message_to_dicts(contexts)
         if new_record:
             context_query.append(new_record)
@@ -797,33 +838,75 @@ class ProviderGoogleGenAI(Provider):
         self.chosen_api_key = key
         self._init_client()
 
-    async def assemble_context(self, text: str, image_urls: list[str] | None = None):
+    async def assemble_context(
+        self,
+        text: str,
+        image_urls: list[str] | None = None,
+        extra_user_content_parts: list[ContentPart] | None = None,
+    ):
         """组装上下文。"""
-        if image_urls:
-            user_content = {
-                "role": "user",
-                "content": [{"type": "text", "text": text if text else "[图片]"}],
+
+        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},
             }
-            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)
-                elif image_url.startswith("file:///"):
-                    image_path = image_url.replace("file:///", "")
-                    image_data = await self.encode_image_bs64(image_path)
+
+        # 构建内容块列表
+        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:
-                    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}
+                    raise ValueError(f"不支持的额外内容块类型: {type(part)}")
+
+        # 3. 图片内容
+        if image_urls:
+            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}
 
     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", "neutral"),
+            "emotion": provider_config.get("minimax-voice-emotion", "auto"),
             "latex_read": provider_config.get("minimax-voice-latex", False),
             "english_normalization": provider_config.get(
                 "minimax-voice-english-normalization",
@@ -59,6 +59,9 @@ 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 Message
+from astrbot.core.agent.message import ContentPart, ImageURLPart, Message, TextPart
 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
@@ -74,28 +74,6 @@ class ProviderOpenAIOfficial(Provider):
 
         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 = []
@@ -134,10 +112,6 @@ 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,
@@ -251,10 +225,14 @@ 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=usage.prompt_tokens - cached,
-            input_cached=ptd.cached_tokens if ptd and ptd.cached_tokens else 0,
-            output=usage.completion_tokens,
+            input_other=prompt_tokens - cached,
+            input_cached=cached,
+            output=completion_tokens,
         )
 
     async def _parse_openai_completion(
@@ -348,6 +326,7 @@ 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:
         """准备聊天所需的有效载荷和上下文"""
@@ -355,7 +334,9 @@ class ProviderOpenAIOfficial(Provider):
             contexts = []
         new_record = None
         if prompt is not None:
-            new_record = await self.assemble_context(prompt, image_urls)
+            new_record = await self.assemble_context(
+                prompt, image_urls, extra_user_content_parts
+            )
         context_query = self._ensure_message_to_dicts(contexts)
         if new_record:
             context_query.append(new_record)
@@ -378,11 +359,27 @@ class ProviderOpenAIOfficial(Provider):
 
         payloads = {"messages": context_query, "model": model}
 
-        # xAI origin search tool inject
-        self._maybe_inject_xai_search(payloads, **kwargs)
+        self._finally_convert_payload(payloads)
 
         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,
@@ -476,6 +473,7 @@ 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(
@@ -485,6 +483,7 @@ class ProviderOpenAIOfficial(Provider):
             system_prompt,
             tool_calls_result,
             model=model,
+            extra_user_content_parts=extra_user_content_parts,
             **kwargs,
         )
 
@@ -624,33 +623,71 @@ class ProviderOpenAIOfficial(Provider):
         self,
         text: str,
         image_urls: list[str] | None = None,
+        extra_user_content_parts: list[ContentPart] | None = None,
     ) -> dict:
         """组装成符合 OpenAI 格式的 role 为 user 的消息段"""
-        if image_urls:
-            user_content = {
-                "role": "user",
-                "content": [{"type": "text", "text": text if text else "[图片]"}],
+
+        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},
             }
-            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)
-                elif image_url.startswith("file:///"):
-                    image_path = image_url.replace("file:///", "")
-                    image_data = await self.encode_image_bs64(image_path)
+
+        # 构建内容块列表
+        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:
-                    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}
+                    raise ValueError(f"不支持的额外内容块类型: {type(part)}")
+
+        # 3. 图片内容
+        if image_urls:
+            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}
 
     async def encode_image_bs64(self, image_url: str) -> str:
         """将图片转换为 base64"""

astrbot/core/provider/sources/xai_source.py

@@ -0,0 +1,29 @@
+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,7 +8,10 @@ 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 tencent_silk_to_wav
+from astrbot.core.utils.tencent_record_helper import (
+    convert_to_pcm_wav,
+    tencent_silk_to_wav,
+)
 
 from ..entities import ProviderType
 from ..provider import STTProvider
@@ -111,17 +114,22 @@ class ProviderXinferenceSTT(STTProvider):
                 return ""
 
             # 2. Check for conversion
-            needs_conversion = False
-            if (
-                audio_url.endswith((".amr", ".silk"))
-                or is_tencent
-                or b"SILK" in audio_bytes[:8]
-            ):
-                needs_conversion = True
+            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"
 
             # 3. Perform conversion if needed
-            if needs_conversion:
-                logger.info("Audio requires conversion, using temporary files...")
+            if conversion_type:
+                logger.info(
+                    f"Audio requires conversion ({conversion_type}), using temporary files..."
+                )
                 temp_dir = os.path.join(get_astrbot_data_path(), "temp")
                 os.makedirs(temp_dir, exist_ok=True)
 
@@ -132,8 +140,12 @@ class ProviderXinferenceSTT(STTProvider):
                 with open(input_path, "wb") as f:
                     f.write(audio_bytes)
 
-                logger.info("Converting silk/amr file to wav ...")
-                await tencent_silk_to_wav(input_path, output_path)
+                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)
 
                 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
+from astrbot.core import db_helper, logger
 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,6 +90,7 @@ 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:
@@ -99,9 +100,24 @@ 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("新的指令名已被其他指令占用，请换一个名称。")
+        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 []
 
     config = await db_helper.upsert_command_config(
         handler_full_name=handler_full_name,
@@ -114,7 +130,7 @@ async def rename_command(
         conflict_key=descriptor.original_command,
         resolution_strategy="manual_rename",
         note=None,
-        extra_data=None,
+        extra_data=merged_extra,
         auto_managed=False,
     )
     _bind_descriptor_with_config(descriptor, config)
@@ -192,12 +208,18 @@ def _collect_descriptors(include_sub_commands: bool) -> list[CommandDescriptor]:
     """收集指令，按需包含子指令。"""
     descriptors: list[CommandDescriptor] = []
     for handler in star_handlers_registry:
-        desc = _build_descriptor(handler)
-        if not desc:
+        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}"
+            )
             continue
-        if not include_sub_commands and desc.is_sub_command:
-            continue
-        descriptors.append(desc)
     return descriptors
 
 
@@ -357,14 +379,27 @@ 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 and descriptor.current_fragment:
-        _set_filter_fragment(descriptor.filter_ref, descriptor.current_fragment)
+    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()],
+            )
 
 
 def _bind_configs_to_descriptors(
@@ -403,6 +438,18 @@ 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

@@ -377,7 +377,7 @@ class Context:
             if not module_path:
                 _parts = []
                 module_part = tool.__module__.split(".")
-                flags = ["packages", "plugins"]
+                flags = ["builtin_stars", "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,6 +18,7 @@ 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
@@ -49,13 +50,10 @@ class PluginManager:
         """存储插件的路径。即 data/plugins"""
         self.plugin_config_path = get_astrbot_config_path()
         """存储插件配置的路径。data/config"""
-        self.reserved_plugin_path = os.path.abspath(
-            os.path.join(
-                os.path.dirname(os.path.abspath(__file__)),
-                "../../../packages",
-            ),
+        self.reserved_plugin_path = os.path.join(
+            get_astrbot_path(), "astrbot", "builtin_stars"
         )
-        """保留插件的路径。在 packages 目录下"""
+        """保留插件的路径。在 astrbot/builtin_stars 目录下"""
         self.conf_schema_fname = "_conf_schema.json"
         self.logo_fname = "logo.png"
         """插件配置 Schema 文件名"""
@@ -252,7 +250,7 @@ class PluginManager:
             list[str]: 与该插件相关的模块名列表
 
         """
-        prefix = "packages." if is_reserved else "data.plugins."
+        prefix = "astrbot.builtin_stars." if is_reserved else "data.plugins."
         return [
             key
             for key in list(sys.modules.keys())
@@ -270,7 +268,7 @@ class PluginManager:
         可以基于模块名模式或插件目录名移除模块，用于清理插件相关的模块缓存
 
         Args:
-            module_patterns: 要移除的模块名模式列表（例如 ["data.plugins", "packages"]）
+            module_patterns: 要移除的模块名模式列表（例如 ["data.plugins", "astrbot.builtin_stars"]）
             root_dir_name: 插件根目录名，用于移除与该插件相关的所有模块
             is_reserved: 插件是否为保留插件（影响模块路径前缀）
 
@@ -382,9 +380,9 @@ class PluginManager:
                 reserved = plugin_module.get(
                     "reserved",
                     False,
-                )  # 是否是保留插件。目前在 packages/ 目录下的都是保留插件。保留插件不可以卸载。
+                )  # 是否是保留插件。目前在 astrbot/builtin_stars 目录下的都是保留插件。保留插件不可以卸载。
 
-                path = "data.plugins." if not reserved else "packages."
+                path = "data.plugins." if not reserved else "astrbot.builtin_stars."
                 path += root_dir_name + "." + module_str
 
                 # 检查是否需要载入指定的插件
@@ -631,7 +629,11 @@ class PluginManager:
         # 清除 pip.main 导致的多余的 logging handlers
         for handler in logging.root.handlers[:]:
             logging.root.removeHandler(handler)
-        await sync_command_configs()
+        try:
+            await sync_command_configs()
+        except Exception as e:
+            logger.error(f"同步指令配置失败: {e!s}")
+            logger.error(traceback.format_exc())
 
         if not fail_rec:
             return True, None
@@ -825,7 +827,7 @@ class PluginManager:
             if (
                 mp
                 and mp.startswith(plugin_module_path)
-                and not mp.endswith(("packages", "data.plugins"))
+                and not mp.endswith(("astrbot.builtin_stars", "data.plugins"))
             ):
                 to_remove.append(func_tool)
         for func_tool in to_remove:
@@ -880,7 +882,7 @@ class PluginManager:
                     plugin.module_path
                     and mp
                     and plugin.module_path.startswith(mp)
-                    and not mp.endswith(("packages", "data.plugins"))
+                    and not mp.endswith(("astrbot.builtin_stars", "data.plugins"))
                 ):
                     func_tool.active = False
                     if func_tool.name not in inactivated_llm_tools:
@@ -929,7 +931,7 @@ class PluginManager:
                 plugin.module_path
                 and mp
                 and plugin.module_path.startswith(mp)
-                and not mp.endswith(("packages", "data.plugins"))
+                and not mp.endswith(("astrbot.builtin_stars", "data.plugins"))
                 and func_tool.name in inactivated_llm_tools
             ):
                 inactivated_llm_tools.remove(func_tool.name)
@@ -942,8 +944,49 @@ 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,6 +5,10 @@
 数据目录路径：固定为根目录下的 data 目录
 配置文件路径：固定为数据目录下的 config 目录
 插件目录路径：固定为数据目录下的 plugins 目录
+插件数据目录路径：固定为数据目录下的 plugin_data 目录
+T2I 模板目录路径：固定为数据目录下的 t2i_templates 目录
+WebChat 数据目录路径：固定为数据目录下的 webchat 目录
+临时文件目录路径：固定为数据目录下的 temp 目录
 """
 
 import os
@@ -37,3 +41,33 @@ 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/pip_installer.py

@@ -1,10 +1,29 @@
 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
@@ -42,7 +61,7 @@ class PipInstaller:
 
             assert process.stdout is not None
             async for line in process.stdout:
-                logger.info(line.decode().strip())
+                logger.info(_robust_decode(line))
 
             await process.wait()
 

astrbot/dashboard/routes/__init__.py

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

astrbot/dashboard/routes/command.py

@@ -61,12 +61,13 @@ 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)
+            await rename_command_service(handler_full_name, new_name, aliases=aliases)
         except ValueError as exc:
             return Response().error(str(exc)).__dict__
 

astrbot/dashboard/routes/config.py

@@ -46,6 +46,46 @@ 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 = []
 
@@ -61,6 +101,11 @@ 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__}",
@@ -185,23 +230,30 @@ class ConfigRoute(Route):
             "/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/<provider_source_id>/models": (
+            "/config/provider_sources/models": (
                 "GET",
                 self.get_provider_source_models,
             ),
-            "/config/provider_sources/<provider_source_id>/update": (
+            "/config/provider_sources/update": (
                 "POST",
                 self.update_provider_source,
             ),
-            "/config/provider_sources/<provider_source_id>/delete": (
+            "/config/provider_sources/delete": (
                 "POST",
                 self.delete_provider_source,
             ),
         }
         self.register_routes()
 
-    async def delete_provider_source(self, provider_source_id: str):
+    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(
@@ -235,15 +287,16 @@ class ConfigRoute(Route):
 
         return Response().ok(message="删除 provider source 成功").__dict__
 
-    async def update_provider_source(self, provider_source_id: str):
+    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 = provider_source_id
+        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__
@@ -684,11 +737,15 @@ class ConfigRoute(Route):
             logger.error(traceback.format_exc())
             return Response().error(f"获取嵌入维度失败: {e!s}").__dict__
 
-    async def get_provider_source_models(self, provider_source_id: str):
+    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
 

astrbot/dashboard/routes/log.py

@@ -1,15 +1,26 @@
 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
+from quart import make_response, request
 
 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)
@@ -21,21 +32,44 @@ class LogRoute(Route):
             methods=["GET"],
         )
 
-    async def log(self):
+    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 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()
-                    payload = {
-                        "type": "log",
-                        **message,  # see astrbot/core/log.py
-                    }
-                    yield f"data: {json.dumps(payload, ensure_ascii=False)}\n\n"
+                    current_ts = message.get("time", time.time())
+                    yield _format_log_sse(message, current_ts)
+
             except asyncio.CancelledError:
                 pass
-            except BaseException as e:
+            except Exception as e:
                 logger.error(f"Log SSE 连接错误: {e}")
             finally:
                 if queue:
@@ -53,7 +87,7 @@ class LogRoute(Route):
                 },
             ),
         )
-        response.timeout = None
+        response.timeout = None  # type: ignore
         return response
 
     async def log_history(self):
@@ -69,6 +103,6 @@ class LogRoute(Route):
                 )
                 .__dict__
             )
-        except BaseException as e:
+        except Exception as e:
             logger.error(f"获取日志历史失败: {e}")
             return Response().error(f"获取日志历史失败: {e}").__dict__

astrbot/dashboard/server.py

@@ -19,6 +19,7 @@ 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
@@ -85,6 +86,7 @@ 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>",
@@ -108,7 +110,13 @@ 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"]
+        allowed_endpoints = [
+            "/api/auth/login",
+            "/api/file",
+            "/api/platform/webhook",
+            "/api/stat/start-time",
+            "/api/backup/download",  # 备份下载使用 URL 参数传递 token
+        ]
         if any(request.path.startswith(prefix) for prefix in allowed_endpoints):
             return None
         # 声明 JWT

changelogs/v4.10.1.md

@@ -0,0 +1,46 @@
+## 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

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

changelogs/v4.10.3.md

@@ -0,0 +1,18 @@
+## 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/package.json

@@ -22,6 +22,7 @@
     "axios-mock-adapter": "^1.22.0",
     "chance": "1.1.11",
     "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",

dashboard/src/components/extension/componentPanel/components/RenameDialog.vue

@@ -1,14 +1,16 @@
 <script setup lang="ts">
+import { computed, ref, watch } from 'vue';
 import { useModuleI18n } from '@/i18n/composables';
 import type { CommandItem } from '../types';
 
 const { tm } = useModuleI18n('features/command');
 
 // Props
-defineProps<{
+const props = defineProps<{
   show: boolean;
   command: CommandItem | null;
   newName: string;
+  aliases: string[];
   loading: boolean;
 }>();
 
@@ -16,8 +18,42 @@ defineProps<{
 const emit = defineEmits<{
   (e: 'update:show', value: boolean): void;
   (e: 'update:newName', value: string): void;
+  (e: 'update:aliases', value: string[]): void;
   (e: 'confirm'): void;
 }>();
+
+const addAlias = () => {
+  emit('update:aliases', [...props.aliases, '']);
+};
+
+const removeAlias = (index: number) => {
+  const newAliases = [...props.aliases];
+  newAliases.splice(index, 1);
+  emit('update:aliases', newAliases);
+};
+
+const updateAlias = (index: number, value: string) => {
+  const newAliases = [...props.aliases];
+  newAliases[index] = value;
+  emit('update:aliases', newAliases);
+};
+
+const hasAliases = computed(() => (props.aliases || []).some(a => (a ?? '').toString().trim()));
+const showAliasEditor = ref(false);
+const aliasEditorEverOpened = ref(false);
+
+watch(
+  () => props.show,
+  (open) => {
+    if (!open) return;
+    // 如果已有别名则默认展开，否则默认收起
+    showAliasEditor.value = hasAliases.value;
+  },
+);
+
+watch(showAliasEditor, (open) => {
+  if (open) aliasEditorEverOpened.value = true;
+});
 </script>
 
 <template>
@@ -32,7 +68,49 @@ const emit = defineEmits<{
           variant="outlined"
           density="compact"
           autofocus
+          class="mb-2"
         />
+
+        <v-card variant="outlined" class="mt-2" elevation="0">
+          <div
+            class="d-flex align-center justify-space-between px-4 py-3"
+            role="button"
+            tabindex="0"
+            @click="showAliasEditor = !showAliasEditor"
+            @keydown.enter.prevent="showAliasEditor = !showAliasEditor"
+            @keydown.space.prevent="showAliasEditor = !showAliasEditor"
+          >
+            <div class="text-subtitle-1">{{ tm('dialogs.rename.aliases') }}</div>
+            <v-icon size="20">{{ showAliasEditor ? 'mdi-chevron-up' : 'mdi-chevron-down' }}</v-icon>
+          </div>
+          <v-divider v-if="showAliasEditor" />
+          <v-slide-y-transition>
+            <div v-if="aliasEditorEverOpened" v-show="showAliasEditor" class="px-4 py-3">
+              <div v-for="(alias, index) in aliases" :key="index" class="d-flex align-center mb-2">
+                <v-text-field
+                  :model-value="alias"
+                  @update:model-value="updateAlias(index, $event)"
+                  variant="outlined"
+                  density="compact"
+                  hide-details
+                  class="flex-grow-1 mr-2"
+                />
+                <v-btn icon="mdi-delete" variant="text" color="error" density="compact" @click="removeAlias(index)" />
+              </div>
+              <v-btn
+                prepend-icon="mdi-plus"
+                variant="outlined"
+                color="primary"
+                block
+                size="small"
+                class="mt-2"
+                @click="addAlias"
+              >
+                {{ tm('dialogs.rename.addAlias') }}
+              </v-btn>
+            </div>
+          </v-slide-y-transition>
+        </v-card>
       </v-card-text>
       <v-card-actions>
         <v-spacer />

dashboard/src/components/extension/componentPanel/composables/useCommandActions.ts

@@ -14,6 +14,7 @@ export function useCommandActions(
     show: false,
     command: null,
     newName: '',
+    aliases: [],
     loading: false
   });
 
@@ -53,6 +54,7 @@ export function useCommandActions(
   const openRenameDialog = (cmd: CommandItem) => {
     renameDialog.command = cmd;
     renameDialog.newName = cmd.current_fragment || '';
+    renameDialog.aliases = [...(cmd.aliases || [])];
     renameDialog.show = true;
   };
 
@@ -66,7 +68,8 @@ export function useCommandActions(
     try {
       const res = await axios.post('/api/commands/rename', {
         handler_full_name: renameDialog.command.handler_full_name,
-        new_name: renameDialog.newName.trim()
+        new_name: renameDialog.newName.trim(),
+        aliases: renameDialog.aliases.filter(a => a.trim())
       });
       if (res.data.status === 'ok') {
         toast(successMessage, 'success');

dashboard/src/components/extension/componentPanel/index.vue

@@ -288,6 +288,8 @@ watch(viewMode, async (mode) => {
     @update:show="renameDialog.show = $event"
     :new-name="renameDialog.newName"
     @update:new-name="renameDialog.newName = $event"
+    :aliases="renameDialog.aliases"
+    @update:aliases="renameDialog.aliases = $event"
     :command="renameDialog.command"
     :loading="renameDialog.loading"
     @confirm="handleConfirmRename"

dashboard/src/components/extension/componentPanel/types.ts

@@ -52,6 +52,7 @@ export interface RenameDialogState {
   show: boolean;
   command: CommandItem | null;
   newName: string;
+  aliases: string[];
   loading: boolean;
 }
 

dashboard/src/components/shared/AstrBotConfig.vue

@@ -1,11 +1,8 @@
 <script setup>
 import { VueMonacoEditor } from '@guolao/vue-monaco-editor'
 import { ref, computed } from 'vue'
-import ListConfigItem from './ListConfigItem.vue'
-import ObjectEditor from './ObjectEditor.vue'
-import ProviderSelector from './ProviderSelector.vue'
-import PersonaSelector from './PersonaSelector.vue'
-import KnowledgeBaseSelector from './KnowledgeBaseSelector.vue'
+import ConfigItemRenderer from './ConfigItemRenderer.vue'
+import TemplateListEditor from './TemplateListEditor.vue'
 import { useI18n } from '@/i18n/composables'
 import axios from 'axios'
 import { useToast } from '@/utils/toast'
@@ -159,6 +156,30 @@ function hasVisibleItemsAfter(items, currentIndex) {
           </div>
         </div>
 
+        <!-- Template List -->
+        <div v-else-if="metadata[metadataKey].items[key]?.type === 'template_list'" class="nested-object w-100">
+          <div v-if="!metadata[metadataKey].items[key]?.invisible && shouldShowItem(metadata[metadataKey].items[key], key)" class="nested-container">
+            <div class="config-section mb-2">
+              <v-list-item-title class="config-title">
+                <span v-if="metadata[metadataKey].items[key]?.description">
+                  {{ metadata[metadataKey].items[key]?.description }}
+                  <span class="property-key">({{ key }})</span>
+                </span>
+                <span v-else>{{ key }}</span>
+              </v-list-item-title>
+              <v-list-item-subtitle class="config-hint">
+                <span v-if="metadata[metadataKey].items[key]?.obvious_hint && metadata[metadataKey].items[key]?.hint" class="important-hint">‼️</span>
+                {{ metadata[metadataKey].items[key]?.hint }}
+              </v-list-item-subtitle>
+            </div>
+            <TemplateListEditor
+              v-model="iterable[key]"
+              :templates="metadata[metadataKey].items[key]?.templates || {}"
+              class="config-field"
+            />
+          </div>
+        </div>
+
         <!-- Regular Property -->
         <template v-else>
           <v-row v-if="!metadata[metadataKey].items[key]?.invisible && shouldShowItem(metadata[metadataKey].items[key], key)" class="config-row">
@@ -181,202 +202,15 @@ function hasVisibleItemsAfter(items, currentIndex) {
             </v-col>
 
             <v-col cols="12" sm="6" class="config-input">
-              <div v-if="metadata[metadataKey].items[key]" class="w-100">
-                <!-- Special handling for specific metadata types -->
-                <div v-if="metadata[metadataKey].items[key]?._special === 'select_provider'">
-                  <ProviderSelector
-                    v-model="iterable[key]"
-                    :provider-type="'chat_completion'"
-                  />
-                </div>
-                <div v-else-if="metadata[metadataKey].items[key]?._special === 'select_provider_stt'">
-                  <ProviderSelector
-                    v-model="iterable[key]"
-                    :provider-type="'speech_to_text'"
-                  />
-                </div>
-                <div v-else-if="metadata[metadataKey].items[key]?._special === 'select_provider_tts'">
-                  <ProviderSelector
-                    v-model="iterable[key]"
-                    :provider-type="'text_to_speech'"
-                  />
-                </div>
-                <div v-else-if="metadata[metadataKey].items[key]?._special === 'select_persona'">
-                  <PersonaSelector
-                    v-model="iterable[key]"
-                  />
-                </div>
-                <div v-else-if="metadata[metadataKey].items[key]?._special === 'select_knowledgebase'">
-                  <KnowledgeBaseSelector
-                    v-model="iterable[key]"
-                  />
-                </div>
-                <!-- Numeric input with get_embedding_dim button -->
-                <div v-else-if="metadata[metadataKey].items[key]?._special === 'get_embedding_dim'"
-                  class="d-flex align-center gap-2">
-                  <v-text-field
-                    v-model="iterable[key]"
-                    density="compact"
-                    variant="outlined"
-                    class="config-field"
-                    type="number"
-                    hide-details
-                  ></v-text-field>
-                  <v-btn
-                    color="primary"
-                    variant="tonal"
-                    size="small"
-                    @click="getEmbeddingDimensions(iterable)"
-                    :loading="loadingEmbeddingDim"
-                    class="ml-2"
-                  >
-                    自动检测
-                  </v-btn>
-                </div>
-
-                <!-- List item with options-->
-                <div v-else-if="metadata[metadataKey].items[key]?.type === 'list' && metadata[metadataKey].items[key]?.options && !metadata[metadataKey].items[key]?.invisible && metadata[metadataKey].items[key]?.render_type === 'checkbox'"
-                  class="d-flex flex-wrap gap-20">
-                  <v-checkbox
-                    v-for="(option, index) in metadata[metadataKey].items[key]?.options"
-                    v-model="iterable[key]"
-                    :label="metadata[metadataKey].items[key]?.labels ? metadata[metadataKey].items[key].labels[index] : option"
-                    :value="option"
-                    class="mr-2"
-                    color="primary"
-                    hide-details
-                  ></v-checkbox>
-                </div>
-                <!-- List item with options-->
-                <v-combobox
-                  v-else-if="metadata[metadataKey].items[key]?.type === 'list' && metadata[metadataKey].items[key]?.options && !metadata[metadataKey].items[key]?.invisible"
-                  v-model="iterable[key]"
-                  :items="metadata[metadataKey].items[key]?.options"
-                  :disabled="metadata[metadataKey].items[key]?.readonly"
-                  density="compact"
-                  variant="outlined"
-                  class="config-field"
-                  hide-details
-                  chips
-                  multiple
-                ></v-combobox>
-                <!-- Select input -->
-                <v-select
-                  v-else-if="metadata[metadataKey].items[key]?.options && !metadata[metadataKey].items[key]?.invisible"
-                  v-model="iterable[key]"
-                  :items="metadata[metadataKey].items[key]?.options"
-                  :disabled="metadata[metadataKey].items[key]?.readonly"
-                  density="compact"
-                  variant="outlined"
-                  class="config-field"
-                  hide-details
-                ></v-select>
-
-                <!-- Code Editor with Full Screen Option -->
-                <div v-else-if="metadata[metadataKey].items[key]?.editor_mode && !metadata[metadataKey].items[key]?.invisible" class="editor-container">
-                  <VueMonacoEditor
-                    :theme="metadata[metadataKey].items[key]?.editor_theme || 'vs-light'"
-                    :language="metadata[metadataKey].items[key]?.editor_language || 'json'"
-                    style="min-height: 100px; flex-grow: 1; border: 1px solid rgba(0, 0, 0, 0.1);"
-                    v-model:value="iterable[key]"
-                  >
-                  </VueMonacoEditor>
-                  <v-btn
-                    icon
-                    size="small"
-                    variant="text"
-                    color="primary"
-                    class="editor-fullscreen-btn"
-                    @click="openEditorDialog(key, iterable, metadata[metadataKey].items[key]?.editor_theme, metadata[metadataKey].items[key]?.editor_language)"
-                    :title="t('core.common.editor.fullscreen')"
-                  >
-                    <v-icon>mdi-fullscreen</v-icon>
-                  </v-btn>
-                </div>
-
-                <!-- String input -->
-                <v-text-field
-                  v-else-if="metadata[metadataKey].items[key]?.type === 'string' && !metadata[metadataKey].items[key]?.invisible"
-                  v-model="iterable[key]"
-                  density="compact"
-                  variant="outlined"
-                  class="config-field"
-                  hide-details
-                ></v-text-field>
-
-                <!-- Numeric input with optional slider -->
-                <div
-                  v-else-if="(metadata[metadataKey].items[key]?.type === 'int' || metadata[metadataKey].items[key]?.type === 'float') && !metadata[metadataKey]?.invisible"
-                  class="d-flex align-center gap-3"
-                >
-                  <v-slider
-                    v-if="metadata[metadataKey].items[key]?.slider"
-                    v-model.number="iterable[key]"
-                    :min="metadata[metadataKey].items[key]?.slider?.min ?? 0"
-                    :max="metadata[metadataKey].items[key]?.slider?.max ?? 100"
-                    :step="metadata[metadataKey].items[key]?.slider?.step ?? 1"
-                    color="primary"
-                    density="compact"
-                    hide-details
-                    class="flex-grow-1"
-                  ></v-slider>
-                  <v-text-field
-                    v-model.number="iterable[key]"
-                    density="compact"
-                    variant="outlined"
-                    class="config-field"
-                    type="number"
-                    hide-details
-                    style="max-width: 140px;"
-                  ></v-text-field>
-                </div>
-
-                <!-- Text area -->
-                <v-textarea
-                  v-else-if="metadata[metadataKey].items[key]?.type === 'text' && !metadata[metadataKey].items[key]?.invisible"
-                  v-model="iterable[key]"
-                  variant="outlined"
-                  rows="3"
-                  class="config-field"
-                  hide-details
-                ></v-textarea>
-
-                <!-- Boolean switch -->
-                <v-switch
-                  v-else-if="metadata[metadataKey].items[key]?.type === 'bool' && !metadata[metadataKey].items[key]?.invisible"
-                  v-model="iterable[key]"
-                  color="primary"
-                  inset
-                  density="compact"
-                  hide-details
-                ></v-switch>
-
-                <!-- List item -->
-                <ListConfigItem
-                  v-else-if="metadata[metadataKey].items[key]?.type === 'list' && !metadata[metadataKey].items[key]?.invisible"
-                  v-model="iterable[key]"
-                  class="config-field"
-                />
-
-                <!-- Dict item (key-value editor) -->
-                <ObjectEditor
-                  v-else-if="metadata[metadataKey].items[key]?.type === 'dict' && !metadata[metadataKey].items[key]?.invisible"
-                  v-model="iterable[key]"
-                  class="config-field"
-                />
-              </div>
-
-              <!-- Fallback for unknown metadata -->
-              <div v-else class="w-100">
-                <v-text-field
-                  v-model="iterable[key]"
-                  :label="key"
-                  density="compact"
-                  variant="outlined"
-                  class="config-field"
-                  hide-details
-                ></v-text-field>
-              </div>
+              <ConfigItemRenderer
+                v-if="metadata[metadataKey].items[key]"
+                v-model="iterable[key]"
+                :item-meta="metadata[metadataKey].items[key]"
+                :loading="loadingEmbeddingDim"
+                :show-fullscreen-btn="!!metadata[metadataKey].items[key]?.editor_mode"
+                @get-embedding-dim="getEmbeddingDimensions(iterable)"
+                @open-fullscreen="openEditorDialog(key, iterable, metadata[metadataKey].items[key]?.editor_theme, metadata[metadataKey].items[key]?.editor_language)"
+              />
             </v-col>
           </v-row>
 
@@ -406,84 +240,17 @@ function hasVisibleItemsAfter(items, currentIndex) {
         </v-col>
 
         <v-col cols="12" sm="5" class="config-input">
-          <div class="w-100">
-            <!-- Select input -->
-            <v-select
-              v-if="metadata[metadataKey]?.options && !metadata[metadataKey]?.invisible"
-              v-model="iterable[metadataKey]"
-              :items="metadata[metadataKey]?.options"
-              :disabled="metadata[metadataKey]?.readonly"
-              density="compact"
-              variant="outlined"
-              class="config-field"
-              hide-details
-            ></v-select>
-
-            <!-- String input -->
-            <v-text-field
-              v-else-if="metadata[metadataKey]?.type === 'string' && !metadata[metadataKey]?.invisible"
-              v-model="iterable[metadataKey]"
-              density="compact"
-              variant="outlined"
-              class="config-field"
-              hide-details
-            ></v-text-field>
-
-            <!-- Numeric input with optional slider -->
-            <div
-              v-else-if="(metadata[metadataKey]?.type === 'int' || metadata[metadataKey]?.type === 'float') && !metadata[metadataKey]?.invisible"
-              class="d-flex align-center gap-3"
-            >
-              <v-slider
-                v-if="metadata[metadataKey]?.slider"
-                v-model.number="iterable[metadataKey]"
-                :min="metadata[metadataKey]?.slider?.min ?? 0"
-                :max="metadata[metadataKey]?.slider?.max ?? 100"
-                :step="metadata[metadataKey]?.slider?.step ?? 1"
-                color="primary"
-                density="compact"
-                hide-details
-                class="flex-grow-1"
-              ></v-slider>
-              <v-text-field
-                v-model.number="iterable[metadataKey]"
-                density="compact"
-                variant="outlined"
-                class="config-field"
-                type="number"
-                hide-details
-                style="max-width: 140px;"
-              ></v-text-field>
-            </div>
-
-            <!-- Text area -->
-            <v-textarea
-              v-else-if="metadata[metadataKey]?.type === 'text' && !metadata[metadataKey]?.invisible"
-              v-model="iterable[metadataKey]"
-              variant="outlined"
-              auto-grow
-              rows="3"
-              class="config-field"
-              hide-details
-            ></v-textarea>
-
-            <!-- Boolean switch -->
-            <v-switch
-              v-else-if="metadata[metadataKey]?.type === 'bool' && !metadata[metadataKey]?.invisible"
-              v-model="iterable[metadataKey]"
-              color="primary"
-              inset
-              density="compact"
-              hide-details
-            ></v-switch>
-
-            <!-- List item -->
-            <ListConfigItem
-              v-else-if="metadata[metadataKey]?.type === 'list' && !metadata[metadataKey]?.invisible"
-              v-model="iterable[metadataKey]"
-              class="config-field"
-            />
-          </div>
+          <TemplateListEditor
+            v-if="metadata[metadataKey]?.type === 'template_list' && !metadata[metadataKey]?.invisible"
+            v-model="iterable[metadataKey]"
+            :templates="metadata[metadataKey]?.templates || {}"
+            class="config-field"
+          />
+          <ConfigItemRenderer
+            v-else
+            v-model="iterable[metadataKey]"
+            :item-meta="metadata[metadataKey]"
+          />
         </v-col>
       </v-row>
 

dashboard/src/components/shared/AstrBotConfigV4.vue

@@ -1,13 +1,8 @@
 <script setup>
 import { VueMonacoEditor } from '@guolao/vue-monaco-editor'
 import { ref, computed } from 'vue'
-import ListConfigItem from './ListConfigItem.vue'
-import ObjectEditor from './ObjectEditor.vue'
-import ProviderSelector from './ProviderSelector.vue'
-import PersonaSelector from './PersonaSelector.vue'
-import KnowledgeBaseSelector from './KnowledgeBaseSelector.vue'
-import PluginSetSelector from './PluginSetSelector.vue'
-import T2ITemplateEditor from './T2ITemplateEditor.vue'
+import ConfigItemRenderer from './ConfigItemRenderer.vue'
+import TemplateListEditor from './TemplateListEditor.vue'
 import { useI18n, useModuleI18n } from '@/i18n/composables'
 
 
@@ -215,118 +210,19 @@ function getSpecialSubtype(value) {
               </v-list-item>
             </v-col>
             <v-col cols="12" sm="6" class="config-input">
-              <div class="w-100" v-if="!itemMeta?._special">
-                <!-- Select input for JSON selector -->
-                <v-select v-if="itemMeta?.options" v-model="createSelectorModel(itemKey).value"
-                  :items="(() => {
-                    const labels = getTranslatedLabels(itemMeta);
-                    return labels 
-                      ? itemMeta.options.map((value, index) => ({ title: labels[index] || value, value: value }))
-                      : itemMeta.options;
-                  })()" 
-                  :disabled="itemMeta?.readonly" density="compact" variant="outlined"
-                  class="config-field" hide-details></v-select>
-
-                <!-- Code Editor for JSON selector -->
-                <div v-else-if="itemMeta?.editor_mode" class="editor-container">
-                  <VueMonacoEditor :theme="itemMeta?.editor_theme || 'vs-light'"
-                    :language="itemMeta?.editor_language || 'json'"
-                    style="min-height: 100px; flex-grow: 1; border: 1px solid rgba(0, 0, 0, 0.1);"
-                    v-model:value="createSelectorModel(itemKey).value">
-                  </VueMonacoEditor>
-                  <v-btn icon size="small" variant="text" color="primary" class="editor-fullscreen-btn"
-                    @click="openEditorDialog(itemKey, iterable, itemMeta?.editor_theme, itemMeta?.editor_language)"
-                    :title="t('core.common.editor.fullscreen')">
-                    <v-icon>mdi-fullscreen</v-icon>
-                  </v-btn>
-                </div>
-
-                <!-- String input for JSON selector -->
-                <v-text-field v-else-if="itemMeta?.type === 'string'" v-model="createSelectorModel(itemKey).value"
-                  density="compact" variant="outlined" class="config-field" hide-details></v-text-field>
-
-                <!-- Numeric input with optional slider for JSON selector -->
-                <div v-else-if="itemMeta?.type === 'int' || itemMeta?.type === 'float'" class="d-flex align-center gap-3">
-                  <v-slider
-                    v-if="itemMeta?.slider"
-                    v-model.number="createSelectorModel(itemKey).value"
-                    :min="itemMeta?.slider?.min ?? 0"
-                    :max="itemMeta?.slider?.max ?? 100"
-                    :step="itemMeta?.slider?.step ?? 1"
-                    color="primary"
-                    density="compact"
-                    hide-details
-                    style="flex: 3"
-                  ></v-slider>
-                  <v-text-field
-                    v-model.number="createSelectorModel(itemKey).value"
-                    density="compact"
-                    variant="outlined"
-                    class="config-field"
-                    style="flex: 2"
-                    type="number"
-                    hide-details
-                  ></v-text-field>
-                </div>
-
-                <!-- Text area for JSON selector -->
-                <v-textarea v-else-if="itemMeta?.type === 'text'" v-model="createSelectorModel(itemKey).value"
-                  variant="outlined" rows="3" class="config-field" hide-details></v-textarea>
-
-                <!-- Boolean switch for JSON selector -->
-                <v-switch v-else-if="itemMeta?.type === 'bool'" v-model="createSelectorModel(itemKey).value"
-                  color="primary" inset density="compact" hide-details
-                  style="display: flex; justify-content: end;"></v-switch>
-
-                <!-- List item for JSON selector -->
-                <ListConfigItem v-else-if="itemMeta?.type === 'list'" v-model="createSelectorModel(itemKey).value"
-                  button-text="修改" class="config-field" />
-
-                <!-- Object editor for JSON selector -->
-                <ObjectEditor v-else-if="itemMeta?.type === 'dict'" v-model="createSelectorModel(itemKey).value"
-                  class="config-field" />
-
-                <!-- Fallback for JSON selector -->
-                <v-text-field v-else v-model="createSelectorModel(itemKey).value" density="compact" variant="outlined"
-                  class="config-field" hide-details></v-text-field>
-              </div>
-
-              <!-- Special handling for specific metadata types -->
-              <div v-else-if="itemMeta?._special === 'select_provider'">
-                <ProviderSelector v-model="createSelectorModel(itemKey).value" :provider-type="'chat_completion'" />
-              </div>
-              <div v-else-if="itemMeta?._special === 'select_provider_stt'">
-                <ProviderSelector v-model="createSelectorModel(itemKey).value" :provider-type="'speech_to_text'" />
-              </div>
-              <div v-else-if="itemMeta?._special === 'select_provider_tts'">
-                <ProviderSelector v-model="createSelectorModel(itemKey).value" :provider-type="'text_to_speech'" />
-              </div>
-              <div v-else-if="getSpecialName(itemMeta?._special) === 'select_agent_runner_provider'">
-                <ProviderSelector
-                  v-model="createSelectorModel(itemKey).value"
-                  :provider-type="'agent_runner'"
-                  :provider-subtype="getSpecialSubtype(itemMeta?._special)"
-                />
-              </div>
-              <div v-else-if="itemMeta?._special === 'provider_pool'">
-                <ProviderSelector v-model="createSelectorModel(itemKey).value" :provider-type="'chat_completion'"
-                  button-text="选择提供商池..." />
-              </div>
-              <div v-else-if="itemMeta?._special === 'select_persona'">
-                <PersonaSelector v-model="createSelectorModel(itemKey).value" />
-              </div>
-              <div v-else-if="itemMeta?._special === 'persona_pool'">
-                <PersonaSelector v-model="createSelectorModel(itemKey).value" button-text="选择人格池..." />
-              </div>
-              <div v-else-if="itemMeta?._special === 'select_knowledgebase'">
-                <KnowledgeBaseSelector v-model="createSelectorModel(itemKey).value" />
-              </div>
-              <div v-else-if="itemMeta?._special === 'select_plugin_set'">
-                <PluginSetSelector v-model="createSelectorModel(itemKey).value" />
-              </div>
-              <div v-else-if="itemMeta?._special === 't2i_template'">
-                <T2ITemplateEditor />
-              </div>
+              <TemplateListEditor
+                v-if="itemMeta?.type === 'template_list'"
+                v-model="createSelectorModel(itemKey).value"
+                :templates="itemMeta?.templates || {}"
+                class="config-field"
+              />
+              <ConfigItemRenderer
+                v-else
+                v-model="createSelectorModel(itemKey).value"
+                :item-meta="itemMeta"
+                :show-fullscreen-btn="!!itemMeta?.editor_mode"
+                @open-fullscreen="openEditorDialog(itemKey, iterable, itemMeta?.editor_theme, itemMeta?.editor_language)"
+              />
             </v-col>
           </v-row>
 

dashboard/src/components/shared/BackupDialog.vue

@@ -0,0 +1,995 @@
+<template>
+    <v-dialog v-model="isOpen" persistent max-width="700" scrollable>
+        <v-card>
+            <v-card-title class="d-flex align-center">
+                <v-icon class="mr-2">mdi-backup-restore</v-icon>
+                {{ t('features.settings.backup.dialog.title') }}
+            </v-card-title>
+
+            <v-card-text class="pa-6">
+                <!-- 选项卡 -->
+                <v-tabs v-model="activeTab" color="primary" class="mb-4">
+                    <v-tab value="export">
+                        <v-icon class="mr-2">mdi-export</v-icon>
+                        {{ t('features.settings.backup.tabs.export') }}
+                    </v-tab>
+                    <v-tab value="import">
+                        <v-icon class="mr-2">mdi-import</v-icon>
+                        {{ t('features.settings.backup.tabs.import') }}
+                    </v-tab>
+                    <v-tab value="list">
+                        <v-icon class="mr-2">mdi-format-list-bulleted</v-icon>
+                        {{ t('features.settings.backup.tabs.list') }}
+                    </v-tab>
+                </v-tabs>
+
+                <v-window v-model="activeTab">
+                    <!-- 导出标签页 -->
+                    <v-window-item value="export">
+                        <div v-if="exportStatus === 'idle'" class="text-center py-8">
+                            <v-icon size="64" color="primary" class="mb-4">mdi-cloud-upload</v-icon>
+                            <h3 class="mb-4">{{ t('features.settings.backup.export.title') }}</h3>
+                            <p class="mb-4 text-grey">{{ t('features.settings.backup.export.description') }}</p>
+                            <v-alert type="info" variant="tonal" class="mb-4 text-left">
+                                <template v-slot:prepend>
+                                    <v-icon>mdi-information</v-icon>
+                                </template>
+                                {{ t('features.settings.backup.export.includes') }}
+                            </v-alert>
+                            <v-btn color="primary" size="large" @click="startExport" :loading="exportStatus === 'processing'">
+                                <v-icon class="mr-2">mdi-export</v-icon>
+                                {{ t('features.settings.backup.export.button') }}
+                            </v-btn>
+                        </div>
+
+                        <div v-else-if="exportStatus === 'processing'" class="text-center py-8">
+                            <v-progress-circular indeterminate color="primary" size="64" class="mb-4"></v-progress-circular>
+                            <h3 class="mb-4">{{ t('features.settings.backup.export.processing') }}</h3>
+                            <p class="text-grey">{{ exportProgress.message || t('features.settings.backup.export.wait') }}</p>
+                            <v-progress-linear :model-value="exportProgress.current" :max="exportProgress.total" class="mt-4" color="primary"></v-progress-linear>
+                        </div>
+
+                        <div v-else-if="exportStatus === 'completed'" class="text-center py-8">
+                            <v-icon size="64" color="success" class="mb-4">mdi-check-circle</v-icon>
+                            <h3 class="mb-4">{{ t('features.settings.backup.export.completed') }}</h3>
+                            <p class="mb-4">{{ exportResult?.filename }}</p>
+                            <v-btn color="primary" @click="downloadBackup(exportResult?.filename)" class="mr-2">
+                                <v-icon class="mr-2">mdi-download</v-icon>
+                                {{ t('features.settings.backup.export.download') }}
+                            </v-btn>
+                            <v-btn color="grey" variant="text" @click="resetExport">
+                                {{ t('features.settings.backup.export.another') }}
+                            </v-btn>
+                        </div>
+
+                        <div v-else-if="exportStatus === 'failed'" class="text-center py-8">
+                            <v-icon size="64" color="error" class="mb-4">mdi-alert-circle</v-icon>
+                            <h3 class="mb-4">{{ t('features.settings.backup.export.failed') }}</h3>
+                            <v-alert type="error" variant="tonal" class="mb-4">
+                                {{ exportError }}
+                            </v-alert>
+                            <v-btn color="primary" @click="resetExport">
+                                {{ t('features.settings.backup.export.retry') }}
+                            </v-btn>
+                        </div>
+                    </v-window-item>
+
+                    <!-- 导入标签页 -->
+                    <v-window-item value="import">
+                        <!-- 步骤1: 选择文件 -->
+                        <div v-if="importStatus === 'idle'" class="py-4">
+                            <v-alert type="warning" variant="tonal" class="mb-4">
+                                <template v-slot:prepend>
+                                    <v-icon>mdi-alert</v-icon>
+                                </template>
+                                {{ t('features.settings.backup.import.warning') }}
+                            </v-alert>
+
+                            <v-file-input
+                                v-model="importFile"
+                                :label="t('features.settings.backup.import.selectFile')"
+                                accept=".zip"
+                                prepend-icon="mdi-file-upload"
+                                show-size
+                                class="mb-4"
+                            ></v-file-input>
+
+                            <div class="d-flex justify-center">
+                                <v-btn
+                                    color="primary"
+                                    size="large"
+                                    @click="uploadAndCheck"
+                                    :disabled="!importFile"
+                                    :loading="importStatus === 'uploading'"
+                                >
+                                    <v-icon class="mr-2">mdi-upload</v-icon>
+                                    {{ t('features.settings.backup.import.uploadAndCheck') }}
+                                </v-btn>
+                            </div>
+                        </div>
+
+                        <!-- 步骤1.5: 上传中 -->
+                        <div v-else-if="importStatus === 'uploading'" class="text-center py-8">
+                            <v-icon size="64" color="primary" class="mb-4">mdi-cloud-upload</v-icon>
+                            <h3 class="mb-4">{{ t('features.settings.backup.import.uploading') }}</h3>
+                            <p class="text-grey mb-2">
+                                {{ uploadProgress.message || t('features.settings.backup.import.uploadWait') }}
+                            </p>
+                            <p class="text-grey-darken-1 mb-4">
+                                {{ formatFileSize(uploadProgress.uploaded) }} / {{ formatFileSize(uploadProgress.total) }}
+                                ({{ uploadProgress.percent }}%)
+                            </p>
+                            <v-progress-linear
+                                :model-value="uploadProgress.percent"
+                                :max="100"
+                                class="mt-2"
+                                color="primary"
+                                height="8"
+                                rounded
+                            ></v-progress-linear>
+                        </div>
+
+                        <!-- 步骤2: 确认导入 -->
+                        <div v-else-if="importStatus === 'confirm'" class="py-4">
+                            <v-alert
+                                :type="versionAlertType"
+                                variant="tonal"
+                                class="mb-4"
+                            >
+                                <template v-slot:prepend>
+                                    <v-icon>{{ versionAlertIcon }}</v-icon>
+                                </template>
+                                <div class="confirm-message">
+                                    <div class="text-h6 mb-2">{{ versionAlertTitle }}</div>
+                                    <div class="mb-2">
+                                        <strong>{{ t('features.settings.backup.import.version.backupVersion') }}:</strong> {{ checkResult?.backup_version }}<br>
+                                        <strong>{{ t('features.settings.backup.import.version.currentVersion') }}:</strong> {{ checkResult?.current_version }}
+                                    </div>
+                                    <div v-if="checkResult?.backup_time && checkResult?.backup_time !== '未知'" class="mb-2">
+                                        <strong>{{ t('features.settings.backup.import.version.backupTime') }}:</strong> {{ formatISODate(checkResult?.backup_time) }}
+                                    </div>
+                                    <div class="mt-3" style="white-space: pre-line;">{{ versionAlertMessage }}</div>
+                                </div>
+                            </v-alert>
+
+                            <!-- 备份摘要 -->
+                            <v-card variant="outlined" class="mb-4" v-if="checkResult?.backup_summary">
+                                <v-card-title class="text-subtitle-1">
+                                    <v-icon class="mr-2">mdi-package-variant</v-icon>
+                                    {{ t('features.settings.backup.import.backupContents') }}
+                                </v-card-title>
+                                <v-card-text>
+                                    <div class="d-flex flex-wrap ga-2">
+                                        <v-chip v-if="checkResult.backup_summary.tables?.length" size="small" color="primary" variant="tonal" :ripple="false" class="non-interactive-chip">
+                                            {{ checkResult.backup_summary.tables.length }} {{ t('features.settings.backup.import.tables') }}
+                                        </v-chip>
+                                        <v-chip v-if="checkResult.backup_summary.has_knowledge_bases" size="small" color="success" variant="tonal" :ripple="false" class="non-interactive-chip">
+                                            {{ t('features.settings.backup.import.knowledgeBases') }}
+                                        </v-chip>
+                                        <v-chip v-if="checkResult.backup_summary.has_config" size="small" color="info" variant="tonal" :ripple="false" class="non-interactive-chip">
+                                            {{ t('features.settings.backup.import.configFiles') }}
+                                        </v-chip>
+                                        <v-chip v-for="dir in (checkResult.backup_summary.directories || [])" :key="dir" size="small" color="warning" variant="tonal" :ripple="false" class="non-interactive-chip">
+                                            {{ dir }}
+                                        </v-chip>
+                                    </div>
+                                </v-card-text>
+                            </v-card>
+
+                            <!-- 警告信息 -->
+                            <v-alert v-if="checkResult?.warnings?.length" type="warning" variant="tonal" class="mb-4">
+                                <div v-for="(warning, idx) in checkResult.warnings" :key="idx">{{ warning }}</div>
+                            </v-alert>
+
+                            <div class="d-flex justify-center align-center mt-4" style="gap: 16px;">
+                                <v-btn
+                                    color="grey-darken-1"
+                                    variant="outlined"
+                                    size="large"
+                                    @click="resetImport"
+                                >
+                                    <v-icon class="mr-2">mdi-close</v-icon>
+                                    {{ t('core.common.cancel') }}
+                                </v-btn>
+                                <v-btn
+                                    v-if="checkResult?.can_import"
+                                    color="error"
+                                    size="large"
+                                    variant="flat"
+                                    @click="confirmImport"
+                                >
+                                    <v-icon class="mr-2">mdi-alert</v-icon>
+                                    {{ t('features.settings.backup.import.confirmImport') }}
+                                </v-btn>
+                            </div>
+                        </div>
+
+                        <!-- 步骤3: 导入进行中 -->
+                        <div v-else-if="importStatus === 'processing'" class="text-center py-8">
+                            <v-progress-circular indeterminate color="primary" size="64" class="mb-4"></v-progress-circular>
+                            <h3 class="mb-4">{{ t('features.settings.backup.import.processing') }}</h3>
+                            <p class="text-grey">{{ importProgress.message || t('features.settings.backup.import.wait') }}</p>
+                            <v-progress-linear :model-value="importProgress.current" :max="importProgress.total" class="mt-4" color="primary"></v-progress-linear>
+                        </div>
+
+                        <div v-else-if="importStatus === 'completed'" class="text-center py-8">
+                            <v-icon size="64" color="success" class="mb-4">mdi-check-circle</v-icon>
+                            <h3 class="mb-4">{{ t('features.settings.backup.import.completed') }}</h3>
+                            <v-alert type="info" variant="tonal" class="mb-4">
+                                {{ t('features.settings.backup.import.restartRequired') }}
+                            </v-alert>
+                            <v-btn color="primary" @click="restartAstrBot" class="mr-2">
+                                <v-icon class="mr-2">mdi-restart</v-icon>
+                                {{ t('features.settings.backup.import.restartNow') }}
+                            </v-btn>
+                            <v-btn color="grey" variant="text" @click="resetImport">
+                                {{ t('core.common.close') }}
+                            </v-btn>
+                        </div>
+
+                        <div v-else-if="importStatus === 'failed'" class="text-center py-8">
+                            <v-icon size="64" color="error" class="mb-4">mdi-alert-circle</v-icon>
+                            <h3 class="mb-4">{{ t('features.settings.backup.import.failed') }}</h3>
+                            <v-alert type="error" variant="tonal" class="mb-4">
+                                {{ importError }}
+                            </v-alert>
+                            <v-btn color="primary" @click="resetImport">
+                                {{ t('features.settings.backup.import.retry') }}
+                            </v-btn>
+                        </div>
+                    </v-window-item>
+
+                    <!-- 备份列表标签页 -->
+                    <v-window-item value="list">
+                        <div v-if="loadingList" class="text-center py-8">
+                            <v-progress-circular indeterminate color="primary"></v-progress-circular>
+                        </div>
+
+                        <div v-else-if="backupList.length === 0" class="text-center py-8">
+                            <v-icon size="64" color="grey" class="mb-4">mdi-folder-open-outline</v-icon>
+                            <p class="text-grey">{{ t('features.settings.backup.list.empty') }}</p>
+                        </div>
+
+                        <v-list v-else lines="two">
+                            <v-list-item
+                                v-for="backup in backupList"
+                                :key="backup.filename"
+                            >
+                                <template v-slot:prepend>
+                                    <v-icon :color="backup.type === 'uploaded' ? 'orange' : 'primary'">
+                                        {{ backup.type === 'uploaded' ? 'mdi-upload' : 'mdi-zip-box' }}
+                                    </v-icon>
+                                </template>
+
+                                <v-list-item-title>{{ backup.filename }}</v-list-item-title>
+                                <v-list-item-subtitle>
+                                    {{ formatFileSize(backup.size) }} · {{ formatDate(backup.created_at) }}
+                                    <v-chip size="x-small" color="primary" variant="tonal" class="ml-2">
+                                        v{{ backup.astrbot_version }}
+                                    </v-chip>
+                                    <v-chip v-if="backup.type === 'uploaded'" size="x-small" color="orange" variant="tonal" class="ml-1">
+                                        {{ t('features.settings.backup.list.uploaded') }}
+                                    </v-chip>
+                                </v-list-item-subtitle>
+
+                                <template v-slot:append>
+                                    <v-btn
+                                        icon="mdi-restore"
+                                        variant="text"
+                                        size="small"
+                                        color="success"
+                                        :title="t('features.settings.backup.list.restore')"
+                                        @click="restoreFromList(backup.filename)"
+                                    ></v-btn>
+                                    <v-btn
+                                        icon="mdi-pencil"
+                                        variant="text"
+                                        size="small"
+                                        :title="t('features.settings.backup.list.rename')"
+                                        @click="openRenameDialog(backup.filename)"
+                                    ></v-btn>
+                                    <v-btn icon="mdi-download" variant="text" size="small" @click="downloadBackup(backup.filename)"></v-btn>
+                                    <v-btn icon="mdi-delete" variant="text" size="small" color="error" @click="deleteBackup(backup.filename)"></v-btn>
+                                </template>
+                            </v-list-item>
+                        </v-list>
+
+                        <div class="d-flex justify-center mt-4">
+                            <v-btn color="primary" variant="text" @click="loadBackupList">
+                                <v-icon class="mr-2">mdi-refresh</v-icon>
+                                {{ t('features.settings.backup.list.refresh') }}
+                            </v-btn>
+                        </div>
+
+                        <!-- 提示信息 -->
+                        <p class="text-caption text-grey text-center mt-4">
+                            <v-icon size="small" class="mr-1">mdi-information-outline</v-icon>
+                            {{ t('features.settings.backup.list.ftpHint') }}
+                        </p>
+                    </v-window-item>
+                </v-window>
+            </v-card-text>
+
+            <v-card-actions class="px-6 py-4">
+                <v-spacer></v-spacer>
+                <v-btn color="grey" variant="text" @click="handleClose" :disabled="isProcessing">
+                    {{ t('core.common.close') }}
+                </v-btn>
+            </v-card-actions>
+        </v-card>
+    </v-dialog>
+
+    <!-- 重命名对话框 -->
+    <v-dialog v-model="renameDialogOpen" max-width="450" persistent>
+        <v-card>
+            <v-card-title>
+                <v-icon class="mr-2">mdi-pencil</v-icon>
+                {{ t('features.settings.backup.list.renameTitle') }}
+            </v-card-title>
+            <v-card-text>
+                <v-text-field
+                    v-model="renameNewName"
+                    :label="t('features.settings.backup.list.newName')"
+                    :rules="[renameValidationRule]"
+                    :error-messages="renameError"
+                    variant="outlined"
+                    density="comfortable"
+                    autofocus
+                    @keyup.enter="confirmRename"
+                >
+                    <template v-slot:append-inner>
+                        <span class="text-grey">.zip</span>
+                    </template>
+                </v-text-field>
+                <p class="text-caption text-grey mt-1">
+                    {{ t('features.settings.backup.list.renameHint') }}
+                </p>
+            </v-card-text>
+            <v-card-actions>
+                <v-spacer></v-spacer>
+                <v-btn color="grey" variant="text" @click="closeRenameDialog">
+                    {{ t('core.common.cancel') }}
+                </v-btn>
+                <v-btn
+                    color="primary"
+                    variant="flat"
+                    @click="confirmRename"
+                    :loading="renameLoading"
+                    :disabled="!renameNewName || !!renameError"
+                >
+                    {{ t('core.common.confirm') }}
+                </v-btn>
+            </v-card-actions>
+        </v-card>
+    </v-dialog>
+
+    <WaitingForRestart ref="wfr"></WaitingForRestart>
+</template>
+
+<script setup>
+import { ref, computed, watch } from 'vue'
+import axios from 'axios'
+import { useI18n } from '@/i18n/composables'
+import WaitingForRestart from './WaitingForRestart.vue'
+
+const { t } = useI18n()
+
+const isOpen = ref(false)
+const activeTab = ref('export')
+const wfr = ref(null)
+
+// 导出状态
+const exportStatus = ref('idle') // idle, processing, completed, failed
+const exportTaskId = ref(null)
+const exportProgress = ref({ current: 0, total: 100, message: '' })
+const exportResult = ref(null)
+const exportError = ref('')
+
+// 导入状态
+const importStatus = ref('idle') // idle, uploading, confirm, processing, completed, failed
+const importFile = ref(null)
+const importTaskId = ref(null)
+const importProgress = ref({ current: 0, total: 100, message: '' })
+const importError = ref('')
+const uploadedFilename = ref('')  // 已上传的文件名
+const checkResult = ref(null)     // 预检查结果
+
+// 分片上传状态
+const CONCURRENT_UPLOADS = 5     // 并发上传数
+const uploadId = ref('')
+const chunkSize = ref(0)         // 分片大小（从后端获取）
+const uploadProgress = ref({
+    uploaded: 0,
+    total: 0,
+    percent: 0,
+    message: ''
+})
+
+// 备份列表
+const loadingList = ref(false)
+const backupList = ref([])
+
+// 重命名对话框状态
+const renameDialogOpen = ref(false)
+const renameOldFilename = ref('')
+const renameNewName = ref('')
+const renameLoading = ref(false)
+const renameError = ref('')
+
+// 计算属性
+const isProcessing = computed(() => {
+    return exportStatus.value === 'processing' ||
+           importStatus.value === 'processing' ||
+           importStatus.value === 'uploading'
+})
+
+// 版本检查相关的计算属性
+const versionAlertType = computed(() => {
+    const status = checkResult.value?.version_status
+    if (status === 'major_diff') return 'error'
+    if (status === 'minor_diff') return 'warning'
+    return 'info'
+})
+
+const versionAlertIcon = computed(() => {
+    const status = checkResult.value?.version_status
+    if (status === 'major_diff') return 'mdi-close-circle'
+    if (status === 'minor_diff') return 'mdi-alert'
+    return 'mdi-check-circle'
+})
+
+const versionAlertTitle = computed(() => {
+    const status = checkResult.value?.version_status
+    if (status === 'major_diff') return t('features.settings.backup.import.version.majorDiffTitle')
+    if (status === 'minor_diff') return t('features.settings.backup.import.version.minorDiffTitle')
+    return t('features.settings.backup.import.version.matchTitle')
+})
+
+const versionAlertMessage = computed(() => {
+    const status = checkResult.value?.version_status
+    if (status === 'major_diff') return t('features.settings.backup.import.version.majorDiffMessage')
+    if (status === 'minor_diff') return t('features.settings.backup.import.version.minorDiffMessage')
+    return t('features.settings.backup.import.version.matchMessage')
+})
+
+// 监听对话框打开
+watch(isOpen, (newVal) => {
+    if (newVal) {
+        loadBackupList()
+    } else {
+        resetAll()
+    }
+})
+
+// 监听标签页切换
+watch(activeTab, (newVal) => {
+    if (newVal === 'list') {
+        loadBackupList()
+    }
+})
+
+// 加载备份列表
+const loadBackupList = async () => {
+    loadingList.value = true
+    try {
+        const response = await axios.get('/api/backup/list')
+        if (response.data.status === 'ok') {
+            backupList.value = response.data.data.items || []
+        }
+    } catch (error) {
+        console.error('Failed to load backup list:', error)
+    } finally {
+        loadingList.value = false
+    }
+}
+
+// 开始导出
+const startExport = async () => {
+    exportStatus.value = 'processing'
+    exportProgress.value = { current: 0, total: 100, message: '' }
+
+    try {
+        const response = await axios.post('/api/backup/export')
+        if (response.data.status === 'ok') {
+            exportTaskId.value = response.data.data.task_id
+            pollExportProgress()
+        } else {
+            throw new Error(response.data.message)
+        }
+    } catch (error) {
+        exportStatus.value = 'failed'
+        exportError.value = error.message || 'Export failed'
+    }
+}
+
+// 轮询导出进度
+const pollExportProgress = async () => {
+    if (!exportTaskId.value) return
+
+    try {
+        const response = await axios.get('/api/backup/progress', {
+            params: { task_id: exportTaskId.value }
+        })
+
+        if (response.data.status === 'ok') {
+            const data = response.data.data
+            
+            if (data.status === 'processing' && data.progress) {
+                exportProgress.value = {
+                    current: data.progress.current || 0,
+                    total: data.progress.total || 100,
+                    message: data.progress.message || ''
+                }
+                setTimeout(pollExportProgress, 1000)
+            } else if (data.status === 'completed') {
+                exportStatus.value = 'completed'
+                exportResult.value = data.result
+                loadBackupList()
+            } else if (data.status === 'failed') {
+                exportStatus.value = 'failed'
+                exportError.value = data.error || 'Export failed'
+            } else {
+                setTimeout(pollExportProgress, 1000)
+            }
+        }
+    } catch (error) {
+        exportStatus.value = 'failed'
+        exportError.value = error.message || 'Failed to get export progress'
+    }
+}
+
+// 重置导出状态
+const resetExport = () => {
+    exportStatus.value = 'idle'
+    exportTaskId.value = null
+    exportProgress.value = { current: 0, total: 100, message: '' }
+    exportResult.value = null
+    exportError.value = ''
+}
+
+/**
+ * 并发上传分片
+ *
+ * 使用并发控制同时上传多个分片，提升上传速度。
+ * 后端按分片索引命名文件（如 0.part, 1.part），合并时按顺序读取，
+ * 因此分片到达顺序不影响最终结果。
+ */
+const uploadChunksInParallel = async (file, totalChunks, currentUploadId, currentChunkSize) => {
+    // 跟踪已完成的字节数（使用原子操作避免并发问题）
+    let completedBytes = 0
+    const chunkSizes = []
+    
+    // 预计算每个分片的大小（使用后端返回的 chunk_size）
+    for (let i = 0; i < totalChunks; i++) {
+        const start = i * currentChunkSize
+        const end = Math.min(start + currentChunkSize, file.size)
+        chunkSizes[i] = end - start
+    }
+
+    // 上传单个分片的函数
+    const uploadSingleChunk = async (chunkIndex) => {
+        const start = chunkIndex * currentChunkSize
+        const end = Math.min(start + currentChunkSize, file.size)
+        const chunk = file.slice(start, end)
+
+        const formData = new FormData()
+        formData.append('upload_id', currentUploadId)
+        formData.append('chunk_index', chunkIndex.toString())
+        formData.append('chunk', chunk)
+
+        const response = await axios.post('/api/backup/upload/chunk', formData, {
+            headers: { 'Content-Type': 'multipart/form-data' }
+        })
+
+        if (response.data.status !== 'ok') {
+            throw new Error(response.data.message)
+        }
+
+        // 更新进度（累加已完成字节）
+        completedBytes += chunkSizes[chunkIndex]
+        uploadProgress.value.uploaded = completedBytes
+        uploadProgress.value.percent = Math.round((completedBytes / file.size) * 100)
+
+        return response
+    }
+
+    // 创建分片索引队列
+    const pendingChunks = Array.from({ length: totalChunks }, (_, i) => i)
+    const activePromises = []
+
+    // 处理队列中的分片
+    while (pendingChunks.length > 0 || activePromises.length > 0) {
+        // 填充并发槽位
+        while (pendingChunks.length > 0 && activePromises.length < CONCURRENT_UPLOADS) {
+            const chunkIndex = pendingChunks.shift()
+            const promise = uploadSingleChunk(chunkIndex).then(() => {
+                // 完成后从活动列表移除
+                const idx = activePromises.indexOf(promise)
+                if (idx > -1) activePromises.splice(idx, 1)
+            })
+            activePromises.push(promise)
+        }
+
+        // 等待至少一个完成
+        if (activePromises.length > 0) {
+            await Promise.race(activePromises)
+        }
+    }
+}
+
+// 上传并检查
+const uploadAndCheck = async () => {
+    if (!importFile.value) return
+
+    importStatus.value = 'uploading'
+    const file = importFile.value
+
+    try {
+        // 初始化上传进度
+        uploadProgress.value = {
+            uploaded: 0,
+            total: file.size,
+            percent: 0,
+            message: t('features.settings.backup.import.uploadInit')
+        }
+
+        // 步骤1: 初始化分片上传（后端计算并返回 chunk_size 和 total_chunks）
+        const initResponse = await axios.post('/api/backup/upload/init', {
+            filename: file.name,
+            total_size: file.size
+        })
+
+        if (initResponse.data.status !== 'ok') {
+            throw new Error(initResponse.data.message)
+        }
+
+        uploadId.value = initResponse.data.data.upload_id
+        chunkSize.value = initResponse.data.data.chunk_size
+        const totalChunks = initResponse.data.data.total_chunks
+
+        // 步骤2: 并行分片上传（5个并发连接）
+        uploadProgress.value.message = t('features.settings.backup.import.uploadingChunks')
+        
+        await uploadChunksInParallel(file, totalChunks, uploadId.value, chunkSize.value)
+
+        // 步骤3: 完成上传
+        uploadProgress.value.message = t('features.settings.backup.import.uploadComplete')
+
+        const completeResponse = await axios.post('/api/backup/upload/complete', {
+            upload_id: uploadId.value
+        })
+
+        if (completeResponse.data.status !== 'ok') {
+            throw new Error(completeResponse.data.message)
+        }
+
+        uploadedFilename.value = completeResponse.data.data.filename
+
+        // 步骤4: 预检查
+        uploadProgress.value.message = t('features.settings.backup.import.checking')
+
+        const checkResponse = await axios.post('/api/backup/check', {
+            filename: uploadedFilename.value
+        })
+
+        if (checkResponse.data.status !== 'ok') {
+            throw new Error(checkResponse.data.message)
+        }
+
+        checkResult.value = checkResponse.data.data
+        
+        // 检查是否有效
+        if (!checkResult.value.valid) {
+            importStatus.value = 'failed'
+            importError.value = checkResult.value.error || t('features.settings.backup.import.invalidBackup')
+            return
+        }
+
+        // 显示确认对话框
+        importStatus.value = 'confirm'
+
+    } catch (error) {
+        // 上传失败时尝试清理已上传的分片
+        if (uploadId.value) {
+            try {
+                await axios.post('/api/backup/upload/abort', {
+                    upload_id: uploadId.value
+                })
+            } catch (abortError) {
+                console.error('Failed to abort upload:', abortError)
+            }
+        }
+        
+        importStatus.value = 'failed'
+        importError.value = error.response?.data?.message || error.message || 'Upload failed'
+    }
+}
+
+// 确认导入
+const confirmImport = async () => {
+    if (!uploadedFilename.value) return
+
+    importStatus.value = 'processing'
+    importProgress.value = { current: 0, total: 100, message: '' }
+
+    try {
+        const response = await axios.post('/api/backup/import', {
+            filename: uploadedFilename.value,
+            confirmed: true
+        })
+
+        if (response.data.status === 'ok') {
+            importTaskId.value = response.data.data.task_id
+            pollImportProgress()
+        } else {
+            throw new Error(response.data.message)
+        }
+    } catch (error) {
+        importStatus.value = 'failed'
+        importError.value = error.response?.data?.message || error.message || 'Import failed'
+    }
+}
+
+// 轮询导入进度
+const pollImportProgress = async () => {
+    if (!importTaskId.value) return
+
+    try {
+        const response = await axios.get('/api/backup/progress', {
+            params: { task_id: importTaskId.value }
+        })
+
+        if (response.data.status === 'ok') {
+            const data = response.data.data
+            
+            if (data.status === 'processing' && data.progress) {
+                importProgress.value = {
+                    current: data.progress.current || 0,
+                    total: data.progress.total || 100,
+                    message: data.progress.message || ''
+                }
+                setTimeout(pollImportProgress, 1000)
+            } else if (data.status === 'completed') {
+                importStatus.value = 'completed'
+            } else if (data.status === 'failed') {
+                importStatus.value = 'failed'
+                importError.value = data.error || 'Import failed'
+            } else {
+                setTimeout(pollImportProgress, 1000)
+            }
+        }
+    } catch (error) {
+        importStatus.value = 'failed'
+        importError.value = error.message || 'Failed to get import progress'
+    }
+}
+
+// 重置导入状态
+const resetImport = async () => {
+    // 如果有进行中的上传，先取消
+    if (uploadId.value && importStatus.value === 'uploading') {
+        try {
+            await axios.post('/api/backup/upload/abort', {
+                upload_id: uploadId.value
+            })
+        } catch (error) {
+            console.error('Failed to abort upload:', error)
+        }
+    }
+    
+    importStatus.value = 'idle'
+    importFile.value = null
+    importTaskId.value = null
+    importProgress.value = { current: 0, total: 100, message: '' }
+    importError.value = ''
+    uploadedFilename.value = ''
+    checkResult.value = null
+    uploadId.value = ''
+    chunkSize.value = 0
+    uploadProgress.value = { uploaded: 0, total: 0, percent: 0, message: '' }
+}
+
+// 下载备份（使用浏览器原生下载，可显示下载进度）
+const downloadBackup = (filename) => {
+    // 获取 token 用于鉴权（因为浏览器原生下载无法携带 Authorization header）
+    const token = localStorage.getItem('token')
+    if (!token) {
+        alert(t('core.common.unauthorized'))
+        return
+    }
+    
+    // 直接使用浏览器下载，这样可以看到原生下载进度条
+    const downloadUrl = `/api/backup/download?filename=${encodeURIComponent(filename)}&token=${encodeURIComponent(token)}`
+    
+    // 创建隐藏的 a 标签触发下载
+    const link = document.createElement('a')
+    link.href = downloadUrl
+    link.download = filename
+    link.style.display = 'none'
+    document.body.appendChild(link)
+    link.click()
+    document.body.removeChild(link)
+}
+
+// 从列表中恢复备份
+const restoreFromList = async (filename) => {
+    // 切换到导入标签页并设置文件名
+    uploadedFilename.value = filename
+    
+    // 预检查
+    try {
+        const checkResponse = await axios.post('/api/backup/check', {
+            filename: filename
+        })
+
+        if (checkResponse.data.status !== 'ok') {
+            throw new Error(checkResponse.data.message)
+        }
+
+        checkResult.value = checkResponse.data.data
+        
+        if (!checkResult.value.valid) {
+            alert(checkResult.value.error || t('features.settings.backup.import.invalidBackup'))
+            return
+        }
+
+        // 切换到导入标签页并显示确认
+        activeTab.value = 'import'
+        importStatus.value = 'confirm'
+
+    } catch (error) {
+        alert(error.response?.data?.message || error.message || 'Check failed')
+    }
+}
+
+// 删除备份
+const deleteBackup = async (filename) => {
+    if (!confirm(t('features.settings.backup.list.confirmDelete'))) return
+
+    try {
+        const response = await axios.post('/api/backup/delete', { filename })
+        if (response.data.status === 'ok') {
+            loadBackupList()
+        } else {
+            alert(response.data.message || 'Delete failed')
+        }
+    } catch (error) {
+        alert(error.message || 'Delete failed')
+    }
+}
+
+// 重命名相关函数
+const openRenameDialog = (filename) => {
+    renameOldFilename.value = filename
+    // 移除 .zip 后缀，只显示文件名部分
+    renameNewName.value = filename.replace(/\.zip$/i, '')
+    renameError.value = ''
+    renameDialogOpen.value = true
+}
+
+const closeRenameDialog = () => {
+    renameDialogOpen.value = false
+    renameOldFilename.value = ''
+    renameNewName.value = ''
+    renameError.value = ''
+}
+
+// 文件名验证规则
+const renameValidationRule = (value) => {
+    if (!value) return t('features.settings.backup.list.renameRequired')
+    // 检查是否包含非法字符
+    if (/[\\/:*?"<>|]/.test(value)) {
+        return t('features.settings.backup.list.renameInvalidChars')
+    }
+    // 检查是否包含路径遍历字符
+    if (value.includes('..')) {
+        return t('features.settings.backup.list.renameInvalidChars')
+    }
+    return true
+}
+
+const confirmRename = async () => {
+    if (!renameNewName.value || renameError.value) return
+    
+    // 前端验证
+    const validationResult = renameValidationRule(renameNewName.value)
+    if (validationResult !== true) {
+        renameError.value = validationResult
+        return
+    }
+
+    renameLoading.value = true
+    renameError.value = ''
+
+    try {
+        const response = await axios.post('/api/backup/rename', {
+            filename: renameOldFilename.value,
+            new_name: renameNewName.value
+        })
+
+        if (response.data.status === 'ok') {
+            closeRenameDialog()
+            loadBackupList()
+        } else {
+            renameError.value = response.data.message || t('features.settings.backup.list.renameFailed')
+        }
+    } catch (error) {
+        renameError.value = error.response?.data?.message || error.message || t('features.settings.backup.list.renameFailed')
+    } finally {
+        renameLoading.value = false
+    }
+}
+
+// 格式化文件大小
+const formatFileSize = (bytes) => {
+    if (bytes === 0) return '0 B'
+    const k = 1024
+    const sizes = ['B', 'KB', 'MB', 'GB']
+    const i = Math.floor(Math.log(bytes) / Math.log(k))
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
+}
+
+// 格式化日期（从时间戳）
+const formatDate = (timestamp) => {
+    return new Date(timestamp * 1000).toLocaleString()
+}
+
+// 格式化 ISO 日期字符串
+const formatISODate = (isoString) => {
+    if (!isoString) return ''
+    try {
+        return new Date(isoString).toLocaleString()
+    } catch {
+        return isoString
+    }
+}
+
+// 重启 AstrBot
+const restartAstrBot = () => {
+    axios.post('/api/stat/restart-core').then(() => {
+        if (wfr.value) {
+            wfr.value.check()
+        }
+    })
+}
+
+// 重置所有状态
+const resetAll = async () => {
+    resetExport()
+    await resetImport()
+    activeTab.value = 'export'
+}
+
+// 关闭对话框
+const handleClose = () => {
+    if (isProcessing.value) return
+    isOpen.value = false
+}
+
+// 打开对话框
+const open = () => {
+    isOpen.value = true
+}
+
+defineExpose({ open })
+</script>
+
+<style scoped>
+.v-list-item {
+    border-bottom: 1px solid rgba(0, 0, 0, 0.08);
+}
+
+.v-list-item:last-child {
+    border-bottom: none;
+}
+
+/* 禁用 Chip 的交互效果 */
+.non-interactive-chip {
+    pointer-events: none;
+    cursor: default;
+}
+
+.non-interactive-chip:hover {
+    box-shadow: none !important;
+}
+</style>

dashboard/src/components/shared/ConfigItemRenderer.vue

@@ -0,0 +1,327 @@
+<template>
+  <div class="w-100">
+    <!-- Special handling for specific metadata types -->
+    <template v-if="itemMeta?._special === 'select_provider'">
+      <ProviderSelector :model-value="modelValue" @update:model-value="emitUpdate" :provider-type="'chat_completion'" />
+    </template>
+    <template v-else-if="itemMeta?._special === 'select_provider_stt'">
+      <ProviderSelector :model-value="modelValue" @update:model-value="emitUpdate" :provider-type="'speech_to_text'" />
+    </template>
+    <template v-else-if="itemMeta?._special === 'select_provider_tts'">
+      <ProviderSelector :model-value="modelValue" @update:model-value="emitUpdate" :provider-type="'text_to_speech'" />
+    </template>
+    <template v-else-if="getSpecialName(itemMeta?._special) === 'select_agent_runner_provider'">
+      <ProviderSelector
+        :model-value="modelValue"
+        @update:model-value="emitUpdate"
+        :provider-type="'agent_runner'"
+        :provider-subtype="getSpecialSubtype(itemMeta?._special)"
+      />
+    </template>
+    <template v-else-if="itemMeta?._special === 'provider_pool'">
+      <ProviderSelector :model-value="modelValue" @update:model-value="emitUpdate" :provider-type="'chat_completion'"
+        button-text="选择提供商池..." />
+    </template>
+    <template v-else-if="itemMeta?._special === 'select_persona'">
+      <PersonaSelector :model-value="modelValue" @update:model-value="emitUpdate" />
+    </template>
+    <template v-else-if="itemMeta?._special === 'persona_pool'">
+      <PersonaSelector :model-value="modelValue" @update:model-value="emitUpdate" button-text="选择人格池..." />
+    </template>
+    <template v-else-if="itemMeta?._special === 'select_knowledgebase'">
+      <KnowledgeBaseSelector :model-value="modelValue" @update:model-value="emitUpdate" />
+    </template>
+    <template v-else-if="itemMeta?._special === 'select_plugin_set'">
+      <PluginSetSelector :model-value="modelValue" @update:model-value="emitUpdate" />
+    </template>
+    <template v-else-if="itemMeta?._special === 't2i_template'">
+      <T2ITemplateEditor />
+    </template>
+    <template v-else-if="itemMeta?._special === 'get_embedding_dim'">
+      <div class="d-flex align-center gap-2">
+        <v-text-field
+          :model-value="modelValue"
+          @update:model-value="emitUpdate"
+          density="compact"
+          variant="outlined"
+          class="config-field"
+          type="number"
+          hide-details
+        ></v-text-field>
+        <v-btn
+          color="primary"
+          variant="tonal"
+          size="small"
+          @click="$emit('get-embedding-dim')"
+          :loading="loading"
+          class="ml-2"
+        >
+          自动检测
+        </v-btn>
+      </div>
+    </template>
+
+    <div
+      v-else-if="itemMeta?.type === 'list' && itemMeta?.options && itemMeta?.render_type === 'checkbox'"
+      class="d-flex flex-wrap gap-20"
+    >
+      <v-checkbox
+        v-for="(option, optionIndex) in itemMeta.options"
+        :key="optionIndex"
+        :model-value="modelValue"
+        @update:model-value="emitUpdate"
+        :label="getLabel(itemMeta, optionIndex, option)"
+        :value="option"
+        class="mr-2"
+        color="primary"
+        hide-details
+      ></v-checkbox>
+    </div>
+
+    <v-combobox
+      v-else-if="itemMeta?.type === 'list' && itemMeta?.options"
+      :model-value="modelValue"
+      @update:model-value="emitUpdate"
+      :items="itemMeta.options"
+      :disabled="itemMeta?.readonly"
+      density="compact"
+      variant="outlined"
+      class="config-field"
+      hide-details
+      chips
+      multiple
+    ></v-combobox>
+
+    <v-select
+      v-else-if="itemMeta?.options"
+      :model-value="modelValue"
+      @update:model-value="emitUpdate"
+      :items="getSelectItems(itemMeta)"
+      :disabled="itemMeta?.readonly"
+      density="compact"
+      variant="outlined"
+      class="config-field"
+      hide-details
+    ></v-select>
+
+    <div v-else-if="itemMeta?.editor_mode" class="editor-container">
+      <VueMonacoEditor
+        :theme="itemMeta?.editor_theme || 'vs-light'"
+        :language="itemMeta?.editor_language || 'json'"
+        style="min-height: 100px; flex-grow: 1; border: 1px solid rgba(0, 0, 0, 0.1);"
+        :value="modelValue"
+        @update:value="emitUpdate"
+      >
+      </VueMonacoEditor>
+      <v-btn v-if="showFullscreenBtn" icon size="small" variant="text" color="primary" class="editor-fullscreen-btn"
+        @click="$emit('open-fullscreen')"
+        :title="t('core.common.editor.fullscreen')">
+        <v-icon>mdi-fullscreen</v-icon>
+      </v-btn>
+    </div>
+
+    <v-text-field
+      v-else-if="itemMeta?.type === 'string'"
+      :model-value="modelValue"
+      @update:model-value="emitUpdate"
+      density="compact"
+      variant="outlined"
+      class="config-field"
+      hide-details
+    ></v-text-field>
+
+    <div
+      v-else-if="itemMeta?.type === 'int' || itemMeta?.type === 'float'"
+      class="d-flex align-center gap-3"
+    >
+      <v-slider
+        v-if="itemMeta?.slider"
+        :model-value="toNumber(modelValue)"
+        @update:model-value="val => emitUpdate(toNumber(val))"
+        :min="itemMeta?.slider?.min ?? 0"
+        :max="itemMeta?.slider?.max ?? 100"
+        :step="itemMeta?.slider?.step ?? 1"
+        color="primary"
+        density="compact"
+        hide-details
+        class="flex-grow-1"
+      ></v-slider>
+      <v-text-field
+        :model-value="modelValue"
+        @update:model-value="val => emitUpdate(toNumber(val))"
+        density="compact"
+        variant="outlined"
+        class="config-field"
+        type="number"
+        hide-details
+        style="max-width: 140px;"
+      ></v-text-field>
+    </div>
+
+    <v-textarea
+      v-else-if="itemMeta?.type === 'text'"
+      :model-value="modelValue"
+      @update:model-value="emitUpdate"
+      variant="outlined"
+      rows="3"
+      class="config-field"
+      hide-details
+    ></v-textarea>
+
+    <v-switch
+      v-else-if="itemMeta?.type === 'bool'"
+      :model-value="modelValue"
+      @update:model-value="emitUpdate"
+      color="primary"
+      inset
+      density="compact"
+      hide-details
+    ></v-switch>
+
+    <ListConfigItem
+      v-else-if="itemMeta?.type === 'list'"
+      :model-value="modelValue"
+      @update:model-value="emitUpdate"
+      class="config-field"
+    />
+
+    <ObjectEditor
+      v-else-if="itemMeta?.type === 'dict'"
+      :model-value="modelValue"
+      @update:model-value="emitUpdate"
+      class="config-field"
+    />
+
+    <v-text-field
+      v-else
+      :model-value="modelValue"
+      @update:model-value="emitUpdate"
+      density="compact"
+      variant="outlined"
+      class="config-field"
+      hide-details
+    ></v-text-field>
+  </div>
+</template>
+
+<script setup>
+import { VueMonacoEditor } from '@guolao/vue-monaco-editor'
+import ListConfigItem from './ListConfigItem.vue'
+import ObjectEditor from './ObjectEditor.vue'
+import ProviderSelector from './ProviderSelector.vue'
+import PersonaSelector from './PersonaSelector.vue'
+import KnowledgeBaseSelector from './KnowledgeBaseSelector.vue'
+import PluginSetSelector from './PluginSetSelector.vue'
+import T2ITemplateEditor from './T2ITemplateEditor.vue'
+import { useI18n, useModuleI18n } from '@/i18n/composables'
+
+const props = defineProps({
+  modelValue: {
+    type: [String, Number, Boolean, Array, Object],
+    default: null
+  },
+  itemMeta: {
+    type: Object,
+    required: true
+  },
+  loading: {
+    type: Boolean,
+    default: false
+  },
+  showFullscreenBtn: {
+    type: Boolean,
+    default: false
+  }
+})
+
+const emit = defineEmits(['update:modelValue', 'get-embedding-dim', 'open-fullscreen'])
+const { t } = useI18n()
+const { getRaw } = useModuleI18n('features/config-metadata')
+
+function emitUpdate(val) {
+  emit('update:modelValue', val)
+}
+
+function toNumber(val) {
+  const n = parseFloat(val)
+  return isNaN(n) ? 0 : n
+}
+
+function getLabel(itemMeta, index, option) {
+  const labels = getTranslatedLabels(itemMeta)
+  return labels ? labels[index] : option
+}
+
+function getTranslatedLabels(itemMeta) {
+  if (!itemMeta?.labels) return null
+  if (typeof itemMeta.labels === 'string') {
+    const translatedLabels = getRaw(itemMeta.labels)
+    if (Array.isArray(translatedLabels)) {
+      return translatedLabels
+    }
+  }
+  if (Array.isArray(itemMeta.labels)) {
+    return itemMeta.labels
+  }
+  return null
+}
+
+function getSelectItems(itemMeta) {
+  const labels = getTranslatedLabels(itemMeta)
+  if (labels && itemMeta.options) {
+    return itemMeta.options.map((value, index) => ({
+      title: labels[index] || value,
+      value: value
+    }))
+  }
+  return itemMeta.options || []
+}
+
+function parseSpecialValue(value) {
+  if (!value || typeof value !== 'string') {
+    return { name: '', subtype: '' }
+  }
+  const [name, ...rest] = value.split(':')
+  return {
+    name,
+    subtype: rest.join(':') || ''
+  }
+}
+
+function getSpecialName(value) {
+  return parseSpecialValue(value).name
+}
+
+function getSpecialSubtype(value) {
+  return parseSpecialValue(value).subtype
+}
+</script>
+
+<style scoped>
+.config-field {
+  margin-bottom: 0;
+}
+
+.editor-container {
+  position: relative;
+  display: flex;
+  width: 100%;
+}
+
+.editor-fullscreen-btn {
+  position: absolute;
+  top: 4px;
+  right: 4px;
+  z-index: 10;
+  background-color: rgba(0, 0, 0, 0.3);
+  border-radius: 4px;
+}
+
+.editor-fullscreen-btn:hover {
+  background-color: rgba(0, 0, 0, 0.5);
+}
+
+.gap-20 {
+  gap: 20px;
+}
+</style>

dashboard/src/components/shared/ConsoleDisplayer.vue

@@ -1,12 +1,11 @@
 <script setup>
 import { useCommonStore } from '@/stores/common';
-import { storeToRefs } from 'pinia';
 import axios from 'axios';
+import { EventSourcePolyfill } from 'event-source-polyfill';
 </script>
 
 <template>
   <div>
-    <!-- 添加筛选级别控件 -->
     <div class="filter-controls mb-2" v-if="showLevelBtns">
       <v-chip-group v-model="selectedLevels" column multiple>
         <v-chip v-for="level in logLevels" :key="level" :color="getLevelColor(level)" filter variant="flat" size="small"
@@ -26,20 +25,19 @@ export default {
   name: 'ConsoleDisplayer',
   data() {
     return {
-      autoScroll: true,  // 默认开启自动滚动
+      autoScroll: true,
       logColorAnsiMap: {
-        '\u001b[1;34m': 'color: #0000FF; font-weight: bold;', // bold_blue
-        '\u001b[1;36m': 'color: #00FFFF; font-weight: bold;', // bold_cyan
-        '\u001b[1;33m': 'color: #FFFF00; font-weight: bold;', // bold_yellow
-        '\u001b[31m': 'color: #FF0000;', // red
-        '\u001b[1;31m': 'color: #FF0000; font-weight: bold;', // bold_red
-        '\u001b[0m': 'color: inherit; font-weight: normal;', // reset
-        '\u001b[32m': 'color: #00FF00;',  // green
+        '\u001b[1;34m': 'color: #0000FF; font-weight: bold;',
+        '\u001b[1;36m': 'color: #00FFFF; font-weight: bold;',
+        '\u001b[1;33m': 'color: #FFFF00; font-weight: bold;',
+        '\u001b[31m': 'color: #FF0000;',
+        '\u001b[1;31m': 'color: #FF0000; font-weight: bold;',
+        '\u001b[0m': 'color: inherit; font-weight: normal;',
+        '\u001b[32m': 'color: #00FF00;',
         'default': 'color: #FFFFFF;'
       },
-      historyNum_: -1,
       logLevels: ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
-      selectedLevels: [0, 1, 2, 3, 4], // 默认选中所有级别
+      selectedLevels: [0, 1, 2, 3, 4],
       levelColors: {
         'DEBUG': 'grey',
         'INFO': 'blue-lighten-3',
@@ -47,17 +45,19 @@ export default {
         'ERROR': 'red',
         'CRITICAL': 'purple'
       },
-      lastProcessedTime: 0, // 记录最后处理的日志时间戳
-      localLogCache: [], // 本地日志缓存
+      localLogCache: [],
+      eventSource: null,
+      retryTimer: null,
+      retryAttempts: 0,           
+      maxRetryAttempts: 10,       
+      baseRetryDelay: 1000,       
+      lastEventId: null,          
     }
   },
   computed: {
     commonStore() {
       return useCommonStore();
     },
-    logCache() {
-      return this.commonStore.log_cache;
-    }
   },
   props: {
     historyNum: {
@@ -70,41 +70,6 @@ export default {
     }
   },
   watch: {
-    logCache: {
-      handler(newVal) {
-        // 基于 timestamp 处理新增的日志
-        if (newVal && newVal.length > 0) {
-          // 确保 DOM 已经准备好
-          this.$nextTick(() => {
-            // 合并到本地缓存并按时间排序
-            const newLogs = newVal.filter(log => log.time > this.lastProcessedTime);
-            
-            if (newLogs.length > 0) {
-              this.localLogCache.push(...newLogs);
-              // 按时间戳排序
-              this.localLogCache.sort((a, b) => a.time - b.time);
-              
-              // 只保留最新的 log_cache_max_len 条
-              if (this.localLogCache.length > this.commonStore.log_cache_max_len) {
-                this.localLogCache.splice(0, this.localLogCache.length - this.commonStore.log_cache_max_len);
-              }
-              
-              // 显示新日志
-              newLogs.forEach(logItem => {
-                if (this.isLevelSelected(logItem.level)) {
-                  this.printLog(logItem.data);
-                }
-              });
-              
-              // 更新最后处理时间
-              this.lastProcessedTime = Math.max(...newLogs.map(log => log.time));
-            }
-          });
-        }
-      },
-      deep: true,
-      immediate: false
-    },
     selectedLevels: {
       handler() {
         this.refreshDisplay();
@@ -113,30 +78,142 @@ export default {
     }
   },
   async mounted() {
-    // 请求历史日志
     await this.fetchLogHistory();
-    
-    // 等待 DOM 准备好后，显示历史日志
-    this.$nextTick(() => {
-      if (this.localLogCache.length > 0) {
-        this.localLogCache.forEach(logItem => {
-          if (this.isLevelSelected(logItem.level)) {
-            this.printLog(logItem.data);
-          }
-        });
-        // 更新最后处理时间
-        this.lastProcessedTime = Math.max(...this.localLogCache.map(log => log.time));
-      }
-    });
+    this.connectSSE();
+  },
+  beforeUnmount() {
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+    this.retryAttempts = 0;
   },
   methods: {
+    connectSSE() {
+      if (this.eventSource) {
+        this.eventSource.close();
+        this.eventSource = null;
+      }
+
+      console.log(`正在连接日志流... (尝试次数: ${this.retryAttempts})`);
+      
+      const token = localStorage.getItem('token');
+
+      this.eventSource = new EventSourcePolyfill('/api/live-log', {
+        headers: {
+            'Authorization': token ? `Bearer ${token}` : ''
+        },
+        heartbeatTimeout: 300000, 
+        withCredentials: true 
+      });
+
+      this.eventSource.onopen = () => {
+        console.log('日志流连接成功！');
+        this.retryAttempts = 0;
+
+        if (!this.lastEventId) {
+            this.fetchLogHistory();
+        }
+      };
+
+      this.eventSource.onmessage = (event) => {
+        try {
+          if (event.lastEventId) {
+            this.lastEventId = event.lastEventId;
+          }
+
+          const payload = JSON.parse(event.data);
+          this.processNewLogs([payload]);
+        } catch (e) {
+          console.error('解析日志失败:', e);
+        }
+      };
+
+      this.eventSource.onerror = (err) => {
+
+        if (err.status === 401) {
+            console.error('鉴权失败 (401)，可能是 Token 过期了。');
+
+        } else {
+            console.warn('日志流连接错误:', err);
+        }
+        
+        if (this.eventSource) {
+            this.eventSource.close();
+            this.eventSource = null;
+        }
+
+        if (this.retryAttempts >= this.maxRetryAttempts) {
+            console.error('❌ 已达到最大重试次数，停止重连。请刷新页面重试。');
+            return; 
+        }
+
+        const delay = Math.min(
+            this.baseRetryDelay * Math.pow(2, this.retryAttempts),
+            30000
+        );
+        
+        console.log(`⏳ ${delay}ms 后尝试第 ${this.retryAttempts + 1} 次重连...`);
+
+        if (this.retryTimer) {
+          clearTimeout(this.retryTimer);
+          this.retryTimer = null;
+        }
+
+        this.retryTimer = setTimeout(async () => {
+          this.retryAttempts++;
+          
+          if (!this.lastEventId) {
+             await this.fetchLogHistory();
+          }
+          
+          this.connectSSE();
+        }, delay);
+      };
+    },
+
+    processNewLogs(newLogs) {
+      if (!newLogs || newLogs.length === 0) return;
+
+      let hasUpdate = false;
+
+      newLogs.forEach(log => {
+
+        const exists = this.localLogCache.some(existing => 
+          existing.time === log.time && 
+          existing.data === log.data &&
+          existing.level === log.level
+        );
+        
+        if (!exists) {
+            this.localLogCache.push(log);
+            hasUpdate = true;
+            
+            if (this.isLevelSelected(log.level)) {
+              this.printLog(log.data);
+            }
+        }
+      });
+
+      if (hasUpdate) {
+        this.localLogCache.sort((a, b) => a.time - b.time);
+        
+        const maxSize = this.commonStore.log_cache_max_len || 200;
+        if (this.localLogCache.length > maxSize) {
+           this.localLogCache.splice(0, this.localLogCache.length - maxSize);
+        }
+      }
+    },
+
     async fetchLogHistory() {
       try {
         const res = await axios.get('/api/log-history');
         if (res.data.data.logs && res.data.data.logs.length > 0) {
-          this.localLogCache = [...res.data.data.logs];
-          // 按时间戳排序
-          this.localLogCache.sort((a, b) => a.time - b.time);
+          this.processNewLogs(res.data.data.logs);
         }
       } catch (err) {
         console.error('Failed to fetch log history:', err);
@@ -162,7 +239,6 @@ export default {
       if (termElement) {
         termElement.innerHTML = '';
         
-        // 重新显示所有符合筛选条件的日志
         if (this.localLogCache && this.localLogCache.length > 0) {
           this.localLogCache.forEach(logItem => {
             if (this.isLevelSelected(logItem.level)) {
@@ -173,16 +249,13 @@ export default {
       }
     },
 
-
     toggleAutoScroll() {
       this.autoScroll = !this.autoScroll;
     },
 
     printLog(log) {
-      // append 一个 span 标签到 term，block 的方式
       let ele = document.getElementById('term')
       if (!ele) {
-        console.warn('term element not found, skipping log print');
         return;
       }
       
@@ -196,11 +269,11 @@ export default {
         }
       }
 
-      span.style = style + 'display: block; font-size: 12px; font-family: Consolas, monospace; white-space: pre-wrap;'
+      span.style = style + 'display: block; font-size: 12px; font-family: Consolas, monospace; white-space: pre-wrap; margin-bottom: 2px;'
       span.classList.add('fade-in')
       span.innerText = `${log}`;
       ele.appendChild(span)
-      if (this.autoScroll ) {
+      if (this.autoScroll) {
         ele.scrollTop = ele.scrollHeight
       }
     }
@@ -230,4 +303,4 @@ export default {
     opacity: 1;
   }
 }
-</style>
+</style>

dashboard/src/components/shared/ObjectEditor.vue

@@ -64,6 +64,16 @@
                   hide-details
                   color="primary"
                 ></v-switch>
+                <v-text-field
+                  v-if="pair.type === 'json'"
+                  v-model="pair.value"
+                  density="compact"
+                  variant="outlined"
+                  hide-details="auto"
+                  placeholder="JSON"
+                  @blur="updateJSON(index, pair.value)"
+                  :error-messages="pair.jsonError"
+                ></v-text-field>
               </v-col>
               <v-col cols="1" class="pl-2">
                 <v-btn
@@ -98,7 +108,7 @@
           ></v-text-field>
           <v-select
             v-model="newValueType"
-            :items="['string', 'number', 'boolean']"
+            :items="['string', 'number', 'boolean', 'json']"
             label="值类型"
             density="compact"
             variant="outlined"
@@ -168,10 +178,12 @@ watch(() => props.modelValue, (newValue) => {
 function initializeLocalKeyValuePairs() {
   localKeyValuePairs.value = []
   for (const [key, value] of Object.entries(props.modelValue)) {
+    let _type = (typeof value) === 'object' ? 'json':(typeof value)
+    let _value = _type === 'json'?JSON.stringify(value):value
     localKeyValuePairs.value.push({
       key: key,
-      value: value,
-      type: typeof value // Store the original type
+      value: _value,
+      type: _type
     })
   }
 }
@@ -201,6 +213,9 @@ function addKeyValuePair() {
       case 'boolean':
         defaultValue = false
         break
+      case 'json':
+        defaultValue = "{}"
+        break
       default: // string
         defaultValue = ""
         break
@@ -215,6 +230,15 @@ function addKeyValuePair() {
   }
 }
 
+function updateJSON(index, newValue) {
+  try {
+    JSON.parse(newValue)
+    localKeyValuePairs.value[index].jsonError = ''
+  } catch (e) {
+    localKeyValuePairs.value[index].jsonError = 'JSON 格式错误'
+  }
+}
+
 function removeKeyValuePair(index) {
   localKeyValuePairs.value.splice(index, 1)
 }
@@ -241,6 +265,7 @@ function updateKey(index, newKey) {
 function confirmDialog() {
   const updatedValue = {}
   for (const pair of localKeyValuePairs.value) {
+    if (pair.type === 'json' && pair.jsonError) return
     let convertedValue = pair.value
     // 根据声明的类型进行转换
     switch (pair.type) {
@@ -256,6 +281,9 @@ function confirmDialog() {
         // 这里直接赋值 pair.value 应该是安全的，因为 v-model 绑定的就是布尔值
         // convertedValue = Boolean(pair.value)
         break
+      case 'json':
+        convertedValue = JSON.parse(pair.value)
+        break
       case 'string':
       default:
         // 默认转换为字符串

dashboard/src/components/shared/TemplateListEditor.vue

@@ -0,0 +1,450 @@
+<template>
+  <div class="template-list-editor">
+    <div class="top-bar d-flex align-center justify-end mb-3">
+      <v-menu transition="fade-transition">
+        <template #activator="{ props: menuProps }">
+          <v-btn
+            color="primary"
+            variant="tonal"
+            size="small"
+            v-bind="menuProps"
+            prepend-icon="mdi-plus"
+          >
+            {{ addButtonText }}
+          </v-btn>
+        </template>
+        <v-list density="compact">
+          <v-list-item
+            v-for="option in templateOptions"
+            :key="option.value"
+            @click="addEntry(option.value)"
+          >
+            <v-list-item-title>{{ option.label }}</v-list-item-title>
+            <v-list-item-subtitle v-if="option.hint">{{ option.hint }}</v-list-item-subtitle>
+          </v-list-item>
+        </v-list>
+      </v-menu>
+    </div>
+
+    <v-alert
+      v-if="!modelValue || modelValue.length === 0"
+      type="info"
+      variant="tonal"
+      density="compact"
+      class="mb-3"
+    >
+      {{ emptyHintText }}
+    </v-alert>
+
+    <v-card
+      v-for="(entry, entryIndex) in modelValue"
+      :key="entryIndex"
+      variant="outlined"
+      class="mb-3"
+    >
+      <v-card-title 
+        class="d-flex align-center justify-space-between entry-header"
+        @click="toggleEntry(entryIndex)"
+      >
+        <div class="d-flex align-center ga-2">
+          <v-btn
+            icon
+            size="small"
+            variant="text"
+            :title="expandedEntries[entryIndex] ? (t('core.common.collapse') || '收起') : (t('core.common.expand') || '展开')"
+          >
+            <v-icon>{{ expandedEntries[entryIndex] ? 'mdi-chevron-down' : 'mdi-chevron-right' }}</v-icon>
+          </v-btn>
+          <div class="d-flex flex-column">
+            <v-list-item-title class="property-name">{{ templateLabel(entry.__template_key) }}</v-list-item-title>
+            <v-list-item-subtitle class="property-hint" v-if="getTemplate(entry)?.hint || getTemplate(entry)?.description">
+              {{ getTemplate(entry)?.hint || getTemplate(entry)?.description }}
+            </v-list-item-subtitle>
+          </div>
+        </div>
+        <div class="d-flex align-center ga-1">
+          <v-btn icon size="small" variant="text" color="error" @click.stop="removeEntry(entryIndex)">
+            <v-icon>mdi-delete</v-icon>
+          </v-btn>
+        </div>
+      </v-card-title>
+      <v-expand-transition>
+        <v-card-text v-show="expandedEntries[entryIndex]" class="px-0 py-1">
+          <div v-if="!getTemplate(entry)" class="px-4 py-2">
+            <v-alert type="error" variant="tonal" density="compact">{{ t('core.common.templateList.missingTemplate') || '找不到对应模板，请删除后重新添加。' }}</v-alert>
+          </div>
+          <div v-else class="template-entry-body">
+            <template v-for="(itemMeta, itemKey, metaIndex) in getTemplate(entry).items" :key="itemKey">
+              <!-- Nested Object -->
+              <div
+                v-if="itemMeta?.type === 'object' && !itemMeta?.invisible && shouldShowItem(itemMeta, entry)"
+                class="nested-container mx-4"
+              >
+                <div class="config-section mb-2">
+                  <v-list-item-title class="config-title">
+                    {{ itemMeta?.description || itemKey }}
+                  </v-list-item-title>
+                  <v-list-item-subtitle class="config-hint" v-if="itemMeta?.hint">
+                    {{ itemMeta.hint }}
+                  </v-list-item-subtitle>
+                </div>
+                <div v-for="(childMeta, childKey, childIndex) in itemMeta.items" :key="childKey">
+                  <template v-if="!childMeta?.invisible && shouldShowItem(childMeta, entry)">
+                    <v-row class="config-row">
+                      <v-col cols="12" sm="6" class="property-info">
+                        <v-list-item density="compact">
+                          <v-list-item-title class="property-name">
+                            {{ childMeta?.description || childKey }}
+                          </v-list-item-title>
+                          <v-list-item-subtitle class="property-hint">
+                            {{ childMeta?.hint }}
+                          </v-list-item-subtitle>
+                        </v-list-item>
+                      </v-col>
+                      <v-col cols="12" sm="6" class="config-input">
+                        <ConfigItemRenderer
+                          v-model="entry[itemKey][childKey]"
+                          :item-meta="childMeta"
+                        />
+                      </v-col>
+                    </v-row>
+                    <v-divider
+                      v-if="hasVisibleItemsAfter(Object.entries(itemMeta.items), childIndex, entry)"
+                      class="config-divider"
+                    ></v-divider>
+                  </template>
+                </div>
+              </div>
+
+              <!-- Regular Property -->
+              <template v-else-if="!itemMeta?.invisible && shouldShowItem(itemMeta, entry)">
+                <v-row class="config-row">
+                  <v-col cols="12" sm="6" class="property-info">
+                    <v-list-item density="compact">
+                      <v-list-item-title class="property-name">
+                        <span v-if="itemMeta?.description">{{ itemMeta?.description }} <span class="property-key">({{ itemKey }})</span></span>
+                        <span v-else>{{ itemKey }}</span>
+                      </v-list-item-title>
+                      <v-list-item-subtitle class="property-hint">
+                        {{ itemMeta?.hint }}
+                      </v-list-item-subtitle>
+                    </v-list-item>
+                  </v-col>
+                  <v-col cols="12" sm="6" class="config-input">
+                    <ConfigItemRenderer
+                      v-model="entry[itemKey]"
+                      :item-meta="itemMeta"
+                    />
+                  </v-col>
+                </v-row>
+                <v-divider
+                  v-if="hasVisibleItemsAfter(Object.entries(getTemplate(entry).items), metaIndex, entry)"
+                  class="config-divider"
+                ></v-divider>
+              </template>
+            </template>
+          </div>
+        </v-card-text>
+      </v-expand-transition>
+    </v-card>
+  </div>
+</template>
+
+<script setup>
+import { computed, ref, watch } from 'vue'
+import ConfigItemRenderer from './ConfigItemRenderer.vue'
+import { useI18n } from '@/i18n/composables'
+
+const props = defineProps({
+  modelValue: {
+    type: Array,
+    default: () => []
+  },
+  templates: {
+    type: Object,
+    default: () => ({})
+  }
+})
+
+const emit = defineEmits(['update:modelValue'])
+const { t } = useI18n()
+
+const expandedEntries = ref({})
+
+const safeText = (val, fallback) => (val && typeof val === 'string' ? val : fallback)
+const addButtonText = computed(() => safeText(t('core.common.templateList.addEntry'), '添加条目'))
+const emptyHintText = computed(() => safeText(t('core.common.templateList.empty'), '暂无条目，请先选择模板并添加。'))
+const defaultValueMap = {
+  int: 0,
+  float: 0.0,
+  bool: false,
+  string: '',
+  text: '',
+  list: [],
+  object: {},
+  template_list: []
+}
+
+const templateOptions = computed(() => {
+  return Object.entries(props.templates || {}).map(([value, meta]) => ({
+    label: meta?.name || value,
+    value,
+    hint: meta?.hint || meta?.description || ''
+  }))
+})
+
+function templateLabel(key) {
+  if (!key) return t('core.common.templateList.unknownTemplate') || '未指定模板'
+  return props.templates?.[key]?.name || key
+}
+
+function buildDefaults(itemsMeta = {}) {
+  const result = {}
+  for (const [k, meta] of Object.entries(itemsMeta)) {
+    if (!meta || !meta.type) continue
+    const fallback = Object.prototype.hasOwnProperty.call(meta, 'default')
+      ? meta.default
+      : defaultValueMap[meta.type]
+
+    if (meta.type === 'object') {
+      result[k] = buildDefaults(meta.items || {})
+    } else {
+      result[k] = fallback
+    }
+  }
+  return result
+}
+
+function applyDefaults(target, itemsMeta = {}) {
+  let changed = false
+  for (const [k, meta] of Object.entries(itemsMeta)) {
+    if (!meta || !meta.type) continue
+    const hasDefault = Object.prototype.hasOwnProperty.call(meta, 'default')
+    const fallback = hasDefault ? meta.default : defaultValueMap[meta.type]
+
+    if (meta.type === 'object') {
+      if (!target[k] || typeof target[k] !== 'object') {
+        target[k] = buildDefaults(meta.items || {})
+        changed = true
+      } else {
+        if (applyDefaults(target[k], meta.items || {})) {
+          changed = true
+        }
+      }
+    } else if (!(k in target)) {
+      target[k] = fallback
+      changed = true
+    }
+  }
+  return changed
+}
+
+function ensureEntryDefaults() {
+  if (!Array.isArray(props.modelValue)) return
+  
+  let totalChanged = false
+  const nextValue = props.modelValue.map((entry, idx) => {
+    const template = getTemplate(entry)
+    if (!template || !template.items) return entry
+    
+    // 我们必须克隆以避免就地修改
+    const newEntry = JSON.parse(JSON.stringify(entry))
+    let entryChanged = applyDefaults(newEntry, template.items)
+    
+    if (!Object.prototype.hasOwnProperty.call(newEntry, '__template_key')) {
+      newEntry.__template_key = ''
+      entryChanged = true
+    }
+    
+    if (!(idx in expandedEntries.value)) {
+      expandedEntries.value[idx] = false
+    }
+    
+    if (entryChanged) {
+      totalChanged = true
+    }
+    return newEntry
+  })
+  
+  if (totalChanged) {
+    emit('update:modelValue', nextValue)
+  }
+}
+
+watch(
+  () => props.modelValue,
+  () => ensureEntryDefaults(),
+  { immediate: true, deep: true }
+)
+
+function addEntry(templateKey) {
+  if (!templateKey) return
+  const template = props.templates?.[templateKey]
+  if (!template) return
+  const newEntry = {
+    __template_key: templateKey,
+    ...buildDefaults(template.items || {})
+  }
+  emit('update:modelValue', [...(props.modelValue || []), newEntry])
+  expandedEntries.value[props.modelValue.length] = true
+}
+
+function removeEntry(index) {
+  const next = [...(props.modelValue || [])]
+  next.splice(index, 1)
+  const rebuilt = {}
+  next.forEach((_, idx) => {
+    const sourceIdx = idx >= index ? idx + 1 : idx
+    rebuilt[idx] = expandedEntries.value[sourceIdx] ?? false
+  })
+  expandedEntries.value = rebuilt
+  emit('update:modelValue', next)
+}
+
+function toggleEntry(index) {
+  expandedEntries.value[index] = !expandedEntries.value[index]
+}
+
+function getTemplate(entry) {
+  if (!entry) return null
+  const key = entry.__template_key
+  if (!key) return null
+  return props.templates?.[key] || null
+}
+
+function getValueBySelector(obj, selector) {
+  const keys = selector.split('.')
+  let current = obj
+  for (const key of keys) {
+    if (current && typeof current === 'object' && key in current) {
+      current = current[key]
+    } else {
+      return undefined
+    }
+  }
+  return current
+}
+
+function shouldShowItem(itemMeta, entry) {
+  if (!itemMeta?.condition) {
+    return true
+  }
+  for (const [conditionKey, expectedValue] of Object.entries(itemMeta.condition)) {
+    const actualValue = getValueBySelector(entry, conditionKey)
+    if (actualValue !== expectedValue) {
+      return false
+    }
+  }
+  return true
+}
+
+function hasVisibleItemsAfter(entries, currentIndex, entry) {
+  for (let i = currentIndex + 1; i < entries.length; i++) {
+    const [k, meta] = entries[i]
+    if (!meta?.invisible && shouldShowItem(meta, entry)) {
+      return true
+    }
+  }
+  return false
+}
+</script>
+
+<style scoped>
+.template-list-editor {
+  width: 100%;
+}
+
+.entry-header {
+  cursor: pointer;
+  user-select: none;
+}
+
+.entry-header:hover {
+  background-color: rgba(0, 0, 0, 0.02);
+}
+
+.top-bar {
+  margin-bottom: 8px;
+}
+
+.config-section {
+  margin-bottom: 12px;
+}
+
+.config-title {
+  font-weight: 600;
+  font-size: 1rem;
+  color: var(--v-theme-primaryText);
+}
+
+.config-hint {
+  font-size: 0.75rem;
+  color: var(--v-theme-secondaryText);
+  margin-top: 2px;
+}
+
+.template-entry-body {
+  margin-top: 4px;
+}
+
+.config-row {
+  margin: 0;
+  align-items: center;
+  padding: 4px 8px;
+  border-radius: 4px;
+}
+
+.config-row:hover {
+  background-color: rgba(0, 0, 0, 0.03);
+}
+
+.property-info {
+  padding: 0;
+}
+
+.property-name {
+  font-size: 0.875rem;
+  font-weight: 600;
+  color: var(--v-theme-primaryText);
+}
+
+.property-hint {
+  font-size: 0.75rem;
+  color: var(--v-theme-secondaryText);
+  margin-top: 2px;
+}
+
+.property-key {
+  font-size: 0.85em;
+  opacity: 0.7;
+  font-weight: normal;
+}
+
+.config-input {
+  padding: 4px 8px;
+}
+
+.config-field {
+  margin-bottom: 0;
+}
+
+.config-divider {
+  border-color: rgba(0, 0, 0, 0.05);
+  margin: 0px 16px;
+}
+
+.nested-container {
+  border: 1px solid rgba(0, 0, 0, 0.1);
+  border-radius: 8px;
+  padding: 12px;
+  margin: 12px 0;
+  background-color: rgba(0, 0, 0, 0.02);
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+}
+
+.editor-container {
+  position: relative;
+  display: flex;
+  width: 100%;
+}
+</style>

dashboard/src/composables/useProviderSources.ts

@@ -398,7 +398,7 @@ export function useProviderSources(options: UseProviderSourcesOptions) {
     if (!confirm(tm('providerSources.deleteConfirm', { id: source.id }))) return
 
     try {
-      await axios.post(`/api/config/provider_sources/${source.id}/delete`)
+      await axios.post('/api/config/provider_sources/delete', { id: source.id })
 
       providers.value = providers.value.filter((p) => p.provider_source_id !== source.id)
       providerSources.value = providerSources.value.filter((s) => s.id !== source.id)
@@ -423,7 +423,7 @@ export function useProviderSources(options: UseProviderSourcesOptions) {
     savingSource.value = true
     const originalId = selectedProviderSourceOriginalId.value || selectedProviderSource.value.id
     try {
-      const response = await axios.post(`/api/config/provider_sources/${originalId}/update`, {
+      const response = await axios.post('/api/config/provider_sources/update', {
         config: editableProviderSource.value,
         original_id: originalId
       })
@@ -478,7 +478,9 @@ export function useProviderSources(options: UseProviderSourcesOptions) {
     loadingModels.value = true
     try {
       const sourceId = editableProviderSource.value?.id || selectedProviderSource.value.id
-      const response = await axios.get(`/api/config/provider_sources/${sourceId}/models`)
+      const response = await axios.get('/api/config/provider_sources/models', {
+        params: { source_id: sourceId }
+      })
       if (response.data.status === 'ok') {
         const metadataMap = response.data.data.model_metadata || {}
         modelMetadata.value = metadataMap
@@ -506,12 +508,19 @@ export function useProviderSources(options: UseProviderSourcesOptions) {
     const sourceId = editableProviderSource.value?.id || selectedProviderSource.value.id
     const newId = `${sourceId}/${modelName}`
 
-    const modalities = ['text']
-    if (supportsImageInput(getModelMetadata(modelName))) {
-      modalities.push('image')
-    }
-    if (supportsToolCall(getModelMetadata(modelName))) {
-      modalities.push('tool_use')
+    const metadata = getModelMetadata(modelName)
+    let modalities: string[]
+    
+    if (!metadata) {
+      modalities = ['text', 'image', 'tool_use']
+    } else {
+      modalities = ['text']
+      if (supportsImageInput(metadata)) {
+        modalities.push('image')
+      }
+      if (supportsToolCall(metadata)) {
+        modalities.push('tool_use')
+      }
     }
 
     const newProvider = {

dashboard/src/i18n/locales/en-US/core/common.json

@@ -65,6 +65,12 @@
     "fullscreen": "Fullscreen Edit",
     "editingTitle": "Editing Content"
   },
+  "templateList": {
+    "addEntry": "Add Entry",
+    "empty": "No entries yet, pick a template to add",
+    "missingTemplate": "Template not found, please remove and add again.",
+    "unknownTemplate": "Template not specified"
+  },
   "list": {
     "addItemPlaceholder": "Add new item, press Enter to confirm",
     "addButton": "Add",
@@ -84,7 +90,6 @@
     "enabled": "Enabled",
     "disabled": "Disabled",
     "delete": "Delete",
-    "copy": "Copy",
     "edit": "Edit",
     "copy": "Copy",
     "noData": "No data available"