myagent-ai 1.6.0 → 1.6.1

package/agents/base.py

@@ -110,7 +110,11 @@ class BaseAgent(ABC):
         return response
 
     async def _call_llm_stream(self, messages, tools=None, stream_response=None, **kwargs):
-        """调用LLM并流式输出token到SSE response"""
+        """调用LLM并流式输出token到SSE response
+
+        当 stream_response 提供时，逐 token 将内容写入 SSE 流。
+        同时积累 tool_call 增量，在流结束时返回完整的 LLMResponse。
+        """
         if not self.llm:
             return LLMResponse(success=False, error="LLM 未初始化")
 
@@ -118,6 +122,8 @@ class BaseAgent(ABC):
         if not stream_response:
             return await self._call_llm(messages, tools=tools, **kwargs)
 
+        import asyncio as _asyncio
+
         self.llm._ensure_client()
         msg_dicts = [m.to_dict() if hasattr(m, 'to_dict') else m for m in messages]
         request_kwargs = {
@@ -125,27 +131,209 @@ class BaseAgent(ABC):
             "messages": msg_dicts,
             "temperature": self.llm.temperature,
             "max_tokens": self.llm.max_tokens,
-            "stream": False,  # We'll handle streaming ourselves
+            "stream": True,
         }
         if tools:
             request_kwargs["tools"] = tools
             request_kwargs["tool_choice"] = "auto"
         request_kwargs.update(kwargs)
 
+        full_text = ""
+        tool_calls_acc: Dict[int, Dict] = {}  # index -> {id, name, arguments_str}
+        finish_reason = ""
+
+        async def _write_sse(data: dict):
+            """将一个事件写入 SSE 流，忽略客户端断开错误"""
+            try:
+                await stream_response.write(
+                    ("data: " + json.dumps(data, ensure_ascii=False) + "\n\n").encode()
+                )
+            except Exception:
+                pass  # Client disconnected
+
         try:
             if self.llm.provider in self.llm._OPENAI_COMPATIBLE_PROVIDERS or self.llm.provider == "zhipu":
-                response = await self.llm._run_with_retry(self.llm._chat_openai, request_kwargs)
+                loop = _asyncio.get_running_loop()
+
+                def _create_stream():
+                    return self.llm._client.chat.completions.create(**request_kwargs)
+
+                stream = await loop.run_in_executor(None, _create_stream)
+
+                def _next_chunk(it):
+                    try:
+                        return next(it)
+                    except StopIteration:
+                        return None
+
+                iterator = iter(stream)
+                while True:
+                    chunk = await loop.run_in_executor(None, _next_chunk, iterator)
+                    if chunk is None:
+                        break
+                    if not chunk.choices:
+                        if hasattr(chunk, 'usage') and chunk.usage:
+                            self.llm._record_usage(
+                                {"prompt_tokens": chunk.usage.prompt_tokens,
+                                 "completion_tokens": chunk.usage.completion_tokens,
+                                 "total_tokens": chunk.usage.total_tokens},
+                                request_kwargs["model"],
+                            )
+                        continue
+
+                    delta = chunk.choices[0].delta
+                    if chunk.choices[0].finish_reason:
+                        finish_reason = chunk.choices[0].finish_reason
+
+                    # Handle content delta (stream to client)
+                    if delta.content:
+                        full_text += delta.content
+                        await _write_sse({"type": "text_delta", "content": delta.content})
+
+                    # Handle tool_call deltas (accumulate)
+                    if hasattr(delta, 'tool_calls') and delta.tool_calls:
+                        for tc_delta in delta.tool_calls:
+                            idx = tc_delta.index if hasattr(tc_delta, 'index') else 0
+                            if idx not in tool_calls_acc:
+                                tool_calls_acc[idx] = {"id": "", "name": "", "arguments": ""}
+                            if tc_delta.id:
+                                tool_calls_acc[idx]["id"] = tc_delta.id
+                            if hasattr(tc_delta, 'function') and tc_delta.function:
+                                if tc_delta.function.name:
+                                    tool_calls_acc[idx]["name"] = tc_delta.function.name
+                                if tc_delta.function.arguments:
+                                    tool_calls_acc[idx]["arguments"] += tc_delta.function.arguments
+
+                    # Handle usage in final chunk
+                    if hasattr(chunk, 'usage') and chunk.usage:
+                        self.llm._record_usage(
+                            {"prompt_tokens": chunk.usage.prompt_tokens,
+                             "completion_tokens": chunk.usage.completion_tokens,
+                             "total_tokens": chunk.usage.total_tokens},
+                            request_kwargs["model"],
+                        )
+
             elif self.llm.provider == "anthropic":
-                response = await self.llm._run_with_retry(self.llm._chat_anthropic, messages, request_kwargs)
+                loop = _asyncio.get_running_loop()
+
+                system_msg = ""
+                anth_messages = []
+                for m in messages:
+                    role = m.role if hasattr(m, 'role') else m.get("role", "user")
+                    content = m.content if hasattr(m, 'content') else m.get("content", "")
+                    if role == "system":
+                        system_msg = content
+                        continue
+                    anth_messages.append({"role": role, "content": content})
+
+                create_kwargs = {
+                    "model": self.llm.model,
+                    "messages": anth_messages,
+                    "max_tokens": self.llm.max_tokens,
+                    "stream": True,
+                }
+                if system_msg:
+                    create_kwargs["system"] = system_msg
+
+                def _create_stream():
+                    return self.llm._client.messages.create(**create_kwargs)
+
+                stream = await loop.run_in_executor(None, _create_stream)
+
+                def _next_event(it):
+                    try:
+                        return next(it)
+                    except StopIteration:
+                        return None
+
+                iterator = iter(stream)
+                while True:
+                    event = await loop.run_in_executor(None, _next_event, iterator)
+                    if event is None:
+                        break
+                    if event.type == "content_block_delta":
+                        if hasattr(event.delta, "text"):
+                            full_text += event.delta.text
+                            await _write_sse({"type": "text_delta", "content": event.delta.text})
+                    elif event.type == "message_stop":
+                        finish_reason = "stop"
+
             elif self.llm.provider == "ollama":
-                response = await self.llm._run_with_retry(self.llm._chat_ollama, request_kwargs)
+                loop = _asyncio.get_running_loop()
+                import requests as req_lib
+
+                url = f"{self.llm.base_url}/api/chat"
+                payload = {
+                    "model": self.llm.model,
+                    "messages": msg_dicts,
+                    "stream": True,
+                    "options": {
+                        "temperature": self.llm.temperature,
+                        "num_predict": self.llm.max_tokens,
+                    },
+                }
+
+                def _request():
+                    r = req_lib.post(url, json=payload, stream=True, timeout=self.llm.timeout)
+                    r.raise_for_status()
+                    return r.iter_lines()
+
+                lines_iter = await loop.run_in_executor(None, _request)
+
+                def _next_line(it):
+                    try:
+                        return next(it)
+                    except StopIteration:
+                        return None
+
+                iterator = iter(lines_iter)
+                while True:
+                    line = await loop.run_in_executor(None, _next_line, iterator)
+                    if line is None:
+                        break
+                    try:
+                        data = json.loads(line.decode('utf-8') if isinstance(line, bytes) else line)
+                        content = data.get("message", {}).get("content", "")
+                        if content:
+                            full_text += content
+                            await _write_sse({"type": "text_delta", "content": content})
+                        if data.get("done"):
+                            finish_reason = "stop"
+                            # Record usage from Ollama
+                            usage = data.get("prompt_eval_count") or data.get("eval_count")
+                            if data.get("prompt_eval_count"):
+                                self.llm._record_usage(
+                                    {"prompt_tokens": data.get("prompt_eval_count", 0),
+                                     "completion_tokens": data.get("eval_count", 0),
+                                     "total_tokens": data.get("prompt_eval_count", 0) + data.get("eval_count", 0)},
+                                    self.llm.model,
+                                )
+                    except Exception:
+                        continue
             else:
