core/workflow/node_runtime.py 就是这批适配器的集中地。每个类都实现引擎的某个 Protocol：

Day05 的 ModelInstance 方法很多（六种 invoke、算 token、拿 schema…）。但引擎里的 LLM 节点只需要其中一小撮。DifyPreparedLLM（api/core/workflow/node_runtime.py:150）就是那层"只暴露必要的"包装：

# api/core/workflow/node_runtime.py:150
class DifyPreparedLLM(LLMProtocol):
    """Workflow-layer adapter that hides the full `ModelInstance` API from `graphon` nodes."""
    def __init__(self, model_instance: ModelInstance, request_metadata=None):
        self._model_instance = model_instance          # ① 把真身藏起来，只留自己当门面
        self._request_metadata = request_metadata

    @property
    def provider(self) -> str:
        return self._model_instance.provider           # ② 引擎要什么，就转发什么

    @override
    def invoke_llm(self, *, prompt_messages, model_parameters, tools, stop, stream):
        return self._model_instance.invoke_llm(         # ③ ★核心：转调 Day05 的 invoke_llm
            prompt_messages=list(prompt_messages),
            model_parameters=dict(model_parameters),
            tools=list(tools or []), stop=list(stop or []),
            stream=stream, request_metadata=self._request_metadata,  # 补上 Dify 的追踪元数据
        )

有些模型调用是长任务（如深度推理、批处理），不能一个请求干等到底。DifyPreparedPollingLLM（api/core/workflow/node_runtime.py:285）在普通适配器上加了"轮询"能力：

# api/core/workflow/node_runtime.py:285
class DifyPreparedPollingLLM(DifyPreparedLLM, LLMPollingCapableProtocol):
    """Prepared workflow LLM adapter that exposes Graphon's polling protocol."""
    def __init__(self, model_instance, request_metadata=None):
        super().__init__(model_instance, request_metadata=request_metadata)
        model_type_instance = model_instance.model_type_instance
        if not isinstance(model_type_instance, LargeLanguageModel):     # ① 前提：必须是 LLM
            raise TypeError("Polling wrapper requires a large-language-model instance.")
        plugin_model_runtime = model_type_instance.model_runtime
        if not isinstance(plugin_model_runtime, PluginModelRuntime):    # ② 前提：必须是插件化模型
            raise TypeError("Polling wrapper requires a plugin-backed model runtime.")
        self._plugin_model_runtime = plugin_model_runtime

    @override
    def start_llm_polling(self, *, prompt_messages, model_parameters, tools, stop, json_schema):
        return self._plugin_model_runtime.start_llm_polling(...)        # ③ 发起：拿一个"任务凭据"
    @override
    def check_llm_polling(self, *, plugin_state):
        return self._plugin_model_runtime.check_llm_polling(...)        # ④ 查询：拿凭据问"好了没"

工具节点要调外部工具（搜索、画图、自定义 API）。DifyToolNodeRuntime（api/core/workflow/node_runtime.py:459）把 Dify 的 ToolManager 适配成引擎的工具协议。看它的 get_runtime：

# api/core/workflow/node_runtime.py:478（get_runtime 节选）
def get_runtime(self, *, node_id, node_data, variable_pool, node_execution_id=None) -> ToolRuntimeHandle:
    try:
        tool_runtime = ToolManager.get_workflow_tool_runtime(     # ① ★转调 Dify 的 ToolManager
            self._run_context.tenant_id, self._run_context.app_id, node_id,
            self._build_tool_runtime_spec(node_data),
            self._run_context.user_id, self._run_context.invoke_from, variable_pool)
    except ToolNodeError:
        raise                                                     # ② 已知工具错，原样上抛
    except Exception as exc:
        raise ToolRuntimeResolutionError(str(exc)) from exc       # ③ 未知错 → 包成引擎认的错

    conversation_id = ... get_system_text(variable_pool, SystemVariableKey.CONVERSATION_ID)
    return ToolRuntimeHandle(                                      # ④ 包成引擎的"工具句柄"
        raw=_WorkflowToolRuntimeBinding(tool=tool_runtime, conversation_id=conversation_id, ...))

现在回看 Day08 WorkflowEntry.__init__ 里造引擎那段（api/core/workflow/workflow_entry.py:213），你能看懂每个零件了：

# api/core/workflow/workflow_entry.py:213
self.graph_engine = GraphEngine(
    workflow_id=workflow_id,
    graph=graph,                          # 结构化图(Day08)
    graph_runtime_state=graph_runtime_state,  # 含变量池的账本(Day08)
    command_channel=command_channel,      # 急停通道(Day08)
    config=GraphEngineConfig(min_workers=..., max_workers=...),  # 并发worker池(Day08)
    child_engine_builder=self._child_engine_builder,            # 嵌套子工作流
)
# 挂各种 Layer：熔断 / 额度 / 观测 / 调试(Day08)
self.graph_engine.layer(ExecutionLimitsLayer(...))
self.graph_engine.layer(LLMQuotaLayer(tenant_id=tenant_id))