myagent-ai 1.15.45 → 1.15.47

package/agents/main_agent.py

@@ -47,7 +47,7 @@ class MainAgent(BaseAgent):
 <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><callback>true/false,要求解析器在该工具执行完后是否要回调llm大模型，将所有工具输出结果+新构造的"context"输入给llm</callback></tool>
+<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>
@@ -69,17 +69,16 @@ class MainAgent(BaseAgent):
 5. <toolstocal>: 列出所有需要执行的工具调用，每个工具包含完整的参数说明
 6. <parms>: **必须使用严格合法的JSON格式**，例如 {"query": "关键词", "num": 10}，不要使用其他格式
 7. <timeout>: 预估超时秒数（简单操作10-30s，文件操作30-60s，网络请求60-120s，数据处理120-300s）
-8. <callback>: 如果该工具的执行结果对后续决策有影响，设为 true；否则设为 false
-9. <remember>: 包含 <type> 和 <content> 子标签。type 填 "global"（跨会话全局记忆）或 "session"（仅当前会话）。content 填从最新用户输入中提炼的值得记忆的关键信息。如果本轮无需记忆，content 为空且不填 type。注意：用户个人偏好、重要结论、通用经验用 global；当前任务的临时上下文、过程信息用 session
-10. <recall>: 填写下一轮需要从记忆库中主动召回的内容描述和关键字（可包含时间参考）。系统将根据这些信息搜索top5相关记忆，在下一轮通过 <recall_memory> 标签注入上下文。如果当前 <automemory> 中的记忆已足够完成任务，<recall> 为空；如果需要更多历史记忆支撑，则填写。你也可以直接使用 recall_memory 工具在当前轮即时搜索
-11. <knowledge>: 从本轮对话或工具执行结果中提炼值得长期保存的专业知识、事实、经验法则、技术要点等。这些知识会被持久化到知识库文件，未来可通过 get_knowledge 检索复用。如果没有需要保存的知识，则为空。格式：简洁明确，每条知识一行
-12. <get_knowledge>: 如果当前 <knowledge> 内容不足以完成任务，填写需要从知识库搜索的关键词；否则为空
-13. <askuser>: 当信息不足需要用户补充时，在此填写要问的问题
-14. <finish>: 当任务已完成或需要等待用户回应时为 true；否则为 false 继续执行
-15. <finish_reason>: **finish=true 时必须填写**，详细说明结束原因（任务完成/等待用户/信息不足/无法处理等）
-16. <next_step>: **finish=false 时必须填写**，描述下一步计划做什么，要求简洁明确（1-2句话）
-17. <mainsubject>: 为当前对话生成6字以内的简短标题，概括对话主题。仅在对话刚开始的前几轮需要输出，已有标题后留空
-18. 使用中文输出所有内容
+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. 使用中文输出所有内容
 
 ## 上下文中的记忆系统说明
 - <automemory>: 系统自动根据你通过 <remember> 保存的记忆和当前用户输入，搜索出的 top10 相关记忆。这些是你过去主动记住的内容（包含时间信息），可供参考。
@@ -462,8 +461,6 @@ class MainAgent(BaseAgent):
         _v2_reasoning_collected: List[str] = []
         # XML 解析失败时的 LLM 修正重试计数
         _xml_correction_retries: int = 0
-        # 连续无工具调用计数（防止模型一直不调用工具导致死循环）
-        _consecutive_no_tool_count: int = 0
 
         conversation_history = list(context.conversation_history or [])
 
@@ -907,9 +904,8 @@ class MainAgent(BaseAgent):
                     )
                 break
 
-            # Step 10: 执行工具调用
+            # Step 10: 无工具调用
             if not parsed.tools_to_call:
-                _consecutive_no_tool_count += 1
                 # 如果 finish=true 且无工具，任务完成
                 if parsed.finish:
                     logger.info(f"[{task_id}] finish=true 且无工具调用，任务完成")
@@ -928,35 +924,10 @@ class MainAgent(BaseAgent):
                             content=final_text,
                         )
                     break
-                elif _consecutive_no_tool_count >= 2:
-                    # 连续 2 轮无工具调用，视为模型无意继续执行任务
-                    logger.warning(
-                        f"[{task_id}] 连续 {_consecutive_no_tool_count} 轮无工具调用且未 finish，"
-                        f"视为任务结束"
-                    )
-                    if _v2_reasoning_collected:
-                        final_text = "\n".join(_v2_reasoning_collected)
-                    else:
-                        before, after = extract_surrounding_text(llm_raw)
-                        final_text = (before + "\n" + after).strip() if (before.strip() or after.strip()) else "任务已完成。"
-                    context.working_memory["final_response"] = final_text
-                    if not _emitted_reasoning_this_iter:
-                        await self._emit_v2_event("v2_reasoning", {"content": truncate_str(final_text, 3000)}, stream_callback)
-                    if self.memory:
-                        self.memory.add_session(
-                            session_id=context.session_id,
-                            role="assistant",
-                            content=final_text,
-                        )
-                    break
                 else:
-                    # 未 finish 且未达到连续无工具阈值，继续回调 LLM
-                    # 模型可能只是在中间步骤输出说明文字，下一轮才调用工具
-                    logger.info(
-                        f"[{task_id}] 无工具调用且未 finish（连续第 {_consecutive_no_tool_count} 轮），"
-                        f"继续回调 LLM"
-                    )
-                    # 将当前输出作为对话历史，回调 LLM 继续执行
+                    # finish=false，不限次数继续回调 LLM
+                    # 模型可能在中间步骤输出说明文字，下一轮才调用工具
+                    logger.info(f"[{task_id}] 无工具调用且 finish=false，继续回调 LLM")
                     if llm_raw.strip():
                         conversation_history.append(Message(role="assistant", content=llm_raw))
                     conversation_history.append(Message(
@@ -967,23 +938,22 @@ class MainAgent(BaseAgent):
                     ))
                     continue
 
-            # Step 11: 有工具调用 — 先执行所有工具，再根据 finish 决定回调
-            _consecutive_no_tool_count = 0  # 有工具调用，重置计数器
-            need_callback = False
+            # Step 11: 有工具调用 — 顺序执行所有工具
+            # 统一回调策略: 所有工具执行完毕，或任一工具超时 → 立即用已收集的结果回调 LLM
             tool_outputs_parts = []
-            _reasoning_len_before_round = len(_v2_reasoning_collected)  # 记录本轮开始时的长度
+            _reasoning_len_before_round = len(_v2_reasoning_collected)
+            _has_timeout = False
 
             for tool_info in parsed.tools_to_call:
                 tool_name = tool_info.get("toolname", "").strip()
                 before_call = tool_info.get("beforecalltext", "")
                 parms = tool_info.get("parms", "")
                 timeout = tool_info.get("timeout", 120)
-                should_callback = tool_info.get("callback", True)
 
                 if not tool_name:
                     continue
 
-                logger.info(f"[{task_id}] 执行工具: {tool_name} (timeout={timeout}s, callback={should_callback})")
+                logger.info(f"[{task_id}] 执行工具: {tool_name} (timeout={timeout}s)")
 
                 # 发送 beforecalltext 作为显示文本
                 if before_call:
@@ -1003,7 +973,6 @@ class MainAgent(BaseAgent):
                         "beforecalltext": before_call,
                         "parms": truncate_str(parms, 500),
                         "timeout": timeout,
-                        "callback": should_callback,
                     }},
                     stream_callback,
                 )
@@ -1167,10 +1136,8 @@ class MainAgent(BaseAgent):
 
                 is_timeout = tool_result.get("timed_out", False)
                 if is_timeout:
-                    need_callback = True
-                    logger.warning(f"[{task_id}] 工具 {tool_name} 超时 ({timeout}s)")
-                elif should_callback:
-                    need_callback = True
+                    _has_timeout = True
+                    logger.warning(f"[{task_id}] 工具 {tool_name} 超时 ({timeout}s)，停止执行剩余工具")
 
                 output_str = tool_output_text
                 # 数据密集型工具允许更长的输出
@@ -1180,10 +1147,12 @@ class MainAgent(BaseAgent):
                     _max_output = 6000
                 else:
                     _max_output = 3000
+                # 超时工具明确标注状态，让 LLM 清楚知道哪个工具超时了
+                _status = "超时" if is_timeout else ('成功' if tool_result.get('success') else '失败')
                 tool_outputs_parts.append(
                     f"### {before_call}\n"
                     f"**工具**: {tool_name}\n"
-                    f"**结果**: {'成功' if tool_result.get('success') else '失败'}\n"
+                    f"**结果**: {_status}\n"
                     f"{truncate_str(output_str, _max_output)}\n"
                 )
 
@@ -1193,7 +1162,7 @@ class MainAgent(BaseAgent):
                 ))
                 conversation_history.append(Message(
                     role="user",
-                    content=f"[工具 {tool_name} 执行完成] {'成功' if tool_result.get('success') else '失败'}",
+                    content=f"[工具 {tool_name} {'超时' if is_timeout else '执行完成'}] {_status}",
                 ))
 
                 # 保存工具调用到会话记忆
@@ -1210,15 +1179,32 @@ class MainAgent(BaseAgent):
                     self.memory.add_session(
                         session_id=context.session_id,
                         role="tool",
-                        content=f"[{tool_name}] {'成功' if tool_result.get('success') else '失败'}\n{truncate_str(output_str, 5000)}",
+                        content=f"[{tool_name}] {_status}\n{truncate_str(output_str, 5000)}",
                         key="tool_result",
                         importance=0.4,
                     )
 
+                # 任一工具超时 → 立即停止执行剩余工具
+                if _has_timeout:
+                    # 收集当前工具之后未执行的工具，一并写入回调数据
+                    _current_idx = parsed.tools_to_call.index(tool_info)
+                    _skipped_tools = []
+                    for _remaining in parsed.tools_to_call[_current_idx + 1:]:
+                        _rname = _remaining.get("toolname", "").strip()
+                        if _rname:
+                            _skipped_tools.append(_rname)
+                    if _skipped_tools:
+                        tool_outputs_parts.append(
+                            f"**注意**: 工具 {tool_name} 执行超时 ({timeout}s)，"
+                            f"以下工具未执行: {', '.join(_skipped_tools)}"
+                        )
+                    break
+
             all_tool_outputs = "\n".join(tool_outputs_parts)
 
-            # Step 12: 工具执行完毕后，根据 finish 标志决定是否回调 LLM
-            # 核心逻辑: finish=true 表示任务已完成/不需要再调用LLM，即使工具设置了callback=true
+            # Step 12: 统一回调决策
+            # 所有工具结果已收集到 all_tool_outputs（或任一超时提前收集）
+            # finish=true → 任务完成，不回调；finish=false → 将结果喂回 LLM 继续执行
             if parsed.finish:
                 logger.info(f"[{task_id}] finish=true，任务已完成，不回调 LLM")
                 # 构建有意义的最终回复：使用当前轮次的 reasoning text + 任务计划摘要
@@ -1249,10 +1235,9 @@ class MainAgent(BaseAgent):
                     )
                 break
 
-            # finish=false: 必须继续回调 LLM，无论工具 callback 设置如何
-            # callback 只控制工具结果是否喂回 LLM，不控制循环是否继续
-            # 只有 finish=true 才应该终止循环
-            logger.info(f"[{task_id}] finish=false，继续回调 LLM...")
+            # finish=false: 统一回调 LLM（所有工具结果已收集到 all_tool_outputs）
+            _timeout_info = "（有工具超时，已停止剩余工具）" if _has_timeout else f"（{len(tool_outputs_parts)} 个工具结果已收集）"
+            logger.info(f"[{task_id}] finish=false，继续回调 LLM {_timeout_info}")
 
             # 回调前，保存当前轮次的 LLM 输出到会话记忆
             # 这样每轮工具调用都有对应的 assistant 消息记录

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.15.45",
+  "version": "1.15.47",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {
@@ -65,4 +65,4 @@
     "departments/",
     "web/"
   ]
-}
+}