myagent-ai 1.21.1 → 1.22.1

package/agents/main_agent.py

@@ -17,6 +17,7 @@ from agents.base import BaseAgent, AgentContext
 from core.utils import generate_id, timestamp, truncate_str
 from core.context_builder import ContextBuilder
 from core.output_parser import ParsedOutput, parse_output, validate_output, extract_surrounding_text
+from core.tool_dispatcher import ToolDispatcher
 
 logger = get_logger("myagent.agent.main")
 
@@ -47,7 +48,7 @@ class MainAgent(BaseAgent):
 <mainsubject>当前对话的6字以内标题（每轮都需输出，系统会每3轮自动更新会话名称）</mainsubject>
 <usersays_correct>通过修正识别错误、调整标点，结合上下文，将用户语音转写文本"usersays"修正为更准确的文本，但尽量少改动。如"usersays"为空，则此处为空。</usersays_correct>
 <response><reply>展示给用户的文本,格式上尽量使用md格式，直观形象展示，甚至可以包括超链接等。内容上，直接回应用户问题；告诉用户，为完成任务，准备如何开展工作；根据工具调用结果，展示任务进展；任务完成后的最终总结。注意:这是给用户展示信息的最重要标签，内容清晰明了，尽量不要跟上次回复重复。</reply><toolstocal>
-<tool><beforecalltext>展示给用户的工具调用信息，方便用户了解调用目的。格式:先使用"接下来、下一步、接着、现在、然后、最后"等连接词，然后介绍调用什么工具，达到什么目的。</beforecalltext><toolname>工具名，用于后台解析器解析调用工具</toolname><parms>调用工具的JSON格式参数对象，如格式: {"query": "搜索关键词", "num": 5}</parms><timeout>预估调用超时时限(秒),工具调用超时会立即回调大语言模型，方便调整工具使用</timeout></tool>
+<tool><beforecalltext>展示给用户的简单工具调用信息。格式:先使用"接下来、下一步、接着、现在、然后、最后"等连接词➕调用"工具名"。</beforecalltext><toolname>工具名，用于后台解析器解析调用工具</toolname><parms>调用工具的JSON格式参数对象，如格式: {"query": "搜索关键词", "num": 5}</parms><timeout>预估调用超时时限(秒),工具调用超时会立即回调大语言模型，方便调整工具使用</timeout></tool>
 </toolstocal>
 </response>
 <task_plan>若"context"包含非空"task_plan"，则更新它:若任务条数已超8，则精简为3条，若主题发生明显变化，重新设计任务列表。若"context"包含空"task_plan"，则先评估任务复杂度，针对单次查询、简单问答、格式转换、单文件修改、简单计算等简单任务，若预计操作步骤不超过2步，则此处输出为空，不创建任务列表；针对多文件修改、需要调研+实现+测试、涉及多个模块联动等复杂任务，如预计超过2步操作，则以Markdown列表格式制定新任务列表。格式：每项用 "- [ ] 任务描述" 或 "- [x] 已完成任务"，含完成状态标记。</task_plan>
@@ -71,8 +72,7 @@ class MainAgent(BaseAgent):
 - **搜索信息**: 用 `web_search`（返回标题+URL+摘要）
 - **读取网页内容**: 用 `web_read`（传入URL，提取正文）
 - **浏览器交互**（填表、点击、截图等）: 才使用 browser_open / browser_click 等
-- **执行代码**: 用 `code` 工具（language: python/javascript/shell）
-- **执行命令**: 用 `command` 或 `command_run` 工具
+- **执行命令/代码**: 用 `command` 工具执行 shell 命令（python/node/bash 等代码也通过 command 执行，如 `python script.py`、`node app.js`）
 - **文件操作**: 用 `file_read` / `file_write` / `file_list` 等文件工具
 - **发送文件给用户**: 用 `file_send` 工具（参数: file_path=文件路径, description=说明），当你生成或处理了文件需要返回给用户时使用
 - **播放音频**: 用 `playaudio` 工具（参数: url=音乐链接或file_path=本地文件路径），在聊天中内嵌播放音频（支持QQ音乐、YouTube音乐、本地MP3/WAV等），播放时自动关闭语音合成
@@ -90,12 +90,16 @@ class MainAgent(BaseAgent):
   - 关闭: `{"action": "close", "session_id": "xxx"}`
   - 注意: 网页通过服务端代理加载，用户可在面板中手动操作。复杂交互建议先用 get_content 查看页面结构再用 click/fill。
 - **主动召回记忆**: 用 `recall_memory` 工具（参数: keyword=关键字, time_point=可选时间点如"2025-01", limit=数量默认5），根据关键字和时间搜索历史记忆
+- **OCR 文字识别**: 用 `image_ocr` 工具（参数: image_path=图片路径, lang=ch/en），从截图、扫描件、照片中提取文字
+- **图片内容分析**: 用 `image_analyze` 工具（参数: image_path=图片路径, prompt=分析提示词），识别图片中的物体、文字、图表数据等（需模型支持视觉）
+- **语音转文字**: 用 `audio_transcribe` 工具（参数: audio_path=音频路径, language=zh/en），将音频文件转录为文本
+- **专业技能指令**: 系统内置了丰富的专业技能指南（如 PDF/DOCX/XLSX/PPT 生成、图表绘制、前端开发、全栈开发、图像生成等），当你需要执行特定领域的复杂任务时，通过 `<get_knowledge>` 标签请求相关技能指令（如填写 "PDF文档生成指南"、"PPT制作规范" 等），系统将在下一轮通过 `<knowledge>` 注入完整指令。
 4. 准备好内容后，最后，再检查输出格式，确保满足以下要求:
 <output>
 <mainsubject>当前对话的6字以内标题（每轮都需输出，系统会每3轮自动更新会话名称）</mainsubject>
 <usersays_correct>通过修正识别错误、调整标点，结合上下文，将用户语音转写文本"usersays"修正为更准确的文本，但尽量少改动。如"usersays"为空，则此处为空。</usersays_correct>
 <response><reply>展示给用户的文本,格式上尽量使用md格式，直观形象展示，甚至可以包括超链接等。内容上，直接回应用户问题；告诉用户，为完成任务，准备如何开展工作；根据工具调用结果，展示任务进展；任务完成后的最终总结。注意:这是给用户展示信息的最重要标签，内容清晰明了，尽量不要跟上次回复重复。</reply><toolstocal>
-<tool><beforecalltext>展示给用户的工具调用信息，方便用户了解调用目的。格式:先使用"接下来、下一步、接着、现在、然后、最后"等连接词，然后介绍调用什么工具，达到什么目的。</beforecalltext><toolname>工具名，用于后台解析器解析调用工具</toolname><parms>调用工具的JSON格式参数对象，如格式: {"query": "搜索关键词", "num": 5}</parms><timeout>预估调用超时时限(秒),工具调用超时会立即回调大语言模型，方便调整工具使用</timeout></tool>
+<tool><beforecalltext>展示给用户的简单工具调用信息。格式:先使用"接下来、下一步、接着、现在、然后、最后"等连接词➕调用"工具名"。</beforecalltext><toolname>工具名，用于后台解析器解析调用工具</toolname><parms>调用工具的JSON格式参数对象，如格式: {"query": "搜索关键词", "num": 5}</parms><timeout>预估调用超时时限(秒),工具调用超时会立即回调大语言模型，方便调整工具使用</timeout></tool>
 </toolstocal>
 </response>
 <task_plan>若"context"包含非空"task_plan"，则更新它:若任务条数已超8，则精简为3条，若主题发生明显变化，重新设计任务列表。若"context"包含空"task_plan"，则先评估任务复杂度，针对单次查询、简单问答、格式转换、单文件修改、简单计算等简单任务，若预计操作步骤不超过2步，则此处输出为空，不创建任务列表；针对多文件修改、需要调研+实现+测试、涉及多个模块联动等复杂任务，如预计超过2步操作，则以Markdown列表格式制定新任务列表。格式：每项用 "- [ ] 任务描述" 或 "- [x] 已完成任务"，含完成状态标记。</task_plan>
@@ -117,6 +121,8 @@ class MainAgent(BaseAgent):
         self._iteration_count = 0
         self._current_task_id: str = ""
         self._registered_task: bool = False
+        # [v1.22.0] 统一工具分发器
+        self.dispatcher: Optional[ToolDispatcher] = None
         # Context Builder (结构化上下文构建)
         self.context_builder: Optional[ContextBuilder] = None
         # 执行事件追踪（用于前端展示命令执行过程）
@@ -1528,9 +1534,7 @@ class MainAgent(BaseAgent):
         stream_callback: Optional[Callable] = None,
         sent_files: Optional[List[Dict[str, Any]]] = None,
     ) -> Dict[str, Any]:
-        """V2 工具执行"""
-        result = {"success": False, "output": "", "error": ""}
-
+        """[v1.22.0] V2 工具执行 — 统一分发到 ToolDispatcher"""
         try:
             import json as _json
             try:
@@ -1538,355 +1542,19 @@ class MainAgent(BaseAgent):
             except (_json.JSONDecodeError, TypeError):
                 params = {"raw_input": parms_str}
 
-            if tool_name == "code" or tool_name.startswith("code_"):
-                code_lang = params.get("language", "python")
-                code_text = params.get("code", parms_str)
-                if self.executor:
-                    # 注入权限检查器（V1 路径在 api_server 中设置，V2 路径需要在此设置）
-                    self.executor.set_permission_checker(
-                        self.check_permission, self.name
-                    )
-                    exec_result = await self.executor.execute(
-                        language=code_lang,
-                        code=code_text,
-                        timeout=timeout,
-                    )
-                    result = exec_result.to_dict()
-                else:
-                    result["error"] = "执行引擎未初始化"
-
-            elif tool_name == "command" or tool_name == "command_run":
-                code_text = params.get("command", parms_str)
-                if self.executor:
-                    # 注入权限检查器（V1 路径在 api_server 中设置，V2 路径需要在此设置）
-                    self.executor.set_permission_checker(
-                        self.check_permission, self.name
-                    )
-                    exec_result = await self.executor.execute(
-                        language="shell",
-                        code=code_text,
-                        timeout=timeout,
-                    )
-                    result = exec_result.to_dict()
-                else:
-                    result["error"] = "执行引擎未初始化"
-
-            elif tool_name == "recall_memory":
-                # === 主动召回记忆工具 ===
-                # 根据 memory_agent.recall_memory() 搜索历史记忆
-                try:
-                    if self.memory_agent:
-                        recall_results = await self.memory_agent.recall_memory(
-                            keyword=params.get("keyword", ""),
-                            time_point=params.get("time_point", ""),
-                            session_id=params.get("session_id", ""),
-                            limit=params.get("limit", 5),
-                        )
-                        if recall_results:
-                            output_lines = [f"找到 {len(recall_results)} 条相关记忆:"]
-                            for i, mem in enumerate(recall_results, 1):
-                                output_lines.append(
-                                    f"{i}. [{mem.get('created_at', '')}] "
-                                    f"[{mem.get('category', '')}] "
-                                    f"{mem.get('content', '')}"
-                                )
-                            result = {"success": True, "output": "\n".join(output_lines), "data": recall_results}
-                        else:
-                            result = {"success": True, "output": "未找到相关记忆", "data": []}
-                    else:
-                        result = {"success": False, "error": "记忆系统未初始化"}
-                except Exception as re_err:
-                    result = {"success": False, "error": f"记忆召回失败: {re_err}"}
-                    logger.warning(f"[{task_id}] recall_memory 工具异常: {re_err}")
-
-            elif tool_name == "file_send":
-                # [v1.16.17→18] 文件发送工具 — 让 Agent 向用户发送文件
-                try:
-                    from skills.file_send import FileSendSkill
-                    _fskill = FileSendSkill()
-                    _fpath = params.get("file_path", "")
-                    _fdesc = params.get("description", "")
-                    # [v1.16.18] 使用当前作用域的 stream_callback（而非 context._stream_callback）
-                    _fresult = await _fskill.execute(_fpath, _fdesc, stream_callback=stream_callback)
-                    result = {"success": True, "output": json.dumps(_fresult, ensure_ascii=False, indent=2), "data": _fresult}
-                    # [v1.18.5→21.1] 追踪发送的文件，用于持久化到会话记忆
-                    if sent_files is not None and _fresult.get("success") and _fresult.get("file_id"):
-                        sent_files.append({
-                            "id": _fresult["file_id"],
-                            "name": _fresult.get("name", ""),
-                            "type": _fresult.get("type", ""),
-                            "size": _fresult.get("size", 0),
-                        })
-                except Exception as _fse:
-                    result = {"success": False, "error": f"文件发送失败: {_fse}"}
-                    logger.warning(f"[{task_id}] file_send 工具异常: {_fse}")
-
-            elif tool_name in ("playaudio", "playvideo"):
-                # [v1.20.3] 音视频播放工具 — 在聊天中内嵌播放器
-                try:
-                    _media_url = params.get("url", "").strip()
-                    _media_file = params.get("file_path", "").strip()
-                    _media_type = "audio" if tool_name == "playaudio" else "video"
-                    _embed_url = None
-                    _embed_title = params.get("title", "")
-                    _fallback_link = None  # [v1.20.10] 无法嵌入时提供外部链接
-
-                    if _media_url:
-                        # 在线链接 — 提取嵌入式播放 URL
-                        import re
-                        _url_lower = _media_url.lower()
-                        # YouTube: https://www.youtube.com/watch?v=xxx 或 youtu.be/xxx
-                        _yt_match = re.search(r'(?:youtube\.com/watch\?v=|youtu\.be/|youtube\.com/embed/)([\w-]+)', _media_url)
-                        if _yt_match:
-                            _embed_url = f"https://www.youtube.com/embed/{_yt_match.group(1)}"
-                            _embed_title = _embed_title or "YouTube 视频"
-                        # YouTube Music 播放列表: https://music.youtube.com/playlist?list=xxx
-                        elif 'music.youtube.com' in _url_lower:
-                            _ym_match = re.search(r'list=([\w-]+)', _media_url)
-                            if _ym_match:
-                                _embed_url = f"https://music.youtube.com/embed?list={_ym_match.group(1)}&layout=full"
-                                _embed_title = _embed_title or "YouTube Music"
-                            else:
-                                # 单曲: https://music.youtube.com/watch?v=xxx
-                                _ymv_match = re.search(r'watch\?v=([\w-]+)', _media_url)
-                                if _ymv_match:
-                                    _embed_url = f"https://music.youtube.com/embed/{_ymv_match.group(1)}"
-                                    _embed_title = _embed_title or "YouTube Music"
-                                else:
-                                    _fallback_link = _media_url
-                                    _embed_title = _embed_title or "YouTube Music"
-                        # Bilibili: https://www.bilibili.com/video/BVxxx 或 b23.tv/xxx
-                        elif 'bilibili.com' in _url_lower or 'b23.tv' in _url_lower:
-                            _bv_match = re.search(r'bilibili\.com/video/(BV[\w]+)', _media_url)
-                            if _bv_match:
-                                _embed_url = f"https://player.bilibili.com/player.html?bvid={_bv_match.group(1)}&autoplay=0"
-                                _embed_title = _embed_title or "B站视频"
-                            else:
-                                _embed_url = _media_url  # b23.tv 短链接直接使用
-                                _embed_title = _embed_title or "B站视频"
-                        # QQ音乐: https://y.qq.com/n/ryqq/songDetail/xxx
-                        elif 'y.qq.com' in _url_lower:
-                            # QQ音乐支持 outchain player
-                            _qq_match = re.search(r'songDetail/(\w+)', _media_url)
-                            if _qq_match:
-                                _embed_url = f"https://y.qq.com/n/ryqq/songDetail/{_qq_match.group(1)}"
-                                _embed_title = _embed_title or "QQ音乐"
-                            else:
-                                _embed_url = _media_url
-                                _embed_title = _embed_title or "QQ音乐"
-                        # 网易云音乐: https://music.163.com/song?id=xxx
-                        elif 'music.163.com' in _url_lower:
-                            _song_match = re.search(r'music\.163\.com.*[?&]id=(\d+)', _media_url)
-                            if _song_match:
-                                _embed_url = f"https://music.163.com/outchain/player?type=2&id={_song_match.group(1)}&auto=0&height=66"
-                                _embed_title = _embed_title or "网易云音乐"
-                            else:
-                                _embed_url = _media_url
-                                _embed_title = _embed_title or "网易云音乐"
-                        # 抖音: https://www.douyin.com/video/xxx
-                        elif 'douyin.com' in _url_lower:
-                            _embed_url = _media_url
-                            _embed_title = _embed_title or "抖音视频"
-                        else:
-                            # 其他 URL，尝试直接嵌入
-                            _embed_url = _media_url
-                            _embed_title = _embed_title or ("在线音乐" if _media_type == "audio" else "在线视频")
-
-                    if _embed_url and stream_callback:
-                        # 在线播放 — 发送 v2_media 事件让前端渲染嵌入播放器
-                        await _safe_sse(stream_callback, {
-                            "type": "v2_media",
-                            "data": {
-                                "media_type": _media_type,
-                                "embed_url": _embed_url,
-                                "title": _embed_title,
-                                "original_url": _media_url,
-                            }
-                        })
-                        result = {"success": True, "output": f"已嵌入{_embed_title}播放器: {_media_url}"}
-
-                    elif _fallback_link and stream_callback:
-                        # [v1.20.10] 无法嵌入但提供外部链接 — 发送链接卡片
-                        await _safe_sse(stream_callback, {
-                            "type": "v2_media",
-                            "data": {
-                                "media_type": _media_type,
-                                "embed_url": "",  # 空 embed_url 告诉前端渲染链接
-                                "title": _embed_title,
-                                "original_url": _fallback_link,
-                            }
-                        })
-                        result = {"success": True, "output": f"已提供{_embed_title}链接（不支持嵌入播放）: {_fallback_link}"}
-
-                    elif _media_file:
-                        # 本地文件 — 使用 file_send 发送文件，前端渲染内嵌播放器
-                        from pathlib import Path as _P
-                        _fpath = _P(_media_file).expanduser().resolve()
-                        if not _fpath.exists():
-                            result = {"success": False, "error": f"文件不存在: {_media_file}"}
-                        else:
-                            from skills.file_send import FileSendSkill
-                            _fskill = FileSendSkill()
-                            _desc = f"{'音频' if _media_type == 'audio' else '视频'}播放: {_fpath.name}"
-                            _fresult = await _fskill.execute(str(_fpath), _desc, stream_callback=stream_callback)
-                            if _fresult.get("success"):
-                                # 标记为媒体文件，前端渲染内嵌播放器
-                                _fresult["_media_type"] = _media_type
-                                result = {"success": True, "output": f"已发送{_media_type}文件: {_fpath.name}", "data": _fresult}
-                                if sent_files is not None and _fresult.get("file_id"):
-                                    sent_files.append({
-                                        "id": _fresult["file_id"],
-                                        "name": _fresult.get("name", ""),
-                                        "type": _fresult.get("type", ""),
-                                        "size": _fresult.get("size", 0),
-                                        "_media_type": _media_type,
-                                    })
-                            else:
-                                result = {"success": False, "error": _fresult.get("error", "文件发送失败")}
-                    else:
-                        result = {"success": False, "error": f"请提供 url（在线链接）或 file_path（本地文件路径）参数"}
-
-                except Exception as _me:
-                    result = {"success": False, "error": f"播放工具异常: {_me}"}
-                    logger.warning(f"[{task_id}] {tool_name} 工具异常: {_me}")
-
-            elif tool_name == "web_control":
-                # [v1.21.0] 网页控制器 — 在聊天中打开可控制的浏览器面板
-                try:
-                    from core.web_control import get_web_control_manager
-                    _wc_mgr = get_web_control_manager()
-                    _wc_action = params.get("action", "open")
-                    _wc_session_id = params.get("session_id", "").strip()
-
-                    # 自动获取或创建会话
-                    _wc_session = None
-                    if _wc_session_id:
-                        _wc_session = _wc_mgr.get_session(_wc_session_id)
-                    if not _wc_session:
-                        _wc_session = _wc_mgr.create_session()
-                        _wc_session_id = _wc_session.session_id
-
-                    if _wc_action == "open":
-                        # 打开面板 — 发送 SSE 事件让前端弹出控制面板
-                        _wc_url = params.get("url", "").strip()
-                        if _wc_url:
-                            _wc_session.current_url = _wc_url
-                        if stream_callback:
-                            await _safe_sse(stream_callback, {
-                                "type": "v2_web_control",
-                                "data": {
-                                    "action": "open",
-                                    "session_id": _wc_session_id,
-                                    "url": _wc_url,
-                                    "panel_url": f"/api/web_control/panel?sid={_wc_session_id}",
-                                }
-                            })
-                        result = {
-                            "success": True,
-                            "output": f"已打开网页控制面板 (session: {_wc_session_id})" + (f"，URL: {_wc_url}" if _wc_url else ""),
-                            "session_id": _wc_session_id,
-                        }
-
-                    elif _wc_action == "close":
-                        _wc_mgr.close_session(_wc_session_id)
-                        if stream_callback:
-                            await _safe_sse(stream_callback, {
-                                "type": "v2_web_control",
-                                "data": {"action": "close", "session_id": _wc_session_id}
-                            })
-                        result = {"success": True, "output": f"已关闭网页控制面板 (session: {_wc_session_id})"}
-
-                    elif _wc_action == "navigate":
-                        _wc_url = params.get("url", "").strip()
-                        if not _wc_url:
-                            result = {"success": False, "error": "请提供 url 参数"}
-                        else:
-                            _wc_session.current_url = _wc_url
-                            if stream_callback:
-                                await _safe_sse(stream_callback, {
-                                    "type": "v2_web_control",
-                                    "data": {"action": "navigate", "session_id": _wc_session_id, "url": _wc_url}
-                                })
-                            result = {"success": True, "output": f"正在导航到: {_wc_url}"}
-
-                    elif _wc_action in ("set_cookies", "get_cookies"):
-                        # Cookie 操作 — 服务端直接处理
-                        if _wc_action == "set_cookies":
-                            _cookies = params.get("cookies", [])
-                            if isinstance(_cookies, str):
-                                import json as _jc
-                                try:
-                                    _cookies = _jc.loads(_cookies)
-                                except:
-                                    _cookies = []
-                            for _c in _cookies:
-                                if isinstance(_c, dict):
-                                    _c_domain = _c.get("domain", "").lstrip(".")
-                                    _c_name = _c.get("name", "")
-                                    _c_value = _c.get("value", "")
-                                    if _c_domain and _c_name:
-                                        _wc_session.cookies[f"{_c_domain}::{_c_name}"] = _c_value
-                            result = {"success": True, "output": f"已设置 {len(_cookies)} 个 cookie", "total_cookies": len(_wc_session.cookies)}
-                        else:
-                            _cookie_list = []
-                            for _ck, _cv in _wc_session.cookies.items():
-                                _parts = _ck.split("::", 1)
-                                if len(_parts) == 2:
-                                    _cookie_list.append({"domain": _parts[0], "name": _parts[1], "value": _cv})
-                            result = {"success": True, "output": json.dumps(_cookie_list, ensure_ascii=False), "cookies": _cookie_list}
-
-                    else:
-                        # 其他操作（click, fill, scroll, evaluate, get_content, wait, screenshot）
-                        # 通过命令队列下发到客户端执行，阻塞等待结果
-                        _wc_params = {k: v for k, v in params.items() if k not in ("action", "session_id")}
-                        _wc_timeout = int(params.get("timeout", timeout))
-                        _wc_result = await _wc_mgr.queue_command(
-                            session_id=_wc_session_id,
-                            action=_wc_action,
-                            params=_wc_params,
-                            timeout=min(_wc_timeout, 60),  # 最大 60 秒
-                        )
-                        result = _wc_result
-
-                except Exception as _wce:
-                    result = {"success": False, "error": f"网页控制器异常: {_wce}"}
-                    logger.warning(f"[{task_id}] web_control 工具异常: {_wce}")
-
-            elif self.skills:
-                exec_result = await self.skills.execute(tool_name, **params)
-                if exec_result is None:
-                    result["error"] = f"技能 {tool_name} 返回了空结果"
-                else:
-                    result = exec_result.to_dict()
-                    # [v1.21.1] Skill 生成文件后自动通过 file_send 发送给前端
-                    if exec_result.success and exec_result.files:
-                        try:
-                            from skills.file_send import FileSendSkill
-                            _auto_fsend = FileSendSkill()
-                            for _auto_fpath in exec_result.files:
-                                if _auto_fpath and os.path.isfile(_auto_fpath):
-                                    _auto_fres = await _auto_fsend.execute(
-                                        _auto_fpath, stream_callback=stream_callback)
-                                    if _auto_fres.get("success") and _auto_fres.get("file_id"):
-                                        # 记录发送的 file_id
-                                        if not result.get("_sent_file_ids"):
-                                            result["_sent_file_ids"] = []
-                                        result["_sent_file_ids"].append(_auto_fres["file_id"])
-                                        # 追踪到 sent_files（持久化到会话记忆）
-                                        if sent_files is not None:
-                                            sent_files.append({
-                                                "id": _auto_fres["file_id"],
-                                                "name": _auto_fres.get("name", ""),
-                                                "type": _auto_fres.get("type", ""),
-                                                "size": _auto_fres.get("size", 0),
-                                            })
-                        except Exception as _afe:
-                            logger.warning(f"[{task_id}] 自动 file_send 失败: {_afe}")
-            else:
-                result["error"] = f"未知工具: {tool_name}"
+            if self.dispatcher:
+                return await self.dispatcher.dispatch(
+                    tool_name=tool_name,
+                    params=params,
+                    timeout=timeout,
+                    task_id=task_id,
+                    stream_callback=stream_callback,
+                    sent_files=sent_files,
+                )
 
+            # 兼容回退: dispatcher 未初始化时使用基础 fallback
+            result = {"success": False, "output": "", "error": f"工具分发器未初始化: {tool_name}"}
         except Exception as e:
-            result["error"] = str(e)
-            logger.error(f"[{task_id}] 工具 {tool_name} 异常: {e}")
-
+            result = {"success": False, "output": "", "error": f"工具调用异常: {tool_name} - {e}"}
+            logger.warning(f"[{task_id}] 工具调用异常 ({tool_name}): {e}")
         return result

package/chatbot/whatsapp_bot.py

@@ -92,22 +92,9 @@ class WhatsAppBot(BaseChatBot):
         # 检查是否已安装依赖
         node_modules = bridge_dir / "node_modules"
         if not node_modules.exists():
-            self.logger.info("正在安装 Baileys 依赖...")
-            try:
-                proc = await asyncio.create_subprocess_exec(
-                    "npm", "install", "--production",
-                    cwd=str(bridge_dir),
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE,
-                )
-                stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=120)
-                if proc.returncode != 0:
-                    self.logger.error(f"Baileys 安装失败: {stderr.decode()[:500]}")
-                    return
-                self.logger.info("Baileys 依赖安装完成")
-            except Exception as e:
-                self.logger.error(f"Baileys 安装异常: {e}")
-                return
+            self.logger.warning("Baileys 依赖未安装，请手动执行:")
+            self.logger.warning(f"  cd {bridge_dir} && npm install")
+            return
 
         env = os.environ.copy()
         env["SESSION_DIR"] = self._session_dir

package/core/context_builder.py

@@ -790,45 +790,14 @@ class ContextBuilder:
         skill_registry: Optional["SkillRegistry"],
     ) -> str:
         """
-        构建 <skill_prompts> 段落 —— SKILL.md 格式技能的完整指令内容。
+        [v1.22.0] 不再全量注入 skill_prompts。
 
-        对于 SKILL.md 目录格式的 Prompt 类型技能，将完整的 markdown body
-        注入到 LLM 上下文中，使 LLM 能按照技能指令执行任务。
-        普通 Python 技能（有 execute 实现）不在此处注入。
-
-        Returns:
-            <skill_prompts> XML 段落字符串，无 Prompt 技能时返回空字符串
+        SKILL.md 内容已通过 _sync_skill_guides_to_knowledge() 写入
+        {kb_dir}/_skill_guides/ 目录，由 RAG 索引。
+        LLM 需要专业技能指令时，通过 <get_knowledge> 按需检索。
+        返回空字符串以节省大量 token。
         """
-        if not skill_registry:
-            return ""
-
-        # 收集所有 markdown 类型且未禁用的技能的 body
-        prompt_skills = []
-        try:
-            for skill in skill_registry._skills.values():
-                if skill_registry._is_disabled(skill.name):
-                    continue
-                # 检查是否为 SKILL.md 格式技能
-                body = getattr(skill, 'get_body', None)
-                if body and callable(body):
-                    content = body()
-                    if content:
-                        prompt_skills.append((skill.name, content))
-        except Exception as e:
-            logger.warning(f"获取 skill prompts 失败: {e}")
-            return ""
-
-        if not prompt_skills:
-            return ""
-
-        lines: List[str] = ["<skill_prompts>"]
-        for skill_name, content in prompt_skills:
-            safe_name = _xml_escape(skill_name)
-            lines.append(f"<{safe_name}>")
-            lines.append(content)
-            lines.append(f"</{safe_name}>")
-        lines.append("</skill_prompts>")
-        return "\n".join(lines)
+        return ""
 
     # =========================================================================
     # Token 预算管理