myagent-ai 1.15.33 → 1.15.35

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/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.33",
+  "version": "1.15.35",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {