myagent-ai 1.26.4 → 1.26.5

package/agents/main_agent.py

@@ -45,7 +45,7 @@ class MainAgent(BaseAgent):
 
 严格以XML格式化输出以下内容，否则解析器无法解析:"""
 
-    # XML 输出格式规范（头部嵌入 SYSTEM_PROMPT，尾部在 _process_v2_inner 中再次追加，一头一尾确保格式正确）
+    # XML 输出格式规范（嵌入 SYSTEM_PROMPT，只出现一次）
     xml_prompt = """
 
 <output>
@@ -756,7 +756,6 @@ GUI桌面 (仅Windows/macOS):
                 + self.SYSTEM_PROMPT.split("\n", 1)[1]
             )
             system_content = _prompt_with_placeholder.replace(_CONTEXT_PLACEHOLDER, context_xml)
-            system_content = system_content + "\n最后，再检查输出格式，确保满足以下要求:" + self.xml_prompt
             
             # Step 3: 构建 LLM 消息（必须包含 role=user，否则 OpenAI 兼容 API 返回 400）
             messages = [Message(role="system", content=system_content)]
@@ -875,7 +874,13 @@ GUI桌面 (仅Windows/macOS):
                 break
 
             llm_raw = response.content
+            _finish_reason = getattr(response, 'finish_reason', '') or ''
             logger.debug(f"[{task_id}] LLM 输出 (前500字): {llm_raw[:500]}")
+            if _finish_reason == "length":
+                logger.warning(
+                    f"[{task_id}] LLM 输出被 max_tokens 截断 (finish_reason=length)，"
+                    f"输出长度={len(llm_raw)} 字符"
+                )
 
             # 保存 LLM 原始输出到会话记忆（用于回溯和审计，key=llm_output 不出现在对话历史中）
             if self.memory:
@@ -918,57 +923,85 @@ GUI桌面 (仅Windows/macOS):
                 stream_callback,
             )
 
-            # Step 4.2: <output> 块完整性检查
-            # 仅在块不完整且解析未提取到任何有效内容时才触发修正
-            # 如果解析器已经从非完整块中提取到有效内容（response/tools等），则正常继续
-            if not parsed.output_block_complete and not parsed.parse_success:
-                # 打印完整消息列表（系统提示词+对话历史），便于分析模型为何输出不完整
-                logger.warning(
-                    f"[{task_id}] <output> 块不完整且未提取到有效内容\n"
-                    f"====== 发送给LLM的完整消息列表（共{len(messages)}条）======\n"
-                    + "\n".join(
-                        f"--- [{i}] role={m.role} ---\n{m.content[:8000]}{'...(截断)' if len(m.content)>8000 else ''}"
-                        for i, m in enumerate(messages)
-                    )
-                    + f"\n====== 消息列表结束 ======"
-                )
+            # Step 4.2: <output> 块完整性检查 + finish_reason 截断检测
+            # 统一处理三种异常:
+            #   A) finish_reason=length → max_tokens 截断
+            #   B) 缺少 <output> 开始标签
+            #   C) 缺少 </output> 闭合标签
+            _has_output_open = bool(re.search(r"<output[^>]*>", llm_raw, re.IGNORECASE))
+            _has_output_close = bool(re.search(r"</output\s*>", llm_raw, re.IGNORECASE))
+            _is_truncated = (_finish_reason == "length")
+            _block_incomplete = (not _has_output_open or not _has_output_close)
+
+            if _is_truncated or (_block_incomplete and not parsed.parse_success):
+                # 构建诊断信息
+                _diag_parts = []
+                if _is_truncated:
+                    _diag_parts.append("finish_reason=length(max_tokens截断)")
+                if not _has_output_open:
+                    _diag_parts.append("缺少<output>开始标签")
+                if not _has_output_close and _has_output_open:
+                    _diag_parts.append("缺少</output>闭合标签")
+                _diag_msg = ", ".join(_diag_parts)
+
                 logger.warning(
-                    f"[{task_id}] <output> 块不完整且未提取到有效内容，"
-                    f"跳过本轮输出和工具执行"
+                    f"[{task_id}] XML 输出异常: {_diag_msg}，"
+                    f"parse_success={parsed.parse_success}, "
+                    f"输出长度={len(llm_raw)} 字符"
                 )