-                return LLMResponse(success=False, error="未知提供商")
-
-            if response.usage:
-                self.llm._record_usage(response.usage, response.model)
-
-            return response
+                return LLMResponse(success=False, error="未知提供商，不支持流式")
+
+            # Build tool_calls list from accumulated deltas
+            final_tool_calls = []
+            for idx in sorted(tool_calls_acc.keys()):
+                tc = tool_calls_acc[idx]
+                try:
+                    args = json.loads(tc["arguments"]) if tc["arguments"] else {}
+                except json.JSONDecodeError:
+                    args = {}
+                final_tool_calls.append({
+                    "id": tc["id"],
+                    "name": tc["name"],
+                    "arguments": args,
+                })
+
+            return LLMResponse(
+                success=True,
+                content=full_text,
+                tool_calls=final_tool_calls,
+                finish_reason=finish_reason,
+                model=request_kwargs.get("model", self.llm.model),
+            )
         except Exception as e:
             logger.error(f"LLM 流式调用失败: {e}")
             return LLMResponse(success=False, error=str(e))

package/package.json

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

package/web/api_server.py

@@ -394,18 +394,23 @@ class ApiServer:
         chat_mode = data.get("mode", "")  # "exec" = 执行模式
         escalated = data.get("escalated", False)  # 临时提权到 local
 
-        # ── 全局执行锁检查 ──
+        # ── 全局执行锁检查 + 获取（原子操作，check+set 之间无 await）──
         agent_cfg_early = self._read_agent_config(agent_path)
         execution_mode = agent_cfg_early.get("execution_mode", "sandbox") if agent_cfg_early else "sandbox"
         needs_lock_check = (execution_mode == "local") or escalated
-        if needs_lock_check and self._execution_lock["locked"]:
-            locked_by = self._execution_lock["locked_by"]
-            if locked_by and locked_by != agent_path:
-                return web.json_response({
-                    "error": f"该Agent当前无法以本地模式运行，因为全局锁被 {locked_by} 持有。请先释放锁或切换到沙盒模式。",
-                    "locked_by": locked_by,
-                    "locked_at": self._execution_lock.get("locked_at"),
-                }, status=423)
+        if needs_lock_check:
+            if self._execution_lock["locked"]:
+                locked_by = self._execution_lock["locked_by"]
+                if locked_by and locked_by != agent_path:
+                    return web.json_response({
+                        "error": f"该Agent当前无法以本地模式运行，因为全局锁被 {locked_by} 持有。请先释放锁或切换到沙盒模式。",
+                        "locked_by": locked_by,
+                        "locked_at": self._execution_lock.get("locked_at"),
+                    }, status=423)
+            # Acquire lock atomically (no await between check and set)
+            self._execution_lock["locked"] = True
+            self._execution_lock["locked_by"] = agent_path
+            self._execution_lock["locked_at"] = time.time()
 
         # ── 执行模式: 注入任务规划上下文 ──
         task_plan_context = ""
@@ -467,6 +472,12 @@ class ApiServer:
         except Exception as e:
             logger.error(f"Chat error: {e}", exc_info=True)
             return web.json_response({"error": str(e)}, status=500)
+        finally:
+            # Release execution lock if we acquired it
+            if needs_lock_check and self._execution_lock["locked_by"] == agent_path:
+                self._execution_lock["locked"] = False
+                self._execution_lock["locked_by"] = None
+                self._execution_lock["locked_at"] = None
 
     async def handle_chat_stream(self, request):
         """POST /api/chat/stream - SSE 流式聊天"""
@@ -2369,7 +2380,11 @@ class ApiServer:
 
     async def _stream_process_message(self, user_message, session_id, stream_response,
                                       agent_path=None, agent_system_prompt=None, chat_mode=""):
-        """使用流式LLM调用处理消息，实时推送token到SSE"""
+        """使用流式LLM调用处理消息，支持完整的agent循环（工具调用/操作执行）+ 实时流式输出
+
+        实现与 MainAgent._process_inner() 相同的计划-执行-反思循环，
+        但将 LLM 的文本响应逐 token 流式推送到 SSE。
+        """
         if not self.core.main_agent or not self.core.llm:
             result = await self.core.process_message(user_message, session_id)
             await stream_response.write(("data: " + json.dumps({"type": "text", "content": result}) + "\n\n").encode())
@@ -2377,6 +2392,7 @@ class ApiServer:
 
         agent = self.core.main_agent
         from agents.base import AgentContext
+        from core.utils import safe_json_parse, truncate_str
         context = AgentContext(session_id=session_id, user_message=user_message)
 
         # Set agent context through context metadata instead of instance attributes
