myagent-ai 1.6.1 → 1.6.2

package/agents/base.py

@@ -43,6 +43,7 @@ class AgentContext:
     working_memory: Dict[str, Any] = field(default_factory=dict)
     metadata: Dict[str, Any] = field(default_factory=dict)
     callbacks: Dict[str, Callable] = field(default_factory=dict)
+    pending_injected_messages: List[str] = field(default_factory=list)
 
 
 class BaseAgent(ABC):
@@ -109,11 +110,16 @@ 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):
+    async def _call_llm_stream(self, messages, tools=None, stream_response=None, text_delta_callback=None, **kwargs):
         """调用LLM并流式输出token到SSE response
 
         当 stream_response 提供时，逐 token 将内容写入 SSE 流。
         同时积累 tool_call 增量，在流结束时返回完整的 LLMResponse。
+
+        Args:
+            text_delta_callback: 可选的回调函数 async (full_text_so_far, delta_text) -> None
+                当提供时，不再自动发送 text_delta SSE 事件，而是调用此回调。
+                回调可以自行决定如何处理文本增量（如过滤 JSON、提取 thought 等）。
         """
         if not self.llm:
             return LLMResponse(success=False, error="LLM 未初始化")
@@ -151,26 +157,21 @@ class BaseAgent(ABC):
             except Exception:
                 pass  # Client disconnected
 
+        async def _emit_text_delta(delta_text: str):
+            """处理一个 text delta：如果提供了回调则调用回调，否则直接发送 SSE"""
+            nonlocal full_text
+            full_text += delta_text
+            if text_delta_callback:
+                await text_delta_callback(full_text, delta_text)
+            else:
+                await _write_sse({"type": "text_delta", "content": delta_text})
+
         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
+                # 使用异步客户端流式
+                stream = await self.llm._client.chat.completions.create(**request_kwargs)
+                
+                async for chunk in stream:
                     if not chunk.choices:
                         if hasattr(chunk, 'usage') and chunk.usage:
                             self.llm._record_usage(
@@ -187,8 +188,7 @@ class BaseAgent(ABC):
 
                     # Handle content delta (stream to client)
                     if delta.content:
-                        full_text += delta.content
-                        await _write_sse({"type": "text_delta", "content": delta.content})
+                        await _emit_text_delta(delta.content)
 
                     # Handle tool_call deltas (accumulate)
                     if hasattr(delta, 'tool_calls') and delta.tool_calls:
@@ -253,8 +253,7 @@ class BaseAgent(ABC):
                         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})
+                            await _emit_text_delta(event.delta.text)
                     elif event.type == "message_stop":
                         finish_reason = "stop"
 
@@ -295,8 +294,7 @@ class BaseAgent(ABC):
                         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})
+                            await _emit_text_delta(content)
                         if data.get("done"):
                             finish_reason = "stop"
                             # Record usage from Ollama

package/agents/main_agent.py

@@ -44,18 +44,29 @@ class MainAgent(BaseAgent):
 5. **浏览器操作**: 自动化浏览器(如已安装 Playwright)
 6. **记忆系统**: 记住用户偏好、历史任务、避免重复犯错
 
-## 工作方式
-- 仔细分析用户需求，拆解为可执行的步骤
-- 使用可用工具完成任务
-- 每一步执行后检查结果，遇到错误自动修复
-- 完成后总结成果
-
-## 重要规则
-- 优先使用技能系统完成操作，而不是直接写代码
-- 执行危险操作前先警告用户
-- 保持回复简洁明了
-- 如果需要多步操作，先规划再执行
-- 用中文回复
+## 工作方式（遵循智能体循环规范）
+你必须严格按照 **思考→执行→观察→思考** 的循环模式工作：
+1. **思考**: 分析当前状态，确定下一步要做什么，用自然语言说明你的思路
+2. **执行**: 执行操作（一个命令或一个技能调用）
+3. **观察**: 查看执行结果，分析是否成功
+4. **继续思考**: 基于结果决定下一步，重复以上循环
+
+**执行模式**：
+- **step 模式**（默认）：每次只执行一个 action，等待结果后再决定下一步。适用于：
+  - 后续操作依赖前一步结果（如先读文件再修改）
+  - 操作可能有副作用需要确认（如删除、写入）
+  - 不确定操作是否会成功
+- **batch 模式**：一次执行多个互不依赖的 action。仅适用于：
+  - 所有操作之间完全独立，不需要前一步的结果
+  - 都是简单的只读操作（如读取多个文件、查看多个系统信息）
+  - 你有很高信心所有操作都会成功
+
+**关键原则**：
+- 默认使用 step 模式（安全优先）
+- 只有当你确信多个操作互不依赖时才用 batch 模式
+- 每个操作前，用 thought 字段说明你为什么要执行这一步
+- 如果前一步失败了，先分析原因，再尝试修复或换一种方法
+- 不要猜测结果，始终基于实际执行结果来判断
 
 ## ⏰ 超时控制规则（强制要求）
 对于每个需要执行的命令(action type="code")，你**必须**在 action 中包含 "timeout_seconds" 字段，
@@ -74,26 +85,48 @@ class MainAgent(BaseAgent):
 
 ## 格式要求
 当你需要执行操作时，输出 JSON 格式:
+
+**step 模式**（默认，逐步执行）:
 ```json
 {
-  "thought": "你的思考过程",
-  "plan": ["步骤1", "步骤2"],
+  "thought": "说明你当前的分析和下一步计划",
+  "mode": "step",
   "actions": [
-    {"type": "skill", "name": "技能名", "params": {}},
-    {"type": "code", "language": "python", "code": "代码", "timeout_seconds": 60},
-    {"type": "memory", "action": "记忆操作", "data": {}}
+    {"type": "code", "language": "python", "code": "代码", "timeout_seconds": 60}
   ]
 }
 ```
 
-**注意**: action type="code" 必须包含 "timeout_seconds" 字段。action type="skill" 或 "memory" 不需要此字段。
+**batch 模式**（多个独立操作，一次性执行）:
+```json
+{
+  "thought": "说明为什么这些操作可以批量执行（互不依赖）",
+  "mode": "batch",
+  "actions": [
+    {"type": "skill", "name": "file_read", "params": {"path": "/a.txt"}},
+    {"type": "skill", "name": "file_read", "params": {"path": "/b.txt"}}
+  ]
+}
+```
 
-你可以用 markdown 格式回复普通对话。
+如果不需要执行操作，只是回复用户，输出:
+```json
+{
+  "thought": "你的思考",
+  "actions": []
+}
+```
+然后在 JSON 外面用 markdown 写你的回复。
+
+或者直接用纯文本/markdown 回复，不包含 JSON。
+
+action type="code" 必须包含 "timeout_seconds" 字段。action type="skill" 或 "memory" 不需要此字段。
+省略 mode 字段时默认为 "step"。
 
 ## 任务规划模式
 当用户消息中包含"当前任务计划"上下文时，你处于**任务规划模式**。请:
 1. 分析用户需求，评估现有任务的完成状态
-2. 根据需要添加新任务、标记已完成任务
+2. 每完成一个任务步骤后，更新任务状态
 3. 在回复末尾用以下格式输出更新后的任务计划:
 
 ## 任务计划
@@ -101,7 +134,15 @@ class MainAgent(BaseAgent):
 - [x] 已完成的任务
 - [ ] 待执行的任务描述2
 
-保持任务简洁明确，每个任务一行。"""
+保持任务简洁明确，每个任务一行。
+
+## 重要规则
+- 优先使用技能系统完成操作，而不是直接写代码
+- 执行危险操作前先警告用户
+- 保持回复简洁明了
+- 用中文回复
+- 绝对不要在回复开头进行自我介绍
+- 不要重复问候"""
 
     def __init__(self, tool_agent=None, memory_agent=None, **kwargs):
         super().__init__(**kwargs)
@@ -118,6 +159,8 @@ class MainAgent(BaseAgent):
         # 执行事件追踪（用于前端展示命令执行过程）
         self._execution_events: List[Dict] = []
         self._exec_event_counter: int = 0
+        # 活跃会话上下文追踪（用于消息注入）
+        self.active_contexts: Dict[str, AgentContext] = {}
 
     def _add_exec_event(self, event_type: str, data: Dict):
         """记录一个执行事件（供前端展示）"""
@@ -158,6 +201,8 @@ class MainAgent(BaseAgent):
         context.task_id = task_id
         self._iteration_count = 0
         self._current_task_id = task_id
+        # 记录活跃上下文
+        self.active_contexts[context.session_id] = context
         # 清空上一轮的执行事件
         self.clear_execution_events()
 
@@ -171,6 +216,8 @@ class MainAgent(BaseAgent):
         try:
             return await self._process_inner(context, task_id)
         finally:
+            # 移除活跃上下文
+            self.active_contexts.pop(context.session_id, None)
             # 注销广播器
             if self.config_broadcaster and self._registered_task:
                 self.config_broadcaster.unregister(task_id)
@@ -220,6 +267,24 @@ class MainAgent(BaseAgent):
                     if reload_type == "code":
                         logger.info(f"[{task_id}] 代码模块已热更新，LLM 客户端将在下次调用时自动重建")
 
+            # ── 检查并处理注入的消息 ──
+            if context.pending_injected_messages:
+                injected = context.pending_injected_messages.copy()
+                context.pending_injected_messages.clear()
+                for msg_text in injected:
+                    logger.info(f"[{task_id}] 注入消息到对话历史: {msg_text[:50]}...")
+                    # 如果不是第一轮，且历史最后一条不是 user 消息，则注入
+                    context.conversation_history.append(
+                        Message(role="user", content=f"[用户中断/补充]: {msg_text}")
+                    )
+                    # 同时也保存到短期记忆
+                    if self.memory:
+                        self.memory.add_short_term(
+                            session_id=context.session_id,
+                            role="user",
+                            content=f"[中断补充]: {msg_text}",
+                        )
+
             # 构建消息列表
             messages = self._build_messages(context)
 
@@ -279,6 +344,16 @@ class MainAgent(BaseAgent):
             if action_data and isinstance(action_data, dict):
                 # 有结构化的操作指令
                 if "actions" in action_data:
+                    action_mode = action_data.get("mode", "step")
+
+                    # step 模式安全保护：只执行第一个 action
+                    if action_mode == "step" and len(action_data.get("actions", [])) > 1:
+                        action_data = {
+                            "thought": action_data.get("thought", ""),
+                            "mode": "step",
+                            "actions": [action_data["actions"][0]],
+                        }
+
                     # 执行操作列表
                     results = await self._execute_actions(
                         action_data, context, task_id
@@ -317,9 +392,9 @@ class MainAgent(BaseAgent):
                         Message(role="user", content=feedback_msg)
                     )
 
-                    # 如果任务已完成(所有操作成功)，退出循环
+                    # 退出循环判断：step 模式始终继续让 LLM 决定，batch 模式全部成功则退出
                     all_success = all(r.get("success", False) for r in results)
-                    if all_success and results:
+                    if action_mode == "batch" and 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"])
@@ -428,7 +503,7 @@ class MainAgent(BaseAgent):
         # 执行模式：强调主动执行能力
         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- 不要反复询问用户是否要执行，直接执行并报告结果"
+            system_prompt += "\n\n## 执行模式 (当前激活)\n你当前处于执行模式，请务必主动使用可用工具执行操作，而不是只提供建议或反问用户。\n- 默认逐步执行（step 模式），每次一个操作，等待结果再决定下一步\n- 仅当多个操作完全独立时使用 batch 模式\n- 优先使用技能系统（skill）完成任务\n- 需要执行代码时，直接使用 code action 执行\n- 遇到不确定的操作，先尝试执行，失败后再调整\n- 不要反复询问用户是否要执行，直接执行并报告结果\n- 每步操作前先用 thought 说明你的计划"
 
         # 记忆上下文
         memory_ctx = context.working_memory.get("memory_context_prompt", "")
@@ -600,20 +675,7 @@ class MainAgent(BaseAgent):
 
                 code_lang = action.get("language", "python")
                 code_text = action.get("code", "")
-                # 记录代码执行开始事件
-                self._add_exec_event("code_exec", {
-                    "title": f"执行 {code_lang} 代码",
-                    "language": code_lang,
-                    "code": code_text,
-                    "code_preview": truncate_str(code_text, 200),
-                    "status": "running",
-                    "timeout": timeout_seconds if 'timeout_seconds' in dir() else 120,
-                })
 
-                # 注入权限检查器到 executor（用于更细粒度的检查）
-                self.executor.set_permission_checker(
-                    self.check_permission, self.name
-                )
                 # 提取 LLM 预估的超时时间
                 timeout_seconds = action.get("timeout_seconds")
                 if timeout_seconds is None:
@@ -633,6 +695,21 @@ class MainAgent(BaseAgent):
                             f"[{task_id}] timeout_seconds 值无效，使用默认值 120s"
                         )
 
+                # 记录代码执行开始事件
+                self._add_exec_event("code_exec", {
+                    "title": f"执行 {code_lang} 代码",
+                    "language": code_lang,
+                    "code": code_text,
+                    "code_preview": truncate_str(code_text, 200),
+                    "status": "running",
+                    "timeout": timeout_seconds,
+                })
+
+                # 注入权限检查器到 executor（用于更细粒度的检查）
+                self.executor.set_permission_checker(
+                    self.check_permission, self.name
+                )
+
                 exec_result = await self.executor.execute(
                     language=action.get("language", "python"),
                     code=action.get("code", ""),
@@ -654,6 +731,7 @@ class MainAgent(BaseAgent):
                     "timed_out": exec_result.timed_out,
                     "exit_code": exec_result.exit_code,
                     "execution_time": round(exec_result.execution_time, 3),
+                    "timeout": timeout_seconds,
                     "stdout": truncate_str(exec_result.stdout, 5000),
                     "stderr": truncate_str(exec_result.stderr, 3000),
                     "error": truncate_str(exec_result.error, 2000),

package/core/llm.py

@@ -231,9 +231,9 @@ class LLMClient:
             self._init_openai()
 
     def _init_openai(self):
-        """初始化 OpenAI / 兼容客户端"""
+        """初始化 OpenAI / 兼容客户端 (异步)"""
         try:
-            from openai import OpenAI
+            from openai import AsyncOpenAI
         except ImportError:
             # 自动尝试安装 openai
             logger.warning("openai 未安装，正在自动安装...")
@@ -249,15 +249,17 @@ class LLMClient:
                 if isinstance(e, ImportError):
                     raise
                 raise ImportError(f"请安装 openai: pip install openai (安装异常: {e})")
-        # 安装成功后重新导入
-        from openai import OpenAI
+        
+        from openai import AsyncOpenAI
         kwargs = {}
         if self.api_key:
             kwargs["api_key"] = self.api_key
         if self.base_url:
             kwargs["base_url"] = self.base_url
-        self._client = OpenAI(**kwargs)
-        logger.info(f"OpenAI 客户端已初始化 (model={self.model})")
+        if self.timeout:
+            kwargs["timeout"] = self.timeout
+        self._client = AsyncOpenAI(**kwargs)
+        logger.info(f"AsyncOpenAI 客户端已初始化 (model={self.model})")
 
     def _init_anthropic(self):
         """初始化 Anthropic 客户端"""
@@ -436,12 +438,9 @@ class LLMClient:
     # ------------------------------------------------------------------
 
     async def _chat_openai(self, kwargs: dict) -> LLMResponse:
-        """OpenAI / 兼容接口调用 (含 Zhipu)"""
-        loop = asyncio.get_running_loop()
+        """OpenAI / 兼容接口调用 (异步)"""
         try:
-            response = await loop.run_in_executor(
-                None, lambda: self._client.chat.completions.create(**kwargs)
-            )
+            response = await self._client.chat.completions.create(**kwargs)
         except Exception as api_err:
             # 记录请求详情以便调试
             msgs = kwargs.get("messages", [])

package/docs//351/205/215/347/275/256/344/275/277/347/224/250/350/257/264/346/230/216.md

@@ -291,7 +291,25 @@ MyAgent 支持两种执行模式：
 - **原子写入**：使用"写入临时文件 → 重命名"的方式确保配置文件写入的原子性，避免写入过程中断导致配置损坏。
 - **回滚机制**：如果校验失败，自动从最近的备份中恢复配置，确保系统始终处于可用状态。
 
-由于以上安全机制的存在，配置助手"永远不会改坏配置"——即使修改过程中出现异常，系统也能安全恢复到之前的工作状态。
+### 面向 AI 助手的管理 API (Technical Guideline)
+
+为了让配置助手能够自动管理系统，MyAgent 专门提供了一套简洁的 REST API：
+
+- **Agent 管理**:
+    - `POST /api/agents`: 创建顶级 Agent。JSON 参数: `{"name": "...", "description": "...", "system_prompt": "..."}`
+    - `POST /api/agents/{parent}/children`: 在指定父级下创建子 Agent。
+    - `PUT /api/agents/{path}`: 更新 Agent 基本配置。
+    - `PUT /api/agents/{path}/soul`: 专门更新系统提示词 (soul.md)。
+- **部门管理**:
+    - `POST /api/departments`: 创建新部门。参数: `{"name": "...", "parent": "..."}`
+    - `PUT /api/departments/{path}/agents`: 为部门分配 Agent 成员。参数: `{"agents": ["agent1", "agent2"]}`
+- **配置操作**:
+    - `POST /api/config/safe-save`: 安全保存主配置。
+
+**重要准则**：
+1. **配置大于代码**：Agent 和部门的创建应始终通过这些 API 或修改 `config.json` 实现。
+2. **禁止修改源码**：严禁通过在 `agents/` 目录下编写新的 `.py` 文件来创建 Agent。
+3. **隔离性**：新创建的 Agent 的数据应存放在 `data/agents/{name}/` 目录下。
 
 ---
 

package/main.py

@@ -115,6 +115,9 @@ class MyAgentApp:
         self.config = self.config_mgr.config
         self.logger = None
         self._running = False
+        self._restart_requested = False
+        self._stop_requested = False
+        self._start_requested = False
 
         # 核心组件
         self.memory: MemoryManager | None = None
@@ -857,12 +860,33 @@ def create_tray_icon(app: MyAgentApp, web_port: int = 8767):
     def restart_service(icon, item):
         """重启 Web 服务"""
         try:
-            icon.notify("正在重启服务...", "MyAgent")
-            # 设置标志让主循环重新启动
+            icon.notify("正在重启并重新加载配置...", "MyAgent")
             app._restart_requested = True
         except Exception as e:
             icon.notify(f"重启失败: {e}", "MyAgent")
 
+    def stop_service(icon, item):
+        """停止 Web 服务"""
+        try:
+            app._stop_requested = True
+            # 为了 UI 响应迅速，预设状态并刷新菜单
+            app._running_service = False
+            _refresh_menu(icon)
+            app.logger.info("用户请求停止服务")
+        except Exception as e:
+            icon.notify(f"停止失败: {e}", "MyAgent")
+
+    def start_service(icon, item):
+        """启动 Web 服务"""
+        try:
+            app._start_requested = True
+            # 为了 UI 响应迅速，预设状态并刷新菜单
+            app._running_service = True
+            _refresh_menu(icon)
+            app.logger.info("用户请求启动服务")
+        except Exception as e:
+            icon.notify(f"启动失败: {e}", "MyAgent")
+
     def on_quit(icon, item):
         """退出应用"""
         try:
@@ -907,6 +931,9 @@ def create_tray_icon(app: MyAgentApp, web_port: int = 8767):
             pystray.MenuItem("打开配置目录", open_config_dir),
             pystray.Menu.SEPARATOR,
             pystray.MenuItem("开机自启", toggle_autostart, checked=_autostart_checked),
+            pystray.Menu.SEPARATOR,
+            pystray.MenuItem("启动服务", start_service, visible=lambda item: not app._running_service),
+            pystray.MenuItem("停止服务", stop_service, visible=lambda item: app._running_service),
             pystray.MenuItem("重启服务", restart_service),
             pystray.Menu.SEPARATOR,
             pystray.MenuItem("退出", on_quit),
@@ -1513,24 +1540,81 @@ def main():
         if app.update_manager:
             asyncio.create_task(app.update_manager.start_auto_check(interval=3600))
 
+        app._running_service = web_port or app.chat_manager
         if args.tray:
             # 托盘模式: 后台等待
             app.logger.info("后台运行中... (Ctrl+C 退出)")
             while app._running:
                 await asyncio.sleep(1)
-                # 检查重启请求
+                
+                # A. 处理停止请求
+                if getattr(app, '_stop_requested', False):
+                    app._stop_requested = False
+                    if app._running_service:
+                        app.logger.info("正在停止所有后台服务...")
+                        if api_server:
+                            try: await api_server.stop()
+                            except Exception: pass
+                            api_server = None
+                        if app.chat_manager:
+                            try: await app.chat_manager.stop_all()
+                            except Exception: pass
+                        app._running_service = False
+                        _tray_notify(app, "服务已停止", "管理后台与聊天平台已关闭")
+
+                # B. 处理启动请求
+                if getattr(app, '_start_requested', False):
+                    app._start_requested = False
+                    if not app._running_service:
+                        app.logger.info("正在启动服务...")
+                        try:
+                            if web_port:
+                                from web.api_server import ApiServer
+                                api_server = ApiServer(app)
+                                await api_server.start(port=web_port)
+                            if app.chat_manager:
+                                asyncio.create_task(app.chat_manager.start_all())
+                            app._running_service = True
+                            _tray_notify(app, "服务已启动", f"管理后台: http://127.0.0.1:{web_port}/ui/")
+                        except Exception as e:
+                            app.logger.error(f"启动失败: {e}")
+                            _tray_notify(app, "启动失败", str(e))
+
+                # C. 检查重启请求
                 if getattr(app, '_restart_requested', False):
                     app._restart_requested = False
-                    app.logger.info("收到重启请求...")
+                    app.logger.info("收到重启请求，正在重新加载所有组件...")
+                    
+                    # 1. 停止现有服务
                     if api_server:
-                        try:
-                            await api_server.stop()
-                        except Exception:
-                            pass
-                        api_server = ApiServer(app)
-                        await api_server.start(port=web_port)
-                        app.logger.info(f"服务已重启: http://127.0.0.1:{web_port}/ui/")
-                    _tray_notify(app, "服务已重启", f"端口: {web_port}")
+                        try: await api_server.stop()
+                        except Exception: pass
+                    if app.chat_manager:
+                        try: await app.chat_manager.stop_all()
+                        except Exception: pass
+                    
+                    # 2. 重新加载配置并初始化核心
+                    try:
+                        app.config_mgr.reload()
+                        app.config = app.config_mgr.config
+                        await app.initialize()
+                        
+                        # 3. 启动 Web 服务
+                        if web_port:
+                            from web.api_server import ApiServer
+                            api_server = ApiServer(app)
+                            await api_server.start(port=web_port)
+                            app.logger.info(f"Web 服务已重启: http://127.0.0.1:{web_port}/ui/")
+
+                        # 4. 启动聊天平台
+                        if app.chat_manager:
+                            asyncio.create_task(app.chat_manager.start_all())
+                            
+                        app._running_service = True
+                        _tray_notify(app, "MyAgent 已重启", f"核心配置已重新加载")
+                    except Exception as e:
+                        app.logger.error(f"重启过程中发生错误: {e}", exc_info=True)
+                        _tray_notify(app, "重启失败", str(e))
         elif web_port:
             # Web 模式 (无托盘): 后台运行保持服务
             app.logger.info("Web 服务运行中... (Ctrl+C 退出)")
@@ -1549,7 +1633,10 @@ def main():
             except Exception:
                 pass
         if api_server:
-            await api_server.stop()
+            try:
+                await api_server.stop()
+            except Exception:
+                pass
 
     try:
         asyncio.run(run())

package/package.json

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