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

jupyter_agent/bot_agents/base.py

@@ -135,6 +135,7 @@ class AgentModelType(str, Enum):
     DEFAULT = "default"
     PLANNER = "planner"
     CODING = "coding"
+    EVALUATING = "evaluating"
     REASONING = "reasoning"
 
 
@@ -152,6 +153,9 @@ class BaseAgent:
     def cells(self):
         return self.notebook_context.cells
 
+    def __call__(self, **kwds: Any) -> Tuple[bool, Any]:
+        raise NotImplementedError
+
 
 class BaseChatAgent(BotChat, BaseAgent):
     """基础聊天代理类"""

jupyter_agent/bot_agents/master_planner.py

@@ -8,7 +8,6 @@ https://opensource.org/licenses/MIT
 from IPython.display import Markdown
 from .base import BaseChatAgent, AgentModelType
 from ..bot_outputs import _C, ReplyType
-from ..bot_evaluators.dummy_task import DummyTaskEvaluator
 
 MASTER_PLANNER_PROMPT = """\
 **角色定义**：
@@ -41,7 +40,7 @@ class MasterPlannerAgent(BaseChatAgent):
     PROMPT = MASTER_PLANNER_PROMPT
     DISPLAY_REPLY = False
     MODEL_TYPE = AgentModelType.PLANNER
-    EVALUATORS = {None: DummyTaskEvaluator}
 
     def on_reply(self, reply):
+        self.task.agent_data.result = ""
         _C(Markdown(reply), reply_type=ReplyType.TASK_RESULT)

jupyter_agent/bot_agents/prepare_next_cell.py

@@ -0,0 +1,52 @@
+"""
+Copyright (c) 2025 viewstar000
+
+This software is released under the MIT License.
+https://opensource.org/licenses/MIT
+"""
+
+import json
+import datetime
+
+from IPython.display import Markdown
+from .base import BaseAgent
+from ..bot_outputs import _D, _I, _W, _E, _F, _M, _B, _C, _O, ReplyType, markdown_block
+from ..bot_actions import get_action_dispatcher, ActionSetCellContent, SetCellContentParams
+from ..utils import get_env_capbilities
+
+
+class PrepareNextCell(BaseAgent):
+
+    def __call__(self):
+        """执行代码逻辑"""
+        if get_env_capbilities().set_cell_content:
+            _I("set next cell content to generate the next task")
+            get_action_dispatcher().send_action(
+                ActionSetCellContent(
+                    source=self.__class__.__name__,
+                    params=SetCellContentParams(
+                        index=1,
+                        type="code",
+                        source=(
+                            "%%bot\n\n"
+                            "# Execute this cell to generate the next task\n"
+                            "# {}\n"
+                            "# Special Note: Ensure the notebook is SAVED before executing this cell!\n"
+                        ).format(datetime.datetime.now().isoformat()),
+                    ),
+                ),
+                need_reply=False,
+            )
+        else:
+            _M("Copy the following code to the next cell to generate the next task ...")
+            _M(
+                (
+                    "```python\n"
+                    "%%bot\n\n"
+                    "# Execute this cell to generate the next task\n"
+                    "# {}\n"
+                    "# Special Note: Ensure the notebook is SAVED before executing this cell!\n"
+                    "```"
+                ).format(datetime.datetime.now().isoformat())
+            )
+        return False, None

jupyter_agent/bot_agents/request_user_supply.py

@@ -145,7 +145,7 @@ class RequestUserSupplyAgent(BaseChatAgent):
             return super().__call__(**kwargs)
         else:
             if get_env_capbilities().user_supply_info:
-                _M(f"**需要用户补充确认信息**，请按要求补充确认信息。")
+                _I(f"Request User Supply Info: {request_supply_infos}")
                 action = ActionRequestUserSupplyInfo(
                     source=self.__class__.__name__,
                     params=RequestUserSupplyInfoParams(title="用户需求补充确认", issues=request_supply_infos),

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

@@ -146,6 +146,12 @@ 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
@@ -168,7 +174,6 @@ class TaskPlannerAgentV3(BaseChatAgent):
             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
-            self.task.agent_data.result = ""
             return False, reply.state
         elif reply.state == TaskPlannerState.REASONING_PLANNED:
             assert reply.subtask_id, "Subtask id is empty"
@@ -182,7 +187,6 @@ class TaskPlannerAgentV3(BaseChatAgent):
             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
-            self.task.agent_data.result = ""
             return False, reply.state
         else:
             raise ValueError(f"Unknown task planner state: {reply.state}")

jupyter_agent/bot_agents/task_reasoner.py

@@ -58,4 +58,5 @@ class TaskReasoningAgent(BaseChatAgent):
     def on_reply(self, reply: str):
         assert reply, "Reply is empty"
         _M("### 任务总结\n" + reply)
+        self.task.agent_data.issue = ""
         self.task.agent_data.result = reply

jupyter_agent/bot_agents/task_structrue_reasoner.py

@@ -98,7 +98,10 @@ class TaskStructureReasoningAgent(BaseChatAgent):
     def on_reply(self, reply: TaskStructureReasonOutput):
         assert reply.summary, "Reply is empty"
         _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.agent_data.important_infos = reply.important_infos
             _B(

jupyter_agent/bot_agents/task_structrue_summarier.py

@@ -109,7 +109,10 @@ class TaskStructureSummaryAgent(BaseChatAgent):
     def on_reply(self, reply: TaskStructureSummaryOutput):
         assert reply.summary, "Reply is empty"
         _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.agent_data.important_infos = reply.important_infos
             _B(

jupyter_agent/bot_agents/task_summarier.py

@@ -73,4 +73,5 @@ class TaskSummaryAgent(BaseChatAgent):
     def on_reply(self, reply: str):
         assert reply, "Reply is empty"
         _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.agent_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

@@ -111,6 +111,7 @@ class TaskVerifySummaryAgent(BaseChatAgent):
         if reply.state == TaskSummaryState.SUCCESS:
             assert reply.summary, "Summary is empty"
             _M("### 任务总结\n\n" + reply.summary)
+            self.task.agent_data.issue = ""
             self.task.agent_data.result = reply.summary
             return False, reply.state
         else:

jupyter_agent/bot_contexts.py

@@ -240,6 +240,14 @@ class AgentCellContext(CodeCellContext):
     def set_data(self, 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命令参数"""
         parser = argparse.ArgumentParser()
@@ -289,7 +297,7 @@ class AgentCellContext(CodeCellContext):
                 cell_options = yaml.safe_load(cell_options)
                 for key, value in cell_options.items():
                     if self.has_data(key):
-                        if isinstance(self.get_data(key), (dict, list)) and isinstance(value, str):
+                        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.set_data(key, value)
@@ -380,12 +388,7 @@ class AgentCellContext(CodeCellContext):
                 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:

jupyter_agent/bot_evaluators/base.py

@@ -17,7 +17,7 @@ class BaseEvaluator(BaseChatAgent):
     """
 
     OUTPUT_FORMAT = AgentOutputFormat.JSON
-    MODEL_TYPE = AgentModelType.REASONING
+    MODEL_TYPE = AgentModelType.EVALUATING
     DISPLAY_REPLY = False
 
     def on_reply(self, reply):

jupyter_agent/bot_flows/base.py

@@ -13,6 +13,7 @@ from enum import Enum
 from typing import List, Dict, Optional, Type
 from IPython.display import Markdown
 from ..bot_agents.base import BaseAgent
+from ..bot_evaluators.base import BaseEvaluator
 from ..bot_evaluators.dummy_global import DummyGlobalEvaluator
 from ..bot_evaluators.flow_task_executor import FlowTaskExecEvaluator
 from ..bot_outputs import _D, _I, _W, _E, _F, _M, _B
@@ -39,9 +40,10 @@ class StageNext[ST](BaseModel):
     message: str = ""
 
 
-class StageTransition[ST, AS](BaseModel):
+class StageNode[ST, AS](BaseModel):
     stage: ST | str
-    agent: Type[BaseAgent] | str
+    agents: Type[BaseAgent] | List[Type[BaseAgent]]
+    evaluators: Optional[Type[BaseEvaluator] | List[Type[BaseEvaluator]]] = None
     states: Dict[AS | str, StageNext[ST] | List[StageNext[ST]] | Dict[TaskAction, StageNext[ST]] | ST | str] = {}
     next_stage: Optional[StageNext[ST] | List[StageNext[ST]] | Dict[TaskAction, StageNext[ST]] | ST | str] = None
 
@@ -51,7 +53,7 @@ class BaseTaskFlow:
     基础任务流程
     """
 
-    STAGE_TRANSITIONS: List[StageTransition] = []
+    STAGE_NODES: List[StageNode] = []
     START_STAGE = TASK_STAGE_START
     STOP_STAGES = [TASK_STAGE_COMPLETED, TASK_STAGE_GLOBAL_FINISHED]
     FLOW_EVALUATOR = FlowTaskExecEvaluator
@@ -61,8 +63,8 @@ class BaseTaskFlow:
         self.notebook_context = notebook_context
         self.agent_factory = agent_factory
         self.evaluator_factory = evaluator_factory
-        self.stage_transitions = {}
-        self.prepare_stage_transitions()
+        self.stage_nodes = {}
+        self.prepare_stage_nodes()
 
     @property
     def task(self):
@@ -72,10 +74,10 @@ class BaseTaskFlow:
     def cells(self):
         return self.notebook_context.cells
 
-    def prepare_stage_transitions(self):
-        for st in self.STAGE_TRANSITIONS:
+    def prepare_stage_nodes(self):
+        for st in self.STAGE_NODES:
             assert not (st.next_stage and st.states), "next_stage and states are mutually exclusive"
-            self.stage_transitions[st.stage] = st
+            self.stage_nodes[st.stage] = st
             if st.next_stage:
                 st.states[TaskAction.DEFAULT] = st.next_stage
                 st.next_stage = None
@@ -104,15 +106,29 @@ class BaseTaskFlow:
             if TASK_AGENT_STATE_ERROR not in st.states:
                 st.states[TASK_AGENT_STATE_ERROR] = {"*": StageNext(stage=st.stage)}
 
-    def get_stage_agent(self, stage):
-        for t in self.STAGE_TRANSITIONS:
+    def get_stage_agents(self, stage) -> List[BaseAgent]:
+        for t in self.STAGE_NODES:
             if t.stage == stage:
-                return self.agent_factory(t.agent)
+                if isinstance(t.agents, list):
+                    return [self.agent_factory(a) for a in t.agents]
+                else:
+                    return [self.agent_factory(t.agents)]
         raise ValueError(f"No agent for stage `{stage}`")
 
+    def get_stage_evaluators(self, stage) -> List[BaseEvaluator]:
+        if self.evaluator_factory is None:
+            return []
+        for t in self.STAGE_NODES:
+            if t.stage == stage:
+                if isinstance(t.evaluators, list):
+                    return [self.evaluator_factory(e) for e in t.evaluators]
+                else:
+                    return [self.evaluator_factory(t.evaluators)]
+        return []
+
     def _get_next_stage_trans(self, stage, state, action=TaskAction.CONTINUE):
 
-        st = self.stage_transitions.get(stage)
+        st = self.stage_nodes.get(stage)
         if st:
             state_ns = st.states.get(state) or st.states.get("*")
             assert state_ns, f"No next stage for stage `{stage}` and state `{state}`"
@@ -162,16 +178,19 @@ class BaseTaskFlow:
         stage_count = 0
         # Initialize the task stage
         stage = stage or self.START_STAGE
+        agent = None
         while n_tries <= max_tries:
             stage_st = time.time()
             try:
                 stage_name = stage.value if isinstance(stage, Enum) else stage
                 stage_name = stage_name.replace(".", "-").capitalize()
                 set_stage(stage_name)
-                agent = self.get_stage_agent(stage)
-                _M(f"**Executing** stage `{stage}` with agent `{type(agent).__name__}` ...")
-                failed, state = agent()
+                agents = self.get_stage_agents(stage)
+                for agent in agents:
+                    _I(f"Executing stage `{stage}` with agent `{type(agent).__name__}` ...")
+                    failed, state = agent()
             except Exception as e:
+                _W(f"Error during task execution stage `{stage}`: `{type(e)}`: `{e}`")
                 _M(f"**Error** during task execution stage `{stage}`: `{type(e)}`: `{e}`")
                 _M(f"```python\n{traceback.format_exc()}\n```")
                 state = TASK_AGENT_STATE_ERROR
@@ -179,30 +198,26 @@ class BaseTaskFlow:
             stage_count += 1
             stage_duration = time.time() - stage_st
             flow_duration += stage_duration
-            _M(f"Stage `{stage}` completed in {stage_duration:.2f} seconds with state `{state}` and failed `{failed}`")
-            if (
-                self.evaluator_factory is not None
-                and not failed
-                and hasattr(agent, "EVALUATORS")
-                and state in agent.EVALUATORS
-            ):
-                # If the agent has evaluators, run them
-                evaluator = self.evaluator_factory(agent.EVALUATORS[state])
-                try:
-                    _M(f"**Evaluating** stage `{stage}` with evaluator `{type(evaluator).__name__}` ...")
-                    evaluation_result = evaluator()
-                    evaluation_result.timestamp = evaluation_result.timestamp or time.time()
-                    evaluation_result.evaluator = evaluation_result.evaluator or type(evaluator).__name__
-                    evaluation_result.cell_index = self.task.cell_idx
-                    evaluation_result.flow = type(self).__name__
-                    evaluation_result.stage = str(stage)
-                    evaluation_result.agent = type(agent).__name__
-                    evaluation_result.execution_duration = stage_duration
-                    evaluation_result.is_success = not failed
-                    output_evaluation(evaluation_result)
-                except Exception as e:
-                    _M(f"**Error** during task evaluation stage `{stage}`: `{type(e)}`: `{e}`")
-                    _M(f"```python\n{traceback.format_exc()}\n```")
+            _I(f"Stage `{stage}` completed in {stage_duration:.2f} seconds with state `{state}` and failed `{failed}`")
+            if evaluators := self.get_stage_evaluators(stage):
+                for evaluator in evaluators:
+                    # If the agent has evaluators, run them
+                    try:
+                        _I(f"Evaluating stage `{stage}` with evaluator `{type(evaluator).__name__}` ...")
+                        evaluation_result = evaluator()
+                        evaluation_result.timestamp = evaluation_result.timestamp or time.time()
+                        evaluation_result.evaluator = evaluation_result.evaluator or type(evaluator).__name__
+                        evaluation_result.cell_index = self.task.cell_idx
+                        evaluation_result.flow = type(self).__name__
+                        evaluation_result.stage = str(stage)
+                        evaluation_result.agent = type(agent).__name__
+                        evaluation_result.execution_duration = stage_duration
+                        evaluation_result.is_success = not failed
+                        output_evaluation(evaluation_result)
+                    except Exception as e:
+                        _W(f"Error during task evaluation stage `{stage}`: `{type(e)}`: `{e}`")
+                        _M(f"**Error** during task evaluation stage `{stage}`: `{type(e)}`: `{e}`")
+                        _M(f"```python\n{traceback.format_exc()}\n```")
             else:
                 output_evaluation(
                     StageEvaluationRecord(
@@ -223,7 +238,7 @@ class BaseTaskFlow:
                 self.task.agent_stage = next_stage
                 self.task.update_cell()
                 if next_stage in self.STOP_STAGES:
-                    _M(f"Task execution **Stopped** at stage `{next_stage}`")
+                    _I(f"Task execution **Stopped** at stage `{next_stage}`")
                     stage = next_stage
                     break
 
@@ -244,20 +259,19 @@ class BaseTaskFlow:
                 self.task.agent_stage = next_stage
                 self.task.update_cell()
                 if action == TaskAction.STOP:
-                    _M(f"Task execution **Stopped**, and set next stage to `{next_stage}`")
+                    _I(f"Task execution **Stopped**, and set next stage to `{next_stage}`")
                     stage = next_stage
                     break
                 else:
-                    _M(f"**Action**: `{action}` transits stage to `{next_stage}`")
+                    _I(f"Action: `{action}` transits stage to `{next_stage}`")
                     stage = next_stage
             else:
                 # transit to the next stage without confirmation
                 next_stage = self.get_next_stage(stage, state, TaskAction.CONTINUE)
                 self.task.agent_stage = next_stage
                 self.task.update_cell()
-                _M(f"**Transits** stage to `{next_stage}`")
+                _I(f"Transits stage to `{next_stage}`")
                 stage = next_stage
-
             if not stage_continue:
                 break
         # Finalize the task execution
@@ -266,7 +280,7 @@ class BaseTaskFlow:
             _M("Task execution **finished** globally.")
             if self.evaluator_factory is not None and hasattr(self, "GLOBAL_EVALUATOR") and self.GLOBAL_EVALUATOR:
                 evaluator = self.evaluator_factory(self.GLOBAL_EVALUATOR)
-                _M(f"**Evaluating** notebook with evaluator `{type(evaluator).__name__}` ...")
+                _I(f"Evaluating notebook with evaluator `{type(evaluator).__name__}` ...")
                 evaluation_result = evaluator()
                 evaluation_result.timestamp = evaluation_result.timestamp or time.time()
                 evaluation_result.evaluator = evaluation_result.evaluator or type(evaluator).__name__
@@ -283,10 +297,10 @@ class BaseTaskFlow:
                     )
                 )
         elif stage_name == TASK_STAGE_COMPLETED:
-            _M(f"Task execution **completed** in {flow_duration:.2f} seconds with {stage_count} stages.")
+            _I(f"Task execution **completed** in {flow_duration:.2f} seconds with {stage_count} stages.")
             if self.evaluator_factory is not None and hasattr(self, "FLOW_EVALUATOR") and self.FLOW_EVALUATOR:
                 evaluator = self.evaluator_factory(self.FLOW_EVALUATOR)
-                _M(f"**Evaluating** flow `{type(self).__name__}` with evaluator `{type(evaluator).__name__}` ...")
+                _I(f"Evaluating flow `{type(self).__name__}` with evaluator `{type(evaluator).__name__}` ...")
                 evaluation_result = evaluator()
                 evaluation_result.timestamp = evaluation_result.timestamp or time.time()
                 evaluation_result.evaluator = evaluation_result.evaluator or type(evaluator).__name__

jupyter_agent/bot_flows/master_planner.py

@@ -5,17 +5,24 @@ This software is released under the MIT License.
 https://opensource.org/licenses/MIT
 """
 
-from .base import BaseTaskFlow, StageTransition, TASK_STAGE_START, TASK_STAGE_COMPLETED
+from .base import BaseTaskFlow, StageNode, TASK_STAGE_START, TASK_STAGE_COMPLETED
 from ..bot_evaluators.flow_global_planning import FlowGlobalPlanningEvaluator
 from ..bot_agents.master_planner import MasterPlannerAgent
 from ..bot_agents.output_task_result import OutputTaskResult
+from ..bot_agents.prepare_next_cell import PrepareNextCell
+from ..bot_evaluators.dummy_task import DummyTaskEvaluator
 
 
 class MasterPlannerFlow(BaseTaskFlow):
 
-    STAGE_TRANSITIONS = [
-        StageTransition(stage=TASK_STAGE_START, agent=MasterPlannerAgent, next_stage=TASK_STAGE_COMPLETED),
-        StageTransition(stage=TASK_STAGE_COMPLETED, agent=OutputTaskResult, next_stage=TASK_STAGE_COMPLETED),
+    STAGE_NODES = [
+        StageNode(
+            stage=TASK_STAGE_START,
+            agents=MasterPlannerAgent,
+            evaluators=DummyTaskEvaluator,
+            next_stage=TASK_STAGE_COMPLETED,
+        ),
+        StageNode(stage=TASK_STAGE_COMPLETED, agents=OutputTaskResult, next_stage=TASK_STAGE_COMPLETED),
     ]
     STOP_STAGES = [TASK_STAGE_COMPLETED]
     FLOW_EVALUATOR = FlowGlobalPlanningEvaluator

jupyter_agent/bot_flows/task_executor_v3.py

@@ -8,7 +8,7 @@ https://opensource.org/licenses/MIT
 from enum import Enum
 from .base import (
     BaseTaskFlow,
-    StageTransition,
+    StageNode,
     StageNext,
     TaskAction,
     TASK_STAGE_COMPLETED,
@@ -22,6 +22,7 @@ from ..bot_agents.task_structrue_summarier import TaskStructureSummaryAgent, Tas
 from ..bot_agents.task_structrue_reasoner import TaskStructureReasoningAgent, TaskStructureReasonState
 from ..bot_agents.output_task_result import OutputTaskResult
 from ..bot_agents.request_user_supply import RequestAboveUserSupplyAgent, RequestBelowUserSupplyAgent
+from ..bot_agents.prepare_next_cell import PrepareNextCell
 
 
 class TaskStage(str, Enum):
@@ -34,6 +35,7 @@ class TaskStage(str, Enum):
     DEBUGGING = "debugging"
     REASONING = "reasoning"
     SUMMARY = "summary"
+    PREPARE_NEXT = "prepare_next"
     OUTPUT_RESULT = "output_result"
     COMPLETED = TASK_STAGE_COMPLETED
     GLOBAL_FINISHED = TASK_STAGE_GLOBAL_FINISHED
@@ -43,10 +45,10 @@ class TaskExecutorFlowV3(BaseTaskFlow):
 
     START_STAGE = TaskStage.PLANNING
     STOP_STAGES = [TaskStage.COMPLETED, TaskStage.PLANNING_PAUSED, TaskStage.GLOBAL_FINISHED]
-    STAGE_TRANSITIONS = [
-        StageTransition[TaskStage, TaskPlannerState](
+    STAGE_NODES = [
+        StageNode[TaskStage, TaskPlannerState](
             stage=TaskStage.PLANNING,
-            agent=TaskPlannerAgentV3,
+            agents=TaskPlannerAgentV3,
             states={
                 TaskPlannerState.CODING_PLANNED: TaskStage.CODING,
                 TaskPlannerState.REASONING_PLANNED: TaskStage.REASONING,
@@ -54,12 +56,14 @@ class TaskExecutorFlowV3(BaseTaskFlow):
                 TaskPlannerState.GLOBAL_FINISHED: TaskStage.GLOBAL_FINISHED,
             },
         ),
-        StageTransition[TaskStage, None](
-            stage=TaskStage.REQUEST_INFO_ABOVE, agent=RequestAboveUserSupplyAgent, next_stage=TaskStage.PLANNING_PAUSED
+        StageNode[TaskStage, None](
+            stage=TaskStage.REQUEST_INFO_ABOVE,
+            agents=RequestAboveUserSupplyAgent,
+            next_stage=TaskStage.PLANNING_PAUSED,
         ),
-        StageTransition[TaskStage, TaskPlannerState](
+        StageNode[TaskStage, TaskPlannerState](
             stage=TaskStage.PLANNING_PAUSED,
-            agent=TaskPlannerAgentV3,
+            agents=TaskPlannerAgentV3,
             states={
                 TaskPlannerState.CODING_PLANNED: TaskStage.CODING,
                 TaskPlannerState.REASONING_PLANNED: TaskStage.REASONING,
@@ -67,48 +71,49 @@ class TaskExecutorFlowV3(BaseTaskFlow):
                 TaskPlannerState.GLOBAL_FINISHED: TaskStage.COMPLETED,
             },
         ),
-        StageTransition[TaskStage, None](
-            stage=TaskStage.CODING, agent=TaskCodingAgent, next_stage=TaskStage.EXECUTING
-        ),
-        StageTransition[TaskStage, bool](
+        StageNode[TaskStage, None](stage=TaskStage.CODING, agents=TaskCodingAgent, next_stage=TaskStage.EXECUTING),
+        StageNode[TaskStage, bool](
             stage=TaskStage.EXECUTING,
-            agent=CodeExecutor,
+            agents=CodeExecutor,
             states={True: TaskStage.SUMMARY, False: TaskStage.DEBUGGING},
         ),
-        StageTransition[TaskStage, None](
-            stage=TaskStage.DEBUGGING, agent=CodeDebugerAgent, next_stage=TaskStage.EXECUTING
-        ),
-        StageTransition[TaskStage, TaskStructureReasonState](
+        StageNode[TaskStage, None](stage=TaskStage.DEBUGGING, agents=CodeDebugerAgent, next_stage=TaskStage.EXECUTING),
+        StageNode[TaskStage, TaskStructureReasonState](
             stage=TaskStage.REASONING,
-            agent=TaskStructureReasoningAgent,
+            agents=TaskStructureReasoningAgent,
             states={
                 TaskStructureReasonState.DONE: TaskStage.COMPLETED,
                 TaskStructureReasonState.REQUEST_INFO: TaskStage.REQUEST_INFO_BELOW,
             },
         ),
-        StageTransition[TaskStage, TaskStructureSummaryState](
+        StageNode[TaskStage, TaskStructureSummaryState](
             stage=TaskStage.SUMMARY,
-            agent=TaskStructureSummaryAgent,
+            agents=TaskStructureSummaryAgent,
             states={
                 TaskStructureSummaryState.DONE: {
-                    TaskAction.DEFAULT: StageNext(stage=TaskStage.COMPLETED),
+                    TaskAction.DEFAULT: StageNext(stage=TaskStage.PREPARE_NEXT),
                     TaskAction.STOP: StageNext(stage=TaskStage.EXECUTING),
                 },
                 TaskStructureSummaryState.REQUEST_INFO: TaskStage.REQUEST_INFO_BELOW,
             },
         ),
-        StageTransition[TaskStage, None](
-            stage=TaskStage.REQUEST_INFO_BELOW, agent=RequestBelowUserSupplyAgent, next_stage=TaskStage.COMPLETED
+        StageNode[TaskStage, None](
+            stage=TaskStage.PREPARE_NEXT, agents=PrepareNextCell, next_stage=TaskStage.COMPLETED
+        ),
+        StageNode[TaskStage, None](
+            stage=TaskStage.REQUEST_INFO_BELOW,
+            agents=[PrepareNextCell, RequestBelowUserSupplyAgent],
+            next_stage=TaskStage.COMPLETED,
         ),
-        StageTransition[TaskStage, bool](
+        StageNode[TaskStage, bool](
             stage=TaskStage.COMPLETED,
-            agent=CodeExecutor,
+            agents=CodeExecutor,
             states={True: TaskStage.OUTPUT_RESULT, False: TaskStage.DEBUGGING},
         ),
-        StageTransition[TaskStage, None](
-            stage=TaskStage.OUTPUT_RESULT, agent=OutputTaskResult, next_stage=TaskStage.COMPLETED
+        StageNode[TaskStage, None](
+            stage=TaskStage.OUTPUT_RESULT, agents=OutputTaskResult, next_stage=TaskStage.COMPLETED
         ),
-        StageTransition[TaskStage, None](
-            stage=TaskStage.GLOBAL_FINISHED, agent=OutputTaskResult, next_stage=TaskStage.GLOBAL_FINISHED
+        StageNode[TaskStage, None](
+            stage=TaskStage.GLOBAL_FINISHED, agents=OutputTaskResult, next_stage=TaskStage.GLOBAL_FINISHED
         ),
     ]

jupyter_agent/bot_magics.py

@@ -40,6 +40,9 @@ class BotMagics(Magics, Configurable):
     coding_api_url = Unicode(None, allow_none=True, help="Coding API URL").tag(config=True)
     coding_api_key = Unicode("API_KEY", help="Coding API Key").tag(config=True)
     coding_model_name = Unicode("", help="Coding Model Name").tag(config=True)
+    evaluating_api_url = Unicode(None, allow_none=True, help="Evaluating API URL").tag(config=True)
+    evaluating_api_key = Unicode("API_KEY", help="Evaluating API Key").tag(config=True)
+    evaluating_model_name = Unicode("", help="Evaluating Model Name").tag(config=True)
     reasoning_api_url = Unicode(None, allow_none=True, help="Reasoning API URL").tag(config=True)
     reasoning_api_key = Unicode("API_KEY", help="Reasoning API Key").tag(config=True)
     reasoning_model_name = Unicode("", help="Reasoning Model Name").tag(config=True)
@@ -54,9 +57,9 @@ class BotMagics(Magics, Configurable):
     enable_supply_mocking = Bool(False, help="Enable supply mocking").tag(config=True)
     notebook_path = Unicode(None, allow_none=True, help="Path to Notebook file").tag(config=True)
     default_task_flow = Unicode("v3", allow_none=True, help="Default task flow").tag(config=True)
-    default_max_tries = Int(3, help="Default max tries for task execution").tag(config=True)
+    default_max_tries = Int(2, help="Default max tries for task execution").tag(config=True)
     default_step_mode = Bool(False, help="Default step mode for task execution").tag(config=True)
-    default_auto_confirm = Bool(False, help="Default auto confirm for task execution").tag(config=True)
+    default_auto_confirm = Bool(True, help="Default auto confirm for task execution").tag(config=True)
 
     def parse_args(self, line):
         """解析命令行参数"""
@@ -67,19 +70,37 @@ class BotMagics(Magics, Configurable):
         parser.add_argument("-f", "--flow", type=str, default=self.default_task_flow, help="Flow name")
         parser.add_argument("-m", "--max-tries", type=int, default=self.default_max_tries, help="Max tries")
         parser.add_argument(
-            "-S",
+            "-t",
             "--step-mode",
             action="store_true",
+            dest="step_mode",
             default=self.default_step_mode,
             help="Run in single step mode",
         )
         parser.add_argument(
-            "-Y",
+            "-T",
+            "--not-step-mode",
+            action="store_false",
+            dest="step_mode",
+            default=self.default_step_mode,
+            help="Run in multi step mode",
+        )
+        parser.add_argument(
+            "-y",
             "--auto-confirm",
             action="store_true",
+            dest="auto_confirm",
             default=self.default_auto_confirm,
             help="Run without confirm",
         )
+        parser.add_argument(
+            "-Y",
+            "--not-auto-confirm",
+            action="store_false",
+            dest="auto_confirm",
+            default=self.default_auto_confirm,
+            help="Run with confirm",
+        )
         options, _ = parser.parse_known_args(shlex.split(line.strip()))
         return options
 
@@ -173,6 +194,9 @@ class BotMagics(Magics, Configurable):
         agent_factory.config_model(
             AgentModelType.CODING, self.coding_api_url, self.coding_api_key, self.coding_model_name
         )
+        agent_factory.config_model(
+            AgentModelType.EVALUATING, self.evaluating_api_url, self.evaluating_api_key, self.evaluating_model_name
+        )
         agent_factory.config_model(
             AgentModelType.REASONING, self.reasoning_api_url, self.reasoning_api_key, self.reasoning_model_name
         )
@@ -190,6 +214,9 @@ class BotMagics(Magics, Configurable):
             evaluator_factory.config_model(
                 AgentModelType.CODING, self.coding_api_url, self.coding_api_key, self.coding_model_name
             )
+            evaluator_factory.config_model(
+                AgentModelType.EVALUATING, self.evaluating_api_url, self.evaluating_api_key, self.evaluating_model_name
+            )
             evaluator_factory.config_model(
                 AgentModelType.REASONING, self.reasoning_api_url, self.reasoning_api_key, self.reasoning_model_name
             )

{jupyter_agent-2025.6.105.dist-info → jupyter_agent-2025.7.100.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jupyter-agent
-Version: 2025.6.105
+Version: 2025.7.100
 Summary: 调用LLM实现Jupyter代码的自动生成、执行、调试等功能
 Author: viewstar000
 License: MIT
@@ -96,6 +96,11 @@ pip install /path/to/jupyter-agent/dist/jupyter_agent-xxxx-py3-none-any.whl
 # 设置当前Notebook的路径，当无法自动获取时需要手工指定，以Vscode中的Notebook为例
 %config BotMagics.notebook_path = globals()["__vsc_ipynb_file__"]
 
+# 是否默认开启单步模式，每执行一个步骤都退出执行循环，需要用户手动执行下一个步骤，默认为False
+%config BotMagics.default_step_mode = False
+# 是否默认开启自动确认，若关闭自动确认，每执行一个步骤都需要用户手动确认，默认为True
+%config BotMagics.default_auto_confirm = True
+
 # 设置运行环境是否保存任务数据到Metadata，默认为False，仅在Vscode中安装jupyter-agent-extension后或在评估模式下支持
 %config BotMagics.support_save_meta = True
 # 设置运行环境是否设置单元格内容，默认为False，权在Vscode中安装jupyter-agent-extension后或在评估模式下支持
@@ -166,6 +171,12 @@ pip install /path/to/jupyter-agent/dist/jupyter_agent-xxxx-py3-none-any.whl
 bot_eval [-o output_eval.ipynb] [-e output_eval.jsonl] input.ipynb
 ```
 
+例如
+
+```bash
+bot_eval examples/data_loader_eval.ipynb
+```
+
 ## 贡献
 
 欢迎提交 issue 或 pull request 参与贡献。
@@ -252,6 +263,11 @@ Advanced Configuration:
 # Set the current notebook path, when it is not automatically obtained, it needs to be manually specified, for example, in Vscode Notebook
 %config BotMagics.notebook_path = globals()["__vsc_ipynb_file__"]
 
+# Whether to enable single step mode, each step will exit the execution loop, you need to manually execute the next step, the default is False
+%config BotMagics.default_step_mode = False
+# Whether to enable automatic confirmation, if automatic confirmation is closed, each step needs to be confirmed by the user, the default is True
+%config BotMagics.default_auto_confirm = True
+
 # Set whether to save task data to Metadata, only Vscode installed with jupyter-agent-extension or evaluation mode supports this.
 %config BotMagics.support_save_meta = True
 # Set whether to set cell content, only Vscode installed with jupyter-agent-extension or evaluation mode supports this.
@@ -320,6 +336,12 @@ Use `bot_eval` command to evaluate the code generated by the agent in evaluation
 bot_eval [-o output_eval.ipynb] [-e output_eval.jsonl] input.ipynb
 ```
 
+For example
+
+```bash
+bot_eval examples/data_loader_eval.ipynb
+```
+
 ## Contributing
 
 Welcome to submit issues or pull requests to participate in contributions.

jupyter_agent-2025.7.100.dist-info/RECORD

@@ -0,0 +1,41 @@
+jupyter_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jupyter_agent/bot_actions.py,sha256=Zq9_nfh4SJdMxkjqcTyQzS0RY4RwofaRkGq_4aexO2o,8453
+jupyter_agent/bot_chat.py,sha256=4zjkHtyOabT1bvGO-n4ZTMw0XREU_XDlgfLCI5gpxsw,8834
+jupyter_agent/bot_contexts.py,sha256=gs3hVIj81jasQYiJjdoAloWx8S1Xpa4cXr8XzcefUus,19475
+jupyter_agent/bot_evaluation.py,sha256=t4SH6Gq4BmSyyRMozyQ2623XNGmgtCi9CTNRvOqzuRM,14266
+jupyter_agent/bot_magics.py,sha256=Sh2CGs_esZqaHWDDLKjJSDlUYcI4PdF2aFPcibcf43Y,11027
+jupyter_agent/bot_outputs.py,sha256=QDzReXLqZsU7RAPR4F9JEotxAtIe9YA3ZklCJ9U_jVg,16239
+jupyter_agent/utils.py,sha256=8XKXXZB1EgCwIJEqYJigA8C84FzVTc2xdcF-y5kO3kY,3634
+jupyter_agent/bot_agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jupyter_agent/bot_agents/base.py,sha256=pAwW_KQZE9LwyxM91umzIlWalgFUKGJOpby8JGfvLQo,12430
+jupyter_agent/bot_agents/master_planner.py,sha256=twDEc0KMCyNkcsD_0nilbPteZqFwUT38QDfeYUhOzzE,1330
+jupyter_agent/bot_agents/output_task_result.py,sha256=4DeAmDzjUI_0yfb26f5sLIwa74aJRzEQXbMRSyYMv1g,761
+jupyter_agent/bot_agents/prepare_next_cell.py,sha256=_4-kYQxAs9PK4a6T5vbsdSixNQ4l-R8qzQNjs8e_09c,1891
+jupyter_agent/bot_agents/request_user_supply.py,sha256=Bkw08hhkUUVnirBijv1mJ0hQW2VpzdXoC3TToQolQos,6106
+jupyter_agent/bot_agents/task_code_executor.py,sha256=V138uj39_lLGuljEDrxzd-jRf1k4nAQkA_gF2_Jhpgw,2243
+jupyter_agent/bot_agents/task_coder.py,sha256=7fXq9nk1yH3F_mJfCMZBktHmxGfgmpuChMQbpEuL0w4,1783
+jupyter_agent/bot_agents/task_debuger.py,sha256=77pa_Awgvzxm3XkFA1oZsGr8SPJkjApKMtkmoySShmI,1367
+jupyter_agent/bot_agents/task_planner_v3.py,sha256=Mlves3v3KL7MAJ8hPPMxUsKdB2v6vuOXlVZ6XtNMbbo,8713
+jupyter_agent/bot_agents/task_reasoner.py,sha256=4oP5DzAkfEGh6LtpX4OH6aMgAPDiRvbSVclxrhx0v20,1465
+jupyter_agent/bot_agents/task_structrue_reasoner.py,sha256=lNt508g4ileRjG9_NETdSrQqVb7tjdu8qHajKcZzB6E,3947
+jupyter_agent/bot_agents/task_structrue_summarier.py,sha256=fnNiXQMiEPHyowqOP6Ht_OnxV_1h_WTLKfcM2IYEt24,4053
+jupyter_agent/bot_agents/task_summarier.py,sha256=Q9b11gdWvwnYLsIjwSpMkZQur1CqFdd_uKb322o8u-M,1787
+jupyter_agent/bot_agents/task_verifier.py,sha256=kGtz8BkSB097RwdgY3FcXpSbVRcikFeTXiokheza0t8,2522
+jupyter_agent/bot_agents/task_verify_summarier.py,sha256=XIxRuW8T1DchHLy3PlGWWUMVC8hcTEyjhQ5tnELWNZk,4943
+jupyter_agent/bot_evaluators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jupyter_agent/bot_evaluators/base.py,sha256=zGxW469lq2Ab1mOaTtVQcWQmJrKNAAaF8X7OPbnUY04,1375
+jupyter_agent/bot_evaluators/dummy_flow.py,sha256=W0BWJKMgXIilZY0i8eP_SNVgqTUd1CT_uqMBs5aygVA,473
+jupyter_agent/bot_evaluators/dummy_global.py,sha256=yZ8fo2xfVN8gZTpBfs8EJ4dcv2t4ls6aXxn3Mo7bNSk,483
+jupyter_agent/bot_evaluators/dummy_task.py,sha256=owh6g6ItPXXYjesplzNMxVcKAU_kktWtuJhqRzZ05V4,475
+jupyter_agent/bot_evaluators/flow_global_planning.py,sha256=kOLd0dCoqrMi6zbe5chXrwxmdahtt8QqX3UnAZgk3AQ,2419
+jupyter_agent/bot_evaluators/flow_task_executor.py,sha256=gzHlKkP9K5fICYgUY5BKAzjwqn3xScxklohqoUCJaZk,4450
+jupyter_agent/bot_flows/__init__.py,sha256=Xe7EbC6bt04Nc4Yr0e--FVvBJCxkZCZkwYL9oahMBtI,338
+jupyter_agent/bot_flows/base.py,sha256=F-iXu59IfnOXWze3e2myvzdBlyk8xzlrqHA8GTfu4vo,14916
+jupyter_agent/bot_flows/master_planner.py,sha256=F1AunpfNwFqEn4z8uzNEq7d_5_cNHRhMlO1P7uWcYf0,980
+jupyter_agent/bot_flows/task_executor_v3.py,sha256=uCuwcG8ZfPIR7V5AX7UfFkYVbJ6MxPscixjtLwBYWtE,4878
+jupyter_agent-2025.7.100.dist-info/licenses/LICENSE,sha256=nWMmSIg7OepTIDX_OPP0-T9ImeCBBoog7eJxm5awtcM,1068
+jupyter_agent-2025.7.100.dist-info/METADATA,sha256=zaOVnSQK797gupNKlYbwOCV9Y_A3R4_6yk12WRDjqYI,12560
+jupyter_agent-2025.7.100.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jupyter_agent-2025.7.100.dist-info/entry_points.txt,sha256=063AB86wSrC_V-iiEEqxTlR4uz-T7VH_YagIpmKFQC0,63
+jupyter_agent-2025.7.100.dist-info/top_level.txt,sha256=c3USTBZ7DZGuvLKlEW-QfGIx0tzn98iCEn3bpdYnDtE,14
+jupyter_agent-2025.7.100.dist-info/RECORD,,

jupyter_agent-2025.6.105.dist-info/RECORD

@@ -1,40 +0,0 @@
-jupyter_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jupyter_agent/bot_actions.py,sha256=Zq9_nfh4SJdMxkjqcTyQzS0RY4RwofaRkGq_4aexO2o,8453
-jupyter_agent/bot_chat.py,sha256=4zjkHtyOabT1bvGO-n4ZTMw0XREU_XDlgfLCI5gpxsw,8834
-jupyter_agent/bot_contexts.py,sha256=f9PmrA8dTH8v4WLdNL_ZSMJUzMVLuRldLWYwL4vXQ6c,19489
-jupyter_agent/bot_evaluation.py,sha256=t4SH6Gq4BmSyyRMozyQ2623XNGmgtCi9CTNRvOqzuRM,14266
-jupyter_agent/bot_magics.py,sha256=fOStbhYwg60hUbuZwqYIbMrn_TBg0JfTwFT92pysUFw,9869
-jupyter_agent/bot_outputs.py,sha256=QDzReXLqZsU7RAPR4F9JEotxAtIe9YA3ZklCJ9U_jVg,16239
-jupyter_agent/utils.py,sha256=8XKXXZB1EgCwIJEqYJigA8C84FzVTc2xdcF-y5kO3kY,3634
-jupyter_agent/bot_agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jupyter_agent/bot_agents/base.py,sha256=FwCl1Z9E-nIL99qheGEcKO0H_PEd0I9OzEXd23cmQrg,12308
-jupyter_agent/bot_agents/master_planner.py,sha256=aXXgtyarBmDFNAypdEbpQoxzgGkU-botX7bE9q9w3sM,1392
-jupyter_agent/bot_agents/output_task_result.py,sha256=4DeAmDzjUI_0yfb26f5sLIwa74aJRzEQXbMRSyYMv1g,761
-jupyter_agent/bot_agents/request_user_supply.py,sha256=wL_DyIWPd5-Jdq0boTCAhF-nxf_gPmzXgSPM6jOBFFU,6128
-jupyter_agent/bot_agents/task_code_executor.py,sha256=M3oeEBlmsNz89f-yk3_nzsWKGH2C0o7AH059D_J94D8,2206
-jupyter_agent/bot_agents/task_coder.py,sha256=7fXq9nk1yH3F_mJfCMZBktHmxGfgmpuChMQbpEuL0w4,1783
-jupyter_agent/bot_agents/task_debuger.py,sha256=77pa_Awgvzxm3XkFA1oZsGr8SPJkjApKMtkmoySShmI,1367
-jupyter_agent/bot_agents/task_planner_v3.py,sha256=qrvgfsgWs-tD8L1NWzyv9-fwamNTEm6etJYBy-Ipz28,8487
-jupyter_agent/bot_agents/task_reasoner.py,sha256=OHYzPEb1e4eOGdKfo9655tTEdZRqz-s-Vdgp-2G0Jxc,1425
-jupyter_agent/bot_agents/task_structrue_reasoner.py,sha256=NQ0V9uY4UelRH5Glw3PwS9HiN4I74A9FxNPcMC5P0lg,3792
-jupyter_agent/bot_agents/task_structrue_summarier.py,sha256=bMrNlb_Xrs4FNosuTBPmMmmHIoPyCIjSUVR_0j7aZZ8,3898
-jupyter_agent/bot_agents/task_summarier.py,sha256=85pW9mSqI-9nfuKr2n-h36OpD3QLA0WPJ1T7eWyww-A,1747
-jupyter_agent/bot_agents/task_verifier.py,sha256=z45jo38c9U4FnS87-AnI4PGki14uuCRhyWVPtAbkl70,2478
-jupyter_agent/bot_agents/task_verify_summarier.py,sha256=usW7RDE8-XAZXAgyHkWU1ZmY-kwi-_ePVXBngYFtb_M,4899
-jupyter_agent/bot_evaluators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jupyter_agent/bot_evaluators/base.py,sha256=yMmeFCNrQRhO9Y4s1OeRAXgxD_m-20a14hM1XFvmN-I,1374
-jupyter_agent/bot_evaluators/dummy_flow.py,sha256=W0BWJKMgXIilZY0i8eP_SNVgqTUd1CT_uqMBs5aygVA,473
-jupyter_agent/bot_evaluators/dummy_global.py,sha256=yZ8fo2xfVN8gZTpBfs8EJ4dcv2t4ls6aXxn3Mo7bNSk,483
-jupyter_agent/bot_evaluators/dummy_task.py,sha256=owh6g6ItPXXYjesplzNMxVcKAU_kktWtuJhqRzZ05V4,475
-jupyter_agent/bot_evaluators/flow_global_planning.py,sha256=kOLd0dCoqrMi6zbe5chXrwxmdahtt8QqX3UnAZgk3AQ,2419
-jupyter_agent/bot_evaluators/flow_task_executor.py,sha256=gzHlKkP9K5fICYgUY5BKAzjwqn3xScxklohqoUCJaZk,4450
-jupyter_agent/bot_flows/__init__.py,sha256=Xe7EbC6bt04Nc4Yr0e--FVvBJCxkZCZkwYL9oahMBtI,338
-jupyter_agent/bot_flows/base.py,sha256=ADNs_-F4XLvEthRyjjBgGkv4KOOYIJRIdaRgjQXHq_k,14116
-jupyter_agent/bot_flows/master_planner.py,sha256=DAsMLXzrKCZaCNoEuPK3A5yWY_PxIcN3bwzYrlpx0pU,794
-jupyter_agent/bot_flows/task_executor_v3.py,sha256=_K6FOM2ZnMZAa8B_Rt1HXDVB20eCQl4Eew2KyfDPyEU,4685
-jupyter_agent-2025.6.105.dist-info/licenses/LICENSE,sha256=nWMmSIg7OepTIDX_OPP0-T9ImeCBBoog7eJxm5awtcM,1068
-jupyter_agent-2025.6.105.dist-info/METADATA,sha256=QqX2ahmch7Ofn_l8GHRjW5BpA1pvlm9kpOTbc5QpnIM,11699
-jupyter_agent-2025.6.105.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jupyter_agent-2025.6.105.dist-info/entry_points.txt,sha256=063AB86wSrC_V-iiEEqxTlR4uz-T7VH_YagIpmKFQC0,63
-jupyter_agent-2025.6.105.dist-info/top_level.txt,sha256=c3USTBZ7DZGuvLKlEW-QfGIx0tzn98iCEn3bpdYnDtE,14
-jupyter_agent-2025.6.105.dist-info/RECORD,,