@@ -2384,6 +2400,9 @@ class ApiServer:
         context.metadata["agent_override_path"] = agent_path
         context.metadata["chat_mode"] = chat_mode
 
+        # Clear execution events from previous runs
+        agent.clear_execution_events()
+
         # Load memory
         if agent.memory_agent:
             mem_ctx = AgentContext(task_id="", session_id=session_id, user_message=user_message,
@@ -2396,30 +2415,185 @@ class ApiServer:
         if agent.memory:
             agent.memory.add_short_term(session_id=session_id, role="user", content=user_message)
 
-        # Build messages
-        messages = agent._build_messages(context)
-        tools = agent._get_tools()
+        async def _write_sse(data: dict):
+            """Write SSE event, ignoring client disconnect errors"""
+            try:
+                await stream_response.write(
+                    ("data: " + json.dumps(data, ensure_ascii=False) + "\n\n").encode()
+                )
+            except Exception:
+                pass  # Client disconnected
 
-        # Call LLM with streaming
-        full_text = ""
-        try:
+        # Full agent loop (plan-execute-reflect) — mirrors MainAgent._process_inner
+        max_iter = agent.config.agent.max_iterations if agent.config else 30
+        final_response = ""
+        iteration = 0
+
+        while iteration < max_iter:
+            iteration += 1
+
+            # Clear any intermediate text from previous iterations on the frontend
+            if iteration > 1:
+                await _write_sse({"type": "clear_text"})
+
+            # Build messages
+            messages = agent._build_messages(context)
+            tools = agent._get_tools()
+
+            # Call LLM with streaming — tokens are pushed to SSE in real-time
             response = await agent._call_llm_stream(messages, tools=tools, stream_response=stream_response)
             if not response.success:
-                await stream_response.write(("data: " + json.dumps({"type": "text", "content": f"⚠️ LLM调用失败: {response.error}"}) + "\n\n").encode())
+                await _write_sse({"type": "text", "content": f"⚠️ LLM调用失败: {response.error}"})
                 return f"⚠️ LLM 调用失败: {response.error}"
 
-            full_text = response.content or ""
-            await stream_response.write(("data: " + json.dumps({"type": "text", "content": full_text}) + "\n\n").encode())
-        except Exception as e:
-            logger.error(f"Stream LLM error: {e}")
-            await stream_response.write(("data: " + json.dumps({"type": "text", "content": f"❌ 处理失败: {str(e)}"}) + "\n\n").encode())
-            return f"❌ 处理失败: {str(e)}"
+            content = response.content or ""
 
-        # Save assistant response
-        if agent.memory and full_text:
-            agent.memory.add_short_term(session_id=session_id, role="assistant", content=full_text)
+            # ── Check for tool calls (OpenAI function calling) ──
+            if response.tool_calls:
+                # Send tool_call event to frontend
+                agent._add_exec_event("tool_call", {
+                    "title": f"调用 {len(response.tool_calls)} 个工具",
+                    "tool_names": [tc["name"] for tc in response.tool_calls],
+                })
+                await _write_sse({"type": "exec_event", "data": {
+                    "type": "tool_call",
+                    "title": f"调用 {len(response.tool_calls)} 个工具",
+                }})
+
+                # Add assistant tool_calls message to history (OpenAI format requirement)
+                context.conversation_history.append(
+                    Message(role="assistant", content=response.content or "",
+                           tool_calls=response.tool_calls)
+                )
 
-        return full_text
+                # Execute tool calls
+                tool_results = await agent._handle_tool_calls(response.tool_calls, context, "")
+
+                # Send tool_result event to frontend
+                for tc, result in tool_results:
+                    success = result.get("success", False)
+                    agent._add_exec_event("tool_result", {
+                        "title": f"工具结果: {tc['name']}",
+                        "tool_name": tc["name"],
+                        "success": success,
+                        "summary": truncate_str(result.get("output", result.get("error", "")), 500),
+                    })
+                    await _write_sse({"type": "exec_event", "data": {
+                        "type": "tool_result",
+                        "title": f"工具结果: {tc['name']}",
+                        "success": success,
+                    }})
+
+                # Add tool results to history
+                for tc, result in tool_results:
+                    context.conversation_history.append(
+                        Message(role="tool", content=json.dumps(result, ensure_ascii=False),
+                               tool_call_id=tc["id"], name=tc["name"])
+                    )
+                continue  # Next iteration — let LLM process tool results
+
+            # ── Try parsing JSON action instructions ──
+            action_data = safe_json_parse(content)
+
+            if action_data and isinstance(action_data, dict):
+                # Has structured action instructions
+                if "actions" in action_data:
+                    # Execute action list
+                    results = await agent._execute_actions(action_data, context, "")
+
+                    # Send execution events accumulated by _execute_actions
+                    # _execute_actions calls _add_exec_event internally; relay them
+                    recent_events = agent.get_execution_events()
+                    # Only send events from this round (events added since last check)
+                    # Since we cleared at start, send all new events
+                    for evt in recent_events:
+                        await _write_sse({"type": "exec_event", "data": evt})
+
+                    # Add assistant action message to conversation history
+                    context.conversation_history.append(Message(role="assistant", content=content))
+
+                    result_summary = agent._summarize_action_results(results)
+
+                    # Handle timeout diagnostics (same as _process_inner)
+                    has_timeout = any(r.get("timed_out") for r in results)
+                    timeout_detail = ""
+                    if has_timeout:
+                        timeout_details = []
+                        for i, r in enumerate(results, 1):
+                            if r.get("timed_out"):
+                                diag = r.get("timeout_diagnosis", {})
+                                timeout_details.append(
+                                    f"### 命令 {i} 超时诊断\n"
+                                    f"- 原因: {diag.get('diagnosis', '未知')}\n"
+                                    f"- 进展: {diag.get('progress', '未知')}\n"
+                                    f"- 是否建议重试: {'是' if diag.get('should_retry') else '否'}\n"
+                                    f"- 重试策略: {diag.get('retry_strategy', '无')}\n"
+                                )
+                        timeout_detail = "\n\n## ⏰ 超时诊断详情\n" + "\n".join(timeout_details)
+
+                    feedback_msg = f"[执行结果]\n{result_summary}\n\n请基于以上结果继续。"
+                    if timeout_detail:
+                        feedback_msg += timeout_detail + "\n\n请根据以上诊断信息决定下一步操作。"
+
+                    context.conversation_history.append(
+                        Message(role="user", content=feedback_msg)
+                    )
+
+                    # Check if all actions succeeded
+                    all_success = all(r.get("success", False) for r in results)
+                    if all_success and results:
+                        final_response = action_data.get("thought", "")
+                        if "plan" in action_data and action_data["plan"]:
+                            final_response += "\n\n已完成: " + " → ".join(action_data["plan"])
+                        break
+
+                    # Check if timeout diagnosis suggests aborting
+                    if has_timeout:
+                        should_abort = False
+                        abort_reasons = []
+                        for i, r in enumerate(results, 1):
+                            if r.get("timed_out"):
+                                diag = r.get("timeout_diagnosis", {})
+                                if diag.get("should_retry") is False:
+                                    should_abort = True
+                                    abort_reasons.append(
+                                        f"命令{i}: {diag.get('diagnosis', '不可恢复的超时')}"
+                                    )
+                        if should_abort:
+                            abort_msg = (
+                                "[系统通知] 以下命令因超时被终止，且超时诊断结果表明不应重试:\n"
+                            )
+                            for reason in abort_reasons:
+                                abort_msg += f"- {reason}\n"
+                            abort_msg += (
+                                "\n请直接以纯文本或 {\"type\": \"final_answer\", \"content\": \"...\"} "
+                                "格式回复，告知用户任务无法完成的原因和建议的替代方案。"
+                            )
+                            context.conversation_history.append(
+                                Message(role="user", content=abort_msg)
+                            )
+                            continue  # Let LLM generate final_answer
+
+                    continue  # Next iteration
+
+                # Single action — final_answer
+                if action_data.get("type") == "final_answer":
+                    final_response = action_data.get("content", content)
+                    # Stream the final answer text if not already streamed
+                    if final_response and final_response != content:
+                        await _write_sse({"type": "text_delta", "content": final_response})
+                    break
+
+            # ── Pure text response (no actions/tool calls) — this is the final answer ──
+            # Content was already streamed token-by-token via _call_llm_stream
+            final_response = content
+            break
+
+        # Save assistant response to memory
+        if agent.memory and final_response:
+            agent.memory.add_short_term(session_id=session_id, role="assistant", content=final_response)
+
+        return final_response
 
     async def handle_reload_config(self, request):
         """POST /api/config/reload - 从配置文件热重载（无需重启）
@@ -3228,11 +3402,14 @@ class ApiServer:
         )
 
         # 3. 广播到所有非禁言成员agent，并行处理
-        responses = []
         active_members = [m for m in group.members if not m.muted]
 
         import asyncio
+        # Build a member_order map for deterministic sorting after gather
+        member_order = {m.agent_path: i for i, m in enumerate(active_members)}
+
         async def process_agent_member(member):
+            """Process a single member's response (DO NOT save messages here)"""
             try:
                 agent_path = member.agent_path
                 agent_cfg = self._read_agent_config(agent_path)
@@ -3257,17 +3434,6 @@ class ApiServer:
                     avatar = agent_cfg.get("avatar_emoji", "🤖") or "🤖"
                     display_name = agent_cfg.get("name", agent_path)
 
-                # 保存agent回复到群消息
-                agent_msg = GroupMessage(
-                    group_id=gid,
-                    sender="agent",
-                    sender_name=display_name,
-                    sender_avatar=avatar,
-                    content=response,
-                    agent_path=agent_path,
-                )
-                mgr.add_message(agent_msg)
-
                 return {
                     "ok": True,
                     "agent_path": agent_path,
@@ -3288,23 +3454,41 @@ class ApiServer:
         # 并行调用所有成员agent
         tasks = [process_agent_member(m) for m in active_members]
         try:
-            responses = await asyncio.gather(*tasks, return_exceptions=True)
+            gather_results = await asyncio.gather(*tasks, return_exceptions=True)
         except Exception as e:
             logger.error(f"群消息广播异常: {e}")
             tp.update_task_status(task_id, "failed", last_message=f"广播异常: {str(e)}")
             return web.json_response({"error": f"群消息广播异常: {str(e)}"}, status=500)
 
-        # 处理异常结果
-        final_responses = []
-        for r in responses:
+        # 处理异常结果并按原始成员顺序排序
+        raw_responses = []
+        for r in gather_results:
             if isinstance(r, Exception):
-                final_responses.append({
+                raw_responses.append({
                     "ok": False, "agent_path": "unknown",
                     "name": "unknown", "avatar": "❌",
                     "response": f"异常: {str(r)}",
                 })
             else:
-                final_responses.append(r)
+                raw_responses.append(r)
+
+        # Sort by original member order to ensure deterministic message ordering
+        final_responses = sorted(
+            raw_responses,
+            key=lambda r: member_order.get(r.get("agent_path", ""), 999999)
+        )
+
+        # Save agent messages sequentially in sorted order
+        for resp in final_responses:
+            agent_msg = GroupMessage(
+                group_id=gid,
+                sender="agent",
+                sender_name=resp["name"],
+                sender_avatar=resp["avatar"],
+                content=resp["response"],
+                agent_path=resp["agent_path"],
+            )
+            mgr.add_message(agent_msg)
 
         # 更新任务状态
         has_failure = any(not r.get("ok") for r in final_responses)

package/web/ui/chat.html

@@ -3608,6 +3608,19 @@ async function sendMessage() {
             fullResponse = evt.content;
             state.messages[msgIdx].content = evt.content;
             renderMessages();
+          } else if (evt.type === 'text_delta') {
+            // Incremental streaming token
+            fullResponse += evt.content;
+            state.messages[msgIdx].content = fullResponse;
+            renderMessages();
+          } else if (evt.type === 'clear_text') {
+            // Clear intermediate text from previous agent loop iterations
+            fullResponse = '';
+            state.messages[msgIdx].content = '';
+            renderMessages();
+          } else if (evt.type === 'exec_event') {
+            // Real-time execution event (tool call, code exec, skill result, etc.)
+            execEventsReceived.push(evt.data);
           } else if (evt.type === 'done') {
             execEventsReceived = evt.exec_events || [];
           } else if (evt.type === 'error') {