chore: bump version to 4.14.6

* perf: optimize webchat and wecom ai queue lifecycle

* perf: enhance webchat back queue management with conversation ID support

ASYNC_TASK_new.md

@@ -1,18 +0,0 @@
-我需要让 Agent 能够在未来提醒自己去做某些事情，这样 Agent 能够主动地去完成一些任务，而不是等用户主动来下达命令。
-
-你需要实现一个 CronJob 系统，允许 Agent 创建未来任务，并且在未来的某个时间点自动触发这些任务的执行.
-
-CronJob 系统分为 BasicCronJob 和 ActiveAgentCronJob 两种类型。前者只是简单的提供一个定时任务功能（给插件用），而后者则允许 Agent 主动地去完成一些任务。BasicCronJob 不必多说，就是定时执行某个函数。对于 ActiveAgentCronJob，Agent 应该可以主动管理（比如通过Tool来管理）这些 CronJobs，当添加的时候，Agent 可以给 CronJob 捎一段文字，以说明未来的自己需要做什么事情。比如说，Agent 在听到用户 “每天早上都给我整理一份今日早报” 之后，应该可以创建 Cron Job，并且自己写脚本来完成这个任务，并且注册 cron job。Agent 给未来的自己捎去的信息应该只是呈现为一段文字，这样可以保持设计简约。当触发后， CronJobManager 会调用 MainAgent 的一轮循环，MainAgent 通过上下文知道这是一个定时任务触发的循环，从而执行相应的操作。
-
-此外，我还有一个需求，后台长任务。需要给当前的 FunctionTool 类增加一个属性，is_background_task: bool = False，插件可以通过这个属性来声明这是一个异步任务。这是为了解决一些 Tool 需要长时间运行的问题，比如 Deep Search tool 需要长时间搜索网页内容、Sub Agent 需要长时间运行来完成一个复杂任务。
-
-基于上面的讨论，我觉得，应该：
-
-1. 需要给当前的 FunctionTool 类增加一个属性is_background_task: bool = False，tool runner 在执行这个 tool 的时候，如果发现是后台任务，就不等待结果返回，而是直接返回一个任务 ID （已经创建成功提示）的结果，tool runner 在后台继续执行这个任务。当任务完成之后，任务的结果回传给 MainAgent（其实就是再执行一次 main agent loop，但是上下文应该是最新的），并且 MainAgent 此时应该有 send_message_to_user 的工具，通过这个工具可以选择是否主动通知用户任务完成的结果。
-2. 增加一个 CronJobManager 类，负责管理所有的定时任务。Agent 可以通过调用这个类的方法来创建、删除、修改定时任务。通过 cron expression 来定义触发条件。
-3. CronJobManager 除了管理普通的定时任务（比如插件可能有一些自己的定时任务），还有一种特殊的任务类型，就是上面提到的主动型 Agent 任务。用户提需求，MainAgent 选择性地调用 CronJobManager 的方法来创建这些任务，并且在任务触发时，CronJobManager 的回调就是执行 MainAgent 的一轮循环（需要加 send_message_to_user tool），MainAgent 通过上下文知道这是一个定时任务触发的循环，从而执行相应的操作。
-4. WebUI 需要增加 Cron Job 管理界面，用户可以在界面上查看、创建、修改、删除定时任务。对于主动型 Agent 任务，用户可以看到任务的描述、触发条件等信息。
-5. 除此之外，现在的代码中已经有了 subagent 的管理。WebUI 可以创建 SubAgent，但是还没写完。除了结合上面我说的之外，你还需要将 SubAgent 与 Persona 结合起来——因为 Persona 是一个包含了 tool、skills、name、description 的完整体，所以 SubAgent 应该直接继承 Persona 的定义，而不是单独定义 SubAgent。SubAgent 本质上就是一个有特定角色和能力的 Persona！多么美妙的设计啊！
-6. 为了实现大一统，is_background_task = True 的时候，后台任务也挂到 CronJobManager 上去管理，只不过这个是立即触发的任务，不需要等到未来某个时间点才触发罢了。
-
-我希望设计尽可能简单，但是强大。

README.md

@@ -34,7 +34,7 @@
 <a href="https://github.com/AstrBotDevs/AstrBot/issues">问题提交</a>
 </div>
 
-AstrBot 是一个开源的一站式 Agent 聊天机器人平台，可接入主流即时通讯软件，为个人、开发者和团队打造可靠、可扩展的对话式智能基础设施。无论是个人 AI 伙伴、智能客服、自动化助手，还是企业知识库，AstrBot 都能在你的即时通讯软件平台的工作流中快速构建生产可用的 AI 应用。
+AstrBot 是一个开源的一站式 Agentic 个人和群聊助手，可在 QQ、Telegram、企业微信、飞书、钉钉、Slack、等数十款主流即时通讯软件上部署，此外还内置类似 OpenWebUI 的轻量化 ChatUI，为个人、开发者和团队打造可靠、可扩展的对话式智能基础设施。无论是个人 AI 伙伴、智能客服、自动化助手，还是企业知识库，AstrBot 都能在你的即时通讯软件平台的工作流中快速构建 AI 应用。
 
 ![521771166-00782c4c-4437-4d97-aabc-605e3738da5c (1)](https://github.com/user-attachments/assets/61e7b505-f7db-41aa-a75f-4ef8f079b8ba)
 
@@ -50,6 +50,23 @@ AstrBot 是一个开源的一站式 Agent 聊天机器人平台，可接入主
 7. 🌈 Web ChatUI 支持，ChatUI 内置代理沙盒、网页搜索等。
 8. 🌐 国际化（i18n）支持。
 
+<br>
+
+<table align="center">
+  <tr align="center">
+    <th>💙 角色扮演 & 情感陪伴</th>
+    <th>✨ 主动式 Agent</th>
+    <th>🚀 通用 Agentic 能力</th>
+    <th>🧩 900+ 社区插件</th>
+  </tr>
+  <tr>
+    <td align="center"><p align="center"><img width="984" height="1746" alt="99b587c5d35eea09d84f33e6cf6cfd4f" src="https://github.com/user-attachments/assets/89196061-3290-458d-b51f-afa178049f84" /></p></td>
+    <td align="center"><p align="center"><img width="976" height="1612" alt="c449acd838c41d0915cc08a3824025b1" src="https://github.com/user-attachments/assets/f75368b4-e022-41dc-a9e0-131c3e73e32e" /></p></td>
+    <td align="center"><p align="center"><img width="974" height="1732" alt="image" src="https://github.com/user-attachments/assets/e22a3968-87d7-4708-a7cd-e7f198c7c32e" /></p></td>
+    <td align="center"><p align="center"><img width="976" height="1734" alt="image" src="https://github.com/user-attachments/assets/0952b395-6b4a-432a-8a50-c294b7f89750" /></p></td>
+  </tr>
+</table>
+
 ## 快速开始
 
 #### Docker 部署(推荐 🥳)
@@ -247,8 +264,9 @@ pre-commit install
 
 <div align="center">
 
+_陪伴与能力从来不应该是对立面。我们希望创造的是一个既能理解情绪、给予陪伴，也能可靠完成工作的机器人。_
+
 _私は、高性能ですから!_
 
 <img src="https://files.astrbot.app/watashiwa-koseino-desukara.gif" width="100"/>
-</div
 

astrbot/builtin_stars/astrbot/main.py

@@ -77,7 +77,6 @@ class Main(star.Star):
 
                     yield event.request_llm(
                         prompt=prompt,
-                        func_tool_manager=self.context.get_llm_tool_manager(),
                         session_id=event.session_id,
                         conversation=conv,
                     )

astrbot/builtin_stars/session_controller/main.py

@@ -49,7 +49,7 @@ class Main(Star):
                     if p_settings.get("empty_mention_waiting_need_reply", True):
                         try:
                             # 尝试使用 LLM 生成更生动的回复
-                            func_tools_mgr = self.context.get_llm_tool_manager()
+                            # func_tools_mgr = self.context.get_llm_tool_manager()
 
                             # 获取用户当前的对话信息
                             curr_cid = await self.context.conversation_manager.get_curr_conversation_id(
@@ -76,7 +76,6 @@ class Main(Star):
                                     "你友好地询问用户想要聊些什么或者需要什么帮助，回复要符合人设，不要太过机械化。"
                                     "请注意，你仅需要输出要回复用户的内容，不要输出其他任何东西"
                                 ),
-                                func_tool_manager=func_tools_mgr,
                                 session_id=curr_cid,
                                 contexts=[],
                                 system_prompt="",

astrbot/builtin_stars/web_searcher/main.py

@@ -23,6 +23,7 @@ class Main(star.Star):
         "fetch_url",
         "web_search_tavily",
         "tavily_extract_web_page",
+        "web_search_bocha",
     ]
 
     def __init__(self, context: star.Context) -> None:
@@ -30,6 +31,9 @@ class Main(star.Star):
         self.tavily_key_index = 0
         self.tavily_key_lock = asyncio.Lock()
 
+        self.bocha_key_index = 0
+        self.bocha_key_lock = asyncio.Lock()
+
         # 将 str 类型的 key 迁移至 list[str]，并保存
         cfg = self.context.get_config()
         provider_settings = cfg.get("provider_settings")
@@ -45,6 +49,14 @@ class Main(star.Star):
                     provider_settings["websearch_tavily_key"] = []
                 cfg.save_config()
 
+            bocha_key = provider_settings.get("websearch_bocha_key")
+            if isinstance(bocha_key, str):
+                if bocha_key:
+                    provider_settings["websearch_bocha_key"] = [bocha_key]
+                else:
+                    provider_settings["websearch_bocha_key"] = []
+                cfg.save_config()
+
         self.bing_search = Bing()
         self.sogo_search = Sogo()
         self.baidu_initialized = False
@@ -341,7 +353,7 @@ class Main(star.Star):
                 }
             )
             if result.favicon:
-                sp.temorary_cache["_ws_favicon"][result.url] = result.favicon
+                sp.temporary_cache["_ws_favicon"][result.url] = result.favicon
         # ret = "\n".join(ret_ls)
         ret = json.dumps({"results": ret_ls}, ensure_ascii=False)
         return ret
@@ -382,6 +394,160 @@ class Main(star.Star):
             return "Error: Tavily web searcher does not return any results."
         return ret
 
+    async def _get_bocha_key(self, cfg: AstrBotConfig) -> str:
+        """并发安全的从列表中获取并轮换BoCha API密钥。"""
+        bocha_keys = cfg.get("provider_settings", {}).get("websearch_bocha_key", [])
+        if not bocha_keys:
+            raise ValueError("错误：BoCha API密钥未在AstrBot中配置。")
+
+        async with self.bocha_key_lock:
+            key = bocha_keys[self.bocha_key_index]
+            self.bocha_key_index = (self.bocha_key_index + 1) % len(bocha_keys)
+            return key
+
+    async def _web_search_bocha(
+        self,
+        cfg: AstrBotConfig,
+        payload: dict,
+    ) -> list[SearchResult]:
+        """使用 BoCha 搜索引擎进行搜索"""
+        bocha_key = await self._get_bocha_key(cfg)
+        url = "https://api.bochaai.com/v1/web-search"
+        header = {
+            "Authorization": f"Bearer {bocha_key}",
+            "Content-Type": "application/json",
+        }
+        async with aiohttp.ClientSession(trust_env=True) as session:
+            async with session.post(
+                url,
+                json=payload,
+                headers=header,
+            ) as response:
+                if response.status != 200:
+                    reason = await response.text()
+                    raise Exception(
+                        f"BoCha web search failed: {reason}, status: {response.status}",
+                    )
+                data = await response.json()
+                data = data["data"]["webPages"]["value"]
+                results = []
+                for item in data:
+                    result = SearchResult(
+                        title=item.get("name"),
+                        url=item.get("url"),
+                        snippet=item.get("snippet"),
+                        favicon=item.get("siteIcon"),
+                    )
+                    results.append(result)
+                return results
+
+    @llm_tool("web_search_bocha")
+    async def search_from_bocha(
+        self,
+        event: AstrMessageEvent,
+        query: str,
+        freshness: str = "noLimit",
+        summary: bool = False,
+        include: str = "",
+        exclude: str = "",
+        count: int = 10,
+    ) -> str:
+        """
+        A web search tool based on Bocha Search API, used to retrieve web pages
+        related to the user's query.
+
+        Args:
+            query (string): Required. User's search query.
+
+            freshness (string): Optional. Specifies the time range of the search.
+                Supported values:
+                - "noLimit": No time limit (default, recommended).
+                - "oneDay": Within one day.
+                - "oneWeek": Within one week.
+                - "oneMonth": Within one month.
+                - "oneYear": Within one year.
+                - "YYYY-MM-DD..YYYY-MM-DD": Search within a specific date range.
+                  Example: "2025-01-01..2025-04-06".
+                - "YYYY-MM-DD": Search on a specific date.
+                  Example: "2025-04-06".
+                It is recommended to use "noLimit", as the search algorithm will
+                automatically optimize time relevance. Manually restricting the
+                time range may result in no search results.
+
+            summary (boolean): Optional. Whether to include a text summary
+                for each search result.
+                - True: Include summary.
+                - False: Do not include summary (default).
+
+            include (string): Optional. Specifies the domains to include in
+                the search. Multiple domains can be separated by "|" or ",".
+                A maximum of 100 domains is allowed.
+                Examples:
+                - "qq.com"
+                - "qq.com|m.163.com"
+
+            exclude (string): Optional. Specifies the domains to exclude from
+                the search. Multiple domains can be separated by "|" or ",".
+                A maximum of 100 domains is allowed.
+                Examples:
+                - "qq.com"
+                - "qq.com|m.163.com"
+
+            count (number): Optional. Number of search results to return.
+                - Range: 1–50
+                - Default: 10
+                The actual number of returned results may be less than the
+                specified count.
+        """
+        logger.info(f"web_searcher - search_from_bocha: {query}")
+        cfg = self.context.get_config(umo=event.unified_msg_origin)
+        # websearch_link = cfg["provider_settings"].get("web_search_link", False)
+        if not cfg.get("provider_settings", {}).get("websearch_bocha_key", []):
+            raise ValueError("Error: BoCha API key is not configured in AstrBot.")
+
+        # build payload
+        payload = {
+            "query": query,
+            "count": count,
+        }
+
+        # freshness：时间范围
+        if freshness:
+            payload["freshness"] = freshness
+
+        # 是否返回摘要
+        payload["summary"] = summary
+
+        # include：限制搜索域
+        if include:
+            payload["include"] = include
+
+        # exclude：排除搜索域
+        if exclude:
+            payload["exclude"] = exclude
+
+        results = await self._web_search_bocha(cfg, payload)
+        if not results:
+            return "Error: BoCha web searcher does not return any results."
+
+        ret_ls = []
+        ref_uuid = str(uuid.uuid4())[:4]
+        for idx, result in enumerate(results, 1):
+            index = f"{ref_uuid}.{idx}"
+            ret_ls.append(
+                {
+                    "title": f"{result.title}",
+                    "url": f"{result.url}",
+                    "snippet": f"{result.snippet}",
+                    "index": index,
+                }
+            )
+            if result.favicon:
+                sp.temporary_cache["_ws_favicon"][result.url] = result.favicon
+        # ret = "\n".join(ret_ls)
+        ret = json.dumps({"results": ret_ls}, ensure_ascii=False)
+        return ret
+
     @filter.on_llm_request(priority=-10000)
     async def edit_web_search_tools(
         self,
@@ -419,6 +585,7 @@ class Main(star.Star):
             tool_set.remove_tool("web_search_tavily")
             tool_set.remove_tool("tavily_extract_web_page")
             tool_set.remove_tool("AIsearch")
+            tool_set.remove_tool("web_search_bocha")
         elif provider == "tavily":
             web_search_tavily = func_tool_mgr.get_func("web_search_tavily")
             tavily_extract_web_page = func_tool_mgr.get_func("tavily_extract_web_page")
@@ -429,6 +596,7 @@ class Main(star.Star):
             tool_set.remove_tool("web_search")
             tool_set.remove_tool("fetch_url")
             tool_set.remove_tool("AIsearch")
+            tool_set.remove_tool("web_search_bocha")
         elif provider == "baidu_ai_search":
             try:
                 await self.ensure_baidu_ai_search_mcp(event.unified_msg_origin)
@@ -440,5 +608,15 @@ class Main(star.Star):
                 tool_set.remove_tool("fetch_url")
                 tool_set.remove_tool("web_search_tavily")
                 tool_set.remove_tool("tavily_extract_web_page")
+                tool_set.remove_tool("web_search_bocha")
             except Exception as e:
                 logger.error(f"Cannot Initialize Baidu AI Search MCP Server: {e}")
+        elif provider == "bocha":
+            web_search_bocha = func_tool_mgr.get_func("web_search_bocha")
+            if web_search_bocha:
+                tool_set.add_tool(web_search_bocha)
+            tool_set.remove_tool("web_search")
+            tool_set.remove_tool("fetch_url")
+            tool_set.remove_tool("AIsearch")
+            tool_set.remove_tool("web_search_tavily")
+            tool_set.remove_tool("tavily_extract_web_page")

astrbot/cli/__init__.py

@@ -1 +1 @@
-__version__ = "4.13.2"
+__version__ = "4.14.6"

astrbot/core/agent/runners/tool_loop_agent_runner.py

@@ -213,6 +213,8 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
             if not llm_response.is_chunk and llm_response.usage:
                 # only count the token usage of the final response for computation purpose
                 self.stats.token_usage += llm_response.usage
+                if self.req.conversation:
+                    self.req.conversation.token_usage = llm_response.usage.total
             break  # got final response
 
         if not llm_resp_result:
@@ -252,6 +254,10 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                 )
             if llm_resp.completion_text:
                 parts.append(TextPart(text=llm_resp.completion_text))
+            if len(parts) == 0:
+                logger.warning(
+                    "LLM returned empty assistant message with no tool calls."
+                )
             self.run_context.messages.append(Message(role="assistant", content=parts))
 
             # call the on_agent_done hook
@@ -307,6 +313,8 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                 )
             if llm_resp.completion_text:
                 parts.append(TextPart(text=llm_resp.completion_text))
+            if len(parts) == 0:
+                parts = None
             tool_calls_result = ToolCallsResult(
                 tool_calls_info=AssistantMessageSegment(
                     tool_calls=llm_resp.to_openai_to_calls_model(),

astrbot/core/agent/tool.py

@@ -246,8 +246,18 @@ class ToolSet:
 
             result = {}
 
-            if "type" in schema and schema["type"] in supported_types:
-                result["type"] = schema["type"]
+            # Avoid side effects by not modifying the original schema
+            origin_type = schema.get("type")
+            target_type = origin_type
+
+            # Compatibility fix: Gemini API expects 'type' to be a string (enum),
+            # but standard JSON Schema (MCP) allows lists (e.g. ["string", "null"]).
+            # We fallback to the first non-null type.
+            if isinstance(origin_type, list):
+                target_type = next((t for t in origin_type if t != "null"), "string")
+
+            if target_type in supported_types:
+                result["type"] = target_type
                 if "format" in schema and schema["format"] in supported_formats.get(
                     result["type"],
                     set(),

astrbot/core/astr_agent_hooks.py

@@ -59,7 +59,7 @@ class MainAgentHooks(BaseAgentRunHooks[AstrAgentContext]):
         platform_name = run_context.context.event.get_platform_name()
         if (
             platform_name == "webchat"
-            and tool.name == "web_search_tavily"
+            and tool.name in ["web_search_tavily", "web_search_bocha"]
             and len(run_context.messages) > 0
             and tool_result
             and len(tool_result.content)

astrbot/core/astr_main_agent.py

@@ -7,6 +7,7 @@ import datetime
 import json
 import os
 import zoneinfo
+from collections.abc import Coroutine
 from dataclasses import dataclass, field
 
 from astrbot.api import sp
@@ -114,6 +115,7 @@ class MainAgentBuildResult:
     agent_runner: AgentRunner
     provider_request: ProviderRequest
     provider: Provider
+    reset_coro: Coroutine | None = None
 
 
 def _select_provider(
@@ -837,8 +839,12 @@ async def build_main_agent(
     config: MainAgentBuildConfig,
     provider: Provider | None = None,
     req: ProviderRequest | None = None,
+    apply_reset: bool = True,
 ) -> MainAgentBuildResult | None:
-    """构建主对话代理（Main Agent），并且自动 reset。"""
+    """构建主对话代理（Main Agent），并且自动 reset。
+
+    If apply_reset is False, will not call reset on the agent runner.
+    """
     provider = provider or _select_provider(event, plugin_context)
     if provider is None:
         logger.info("未找到任何对话模型（提供商），跳过 LLM 请求处理。")
@@ -955,7 +961,7 @@ async def build_main_agent(
     if action_type == "live":
         req.system_prompt += f"\n{LIVE_MODE_SYSTEM_PROMPT}\n"
 
-    await agent_runner.reset(
+    reset_coro = agent_runner.reset(
         provider=provider,
         request=req,
         run_context=AgentContextWrapper(
@@ -973,8 +979,12 @@ async def build_main_agent(
         tool_schema_mode=config.tool_schema_mode,
     )
 
+    if apply_reset:
+        await reset_coro
+
     return MainAgentBuildResult(
         agent_runner=agent_runner,
         provider_request=req,
         provider=provider,
+        reset_coro=reset_coro if not apply_reset else None,
     )

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.13.2"
+VERSION = "4.14.6"
 DB_PATH = os.path.join(get_astrbot_data_path(), "data_v4.db")
 
 WEBHOOK_SUPPORTED_PLATFORMS = [
@@ -74,6 +74,7 @@ DEFAULT_CONFIG = {
         "web_search": False,
         "websearch_provider": "default",
         "websearch_tavily_key": [],
+        "websearch_bocha_key": [],
         "websearch_baidu_app_builder_key": "",
         "web_search_link": False,
         "display_reasoning_text": False,
@@ -2563,7 +2564,7 @@ CONFIG_METADATA_3 = {
                     "provider_settings.websearch_provider": {
                         "description": "网页搜索提供商",
                         "type": "string",
-                        "options": ["default", "tavily", "baidu_ai_search"],
+                        "options": ["default", "tavily", "baidu_ai_search", "bocha"],
                         "condition": {
                             "provider_settings.web_search": True,
                         },
@@ -2578,6 +2579,16 @@ CONFIG_METADATA_3 = {
                             "provider_settings.web_search": True,
                         },
                     },
+                    "provider_settings.websearch_bocha_key": {
+                        "description": "BoCha API Key",
+                        "type": "list",
+                        "items": {"type": "string"},
+                        "hint": "可添加多个 Key 进行轮询。",
+                        "condition": {
+                            "provider_settings.websearch_provider": "bocha",
+                            "provider_settings.web_search": True,
+                        },
+                    },
                     "provider_settings.websearch_baidu_app_builder_key": {
                         "description": "百度千帆智能云 APP Builder API Key",
                         "type": "string",

astrbot/core/cron/manager.py

@@ -310,6 +310,7 @@ class CronJobManager:
         config = MainAgentBuildConfig(
             tool_call_timeout=3600,
             llm_safety_mode=False,
+            streaming_response=False,
         )
         req = ProviderRequest()
         conv = await _get_session_conv(event=cron_event, plugin_context=self.ctx)

astrbot/core/pipeline/content_safety_check/strategies/baidu_aip.py

@@ -1,5 +1,7 @@
 """使用此功能应该先 pip install baidu-aip"""
 
+from typing import Any, cast
+
 from aip import AipContentCensor
 
 from . import ContentSafetyStrategy
@@ -23,7 +25,8 @@ class BaiduAipStrategy(ContentSafetyStrategy):
         count = len(res["data"])
         parts = [f"百度审核服务发现 {count} 处违规：\n"]
         for i in res["data"]:
-            parts.append(f"{i['msg']}；\n")
+            # 百度 AIP 返回结构是动态 dict；类型检查时 i 可能被推断为序列，转成 dict 后用 get 取字段
+            parts.append(f"{cast(dict[str, Any], i).get('msg', '')}；\n")
         parts.append("\n判断结果：" + res["conclusion"])
         info = "".join(parts)
         return False, info

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

@@ -164,6 +164,7 @@ class InternalAgentSubStage(Stage):
                     event=event,
                     plugin_context=self.ctx.plugin_manager.context,
                     config=build_cfg,
+                    apply_reset=False,
                 )
 
                 if build_result is None:
@@ -172,6 +173,7 @@ class InternalAgentSubStage(Stage):
                 agent_runner = build_result.agent_runner
                 req = build_result.provider_request
                 provider = build_result.provider
+                reset_coro = build_result.reset_coro
 
                 api_base = provider.provider_config.get("api_base", "")
                 for host in decoded_blocked:
@@ -190,6 +192,10 @@ class InternalAgentSubStage(Stage):
                 if await call_event_hook(event, EventType.OnLLMRequestEvent, req):
                     return
 
+                # apply reset
+                if reset_coro:
+                    await reset_coro
+
                 action_type = event.get_extra("action_type")
 
                 event.trace.record(
@@ -357,7 +363,8 @@ class InternalAgentSubStage(Stage):
 
         token_usage = None
         if runner_stats:
-            token_usage = runner_stats.token_usage.total
+            # token_usage = runner_stats.token_usage.total
+            token_usage = llm_response.usage.total if llm_response.usage else None
 
         await self.conv_manager.update_conversation(
             event.unified_msg_origin,

astrbot/core/platform/astr_message_event.py

@@ -8,6 +8,7 @@ from time import time
 from typing import Any
 
 from astrbot import logger
+from astrbot.core.agent.tool import ToolSet
 from astrbot.core.db.po import Conversation
 from astrbot.core.message.components import (
     At,
@@ -355,6 +356,7 @@ class AstrMessageEvent(abc.ABC):
         self,
         prompt: str,
         func_tool_manager=None,
+        tool_set: ToolSet | None = None,
         session_id: str = "",
         image_urls: list[str] | None = None,
         contexts: list | None = None,
@@ -377,7 +379,7 @@ class AstrMessageEvent(abc.ABC):
 
         contexts: 当指定 contexts 时，将会使用 contexts 作为上下文。如果同时传入了 conversation，将会忽略 conversation。
 
-        func_tool_manager: 函数工具管理器，用于调用函数工具。用 self.context.get_llm_tool_manager() 获取。
+        func_tool_manager: [Deprecated] 函数工具管理器，用于调用函数工具。用 self.context.get_llm_tool_manager() 获取。已过时，请使用 tool_set 参数代替。
 
         conversation: 可选。如果指定，将在指定的对话中进行 LLM 请求。对话的人格会被用于 LLM 请求，并且结果将会被记录到对话中。
 
@@ -393,7 +395,8 @@ class AstrMessageEvent(abc.ABC):
             prompt=prompt,
             session_id=session_id,
             image_urls=image_urls,
-            func_tool=func_tool_manager,
+            # func_tool=func_tool_manager,
+            func_tool=tool_set,
             contexts=contexts,
             system_prompt=system_prompt,
             conversation=conversation,

astrbot/core/platform/message_session.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 from astrbot.core.platform.message_type import MessageType
 
@@ -13,7 +13,7 @@ class MessageSession:
     """平台适配器实例的唯一标识符。自 AstrBot v4.0.0 起，该字段实际为 platform_id。"""
     message_type: MessageType
     session_id: str
-    platform_id: str | None = None
+    platform_id: str = field(init=False)
 
     def __str__(self):
         return f"{self.platform_id}:{self.message_type.value}:{self.session_id}"

astrbot/core/platform/platform_metadata.py

@@ -21,3 +21,6 @@ class PlatformMetadata:
     """平台是否支持真实流式传输"""
     support_proactive_message: bool = True
     """平台是否支持主动消息推送（非用户触发）"""
+
+    module_path: str | None = None
+    """注册该适配器的模块路径，用于插件热重载时清理"""

astrbot/core/platform/register.py

@@ -37,6 +37,9 @@ def register_platform_adapter(
             if "id" not in default_config_tmpl:
                 default_config_tmpl["id"] = adapter_name
 
+        # Get the module path of the class being decorated
+        module_path = cls.__module__
+
         pm = PlatformMetadata(
             name=adapter_name,
             description=desc,
@@ -45,6 +48,7 @@ def register_platform_adapter(
             adapter_display_name=adapter_display_name,
             logo_path=logo_path,
             support_streaming_message=support_streaming_message,
+            module_path=module_path,
         )
         platform_registry.append(pm)
         platform_cls_map[adapter_name] = cls
@@ -52,3 +56,31 @@ def register_platform_adapter(
         return cls
 
     return decorator
+
+
+def unregister_platform_adapters_by_module(module_path_prefix: str) -> list[str]:
+    """根据模块路径前缀注销平台适配器。
+
+    在插件热重载时调用，用于清理该插件注册的所有平台适配器。
+
+    Args:
+        module_path_prefix: 模块路径前缀，如 "data.plugins.my_plugin"
+
+    Returns:
+        被注销的平台适配器名称列表
+    """
+    unregistered = []
+    to_remove = []
+
+    for pm in platform_registry:
+        if pm.module_path and pm.module_path.startswith(module_path_prefix):
+            to_remove.append(pm)
+            unregistered.append(pm.name)
+
+    for pm in to_remove:
+        platform_registry.remove(pm)
+        if pm.name in platform_cls_map:
+            del platform_cls_map[pm.name]
+        logger.debug(f"平台适配器 {pm.name} 已注销 (来自模块 {pm.module_path})")
+
+    return unregistered

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

@@ -444,9 +444,20 @@ class DiscordPlatformAdapter(Platform):
                 logger.warning(f"[Discord] 指令 '{cmd_name}' defer 失败: {e}")
 
             # 2. 构建 AstrBotMessage
+            channel = ctx.channel
             abm = AstrBotMessage()
-            abm.type = self._get_message_type(ctx.channel, ctx.guild_id)
-            abm.group_id = self._get_channel_id(ctx.channel)
+            if channel is not None:
+                abm.type = self._get_message_type(channel, ctx.guild_id)
+                abm.group_id = self._get_channel_id(channel)
+            else:
+                # 防守式兜底：channel 取不到时，仍能根据 guild_id/channel_id 推断会话信息
+                abm.type = (
+                    MessageType.GROUP_MESSAGE
+                    if ctx.guild_id is not None
+                    else MessageType.FRIEND_MESSAGE
+                )
+                abm.group_id = str(ctx.channel_id)
+
             abm.message_str = message_str_for_filter
             abm.sender = MessageMember(
                 user_id=str(ctx.author.id),

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

@@ -3,13 +3,10 @@ import base64
 import json
 import re
 import time
-import uuid
 from typing import Any, cast
 
 import lark_oapi as lark
 from lark_oapi.api.im.v1 import (
-    CreateMessageRequest,
-    CreateMessageRequestBody,
     GetMessageResourceRequest,
 )
 from lark_oapi.api.im.v1.processor import P2ImMessageReceiveV1Processor
@@ -125,44 +122,23 @@ class LarkPlatformAdapter(Platform):
         session: MessageSesion,
         message_chain: MessageChain,
     ):
-        if self.lark_api.im is None:
-            logger.error("[Lark] API Client im 模块未初始化，无法发送消息")
-            return
-
-        res = await LarkMessageEvent._convert_to_lark(message_chain, self.lark_api)
-        wrapped = {
-            "zh_cn": {
-                "title": "",
-                "content": res,
-            },
-        }
-
         if session.message_type == MessageType.GROUP_MESSAGE:
             id_type = "chat_id"
-            if "%" in session.session_id:
-                session.session_id = session.session_id.split("%")[1]
+            receive_id = session.session_id
+            if "%" in receive_id:
+                receive_id = receive_id.split("%")[1]
         else:
             id_type = "open_id"
+            receive_id = session.session_id
 
-        request = (
-            CreateMessageRequest.builder()
-            .receive_id_type(id_type)
-            .request_body(
-                CreateMessageRequestBody.builder()
-                .receive_id(session.session_id)
-                .content(json.dumps(wrapped))
-                .msg_type("post")
-                .uuid(str(uuid.uuid4()))
-                .build(),
-            )
-            .build()
+        # 复用 LarkMessageEvent 中的通用发送逻辑
+        await LarkMessageEvent.send_message_chain(
+            message_chain,
+            self.lark_api,
+            receive_id=receive_id,
+            receive_id_type=id_type,
         )
 
-        response = await self.lark_api.im.v1.message.acreate(request)
-
-        if not response.success():
-            logger.error(f"发送飞书消息失败({response.code}): {response.msg}")
-
         await super().send_by_session(session, message_chain)
 
     def meta(self) -> PlatformMetadata:

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

@@ -6,6 +6,8 @@ from io import BytesIO
 
 import lark_oapi as lark
 from lark_oapi.api.im.v1 import (
+    CreateFileRequest,
+    CreateFileRequestBody,
     CreateImageRequest,
     CreateImageRequestBody,
     CreateMessageReactionRequest,
@@ -17,10 +19,15 @@ from lark_oapi.api.im.v1 import (
 
 from astrbot import logger
 from astrbot.api.event import AstrMessageEvent, MessageChain
-from astrbot.api.message_components import At, Plain
+from astrbot.api.message_components import At, File, Plain, Record, Video
 from astrbot.api.message_components import Image as AstrBotImage
 from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 from astrbot.core.utils.io import download_image_by_url
+from astrbot.core.utils.media_utils import (
+    convert_audio_to_opus,
+    convert_video_format,
+    get_media_duration,
+)
 
 
 class LarkMessageEvent(AstrMessageEvent):
@@ -35,6 +42,144 @@ class LarkMessageEvent(AstrMessageEvent):
         super().__init__(message_str, message_obj, platform_meta, session_id)
         self.bot = bot
 
+    @staticmethod
+    async def _send_im_message(
+        lark_client: lark.Client,
+        *,
+        content: str,
+        msg_type: str,
+        reply_message_id: str | None = None,
+        receive_id: str | None = None,
+        receive_id_type: str | None = None,
+    ) -> bool:
+        """发送飞书 IM 消息的通用辅助函数
+
+        Args:
+            lark_client: 飞书客户端
+            content: 消息内容（JSON字符串）
+            msg_type: 消息类型（post/file/audio/media等）
+            reply_message_id: 回复的消息ID（用于回复消息）
+            receive_id: 接收者ID（用于主动发送）
+            receive_id_type: 接收者ID类型（用于主动发送）
+
+        Returns:
+            是否发送成功
+        """
+        if lark_client.im is None:
+            logger.error("[Lark] API Client im 模块未初始化")
+            return False
+
+        if reply_message_id:
+            request = (
+                ReplyMessageRequest.builder()
+                .message_id(reply_message_id)
+                .request_body(
+                    ReplyMessageRequestBody.builder()
+                    .content(content)
+                    .msg_type(msg_type)
+                    .uuid(str(uuid.uuid4()))
+                    .reply_in_thread(False)
+                    .build()
+                )
+                .build()
+            )
+            response = await lark_client.im.v1.message.areply(request)
+        else:
+            from lark_oapi.api.im.v1 import (
+                CreateMessageRequest,
+                CreateMessageRequestBody,
+            )
+
+            if receive_id_type is None or receive_id is None:
+                logger.error(
+                    "[Lark] 主动发送消息时，receive_id 和 receive_id_type 不能为空",
+                )
+                return False
+
+            request = (
+                CreateMessageRequest.builder()
+                .receive_id_type(receive_id_type)
+                .request_body(
+                    CreateMessageRequestBody.builder()
+                    .receive_id(receive_id)
+                    .content(content)
+                    .msg_type(msg_type)
+                    .uuid(str(uuid.uuid4()))
+                    .build()
+                )
+                .build()
+            )
+            response = await lark_client.im.v1.message.acreate(request)
+
+        if not response.success():
+            logger.error(f"[Lark] 发送飞书消息失败({response.code}): {response.msg}")
+            return False
+
+        return True
+
+    @staticmethod
+    async def _upload_lark_file(
+        lark_client: lark.Client,
+        *,
+        path: str,
+        file_type: str,
+        duration: int | None = None,
+    ) -> str | None:
+        """上传文件到飞书的通用辅助函数
+
+        Args:
+            lark_client: 飞书客户端
+            path: 文件路径
+            file_type: 文件类型（stream/opus/mp4等）
+            duration: 媒体时长（毫秒），可选
+
+        Returns:
+            成功返回file_key，失败返回None
+        """
+        if not path or not os.path.exists(path):
+            logger.error(f"[Lark] 文件不存在: {path}")
+            return None
+
+        if lark_client.im is None:
+            logger.error("[Lark] API Client im 模块未初始化，无法上传文件")
+            return None
+
+        try:
+            with open(path, "rb") as file_obj:
+                body_builder = (
+                    CreateFileRequestBody.builder()
+                    .file_type(file_type)
+                    .file_name(os.path.basename(path))
+                    .file(file_obj)
+                )
+                if duration is not None:
+                    body_builder.duration(duration)
+
+                request = (
+                    CreateFileRequest.builder()
+                    .request_body(body_builder.build())
+                    .build()
+                )
+                response = await lark_client.im.v1.file.acreate(request)
+
+                if not response.success():
+                    logger.error(
+                        f"[Lark] 无法上传文件({response.code}): {response.msg}"
+                    )
+                    return None
+
+                if response.data is None:
+                    logger.error("[Lark] 上传文件成功但未返回数据(data is None)")
+                    return None
+
+                file_key = response.data.file_key
+                logger.debug(f"[Lark] 文件上传成功: {file_key}")
+                return file_key
+
+        except Exception as e:
+            logger.error(f"[Lark] 无法打开或上传文件: {e}")
+            return None
+
     @staticmethod
     async def _convert_to_lark(message: MessageChain, lark_client: lark.Client) -> list:
         ret = []
@@ -103,6 +248,18 @@ class LarkMessageEvent(AstrMessageEvent):
                 ret.append(_stage)
                 ret.append([{"tag": "img", "image_key": image_key}])
                 _stage.clear()
+            elif isinstance(comp, File):
+                # 文件将通过 _send_file_message 方法单独发送，这里跳过
+                logger.debug("[Lark] 检测到文件组件，将单独发送")
+                continue
+            elif isinstance(comp, Record):
+                # 音频将通过 _send_audio_message 方法单独发送，这里跳过
+                logger.debug("[Lark] 检测到音频组件，将单独发送")
+                continue
+            elif isinstance(comp, Video):
+                # 视频将通过 _send_media_message 方法单独发送，这里跳过
+                logger.debug("[Lark] 检测到视频组件，将单独发送")
+                continue
             else:
                 logger.warning(f"飞书 暂时不支持消息段: {comp.type}")
 
@@ -110,40 +267,270 @@ class LarkMessageEvent(AstrMessageEvent):
             ret.append(_stage)
         return ret
 
-    async def send(self, message: MessageChain):
-        res = await LarkMessageEvent._convert_to_lark(message, self.bot)
-        wrapped = {
-            "zh_cn": {
-                "title": "",
-                "content": res,
-            },
-        }
+    @staticmethod
+    async def send_message_chain(
+        message_chain: MessageChain,
+        lark_client: lark.Client,
+        reply_message_id: str | None = None,
+        receive_id: str | None = None,
+        receive_id_type: str | None = None,
+    ):
+        """通用的消息链发送方法
 
-        request = (
-            ReplyMessageRequest.builder()
-            .message_id(self.message_obj.message_id)
-            .request_body(
-                ReplyMessageRequestBody.builder()
-                .content(json.dumps(wrapped))
-                .msg_type("post")
-                .uuid(str(uuid.uuid4()))
-                .reply_in_thread(False)
-                .build(),
-            )
-            .build()
-        )
-
-        if self.bot.im is None:
-            logger.error("[Lark] API Client im 模块未初始化，无法回复消息")
+        Args:
+            message_chain: 要发送的消息链
+            lark_client: 飞书客户端
+            reply_message_id: 回复的消息ID（用于回复消息）
+            receive_id: 接收者ID（用于主动发送）
+            receive_id_type: 接收者ID类型，如 'open_id', 'chat_id'（用于主动发送）
+        """
+        if lark_client.im is None:
+            logger.error("[Lark] API Client im 模块未初始化")
             return
 
-        response = await self.bot.im.v1.message.areply(request)
+        # 分离文件、音频、视频组件和其他组件
+        file_components: list[File] = []
+        audio_components: list[Record] = []
+        media_components: list[Video] = []
+        other_components = []
 
-        if not response.success():
-            logger.error(f"回复飞书消息失败({response.code}): {response.msg}")
+        for comp in message_chain.chain:
+            if isinstance(comp, File):
+                file_components.append(comp)
+            elif isinstance(comp, Record):
+                audio_components.append(comp)
+            elif isinstance(comp, Video):
+                media_components.append(comp)
+            else:
+                other_components.append(comp)
 
+        # 先发送非文件内容（如果有）
+        if other_components:
+            temp_chain = MessageChain()
+            temp_chain.chain = other_components
+            res = await LarkMessageEvent._convert_to_lark(temp_chain, lark_client)
+
+            if res:  # 只在有内容时发送
+                wrapped = {
+                    "zh_cn": {
+                        "title": "",
+                        "content": res,
+                    },
+                }
+                await LarkMessageEvent._send_im_message(
+                    lark_client,
+                    content=json.dumps(wrapped),
+                    msg_type="post",
+                    reply_message_id=reply_message_id,
+                    receive_id=receive_id,
+                    receive_id_type=receive_id_type,
+                )
+
+        # 发送附件
+        for file_comp in file_components:
+            await LarkMessageEvent._send_file_message(
+                file_comp, lark_client, reply_message_id, receive_id, receive_id_type
+            )
+
+        for audio_comp in audio_components:
+            await LarkMessageEvent._send_audio_message(
+                audio_comp, lark_client, reply_message_id, receive_id, receive_id_type
+            )
+
+        for media_comp in media_components:
+            await LarkMessageEvent._send_media_message(
+                media_comp, lark_client, reply_message_id, receive_id, receive_id_type
+            )
+
+    async def send(self, message: MessageChain):
+        """发送消息链到飞书，然后交给父类做框架级发送/记录"""
+        await LarkMessageEvent.send_message_chain(
+            message,
+            self.bot,
+            reply_message_id=self.message_obj.message_id,
+        )
         await super().send(message)
 
+    @staticmethod
+    async def _send_file_message(
+        file_comp: File,
+        lark_client: lark.Client,
+        reply_message_id: str | None = None,
+        receive_id: str | None = None,
+        receive_id_type: str | None = None,
+    ):
+        """发送文件消息
+
+        Args:
+            file_comp: 文件组件
+            lark_client: 飞书客户端
+            reply_message_id: 回复的消息ID（用于回复消息）
+            receive_id: 接收者ID（用于主动发送）
+            receive_id_type: 接收者ID类型（用于主动发送）
+        """
+        file_path = file_comp.file or ""
+        file_key = await LarkMessageEvent._upload_lark_file(
+            lark_client, path=file_path, file_type="stream"
+        )
+        if not file_key:
+            return
+
+        content = json.dumps({"file_key": file_key})
+        await LarkMessageEvent._send_im_message(
+            lark_client,
+            content=content,
+            msg_type="file",
+            reply_message_id=reply_message_id,
+            receive_id=receive_id,
+            receive_id_type=receive_id_type,
+        )
+
+    @staticmethod
+    async def _send_audio_message(
+        audio_comp: Record,
+        lark_client: lark.Client,
+        reply_message_id: str | None = None,
+        receive_id: str | None = None,
+        receive_id_type: str | None = None,
+    ):
+        """发送音频消息
+
+        Args:
+            audio_comp: 音频组件
+            lark_client: 飞书客户端
+            reply_message_id: 回复的消息ID（用于回复消息）
+            receive_id: 接收者ID（用于主动发送）
+            receive_id_type: 接收者ID类型（用于主动发送）
+        """
+        # 获取音频文件路径
+        try:
+            original_audio_path = await audio_comp.convert_to_file_path()
+        except Exception as e:
+            logger.error(f"[Lark] 无法获取音频文件路径: {e}")
+            return
+
+        if not original_audio_path or not os.path.exists(original_audio_path):
+            logger.error(f"[Lark] 音频文件不存在: {original_audio_path}")
+            return
+
+        # 转换为opus格式
+        converted_audio_path = None
+        try:
+            audio_path = await convert_audio_to_opus(original_audio_path)
+            # 如果转换后路径与原路径不同，说明生成了新文件
+            if audio_path != original_audio_path:
+                converted_audio_path = audio_path
+            else:
+                audio_path = original_audio_path
+        except Exception as e:
+            logger.error(f"[Lark] 音频格式转换失败，将尝试直接上传: {e}")
+            # 如果转换失败，继续尝试直接上传原始文件
+            audio_path = original_audio_path
+
+        # 获取音频时长
+        duration = await get_media_duration(audio_path)
+
+        # 上传音频文件
+        file_key = await LarkMessageEvent._upload_lark_file(
+            lark_client,
+            path=audio_path,
+            file_type="opus",
+            duration=duration,
+        )
+
+        # 清理转换后的临时音频文件
+        if converted_audio_path and os.path.exists(converted_audio_path):
+            try:
+                os.remove(converted_audio_path)
+                logger.debug(f"[Lark] 已删除转换后的音频文件: {converted_audio_path}")
+            except Exception as e:
+                logger.warning(f"[Lark] 删除转换后的音频文件失败: {e}")
+
+        if not file_key:
+            return
+
+        await LarkMessageEvent._send_im_message(
+            lark_client,
+            content=json.dumps({"file_key": file_key}),
+            msg_type="audio",
+            reply_message_id=reply_message_id,
+            receive_id=receive_id,
+            receive_id_type=receive_id_type,
+        )
+
+    @staticmethod
+    async def _send_media_message(
+        media_comp: Video,
+        lark_client: lark.Client,
+        reply_message_id: str | None = None,
+        receive_id: str | None = None,
+        receive_id_type: str | None = None,
+    ):
+        """发送视频消息
+
+        Args:
+            media_comp: 视频组件
+            lark_client: 飞书客户端
+            reply_message_id: 回复的消息ID（用于回复消息）
+            receive_id: 接收者ID（用于主动发送）
+            receive_id_type: 接收者ID类型（用于主动发送）
+        """
+        # 获取视频文件路径
+        try:
+            original_video_path = await media_comp.convert_to_file_path()
+        except Exception as e:
+            logger.error(f"[Lark] 无法获取视频文件路径: {e}")
+            return
+
+        if not original_video_path or not os.path.exists(original_video_path):
+            logger.error(f"[Lark] 视频文件不存在: {original_video_path}")
+            return
+
+        # 转换为mp4格式
+        converted_video_path = None
+        try:
+            video_path = await convert_video_format(original_video_path, "mp4")
+            # 如果转换后路径与原路径不同，说明生成了新文件
+            if video_path != original_video_path:
+                converted_video_path = video_path
+            else:
+                video_path = original_video_path
+        except Exception as e:
+            logger.error(f"[Lark] 视频格式转换失败，将尝试直接上传: {e}")
+            # 如果转换失败，继续尝试直接上传原始文件
+            video_path = original_video_path
+
+        # 获取视频时长
+        duration = await get_media_duration(video_path)
+
+        # 上传视频文件
+        file_key = await LarkMessageEvent._upload_lark_file(
+            lark_client,
+            path=video_path,
+            file_type="mp4",
+            duration=duration,
+        )
+
+        # 清理转换后的临时视频文件
+        if converted_video_path and os.path.exists(converted_video_path):
+            try:
+                os.remove(converted_video_path)
+                logger.debug(f"[Lark] 已删除转换后的视频文件: {converted_video_path}")
+            except Exception as e:
+                logger.warning(f"[Lark] 删除转换后的视频文件失败: {e}")
+
+        if not file_key:
+            return
+
+        await LarkMessageEvent._send_im_message(
+            lark_client,
+            content=json.dumps({"file_key": file_key}),
+            msg_type="media",
+            reply_message_id=reply_message_id,
+            receive_id=receive_id,
+            receive_id_type=receive_id_type,
+        )
+
     async def react(self, emoji: str):
         if self.bot.im is None:
             logger.error("[Lark] API Client im 模块未初始化，无法发送表情")

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

@@ -29,43 +29,11 @@ class QueueListener:
     def __init__(self, webchat_queue_mgr: WebChatQueueMgr, callback: Callable) -> None:
         self.webchat_queue_mgr = webchat_queue_mgr
         self.callback = callback
-        self.running_tasks = set()
-
-    async def listen_to_queue(self, conversation_id: str):
-        """Listen to a specific conversation queue"""
-        queue = self.webchat_queue_mgr.get_or_create_queue(conversation_id)
-        while True:
-            try:
-                data = await queue.get()
-                await self.callback(data)
-            except Exception as e:
-                logger.error(
-                    f"Error processing message from conversation {conversation_id}: {e}",
-                )
-                break
 
     async def run(self):
-        """Monitor for new conversation queues and start listeners"""
-        monitored_conversations = set()
-
-        while True:
-            # Check for new conversations
-            current_conversations = set(self.webchat_queue_mgr.queues.keys())
-            new_conversations = current_conversations - monitored_conversations
-
-            # Start listeners for new conversations
-            for conversation_id in new_conversations:
-                task = asyncio.create_task(self.listen_to_queue(conversation_id))
-                self.running_tasks.add(task)
-                task.add_done_callback(self.running_tasks.discard)
-                monitored_conversations.add(conversation_id)
-                logger.debug(f"Started listener for conversation: {conversation_id}")
-
-            # Clean up monitored conversations that no longer exist
-            removed_conversations = monitored_conversations - current_conversations
-            monitored_conversations -= removed_conversations
-
-            await asyncio.sleep(1)  # Check for new conversations every second
+        """Register callback and keep adapter task alive."""
+        self.webchat_queue_mgr.set_listener(self.callback)
+        await asyncio.Event().wait()
 
 
 @register_platform_adapter("webchat", "webchat")

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

@@ -26,8 +26,12 @@ class WebChatMessageEvent(AstrMessageEvent):
         session_id: str,
         streaming: bool = False,
     ) -> str | None:
-        cid = session_id.split("!")[-1]
-        web_chat_back_queue = webchat_queue_mgr.get_or_create_back_queue(cid)
+        request_id = str(message_id)
+        conversation_id = session_id.split("!")[-1]
+        web_chat_back_queue = webchat_queue_mgr.get_or_create_back_queue(
+            request_id,
+            conversation_id,
+        )
         if not message:
             await web_chat_back_queue.put(
                 {
@@ -124,9 +128,13 @@ class WebChatMessageEvent(AstrMessageEvent):
     async def send_streaming(self, generator, use_fallback: bool = False):
         final_data = ""
         reasoning_content = ""
-        cid = self.session_id.split("!")[-1]
-        web_chat_back_queue = webchat_queue_mgr.get_or_create_back_queue(cid)
         message_id = self.message_obj.message_id
+        request_id = str(message_id)
+        conversation_id = self.session_id.split("!")[-1]
+        web_chat_back_queue = webchat_queue_mgr.get_or_create_back_queue(
+            request_id,
+            conversation_id,
+        )
         async for chain in generator:
             # 处理音频流（Live Mode）
             if chain.type == "audio_chunk":

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

@@ -1,35 +1,147 @@
 import asyncio
+from collections.abc import Awaitable, Callable
+
+from astrbot import logger
 
 
 class WebChatQueueMgr:
-    def __init__(self) -> None:
-        self.queues = {}
+    def __init__(self, queue_maxsize: int = 128, back_queue_maxsize: int = 512) -> None:
+        self.queues: dict[str, asyncio.Queue] = {}
         """Conversation ID to asyncio.Queue mapping"""
-        self.back_queues = {}
-        """Conversation ID to asyncio.Queue mapping for responses"""
+        self.back_queues: dict[str, asyncio.Queue] = {}
+        """Request ID to asyncio.Queue mapping for responses"""
+        self._conversation_back_requests: dict[str, set[str]] = {}
+        self._request_conversation: dict[str, str] = {}
+        self._queue_close_events: dict[str, asyncio.Event] = {}
+        self._listener_tasks: dict[str, asyncio.Task] = {}
+        self._listener_callback: Callable[[tuple], Awaitable[None]] | None = None
+        self.queue_maxsize = queue_maxsize
+        self.back_queue_maxsize = back_queue_maxsize
 
     def get_or_create_queue(self, conversation_id: str) -> asyncio.Queue:
         """Get or create a queue for the given conversation ID"""
         if conversation_id not in self.queues:
-            self.queues[conversation_id] = asyncio.Queue()
+            self.queues[conversation_id] = asyncio.Queue(maxsize=self.queue_maxsize)
+            self._queue_close_events[conversation_id] = asyncio.Event()
+            self._start_listener_if_needed(conversation_id)
         return self.queues[conversation_id]
 
-    def get_or_create_back_queue(self, conversation_id: str) -> asyncio.Queue:
-        """Get or create a back queue for the given conversation ID"""
-        if conversation_id not in self.back_queues:
-            self.back_queues[conversation_id] = asyncio.Queue()
-        return self.back_queues[conversation_id]
+    def get_or_create_back_queue(
+        self,
+        request_id: str,
+        conversation_id: str | None = None,
+    ) -> asyncio.Queue:
+        """Get or create a back queue for the given request ID"""
+        if request_id not in self.back_queues:
+            self.back_queues[request_id] = asyncio.Queue(
+                maxsize=self.back_queue_maxsize
+            )
+        if conversation_id:
+            self._request_conversation[request_id] = conversation_id
+            if conversation_id not in self._conversation_back_requests:
+                self._conversation_back_requests[conversation_id] = set()
+            self._conversation_back_requests[conversation_id].add(request_id)
+        return self.back_queues[request_id]
+
+    def remove_back_queue(self, request_id: str):
+        """Remove back queue for the given request ID"""
+        self.back_queues.pop(request_id, None)
+        conversation_id = self._request_conversation.pop(request_id, None)
+        if conversation_id:
+            request_ids = self._conversation_back_requests.get(conversation_id)
+            if request_ids is not None:
+                request_ids.discard(request_id)
+                if not request_ids:
+                    self._conversation_back_requests.pop(conversation_id, None)
 
     def remove_queues(self, conversation_id: str):
         """Remove queues for the given conversation ID"""
-        if conversation_id in self.queues:
-            del self.queues[conversation_id]
-        if conversation_id in self.back_queues:
-            del self.back_queues[conversation_id]
+        for request_id in list(
+            self._conversation_back_requests.get(conversation_id, set())
+        ):
+            self.remove_back_queue(request_id)
+        self._conversation_back_requests.pop(conversation_id, None)
+        self.remove_queue(conversation_id)
+
+    def remove_queue(self, conversation_id: str):
+        """Remove input queue and listener for the given conversation ID"""
+        self.queues.pop(conversation_id, None)
+
+        close_event = self._queue_close_events.pop(conversation_id, None)
+        if close_event is not None:
+            close_event.set()
+
+        task = self._listener_tasks.pop(conversation_id, None)
+        if task is not None:
+            task.cancel()
 
     def has_queue(self, conversation_id: str) -> bool:
         """Check if a queue exists for the given conversation ID"""
         return conversation_id in self.queues
 
+    def set_listener(
+        self,
+        callback: Callable[[tuple], Awaitable[None]],
+    ):
+        self._listener_callback = callback
+        for conversation_id in list(self.queues.keys()):
+            self._start_listener_if_needed(conversation_id)
+
+    def _start_listener_if_needed(self, conversation_id: str):
+        if self._listener_callback is None:
+            return
+        if conversation_id in self._listener_tasks:
+            task = self._listener_tasks[conversation_id]
+            if not task.done():
+                return
+        queue = self.queues.get(conversation_id)
+        close_event = self._queue_close_events.get(conversation_id)
+        if queue is None or close_event is None:
+            return
+        task = asyncio.create_task(
+            self._listen_to_queue(conversation_id, queue, close_event),
+            name=f"webchat_listener_{conversation_id}",
+        )
+        self._listener_tasks[conversation_id] = task
+        task.add_done_callback(
+            lambda _: self._listener_tasks.pop(conversation_id, None)
+        )
+        logger.debug(f"Started listener for conversation: {conversation_id}")
+
+    async def _listen_to_queue(
+        self,
+        conversation_id: str,
+        queue: asyncio.Queue,
+        close_event: asyncio.Event,
+    ):
+        while True:
+            get_task = asyncio.create_task(queue.get())
+            close_task = asyncio.create_task(close_event.wait())
+            try:
+                done, pending = await asyncio.wait(
+                    {get_task, close_task},
+                    return_when=asyncio.FIRST_COMPLETED,
+                )
+                for task in pending:
+                    task.cancel()
+                if close_task in done:
+                    break
+                data = get_task.result()
+                if self._listener_callback is None:
+                    continue
+                try:
+                    await self._listener_callback(data)
+                except Exception as e:
+                    logger.error(
+                        f"Error processing message from conversation {conversation_id}: {e}"
+                    )
+            except asyncio.CancelledError:
+                break
+            finally:
+                if not get_task.done():
+                    get_task.cancel()
+                if not close_task.done():
+                    close_task.cancel()
+
 
 webchat_queue_mgr = WebChatQueueMgr()

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

@@ -51,44 +51,13 @@ class WecomAIQueueListener:
     ) -> None:
         self.queue_mgr = queue_mgr
         self.callback = callback
-        self.running_tasks = set()
-
-    async def listen_to_queue(self, session_id: str):
-        """监听特定会话的队列"""
-        queue = self.queue_mgr.get_or_create_queue(session_id)
-        while True:
-            try:
-                data = await queue.get()
-                await self.callback(data)
-            except Exception as e:
-                logger.error(f"处理会话 {session_id} 消息时发生错误: {e}")
-                break
 
     async def run(self):
-        """监控新会话队列并启动监听器"""
-        monitored_sessions = set()
-
+        """注册监听回调并定期清理过期响应。"""
+        self.queue_mgr.set_listener(self.callback)
         while True:
-            # 检查新会话
-            current_sessions = set(self.queue_mgr.queues.keys())
-            new_sessions = current_sessions - monitored_sessions
-
-            # 为新会话启动监听器
-            for session_id in new_sessions:
-                task = asyncio.create_task(self.listen_to_queue(session_id))
-                self.running_tasks.add(task)
-                task.add_done_callback(self.running_tasks.discard)
-                monitored_sessions.add(session_id)
-                logger.debug(f"[WecomAI] 为会话启动监听器: {session_id}")
-
-            # 清理已不存在的会话
-            removed_sessions = monitored_sessions - current_sessions
-            monitored_sessions -= removed_sessions
-
-            # 清理过期的待处理响应
             self.queue_mgr.cleanup_expired_responses()
-
-            await asyncio.sleep(1)  # 每秒检查一次新会话
+            await asyncio.sleep(1)
 
 
 @register_platform_adapter(
@@ -212,7 +181,12 @@ class WecomAIBotAdapter(Platform):
             # wechat server is requesting for updates of a stream
             stream_id = message_data["stream"]["id"]
             if not self.queue_mgr.has_back_queue(stream_id):
-                logger.error(f"Cannot find back queue for stream_id: {stream_id}")
+                if self.queue_mgr.is_stream_finished(stream_id):
+                    logger.debug(
+                        f"Stream already finished, returning end message: {stream_id}"
+                    )
+                else:
+                    logger.warning(f"Cannot find back queue for stream_id: {stream_id}")
 
                 # 返回结束标志，告诉微信服务器流已结束
                 end_message = WecomAIBotStreamMessageBuilder.make_text_stream(
@@ -243,10 +217,10 @@ class WecomAIBotAdapter(Platform):
                     latest_plain_content = msg["data"] or ""
                 elif msg["type"] == "image":
                     image_base64.append(msg["image_data"])
-                elif msg["type"] == "end":
+                elif msg["type"] in {"end", "complete"}:
                     # stream end
                     finish = True
-                    self.queue_mgr.remove_queues(stream_id)
+                    self.queue_mgr.remove_queues(stream_id, mark_finished=True)
                     break
 
             logger.debug(

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

@@ -4,6 +4,7 @@
 """
 
 import asyncio
+from collections.abc import Awaitable, Callable
 from typing import Any
 
 from astrbot.api import logger
@@ -12,7 +13,7 @@ from astrbot.api import logger
 class WecomAIQueueMgr:
     """企业微信智能机器人队列管理器"""
 
-    def __init__(self) -> None:
+    def __init__(self, queue_maxsize: int = 128, back_queue_maxsize: int = 512) -> None:
         self.queues: dict[str, asyncio.Queue] = {}
         """StreamID 到输入队列的映射 - 用于接收用户消息"""
 
@@ -21,6 +22,13 @@ class WecomAIQueueMgr:
 
         self.pending_responses: dict[str, dict[str, Any]] = {}
         """待处理的响应缓存，用于流式响应"""
+        self.completed_streams: dict[str, float] = {}
+        """已结束的 stream 缓存，用于兼容平台后续重复轮询"""
+        self._queue_close_events: dict[str, asyncio.Event] = {}
+        self._listener_tasks: dict[str, asyncio.Task] = {}
+        self._listener_callback: Callable[[dict], Awaitable[None]] | None = None
+        self.queue_maxsize = queue_maxsize
+        self.back_queue_maxsize = back_queue_maxsize
 
     def get_or_create_queue(self, session_id: str) -> asyncio.Queue:
         """获取或创建指定会话的输入队列
@@ -33,7 +41,9 @@ class WecomAIQueueMgr:
 
         """
         if session_id not in self.queues:
-            self.queues[session_id] = asyncio.Queue()
+            self.queues[session_id] = asyncio.Queue(maxsize=self.queue_maxsize)
+            self._queue_close_events[session_id] = asyncio.Event()
+            self._start_listener_if_needed(session_id)
             logger.debug(f"[WecomAI] 创建输入队列: {session_id}")
         return self.queues[session_id]
 
@@ -48,20 +58,21 @@ class WecomAIQueueMgr:
 
         """
         if session_id not in self.back_queues:
-            self.back_queues[session_id] = asyncio.Queue()
+            self.back_queues[session_id] = asyncio.Queue(
+                maxsize=self.back_queue_maxsize
+            )
             logger.debug(f"[WecomAI] 创建输出队列: {session_id}")
         return self.back_queues[session_id]
 
-    def remove_queues(self, session_id: str):
+    def remove_queues(self, session_id: str, mark_finished: bool = False):
         """移除指定会话的所有队列
 
         Args:
             session_id: 会话ID
+            mark_finished: 是否标记为已正常结束
 
         """
-        if session_id in self.queues:
-            del self.queues[session_id]
-            logger.debug(f"[WecomAI] 移除输入队列: {session_id}")
+        self.remove_queue(session_id)
 
         if session_id in self.back_queues:
             del self.back_queues[session_id]
@@ -70,6 +81,23 @@ class WecomAIQueueMgr:
         if session_id in self.pending_responses:
             del self.pending_responses[session_id]
             logger.debug(f"[WecomAI] 移除待处理响应: {session_id}")
+        if mark_finished:
+            self.completed_streams[session_id] = asyncio.get_event_loop().time()
+            logger.debug(f"[WecomAI] 标记流已结束: {session_id}")
+
+    def remove_queue(self, session_id: str):
+        """仅移除输入队列和对应监听任务"""
+        if session_id in self.queues:
+            del self.queues[session_id]
+            logger.debug(f"[WecomAI] 移除输入队列: {session_id}")
+
+        close_event = self._queue_close_events.pop(session_id, None)
+        if close_event is not None:
+            close_event.set()
+
+        task = self._listener_tasks.pop(session_id, None)
+        if task is not None:
+            task.cancel()
 
     def has_queue(self, session_id: str) -> bool:
         """检查是否存在指定会话的队列
@@ -121,6 +149,20 @@ class WecomAIQueueMgr:
         """
         return self.pending_responses.get(session_id)
 
+    def is_stream_finished(
+        self,
+        session_id: str,
+        max_age_seconds: int = 60,
+    ) -> bool:
+        """判断 stream 是否在短期内已结束"""
+        finished_at = self.completed_streams.get(session_id)
+        if finished_at is None:
+            return False
+        if asyncio.get_event_loop().time() - finished_at > max_age_seconds:
+            self.completed_streams.pop(session_id, None)
+            return False
+        return True
+
     def cleanup_expired_responses(self, max_age_seconds: int = 300):
         """清理过期的待处理响应
 
@@ -136,8 +178,75 @@ class WecomAIQueueMgr:
                 expired_sessions.append(session_id)
 
         for session_id in expired_sessions:
-            del self.pending_responses[session_id]
-            logger.debug(f"[WecomAI] 清理过期响应: {session_id}")
+            self.remove_queues(session_id)
+            logger.debug(f"[WecomAI] 清理过期响应及队列: {session_id}")
+        expired_finished = [
+            session_id
+            for session_id, finished_at in self.completed_streams.items()
+            if current_time - finished_at > 60
+        ]
+        for session_id in expired_finished:
+            self.completed_streams.pop(session_id, None)
+
+    def set_listener(
+        self,
+        callback: Callable[[dict], Awaitable[None]],
+    ):
+        self._listener_callback = callback
+        for session_id in list(self.queues.keys()):
+            self._start_listener_if_needed(session_id)
+
+    def _start_listener_if_needed(self, session_id: str):
+        if self._listener_callback is None:
+            return
+        if session_id in self._listener_tasks:
+            task = self._listener_tasks[session_id]
+            if not task.done():
+                return
+        queue = self.queues.get(session_id)
+        close_event = self._queue_close_events.get(session_id)
+        if queue is None or close_event is None:
+            return
+        task = asyncio.create_task(
+            self._listen_to_queue(session_id, queue, close_event),
+            name=f"wecomai_listener_{session_id}",
+        )
+        self._listener_tasks[session_id] = task
+        task.add_done_callback(lambda _: self._listener_tasks.pop(session_id, None))
+        logger.debug(f"[WecomAI] 为会话启动监听器: {session_id}")
+
+    async def _listen_to_queue(
+        self,
+        session_id: str,
+        queue: asyncio.Queue,
+        close_event: asyncio.Event,
+    ):
+        while True:
+            get_task = asyncio.create_task(queue.get())
+            close_task = asyncio.create_task(close_event.wait())
+            try:
+                done, pending = await asyncio.wait(
+                    {get_task, close_task},
+                    return_when=asyncio.FIRST_COMPLETED,
+                )
+                for task in pending:
+                    task.cancel()
+                if close_task in done:
+                    break
+                data = get_task.result()
+                if self._listener_callback is None:
+                    continue
+                try:
+                    await self._listener_callback(data)
+                except Exception as e:
+                    logger.error(f"处理会话 {session_id} 消息时发生错误: {e}")
+            except asyncio.CancelledError:
+                break
+            finally:
+                if not get_task.done():
+                    get_task.cancel()
+                if not close_task.done():
+                    close_task.cancel()
 
     def get_stats(self) -> dict[str, int]:
         """获取队列统计信息

astrbot/core/provider/sources/fishaudio_tts_api_source.py

@@ -63,7 +63,7 @@ class ProviderFishAudioTTSAPI(TTSProvider):
         self.headers = {
             "Authorization": f"Bearer {self.chosen_api_key}",
         }
-        self.set_model(provider_config.get("model", None))
+        self.set_model(provider_config.get("model", ""))
 
     async def _get_reference_id_by_character(self, character: str) -> str | None:
         """获取角色的reference_id

astrbot/core/star/filter/custom_filter.py

@@ -37,9 +37,9 @@ class CustomFilter(HandlerFilter, metaclass=CustomFilterMeta):
 class CustomFilterOr(CustomFilter):
     def __init__(self, filter1: CustomFilter, filter2: CustomFilter):
         super().__init__()
-        if not isinstance(filter1, CustomFilter | CustomFilterAnd | CustomFilterOr):
+        if not isinstance(filter1, (CustomFilter, CustomFilterAnd, CustomFilterOr)):
             raise ValueError(
-                "CustomFilter lass can only operate with other CustomFilter.",
+                "CustomFilter class can only operate with other CustomFilter.",
             )
         self.filter1 = filter1
         self.filter2 = filter2
@@ -51,7 +51,7 @@ class CustomFilterOr(CustomFilter):
 class CustomFilterAnd(CustomFilter):
     def __init__(self, filter1: CustomFilter, filter2: CustomFilter):
         super().__init__()
-        if not isinstance(filter1, CustomFilter | CustomFilterAnd | CustomFilterOr):
+        if not isinstance(filter1, (CustomFilter, CustomFilterAnd, CustomFilterOr)):
             raise ValueError(
                 "CustomFilter lass can only operate with other CustomFilter.",
             )

astrbot/core/star/register/star_handler.py

@@ -150,7 +150,7 @@ def register_custom_filter(custom_type_filter, *args, **kwargs):
         if args:
             raise_error = args[0]
 
-    if not isinstance(custom_filter, CustomFilterAnd | CustomFilterOr):
+    if not isinstance(custom_filter, (CustomFilterAnd, CustomFilterOr)):
         custom_filter = custom_filter(raise_error)
 
     def decorator(awaitable):

astrbot/core/star/star_manager.py

@@ -15,6 +15,7 @@ import yaml
 from astrbot.core import logger, pip_installer, sp
 from astrbot.core.agent.handoff import FunctionTool, HandoffTool
 from astrbot.core.config.astrbot_config import AstrBotConfig
+from astrbot.core.platform.register import unregister_platform_adapters_by_module
 from astrbot.core.provider.register import llm_tools
 from astrbot.core.utils.astrbot_path import (
     get_astrbot_config_path,
@@ -842,6 +843,18 @@ class PluginManager:
         for func_tool in to_remove:
             llm_tools.func_list.remove(func_tool)
 
+        # Unregister platform adapters registered by this plugin
+        # module_path is like "data.plugins.my_plugin.main", extract prefix like "data.plugins.my_plugin"
+        module_prefix = ".".join(plugin_module_path.split(".")[:-1])
+        if module_prefix:
+            unregistered_adapters = unregister_platform_adapters_by_module(
+                module_prefix
+            )
+            for adapter_name in unregistered_adapters:
+                logger.info(
+                    f"移除了插件 {plugin_name} 的平台适配器 {adapter_name}",
+                )
+
         if plugin is None:
             return
 

astrbot/core/utils/media_utils.py

@@ -0,0 +1,207 @@
+"""媒体文件处理工具
+
+提供音视频格式转换、时长获取等功能。
+"""
+
+import asyncio
+import os
+import subprocess
+import uuid
+
+from astrbot import logger
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path
+
+
+async def get_media_duration(file_path: str) -> int | None:
+    """使用ffprobe获取媒体文件时长
+
+    Args:
+        file_path: 媒体文件路径
+
+    Returns:
+        时长（毫秒），如果获取失败返回None
+    """
+    try:
+        # 使用ffprobe获取时长
+        process = await asyncio.create_subprocess_exec(
+            "ffprobe",
+            "-v",
+            "error",
+            "-show_entries",
+            "format=duration",
+            "-of",
+            "default=noprint_wrappers=1:nokey=1",
+            file_path,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        stdout, stderr = await process.communicate()
+
+        if process.returncode == 0 and stdout:
+            duration_seconds = float(stdout.decode().strip())
+            duration_ms = int(duration_seconds * 1000)
+            logger.debug(f"[Media Utils] 获取媒体时长: {duration_ms}ms")
+            return duration_ms
+        else:
+            logger.warning(f"[Media Utils] 无法获取媒体文件时长: {file_path}")
+            return None
+
+    except FileNotFoundError:
+        logger.warning(
+            "[Media Utils] ffprobe未安装或不在PATH中，无法获取媒体时长。请安装ffmpeg: https://ffmpeg.org/"
+        )
+        return None
+    except Exception as e:
+        logger.warning(f"[Media Utils] 获取媒体时长时出错: {e}")
+        return None
+
+
+async def convert_audio_to_opus(audio_path: str, output_path: str | None = None) -> str:
+    """使用ffmpeg将音频转换为opus格式
+
+    Args:
+        audio_path: 原始音频文件路径
+        output_path: 输出文件路径，如果为None则自动生成
+
+    Returns:
+        转换后的opus文件路径
+
+    Raises:
+        Exception: 转换失败时抛出异常
+    """
+    # 如果已经是opus格式，直接返回
+    if audio_path.lower().endswith(".opus"):
+        return audio_path
+
+    # 生成输出文件路径
+    if output_path is None:
+        temp_dir = os.path.join(get_astrbot_data_path(), "temp")
+        os.makedirs(temp_dir, exist_ok=True)
+        output_path = os.path.join(temp_dir, f"{uuid.uuid4()}.opus")
+
+    try:
+        # 使用ffmpeg转换为opus格式
+        # -y: 覆盖输出文件
+        # -i: 输入文件
+        # -acodec libopus: 使用opus编码器
+        # -ac 1: 单声道
+        # -ar 16000: 采样率16kHz
+        process = await asyncio.create_subprocess_exec(
+            "ffmpeg",
+            "-y",
+            "-i",
+            audio_path,
+            "-acodec",
+            "libopus",
+            "-ac",
+            "1",
+            "-ar",
+            "16000",
+            output_path,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        stdout, stderr = await process.communicate()
+
+        if process.returncode != 0:
+            # 清理可能已生成但无效的临时文件
+            if output_path and os.path.exists(output_path):
+                try:
+                    os.remove(output_path)
+                    logger.debug(
+                        f"[Media Utils] 已清理失败的opus输出文件: {output_path}"
+                    )
+                except OSError as e:
+                    logger.warning(f"[Media Utils] 清理失败的opus输出文件时出错: {e}")
+
+            error_msg = stderr.decode() if stderr else "未知错误"
+            logger.error(f"[Media Utils] ffmpeg转换音频失败: {error_msg}")
+            raise Exception(f"ffmpeg conversion failed: {error_msg}")
+
+        logger.debug(f"[Media Utils] 音频转换成功: {audio_path} -> {output_path}")
+        return output_path
+
+    except FileNotFoundError:
+        logger.error(
+            "[Media Utils] ffmpeg未安装或不在PATH中，无法转换音频格式。请安装ffmpeg: https://ffmpeg.org/"
+        )
+        raise Exception("ffmpeg not found")
+    except Exception as e:
+        logger.error(f"[Media Utils] 转换音频格式时出错: {e}")
+        raise
+
+
+async def convert_video_format(
+    video_path: str, output_format: str = "mp4", output_path: str | None = None
+) -> str:
+    """使用ffmpeg转换视频格式
+
+    Args:
+        video_path: 原始视频文件路径
+        output_format: 目标格式，默认mp4
+        output_path: 输出文件路径，如果为None则自动生成
+
+    Returns:
+        转换后的视频文件路径
+
+    Raises:
+        Exception: 转换失败时抛出异常
+    """
+    # 如果已经是目标格式，直接返回
+    if video_path.lower().endswith(f".{output_format}"):
+        return video_path
+
+    # 生成输出文件路径
+    if output_path is None:
+        temp_dir = os.path.join(get_astrbot_data_path(), "temp")
+        os.makedirs(temp_dir, exist_ok=True)
+        output_path = os.path.join(temp_dir, f"{uuid.uuid4()}.{output_format}")
+
+    try:
+        # 使用ffmpeg转换视频格式
+        process = await asyncio.create_subprocess_exec(
+            "ffmpeg",
+            "-y",
+            "-i",
+            video_path,
+            "-c:v",
+            "libx264",
+            "-c:a",
+            "aac",
+            output_path,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        stdout, stderr = await process.communicate()
+
+        if process.returncode != 0:
+            # 清理可能已生成但无效的临时文件
+            if output_path and os.path.exists(output_path):
+                try:
+                    os.remove(output_path)
+                    logger.debug(
+                        f"[Media Utils] 已清理失败的{output_format}输出文件: {output_path}"
+                    )
+                except OSError as e:
+                    logger.warning(
+                        f"[Media Utils] 清理失败的{output_format}输出文件时出错: {e}"
+                    )
+
+            error_msg = stderr.decode() if stderr else "未知错误"
+            logger.error(f"[Media Utils] ffmpeg转换视频失败: {error_msg}")
+            raise Exception(f"ffmpeg conversion failed: {error_msg}")
+
+        logger.debug(f"[Media Utils] 视频转换成功: {video_path} -> {output_path}")
+        return output_path
+
+    except FileNotFoundError:
+        logger.error(
+            "[Media Utils] ffmpeg未安装或不在PATH中，无法转换视频格式。请安装ffmpeg: https://ffmpeg.org/"
+        )
+        raise Exception("ffmpeg not found")
+    except Exception as e:
+        logger.error(f"[Media Utils] 转换视频格式时出错: {e}")
+        raise

astrbot/core/utils/shared_preferences.py

@@ -23,7 +23,7 @@ class SharedPreferences:
             )
         self.path = json_storage_path
         self.db_helper = db_helper
-        self.temorary_cache: dict[str, dict[str, Any]] = defaultdict(dict)
+        self.temporary_cache: dict[str, dict[str, Any]] = defaultdict(dict)
         """automatically clear per 24 hours. Might be helpful in some cases XD"""
 
         self._sync_loop = asyncio.new_event_loop()
@@ -37,7 +37,7 @@ class SharedPreferences:
         self._scheduler.start()
 
     def _clear_temporary_cache(self):
-        self.temorary_cache.clear()
+        self.temporary_cache.clear()
 
     async def get_async(
         self,

astrbot/dashboard/routes/chat.py

@@ -238,6 +238,7 @@ class ChatRoute(Route):
         Returns:
             包含 used 列表的字典，记录被引用的搜索结果
         """
+        supported = ["web_search_tavily", "web_search_bocha"]
         # 从 accumulated_parts 中找到所有 web_search_tavily 的工具调用结果
         web_search_results = {}
         tool_call_parts = [
@@ -248,7 +249,7 @@ class ChatRoute(Route):
 
         for part in tool_call_parts:
             for tool_call in part["tool_calls"]:
-                if tool_call.get("name") != "web_search_tavily" or not tool_call.get(
+                if tool_call.get("name") not in supported or not tool_call.get(
                     "result"
                 ):
                     continue
@@ -278,7 +279,7 @@ class ChatRoute(Route):
             if ref_index not in web_search_results:
                 continue
             payload = {"index": ref_index, **web_search_results[ref_index]}
-            if favicon := sp.temorary_cache.get("_ws_favicon", {}).get(payload["url"]):
+            if favicon := sp.temporary_cache.get("_ws_favicon", {}).get(payload["url"]):
                 payload["favicon"] = favicon
             used_refs.append(payload)
 
@@ -353,12 +354,15 @@ class ChatRoute(Route):
             return Response().error("session_id is empty").__dict__
 
         webchat_conv_id = session_id
-        back_queue = webchat_queue_mgr.get_or_create_back_queue(webchat_conv_id)
 
         # 构建用户消息段（包含 path 用于传递给 adapter）
         message_parts = await self._build_user_message_parts(message)
 
         message_id = str(uuid.uuid4())
+        back_queue = webchat_queue_mgr.get_or_create_back_queue(
+            message_id,
+            webchat_conv_id,
+        )
 
         async def stream():
             client_disconnected = False
@@ -531,6 +535,8 @@ class ChatRoute(Route):
                             refs = {}
             except BaseException as e:
                 logger.exception(f"WebChat stream unexpected error: {e}", exc_info=True)
+            finally:
+                webchat_queue_mgr.remove_back_queue(message_id)
 
         # 将消息放入会话特定的队列
         chat_queue = webchat_queue_mgr.get_or_create_queue(webchat_conv_id)

astrbot/dashboard/routes/cron.py

@@ -23,7 +23,7 @@ class CronRoute(Route):
         ]
         self.register_routes()
 
-    def _serialize_job(self, job):
+    def _serialize_job(self, job) -> dict:
         data = job.model_dump() if hasattr(job, "model_dump") else job.__dict__
         for k in ["created_at", "updated_at", "last_run_at", "next_run_time"]:
             if isinstance(data.get(k), datetime):

astrbot/dashboard/routes/knowledge_base.py

@@ -4,6 +4,7 @@ import asyncio
 import os
 import traceback
 import uuid
+from typing import Any
 
 import aiofiles
 from quart import request
@@ -75,7 +76,7 @@ class KnowledgeBaseRoute(Route):
         }
 
     def _set_task_result(
-        self, task_id: str, status: str, result: any = None, error: str | None = None
+        self, task_id: str, status: str, result: Any = None, error: str | None = None
     ) -> None:
         self.upload_tasks[task_id] = {
             "status": status,

astrbot/dashboard/routes/live_chat.py

@@ -256,143 +256,148 @@ class LiveChatRoute(Route):
             await queue.put((session.username, cid, payload))
 
             # 3. 等待响应并流式发送 TTS 音频
-            back_queue = webchat_queue_mgr.get_or_create_back_queue(cid)
+            back_queue = webchat_queue_mgr.get_or_create_back_queue(message_id, cid)
 
             bot_text = ""
             audio_playing = False
 
-            while True:
-                if session.should_interrupt:
-                    # 用户打断，停止处理
-                    logger.info("[Live Chat] 检测到用户打断")
-                    await websocket.send_json({"t": "stop_play"})
-                    # 保存消息并标记为被打断
-                    await self._save_interrupted_message(session, user_text, bot_text)
-                    # 清空队列中未处理的消息
-                    while not back_queue.empty():
+            try:
+                while True:
+                    if session.should_interrupt:
+                        # 用户打断，停止处理
+                        logger.info("[Live Chat] 检测到用户打断")
+                        await websocket.send_json({"t": "stop_play"})
+                        # 保存消息并标记为被打断
+                        await self._save_interrupted_message(
+                            session, user_text, bot_text
+                        )
+                        # 清空队列中未处理的消息
+                        while not back_queue.empty():
+                            try:
+                                back_queue.get_nowait()
+                            except asyncio.QueueEmpty:
+                                break
+                        break
+
+                    try:
+                        result = await asyncio.wait_for(back_queue.get(), timeout=0.5)
+                    except asyncio.TimeoutError:
+                        continue
+
+                    if not result:
+                        continue
+
+                    result_message_id = result.get("message_id")
+                    if result_message_id != message_id:
+                        logger.warning(
+                            f"[Live Chat] 消息 ID 不匹配: {result_message_id} != {message_id}"
+                        )
+                        continue
+
+                    result_type = result.get("type")
+                    result_chain_type = result.get("chain_type")
+                    data = result.get("data", "")
+
+                    if result_chain_type == "agent_stats":
                         try:
-                            back_queue.get_nowait()
-                        except asyncio.QueueEmpty:
-                            break
-                    break
+                            stats = json.loads(data)
+                            await websocket.send_json(
+                                {
+                                    "t": "metrics",
+                                    "data": {
+                                        "llm_ttft": stats.get("time_to_first_token", 0),
+                                        "llm_total_time": stats.get("end_time", 0)
+                                        - stats.get("start_time", 0),
+                                    },
+                                }
+                            )
+                        except Exception as e:
+                            logger.error(f"[Live Chat] 解析 AgentStats 失败: {e}")
+                        continue
 
-                try:
-                    result = await asyncio.wait_for(back_queue.get(), timeout=0.5)
-                except asyncio.TimeoutError:
-                    continue
+                    if result_chain_type == "tts_stats":
+                        try:
+                            stats = json.loads(data)
+                            await websocket.send_json(
+                                {
+                                    "t": "metrics",
+                                    "data": stats,
+                                }
+                            )
+                        except Exception as e:
+                            logger.error(f"[Live Chat] 解析 TTSStats 失败: {e}")
+                        continue
 
-                if not result:
-                    continue
+                    if result_type == "plain":
+                        # 普通文本消息
+                        bot_text += data
 
-                result_message_id = result.get("message_id")
-                if result_message_id != message_id:
-                    logger.warning(
-                        f"[Live Chat] 消息 ID 不匹配: {result_message_id} != {message_id}"
-                    )
-                    continue
+                    elif result_type == "audio_chunk":
+                        # 流式音频数据
+                        if not audio_playing:
+                            audio_playing = True
+                            logger.debug("[Live Chat] 开始播放音频流")
 
-                result_type = result.get("type")
-                result_chain_type = result.get("chain_type")
-                data = result.get("data", "")
+                            # Calculate latency from wav assembly finish to first audio chunk
+                            speak_to_first_frame_latency = (
+                                time.time() - wav_assembly_finish_time
+                            )
+                            await websocket.send_json(
+                                {
+                                    "t": "metrics",
+                                    "data": {
+                                        "speak_to_first_frame": speak_to_first_frame_latency
+                                    },
+                                }
+                            )
 
-                if result_chain_type == "agent_stats":
-                    try:
-                        stats = json.loads(data)
+                        text = result.get("text")
+                        if text:
+                            await websocket.send_json(
+                                {
+                                    "t": "bot_text_chunk",
+                                    "data": {"text": text},
+                                }
+                            )
+
+                        # 发送音频数据给前端
+                        await websocket.send_json(
+                            {
+                                "t": "response",
+                                "data": data,  # base64 编码的音频数据
+                            }
+                        )
+
+                    elif result_type in ["complete", "end"]:
+                        # 处理完成
+                        logger.info(f"[Live Chat] Bot 回复完成: {bot_text}")
+
+                        # 如果没有音频流，发送 bot 消息文本
+                        if not audio_playing:
+                            await websocket.send_json(
+                                {
+                                    "t": "bot_msg",
+                                    "data": {
+                                        "text": bot_text,
+                                        "ts": int(time.time() * 1000),
+                                    },
+                                }
+                            )
+
+                        # 发送结束标记
+                        await websocket.send_json({"t": "end"})
+
+                        # 发送总耗时
+                        wav_to_tts_duration = time.time() - wav_assembly_finish_time
                         await websocket.send_json(
                             {
                                 "t": "metrics",
-                                "data": {
-                                    "llm_ttft": stats.get("time_to_first_token", 0),
-                                    "llm_total_time": stats.get("end_time", 0)
-                                    - stats.get("start_time", 0),
-                                },
+                                "data": {"wav_to_tts_total_time": wav_to_tts_duration},
                             }
                         )
-                    except Exception as e:
-                        logger.error(f"[Live Chat] 解析 AgentStats 失败: {e}")
-                    continue
-
-                if result_chain_type == "tts_stats":
-                    try:
-                        stats = json.loads(data)
-                        await websocket.send_json(
-                            {
-                                "t": "metrics",
-                                "data": stats,
-                            }
-                        )
-                    except Exception as e:
-                        logger.error(f"[Live Chat] 解析 TTSStats 失败: {e}")
-                    continue
-
-                if result_type == "plain":
-                    # 普通文本消息
-                    bot_text += data
-
-                elif result_type == "audio_chunk":
-                    # 流式音频数据
-                    if not audio_playing:
-                        audio_playing = True
-                        logger.debug("[Live Chat] 开始播放音频流")
-
-                        # Calculate latency from wav assembly finish to first audio chunk
-                        speak_to_first_frame_latency = (
-                            time.time() - wav_assembly_finish_time
-                        )
-                        await websocket.send_json(
-                            {
-                                "t": "metrics",
-                                "data": {
-                                    "speak_to_first_frame": speak_to_first_frame_latency
-                                },
-                            }
-                        )
-
-                    text = result.get("text")
-                    if text:
-                        await websocket.send_json(
-                            {
-                                "t": "bot_text_chunk",
-                                "data": {"text": text},
-                            }
-                        )
-
-                    # 发送音频数据给前端
-                    await websocket.send_json(
-                        {
-                            "t": "response",
-                            "data": data,  # base64 编码的音频数据
-                        }
-                    )
-
-                elif result_type in ["complete", "end"]:
-                    # 处理完成
-                    logger.info(f"[Live Chat] Bot 回复完成: {bot_text}")
-
-                    # 如果没有音频流，发送 bot 消息文本
-                    if not audio_playing:
-                        await websocket.send_json(
-                            {
-                                "t": "bot_msg",
-                                "data": {
-                                    "text": bot_text,
-                                    "ts": int(time.time() * 1000),
-                                },
-                            }
-                        )
-
-                    # 发送结束标记
-                    await websocket.send_json({"t": "end"})
-
-                    # 发送总耗时
-                    wav_to_tts_duration = time.time() - wav_assembly_finish_time
-                    await websocket.send_json(
-                        {
-                            "t": "metrics",
-                            "data": {"wav_to_tts_total_time": wav_to_tts_duration},
-                        }
-                    )
-                    break
+                        break
+            finally:
+                webchat_queue_mgr.remove_back_queue(message_id)
 
         except Exception as e:
             logger.error(f"[Live Chat] 处理音频失败: {e}", exc_info=True)

astrbot/dashboard/routes/plugin.py

@@ -315,6 +315,17 @@ class PluginRoute(Route):
                 "display_name": plugin.display_name,
                 "logo": f"/api/file/{logo_url}" if logo_url else None,
             }
+            # 检查是否为全空的幽灵插件
+            if not any(
+                [
+                    plugin.name,
+                    plugin.author,
+                    plugin.desc,
+                    plugin.version,
+                    plugin.display_name,
+                ]
+            ):
+                continue
             _plugin_resp.append(_t)
         return (
             Response()

astrbot/dashboard/server.py

@@ -2,14 +2,13 @@ import asyncio
 import logging
 import os
 import socket
-from typing import cast
+from typing import Protocol, cast
 
 import jwt
 import psutil
 from flask.json.provider import DefaultJSONProvider
 from hypercorn.asyncio import serve
 from hypercorn.config import Config as HyperConfig
-from psutil._common import addr as psutil_addr
 from quart import Quart, g, jsonify, request
 from quart.logging import default_handler
 
@@ -29,6 +28,11 @@ from .routes.session_management import SessionManagementRoute
 from .routes.subagent import SubAgentRoute
 from .routes.t2i import T2iRoute
 
+
+class _AddrWithPort(Protocol):
+    port: int
+
+
 APP: Quart
 
 
@@ -168,7 +172,7 @@ class AstrBotDashboard:
         """获取占用端口的进程详细信息"""
         try:
             for conn in psutil.net_connections(kind="inet"):
-                if cast(psutil_addr, conn.laddr).port == port:
+                if cast(_AddrWithPort, conn.laddr).port == port:
                     try:
                         process = psutil.Process(conn.pid)
                         # 获取详细信息

changelogs/v4.14.0.md

@@ -0,0 +1,72 @@
+## What's Changed - BIG AND BEAUTIFUL VERSION
+
+> 如果在之前版本使用了 Skill，这次更新之后**需要重新配置** Skill Runtime 相关选项。
+
+### 新增
+- 🔥 新增未来任务系统（Future Tasks）。给 AstrBot 布置的未来任务，让 AstrBot 能够在某一时刻自动唤醒，帮你完成任务。详见 [主动任务](https://docs.astrbot.app/use/proactive-agent.html) 。（实验性） ([#4697](https://github.com/AstrBotDevs/AstrBot/issues/4831))
+- 🔥 新增子代理（SubAgent）编排器。（实验性）([#4697](https://github.com/AstrBotDevs/AstrBot/issues/4831))
+- 🔥 AstrBot 目前可以直接通过调用 tool 将图片 / 文件推送给用户，大大提高交互效果。
+- 新增 Computer Use 运行时配置，以融合 Skill 和 Sandbox 配置 ([#4831](https://github.com/AstrBotDevs/AstrBot/issues/4831))
+- 新增主题自定义功能，可设置主色与辅色
+- 支持在配置页下人格对话框的编辑人格 ([#4826](https://github.com/AstrBotDevs/AstrBot/issues/4826))
+- 支持开关 “追踪” 功能；支持在系统配置中设置是否将日志写入 log 文件 ([#4822](https://github.com/AstrBotDevs/AstrBot/issues/4822))
+
+### 修复
+- ‼️ 修复 ChatUI 图片、思考等显示异常问题。
+- ‼️ 修复 Skill 上传到 Sandbox 后未自动解压导致 Agent 无法读取的问题。
+- ‼️ 修复配置特定插件集时 MCP 工具被过滤的问题 ([#4825](https://github.com/AstrBotDevs/AstrBot/issues/4825))
+- ‼️ 移除 ChatUI 自带的让 LLM 最后提出问题的 prompt ([#4824](https://github.com/AstrBotDevs/AstrBot/issues/4824))
+- ‼️ 修复 WebUI 在上传 Skill 失败后仍显示成功消息的 bug ([#4768](https://github.com/AstrBotDevs/AstrBot/issues/4768))
+- 修复 MCP 服务器无法重命名的问题 ([#4766](https://github.com/AstrBotDevs/AstrBot/issues/4766))
+- 修复插件的 tool 无法在 WebUI 管理行为中看到来源的问题 ([#4776](https://github.com/AstrBotDevs/AstrBot/issues/4776))
+- ‼️ 修复 skill-like 的 tool 模式下，调用 tool 失败的问题 ([#4775](https://github.com/AstrBotDevs/AstrBot/issues/4775))
+
+### 优化
+
+- WebUI 整体 UI 效果优化
+- 部分 Dialog 标题样式统一
+
+## What's Changed (EN)
+
+### New Features
+- Introduce CronJob system with one-time tasks and enhanced dashboard management
+- Add theme customization with primary & secondary color options
+- Add computer-use runtime config for skills sandbox execution ([#4831](https://github.com/AstrBotDevs/AstrBot/issues/4831))
+- Add edit button to persona selector dialog ([#4826](https://github.com/AstrBotDevs/AstrBot/issues/4826))
+- Add trace logging toggle and configuration UI ([#4822](https://github.com/AstrBotDevs/AstrBot/issues/4822))
+- Add proactive-messaging capability with cron-tool trigger
+- Implement SubAgent orchestrator with configurable tool-management policies
+- Support resolving sandbox file paths and auto-download when necessary
+- Add embedded image & audio styles in MessagePartsRenderer
+- Introduce i18n foundation
+- Persist agent-interaction history
+- Add user notifications for file-download success/removal
+
+### Bug Fixes
+- Improve ghost-plugin detection accuracy
+- Add error handling to prevent ghost-plugin crashes
+- Prevent skills bundle from overwriting existing files
+- Fix skills bundle unzip failure inside sandbox
+- Fix MCP tools being filtered when specific plugin set configured ([#4825](https://github.com/AstrBotDevs/AstrBot/issues/4825))
+- Merge ChatUI persona pop-up into default persona ([#4824](https://github.com/AstrBotDevs/AstrBot/issues/4824))
+- Fix reasoning block style
+- Add missing comma in truncate_and_compress hint
+- Fix frontend still showing success message ([#4768](https://github.com/AstrBotDevs/AstrBot/issues/4768))
+- Fix unable to rename MCP server ([#4766](https://github.com/AstrBotDevs/AstrBot/issues/4766))
+- Remove leftover sandbox runtime handling in skill upload ([#4798](https://github.com/AstrBotDevs/AstrBot/issues/4798))
+- Fix handler module path construction ([#4776](https://github.com/AstrBotDevs/AstrBot/issues/4776))
+- Fix skill-like tool invocation error ([#4775](https://github.com/AstrBotDevs/AstrBot/issues/4775))
+
+### Improvements
+- Runtime hints & refined UI in skills management
+- Performance and UX improvements on cron-job page
+- General WebUI performance boost
+- Group tools by plugin in dropdown
+- Consistent dialog titles with padding and text styles
+- Code formatting unified (ruff format)
+- Bump version to 4.13.2
+
+### Others
+- Remove obsolete reminder code
+- Extract main-agent module for better architecture
+- Merge AstrBot_skill branch changes

changelogs/v4.14.1.md

@@ -0,0 +1,7 @@
+## What's Changed - BIG AND BEAUTIFUL VERSION
+
+hotfix of v4.14.0
+
+fixes:
+
+- 由 `event.request_llm()` 过时导致的群聊上下文感知-主动回复功能可能不可用的问题

changelogs/v4.14.2.md

@@ -0,0 +1,23 @@
+## What's Changed
+
+### 新增
+- 控制台页面新增调试提示和本地化文件 ([#4852](https://github.com/AstrBotDevs/AstrBot/pull/4852))
+
+### 修复
+- 修复插件热重载时平台适配器未清理导致注册冲突的问题 ([#4859](https://github.com/AstrBotDevs/AstrBot/pull/4859))
+
+### 其他
+- 更新 ruff 版本至 0.15.0
+- 新增 robots.txt ([#4847](https://github.com/AstrBotDevs/AstrBot/pull/4847))
+
+## What's Changed (EN)
+
+### New Features
+- Add debug hint to console page and localization files ([#4852](https://github.com/AstrBotDevs/AstrBot/pull/4852))
+
+### Bug Fixes
+- Fix platform adapter not being cleaned up during plugin hot reload, causing registration conflicts ([#4859](https://github.com/AstrBotDevs/AstrBot/pull/4859))
+
+### Others
+- Update ruff version to 0.15.0
+- Add robots.txt ([#4847](https://github.com/AstrBotDevs/AstrBot/pull/4847))

changelogs/v4.14.3.md

@@ -0,0 +1,4 @@
+## What's Changed
+
+### 修复
+- 修复 `on_llm_request` 钩子可能无法应用效果的问题

changelogs/v4.14.4.md

@@ -0,0 +1,4 @@
+## What's Changed
+
+### 修复
+- 修复 token 统计错误的问题，修复在多轮 tool call 情况下或者其他极端情况下可能造成 tool 无限调用的问题。

changelogs/v4.14.5.md

@@ -0,0 +1,11 @@
+## What's Changed
+
+### Fix
+- fix: `fix: messages[x] assistant content must contain at least one part` after tool calling ([#4928](https://github.com/AstrBotDevs/AstrBot/issues/4928)) after tool calls.
+- fix: TypeError when MCP schema type is a list ([#4867](https://github.com/AstrBotDevs/AstrBot/issues/4867))
+- fix: Fixed an issue that caused scheduled task execution failures with specific providers 修复特定提供商导致的定时任务执行失败的问题 ([#4872](https://github.com/AstrBotDevs/AstrBot/issues/4872))
+
+
+### Feature
+- feat: add bocha web search tool ([#4902](https://github.com/AstrBotDevs/AstrBot/issues/4902))
+- feat: systemd support ([#4880](https://github.com/AstrBotDevs/AstrBot/issues/4880))

changelogs/v4.14.6.md

@@ -0,0 +1,10 @@
+## What's Changed
+
+### 修复
+- 修复一些原因导致 Tavily WebSearch、Bocha WebSearch 无法使用的问题
+
+### xinzeng
+- 飞书支持 Bot 发送文件、图片和视频消息类型。
+
+### 优化
+- 优化 WebChat 和 企业微信 AI 会话队列生命周期管理，减少内存泄漏，提高性能。

dashboard/index.html

@@ -6,6 +6,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="keywords" content="AstrBot Soulter" />
     <meta name="description" content="AstrBot Dashboard" />
+    <meta name="robots" content="noindex, nofollow" />
     <link
       rel="stylesheet"
       href="https://fonts.googleapis.com/css2?family=Outfit&family=Poppins:wght@400;500;600;700&family=Roboto:wght@400;500;700&display=swap"

dashboard/package.json

@@ -30,7 +30,7 @@
     "markdown-it": "^14.1.0",
     "markstream-vue": "^0.0.6",
     "mermaid": "^11.12.2",
-    "monaco-editor": "^0.55.1",
+    "monaco-editor": "^0.52.2",
     "pinia": "2.1.6",
     "pinyin-pro": "^3.26.0",
     "remixicon": "3.5.0",

dashboard/public/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /

dashboard/src/i18n/locales/en-US/features/config-metadata.json

@@ -108,6 +108,10 @@
           "description": "Tavily API Key",
           "hint": "Multiple keys can be added for rotation."
         },
+        "websearch_bocha_key": {
+          "description": "BoCha API Key",
+          "hint": "Multiple keys can be added for rotation."
+        },
         "websearch_baidu_app_builder_key": {
           "description": "Baidu Qianfan Smart Cloud APP Builder API Key",
           "hint": "Reference: [https://console.bce.baidu.com/iam/#/iam/apikey/list](https://console.bce.baidu.com/iam/#/iam/apikey/list)"

dashboard/src/i18n/locales/en-US/features/console.json

@@ -11,5 +11,8 @@
     "mirrorLabel": "Force PyPI repository URL (optional)",
     "mirrorHint": "Force PyPI repository URL > Config item `PyPI Repository Address`",
     "installButton": "Install"
+  },
+  "debugHint": {
+    "text": "Debug logs can be enabled in \"Configuration File → System → Console Log Level\""
   }
-} 
+}

dashboard/src/i18n/locales/en-US/features/cron.json

@@ -22,6 +22,7 @@
       "name": "Name",
       "type": "Type",
       "cron": "Cron",
+      "session": "Session ID",
       "nextRun": "Next Run",
       "lastRun": "Last Run",
       "note": "Note",

dashboard/src/i18n/locales/zh-CN/features/config-metadata.json

@@ -111,6 +111,10 @@
           "description": "Tavily API Key",
           "hint": "可添加多个 Key 进行轮询。"
         },
+        "websearch_bocha_key": {
+          "description": "BoCha API Key",
+          "hint": "可添加多个 Key 进行轮询。"
+        },
         "websearch_baidu_app_builder_key": {
           "description": "百度千帆智能云 APP Builder API Key",
           "hint": "参考:[https://console.bce.baidu.com/iam/#/iam/apikey/list](https://console.bce.baidu.com/iam/#/iam/apikey/list)"

dashboard/src/i18n/locales/zh-CN/features/console.json

@@ -11,5 +11,8 @@
     "mirrorLabel": "强制 PyPI 软件仓库链接（可选）",
     "mirrorHint": "强制 PyPI 软件仓库链接 > 配置项 `PyPI 软件仓库地址`",
     "installButton": "安装"
+  },
+  "debugHint": {
+    "text": "Debug 日志需要在「配置文件 → 系统 → 控制台日志级别」中开启"
   }
-}
+}

dashboard/src/i18n/locales/zh-CN/features/cron.json

@@ -22,6 +22,7 @@
       "name": "名称",
       "type": "类型",
       "cron": "Cron",
+      "session": "会话 ID",
       "nextRun": "下一次执行",
       "lastRun": "最近执行",
       "note": "说明",

dashboard/src/i18n/locales/zh-CN/features/subagent.json

@@ -35,8 +35,8 @@
     "nameHint": "建议使用英文小写+下划线，且全局唯一",
     "providerLabel": "Chat Provider（可选）",
     "providerHint": "留空表示跟随全局默认 provider。",
-    "personaLabel": "选择 Persona",
-    "personaHint": "SubAgent 将直接继承所选 Persona 的系统设定与工具。",
+    "personaLabel": "选择人格设定",
+    "personaHint": "SubAgent 将直接继承所选 Persona 的系统设定与工具。在人格设定页管理和新建人格。",
     "descriptionLabel": "对主 LLM 的描述（用于决定是否 handoff）",
     "descriptionHint": "这段会作为 transfer_to_* 工具的描述给主 LLM 看，建议简短明确。"
   },

dashboard/src/views/ConsolePage.vue

@@ -10,7 +10,18 @@ const { tm } = useModuleI18n('features/console');
   <div style="height: 100%;">
     <div
       style="background-color: var(--v-theme-surface); padding: 8px; padding-left: 16px; border-radius: 8px; margin-bottom: 16px; display: flex; flex-direction: row; align-items: center; justify-content: space-between;">
-      <h4>{{ tm('title') }}</h4>
+      <div>
+        <h4>{{ tm('title') }}</h4>
+        <v-alert
+          type="info"
+          variant="tonal"
+          density="compact"
+          class="mt-2"
+          style="max-width: 600px;"
+        >
+          {{ tm('debugHint.text') }}
+        </v-alert>
+      </div>
       <div class="d-flex align-center">
         <v-switch
           v-model="autoScrollEnabled"
@@ -111,4 +122,4 @@ export default {
 .fade-in {
   animation: fadeIn 0.2s ease-in-out;
 }
-</style>
+</style>

dashboard/src/views/CronJobPage.vue

@@ -48,6 +48,9 @@
               <div class="text-caption text-medium-emphasis">{{ item.timezone || tm('table.timezoneLocal') }}</div>
             </div>
           </template>
+          <template #item.session="{ item }">
+            <div>{{ item.session || tm('table.notAvailable') }}</div>
+          </template>
           <template #item.next_run_time="{ item }">{{ formatTime(item.next_run_time) }}</template>
           <template #item.last_run_at="{ item }">{{ formatTime(item.last_run_at) }}</template>
           <template #item.note="{ item }">{{ item.note || tm('table.notAvailable') }}</template>
@@ -129,6 +132,7 @@ const headers = computed(() => [
   { title: tm('table.headers.name'), key: 'name', minWidth: '200px' },
   { title: tm('table.headers.type'), key: 'type', width: 110 },
   { title: tm('table.headers.cron'), key: 'cron_expression', minWidth: '160px' },
+  { title: tm('table.headers.session'), key: 'session', minWidth: '200px' },
   { title: tm('table.headers.nextRun'), key: 'next_run_time', minWidth: '160px' },
   { title: tm('table.headers.lastRun'), key: 'last_run_at', minWidth: '160px' },
   { title: tm('table.headers.note'), key: 'note', minWidth: '220px' },
@@ -163,7 +167,11 @@ async function loadJobs() {
   try {
     const res = await axios.get('/api/cron/jobs')
     if (res.data.status === 'ok') {
-      jobs.value = Array.isArray(res.data.data) ? res.data.data : []
+      const data = Array.isArray(res.data.data) ? res.data.data : []
+      jobs.value = data.map((job: any) => ({
+        ...job,
+        session: job?.payload?.session || job?.session || ''
+      }))
     } else {
       toast(res.data.message || tm('messages.loadFailed'), 'error')
     }

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "AstrBot"
-version = "4.13.2"
+version = "4.14.6"
 description = "Easy-to-use multi-platform LLM chatbot and development framework"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -69,14 +69,14 @@ dev = [
   "pytest>=8.4.1",
   "pytest-asyncio>=1.1.0",
   "pytest-cov>=6.2.1",
-  "ruff>=0.12.8",
+  "ruff>=0.15.0",
 ]
 
 [project.scripts]
 astrbot = "astrbot.cli.__main__:cli"
 
 [tool.ruff]
-exclude = ["astrbot/core/utils/t2i/local_strategy.py", "astrbot/api/all.py"]
+exclude = ["astrbot/core/utils/t2i/local_strategy.py", "astrbot/api/all.py", "tests"]
 line-length = 88
 target-version = "py310"
 
@@ -97,6 +97,7 @@ ignore = [
   "F405",
   "E501",
   "ASYNC230", # TODO: handle ASYNC230 in AstrBot
+  "ASYNC240", # TODO: handle ASYNC240 in AstrBot
 ]
 
 [tool.pyright]

scripts/astrbot.service

@@ -0,0 +1,15 @@
+[Unit]
+Description=AstrBot Service
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+WorkingDirectory=%h/.local/share/astrbot
+ExecStart=/usr/bin/sh -c '/usr/bin/astrbot run || { /usr/bin/astrbot init && /usr/bin/astrbot run; }'
+Restart=on-failure
+RestartSec=5
+Environment=PYTHONUNBUFFERED=1
+
+[Install]
+WantedBy=default.target

scripts/generate_changelog.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""
+Auto-generate changelog from git commits using LLM.
+Usage: python scripts/generate_changelog.py [--version VERSION]
+"""
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+
+def get_latest_tag():
+    """Get the latest git tag."""
+    result = subprocess.run(
+        ["git", "describe", "--tags", "--abbrev=0"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return result.stdout.strip()
+
+
+def get_commits_since_tag(tag):
+    """Get all commit messages since the specified tag."""
+    result = subprocess.run(
+        ["git", "log", f"{tag}..HEAD", "--pretty=format:%H|%s|%b"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    commits = []
+    for line in result.stdout.strip().split("\n"):
+        if not line:
+            continue
+        parts = line.split("|", 2)
+        if len(parts) >= 2:
+            commit_hash = parts[0]
+            subject = parts[1]
+            body = parts[2] if len(parts) > 2 else ""
+            commits.append({"hash": commit_hash[:7], "subject": subject, "body": body})
+    return commits
+
+
+def extract_issue_number(text):
+    """Extract issue number from commit message."""
+    # Match #1234 or (#1234)
+    match = re.search(r"#(\d+)", text)
+    return match.group(1) if match else None
+
+
+def call_llm_for_changelog(commits, version):
+    """Call LLM to generate changelog from commits."""
+    try:
+        # Try to use OpenAI API or other LLM providers
+        import openai
+
+        # Build prompt
+        commits_text = "\n".join([f"- {c['subject']}" for c in commits])
+
+        prompt = f"""Based on the following git commit messages, generate a changelog document in BOTH Chinese and English.
+
+Commit messages:
+{commits_text}
+
+Please organize the changes into these categories:
+- 新增 (New Features)
+- 修复 (Bug Fixes)
+- 优化 (Improvements)
+- 其他 (Others)
+
+Format requirements:
+1. Start with Chinese version under "## What's Changed"
+2. Follow with English version under "## What's Changed (EN)"
+3. Use markdown format with proper bullet points
+4. Keep descriptions concise and user-friendly
+5. If a commit mentions an issue number (#1234), include it in the format ([#1234](https://github.com/AstrBotDevs/AstrBot/issues/1234))
+
+Example format:
+## What's Changed
+
+### 新增
+- 支持某某功能 ([#1234](https://github.com/AstrBotDevs/AstrBot/issues/1234))
+
+### 修复
+- 修复某某问题
+
+## What's Changed (EN)
+
+### New Features
+- Add support for something ([#1234](https://github.com/AstrBotDevs/AstrBot/issues/1234))
+
+### Bug Fixes
+- Fix something
+"""
+
+        client = openai.OpenAI(
+            api_key=os.getenv("OPENAI_API_KEY"),
+            base_url=os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1"),
+        )
+
+        response = client.chat.completions.create(
+            model=os.getenv("OPENAI_MODEL", "gpt-4"),
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are a helpful assistant that generates well-structured changelogs.",
+                },
+                {"role": "user", "content": prompt},
+            ],
+            temperature=0.3,
+        )
+
+        return response.choices[0].message.content
+
+    except ImportError:
+        print(
+            "Warning: openai package not installed. Install it with: pip install openai"
+        )
+        return generate_simple_changelog(commits)
+    except Exception as e:
+        print(f"Warning: Failed to call LLM API: {e}")
+        print("Falling back to simple changelog generation...")
+        return generate_simple_changelog(commits)
+
+
+def generate_simple_changelog(commits):
+    """Generate a simple changelog without LLM."""
+    sections = {
+        "feat": ("新增", "New Features", []),
+        "fix": ("修复", "Bug Fixes", []),
+        "perf": ("优化", "Improvements", []),
+        "docs": ("文档", "Documentation", []),
+        "refactor": ("重构", "Refactoring", []),
+        "test": ("测试", "Tests", []),
+        "chore": ("其他", "Chore", []),
+        "other": ("其他", "Others", []),
+    }
+
+    # Categorize commits by conventional commit type
+    for commit in commits:
+        subject = commit["subject"]
+        issue_num = extract_issue_number(subject)
+        issue_link = (
+            f" ([#{issue_num}](https://github.com/AstrBotDevs/AstrBot/issues/{issue_num}))"
+            if issue_num
+            else ""
+        )
+
+        # Detect conventional commit type
+        matched = False
+        for prefix in ["feat", "fix", "perf", "docs", "refactor", "test", "chore"]:
+            if subject.lower().startswith(f"{prefix}:") or subject.lower().startswith(
+                f"{prefix}("
+            ):
+                # Remove prefix for display
+                clean_subject = re.sub(
+                    r"^[a-z]+(\([^)]+\))?:\s*", "", subject, flags=re.IGNORECASE
+                )
+                sections[prefix][2].append(f"- {clean_subject}{issue_link}")
+                matched = True
+                break
+
+        if not matched:
+            sections["other"][2].append(f"- {subject}{issue_link}")
+
+    # Build Chinese version
+    changelog_zh = "## What's Changed\n\n"
+    for section_key in ["feat", "fix", "perf", "docs", "refactor", "test", "other"]:
+        zh_title, _, items = sections[section_key]
+        if items:
+            changelog_zh += f"### {zh_title}\n\n"
+            changelog_zh += "\n".join(items) + "\n\n"
+
+    # Build English version
+    changelog_en = "## What's Changed (EN)\n\n"
+    for section_key in ["feat", "fix", "perf", "docs", "refactor", "test", "other"]:
+        _, en_title, items = sections[section_key]
+        if items:
+            changelog_en += f"### {en_title}\n\n"
+            changelog_en += "\n".join(items) + "\n\n"
+
+    return changelog_zh + changelog_en
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate changelog from git commits")
+    parser.add_argument(
+        "--version", help="Version number for the changelog (e.g., v4.13.3)"
+    )
+    parser.add_argument(
+        "--use-llm",
+        action="store_true",
+        help="Use LLM to generate changelog (requires OpenAI API key)",
+    )
+    args = parser.parse_args()
+
+    # Get latest tag
+    try:
+        latest_tag = get_latest_tag()
+        print(f"Latest tag: {latest_tag}")
+    except subprocess.CalledProcessError:
+        print("Error: No tags found in repository")
+        sys.exit(1)
+
+    # Get commits since tag
+    commits = get_commits_since_tag(latest_tag)
+    if not commits:
+        print(f"No commits found since {latest_tag}")
+        sys.exit(0)
+
+    print(f"Found {len(commits)} commits since {latest_tag}")
+
+    # Determine version
+    if args.version:
+        version = args.version
+    else:
+        # Auto-increment patch version
+        match = re.match(r"v(\d+)\.(\d+)\.(\d+)", latest_tag)
+        if match:
+            major, minor, patch = map(int, match.groups())
+            version = f"v{major}.{minor}.{patch + 1}"
+        else:
+            print(f"Warning: Could not parse version from tag {latest_tag}")
+            version = "vX.X.X"
+
+    print(f"Generating changelog for {version}...")
+
+    # Generate changelog
+    if args.use_llm:
+        changelog_content = call_llm_for_changelog(commits, version)
+    else:
+        changelog_content = generate_simple_changelog(commits)
+
+    # Save to file
+    changelog_dir = Path(__file__).parent.parent / "changelogs"
+    changelog_dir.mkdir(exist_ok=True)
+    changelog_file = changelog_dir / f"{version}.md"
+
+    with open(changelog_file, "w", encoding="utf-8") as f:
+        f.write(changelog_content)
+
+    print(f"\n✓ Changelog generated: {changelog_file}")
+    print("\nPreview:")
+    print("=" * 80)
+    print(changelog_content)
+    print("=" * 80)
+
+
+if __name__ == "__main__":
+    main()