♻️ refactor(tools): 重构工具装饰器系统并优化沙箱与文档注释 (#2147)

* ♻️ refactor(ai): 重构 AI 服务模块并完善文档注释

- 【重构】统一清理并优化所有 AI 服务模块文件的导入语句，将其移至文件顶部
- 【重构】重构 `hooks.py` 中的 `Hooks` 派发逻辑，使用通用管道函数消除重复代码，并引入 `HookPoint` 描述符
- 【重构】重构工具装饰器实现，新增 `toolkit` 类装饰器，优化 `BaseToolkit` 配置合并与前缀处理
- 【功能】Docker 沙箱容器创建时支持自动注入系统代理环境变量并配置 `ExtraHosts`
- 【功能】Jupyter 服务启动前自动清理旧进程并初始化临时目录权限
- 【修复】优化 Pydantic 结构化输出校验失败时的错误信息提取，提供更详细的字段级错误反馈
- 【修复】在 `api.py` 中避免将 `ModelRetry` 和 `ControlFlowExit` 异常错误地包装为 `LLMException`
- 【文档】为 AI 服务、沙箱、工具链、工作流等核心模块补充完整的 Docstring 和类型注释

* 📝 docs(ai): 补全核心模块文档注释并清理冗余代码

- 补全 `run/context`、`run/hooks` 和 `tools/engine/registry` 中类与方法的中文文档注释
- 清理 `tools/providers/builtin/sandbox` 中未使用的 `PythonPluginProtocol` 协议及相关导入
- 规范化部分代码的格式与尾随逗号

* ♻️ refactor!(flow): 重构 Task 为 AgentTask 并优化工作流元数据定义

- 【Breaking Change】将 `Task` 重命名为 `AgentTask` 以避免命名冲突
- 更新 Agent、Team、Workflow 等模块中的类型声明与相关逻辑
- 引入 `AutoNodeMeta` 强类型元数据，替换工作流装饰器中的裸字典定义
- 将 `StepMeta`、`ConditionMeta` 和 `RouterMeta` 统一移动至 `types.py`
- 优化 `RunnableNode` 对上游 `AgentTask` 的处理与拼接逻辑
- 调整团队协作策略中 `FinishAction` 的返回值为完整结果对象

* ♻️ refactor(workflow): 移除人工确认机制并重构错误策略

- 移除工作流节点的人工确认（HITL）与挂起继续机制
- 删除 `auto` 自动化工作流及相关装饰器文件
- 将错误处理策略类从 `types.py` 拆分并移动到新文件 `policies.py`
- 优化节点执行失败时的异常信息格式化输出
- 移除 `WorkflowRunResult` 和 `StepOutput` 中与挂起相关的状态字段

* 🚨 auto fix by pre-commit hooks

---------

Co-authored-by: webjoin111 <455457521@qq.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

zhenxun/services/ai/flow/workflow/engine.py

@@ -1,12 +1,13 @@
 import asyncio
 from collections.abc import AsyncIterator
+import contextlib
 from typing import TYPE_CHECKING, Any
 import uuid
 
+from nonebot.params import Depends
+
 if TYPE_CHECKING:
     from zhenxun.services.ai.flow.workflow.nodes import NodeSource
-    from zhenxun.services.ai.run import StreamedRunResult
-
 
 from zhenxun.services.ai.core.exceptions import ControlFlowExit, ToolRetryError
 from zhenxun.services.ai.core.messages import PromptInput, UsageInfo
@@ -18,9 +19,16 @@ from zhenxun.services.ai.flow.workflow.types import (
     StepOutput,
     WorkflowRunResult,
 )
-from zhenxun.services.ai.run import RunContext
+from zhenxun.services.ai.run.context import RunContext
+from zhenxun.services.ai.run.models import (
+    AgentRunEnd,
+    AgentRunError,
+    AgentRunResult,
+    StreamedRunResult,
+)
 from zhenxun.services.ai.tools.core.tool import FunctionTool
 from zhenxun.services.log import logger
+from zhenxun.utils.message import MessageUtils
 
 
 class Workflow(BaseRunnable[WorkflowRunResult]):
@@ -52,6 +60,7 @@ class Workflow(BaseRunnable[WorkflowRunResult]):
         safe_context: RunContext,
         final_output: StepOutput,
     ) -> WorkflowRunResult:
+        """根据执行链上的全量输出构建最终的工作流执行结果对象"""
         flat_outputs = {}
 
         def _extract(out: StepOutput):
@@ -63,19 +72,7 @@ class Workflow(BaseRunnable[WorkflowRunResult]):
         if final_output:
             _extract(final_output)
 
