vellum-ai 0.14.18__py3-none-any.whl → 0.14.20__py3-none-any.whl

vellum_ee/workflows/display/nodes/base_node_display.py

@@ -115,6 +115,10 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
     port_displays: Dict[Port, PortDisplayOverrides] = {}
     node_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
 
+    # 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 store the mapping between node types and their display classes
     _node_display_registry: Dict[Type[NodeType], Type["BaseNodeDisplay"]] = {}
 
@@ -129,13 +133,16 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 continue
 
             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)),
-                }
-            )
+            try:
+                attributes.append(
+                    {
+                        "id": id,
+                        "name": attribute.name,
+                        "value": self.serialize_value(display_context, attribute.instance),
+                    }
+                )
+            except ValueError as e:
+                raise ValueError(f"Failed to serialize attribute '{attribute.name}': {e}")
 
         adornments = kwargs.get("adornments", None)
         wrapped_node = get_wrapped_node(node)
@@ -202,7 +209,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
             "trigger": {
-                "id": str(self.get_trigger_id()),
+                "id": str(self.get_target_handle_id()),
                 "merge_behavior": node.Trigger.merge_behavior.value,
             },
             "ports": ports,
@@ -252,7 +259,24 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
         return PortDisplay(id=port_id, node_id=self.node_id)
 
     def get_trigger_id(self) -> UUID:
-        return uuid4_from_hash(f"{self.node_id}|trigger")
+        return self.get_target_handle_id()
+
+    def get_target_handle_id(self) -> UUID:
+        """
+        Is the same as `get_trigger_id()` but kept for legacy workflows. Once all workflows have been updated to
+        become Generic Nodes, we should be able to drive off of only `get_trigger_id()` going forward
+        """
+
+        return self._get_node_display_uuid("target_handle_id")
+
+    def get_target_handle_id_by_source_node_id(self, source_node_id: UUID) -> UUID:
+        """
+        In the vast majority of cases, nodes will only have a single target handle and can be retrieved independently
+        of the source node. However, in rare cases (such as legacy Merge nodes), this method can be overridden to
+        account for the case of retrieving one amongst multiple target handles on a node.
+        """
+
+        return self.get_target_handle_id()
 
     @classmethod
     def get_from_node_display_registry(cls, node_class: Type[NodeType]) -> Optional[Type["BaseNodeDisplay"]]:
@@ -312,6 +336,10 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
 
         raise ValueError(f"Node {cls.__name__} must define an explicit {attribute} of type {attribute_type.__name__}.")
 
+    def _get_node_display_uuid(self, attribute: str) -> UUID:
+        explicit_value = self._get_explicit_node_display_attr(attribute, UUID)
+        return explicit_value if explicit_value else uuid4_from_hash(f"{self.node_id}|{attribute}")
+
     def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
         if not cls._node_display_registry:
@@ -369,7 +397,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 "rhs": rhs,
             }
 
-    def serialize_value(self, display_context: "WorkflowDisplayContext", value: BaseDescriptor) -> JsonObject:
+    def serialize_value(self, display_context: "WorkflowDisplayContext", value: Any) -> JsonObject:
         if isinstance(value, ConstantValueReference):
             return self.serialize_value(display_context, value._value)
 
@@ -415,6 +443,9 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 "node_id": str(node_class_display.node_id),
             }
 
+        if isinstance(value, dict) and any(isinstance(v, BaseDescriptor) for v in value.values()):
+            raise ValueError("Nested references are not supported.")
+
         if not isinstance(value, BaseDescriptor):
             vellum_value = primitive_to_vellum_value(value)
             return {

vellum_ee/workflows/display/nodes/base_node_vellum_display.py

@@ -4,7 +4,6 @@ from typing import ClassVar, Dict, Optional
 from vellum.workflows.nodes.utils import get_unadorned_node
 from vellum.workflows.ports import Port
 from vellum.workflows.types.generics import NodeType
-from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.types import PortDisplay
 from vellum_ee.workflows.display.vellum import NodeDisplayComment, NodeDisplayData
@@ -14,13 +13,6 @@ class BaseNodeVellumDisplay(BaseNodeDisplay[NodeType]):
     # Used to explicitly set display data for a node
     display_data: ClassVar[Optional[NodeDisplayData]] = None
 
-    # Used to explicitly set the target handle id for a node
-    target_handle_id: ClassVar[Optional[UUID]] = None
-
-    def _get_node_display_uuid(self, attribute: str) -> UUID:
-        explicit_value = self._get_explicit_node_display_attr(attribute, UUID)
-        return explicit_value if explicit_value else uuid4_from_hash(f"{self.node_id}|{attribute}")
-
     def get_display_data(self) -> NodeDisplayData:
         explicit_value = self._get_explicit_node_display_attr("display_data", NodeDisplayData)
         docstring = self._node.__doc__
@@ -40,18 +32,6 @@ class BaseNodeVellumDisplay(BaseNodeDisplay[NodeType]):
 
         return explicit_value if explicit_value else NodeDisplayData()
 
-    def get_target_handle_id(self) -> UUID:
-        return self._get_node_display_uuid("target_handle_id")
-
-    def get_target_handle_id_by_source_node_id(self, source_node_id: UUID) -> UUID:
-        """
-        In the vast majority of cases, nodes will only have a single target handle and can be retrieved independently
-        of the source node. However, in rare cases (such as legacy Merge nodes), this method can be overridden to
-        account for the case of retrieving one amongst multiple target handles on a node.
-        """
-
-        return self.get_target_handle_id()
-
     def get_source_handle_id(self, port_displays: Dict[Port, PortDisplay]) -> UUID:
         unadorned_node = get_unadorned_node(self._node)
         default_port = unadorned_node.Ports.default

vellum_ee/workflows/display/nodes/get_node_display_class.py

@@ -7,12 +7,12 @@ from vellum.workflows.types.generics import NodeType
 from vellum.workflows.utils.uuids import uuid4_from_hash
 
 if TYPE_CHECKING:
-    from vellum_ee.workflows.display.types import NodeDisplayType
+    from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 
 
 def get_node_display_class(
-    base_class: Type["NodeDisplayType"], node_class: Type[NodeType], root_node_class: Optional[Type[NodeType]] = None
-) -> Type["NodeDisplayType"]:
+    base_class: Type["BaseNodeDisplay"], node_class: Type[NodeType], root_node_class: Optional[Type[NodeType]] = None
+) -> Type["BaseNodeDisplay"]:
     node_display_class = base_class.get_from_node_display_registry(node_class)
     if node_display_class:
         if not issubclass(node_display_class, base_class):

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

@@ -15,9 +15,6 @@ _CodeExecutionNodeType = TypeVar("_CodeExecutionNodeType", bound=CodeExecutionNo
 
 
 class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType], Generic[_CodeExecutionNodeType]):
-    code_input_id: ClassVar[Optional[UUID]] = None
-    runtime_input_id: ClassVar[Optional[UUID]] = None
-
     output_id: ClassVar[Optional[UUID]] = None
     log_output_id: ClassVar[Optional[UUID]] = None
 
@@ -27,17 +24,20 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
         node = self._node
         node_id = self.node_id
         raw_code = raise_if_descriptor(node.code)
+        filepath = raise_if_descriptor(node.filepath)
 
         code_value: Optional[str]
         if raw_code:
             code_value = raw_code
-        else:
+        elif filepath:
             node_file_path = inspect.getfile(node)
             file_code = read_file_from_path(
                 node_filepath=node_file_path,
-                script_filepath=(raise_if_descriptor(node.filepath)),  # type: ignore
+                script_filepath=filepath,
             )
             code_value = file_code
+        else:
+            code_value = ""
 
         code_inputs = raise_if_descriptor(node.code_inputs)
 
@@ -47,24 +47,28 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
                 input_name=variable_name,
                 value=variable_value,
                 display_context=display_context,
-                input_id=self.node_input_ids_by_name.get(variable_name),
+                input_id=self.node_input_ids_by_name.get(f"{CodeExecutionNode.code_inputs.name}.{variable_name}")
+                or self.node_input_ids_by_name.get(variable_name),
             )
             for variable_name, variable_value in code_inputs.items()
         ]
 
+        code_input_id = self.node_input_ids_by_name.get(CodeExecutionNode.code.name)
         code_node_input = create_node_input(
             node_id=node_id,
             input_name="code",
             value=code_value,
             display_context=display_context,
-            input_id=self.code_input_id,
+            input_id=code_input_id,
         )
+
+        runtime_input_id = self.node_input_ids_by_name.get(CodeExecutionNode.runtime.name)
         runtime_node_input = create_node_input(
             node_id=node_id,
             input_name="runtime",
             value=node.runtime,
             display_context=display_context,
-            input_id=self.runtime_input_id,
+            input_id=runtime_input_id,
         )
         inputs.extend([code_node_input, runtime_node_input])
 
@@ -84,8 +88,8 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
                 "error_output_id": str(error_output_id) if error_output_id else None,
                 "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
                 "target_handle_id": str(self.get_target_handle_id()),
-                "code_input_id": str(self.code_input_id) if self.code_input_id else code_node_input.id,
-                "runtime_input_id": str(self.runtime_input_id) if self.runtime_input_id else runtime_node_input.id,
+                "code_input_id": code_node_input.id,
+                "runtime_input_id": runtime_node_input.id,
                 "output_type": output_type,
                 "packages": [package.dict() for package in packages] if packages is not None else [],
                 "output_id": str(self.output_id) if self.output_id else str(output_display.id),

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

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import Callable, ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union
+from typing import Callable, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union
 
 from vellum import FunctionDefinition, PromptBlock, RichTextChildBlock, VellumVariable
 from vellum.workflows.nodes import InlinePromptNode
@@ -17,10 +17,6 @@ _InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
 
 
 class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType], Generic[_InlinePromptNodeType]):
-    output_id: ClassVar[Optional[UUID]] = None
-    array_output_id: ClassVar[Optional[UUID]] = None
-    prompt_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
-
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:
@@ -98,7 +94,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
                 input_name=variable_name,
                 value=variable_value,
                 display_context=display_context,
-                input_id=self.prompt_input_ids_by_name.get(variable_name),
+                input_id=self.node_input_ids_by_name.get(variable_name),
             )
             vellum_variable_type = infer_vellum_variable_type(variable_value)
             node_inputs.append(node_input)

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

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import ClassVar, Dict, Generic, Optional, TypeVar, cast
+from typing import Generic, Optional, TypeVar, cast
 
 from vellum.workflows.nodes.displayable.prompt_deployment_node import PromptDeploymentNode
 from vellum.workflows.references import OutputReference
@@ -16,10 +16,6 @@ _PromptDeploymentNodeType = TypeVar("_PromptDeploymentNodeType", bound=PromptDep
 class BasePromptDeploymentNodeDisplay(
     BaseNodeVellumDisplay[_PromptDeploymentNodeType], Generic[_PromptDeploymentNodeType]
 ):
-    output_id: ClassVar[Optional[UUID]] = None
-    array_output_id: ClassVar[Optional[UUID]] = None
-    prompt_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
-
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:
@@ -34,7 +30,7 @@ class BasePromptDeploymentNodeDisplay(
                     input_name=variable_name,
                     value=variable_value,
                     display_context=display_context,
-                    input_id=self.prompt_input_ids_by_name.get(variable_name),
+                    input_id=self.node_input_ids_by_name.get(variable_name),
                 )
                 for variable_name, variable_value in prompt_inputs.items()
             ]

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

@@ -0,0 +1,113 @@
+import pytest
+from uuid import UUID
+from typing import Type
+
+from vellum.workflows.nodes.displayable.code_execution_node.node import CodeExecutionNode
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.nodes.vellum.code_execution_node import BaseCodeExecutionNodeDisplay
+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
+
+
+def _no_display_class(Node: Type[CodeExecutionNode]):
+    return None
+
+
+def _display_class_with_node_input_ids_by_name(Node: Type[CodeExecutionNode]):
+    class CodeExecutionNodeDisplay(BaseCodeExecutionNodeDisplay[Node]):  # type: ignore[valid-type]
+        node_input_ids_by_name = {"foo": UUID("fba6a4d5-835a-4e99-afb7-f6a4aed15110")}
+
+    return CodeExecutionNodeDisplay
+
+
+def _display_class_with_node_input_ids_by_name_with_inputs_prefix(Node: Type[CodeExecutionNode]):
+    class CodeExecutionNodeDisplay(BaseCodeExecutionNodeDisplay[Node]):  # type: ignore[valid-type]
+        node_input_ids_by_name = {"code_inputs.foo": UUID("fba6a4d5-835a-4e99-afb7-f6a4aed15110")}
+
+    return CodeExecutionNodeDisplay
+
+
+@pytest.mark.parametrize(
+    ["GetDisplayClass", "expected_input_id"],
+    [
+        (_no_display_class, "e3cdb222-324e-4ad1-abb2-bdd7881b3a0e"),
+        (_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"),
+    ],
+    ids=[
+        "no_display_class",
+        "display_class_with_node_input_ids_by_name",
+        "display_class_with_node_input_ids_by_name_with_inputs_prefix",
+    ],
+)
+def test_serialize_node__code_node_inputs(GetDisplayClass, expected_input_id):
+    # GIVEN a code node with inputs
+    class MyCodeExecutionNode(CodeExecutionNode):
+        code_inputs = {"foo": "bar"}
+
+    # AND a workflow with the code node
+    class Workflow(BaseWorkflow):
+        graph = MyCodeExecutionNode
+
+    # AND a display class
+    GetDisplayClass(MyCodeExecutionNode)
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(base_display_class=VellumWorkflowDisplay, workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the inputs
+    my_code_execution_node = next(
+        node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["type"] == "CODE_EXECUTION"
+    )
+
+    assert my_code_execution_node["inputs"] == [
+        {
+            "id": expected_input_id,
+            "key": "foo",
+            "value": {
+                "combinator": "OR",
+                "rules": [
+                    {
+                        "type": "CONSTANT_VALUE",
+                        "data": {
+                            "type": "STRING",
+                            "value": "bar",
+                        },
+                    }
+                ],
+            },
+        },
+        {
+            "id": "9774d864-c76d-4a1a-8181-b632ed3ab87c",
+            "key": "code",
+            "value": {
+                "combinator": "OR",
+                "rules": [
+                    {
+                        "type": "CONSTANT_VALUE",
+                        "data": {
+                            "type": "STRING",
+                            "value": "",
+                        },
+                    }
+                ],
+            },
+        },
+        {
+            "id": "34742235-5699-45cd-9d34-bce3745e743d",
+            "key": "runtime",
+            "value": {
+                "combinator": "OR",
+                "rules": [
+                    {
+                        "type": "CONSTANT_VALUE",
+                        "data": {
+                            "type": "STRING",
+                            "value": "PYTHON_3_11_6",
+                        },
+                    }
+                ],
+            },
+        },
+    ]

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

@@ -12,7 +12,7 @@ from vellum_ee.workflows.display.base import StateValueDisplayType, WorkflowInpu
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
-from vellum_ee.workflows.display.types import NodeDisplayType, WorkflowDisplayContext
+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
 
@@ -24,7 +24,7 @@ def serialize_node():
         base_class: type[BaseNodeDisplay[Any]] = BaseNodeDisplay,
         global_workflow_input_displays: Dict[WorkflowInputReference, WorkflowInputsDisplayType] = {},
         global_state_value_displays: Dict[StateValueReference, StateValueDisplayType] = {},
-        global_node_displays: Dict[Type[BaseNode], NodeDisplayType] = {},
+        global_node_displays: Dict[Type[BaseNode], BaseNodeDisplay] = {},
         global_node_output_displays: Dict[OutputReference, Tuple[Type[BaseNode], NodeOutputDisplay]] = {},
     ) -> JsonObject:
         node_display_class = get_node_display_class(base_class, node_class)

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

@@ -64,7 +64,7 @@ def test_serialize_node__retry(serialize_node):
                     "test_adornments_serialization",
                 ],
             },
-            "trigger": {"id": "d38a83bf-23d1-4f9d-a875-a08dc27cf397", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "75fbe874-c00b-4fc2-9ade-52f4fe9209fa", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "078650c9-f775-4cd0-a08c-23af9983a361", "name": "default", "type": "DEFAULT"}],
             "adornments": [
                 {
@@ -175,7 +175,7 @@ def test_serialize_node__try(serialize_node):
                     "test_adornments_serialization",
                 ],
             },
-            "trigger": {"id": "16bc1522-c408-47ad-9a22-0ef136384abf", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "bbb343ff-2b7a-4793-a8cf-fb05132ca46a", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "8d25f244-4b12-4f8b-b202-8948698679a0", "name": "default", "type": "DEFAULT"}],
             "adornments": [
                 {
@@ -283,7 +283,7 @@ def test_serialize_node__stacked():
                                 "test_adornments_serialization",
                             ],
                         },
-                        "trigger": {"id": "f206358d-04a5-41c9-beee-0871a074fa48", "merge_behavior": "AWAIT_ATTRIBUTES"},
+                        "trigger": {"id": "6e4af17f-bbee-4777-b10d-af042cd6e16a", "merge_behavior": "AWAIT_ATTRIBUTES"},
                         "ports": [{"id": "408cd5fb-3a3e-4eb2-9889-61111bd6a129", "name": "default", "type": "DEFAULT"}],
                         "adornments": [
                             {
@@ -342,7 +342,7 @@ def test_serialize_node__stacked():
                         "source_node_id": "c14c1c9b-a7a4-4d2c-84fb-c940cfb09525",
                         "source_handle_id": "51a5eb25-af14-4bee-9ced-d2aa534ea8e9",
                         "target_node_id": "074833b0-e142-4bbc-8dec-209a35e178a3",
-                        "target_handle_id": "f206358d-04a5-41c9-beee-0871a074fa48",
+                        "target_handle_id": "6e4af17f-bbee-4777-b10d-af042cd6e16a",
                         "type": "DEFAULT",
                     }
                 ],

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

@@ -1,12 +1,16 @@
+import pytest
 from uuid import uuid4
+from typing import List
 
 from deepdiff import DeepDiff
 
+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.lazy import LazyReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
+from vellum.workflows.state.base import BaseState
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.base import WorkflowInputsDisplay
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
@@ -44,7 +48,7 @@ def test_serialize_node__constant_value(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "5d41f6fc-fc1a-4a19-9a06-6a0ea9d38557", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "e2cde904-de60-4755-87cf-55052ea23a51", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "96ac6512-0128-4cf7-ba51-2725b4807c8f", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
@@ -92,7 +96,7 @@ def test_serialize_node__constant_value_reference(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "174f3a8e-99c2-4045-8327-ad2dc658889e", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "dc2f90b9-14a1-457a-a9f9-dec7a04f74eb", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "61adfacf-c3a9-4aea-a3da-bcdbc03273c6", "name": "default", "type": "DEFAULT"}],
             "adornments": None,
             "attributes": [
@@ -134,7 +138,7 @@ def test_serialize_node__lazy_reference(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "a3598540-7464-4965-8a2f-f022a011007d", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "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": [
@@ -217,7 +221,7 @@ def test_serialize_node__workflow_input(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "dcb92d51-1fbd-4d41-ab89-c8f490d2bb38", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "debf37b9-720d-48dd-9699-69283966f927", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "20d91130-ca86-4420-b2e7-a962c0f1a509", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
@@ -237,6 +241,33 @@ def test_serialize_node__workflow_input(serialize_node):
     )
 
 
+def test_serialize_node__workflow_input_as_nested_chat_history():
+    # GIVEN workflow inputs as chat history
+    class Inputs(BaseInputs):
+        chat_history: List[ChatMessage]
+
+    # AND a node referencing the workflow input
+    class GenericNode(BaseNode):
+        attr = {
+            "hello": Inputs.chat_history,
+        }
+
+    # AND a workflow with the node
+    class Workflow(BaseWorkflow[Inputs, BaseState]):
+        graph = GenericNode
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay,
+        workflow_class=Workflow,
+    )
+    with pytest.raises(Exception) as exc_info:
+        workflow_display.serialize()
+
+    # THEN we should raise a user facing error
+    assert str(exc_info.value) == "Failed to serialize attribute 'attr': Nested references are not supported."
+
+
 def test_serialize_node__node_output(serialize_node):
     class NodeWithOutput(BaseNode):
         class Outputs(BaseNode.Outputs):
@@ -278,7 +309,7 @@ def test_serialize_node__node_output(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "aa7f0dce-0413-4802-b1dd-f96a2d2eb8e5", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "d4b08664-bb78-4fdd-83a2-877c4ca4175a", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "a345665a-decd-4f6b-af38-387bd41c2643", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
@@ -328,7 +359,7 @@ def test_serialize_node__vellum_secret(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "c5006d90-90cc-4e97-9092-f75785fa61ec", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "70a3d4c0-83e3-428d-ac84-bf9e5644a84d", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "6d1c2139-64bd-4433-84d7-3fe08850134b", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
@@ -381,7 +412,7 @@ def test_serialize_node__node_execution(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "2fc95236-b5bc-4574-bade-2c9f0933b18c", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "0c06baa5-55b6-494a-a89d-9535dfa5f24b", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "59844b72-ac5e-43c5-b3a7-9c57ba73ec8c", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
@@ -462,7 +493,7 @@ def test_serialize_node__coalesce(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "0302231d-73f2-4587-8a62-8ed3640f0f91", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "b9894d9a-1887-416d-895d-a4129aac37b8", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "9d97a0c9-6a79-433a-bcdf-e07aa10c0f3c", "name": "default", "type": "DEFAULT"}],
             "adornments": None,
             "attributes": [

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

@@ -39,7 +39,7 @@ def test_serialize_node__annotated_output(serialize_node):
                     "test_outputs_serialization",
                 ],
             },
-            "trigger": {"id": "753f7ef1-8724-4af2-939a-794f74ffc21b", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "e66c7dde-02c9-4f6d-84a6-16117b54cd88", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "d83b7a5d-bbac-47ee-9277-1fbed71e83e8", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [],
@@ -87,7 +87,7 @@ def test_serialize_node__workflow_input(serialize_node):
                     "test_outputs_serialization",
                 ],
             },
-            "trigger": {"id": "dcb92d51-1fbd-4d41-ab89-c8f490d2bb38", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "debf37b9-720d-48dd-9699-69283966f927", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "20d91130-ca86-4420-b2e7-a962c0f1a509", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [],
@@ -150,7 +150,7 @@ def test_serialize_node__node_output_reference(serialize_node):
                     "test_outputs_serialization",
                 ],
             },
-            "trigger": {"id": "e949426f-9f3c-425e-a4de-8c0c5f6a8945", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "c8804b97-9f84-41b6-ade8-aa74544d6846", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "383dc10a-d8f3-4bac-b995-8b95bc6deb21", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [],