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

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"

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

@@ -0,0 +1,65 @@
+from typing import List
+
+from vellum import VellumDocument
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs import BaseInputs
+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 Inputs(BaseInputs):
+    documents: List[VellumDocument]
+
+
+class MyFinalOutputNode(FinalOutputNode):
+    class Outputs(BaseOutputs):
+        value = Inputs.documents
+
+
+class WorkflowWithListVellumDocument(BaseWorkflow[Inputs, BaseState]):
+    """A workflow that takes a list of VellumDocument as input."""
+
+    graph = MyFinalOutputNode
+
+    class Outputs(BaseOutputs):
+        result = MyFinalOutputNode.Outputs.value
+
+
+def test_serialize_workflow_with_list_vellum_document():
+    """Tests that we can serialize a workflow with List[VellumDocument] input."""
+
+    workflow_display = get_workflow_display(workflow_class=WorkflowWithListVellumDocument)
+
+    # 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",
+    }
+
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+
+    input_var = input_variables[0]
+    assert input_var["key"] == "documents"
+    assert input_var["type"] == "JSON"
+    # NOTE: Once custom type serialization is supported, we will want to represent this using an openapi spec
+    assert input_var["required"] is True
+    assert input_var["default"] is None
+    assert input_var["extensions"] == {"color": None}
+
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 1
+
+    output_var = output_variables[0]
+    assert output_var["key"] == "result"
+
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    assert len(workflow_raw_data["nodes"]) == 2
+    assert len(workflow_raw_data["edges"]) == 1

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

@@ -0,0 +1,110 @@
+import pytest
+
+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.base import BaseTrigger
+from vellum.workflows.triggers.manual import ManualTrigger
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_manual_trigger_serialization():
+    """Workflow with ManualTrigger serializes with triggers field."""
+
+    class SimpleNode(BaseNode):
+        pass
+
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = ManualTrigger >> SimpleNode
+
+    result = get_workflow_display(workflow_class=TestWorkflow).serialize()
+    assert "triggers" in result
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+
+    assert len(triggers) == 1
+    assert triggers[0] == {"id": "b3c8ab56-001f-4157-bbc2-4a7fe5ebf8c6", "type": "MANUAL", "attributes": []}
+
+
+def test_manual_trigger_multiple_entrypoints():
+    """ManualTrigger with multiple entrypoints."""
+
+    class NodeA(BaseNode):
+        pass
+
+    class NodeB(BaseNode):
+        pass
+
+    class MultiWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = ManualTrigger >> {NodeA, NodeB}
+
+    result = get_workflow_display(workflow_class=MultiWorkflow).serialize()
+    workflow_data = result["workflow_raw_data"]
+    assert isinstance(workflow_data, dict)
+    assert "nodes" in workflow_data
+    nodes = workflow_data["nodes"]
+    assert isinstance(nodes, list)
+
+    # entrypoint + 2 nodes
+    assert len(nodes) == 3
+
+    assert "triggers" in result
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+
+    assert len(triggers) == 1
+    assert triggers[0] == {"id": "b3c8ab56-001f-4157-bbc2-4a7fe5ebf8c6", "type": "MANUAL", "attributes": []}
+
+
+def test_unknown_trigger_type():
+    """Unknown trigger types raise ValueError."""
+
+    class UnknownTrigger(BaseTrigger):
+        pass
+
+    class SimpleNode(BaseNode):
+        pass
+
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = UnknownTrigger >> SimpleNode
+
+    with pytest.raises(ValueError, match="Unknown trigger type: UnknownTrigger"):
+        get_workflow_display(workflow_class=TestWorkflow).serialize()
+
+
+def test_manual_trigger_entrypoint_id_consistency():
+    """ManualTrigger ID matches entrypoint node ID for backward compatibility."""
+
+    class SimpleNode(BaseNode):
+        pass
+
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = ManualTrigger >> SimpleNode
+
+    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"]
+
+    # Get entrypoint node ID - ManualTrigger workflows still use ENTRYPOINT nodes
+    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["type"] == "ENTRYPOINT"]
+    assert len(entrypoint_nodes) == 1, "ManualTrigger workflows should have ENTRYPOINT node for backward compatibility"
+    entrypoint_id = entrypoint_nodes[0]["id"]
+
+    # Verify IDs match
+    assert trigger_id == entrypoint_id, (
+        f"ManualTrigger ID ({trigger_id}) must match entrypoint node ID ({entrypoint_id}) "
+        "to maintain trigger-entrypoint linkage"
+    )
+    # Also verify the expected UUID
+    assert trigger_id == "b3c8ab56-001f-4157-bbc2-4a7fe5ebf8c6"

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

@@ -0,0 +1,62 @@
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.map_node_with_terminal_nodes.workflow import MapNodeWithTerminalNodes
+
+
+def test_serialize_workflow__terminal_nodes_have_different_output_ids():
+    """
+    Tests that terminal nodes with the same base class serialize to different output IDs
+    when one is at the top level and one is inside a map node.
+    """
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=MapNodeWithTerminalNodes)
+    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",
+    }
+
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+
+    map_node = None
+    top_level_terminal_node = None
+
+    for node in workflow_raw_data["nodes"]:
+        if node["type"] == "MAP":
+            map_node = node
+        elif node["type"] == "TERMINAL":
+            top_level_terminal_node = node
+
+    assert map_node is not None, "Map node should be present"
+    assert top_level_terminal_node is not None, "Top-level terminal node should be present"
+
+    subworkflow_raw_data = map_node["data"]["workflow_raw_data"]
+    map_terminal_node = None
+
+    for node in subworkflow_raw_data["nodes"]:
+        if node["type"] == "TERMINAL":
+            map_terminal_node = node
+            break
+
+    assert map_terminal_node is not None, "Terminal node inside map should be present"
+
+    assert top_level_terminal_node["base"]["name"] == "FinalOutputNode", (
+        f"Top-level terminal should have base name 'FinalOutputNode', " f"got {top_level_terminal_node['base']['name']}"
+    )
+    assert map_terminal_node["base"]["name"] == "FinalOutputNode", (
+        f"Map terminal should have base name 'FinalOutputNode', " f"got {map_terminal_node['base']['name']}"
+    )
+
+    # THEN the top-level terminal node and the map's terminal node should have different output IDs
+    top_level_output_id = top_level_terminal_node["data"]["output_id"]
+    map_terminal_output_id = map_terminal_node["data"]["output_id"]
+
+    assert top_level_output_id != map_terminal_output_id, (
+        f"Terminal nodes should have different output IDs. "
+        f"Top-level: {top_level_output_id}, Map terminal: {map_terminal_output_id}"
+    )