myagent-ai 1.26.5 → 1.26.7

package/agents/main_agent.py

@@ -206,7 +206,7 @@ GUI桌面 (仅Windows/macOS):
         self._execution_events = []
         self._exec_event_counter = 0
 
-    async def process(self, context: AgentContext) -> AgentContext:
+    async def process(self, context: AgentContext, stream_callback=None) -> AgentContext:
         """
         主处理循环。
 
@@ -250,6 +250,7 @@ GUI桌面 (仅Windows/macOS):
                 agent_name=_injected_name or self.name,
                 agent_description=_injected_desc or self.description,
                 agent_override_prompt=_override_prompt,
+                stream_callback=stream_callback,
                 agent_path=getattr(self, '_agent_override_path', None),
             )
         finally:
@@ -950,7 +951,7 @@ GUI桌面 (仅Windows/macOS):
                     f"输出长度={len(llm_raw)} 字符"
                 )
 
-                if _xml_correction_retries < 2:
+                if _xml_correction_retries < 3:
                     _xml_correction_retries += 1
                     # 尝试从不完整输出中提取已有内容，防止内容完全丢失
                     _partial_text = self._try_extract_partial_response(llm_raw)
@@ -995,53 +996,46 @@ GUI桌面 (仅Windows/macOS):
                     )
                     await self._emit_v2_event(
                         "v2_reasoning",
-                        {"content": f"⚠️ 模型输出异常({_diag_msg})，正在自动修正({_xml_correction_retries}/2)..."},
+                        {"content": f"⚠️ 模型输出异常({_diag_msg})，正在自动修正({_xml_correction_retries}/3)..."},
                         stream_callback,
                     )
                     continue  # 重新进入循环，让 LLM 重新生成
                 else:
-                    # 已重试 2 次，强制终止
-                    logger.warning(f"[{task_id}] XML输出异常已重试2次仍失败，终止循环: {_diag_msg}")
+                    # 已重试 3 次 → 不终止，提取已有内容作为 response 继续执行
+                    logger.warning(f"[{task_id}] XML输出异常已重试3次，提取已有内容继续执行: {_diag_msg}")
+                    _fallback_save = ""
                     if _v2_reasoning_collected:
                         _fallback_save = "\n".join(_v2_reasoning_collected)
-                        if _fallback_save.strip():
-                            context.working_memory["final_response"] = _fallback_save
-                            if self.memory:
-                                self.memory.add_session(
-                                    session_id=context.session_id,
-                                    role="assistant",
-                                    content=_fallback_save,
-                                )
-                            await self._emit_v2_event(
-                                "v2_reasoning",
-                                {"content": _fallback_save},
-                                stream_callback,
-                            )
-                    else:
-                        context.working_memory["final_response"] = "模型输出格式异常，请重新尝试。"
-                        await self._emit_v2_event(
-                            "v2_reasoning",
-                            {"content": "模型输出格式异常，已自动终止。"},
-                            stream_callback,
-                        )
-                    break
+                    if not _fallback_save.strip():
+                        before, after = extract_surrounding_text(llm_raw)
+                        _fallback_save = ((before + "\n" + after) if (before.strip() or after.strip()) else re.sub(r"<[^>]+>", "", llm_raw).strip())
+                    _fallback_save = _fallback_save.strip() if _fallback_save.strip() else "处理完毕。"
+                    parsed.parse_success = True
+                    parsed.response = _fallback_save
+                    parsed.finish = True
+                    parsed.finish_reason = f"输出异常({_diag_msg})，已提取内容继续执行"
             elif _block_incomplete and parsed.parse_success:
                 # 块不完整但已提取到有效内容，记录日志但正常继续
                 logger.info(
                     f"[{task_id}] <output> 块不完整但已提取到有效内容，跳过修正直接处理"
                 )
 
-            # Step 4.5: 解析失败处理 — 回退给 LLM 修正或提取周边文本
+            # Step 4.5: 解析失败处理 — 三层兜底，确保执行不会因解析错误而中断
+            # 兜底策略（由 output_parser Step 4.5 已完成 L1/L2，此处处理 L3）:
+            #   L1 (parser): 直接搜索 <tool> 块（跳过 toolstocal 包装）
+            #   L2 (parser): 搜索散落的 <toolname>+<parms> 配对
+            #   L3 (此处):  将原始文本回退给 LLM 修正格式，或提取为纯文本继续
             if not parsed.parse_success:
-                # 即使解析失败，如果 regex fallback 提取到了工具调用，仍然继续执行
                 if parsed.tools_to_call:
-                    logger.warning(f"[{task_id}] XML 解析失败但提取到 {len(parsed.tools_to_call)} 个工具调用，跳过修正直接执行")
-                elif parsed.needs_correction and _xml_correction_retries < 2:
-                    # XML 完全无法解析，让 LLM 重新格式化输出
+                    # L1/L2 兜底成功提取到了工具调用 → 标记为成功，继续执行工具
+                    parsed.parse_success = True
+                    logger.warning(f"[{task_id}] 解析兜底成功: 提取到 {len(parsed.tools_to_call)} 个工具调用，继续执行")
+                elif parsed.needs_correction and _xml_correction_retries < 3:
+                    # L3 兜底: 将原始文本回退给 LLM 让它调好格式再输出
                     _xml_correction_retries += 1
                     logger.warning(
-                        f"[{task_id}] XML 解析完全失败，回退给 LLM 修正 "
-                        f"(重试 {_xml_correction_retries}/2)"
+                        f"[{task_id}] 解析兜底L3: 回退给LLM修正格式 "
+                        f"(重试 {_xml_correction_retries}/3)"
                     )
                     correction_prompt = (
                         "你上一次的输出格式有误，XML解析器无法识别。\n"
@@ -1058,31 +1052,23 @@ GUI桌面 (仅Windows/macOS):
                     )
                     await self._emit_v2_event(
                         "v2_reasoning",
-                        {"content": f"⚠️ 模型输出格式异常，正在自动修正({_xml_correction_retries}/2)..."},
+                        {"content": f"⚠️ 输出格式异常，正在自动修正({_xml_correction_retries}/3)..."},
                         stream_callback,
                     )
                     continue  # 重新进入循环，让 LLM 重新生成
                 else:
-                    # 已重试过或不需要修正，提取周边文本作为备选
-                    logger.warning(f"[{task_id}] XML 解析失败，提取周边文本作为备选")
+                    # 所有兜底都失败 → 把原始文本去除标签后作为 response，不中断执行
+                    logger.warning(f"[{task_id}] 所有解析兜底失败，提取原始文本作为response继续执行")
                     before, after = extract_surrounding_text(llm_raw)
                     if before.strip() or after.strip():
                         final_text = (before + "\n" + after).strip()
                     else:
-                        # 清除残余 XML 标签后作为纯文本
                         final_text = re.sub(r"<[^>]+>", "", llm_raw).strip()
                         final_text = final_text if final_text else "处理完毕。"
-                    context.working_memory["final_response"] = final_text
-                    await self._emit_v2_event(
-                        "v2_reasoning", {"content": final_text}, stream_callback
-                    )
-                    if self.memory:
-                        self.memory.add_session(
-                            session_id=context.session_id,
-                            role="assistant",
-                            content=final_text,
-                        )
-                    break
+                    parsed.parse_success = True
+                    parsed.response = final_text
+                    parsed.finish = True
+                    parsed.finish_reason = "输出格式异常，已提取文本内容作为最终回复"
 
             warnings = validate_output(parsed)
             for w in warnings:

package/core/output_parser.py

@@ -548,6 +548,63 @@ def _custom_parse(raw_text: str) -> ParsedOutput:
     if toolstocal_raw.strip():
         parsed.tools_to_call = _parse_toolstocal(toolstocal_raw, conservative=conservative)
 
+    # ── Step 4.5: 兜底机制 — 宽松提取工具调用，确保执行不会因解析错误而中断 ──
+    # 策略优先级:
+    #   1. _parse_toolstocal 已成功提取 → 不做任何事
+    #   2. 直接在整个输出中搜索 <tool>...</tool> 块（跳过 toolstocal 包装）
+    #   3. 搜索散落的 <toolname>...</toolname> + <parms>...</parms> 配对
+    if not parsed.tools_to_call:
+        # 兜底 Level 1: 在整个原始文本中直接搜索 <tool> 块
+        _raw_tool_blocks = _extract_all_tag_blocks(
+            raw_text, "tool", parent_close_tag=None, conservative=False,
+        )
+        for block in _raw_tool_blocks:
+            tn = _safe_strip(_extract_tag_content(block, "toolname", TOOL_INNER_TAGS))
+            if tn:
+                parsed.tools_to_call.append({
+                    "beforecalltext": _safe_strip(_extract_tag_content(block, "beforecalltext", TOOL_INNER_TAGS)),
+                    "toolname": tn,
+                    "parms": _safe_strip(_extract_tag_content(block, "parms", TOOL_INNER_TAGS)),
+                    "timeout": _parse_int(_extract_tag_content(block, "timeout", TOOL_INNER_TAGS), _DEFAULT_TIMEOUT),
+                })
+                logger.info(f"[兜底L1] 从非<toolstocal>区域提取到工具调用: {tn}")
+
+    if not parsed.tools_to_call:
+        # 兜底 Level 2: 搜索散落的 <toolname>...</toolname>，然后在同一段中找最近的 <parms>
+        _toolname_positions = []
+        for m in re.finditer(r"<toolname[^>]*>(.*?)</toolname\s*>", raw_text, re.DOTALL | re.IGNORECASE):
+            tn = html.unescape(m.group(1)).strip()
+            if tn:
+                _toolname_positions.append((m.start(), m.end(), tn))
+
+        if _toolname_positions:
+            logger.info(f"[兜底L2] 找到 {len(_toolname_positions)} 个散落的 <toolname> 标签")
+            for _i, (_start, _end, _tn) in enumerate(_toolname_positions):
+                # 在 toolname 之后的 500 字符内搜索最近的 <parms>
+                _search_region = raw_text[_end:_end + 500]
+                _parms_match = re.search(
+                    r"<parms[^>]*>(.*?)</parms\s*>",
+                    _search_region, re.DOTALL | re.IGNORECASE,
+                )
+                _parms = html.unescape(_parms_match.group(1)).strip() if _parms_match else ""
+
+                # 也尝试在 toolname 之前的 200 字符内搜索（parms 可能在 toolname 前面）
+                if not _parms:
+                    _pre_region = raw_text[max(0, _start - 200):_start]
+                    _parms_match = re.search(
+                        r"<parms[^>]*>(.*?)</parms\s*>",
+                        _pre_region, re.DOTALL | re.IGNORECASE,
+                    )
+                    _parms = html.unescape(_parms_match.group(1)).strip() if _parms_match else ""
+
+                parsed.tools_to_call.append({
+                    "beforecalltext": "",
+                    "toolname": _tn,
+                    "parms": _parms,
+                    "timeout": _DEFAULT_TIMEOUT,
+                })
+                logger.info(f"[兜底L2] 散落提取工具: {_tn}, parms={'有' if _parms else '无'}")
+
     # ── Step 5: Determine parse success ──
     has_content = bool(
         parsed.response

package/main.py

@@ -374,10 +374,6 @@ class MyAgentApp:
 
     def _register_builtin_skills(self):
         """注册内置技能"""
-        from skills.file_skill import (
-            FileReadSkill, FileWriteSkill, FileListSkill,
-            FileDeleteSkill, FileSearchSkill, FileMoveSkill,
-        )
         from skills.search_skill import WebSearchSkill, WebReadSkill, URLReadSkill
         from skills.system_skill import (
             SystemInfoSkill, ProcessListSkill,
@@ -392,13 +388,6 @@ class MyAgentApp:
             TypeTextSkill, HotkeySkill, WindowListSkill, WindowFocusSkill, ScreenElementSkill,
         )
 
-        # 文件技能
-        for skill_cls in [
-            FileReadSkill, FileWriteSkill, FileListSkill,
-            FileDeleteSkill, FileSearchSkill, FileMoveSkill,
-        ]:
-            self.skill_registry.register(skill_cls())
-
         # 搜索技能
         for skill_cls in [WebSearchSkill, WebReadSkill, URLReadSkill]:
             self.skill_registry.register(skill_cls())
@@ -499,6 +488,7 @@ class MyAgentApp:
         self,
         user_message: str,
         session_id: str = "",
+        stream_callback=None,
     ) -> str:
         """
         处理用户消息并返回回复。
@@ -506,6 +496,7 @@ class MyAgentApp:
         Args:
             user_message: 用户消息
             session_id: 会话 ID
+            stream_callback: SSE 流式回调（群聊等场景需要，用于推送 v2_file 等事件）
 
         Returns:
             助手回复文本
@@ -522,7 +513,7 @@ class MyAgentApp:
         )
 
         try:
-            result_context = await self.main_agent.process(context)
+            result_context = await self.main_agent.process(context, stream_callback=stream_callback)
             response = result_context.working_memory.get(
                 "final_response", "⚠️ 未能生成回复"
             )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.26.5",
+  "version": "1.26.7",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {

package/scripts/cli.py

@@ -9,7 +9,7 @@ scripts/cli.py - MyAgent CLI 工具集
 命令分类:
   感知:    ocr, analyze-image, transcribe
   搜索:    search, read-url, fetch-url
-  文件:    read, write, ls, rm, grep, mv, send-file
+  文件:    send-file
   文档:    docx-create, docx-read, xlsx-create, xlsx-read, xlsx-edit,
            ppt-create, ppt-read, pdf-create, pdf-read
   系统:    sysinfo, ps, env, pathinfo
@@ -90,12 +90,6 @@ async def _run():
         "read-url": cmd_read_url,
         "fetch-url": cmd_fetch_url,
         # 文件操作
-        "read": cmd_read,
-        "write": cmd_write,
-        "ls": cmd_ls,
-        "rm": cmd_rm,
-        "grep": cmd_grep,
-        "mv": cmd_mv,
         "send-file": cmd_send_file,
         # 文档
         "docx-create": cmd_docx_create,
@@ -332,123 +326,6 @@ async def cmd_fetch_url(args):
 # 文件操作命令
 # =============================================================================
 
-async def cmd_read(args):
-    """读取文件内容"""
-    import argparse
-    p = argparse.ArgumentParser(prog="myagent-ai read", description="读取文件内容")
-    p.add_argument("path", help="文件路径")
-    p.add_argument("-e", "--encoding", default="utf-8", help="文件编码 (默认 utf-8)")
-    p.add_argument("--offset", type=int, default=0, help="起始行号 (从0开始)")
-    p.add_argument("--limit", type=int, default=500, help="读取行数 (默认500)")
-    a = p.parse_args(args)
-
-    from skills.file_skill import FileReadSkill
-    skill = FileReadSkill()
-    result = await skill.execute(path=a.path, encoding=a.encoding, offset=a.offset, limit=a.limit)
-    _print_result({"success": result.success, "message": result.message,
-                   "data": result.data, "error": result.error})
-
-
-async def cmd_write(args):
-    """写入文件"""
-    import argparse
-    p = argparse.ArgumentParser(prog="myagent-ai write", description="写入文件")
-    p.add_argument("path", help="文件路径")
-    p.add_argument("-c", "--content", default="", help="写入内容 (或通过 stdin)")
-    p.add_argument("-e", "--encoding", default="utf-8", help="文件编码")
-    p.add_argument("--append", action="store_true", help="追加模式")
-    a = p.parse_args(args)
-
-    content = a.content
-    if not content:
-        content = _read_stdin()
-    if content is None:
-        content = ""
-
-    from skills.file_skill import FileWriteSkill
-    skill = FileWriteSkill()
-    result = await skill.execute(path=a.path, content=content, encoding=a.encoding, append=a.append)
-    _print_result({"success": result.success, "message": result.message,
-                   "data": result.data, "error": result.error})
-
-    # CLI send-file 标记
-    if result.success and result.files:
-        fpath = result.files[0]
-        print(f"\n__SEND_FILE__{fpath}|文件已写入: {Path(fpath).name}__END__")
-
-
-async def cmd_ls(args):
-    """列出目录内容"""
-    import argparse
-    # [v1.23.46] 过滤系统 ls 参数（-l, -a, -la 等）
-    # [v1.23.48] 过滤纯数字参数（LLM 误传如 myagent-ai ls 2）
-    args = [a for a in args if not a.isdigit()]
-    args = _filter_unknown_args(args, allowed_prefixes={"-p", "--pattern", "-r", "--recursive", "--max"})
-    p = argparse.ArgumentParser(prog="myagent-ai ls", description="列出目录内容")
-    p.add_argument("path", nargs="?", default=".", help="目录路径 (默认当前目录)")
-    p.add_argument("-p", "--pattern", default="*", help="文件匹配模式 (如 *.py)")
-    p.add_argument("-r", "--recursive", action="store_true", help="递归列出")
-    p.add_argument("--max", type=int, default=500, help="最大返回条目数 (默认500)")
-    a = p.parse_args(args)
-
-    from skills.file_skill import FileListSkill
-    skill = FileListSkill()
-    result = await skill.execute(path=a.path, pattern=a.pattern, recursive=a.recursive, max_items=a.max)
-    _print_result({"success": result.success, "message": result.message,
-                   "data": result.data, "error": result.error})
-
-
-async def cmd_rm(args):
-    """删除文件或目录"""
-    import argparse
-    p = argparse.ArgumentParser(prog="myagent-ai rm", description="删除文件或目录")
-    p.add_argument("path", help="文件/目录路径")
-    p.add_argument("-r", "--recursive", action="store_true", help="递归删除目录")
-    a = p.parse_args(args)
-
-    from skills.file_skill import FileDeleteSkill
-    skill = FileDeleteSkill()
-    result = await skill.execute(path=a.path, recursive=a.recursive)
-    _print_result({"success": result.success, "message": result.message,
-                   "data": result.data, "error": result.error})
-
-
-async def cmd_grep(args):
-    """搜索文件内容"""
-    import argparse
-    # [v1.23.46] 使用通用过滤器，过滤系统 grep 参数（-n, -i, -r 等）
-    args = _filter_unknown_args(args, allowed_prefixes={"-p", "--pattern", "--max", "--depth"})
-    p = argparse.ArgumentParser(prog="myagent-ai grep", description="在目录中搜索文件内容")
-    p.add_argument("query", help="搜索关键词")
-    p.add_argument("path", help="搜索目录路径")
-    p.add_argument("-p", "--pattern", default="*", help="文件匹配模式 (如 *.py)")
-    p.add_argument("--max", type=int, default=50, help="最大结果数 (默认50)")
-    p.add_argument("--depth", type=int, default=10, help="最大递归深度 (默认10)")
-    a = p.parse_args(args)
-
-    from skills.file_skill import FileSearchSkill
-    skill = FileSearchSkill()
-    result = await skill.execute(path=a.path, query=a.query, pattern=a.pattern,
-                                  max_results=a.max, max_depth=a.depth)
-    _print_result({"success": result.success, "message": result.message,
-                   "data": result.data, "error": result.error})
-
-
-async def cmd_mv(args):
-    """移动/重命名文件"""
-    import argparse
-    p = argparse.ArgumentParser(prog="myagent-ai mv", description="移动或重命名文件/目录")
-    p.add_argument("source", help="源路径")
-    p.add_argument("dest", help="目标路径")
-    a = p.parse_args(args)
-
-    from skills.file_skill import FileMoveSkill
-    skill = FileMoveSkill()
-    result = await skill.execute(source=a.source, destination=a.dest)
-    _print_result({"success": result.success, "message": result.message,
-                   "data": result.data, "error": result.error})
-
-
 async def cmd_send_file(args):
     """发送文件给用户"""
     import argparse