vellum-ai 0.14.63__py3-none-any.whl → 1.13.5__py3-none-any.whl

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

@@ -1,12 +1,16 @@
+import pytest
+from dataclasses import dataclass
 from uuid import uuid4
 from typing import List
 
 from deepdiff import DeepDiff
+from pydantic import BaseModel
 
 from vellum.client.types.chat_message import ChatMessage
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.references.environment_variable import EnvironmentVariableReference
 from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.state.base import BaseState
@@ -29,8 +33,8 @@ def test_serialize_node__constant_value(serialize_node):
 
     assert not DeepDiff(
         {
-            "id": "67e07859-7f67-4287-9854-06ab4199e576",
-            "label": "test_serialize_node__constant_value.<locals>.ConstantValueGenericNode",
+            "id": "115acb09-8bb4-4088-a76a-99a145802c00",
+            "label": "Constant Value Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -46,12 +50,12 @@ def test_serialize_node__constant_value(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "e2cde904-de60-4755-87cf-55052ea23a51", "merge_behavior": "AWAIT_ATTRIBUTES"},
-            "ports": [{"id": "96ac6512-0128-4cf7-ba51-2725b4807c8f", "type": "DEFAULT", "name": "default"}],
+            "trigger": {"id": "3522f3b2-5e4e-4296-a7b9-09849c57ec57", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [{"id": "72cf5f4b-9c3e-4e0c-989e-f44c04652280", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
                 {
-                    "id": "84e4f91c-af1a-4f9d-a578-e3f234dea23b",
+                    "id": "889e90b4-a139-4f75-85a3-21d3974dccef",
                     "name": "attr",
                     "value": {
                         "type": "CONSTANT_VALUE",
@@ -69,6 +73,28 @@ def test_serialize_node__constant_value(serialize_node):
     )
 
 
+@pytest.mark.parametrize(
+    "boolean_value, expected_value",
+    [
+        (True, True),
+        (False, False),
+    ],
+)
+def test_serialize_node__constant_boolean_value(serialize_node, boolean_value, expected_value):
+    class BooleanValueGenericNode(BaseNode):
+        attr: bool = boolean_value
+
+    serialized_node = serialize_node(BooleanValueGenericNode)
+
+    assert serialized_node["attributes"][0]["value"] == {
+        "type": "CONSTANT_VALUE",
+        "value": {
+            "type": "JSON",
+            "value": expected_value,
+        },
+    }
+
+
 def test_serialize_node__constant_value_reference(serialize_node):
     class ConstantValueReferenceGenericNode(BaseNode):
         attr: str = ConstantValueReference("hello")
@@ -77,8 +103,8 @@ def test_serialize_node__constant_value_reference(serialize_node):
 
     assert not DeepDiff(
         {
-            "id": "73643f17-e49e-47d2-bd01-bb9c3eab6ae9",
-            "label": "test_serialize_node__constant_value_reference.<locals>.ConstantValueReferenceGenericNode",
+            "id": "e99eebee-2a3d-488f-9365-7210de6daef9",
+            "label": "Constant Value Reference Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -94,12 +120,12 @@ def test_serialize_node__constant_value_reference(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "dc2f90b9-14a1-457a-a9f9-dec7a04f74eb", "merge_behavior": "AWAIT_ATTRIBUTES"},
-            "ports": [{"id": "61adfacf-c3a9-4aea-a3da-bcdbc03273c6", "name": "default", "type": "DEFAULT"}],
+            "trigger": {"id": "e1a16f8a-5ab4-463f-a888-b9d2699af96d", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [{"id": "6a1632c7-232f-4546-b2fe-94381f7a670e", "name": "default", "type": "DEFAULT"}],
             "adornments": None,
             "attributes": [
                 {
-                    "id": "f8e5efc6-8117-4a1c-bcea-5ba23555409a",
+                    "id": "35885b7e-bca5-4053-96c1-a2bcf5530348",
                     "name": "attr",
                     "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "hello"}},
                 }
@@ -116,41 +142,15 @@ def test_serialize_node__lazy_reference(serialize_node):
         attr: str = LazyReference(lambda: ConstantValueReference("hello"))
 
     serialized_node = serialize_node(LazyReferenceGenericNode)
+    attributes = serialized_node["attributes"]
 
-    assert not DeepDiff(
+    assert attributes == [
         {
-            "id": "3d6bfe3b-263a-40a6-8a05-98288e9559a4",
-            "label": "test_serialize_node__lazy_reference.<locals>.LazyReferenceGenericNode",
-            "type": "GENERIC",
-            "display_data": {"position": {"x": 0.0, "y": 0.0}},
-            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
-            "definition": {
-                "name": "LazyReferenceGenericNode",
-                "module": [
-                    "vellum_ee",
-                    "workflows",
-                    "display",
-                    "tests",
-                    "workflow_serialization",
-                    "generic_nodes",
-                    "test_attributes_serialization",
-                ],
-            },
-            "trigger": {"id": "14ec4d19-13e5-4db3-94fa-4e15274bffc7", "merge_behavior": "AWAIT_ATTRIBUTES"},
-            "ports": [{"id": "2dba7224-a376-4780-8414-2b50601f9283", "name": "default", "type": "DEFAULT"}],
-            "adornments": None,
-            "attributes": [
-                {
-                    "id": "7ae37eb4-18c8-49e1-b5ac-6369ce7ed5dd",
-                    "name": "attr",
-                    "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "hello"}},
-                }
-            ],
-            "outputs": [],
-        },
-        serialized_node,
-        ignore_order=True,
-    )
+            "id": "7d98966d-8ef0-4fc4-ac90-2f1d46da0ba4",
+            "name": "attr",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "hello"}},
+        }
+    ]
 
 
 def test_serialize_node__lazy_reference_with_string():
@@ -179,17 +179,126 @@ def test_serialize_node__lazy_reference_with_string():
 
     assert lazy_reference_node["attributes"] == [
         {
-            "id": "98833d71-42a8-47e9-81c4-6a35646e3d3c",
+            "id": "c8da84b7-fd1b-4629-a80b-a31eabada2a9",
             "name": "attr",
             "value": {
                 "type": "NODE_OUTPUT",
                 "node_id": str(OtherNode.__id__),
-                "node_output_id": "7a3406a1-6f11-4568-8aa0-e5dba6534dc2",
+                "node_output_id": "3c28ab49-1c7c-42cc-8175-be17bf05b5e7",
             },
         }
     ]
 
 
+def test_serialize_node__lazy_reference_workflow_output():
+    """Test that LazyReference to workflow output serializes as WORKFLOW_OUTPUT type."""
+
+    # GIVEN a node with a LazyReference to a workflow output
+    class NodeWithWorkflowOutputReference(BaseNode):
+        workflow_output_ref = LazyReference(lambda: TestWorkflow.Outputs.final_result)
+
+    class TestNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str = "test result"
+
+    # AND a workflow that defines an output
+    class TestWorkflow(BaseWorkflow):
+        graph = NodeWithWorkflowOutputReference >> TestNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = TestNode.Outputs.result
+
+    # WHEN the node is serialized in the context of the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the workflow output reference
+    node_with_lazy_reference = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(NodeWithWorkflowOutputReference.__id__)
+    )
+
+    # AND the workflow output reference should serialize as WORKFLOW_OUTPUT type
+    assert len(node_with_lazy_reference["attributes"]) == 1
+    attr = node_with_lazy_reference["attributes"][0]
+    assert attr["name"] == "workflow_output_ref"
+    assert attr["value"]["type"] == "WORKFLOW_OUTPUT"
+
+    # AND the output_variable_id should match the workflow output
+    workflow_output = next(
+        output for output in serialized_workflow["output_variables"] if output["key"] == "final_result"
+    )
+    assert attr["value"]["output_variable_id"] == workflow_output["id"]
+
+
+def test_serialize_node__lazy_reference_workflow_output_with_string():
+    """Test that string-based LazyReference to workflow output serializes as WORKFLOW_OUTPUT type."""
+
+    # GIVEN a node with a string-based LazyReference to a workflow output
+    class NodeWithWorkflowOutputReference(BaseNode):
+        workflow_output_ref = LazyReference[str]("StringWorkflow.Outputs.final_result")
+
+    class TestNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str = "test result"
+
+    # AND a workflow that defines an output
+    class StringWorkflow(BaseWorkflow):
+        graph = NodeWithWorkflowOutputReference >> TestNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = TestNode.Outputs.result
+
+    # WHEN the node is serialized in the context of the workflow
+    workflow_display = get_workflow_display(workflow_class=StringWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the workflow output reference
+    node_with_lazy_reference = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(NodeWithWorkflowOutputReference.__id__)
+    )
+
+    # AND the workflow output reference should serialize as WORKFLOW_OUTPUT type
+    assert len(node_with_lazy_reference["attributes"]) == 1
+    attr = node_with_lazy_reference["attributes"][0]
+    assert attr["name"] == "workflow_output_ref"
+    assert attr["value"]["type"] == "WORKFLOW_OUTPUT"
+
+    # AND the output_variable_id should match the workflow output
+    workflow_output = next(
+        output for output in serialized_workflow["output_variables"] if output["key"] == "final_result"
+    )
+    assert attr["value"]["output_variable_id"] == workflow_output["id"]
+
+
+def test_serialize_node__lazy_reference_with_string__class_not_found():
+    """Test that InvalidOutputReferenceError is added to display context when the referenced class is not found."""
+
+    # GIVEN a node with a string-based LazyReference to a non-existent class
+    class NodeWithInvalidReference(BaseNode):
+        invalid_ref = LazyReference[str]("NonExistentClass.Outputs.result")
+
+    # AND a workflow that contains the node
+    class TestWorkflow(BaseWorkflow):
+        graph = NodeWithInvalidReference
+
+    # WHEN we try to serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    workflow_display.serialize()
+
+    # THEN the error should be added to the display context
+    errors = list(workflow_display.display_context.errors)
+    assert len(errors) == 1
+
+    # AND the error message should mention the class that could not be found
+    error_message = str(errors[0])
+    assert "NonExistentClass" in error_message
+    assert "Could not find node or workflow class" in error_message
+
+
 def test_serialize_node__workflow_input(serialize_node):
     class WorkflowInputGenericNode(BaseNode):
         attr: str = Inputs.input
@@ -202,8 +311,8 @@ def test_serialize_node__workflow_input(serialize_node):
 
     assert not DeepDiff(
         {
-            "id": "30116483-6f38-40e0-baf2-32de0e14e9a3",
-            "label": "test_serialize_node__workflow_input.<locals>.WorkflowInputGenericNode",
+            "id": "8ad5d3b2-4d4d-494f-ab5c-caa650a397e9",
+            "label": "Workflow Input Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -219,12 +328,12 @@ def test_serialize_node__workflow_input(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "debf37b9-720d-48dd-9699-69283966f927", "merge_behavior": "AWAIT_ATTRIBUTES"},
-            "ports": [{"id": "20d91130-ca86-4420-b2e7-a962c0f1a509", "type": "DEFAULT", "name": "default"}],
+            "trigger": {"id": "f8a79f35-b083-47d1-80ee-5efc2baa54e5", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [{"id": "78878dd7-87fc-4f93-b340-0e1155260f23", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
                 {
-                    "id": "6b2f781b-1a70-4abc-965a-a4edb8563f0e",
+                    "id": "23fddc82-c5a9-4aee-b736-2484518d6779",
                     "name": "attr",
                     "value": {
                         "type": "WORKFLOW_INPUT",
@@ -265,10 +374,10 @@ def test_serialize_node__workflow_input_as_nested_chat_history():
 
     assert not DeepDiff(
         {
-            "id": "11be9d37-0069-4695-a317-14a3b6519d4e",
-            "label": "test_serialize_node__workflow_input_as_nested_chat_history.<locals>.GenericNode",
+            "id": "6cf118f2-f550-493b-b49e-c24d4001baea",
+            "label": "Generic Node",
             "type": "GENERIC",
-            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "display_data": {"position": {"x": 200.0, "y": -50.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
             "definition": {
                 "name": "GenericNode",
@@ -282,18 +391,18 @@ def test_serialize_node__workflow_input_as_nested_chat_history():
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "d4548468-85a4-449e-92e0-e2d8b8fd097c", "merge_behavior": "AWAIT_ATTRIBUTES"},
-            "ports": [{"id": "c4a9a57d-1380-4689-8500-e8a0b6477291", "name": "default", "type": "DEFAULT"}],
+            "trigger": {"id": "33ad6542-c6bc-4030-a110-167e37cceb7b", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [{"id": "1f963bfe-d826-452c-8f1f-9f23e350b299", "name": "default", "type": "DEFAULT"}],
             "adornments": None,
             "attributes": [
                 {
-                    "id": "e878bbc9-1231-461e-9e9d-947604da116e",
+                    "id": "07ca2e5d-0215-45c7-bcf5-88b2f5fe2dd3",
                     "name": "attr",
                     "value": {
                         "type": "DICTIONARY_REFERENCE",
                         "entries": [
                             {
-                                "id": "52d98e78-5c2a-488e-be3e-f3b487d94ad3",
+                                "id": "03260b95-1648-4a60-9c4a-51402b3d9a3a",
                                 "key": "hello",
                                 "value": {
                                     "type": "WORKFLOW_INPUT",
@@ -313,6 +422,7 @@ def test_serialize_node__workflow_input_as_nested_chat_history():
 
 def test_serialize_node__node_output(serialize_node):
     class NodeWithOutput(BaseNode):
+
         class Outputs(BaseNode.Outputs):
             output = Inputs.input
 
@@ -329,14 +439,14 @@ def test_serialize_node__node_output(serialize_node):
         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"))
+            NodeWithOutput.Outputs.output: NodeOutputDisplay(id=node_output_id, name="output")
         },
     )
 
     assert not DeepDiff(
         {
-            "id": "7210742f-8c3e-4379-9800-8b4b7f5dd7ed",
-            "label": "test_serialize_node__node_output.<locals>.GenericNodeReferencingOutput",
+            "id": "b79e1e71-a81d-4cb6-a4cb-efa8fc350e9f",
+            "label": "Generic Node Referencing Output",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -352,16 +462,16 @@ def test_serialize_node__node_output(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "d4b08664-bb78-4fdd-83a2-877c4ca4175a", "merge_behavior": "AWAIT_ATTRIBUTES"},
-            "ports": [{"id": "a345665a-decd-4f6b-af38-387bd41c2643", "type": "DEFAULT", "name": "default"}],
+            "trigger": {"id": "4dc05332-fc5d-420e-ae39-5186329bc6a7", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [{"id": "9fd4e17b-e270-40e9-8e34-6b4203839648", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
                 {
-                    "id": "1318ab14-deb1-4254-9636-4bd783bdd9eb",
+                    "id": "4455b900-fae8-45d6-8791-af2b4c324519",
                     "name": "attr",
                     "value": {
                         "type": "NODE_OUTPUT",
-                        "node_id": "48cf26cc-7b6d-49a7-a1a3-298f6d66772b",
+                        "node_id": "e253523d-da42-405f-b44f-24999a1ea2b0",
                         "node_output_id": str(node_output_id),
                     },
                 }
@@ -385,8 +495,8 @@ def test_serialize_node__vellum_secret(serialize_node):
 
     assert not DeepDiff(
         {
-            "id": "0e75bd8f-882e-4ab7-8348-061319b574f7",
-            "label": "test_serialize_node__vellum_secret.<locals>.VellumSecretGenericNode",
+            "id": "7400819d-68dc-4469-a390-2ca908e827f4",
+            "label": "Vellum Secret Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -402,12 +512,12 @@ def test_serialize_node__vellum_secret(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "70a3d4c0-83e3-428d-ac84-bf9e5644a84d", "merge_behavior": "AWAIT_ATTRIBUTES"},
-            "ports": [{"id": "6d1c2139-64bd-4433-84d7-3fe08850134b", "type": "DEFAULT", "name": "default"}],
+            "trigger": {"id": "299e9fca-dab9-42df-ac49-ef4e69fe8abd", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [{"id": "65a83e3e-e8b4-4744-a200-109ff0148ae8", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
                 {
-                    "id": "c2eb79e2-4cd3-4176-8da9-0d76327cbf0f",
+                    "id": "2cc1113c-69db-42f1-a378-d09414a3cb2c",
                     "name": "attr",
                     "value": {"type": "VELLUM_SECRET", "vellum_secret_name": "hello"},
                 }
@@ -438,8 +548,8 @@ def test_serialize_node__node_execution(serialize_node):
 
     assert not DeepDiff(
         {
-            "id": "f42dda6b-e856-49bd-b203-46c9dd66c08b",
-            "label": "test_serialize_node__node_execution.<locals>.GenericNodeReferencingExecutions",
+            "id": "8f96a3df-ea29-48a5-a5f3-5ef95296d25f",
+            "label": "Generic Node Referencing Executions",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -455,16 +565,16 @@ def test_serialize_node__node_execution(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "0c06baa5-55b6-494a-a89d-9535dfa5f24b", "merge_behavior": "AWAIT_ATTRIBUTES"},
-            "ports": [{"id": "59844b72-ac5e-43c5-b3a7-9c57ba73ec8c", "type": "DEFAULT", "name": "default"}],
+            "trigger": {"id": "ecd645fb-8079-4217-ac35-720993845899", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [{"id": "faed7c7b-3aed-4662-8b36-5c6ce92c6754", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
                 {
-                    "id": "8be1be85-ac70-4e61-b52a-cd416f5320b9",
+                    "id": "235d400b-e46e-46fd-9a75-8d1220bee29d",
                     "name": "attr",
                     "value": {
                         "type": "EXECUTION_COUNTER",
-                        "node_id": "d68cc3c3-d5dc-4a51-bbfc-1fd4b41abad0",
+                        "node_id": "d1edee11-6fa1-4ccf-a62c-9f7ca3d446da",
                     },
                 }
             ],
@@ -475,8 +585,24 @@ def test_serialize_node__node_execution(serialize_node):
     )
 
 
+def test_serialize_node__environment_variable(serialize_node):
+    class EnvironmentVariableGenericNode(BaseNode):
+        attr = EnvironmentVariableReference(name="API_KEY")
+
+    serialized_node = serialize_node(EnvironmentVariableGenericNode)
+
+    expected_value = {
+        "type": "ENVIRONMENT_VARIABLE",
+        "environment_variable": "API_KEY",
+    }
+
+    actual_value = serialized_node["attributes"][0]["value"]
+    assert actual_value == expected_value
+
+
 def test_serialize_node__coalesce(serialize_node):
     class CoalesceNodeA(BaseNode):
+
         class Outputs(BaseNode.Outputs):
             output: str
 
@@ -484,6 +610,7 @@ def test_serialize_node__coalesce(serialize_node):
         pass
 
     class CoalesceNodeB(BaseNode):
+
         class Outputs(BaseNode.Outputs):
             output: str
 
@@ -506,21 +633,15 @@ def test_serialize_node__coalesce(serialize_node):
             CoalesceNodeFinal: CoalesceNodeFinalDisplay(),
         },
         global_node_output_displays={
-            CoalesceNodeA.Outputs.output: (
-                CoalesceNodeA,
-                NodeOutputDisplay(id=coalesce_node_a_output_id, name="output"),
-            ),
-            CoalesceNodeB.Outputs.output: (
-                CoalesceNodeB,
-                NodeOutputDisplay(id=coalesce_node_b_output_id, name="output"),
-            ),
+            CoalesceNodeA.Outputs.output: NodeOutputDisplay(id=coalesce_node_a_output_id, name="output"),
+            CoalesceNodeB.Outputs.output: NodeOutputDisplay(id=coalesce_node_b_output_id, name="output"),
         },
     )
 
     assert not DeepDiff(
         {
-            "id": "bb99f326-7d2a-4b5e-95f3-6039114798da",
-            "label": "test_serialize_node__coalesce.<locals>.CoalesceNodeFinal",
+            "id": "fc3216ee-4ab4-4856-b660-d9158e72ed5f",
+            "label": "Coalesce Node Final",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -536,24 +657,24 @@ def test_serialize_node__coalesce(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "b9894d9a-1887-416d-895d-a4129aac37b8", "merge_behavior": "AWAIT_ATTRIBUTES"},
-            "ports": [{"id": "9d97a0c9-6a79-433a-bcdf-e07aa10c0f3c", "name": "default", "type": "DEFAULT"}],
+            "trigger": {"id": "80b9055b-e1da-454c-babc-b1605c5cfab3", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [{"id": "4ceb95a9-c257-4492-828f-ebcdc685d8b0", "name": "default", "type": "DEFAULT"}],
             "adornments": None,
             "attributes": [
                 {
-                    "id": "2e25b25b-4aac-425f-91f4-f0fa55453b8c",
+                    "id": "f5fba9a8-0d90-4a99-a5b0-9f95a61e61d1",
                     "name": "attr",
                     "value": {
                         "type": "BINARY_EXPRESSION",
                         "lhs": {
                             "type": "NODE_OUTPUT",
-                            "node_id": "f6d1aa4d-c3fd-421d-9dc8-4209bddf7fd3",
+                            "node_id": "bacedc11-f833-4bce-80e6-4becbf002fd0",
                             "node_output_id": str(coalesce_node_a_output_id),
                         },
                         "operator": "coalesce",
                         "rhs": {
                             "type": "NODE_OUTPUT",
-                            "node_id": "d1f673fb-80e1-4f9e-9d7d-afe64599ce39",
+                            "node_id": "1637e989-eb51-4edd-a4d9-831cb5e58368",
                             "node_output_id": str(coalesce_node_b_output_id),
                         },
                     },
@@ -564,3 +685,134 @@ def test_serialize_node__coalesce(serialize_node):
         serialized_node,
         ignore_order=True,
     )
+
+
+def test_serialize_node__dataclass_with_node_output_reference(serialize_node):
+    @dataclass
+    class MyDataClass:
+        name: str
+        node_ref: str
+
+    class NodeWithOutput(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+    class NodeWithOutputDisplay(BaseNodeDisplay[NodeWithOutput]):
+        pass
+
+    class GenericNodeWithDataclass(BaseNode):
+        attr = MyDataClass(name="test", node_ref=NodeWithOutput.Outputs.result)
+
+    node_output_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=GenericNodeWithDataclass,
+        global_node_displays={NodeWithOutput: NodeWithOutputDisplay()},
+        global_node_output_displays={
+            NodeWithOutput.Outputs.result: NodeOutputDisplay(id=node_output_id, name="result")
+        },
+    )
+
+    attr_value = serialized_node["attributes"][0]["value"]
+    assert attr_value["type"] == "DICTIONARY_REFERENCE"
+
+    assert any(
+        entry["key"] == "node_ref" and entry["value"]["type"] == "NODE_OUTPUT" for entry in attr_value["entries"]
+    )
+
+
+def test_serialize_node__pydantic_with_node_output_reference(serialize_node):
+    class MyPydanticModel(BaseModel):
+        name: str
+        node_ref: str
+
+    class NodeWithOutput(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+    class NodeWithOutputDisplay(BaseNodeDisplay[NodeWithOutput]):
+        pass
+
+    class GenericNodeWithPydantic(BaseNode):
+        attr = MyPydanticModel(name="test", node_ref=NodeWithOutput.Outputs.result)
+
+    node_output_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=GenericNodeWithPydantic,
+        global_node_displays={NodeWithOutput: NodeWithOutputDisplay()},
+        global_node_output_displays={
+            NodeWithOutput.Outputs.result: NodeOutputDisplay(id=node_output_id, name="result")
+        },
+    )
+
+    attr_value = serialized_node["attributes"][0]["value"]
+    assert attr_value["type"] == "DICTIONARY_REFERENCE"
+
+    assert any(
+        entry["key"] == "node_ref" and entry["value"]["type"] == "NODE_OUTPUT" for entry in attr_value["entries"]
+    )
+
+
+def test_serialize_node__comment_expanded_true_when_content_exists(serialize_node):
+    """
+    Tests that node comment serialization sets expanded=True when comment has content.
+    """
+
+    class NodeWithComment(BaseNode):
+        """This is a test comment for the node."""
+
+        pass
+
+    serialized_node = serialize_node(NodeWithComment)
+
+    # WHEN the node is serialized
+    display_data = serialized_node["display_data"]
+
+    # THEN the comment should have expanded=True
+    assert "comment" in display_data
+    assert display_data["comment"]["value"] == "This is a test comment for the node."
+    assert display_data["comment"]["expanded"] is True
+
+
+def test_serialize_node__comment_expanded_preserved_when_explicitly_set(serialize_node):
+    """
+    Tests that explicitly set expanded value is preserved during serialization.
+    """
+    from vellum_ee.workflows.display.editor.types import NodeDisplayComment, NodeDisplayData
+    from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
+
+    class NodeWithExplicitComment(BaseNode):
+        """This is a test comment."""
+
+        pass
+
+    class NodeWithExplicitCommentDisplay(BaseNodeDisplay[NodeWithExplicitComment]):
+        display_data = NodeDisplayData(comment=NodeDisplayComment(value="Custom comment", expanded=False))
+
+    serialized_node = serialize_node(
+        NodeWithExplicitComment,
+        global_node_displays={NodeWithExplicitComment: NodeWithExplicitCommentDisplay()},
+    )
+
+    # WHEN the node is serialized
+    display_data = serialized_node["display_data"]
+
+    # THEN the comment should preserve expanded=False
+    assert "comment" in display_data
+    assert display_data["comment"]["value"] == "This is a test comment."
+    assert display_data["comment"]["expanded"] is False
+
+
+def test_serialize_node__attribute_with_type_annotation_no_default(serialize_node):
+    """
+    Tests that attributes with type annotations but no default values serialize as None.
+    """
+
+    # GIVEN a node with typed attributes but no default values
+    class NodeWithTypedAttributesNoDefault(BaseNode):
+        attr: str
+
+    # WHEN the node is serialized
+    serialized_node = serialize_node(NodeWithTypedAttributesNoDefault)
+
+    # THEN the attribute should serialize as None
+    assert serialized_node["attributes"][0]["value"] is None