vellum-ai 0.12.15__py3-none-any.whl → 0.12.17__py3-none-any.whl

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

@@ -448,17 +448,8 @@ def test_serialize_workflow():
         ignore_order=True,
     )
 
-    assert not DeepDiff(
-        [
-            {"id": "148c61bd-e8b0-4d4b-8734-b043a72b90ed", "type": "GENERIC"},
-            {"id": "ed7caf01-9ae7-47a3-b15a-16697abaf486", "type": "GENERIC"},
-            {"id": "0d959311-c836-4641-a867-58f63df9dfea", "type": "GENERIC"},
-            {"id": "8df781b1-ff28-48a5-98a2-d7d796b932b0", "type": "GENERIC"},
-            {"id": "68c02b7c-5077-4087-803d-841474a8081f", "type": "GENERIC"},
-        ],
-        workflow_raw_data["nodes"][2:7],
-        ignore_order=True,
-    )
+    passthrough_nodes = [node for node in workflow_raw_data["nodes"] if node["type"] == "GENERIC"]
+    assert len(passthrough_nodes) == 5
 
     assert not DeepDiff(
         [

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

@@ -122,20 +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(
-        [
-            {"id": "1381c078-efa2-4255-89a1-7b4cb742c7fc", "type": "GENERIC"},
-            {"id": "1eee9b4e-531f-45f2-a4b9-42207fac2c33", "type": "GENERIC"},
-        ],
-        mocked_base_nodes,
-        ignore_order=True,
-    )
+    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

@@ -79,13 +79,7 @@ def test_serialize_workflow(vellum_client):
     }
 
     api_node = workflow_raw_data["nodes"][1]
-    assert not DeepDiff(
-        {
-            "id": "c2ed23f7-f6cb-4a56-a91c-2e5f9d8fda7f",
-            "type": "GENERIC",
-        },
-        api_node,
-    )
+    assert api_node["id"] == "c2ed23f7-f6cb-4a56-a91c-2e5f9d8fda7f"
 
     final_output_node = workflow_raw_data["nodes"][2]
     assert not DeepDiff(

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

@@ -148,7 +148,23 @@ def test_serialize_workflow():
                                 "bases": [],
                             },
                         },
-                        {"id": "1381c078-efa2-4255-89a1-7b4cb742c7fc", "type": "GENERIC"},
+                        {
+                            "id": "1381c078-efa2-4255-89a1-7b4cb742c7fc",
+                            "label": "StartNode",
+                            "type": "GENERIC",
+                            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                            "definition": {
+                                "name": "StartNode",
+                                "module": ["tests", "workflows", "basic_inline_subworkflow", "workflow"],
+                                "bases": [
+                                    {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]}
+                                ],
+                            },
+                            "trigger": {"id": "a95a34f2-e894-4fb6-a2c9-15d12c1e3135", "merge_behavior": "AWAIT_ANY"},
+                            "ports": [],
+                            "adornments": None,
+                            "attributes": [],
+                        },
                         {
                             "id": "a773c3a5-78cb-4250-8d29-7282e8a579d3",
                             "type": "TERMINAL",

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

@@ -133,7 +133,23 @@ def test_serialize_workflow():
                                 "bases": [],
                             },
                         },
-                        {"id": "baf6d316-dc75-41e8-96c0-015aede96309", "type": "GENERIC"},
+                        {
+                            "id": "baf6d316-dc75-41e8-96c0-015aede96309",
+                            "label": "Iteration",
+                            "type": "GENERIC",
+                            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                            "definition": {
+                                "name": "Iteration",
+                                "module": ["tests", "workflows", "basic_map_node", "workflow"],
+                                "bases": [
+                                    {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]}
+                                ],
+                            },
+                            "trigger": {"id": "01324747-9bc0-4ecd-a8ab-40dca5a94e2e", "merge_behavior": "AWAIT_ANY"},
+                            "ports": [],
+                            "adornments": None,
+                            "attributes": [],
+                        },
                         {
                             "id": "6f4883b2-70b1-4e1c-ae15-7d0f5aec810b",
                             "type": "TERMINAL",

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

@@ -69,15 +69,7 @@ def test_serialize_workflow__await_all():
     }
 
     passthrough_nodes = [node for node in workflow_raw_data["nodes"] if node["type"] == "GENERIC"]
-    assert not DeepDiff(
-        [
-            {"id": "127ef456-91bc-43c6-bd8b-1772db5e3cb5", "type": "GENERIC"},
-            {"id": "59243c65-053f-4ea6-9157-3f3edb1477bf", "type": "GENERIC"},
-            {"id": "634f0202-9ea9-4c62-b152-1a58c595cffb", "type": "GENERIC"},
-        ],
-        passthrough_nodes,
-        ignore_order=True,
-    )
+    assert len(passthrough_nodes) == 3
 
     merge_node = next(node for node in workflow_raw_data["nodes"] if node["type"] == "MERGE")
     assert not DeepDiff(

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

@@ -76,4 +76,4 @@ def test_serialize_workflow():
     }
 
     try_node = workflow_raw_data["nodes"][1]
-    assert try_node == {"id": "1381c078-efa2-4255-89a1-7b4cb742c7fc", "type": "GENERIC"}
+    assert try_node["id"] == "1381c078-efa2-4255-89a1-7b4cb742c7fc"

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

@@ -91,10 +91,7 @@ def test_serialize_workflow__missing_final_output_node():
     }
 
     passthrough_node = next(node for node in workflow_raw_data["nodes"] if node["type"] == "GENERIC")
-    assert passthrough_node == {
-        "id": "32d88cab-e9fa-4a56-9bc2-fb6e1fd0897f",
-        "type": "GENERIC",
-    }
+    assert passthrough_node["id"] == "32d88cab-e9fa-4a56-9bc2-fb6e1fd0897f"
 
     final_output_nodes = [node for node in workflow_raw_data["nodes"] if node["type"] == "TERMINAL"]
     assert not DeepDiff(

vellum_ee/workflows/display/types.py

@@ -36,8 +36,12 @@ class WorkflowDisplayContext(
     workflow_display_class: Type["BaseWorkflowDisplay"]
     workflow_display: WorkflowMetaDisplayType
     workflow_input_displays: Dict[WorkflowInputReference, WorkflowInputsDisplayType] = field(default_factory=dict)
+    global_workflow_input_displays: Dict[WorkflowInputReference, WorkflowInputsDisplayType] = field(
+        default_factory=dict
+    )
     node_displays: Dict[Type[BaseNode], "NodeDisplayType"] = field(default_factory=dict)
-    node_output_displays: Dict[OutputReference, Tuple[Type[BaseNode], "NodeOutputDisplay"]] = field(
+    global_node_displays: Dict[Type[BaseNode], NodeDisplayType] = field(default_factory=dict)
+    global_node_output_displays: Dict[OutputReference, Tuple[Type[BaseNode], "NodeOutputDisplay"]] = field(
         default_factory=dict
     )
     entrypoint_displays: Dict[Type[BaseNode], EntrypointDisplayType] = field(default_factory=dict)

vellum_ee/workflows/display/utils/vellum.py

@@ -58,13 +58,13 @@ def create_node_input_value_pointer_rule(
     value: Any, display_context: WorkflowDisplayContext
 ) -> NodeInputValuePointerRule:
     if isinstance(value, OutputReference):
-        upstream_node, output_display = display_context.node_output_displays[value]
-        upstream_node_display = display_context.node_displays[upstream_node]
+        upstream_node, output_display = display_context.global_node_output_displays[value]
+        upstream_node_display = display_context.global_node_displays[upstream_node]
         return NodeOutputPointer(
             data=NodeOutputData(node_id=str(upstream_node_display.node_id), output_id=str(output_display.id)),
         )
     if isinstance(value, WorkflowInputReference):
-        workflow_input_display = display_context.workflow_input_displays[value]
+        workflow_input_display = display_context.global_workflow_input_displays[value]
         return InputVariablePointer(data=InputVariableData(input_variable_id=str(workflow_input_display.id)))
     if isinstance(value, VellumSecretReference):
         # TODO: Pass through the name instead of retrieving the ID

vellum_ee/workflows/display/vellum.py

@@ -38,6 +38,10 @@ class NodeDisplayData(UniversalBaseModel):
     comment: Optional[NodeDisplayComment] = None
 
 
+class GenericNodeDisplayData(UniversalBaseModel):
+    position: NodeDisplayPosition = Field(default_factory=NodeDisplayPosition)
+
+
 class CodeResourceDefinition(UniversalBaseModel):
     name: str
     module: List[str]

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -1,9 +1,9 @@
 from abc import abstractmethod
-from copy import deepcopy
+from copy import copy
 from functools import cached_property
 import logging
 from uuid import UUID
-from typing import Any, Dict, Generic, Optional, Tuple, Type, get_args
+from typing import Any, Dict, Generic, Iterator, List, Optional, Tuple, Type, get_args
 
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.edges import Edge
@@ -71,6 +71,10 @@ class BaseWorkflowDisplay(
     # Used to store the mapping between workflows and their display classes
     _workflow_display_registry: Dict[Type[WorkflowType], Type["BaseWorkflowDisplay"]] = {}
 
+    _errors: List[Exception]
+
+    _dry_run: bool
+
     def __init__(
         self,
         workflow: Type[WorkflowType],
@@ -85,12 +89,15 @@ class BaseWorkflowDisplay(
                 EdgeDisplayType,
             ]
         ] = None,
+        dry_run: bool = False,
     ):
         self._workflow = workflow
         self._parent_display_context = parent_display_context
+        self._errors: List[Exception] = []
+        self._dry_run = dry_run
 
     @abstractmethod
-    def serialize(self, raise_errors: bool = True) -> JsonObject:
+    def serialize(self) -> JsonObject:
         pass
 
     @classmethod
@@ -110,7 +117,18 @@ class BaseWorkflowDisplay(
     def node_display_base_class(self) -> Type[NodeDisplayType]:
         pass
 
-    def _enrich_node_output_displays(
+    def add_error(self, error: Exception) -> None:
+        if self._dry_run:
+            self._errors.append(error)
+            return
+
+        raise error
+
+    @property
+    def errors(self) -> Iterator[Exception]:
+        return iter(self._errors)
+
+    def _enrich_global_node_output_displays(
         self,
         node: Type[BaseNode],
         node_display: NodeDisplayType,
@@ -126,7 +144,7 @@ class BaseWorkflowDisplay(
                 inner_node = get_wrapped_node(node)
                 if inner_node._is_wrapped_node:
                     inner_node_display = self._get_node_display(inner_node)
-                    self._enrich_node_output_displays(inner_node, inner_node_display, node_output_displays)
+                    self._enrich_global_node_output_displays(inner_node, inner_node_display, node_output_displays)
 
             # TODO: Make sure this output ID matches the workflow output ID of the subworkflow node's workflow
             # https://app.shortcut.com/vellum/story/5660/fix-output-id-in-subworkflow-nodes
@@ -174,19 +192,26 @@ class BaseWorkflowDisplay(
     ]:
         workflow_display = self._generate_workflow_meta_display()
 
-        # If we're dealing with a nested workflow, then it should have access to the outputs of all nodes
-        node_output_displays: Dict[OutputReference, Tuple[Type[BaseNode], NodeOutputDisplay]] = (
-            deepcopy(self._parent_display_context.node_output_displays) if self._parent_display_context else {}
+        global_node_output_displays: Dict[OutputReference, Tuple[Type[BaseNode], NodeOutputDisplay]] = (
+            copy(self._parent_display_context.global_node_output_displays) if self._parent_display_context else {}
         )
 
         node_displays: Dict[Type[BaseNode], NodeDisplayType] = {}
+
+        global_node_displays: Dict[Type[BaseNode], NodeDisplayType] = (
+            copy(self._parent_display_context.global_node_displays) if self._parent_display_context else {}
+        )
+
         port_displays: Dict[Port, PortDisplay] = {}
 
         # TODO: We should still serialize nodes that are in the workflow's directory but aren't used in the graph.
         # https://app.shortcut.com/vellum/story/5394
         for node in self._workflow.get_nodes():
+            if node in global_node_displays:
+                continue
             node_display = self._get_node_display(node)
             node_displays[node] = node_display
+            global_node_displays[node] = node_display
 
             # Nodes wrapped in a decorator need to be in our node display dictionary for later retrieval
             if has_wrapped_node(node):
@@ -195,22 +220,23 @@ class BaseWorkflowDisplay(
 
                 if inner_node._is_wrapped_node:
                     node_displays[inner_node] = inner_node_display
+                    global_node_displays[inner_node] = inner_node_display
 
-            self._enrich_node_output_displays(node, node_display, node_output_displays)
+            self._enrich_global_node_output_displays(node, node_display, global_node_output_displays)
             self._enrich_node_port_displays(node, node_display, port_displays)
 
+        workflow_input_displays: Dict[WorkflowInputReference, WorkflowInputsDisplayType] = {}
         # If we're dealing with a nested workflow, then it should have access to the inputs of its parents.
-        workflow_input_displays: Dict[WorkflowInputReference, WorkflowInputsDisplayType] = (
-            deepcopy(self._parent_display_context.workflow_input_displays) if self._parent_display_context else {}
+        global_workflow_input_displays = (
+            copy(self._parent_display_context.workflow_input_displays) if self._parent_display_context else {}
         )
         for workflow_input in self._workflow.get_inputs_class():
-            if workflow_input in workflow_input_displays:
-                continue
-
             workflow_input_display_overrides = self.inputs_display.get(workflow_input)
-            workflow_input_displays[workflow_input] = self._generate_workflow_input_display(
+            input_display = self._generate_workflow_input_display(
                 workflow_input, overrides=workflow_input_display_overrides
             )
+            workflow_input_displays[workflow_input] = input_display
+            global_workflow_input_displays[workflow_input] = input_display
 
         entrypoint_displays: Dict[Type[BaseNode], EntrypointDisplayType] = {}
         for entrypoint in self._workflow.get_entrypoints():
@@ -253,8 +279,10 @@ class BaseWorkflowDisplay(
         return WorkflowDisplayContext(
             workflow_display=workflow_display,
             workflow_input_displays=workflow_input_displays,
+            global_workflow_input_displays=global_workflow_input_displays,
             node_displays=node_displays,
-            node_output_displays=node_output_displays,
+            global_node_output_displays=global_node_output_displays,
+            global_node_displays=global_node_displays,
             entrypoint_displays=entrypoint_displays,
             workflow_output_displays=workflow_output_displays,
             edge_displays=edge_displays,

vellum_ee/workflows/display/workflows/get_vellum_workflow_display_class.py

@@ -10,6 +10,7 @@ def get_workflow_display(
     workflow_class: Type[WorkflowType],
     root_workflow_class: Optional[Type[WorkflowType]] = None,
     parent_display_context: Optional[WorkflowDisplayContext] = None,
+    dry_run: bool = False,
 ) -> WorkflowDisplayType:
     try:
         workflow_display_class = base_display_class.get_from_workflow_display_registry(workflow_class)
@@ -20,6 +21,7 @@ def get_workflow_display(
                 workflow_class=workflow_class.__bases__[0],
                 root_workflow_class=workflow_class if root_workflow_class is None else root_workflow_class,
                 parent_display_context=parent_display_context,
+                dry_run=dry_run,
             )
         except IndexError:
             return base_display_class(workflow_class)
@@ -27,4 +29,5 @@ def get_workflow_display(
     return workflow_display_class(  # type: ignore[return-value]
         workflow_class,
         parent_display_context=parent_display_context,
+        dry_run=dry_run,
     )

vellum_ee/workflows/display/workflows/vellum_workflow_display.py

@@ -53,7 +53,7 @@ class VellumWorkflowDisplay(
 ):
     node_display_base_class = BaseNodeVellumDisplay
 
-    def serialize(self, raise_errors: bool = True) -> JsonObject:
+    def serialize(self) -> JsonObject:
         input_variables: JsonArray = []
         for workflow_input, workflow_input_display in self.display_context.workflow_input_displays.items():
             default = primitive_to_vellum_value(workflow_input.instance) if workflow_input.instance else None
@@ -106,12 +106,9 @@ class VellumWorkflowDisplay(
 
             try:
                 serialized_node = node_display.serialize(self.display_context)
-            except NotImplementedError:
-                logger.warning("Unable to serialize node", extra={"node": node.__name__})
-                if raise_errors:
-                    raise
-                else:
-                    continue
+            except NotImplementedError as e:
+                self.add_error(e)
+                continue
 
             nodes.append(serialized_node)
 
@@ -205,7 +202,9 @@ class VellumWorkflowDisplay(
         # If there are terminal nodes with no workflow output reference,
         # raise a serialization error
         if len(unreferenced_final_output_node_outputs) > 0:
-            raise ValueError("Unable to serialize terminal nodes that are not referenced by workflow outputs.")
+            self.add_error(
+                ValueError("Unable to serialize terminal nodes that are not referenced by workflow outputs.")
+            )
 
         # Add an edge for each edge in the workflow
         all_edge_displays: List[EdgeVellumDisplay] = [