refactor(api): move workflow knowledge nodes and trigger nodes (#33445)

api/dify_graph/graph_engine/response_coordinator/__init__.py

@@ -6,5 +6,6 @@ of responses based on upstream node outputs and constants.
 """
 
 from .coordinator import ResponseStreamCoordinator
+from .session import RESPONSE_SESSION_NODE_TYPES
 
-__all__ = ["ResponseStreamCoordinator"]
+__all__ = ["RESPONSE_SESSION_NODE_TYPES", "ResponseStreamCoordinator"]

api/dify_graph/graph_engine/response_coordinator/session.py

@@ -3,19 +3,34 @@ Internal response session management for response coordinator.
 
 This module contains the private ResponseSession class used internally
 by ResponseStreamCoordinator to manage streaming sessions.
+
+`RESPONSE_SESSION_NODE_TYPES` is intentionally mutable so downstream applications
+can opt additional response-capable node types into session creation without
+patching the coordinator.
 """
 
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import Protocol, cast
 
-from dify_graph.nodes.answer.answer_node import AnswerNode
+from dify_graph.enums import BuiltinNodeTypes, NodeType
 from dify_graph.nodes.base.template import Template
-from dify_graph.nodes.end.end_node import EndNode
-from dify_graph.nodes.knowledge_index import KnowledgeIndexNode
 from dify_graph.runtime.graph_runtime_state import NodeProtocol
 
 
+class _ResponseSessionNodeProtocol(NodeProtocol, Protocol):
+    """Structural contract required from nodes that can open a response session."""
+
+    def get_streaming_template(self) -> Template: ...
+
+
+RESPONSE_SESSION_NODE_TYPES: list[NodeType] = [
+    BuiltinNodeTypes.ANSWER,
+    BuiltinNodeTypes.END,
+]
+
+
 @dataclass
 class ResponseSession:
     """
@@ -33,10 +48,9 @@ class ResponseSession:
         """
         Create a ResponseSession from a response-capable node.
 
-        The parameter is typed as `NodeProtocol` because the graph is exposed behind a protocol at the runtime layer,
-        but at runtime this must be an `AnswerNode`, `EndNode`, or `KnowledgeIndexNode` that provides:
-        - `id: str`
-        - `get_streaming_template() -> Template`
+        The parameter is typed as `NodeProtocol` because the graph is exposed behind a protocol at the runtime layer.
+        At runtime this must be a node whose `node_type` is listed in `RESPONSE_SESSION_NODE_TYPES`
+        and which implements `get_streaming_template()`.
 
         Args:
             node: Node from the materialized workflow graph.
@@ -47,11 +61,22 @@ class ResponseSession:
         Raises:
             TypeError: If node is not a supported response node type.
         """
-        if not isinstance(node, AnswerNode | EndNode | KnowledgeIndexNode):
-            raise TypeError("ResponseSession.from_node only supports AnswerNode, EndNode, or KnowledgeIndexNode")
+        if node.node_type not in RESPONSE_SESSION_NODE_TYPES:
+            supported_node_types = ", ".join(RESPONSE_SESSION_NODE_TYPES)
+            raise TypeError(
+                "ResponseSession.from_node only supports node types in "
+                f"RESPONSE_SESSION_NODE_TYPES: {supported_node_types}"
+            )
+
+        response_node = cast(_ResponseSessionNodeProtocol, node)
+        try:
+            template = response_node.get_streaming_template()
+        except AttributeError as exc:
+            raise TypeError("ResponseSession.from_node requires get_streaming_template() on response nodes") from exc
+
         return cls(
             node_id=node.id,
-            template=node.get_streaming_template(),
+            template=template,
         )
 
     def is_complete(self) -> bool: