vellum-ai 0.14.41__py3-none-any.whl → 1.11.2__py3-none-any.whl

vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_node_serialization.py

@@ -15,41 +15,7 @@ def test_serialize_workflow__missing_final_output_node():
     # WHEN we serialize it
     serialized_workflow: dict = workflow_display.serialize()
 
-    # THEN we should get a serialized representation of the Workflow
-    assert serialized_workflow.keys() == {
-        "workflow_raw_data",
-        "input_variables",
-        "state_variables",
-        "output_variables",
-    }
-
-    # AND its input variables should be what we expect
-    input_variables = serialized_workflow["input_variables"]
-    assert len(input_variables) == 2
-    assert not DeepDiff(
-        [
-            {
-                "id": "da086239-d743-4246-b666-5c91e22fb88c",
-                "key": "alpha",
-                "type": "STRING",
-                "required": True,
-                "default": None,
-                "extensions": {"color": None},
-            },
-            {
-                "id": "a8b6c5d4-a0e9-4457-834b-46b633c466a6",
-                "key": "beta",
-                "type": "STRING",
-                "required": True,
-                "default": None,
-                "extensions": {"color": None},
-            },
-        ],
-        input_variables,
-        ignore_order=True,
-    )
-
-    # AND its output variables should be what we expect
+    # THEN we should get a serialized representation its output variables to be what we expect
     output_variables = serialized_workflow["output_variables"]
     assert len(output_variables) == 2
     assert not DeepDiff(
@@ -61,44 +27,28 @@ def test_serialize_workflow__missing_final_output_node():
         ignore_order=True,
     )
 
-    # AND its raw data should be what we expect
-    workflow_raw_data = serialized_workflow["workflow_raw_data"]
-    assert workflow_raw_data.keys() == {"edges", "nodes", "display_data", "definition"}
-    assert len(workflow_raw_data["edges"]) == 3
-    assert len(workflow_raw_data["nodes"]) == 4
-
     # AND each node should be serialized correctly
-    entrypoint_node = workflow_raw_data["nodes"][0]
-    assert entrypoint_node == {
-        "id": "b109349f-ca1b-4a5a-a66e-a1321cf297f7",
-        "type": "ENTRYPOINT",
-        "inputs": [],
-        "data": {"label": "Entrypoint Node", "source_handle_id": "943ac183-d107-4604-aed1-619bd7fef09c"},
-        "display_data": {"position": {"x": 0.0, "y": 0.0}},
-        "base": None,
-        "definition": None,
-    }
-
-    passthrough_node = next(node for node in workflow_raw_data["nodes"] if node["type"] == "GENERIC")
-    assert passthrough_node["id"] == "32d88cab-e9fa-4a56-9bc2-fb6e1fd0897f"
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    assert isinstance(workflow_raw_data, dict)
 
+    # AND we should create synthetic terminal nodes for each output variable
     final_output_nodes = [node for node in workflow_raw_data["nodes"] if node["type"] == "TERMINAL"]
     assert not DeepDiff(
         [
             {
-                "id": "acc91103-f761-47a5-bdd4-0e5e7650bb30",
+                "id": "8683c087-4372-4357-bdd4-e13a50447d5e",
                 "type": "TERMINAL",
                 "data": {
                     "label": "First Final Output Node",
-                    "name": "first-final-output-node",
-                    "target_handle_id": "a0c2eb7a-398e-4f28-b63d-f3bae9b563ee",
-                    "output_id": "5517e50d-7f40-4f7c-acb2-e329d79a25bf",
+                    "name": "alpha",
+                    "target_handle_id": "438edefd-131d-4d00-8645-d0a7ea07029e",
+                    "output_id": "1d261e4b-4d77-4ace-9349-972129583519",
                     "output_type": "STRING",
-                    "node_input_id": "16363762-c14a-4162-8fab-525079d3cffe",
+                    "node_input_id": "ec1a9df2-a809-49fa-971b-8718df47e456",
                 },
                 "inputs": [
                     {
-                        "id": "16363762-c14a-4162-8fab-525079d3cffe",
+                        "id": "ec1a9df2-a809-49fa-971b-8718df47e456",
                         "key": "node_input",
                         "value": {
                             "rules": [
@@ -111,7 +61,7 @@ def test_serialize_workflow__missing_final_output_node():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 200.0, "y": 75.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -122,7 +72,7 @@ def test_serialize_workflow__missing_final_output_node():
                 },
                 "outputs": [
                     {
-                        "id": "5517e50d-7f40-4f7c-acb2-e329d79a25bf",
+                        "id": "1d261e4b-4d77-4ace-9349-972129583519",
                         "name": "value",
                         "type": "STRING",
                         "value": {
@@ -131,6 +81,11 @@ def test_serialize_workflow__missing_final_output_node():
                         },
                     }
                 ],
+                "trigger": {
+                    "id": "438edefd-131d-4d00-8645-d0a7ea07029e",
+                    "merge_behavior": "AWAIT_ANY",
+                },
+                "ports": [],
             },
             {
                 "id": "bb88768d-472e-4997-b7ea-de09163d1b4c",
@@ -152,8 +107,8 @@ def test_serialize_workflow__missing_final_output_node():
                                 {
                                     "type": "NODE_OUTPUT",
                                     "data": {
-                                        "node_id": "32d88cab-e9fa-4a56-9bc2-fb6e1fd0897f",
-                                        "output_id": "04df0e76-690a-4ae1-ab52-fe825a334dcc",
+                                        "node_id": "74b891e0-5573-4c7a-a0ef-c3c210187738",
+                                        "output_id": "ae21fc3f-dd81-4174-b08a-97bc96422a8f",
                                     },
                                 }
                             ],
@@ -161,7 +116,7 @@ def test_serialize_workflow__missing_final_output_node():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 400.0, "y": -50.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],

vellum_ee/workflows/display/tests/workflow_serialization/test_final_output_node_map_reference_serialization.py

@@ -0,0 +1,88 @@
+from typing import List
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes import MapNode
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.displayable import FinalOutputNode
+from vellum.workflows.outputs import BaseOutputs
+from vellum.workflows.state import BaseState
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+class TestInputs(BaseInputs):
+    items: List[str]
+
+
+class TestIteration(BaseNode):
+    item = MapNode.SubworkflowInputs.item
+    index = MapNode.SubworkflowInputs.index
+
+    class Outputs(BaseOutputs):
+        processed: str
+
+    def run(self) -> Outputs:
+        return self.Outputs(processed=f"processed_{self.item}_{self.index}")
+
+
+class TestIterationSubworkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
+    graph = TestIteration
+
+    class Outputs(BaseOutputs):
+        processed = TestIteration.Outputs.processed
+
+
+class TestMapNode(MapNode):
+    items = TestInputs.items
+    subworkflow = TestIterationSubworkflow
+
+
+class TestFinalOutputNode(FinalOutputNode[BaseState, List[str]]):
+    class Outputs(FinalOutputNode.Outputs):
+        value = TestMapNode.Outputs.processed
+
+
+class TestWorkflowWithFinalOutputReferencingMap(BaseWorkflow[TestInputs, BaseState]):
+    graph = TestMapNode >> TestFinalOutputNode
+
+    class Outputs(BaseOutputs):
+        final_result = TestFinalOutputNode.Outputs.value
+
+
+def test_serialize_workflow__final_output_node_referencing_map_node():
+    """
+    Test that final output nodes referencing map node outputs have correct outputs structure.
+
+    This test verifies that when a FinalOutputNode references a MapNode output,
+    the serialized output contains proper NODE_OUTPUT references instead of None values.
+    This addresses the Agent Builder issue where final outputs showed value=None in the UI.
+    """
+    workflow_display = get_workflow_display(workflow_class=TestWorkflowWithFinalOutputReferencingMap)
+
+    # WHEN we serialize it
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the final output node should have the correct outputs structure
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    map_node = next(node for node in workflow_raw_data["nodes"] if node["type"] == "MAP")
+    final_output_node = next(node for node in workflow_raw_data["nodes"] if node["type"] == "TERMINAL")
+
+    # AND the map node's subworkflow should have the one output variable
+    output_variable = next(iter(map_node["data"]["output_variables"]))
+    map_node_output_id = output_variable["id"]
+
+    # AND the final output node should have an outputs array with proper structure
+    assert "outputs" in final_output_node
+    outputs = final_output_node["outputs"]
+    assert len(outputs) == 1
+
+    output = outputs[0]
+    # AND the output should have the correct structure with NODE_OUTPUT reference instead of None
+    assert output["name"] == "value"
+    assert output["type"] == "JSON"
+
+    # AND the value should be a NODE_OUTPUT reference, not None
+    assert output["value"] is not None, f"Expected NODE_OUTPUT reference but got None. Full output: {output}"
+    assert output["value"]["type"] == "NODE_OUTPUT", f"Expected NODE_OUTPUT type but got {output['value']['type']}"
+    assert "node_id" in output["value"], f"Missing node_id in output value: {output['value']}"
+    assert output["value"]["node_output_id"] == map_node_output_id

vellum_ee/workflows/display/tests/workflow_serialization/test_integration_trigger_serialization.py

@@ -0,0 +1,306 @@
+"""Tests for IntegrationTrigger serialization."""
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.triggers.integration import IntegrationTrigger
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_vellum_integration_trigger_serialization():
+    """IntegrationTrigger subclass serializes with class name and module path."""
+
+    # Create a custom IntegrationTrigger subclass
+    class SlackMessageTrigger(IntegrationTrigger):
+        """Custom Slack message trigger."""
+
+        message: str
+        channel: str
+        user: str
+
+        class Config:
+            provider = "COMPOSIO"
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+            setup_attributes = {"team_id": "72485c1d-b72e-48e6-88de-a952968ae2a2"}
+
+    class ProcessNode(BaseNode):
+        """Node that processes the trigger."""
+
+        class Outputs(BaseNode.Outputs):
+            result = SlackMessageTrigger.message
+
+        def run(self) -> Outputs:
+            return self.Outputs()
+
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = SlackMessageTrigger >> ProcessNode
+
+    result: dict = get_workflow_display(workflow_class=TestWorkflow).serialize()
+
+    # Verify triggers field exists
+    assert "triggers" in result
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 1
+
+    trigger = triggers[0]
+    assert isinstance(trigger, dict)
+    assert trigger["type"] == "INTEGRATION"
+
+    # Check that attributes are serialized
+    assert "attributes" in trigger
+    attributes = trigger["attributes"]
+    assert isinstance(attributes, list)
+    assert len(attributes) == 3
+
+    attribute_names = {attr["key"] for attr in attributes if isinstance(attr, dict)}
+    assert attribute_names == {"message", "channel", "user"}
+
+    exec_config = trigger["exec_config"]
+    assert isinstance(exec_config, dict)
+    assert exec_config["type"] == "COMPOSIO"
+    assert exec_config["slug"] == "slack_new_message"
+    assert exec_config["integration_name"] == "SLACK"
+
+    setup_attributes = exec_config["setup_attributes"]
+    assert isinstance(setup_attributes, list)
+    assert len(setup_attributes) == 1
+    setup_attribute = setup_attributes[0]
+
+    assert setup_attribute["key"] == "team_id"
+    assert setup_attribute["type"] == "STRING"
+    assert setup_attribute["required"] is True
+
+    default_value = setup_attribute["default"]
+    assert isinstance(default_value, dict)
+    assert default_value["type"] == "STRING"
+    assert default_value["value"] == "72485c1d-b72e-48e6-88de-a952968ae2a2"
+    assert setup_attribute["extensions"] == {"color": None, "description": None}
+
+
+def test_vellum_integration_trigger_id_consistency():
+    """Validates trigger and attribute IDs match between definitions and references."""
+
+    class SlackMessageTrigger(IntegrationTrigger):
+        message: str
+        channel: str
+
+        class Config:
+            provider = "COMPOSIO"
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    class ProcessNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            msg_output = SlackMessageTrigger.message
+            channel_output = SlackMessageTrigger.channel
+
+        def run(self) -> Outputs:
+            return self.Outputs()
+
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = SlackMessageTrigger >> ProcessNode
+
+    result: dict = get_workflow_display(workflow_class=TestWorkflow).serialize()
+
+    # Get trigger definition IDs
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    trigger = triggers[0]
+    assert isinstance(trigger, dict)
+    trigger_id = trigger["id"]
+    trigger_attributes = trigger["attributes"]
+    assert isinstance(trigger_attributes, list)
+    trigger_attrs = {attr["key"]: attr["id"] for attr in trigger_attributes if isinstance(attr, dict)}
+
+    # Find node with trigger attribute references
+    workflow_raw_data = result["workflow_raw_data"]
+    assert isinstance(workflow_raw_data, dict)
+    nodes = workflow_raw_data["nodes"]
+    assert isinstance(nodes, list)
+    process_node = next(
+        (
+            n
+            for n in nodes
+            if isinstance(n, dict)
+            and isinstance(n.get("outputs"), list)
+            and any(
+                isinstance(o, dict)
+                and isinstance(o.get("value"), dict)
+                and o.get("value", {}).get("type") == "TRIGGER_ATTRIBUTE"
+                for o in n.get("outputs", [])
+            )
+        ),
+        None,
+    )
+    assert process_node, "No node found with trigger attribute references"
+
+    # Validate all trigger attribute references have matching IDs
+    attr_mapping = {"msg_output": "message", "channel_output": "channel"}
+    outputs = process_node["outputs"]
+    assert isinstance(outputs, list)
+    for output in outputs:
+        if not isinstance(output, dict):
+            continue
+        value = output.get("value", {})
+        if not isinstance(value, dict):
+            continue
+        if value.get("type") == "TRIGGER_ATTRIBUTE":
+            assert value["trigger_id"] == trigger_id, "Trigger ID mismatch"
+
+            output_name = output["name"]
+            expected_attr = attr_mapping[output_name]
+            expected_id = trigger_attrs[expected_attr]
+            assert value["attribute_id"] == expected_id, f"Attribute ID mismatch for {expected_attr}"
+
+
+def test_trigger_module_paths_are_canonical():
+    """Validates trigger module_path and class_name for consistent codegen."""
+
+    class TestSlackTrigger(IntegrationTrigger):
+        message: str
+
+        class Config:
+            provider = "COMPOSIO"
+            integration_name = "SLACK"
+            slug = "test_slack_trigger"
+
+    class SimpleNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result = TestSlackTrigger.message
+
+        def run(self) -> Outputs:
+            return self.Outputs()
+
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = TestSlackTrigger >> SimpleNode
+
+    result = get_workflow_display(workflow_class=TestWorkflow).serialize()
+
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    trigger = triggers[0]
+    assert isinstance(trigger, dict)
+    assert trigger["type"] == "INTEGRATION"
+
+
+def test_integration_trigger_no_entrypoint_node():
+    """IntegrationTrigger workflows now create ENTRYPOINT nodes and route edges through them."""
+
+    class SlackMessageTrigger(IntegrationTrigger):
+        message: str
+
+        class Config:
+            provider = "COMPOSIO"
+            integration_name = "SLACK"
+            slug = "slack_message"
+
+    class ProcessNode(BaseNode):
+        pass
+
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = SlackMessageTrigger >> ProcessNode
+
+    result = get_workflow_display(workflow_class=TestWorkflow).serialize()
+
+    # Get trigger ID
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 1
+    trigger = triggers[0]
+    assert isinstance(trigger, dict)
+    trigger_id = trigger["id"]
+
+    # Verify ENTRYPOINT node exists
+    workflow_raw_data = result["workflow_raw_data"]
+    assert isinstance(workflow_raw_data, dict)
+    nodes = workflow_raw_data["nodes"]
+    assert isinstance(nodes, list)
+    entrypoint_nodes = [n for n in nodes if isinstance(n, dict) and n.get("type") == "ENTRYPOINT"]
+    assert len(entrypoint_nodes) == 1, "IntegrationTrigger workflows should have an ENTRYPOINT node"
+
+    entrypoint_node = entrypoint_nodes[0]
+    assert isinstance(entrypoint_node, dict)
+    entrypoint_node_id = entrypoint_node["id"]
+
+    edges = workflow_raw_data["edges"]
+    assert isinstance(edges, list)
+    entrypoint_edges = [e for e in edges if isinstance(e, dict) and e.get("source_node_id") == entrypoint_node_id]
+    assert len(entrypoint_edges) == 0
+
+    # Verify edges use trigger ID as sourceNodeId (not ENTRYPOINT)
+    trigger_edges = [e for e in edges if isinstance(e, dict) and e.get("source_node_id") == trigger_id]
+    assert len(trigger_edges) > 0, "Should have edges from trigger ID"
+
+    # Verify the edge connects trigger to first node
+    # ProcessNode should be the only non-terminal, non-entrypoint node
+    process_nodes = [n for n in nodes if isinstance(n, dict) and n.get("type") not in ("TERMINAL", "ENTRYPOINT")]
+    assert len(process_nodes) > 0, "Should have at least one process node"
+    process_node = process_nodes[0]
+    assert isinstance(process_node, dict)
+    process_node_id = process_node["id"]
+
+    trigger_to_process_edge = next(
+        (e for e in trigger_edges if isinstance(e, dict) and e.get("target_node_id") == process_node_id),
+        None,
+    )
+    assert trigger_to_process_edge is not None, "Should have edge from trigger to ProcessNode"
+    assert isinstance(trigger_to_process_edge, dict)
+    assert trigger_to_process_edge["source_node_id"] == trigger_id
+    assert trigger_to_process_edge["target_node_id"] == process_node_id
+
+
+def test_integration_trigger_serialization_display_data():
+    """IntegrationTrigger with Display class serializes all display attributes correctly."""
+
+    # GIVEN an integration trigger with comprehensive Display attributes
+    class SlackMessageTriggerWithDisplay(IntegrationTrigger):
+        message: str
+        channel: str
+        user: str
+
+        class Config:
+            provider = "COMPOSIO"
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+        class Display(IntegrationTrigger.Display):
+            label = "Slack Message"
+            x = 150.5
+            y = 250.75
+            z_index = 5
+            icon = "vellum:icon:integrations/COMPOSIO/SLACK"
+            color = "#4A154B"
+
+    class ProcessNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result = SlackMessageTriggerWithDisplay.message
+
+        def run(self) -> Outputs:
+            return self.Outputs()
+
+    # AND a workflow that uses the trigger
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = SlackMessageTriggerWithDisplay >> ProcessNode
+
+    # WHEN we serialize the workflow
+    result: dict = get_workflow_display(workflow_class=TestWorkflow).serialize()
+
+    # THEN we get the expected trigger
+    assert "triggers" in result
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 1
+
+    trigger = triggers[0]
+    assert isinstance(trigger, dict)
+    assert trigger["type"] == "INTEGRATION"
+
+    # AND display_data is serialized with icon and color
+    assert "display_data" in trigger
+    display_data = trigger["display_data"]
+    assert isinstance(display_data, dict)
+    assert display_data["icon"] == "vellum:icon:integrations/COMPOSIO/SLACK"
+    assert display_data["color"] == "#4A154B"

vellum_ee/workflows/display/tests/workflow_serialization/test_integration_trigger_with_entrypoint_node_id.py

@@ -0,0 +1,88 @@
+"""Tests for IntegrationTrigger with explicit entrypoint_node_id serialization."""
+
+from uuid import uuid4
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.triggers.integration import IntegrationTrigger
+from vellum_ee.workflows.display.base import EdgeDisplay, EntrypointDisplay, WorkflowMetaDisplay
+from vellum_ee.workflows.display.editor.types import NodeDisplayData
+from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_integration_trigger_with_explicit_entrypoint_node_id():
+    """
+    Tests that a workflow with an IntegrationTrigger and explicit entrypoint_node_id
+    creates an ENTRYPOINT node using the explicit ID (not the trigger's ID).
+    """
+
+    class SlackMessageTrigger(IntegrationTrigger):
+        message: str
+
+        class Config:
+            provider = "COMPOSIO"
+            integration_name = "SLACK"
+            slug = "slack_message"
+
+    class ProcessNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result = SlackMessageTrigger.message
+
+        def run(self) -> Outputs:
+            return self.Outputs()
+
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = SlackMessageTrigger >> ProcessNode
+
+    explicit_entrypoint_node_id = uuid4()
+    explicit_entrypoint_source_handle_id = uuid4()
+
+    class TestWorkflowDisplay(BaseWorkflowDisplay[TestWorkflow]):
+        workflow_display = WorkflowMetaDisplay(
+            entrypoint_node_id=explicit_entrypoint_node_id,
+            entrypoint_node_source_handle_id=explicit_entrypoint_source_handle_id,
+            entrypoint_node_display=NodeDisplayData(),
+        )
+        entrypoint_displays = {
+            ProcessNode: EntrypointDisplay(
+                id=uuid4(),
+                edge_display=EdgeDisplay(id=uuid4()),
+            )
+        }
+
+    result: dict = get_workflow_display(workflow_class=TestWorkflow).serialize()
+
+    assert "workflow_raw_data" in result
+    workflow_raw_data = result["workflow_raw_data"]
+    assert isinstance(workflow_raw_data, dict)
+
+    assert "triggers" in result
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 1
+    trigger = triggers[0]
+    assert isinstance(trigger, dict)
+    trigger_id = trigger["id"]
+
+    nodes = workflow_raw_data["nodes"]
+    assert isinstance(nodes, list)
+
+    entrypoint_nodes = [n for n in nodes if isinstance(n, dict) and n.get("type") == "ENTRYPOINT"]
+
+    assert (
+        len(entrypoint_nodes) == 1
+    ), "IntegrationTrigger workflows with explicit entrypoint_node_id should create an ENTRYPOINT node"
+
+    entrypoint_node = entrypoint_nodes[0]
+    assert isinstance(entrypoint_node, dict)
+    entrypoint_node_id = entrypoint_node["id"]
+
+    assert entrypoint_node_id == str(explicit_entrypoint_node_id), (
+        f"Entrypoint node ID should be {explicit_entrypoint_node_id} from workflow_display, "
+        f"not {trigger_id} from trigger"
+    )
+
+    assert entrypoint_node_id != trigger_id, "Entrypoint node should not use the trigger's ID"