-                if _xml_correction_retries < 1:
+
+                if _xml_correction_retries < 2:
                     _xml_correction_retries += 1
-                    # [v1.15.73] 在重试前，尝试从不完整的 llm_raw 中提取已有内容
-                    # 防止 reasoning 模型因 max_tokens 截断导致内容完全丢失
+                    # 尝试从不完整输出中提取已有内容，防止内容完全丢失
                     _partial_text = self._try_extract_partial_response(llm_raw)
                     if _partial_text:
                         logger.info(f"[{task_id}] 从不完整XML中提取到部分回复: {_partial_text[:100]}")
                         _v2_reasoning_collected.append(_partial_text)
                         _emitted_reasoning_this_iter = True
                         await self._emit_v2_event("v2_reasoning", {"content": _partial_text}, stream_callback)
-                    correction_prompt = (
-                        "你的输出缺少 </output> 闭合标签，XML块不完整，"
-                        "解析器不会处理不完整的块。\n"
-                        "请严格按照 <output>...</output> 格式重新输出，"
-                        "确保所有标签正确闭合。\n\n"
-                        f"你上一次的原始输出如下：\n{llm_raw}"
-                    )
+
+                    # 根据诊断信息构建精准修正提示词
+                    if _is_truncated:
+                        correction_prompt = (
+                            "你的上一次输出因长度限制被截断，XML块不完整。\n"
+                            "请在回复中只包含精简的核心内容，避免冗长描述。\n"
+                            "如果需要执行工具调用，只保留最关键的工具。\n"
+                            "严格按照 <output>...</output> 格式输出，确保标签完整闭合。\n\n"
+                            f"你上一次被截断的输出如下（供参考，不要照搬）:\n{llm_raw[-2000:]}"
+                        )
+                    elif not _has_output_open:
+                        correction_prompt = (
+                            "你的输出缺少 <output> 开始标签，解析器无法识别。\n"
+                            "请严格按照 <output>...</output> 格式重新输出，"
+                            "确保以 <output> 开头、以 </output> 结尾。\n"
+                            "不要在 <output> 标签前后输出任何其他文字。\n\n"
+                            f"你上一次的原始输出如下：\n{llm_raw[-2000:]}"
+                        )
+                    else:
+                        correction_prompt = (
+                            "你的输出缺少 </output> 闭合标签，XML块不完整，"
+                            "解析器不会处理不完整的块。\n"
+                            "请严格按照 <output>...</output> 格式重新输出，"
+                            "确保所有标签正确闭合。\n\n"
+                            f"你上一次的原始输出如下：\n{llm_raw[-2000:]}"
+                        )
+
+                    # 追加到 history 时使用截断版本，防止 history 膨胀
                     conversation_history.append(
-                        Message(role="assistant", content=llm_raw)
+                        Message(role="assistant", content=llm_raw[-3000:] if len(llm_raw) > 3000 else llm_raw)
                     )
                     conversation_history.append(
                         Message(role="user", content=correction_prompt)
                     )
                     await self._emit_v2_event(
                         "v2_reasoning",
-                        {"content": "⚠️ 模型输出XML块不完整，正在自动修正..."},
+                        {"content": f"⚠️ 模型输出异常({_diag_msg})，正在自动修正({_xml_correction_retries}/2)..."},
                         stream_callback,
                     )
                     continue  # 重新进入循环，让 LLM 重新生成
                 else:
-                    # 已重试过，强制终止并提示用户
-                    logger.warning(f"[{task_id}] XML块仍不完整且已重试，终止循环")
-                    # [v1.15.73] 保存已积累的内容，避免空回复
+                    # 已重试 2 次，强制终止
+                    logger.warning(f"[{task_id}] XML输出异常已重试2次仍失败，终止循环: {_diag_msg}")
                     if _v2_reasoning_collected:
                         _fallback_save = "\n".join(_v2_reasoning_collected)
                         if _fallback_save.strip():
@@ -992,7 +1025,7 @@ GUI桌面 (仅Windows/macOS):
                             stream_callback,
                         )
                     break
-            elif not parsed.output_block_complete and parsed.parse_success:
+            elif _block_incomplete and parsed.parse_success:
                 # 块不完整但已提取到有效内容，记录日志但正常继续
                 logger.info(
                     f"[{task_id}] <output> 块不完整但已提取到有效内容，跳过修正直接处理"
@@ -1003,28 +1036,29 @@ GUI桌面 (仅Windows/macOS):
                 # 即使解析失败，如果 regex fallback 提取到了工具调用，仍然继续执行
                 if parsed.tools_to_call:
                     logger.warning(f"[{task_id}] XML 解析失败但提取到 {len(parsed.tools_to_call)} 个工具调用，跳过修正直接执行")
-                elif parsed.needs_correction and _xml_correction_retries < 1:
+                elif parsed.needs_correction and _xml_correction_retries < 2:
                     # XML 完全无法解析，让 LLM 重新格式化输出
                     _xml_correction_retries += 1
                     logger.warning(
                         f"[{task_id}] XML 解析完全失败，回退给 LLM 修正 "
-                        f"(重试 {_xml_correction_retries}/1)"
+                        f"(重试 {_xml_correction_retries}/2)"
                     )
                     correction_prompt = (
-                        "你上一次的输出格式有误，XML解析器无法识别。"
-                        "请严格按照 <output>...</output> 格式重新输出你的回答。"
-                        "注意：不要在 <output> 标签前后输出任何其他文字。\n\n"
-                        f"你上一次的原始输出如下：\n{llm_raw}"
+                        "你上一次的输出格式有误，XML解析器无法识别。\n"
+                        "请严格按照 <output>...</output> 格式重新输出你的回答。\n"
+                        "注意：以 <output> 开头，以 </output> 结尾，"
+                        "不要在 <output> 标签前后输出任何其他文字。\n\n"
+                        f"你上一次的原始输出如下：\n{llm_raw[-2000:]}"
                     )
                     conversation_history.append(
-                        Message(role="assistant", content=llm_raw)
+                        Message(role="assistant", content=llm_raw[-3000:] if len(llm_raw) > 3000 else llm_raw)
                     )
                     conversation_history.append(
                         Message(role="user", content=correction_prompt)
                     )
                     await self._emit_v2_event(
                         "v2_reasoning",
-                        {"content": "⚠️ 模型输出格式异常，正在自动修正..."},
+                        {"content": f"⚠️ 模型输出格式异常，正在自动修正({_xml_correction_retries}/2)..."},
                         stream_callback,
                     )
                     continue  # 重新进入循环，让 LLM 重新生成

package/config.py

@@ -28,7 +28,7 @@ class LLMConfig:
     base_url: str = "https://api.openai.com/v1"
     model: str = "gpt-4"
     temperature: float = 0.1
-    max_tokens: int = 4096
+    max_tokens: int = 30000
     context_window: int = 128000         # 上下文窗口大小
     input_modes: List[str] = field(default_factory=lambda: ["text"])  # 支持的输入模式
     reasoning: bool = False              # 是否支持推理
@@ -94,7 +94,7 @@ class ModelEntry:
     model: str = ""               # API 调用使用的实际模型字符串
     base_url: str = ""            # 自定义 Base URL（空=使用 provider 默认值）
     api_key: str = ""             # 专用 API Key（空=使用全局默认值）
-    max_tokens: int = 4096
+    max_tokens: int = 30000
     temperature: float = 0.1
     context_window: int = 128000  # 上下文窗口大小（token）
     input_modes: List[str] = field(default_factory=lambda: ["text"])  # 支持的输入模式: text, image, video, audio

package/core/llm.py

@@ -133,7 +133,7 @@ class LLMClient:
         base_url: str = "",
         model: str = "gpt-4",
         temperature: float = 0.1,
-        max_tokens: int = 4096,
+        max_tokens: int = 30000,
         timeout: int = 120,
         max_retries: int = 3,
         reasoning: bool = False,
@@ -567,13 +567,26 @@ class LLMClient:
                     "arguments": args,
                 })
 
+        # 提取推理模型的思考过程 (DeepSeek-R1, o1, o3, QwQ 等)
+        _reasoning = ""
+        _content = choice.message.content or ""
+        # 尝试多种属性名（不同 API 提供商的命名差异）
+        for _attr in ("reasoning_content", "reasoning", "thinking"):
+            _reasoning = getattr(choice.message, _attr, None) or ""
+            if _reasoning:
+                break
+        # 如果 content 为空但 reasoning 有内容，用 reasoning 作为 content
+        if not _content.strip() and _reasoning.strip():
+            _content = _reasoning
+
         return LLMResponse(
-            content=choice.message.content or "",
+            content=_content,
             tool_calls=tool_calls,
             usage=usage,
             model=response.model,
             finish_reason=choice.finish_reason or "",
             raw_response=response,
+            reasoning=_reasoning,
         )
 
     async def _chat_anthropic(self, messages: List[Message], kwargs: dict) -> LLMResponse:
@@ -604,9 +617,16 @@ class LLMClient:
         )
 
         content = ""
+        _reasoning = ""
         for block in response.content:
             if block.type == "text":
                 content += block.text
+            elif block.type == "thinking":
+                _reasoning += getattr(block, "thinking", "") or ""
+
+        # 如果 content 为空但 reasoning 有内容，用 reasoning 作为 content
+        if not content.strip() and _reasoning.strip():
+            content = _reasoning
 
         return LLMResponse(
             content=content,
@@ -616,6 +636,7 @@ class LLMClient:
             },
             model=response.model,
             finish_reason=response.stop_reason or "",
+            reasoning=_reasoning,
         )
 
     async def _chat_ollama(self, kwargs: dict) -> LLMResponse:

package/core/output_parser.py

@@ -429,8 +429,36 @@ 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)
+    # ── Step 0: 检查 <output> 块，处理缺少开始/闭合标签的情况 ──
+    _has_open = bool(re.search(r"<output[^>]*>", raw_text, re.IGNORECASE))
+    _has_close = bool(re.search(r"</output\s*>", raw_text, re.IGNORECASE))
+
+    if not _has_open and not _has_close:
+        # 完全没有 <output> 标签 — 检查是否包含已知子标签
+        _has_known_tags = any(
+            re.search(rf"<{re.escape(t)}[\s>]", raw_text, re.IGNORECASE)
+            for t in KNOWN_TOP_LEVEL_TAGS
+        )
+        if _has_known_tags:
+            # 有子标签但缺少 <output> 包装 — 自动补全后正常解析
+            logger.info(
+                "LLM 输出缺少 <output> 标签但包含已知子标签，"
+                "自动补全 <output> 包装后解析"
+            )
+            raw_text = "<output>\n" + raw_text.strip() + "\n</output>"
+            parsed.output_block_complete = True
+        else:
+            parsed.output_block_complete = False
+    elif _has_open and not _has_close:
+        parsed.output_block_complete = False
+    elif not _has_open and _has_close:
+        # 有闭合标签但没开始标签 — 补全开始标签
+        logger.info("LLM 输出缺少 <output> 开始标签但有 </output>，自动补全")
+        raw_text = "<output>\n" + raw_text.strip()
+        parsed.output_block_complete = True
+    else:
+        parsed.output_block_complete = True
+
     conservative = not parsed.output_block_complete
 
     if conservative:

package/package.json

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