Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

fix(api): restore Human Input completion events (#42082)

QuantumGhost798fd5e4c067
diff --git a/api/core/workflow/nodes/human_input/boundary.py b/api/core/workflow/nodes/human_input/boundary.py
index ff61f59a318..b15bdf9f74f 100644
--- a/api/core/workflow/nodes/human_input/boundary.py
+++ b/api/core/workflow/nodes/human_input/boundary.py
@@ -1,12 +1,23 @@
from __future__ import annotations
-from collections.abc import Sequence
+from collections.abc import Iterable, Sequence
from core.repositories.human_input_repository import HumanInputFormSubmissionRepository
from core.workflow.human_input_policy import resolve_variable_select_input_options
+from core.workflow.system_variables import SystemVariableKey, get_system_text
from graphon.entities.pause_reason import HitlRequired, SchedulingPause
+from graphon.enums import BuiltinNodeTypes
+from graphon.filters import GraphEventFilterContext
+from graphon.graph_events import (
+ GraphEngineEvent,
+ NodeRunHumanInputFormFilledEvent,
+ NodeRunHumanInputFormTimeoutEvent,
+ NodeRunStartedEvent,
+ NodeRunSucceededEvent,
+)
from graphon.runtime.graph_runtime_state_protocol import ReadOnlyVariablePool
+from .constants import OUTPUT_FIELD_ACTION_ID, OUTPUT_FIELD_ACTION_VALUE, OUTPUT_FIELD_RENDERED_CONTENT, TIMEOUT_HANDLE
from .pause_reason import HumanInputRequired, PauseReason
from .session_binding import default_session_binding
@@ -15,6 +26,72 @@ class HumanInputPauseReasonResolutionError(LookupError):
"""Raised when a graph pause reason cannot be resolved into Dify-owned form state."""
+class HumanInputFormEventFilter:
+ """Adapt HITL callback results into Dify's form lifecycle event stream."""
+
+ def __init__(self, *, form_repository: HumanInputFormSubmissionRepository) -> None:
+ self._form_repository = form_repository
+ self._node_titles: dict[str, str] = {}
+ self._app_id: str | None = None
+
+ @property
+ def filter_id(self) -> str:
+ return "dify-human-input-form-events"
+
+ def initialize(self, context: GraphEventFilterContext) -> None:
+ self._node_titles.clear()
+ self._app_id = get_system_text(context.runtime_state.variable_pool, SystemVariableKey.APP_ID)
+
+ def on_event(self, event: GraphEngineEvent) -> Iterable[GraphEngineEvent]:
+ if isinstance(event, NodeRunStartedEvent) and event.node_type == BuiltinNodeTypes.HUMAN_INPUT:
+ self._node_titles[event.id] = event.node_title
+ elif isinstance(event, NodeRunSucceededEvent) and event.node_type == BuiltinNodeTypes.HUMAN_INPUT:
+ yield self._completion_event(event)
+
+ yield event
+
+ def flush(self) -> Iterable[GraphEngineEvent]:
+ return ()
+
+ def _completion_event(
+ self, event: NodeRunSucceededEvent
+ ) -> NodeRunHumanInputFormFilledEvent | NodeRunHumanInputFormTimeoutEvent:
+ # Titles are present only on start events. Key by execution ID so loop
+ # iterations and concurrent executions do not share completion metadata.
+ node_title = self._node_titles.pop(event.id)
+ result = event.node_run_result
+ if result.edge_source_handle == TIMEOUT_HANDLE:
+ # The callback's timeout result omits the deadline. Resolve the form
+ # by its bound execution ID rather than choosing a form by node ID.
+ form = self._form_repository.get_by_form_id(event.id)
+ if form is None or form.app_id != self._app_id or form.node_id != event.node_id:
+ raise ValueError(f"Cannot resolve timed-out human input form for node execution {event.id}")
+ return NodeRunHumanInputFormTimeoutEvent(
+ id=event.id,
+ node_id=event.node_id,
+ node_type=event.node_type,
+ node_title=node_title,
+ node_version=event.node_version,
+ in_iteration_id=event.in_iteration_id,
+ in_loop_id=event.in_loop_id,
+ expiration_time=form.expiration_time,
+ )
+
+ return NodeRunHumanInputFormFilledEvent(
+ id=event.id,
+ node_id=event.node_id,
+ node_type=event.node_type,
+ node_title=node_title,
+ node_version=event.node_version,
+ in_iteration_id=event.in_iteration_id,
+ in_loop_id=event.in_loop_id,
+ rendered_content=result.outputs[OUTPUT_FIELD_RENDERED_CONTENT].text,
+ action_id=result.outputs[OUTPUT_FIELD_ACTION_ID].text,
+ action_text=result.outputs[OUTPUT_FIELD_ACTION_VALUE].text,
+ submitted_data=result.inputs,
+ )
+
+
def enrich_graph_pause_reasons(
*,
reasons: Sequence[HitlRequired | PauseReason],
diff --git a/api/core/workflow/nodes/human_input/callback.py b/api/core/workflow/nodes/human_input/callback.py
index 9f83c3c85e4..17b26f3cde6 100644
--- a/api/core/workflow/nodes/human_input/callback.py
+++ b/api/core/workflow/nodes/human_input/callback.py
@@ -17,6 +17,7 @@ from graphon.variables.segments import Segment
from graphon.variables.template_resolution import convert_template
from libs.datetime_utils import ensure_naive_utc, naive_utc_now
+from .constants import OUTPUT_FIELD_ACTION_ID, OUTPUT_FIELD_ACTION_VALUE, OUTPUT_FIELD_RENDERED_CONTENT, TIMEOUT_HANDLE
from .entities import (
FileInputConfig,
FileListInputConfig,
@@ -65,11 +66,6 @@ class DifyHITLCallback:
pause_requested_type = PauseRequested
- _OUTPUT_FIELD_ACTION_ID = "__action_id"
- _OUTPUT_FIELD_ACTION_VALUE = "__action_value"
- _OUTPUT_FIELD_RENDERED_CONTENT = "__rendered_content"
- _TIMEOUT_HANDLE = "__timeout"
-
def __init__(
self,
*,
@@ -106,7 +102,7 @@ class DifyHITLCallback:
status = self._normalize_status(form.status)
if status == HumanInputFormStatus.TIMEOUT.value:
return Expired(
- selected_handle=self._TIMEOUT_HANDLE,
+ selected_handle=TIMEOUT_HANDLE,
outputs=self._build_special_outputs(
action_id="",
action_value="",
@@ -124,7 +120,7 @@ class DifyHITLCallback:
raise AssertionError(msg)
if self._is_past_node_deadline(form.expiration_time):
return Expired(
- selected_handle=self._TIMEOUT_HANDLE,
+ selected_handle=TIMEOUT_HANDLE,
outputs=self._build_special_outputs(
action_id="",
action_value="",
@@ -311,16 +307,15 @@ class DifyHITLCallback:
raise ValueError("file_reference_factory is required to restore file submissions")
return self._file_reference_factory.build_from_mapping(mapping=mapping)
- @classmethod
+ @staticmethod
def _build_special_outputs(
- cls,
*,
action_id: str,
action_value: str,
rendered_content: str,
) -> dict[str, Segment]:
return {
- cls._OUTPUT_FIELD_ACTION_ID: build_segment(action_id),
- cls._OUTPUT_FIELD_ACTION_VALUE: build_segment(action_value),
- cls._OUTPUT_FIELD_RENDERED_CONTENT: build_segment(rendered_content),
+ OUTPUT_FIELD_ACTION_ID: build_segment(action_id),
+ OUTPUT_FIELD_ACTION_VALUE: build_segment(action_value),
+ OUTPUT_FIELD_RENDERED_CONTENT: build_segment(rendered_content),
}
diff --git a/api/core/workflow/nodes/human_input/constants.py b/api/core/workflow/nodes/human_input/constants.py
new file mode 100644
index 00000000000..b8c84a9e0e7
--- /dev/null
+++ b/api/core/workflow/nodes/human_input/constants.py
@@ -0,0 +1,6 @@
+"""Dify-owned Human Input completion contract carried through Graphon."""
+
+OUTPUT_FIELD_ACTION_ID = "__action_id"
+OUTPUT_FIELD_ACTION_VALUE = "__action_value"
+OUTPUT_FIELD_RENDERED_CONTENT = "__rendered_content"
+TIMEOUT_HANDLE = "__timeout"
diff --git a/api/core/workflow/workflow_entry.py b/api/core/workflow/workflow_entry.py
index 4ce22fa23d8..873cd8607fb 100644
--- a/api/core/workflow/workflow_entry.py
+++ b/api/core/workflow/workflow_entry.py
@@ -15,12 +15,14 @@ from core.app.entities.app_invoke_entities import (
from core.app.file_access import DatabaseFileAccessController
from core.app.workflow.layers.observability import ObservabilityLayer
from core.credit_usage import CreditUsageAppType
+from core.repositories.human_input_repository import HumanInputFormSubmissionRepository
from core.workflow.node_factory import (
DifyGraphInitContext,
DifyNodeFactory,
is_start_node_type,
resolve_workflow_node_class,
)
+from core.workflow.nodes.human_input.boundary import HumanInputFormEventFilter
from core.workflow.system_variables import (
default_system_variables,
get_node_creation_preload_selectors,
@@ -70,7 +72,10 @@ def iter_dify_graph_engine_events(
yield from filter_graph_events(
engine.run(),
context=GraphEventFilterContext.from_engine(engine),
- filters=[response_stream_filter or ResponseStreamFilter()],
+ filters=[
+ HumanInputFormEventFilter(form_repository=HumanInputFormSubmissionRepository()),
+ response_stream_filter or ResponseStreamFilter(),
+ ],
)
diff --git a/api/tests/unit_tests/core/workflow/nodes/human_input/test_human_input_form_filled_event.py b/api/tests/unit_tests/core/workflow/nodes/human_input/test_human_input_form_filled_event.py
index 74b35217cae..d4de384c5a5 100644
--- a/api/tests/unit_tests/core/workflow/nodes/human_input/test_human_input_form_filled_event.py
+++ b/api/tests/unit_tests/core/workflow/nodes/human_input/test_human_input_form_filled_event.py
@@ -1,9 +1,46 @@
import datetime
-from collections.abc import Mapping
+import json
+from collections.abc import Generator, Iterable, Mapping, Sequence
+from contextlib import nullcontext
from types import SimpleNamespace
from typing import Any
+from unittest.mock import MagicMock, patch
-from core.app.entities.app_invoke_entities import DIFY_RUN_CONTEXT_KEY, InvokeFrom, UserFrom
+import pytest
+from flask import Flask
+from sqlalchemy.orm import Session
+
+from core.app.app_config.entities import WorkflowUIBasedAppConfig
+from core.app.apps.advanced_chat.generate_response_converter import AdvancedChatAppGenerateResponseConverter
+from core.app.apps.advanced_chat.generate_task_pipeline import (
+ AdvancedChatAppGenerateTaskPipeline,
+ ConversationSnapshot,
+ MessageSnapshot,
+ WorkflowSnapshot,
+)
+from core.app.apps.base_app_generator import BaseAppGenerator
+from core.app.apps.base_app_queue_manager import AppQueueManager
+from core.app.apps.workflow_app_runner import WorkflowBasedAppRunner
+from core.app.entities.app_invoke_entities import (
+ DIFY_RUN_CONTEXT_KEY,
+ AdvancedChatAppGenerateEntity,
+ InvokeFrom,
+ UserFrom,
+)
+from core.app.entities.queue_entities import (
+ AppQueueEvent,
+ QueueHumanInputFormFilledEvent,
+ QueueNodeSucceededEvent,
+ QueueWorkflowStartedEvent,
+ WorkflowQueueMessage,
+)
+from core.repositories.human_input_repository import (
+ HumanInputFormEntity,
+ HumanInputFormRecord,
+ HumanInputFormRepository,
+ HumanInputFormSubmissionRepository,
+)
+from core.workflow.nodes.human_input.boundary import HumanInputFormEventFilter
from core.workflow.nodes.human_input.callback import (
DifyHITLCallback,
)
@@ -17,20 +54,35 @@ from core.workflow.nodes.human_input.entities import (
UserActionConfig,
)
from core.workflow.nodes.human_input.enums import HumanInputFormStatus
-from core.workflow.system_variables import default_system_variables
-from graphon.entities import GraphInitParams
+from core.workflow.system_variables import build_system_variables
+from core.workflow.workflow_entry import WorkflowEntry, iter_dify_graph_engine_events
+from graphon.entities import GraphInitParams, WorkflowStartReason
from graphon.enums import BuiltinNodeTypes
from graphon.file import File, FileTransferMethod, FileType
+from graphon.filters import GraphEventFilterContext, filter_graph_events
+from graphon.graph import Graph
+from graphon.graph_engine import GraphEngine, GraphEngineConfig
+from graphon.graph_engine.command_channels import InMemoryChannel
from graphon.graph_events import (
- NodeRunStartedEvent,
- NodeRunSucceededEvent,
+ GraphEdgeSkippedEvent,
+ GraphEdgeTakenEvent,
+ GraphEngineEvent,
)
+from graphon.nodes.answer.answer_node import AnswerNode
+from graphon.nodes.answer.entities import AnswerNodeData
+from graphon.nodes.end.end_node import EndNode
+from graphon.nodes.end.entities import EndNodeData
from graphon.nodes.human_input.human_input_node import HumanInputNode
from graphon.nodes.protocols import FileReferenceFactoryProtocol
-from graphon.runtime import GraphRuntimeState, VariablePool
-from graphon.variables.segments import ArrayFileSegment, FileSegment, StringSegment
-from graphon.variables.types import SegmentType
+from graphon.nodes.start.entities import StartNodeData
+from graphon.nodes.start.start_node import StartNode
+from graphon.runtime import GraphRuntimeState, ReadOnlyGraphRuntimeStateWrapper, VariablePool
+from graphon.variables.segments import StringSegment
from libs.datetime_utils import naive_utc_now
+from libs.helper import compact_generate_response
+from models.account import Account
+from models.enums import MessageStatus
+from models.model import AppMode, Message
class _FakeFormRepository:
@@ -91,8 +143,11 @@ def _build_node(
"Attachment: {{#$output.attachment#}}\n"
"Attachments: {{#$output.attachments#}}"
),
+ *,
+ with_inputs: bool = True,
+ node_id: str = "node-1",
) -> HumanInputNode:
- system_variables = default_system_variables()
+ system_variables = build_system_variables(app_id="app", workflow_execution_id="run-1")
graph_runtime_state = GraphRuntimeState(
variable_pool=VariablePool.from_bootstrap(
system_variables=system_variables,
@@ -117,7 +172,7 @@ def _build_node(
)
config = {
- "id": "node-1",
+ "id": node_id,
"type": BuiltinNodeTypes.HUMAN_INPUT,
"data": {
"title": "Human Input",
@@ -166,6 +221,10 @@ def _build_node(
expiration_time=naive_utc_now() + datetime.timedelta(days=1),
)
+ if not with_inputs:
+ config["data"]["inputs"] = []
+ fake_form.submitted_data = {}
+
repo = _FakeFormRepository(fake_form)
return _create_human_input_node(
config=config,
@@ -175,8 +234,13 @@ def _build_node(
)
-def _build_timeout_node() -> HumanInputNode:
- system_variables = default_system_variables()
+def _build_timeout_node(
+ expiration_time: datetime.datetime | None = None,
+ *,
+ status: HumanInputFormStatus = HumanInputFormStatus.TIMEOUT,
+ node_id: str = "node-1",
+) -> HumanInputNode:
+ system_variables = build_system_variables(app_id="app", workflow_execution_id="run-1")
graph_runtime_state = GraphRuntimeState(
variable_pool=VariablePool.from_bootstrap(
system_variables=system_variables,
@@ -201,7 +265,7 @@ def _build_timeout_node() -> HumanInputNode:
)
config = {
- "id": "node-1",
+ "id": node_id,
"type": BuiltinNodeTypes.HUMAN_INPUT,
"data": {
"title": "Human Input",
@@ -217,8 +281,9 @@ def _build_timeout_node() -> HumanInputNode:
submitted=False,
selected_action_id=None,
submitted_data=None,
- status=HumanInputFormStatus.TIMEOUT,
- expiration_time=naive_utc_now() - datetime.timedelta(minutes=1),
+ status=status,
+ created_at=naive_utc_now(),
+ expiration_time=expiration_time or naive_utc_now() - datetime.timedelta(minutes=1),
)
repo = _FakeFormRepository(fake_form)
@@ -230,38 +295,328 @@ def _build_timeout_node() -> HumanInputNode:
)
-def test_human_input_node_emits_form_filled_event_before_succeeded():
+def _publish_node_events(node: HumanInputNode) -> list[AppQueueEvent]:
+ return _publish_graph_events(_filter_human_input_events(node.run(), node=node))
+
+
+def _filter_human_input_events(events: Iterable[GraphEngineEvent], *, node: HumanInputNode | None = None):
+ node = node or _build_node()
+ return filter_graph_events(
+ events,
+ context=GraphEventFilterContext(
+ graph=Graph(root_node=node),
+ runtime_state=ReadOnlyGraphRuntimeStateWrapper(node.graph_runtime_state),
+ ),
+ filters=[HumanInputFormEventFilter(form_repository=HumanInputFormSubmissionRepository())],
+ )
+
+
[email protected]("event_type", [GraphEdgeTakenEvent, GraphEdgeSkippedEvent])
+def test_human_input_filter_forwards_traversals_without_waiting_for_completion(event_type):
+ started, _ = list(_build_node().run())
+ edge = event_type(edge_id="human-answer", source_node_id="node-1", target_node_id="answer")
+ edge_forwarded = False
+
+ def source() -> Generator[GraphEngineEvent, None, None]:
+ yield started
+ yield edge
+ assert edge_forwarded, "The traversal must be forwarded before consuming more upstream events"
+
+ events = iter(_filter_human_input_events(source()))
+ assert next(events) == started
+ assert next(events) == edge
+ edge_forwarded = True
+ assert list(events) == []
+
+
+def test_form_events_keep_titles_for_interleaved_executions_of_one_node():
node = _build_node()
+ started, succeeded = list(node.run())
+ first_start = started.model_copy(update={"id": "first", "node_title": "First approval"})
+ second_start = started.model_copy(update={"id": "second", "node_title": "Second approval"})
+ first_result = succeeded.model_copy(update={"id": "first", "in_loop_id": "loop-1"})
+ second_result = succeeded.model_copy(update={"id": "second", "in_iteration_id": "iteration-2"})
+
+ events = _publish_graph_events(
+ _filter_human_input_events([first_start, second_start, second_result, first_result], node=node)
+ )
+
+ filled = [event for event in events if isinstance(event, QueueHumanInputFormFilledEvent)]
+ assert [(event.node_execution_id, event.node_title) for event in filled] == [
+ ("second", "Second approval"),
+ ("first", "First approval"),
+ ]
+ completed = [event for event in events if isinstance(event, QueueNodeSucceededEvent)]
+ assert [(event.node_execution_id, event.in_loop_id, event.in_iteration_id) for event in completed] == [
+ ("second", None, "iteration-2"),
+ ("first", "loop-1", None),
+ ]
+
+
+def _publish_graph_events(events: Iterable[GraphEngineEvent]) -> list[AppQueueEvent]:
+ published: list[AppQueueEvent] = []
+ queue_manager = MagicMock(spec=AppQueueManager)
+ queue_manager.publish.side_effect = lambda event, _publish_from: published.append(event)
+ runner = WorkflowBasedAppRunner(queue_manager=queue_manager, app_id="app")
+ workflow_entry = MagicMock(spec=WorkflowEntry)
+
+ for event in events:
+ runner._handle_event(workflow_entry, event)
+
+ return published
+
+
+def _sse_payloads(
+ events: Sequence[AppQueueEvent],
+ invoke_from: InvokeFrom,
+ app: Flask,
+ runtime_state: GraphRuntimeState | None = None,
+) -> list[dict[str, Any]]:
+ generate_entity = AdvancedChatAppGenerateEntity(
+ task_id="task-1",
+ app_config=WorkflowUIBasedAppConfig(
+ tenant_id="tenant",
+ app_id="app",
+ app_mode=AppMode.ADVANCED_CHAT,
+ workflow_id="workflow",
+ ),
+ inputs={},
+ query="hello",
+ files=[],
+ user_id="user",
+ stream=True,
+ invoke_from=invoke_from,
+ workflow_run_id="run-1",
+ )
+ if runtime_state is None:
+ runtime_state = GraphRuntimeState(
+ variable_pool=VariablePool.from_bootstrap(
+ system_variables=build_system_variables(workflow_execution_id="run-1")
+ ),
+ start_at=0,
+ )
+ queue_manager = MagicMock(spec=AppQueueManager)
+ queue_manager.invoke_from = invoke_from
+ queue_manager.graph_runtime_state = runtime_state
+ queue_manager.listen.return_value = iter(
+ WorkflowQueueMessage(task_id="task-1", app_mode=AppMode.ADVANCED_CHAT, event=event) for event in events
+ )
+ pipeline = AdvancedChatAppGenerateTaskPipeline(
+ application_generate_entity=generate_entity,
+ workflow=WorkflowSnapshot(id="workflow", tenant_id="tenant", features_dict={}),
+ queue_manager=queue_manager,
+ conversation=ConversationSnapshot(id="conversation-1", mode=AppMode.ADVANCED_CHAT),
+ message=MessageSnapshot(
+ id="message-1", query="hello", created_at=naive_utc_now(), status=MessageStatus.PAUSED, answer=""
+ ),
+ user=Account(name="tester", email="[email protected]"),
+ stream=True,
+ dialogue_count=1,
+ draft_var_saver_factory=MagicMock(),
+ )
+ session = MagicMock(spec=Session)
+ session.scalar.return_value = None
+ form = MagicMock(spec=HumanInputFormEntity)
+ form.id = "form-1"
+ form_repository = MagicMock(spec=HumanInputFormRepository)
+ form_repository.get_form.return_value = form
+
+ with (
+ app.test_request_context(),
+ patch.object(pipeline, "_database_session", return_value=nullcontext(session)),
+ patch.object(pipeline, "_get_message", return_value=Message(id="message-1", status=MessageStatus.PAUSED)),
+ patch(
+ "core.app.apps.advanced_chat.generate_task_pipeline.HumanInputFormRepositoryImpl",
+ return_value=form_repository,
+ ),
+ ):
+ if not any(isinstance(event, QueueWorkflowStartedEvent) for event in events):
+ list(
+ pipeline._handle_workflow_started_event(
+ QueueWorkflowStartedEvent(reason=WorkflowStartReason.RESUMPTION)
+ )
+ )
+ response = compact_generate_response(
+ BaseAppGenerator.convert_to_event_stream(
+ AdvancedChatAppGenerateResponseConverter.convert(
+ pipeline._to_stream_response(pipeline._process_stream_response()), invoke_from
+ )
+ )
+ )
+ assert response.mimetype == "text/event-stream"
+ return [
+ json.loads(line.removeprefix("data: ")) for line in response.get_data(as_text=True).splitlines() if line
+ ]
- events = list(node.run())
- assert isinstance(events[0], NodeRunStartedEvent)
- assert isinstance(events[1], NodeRunSucceededEvent)
[email protected]("invoke_from", [InvokeFrom.DEBUGGER, InvokeFrom.WEB_APP], ids=["full", "simple"])
+def test_submitted_human_input_reaches_response_stream(invoke_from: InvokeFrom, app: Flask):
+ events = _publish_node_events(_build_node())
- completed_event = events[1]
- assert completed_event.node_run_result.outputs["__rendered_content"] == StringSegment(
- value="Please enter your name:\n\nAlice\nDecision: approve\nAttachment: [file]\nAttachments: [1 files]"
+ payloads = _sse_payloads(events, invoke_from, app)
+
+ # Dify's original HumanInputNode (9c339239850) emitted the form event
+ # before node completion; its runner and task pipeline preserved that order.
+ assert [payload["event"] for payload in payloads] == [
+ "node_started",
+ "human_input_form_filled",
+ "node_finished",
+ ]
+ payload = payloads[1]
+ assert payload["workflow_run_id"] == "run-1"
+ assert payload["data"]["node_id"] == "node-1"
+ assert payload["data"]["node_title"] == "Human Input"
+ assert payload["data"]["action_id"] == "Accept"
+ assert payload["data"]["action_text"] == "Approve"
+ assert payload["data"]["rendered_content"] == (
+ "Please enter your name:\n\nAlice\nDecision: approve\nAttachment: [file]\nAttachments: [1 files]"
)
- assert completed_event.node_run_result.outputs["__action_id"] == StringSegment(value="Accept")
- assert completed_event.node_run_result.outputs["__action_value"] == StringSegment(value="Approve")
- assert completed_event.node_run_result.inputs["name"] == StringSegment(value="Alice")
- assert completed_event.node_run_result.inputs["decision"] == StringSegment(value="approve")
- assert isinstance(completed_event.node_run_result.inputs["attachment"], FileSegment)
- assert completed_event.node_run_result.inputs["attachment"].value_type == SegmentType.FILE
- assert completed_event.node_run_result.inputs["attachment"].value.filename == "resume.pdf"
- assert completed_event.node_run_result.inputs["attachment"].value.type == FileType.DOCUMENT
- assert completed_event.node_run_result.inputs["attachment"].value.transfer_method == FileTransferMethod.REMOTE_URL
- assert isinstance(completed_event.node_run_result.inputs["attachments"], ArrayFileSegment)
- assert completed_event.node_run_result.inputs["attachments"].value_type == SegmentType.ARRAY_FILE
- assert completed_event.node_run_result.inputs["attachments"].value[0].filename == "a.png"
- assert completed_event.node_run_result.inputs["attachments"].value[0].type == FileType.IMAGE
-
-
-def test_human_input_node_emits_timeout_event_before_succeeded():
- node = _build_timeout_node()
-
- events = list(node.run())
-
- assert isinstance(events[0], NodeRunStartedEvent)
- assert isinstance(events[1], NodeRunSucceededEvent)
- assert events[1].node_run_result.edge_source_handle == "__timeout"
+ submitted_data = payload["data"]["submitted_data"]
+ assert submitted_data["name"] == "Alice"
+ assert submitted_data["decision"] == "approve"
+ assert submitted_data["attachment"]["filename"] == "resume.pdf"
+ assert submitted_data["attachment"]["type"] == "document"
+ assert submitted_data["attachment"]["transfer_method"] == "remote_url"
+ assert submitted_data["attachments"][0]["filename"] == "a.png"
+ assert submitted_data["attachments"][0]["type"] == "image"
+
+
+def test_button_only_human_input_reaches_response_stream(app: Flask):
+ events = _publish_node_events(_build_node("Approve deployment?", with_inputs=False))
+
+ payloads = _sse_payloads(events, InvokeFrom.WEB_APP, app)
+
+ assert [payload["event"] for payload in payloads] == [
+ "node_started",
+ "human_input_form_filled",
+ "node_finished",
+ ]
+ assert payloads[1]["data"]["rendered_content"] == "Approve deployment?"
+ assert payloads[1]["data"]["submitted_data"] == {}
+ assert payloads[1]["data"]["action_id"] == "Accept"
+
+
[email protected]("status", [HumanInputFormStatus.TIMEOUT, HumanInputFormStatus.WAITING])
+def test_timed_out_human_input_reaches_response_stream(
+ status: HumanInputFormStatus, monkeypatch: pytest.MonkeyPatch, app: Flask
+):
+ expiration_time = datetime.datetime(2025, 1, 1)
+ form = MagicMock(spec=HumanInputFormRecord)
+ form.app_id = "app"
+ form.node_id = "node-1"
+ form.expiration_time = expiration_time
+ repository = MagicMock(spec=HumanInputFormSubmissionRepository)
+ earlier_form = SimpleNamespace(app_id="app", node_id="node-1", expiration_time=datetime.datetime(2024, 1, 1))
+ forms = {
+ "previous-execution": earlier_form,
+ "00000000-0000-4000-8000-000000000001": form,
+ }
+ repository.get_by_form_id.side_effect = forms.get
+ monkeypatch.setattr(HumanInputFormSubmissionRepository, "get_by_form_id", repository.get_by_form_id)
+
+ events = _publish_node_events(_build_timeout_node(expiration_time, status=status))
+
+ payloads = _sse_payloads(events, InvokeFrom.WEB_APP, app)
+ assert [payload["event"] for payload in payloads] == [
+ "node_started",
+ "human_input_form_timeout",
+ "node_finished",
+ ]
+ assert payloads[1]["data"] == {
+ "node_id": "node-1",
+ "node_title": "Human Input",
+ "expiration_time": 1735689600,
+ }
+
+
[email protected]("timed_out", [False, True])
[email protected]("terminal", ["end", "answer"])
+def test_human_input_completion_and_referenced_answer_reach_response_stream(
+ timed_out: bool, terminal: str, monkeypatch: pytest.MonkeyPatch, app: Flask
+):
+ expiration_time = datetime.datetime(2025, 1, 1)
+ node = (
+ _build_timeout_node(expiration_time, node_id="human")
+ if timed_out
+ else _build_node("Approve?", with_inputs=False, node_id="human")
+ )
+ runtime_state = node.graph_runtime_state
+ runtime_state.variable_pool.add(["sys", "workflow_execution_id"], StringSegment(value="run-1"))
+ init_params = GraphInitParams(workflow_id="workflow", graph_config={}, run_context={}, call_depth=0)
+ start = StartNode(
+ node_id="start",
+ data=StartNodeData(title="Start", variables=[]),
+ graph_init_params=init_params,
+ graph_runtime_state=runtime_state,
+ )
+ if terminal == "answer":
+ terminal_node = AnswerNode(
+ node_id="answer",
+ data=AnswerNodeData(title="Answer", answer="Action: {{#human.__action_id#}}"),
+ graph_init_params=init_params,
+ graph_runtime_state=runtime_state,
+ )
+ else:
+ terminal_node = EndNode(
+ node_id="end",
+ data=EndNodeData(title="End", outputs=[]),
+ graph_init_params=init_params,
+ graph_runtime_state=runtime_state,
+ )
+ graph = (
+ Graph.new()
+ .add_root(start)
+ .add_node(node, from_node_id="start")
+ .add_node(terminal_node, from_node_id=node.id, source_handle="__timeout" if timed_out else "Accept")
+ .build()
+ )
+ engine = GraphEngine(
+ workflow_id="workflow",
+ graph=graph,
+ graph_runtime_state=runtime_state,
+ command_channel=InMemoryChannel(),
+ config=GraphEngineConfig(min_workers=1, max_workers=1),
+ )
+ form = MagicMock(spec=HumanInputFormRecord)
+ form.app_id = "app"
+ form.node_id = node.id
+ form.expiration_time = expiration_time
+ repository = MagicMock(spec=HumanInputFormSubmissionRepository)
+ repository.get_by_form_id.return_value = form
+ monkeypatch.setattr(HumanInputFormSubmissionRepository, "get_by_form_id", repository.get_by_form_id)
+
+ events = _publish_graph_events(iter_dify_graph_engine_events(engine))
+ payloads = _sse_payloads(events, InvokeFrom.WEB_APP, app, runtime_state)
+
+ form_event = "human_input_form_timeout" if timed_out else "human_input_form_filled"
+ lifecycle_events = [payload for payload in payloads if payload["event"] != "message"]
+ assert [(payload["event"], payload.get("data", {}).get("node_id")) for payload in lifecycle_events] == [
+ ("workflow_started", None),
+ ("node_started", "start"),
+ ("node_finished", "start"),
+ ("node_started", node.id),
+ (form_event, node.id),
+ ("node_finished", node.id),
+ ("node_started", terminal),
+ ("node_finished", terminal),
+ ("message_end", None),
+ ("workflow_finished", None),
+ ]
+ answer = "".join(payload["answer"] for payload in payloads if payload["event"] == "message")
+ expected_answer = "Action: " + ("" if timed_out else "Accept")
+ assert answer == (expected_answer if terminal == "answer" else "")
+ assert payloads[-1]["data"]["status"] == "succeeded"
+
+
[email protected]("form_owner", [None, ("other-app", "node-1"), ("app", "other-node")])
+def test_timeout_rejects_missing_or_unrelated_form(form_owner: tuple[str, str] | None, monkeypatch: pytest.MonkeyPatch):
+ form = None
+ if form_owner is not None:
+ form = MagicMock(spec=HumanInputFormRecord)
+ form.app_id, form.node_id = form_owner
+ repository = MagicMock(spec=HumanInputFormSubmissionRepository)
+ repository.get_by_form_id.return_value = form
+ monkeypatch.setattr(HumanInputFormSubmissionRepository, "get_by_form_id", repository.get_by_form_id)
+
+ with pytest.raises(ValueError, match="Cannot resolve timed-out human input form"):
+ _publish_node_events(_build_timeout_node())
diff --git a/api/tests/unit_tests/core/workflow/test_workflow_entry_helpers.py b/api/tests/unit_tests/core/workflow/test_workflow_entry_helpers.py
index 5feb62d45f4..938fe289b0a 100644
--- a/api/tests/unit_tests/core/workflow/test_workflow_entry_helpers.py
+++ b/api/tests/unit_tests/core/workflow/test_workflow_entry_helpers.py
@@ -191,6 +191,11 @@ class TestWorkflowEntryRun:
"ResponseStreamFilter",
return_value=sentinel.response_stream_filter,
) as response_stream_filter_cls,
+ patch.object(
+ workflow_entry,
+ "HumanInputFormEventFilter",
+ return_value=sentinel.human_input_filter,
+ ),
patch.object(
workflow_entry,
"filter_graph_events",
@@ -205,7 +210,7 @@ class TestWorkflowEntryRun:
filter_graph_events.assert_called_once_with(
graph_engine.run.return_value,
context=sentinel.filter_context,
- filters=[sentinel.response_stream_filter],
+ filters=[sentinel.human_input_filter, sentinel.response_stream_filter],
)
def test_run_delegates_to_dify_event_iterator(self):