myagent-ai 1.47.20 → 1.47.21

package/agents/main_agent.py

@@ -16,7 +16,6 @@ from core.llm import LLMClient, LLMResponse, Message
 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")
@@ -501,79 +500,20 @@ class MainAgent(BaseAgent):
                 logger.debug(f"V2 SSE 事件发送失败 ({event_type}): {e}")
 
     def _try_extract_partial_response(self, llm_raw: str) -> str:
-        """[v1.15.73] 从不完整的 LLM 输出中提取部分回复内容。
-
-        当 <output> 块被截断（缺少 </output>）时，尝试：
-        1. 提取 <reply>...</reply> 中已闭合的内容
-        2. 提取未闭合的 <reply> 后的内容（宽松模式）
-        3. 提取 <knowledge>...</knowledge> 中已闭合的内容（兜底）
-        4. 提取 <output> 后到截断点之间的纯文本
-        5. 去除 XML 标签后的残余文本（跳过工具执行状态文本）
+        """[v1.47.21] 从不完整的 LLM 输出中提取纯文本回复。
+
+        完全依赖原生 tool_calling，不再解析 XML 格式。
+        仅做简单的 XML 标签清理（兜底，防止模型意外输出 XML）。
         """
         if not llm_raw:
             return ""
 
         import re
-        _parts = []
-
-        # 策略1: 尝试提取已闭合的 <reply> 内容
-        reply_match = re.search(
-            r"<reply[^>]*>(.*?)</reply>",
-            llm_raw,
-            re.DOTALL | re.IGNORECASE,
-        )
-        if reply_match:
-            text = reply_match.group(1).strip()
-            if text:
-                _parts.append(text)
-
-        # 策略2: 尝试提取未闭合的 <reply> 内容（LLM 截断时 <reply> 常未闭合）
-        if not _parts:
-            reply_open_match = re.search(
-                r"<reply[^>]*>(.*?)$",
-                llm_raw,
-                re.DOTALL | re.IGNORECASE,
-            )
-            if reply_open_match:
-                text = reply_open_match.group(1).strip()
-                # 去除尾部可能的不完整标签
-                text = re.sub(r"<[^>]*$", "", text).strip()
-                if text and len(text) > 5:
-                    _parts.append(text)
-
-        # 策略3: 尝试提取已闭合的 <knowledge> 内容（兜底）
-        if not _parts:
-            knowledge_match = re.search(
-                r"<knowledge[^>]*>(.*?)</knowledge>",
-                llm_raw,
-                re.DOTALL | re.IGNORECASE,
-            )
-            if knowledge_match:
-                text = knowledge_match.group(1).strip()
-                if text and len(text) > 20:
-                    _parts.append(text)
-
-        if _parts:
-            return "\n".join(_parts)
-
-        # 策略4: 提取 <output> 标签后的内容（可能包含未闭合的标签）
-        output_match = re.search(r"<output[^>]*>", llm_raw, re.IGNORECASE)
-        if output_match:
-            after_output = llm_raw[output_match.end():].strip()
-            if after_output:
-                cleaned = re.sub(r"<[^>]+>", "", after_output).strip()
-                cleaned = re.sub(r"^(reasoning|assistant)\s*", "", cleaned, flags=re.IGNORECASE).strip()
-                # 跳过工具执行状态文本（如"执行工具 task_plan:..."）
-                if cleaned and len(cleaned) > 5 and not re.match(
-                    r"^(执行工具|调用工具|Running tool|Calling tool)", cleaned, re.IGNORECASE
-                ):
-                    return cleaned
-
-        # 策略5: 提取去除 XML 标签后的整体文本
+        # 去除所有 XML 标签
         cleaned = re.sub(r"<[^>]+>", "", llm_raw).strip()
         cleaned = re.sub(r"^(reasoning|assistant)\s*", "", cleaned, flags=re.IGNORECASE).strip()
         # 跳过工具执行状态文本
-        if cleaned and len(cleaned) > 10 and not re.match(
+        if cleaned and len(cleaned) > 5 and not re.match(
             r"^(执行工具|调用工具|Running tool|Calling tool)", cleaned, re.IGNORECASE
         ):
             return cleaned
@@ -783,13 +723,13 @@ class MainAgent(BaseAgent):
         agent_path: Optional[str] = None,
     ) -> AgentContext:
         """
-        V2 主处理循环 — 使用结构化输出格式。
+        V2 主处理循环 — 使用原生 tool_calling。
 
         核心流程:
           1. 使用 ContextBuilder 构建 <context> XML
           2. 将 context 注入 SYSTEM_PROMPT，调用 LLM
-          3. 使用 OutputParser 解析 <output> XML
-          4. 根据 parsed.tools_to_call 依次执行工具
+          3. LLM 通过原生 tool_calling 返回工具调用
+          4. 根据 tool_calls 依次执行工具
           5. 任一工具超时 → 强制回调 LLM
           6. 根据 callback 标志决定是否回调 LLM
           7. 处理 remember/recall
@@ -1240,199 +1180,19 @@ class MainAgent(BaseAgent):
                 continue
 
             else:
-                # 没有原生工具调用 → 检查是否为旧格式 <output> XML（某些模型不支持 tool_calling）
+                # [v1.47.21] 没有原生工具调用 → 纯文本回复
+                # 完全依赖 tool_calling，不再解析 <output> XML
                 raw_content = (response.content or "").strip()
 
-                # [v1.47.16] 兼容旧格式：当 LLM 输出 <output> XML 时，用 output_parser 解析
-                if raw_content.startswith("<output") or ("<output>" in raw_content and "<toolstocal>" in raw_content):
-                    logger.info(f"[{task_id}] 检测到旧格式 <output> XML 输出，启用 output_parser 解析")
-                    parsed = parse_output(raw_content)
-
-                    if parsed.parse_success:
-                        # 1) 处理 mainsubject → 更新会话标题
-                        if parsed.mainsubject and self.dispatcher:
-                            try:
-                                await self.dispatcher.dispatch(
-                                    tool_name="update_conversation_title",
-                                    params={"title": parsed.mainsubject, "session_id": context.session_id},
-                                    timeout=10,
-                                )
-                            except Exception:
-                                pass
-
-                        # 2) 处理 remember → 保存记忆
-                        if parsed.remember and self.dispatcher:
-                            try:
-                                await self.dispatcher.dispatch(
-                                    tool_name="save_memory",
-                                    params={
-                                        "content": parsed.remember,
-                                        "type": parsed.remember_type or "session",
-                                        "session_id": context.session_id,
-                                    },
-                                    timeout=10,
-                                )
-                            except Exception:
-                                pass
-
-                        # 3) 处理 task_plan
-                        if parsed.task_plan and self.dispatcher:
-                            try:
-                                await self.dispatcher.dispatch(
-                                    tool_name="task_plan",
-                                    params={"action": "create", "plan": parsed.task_plan},
-                                    timeout=10,
-                                )
-                                current_task_plan = parsed.task_plan
-                                await self._emit_v2_event(
-                                    "v2_task_plan",
-                                    {"plan": truncate_str(current_task_plan, 2000)},
-                                    stream_callback,
-                                )
-                            except Exception:
-                                pass
-
-                        # 4) 处理 tools_to_call → 执行工具
-                        if parsed.tools_to_call:
-                            logger.info(f"[{task_id}] 从 <output> XML 提取到 {len(parsed.tools_to_call)} 个工具调用")
-
-                            # 添加 assistant 消息到消息列表
-                            messages.append(Message(
-                                role="assistant",
-                                content=raw_content,
-                            ))
-
-                            # 保存 LLM 原始输出
-                            if self.memory:
-                                self.memory.add_session(agent_id=_effective_agent_id,
-                                    session_id=context.session_id,
-                                    role="assistant",
-                                    content=raw_content,
-                                    key="llm_output",
-                                    importance=0.3,
-                                )
-
-                            for tool_desc in parsed.tools_to_call:
-                                _tc_name = tool_desc.get("toolname", "")
-                                _tc_parms = tool_desc.get("parms", "{}")
-                                _tc_timeout = int(tool_desc.get("timeout", 120))
-
-                                if not _tc_name:
-                                    continue
-
-                                # 注入 session_id
-                                if _tc_name in ("save_memory", "recall_memory", "update_conversation_title"):
-                                    if isinstance(_tc_parms, str):
-                                        try:
-                                            _tc_parms_dict = json.loads(_tc_parms)
-                                        except (json.JSONDecodeError, TypeError):
-                                            _tc_parms_dict = {"raw_input": _tc_parms}
-                                    else:
-                                        _tc_parms_dict = _tc_parms
-                                    _tc_parms_dict.setdefault("session_id", context.session_id)
-                                    _tc_parms = json.dumps(_tc_parms_dict, ensure_ascii=False)
-
-                                # 发送工具开始事件
-                                await self._emit_v2_event(
-                                    "v2_tool_start",
-                                    {"tool": {"toolname": _tc_name, "parms": truncate_str(str(_tc_parms), 500)}},
-                                    stream_callback,
-                                )
-
-                                self._add_exec_event("tool_call", {
-                                    "title": f"调用工具: {_tc_name}",
-                                    "tool_name": _tc_name,
-                                    "arguments": str(_tc_parms),
-                                })
-
-                                # 执行工具
-                                tool_result = await self._execute_v2_tool(
-                                    _tc_name, str(_tc_parms), _tc_timeout,
-                                    context, task_id,
-                                    stream_callback=stream_callback,
-                                    sent_files=_sent_files,
-                                    agent_path=agent_path,
-                                )
-
-                                # 提取输出
-                                if tool_result is None:
-                                    tool_result = {"success": False, "error": "工具返回了空结果"}
-                                _output_text = (
-                                    tool_result.get("output", "")
-                                    or tool_result.get("message", "")
-                                    or tool_result.get("stdout", "")
-                                    or tool_result.get("error", "")
-                                )
-                                if not _output_text and tool_result.get("data"):
-                                    try:
-                                        _output_text = json.dumps(tool_result["data"], ensure_ascii=False, default=str)[:30000]
-                                    except Exception:
-                                        _output_text = str(tool_result["data"])[:30000]
-
-                                # 发送工具结果事件
-                                await self._emit_v2_event(
-                                    "v2_tool_result",
-                                    {"tool": {"toolname": _tc_name}, "result": {
-                                        "success": tool_result.get("success", False),
-                                        "output": truncate_str(_output_text, 30000),
-                                        "error": truncate_str(tool_result.get("error", ""), 30000),
-                                    }},
-                                    stream_callback,
-                                )
-
-                                self._add_exec_event("tool_result", {
-                                    "title": f"工具结果: {_tc_name}",
-                                    "tool_name": _tc_name,
-                                    "success": tool_result.get("success", False),
-                                    "summary": truncate_str(_output_text, 30000),
-                                })
-
-                                # 添加 tool result 消息
-                                messages.append(Message(
-                                    role="user",
-                                    content=f"[工具结果: {_tc_name}] {truncate_str(_output_text, 5000)}",
-                                ))
-
-                            # 工具执行完毕 → 继续循环让 LLM 处理结果
-                            continue
-
-                        # 5) 没有工具但有 reply → 提取纯文本回复
-                        if parsed.reply:
-                            reply_text = parsed.reply.strip()
-                        else:
-                            # 兜底：去除所有 XML 标签
-                            import re as _re_xml
-                            reply_text = _re_xml.sub(r'<[^>]+>', '', raw_content).strip()
-
-                        if not reply_text:
-                            reply_text = "处理完毕。"
-
-                        context.working_memory["final_response"] = reply_text
-                        await self._emit_v2_event("v2_reasoning", {"content": truncate_str(reply_text, 3000)}, stream_callback)
-
-                        # 保存回复到会话记忆
-                        if self.memory:
-                            self.memory.add_session(agent_id=_effective_agent_id,
-                                session_id=context.session_id,
-                                role="assistant",
-                                content=reply_text,
-                                key="reply",
-                                importance=0.5,
-                            )
-
-                        # 保存 LLM 原始输出
-                        if self.memory:
-                            self.memory.add_session(agent_id=_effective_agent_id,
-                                session_id=context.session_id,
-                                role="assistant",
-                                content=raw_content,
-                                key="llm_output",
-                                importance=0.3,
-                            )
-
-                        break
+                # 如果模型意外输出了 XML 标签，清理掉
+                import re as _re_clean
+                if raw_content.startswith("<") and "</" in raw_content:
+                    # 清除 XML 标签，提取纯文本
+                    cleaned = _re_clean.sub(r'<[^>]+>', '', raw_content).strip()
+                    if cleaned:
+                        raw_content = cleaned
+                        logger.info(f"[{task_id}] 清理了 LLM 输出中的 XML 标签")
 
-                # 纯文本回复（非 XML 格式）
                 reply_text = raw_content
                 logger.info(f"[{task_id}] 无工具调用，任务完成 (reply长度={len(reply_text)})")
 

package/package.json

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

package/web/api_server.py

@@ -7901,11 +7901,10 @@ window.addEventListener('beforeunload', function() {{
             # 4. 检测到裸 JSON（整个回复以 { 开头）：进入 action 模式，提取 thought
             # 5. 代码块结束后回到文本模式，继续流式推送
             _stream_state = {
-                "mode": "text",         # "text" | "action_block" | "tasklist_block" | "bare_json" | "output_xml"
+                "mode": "text",         # "text" | "action_block" | "tasklist_block" | "bare_json"
                 "processed_pos": 0,     # 已处理到的位置（用于去重 streaming）
                 "thought_sent": 0,      # 已推送的 thought 长度
                 "action_block_depth": 0, # ``` 嵌套深度
-                "reply_sent": 0,        # [v1.47.16] output_xml 模式下已推送的 reply 长度
             }
 
             # 需要回退(hold back)的最大字符数，用于检测 ```action 或 ```tasklist 标记
@@ -7914,30 +7913,12 @@ window.addEventListener('beforeunload', function() {{
             _MAX_HOLD = 12
 
             async def _text_delta_callback(full_text_so_far: str, delta_text: str):
-                """智能流式过滤器：文本正常推送，JSON action 块拦截，<output> XML 拦截"""
+                """[v1.47.21] 智能流式过滤器：文本正常推送，JSON action 块拦截"""
                 st = _stream_state
                 remaining = full_text_so_far[st["processed_pos"]:]
 
                 while remaining:
                     if st["mode"] == "text":
-                        # ── [v1.47.16] 检测 <output> XML 标签 → 进入 output_xml 模式 ──
-                        output_marker = remaining.find("<output")
-                        if output_marker >= 0:
-                            # 推送 <output> 之前的文本
-                            text_before = remaining[:output_marker]
-                            if text_before.strip():
-                                await _write_sse({"type": "text_delta", "content": text_before})
-                                _all_streamed_text_parts.append(text_before)
-                            # 跳过 <output...> 开始标签
-                            tag_end = remaining.find(">", output_marker)
-                            if tag_end >= 0:
-                                st["processed_pos"] += tag_end + 1
-                            else:
-                                st["processed_pos"] += len(remaining)
-                            st["mode"] = "output_xml"
-                            remaining = full_text_so_far[st["processed_pos"]:]
-                            continue
-
                         # ── 文本模式：寻找 ```action 或 ```tasklist 标记 ──
                         action_marker = remaining.find("```action")
                         tasklist_marker = remaining.find("```tasklist")
@@ -8056,63 +8037,9 @@ window.addEventListener('beforeunload', function() {{
                         remaining = ""
                         break
 
-                    elif st["mode"] == "output_xml":
-                        # ── [v1.47.16] <output> XML 模式：提取 <reply> 内容流式推送，其余全部拦截 ──
-                        # 策略：在 output_xml 模式下，只在检测到 <reply> 内容时推送，其他标签内容全部跳过
-                        import re as _re_xml_stream
-
-                        # 检查 </output> 闭合标签 → 退出 output_xml 模式
-                        close_output = remaining.find("</output>")
-                        if close_output >= 0:
-                            # 在闭合标签前，检查是否有未推送的 <reply> 内容
-                            before_close = full_text_so_far[st["processed_pos"]:st["processed_pos"] + close_output]
-                            # 尝试提取 <reply> 内容
-                            reply_m = _re_xml_stream.search(r'<reply[^>]*>([\s\S]*?)</reply>', before_close)
-                            if reply_m and reply_m.group(1).strip():
-                                reply_content = reply_m.group(1).strip()
-                                new_part = reply_content[st["reply_sent"]:]
-                                if new_part:
-                                    await _write_sse({"type": "text_delta", "content": new_part})
-                                    _all_streamed_text_parts.append(new_part)
-                                st["reply_sent"] = len(reply_content)
-                            # 跳过到 </output> 之后
-                            st["processed_pos"] += close_output + len("</output>")
-                            st["mode"] = "text"
-                            remaining = full_text_so_far[st["processed_pos"]:]
-                            continue
-
-                        # 尚未闭合：尝试提取已闭合的 <reply>...</reply> 内容并流式推送
-                        all_so_far = full_text_so_far[st["processed_pos"]:]
-                        reply_m = _re_xml_stream.search(r'<reply[^>]*>([\s\S]*?)</reply>', all_so_far)
-                        if reply_m and reply_m.group(1).strip():
-                            reply_content = reply_m.group(1).strip()
-                            new_part = reply_content[st["reply_sent"]:]
-                            if new_part:
-                                await _write_sse({"type": "text_delta", "content": new_part})
-                                _all_streamed_text_parts.append(new_part)
-                            st["reply_sent"] = len(reply_content)
-
-                        # 尝试提取未闭合的 <reply> 内容（流式输出中标签可能尚未关闭）
-                        elif not reply_m:
-                            reply_open_m = _re_xml_stream.search(r'<reply[^>]*>([\s\S]+)$', all_so_far)
-                            if reply_open_m and reply_open_m.group(1).strip():
-                                partial_reply = reply_open_m.group(1)
-                                # 去除尾部可能的不完整标签
-                                partial_reply = _re_xml_stream.sub(r'<[^>]*$', '', partial_reply).strip()
-                                if partial_reply and len(partial_reply) > st["reply_sent"]:
-                                    new_part = partial_reply[st["reply_sent"]:]
-                                    if new_part:
-                                        await _write_sse({"type": "text_delta", "content": new_part})
-                                        _all_streamed_text_parts.append(new_part)
-                                    st["reply_sent"] = len(partial_reply)
-
-                        # 等待更多 token
-                        remaining = ""
-                        break
-
             # Stream 结束后的 flush：推送所有 hold 住的文本
             async def _flush_remaining_text(full_text: str):
-                """流结束后，推送所有剩余的文本（处理 hold back 的部分）"""
+                """[v1.47.21] 流结束后，推送所有剩余的文本（处理 hold back 的部分）"""
                 st = _stream_state
                 remaining = full_text[st["processed_pos"]:]
                 if remaining.strip() and st["mode"] == "text":
@@ -8123,25 +8050,6 @@ window.addEventListener('beforeunload', function() {{
                         await _write_sse({"type": "text_delta", "content": remaining})
                     _all_streamed_text_parts.append(remaining)
                     st["processed_pos"] = len(full_text)
-                elif st["mode"] == "output_xml":
-                    # [v1.47.16] output_xml 模式下 flush：尝试提取 <reply> 内容
-                    import re as _re_xml_flush
-                    reply_m = _re_xml_flush.search(r'<reply[^>]*>([\s\S]*?)(?:</reply>|$)', remaining)
-                    if reply_m and reply_m.group(1).strip():
-                        reply_content = reply_m.group(1).strip()
-                        new_part = reply_content[st["reply_sent"]:]
-                        if new_part:
-                            await _write_sse({"type": "text_delta", "content": new_part})
-                            _all_streamed_text_parts.append(new_part)
-                        st["reply_sent"] = len(reply_content)
-                    # 检查 </output> 之后是否还有文本
-                    close_pos = remaining.find("</output>")
-                    if close_pos >= 0:
-                        after_output = remaining[close_pos + len("</output>"):].strip()
-                        if after_output and st["mode"] == "output_xml":
-                            # 不推送（output_xml 模式结束后可能有残余标签文本）
-                            pass
-                    st["processed_pos"] = len(full_text)
 
             # Call LLM with streaming — tokens are filtered through _text_delta_callback
             # Call LLM with streaming + frequency_penalty to reduce repetition

package/web/ui/chat/chat_main.js

@@ -2999,12 +2999,10 @@ async function selectSession(id) {
       return m && (m.role === 'user' || m.role === 'assistant' || m.role === 'tool');
     }).map(function(m) {
       var content = (m.content != null) ? String(m.content) : '';
-      // [v1.47.16] 剥离 XML 标签：无 key 的旧格式 + key=reply 但仍含 XML 标签的消息
+      // [v1.47.21] 清理意外输出的 XML 标签（完全依赖 tool_calling）
       var mkey = (m.key || '').toLowerCase();
       if (m.role === 'assistant' && content && content.trim().startsWith('<')) {
-        if (!mkey || mkey === 'reply') {
-          content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
-        }
+        content = content.replace(/<[^>]+>/g, ' ').replace(/\s{2,}/g, ' ').trim();
       }
       var mapped = {
         role: m.role || 'assistant',
@@ -3110,10 +3108,9 @@ async function loadMoreMessages() {
     }).map(function(m) {
       var content = (m.content != null) ? String(m.content) : '';
       var mkey = (m.key || '').toLowerCase();
+      // [v1.47.21] 清理意外输出的 XML 标签
       if (m.role === 'assistant' && content && content.trim().startsWith('<')) {
-        if (!mkey || mkey === 'reply' || (mkey !== 'tool_call' && mkey !== 'reasoning')) {
-          content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
-        }
+        content = content.replace(/<[^>]+>/g, ' ').replace(/\s{2,}/g, ' ').trim();
       }
       var mapped = {
         role: m.role || 'assistant',

package/web/ui/chat/flow_engine.js

@@ -398,12 +398,9 @@ async function pollChatHistory() {
     }).map(function(m) {
       var content = (m.content != null) ? String(m.content) : '';
       var mkey = (m.key || '').toLowerCase();
-      // [v1.47.16] 剥离 XML 标签：无 key 的旧格式 + key=reply 但仍含 XML 标签的消息
-      // 有 key 的消息（reasoning/reply/tool_call）一般已是纯内容，但部分模型仍会输出 XML
+      // [v1.47.21] 清理意外输出的 XML 标签（完全依赖 tool_calling，不再解析 XML）
       if (m.role === 'assistant' && content && content.trim().startsWith('<')) {
-        if (!mkey || mkey === 'reply') {
-          content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
-        }
+        content = content.replace(/<[^>]+>/g, ' ').replace(/\s{2,}/g, ' ').trim();
       }
       var mapped = {
         role: m.role || 'assistant',
@@ -475,11 +472,9 @@ async function forceRefreshHistory() {
     }).map(function(m) {
       var content = (m.content != null) ? String(m.content) : '';
       var mkey = (m.key || '').toLowerCase();
-      // [v1.47.16] 剥离 XML 标签：无 key 的旧格式 + key=reply 但仍含 XML 标签的消息
+      // [v1.47.21] 清理意外输出的 XML 标签
       if (m.role === 'assistant' && content && content.trim().startsWith('<')) {
-        if (!mkey || mkey === 'reply') {
-          content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
-        }
+        content = content.replace(/<[^>]+>/g, ' ').replace(/\s{2,}/g, ' ').trim();
       }
       var mapped = {
         role: m.role || 'assistant',
@@ -1120,34 +1115,13 @@ function _showFinishNotification(text) {
 }
 
 /**
- * Strip XML tags from text for real-time streaming preview in V2 mode.
- * Shows plain text between tags so the user sees progress during LLM streaming.
+ * [v1.47.21] Strip XML tags from text — simple regex cleanup for accidental XML output.
+ * No longer parses <output>/<reply>/<toolstocal> — fully relies on native tool_calling.
  */
 function _stripXmlTags(xml) {
   if (!xml) return '';
-  var text = xml;
-  // [v1.15.12] 移除未闭合的 <task_plan>...</task_plan> 区域（流式输出中常见）
-  // 当只有开始标签没有闭合标签时，将开始标签到文本末尾的内容完全移除
-  text = text.replace(/<task_plan[^>]*>[\s\S]*?<\/task_plan>/g, '');  // 已闭合的完整 task_plan
-  text = text.replace(/<task_plan[^>]*>[\s\S]*$/g, '');  // 未闭合的 task_plan（流式中标签已打开但未关闭）
-  // [v1.37] 优先提取 <reply> 标签内容，不再兜底 <response>
-  var replyMatch = text.match(/<reply[^>]*>([\s\S]*?)<\/reply>/i);
-  if (replyMatch && replyMatch[1] && replyMatch[1].trim()) {
-    return replyMatch[1].trim();
-  }
-  // [v1.37] 移除 <response> 包裹（不再作为兜底提取，直接剥离标签）
-  text = text.replace(/<response[^>]*>|<\/response>/gi, '');
-  // 兜底：去除所有XML标签
-  return text
-    .replace(/<[^>]+>/g, ' ')     // Replace tags with space
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-    .replace(/&amp;/g, '&')
-    .replace(/&quot;/g, '"')
-    .replace(/&#39;/g, "'")
-    .replace(/&#x27;/g, "'")
-    .replace(/\s{3,}/g, ' ')      // Collapse 3+ whitespace to single space
-    .trim();
+  return xml.replace(/<[^>]+>/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&').replace(/\s{2,}/g, ' ').trim();
 }
 
 // ══════════════════════════════════════════════════════

package/worklog.md

@@ -117,3 +117,30 @@ Stage Summary:
 - Streaming filter extracts only `<reply>` content for real-time display
 - Frontend strips XML from both keyless and key="reply" assistant messages
 - VNC mode Firefox support fully functional
+
+---
+Task ID: 2
+Agent: Main
+Task: Fix Firefox+VNC browser_stealth: content/close/evaluate/wait_for + browser_open/web_control VNC fallback
+
+Work Log:
+- Analyzed logs: stealth_browser_navigate now works (Popen non-blocking), but stealth_browser_content returns "不支持" and agent falls back to web_control/browser_open which also fail in VNC mode
+- Added `_firefox_read_sessionstore()` method: reads Firefox's recovery.jsonlz4 (mozLz4 format) to get current tab URL/title
+- Added `_firefox_get_content()` method: screenshot + sessionstore → returns screenshot path, URL, title, tabs list
+- Changed `get_content()` Firefox mode: calls `_firefox_get_content()` instead of returning error
+- Changed `get_html()` Firefox mode: calls `_firefox_get_content()` instead of returning error
+- Changed `close()` Firefox mode: VNC mode only clears internal state, does NOT kill Firefox (managed by vnc_manager)
+- Changed `StealthBrowserCloseSkill.execute()`: VNC mode returns "会话已释放" instead of "浏览器已关闭"
+- Changed `evaluate()` Firefox mode: better error message suggesting stealth_browser alternatives
+- Changed `wait_for()` Firefox mode: sleep + sessionstore read instead of returning error
+- Changed `browser_open` in chromedev_mcp.py: VNC mode without Chromium → returns error suggesting stealth_browser
+- Added VNC mode hint injection in main_agent.py system prompt: tells agent to use stealth_browser_* tools in VNC mode
+- Published v1.47.20 to npm
+
+Stage Summary:
+- Firefox+VNC mode: stealth_browser_content now returns screenshot + tab info (URL/title/tabs)
+- Firefox+VNC mode: close() no longer kills VNC browser process
+- Firefox+VNC mode: wait_for() works (sleep + sessionstore), evaluate() has actionable error message
+- browser_open: VNC mode without Chromium → clear error suggesting stealth_browser
+- main_agent: VNC mode system prompt tells agent to prefer stealth_browser over browser_open/web_control
+- All syntax checks passed

package/core/output_parser.py

@@ -1,730 +0,0 @@
-"""
-Custom Fault-Tolerant XML Output Parser Module.
-
-Parses the XML ``<output>`` block generated by the LLM in response to the
-system prompt.  The LLM produces structured XML that drives the agent's
-execution loop — including tool calls, memory operations, user interaction
-hints, and loop-control flags.
-
-**This module does NOT use xml.etree.ElementTree.**  All parsing is done with
-pure Python + regex to achieve maximum fault tolerance.
-
-Expected XML schema produced by the LLM::
-
-    <output>
-        <mainsubject>当前对话的6字以内标题</mainsubject>
-        <usersays_correct>...</usersays_correct>
-        <reply>展示给用户的文本内容</reply>
-        <toolstocal>
-            <tool>
-                
-                <toolname>工具名</toolname>
-                <parms>参数JSON或描述</parms>
-                <timeout>预估超时时限(秒)</timeout>
-            </tool>
-        </toolstocal>
-        <remember>
-            <type>global|session</type>
-            <content>记忆内容</content>
-        </remember>
-        <recall>下一轮需要调取的记忆</recall>
-        <get_knowledge>下一轮需要搜索获得的知识</get_knowledge>
-    </output>
-
-Fault-tolerance features:
-
-* Text before ``<output>`` or after ``</output>`` is silently stripped.
-* Unclosed tags are auto-closed at the next sibling tag boundary.
-* Self-closing tags (``<tag/>``) resolve to empty strings.
-* Case-insensitive tag matching (``<OUTPUT>`` == ``<output>``).
-* Tag-name aliases (reserved for future use).
-* If extraction yields nothing meaningful, ``needs_correction`` is set to
-  ``True`` so the caller can ask the LLM to re-format.
-"""
-
-from __future__ import annotations
-
-import html
-import re
-from dataclasses import dataclass, field
-from typing import Any, Dict, List
-
-from core.logger import get_logger
-
-logger = get_logger("myagent.output_parser")
-
-# ---------------------------------------------------------------------------
-# Constants
-# ---------------------------------------------------------------------------
-
-_DEFAULT_TIMEOUT: int = 120
-
-# All top-level tags we recognise inside <output>.
-KNOWN_TOP_LEVEL_TAGS = [
-    "usersays_correct",
-    "task_plan",  # 任务计划（Markdown格式）
-    "toolstocal",
-    "remember",
-    "recall",
-    "knowledge",
-    "get_knowledge",
-
-    "reply",  # [v1.36] 用户可见文本（顶层标签，不再嵌套在 <response> 内）
-    # [v1.37] "response" 已移除 — 不再兼容 <response> 包裹，统一使用 <reply>
-    "mainsubject",  # [v1.15.8] 会话标题自动命名
-]
-
-# Inner tags inside each <tool>.
-TOOL_INNER_TAGS = [
-    "toolname",
-    "parms",
-    "timeout",
-]
-
-# Inner tags inside <remember>.
-REMEMBER_INNER_TAGS = ["type", "content"]
-
-# Tag aliases: canonical name -> list of aliases.
-_TAG_ALIASES: Dict[str, List[str]] = {
-    # [v1.36] askuser/ask_user aliases removed — tag no longer used
-}
-
-# Build reverse lookup: alias -> canonical.
-_ALIAS_TO_CANONICAL: Dict[str, str] = {}
-for _canonical, _aliases in _TAG_ALIASES.items():
-    for _alias in _aliases:
-        _ALIAS_TO_CANONICAL[_alias.lower()] = _canonical
-
-
-# ---------------------------------------------------------------------------
-# Data classes
-# ---------------------------------------------------------------------------
-
-
-@dataclass
-class ParsedOutput:
-    """Structured representation of the LLM's ``<output>`` block.
-
-    Attributes:
-        usersays_correct: Corrected / canonicalised version of the user's
-            voice input.
-        task_plan: Updated or new task plan (may contain Markdown).
-        tools_to_call: Ordered list of tool descriptors to execute.
-        remember: Content that should be persisted to the agent's memory.
-        remember_type: "global" (cross-session) or "session" (current session only).
-        recall: Memory keys / descriptions to retrieve for the next loop
-            iteration.
-        knowledge: Knowledge content the LLM wants to persist.
-        get_knowledge: Knowledge search keywords for the next loop iteration.
-        reply: User-visible text content extracted from <reply> tag (sole display content).
-        raw_text: The verbatim raw text returned by the LLM.
-        parse_success: Whether parsing extracted at least one meaningful field.
-        needs_correction: When ``True``, the caller should send the raw text
-            back to the LLM for re-formatting.
-    """
-
-    usersays_correct: str = ""
-    task_plan: str = ""  # 任务计划（Markdown格式）
-    tools_to_call: List[Dict[str, Any]] = field(default_factory=list)
-    remember: str = ""
-    remember_type: str = ""
-    recall: str = ""
-    knowledge: str = ""
-    get_knowledge: str = ""
-
-    reply: str = ""  # [v1.37] 用户可见文本（<reply> 标签，唯一回复来源）
-    mainsubject: str = ""  # [v1.15.8] 会话标题自动命名（6字以内）
-    raw_text: str = ""
-    parse_success: bool = False
-    needs_correction: bool = False
-    output_block_complete: bool = False  # </output> 闭合标签是否存在
-
-
-# ---------------------------------------------------------------------------
-# Low-level extraction helpers
-# ---------------------------------------------------------------------------
-
-
-def _safe_strip(value: str | None) -> str:
-    if value is None:
-        return ""
-    return value.strip()
-
-
-def _parse_bool(value: str | None, default: bool) -> bool:
-    if value is None:
-        return default
-    stripped = value.strip().lower()
-    if stripped in ("true", "1", "yes"):
-        return True
-    if stripped in ("false", "0", "no"):
-        return False
-    return default
-
-
-def _parse_int(value: str | None, default: int) -> int:
-    if value is None:
-        return default
-    try:
-        return int(value.strip())
-    except (ValueError, TypeError):
-        return default
-
-
-def _canonical_tag(tag_name: str) -> str:
-    """Return the canonical tag name for *tag_name* (alias-aware, lowercased)."""
-    lower = tag_name.strip().lower()
-    return _ALIAS_TO_CANONICAL.get(lower, lower)
-
-
-def _extract_tag_content(text: str, tag_name: str, stop_tags: List[str] | None = None, *, conservative: bool = False) -> str:
-    """Extract the text content of ``<tag_name>…</tag_name>`` from *text*.
-
-    Fault-tolerant strategies tried in order:
-
-    1. **Properly closed**: ``<tag>content</tag>``
-    2. **Unclosed at next sibling opening tag**: ``<tag>content<next_tag>…``
-    3. **Unclosed at ``</output>``**: ``<tag>content</output>``
-    4. **Self-closing**: ``<tag/>``
-    5. **Opening tag at end of string**: ``<tag>content$``
-
-    Parameters:
-        text: The text to search within (typically the body of ``<output>``).
-        tag_name: The tag name to extract (case-insensitive).
-        stop_tags: Sibling tag names that signal the end of this tag's
-            content (used for unclosed-tag detection).  Defaults to
-            ``KNOWN_TOP_LEVEL_TAGS``.
-    """
-    if not text or not tag_name:
-        return ""
-
-    if stop_tags is None:
-        stop_tags = KNOWN_TOP_LEVEL_TAGS
-
-    tag_esc = re.escape(tag_name)
-
-    # Strategy 1: Properly closed <tag>content</tag>
-    m = re.search(
-        rf"<{tag_esc}[^>]*>(.*?)</{tag_esc}\s*>",
-        text,
-        re.DOTALL | re.IGNORECASE,
-    )
-    if m:
-        return html.unescape(m.group(1))
-
-    # Conservative mode: only extract properly closed tags, skip all fallbacks
-    if conservative:
-        return ""
-
-    # Strategy 2: Unclosed — content runs until the next opening/closing
-    # sibling tag or </output>.
-    sibling_names = [t for t in stop_tags if t.lower() != tag_name.lower()]
-    if sibling_names:
-        sibling_pat = "|".join(re.escape(t) for t in sibling_names)
-        # CRITICAL: Wrap sibling_pat in (?:...) so that | doesn't split the
-        # leading < or </ from the alternation.  Without this, e.g.
-        # "<a|b|c" is parsed as "<a" OR "b" OR "c" — NOT "<a" OR "<b" OR "<c".
-        boundary = rf"(?:</output\s*>|<(?:{sibling_pat})\b|</(?:{sibling_pat})\s*>)"
-    else:
-        boundary = r"</output\s*>"
-
-    m = re.search(
-        rf"<{tag_esc}[^>]*>(.*?)({boundary})",
-        text,
-        re.DOTALL | re.IGNORECASE,
-    )
-    if m:
-        return html.unescape(m.group(1))
-
-    # Strategy 3: Self-closing <tag/> or <tag />
-    m = re.search(rf"<{tag_esc}[^>]*/\s*>", text, re.IGNORECASE)
-    if m:
-        return ""
-
-    # Strategy 4: Opening tag at end of text with no closing
-    m = re.search(
-        rf"<{tag_esc}[^>]*>(.*?)$",
-        text,
-        re.DOTALL | re.IGNORECASE,
-    )
-    if m:
-        content = m.group(1).strip()
-        # Only return if there's actual content (not just whitespace)
-        if content:
-            return html.unescape(content)
-
-    return ""
-
-
-def _extract_all_tag_blocks(
-    text: str,
-    tag_name: str,
-    parent_close_tag: str | None = None,
-    *,
-    conservative: bool = False,
-) -> List[str]:
-    """Extract all ``<tag_name>…`` blocks from *text*.
-
-    Used for extracting multiple ``<tool>`` blocks from ``<toolstocal>``
-    content.  Handles both properly closed and unclosed blocks.
-
-    Returns a list of content strings, one per block.
-    """
-    if not text:
-        return []
-
-    tag_esc = re.escape(tag_name)
-    blocks: List[str] = []
-
-    # Strategy 1: Find all properly closed <tag>content</tag> blocks
-    properly_closed = re.findall(
-        rf"<{tag_esc}[^>]*>(.*?)</{tag_esc}\s*>",
-        text,
-        re.DOTALL | re.IGNORECASE,
-    )
-    if properly_closed:
-        return [html.unescape(b) for b in properly_closed]
-
-    # Conservative mode: only extract properly closed blocks
-    if conservative:
-        return []
-
-    # Strategy 2: Split by <tag> openings — each segment is a block
-    positions = [
-        m.end() for m in re.finditer(rf"<{tag_esc}[^>]*>", text, re.IGNORECASE)
-    ]
-
-    for i, content_start in enumerate(positions):
-        if i + 1 < len(positions):
-            # Block ends at next <tag> opening
-            content_end = positions[i + 1]
-        elif parent_close_tag:
-            # Last block — ends at parent close tag
-            close_m = re.search(
-                re.escape(parent_close_tag),
-                text[content_start:],
-                re.IGNORECASE,
-            )
-            content_end = content_start + close_m.start() if close_m else len(text)
-        else:
-            content_end = len(text)
-
-        blocks.append(html.unescape(text[content_start:content_end]))
-
-    return blocks
-
-
-def _extract_output_body(raw_text: str) -> str | None:
-    """Extract the content between ``<output>`` and ``</output>``.
-
-    If ``</output>`` is missing (unclosed), returns everything after the
-    opening ``<output>`` tag.
-
-    Returns ``None`` if no ``<output>`` opening tag is found at all.
-    """
-    open_match = re.search(r"<output[^>]*>", raw_text, re.IGNORECASE)
-    if open_match is None:
-        return None
-
-    content_start = open_match.end()
-
-    close_match = re.search(
-        r"</output\s*>",
-        raw_text[content_start:],
-        re.IGNORECASE,
-    )
-    if close_match:
-        return raw_text[content_start : content_start + close_match.start()]
-
-    # Unclosed <output> — take everything after it
-    return raw_text[content_start:]
-
-
-def _strip_outer_noise(text: str) -> str:
-    """Remove text that is outside any recognised XML tags.
-
-    This handles the case where the LLM outputs plain text before or
-    after the ``<output>`` block, e.g.::
-
-        "我来使用 Python 脚本下载... <output>...</output>"
-
-    The function returns the ``<output>…</output>`` body, or the original
-    text if no output block is found.
-    """
-    if not text:
-        return text
-
-    body = _extract_output_body(text)
-    if body is not None:
-        return body
-
-    # No <output> tag at all — check if there are any recognised tags
-    has_tags = False
-    for tag in KNOWN_TOP_LEVEL_TAGS:
-        if re.search(rf"<{re.escape(tag)}[\s>]", text, re.IGNORECASE):
-            has_tags = True
-            break
-
-    if has_tags:
-        # Tags exist but no <output> wrapper — return as-is
-        return text
-
-    # No tags at all — return original (caller will set needs_correction)
-    return text
-
-
-def is_output_block_complete(raw_text: str) -> bool:
-    """Check if *raw_text* contains a properly closed ``<output>...</output>`` block.
-
-    Returns:
-        True if both ``<output>`` and ``</output>`` tags are present.
-        False if neither tag, or only the opening tag, is found.
-    """
-    if not raw_text:
-        return False
-    open_m = re.search(r"<output[^>]*>", raw_text, re.IGNORECASE)
-    if open_m is None:
-        return False
-    close_m = re.search(r"</output\s*>", raw_text[open_m.end():], re.IGNORECASE)
-    return close_m is not None
-
-
-# ---------------------------------------------------------------------------
-# Core custom parser — NO xml.etree.ElementTree
-# ---------------------------------------------------------------------------
-
-
-def _custom_parse(raw_text: str) -> ParsedOutput:
-    """Fully custom, regex-based XML parser with maximum fault tolerance.
-
-    This function does NOT use ``xml.etree.ElementTree`` at all.  Every
-    extraction is done via regex patterns that handle malformed XML
-    gracefully.
-
-    Returns a :class:`ParsedOutput` with ``parse_success=True`` if at least
-    one meaningful field was extracted, or ``needs_correction=True`` if
-    nothing could be parsed.
-    """
-    parsed = ParsedOutput(raw_text=raw_text)
-
-    if not raw_text or not raw_text.strip():
-        parsed.needs_correction = True
-        return parsed
-
-    # ── Step 0: 检查 <output> 块，处理缺少开始/闭合标签的情况 ──
-    _has_open = bool(re.search(r"<output[^>]*>", raw_text, re.IGNORECASE))
-    _has_close = bool(re.search(r"</output\s*>", raw_text, re.IGNORECASE))
-
-    if not _has_open and not _has_close:
-        # 完全没有 <output> 标签 — 检查是否包含已知子标签
-        _has_known_tags = any(
-            re.search(rf"<{re.escape(t)}[\s>]", raw_text, re.IGNORECASE)
-            for t in KNOWN_TOP_LEVEL_TAGS
-        )
-        if _has_known_tags:
-            # 有子标签但缺少 <output> 包装 — 自动补全后正常解析
-            logger.info(
-                "LLM 输出缺少 <output> 标签但包含已知子标签，"
-                "自动补全 <output> 包装后解析"
-            )
-            raw_text = "<output>\n" + raw_text.strip() + "\n</output>"
-            parsed.output_block_complete = True
-        else:
-            parsed.output_block_complete = False
-    elif _has_open and not _has_close:
-        parsed.output_block_complete = False
-    elif not _has_open and _has_close:
-        # 有闭合标签但没开始标签 — 补全开始标签
-        logger.info("LLM 输出缺少 <output> 开始标签但有 </output>，自动补全")
-        raw_text = "<output>\n" + raw_text.strip()
-        parsed.output_block_complete = True
-    else:
-        parsed.output_block_complete = True
-
-    conservative = not parsed.output_block_complete
-
-    if conservative:
-        logger.warning(
-            "XML <output> 块不完整（缺少 </output> 闭合标签），"
-            "启用保守解析模式（仅提取完整闭合的标签）\n"
-            "====== LLM 完整输出开始 ======\n"
-            f"{raw_text}\n"
-            "====== LLM 完整输出结束 ======"
-        )
-
-    # ── Step 1: Strip non-XML noise (text before/after <output>) ──
-    body = _strip_outer_noise(raw_text)
-
-    # ── Step 2: Extract each known top-level tag ──
-
-    # usersays_correct
-    raw_val = _extract_tag_content(body, "usersays_correct", conservative=conservative)
-    parsed.usersays_correct = _safe_strip(raw_val)
-
-    # task_plan [v1.34.5] 任务计划（Markdown格式）
-    raw_val = _extract_tag_content(body, "task_plan", conservative=conservative)
-    parsed.task_plan = _safe_strip(raw_val)
-
-    # [v1.37] 不再提取 <response> — 统一使用 <reply>，<response> 标签直接剥离不保留
-    # reply — 用户可见文本（唯一回复来源）
-    # [v1.38] 保守模式下 <reply> 仍尝试宽松提取 — LLM 输出截断时 <reply> 常不完整但包含重要内容
-    raw_val = _extract_tag_content(body, "reply", conservative=conservative)
-    if not raw_val.strip() and conservative:
-        # 保守模式未提取到闭合的 <reply>，尝试宽松模式（允许未闭合标签）
-        raw_val = _extract_tag_content(body, "reply", conservative=False)
-        if raw_val.strip():
-            logger.info("保守模式下 <reply> 未闭合但通过宽松提取恢复内容")
-    parsed.reply = _safe_strip(raw_val)
-
-    # recall
-    raw_val = _extract_tag_content(body, "recall", conservative=conservative)
-    parsed.recall = _safe_strip(raw_val)
-
-    # knowledge
-    raw_val = _extract_tag_content(body, "knowledge", conservative=conservative)
-    parsed.knowledge = _safe_strip(raw_val)
-
-    # get_knowledge
-    raw_val = _extract_tag_content(body, "get_knowledge", conservative=conservative)
-    parsed.get_knowledge = _safe_strip(raw_val)
-
-
-
-    # mainsubject [v1.15.8] 会话标题自动命名
-    raw_val = _extract_tag_content(body, "mainsubject", conservative=conservative)
-    parsed.mainsubject = _safe_strip(raw_val)
-
-    # ── Step 3: Parse <remember> (may contain <type> and <content>) ──
-    remember_raw = _extract_tag_content(body, "remember", conservative=conservative)
-    if remember_raw.strip():
-        # Try structured format: <type>global</type><content>...</content>
-        type_val = _extract_tag_content(remember_raw, "type", REMEMBER_INNER_TAGS, conservative=conservative)
-        content_val = _extract_tag_content(remember_raw, "content", REMEMBER_INNER_TAGS, conservative=conservative)
-
-        if content_val.strip():
-            mem_type = _safe_strip(type_val) or "session"
-            if mem_type not in ("global", "session"):
-                mem_type = "session"
-            parsed.remember = _safe_strip(content_val)
-            parsed.remember_type = mem_type
-        else:
-            # Legacy plain-text format
-            parsed.remember = _safe_strip(remember_raw)
-            parsed.remember_type = "session"
-
-    # ── Step 4: Parse <toolstocal> → list of tool dicts ──
-    toolstocal_raw = _extract_tag_content(body, "toolstocal", conservative=conservative)
-    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({
-                    "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({
-                    "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.reply
-        or parsed.usersays_correct
-        or parsed.tools_to_call
-        or parsed.remember
-        or parsed.recall
-        or parsed.knowledge
-        or parsed.get_knowledge
-    )
-
-    if has_content:
-        parsed.parse_success = True
-    else:
-        # Nothing was extracted — check if there's any raw text that could
-        # be a response (the LLM might have skipped XML entirely)
-        cleaned = raw_text.strip()
-        # Remove any residual XML tags
-        cleaned_no_tags = re.sub(r"<[^>]+>", "", cleaned).strip()
-        if cleaned_no_tags:
-            # The LLM output something but not in XML format
-            # Treat the entire output as a response
-            parsed.reply = cleaned_no_tags
-            parsed.parse_success = True
-            logger.info(
-                f"XML解析未提取到结构化字段，将原始文本（去除标签后）作为reply: "
-                f"{cleaned_no_tags[:100]}..."
-            )
-        else:
-            # Complete parse failure
-            parsed.needs_correction = True
-            logger.warning(
-                f"XML解析完全失败，需要LLM修正。原始输出前200字符: {raw_text[:200]}"
-            )
-
-    return parsed
-
-
-def _parse_toolstocal(toolstocal_content: str, *, conservative: bool = False) -> List[Dict[str, Any]]:
-    """Parse ``<toolstocal>`` body into a list of tool descriptors."""
-    tools: List[Dict[str, Any]] = []
-
-    tool_blocks = _extract_all_tag_blocks(
-        toolstocal_content, "tool", parent_close_tag="</toolstocal>",
-        conservative=conservative,
-    )
-
-    for block in tool_blocks:
-        tool: Dict[str, Any] = {
-            "toolname": _safe_strip(
-                _extract_tag_content(block, "toolname", TOOL_INNER_TAGS, conservative=conservative)
-            ),
-            "parms": _safe_strip(
-                _extract_tag_content(block, "parms", TOOL_INNER_TAGS, conservative=conservative)
-            ),
-            "timeout": _parse_int(
-                _extract_tag_content(block, "timeout", TOOL_INNER_TAGS, conservative=conservative),
-                _DEFAULT_TIMEOUT,
-            ),
-        }
-        # Only add if toolname is present
-        if tool["toolname"]:
-            tools.append(tool)
-
-    return tools
-
-
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
-
-
-def parse_output(raw_text: str) -> ParsedOutput:
-    """Parse the LLM's raw response into a :class:`ParsedOutput`.
-
-    This function uses a **fully custom regex-based parser** (no
-    ``xml.etree.ElementTree``) for maximum fault tolerance.
-
-    If the custom parser cannot extract any meaningful content, it falls
-    back to treating the raw text as a plain response.  Only if even that
-    fails does it set ``needs_correction=True``, signalling the caller to
-    ask the LLM to re-format its output.
-
-    Parameters:
-        raw_text: The complete text returned by the LLM.
-
-    Returns:
-        A :class:`ParsedOutput` instance.
-    """
-    if not raw_text:
-        return ParsedOutput(raw_text=raw_text, needs_correction=True)
-
-    return _custom_parse(raw_text)
-
-
-def extract_surrounding_text(full_text: str) -> tuple[str, str]:
-    """Split *full_text* around the ``<output>…</output>`` block.
-
-    Returns:
-        A ``(text_before_xml, text_after_xml)`` tuple.  Both parts are
-        stripped.  If no ``<output>`` block is found the original text
-        becomes *text_before_xml* and *text_after_xml* is ``""``.
-    """
-    open_match = re.search(r"<output[^>]*>", full_text, re.IGNORECASE)
-    if open_match is None:
-        return full_text.strip(), ""
-
-    text_before = full_text[: open_match.start()].strip()
-
-    rest = full_text[open_match.end() :]
-    close_match = re.search(r"</output\s*>", rest, re.IGNORECASE)
-    if close_match is None:
-        text_after = rest.strip()
-    else:
-        text_after = rest[close_match.end() :].strip()
-
-    return text_before, text_after
-
-
-# ---------------------------------------------------------------------------
-# Validation
-# ---------------------------------------------------------------------------
-
-
-def validate_output(parsed: ParsedOutput) -> list[str]:
-    """Validate a :class:`ParsedOutput` and return a list of warnings.
-
-    An empty list means no issues were detected.  Warnings are non-fatal
-    hints that the calling code may log or present to the user.
-    """
-    warnings: list[str] = []
-
-    # --- Tool-level checks ---
-    for idx, tool in enumerate(parsed.tools_to_call):
-        prefix = f"tool[{idx}]"
-
-        if not tool.get("toolname"):
-            warnings.append(f"{prefix}: missing 'toolname'")
-
-        timeout = tool.get("timeout", _DEFAULT_TIMEOUT)
-        if isinstance(timeout, int) and timeout <= 0:
-            warnings.append(
-                f"{prefix}: timeout={timeout} is not positive; "
-                f"defaulting to {_DEFAULT_TIMEOUT}s"
-            )
-
-        if tool.get("toolname") and not tool.get("parms"):
-            warnings.append(
-                f"{prefix} ('{tool['toolname']}'): 'parms' is empty — "
-                "verify the tool requires no parameters"
-            )
-
-    # --- Semantic checks ---
-    # [v1.36] askuser/finish/finish_reason 已废弃，移除相关校验
-
-    return warnings