myagent-ai 1.47.17 → 1.47.19

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

@@ -1865,25 +1865,53 @@ class StealthBrowser:
         """Firefox+VNC 模式下导航到指定 URL。
 
         Firefox 支持远程打开 URL：firefox <url> 会在已运行的实例中打开新标签页。
+        [v1.47.19] 改用 Popen 非阻塞方式：firefox <url> 在已运行实例中打开新标签页
+        后会阻塞等待窗口关闭，subprocess.run + timeout 会导致超时。
+        改用 Popen 后不等待命令完成，只确认启动即可。
         """
         display = os.environ.get("DISPLAY", ":99")
         env = {**os.environ, "DISPLAY": display}
         if not env.get("G_SLICE"):
             env["G_SLICE"] = "always-malloc"
+        if not env.get("GSETTINGS_BACKEND"):
+            env["GSETTINGS_BACKEND"] = "memory"
+        if os.environ.get("DBUS_SESSION_BUS_ADDRESS"):
+            env["DBUS_SESSION_BUS_ADDRESS"] = os.environ["DBUS_SESSION_BUS_ADDRESS"]
 
         try:
             firefox_path = shutil.which("firefox") or shutil.which("myagent-browser")
             if not firefox_path:
                 return SkillResult(success=False, error="Firefox 未找到")
 
-            result = subprocess.run(
+            # [v1.47.19] 使用 Popen 非阻塞方式启动
+            # firefox <url> 在已有实例运行时会将 URL 发送给已有实例，
+            # 然后阻塞等待（因为 Firefox 的 -no-remote 行为）。
+            # 用 Popen 启动后不等待完成，只等待进程启动成功。
+            process = subprocess.Popen(
                 [firefox_path, "--profile", self._firefox_profile_dir, url],
-                capture_output=True, text=True, timeout=10,
-                env=env, start_new_session=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                env=env,
+                start_new_session=True,
             )
-            logger.info(f"Firefox 打开 URL: {url}")
+            # 等待短时间确认进程没有立即崩溃
+            time.sleep(0.5)
+            if process.poll() is not None:
+                # 进程已退出，可能是错误
+                exit_code = process.returncode
+                # Firefox 在已有实例时，转发URL后以 exit code 0 退出（正常行为）
+                if exit_code == 0:
+                    logger.info(f"Firefox 已转发 URL 到已有实例: {url}")
+                else:
+                    return SkillResult(
+                        success=False,
+                        error=f"Firefox 打开 URL 失败 (exit code: {exit_code}): {url}",
+                    )
+
             if wait > 0:
                 time.sleep(wait)
+
+            logger.info(f"Firefox 已打开 URL: {url}")
             return SkillResult(
                 success=True,
                 message=f"Firefox 已打开: {url}",

package/core/vnc_manager.py

@@ -1398,10 +1398,32 @@ class VNCManager:
             # --session: 会话总线
             # --address: 指定 unix socket
             env = {**os.environ, "DISPLAY": os.environ.get("DISPLAY", self.display)}
+
+            # [v1.47.19] 创建自定义 dbus 会话配置，禁用 launch-helper
+            # 避免 "error: expected absolute path: --shm-helper" 错误
+            # dbus-daemon 的默认 session.conf 包含 <servicedir> 和
+            # <servicehelper> 指令，后者会调用 dbus-daemon-launch-helper --shm-helper
+            # 在 proot 下路径翻译破坏了参数传递。改为创建不含 servicehelper 的配置。
+            custom_config_path = f"{dbus_socket_dir}.conf"
+            try:
+                custom_config = self._create_dbus_session_config()
+                with open(custom_config_path, "w") as f:
+                    f.write(custom_config)
+                logger.debug(f"已创建自定义 D-Bus 会话配置: {custom_config_path}")
+            except Exception as conf_err:
+                logger.debug(f"创建自定义 D-Bus 配置失败，使用默认配置: {conf_err}")
+                custom_config_path = None
+
+            dbus_cmd = [dbus_daemon, "--nofork",
+                        f"--address={dbus_socket}",
+                        f"--pidfile={dbus_pid_file}"]
+            if custom_config_path:
+                dbus_cmd.extend(["--config-file", custom_config_path])
+            else:
+                dbus_cmd.append("--session")
+
             proc = subprocess.Popen(
-                [dbus_daemon, "--session", "--nofork",
-                 f"--address={dbus_socket}",
-                 f"--pidfile={dbus_pid_file}"],
+                dbus_cmd,
                 stdin=subprocess.DEVNULL,
                 stdout=subprocess.DEVNULL,
                 stderr=subprocess.DEVNULL,
@@ -1438,6 +1460,64 @@ class VNCManager:
         except Exception as e:
             logger.warning(f"dbus-daemon 直接启动异常: {e}")
 
+    def _create_dbus_session_config(self) -> str:
+        """[v1.47.19] 创建不含 servicehelper 的 D-Bus 会话配置。
+
+        标准 session.conf 包含 <servicehelper> 指向 dbus-daemon-launch-helper，
+        后者会被 dbus-daemon 用 --shm-helper 参数调用。
+        在 proot 下路径翻译破坏了这个调用，导致反复出现:
+          error: expected absolute path: "--shm-helper"
+
+        解决方法: 读取系统默认 session.conf，移除 <servicehelper> 行，
+        保留其他配置（<servicedir>、<policy> 等）。
+        这样 D-Bus 服务仍可被发现，但不会被 launch-helper 激活
+        （需要程序自己启动对应的 D-Bus 服务）。
+        """
+        import re as _re
+
+        # 查找系统默认 session.conf
+        conf_paths = [
+            "/usr/share/dbus-1/session.conf",
+            "/etc/dbus-1/session.conf",
+        ]
+        default_conf = ""
+        for cp in conf_paths:
+            if os.path.isfile(cp):
+                try:
+                    with open(cp, "r") as f:
+                        default_conf = f.read()
+                    break
+                except Exception:
+                    pass
+
+        if not default_conf:
+            # 无法读取默认配置，创建最小配置
+            return """<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+  <type>session</type>
+  <listen>unix:tmpdir=/tmp</listen>
+  <servicedir>/usr/share/dbus-1/services</servicedir>
+  <policy context="default">
+    <allow send_destination="*" eavesdrop="true"/>
+    <allow eavesdrop="true"/>
+    <allow own="*"/>
+  </policy>
+</busconfig>"""
+
+        # 从默认配置中移除 <servicehelper> 行
+        # 匹配 <servicehelper>...</servicehelper> 或 <servicehelper .../>
+        lines = default_conf.split("\n")
+        filtered = []
+        for line in lines:
+            stripped = line.strip()
+            # 跳过 servicehelper 行（这是导致 --shm-helper 错误的根源）
+            if stripped.startswith("<servicehelper"):
+                continue
+            filtered.append(line)
+
+        return "\n".join(filtered)
+
     def _start_dbus_launch_standard(self) -> None:
         """[v1.43.3] 非 proot 环境下用 dbus-launch 标准方式启动 D-Bus。"""
         dbus_launch = shutil.which("dbus-launch")
@@ -3316,7 +3396,18 @@ exec {backup_path} "${{args[@]}}"
                 '    DBUS_SOCKET_DIR="/tmp/dbus-myagent-$(id -u)"',
                 '    mkdir -p "$DBUS_SOCKET_DIR" 2>/dev/null',
                 '    chmod 700 "$DBUS_SOCKET_DIR" 2>/dev/null',
-                '    dbus-daemon --session --nofork --address="unix:path=$DBUS_SOCKET_DIR" &',
+                # [v1.47.19] 使用自定义配置（移除 servicehelper，避免 --shm-helper 错误）
+                '    DBUS_CONF="$DBUS_SOCKET_DIR.conf"',
+                '    if [ ! -f "$DBUS_CONF" ]; then',
+                '      if [ -f /usr/share/dbus-1/session.conf ]; then',
+                '        grep -v "<servicehelper" /usr/share/dbus-1/session.conf > "$DBUS_CONF" 2>/dev/null',
+                '      fi',
+                '    fi',
+                '    if [ -f "$DBUS_CONF" ]; then',
+                '      dbus-daemon --nofork --config-file="$DBUS_CONF" --address="unix:path=$DBUS_SOCKET_DIR" &',
+                '    else',
+                '      dbus-daemon --session --nofork --address="unix:path=$DBUS_SOCKET_DIR" &',
+                '    fi',
                 '    export DBUS_SESSION_BUS_ADDRESS="unix:path=$DBUS_SOCKET_DIR"',
                 '  elif [ -x /usr/bin/dbus-launch ]; then',
                 '    # 非 proot: 标准方式',
@@ -4836,7 +4927,18 @@ if [ -z "$DBUS_SESSION_BUS_ADDRESS" ]; then
     if [ "$IS_PROOT" = "1" ] && [ -x /usr/bin/dbus-daemon ]; then
         DBUS_SOCK="/tmp/dbus-myagent-$(id -u)"
         mkdir -p "$DBUS_SOCK" 2>/dev/null && chmod 700 "$DBUS_SOCK" 2>/dev/null
-        dbus-daemon --session --nofork --address="unix:path=$DBUS_SOCK" &
+        # [v1.47.19] 使用自定义配置（移除 servicehelper，避免 --shm-helper 错误）
+        DBUS_CONF="$DBUS_SOCK.conf"
+        if [ ! -f "$DBUS_CONF" ]; then
+            if [ -f /usr/share/dbus-1/session.conf ]; then
+                grep -v "<servicehelper" /usr/share/dbus-1/session.conf > "$DBUS_CONF" 2>/dev/null
+            fi
+        fi
+        if [ -f "$DBUS_CONF" ]; then
+            dbus-daemon --nofork --config-file="$DBUS_CONF" --address="unix:path=$DBUS_SOCK" &
+        else
+            dbus-daemon --session --nofork --address="unix:path=$DBUS_SOCK" &
+        fi
         export DBUS_SESSION_BUS_ADDRESS="unix:path=$DBUS_SOCK"
     elif [ -x /usr/bin/dbus-launch ]; then
         eval $(dbus-launch --sh-syntax 2>/dev/null) || true
@@ -4884,7 +4986,18 @@ if [ -z "$DBUS_SESSION_BUS_ADDRESS" ]; then
     if [ "$IS_PROOT" = "1" ] && [ -x /usr/bin/dbus-daemon ]; then
         DBUS_SOCK="/tmp/dbus-myagent-$(id -u)"
         mkdir -p "$DBUS_SOCK" 2>/dev/null && chmod 700 "$DBUS_SOCK" 2>/dev/null
-        dbus-daemon --session --nofork --address="unix:path=$DBUS_SOCK" &
+        # [v1.47.19] 使用自定义配置（移除 servicehelper，避免 --shm-helper 错误）
+        DBUS_CONF="$DBUS_SOCK.conf"
+        if [ ! -f "$DBUS_CONF" ]; then
+            if [ -f /usr/share/dbus-1/session.conf ]; then
+                grep -v "<servicehelper" /usr/share/dbus-1/session.conf > "$DBUS_CONF" 2>/dev/null
+            fi
+        fi
+        if [ -f "$DBUS_CONF" ]; then
+            dbus-daemon --nofork --config-file="$DBUS_CONF" --address="unix:path=$DBUS_SOCK" &
+        else
+            dbus-daemon --session --nofork --address="unix:path=$DBUS_SOCK" &
+        fi
         export DBUS_SESSION_BUS_ADDRESS="unix:path=$DBUS_SOCK"
     elif [ -x /usr/bin/dbus-launch ]; then
         eval $(dbus-launch --sh-syntax 2>/dev/null) || true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.47.17",
+  "version": "1.47.19",
   "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',

package/worklog.md

@@ -69,3 +69,51 @@ Stage Summary:
 - Async non-blocking: waiting for lock does NOT block the event loop (other coroutines run normally)
 - New `browser_wait_status` tool: agents can check lock status and optionally wait for browser to become free
 - All 19 tests passed (7 import/signature + 12 async contention)
+
+---
+Task ID: 3
+Agent: Main
+Task: Fix model outputting `<output>` XML tags visible to users + VNC mode Firefox fix
+
+Work Log:
+- Analyzed the full streaming pipeline: LLM → _call_llm_stream → _emit_text_delta → _text_delta_callback → SSE → Frontend
+- Found root cause: v1.38 switched to native tool_calling, but some models still output old `<output>` XML format
+- When models output `<output>` XML without native tool_calls, the XML was treated as plain text and shown to users
+- The frontend `_stripXmlTags` only ran on keyless assistant messages, not key="reply" messages
+
+Changes made:
+1. **agents/main_agent.py** (_process_v2_inner):
+   - Added `<output>` XML fallback: when response.tool_calls is empty but content contains `<output>` XML, use output_parser to parse
+   - Handles mainsubject, remember, task_plan, and tools_to_call from parsed XML
+   - Executes tools from `<toolstocal>` and continues the LLM loop
+   - Extracts `<reply>` content for user display, strips all XML tags as fallback
+   - Saves clean reply as key="reply" and raw XML as key="llm_output"
+
+2. **web/api_server.py** (_text_delta_callback):
+   - Added "output_xml" mode to streaming filter
+   - Detects `<output>` tag and enters output_xml mode, suppressing all non-reply content
+   - Extracts and streams `<reply>` content in real-time
+   - Handles both closed `<reply>...</reply>` and unclosed `<reply>` during streaming
+   - Exits output_xml mode on `</output>` close tag
+   - Updated _flush_remaining_text to handle output_xml mode
+
+3. **web/ui/chat/flow_engine.js** (pollChatHistory, forceRefreshHistory):
+   - Extended XML stripping to also handle key="reply" messages (not just keyless)
+   - Condition: `(!mkey || mkey === 'reply')` for assistant messages starting with `<`
+
+4. **web/ui/chat/chat_main.js** (two locations):
+   - Same fix: extended XML stripping to handle key="reply" messages
+
+5. **aiskills/browser_stealth.py** (VNC+Firefox):
+   - Already implemented in previous session: VNC mode directly uses Firefox, skipping Chrome/DrissionPage
+   - `_start_firefox_in_vnc()` method handles Firefox launch with proper env vars for proot ARM64
+   - `_detect_browser(skip_puppeteer=True)` in VNC mode skips Puppeteer Chrome detection
+
+6. **package.json**: Bumped version to 1.47.18, published to npm
+
+Stage Summary:
+- `<output>` XML tags no longer visible to users in any path (streaming, polling, history)
+- Models that don't support native tool_calling now have their XML output properly parsed and executed
+- 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