myagent-ai 1.47.16 → 1.47.18

package/agents/main_agent.py

@@ -1222,8 +1222,200 @@ class MainAgent(BaseAgent):
                 continue
 
             else:
-                # 没有工具调用 → 纯文本回复 → 结束循环
-                reply_text = (response.content or "").strip()
+                # 没有原生工具调用 → 检查是否为旧格式 <output> XML（某些模型不支持 tool_calling）
+                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 格式）
+                reply_text = raw_content
                 logger.info(f"[{task_id}] 无工具调用，任务完成 (reply长度={len(reply_text)})")
 
                 if not reply_text:

package/aiskills/browser_stealth.py

@@ -544,6 +544,73 @@ class StealthBrowser:
 
     async def start(self) -> SkillResult:
         """启动反检测浏览器"""
+        # [v1.47.16] VNC/Termux 模式下直接使用 Firefox，不走 DrissionPage/Chromium
+        # Chromium 在 proot ARM64 下与 DrissionPage 不兼容，
+        # 所以 VNC 模式下先检测环境，直接走 Firefox 路径，不需要 import DrissionPage
+        _is_vnc_mode = False
+        _is_termux_env = False
+        try:
+            from core.env_detect import is_termux
+            _is_termux_env = is_termux()
+        except ImportError:
+            pass
+        try:
+            from core.env_detect import is_desktop
+            if not is_desktop():
+                _is_vnc_mode = True
+        except ImportError:
+            if not _has_display():
+                _is_vnc_mode = True
+
+        # VNC 模式：跳过所有 Chrome/DrissionPage 逻辑，直接用 Firefox
+        if _is_vnc_mode:
+            logger.info("VNC/非桌面环境: 直接启动 Firefox（跳过 Chromium 检测）")
+            if not self._headless:
+                display = _ensure_display()
+                if display:
+                    self._vnc_used = display.get("vnc", False)
+                    self._xvfb_started_by_us = display.get("xvfb_standalone", False)
+                    if self._vnc_used:
+                        return self._start_firefox_in_vnc()
+                # VNC/Xvfb 不可用
+                if _is_termux_env:
+                    return SkillResult(
+                        success=False,
+                        error=(
+                            "Termux+Ubuntu 环境仅支持通过 VNC 启动浏览器，"
+                            "VNC 启动失败。请先启动 VNC 远程桌面后再使用浏览器功能。"
+                        ),
+                    )
+                # 非 Termux：尝试 Xvfb
+                if display and display.get("xvfb_standalone"):
+                    # 有 Xvfb 但没有 VNC → 用 Xvfb + Chromium（走下面的正常流程）
+                    pass
+                else:
+                    # 没有 Xvfb 也没有 VNC → 降级 headless 或报错
+                    logger.warning("无显示环境且 VNC/Xvfb 均不可用，尝试 Firefox headless 模式")
+                    return self._start_firefox_in_vnc()
+            else:
+                # headless=True 被显式请求
+                if _is_termux_env:
+                    logger.info("Termux+Ubuntu 环境: 忽略 headless 请求，强制使用 VNC 模式")
+                    self._headless = False
+                    display = _ensure_display()
+                    if display:
+                        self._vnc_used = display.get("vnc", False)
+                        self._xvfb_started_by_us = display.get("xvfb_standalone", False)
+                        if self._vnc_used:
+                            return self._start_firefox_in_vnc()
+                    return SkillResult(
+                        success=False,
+                        error=(
+                            "Termux+Ubuntu 环境仅支持通过 VNC 启动浏览器，"
+                            "VNC 启动失败。headless 模式在此环境下不可用。"
+                        ),
+                    )
+                # 非 Termux headless → 仍然尝试 Firefox
+                return self._start_firefox_in_vnc()
+
+        # ── 桌面环境：使用 DrissionPage + Chromium ──
         try:
             from DrissionPage import Chromium, ChromiumOptions
         except ImportError:
@@ -613,98 +680,10 @@ class StealthBrowser:
             else:
                 logger.info("桌面环境，使用系统 Chrome 原生参数")
 
-            # ── 无显示环境处理 ──
-            # 桌面环境 (Windows/macOS/Linux有真实显示器): 直接用系统 Chrome
-            # Termux+Ubuntu: 仅支持 VNC，不降级到 headless
-            # 非 Termux 容器: VNC > Xvfb > headless 降级
-            _is_termux_env = False
-            try:
-                from core.env_detect import is_termux
-                _is_termux_env = is_termux()
-            except ImportError:
-                pass
-
+            # ── 显示环境处理（仅桌面环境到达此代码路径）──
+            # VNC/Termux 模式已在方法开头走 Firefox 分支，这里只处理桌面环境
             if not self._headless:
-                try:
-                    from core.env_detect import is_desktop
-                    if is_desktop():
-                        # 桌面环境: 直接用系统 Chrome
-                        logger.info("桌面环境，直接使用系统浏览器，跳过 VNC/Xvfb")
-                    else:
-                        # 非桌面环境 (容器/Termux): 通过 _ensure_display() 获取显示
-                        display = _ensure_display()
-                        if display:
-                            self._vnc_used = display.get("vnc", False)
-                            self._xvfb_started_by_us = display.get("xvfb_standalone", False)
-                            if self._vnc_used:
-                                logger.info(f"复用 VNC 远程桌面显示 ({display['display']}），可在 VNC 中查看浏览器操作")
-                                # [v1.47.16] VNC 模式下直接用 Firefox，不走 DrissionPage/Chromium
-                                # Chromium 在 proot ARM64 下与 DrissionPage 不兼容
-                                logger.info("VNC 模式: 直接启动 Firefox（跳过 Chromium 检测）")
-                                return self._start_firefox_in_vnc()
-                        else:
-                            # ── Termux+Ubuntu: VNC 失败 → 直接报错，不降级 headless ──
-                            if _is_termux_env:
-                                return SkillResult(
-                                    success=False,
-                                    error=(
-                                        "Termux+Ubuntu 环境仅支持通过 VNC 启动浏览器，"
-                                        "VNC 启动失败。请先启动 VNC 远程桌面，"
-                                        "或通过 Web 管理面板打开 VNC 后再使用浏览器功能。"
-                                    ),
-                                )
-                            # ── 非 Termux 容器: 降级到 headless ──
-                            self._headless = True
-                            logger.warning(
-                                "无显示环境且 VNC/Xvfb 均不可用，自动降级为 headless 模式"
-                            )
-                except ImportError:
-                    # env_detect 不可用时，降级为原有 X11 检测逻辑
-                    if not _has_display():
-                        display = _ensure_display()
-                        if display:
-                            self._vnc_used = display.get("vnc", False)
-                            self._xvfb_started_by_us = display.get("xvfb_standalone", False)
-                            if self._vnc_used:
-                                # [v1.47.16] VNC 模式下直接用 Firefox
-                                logger.info("VNC 模式 (env_detect不可用): 直接启动 Firefox")
-                                return self._start_firefox_in_vnc()
-                        else:
-                            if _is_termux_env:
-                                return SkillResult(
-                                    success=False,
-                                    error=(
-                                        "Termux+Ubuntu 环境仅支持通过 VNC 启动浏览器，"
-                                        "VNC 启动失败。请先启动 VNC 远程桌面后再使用浏览器功能。"
-                                    ),
-                                )
-                            self._headless = True
-                            logger.warning(
-                                "无 DISPLAY 环境且 VNC/Xvfb 均不可用，自动降级为 headless 模式"
-                            )
-            else:
-                # headless=True 被显式请求，但 Termux 环境下仍强制使用 VNC
-                # 因为 headless Chromium 在 Termux 下容易被 OOM Kill
-                if _is_termux_env:
-                    logger.info("Termux+Ubuntu 环境: 忽略 headless 请求，强制使用 VNC 模式")
-                    self._headless = False
-                    display = _ensure_display()
-                    if display:
-                        self._vnc_used = display.get("vnc", False)
-                        self._xvfb_started_by_us = display.get("xvfb_standalone", False)
-                        if self._vnc_used:
-                            # [v1.47.16] VNC 模式下直接用 Firefox
-                            logger.info(f"Termux+Ubuntu VNC 模式: 直接启动 Firefox")
-                            return self._start_firefox_in_vnc()
-                    else:
-                        return SkillResult(
-                            success=False,
-                            error=(
-                                "Termux+Ubuntu 环境仅支持通过 VNC 启动浏览器，"
-                                "VNC 启动失败。headless 模式在此环境下不可用（容易被 OOM Kill）。"
-                                "请先启动 VNC 远程桌面后再使用浏览器功能。"
-                            ),
-                        )
+                logger.info("桌面环境，直接使用系统浏览器，跳过 VNC/Xvfb")
 
             # 无头模式（co.headless() 内部设置 --headless=new）
             if self._headless:
@@ -1273,8 +1252,11 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：通过 xdotool type 输入
+        if self._firefox_mode:
+            return self._firefox_fill(selector or "", text, clear, wait)
+
         try:
-            # 如果提供了 selector，先点击聚焦
             if selector:
                 ele = self._find_element(selector, timeout=10)
                 if not ele:
@@ -1366,8 +1348,11 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：通过 xdotool key 按键
+        if self._firefox_mode:
+            return self._firefox_press_key(key, selector, wait)
+
         try:
-            # 如果提供了 selector，先聚焦
             if selector:
                 ele = self._find_element(selector, timeout=10)
                 if ele:
@@ -1490,6 +1475,13 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：无法通过 CDP 执行 JS
+        if self._firefox_mode:
+            return SkillResult(
+                success=False,
+                error="Firefox+VNC 模式下不支持 JS 执行。请在 VNC 中手动操作，或切换到桌面环境使用 Chromium。",
+            )
+
         try:
             _script = script.strip()
             # 检测是否包含 return 语句
@@ -1546,6 +1538,13 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：无法获取页面内容
+        if self._firefox_mode:
+            return SkillResult(
+                success=False,
+                error="Firefox+VNC 模式下不支持获取页面内容。请在 VNC 中手动查看，或切换到桌面环境使用 Chromium。",
+            )
+
         try:
             # Bug Fix: DrissionPage 没有 page.text 属性
             # 需要通过 page.ele('tag:html').text 获取页面文本
@@ -1584,6 +1583,13 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：无法获取页面 HTML
+        if self._firefox_mode:
+            return SkillResult(
+                success=False,
+                error="Firefox+VNC 模式下不支持获取页面 HTML。请在 VNC 中手动查看，或切换到桌面环境使用 Chromium。",
+            )
+
         try:
             html = self._page.html or ""
             output_html = html[:50000] if len(html) > 50000 else html
@@ -1608,6 +1614,13 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：无法等待元素
+        if self._firefox_mode:
+            return SkillResult(
+                success=False,
+                error="Firefox+VNC 模式下不支持等待元素。请在 VNC 中手动操作。",
+            )
+
         try:
             ele = self._find_element(selector, timeout=timeout)
             if ele:
@@ -1662,6 +1675,13 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：Cookie 已由 Firefox 自动保存到 profile 目录
+        if self._firefox_mode:
+            return SkillResult(
+                success=True,
+                message="Firefox+VNC 模式: Cookie 由 Firefox 自动保存到 profile 目录",
+            )
+
         try:
             cookies = self._page.cookies()
             cookie_list = []
@@ -1691,6 +1711,13 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
+        # [v1.47.16] Firefox+VNC 模式：Cookie 由 Firefox 自动从 profile 目录加载
+        if self._firefox_mode:
+            return SkillResult(
+                success=True,
+                message="Firefox+VNC 模式: Cookie 由 Firefox 自动从 profile 目录加载",
+            )
+
         try:
             from core.browser_profile import get_browser_profile_manager
             mgr = get_browser_profile_manager()
@@ -1970,6 +1997,74 @@ class StealthBrowser:
                 error=f"Firefox+VNC 输入失败: {e}",
             )
 
+    def _firefox_press_key(self, key: str, selector: str = "", wait: float = 0.5) -> SkillResult:
+        """[v1.47.16] Firefox+VNC 模式下通过 xdotool key 按键。"""
+        display = os.environ.get("DISPLAY", ":99")
+        env = {**os.environ, "DISPLAY": display}
+
+        try:
+            # 查找 Firefox 窗口
+            result = subprocess.run(
+                ["xdotool", "search", "--onlyvisible", "--class", "firefox"],
+                capture_output=True, text=True, timeout=5,
+                env=env, start_new_session=True,
+            )
+            if result.returncode != 0 or not result.stdout.strip():
+                return SkillResult(
+                    success=False,
+                    error="Firefox+VNC: 未找到 Firefox 窗口。请在 VNC 中确认 Firefox 已打开。",
+                )
+
+            window_id = result.stdout.strip().split()[0]
+            subprocess.run(
+                ["xdotool", "windowactivate", "--sync", window_id],
+                capture_output=True, timeout=5, env=env, start_new_session=True,
+            )
+
+            # 将 JS 按键名称映射为 xdotool 按键名称
+            xdotool_key_map = {
+                'enter': 'Return', 'tab': 'Tab', 'escape': 'Escape', 'esc': 'Escape',
+                'backspace': 'BackSpace', 'delete': 'Delete', 'del': 'Delete',
+                'arrowup': 'Up', 'arrowdown': 'Down', 'arrowleft': 'Left', 'arrowright': 'Right',
+                'up': 'Up', 'down': 'Down', 'left': 'Left', 'right': 'Right',
+                'home': 'Home', 'end': 'End',
+                'pageup': 'Page_Up', 'pagedown': 'Page_Down',
+                'space': 'space', ' ': 'space',
+                'ctrl': 'ctrl', 'shift': 'shift', 'alt': 'alt', 'meta': 'super',
+                'cmd': 'super', 'command': 'super',
+            }
+            # F1-F12
+            for i in range(1, 13):
+                xdotool_key_map[f'f{i}'] = f'F{i}'
+
+            # 解析组合键
+            parts = key.strip().split('+')
+            xdotool_keys = []
+            for part in parts:
+                p = part.strip()
+                mapped = xdotool_key_map.get(p.lower(), p)
+                xdotool_keys.append(mapped)
+
+            # 构建 xdotool key 参数
+            xdotool_key_str = '+'.join(xdotool_keys)
+            subprocess.run(
+                ["xdotool", "key", "--window", window_id, xdotool_key_str],
+                capture_output=True, timeout=5, env=env, start_new_session=True,
+            )
+
+            if wait > 0:
+                time.sleep(wait)
+
+            return SkillResult(
+                success=True,
+                message=f"Firefox+VNC: 已按键: {key}",
+            )
+        except Exception as e:
+            return SkillResult(
+                success=False,
+                error=f"Firefox+VNC 按键失败: {e}",
+            )
+
     def _firefox_screenshot(self, save_path: str = "") -> SkillResult:
         """Firefox+VNC 模式下通过 xdotool + import 截图。"""
         display = os.environ.get("DISPLAY", ":99")

package/package.json

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

package/web/api_server.py

@@ -7901,10 +7901,11 @@ window.addEventListener('beforeunload', function() {{
             # 4. 检测到裸 JSON（整个回复以 { 开头）：进入 action 模式，提取 thought
             # 5. 代码块结束后回到文本模式，继续流式推送
             _stream_state = {
-                "mode": "text",         # "text" | "action_block" | "tasklist_block" | "bare_json"
+                "mode": "text",         # "text" | "action_block" | "tasklist_block" | "bare_json" | "output_xml"
                 "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 标记
@@ -7913,12 +7914,30 @@ window.addEventListener('beforeunload', function() {{
             _MAX_HOLD = 12
 
             async def _text_delta_callback(full_text_so_far: str, delta_text: str):
-                """智能流式过滤器：文本正常推送，JSON action 块拦截"""
+                """智能流式过滤器：文本正常推送，JSON action 块拦截，<output> XML 拦截"""
                 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")
@@ -8037,6 +8056,60 @@ 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 的部分）"""
@@ -8050,6 +8123,25 @@ 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,12 @@ 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) : '';
-      // Strip XML tags from assistant messages that are raw LLM output (key is empty or llm_output)
-      // 只有无 key 的旧格式 assistant 消息且内容以 < 开头时才需要剥离 XML
-      // 有 key 的消息（reasoning/reply/tool_call）已经是解析后的纯内容，无需处理
+      // [v1.47.16] 剥离 XML 标签：无 key 的旧格式 + key=reply 但仍含 XML 标签的消息
       var mkey = (m.key || '').toLowerCase();
-      if (m.role === 'assistant' && !mkey && content && content.trim().startsWith('<')) {
-        content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+      if (m.role === 'assistant' && content && content.trim().startsWith('<')) {
+        if (!mkey || mkey === 'reply') {
+          content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+        }
       }
       var mapped = {
         role: m.role || 'assistant',
@@ -3110,8 +3110,10 @@ async function loadMoreMessages() {
     }).map(function(m) {
       var content = (m.content != null) ? String(m.content) : '';
       var mkey = (m.key || '').toLowerCase();
-      if (m.role === 'assistant' && mkey !== 'tool_call' && mkey !== 'reasoning' && content && content.trim().startsWith('<')) {
-        content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+      if (m.role === 'assistant' && content && content.trim().startsWith('<')) {
+        if (!mkey || mkey === 'reply' || (mkey !== 'tool_call' && mkey !== 'reasoning')) {
+          content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+        }
       }
       var mapped = {
         role: m.role || 'assistant',

package/web/ui/chat/flow_engine.js

@@ -398,10 +398,12 @@ async function pollChatHistory() {
     }).map(function(m) {
       var content = (m.content != null) ? String(m.content) : '';
       var mkey = (m.key || '').toLowerCase();
-      // 只有无 key 的旧格式 assistant 消息且内容以 < 开头时才需要剥离 XML
-      // 有 key 的消息（reasoning/reply/tool_call）已经是解析后的纯内容，无需处理
-      if (m.role === 'assistant' && !mkey && content && content.trim().startsWith('<')) {
-        content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+      // [v1.47.16] 剥离 XML 标签：无 key 的旧格式 + key=reply 但仍含 XML 标签的消息
+      // 有 key 的消息（reasoning/reply/tool_call）一般已是纯内容，但部分模型仍会输出 XML
+      if (m.role === 'assistant' && content && content.trim().startsWith('<')) {
+        if (!mkey || mkey === 'reply') {
+          content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+        }
       }
       var mapped = {
         role: m.role || 'assistant',
@@ -473,9 +475,11 @@ async function forceRefreshHistory() {
     }).map(function(m) {
       var content = (m.content != null) ? String(m.content) : '';
       var mkey = (m.key || '').toLowerCase();
-      // 只有无 key 的旧格式 assistant 消息且内容以 < 开头时才需要剥离 XML
-      if (m.role === 'assistant' && !mkey && content && content.trim().startsWith('<')) {
-        content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+      // [v1.47.16] 剥离 XML 标签：无 key 的旧格式 + key=reply 但仍含 XML 标签的消息
+      if (m.role === 'assistant' && content && content.trim().startsWith('<')) {
+        if (!mkey || mkey === 'reply') {
+          content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+        }
       }
       var mapped = {
         role: m.role || 'assistant',