myagent-ai 1.7.0 → 1.7.1

package/package.json

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

package/web/api_server.py

@@ -2611,10 +2611,29 @@ class ApiServer:
         max_iter = agent.config.agent.max_iterations if agent.config else 30
         final_response = ""
         iteration = 0
+        # 追踪连续无 action 迭代次数，防止无限重新提示
+        _consecutive_no_action = 0
+        _MAX_NO_ACTION_RETRIES = 3
 
         while iteration < max_iter:
             iteration += 1
 
+            # ── 执行模式：每轮迭代前刷新任务进度上下文 ──
+            # 这样 LLM 在每次调用时都能看到最新的任务列表状态
+            if chat_mode == "exec":
+                fresh_task_context = self._build_task_plan_context(agent_path, chat_mode, user_message)
+                if fresh_task_context:
+                    # 替换掉之前的任务规划上下文（保留非任务规划部分）
+                    base_prompt = context.metadata.get("agent_override_prompt", "")
+                    task_section_marker = "\n\n## 任务规划\n"
+                    idx = base_prompt.find(task_section_marker)
+                    if idx >= 0:
+                        # 替换旧的任务规划上下文
+                        context.metadata["agent_override_prompt"] = base_prompt[:idx] + task_section_marker + fresh_task_context
+                    else:
+                        # 没有旧的任务规划上下文，追加
+                        context.metadata["agent_override_prompt"] = base_prompt + task_section_marker + fresh_task_context
+
             # Build messages
             messages = agent._build_messages(context)
             tools = agent._get_tools()
@@ -2634,7 +2653,9 @@ class ApiServer:
             }
 
             # 需要回退(hold back)的最大字符数，用于检测 ```action 或 ```tasklist 标记
-            _MAX_HOLD = 22  # ```tasklist\n 最长 14 字符，留余量
+            # 注意: 12 足够覆盖 ```tasklist\n (12字符) + 余量
+            # 过大的值会导致短文本被 hold 住，流结束后一次性输出（看起来像非流式）
+            _MAX_HOLD = 12
 
             async def _text_delta_callback(full_text_so_far: str, delta_text: str):
                 """智能流式过滤器：文本正常推送，JSON action 块拦截"""
@@ -2661,7 +2682,8 @@ class ApiServer:
                             text_before = remaining[:marker_pos]
                             if text_before.strip():
                                 await _write_sse({"type": "text_delta", "content": text_before})
-                            st["processed_pos"] += marker_pos
+                            # 跳过整个开始标记（```action 或 ```tasklist），不要只跳到 ```
+                            st["processed_pos"] += marker_pos + len(f"```{block_type}")
                             if block_type == "tasklist":
                                 st["mode"] = "tasklist_block"
                             else:
@@ -2706,10 +2728,14 @@ class ApiServer:
 
                     elif st["mode"] == "action_block":
                         # ── Action 代码块模式：寻找结束标记 ``` ──
-                        end_marker = remaining.find("```")
+                        # 结束标记是独立的 ``` 行（前面有换行），不要匹配块开始标记内的 ```
+                        end_marker = remaining.find("\n```")
+                        if end_marker < 0 and remaining.startswith("```"):
+                            end_marker = 0
                         if end_marker >= 0:
                             # 找到结束标记，跳过整个 action 块（不推送）
-                            st["processed_pos"] += end_marker + 3  # 跳过 ```
+                            skip_len = (end_marker + 1 + 3) if end_marker > 0 else 3
+                            st["processed_pos"] += skip_len
                             st["mode"] = "text"
                             remaining = full_text_so_far[st["processed_pos"]:]
                             continue
@@ -2719,10 +2745,13 @@ class ApiServer:
 
                     elif st["mode"] == "tasklist_block":
                         # ── Tasklist 代码块模式：寻找结束标记 ``` ──
-                        end_marker = remaining.find("```")
+                        end_marker = remaining.find("\n```")
+                        if end_marker < 0 and remaining.startswith("```"):
+                            end_marker = 0
                         if end_marker >= 0:
                             # 找到结束标记，跳过整个 tasklist 块（不推送）
-                            st["processed_pos"] += end_marker + 3  # 跳过 ```
+                            skip_len = (end_marker + 1 + 3) if end_marker > 0 else 3
+                            st["processed_pos"] += skip_len
                             st["mode"] = "text"
                             remaining = full_text_so_far[st["processed_pos"]:]
                             continue
@@ -2756,7 +2785,11 @@ class ApiServer:
                 st = _stream_state
                 remaining = full_text[st["processed_pos"]:]
                 if remaining.strip() and st["mode"] == "text":
-                    await _write_sse({"type": "text_delta", "content": remaining})
+                    # 如果剩余文本较长，逐 token 推送以保持流式体验
+                    if len(remaining) > 20:
+                        await _stream_text_chunked(remaining, _write_sse, chunk_size=3, delay=0.01)
+                    else:
+                        await _write_sse({"type": "text_delta", "content": remaining})
                     st["processed_pos"] = len(full_text)
 
             # Call LLM with streaming — tokens are filtered through _text_delta_callback
@@ -2825,6 +2858,8 @@ class ApiServer:
                     )
                 continue  # Next iteration — let LLM process tool results
 
+            # 注意：成功处理 tool_calls 或 actions 后，_consecutive_no_action 会被重置
+
             # ── 从混合内容中提取 JSON action 指令 ──
             # 支持格式：
             #   1. 纯 JSON（向后兼容）
@@ -2945,6 +2980,7 @@ class ApiServer:
 
                     # Continue the loop — let LLM decide next step based on execution results
                     # tasklist 已在循环顶部 LLM 调用后提取并推送，此处无需重复
+                    _consecutive_no_action = 0  # 成功执行 action，重置无 action 计数
 
                     continue
 
@@ -2956,10 +2992,66 @@ class ApiServer:
                         await _stream_text_chunked(final_response, _write_sse)
                     break
 
-            # ── Pure text response (no actions/tool calls) — this is the final answer ──
+            # ── Pure text response (no actions/tool calls) ──
             # Content was already streamed token-by-token via _text_delta_callback
-            final_response = content
-            break
+
+            # ── 执行模式多轮续命机制 ──
+            # 问题：LLM 有时只输出文字总结而不输出 ```action``` 块，
+            # 导致循环在此处 break，任务未完成就停止。
+            # 修复：检查任务列表中是否还有未完成步骤，如果有则重新提示 LLM 继续。
+            if chat_mode == "exec":
+                current_tasks = self._task_list_store.get(agent_path, [])
+                pending_count = sum(
+                    1 for t in current_tasks
+                    if t.get("status") in ("pending", "running", "blocked")
+                )
+                if pending_count > 0 and _consecutive_no_action < _MAX_NO_ACTION_RETRIES and iteration < max_iter - 1:
+                    # 还有未完成任务，LLM 忘记了输出 action 块，重新提示
+                    _consecutive_no_action += 1
+                    logger.info(
+                        f"[{session_id}] Exec 模式: LLM 未输出 action，"
+                        f"重新提示继续执行 ({_consecutive_no_action}/{_MAX_NO_ACTION_RETRIES})"
+                    )
+                    context.conversation_history.append(
+                        Message(role="assistant", content=content)
+                    )
+                    context.conversation_history.append(
+                        Message(
+                            role="user",
+                            content=(
+                                f"[系统提示] 任务尚未完成，仍有 {pending_count} 个未执行步骤。"
+                                "你必须继续执行操作：用 ```action``` 代码块输出操作指令。"
+                                "不要只输出文字总结或反馈，必须输出具体的操作命令。"
+                            ),
+                        )
+                    )
+                    await _write_sse({
+                        "type": "thought",
+                        "content": (
+                            f"\n\n⏳ 检测到 {pending_count} 个未完成任务，"
+                            f"继续执行下一步操作..."
+                        ),
+                    })
+                    # 清除上一轮的流式输出，为下一轮腾出空间
+                    await _write_sse({"type": "clear_text"})
+                    continue
+                else:
+                    # 所有任务完成，或已达到重试上限
+                    if pending_count > 0 and _consecutive_no_action >= _MAX_NO_ACTION_RETRIES:
+                        logger.warning(
+                            f"[{session_id}] Exec 模式: 连续 {_MAX_NO_ACTION_RETRIES} 次"
+                            f"无 action 输出，强制结束循环"
+                        )
+                        # 在回复末尾追加提示
+                        final_response = content + (
+                            f"\n\n⚠️ 注意：仍有 {pending_count} 个任务未完成，"
+                            "但 Agent 已达到最大重试次数。你可以要求我继续完成这些任务。"
+                        )
+                    break
+            else:
+                # 非 exec 模式或无待办任务，正常结束
+                final_response = content
+                break
 
         # Save assistant response to memory
         if agent.memory and final_response: