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

jupyter_agent/bot_evaluators/flow_task_executor.py

@@ -0,0 +1,152 @@
+"""
+Copyright (c) 2025 viewstar000
+
+This software is released under the MIT License.
+https://opensource.org/licenses/MIT
+"""
+
+import time
+
+from enum import Enum
+from typing import Optional, List
+from pydantic import BaseModel, Field
+from IPython.display import Markdown
+from .base import BaseEvaluator
+from ..bot_outputs import _D, _I, _W, _E, _F, _A, _O, _C, _M, _B
+from ..bot_evaluation import FlowEvaluationRecord
+
+
+FLOW_TASK_EXEC_EVAL_PROMPT = """\
+**角色定义**：
+
+你是一个任务规划评估专家，负责对任务规划的结果进行评估。
+
+**任务要求**：
+
+请你根据任务规划的结果，评估任务规划的质量和准确性，并给出相应的评分和反馈。
+
+{% include "TASK_OUTPUT_FORMAT" %}
+
+---
+
+{% include "TASK_CONTEXTS" %}
+
+---
+
+{% include "CODE_CONTEXTS" %}
+
+---
+
+**当前子任务规划信息**:
+
+### 当前子任务规划目标：
+
+{{ task.subject }}
+
+{% if task.coding_prompt %}
+### 当前子任务代码需求：
+
+{{ task.coding_prompt }}
+
+### 当前子任务生成的代码：
+
+```python
+{{ task.source }}
+```
+
+### 当前代码执行的输出与结果：
+
+{{ task.output }}
+{% endif %}
+
+### 当前子任务总结要求：
+
+{{ task.summary_prompt }}
+
+
+### 当前子任务输出的分析总结后的最终结果：
+
+```markdown
+{{ task.result }}
+```
+
+{% if task.important_infos %}
+### 当前子任务输出的重要信息：
+
+```json
+{{ task.important_infos | json }}
+```
+{% endif %}
+
+{% if task.request_below_supply_infos %}
+### 当前子任务输出的请求用户补充确认的信息：
+
+```json
+{{ task.request_below_supply_infos | json }}
+```
+{% endif %}
+
+---
+
+请按要求给出当前子任务规划的评估结果：
+"""
+
+
+class FlowTaskExecEvalResult(BaseModel):
+    """
+    任务规划评估结果
+    """
+
+    is_correct: bool = Field(description="最终结果是否符合当前子任务的目标", examples=[True, False])
+    correct_score: float = Field(
+        description="最终结果符合当前子任务目标的分数，范围0-1，>=0.5表示符合目标，<0.5表示不符合目标",
+        examples=[0.95, 0.3],
+    )
+    planning_score: float = Field(
+        description="当前子任务的目标规划、代码生成、总结是否符合全局目标规划要求，范围0-1，>=0.5表示符合要求，<0.5表示不符合要求",
+        examples=[0.85, 0.25],
+    )
+    reasoning_score: float = Field(
+        description="当前子任务的推理过程是否合理，是否存在逻辑错误，是否存在与前置子任务相冲突的情况，"
+        "范围0-1，>=0.5表示合理、正确、无冲突，<0.5表示不合理",
+        examples=[0.9, 0.4],
+    )
+    coding_score: float = Field(
+        description="代码生成的质量评分，代码逻辑是否符合规划要求，是否存在逻辑错误，是否存在冗余、抽象不合理等情况，"
+        "范围0-1，>=0.5表示代码质量较高，<0.5表示代码质量较低",
+        examples=[0.75, 0.2],
+    )
+    important_info_score: float = Field(
+        description="重要信息分数，当前子任务的规划、代码生成、总结是否充分考虑了前置任务生成的重要信息，"
+        "以及当前子任务的重要信息是否完整、准确、无误导、无冲突，"
+        "范围0-1，>=0.5表示重要信息完整、准确，<0.5表示重要信息不完整或不准确",
+        examples=[0.9, 0.4],
+    )
+    user_supply_info_score: float = Field(
+        description="用户补充信息分数，当前子任务的规划、代码生成、总结是否充分考虑了用户补充的信息，"
+        "范围0-1，>=0.5表示充分考虑，<0.5表示未充分考虑",
+        examples=[0.8, 0.3],
+    )
+    feedback: Optional[str] = Field(default=None, description="评估反馈")
+
+
+class FlowTaskExecEvaluator(BaseEvaluator):
+    """
+    任务规划评估器
+    """
+
+    PROMPT = FLOW_TASK_EXEC_EVAL_PROMPT
+    OUTPUT_JSON_SCHEMA = FlowTaskExecEvalResult
+
+    def on_reply(self, reply):
+        reply = super().on_reply(reply)
+        return FlowEvaluationRecord(
+            timestamp=time.time(),
+            evaluator="flow_task_executor",
+            correct_score=reply.correct_score,
+            planning_score=reply.planning_score,
+            reasoning_score=reply.reasoning_score,
+            coding_score=reply.coding_score,
+            important_score=reply.important_info_score,
+            user_supply_score=reply.user_supply_info_score,
+        )

jupyter_agent/bot_flows/__init__.py

@@ -7,14 +7,10 @@ https://opensource.org/licenses/MIT
 
 from .base import BaseTaskFlow
 from .master_planner import MasterPlannerFlow
-from .task_executor_v1 import TaskExecutorFlowV1
-from .task_executor_v2 import TaskExecutorFlowV2
 from .task_executor_v3 import TaskExecutorFlowV3
 
 __all__ = [
     "BaseTaskFlow",
     "MasterPlannerFlow",
-    "TaskExecutorFlowV1",
-    "TaskExecutorFlowV2",
     "TaskExecutorFlowV3",
 ]

jupyter_agent/bot_flows/base.py

@@ -13,9 +13,11 @@ 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.dummy_global import DummyGlobalEvaluator
+from ..bot_evaluators.flow_task_executor import FlowTaskExecEvaluator
 from ..bot_outputs import _D, _I, _W, _E, _F, _M, _B
 from ..bot_outputs import set_stage, flush_output, output_evaluation
-from ..bot_outputs import FlowEvalutionRecord, StageEvalutionRecord, NotebookEvalutionRecord
+from ..bot_evaluation import FlowEvaluationRecord, StageEvaluationRecord, NotebookEvaluationRecord
 
 TASK_AGENT_STATE_ERROR = "_AGENT_STATE_ERROR_32534526_"
 TASK_STAGE_START = "start"
@@ -52,10 +54,13 @@ class BaseTaskFlow:
     STAGE_TRANSITIONS: List[StageTransition] = []
     START_STAGE = TASK_STAGE_START
     STOP_STAGES = [TASK_STAGE_COMPLETED, TASK_STAGE_GLOBAL_FINISHED]
+    FLOW_EVALUATOR = FlowTaskExecEvaluator
+    GLOBAL_EVALUATOR = DummyGlobalEvaluator
 
-    def __init__(self, notebook_context, agent_factory):
+    def __init__(self, notebook_context, agent_factory, evaluator_factory=None):
         self.notebook_context = notebook_context
         self.agent_factory = agent_factory
+        self.evaluator_factory = evaluator_factory
         self.stage_transitions = {}
         self.prepare_stage_transitions()
 
@@ -175,15 +180,42 @@ class BaseTaskFlow:
             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}`")
-            output_evaluation(
-                StageEvalutionRecord(
-                    cell_index=self.task.cell_idx,
-                    flow=type(self).__name__,
-                    stage=str(stage),
-                    execution_duration=stage_duration,
-                    is_success=not 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```")
+            else:
+                output_evaluation(
+                    StageEvaluationRecord(
+                        timestamp=time.time(),
+                        evaluator="default",
+                        cell_index=self.task.cell_idx,
+                        flow=type(self).__name__,
+                        stage=str(stage),
+                        agent=type(agent).__name__,
+                        execution_duration=stage_duration,
+                        is_success=not failed,
+                    )
                 )
-            )
 
             if state != TASK_AGENT_STATE_ERROR:
                 # Agent did not fail, check if we have reached the final stage
@@ -232,17 +264,50 @@ class BaseTaskFlow:
         stage_name = stage.value if isinstance(stage, Enum) else stage
         if stage_name == TASK_STAGE_GLOBAL_FINISHED:
             _M("Task execution **finished** globally.")
-            output_evaluation(NotebookEvalutionRecord(cell_index=self.task.cell_idx, is_success=True))
+            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__}` ...")
+                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.is_success = True
+                output_evaluation(evaluation_result)
+            else:
+                output_evaluation(
+                    NotebookEvaluationRecord(
+                        timestamp=time.time(),
+                        evaluator="default",
+                        cell_index=self.task.cell_idx,
+                        is_success=True,
+                    )
+                )
         elif stage_name == TASK_STAGE_COMPLETED:
             _M(f"Task execution **completed** in {flow_duration:.2f} seconds with {stage_count} stages.")
-            output_evaluation(
-                FlowEvalutionRecord(
-                    cell_index=self.task.cell_idx,
-                    flow=type(self).__name__,
-                    stage_count=stage_count,
-                    execution_duration=flow_duration,
-                    is_success=True,
+            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__}` ...")
+                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_count = stage_count
+                evaluation_result.execution_duration = flow_duration
+                evaluation_result.is_success = True
+                output_evaluation(evaluation_result)
+            else:
+                # If no evaluator, just output the evaluation record
+                output_evaluation(
+                    FlowEvaluationRecord(
+                        timestamp=time.time(),
+                        evaluator="default",
+                        cell_index=self.task.cell_idx,
+                        flow=type(self).__name__,
+                        stage_count=stage_count,
+                        execution_duration=flow_duration,
+                        is_success=True,
+                    )
                 )
-            )
         flush_output()
         return stage

jupyter_agent/bot_flows/master_planner.py

@@ -6,12 +6,16 @@ https://opensource.org/licenses/MIT
 """
 
 from .base import BaseTaskFlow, StageTransition, 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
 
 
 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),
+        StageTransition(stage=TASK_STAGE_START, agent=MasterPlannerAgent, next_stage=TASK_STAGE_COMPLETED),
+        StageTransition(stage=TASK_STAGE_COMPLETED, agent=OutputTaskResult, next_stage=TASK_STAGE_COMPLETED),
     ]
     STOP_STAGES = [TASK_STAGE_COMPLETED]
+    FLOW_EVALUATOR = FlowGlobalPlanningEvaluator

jupyter_agent/bot_flows/task_executor_v3.py

@@ -14,21 +14,21 @@ from .base import (
     TASK_STAGE_COMPLETED,
     TASK_STAGE_GLOBAL_FINISHED,
 )
-from ..bot_agents import (
-    TaskPlannerAgentV3,
-    TaskCodingAgent,
-    CodeDebugerAgent,
-    CodeExecutor,
-    TaskStructureSummaryAgent,
-    TaskStructureReasoningAgent,
-    OutputTaskResult,
-)
-from ..bot_agents.task_planner_v3 import TaskPlannerState
+from ..bot_agents.task_planner_v3 import TaskPlannerAgentV3, TaskPlannerState
+from ..bot_agents.task_coder import TaskCodingAgent
+from ..bot_agents.task_debuger import CodeDebugerAgent
+from ..bot_agents.task_code_executor import CodeExecutor
+from ..bot_agents.task_structrue_summarier import TaskStructureSummaryAgent, TaskStructureSummaryState
+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
 
 
 class TaskStage(str, Enum):
     PLANNING = "planning"
     PLANNING_PAUSED = "planning_paused"
+    REQUEST_INFO_ABOVE = "request_info_above"
+    REQUEST_INFO_BELOW = "request_info_below"
     CODING = "coding"
     EXECUTING = "executing"
     DEBUGGING = "debugging"
@@ -50,10 +50,13 @@ class TaskExecutorFlowV3(BaseTaskFlow):
             states={
                 TaskPlannerState.CODING_PLANNED: TaskStage.CODING,
                 TaskPlannerState.REASONING_PLANNED: TaskStage.REASONING,
-                TaskPlannerState.REQUEST_INFO: TaskStage.PLANNING_PAUSED,
+                TaskPlannerState.REQUEST_INFO: TaskStage.REQUEST_INFO_ABOVE,
                 TaskPlannerState.GLOBAL_FINISHED: TaskStage.GLOBAL_FINISHED,
             },
         ),
+        StageTransition[TaskStage, None](
+            stage=TaskStage.REQUEST_INFO_ABOVE, agent=RequestAboveUserSupplyAgent, next_stage=TaskStage.PLANNING_PAUSED
+        ),
         StageTransition[TaskStage, TaskPlannerState](
             stage=TaskStage.PLANNING_PAUSED,
             agent=TaskPlannerAgentV3,
@@ -75,17 +78,28 @@ class TaskExecutorFlowV3(BaseTaskFlow):
         StageTransition[TaskStage, None](
             stage=TaskStage.DEBUGGING, agent=CodeDebugerAgent, next_stage=TaskStage.EXECUTING
         ),
-        StageTransition[TaskStage, None](
-            stage=TaskStage.REASONING, agent=TaskStructureReasoningAgent, next_stage=TaskStage.COMPLETED
+        StageTransition[TaskStage, TaskStructureReasonState](
+            stage=TaskStage.REASONING,
+            agent=TaskStructureReasoningAgent,
+            states={
+                TaskStructureReasonState.DONE: TaskStage.COMPLETED,
+                TaskStructureReasonState.REQUEST_INFO: TaskStage.REQUEST_INFO_BELOW,
+            },
         ),
-        StageTransition[TaskStage, None](
+        StageTransition[TaskStage, TaskStructureSummaryState](
             stage=TaskStage.SUMMARY,
             agent=TaskStructureSummaryAgent,
-            next_stage={
-                TaskAction.DEFAULT: StageNext(stage=TaskStage.COMPLETED),
-                TaskAction.STOP: StageNext(stage=TaskStage.EXECUTING),
+            states={
+                TaskStructureSummaryState.DONE: {
+                    TaskAction.DEFAULT: StageNext(stage=TaskStage.COMPLETED),
+                    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
+        ),
         StageTransition[TaskStage, bool](
             stage=TaskStage.COMPLETED,
             agent=CodeExecutor,

jupyter_agent/bot_magics.py

@@ -15,11 +15,14 @@ from IPython.display import Markdown
 from IPython.core.magic import Magics, magics_class, cell_magic
 from traitlets import Unicode, Int, Bool
 from traitlets.config.configurable import Configurable
-from .bot_contexts import NotebookContext, AgentCellContext
-from .bot_agents import AgentFactory
-from .bot_agents.base import AgentModelType
-from .bot_flows import MasterPlannerFlow, TaskExecutorFlowV1, TaskExecutorFlowV2, TaskExecutorFlowV3
-from .bot_outputs import _D, _I, _W, _E, _F, _M, _B, _O, reset_output, set_logging_level
+from .bot_contexts import NotebookContext
+from .bot_agents.base import AgentModelType, AgentFactory
+from .bot_agents.request_user_supply import RequestUserSupplyAgent
+from .bot_evaluators.base import EvaluatorFactory
+from .bot_flows import MasterPlannerFlow, TaskExecutorFlowV3
+from .bot_outputs import _D, _I, _W, _E, _F, _M, _B, _O, reset_output, set_logging_level, flush_output
+from .bot_actions import close_action_dispatcher
+from .utils import get_env_capbilities
 
 
 @magics_class
@@ -44,6 +47,11 @@ class BotMagics(Magics, Configurable):
     display_think = Bool(True, help="Display chatthink response").tag(config=True)
     display_response = Bool(False, help="Display chat full response").tag(config=True)
     support_save_meta = Bool(False, help="Support save metadata to cell").tag(config=True)
+    support_user_confirm = Bool(False, help="Support user confirm").tag(config=True)
+    support_user_supply_info = Bool(False, help="Support user supply info").tag(config=True)
+    support_set_cell_content = Bool(False, help="Support set cell content").tag(config=True)
+    enable_evaluating = Bool(False, help="Enable evaluating task").tag(config=True)
+    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)
@@ -73,27 +81,16 @@ class BotMagics(Magics, Configurable):
             help="Run without confirm",
         )
         options, _ = parser.parse_known_args(shlex.split(line.strip()))
-
         return options
 
-    def ensure_notebook_path(self):
-        if self.notebook_path:
-            return self.notebook_path
-        result = self.shell and self.shell.run_cell("globals().get('__vsc_ipynb_file__')")
-        if result and result.success and result.result:
-            self.notebook_path = result.result
-            return self.notebook_path
-        try:
-            self.notebook_path = str(ipynbname.path())
-            return self.notebook_path
-        except Exception as e:
-            _F(f"Failed to get notebook path: {e}")
-            return None
-
     @cell_magic
     def bot(self, line, cell):
         """Jupyter cell magic: %%bot"""
         try:
+            reset_output(stage="Logging", logging_level=self.logging_level)
+            _I("Cell magic %%bot executing ...")
+            _D(f"Cell magic called with line: {line}")
+            _D(f"Cell magic called with cell: {repr(cell)[:50]} ...")
             if not self.ensure_notebook_path():
                 _O(
                     Markdown(
@@ -103,11 +100,6 @@ class BotMagics(Magics, Configurable):
                     )
                 )
                 return
-            AgentCellContext.SUPPORT_SAVE_META = self.support_save_meta
-            reset_output(stage="Logging", logging_level=self.logging_level)
-            _I("Cell magic %%bot executing ...")
-            _D(f"Cell magic called with line: {line}")
-            _D(f"Cell magic called with cell: {repr(cell)[:50]} ...")
             if not cell.strip():
                 _O(
                     Markdown(
@@ -120,51 +112,23 @@ class BotMagics(Magics, Configurable):
                         "%%bot {}\n\n# {}".format(line.strip(), time.strftime("%Y-%m-%d %H:%M:%S")), replace=True
                     )
                 return
+            get_env_capbilities().save_metadata = self.support_save_meta
+            get_env_capbilities().user_confirm = self.support_user_confirm
+            get_env_capbilities().user_supply_info = self.support_user_supply_info
+            get_env_capbilities().set_cell_content = self.support_set_cell_content
+            RequestUserSupplyAgent.MOCK_USER_SUPPLY = self.enable_supply_mocking
             options = self.parse_args(line)
-            _D(f"Cell magic called with options: {options}")
             set_logging_level(options.logging_level)
+            _D(f"Cell magic called with options: {options}")
             nb_context = NotebookContext(line, cell, notebook_path=self.notebook_path)
-            agent_factory = AgentFactory(
-                nb_context,
-                display_think=self.display_think,
-                display_message=self.display_message,
-                display_response=self.display_response,
-            )
-            agent_factory.config_model(
-                AgentModelType.DEFAULT,
-                self.default_api_url,
-                self.default_api_key,
-                self.default_model_name,
-            )
-            agent_factory.config_model(
-                AgentModelType.PLANNER,
-                self.planner_api_url,
-                self.planner_api_key,
-                self.planner_model_name,
-            )
-            agent_factory.config_model(
-                AgentModelType.CODING,
-                self.coding_api_url,
-                self.coding_api_key,
-                self.coding_model_name,
-            )
-            agent_factory.config_model(
-                AgentModelType.REASONING,
-                self.reasoning_api_url,
-                self.reasoning_api_key,
-                self.reasoning_model_name,
-            )
+            agent_factory = self.get_agent_factory(nb_context)
+            evaluator_factory = self.get_evaluator_factory(nb_context)
             if options.planning:
-                flow = MasterPlannerFlow(nb_context, agent_factory)
+                flow = MasterPlannerFlow(nb_context, agent_factory, evaluator_factory)
+            elif options.flow == "v3":
+                flow = TaskExecutorFlowV3(nb_context, agent_factory, evaluator_factory)
             else:
-                if options.flow == "v1":
-                    flow = TaskExecutorFlowV1(nb_context, agent_factory)
-                elif options.flow == "v2":
-                    flow = TaskExecutorFlowV2(nb_context, agent_factory)
-                elif options.flow == "v3":
-                    flow = TaskExecutorFlowV3(nb_context, agent_factory)
-                else:
-                    raise ValueError(f"Unknown flow: {options.flow}")
+                raise ValueError(f"Unknown flow: {options.flow}")
             flow(
                 options.stage,
                 options.max_tries,
@@ -173,6 +137,65 @@ class BotMagics(Magics, Configurable):
             )
         except Exception as e:
             traceback.print_exc()
+        finally:
+            close_action_dispatcher()
+            flush_output()
+
+    def ensure_notebook_path(self):
+        if self.notebook_path:
+            return self.notebook_path
+        result = self.shell and self.shell.run_cell(
+            "globals().get('__vsc_ipynb_file__') or globals().get('__evaluation_ipynb_file__')"
+        )
+        if result and result.success and result.result:
+            self.notebook_path = result.result
+            return self.notebook_path
+        try:
+            self.notebook_path = str(ipynbname.path())
+            return self.notebook_path
+        except Exception as e:
+            _F(f"Failed to get notebook path: {e}")
+            return None
+
+    def get_agent_factory(self, nb_context):
+        agent_factory = AgentFactory(
+            nb_context,
+            display_think=self.display_think,
+            display_message=self.display_message,
+            display_response=self.display_response,
+        )
+        agent_factory.config_model(
+            AgentModelType.DEFAULT, self.default_api_url, self.default_api_key, self.default_model_name
+        )
+        agent_factory.config_model(
+            AgentModelType.PLANNER, self.planner_api_url, self.planner_api_key, self.planner_model_name
+        )
+        agent_factory.config_model(
+            AgentModelType.CODING, self.coding_api_url, self.coding_api_key, self.coding_model_name
+        )
+        agent_factory.config_model(
+            AgentModelType.REASONING, self.reasoning_api_url, self.reasoning_api_key, self.reasoning_model_name
+        )
+        return agent_factory
+
+    def get_evaluator_factory(self, nb_context):
+        if self.enable_evaluating:
+            evaluator_factory = EvaluatorFactory(nb_context)
+            evaluator_factory.config_model(
+                AgentModelType.DEFAULT, self.default_api_url, self.default_api_key, self.default_model_name
+            )
+            evaluator_factory.config_model(
+                AgentModelType.PLANNER, self.planner_api_url, self.planner_api_key, self.planner_model_name
+            )
+            evaluator_factory.config_model(
+                AgentModelType.CODING, self.coding_api_url, self.coding_api_key, self.coding_model_name
+            )
+            evaluator_factory.config_model(
+                AgentModelType.REASONING, self.reasoning_api_url, self.reasoning_api_key, self.reasoning_model_name
+            )
+        else:
+            evaluator_factory = None
+        return evaluator_factory
 
 
 def load_ipython_extension(ipython):