myagent-ai 1.5.9 → 1.6.1

package/agents/base.py

@@ -109,6 +109,235 @@ class BaseAgent(ABC):
             logger.error(f"{self.name} LLM 调用失败: {response.error}")
         return response
 
+    async def _call_llm_stream(self, messages, tools=None, stream_response=None, **kwargs):
+        """调用LLM并流式输出token到SSE response
+
+        当 stream_response 提供时，逐 token 将内容写入 SSE 流。
+        同时积累 tool_call 增量，在流结束时返回完整的 LLMResponse。
+        """
+        if not self.llm:
+            return LLMResponse(success=False, error="LLM 未初始化")
+
+        # If no stream_response, fall back to non-streaming
+        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 = {
+            "model": self.llm.model,
+            "messages": msg_dicts,
+            "temperature": self.llm.temperature,
+            "max_tokens": self.llm.max_tokens,
+            "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":
+                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":
+                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":
+                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="未知提供商，不支持流式")
+
+            # 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))
+
     async def _call_llm_json(self, messages: List[Message], **kwargs) -> Dict[str, Any]:
         """调用 LLM 并获取 JSON 响应"""
         if not self.llm:

package/agents/main_agent.py

@@ -416,8 +416,8 @@ class MainAgent(BaseAgent):
             system_prompt += "\n\n" + org_context
 
         # 注入 Agent 专属 system_prompt（如果有覆盖）
-        agent_prompt = getattr(self, '_agent_override_prompt', None)
-        agent_path = getattr(self, '_agent_override_path', None)
+        agent_prompt = context.metadata.get("agent_override_prompt") if context.metadata else None
+        agent_path = context.metadata.get("agent_override_path") if context.metadata else None
         if agent_prompt:
             prefix = f"## 当前角色\n你当前正在扮演「{agent_path}」Agent。请严格遵循以下角色设定:\n\n"
             system_prompt += "\n\n" + prefix + agent_prompt
@@ -426,7 +426,7 @@ class MainAgent(BaseAgent):
         system_prompt += "\n\n## 对话规则\n- 绝对不要在回复开头进行自我介绍（如'你好，我是XXX'），直接回答用户的问题或执行任务\n- 不要重复问候，除非用户主动打招呼"
 
         # 执行模式：强调主动执行能力
-        chat_mode = getattr(self, '_chat_mode', '')
+        chat_mode = (context.metadata.get("chat_mode") or '') if context.metadata else ''
         if chat_mode == 'exec':
             system_prompt += "\n\n## 执行模式 (当前激活)\n你当前处于执行模式，请务必主动使用可用工具执行操作，而不是只提供建议或反问用户。\n- 优先使用技能系统（skill）完成任务\n- 需要执行代码时，直接使用 code action 执行\n- 遇到不确定的操作，先尝试执行，失败后再调整\n- 不要反复询问用户是否要执行，直接执行并报告结果"
 

package/package.json

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

package/web/api_server.py

@@ -235,6 +235,7 @@ class ApiServer:
         r.add_get("/api/logs", self.handle_get_logs)
         r.add_get("/api/logs/stream", self.handle_log_stream)
         r.add_post("/api/chat", self.handle_chat)
+        r.add_post("/api/chat/stream", self.handle_chat_stream)
         r.add_get("/chat", self.handle_chat_page)
         r.add_get("/api/execution/progress", self.handle_execution_progress)
         # ── 组织管理 ──
@@ -393,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 = ""
@@ -466,6 +472,134 @@ 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 流式聊天"""
+        try:
+            data = await request.json()
+        except Exception:
+            return web.Response(text="data: " + json.dumps({"error": "invalid JSON"}) + "\n\n", content_type="text/event-stream")
+
+        message = data.get("message", "").strip()
+        if not message:
+            return web.Response(text="data: " + json.dumps({"error": "message is required"}) + "\n\n", content_type="text/event-stream")
+
+        agent_path = data.get("agent_path", data.get("agent_name", "default")) or "default"
+        raw_session_id = data.get("session_id", "") or "web_default"
+        session_id = f"{agent_path}_{raw_session_id}"
+        chat_mode = data.get("mode", "")
+        escalated = data.get("escalated", False)
+
+        # Lock check
+        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:
+                error_data = json.dumps({"error": f"执行锁被 {locked_by} 持有", "locked": True})
+                return web.Response(text="data: " + error_data + "\n\n", content_type="text/event-stream")
+
+        # Acquire execution lock if needed
+        if needs_lock_check:
+            self._execution_lock["locked"] = True
+            self._execution_lock["locked_by"] = agent_path
+            self._execution_lock["locked_at"] = time.time()
+
+        response = web.StreamResponse(
+            status=200,
+            headers={
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+            }
+        )
+        await response.prepare(request)
+
+        try:
+            agent_cfg = self._read_agent_config(agent_path)
+            model_chain = self._build_model_chain(agent_cfg, agent_path)
+
+            # Build context with task plan injection (SEPARATE from user message)
+            task_plan_context = self._build_task_plan_context(agent_path, chat_mode, message)
+            clean_message, agent_system_prompt = self._build_agent_chat_context(agent_path, agent_cfg, message)
+            if task_plan_context:
+                clean_message = clean_message + task_plan_context
+
+            # Send session info first
+            await response.write(("data: " + json.dumps({"type": "session", "session_id": session_id, "agent_path": agent_path}) + "\n\n").encode())
+
+            # Use streaming LLM call
+            if model_chain and self.core.llm:
+                full_response = await self._try_model_chain_stream(
+                    model_chain, clean_message, session_id,
+                    agent_path=agent_path, agent_system_prompt=agent_system_prompt,
+                    chat_mode=chat_mode, stream_response=response,
+                )
+            else:
+                full_response = await self.core.process_message(clean_message, session_id)
+                await response.write(("data: " + json.dumps({"type": "text", "content": full_response}) + "\n\n").encode())
+
+            # Collect exec events
+            exec_events = []
+            if self.core.main_agent:
+                exec_events = self.core.main_agent.get_execution_events()
+
+            # Update task plan from response
+            if chat_mode == "exec" and self.core.llm and full_response:
+                try:
+                    await self._extract_and_update_task_plan(agent_path, full_response)
+                except Exception:
+                    pass
+
+            # Send done event
+            done_data = {"type": "done", "exec_events": exec_events}
+            await response.write(("data: " + json.dumps(done_data) + "\n\n").encode())
+
+        except Exception as e:
+            logger.error(f"Stream chat error: {e}", exc_info=True)
+            await response.write(("data: " + json.dumps({"type": "error", "error": str(e)}) + "\n\n").encode())
+        finally:
+            # Release execution lock
+            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
+            try:
+                await response.write_eof()
+            except Exception:
+                pass
+
+        return response
+
+    def _build_task_plan_context(self, agent_path: str, chat_mode: str, original_message: str) -> str:
+        """构建任务计划上下文（不修改原始消息）"""
+        if chat_mode != "exec":
+            return ""
+        tp = self._task_md_path(agent_path)
+        if not tp.exists():
+            # No existing task plan - tell agent to create one
+            return "\n\n## 任务规划\n你当前处于执行模式。请先分析用户需求，制定任务计划，然后逐步执行。\n在回复开头用以下格式列出任务计划:\n```\n## 任务计划\n- [ ] 步骤1\n- [ ] 步骤2\n```\n然后开始执行第一个步骤。"
+        existing_content = tp.read_text(encoding="utf-8")
+        tasks = self._parse_task_md(existing_content)
+        if not tasks:
+            return "\n\n## 任务规划\n你当前处于执行模式。请先分析用户需求，制定任务计划，然后逐步执行。\n在回复开头用以下格式列出任务计划:\n```\n## 任务计划\n- [ ] 步骤1\n- [ ] 步骤2\n```\n然后开始执行第一个步骤。"
+        pending = [f"  - [ ] {t['text']}" for t in tasks if not t['done']]
+        done = [f"  - [x] {t['text']}" for t in tasks if t['done']]
+        context = "\n\n## 当前任务计划 (task.md)\n"
+        if done:
+            context += "已完成:\n" + "\n".join(done) + "\n"
+        if pending:
+            context += "待完成:\n" + "\n".join(pending) + "\n"
+        context += "\n请继续执行任务。执行完成后更新任务计划状态。在回复开头包含更新后的任务计划:\n```\n## 任务计划\n- [x] 已完成的步骤\n- [ ] 下一步骤\n```\n"
+        return context
 
     async def handle_chat_page(self, request):
         """GET /chat - 重定向到聊天页面"""
@@ -2201,6 +2335,266 @@ class ApiServer:
         # 所有模型都失败
         return f"⚠️ 所有模型均调用失败 (共 {len(model_chain)} 个)。最后错误: {last_error}"
 
+    async def _try_model_chain_stream(self, model_chain, message, session_id,
+                                       agent_path=None, agent_system_prompt=None,
+                                       chat_mode="", stream_response=None):
+        """流式版本的模型链调用，逐token输出到SSE"""
+        if not model_chain:
+            result = await self.core.process_message(message, session_id)
+            await stream_response.write(("data: " + json.dumps({"type": "text", "content": result}) + "\n\n").encode())
+            return result
+
+        llm = self.core.llm
+        full_text = ""
+
+        for i, mc in enumerate(model_chain):
+            orig = {
+                "provider": llm.provider, "model": llm.model, "base_url": llm.base_url,
+                "api_key": llm.api_key, "temperature": llm.temperature, "max_tokens": llm.max_tokens,
+            }
+            try:
+                if "provider" in mc: llm.provider = mc["provider"]
+                if "model" in mc: llm.model = mc["model"]
+                if "base_url" in mc: llm.base_url = mc["base_url"]
+                if "api_key" in mc: llm.api_key = mc["api_key"]
+                if "temperature" in mc: llm.temperature = mc["temperature"]
+                if "max_tokens" in mc: llm.max_tokens = mc["max_tokens"]
+                llm._client = None
+
+                # Pass agent context through AgentContext instead of instance attrs
+                result = await self._stream_process_message(
+                    message, session_id, stream_response,
+                    agent_path=agent_path, agent_system_prompt=agent_system_prompt,
+                    chat_mode=chat_mode,
+                )
+                if result and not result.startswith("⚠️") and not result.startswith("❌"):
+                    return result
+            except Exception as e:
+                logger.warning(f"模型 {i} 流式调用失败: {e}")
+            finally:
+                llm.provider = orig["provider"]; llm.model = orig["model"]
+                llm.base_url = orig["base_url"]; llm.api_key = orig["api_key"]
+                llm.temperature = orig["temperature"]; llm.max_tokens = orig["max_tokens"]
+
+        return full_text
+
+    async def _stream_process_message(self, user_message, session_id, stream_response,
+                                      agent_path=None, agent_system_prompt=None, chat_mode=""):
+        """使用流式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())
+            return result
+
+        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
+        context.metadata["agent_override_prompt"] = agent_system_prompt
+        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,
+                                   metadata={"memory_action": "get_relevant"})
+            await agent.memory_agent.process(mem_ctx)
+            if "memory_context_prompt" in mem_ctx.working_memory:
+                context.working_memory["memory_context_prompt"] = mem_ctx.working_memory["memory_context_prompt"]
+
+        # Save ORIGINAL user message (not the one with task plan appended)
+        if agent.memory:
+            agent.memory.add_short_term(session_id=session_id, role="user", content=user_message)
+
+        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
+
+        # 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 _write_sse({"type": "text", "content": f"⚠️ LLM调用失败: {response.error}"})
+                return f"⚠️ LLM 调用失败: {response.error}"
+
+            content = response.content or ""
+
+            # ── 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)
+                )
+
+                # 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 - 从配置文件热重载（无需重启）
 
