jupyter-agent 2025.6.104__py3-none-any.whl → 2025.7.100__py3-none-any.whl

jupyter_agent/bot_agents/request_user_supply.py

@@ -0,0 +1,186 @@
+"""
+Copyright (c) 2025 viewstar000
+
+This software is released under the MIT License.
+https://opensource.org/licenses/MIT
+"""
+
+import time
+import uuid
+import json
+
+from enum import Enum
+from typing import List, Optional, Dict, Any, Tuple
+from pydantic import BaseModel, Field
+from IPython.display import Markdown
+from .base import BaseChatAgent, AgentOutputFormat
+from ..bot_outputs import _D, _I, _W, _E, _F, _M, _B, _C, _O
+from ..bot_actions import (
+    get_action_dispatcher,
+    RequestUserSupplyInfo,
+    UserSupplyInfoReply,
+    ActionRequestUserSupplyInfo,
+    RequestUserSupplyInfoParams,
+    ActionReceiveUserSupplyInfo,
+    ReceiveUserSupplyInfoParams,
+    ActionSetCellContent,
+    SetCellContentParams,
+)
+from ..utils import get_env_capbilities
+
+MOCK_USER_REPLY_PROMPT = """\
+**角色定义**：
+
+你是一个用户需求补充专家，负责补充用户的需求信息，以便于更好的完成任务。
+
+**任务要求**：
+
+根据提示补充待确认的信息，以便于更好的完成任务。
+
+
+{% include "TASK_OUTPUT_FORMAT" %}
+
+---
+
+{% include "TASK_CONTEXTS" %}
+
+---
+
+{% include "CODE_CONTEXTS" %}
+
+---
+
+**当前子任务信息**:
+
+### 当前子任务目标：
+{{ task.subject }}
+
+### 当前子任务代码需求：
+{{ task.coding_prompt }}
+
+### 当前代码：
+```python
+{{ task.source }}
+```
+
+### 当前代码执行的输出与结果：
+{{ task.output }}
+
+### 当前任务总结要求：
+{{ task.summary_prompt }}
+
+### 当前任务总结结果：
+{{ task.result }}
+
+---
+
+需要补充确认的信息：
+
+{% for issue in request_supply_infos %}
+- {{ issue.prompt }}, (例如: {{ issue.example }})
+{% endfor %}
+
+---
+
+请按要求补充上述待确认的信息：
+"""
+
+
+def format_request_user_supply_info(
+    issues: list[RequestUserSupplyInfo], title="用户补充确认信息", use_markdown_block=True
+) -> str:
+    result = f"### {title}\n\n"
+    result += "\n".join(
+        [f"- **Assistant**: {prompt.prompt} (例如: {prompt.example})\n- **User Reply**: " for prompt in issues]
+    )
+    if use_markdown_block:
+        result = f"```markdown\n{result}\n```\n"
+    return result
+
+
+def format_received_user_supply_info(
+    replies: list[UserSupplyInfoReply], title="用户补充确认信息", use_markdown_block=True
+) -> str:
+    result = f"### {title}\n\n"
+    result += "\n".join([f"- **Assistant**: {reply.prompt}\n- **User Reply**: {reply.reply}" for reply in replies])
+    if use_markdown_block:
+        result = f"```markdown\n{result}\n```\n"
+    return result
+
+
+class RequestUserSupplyAgent(BaseChatAgent):
+
+    PROMPT = MOCK_USER_REPLY_PROMPT
+    OUTPUT_FORMAT = AgentOutputFormat.JSON
+    OUTPUT_JSON_SCHEMA = ReceiveUserSupplyInfoParams
+    DISPLAY_REPLY = True
+    MOCK_USER_SUPPLY: bool = False
+    WHERE_USER_SUPPLY = "below"  # "above" or "below"
+
+    def on_reply(self, reply: ReceiveUserSupplyInfoParams):
+        assert reply, "Reply is empty"
+        if get_env_capbilities().set_cell_content:
+            insert_cell_idx = -1 if self.WHERE_USER_SUPPLY == "above" else 1
+            action = ActionSetCellContent(
+                source=self.__class__.__name__,
+                params=SetCellContentParams(
+                    index=insert_cell_idx,
+                    type="markdown",
+                    source=format_received_user_supply_info(reply.replies, use_markdown_block=False),
+                ),
+            )
+            get_action_dispatcher().send_action(action, need_reply=False)
+        else:
+            _M("### 用户补充确认的信息\n\n请将下面的内容保存到单独的单元格中，以便于更好的完成任务\n\n")
+            _M(format_received_user_supply_info(reply.replies))
+
+    def __call__(self, **kwargs) -> Tuple[bool, Any]:
+        request_supply_infos = (
+            self.task.request_above_supply_infos
+            if self.WHERE_USER_SUPPLY == "above"
+            else self.task.request_below_supply_infos
+        )
+        kwargs["request_supply_infos"] = request_supply_infos
+        if self.MOCK_USER_SUPPLY:
+            return super().__call__(**kwargs)
+        else:
+            if get_env_capbilities().user_supply_info:
+                _I(f"Request User Supply Info: {request_supply_infos}")
+                action = ActionRequestUserSupplyInfo(
+                    source=self.__class__.__name__,
+                    params=RequestUserSupplyInfoParams(title="用户需求补充确认", issues=request_supply_infos),
+                )
+                get_action_dispatcher().send_action(action, need_reply=True)
+                res = get_action_dispatcher().get_action_reply(action, wait=True)
+                return False, self.on_reply(res and res.params)  # type: ignore
+            elif get_env_capbilities().set_cell_content:
+                _M(
+                    f"**需要用户补充确认信息**，"
+                    f"请将{'下面' if self.WHERE_USER_SUPPLY == 'below' else '上面'}的单元格中的内容补充完整，"
+                    f"以便于更好的完成任务"
+                )
+                insert_cell_idx = -1 if self.WHERE_USER_SUPPLY == "above" else 1
+                action = ActionSetCellContent(
+                    source=self.__class__.__name__,
+                    params=SetCellContentParams(
+                        index=insert_cell_idx,
+                        type="markdown",
+                        source=format_request_user_supply_info(request_supply_infos, use_markdown_block=False),
+                    ),
+                )
+                get_action_dispatcher().send_action(action, need_reply=False)
+            else:
+                _M(
+                    "### 需要补充确认的信息\n\n"
+                    "请将下面的内容保存到单独的单元格中并将其补充完整，以便于更好的完成任务\n\n"
+                )
+                _M(format_request_user_supply_info(request_supply_infos))
+            return False, None
+
+
+class RequestAboveUserSupplyAgent(RequestUserSupplyAgent):
+    WHERE_USER_SUPPLY = "above"
+
+
+class RequestBelowUserSupplyAgent(RequestUserSupplyAgent):
+    WHERE_USER_SUPPLY = "below"

jupyter_agent/bot_agents/task_code_executor.py

@@ -11,7 +11,7 @@ from IPython.core.getipython import get_ipython
 from IPython.display import Markdown, clear_output
 from .base import BaseAgent
 from ..utils import TeeOutputCapture
-from ..bot_outputs import _D, _I, _W, _E, _F, _M, _B, _C, ReplyType
+from ..bot_outputs import _D, _I, _W, _E, _F, _M, _B, _C, flush_output
 
 
 class CodeExecutor(BaseAgent):
@@ -21,6 +21,8 @@ class CodeExecutor(BaseAgent):
         _D(f"执行代码: {repr(self.task.source)[:80]}")
         ipython = get_ipython()
         exec_failed = False
+        self.task.cell_output = ""
+        self.task.cell_error = ""
         with TeeOutputCapture() as captured:
             if ipython is None:
                 exec_failed = True
@@ -39,7 +41,6 @@ class CodeExecutor(BaseAgent):
                     clean_traceback = "\n".join(ansi_escape.sub("", line) for line in exc_info["traceback"])
                     self.task.cell_error = clean_traceback
                     _E(f"执行失败: {clean_traceback}")
-        self.task.cell_output = ""
         if captured.stdout:
             self.task.cell_output += "Stdout:\n" + captured.stdout + "\n"
         if captured.stderr:

jupyter_agent/bot_agents/task_planner_v3.py

@@ -11,7 +11,7 @@ from pydantic import BaseModel, Field
 from IPython.display import Markdown
 from .base import BaseChatAgent, AgentOutputFormat, AgentModelType
 from ..bot_outputs import ReplyType, _D, _I, _W, _E, _F, _A, _O, _C, _M, _B
-from ..utils import RequestUserPrompt, format_user_prompts
+from ..bot_actions import RequestUserSupplyInfo
 
 
 TASK_PLANNER_PROMPT = """\
@@ -131,7 +131,7 @@ class TaskPlannerOutput(BaseModel):
         ),
         examples=["请对当前任务的结果进行总结，输出以下要素：..."],
     )
-    request_supply_infos: Optional[List[RequestUserPrompt]] = Field(
+    request_supply_infos: Optional[List[RequestUserSupplyInfo]] = Field(
         None, description=f'需要用户补充更详细的信息的 Prompt, 在 state="{TaskPlannerState.REQUEST_INFO}" 时必填'
     )
 
@@ -146,13 +146,18 @@ class TaskPlannerAgentV3(BaseChatAgent):
 
     def on_reply(self, reply: TaskPlannerOutput):
         """执行规划逻辑"""
+        self.task.agent_data.result = ""
+        self.task.agent_data.coding_prompt = ""
+        self.task.agent_data.summary_prompt = ""
+        self.task.agent_data.important_infos = None
+        self.task.agent_data.request_above_supply_infos = None
+        self.task.agent_data.request_below_supply_infos = None
         if reply.state == TaskPlannerState.GLOBAL_FINISHED:
             _C(Markdown("全局目标已达成，任务完成！"), reply_type=ReplyType.TASK_RESULT)
             return False, reply.state
         elif reply.state == TaskPlannerState.REQUEST_INFO:
             assert reply.request_supply_infos, "Request info prompt is empty"
-            _O(Markdown(f"### 需要补充更详细的信息\n"))
-            _O(Markdown(format_user_prompts(reply.request_supply_infos)))
+            self.task.agent_data.request_above_supply_infos = reply.request_supply_infos
             return True, reply.state
         elif reply.state == TaskPlannerState.CODING_PLANNED:
             assert reply.subtask_id, "Subtask id is empty"
@@ -165,11 +170,10 @@ class TaskPlannerAgentV3(BaseChatAgent):
                 f"- Coding: {reply.subtask_coding_prompt}\n"
                 f"- Summary: {reply.subtask_summary_prompt}\n"
             )
-            self.task.set_data("task_id", reply.subtask_id)
-            self.task.set_data("subject", reply.subtask_subject)
-            self.task.set_data("coding_prompt", reply.subtask_coding_prompt)
-            self.task.set_data("summary_prompt", reply.subtask_summary_prompt)
-            self.task.set_data("result", "")
+            self.task.agent_data.task_id = reply.subtask_id
+            self.task.agent_data.subject = reply.subtask_subject
+            self.task.agent_data.coding_prompt = reply.subtask_coding_prompt
+            self.task.agent_data.summary_prompt = reply.subtask_summary_prompt
             return False, reply.state
         elif reply.state == TaskPlannerState.REASONING_PLANNED:
             assert reply.subtask_id, "Subtask id is empty"
@@ -180,10 +184,9 @@ class TaskPlannerAgentV3(BaseChatAgent):
                 f"- ID: {reply.subtask_id}\n"
                 f"- Reasoning: {reply.subtask_summary_prompt}\n"
             )
-            self.task.set_data("task_id", reply.subtask_id)
-            self.task.set_data("subject", reply.subtask_subject)
-            self.task.set_data("summary_prompt", reply.subtask_summary_prompt)
-            self.task.set_data("result", "")
+            self.task.agent_data.task_id = reply.subtask_id
+            self.task.agent_data.subject = reply.subtask_subject
+            self.task.agent_data.summary_prompt = reply.subtask_summary_prompt
             return False, reply.state
         else:
             raise ValueError(f"Unknown task planner state: {reply.state}")

jupyter_agent/bot_agents/task_reasoner.py

@@ -56,6 +56,7 @@ class TaskReasoningAgent(BaseChatAgent):
     DISPLAY_REPLY = False
 
     def on_reply(self, reply: str):
-        _C(Markdown("### 任务总结\n" + reply), reply_type=ReplyType.TASK_RESULT)
         assert reply, "Reply is empty"
-        self.task.set_data("result", reply)
+        _M("### 任务总结\n" + reply)
+        self.task.agent_data.issue = ""
+        self.task.agent_data.result = reply

jupyter_agent/bot_agents/task_structrue_reasoner.py

@@ -13,7 +13,8 @@ from pydantic import BaseModel, Field
 from IPython.display import Markdown
 from .base import BaseChatAgent, AgentOutputFormat
 from ..bot_outputs import ReplyType, _D, _I, _W, _E, _F, _M, _B, _C, _O, markdown_block
-from ..utils import RequestUserPrompt, format_user_prompts
+from ..bot_actions import RequestUserSupplyInfo
+
 
 TASK_REASONER_PROMPT = """\
 **角色定义**：
@@ -58,6 +59,11 @@ TASK_REASONER_PROMPT = """\
 """
 
 
+class TaskStructureReasonState(str, Enum):
+    DONE = "done"
+    REQUEST_INFO = "request_info"
+
+
 class TaskStructureReasonOutput(BaseModel):
 
     summary: str = Field(description=f"任务总结的详细描述", examples=["..."])
@@ -77,7 +83,7 @@ class TaskStructureReasonOutput(BaseModel):
             }
         ],
     )
-    request_confirm_infos: Optional[List[RequestUserPrompt]] = Field(
+    request_confirm_infos: Optional[List[RequestUserSupplyInfo]] = Field(
         None, description="需要用户补充确认的信息，问题应尽量简单，只需要用户回答是/否或在备选项中选择即可"
     )
 
@@ -91,16 +97,20 @@ class TaskStructureReasoningAgent(BaseChatAgent):
 
     def on_reply(self, reply: TaskStructureReasonOutput):
         assert reply.summary, "Reply is empty"
-        _C(Markdown("### 任务总结\n\n" + reply.summary), reply_type=ReplyType.TASK_RESULT)
-        self.task.set_data("result", reply.summary)
+        _M("### 任务总结\n\n" + reply.summary)
+        self.task.agent_data.issue = ""
+        self.task.agent_data.result = reply.summary
+        self.task.agent_data.important_infos = None
+        self.task.agent_data.request_below_supply_infos = None
         if reply.important_infos:
-            self.task.set_data("important_infos", reply.important_infos)
-            _O(
-                markdown_block(
-                    f"```json\n{json.dumps(reply.important_infos, indent=4, ensure_ascii=False)}\n```",
-                    title="重要信息",
-                )
+            self.task.agent_data.important_infos = reply.important_infos
+            _B(
+                json.dumps(reply.important_infos, indent=4, ensure_ascii=False),
+                title="重要信息",
+                format="code",
+                code_language="json",
             )
         if reply.request_confirm_infos:
-            _O(Markdown(f"### 需要补充确认的信息\n"))
-            _O(Markdown(format_user_prompts(reply.request_confirm_infos, title="用户补充确认信息")))
+            self.task.agent_data.request_below_supply_infos = reply.request_confirm_infos
+            return TaskStructureReasonState.REQUEST_INFO
+        return TaskStructureReasonState.DONE

jupyter_agent/bot_agents/task_structrue_summarier.py

@@ -13,7 +13,7 @@ from pydantic import BaseModel, Field
 from IPython.display import Markdown
 from .base import BaseChatAgent, AgentOutputFormat
 from ..bot_outputs import ReplyType, _D, _I, _W, _E, _F, _M, _B, _C, _O, markdown_block
-from ..utils import RequestUserPrompt, format_user_prompts
+from ..bot_actions import RequestUserSupplyInfo
 
 TASK_SUMMARY_PROMPT = """\
 **角色定义**：
@@ -70,12 +70,12 @@ TASK_SUMMARY_PROMPT = """\
 """
 
 
-class RequestInfo(BaseModel):
-    prompt: str = Field(description="需要用户补充更详细的信息的 Prompt", examples=["请补充与...相关的详细的信息"])
-    example: Optional[str] = Field(None, description="示例", examples=["..."])
+class TaskStructureSummaryState(str, Enum):
+    DONE = "done"
+    REQUEST_INFO = "request_info"
 
 
-class TaskStructureSumaryOutput(BaseModel):
+class TaskStructureSummaryOutput(BaseModel):
 
     summary: str = Field(description=f"任务总结的详细描述", examples=["..."])
     important_infos: Optional[Dict[str, Any]] = Field(
@@ -94,7 +94,7 @@ class TaskStructureSumaryOutput(BaseModel):
             }
         ],
     )
-    request_confirm_infos: Optional[List[RequestUserPrompt]] = Field(
+    request_confirm_infos: Optional[List[RequestUserSupplyInfo]] = Field(
         None, description="需要用户补充确认的信息，问题应尽量简单，只需要用户回答是/否或在备选项中选择即可"
     )
 
@@ -103,21 +103,25 @@ class TaskStructureSummaryAgent(BaseChatAgent):
 
     PROMPT = TASK_SUMMARY_PROMPT
     OUTPUT_FORMAT = AgentOutputFormat.JSON
-    OUTPUT_JSON_SCHEMA = TaskStructureSumaryOutput
+    OUTPUT_JSON_SCHEMA = TaskStructureSummaryOutput
     DISPLAY_REPLY = True
 
-    def on_reply(self, reply: TaskStructureSumaryOutput):
+    def on_reply(self, reply: TaskStructureSummaryOutput):
         assert reply.summary, "Reply is empty"
-        _C(Markdown("### 任务总结\n\n" + reply.summary), reply_type=ReplyType.TASK_RESULT)
-        self.task.set_data("result", reply.summary)
+        _M("### 任务总结\n\n" + reply.summary)
+        self.task.agent_data.issue = ""
+        self.task.agent_data.result = reply.summary
+        self.task.agent_data.important_infos = None
+        self.task.agent_data.request_below_supply_infos = None
         if reply.important_infos:
-            self.task.set_data("important_infos", reply.important_infos)
-            _O(
-                markdown_block(
-                    f"```json\n{json.dumps(reply.important_infos, indent=4, ensure_ascii=False)}\n```",
-                    title="重要信息",
-                )
+            self.task.agent_data.important_infos = reply.important_infos
+            _B(
+                json.dumps(reply.important_infos, indent=4, ensure_ascii=False),
+                format="code",
+                code_language="json",
+                title="重要信息",
             )
         if reply.request_confirm_infos:
-            _O(Markdown(f"### 需要补充确认的信息\n"))
-            _O(Markdown(format_user_prompts(reply.request_confirm_infos, title="用户补充确认信息")))
+            self.task.agent_data.request_below_supply_infos = reply.request_confirm_infos
+            return TaskStructureSummaryState.REQUEST_INFO
+        return TaskStructureSummaryState.DONE

jupyter_agent/bot_agents/task_summarier.py

@@ -71,6 +71,7 @@ class TaskSummaryAgent(BaseChatAgent):
     DISPLAY_REPLY = False
 
     def on_reply(self, reply: str):
-        _C(Markdown("### 任务总结\n" + reply), reply_type=ReplyType.TASK_RESULT)
         assert reply, "Reply is empty"
-        self.task.set_data("result", reply)
+        _M("### 任务总结\n" + reply)
+        self.task.agent_data.issue = ""
+        self.task.agent_data.result = reply

jupyter_agent/bot_agents/task_verifier.py

@@ -87,6 +87,7 @@ class TaskVerifyAgent(BaseChatAgent):
 
         if reply.state == TaskVerifyState.PASSED:
             _M("### 任务验证通过！")
+            self.task.agent_data.issue = ""
             return False, reply.state
         else:
             _M("### 任务验证不通过！\n")
@@ -94,6 +95,6 @@ class TaskVerifyAgent(BaseChatAgent):
             if reply.issues:
                 for issue in reply.issues:
                     task_issue += "- {}\n".format(issue)
-            self.task.set_data("issue", task_issue)
             _M(task_issue)
+            self.task.agent_data.issue = task_issue
             return True, reply.state

jupyter_agent/bot_agents/task_verify_summarier.py

@@ -109,10 +109,10 @@ class TaskVerifySummaryAgent(BaseChatAgent):
     def on_reply(self, reply: TaskSummaryOutput):
 
         if reply.state == TaskSummaryState.SUCCESS:
-            _O(Markdown("### 任务总结"))
             assert reply.summary, "Summary is empty"
-            _C(Markdown(reply.summary), reply_type=ReplyType.TASK_RESULT)
-            self.task.set_data("result", reply.summary)
+            _M("### 任务总结\n\n" + reply.summary)
+            self.task.agent_data.issue = ""
+            self.task.agent_data.result = reply.summary
             return False, reply.state
         else:
             _M("### 任务验证不通过！\n")
@@ -124,9 +124,9 @@ class TaskVerifySummaryAgent(BaseChatAgent):
             if reply.enhancement.issues:
                 for issue in reply.enhancement.issues:
                     task_issue += "- {}\n".format(issue)
-            self.task.set_data("issue", task_issue)
-            self.task.set_data("coding_prompt", reply.enhancement.code_prompt)
-            self.task.set_data("summary_prompt", reply.enhancement.summary_prompt)
+            self.task.agent_data.issue = task_issue
+            self.task.agent_data.coding_prompt = reply.enhancement.code_prompt
+            self.task.agent_data.summary_prompt = reply.enhancement.summary_prompt
             _M(task_issue)
             _M("### 修改后的子任务信息\n")
             _M(f"### 当前子任务代码需求：\n\n{reply.enhancement.code_prompt}")

jupyter_agent/bot_chat.py

@@ -63,7 +63,7 @@ class BotChat:
         self.base_url = base_url
         self.api_key = api_key
         self.model_name = model_name
-        self.dispaly_think = chat_kwargs.get("dispaly_think", self.display_think)
+        self.display_think = chat_kwargs.get("display_think", self.display_think)
         self.display_message = chat_kwargs.get("display_message", self.display_message)
         self.display_response = chat_kwargs.get("display_response", self.display_response)
 
@@ -143,7 +143,7 @@ class BotChat:
                 if token == "<think>":
                     think_block = _read_think_block(iter_tokens)
                     raw_think_block = token + think_block + "</think>"
-                    if (self.dispaly_think or display_reply) and think_block and think_block.strip():
+                    if (self.display_think or display_reply) and think_block and think_block.strip():
                         _B(think_block, title="Thought Block")
                     if ret_think_block and (ret_empty_block or think_block and think_block.strip()):
                         yield {"type": "think", "content": think_block, "raw": raw_think_block}

jupyter_agent/bot_contexts.py

@@ -21,6 +21,7 @@ from enum import Enum
 from pydantic import BaseModel, Field
 from IPython.core.getipython import get_ipython
 from .bot_outputs import _D, _I, _W, _E, _F, _A, ReplyType
+from .utils import get_env_capbilities
 
 
 class CellType(str, Enum):
@@ -175,24 +176,25 @@ class AgentData(BaseModel):
     issue: str = Field("", description="Agent验证不通过的问题")
     result: str = Field("", description="Agent执行结果")
     important_infos: Optional[dict] = Field(None, description="重要信息[JSON]")
+    request_above_supply_infos: Optional[list] = Field(None, description="前置用户需求补充[JSON]")
+    request_below_supply_infos: Optional[list] = Field(None, description="后置用户需求补充[JSON]")
 
     @classmethod
-    def default(cls):
+    def default(cls) -> "AgentData":
         model_fields = getattr(cls, "model_fields", None)
         if model_fields and hasattr(model_fields, "items"):
-            return {
+            default = {
                 name: field.examples[0] if getattr(field, "examples", None) else getattr(field, "default", None)
                 for name, field in model_fields.items()
             }
         else:
-            return {}
+            default = {}
+        return cls(**default)  # type: ignore
 
 
 class AgentCellContext(CodeCellContext):
     """任务单元格上下文类"""
 
-    SUPPORT_SAVE_META: bool = False
-
     def __init__(self, idx: int, cell: dict):
         """初始化任务单元格上下文"""
         super().__init__(idx, cell)
@@ -202,8 +204,8 @@ class AgentCellContext(CodeCellContext):
         self.magic_argv = shlex.split(self.magic_line)
         self.magic_name = self.magic_argv[0]
         self.magic_argv = self.magic_argv[1:]
+        self.agent_data = AgentData.default()
         self._remain_args = []
-        self._agent_data = AgentData.default()
         self._cell_code = ""
         self.parse_magic_argv()
         self.load_result_from_outputs(cell)
@@ -224,16 +226,27 @@ class AgentCellContext(CodeCellContext):
 
     @property
     def result(self):
-        return self._agent_data["result"]
+        return self.agent_data.result
 
     def __getattr__(self, name):
-        return self._agent_data[name]
+        return getattr(self.agent_data, name)
+
+    def has_data(self, name):
+        return hasattr(self.agent_data, name)
 
     def get_data(self, name):
-        return self._agent_data[name]
+        return getattr(self.agent_data, name)
 
     def set_data(self, name, value):
-        self._agent_data[name] = value
+        setattr(self.agent_data, name, value)
+
+    def is_json_field(self, name):
+
+        return (
+            AgentData.model_fields[name]
+            and AgentData.model_fields[name].description is not None
+            and "[JSON]" in AgentData.model_fields[name].description  # type: ignore
+        )
 
     def parse_magic_argv(self):
         """解析任务单元格的magic命令参数"""
@@ -283,11 +296,11 @@ class AgentCellContext(CodeCellContext):
             try:
                 cell_options = yaml.safe_load(cell_options)
                 for key, value in cell_options.items():
-                    if key in self._agent_data:
-                        if isinstance(self._agent_data[key], (dict, list)) and isinstance(value, str):
+                    if self.has_data(key):
+                        if self.is_json_field(key) and isinstance(value, str):
                             value = json.loads(value)
                         _D("CELL[{}] Load task option {}: {}".format(self.cell_idx, key, value))
-                        self._agent_data[key] = value
+                        self.set_data(key, value)
             except Exception as e:
                 _W("Failed to load task options {}: {}".format(type(e), str(e)))
                 _W(traceback.format_exc(limit=2))
@@ -304,15 +317,15 @@ class AgentCellContext(CodeCellContext):
                     _D(f"CELL[{self.cell_idx}] Task result: {repr(output_text)[:80]}")
                     task_result += "\n" + output_text
         if task_result.strip():
-            self._agent_data["result"] = task_result
+            self.agent_data.result = task_result
 
     def load_data_from_metadata(self, cell):
         agent_meta_infos = cell.get("metadata", {}).get("jupyter-agent-data", {})
         _D("CELL[{}] Agent Meta Data: {}".format(self.cell_idx, repr(agent_meta_infos)[:80]))
         for k, v in agent_meta_infos.items():
-            if k in self._agent_data:
+            if self.has_data(k):
                 _D(f"CELL[{self.cell_idx}] Load agent meta data: {k}: {repr(v)[:80]}")
-                self._agent_data[k] = v
+                self.set_data(k, v)
 
     def format_magic_line(self):
         magic_args = ["%%bot"]
@@ -365,22 +378,17 @@ class AgentCellContext(CodeCellContext):
 
     def format_cell_options(self):
         cell_options = {}
-        if self.SUPPORT_SAVE_META:
-            if self._agent_data.get("task_id"):
-                cell_options["task_id"] = self._agent_data["task_id"]
-            if self._agent_data.get("subject"):
-                cell_options["subject"] = self._agent_data["subject"]
+        if get_env_capbilities().save_metadata:
+            if self.agent_data.task_id:
+                cell_options["task_id"] = self.agent_data.task_id
+            if self.agent_data.subject:
+                cell_options["subject"] = self.agent_data.subject
         else:
-            for key, value in self._agent_data.items():
+            for key, value in self.agent_data.model_dump().items():
                 if key == "result" and self.type == CellType.PLANNING:
                     continue
                 if value:
-                    if (
-                        isinstance(value, (dict, list))
-                        and AgentData.model_fields[key]
-                        and AgentData.model_fields[key].description is not None
-                        and "[JSON]" in AgentData.model_fields[key].description  # type: ignore
-                    ):
+                    if isinstance(value, (dict, list)) and self.is_json_field(key):
                         value = json.dumps(value, ensure_ascii=False, indent=4)
                     cell_options[key] = value
             if cell_options:
@@ -394,7 +402,7 @@ class AgentCellContext(CodeCellContext):
     def update_cell(self):
         """生成Cell内容"""
         _I("Updating Cell ...")
-        _A(**self._agent_data)
+        _A(**self.agent_data.model_dump())
         cell_source = ""
         cell_source += self.format_magic_line()
         cell_source += "\n" + self.format_cell_options()