myagent-ai 1.15.73 → 1.15.75

package/agents/main_agent.py

@@ -39,54 +39,34 @@ class MainAgent(BaseAgent):
     # =========================================================================
     # 系统提示词 — 结构化输出格式
     # =========================================================================
-    SYSTEM_PROMPT = """你是一个强内容分析格式转化引擎，要深入分析以下上下文内容：
+    SYSTEM_PROMPT = """你是一个智能AI助手，请深入分析以下上下文内容。
 
-严格以XML格式化输出以下内容:
+严格以XML格式化输出以下内容，否则解析器无法解析:
 <output>
-<response>直接回复用户的内容。这是一段友好、自然的话语，用于向用户说明你正在做什么，或者回应用户的问题/问候。要求简洁、有礼貌、符合对话场景。如果用户只是问候，简单回应即可；如果用户有具体任务，要说明你的计划。</response>
-<usersays_correct>根据用户输入的"usersays"内容（语音转写文本），结合对话语境优化为更准确的用户意图表达（修正识别错误、补充标点、口语转书面语）。如果"usersays"为空，这里输出为空。</usersays_correct>
-<task_plan>任务计划（仅复杂任务使用）：如"context"包含非空"task_plan"，则更新它。否则，先评估任务复杂度——如果预计操作步骤不超过3步（如：单次查询、简单问答、格式转换、单文件修改、简单计算等简单任务），则<task_plan>输出为空，不要创建任务列表；只有当任务较复杂（预计超过3步操作，如：多文件修改、需要调研+实现+测试、涉及多个模块联动等），才以Markdown列表格式制定新任务列表。格式：每项用 "- [ ] 任务描述" 或 "- [x] 已完成任务"，含完成状态标记。</task_plan>
-
-<toolstocal>
-<tool><beforecalltext>连接词，介绍调用什么工具，达到什么目的。</beforecalltext><toolname>工具名</toolname><parms>JSON格式的参数对象，例如: {"query": "搜索关键词", "num": 5}</parms><timeout>预估超时时限(秒)</timeout></tool>
+<mainsubject>当前对话的6字以内标题</mainsubject>
+<usersays_correct>通过修正识别错误、调整标点，结合上下文，将用户语音转写文本"usersays"修正为更准确的文本，但尽量少改动。如"usersays"为空，则此处为空。</usersays_correct>
+<response><reply>展示给用户的文本内容:直接回应用户问题；告诉用户，为完成任务，准备如何开展工作；根据工具调用结果，展示任务进展。注意:这是给用户展示信息的最重要标签。</reply><toolstocal>
+<tool><beforecalltext>展示给用户的工具调用信息，方便用户了解调用目的。格式:先使用"接下来、下一步、接着、现在、然后"等连接词，然后介绍调用什么工具，达到什么目的。</beforecalltext><toolname>工具名，用于后台解析器解析调用工具</toolname><parms>调用工具的JSON格式参数对象，如格式: {"query": "搜索关键词", "num": 5}</parms><timeout>预估调用超时时限(秒),工具调用超时会立即回调大语言模型，方便调整工具使用</timeout></tool>
 </toolstocal>
