Merge main HEAD (segment 5) into sandboxed-agent-rebase

Resolve 83 conflicts: 10 backend, 62 frontend, 11 config/lock files.
Preserve sandbox/agent/collaboration features while adopting main's
UI refactorings (Dialog/AlertDialog/Popover), model provider updates,
and enterprise features.

Made-with: Cursor

api/dify_graph/graph_engine/error_handler.py

@@ -159,6 +159,7 @@ class ErrorHandler:
             node_id=event.node_id,
             node_type=event.node_type,
             start_at=event.start_at,
+            finished_at=event.finished_at,
             node_run_result=NodeRunResult(
                 status=WorkflowNodeExecutionStatus.EXCEPTION,
                 inputs=event.node_run_result.inputs,
@@ -198,6 +199,7 @@ class ErrorHandler:
             node_id=event.node_id,
             node_type=event.node_type,
             start_at=event.start_at,
+            finished_at=event.finished_at,
             node_run_result=NodeRunResult(
                 status=WorkflowNodeExecutionStatus.EXCEPTION,
                 inputs=event.node_run_result.inputs,

api/dify_graph/graph_engine/response_coordinator/__init__.py

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

api/dify_graph/graph_engine/response_coordinator/session.py

@@ -3,10 +3,6 @@ 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
@@ -14,7 +10,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Protocol, cast
 
-from dify_graph.enums import BuiltinNodeTypes, NodeType
 from dify_graph.nodes.base.template import Template
 from dify_graph.runtime.graph_runtime_state import NodeProtocol
 
@@ -25,12 +20,6 @@ class _ResponseSessionNodeProtocol(NodeProtocol, Protocol):
     def get_streaming_template(self) -> Template: ...
 
 
-RESPONSE_SESSION_NODE_TYPES: list[NodeType] = [
-    BuiltinNodeTypes.ANSWER,
-    BuiltinNodeTypes.END,
-]
-
-
 @dataclass
 class ResponseSession:
     """
@@ -49,8 +38,8 @@ 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.
-        At runtime this must be a node whose `node_type` is listed in `RESPONSE_SESSION_NODE_TYPES`
-        and which implements `get_streaming_template()`.
+        At runtime this must be a node that implements `get_streaming_template()`. The coordinator decides which
+        graph nodes should be treated as response-capable before they reach this factory.
 
         Args:
             node: Node from the materialized workflow graph.
@@ -59,15 +48,8 @@ class ResponseSession:
             ResponseSession configured with the node's streaming template
 
         Raises:
-            TypeError: If node is not a supported response node type.
+            TypeError: If node does not implement the response-session streaming contract.
         """
-        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()

api/dify_graph/graph_engine/worker.py

@@ -15,10 +15,13 @@ from typing import TYPE_CHECKING, final
 from typing_extensions import override
 
 from dify_graph.context import IExecutionContext
+from dify_graph.enums import WorkflowNodeExecutionStatus
 from dify_graph.graph import Graph
 from dify_graph.graph_engine.layers.base import GraphEngineLayer
-from dify_graph.graph_events import GraphNodeEventBase, NodeRunFailedEvent, is_node_result_event
+from dify_graph.graph_events import GraphNodeEventBase, NodeRunFailedEvent, NodeRunStartedEvent, is_node_result_event
+from dify_graph.node_events import NodeRunResult
 from dify_graph.nodes.base.node import Node
+from libs.datetime_utils import naive_utc_now
 
 from .ready_queue import ReadyQueue
 
@@ -65,6 +68,7 @@ class Worker(threading.Thread):
         self._stop_event = threading.Event()
         self._layers = layers if layers is not None else []
         self._last_task_time = time.time()
+        self._current_node_started_at: datetime | None = None
 
     def stop(self) -> None:
         """Signal the worker to stop processing."""
@@ -104,18 +108,15 @@ class Worker(threading.Thread):
             self._last_task_time = time.time()
             node = self._graph.nodes[node_id]
             try:
+                self._current_node_started_at = None
                 self._execute_node(node)
                 self._ready_queue.task_done()
             except Exception as e:
-                error_event = NodeRunFailedEvent(
-                    id=node.execution_id,
-                    node_id=node.id,
-                    node_type=node.node_type,
-                    in_iteration_id=None,
-                    error=str(e),
-                    start_at=datetime.now(),
+                self._event_queue.put(
+                    self._build_fallback_failure_event(node, e, started_at=self._current_node_started_at)
                 )
-                self._event_queue.put(error_event)
+            finally:
+                self._current_node_started_at = None
 
     def _execute_node(self, node: Node) -> None:
         """
@@ -136,6 +137,8 @@ class Worker(threading.Thread):
                 try:
                     node_events = node.run()
                     for event in node_events:
+                        if isinstance(event, NodeRunStartedEvent) and event.id == node.execution_id:
+                            self._current_node_started_at = event.start_at
                         self._event_queue.put(event)
                         if is_node_result_event(event):
                             result_event = event
@@ -149,6 +152,8 @@ class Worker(threading.Thread):
             try:
                 node_events = node.run()
                 for event in node_events:
+                    if isinstance(event, NodeRunStartedEvent) and event.id == node.execution_id:
+                        self._current_node_started_at = event.start_at
                     self._event_queue.put(event)
                     if is_node_result_event(event):
                         result_event = event
@@ -177,3 +182,24 @@ class Worker(threading.Thread):
             except Exception:
                 # Silently ignore layer errors to prevent disrupting node execution
                 continue
+
+    def _build_fallback_failure_event(
+        self, node: Node, error: Exception, *, started_at: datetime | None = None
+    ) -> NodeRunFailedEvent:
+        """Build a failed event when worker-level execution aborts before a node emits its own result event."""
+        failure_time = naive_utc_now()
+        error_message = str(error)
+        return NodeRunFailedEvent(
+            id=node.execution_id,
+            node_id=node.id,
+            node_type=node.node_type,
+            in_iteration_id=None,
+            error=error_message,
+            start_at=started_at or failure_time,
+            finished_at=failure_time,
+            node_run_result=NodeRunResult(
+                status=WorkflowNodeExecutionStatus.FAILED,
+                error=error_message,
+                error_type=type(error).__name__,
+            ),
+        )