vellum-ai 0.13.0__py3-none-any.whl → 0.13.2__py3-none-any.whl

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

@@ -1,12 +1,11 @@
-from typing import Any, Generic, TypeVar
+from typing import Any, Generic, TypeVar, cast
 
+from vellum.workflows.constants import UNDEF
 from vellum.workflows.descriptors.base import BaseDescriptor
-from vellum.workflows.expressions.and_ import AndExpression
 from vellum.workflows.expressions.between import BetweenExpression
 from vellum.workflows.expressions.is_not_null import IsNotNullExpression
 from vellum.workflows.expressions.is_null import IsNullExpression
 from vellum.workflows.expressions.not_between import NotBetweenExpression
-from vellum.workflows.expressions.or_ import OrExpression
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.references.execution_count import ExecutionCountReference
 from vellum.workflows.references.output import OutputReference
@@ -14,6 +13,7 @@ from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.references.workflow_input import WorkflowInputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.vellum.utils import convert_descriptor_to_operator
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -28,6 +28,18 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
         node = self._node
         node_id = self.node_id
 
+        attributes: JsonArray = []
+        for attribute in node:
+            id = str(uuid4_from_hash(f"{node_id}|{attribute.name}"))
+
+            attributes.append(
+                {
+                    "id": id,
+                    "name": attribute.name,
+                    "value": self.serialize_value(display_context, cast(BaseDescriptor, attribute.instance)),
+                }
+            )
+
         ports: JsonArray = []
         for idx, port in enumerate(node.Ports):
             id = str(uuid4_from_hash(f"{node_id}|{idx}"))
@@ -36,6 +48,7 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
                 ports.append(
                     {
                         "id": id,
+                        "name": port.name,
                         "type": port._condition_type.value,
                         "expression": (
                             self.serialize_condition(display_context, port._condition) if port._condition else None
@@ -46,10 +59,29 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
                 ports.append(
                     {
                         "id": id,
+                        "name": port.name,
                         "type": "DEFAULT",
                     }
                 )
 
+        outputs: JsonArray = []
+        for output in node.Outputs:
+            type = primitive_type_to_vellum_variable_type(output)
+            value = (
+                self.serialize_value(display_context, output.instance)
+                if output.instance is not None and output.instance != UNDEF
+                else None
+            )
+
+            outputs.append(
+                {
+                    "id": str(uuid4_from_hash(f"{node_id}|{output.name}")),
+                    "name": output.name,
+                    "type": type,
+                    "value": value,
+                }
+            )
+
         return {
             "id": str(node_id),
             "label": node.__qualname__,
@@ -63,7 +95,8 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
             },
             "ports": ports,
             "adornments": None,
-            "attributes": [],
+            "attributes": attributes,
+            "outputs": outputs,
         }
 
     def get_generic_node_display_data(self) -> GenericNodeDisplayData:
@@ -71,12 +104,25 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
         return explicit_value if explicit_value else GenericNodeDisplayData()
 
     def serialize_condition(self, display_context: WorkflowDisplayContext, condition: BaseDescriptor) -> JsonObject:
-        if isinstance(condition, (AndExpression, OrExpression)):
-            return {}
-        elif isinstance(condition, (IsNullExpression, IsNotNullExpression)):
-            return {}
+        if isinstance(condition, (IsNullExpression, IsNotNullExpression)):
+            lhs = self.serialize_value(display_context, condition._expression)  # type: ignore[attr-defined]
+            return {
+                "type": "UNARY_EXPRESSION",
+                "lhs": lhs,
+                "operator": convert_descriptor_to_operator(condition),
+            }
         elif isinstance(condition, (BetweenExpression, NotBetweenExpression)):
-            return {}
+            base = self.serialize_value(display_context, condition._value)  # type: ignore[attr-defined]
+            lhs = self.serialize_value(display_context, condition._start)  # type: ignore[attr-defined]
+            rhs = self.serialize_value(display_context, condition._end)  # type: ignore[attr-defined]
+
+            return {
+                "type": "TERNARY_EXPRESSION",
+                "base": base,
+                "operator": convert_descriptor_to_operator(condition),
+                "lhs": lhs,
+                "rhs": rhs,
+            }
         else:
             lhs = self.serialize_value(display_context, condition._lhs)  # type: ignore[attr-defined]
             rhs = self.serialize_value(display_context, condition._rhs)  # type: ignore[attr-defined]
@@ -113,7 +159,7 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
             }
 
         if isinstance(value, ExecutionCountReference):
-            node_class_display = display_context.node_displays[value.node_class]
+            node_class_display = display_context.global_node_displays[value.node_class]
 
             return {
                 "type": "EXECUTION_COUNTER",
@@ -127,4 +173,6 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
                 "value": vellum_value.dict(),
             }
 
-        raise ValueError(f"Unsupported descriptor type: {value.__class__.__name__}")
+        # If it's not any of the references we know about,
+        # then try to serialize it as a nested value
+        return self.serialize_condition(display_context, value)

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

@@ -74,6 +74,9 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
         node_inputs: List[NodeInput] = []
         prompt_inputs: List[VellumVariable] = []
 
+        if not value:
+            return node_inputs, prompt_inputs
+
         for variable_name, variable_value in value.items():
             node_input = create_node_input(
                 node_id=node_id,

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

@@ -69,7 +69,7 @@ class BaseMapNodeDisplay(BaseNodeVellumDisplay[_MapNodeType], Generic[_MapNodeTy
                 "workflow_raw_data": serialized_subworkflow["workflow_raw_data"],
                 "input_variables": cast(JsonObject, renamed_input_variables),
                 "output_variables": serialized_subworkflow["output_variables"],
-                "concurrency": raise_if_descriptor(node.concurrency),
+                "concurrency": raise_if_descriptor(node.max_concurrency),
                 "items_input_id": items_workflow_input_id,
                 "item_input_id": item_workflow_input_id,
                 "index_input_id": index_workflow_input_id,

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

@@ -27,16 +27,20 @@ class BasePromptDeploymentNodeDisplay(
         node_id = self.node_id
 
         prompt_inputs = raise_if_descriptor(node.prompt_inputs)
-        node_inputs = [
-            create_node_input(
-                node_id=node_id,
-                input_name=variable_name,
-                value=variable_value,
-                display_context=display_context,
-                input_id=self.prompt_input_ids_by_name.get(variable_name),
-            )
-            for variable_name, variable_value in prompt_inputs.items()
-        ]
+        node_inputs = (
+            [
+                create_node_input(
+                    node_id=node_id,
+                    input_name=variable_name,
+                    value=variable_value,
+                    display_context=display_context,
+                    input_id=self.prompt_input_ids_by_name.get(variable_name),
+                )
+                for variable_name, variable_value in prompt_inputs.items()
+            ]
+            if prompt_inputs
+            else []
+        )
 
         _, 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)]

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

@@ -2,6 +2,7 @@ import pytest
 from uuid import UUID, uuid4
 from typing import List, cast
 
+from vellum.client.types.string_vellum_value import StringVellumValue
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
@@ -19,7 +20,6 @@ from vellum_ee.workflows.display.vellum import (
     NodeInputValuePointerRule,
     NodeOutputData,
     NodeOutputPointer,
-    StringVellumValue,
     WorkflowInputsVellumDisplayOverrides,
     WorkflowMetaVellumDisplay,
 )
@@ -74,7 +74,7 @@ class MyNodeB(BaseNode):
                     type="INPUT_VARIABLE",
                     data=InputVariableData(input_variable_id="a154c29d-fac0-4cd0-ba88-bc52034f5470"),
                 ),
-                ConstantValuePointer(type="CONSTANT_VALUE", data=StringVellumValue(type="STRING", value="fallback")),
+                ConstantValuePointer(type="CONSTANT_VALUE", data=StringVellumValue(value="fallback")),
             ],
         ),
     ],

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

