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

vellum_ee/workflows/display/nodes/base_node_display.py

@@ -9,6 +9,7 @@ from typing import (
     ForwardRef,
     Generic,
     Optional,
+    Set,
     Tuple,
     Type,
     TypeVar,
@@ -24,6 +25,7 @@ from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.utils import get_unadorned_node, get_wrapped_node
 from vellum.workflows.ports import Port
 from vellum.workflows.references import OutputReference
+from vellum.workflows.references.node import NodeReference
 from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum.workflows.types.generics import NodeType
 from vellum.workflows.types.utils import get_original_base
@@ -33,7 +35,7 @@ from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_var
 from vellum_ee.workflows.display.editor.types import NodeDisplayComment, NodeDisplayData
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay, PortDisplayOverrides
-from vellum_ee.workflows.display.utils.expressions import serialize_condition, serialize_value
+from vellum_ee.workflows.display.utils.expressions import serialize_value
 from vellum_ee.workflows.display.utils.registry import register_node_display_class
 
 if TYPE_CHECKING:
@@ -98,11 +100,18 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
     # Default values set by the metaclass
     output_display: Dict[OutputReference, NodeOutputDisplay]
     port_displays: Dict[Port, PortDisplayOverrides] = {}
-    node_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
+    attribute_ids_by_name: ClassVar[Dict[str, UUID]] = {}
 
+    # START: Attributes for backwards compatible serialization
     # Used to explicitly set the target handle id for a node
     # Once all nodes are Generic Nodes, we may replace this with a trigger_id or trigger attribute
     target_handle_id: ClassVar[Optional[UUID]] = None
+    # Used to explicitly set the input ids for each node input
+    node_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
+    # Used by each class extending BaseNodeDisplay to specify which attributes are meant to be serialized
+    # as the former `"inputs"` field
+    __serializable_inputs__: Set[NodeReference] = set()
+    # END: Attributes for backwards compatible serialization
 
     def serialize(self, display_context: "WorkflowDisplayContext", **kwargs: Any) -> JsonObject:
         node = self._node
@@ -114,7 +123,11 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 # We don't need to serialize generic node attributes containing a subworkflow
                 continue
 
-            id = str(uuid4_from_hash(f"{node_id}|{attribute.name}"))
+            id = (
+                str(self.attribute_ids_by_name[attribute.name])
+                if self.attribute_ids_by_name
+                else str(uuid4_from_hash(f"{node_id}|{attribute.name}"))
+            )
             try:
                 attributes.append(
                     {
@@ -191,9 +204,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                         "id": id,
                         "name": port.name,
                         "type": port._condition_type.value,
-                        "expression": (
-                            serialize_condition(display_context, port._condition) if port._condition else None
-                        ),
+                        "expression": (serialize_value(display_context, port._condition) if port._condition else None),
                     }
                 )
             else:

vellum_ee/workflows/display/nodes/get_node_display_class.py

@@ -2,7 +2,6 @@ import types
 from uuid import UUID
 from typing import TYPE_CHECKING, Any, Dict, Generic, Type, TypeVar
 
-from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.types.generics import NodeType
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.utils.registry import get_from_node_display_registry
@@ -30,14 +29,14 @@ def get_node_display_class(node_class: Type[NodeType]) -> Type["BaseNodeDisplay"
                 node_input_ids_by_name.update(_get_node_input_ids_by_ref(f"{path}.{key}", value))
             return node_input_ids_by_name
 
-        if isinstance(inst, BaseDescriptor):
-            return {path: uuid4_from_hash(f"{node_class.__id__}|{path}")}
-
-        return {}
+        return {path: uuid4_from_hash(f"{node_class.__id__}|{path}")}
 
     def exec_body(ns: Dict):
         node_input_ids_by_name: Dict[str, UUID] = {}
         for ref in node_class:
+            if ref not in base_node_display_class.__serializable_inputs__:
+                continue
+
             node_input_ids_by_name.update(_get_node_input_ids_by_ref(ref.name, ref.instance))
 
         if node_input_ids_by_name:

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

@@ -20,6 +20,17 @@ class BaseAPINodeDisplay(BaseNodeDisplay[_APINodeType], Generic[_APINodeType]):
     # A mapping between node input keys and their ids for inputs representing additional header values
     additional_header_value_input_ids: ClassVar[Optional[Dict[str, UUID]]] = None
 
+    __serializable_inputs__ = {
+        APINode.url,
+        APINode.method,
+        APINode.json,
+        APINode.headers,
+        APINode.api_key_header_key,
+        APINode.api_key_header_value,
+        APINode.bearer_token_value,
+        APINode.authorization_type,
+    }
+
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs: Any
     ) -> JsonObject:

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

@@ -18,6 +18,11 @@ class BaseCodeExecutionNodeDisplay(BaseNodeDisplay[_CodeExecutionNodeType], Gene
     output_id: ClassVar[Optional[UUID]] = None
     log_output_id: ClassVar[Optional[UUID]] = None
 
+    __serializable_inputs__ = {
+        CodeExecutionNode.code,
+        CodeExecutionNode.code_inputs,
+    }
+
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:

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

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import ClassVar, Generic, Optional, TypeVar
+from typing import Any, ClassVar, Generic, Optional, TypeVar
 
 from vellum.workflows.nodes import ErrorNode
 from vellum.workflows.types.core import JsonObject
@@ -9,47 +9,53 @@ from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 
 _ErrorNodeType = TypeVar("_ErrorNodeType", bound=ErrorNode)
+LEGACY_INPUT_NAME = "error_source_input_id"
 
 
 class BaseErrorNodeDisplay(BaseNodeDisplay[_ErrorNodeType], Generic[_ErrorNodeType]):
+    # DEPRECATED: Remove in 0.15.0 once removed from the vellum-side
     error_output_id: ClassVar[Optional[UUID]] = None
+    # DEPRECATED: Remove in 0.15.0 once removed from the vellum-side
+    name: ClassVar[Optional[str]] = None
 
-    name: ClassVar[str] = "error-node"
+    __serializable_inputs__ = {ErrorNode.error}
 
-    def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
-    ) -> JsonObject:
+    def serialize(self, display_context: WorkflowDisplayContext, **kwargs) -> JsonObject:
         node_id = self.node_id
-        error_source_input_id = self.node_input_ids_by_name.get("error_source_input_id")
+        error_source_input_id = self.node_input_ids_by_name.get(
+            ErrorNode.error.name,
+        ) or self.node_input_ids_by_name.get(LEGACY_INPUT_NAME)
 
         error_attribute = raise_if_descriptor(self._node.error)
-        input_values_by_name = {
-            "error_source_input_id": error_attribute,
-        }
 
         node_inputs = [
             create_node_input(
                 node_id=node_id,
-                input_name=variable_name,
-                value=variable_value,
+                input_name=LEGACY_INPUT_NAME,
+                value=error_attribute,
                 display_context=display_context,
-                input_id=self.node_input_ids_by_name.get(variable_name),
+                input_id=error_source_input_id,
             )
-            for variable_name, variable_value in input_values_by_name.items()
         ]
 
-        return {
+        node_data: dict[str, Any] = {
             "id": str(node_id),
             "type": "ERROR",
             "inputs": [node_input.dict() for node_input in node_inputs],
             "data": {
-                "name": self.name,
                 "label": self.label,
                 "target_handle_id": str(self.get_target_handle_id()),
                 "error_source_input_id": str(error_source_input_id),
-                "error_output_id": str(self.error_output_id),
             },
             "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }
+
+        if self.name:
+            node_data["data"]["name"] = self.name
+
+        if self.error_output_id:
+            node_data["data"]["error_output_id"] = str(self.error_output_id)
+
+        return node_data

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

@@ -12,6 +12,8 @@ _GuardrailNodeType = TypeVar("_GuardrailNodeType", bound=GuardrailNode)
 
 
 class BaseGuardrailNodeDisplay(BaseNodeDisplay[_GuardrailNodeType], Generic[_GuardrailNodeType]):
+    __serializable_inputs__ = {GuardrailNode.metric_inputs}
+
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:

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

@@ -10,6 +10,7 @@ from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum_ee.workflows.display.utils.expressions import serialize_value
 from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
 from vellum_ee.workflows.display.vellum import NodeInput
 
@@ -17,6 +18,8 @@ _InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
 
 
 class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generic[_InlinePromptNodeType]):
+    __serializable_inputs__ = {InlinePromptNode.prompt_inputs}
+
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:
@@ -26,12 +29,14 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         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.global_node_output_displays[node.Outputs.text]
-        _, array_display = display_context.global_node_output_displays[node.Outputs.results]
-        _, json_display = display_context.global_node_output_displays[node.Outputs.json]
+        output_display = self.output_display[node.Outputs.text]
+        array_display = self.output_display[node.Outputs.results]
+        json_display = self.output_display[node.Outputs.json]
         node_blocks = raise_if_descriptor(node.blocks)
         function_definitions = raise_if_descriptor(node.functions)
 
+        ml_model = str(raise_if_descriptor(node.ml_model))
+
         blocks: list = [
             self._generate_prompt_block(block, input_variable_id_by_name, [i]) for i, block in enumerate(node_blocks)
         ]
@@ -42,7 +47,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         )
         blocks.extend(functions)
 
-        return {
+        serialized_node: JsonObject = {
             "id": str(node_id),
             "type": "PROMPT",
             "inputs": [node_input.dict() for node_input in node_inputs],
@@ -62,7 +67,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
                         "blocks": blocks,
                     },
                 },
-                "ml_model_name": raise_if_descriptor(node.ml_model),
+                "ml_model_name": ml_model,
             },
             "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
