myagent-ai 1.47.19 → 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
@@ -924,6 +864,24 @@ class MainAgent(BaseAgent):
 
         messages.append(Message(role="system", content=_system_content))
 
+        # [v1.47.20] VNC 模式下注入浏览器工具使用提示
+        try:
+            from core.vnc_manager import get_vnc_manager
+            vnc_mgr = get_vnc_manager()
+            if vnc_mgr.is_running:
+                vnc_hint = (
+                    "\n\n## VNC 远程桌面模式提示\n"
+                    "当前运行在 VNC 远程桌面环境，浏览器为 Firefox（不支持 Chromium/CDP）。\n"
+                    "- **网页浏览**: 优先使用 stealth_browser_start → stealth_browser_navigate → stealth_browser_content\n"
+                    "- **获取页面内容**: stealth_browser_content（返回截图+标签页信息），不要使用 browser_open\n"
+                    "- **交互操作**: stealth_browser_click / stealth_browser_fill / stealth_browser_key\n"
+                    "- **不要使用**: browser_open（需要 Chromium）、web_control（需要前端面板）\n"
+                    "- **不要关闭 Firefox**: stealth_browser_close 在 VNC 模式下只释放会话，不关闭浏览器"
+                )
+                messages[0] = Message(role="system", content=messages[0].content + vnc_hint)
+        except (ImportError, Exception):
+            pass
+
         # 注入对话历史
         if conversation_history:
             _history_budget = int(self.context_builder.context_window * 0.25) if self.context_builder else 50000
@@ -1222,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/aiskills/browser_stealth.py

@@ -956,10 +956,15 @@ class StealthBrowser:
         """关闭浏览器"""
         self._started = False
 
-        # [v1.47.16] Firefox+VNC 模式
+        # [v1.47.20] Firefox+VNC 模式：VNC 桌面的浏览器不能杀，只清理内部状态
         if self._firefox_mode:
             try:
-                if self._firefox_process and self._firefox_process.poll() is None:
+                if self._vnc_used:
+                    # VNC 模式：Firefox 由 vnc_manager 管理，不能杀进程
+                    # 只清理本实例的内部状态
+                    logger.info("Firefox+VNC 模式: 不关闭 VNC 浏览器（由 vnc_manager 管理），仅释放内部状态")
+                elif self._firefox_process and self._firefox_process.poll() is None:
+                    # 非 VNC 模式（独立启动的 Firefox）：可以关闭
                     self._firefox_process.terminate()
                     try:
                         self._firefox_process.wait(timeout=5)
@@ -970,19 +975,15 @@ class StealthBrowser:
                             pass
                     logger.info("Firefox 已关闭")
                 else:
-                    # 可能是复用的 Firefox 进程，尝试通过 pkill 关闭
-                    try:
-                        subprocess.run(["pkill", "-f", "firefox"], capture_output=True, timeout=5)
-                        logger.info("Firefox 进程已终止 (pkill)")
-                    except Exception:
-                        pass
+                    # 可能是复用的非 VNC Firefox 进程
+                    logger.info("Firefox 进程非本实例启动，跳过关闭")
             except Exception as e:
                 logger.error(f"关闭 Firefox 异常: {e}")
             finally:
                 self._firefox_process = None
                 self._firefox_mode = False
                 self._vnc_used = False
-            return SkillResult(success=True, message="Firefox 已关闭")
+            return SkillResult(success=True, message="浏览器会话已释放（VNC 浏览器保持运行）")
 
         try:
             if self._browser:
@@ -1475,11 +1476,13 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
-        # [v1.47.16] Firefox+VNC 模式：无法通过 CDP 执行 JS
+        # [v1.47.20] Firefox+VNC 模式：无法通过 CDP 执行 JS
         if self._firefox_mode:
             return SkillResult(
                 success=False,
-                error="Firefox+VNC 模式下不支持 JS 执行。请在 VNC 中手动操作，或切换到桌面环境使用 Chromium。",
+                error="Firefox+VNC 模式下不支持 JS 执行。请使用 stealth_browser_navigate "
+                      "导航页面，用 stealth_browser_content（截图+标签页信息）获取内容，"
+                      "用 xdotool 相关操作（click/fill/key）进行交互。",
             )
 
         try:
@@ -1538,12 +1541,9 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
-        # [v1.47.16] Firefox+VNC 模式：无法获取页面内容
+        # [v1.47.20] Firefox+VNC 模式：截图 + sessionstore 读取
         if self._firefox_mode:
-            return SkillResult(
-                success=False,
-                error="Firefox+VNC 模式下不支持获取页面内容。请在 VNC 中手动查看，或切换到桌面环境使用 Chromium。",
-            )
+            return self._firefox_get_content()
 
         try:
             # Bug Fix: DrissionPage 没有 page.text 属性
@@ -1583,12 +1583,9 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
-        # [v1.47.16] Firefox+VNC 模式：无法获取页面 HTML
+        # [v1.47.20] Firefox+VNC 模式：截图 + sessionstore 替代
         if self._firefox_mode:
-            return SkillResult(
-                success=False,
-                error="Firefox+VNC 模式下不支持获取页面 HTML。请在 VNC 中手动查看，或切换到桌面环境使用 Chromium。",
-            )
+            return self._firefox_get_content()
 
         try:
             html = self._page.html or ""
@@ -1614,11 +1611,17 @@ class StealthBrowser:
         if not self._ensure_page():
             return SkillResult(success=False, error="浏览器未启动")
 
-        # [v1.47.16] Firefox+VNC 模式：无法等待元素
+        # [v1.47.20] Firefox+VNC 模式：sleep + 截图替代
         if self._firefox_mode:
+            await asyncio.sleep(min(timeout, 5))
+            # 等待后截图，确认页面状态
+            session_info = self._firefox_read_sessionstore()
+            url = session_info.get("url", "")
+            title = session_info.get("title", "")
             return SkillResult(
-                success=False,
-                error="Firefox+VNC 模式下不支持等待元素。请在 VNC 中手动操作。",
+                success=True,
+                message=f"Firefox+VNC: 已等待 {min(timeout, 5)}秒，当前页面: {title or url}",
+                data={"url": url, "title": title},
             )
 
         try:
@@ -2174,6 +2177,162 @@ class StealthBrowser:
         except Exception as e:
             return SkillResult(success=False, error=f"Firefox+VNC 截图失败: {e}")
 
+    def _firefox_read_sessionstore(self) -> dict:
+        """[v1.47.20] 读取 Firefox sessionstore 获取当前标签页 URL/标题。
+
+        Firefox 运行时会将当前会话信息写入 sessionstore-backups/recovery.jsonlz4。
+        该文件使用 mozLz4 格式（8字节自定义头 + LZ4 压缩数据）。
+
+        Returns:
+            dict: {"url": str, "title": str, "tabs": [{"url": str, "title": str}]}
+        """
+        result_info = {"url": "", "title": "", "tabs": []}
+
+        # 搜索可能的 sessionstore 路径
+        search_dirs = []
+        if self._firefox_profile_dir:
+            search_dirs.append(self._firefox_profile_dir)
+        # 也搜索 Firefox 默认 profile 和 vnc_manager 启动的 profile
+        for extra in [
+            os.path.expanduser("~/.mozilla/firefox/default"),
+            os.path.expanduser("~/.mozilla/firefox"),
+        ]:
+            if os.path.isdir(extra) and extra not in search_dirs:
+                search_dirs.append(extra)
+
+        recovery_files = []
+        for base_dir in search_dirs:
+            ss_dir = os.path.join(base_dir, "sessionstore-backups")
+            if os.path.isdir(ss_dir):
+                for fname in ("recovery.jsonlz4", "recovery.baklz4",
+                              "previous.jsonlz4"):
+                    fpath = os.path.join(ss_dir, fname)
+                    if os.path.isfile(fpath):
+                        recovery_files.append(fpath)
+            # 也检查 base_dir 本身（有些 Firefox 版本）
+            for fname in ("sessionstore.jsonlz4", "sessionstore-backups/recovery.jsonlz4"):
+                fpath = os.path.join(base_dir, fname)
+                if os.path.isfile(fpath):
+                    recovery_files.append(fpath)
+
+        if not recovery_files:
+            logger.debug("[_firefox_read_sessionstore] 未找到 sessionstore 文件")
+            return result_info
+
+        # 读取 mozLz4 格式
+        for fpath in recovery_files:
+            try:
+                import struct
+                with open(fpath, "rb") as f:
+                    data = f.read()
+                if len(data) < 8:
+                    continue
+                magic = struct.unpack("<I", data[:4])[0]
+                if magic != 0x00080000:
+                    continue
+                orig_size = struct.unpack("<I", data[4:8])[0]
+                try:
+                    import lz4.block
+                    decompressed = lz4.block.decompress(
+                        data[8:], uncompressed_size=orig_size
+                    )
+                except ImportError:
+                    logger.debug("[_firefox_read_sessionstore] lz4 未安装，跳过 mozLz4 解析")
+                    continue
+                except Exception as lz4_err:
+                    logger.debug(f"[_firefox_read_sessionstore] lz4 解压失败: {lz4_err}")
+                    continue
+
+                session = json.loads(decompressed)
+                tabs_info = []
+                for win in session.get("windows", []):
+                    for tab in win.get("tabs", []):
+                        idx = tab.get("index", 1) - 1
+                        entries = tab.get("entries", [])
+                        if entries and 0 <= idx < len(entries):
+                            entry = entries[idx]
+                            tab_info = {
+                                "url": entry.get("url", ""),
+                                "title": entry.get("title", ""),
+                            }
+                            tabs_info.append(tab_info)
+
+                result_info["tabs"] = tabs_info
+                if tabs_info:
+                    # 取第一个标签页作为当前页面（通常是最活跃的）
+                    result_info["url"] = tabs_info[0]["url"]
+                    result_info["title"] = tabs_info[0]["title"]
+
+                logger.info(
+                    f"[_firefox_read_sessionstore] 读取成功: {len(tabs_info)} 个标签页, "
+                    f"当前: {result_info['title'][:50]}"
+                )
+                return result_info
+
+            except Exception as e:
+                logger.debug(f"[_firefox_read_sessionstore] 读取 {fpath} 失败: {e}")
+                continue
+
+        return result_info
+
+    def _firefox_get_content(self) -> SkillResult:
+        """[v1.47.20] Firefox+VNC 模式下获取页面内容。
+
+        由于无法通过 CDP 获取 Firefox 页面文本，采用以下策略：
+        1. 截取当前屏幕截图（供 VLM 视觉理解）
+        2. 读取 Firefox sessionstore 获取 URL/标题
+        3. 返回截图路径和基本元信息
+
+        Agent 可以使用截图进行视觉理解，或使用 web_search/web_read 获取页面文本。
+        """
+        # 1. 截图
+        screenshot_result = self._firefox_screenshot()
+        screenshot_path = ""
+        if screenshot_result.success and screenshot_result.data:
+            screenshot_path = screenshot_result.data.get("path", "")
+
+        # 2. 读取 sessionstore
+        session_info = self._firefox_read_sessionstore()
+
+        # 3. 组合返回信息
+        url = session_info.get("url", "")
+        title = session_info.get("title", "")
+        tabs = session_info.get("tabs", [])
+        tabs_summary = ""
+        if tabs:
+            tabs_lines = []
+            for i, tab in enumerate(tabs[:10]):  # 最多10个标签页
+                tabs_lines.append(f"  [{i+1}] {tab.get('title', '?')} - {tab.get('url', '?')}")
+            tabs_summary = "\n".join(tabs_lines)
+
+        content_parts = []
+        if title:
+            content_parts.append(f"标题: {title}")
+        if url:
+            content_parts.append(f"URL: {url}")
+        if tabs_summary:
+            content_parts.append(f"标签页:\n{tabs_summary}")
+        if screenshot_path:
+            content_parts.append(f"截图: {screenshot_path}")
+
+        content_text = "\n".join(content_parts) if content_parts else "无法获取页面内容"
+
+        return SkillResult(
+            success=True,
+            message=f"Firefox+VNC 页面信息: {title or url or '未知'}",
+            data={
+                "url": url,
+                "title": title,
+                "tabs": tabs,
+                "screenshot_path": screenshot_path,
+                "mode": "firefox_vnc",
+                "note": "Firefox+VNC 模式无法直接获取页面文本，已提供截图和标签页信息。"
+                        "请使用截图进行视觉理解，或用 web_search/web_read 获取网页文本。",
+            },
+            files=[screenshot_path] if screenshot_path else [],
+            output=content_text,
+        )
+
     def _firefox_get_cookies(self) -> SkillResult:
         """Firefox+VNC 模式下读取 cookies.sqlite。"""
         try:
@@ -3063,8 +3222,25 @@ class StealthBrowserCloseSkill(Skill):
     ]
 
     async def execute(self, profile: str = "", **kw) -> SkillResult:
-        # close_stealth_browser 现在是同步函数，直接调用
+        # [v1.47.20] VNC 模式下不关闭 Firefox，只释放会话状态
+        with _browser_lock:
+            is_vnc = False
+            if profile:
+                for key, browser in _browsers.items():
+                    if key == profile or key == f"__system__:{profile}":
+                        if browser._vnc_used:
+                            is_vnc = True
+                            break
+            else:
+                is_vnc = any(b._vnc_used for b in _browsers.values())
+
         close_stealth_browser(profile_name=profile)
+
+        if is_vnc:
+            return SkillResult(
+                success=True,
+                message="VNC 模式: 浏览器会话已释放，Firefox 保持运行（VNC 远程桌面需要）",
+            )
         return SkillResult(success=True, message="浏览器已关闭")
 
 

package/aiskills/chromedev_mcp.py

@@ -1372,6 +1372,26 @@ class BrowserOpenSkill(Skill):
         if not url:
             return SkillResult(success=False, error="缺少必需参数: url")
 
+        # [v1.47.20] VNC 模式下：Chromium 不可用时回退到 stealth_browser_navigate
+        try:
+            from core.vnc_manager import get_vnc_manager
+            vnc_mgr = get_vnc_manager()
+            if vnc_mgr.is_running:
+                # 检查是否有可用的 Chromium
+                import shutil
+                has_chrome = bool(shutil.which("chromium-browser") or shutil.which("chromium")
+                                 or shutil.which("google-chrome"))
+                if not has_chrome:
+                    # VNC 模式下无 Chromium，回退到 stealth_browser
+                    return SkillResult(
+                        success=False,
+                        error="VNC 远程桌面模式下没有 Chromium 浏览器，无法使用 browser_open。"
+                              "请改用 stealth_browser_start + stealth_browser_navigate 操作 Firefox。"
+                              "Firefox 在 VNC 模式下已可用。",
+                    )
+        except ImportError:
+            pass  # vnc_manager 不可用，跳过检测
+
         # 检查依赖
         dep_err = await asyncio.get_event_loop().run_in_executor(None, _ensure_node_deps)
         if dep_err: