vellum-ai 0.14.44__py3-none-any.whl → 0.14.46__py3-none-any.whl

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

@@ -237,124 +237,86 @@ def test_serialize_node__stacked():
     exec_config = workflow_display.serialize()
 
     # THEN the workflow display is created successfully
+    assert isinstance(exec_config["workflow_raw_data"], dict)
+    assert isinstance(exec_config["workflow_raw_data"]["nodes"], list)
+    inner_stacked_generic_node = [
+        node
+        for node in exec_config["workflow_raw_data"]["nodes"]
+        if isinstance(node, dict) and node["type"] == "GENERIC"
+    ][0]
     assert not DeepDiff(
         {
-            "workflow_raw_data": {
-                "nodes": [
-                    {
-                        "id": "c14c1c9b-a7a4-4d2c-84fb-c940cfb09525",
-                        "type": "ENTRYPOINT",
-                        "inputs": [],
-                        "data": {
-                            "label": "Entrypoint Node",
-                            "source_handle_id": "51a5eb25-af14-4bee-9ced-d2aa534ea8e9",
-                        },
-                        "display_data": {"position": {"x": 0.0, "y": 0.0}},
-                        "base": None,
-                        "definition": None,
+            "id": "074833b0-e142-4bbc-8dec-209a35e178a3",
+            "label": "test_serialize_node__stacked.<locals>.InnerStackedGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "InnerStackedGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_adornments_serialization",
+                ],
+            },
+            "trigger": {
+                "id": "6e4af17f-bbee-4777-b10d-af042cd6e16a",
+                "merge_behavior": "AWAIT_ATTRIBUTES",
+            },
+            "ports": [{"id": "408cd5fb-3a3e-4eb2-9889-61111bd6a129", "name": "default", "type": "DEFAULT"}],
+            "adornments": [
+                {
+                    "id": "5be7d260-74f7-4734-b31b-a46a94539586",
+                    "label": "RetryNode",
+                    "base": {
+                        "name": "RetryNode",
+                        "module": ["vellum", "workflows", "nodes", "core", "retry_node", "node"],
                     },
-                    {
-                        "id": "074833b0-e142-4bbc-8dec-209a35e178a3",
-                        "label": "test_serialize_node__stacked.<locals>.InnerStackedGenericNode",
-                        "type": "GENERIC",
-                        "display_data": {"position": {"x": 0.0, "y": 0.0}},
-                        "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
-                        "definition": {
-                            "name": "InnerStackedGenericNode",
-                            "module": [
-                                "vellum_ee",
-                                "workflows",
-                                "display",
-                                "tests",
-                                "workflow_serialization",
-                                "generic_nodes",
-                                "test_adornments_serialization",
-                            ],
+                    "attributes": [
+                        {
+                            "id": "f388e93b-8c68-4f54-8577-bbd0c9091557",
+                            "name": "max_attempts",
+                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5.0}},
                         },
-                        "trigger": {
-                            "id": "6e4af17f-bbee-4777-b10d-af042cd6e16a",
-                            "merge_behavior": "AWAIT_ATTRIBUTES",
+                        {
+                            "id": "8a07dc58-3fed-41d4-8ca6-31ee0bb86c61",
+                            "name": "delay",
+                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                        },
+                        {
+                            "id": "c91782e3-140f-4938-9c23-d2a7b85dcdd8",
+                            "name": "retry_on_error_code",
+                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
                         },
-                        "ports": [{"id": "408cd5fb-3a3e-4eb2-9889-61111bd6a129", "name": "default", "type": "DEFAULT"}],
-                        "adornments": [
-                            {
-                                "id": "5be7d260-74f7-4734-b31b-a46a94539586",
-                                "label": "RetryNode",
-                                "base": {
-                                    "name": "RetryNode",
-                                    "module": ["vellum", "workflows", "nodes", "core", "retry_node", "node"],
-                                },
-                                "attributes": [
-                                    {
-                                        "id": "c91782e3-140f-4938-9c23-d2a7b85dcdd8",
-                                        "name": "retry_on_error_code",
-                                        "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
-                                    },
-                                    {
-                                        "id": "f388e93b-8c68-4f54-8577-bbd0c9091557",
-                                        "name": "max_attempts",
-                                        "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5}},
-                                    },
-                                    {
-                                        "id": "8a07dc58-3fed-41d4-8ca6-31ee0bb86c61",
-                                        "name": "delay",
-                                        "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
-                                    },
-                                    {
-                                        "id": "73a02e62-4535-4e1f-97b5-1264ca8b1d71",
-                                        "name": "retry_on_condition",
-                                        "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
-                                    },
-                                ],
-                            },
-                            {
-                                "id": "3344083c-a32c-4a32-920b-0fb5093448fa",
-                                "label": "TryNode",
-                                "base": {
-                                    "name": "TryNode",
-                                    "module": ["vellum", "workflows", "nodes", "core", "try_node", "node"],
-                                },
-                                "attributes": [
-                                    {
-                                        "id": "ab2fbab0-e2a0-419b-b1ef-ce11ecf11e90",
-                                        "name": "on_error_code",
-                                        "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
-                                    }
-                                ],
-                            },
-                        ],
-                        "attributes": [],
-                        "outputs": [],
+                        {
+                            "id": "73a02e62-4535-4e1f-97b5-1264ca8b1d71",
+                            "name": "retry_on_condition",
+                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                        },
+                    ],
+                },
+                {
+                    "id": "3344083c-a32c-4a32-920b-0fb5093448fa",
+                    "label": "TryNode",
+                    "base": {
+                        "name": "TryNode",
+                        "module": ["vellum", "workflows", "nodes", "core", "try_node", "node"],
                     },
-                ],
-                "edges": [
-                    {
-                        "id": "e8bd50dd-37a0-49b0-8b7b-f1dd8eb478b9",
-                        "source_node_id": "c14c1c9b-a7a4-4d2c-84fb-c940cfb09525",
-                        "source_handle_id": "51a5eb25-af14-4bee-9ced-d2aa534ea8e9",
-                        "target_node_id": "074833b0-e142-4bbc-8dec-209a35e178a3",
-                        "target_handle_id": "6e4af17f-bbee-4777-b10d-af042cd6e16a",
-                        "type": "DEFAULT",
-                    }
-                ],
-                "display_data": {"viewport": {"x": 0.0, "y": 0.0, "zoom": 1.0}},
-                "definition": {
-                    "name": "StackedWorkflow",
-                    "module": [
-                        "vellum_ee",
-                        "workflows",
-                        "display",
-                        "tests",
-                        "workflow_serialization",
-                        "generic_nodes",
-                        "test_adornments_serialization",
+                    "attributes": [
+                        {
+                            "id": "ab2fbab0-e2a0-419b-b1ef-ce11ecf11e90",
+                            "name": "on_error_code",
+                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                        }
                     ],
                 },
-            },
-            "input_variables": [],
-            "state_variables": [],
-            "output_variables": [],
+            ],
+            "attributes": [],
+            "outputs": [],
         },
-        exec_config,
-        ignore_order=True,
+        inner_stacked_generic_node,
     )

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

@@ -54,7 +54,6 @@ def test_serialize_workflow(vellum_client):
 
     # 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"]) == 4
     assert len(workflow_raw_data["nodes"]) == 5
 

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

@@ -40,7 +40,6 @@ def test_serialize_workflow_with_filepath():
 
     # 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
 
@@ -280,7 +279,6 @@ def test_serialize_workflow_with_code():
 
     # 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
 
@@ -508,7 +506,6 @@ def test_serialize_workflow__try_wrapped():
 
     # 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
 

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

@@ -95,7 +95,6 @@ def test_serialize_workflow():
 
     # 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"]) == 11
     assert len(workflow_raw_data["nodes"]) == 12
 
@@ -872,7 +871,6 @@ def test_conditional_node_serialize_all_operators_with_lhs_and_rhs(descriptor, o
 
     # 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"}
 
     # AND the conditional node should be what we expect
     conditional_node = workflow_raw_data["nodes"][1]
@@ -997,7 +995,6 @@ def test_conditional_node_serialize_all_operators_with_expression(descriptor, op
 
     # 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"}
 
     # AND the conditional node should be what we expect
     conditional_node = workflow_raw_data["nodes"][1]
@@ -1108,7 +1105,6 @@ def test_conditional_node_serialize_all_operators_with_value_and_start_and_end(d
 
     # 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"}
 
     # AND the conditional node should be what we expect
     conditional_node = workflow_raw_data["nodes"][1]

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

@@ -77,7 +77,6 @@ def test_serialize_workflow():
 
     # 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
 

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

@@ -55,7 +55,6 @@ def test_serialize_workflow():
 
     # 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"]) == 4
     assert len(workflow_raw_data["nodes"]) == 5
 

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

@@ -51,7 +51,6 @@ def test_serialize_workflow():
 
     # 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
 

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

@@ -53,7 +53,6 @@ def test_serialize_workflow():
 
     # AND its raw data is what we expect
     workflow_raw_data = serialized_workflow["workflow_raw_data"]
-    assert workflow_raw_data.keys() == {"nodes", "edges", "display_data", "definition"}
     assert len(workflow_raw_data["nodes"]) == 3
     assert len(workflow_raw_data["edges"]) == 2
 

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

@@ -67,7 +67,6 @@ def test_serialize_workflow():
 
     # 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
 
@@ -283,6 +282,24 @@ def test_serialize_workflow():
                         "name": "NestedWorkflow",
                         "module": ["tests", "workflows", "basic_inline_subworkflow", "workflow"],
                     },
+                    "output_values": [
+                        {
+                            "output_variable_id": "2fc57139-7420-49e5-96a6-dcbb3ff5d622",
+                            "value": {
+                                "type": "NODE_OUTPUT",
+                                "node_id": "1381c078-efa2-4255-89a1-7b4cb742c7fc",
+                                "node_output_id": "3f4c753e-f057-47bb-9748-7968283cc8aa",
+                            },
+                        },
+                        {
+                            "output_variable_id": "fad5dd9f-3328-4e70-ad55-65a5325a4a82",
+                            "value": {
+                                "type": "NODE_OUTPUT",
+                                "node_id": "1381c078-efa2-4255-89a1-7b4cb742c7fc",
+                                "node_output_id": "2a4a62b3-cd26-4d2c-b3f1-eaa5f9dd22dd",
+                            },
+                        },
+                    ],
                 },
                 "input_variables": [{"id": "704c4640-bfda-44f0-8da3-e9cfc4f21cf2", "key": "metro", "type": "STRING"}],
                 "output_variables": [
@@ -302,7 +319,6 @@ def test_serialize_workflow():
             "ports": [{"id": "cfd831bc-ee7f-44d0-8d76-0ba0cd0277dc", "name": "default", "type": "DEFAULT"}],
         },
         subworkflow_node,
-        ignore_order=True,
     )
 
     temperature_terminal_node = next(

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

@@ -54,7 +54,6 @@ def test_serialize_workflow():
 
     # 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
 
@@ -235,6 +234,16 @@ def test_serialize_workflow():
                             "workflow",
                         ],
                     },
+                    "output_values": [
+                        {
+                            "output_variable_id": "2a957315-fae0-4366-8a35-f0b315c5eade",
+                            "value": {
+                                "type": "NODE_OUTPUT",
+                                "node_id": "baf6d316-dc75-41e8-96c0-015aede96309",
+                                "node_output_id": "a7bcb362-a2b8-4476-b0de-a361efeec204",
+                            },
+                        }
+                    ],
                 },
                 "input_variables": [
                     {

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

@@ -36,7 +36,6 @@ def test_serialize_workflow__await_all():
 
     # 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"]) == 6
     assert len(workflow_raw_data["nodes"]) == 6
 

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

@@ -74,7 +74,6 @@ def test_serialize_workflow(vellum_client):
 
     # 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
 
@@ -101,7 +100,7 @@ def test_serialize_workflow(vellum_client):
         "type": "PROMPT",
         "inputs": [
             {
-                "id": "509cf3d4-db72-483e-897a-0f7f20e70d03",
+                "id": "947d7ead-0fad-4e5f-aa3a-d06029ac94bc",
                 "key": "city",
                 "value": {
                     "combinator": "OR",
@@ -116,7 +115,7 @@ def test_serialize_workflow(vellum_client):
                 },
             },
             {
-                "id": "7d6ec5ac-c582-4153-bd8a-b8794c367420",
+                "id": "3deebdd7-2900-4d8c-93f2-e5b90649ac42",
                 "key": "date",
                 "value": {
                     "combinator": "OR",

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

@@ -40,7 +40,6 @@ def test_serialize_workflow():
 
     # AND its raw data is what we expect
     workflow_raw_data = serialized_workflow["workflow_raw_data"]
-    assert workflow_raw_data.keys() == {"nodes", "edges", "display_data", "definition"}
     assert len(workflow_raw_data["nodes"]) == 3
     assert len(workflow_raw_data["edges"]) == 2
 

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

@@ -83,7 +83,6 @@ def test_serialize_workflow(vellum_client):
 
     # 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
 
@@ -110,7 +109,7 @@ def test_serialize_workflow(vellum_client):
         "type": "SUBWORKFLOW",
         "inputs": [
             {
-                "id": "dade23b9-dab6-4760-9247-da189f1019d2",
+                "id": "be426336-0844-4ebd-8cfe-efef60305b92",
                 "key": "city",
                 "value": {
                     "rules": [
@@ -123,7 +122,7 @@ def test_serialize_workflow(vellum_client):
                 },
             },
             {
-                "id": "8d73270e-2cf9-4146-b053-4780b99857a6",
+                "id": "8a7495b1-a7fc-405f-8ef6-ba05dd3f9e5c",
                 "key": "date",
                 "value": {
                     "rules": [

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

@@ -46,7 +46,6 @@ def test_serialize_workflow():
 
     # 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
 

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

@@ -44,7 +44,6 @@ def test_serialize_workflow():
 
     # 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"]) == 1
     assert len(workflow_raw_data["nodes"]) == 2
 
@@ -66,7 +65,7 @@ def test_serialize_workflow():
         "type": "TERMINAL",
         "data": {
             "label": "Basic Final Output Node",
-            "name": "basic-final-output-node",
+            "name": "value",
             "target_handle_id": "0173d3c6-11d1-44b7-b070-ca9ff5119046",
             "output_id": "aa63e3f6-fde3-4d19-84ef-29982d44d709",
             "output_type": "STRING",

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

@@ -47,7 +47,6 @@ def test_serialize_workflow():
 
     # 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
 

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,27 +27,11 @@ 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(
         [
@@ -90,7 +40,7 @@ def test_serialize_workflow__missing_final_output_node():
                 "type": "TERMINAL",
                 "data": {
                     "label": "First Final Output Node",
-                    "name": "first-final-output-node",
+                    "name": "alpha",
                     "target_handle_id": "a0c2eb7a-398e-4f28-b63d-f3bae9b563ee",
                     "output_id": "0cd02933-c5b9-47c9-aede-e97c5870e8aa",
                     "output_type": "STRING",

vellum_ee/workflows/display/types.py

@@ -1,11 +1,13 @@
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Dict, Tuple, Type
 
+from vellum.client import Vellum as VellumClient
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.events.workflow import WorkflowEventDisplayContext  # noqa: F401
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.ports import Port
 from vellum.workflows.references import OutputReference, StateValueReference, WorkflowInputReference
+from vellum.workflows.vellum_client import create_vellum_client
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.base import (
     EdgeDisplay,
@@ -35,6 +37,7 @@ PortDisplays = Dict[Port, PortDisplay]
 
 @dataclass
 class WorkflowDisplayContext:
+    client: VellumClient = field(default_factory=create_vellum_client)
     workflow_display_class: Type["BaseWorkflowDisplay"] = field(default_factory=get_default_workflow_display_class)
     workflow_display: WorkflowMetaDisplay = field(default_factory=lambda: WorkflowMetaDisplay.get_default(BaseWorkflow))
     workflow_input_displays: WorkflowInputsDisplays = field(default_factory=dict)