myagent-ai 1.15.34 → 1.15.36

package/README.md

@@ -123,6 +123,20 @@ powershell -c "irm https://raw.githubusercontent.com/ctz168/myagent/main/install
 curl -fsSL https://raw.githubusercontent.com/ctz168/myagent/main/install/install.sh | bash
 ```
 
+### 一键重装（跳过依赖检查）
+
+> 已安装过 MyAgent 的环境下，快速升级/重装，不检查 Python/Node.js 和 pip 依赖。
+
+**Windows（PowerShell）：**
+```powershell
+powershell -c "& ([scriptblock]::Create((irm https://raw.githubusercontent.com/ctz168/myagent/main/install/install.ps1))) -NoDeps"
+```
+
+**macOS / Linux：**
+```bash
+curl -fsSL https://raw.githubusercontent.com/ctz168/myagent/main/install/install.sh | bash -s -- --no-deps
+```
+
 ---
 
 ## 📋 系统要求

package/agents/main_agent.py

@@ -637,10 +637,49 @@ class MainAgent(BaseAgent):
                     "response": truncate_str(parsed.response, 500),
                     "parse_success": parsed.parse_success,
                     "needs_correction": parsed.needs_correction,
+                    "output_block_complete": parsed.output_block_complete,
                 }},
                 stream_callback,
             )
 
+            # Step 4.2: <output> 块完整性检查 — 不完整的块不输出，触发修正
+            if not parsed.output_block_complete:
+                logger.warning(
+                    f"[{task_id}] <output> 块不完整（缺少 </output> 闭合标签），"
+                    f"跳过本轮输出和工具执行"
+                )
+                if _xml_correction_retries < 1:
+                    _xml_correction_retries += 1
+                    correction_prompt = (
+                        "你的输出缺少 </output> 闭合标签，XML块不完整，"
+                        "解析器不会处理不完整的块。\n"
+                        "请严格按照 <output>...</output> 格式重新输出，"
+                        "确保所有标签正确闭合。\n\n"
+                        f"你上一次的原始输出如下：\n{llm_raw}"
+                    )
+                    conversation_history.append(
+                        Message(role="assistant", content=llm_raw)
+                    )
+                    conversation_history.append(
+                        Message(role="user", content=correction_prompt)
+                    )
+                    await self._emit_v2_event(
+                        "v2_reasoning",
+                        {"content": "⚠️ 模型输出XML块不完整，正在自动修正..."},
+                        stream_callback,
+                    )
+                    continue  # 重新进入循环，让 LLM 重新生成
+                else:
+                    # 已重试过，强制终止并提示用户
+                    logger.warning(f"[{task_id}] XML块仍不完整且已重试，终止循环")
+                    context.working_memory["final_response"] = "模型输出格式异常，请重新尝试。"
+                    await self._emit_v2_event(
+                        "v2_reasoning",
+                        {"content": "模型输出格式异常，已自动终止。"},
+                        stream_callback,
+                    )
+                    break
+
             # Step 4.5: 解析失败处理 — 回退给 LLM 修正或提取周边文本
             if not parsed.parse_success:
                 # 即使解析失败，如果 regex fallback 提取到了工具调用，仍然继续执行

package/core/deps_checker.py

@@ -12,7 +12,7 @@ core/deps_checker.py - 自动依赖检测与安装
 
 依赖映射:
   核心功能: openai, aiohttp, requests
-  搜索技能: bs4
+  搜索技能: duckduckgo_search, bs4, lxml
   系统技能: psutil
   托盘功能: pystray, PIL
   语音合成: edge_tts
@@ -62,7 +62,9 @@ DEPENDENCIES: List[DepInfo] = [
     DepInfo("requests", "requests", "2.31.0", "core", "all"),
 
     # ── 搜索技能 ──
+    DepInfo("duckduckgo_search", "duckduckgo-search", "6.0.0", "search", "all"),
     DepInfo("bs4", "beautifulsoup4", "4.12.0", "search", "all"),
+    DepInfo("lxml", "lxml", "5.0.0", "search", "all"),
 
     # ── 系统技能 ──
     DepInfo("psutil", "psutil", "5.9.0", "system", "all"),

package/core/output_parser.py

@@ -152,6 +152,7 @@ class ParsedOutput:
     raw_text: str = ""
     parse_success: bool = False
     needs_correction: bool = False
+    output_block_complete: bool = False  # </output> 闭合标签是否存在
 
 
 # ---------------------------------------------------------------------------
@@ -191,7 +192,7 @@ def _canonical_tag(tag_name: str) -> str:
     return _ALIAS_TO_CANONICAL.get(lower, lower)
 
 
-def _extract_tag_content(text: str, tag_name: str, stop_tags: List[str] | None = None) -> str:
+def _extract_tag_content(text: str, tag_name: str, stop_tags: List[str] | None = None, *, conservative: bool = False) -> str:
     """Extract the text content of ``<tag_name>…</tag_name>`` from *text*.
 
     Fault-tolerant strategies tried in order:
@@ -226,6 +227,10 @@ def _extract_tag_content(text: str, tag_name: str, stop_tags: List[str] | None =
     if m:
         return m.group(1)
 
+    # Conservative mode: only extract properly closed tags, skip all fallbacks
+    if conservative:
+        return ""
+
     # Strategy 2: Unclosed — content runs until the next opening/closing
     # sibling tag or </output>.
     sibling_names = [t for t in stop_tags if t.lower() != tag_name.lower()]
@@ -270,6 +275,8 @@ def _extract_all_tag_blocks(
     text: str,
     tag_name: str,
     parent_close_tag: str | None = None,
+    *,
+    conservative: bool = False,
 ) -> List[str]:
     """Extract all ``<tag_name>…`` blocks from *text*.
 
@@ -293,6 +300,10 @@ def _extract_all_tag_blocks(
     if properly_closed:
         return properly_closed
 
+    # Conservative mode: only extract properly closed blocks
+    if conservative:
+        return []
+
     # Strategy 2: Split by <tag> openings — each segment is a block
     positions = [
         m.end() for m in re.finditer(rf"<{tag_esc}[^>]*>", text, re.IGNORECASE)
@@ -377,6 +388,22 @@ def _strip_outer_noise(text: str) -> str:
     return text
 
 
+def is_output_block_complete(raw_text: str) -> bool:
+    """Check if *raw_text* contains a properly closed ``<output>...</output>`` block.
+
+    Returns:
+        True if both ``<output>`` and ``</output>`` tags are present.
+        False if neither tag, or only the opening tag, is found.
+    """
+    if not raw_text:
+        return False
+    open_m = re.search(r"<output[^>]*>", raw_text, re.IGNORECASE)
+    if open_m is None:
+        return False
+    close_m = re.search(r"</output\s*>", raw_text[open_m.end():], re.IGNORECASE)
+    return close_m is not None
+
+
 # ---------------------------------------------------------------------------
 # Core custom parser — NO xml.etree.ElementTree
 # ---------------------------------------------------------------------------
@@ -399,63 +426,73 @@ def _custom_parse(raw_text: str) -> ParsedOutput:
         parsed.needs_correction = True
         return parsed
 
+    # ── Step 0: Check <output> block completeness ──
+    parsed.output_block_complete = is_output_block_complete(raw_text)
+    conservative = not parsed.output_block_complete
+
+    if conservative:
+        logger.info(
+            "XML <output> 块不完整（缺少 </output> 闭合标签），"
+            "启用保守解析模式（仅提取完整闭合的标签）"
+        )
+
     # ── Step 1: Strip non-XML noise (text before/after <output>) ──
     body = _strip_outer_noise(raw_text)
 
     # ── Step 2: Extract each known top-level tag ──
 
     # usersays_correct
-    raw_val = _extract_tag_content(body, "usersays_correct")
+    raw_val = _extract_tag_content(body, "usersays_correct", conservative=conservative)
     parsed.usersays_correct = _safe_strip(raw_val)
 
     # task_plan
-    raw_val = _extract_tag_content(body, "task_plan")
+    raw_val = _extract_tag_content(body, "task_plan", conservative=conservative)
     parsed.task_plan = _safe_strip(raw_val)
 
     # response
-    raw_val = _extract_tag_content(body, "response")
+    raw_val = _extract_tag_content(body, "response", conservative=conservative)
     parsed.response = _safe_strip(raw_val)
 
     # recall
-    raw_val = _extract_tag_content(body, "recall")
+    raw_val = _extract_tag_content(body, "recall", conservative=conservative)
     parsed.recall = _safe_strip(raw_val)
 
     # knowledge
-    raw_val = _extract_tag_content(body, "knowledge")
+    raw_val = _extract_tag_content(body, "knowledge", conservative=conservative)
     parsed.knowledge = _safe_strip(raw_val)
 
     # askuser (also try alias ask_user)
-    raw_val = _extract_tag_content(body, "askuser")
+    raw_val = _extract_tag_content(body, "askuser", conservative=conservative)
     if not raw_val.strip():
-        raw_val = _extract_tag_content(body, "ask_user")
+        raw_val = _extract_tag_content(body, "ask_user", conservative=conservative)
     parsed.ask_user = _safe_strip(raw_val)
 
     # get_knowledge
-    raw_val = _extract_tag_content(body, "get_knowledge")
+    raw_val = _extract_tag_content(body, "get_knowledge", conservative=conservative)
     parsed.get_knowledge = _safe_strip(raw_val)
 
     # finish
-    raw_val = _extract_tag_content(body, "finish")
+    raw_val = _extract_tag_content(body, "finish", conservative=conservative)
     parsed.finish = _parse_bool(raw_val, False)
 
     # finish_reason
-    raw_val = _extract_tag_content(body, "finish_reason")
+    raw_val = _extract_tag_content(body, "finish_reason", conservative=conservative)
     parsed.finish_reason = _safe_strip(raw_val)
 
     # next_step
-    raw_val = _extract_tag_content(body, "next_step")
+    raw_val = _extract_tag_content(body, "next_step", conservative=conservative)
     parsed.next_step = _safe_strip(raw_val)
 
     # mainsubject [v1.15.8] 会话标题自动命名
-    raw_val = _extract_tag_content(body, "mainsubject")
+    raw_val = _extract_tag_content(body, "mainsubject", conservative=conservative)
     parsed.mainsubject = _safe_strip(raw_val)
 
     # ── Step 3: Parse <remember> (may contain <type> and <content>) ──
-    remember_raw = _extract_tag_content(body, "remember")
+    remember_raw = _extract_tag_content(body, "remember", conservative=conservative)
     if remember_raw.strip():
         # Try structured format: <type>global</type><content>...</content>
-        type_val = _extract_tag_content(remember_raw, "type", REMEMBER_INNER_TAGS)
-        content_val = _extract_tag_content(remember_raw, "content", REMEMBER_INNER_TAGS)
+        type_val = _extract_tag_content(remember_raw, "type", REMEMBER_INNER_TAGS, conservative=conservative)
+        content_val = _extract_tag_content(remember_raw, "content", REMEMBER_INNER_TAGS, conservative=conservative)
 
         if content_val.strip():
             mem_type = _safe_strip(type_val) or "session"
@@ -469,9 +506,9 @@ def _custom_parse(raw_text: str) -> ParsedOutput:
             parsed.remember_type = "session"
 
     # ── Step 4: Parse <toolstocal> → list of tool dicts ──
-    toolstocal_raw = _extract_tag_content(body, "toolstocal")
+    toolstocal_raw = _extract_tag_content(body, "toolstocal", conservative=conservative)
     if toolstocal_raw.strip():
-        parsed.tools_to_call = _parse_toolstocal(toolstocal_raw)
+        parsed.tools_to_call = _parse_toolstocal(toolstocal_raw, conservative=conservative)
 
     # ── Step 5: Determine parse success ──
     has_content = bool(
@@ -516,31 +553,32 @@ def _custom_parse(raw_text: str) -> ParsedOutput:
     return parsed
 
 
-def _parse_toolstocal(toolstocal_content: str) -> List[Dict[str, Any]]:
+def _parse_toolstocal(toolstocal_content: str, *, conservative: bool = False) -> List[Dict[str, Any]]:
     """Parse ``<toolstocal>`` body into a list of tool descriptors."""
     tools: List[Dict[str, Any]] = []
 
     tool_blocks = _extract_all_tag_blocks(
-        toolstocal_content, "tool", parent_close_tag="</toolstocal>"
+        toolstocal_content, "tool", parent_close_tag="</toolstocal>",
+        conservative=conservative,
     )
 
     for block in tool_blocks:
         tool: Dict[str, Any] = {
             "beforecalltext": _safe_strip(
-                _extract_tag_content(block, "beforecalltext", TOOL_INNER_TAGS)
+                _extract_tag_content(block, "beforecalltext", TOOL_INNER_TAGS, conservative=conservative)
             ),
             "toolname": _safe_strip(
-                _extract_tag_content(block, "toolname", TOOL_INNER_TAGS)
+                _extract_tag_content(block, "toolname", TOOL_INNER_TAGS, conservative=conservative)
             ),
             "parms": _safe_strip(
-                _extract_tag_content(block, "parms", TOOL_INNER_TAGS)
+                _extract_tag_content(block, "parms", TOOL_INNER_TAGS, conservative=conservative)
             ),
             "timeout": _parse_int(
-                _extract_tag_content(block, "timeout", TOOL_INNER_TAGS),
+                _extract_tag_content(block, "timeout", TOOL_INNER_TAGS, conservative=conservative),
                 _DEFAULT_TIMEOUT,
             ),
             "callback": _parse_bool(
-                _extract_tag_content(block, "callback", TOOL_INNER_TAGS),
+                _extract_tag_content(block, "callback", TOOL_INNER_TAGS, conservative=conservative),
                 _DEFAULT_CALLBACK,
             ),
         }

package/package.json

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

package/requirements.txt

@@ -11,8 +11,9 @@ requests>=2.31.0
 # ============================================================
 # 技能系统 - 搜索
 # ============================================================
-# 搜索使用 requests + BeautifulSoup (html.parser)，无需额外库
+duckduckgo-search>=6.0.0
 beautifulsoup4>=4.12.0
+lxml>=5.0.0
 psutil>=5.9.0
 
 # ============================================================
@@ -54,11 +55,6 @@ edge-tts>=6.1.0
 # ============================================================
 faster-whisper>=1.0.0
 
-# ============================================================
-# 音频处理 (TTS 服务端处理)
-# ============================================================
-pydub>=0.25.1
-
 # ============================================================
 # Anthropic Claude (可选)
 # ============================================================

package/setup.py

@@ -27,19 +27,22 @@ setup(
         "openai>=1.12.0",
         "aiohttp>=3.9.0",
         "requests>=2.31.0",
-        # 搜索 (BeautifulSoup + html.parser)
+        # 搜索
+        "duckduckgo-search>=6.0.0",
         "beautifulsoup4>=4.12.0",
+        "lxml>=5.0.0",
         "psutil>=5.9.0",
-        # 图像处理
+        # 系统托盘
+        "pystray>=0.19.5",
         "Pillow>=10.0.0",
         # 语音合成
         "edge-tts>=6.1.0",
         # 语音识别 (本地 STT)
         "faster-whisper>=1.0.0",
-        # 音频处理
-        "pydub>=0.25.1",
+        # 浏览器自动化 (ChromeDev MCP, 无需 Playwright)
         # 桌面 GUI 自动化 (内置技能)
         "pynput>=1.7.6",
+        "pygetwindow>=0.0.9",
         "mss>=9.0.0",
     ],
     extras_require={
@@ -47,8 +50,6 @@ setup(
         "discord": ["discord.py>=2.3.0"],
         "anthropic": ["anthropic>=0.18.0"],
         "communication": ["cryptography>=41.0.0", "websockets>=12.0"],
-        "tray": ["pystray>=0.19.5"],
-        "gui": ["pygetwindow>=0.0.9"],
         "voice": ["faster-whisper>=1.0.0"],
         "all": [
             "python-telegram-bot>=21.0",
@@ -56,8 +57,6 @@ setup(
             "anthropic>=0.18.0",
             "cryptography>=41.0.0",
             "websockets>=12.0",
-            "pystray>=0.19.5",
-            "pygetwindow>=0.0.9",
             "faster-whisper>=1.0.0",
         ],
     },

package/start.js

@@ -17,6 +17,7 @@
  *   myagent-ai setup      # 配置向导
  *   myagent-ai reinstall  # 重新安装依赖到 venv
  *   myagent-ai uninstall  # 卸载 MyAgent（删除npm包+数据）
+ *   myagent-ai --skip-deps  # 跳过依赖检查，直接启动
  */
 "use strict";
 
@@ -264,11 +265,11 @@ function parseRequirements(reqFile) {
         // 特殊映射: pip 包名和 import 名不一致的
         const importMap = {
           "beautifulsoup4": "bs4",
+          "py_getwindow": "pygetwindow",
           "python_telegram_bot": "telegram",
           "pillow": "PIL",
           "psutil": "psutil",
           "edge_tts": "edge_tts",
-          "pydub": "pydub",
         };
         modules.push(importMap[pkg] || pkg);
       }
@@ -286,12 +287,14 @@ const CORE_PACKAGES = [
   "openai>=1.12.0",
   "aiohttp>=3.9.0",
   "requests>=2.31.0",
+  "duckduckgo-search>=6.0.0",
   "beautifulsoup4>=4.12.0",
+  "lxml>=5.0.0",
   "psutil>=5.9.0",
+  "pystray>=0.19.5",
   "Pillow>=10.0.0",
   "edge-tts>=6.1.0",
   "faster-whisper>=1.0.0",
-  "pydub>=0.25.1",
   "anthropic>=0.18.0",
 ];
 
@@ -522,11 +525,18 @@ function main() {
   console.log("  \x1b[1m\x1b[36mMyAgent\x1b[0m - 本地桌面端执行型 AI 助手");
   console.log("");
 
+  // 是否跳过依赖检查
+  const skipDeps = userArgs.includes("--skip-deps") || userArgs.includes("--no-deps");
+  // 从参数中移除 --skip-deps/--no-deps，避免传入 main.py
+  const filteredArgs = userArgs.filter(a => a !== "--skip-deps" && a !== "--no-deps");
+
   // 确保 venv 存在
   const { venvDir, venvPython, isNew } = ensureVenv();
 
-  // 检查并安装依赖
-  if (isNew) {
+  // 检查并安装依赖（--skip-deps 时跳过）
+  if (skipDeps) {
+    console.log("  \x1b[90m[i]\x1b[0m 跳过依赖检查（--skip-deps）");
+  } else if (isNew) {
     installDeps(venvPython, getVenvPip(venvDir), pkgDir);
   } else {
     // 即使 venv 已存在，也快速检查核心依赖
@@ -548,9 +558,9 @@ function main() {
   console.log(`  \x1b[90m[i]\x1b[0m Python: ${venvPython}`);
   console.log("");
 
-  // 构建 Python 参数
-  let mode = userArgs[0] || "";
-  let pyArgs = buildArgs(userArgs);
+  // 构建 Python 参数（使用过滤后的参数）
+  let mode = filteredArgs[0] || "";
+  let pyArgs = buildArgs(filteredArgs);
 
   // 首次运行且未指定模式 → 自动选择 web 模式
   if (isFirstRun && !mode) {

package/start.sh

@@ -137,8 +137,8 @@ install_deps() {
         # fallback: 直接安装核心包
         "$VENV_PY" -m pip install --quiet \
             "openai>=1.12.0" "aiohttp>=3.9.0" "requests>=2.31.0" \
-            "beautifulsoup4>=4.12.0" \
-            "psutil>=5.9.0" --disable-pip-version-check 2>/dev/null || true
+            "duckduckgo-search>=6.0.0" "beautifulsoup4>=4.12.0" \
+            "lxml>=5.0.0" "psutil>=5.9.0" --disable-pip-version-check 2>/dev/null || true
         success "核心依赖安装完成"
     fi
 }