-        paused_step = next(
-            (
-                v.step_name
-                for v in reversed(list(flat_outputs.values()))
-                if getattr(v, "is_paused", False) and v.step_name
-            ),
-            None,
-        )
-        status = (
-            "paused"
-            if paused_step
-            else ("completed" if final_output and final_output.success else "error")
-        )
+        status = "completed" if final_output and final_output.success else "error"
 
         return WorkflowRunResult(
             workflow_id=self.id,
@@ -86,12 +83,10 @@ class Workflow(BaseRunnable[WorkflowRunResult]):
             step_outputs=flat_outputs,
             last_step_content=final_output.content if final_output else None,
             final_output=final_output,
-            paused_step_name=paused_step,
         )
 
     def bind(self, **kwargs: Any) -> Any:
         """DI 注入语法糖"""
-        from nonebot.params import Depends
 
         async def _dependency() -> "Workflow":
             return self
@@ -112,8 +107,6 @@ class Workflow(BaseRunnable[WorkflowRunResult]):
         返回:
             WorkflowRunResult: 包含执行状态、断点快照、各节点产出的全量工作流结果对象。
         """
-        from zhenxun.utils.message import MessageUtils
-
         ctx = RunContext()
         bot = ctx.get_bot()
         event = ctx.get_event()
@@ -128,12 +121,6 @@ class Workflow(BaseRunnable[WorkflowRunResult]):
                     else "执行完毕"
                 )
                 await MessageUtils.build_message(msg).send(reply_to=reply_to)
-            elif res.status == "paused":
-                pause_msg = (
-                    f"⏸️ 工作流执行已被挂起，停在步骤: {res.paused_step_name}。"
-                    "请提供授权或人工输入后继续。"
-                )
-                await MessageUtils.build_message(pause_msg).send(reply_to=reply_to)
             elif res.status == "error":
                 err_msg = res.final_output.error if res.final_output else "未知异常"
                 await MessageUtils.build_message(
@@ -186,8 +173,6 @@ class Workflow(BaseRunnable[WorkflowRunResult]):
 
             raise e
 
-    import contextlib
-
     @contextlib.asynccontextmanager
     async def run_stream(
         self,
@@ -197,9 +182,6 @@ class Workflow(BaseRunnable[WorkflowRunResult]):
         **kwargs: Any,
     ) -> AsyncIterator["StreamedRunResult[Any]"]:
         """对齐 BaseRunnable 接口的流式上下文管理器"""
-        from zhenxun.services.ai.run import StreamedRunResult
-        from zhenxun.services.ai.run.models import AgentRunError
-
         event_bus = EventBus()
         if context:
             context.run.event_bus = event_bus
@@ -226,7 +208,7 @@ class Workflow(BaseRunnable[WorkflowRunResult]):
         context: RunContext | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[Any]:
-        """原 arun_stream 逻辑改名，供内部 _execution_task 调用"""
+        """流式执行工作流节点树的内部实现"""
         session_id = (
             context.session_id if context and context.session_id else f"wf_{self.id}"
         )
@@ -251,9 +233,6 @@ class Workflow(BaseRunnable[WorkflowRunResult]):
             if final_output:
                 logger.debug(f"🏭 **工作流 [{self.name}] 运行结束**")
 
-                from zhenxun.services.ai.run import AgentRunResult
-                from zhenxun.services.ai.run.models import AgentRunEnd
-
                 wf_result = self._build_result(
                     initial_input, safe_context, final_output
                 )
@@ -266,41 +245,9 @@ class Workflow(BaseRunnable[WorkflowRunResult]):
         except Exception:
             pass
 
-    async def acontinue_run(
-        self,
-        run_result: WorkflowRunResult,
-        user_auth_data: dict[str, Any] | None = None,
-        context: RunContext | None = None,
-    ) -> WorkflowRunResult:
-        safe_context = context or RunContext(session_id=f"wf_{self.id}")
-        safe_context.state.update(run_result.state)
-
-        safe_context.state["__completed_steps__"] = run_result.step_outputs.copy()
-        for step_name, out in run_result.step_outputs.items():
-            safe_context.upstream_results[step_name] = out.content
-
-        if run_result.paused_step_name:
-            safe_context.state[f"__hitl_confirmed_{run_result.paused_step_name}"] = True
-            if user_auth_data:
-                safe_context.state[f"__hitl_input_{run_result.paused_step_name}"] = (
-                    user_auth_data
-                )
-
-        resume_input = StepInput(
-            input=run_result.original_input,
-            previous_step_content=run_result.last_step_content,
-        )
-
-        logger.debug(
-            f"🚀 工作流 [{self.name}] 状态已恢复，"
-            f"正在快进到步骤: {run_result.paused_step_name}..."
-        )
-
-        final_output = await self.root_steps.aexecute(resume_input, safe_context)
-
-        return self._build_result(resume_input, safe_context, final_output)
-
     def as_tool(self, tool_name: str | None = None) -> FunctionTool:
+        """将工作流封装并导出为可供 Agent 直接调用的 FunctionTool 实例"""
+
         async def _execute_workflow_tool(prompt: str, context: RunContext) -> str:
             run_result = await self.run(prompt=prompt, context=context)
             output = run_result.final_output