@@ -2,6 +2,7 @@ from uuid import UUID
 from typing import Any, List, Optional, Type, Union, cast
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.expressions.and_ import AndExpression
 from vellum.workflows.expressions.begins_with import BeginsWithExpression
 from vellum.workflows.expressions.between import BetweenExpression
 from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
@@ -25,11 +26,13 @@ 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.workflows.expressions.or_ import OrExpression
+from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.nodes.utils import get_wrapped_node, has_wrapped_node
 from vellum.workflows.references import NodeReference, OutputReference
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
-from vellum_ee.workflows.display.utils.vellum import create_node_input_value_pointer_rule, primitive_to_vellum_value
+from vellum_ee.workflows.display.utils.vellum import create_node_input_value_pointer_rule
 from vellum_ee.workflows.display.vellum import (
     ConstantValuePointer,
     ExecutionCounterData,
@@ -170,5 +173,9 @@ def convert_descriptor_to_operator(descriptor: BaseDescriptor) -> str:
         return "between"
     elif isinstance(descriptor, NotBetweenExpression):
         return "notBetween"
+    elif isinstance(descriptor, AndExpression):
+        return "and"
+    elif isinstance(descriptor, OrExpression):
+        return "or"
     else:
         raise ValueError(f"Unsupported descriptor type: {descriptor}")

vellum_ee/workflows/display/tests/test_vellum_workflow_display.py

@@ -1,4 +1,10 @@
+from uuid import UUID
+
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes import BaseNode
+from vellum.workflows.state import BaseState
 from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.vellum import WorkflowInputsVellumDisplayOverrides
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 from vellum_ee.workflows.display.workflows.vellum_workflow_display import VellumWorkflowDisplay
 
@@ -40,3 +46,45 @@ def test_vellum_workflow_display__serialize_empty_workflow():
             ],
         },
     }
+
+
+def test_vellum_workflow_display__serialize_input_variables_with_capitalized_variable_override():
+    # GIVEN a workflow with input variables
+    class Inputs(BaseInputs):
+        foo: str
+
+    class StartNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            output = Inputs.foo
+
+    class ExampleWorkflow(BaseWorkflow[Inputs, BaseState]):
+        graph = StartNode
+
+    class ExampleWorkflowDisplay(VellumWorkflowDisplay[ExampleWorkflow]):
+        inputs_display = {
+            Inputs.foo: WorkflowInputsVellumDisplayOverrides(
+                id=UUID("97b63d71-5413-417f-9cf5-49e1b4fd56e4"), name="Foo", required=True
+            )
+        }
+
+    display = get_workflow_display(
+        base_display_class=ExampleWorkflowDisplay,
+        workflow_class=ExampleWorkflow,
+    )
+
+    # WHEN serializing the workflow
+    exec_config = display.serialize()
+
+    # THEN the input variables are what we expect
+    input_variables = exec_config["input_variables"]
+
+    assert input_variables == [
+        {
+            "id": "97b63d71-5413-417f-9cf5-49e1b4fd56e4",
+            "key": "Foo",
+            "type": "STRING",
+            "default": None,
+            "required": True,
+            "extensions": {"color": None},
+        }
+    ]

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

@@ -0,0 +1,67 @@
+import pytest
+
+from deepdiff import DeepDiff
+
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.core.map_node.node import MapNode
+from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.state.base import BaseState
+
+
+class Inputs(BaseInputs):
+    foo: str
+
+
+class State(BaseState):
+    bar: str
+
+
+@MapNode.wrap(items=[1, 2, 3])
+class MapGenericNode(BaseNode):
+    item = MapNode.SubworkflowInputs.item
+    foo = Inputs.foo
+    bar = State.bar
+
+    class Outputs(BaseOutputs):
+        value: str
+
+    def run(self) -> Outputs:
+        return self.Outputs(value=f"{self.foo} {self.bar} {self.item}")
+
+
+@pytest.mark.skip(reason="not implemented")
+def test_serialize_node__try(serialize_node):
+    serialized_node = serialize_node(MapGenericNode)
+    assert not DeepDiff(
+        {
+            "id": "c2ed23f7-f6cb-4a56-a91c-2e5f9d8fda7f",
+            "label": "BasicGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "BasicGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_adornments_serialization",
+                ],
+            },
+            "trigger": {"id": "9d3a1b3d-4a38-4f2e-bbf1-dd8be152bce8", "merge_behavior": "AWAIT_ANY"},
+            "ports": [
+                {
+                    "id": "4fbf0fff-a42e-4410-852a-238b5059198e",
+                    "type": "DEFAULT",
+                }
+            ],
+            "adornments": None,
+            "attributes": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )

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

@@ -0,0 +1,286 @@
+from uuid import uuid4
+
+from deepdiff import DeepDiff
+
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.references.vellum_secret import VellumSecretReference
+from vellum_ee.workflows.display.base import WorkflowInputsDisplay
+from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
+from vellum_ee.workflows.display.nodes.vellum.base_node import BaseNodeDisplay
+
+
+class Inputs(BaseInputs):
+    input: str
+
+
+class ConstantValueGenericNode(BaseNode):
+    attr: str = "hello"
+
+
+def test_serialize_node__constant_value(serialize_node):
+    input_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=ConstantValueGenericNode,
+        global_workflow_input_displays={Inputs.input: WorkflowInputsDisplay(id=input_id)},
+    )
+
+    assert not DeepDiff(
+        {
+            "id": "be892bc8-e4de-47ef-ab89-dc9d869af1fe",
+            "label": "ConstantValueGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "ConstantValueGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_attributes_serialization",
+                ],
+            },
+            "trigger": {"id": "279e8228-9b82-43a3-8c31-affc036e3a0b", "merge_behavior": "AWAIT_ANY"},
+            "ports": [{"id": "e6cf13b0-5590-421c-84f2-5a0b169677e1", "type": "DEFAULT", "name": "default"}],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "4cbbfd98-9ab6-41a8-bf4e-ae65f0eafe47",
+                    "name": "attr",
+                    "value": {
+                        "type": "CONSTANT_VALUE",
+                        "value": {
+                            "type": "STRING",
+                            "value": "hello",
+                        },
+                    },
+                }
+            ],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )
+
+
+class WorkflowInputGenericNode(BaseNode):
+    attr: str = Inputs.input
+
+
+def test_serialize_node__workflow_input(serialize_node):
+    input_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=WorkflowInputGenericNode,
+        global_workflow_input_displays={Inputs.input: WorkflowInputsDisplay(id=input_id)},
+    )
+    assert not DeepDiff(
+        {
+            "id": "ddfa947f-0830-476b-b07e-ac573968f9a7",
+            "label": "WorkflowInputGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "WorkflowInputGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_attributes_serialization",
+                ],
+            },
+            "trigger": {"id": "b1a5d749-bac0-4f11-8427-191febb2198e", "merge_behavior": "AWAIT_ANY"},
+            "ports": [{"id": "f013bf3f-49f6-41cd-ac13-7439b71a304a", "type": "DEFAULT", "name": "default"}],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "56d44313-cfdd-4d75-9b19-0beb94e59c4e",
+                    "name": "attr",
+                    "value": {
+                        "type": "WORKFLOW_INPUT",
+                        "input_variable_id": str(input_id),
+                    },
+                }
+            ],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )
+
+
+class NodeWithOutput(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        output = Inputs.input
+
+
+class NodeWithOutputDisplay(BaseNodeDisplay[NodeWithOutput]):
+    pass
+
+
+class GenericNodeReferencingOutput(BaseNode):
+    attr = NodeWithOutput.Outputs.output
+
+
+def test_serialize_node__node_output(serialize_node):
+    workflow_input_id = uuid4()
+    node_output_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=GenericNodeReferencingOutput,
+        global_workflow_input_displays={Inputs.input: WorkflowInputsDisplay(id=workflow_input_id)},
+        global_node_displays={NodeWithOutput: NodeWithOutputDisplay()},
+        global_node_output_displays={
+            NodeWithOutput.Outputs.output: (NodeWithOutput, NodeOutputDisplay(id=node_output_id, name="output"))
+        },
+    )
+
+    assert not DeepDiff(
+        {
+            "id": "c1e2ce60-ac3a-4b17-915e-abe861734e03",
+            "label": "GenericNodeReferencingOutput",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "GenericNodeReferencingOutput",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_attributes_serialization",
+                ],
+            },
+            "trigger": {"id": "449072ba-f7b6-4314-ac96-682123f225e5", "merge_behavior": "AWAIT_ANY"},
+            "ports": [{"id": "ec9a79b8-65c3-4de8-bd29-42c914d72d4f", "type": "DEFAULT", "name": "default"}],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "73e6a103-1339-41ec-a245-42d43b0637c1",
+                    "name": "attr",
+                    "value": {
+                        "type": "NODE_OUTPUT",
+                        "node_id": "cd954d76-0b0a-4d9b-9bdf-347179c38cb6",
+                        "node_output_id": str(node_output_id),
+                    },
+                }
+            ],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )
+
+
+class VellumSecretGenericNode(BaseNode):
+    attr = VellumSecretReference(name="hello")
+
+
+def test_serialize_node__vellum_secret(serialize_node):
+    input_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=VellumSecretGenericNode,
+        global_workflow_input_displays={Inputs.input: WorkflowInputsDisplay(id=input_id)},
+    )
+    assert not DeepDiff(
+        {
+            "id": "89aa6faa-b533-4179-8912-70a048bf0712",
+            "label": "VellumSecretGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "VellumSecretGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_attributes_serialization",
+                ],
+            },
+            "trigger": {"id": "3ea0305d-d8ea-45fe-8cf1-f6c1c85e6979", "merge_behavior": "AWAIT_ANY"},
+            "ports": [{"id": "69e49322-8f8a-42d2-b36f-3fbe53dad616", "type": "DEFAULT", "name": "default"}],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "8edd27da-eec1-4539-8bec-629b5ef7a9f9",
+                    "name": "attr",
+                    "value": {"type": "VELLUM_SECRET", "vellum_secret_name": "hello"},
+                }
+            ],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )
+
+
+class NodeWithExecutions(BaseNode):
+    pass
+
+
+class NodeWithExecutionsDisplay(BaseNodeDisplay[NodeWithExecutions]):
+    pass
+
+
+class GenericNodeReferencingExecutions(BaseNode):
+    attr: int = NodeWithExecutions.Execution.count
+
+
+def test_serialize_node__node_execution(serialize_node):
+    workflow_input_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=GenericNodeReferencingExecutions,
+        global_workflow_input_displays={Inputs.input: WorkflowInputsDisplay(id=workflow_input_id)},
+        global_node_displays={NodeWithExecutions: NodeWithExecutionsDisplay()},
+    )
+
+    assert not DeepDiff(
+        {
+            "id": "6e4d2fb7-891e-492e-97a1-adf44693f518",
+            "label": "GenericNodeReferencingExecutions",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "GenericNodeReferencingExecutions",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_attributes_serialization",
+                ],
+            },
+            "trigger": {"id": "68a91426-4c30-4194-a4c0-cff224d3c0f3", "merge_behavior": "AWAIT_ANY"},
+            "ports": [{"id": "1794c2eb-5cab-49fe-9354-dfc29f11b374", "type": "DEFAULT", "name": "default"}],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "090e18d7-d5b9-4d5f-9aec-0f562e4b33a8",
+                    "name": "attr",
+                    "value": {
+                        "type": "EXECUTION_COUNTER",
+                        "node_id": "c09bd5a6-dc04-4036-90d4-580acd43c71f",
+                    },
+                }
+            ],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )