vellum-ai 0.12.14__py3-none-any.whl → 0.12.16__py3-none-any.whl

vellum_ee/workflows/display/nodes/vellum/base_node.py

@@ -0,0 +1,35 @@
+from typing import Any, Generic, TypeVar
+
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.types.core import JsonObject
+from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum_ee.workflows.display.vellum import GenericNodeDisplayData
+
+_BaseNodeType = TypeVar("_BaseNodeType", bound=BaseNode)
+
+
+class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeType]):
+    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+        node = self._node
+        node_id = self.node_id
+
+        return {
+            "id": str(node_id),
+            "label": node.__qualname__,
+            "type": "GENERIC",
+            "display_data": self.get_generic_node_display_data().dict(),
+            "definition": self.get_definition().dict(),
+            "trigger": {
+                "id": str(uuid4_from_hash(f"{node_id}|trigger")),
+                "merge_behavior": node.Trigger.merge_behavior.value,
+            },
+            "ports": [],
+            "adornments": None,
+            "attributes": [],
+        }
+
+    def get_generic_node_display_data(self) -> GenericNodeDisplayData:
+        explicit_value = self._get_explicit_node_display_attr("display_data", GenericNodeDisplayData)
+        return explicit_value if explicit_value else GenericNodeDisplayData()

vellum_ee/workflows/display/nodes/vellum/code_execution_node.py

@@ -70,8 +70,8 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
 
         packages = raise_if_descriptor(node.packages)
 
-        _, output_display = display_context.node_output_displays[node.Outputs.result]
-        _, log_output_display = display_context.node_output_displays[node.Outputs.log]
+        _, output_display = display_context.global_node_output_displays[node.Outputs.result]
+        _, log_output_display = display_context.global_node_output_displays[node.Outputs.log]
 
         output_type = primitive_type_to_vellum_variable_type(node.get_output_type())
 

vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -29,8 +29,8 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
         node_inputs, prompt_inputs = self._generate_node_and_prompt_inputs(node_id, node, display_context)
         input_variable_id_by_name = {prompt_input.key: prompt_input.id for prompt_input in prompt_inputs}
 
-        _, output_display = display_context.node_output_displays[node.Outputs.text]
-        _, array_display = display_context.node_output_displays[node.Outputs.results]
+        _, output_display = display_context.global_node_output_displays[node.Outputs.text]
+        _, array_display = display_context.global_node_output_displays[node.Outputs.results]
         node_blocks = raise_if_descriptor(node.blocks)
 
         return {

vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py

@@ -2,6 +2,7 @@ from uuid import UUID
 from typing import ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar, cast
 
 from vellum import VellumVariable
+from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes import InlineSubworkflowNode
 from vellum.workflows.types.core import JsonObject
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
@@ -60,12 +61,25 @@ class BaseInlineSubworkflowNodeDisplay(
         node: Type[InlineSubworkflowNode],
         display_context: WorkflowDisplayContext,
     ) -> Tuple[List[NodeInput], List[VellumVariable]]:
+        subworkflow = raise_if_descriptor(node.subworkflow)
+        subworkflow_inputs_class = subworkflow.get_inputs_class()
         subworkflow_inputs = raise_if_descriptor(node.subworkflow_inputs)
-        subworkflow_entries = (
-            [(variable_name, variable_value) for variable_name, variable_value in subworkflow_inputs.items()]
-            if isinstance(subworkflow_inputs, dict)
-            else [(variable_ref.name, variable_value) for variable_ref, variable_value in subworkflow_inputs]
-        )
+
+        if isinstance(subworkflow_inputs, BaseInputs):
+            subworkflow_entries = [
+                (variable_ref.name, variable_value) for variable_ref, variable_value in subworkflow_inputs
+            ]
+        elif isinstance(subworkflow_inputs, dict):
+            subworkflow_entries = [
+                (variable_name, variable_value) for variable_name, variable_value in subworkflow_inputs.items()
+            ]
+        else:
+            subworkflow_entries = [
+                (descriptor.name, getattr(subworkflow_inputs_class, descriptor.name))
+                for descriptor in subworkflow_inputs_class
+                if hasattr(subworkflow_inputs_class, descriptor.name)
+            ]
+
         node_inputs = [
             create_node_input(
                 node_id=node_id,
@@ -83,7 +97,7 @@ class BaseInlineSubworkflowNodeDisplay(
                 key=descriptor.name,
                 type=infer_vellum_variable_type(descriptor),
             )
-            for descriptor in raise_if_descriptor(node.subworkflow).get_inputs_class()
+            for descriptor in subworkflow_inputs_class
         ]
 
         return node_inputs, workflow_inputs

vellum_ee/workflows/display/nodes/vellum/map_node.py

@@ -33,6 +33,7 @@ class BaseMapNodeDisplay(BaseNodeVellumDisplay[_MapNodeType], Generic[_MapNodeTy
         subworkflow_display = get_workflow_display(
             base_display_class=display_context.workflow_display_class,
             workflow_class=subworkflow,
+            parent_display_context=display_context,
         )
         serialized_subworkflow = subworkflow_display.serialize()
 

vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py

@@ -38,8 +38,8 @@ class BasePromptDeploymentNodeDisplay(
             for variable_name, variable_value in prompt_inputs.items()
         ]
 
-        _, output_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.text)]
-        _, array_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.results)]
+        _, output_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.text)]
+        _, array_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.results)]
 
         # TODO: Pass through the name instead of retrieving the ID
         # https://app.shortcut.com/vellum/story/4702

vellum_ee/workflows/display/nodes/vellum/search_node.py

@@ -39,8 +39,10 @@ class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_Sea
         node_id = self.node_id
         node_inputs = self._generate_search_node_inputs(node_id, node, display_context)
 
-        _, results_output_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.results)]
-        _, text_output_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.text)]
+        _, results_output_display = display_context.global_node_output_displays[
+            cast(OutputReference, node.Outputs.results)
+        ]
+        _, text_output_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.text)]
 
         return {
             "id": str(node_id),

vellum_ee/workflows/display/nodes/vellum/templating_node.py

@@ -56,7 +56,7 @@ class BaseTemplatingNodeDisplay(BaseNodeVellumDisplay[_TemplatingNodeType], Gene
         # Misc type ignore is due to `node.Outputs` being generic
         # https://app.shortcut.com/vellum/story/4784
         output_descriptor = node.Outputs.result  # type: ignore [misc]
-        _, output_display = display_context.node_output_displays[output_descriptor]
+        _, output_display = display_context.global_node_output_displays[output_descriptor]
         inferred_output_type = primitive_type_to_vellum_variable_type(output_descriptor)
 
         return {

vellum_ee/workflows/display/nodes/vellum/tests/test_utils.py

@@ -91,18 +91,18 @@ def test_create_node_input_value_pointer_rules(
                 entrypoint_node_source_handle_id=uuid4(),
                 entrypoint_node_display=NodeDisplayData(),
             ),
-            workflow_input_displays={
+            global_workflow_input_displays={
                 cast(WorkflowInputReference, Inputs.example_workflow_input): WorkflowInputsVellumDisplayOverrides(
                     id=UUID("a154c29d-fac0-4cd0-ba88-bc52034f5470"),
                 ),
             },
-            node_output_displays={
+            global_node_output_displays={
                 cast(OutputReference, MyNodeA.Outputs.output): (
                     MyNodeA,
                     NodeOutputDisplay(id=UUID("4b16a629-11a1-4b3f-a965-a57b872d13b8"), name="output"),
                 ),
             },
-            node_displays={
+            global_node_displays={
                 MyNodeA: MyNodeADisplay(),
             },
         ),

vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/conftest.py

@@ -0,0 +1,28 @@
+import pytest
+from uuid import uuid4
+
+from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
+from vellum_ee.workflows.display.nodes.vellum.base_node import BaseNodeDisplay
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum_ee.workflows.display.vellum import NodeDisplayData, WorkflowMetaVellumDisplay
+from vellum_ee.workflows.display.workflows.vellum_workflow_display import VellumWorkflowDisplay
+
+
+@pytest.fixture()
+def serialize_node():
+    def _serialize_node(node_class) -> dict:
+        node_display_class = get_node_display_class(BaseNodeDisplay, node_class)
+        node_display = node_display_class()
+
+        context: WorkflowDisplayContext = WorkflowDisplayContext(
+            workflow_display_class=VellumWorkflowDisplay,
+            workflow_display=WorkflowMetaVellumDisplay(
+                entrypoint_node_id=uuid4(),
+                entrypoint_node_source_handle_id=uuid4(),
+                entrypoint_node_display=NodeDisplayData(),
+            ),
+            node_displays={node_class: node_display},
+        )
+        return node_display.serialize(context)
+
+    return _serialize_node

vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_trigger_serialization.py

@@ -0,0 +1,123 @@
+from deepdiff import DeepDiff
+
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.types.core import MergeBehavior
+
+
+class Inputs(BaseInputs):
+    input: str
+
+
+class BasicGenericNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        output = Inputs.input
+
+
+class AwaitAnyGenericNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        output = Inputs.input
+
+    class Trigger(BaseNode.Trigger):
+        merge_behavior = MergeBehavior.AWAIT_ANY
+
+
+class AwaitAllGenericNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        output = Inputs.input
+
+    class Trigger(BaseNode.Trigger):
+        merge_behavior = MergeBehavior.AWAIT_ALL
+
+
+def test_serialize_node__basic(serialize_node):
+    serialized_node = serialize_node(BasicGenericNode)
+    assert not DeepDiff(
+        {
+            "id": "c2ed23f7-f6cb-4a56-a91c-2e5f9d8fda7f",
+            "label": "BasicGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "definition": {
+                "name": "BasicGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_trigger_serialization",
+                ],
+                "bases": [{"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]}],
+            },
+            "trigger": {"id": "9d3a1b3d-4a38-4f2e-bbf1-dd8be152bce8", "merge_behavior": "AWAIT_ANY"},
+            "ports": [],
+            "adornments": None,
+            "attributes": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )
+
+
+def test_serialize_node__await_any(serialize_node):
+    serialized_node = serialize_node(AwaitAnyGenericNode)
+    assert not DeepDiff(
+        {
+            "id": "0ba67f76-aaff-4bd4-a20f-73a32ef5810d",
+            "label": "AwaitAnyGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "definition": {
+                "name": "AwaitAnyGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_trigger_serialization",
+                ],
+                "bases": [{"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]}],
+            },
+            "trigger": {"id": "ffa72187-9a18-453f-ae55-b77aad332630", "merge_behavior": "AWAIT_ANY"},
+            "ports": [],
+            "adornments": None,
+            "attributes": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )
+
+
+def test_serialize_node__await_all(serialize_node):
+    serialized_node = serialize_node(AwaitAllGenericNode)
+    assert not DeepDiff(
+        {
+            "id": "09d06cd3-06ea-40cc-afd8-17ad88542271",
+            "label": "AwaitAllGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "definition": {
+                "name": "AwaitAllGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_trigger_serialization",
+                ],
+                "bases": [{"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]}],
+            },
+            "trigger": {"id": "62074276-c817-476d-b59d-da523ae3f218", "merge_behavior": "AWAIT_ALL"},
+            "ports": [],
+            "adornments": None,
+            "attributes": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )

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

@@ -1,5 +1,4 @@
 import pytest
-from unittest import mock
 
 from deepdiff import DeepDiff
 
@@ -21,7 +20,6 @@ from vellum.workflows.expressions.less_than import LessThanExpression
 from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
 from vellum.workflows.expressions.not_between import NotBetweenExpression
 from vellum.workflows.expressions.not_in import NotInExpression
-from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
@@ -33,12 +31,7 @@ def test_serialize_workflow():
     # GIVEN a Workflow that uses a ConditionalNode
     # WHEN we serialize it
     workflow_display = get_workflow_display(base_display_class=VellumWorkflowDisplay, workflow_class=CategoryWorkflow)
-
-    # TODO: Support serialization of BaseNode
-    # https://app.shortcut.com/vellum/story/4871/support-serialization-of-base-node
-    with mock.patch.object(BaseNodeVellumDisplay, "serialize") as mocked_serialize:
-        mocked_serialize.return_value = {"type": "MOCKED"}
-        serialized_workflow: dict = workflow_display.serialize()
+    serialized_workflow: dict = workflow_display.serialize()
 
     # THEN we should get a serialized representation of the Workflow
     assert serialized_workflow.keys() == {
@@ -455,26 +448,8 @@ def test_serialize_workflow():
         ignore_order=True,
     )
 
-    assert not DeepDiff(
-        [
-            {
-                "type": "MOCKED",
-            },
-            {
-                "type": "MOCKED",
-            },
-            {
-                "type": "MOCKED",
-            },
-            {
-                "type": "MOCKED",
-            },
-            {
-                "type": "MOCKED",
-            },
-        ],
-        workflow_raw_data["nodes"][2:7],
-    )
+    passthrough_nodes = [node for node in workflow_raw_data["nodes"] if node["type"] == "GENERIC"]
+    assert len(passthrough_nodes) == 5
 
     assert not DeepDiff(
         [
@@ -917,12 +892,7 @@ def test_conditional_node_serialize_all_operators_with_lhs_and_rhs(descriptor, o
     workflow_cls = create_simple_workflow(descriptor)
 
     workflow_display = get_workflow_display(base_display_class=VellumWorkflowDisplay, workflow_class=workflow_cls)
-
-    # TODO: Support serialization of BaseNode
-    # https://app.shortcut.com/vellum/story/4871/support-serialization-of-base-node
-    with mock.patch.object(BaseNodeVellumDisplay, "serialize") as mocked_serialize:
-        mocked_serialize.return_value = {"type": "MOCKED"}
-        serialized_workflow: dict = workflow_display.serialize()
+    serialized_workflow: dict = workflow_display.serialize()
 
     # THEN we should get a serialized representation of the Workflow
     assert serialized_workflow.keys() == {
@@ -1041,12 +1011,7 @@ def test_conditional_node_serialize_all_operators_with_expression(descriptor, op
     workflow_cls = create_simple_workflow(descriptor)
 
     workflow_display = get_workflow_display(base_display_class=VellumWorkflowDisplay, workflow_class=workflow_cls)
-
-    # TODO: Support serialization of BaseNode
-    # https://app.shortcut.com/vellum/story/4871/support-serialization-of-base-node
-    with mock.patch.object(BaseNodeVellumDisplay, "serialize") as mocked_serialize:
-        mocked_serialize.return_value = {"type": "MOCKED"}
-        serialized_workflow: dict = workflow_display.serialize()
+    serialized_workflow: dict = workflow_display.serialize()
 
     # THEN we should get a serialized representation of the Workflow
     assert serialized_workflow.keys() == {
@@ -1152,12 +1117,7 @@ def test_conditional_node_serialize_all_operators_with_value_and_start_and_end(d
     workflow_cls = create_simple_workflow(descriptor)
 
     workflow_display = get_workflow_display(base_display_class=VellumWorkflowDisplay, workflow_class=workflow_cls)
-
-    # TODO: Support serialization of BaseNode
-    # https://app.shortcut.com/vellum/story/4871/support-serialization-of-base-node
-    with mock.patch.object(BaseNodeVellumDisplay, "serialize") as mocked_serialize:
-        mocked_serialize.return_value = {"type": "MOCKED"}
-        serialized_workflow: dict = workflow_display.serialize()
+    serialized_workflow: dict = workflow_display.serialize()
 
     # THEN we should get a serialized representation of the Workflow
     assert serialized_workflow.keys() == {

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

@@ -1,8 +1,5 @@
-from unittest import mock
-
 from deepdiff import DeepDiff
 
-from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
@@ -16,11 +13,7 @@ def test_serialize_workflow():
         base_display_class=VellumWorkflowDisplay, workflow_class=BasicErrorNodeWorkflow
     )
 
-    # TODO: Support serialization of BaseNode
-    # https://app.shortcut.com/vellum/story/4871/support-serialization-of-base-node
-    with mock.patch.object(BaseNodeVellumDisplay, "serialize") as mocked_serialize:
-        mocked_serialize.return_value = {"type": "MOCKED"}
-        serialized_workflow: dict = workflow_display.serialize()
+    serialized_workflow: dict = workflow_display.serialize()
 
     # THEN we should get a serialized representation of the Workflow
     assert serialized_workflow.keys() == {
@@ -129,23 +122,8 @@ def test_serialize_workflow():
         ignore_order=True,
     )
 
-    mocked_base_nodes = [
-        node
-        for i, node in enumerate(workflow_raw_data["nodes"])
-        if i != error_index and i != 0 and i != len(workflow_raw_data["nodes"]) - 1
-    ]
-
-    assert not DeepDiff(
-        [
-            {
-                "type": "MOCKED",
-            },
-            {
-                "type": "MOCKED",
-            },
-        ],
-        mocked_base_nodes,
-    )
+    passthrough_nodes = [node for node in workflow_raw_data["nodes"] if node["type"] == "GENERIC"]
+    assert len(passthrough_nodes) == 2
 
     terminal_node = workflow_raw_data["nodes"][-1]
     assert not DeepDiff(

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

@@ -0,0 +1,168 @@
+from deepdiff import DeepDiff
+
+from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_generic_node.workflow import BasicGenericNodeWorkflow
+
+
+def test_serialize_workflow(vellum_client):
+    # GIVEN a Workflow that uses a generic node
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay, workflow_class=BasicGenericNodeWorkflow
+    )
+
+    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",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+    assert not DeepDiff(
+        [
+            {
+                "id": "a07c2273-34a7-42b5-bcad-143b6127cc8a",
+                "key": "input",
+                "type": "STRING",
+                "default": None,
+                "required": True,
+                "extensions": {"color": None},
+            },
+        ],
+        input_variables,
+        ignore_order=True,
+    )
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 1
+    assert not DeepDiff(
+        [
+            {"id": "2b6389d0-266a-4be4-843e-4e543dd3d727", "key": "output", "type": "STRING"},
+        ],
+        output_variables,
+        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"]) == 2
+    assert len(workflow_raw_data["nodes"]) == 3
+
+    # AND each node should be serialized correctly
+    entrypoint_node = workflow_raw_data["nodes"][0]
+    assert entrypoint_node == {
+        "id": "f1e4678f-c470-400b-a40e-c8922cc99a86",
+        "type": "ENTRYPOINT",
+        "inputs": [],
+        "data": {"label": "Entrypoint Node", "source_handle_id": "40201804-8beb-43ad-8873-a027759512f1"},
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "definition": {
+            "name": "BaseNode",
+            "module": [
+                "vellum",
+                "workflows",
+                "nodes",
+                "bases",
+                "base",
+            ],
+            "bases": [],
+        },
+    }
+
+    api_node = workflow_raw_data["nodes"][1]
+    assert api_node["id"] == "c2ed23f7-f6cb-4a56-a91c-2e5f9d8fda7f"
+
+    final_output_node = workflow_raw_data["nodes"][2]
+    assert not DeepDiff(
+        {
+            "id": "50e3b446-afcd-4a5d-8c6f-5f05eaf2200e",
+            "type": "TERMINAL",
+            "data": {
+                "label": "Final Output",
+                "name": "output",
+                "target_handle_id": "8bd9f4f3-9f66-4d95-8e84-529b0002c531",
+                "output_id": "2b6389d0-266a-4be4-843e-4e543dd3d727",
+                "output_type": "STRING",
+                "node_input_id": "7a9f2d3a-0b23-4bd4-b567-e9493135b727",
+            },
+            "inputs": [
+                {
+                    "id": "7a9f2d3a-0b23-4bd4-b567-e9493135b727",
+                    "key": "node_input",
+                    "value": {
+                        "rules": [
+                            {
+                                "type": "NODE_OUTPUT",
+                                "data": {
+                                    "node_id": "c2ed23f7-f6cb-4a56-a91c-2e5f9d8fda7f",
+                                    "output_id": "0a9c7a80-fc89-4a71-aac0-66489e4ddb85",
+                                },
+                            }
+                        ],
+                        "combinator": "OR",
+                    },
+                }
+            ],
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "definition": {
+                "name": "FinalOutputNode",
+                "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
+                "bases": [
+                    {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"], "bases": []}
+                ],
+            },
+        },
+        final_output_node,
+        ignore_order=True,
+    )
+
+    # AND each edge should be serialized correctly
+    serialized_edges = workflow_raw_data["edges"]
+    assert not DeepDiff(
+        [
+            {
+                "id": "445dd2de-82b2-482b-89f6-5f49d8eb21a9",
+                "source_node_id": "f1e4678f-c470-400b-a40e-c8922cc99a86",
+                "source_handle_id": "40201804-8beb-43ad-8873-a027759512f1",
+                "target_node_id": "c2ed23f7-f6cb-4a56-a91c-2e5f9d8fda7f",
+                "target_handle_id": "b7bfb298-959a-4d2b-8b85-bbd0d2522703",
+                "type": "DEFAULT",
+            },
+            {
+                "id": "b741c861-cf67-4649-b9ef-b43a4add72b1",
+                "source_node_id": "c2ed23f7-f6cb-4a56-a91c-2e5f9d8fda7f",
+                "source_handle_id": "89dccfa5-cc1a-4612-bd87-86cb444f6dd4",
+                "target_node_id": "50e3b446-afcd-4a5d-8c6f-5f05eaf2200e",
+                "target_handle_id": "8bd9f4f3-9f66-4d95-8e84-529b0002c531",
+                "type": "DEFAULT",
+            },
+        ],
+        serialized_edges,
+        ignore_order=True,
+    )
+
+    # AND the display data should be what we expect
+    display_data = workflow_raw_data["display_data"]
+    assert display_data == {
+        "viewport": {
+            "x": 0.0,
+            "y": 0.0,
+            "zoom": 1.0,
+        }
+    }
+
+    # AND the definition should be what we expect
+    definition = workflow_raw_data["definition"]
+    assert definition == {
+        "name": "BasicGenericNodeWorkflow",
+        "module": ["tests", "workflows", "basic_generic_node", "workflow"],
+    }