myagent-ai 1.6.0 → 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,8 +110,17 @@ 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"""
+    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 未初始化")
 
@@ -118,6 +128,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 +137,201 @@ 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
+
+        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":
-                response = await self.llm._run_with_retry(self.llm._chat_openai, request_kwargs)
+                # 使用异步客户端流式
+                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(
+                                {"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:
+                        await _emit_text_delta(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"):
+                            await _emit_text_delta(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:
+                            await _emit_text_delta(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/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}/` 目录下。
 
 ---