@@ -3008,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)
@@ -3037,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,
@@ -3068,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

@@ -3556,8 +3556,11 @@ async function sendMessage() {
 
   try {
     state.abortController = new AbortController();
-    const data = await api('/api/chat', {
+    
+    // Use SSE streaming
+    const resp = await fetch('/api/chat/stream', {
       method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
         message: text,
         session_id: sessionId,
@@ -3568,34 +3571,90 @@ async function sendMessage() {
       }),
       signal: state.abortController.signal,
     });
-
-    // Add assistant response
-    state.messages.push({
-      role: 'assistant',
-      content: data.response || '(无回复)',
-      time: new Date().toISOString(),
-      exec_events: data.exec_events || [],
-    });
-
-    // Update session in list
-    const existing = state.sessions.find(s => s.id === sessionId);
+    
+    if (!resp.ok) {
+      const errText = await resp.text();
+      throw new Error('HTTP ' + resp.status + ': ' + errText);
+    }
+    
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let fullResponse = '';
+    let msgIdx = state.messages.length;
+    let sessionIdReceived = sessionId;
+    let execEventsReceived = [];
+    
+    // Add placeholder for streaming response
+    state.messages.push({ role: 'assistant', content: '', time: new Date().toISOString(), streaming: true });
+    renderMessages();
+    
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        try {
+          const evt = JSON.parse(line.substring(6));
+          
+          if (evt.type === 'session') {
+            sessionIdReceived = evt.session_id;
+          } else if (evt.type === 'text') {
+            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') {
+            fullResponse = '❌ ' + evt.error;
+            state.messages[msgIdx].content = fullResponse;
+          }
+        } catch (e) { /* skip malformed */ }
+      }
+    }
+    
+    // Finalize message
+    if (state.messages[msgIdx]) {
+      state.messages[msgIdx].streaming = false;
+      if (execEventsReceived.length > 0) {
+        state.messages[msgIdx].exec_events = execEventsReceived;
+      }
+      if (!state.messages[msgIdx].content) {
+        state.messages[msgIdx].content = '(无回复)';
+      }
+    }
+    
+    // Update session
+    const existing = state.sessions.find(s => s.id === sessionIdReceived);
     if (existing) {
       existing.messages = (existing.messages || 0) + 2;
       existing.last = new Date().toISOString();
     } else {
-      state.sessions.splice(1, 0, {
-        id: sessionId,
-        name: formatSessionName(sessionId),
-        messages: 2,
-        last: new Date().toISOString(),
-      });
+      state.sessions.splice(1, 0, { id: sessionIdReceived, name: formatSessionName(sessionIdReceived), messages: 2, last: new Date().toISOString() });
     }
-    // Update cache
     state.agentSessions[state.activeAgent] = [...state.sessions];
     renderSessions();
 
     // Auto-play TTS if enabled (skip command execution results)
-    if (ttsManager.enabled && data.response && !data.response.match(/^\s*[✅❌⏰]\s*\[执行结果\]/m)) {
+    if (ttsManager.enabled && fullResponse && !fullResponse.match(/^\s*[✅❌⏰]\s*\[执行结果\]/m)) {
       const idx = state.messages.length - 1;
       ttsManager.speak(idx);
     }