-<remember><type>global或session</type><content>仅从最新用户输入（userprint 或 usersays_correct）中提炼值得记忆的信息（如用户偏好、重要结论、错误经验等）。type=global表示跨会话全局记忆，type=session表示仅当前会话可用的记忆。如果本轮没有新信息需要记忆，则<content>为空、<type>不填。</content></remember>
-<recall>下一轮需要主动召回的记忆描述。填写需要从记忆库中检索的关键字或描述。如果不填写则为空。如果需要更多记忆支持当前任务，填写相关关键词（可包含时间参考，如"2025年1月的项目"），系统将在下一轮搜索top5相关记忆并通过<recall_memory>注入上下文。你也可以直接调用recall_memory工具即时搜索。</recall>
-<knowledge>从本轮对话或工具执行结果中提炼值得长期保存到知识库的专业知识、事实、经验法则、技术要点等。这些知识将被持久化存储，未来可通过 <get_knowledge> 检索复用。如果本轮没有需要保存的知识，则为空。格式要求：简洁明确，每条知识一行，用换行分隔。</knowledge>
-<get_knowledge>下一轮执行时需要从知识库搜索获得的知识，填写检索关键词或描述。如context中已包含充足的<knowledge>内容，则为空。如需更多专业知识支撑，则填写相关搜索词。</get_knowledge>
+</response>
+<task_plan>仅复杂任务使用任务计划，如"context"包含非空"task_plan"，则更新它。否则，先评估任务复杂度，针对单次查询、简单问答、格式转换、单文件修改、简单计算等简单任务，若预计操作步骤不超过3步，则此处输出为空，不要创建任务列表；针对多文件修改、需要调研+实现+测试、涉及多个模块联动等复杂任务，如预计超过3步操作，则以Markdown列表格式制定新任务列表。格式：每项用 "- [ ] 任务描述" 或 "- [x] 已完成任务"，含完成状态标记。</task_plan>
+<remember><type>填global或session，其中"global"为跨会话全局记忆，"session"为仅当前会话。</type><content>仅从最新用户输入，包括"userprint"或"usersays_correct"或工具调用结果，中提炼值得记忆的信息（如用户偏好、重要结论、错误经验等）。如本轮无新信息要记忆，则为空，type也为空。</content></remember>
+<recall>下一轮需要主动召回的记忆描述。填写需要从记忆库中检索的关键字或描述。如果不填写则为空。如果需要更多记忆支持当前任务，填写相关关键词（可包含时间参考，如"2025年1月的项目"），系统将在下一轮搜索top5相关记忆并通过"recall_memory"注入上下文。也可直接调用"recall_memory"工具即时搜索。</recall>
+<knowledge>从本轮对话或工具执行结果中提炼值得长期保存到知识库的专业知识、事实、经验法则、技术要点等，将被持久化存储，未来可通过 "get_knowledge"检索复用。如果本轮无需保存的知识，则为空。格式要求：简洁明确，每条知识一行，用换行分隔。</knowledge>
+<get_knowledge>下一轮执行时需要从知识库搜索获得的知识，填写检索关键词或描述。如context中已包含充足的knowledge内容，则为空。如需更多专业知识支撑，则填写相关搜索词。</get_knowledge>
 <askuser>需要询问用户的内容，如无，则为空</askuser>
-<finish>true/false，是否结束循环调用llm。如"askuser"为非空，则"finish"输出true。否则，根据"context"判断任务是否已完成，是否结束llm回调</finish>
-<finish_reason>当 finish=true 时必填，详细说明为什么现在结束任务（如：任务已完成/需要用户补充信息/信息不足无法继续等）。finish=false 时为空。</finish_reason>
+<finish>true/false，是否结束循环调用llm。如"askuser"为非空，则"finish"为true。否则，根据"context"判断任务是否已完成，是否结束llm回调</finish>
+<finish_reason>当"finish"为true 时必填，详细说明为什么现在结束任务（如：任务已完成/需要用户补充信息/信息不足无法继续等）。finish若为false ，此处为空。</finish_reason>
 <next_step>当 finish=false 时必填，描述下一步计划做什么（简洁明了，1-2句话）。finish=true 时为空。</next_step>
-<mainsubject>为当前对话生成一个简短的标题（6个字以内），概括对话主题。仅在对话刚开始（前几轮）时需要输出，已有标题的对话此标签留空即可。要求简洁精炼，例如"Python安装"、"请假流程"、"翻译助手"等。</mainsubject>
-
 </output>
 
-## 核心规则
-1. 你必须且只能输出 <output> XML 结构，不要输出任何其他文本
-2. <response>: 必须输出一段直接回复用户的话语（这是用户实际看到的回复），要求简洁友好、自然流畅。不要只输出任务计划而不说话！
-3. <usersays_correct>: 如果 context 中 usersays 非空（说明用户通过语音输入），则根据对话语境将语音转写文本优化为更准确的用户意图表达，修正识别错误、补充标点、口语转书面语。如果 usersays 为空，这里输出为空。
-4. <task_plan>: 仅用于复杂任务（预计超过3步操作）。简单任务（≤3步）输出为空。复杂任务使用 Markdown 列表格式，每项包含任务描述和完成状态标记 [x]/[ ]
-5. <toolstocal>: 列出所有需要执行的工具调用，每个工具包含完整的参数说明
-6. <parms>: **必须使用严格合法的JSON格式**，例如 {"query": "关键词", "num": 10}，不要使用其他格式
-7. <timeout>: 预估超时秒数（简单操作10-30s，文件操作30-60s，网络请求60-120s，数据处理120-300s）
-8. <remember>: 包含 <type> 和 <content> 子标签。type 填 "global"（跨会话全局记忆）或 "session"（仅当前会话）。content 填从最新用户输入中提炼的值得记忆的关键信息。如果本轮无需记忆，content 为空且不填 type。注意：用户个人偏好、重要结论、通用经验用 global；当前任务的临时上下文、过程信息用 session
-9. <recall>: 填写下一轮需要从记忆库中主动召回的内容描述和关键字（可包含时间参考）。系统将根据这些信息搜索top5相关记忆，在下一轮通过 <recall_memory> 标签注入上下文。如果当前 <automemory> 中的记忆已足够完成任务，<recall> 为空；如果需要更多历史记忆支撑，则填写。你也可以直接使用 recall_memory 工具在当前轮即时搜索
-10. <knowledge>: 从本轮对话或工具执行结果中提炼值得长期保存的专业知识、事实、经验法则、技术要点等。这些知识会被持久化到知识库文件，未来可通过 get_knowledge 检索复用。如果没有需要保存的知识，则为空。格式：简洁明确，每条知识一行
-11. <get_knowledge>: 如果当前 <knowledge> 内容不足以完成任务，填写需要从知识库搜索的关键词；否则为空
-12. <askuser>: 当信息不足需要用户补充时，在此填写要问的问题
-13. <finish>: 当任务已完成或需要等待用户回应时为 true；否则为 false 继续执行
-14. <finish_reason>: **finish=true 时必须填写**，详细说明结束原因（任务完成/等待用户/信息不足/无法处理等）
-15. <next_step>: **finish=false 时必须填写**，描述下一步计划做什么，要求简洁明确（1-2句话）
-16. <mainsubject>: 为当前对话生成6字以内的简短标题，概括对话主题。仅在对话刚开始的前几轮需要输出，已有标题后留空
-17. 使用中文输出所有内容
-
-## 上下文中的记忆系统说明
+事项注意:
+1.  toolstocal标签: 可列出所有需要执行的工具调用，可以多个工具。解析器会按顺序执行工具调用，最终全部执行完后，会连同所有结果，回调大语言模型。如果某个工具执行超时了，也会回调回调大模型，让大模型分析为什么超时，改用其他工具。
+2. 上下文中的记忆系统说明
 - <automemory>: 系统自动根据你通过 <remember> 保存的记忆和当前用户输入，搜索出的 top10 相关记忆。这些是你过去主动记住的内容（包含时间信息），可供参考。
 - <recall_memory>: 你在上一轮通过 <recall> 指定的记忆搜索结果。系统根据你提供的关键字和时间点搜索了 top5 相关记忆。
 - 两种记忆互补：automemory 是自动匹配的，recall_memory 是你主动指定搜索的。如果 automemory 不足，使用 <recall> 请求更多。
-
-## 工具选择指南
+3. 工具选择指南
 - **搜索信息**: 用 `web_search`（返回标题+URL+摘要），不要用 browser_open
 - **读取网页内容**: 用 `web_read`（传入URL，提取正文）
 - **浏览器交互**（填表、点击、截图等）: 才使用 browser_open / browser_click 等
@@ -206,39 +186,70 @@ class MainAgent(BaseAgent):
         """[v1.15.73] 从不完整的 LLM 输出中提取部分回复内容。
 
         当 <output> 块被截断（缺少 </output>）时，尝试：
-        1. 提取 <response>...</response> 中已闭合的内容
-        2. 提取 <output> 后到截断点之间的纯文本
-        3. 去除 XML 标签后的残余文本
+        1. 提取 <reply>...</reply> 中已闭合的内容（优先，v1.15.74）
+        2. 提取 <response>...</response> 中已闭合的内容（兜底）
+        3. 提取 <knowledge>...</knowledge> 中已闭合的内容（兜底）
+        4. 提取 <output> 后到截断点之间的纯文本
+        5. 去除 XML 标签后的残余文本
         """
         if not llm_raw:
             return ""
 
         import re
+        _parts = []
 
-        # 策略1: 尝试提取已闭合的 <response> 内容
-        response_match = re.search(
-            r"<response[^>]*>(.*?)</response>",
+        # 策略1: 尝试提取已闭合的 <reply> 内容（v1.15.74 新结构）
+        reply_match = re.search(
+            r"<reply[^>]*>(.*?)</reply>",
             llm_raw,
             re.DOTALL | re.IGNORECASE,
         )
-        if response_match:
-            text = response_match.group(1).strip()
+        if reply_match:
+            text = reply_match.group(1).strip()
             if text:
-                return text
+                _parts.append(text)
+
+        # 策略2: 尝试提取已闭合的 <response> 内容（不含嵌套XML则为旧格式）
+        if not _parts:
+            response_match = re.search(
+                r"<response[^>]*>(.*?)</response>",
+                llm_raw,
+                re.DOTALL | re.IGNORECASE,
+            )
+            if response_match:
+                raw_resp = response_match.group(1).strip()
+                if raw_resp:
+                    # 去除嵌套的 <reply>/<toolstocal> 标签
+                    cleaned = re.sub(r"<[^>]+>", "", raw_resp).strip()
+                    if cleaned:
+                        _parts.append(cleaned)
+
+        # 策略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)
 
-        # 策略2: 提取 <output> 标签后的内容（可能包含未闭合的 <response>）
+        # 策略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:
-                # 去除所有 XML 标签，保留纯文本
                 cleaned = re.sub(r"<[^>]+>", "", after_output).strip()
-                # 去除 reasoning/assistant 前缀
                 cleaned = re.sub(r"^(reasoning|assistant)\s*", "", cleaned, flags=re.IGNORECASE).strip()
                 if cleaned and len(cleaned) > 5:
                     return cleaned
 
-        # 策略3: 提取去除 XML 标签后的整体文本
+        # 策略5: 提取去除 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:
@@ -603,7 +614,7 @@ class MainAgent(BaseAgent):
             # Step 2: 构建系统消息 — 将 context XML 插入 SYSTEM_PROMPT 的 "上下文" 占位处
             _CONTEXT_PLACEHOLDER = "__CONTEXT_PLACEHOLDER__"
             _prompt_with_placeholder = (
-                "你是一个强内容分析格式转化引擎，要深入分析以下上下文内容：\n\n"
+                "你是一个智能AI助手，请深入分析以下上下文内容。\n\n"
                 + _CONTEXT_PLACEHOLDER + "\n\n"
                 + self.SYSTEM_PROMPT.split("\n", 1)[1]
             )
@@ -860,19 +871,38 @@ class MainAgent(BaseAgent):
             if parsed.usersays_correct:
                 context.working_memory["usersays_correct"] = parsed.usersays_correct
 
-            # Step 5.5: 处理 response — 直接回复用户的内容
-            if parsed.response:
-                response_text = parsed.response.strip()
-                if response_text:
-                    logger.debug(f"[{task_id}] 模型回复用户: {response_text[:100]}")
-                    context.working_memory["model_response"] = response_text
-                    _v2_reasoning_collected.append(response_text)
-                    _emitted_reasoning_this_iter = True
-                    await self._emit_v2_event(
-                        "v2_reasoning",
-                        {"content": response_text},
-                        stream_callback,
-                    )
+            # Step 5.5: 处理 reply + response — 直接回复用户的内容
+            # [v1.15.74] reply(嵌套在<response>内，优先) 作为用户主要可见文本
+            # response 可能包含嵌套的 <reply> 和 <toolstocal> XML，需提取纯文本作为兜底
+            import re as _re
+            _user_visible_parts = []
+            if parsed.reply:
+                reply_text = parsed.reply.strip()
+                if reply_text:
+                    logger.debug(f"[{task_id}] 模型reply: {reply_text[:100]}")
+                    _user_visible_parts.append(reply_text)
+            if not _user_visible_parts and parsed.response:
+                # 兜底：从 response 中去除 XML 标签提取纯文本
+                response_clean = _re.sub(r"<[^>]+>", "", parsed.response).strip()
+                if response_clean:
+                    logger.debug(f"[{task_id}] 模型response(去除标签): {response_clean[:100]}")
+                    _user_visible_parts.append(response_clean)
+            # 防御性兜底：如果 knowledge 非空且 reply/response 都空，追加 knowledge
+            if not _user_visible_parts and parsed.knowledge:
+                kb_text = parsed.knowledge.strip()
+                if kb_text and len(kb_text) > 20:
+                    logger.debug(f"[{task_id}] knowledge内容兜底追加到用户回复: {kb_text[:100]}")
+                    _user_visible_parts.append(kb_text)
+            if _user_visible_parts:
+                combined_text = "\n".join(_user_visible_parts)
+                context.working_memory["model_response"] = combined_text
+                _v2_reasoning_collected.append(combined_text)
+                _emitted_reasoning_this_iter = True
+                await self._emit_v2_event(
+                    "v2_reasoning",
+                    {"content": combined_text},
+                    stream_callback,
+                )
 
             # Step 6: 处理 remember — 按 type 分全局/会话存储
             if parsed.remember:

package/core/output_parser.py

@@ -12,17 +12,20 @@ pure Python + regex to achieve maximum fault tolerance.
 Expected XML schema produced by the LLM::
 
     <output>
+        <mainsubject>当前对话的6字以内标题</mainsubject>
         <usersays_correct>...</usersays_correct>
-        <task_plan>...</task_plan>
-        <toolstocal>
-            <tool>
-                <beforecalltext>连接词，介绍调用什么工具</beforecalltext>
-                <toolname>工具名</toolname>
-                <parms>参数JSON或描述</parms>
-                <timeout>预估超时时限(秒)</timeout>
-                <callback>true/false</callback>
-            </tool>
-        </toolstocal>
+        <response>
+            <reply>展示给用户的文本内容</reply>
+            <toolstocal>
+                <tool>
+                    <beforecalltext>连接词，介绍调用什么工具</beforecalltext>
+                    <toolname>工具名</toolname>
+                    <parms>参数JSON或描述</parms>
+                    <timeout>预估超时时限(秒)</timeout>
+                    <callback>true/false</callback>
+                </tool>
+            </toolstocal>
+        </response>
         <remember>
             <type>global|session</type>
             <content>记忆内容</content>
@@ -31,7 +34,6 @@ Expected XML schema produced by the LLM::
         <askuser>需要询问用户的内容</askuser>
         <get_knowledge>下一轮需要搜索获得的知识</get_knowledge>
         <finish>true/false</finish>
-        <response>模型对用户的直接回复</response>
     </output>
 
 Fault-tolerance features:
@@ -76,6 +78,7 @@ KNOWN_TOP_LEVEL_TAGS = [
     "finish",
     "finish_reason",
     "next_step",
+    "reply",  # [v1.15.74] 用户可见文本（嵌套在<response>内）
     "response",
     "mainsubject",  # [v1.15.8] 会话标题自动命名
 ]
@@ -128,7 +131,8 @@ class ParsedOutput:
         finish: When ``True`` the execution loop should terminate.
         finish_reason: When finish=True, explains why the task is ending.
         next_step: When finish=False, describes what to do next.
-        response: Model's direct reply to the user (friendly natural language).
+        response: Model's direct reply to the user (may contain nested <reply> and <toolstocal>).
+        reply: User-visible text content extracted from <reply> tag (primary display content).
         raw_text: The verbatim raw text returned by the LLM.
         parse_success: Whether parsing extracted at least one meaningful field.
         needs_correction: When ``True``, the caller should send the raw text
@@ -148,6 +152,7 @@ class ParsedOutput:
     finish_reason: str = ""
     next_step: str = ""
     response: str = ""
+    reply: str = ""  # [v1.15.74] 用户可见文本（嵌套在<response>内）
     mainsubject: str = ""  # [v1.15.8] 会话标题自动命名（6字以内）
     raw_text: str = ""
     parse_success: bool = False
@@ -456,6 +461,10 @@ def _custom_parse(raw_text: str) -> ParsedOutput:
     raw_val = _extract_tag_content(body, "response", conservative=conservative)
     parsed.response = _safe_strip(raw_val)
 
+    # reply [v1.15.74] 用户可见文本（嵌套在<response>内，优先使用）
+    raw_val = _extract_tag_content(body, "reply", conservative=conservative)
+    parsed.reply = _safe_strip(raw_val)
+
     # recall
     raw_val = _extract_tag_content(body, "recall", conservative=conservative)
     parsed.recall = _safe_strip(raw_val)
@@ -516,6 +525,7 @@ def _custom_parse(raw_text: str) -> ParsedOutput:
     # ── Step 5: Determine parse success ──
     has_content = bool(
         parsed.response
+        or parsed.reply
         or parsed.usersays_correct
         or parsed.task_plan
         or parsed.tools_to_call

package/package.json

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

package/start.js

@@ -408,15 +408,6 @@ function cmdUpdate(pkgDir) {
     process.exit(1);
   }
 
-  // 3. 删除旧 venv 并重建
-  const venvDir = getVenvDir();
-  if (fs.existsSync(venvDir)) {
-    console.log("  删除旧虚拟环境...");
-    fs.rmSync(venvDir, { recursive: true, force: true });
-  }
-  const venvPython = ensureVenv();
-  installAllDeps(venvPython, newPkgDir);
-
   let ver = "";
   try { ver = JSON.parse(fs.readFileSync(path.join(newPkgDir, "package.json"), "utf8")).version || ""; } catch (_) {}
   markDepsInstalled(ver);

package/web/ui/chat/flow_engine.js

@@ -1155,7 +1155,23 @@ function _stripXmlTags(xml) {
   // 当只有开始标签没有闭合标签时，将开始标签到文本末尾的内容完全移除
   text = text.replace(/<task_plan[^>]*>[\s\S]*?<\/task_plan>/g, '');  // 已闭合的完整 task_plan
   text = text.replace(/<task_plan[^>]*>[\s\S]*$/g, '');  // 未闭合的 task_plan（流式中标签已打开但未关闭）
-  // Remove all other XML tags, collapse excessive whitespace
+  // [v1.15.74] 优先提取 <reply> 标签内容（新结构，嵌套在<response>内）
+  var replyMatch = text.match(/<reply[^>]*>([\s\S]*?)<\/reply>/i);
+  if (replyMatch && replyMatch[1] && replyMatch[1].trim()) {
+    return replyMatch[1].trim();
+  }
+  // [v1.15.74] 兜底：提取 <response> 标签内容并去除内部嵌套标签
+  var responseMatch = text.match(/<response[^>]*>([\s\S]*?)<\/response>/i);
+  if (responseMatch && responseMatch[1] && responseMatch[1].trim()) {
+    var innerContent = responseMatch[1]
+      .replace(/<toolstocal[\s\S]*?<\/toolstocal>/gi, '')   // 移除嵌套的toolstocal
+      .replace(/<reply[^>]*>[\s\S]*?<\/reply>/gi, '')       // 移除嵌套的reply（已提取）
+      .replace(/<[^>]+>/g, ' ')                              // 去除其他标签
+      .replace(/\s{3,}/g, ' ')
+      .trim();
+    if (innerContent) return innerContent;
+  }
+  // 兜底：去除所有XML标签
   return text
     .replace(/<[^>]+>/g, ' ')     // Replace tags with space
     .replace(/&lt;/g, '<')