myagent-ai 1.47.19 → 1.47.21

package/package.json

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

package/web/api_server.py

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

package/web/ui/chat/chat_main.js

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

package/web/ui/chat/flow_engine.js

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

package/worklog.md

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