@@ -74,6 +79,10 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
             ],
             "ports": self.serialize_ports(display_context),
         }
+        attributes = self._serialize_attributes(display_context)
+        if attributes:
+            serialized_node["attributes"] = attributes
+        return serialized_node
 
     def _generate_node_and_prompt_inputs(
         self,
@@ -127,6 +136,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         path: List[int],
     ) -> JsonObject:
         block: JsonObject
+        block_id = uuid4_from_hash(f"{self.node_id}-{prompt_block.block_type}-{'-'.join([str(i) for i in path])}")
         if prompt_block.block_type == "JINJA":
             block = {
                 "block_type": "JINJA",
@@ -162,10 +172,21 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
             }
 
         elif prompt_block.block_type == "VARIABLE":
-            block = {
-                "block_type": "VARIABLE",
-                "input_variable_id": input_variable_id_by_name[prompt_block.input_variable],
-            }
+            input_variable_id = input_variable_id_by_name.get(prompt_block.input_variable)
+            if input_variable_id:
+                block = {
+                    "block_type": "VARIABLE",
+                    "input_variable_id": input_variable_id,
+                }
+            else:
+                # Even though this will likely fail in runtime, we want to allow serialization to succeed
+                # in case the block is work in progress or the node is not yet part of the graph
+                block = {
+                    "block_type": "VARIABLE",
+                    "input_variable_id": str(
+                        uuid4_from_hash(f"{block_id}-input_variable-{prompt_block.input_variable}")
+                    ),
+                }
 
         elif prompt_block.block_type == "PLAIN_TEXT":
             block = {
@@ -184,9 +205,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         else:
             raise NotImplementedError(f"Serialization for prompt block type {prompt_block.block_type} not implemented")
 
-        block["id"] = str(
-            uuid4_from_hash(f"{self.node_id}-{prompt_block.block_type}-{'-'.join([str(i) for i in path])}")
-        )
+        block["id"] = str(block_id)
         if prompt_block.cache_config:
             block["cache_config"] = prompt_block.cache_config.dict()
         else:
@@ -198,3 +217,18 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
             block["state"] = "ENABLED"
 
         return block
+
+    def _serialize_attributes(self, display_context: "WorkflowDisplayContext"):
+        attribute_instances_by_name = {}
+        for attribute in self._node:
+            if attribute.name in self.attribute_ids_by_name:
+                attribute_instances_by_name[attribute.name] = attribute.instance
+
+        return [
+            {
+                "id": str(attr_id),
+                "name": attr_name,
+                "value": serialize_value(display_context, attribute_instances_by_name[attr_name]),
+            }
+            for attr_name, attr_id in self.attribute_ids_by_name.items()
+        ]

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

@@ -21,6 +21,8 @@ class BaseInlineSubworkflowNodeDisplay(
 ):
     workflow_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
 
+    __serializable_inputs__ = {InlineSubworkflowNode.subworkflow_inputs}
+
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:

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

@@ -13,6 +13,8 @@ _MapNodeType = TypeVar("_MapNodeType", bound=MapNode)
 
 
 class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNodeType]):
+    __serializable_inputs__ = {MapNode.items}  # type: ignore[misc]
+
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:

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

@@ -13,6 +13,8 @@ _PromptDeploymentNodeType = TypeVar("_PromptDeploymentNodeType", bound=PromptDep
 
 
 class BasePromptDeploymentNodeDisplay(BaseNodeDisplay[_PromptDeploymentNodeType], Generic[_PromptDeploymentNodeType]):
+    __serializable_inputs__ = {PromptDeploymentNode.prompt_inputs}
+
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:

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

@@ -32,6 +32,14 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
     # A mapping between the id of the operand (e.g. "lhs_variable_id" or "rhs_variable_id") and the id of the node input
     # that the operand is pointing to.
     metadata_filter_input_id_by_operand_id: Dict[UUID, UUID] = {}
+    __serializable_inputs__ = {
+        SearchNode.query,
+        SearchNode.document_index,
+        SearchNode.weights,
+        SearchNode.chunk_separator,
+        SearchNode.limit,
+        SearchNode.result_merging,
+    }
 
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs

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

@@ -14,6 +14,7 @@ _SubworkflowDeploymentNodeType = TypeVar("_SubworkflowDeploymentNodeType", bound
 class BaseSubworkflowDeploymentNodeDisplay(
     BaseNodeDisplay[_SubworkflowDeploymentNodeType], Generic[_SubworkflowDeploymentNodeType]
 ):
+    __serializable_inputs__ = {SubworkflowDeploymentNode.subworkflow_inputs}
 
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs

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

@@ -15,6 +15,8 @@ TEMPLATE_INPUT_NAME = TemplatingNode.template.name
 
 
 class BaseTemplatingNodeDisplay(BaseNodeDisplay[_TemplatingNodeType], Generic[_TemplatingNodeType]):
+    __serializable_inputs__ = {TemplatingNode.inputs}
+
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:

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

@@ -29,7 +29,7 @@ def _display_class_with_node_input_ids_by_name_with_inputs_prefix(Node: Type[Cod
 @pytest.mark.parametrize(
     ["GetDisplayClass", "expected_input_id"],
     [
-        (_no_display_class, "e3cdb222-324e-4ad1-abb2-bdd7881b3a0e"),
+        (_no_display_class, "a5dbe403-0b00-4df6-b8f7-ed5f7794b003"),
         (_display_class_with_node_input_ids_by_name, "fba6a4d5-835a-4e99-afb7-f6a4aed15110"),
         (_display_class_with_node_input_ids_by_name_with_inputs_prefix, "fba6a4d5-835a-4e99-afb7-f6a4aed15110"),
     ],

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

@@ -41,3 +41,7 @@ def test_error_node_display__serialize_with_vellum_error() -> None:
             }
         ],
     }
+
+    # AND we serialize the DEPRECATED fields
+    assert "error_output_id" not in serialized_node["data"]
+    assert "name" not in serialized_node["data"]

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

@@ -5,6 +5,7 @@ from typing import Type
 
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.nodes import PromptDeploymentNode
+from vellum_ee.workflows.display.nodes.vellum.prompt_deployment_node import BasePromptDeploymentNodeDisplay
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 
@@ -13,14 +14,14 @@ def _no_display_class(Node: Type[PromptDeploymentNode]):  # type: ignore
 
 
 def _display_class_with_node_input_ids_by_name(Node: Type[PromptDeploymentNode]):
-    class PromptDeploymentNodeDisplay(PromptDeploymentNode[Node]):  # type: ignore[valid-type]
+    class PromptDeploymentNodeDisplay(BasePromptDeploymentNodeDisplay[Node]):  # type: ignore[valid-type]
         node_input_ids_by_name = {"foo": UUID("6037747a-1d35-4094-b363-4369fc92c5d4")}
 
     return PromptDeploymentNodeDisplay
 
 
 def _display_class_with_node_input_ids_by_name_with_inputs_prefix(Node: Type[PromptDeploymentNode]):
-    class PromptDeploymentNodeDisplay(PromptDeploymentNode[Node]):  # type: ignore[valid-type]
+    class PromptDeploymentNodeDisplay(BasePromptDeploymentNodeDisplay[Node]):  # type: ignore[valid-type]
         node_input_ids_by_name = {"prompt_inputs.foo": UUID("6037747a-1d35-4094-b363-4369fc92c5d4")}
 
     return PromptDeploymentNodeDisplay
@@ -51,7 +52,7 @@ def mock_fetch_deployment(mocker):
 @pytest.mark.parametrize(
     ["GetDisplayClass", "expected_input_id"],
     [
-        (_no_display_class, "6037747a-1d35-4094-b363-4369fc92c5d4"),
+        (_no_display_class, "016187d6-2830-4256-a61d-e52f9bf6355e"),
         (_display_class_with_node_input_ids_by_name, "6037747a-1d35-4094-b363-4369fc92c5d4"),
         (_display_class_with_node_input_ids_by_name_with_inputs_prefix, "6037747a-1d35-4094-b363-4369fc92c5d4"),
     ],

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

@@ -2,6 +2,7 @@ import pytest
 from uuid import UUID
 from typing import Type
 
+from vellum.client.types.variable_prompt_block import VariablePromptBlock
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
@@ -78,7 +79,7 @@ def _display_class_with_node_input_ids_by_name_with_inputs_prefix(Node: Type[Inl
 @pytest.mark.parametrize(
     ["GetDisplayClass", "expected_input_id"],
     [
-        (_no_display_class, "8aa4ce7f-5eb8-41b7-abd0-ea2b40c8fb88"),
+        (_no_display_class, "9b036991-67ff-4cd0-a4d7-b4ed581e8b6d"),
         (_display_class_with_node_input_ids_by_name, "fba6a4d5-835a-4e99-afb7-f6a4aed15110"),
         (_display_class_with_node_input_ids_by_name_with_inputs_prefix, "fba6a4d5-835a-4e99-afb7-f6a4aed15110"),
     ],
@@ -165,7 +166,7 @@ def test_serialize_node__prompt_inputs__state_reference():
             },
         },
         {
-            "id": "3750feb9-5d5c-4150-b62d-a9924f466888",
+            "id": "b83c40f7-0159-442f-af03-e80870363c52",
             "key": "bar",
             "value": {
                 "rules": [
@@ -181,3 +182,36 @@ def test_serialize_node__prompt_inputs__state_reference():
             },
         },
     ]
+
+
+def test_serialize_node__unreferenced_variable_block__still_serializes():
+    # GIVEN a prompt node with an unreferenced variable block
+    class MyPromptNode(InlinePromptNode):
+        blocks = [VariablePromptBlock(input_variable="foo")]
+
+    # AND a workflow with the prompt node
+    class MyWorkflow(BaseWorkflow):
+        graph = MyPromptNode
+
+    # WHEN the prompt node is serialized
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should skip the state reference input rule
+    assert serialized_workflow["workflow_raw_data"]["nodes"][1]["data"]["exec_config"]["prompt_template_block_data"][
+        "blocks"
+    ] == [
+        {
+            "id": "fecbb5f3-e0a3-42ed-9774-6c68fd5db50c",
+            "block_type": "VARIABLE",
+            "input_variable_id": "ea3f6348-8553-4375-bd27-527df4e4f3c2",
+            "state": "ENABLED",
+            "cache_config": None,
+        }
+    ]
+
+    # AND we should have a warning of the invalid reference
+    # TODO: Come up with a proposal for how nodes should propagate warnings
+    # warnings = list(workflow_display.errors)
+    # assert len(warnings) == 1
+    # assert "Missing input variable 'foo' for prompt block 0" in str(warnings[0])

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

@@ -4,7 +4,8 @@ from uuid import UUID, uuid4
 from typing import Type
 
 from vellum.workflows import BaseWorkflow
-from vellum.workflows.nodes import SubworkflowDeploymentNode
+from vellum.workflows.nodes.displayable.subworkflow_deployment_node.node import SubworkflowDeploymentNode
+from vellum_ee.workflows.display.nodes.vellum.subworkflow_deployment_node import BaseSubworkflowDeploymentNodeDisplay
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 
@@ -13,14 +14,14 @@ def _no_display_class(Node: Type[SubworkflowDeploymentNode]):  # type: ignore
 
 
 def _display_class_with_node_input_ids_by_name(Node: Type[SubworkflowDeploymentNode]):
-    class SubworkflowNodeDisplay(SubworkflowDeploymentNode[Node]):  # type: ignore[valid-type]
+    class SubworkflowNodeDisplay(BaseSubworkflowDeploymentNodeDisplay[Node]):  # type: ignore[valid-type]
         node_input_ids_by_name = {"foo": UUID("aff4f838-577e-44b9-ac5c-6d8213abbb9c")}
 
     return SubworkflowNodeDisplay
 
 
 def _display_class_with_node_input_ids_by_name_with_inputs_prefix(Node: Type[SubworkflowDeploymentNode]):
-    class SubworkflowNodeDisplay(SubworkflowDeploymentNode[Node]):  # type: ignore[valid-type]
+    class SubworkflowNodeDisplay(BaseSubworkflowDeploymentNodeDisplay[Node]):  # type: ignore[valid-type]
         node_input_ids_by_name = {"subworkflow_inputs.foo": UUID("aff4f838-577e-44b9-ac5c-6d8213abbb9c")}
 
     return SubworkflowNodeDisplay
@@ -55,7 +56,7 @@ def mock_fetch_deployment(mocker):
 @pytest.mark.parametrize(
     ["GetDisplayClass", "expected_input_id"],
     [
-        (_no_display_class, "aff4f838-577e-44b9-ac5c-6d8213abbb9c"),
+        (_no_display_class, "394132c2-1817-455e-9f3f-b7073eb63a2b"),
         (_display_class_with_node_input_ids_by_name, "aff4f838-577e-44b9-ac5c-6d8213abbb9c"),
         (_display_class_with_node_input_ids_by_name_with_inputs_prefix, "aff4f838-577e-44b9-ac5c-6d8213abbb9c"),
     ],

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

@@ -29,7 +29,7 @@ def _display_class_with_node_input_ids_by_name_with_inputs_prefix(Node: Type[Tem
 @pytest.mark.parametrize(
     ["GetDisplayClass", "expected_input_id"],
     [
-        (_no_display_class, "d3519cec-590c-416d-8eb1-96051aed5ddd"),
+        (_no_display_class, "91d982a9-6c41-42ac-aff9-7b623c450a55"),
         (_display_class_with_node_input_ids_by_name, "fba6a4d5-835a-4e99-afb7-f6a4aed15110"),
         (_display_class_with_node_input_ids_by_name_with_inputs_prefix, "fba6a4d5-835a-4e99-afb7-f6a4aed15110"),
     ],

vellum_ee/workflows/display/tests/test_base_workflow_display.py

@@ -3,6 +3,8 @@ from typing import Dict
 
 from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes import BaseNode
+from vellum.workflows.ports.port import Port
+from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state import BaseState
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.vellum import WorkflowInputsVellumDisplayOverrides
@@ -285,3 +287,45 @@ def test_vellum_workflow_display__serialize_with_parse_json_expression():
             "operator": "parseJson",
         },
     }
+
+
+def test_serialize__port_with_lazy_reference():
+    # GIVEN a node with a lazy reference in a Port
+    class MyNode(BaseNode):
+        class Ports(BaseNode.Ports):
+            foo = Port.on_if(LazyReference(lambda: MyNode.Outputs.bar))
+
+        class Outputs(BaseNode.Outputs):
+            bar: bool
+
+    # AND a workflow that uses the node
+    class Workflow(BaseWorkflow):
+        graph = MyNode
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=Workflow)
+    exec_config = workflow_display.serialize()
+
+    # THEN the lazy reference should be serialized correctly
+    raw_data = exec_config["workflow_raw_data"]
+    assert isinstance(raw_data, dict)
+
+    nodes = raw_data["nodes"]
+    assert isinstance(nodes, list)
+
+    my_node = nodes[1]
+    assert isinstance(my_node, dict)
+    ports = my_node.get("ports")
+    assert isinstance(ports, list)
+    assert ports == [
+        {
+            "id": "6c26bc2b-6469-47c1-b858-d63f0d311ea6",
+            "name": "foo",
+            "type": "IF",
+            "expression": {
+                "type": "NODE_OUTPUT",
+                "node_id": str(MyNode.__id__),
+                "node_output_id": str(MyNode.__output_ids__["bar"]),
+            },
+        }
+    ]

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

@@ -87,7 +87,7 @@ def test_serialize_workflow():
             "type": "ERROR",
             "inputs": [
                 {
-                    "id": "690d825f-6ffd-493e-8141-c86d384e6150",
+                    "id": "8e4c8d76-2e02-4d7e-a7bf-d71af392dc49",
                     "key": "error_source_input_id",
                     "value": {
                         "rules": [
@@ -101,11 +101,9 @@ def test_serialize_workflow():
                 }
             ],
             "data": {
-                "name": "error-node",
                 "label": "Fail Node",
                 "target_handle_id": "70c19f1c-309c-4a5d-ba65-664c0bb2fedf",
-                "error_source_input_id": "None",
-                "error_output_id": "None",
+                "error_source_input_id": "8e4c8d76-2e02-4d7e-a7bf-d71af392dc49",
             },
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {