vellum-ai 0.13.9__py3-none-any.whl → 0.13.11__py3-none-any.whl

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

@@ -88,7 +88,21 @@ def test_serialize_workflow():
         {
             "id": "5cf9c5e3-0eae-4daf-8d73-8b9536258eb9",
             "type": "ERROR",
-            "inputs": [],
+            "inputs": [
+                {
+                    "id": "690d825f-6ffd-493e-8141-c86d384e6150",
+                    "key": "error_source_input_id",
+                    "value": {
+                        "rules": [
+                            {
+                                "type": "CONSTANT_VALUE",
+                                "data": {"type": "STRING", "value": "Input threshold was too low"},
+                            }
+                        ],
+                        "combinator": "OR",
+                    },
+                }
+            ],
             "data": {
                 "name": "error-node",
                 "label": "Fail Node",

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

@@ -123,7 +123,7 @@ def test_serialize_workflow(vellum_client):
                 "source_node_id": "f1e4678f-c470-400b-a40e-c8922cc99a86",
                 "source_handle_id": "40201804-8beb-43ad-8873-a027759512f1",
                 "target_node_id": "c2ed23f7-f6cb-4a56-a91c-2e5f9d8fda7f",
-                "target_handle_id": "b7bfb298-959a-4d2b-8b85-bbd0d2522703",
+                "target_handle_id": "9d3a1b3d-4a38-4f2e-bbf1-dd8be152bce8",
                 "type": "DEFAULT",
             },
             {

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

@@ -140,9 +140,12 @@ def test_serialize_workflow():
                                 "name": "StartNode",
                                 "module": ["tests", "workflows", "basic_inline_subworkflow", "workflow"],
                             },
-                            "trigger": {"id": "a95a34f2-e894-4fb6-a2c9-15d12c1e3135", "merge_behavior": "AWAIT_ANY"},
+                            "trigger": {
+                                "id": "a95a34f2-e894-4fb6-a2c9-15d12c1e3135",
+                                "merge_behavior": "AWAIT_ATTRIBUTES",
+                            },
                             "ports": [
-                                {"id": "4a62dea3-6a4a-4390-88d8-4af5d2c81474", "type": "DEFAULT", "name": "default"}
+                                {"id": "1e739e86-a285-4438-9725-a152c15a63e3", "type": "DEFAULT", "name": "default"}
                             ],
                             "adornments": None,
                             "attributes": [
@@ -271,7 +274,7 @@ def test_serialize_workflow():
                             "source_node_id": "afa49a0f-db35-4552-9217-5b8f237e84bc",
                             "source_handle_id": "9914a6a0-9a99-430d-8ddd-f7c13847fe1a",
                             "target_node_id": "1381c078-efa2-4255-89a1-7b4cb742c7fc",
-                            "target_handle_id": "6492efcf-4437-4af1-9ad7-269795ccb27a",
+                            "target_handle_id": "a95a34f2-e894-4fb6-a2c9-15d12c1e3135",
                             "type": "DEFAULT",
                         },
                         {

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

@@ -129,9 +129,12 @@ def test_serialize_workflow():
                                 "name": "Iteration",
                                 "module": ["tests", "workflows", "basic_map_node", "workflow"],
                             },
-                            "trigger": {"id": "01324747-9bc0-4ecd-a8ab-40dca5a94e2e", "merge_behavior": "AWAIT_ANY"},
+                            "trigger": {
+                                "id": "01324747-9bc0-4ecd-a8ab-40dca5a94e2e",
+                                "merge_behavior": "AWAIT_ATTRIBUTES",
+                            },
                             "ports": [
-                                {"id": "36791877-95b0-4390-a794-10accd8f548e", "type": "DEFAULT", "name": "default"}
+                                {"id": "71ada606-d791-4a59-a252-0795c5faeeaf", "type": "DEFAULT", "name": "default"}
                             ],
                             "adornments": None,
                             "attributes": [
@@ -211,7 +214,7 @@ def test_serialize_workflow():
                             "source_node_id": "ff9bfe6e-839d-4d40-b8fc-313b3bbd0ab0",
                             "source_handle_id": "520d3616-8369-4e79-9da5-3febae299c2a",
                             "target_node_id": "baf6d316-dc75-41e8-96c0-015aede96309",
-                            "target_handle_id": "551d5528-f4e1-42ea-bde0-9de4b4968253",
+                            "target_handle_id": "01324747-9bc0-4ecd-a8ab-40dca5a94e2e",
                             "type": "DEFAULT",
                         },
                         {

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

@@ -145,7 +145,7 @@ def test_serialize_workflow__await_all():
                 "source_node_id": "dc8aecd0-49ba-4464-a45f-29d3bfd686e4",
                 "source_handle_id": "017d40f5-8326-4e42-a409-b08995defaa8",
                 "target_node_id": "59243c65-053f-4ea6-9157-3f3edb1477bf",
-                "target_handle_id": "e622fe61-3bca-4aff-86e1-25dad7bdf9d4",
+                "target_handle_id": "75293c10-d6d8-4fc0-afae-ba6437af982e",
                 "type": "DEFAULT",
             },
             {
@@ -153,7 +153,7 @@ def test_serialize_workflow__await_all():
                 "source_node_id": "dc8aecd0-49ba-4464-a45f-29d3bfd686e4",
                 "source_handle_id": "017d40f5-8326-4e42-a409-b08995defaa8",
                 "target_node_id": "127ef456-91bc-43c6-bd8b-1772db5e3cb5",
-                "target_handle_id": "e5cc41cb-71db-43ec-b3f0-c78706af3351",
+                "target_handle_id": "10c7392f-7dc0-4273-8380-ddc3497e6072",
                 "type": "DEFAULT",
             },
             {
@@ -177,7 +177,7 @@ def test_serialize_workflow__await_all():
                 "source_node_id": "37c10e8a-771b-432b-a767-31f5007851f0",
                 "source_handle_id": "3bbc469f-0fb0-4b3d-a28b-746fefec2818",
                 "target_node_id": "634f0202-9ea9-4c62-b152-1a58c595cffb",
-                "target_handle_id": "acd48f48-54fb-4b2b-ab37-96d336f6dfb3",
+                "target_handle_id": "c0c993cd-1370-480b-b175-59590735aa46",
                 "type": "DEFAULT",
             },
             {

vellum_ee/workflows/display/utils/vellum.py

@@ -1,7 +1,32 @@
-from typing import Any, TypeVar
+from typing import TYPE_CHECKING, Any
 
+from vellum.client.types.logical_operator import LogicalOperator
 from vellum.client.types.vellum_variable_type import VellumVariableType
 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.contains import ContainsExpression
+from vellum.workflows.expressions.does_not_begin_with import DoesNotBeginWithExpression
+from vellum.workflows.expressions.does_not_contain import DoesNotContainExpression
+from vellum.workflows.expressions.does_not_end_with import DoesNotEndWithExpression
+from vellum.workflows.expressions.does_not_equal import DoesNotEqualExpression
+from vellum.workflows.expressions.ends_with import EndsWithExpression
+from vellum.workflows.expressions.equals import EqualsExpression
+from vellum.workflows.expressions.greater_than import GreaterThanExpression
+from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
+from vellum.workflows.expressions.in_ import InExpression
+from vellum.workflows.expressions.is_nil import IsNilExpression
+from vellum.workflows.expressions.is_not_nil import IsNotNilExpression
+from vellum.workflows.expressions.is_not_null import IsNotNullExpression
+from vellum.workflows.expressions.is_not_undefined import IsNotUndefinedExpression
+from vellum.workflows.expressions.is_null import IsNullExpression
+from vellum.workflows.expressions.is_undefined import IsUndefinedExpression
+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.references import OutputReference, WorkflowInputReference
 from vellum.workflows.references.execution_count import ExecutionCountReference
@@ -9,7 +34,6 @@ from vellum.workflows.references.node import NodeReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
 from vellum.workflows.vellum_client import create_vellum_client
-from vellum_ee.workflows.display.types import WorkflowDisplayContext
 from vellum_ee.workflows.display.vellum import (
     ConstantValuePointer,
     ExecutionCounterData,
@@ -23,7 +47,8 @@ from vellum_ee.workflows.display.vellum import (
     WorkspaceSecretPointer,
 )
 
-_T = TypeVar("_T")
+if TYPE_CHECKING:
+    from vellum_ee.workflows.display.types import WorkflowDisplayContext
 
 
 def infer_vellum_variable_type(value: Any) -> VellumVariableType:
@@ -47,7 +72,7 @@ def infer_vellum_variable_type(value: Any) -> VellumVariableType:
 
 
 def create_node_input_value_pointer_rule(
-    value: Any, display_context: WorkflowDisplayContext
+    value: Any, display_context: "WorkflowDisplayContext"
 ) -> NodeInputValuePointerRule:
     if isinstance(value, OutputReference):
         upstream_node, output_display = display_context.global_node_output_displays[value]
@@ -82,3 +107,48 @@ def create_node_input_value_pointer_rule(
         return ConstantValuePointer(type="CONSTANT_VALUE", data=vellum_value)
 
     raise ValueError(f"Unsupported descriptor type: {value.__class__.__name__}")
+
+
+def convert_descriptor_to_operator(descriptor: BaseDescriptor) -> LogicalOperator:
+    if isinstance(descriptor, EqualsExpression):
+        return "="
+    elif isinstance(descriptor, DoesNotEqualExpression):
+        return "!="
+    elif isinstance(descriptor, LessThanExpression):
+        return "<"
+    elif isinstance(descriptor, GreaterThanExpression):
+        return ">"
+    elif isinstance(descriptor, LessThanOrEqualToExpression):
+        return "<="
+    elif isinstance(descriptor, GreaterThanOrEqualToExpression):
+        return ">="
+    elif isinstance(descriptor, ContainsExpression):
+        return "contains"
+    elif isinstance(descriptor, BeginsWithExpression):
+        return "beginsWith"
+    elif isinstance(descriptor, EndsWithExpression):
+        return "endsWith"
+    elif isinstance(descriptor, DoesNotContainExpression):
+        return "doesNotContain"
+    elif isinstance(descriptor, DoesNotBeginWithExpression):
+        return "doesNotBeginWith"
+    elif isinstance(descriptor, DoesNotEndWithExpression):
+        return "doesNotEndWith"
+    elif isinstance(descriptor, (IsNullExpression, IsNilExpression, IsUndefinedExpression)):
+        return "null"
+    elif isinstance(descriptor, (IsNotNullExpression, IsNotNilExpression, IsNotUndefinedExpression)):
+        return "notNull"
+    elif isinstance(descriptor, InExpression):
+        return "in"
+    elif isinstance(descriptor, NotInExpression):
+        return "notIn"
+    elif isinstance(descriptor, BetweenExpression):
+        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/workflows/base_workflow_display.py

@@ -207,11 +207,13 @@ class BaseWorkflowDisplay(
         # TODO: We should still serialize nodes that are in the workflow's directory but aren't used in the graph.
         # https://app.shortcut.com/vellum/story/5394
         for node in self._workflow.get_nodes():
-            if node in global_node_displays:
-                continue
             node_display = self._get_node_display(node)
-            node_displays[node] = node_display
-            global_node_displays[node] = node_display
+
+            if node not in node_displays:
+                node_displays[node] = node_display
+
+            if node not in global_node_displays:
+                global_node_displays[node] = node_display
 
             # Nodes wrapped in a decorator need to be in our node display dictionary for later retrieval
             inner_node = get_wrapped_node(node)

vellum_ee/workflows/display/workflows/vellum_workflow_display.py

@@ -14,6 +14,7 @@ from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum.workflows.types.generics import WorkflowType
 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.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.types import PortDisplay
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
@@ -43,7 +44,7 @@ class VellumWorkflowDisplay(
         WorkflowMetaVellumDisplayOverrides,
         WorkflowInputsVellumDisplay,
         WorkflowInputsVellumDisplayOverrides,
-        BaseNodeVellumDisplay,
+        BaseNodeDisplay,
         EntrypointVellumDisplay,
         EntrypointVellumDisplayOverrides,
         EdgeVellumDisplay,
@@ -52,7 +53,7 @@ class VellumWorkflowDisplay(
         WorkflowOutputVellumDisplayOverrides,
     ]
 ):
-    node_display_base_class = BaseNodeVellumDisplay
+    node_display_base_class = BaseNodeDisplay
 
     def serialize(self) -> JsonObject:
         input_variables: JsonArray = []
@@ -137,7 +138,7 @@ class VellumWorkflowDisplay(
                     workflow_output_display.node_input_id,
                 )
 
-                source_node_display: Optional[BaseNodeVellumDisplay]
+                source_node_display: Optional[BaseNodeDisplay]
                 first_rule = node_input.value.rules[0]
                 if first_rule.type == "NODE_OUTPUT":
                     source_node_id = UUID(first_rule.data.node_id)
@@ -170,15 +171,20 @@ class VellumWorkflowDisplay(
                 )
 
                 if source_node_display:
+                    if isinstance(source_node_display, BaseNodeVellumDisplay):
+                        source_handle_id = source_node_display.get_source_handle_id(
+                            port_displays=self.display_context.port_displays
+                        )
+                    else:
+                        source_handle_id = source_node_display.get_node_port_display(
+                            source_node_display._node.Ports.default
+                        ).id
+
                     synthetic_output_edges.append(
                         {
                             "id": str(workflow_output_display.edge_id),
                             "source_node_id": str(source_node_display.node_id),
-                            "source_handle_id": str(
-                                source_node_display.get_source_handle_id(
-                                    port_displays=self.display_context.port_displays
-                                )
-                            ),
+                            "source_handle_id": str(source_handle_id),
                             "target_node_id": str(workflow_output_display.node_id),
                             "target_handle_id": str(workflow_output_display.target_handle_id),
                             "type": "DEFAULT",
@@ -279,7 +285,7 @@ class VellumWorkflowDisplay(
         self,
         entrypoint: Type[BaseNode],
         workflow_display: WorkflowMetaVellumDisplay,
-        node_displays: Dict[Type[BaseNode], BaseNodeVellumDisplay],
+        node_displays: Dict[Type[BaseNode], BaseNodeDisplay],
         overrides: Optional[EntrypointVellumDisplayOverrides] = None,
     ) -> EntrypointVellumDisplay:
         entrypoint_node_id = workflow_display.entrypoint_node_id
@@ -293,8 +299,12 @@ class VellumWorkflowDisplay(
         )
 
         entrypoint_target = get_unadorned_node(entrypoint)
-        target_node_id = node_displays[entrypoint_target].node_id
-        target_handle_id = node_displays[entrypoint_target].get_target_handle_id()
+        target_node_display = node_displays[entrypoint_target]
+        target_node_id = target_node_display.node_id
+        if isinstance(target_node_display, BaseNodeVellumDisplay):
+            target_handle_id = target_node_display.get_target_handle_id_by_source_node_id(entrypoint_node_id)
+        else:
+            target_handle_id = target_node_display.get_trigger_id()
 
         edge_display = self._generate_edge_display_from_source(
             entrypoint_node_id, source_handle_id, target_node_id, target_handle_id, overrides=edge_display_overrides
@@ -339,7 +349,7 @@ class VellumWorkflowDisplay(
     def _generate_edge_display(
         self,
         edge: Edge,
-        node_displays: Dict[Type[BaseNode], BaseNodeVellumDisplay],
+        node_displays: Dict[Type[BaseNode], BaseNodeDisplay],
         port_displays: Dict[Port, PortDisplay],
         overrides: Optional[EdgeVellumDisplayOverrides] = None,
     ) -> EdgeVellumDisplay:
@@ -353,8 +363,10 @@ class VellumWorkflowDisplay(
         target_node_display = node_displays[target_node]
         target_node_id = target_node_display.node_id
 
-        target_handle_id: UUID
-        target_handle_id = target_node_display.get_target_handle_id_by_source_node_id(source_node_id)
+        if isinstance(target_node_display, BaseNodeVellumDisplay):
+            target_handle_id = target_node_display.get_target_handle_id_by_source_node_id(source_node_id)
+        else:
+            target_handle_id = target_node_display.get_trigger_id()
 
         return self._generate_edge_display_from_source(
             source_node_id, source_handle_id, target_node_id, target_handle_id, overrides

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

@@ -1,192 +0,0 @@
-from typing import Any, Generic, TypeVar, cast
-
-from vellum.workflows.constants import UNDEF
-from vellum.workflows.descriptors.base import BaseDescriptor
-from vellum.workflows.expressions.between import BetweenExpression
-from vellum.workflows.expressions.is_nil import IsNilExpression
-from vellum.workflows.expressions.is_not_nil import IsNotNilExpression
-from vellum.workflows.expressions.is_not_null import IsNotNullExpression
-from vellum.workflows.expressions.is_not_undefined import IsNotUndefinedExpression
-from vellum.workflows.expressions.is_null import IsNullExpression
-from vellum.workflows.expressions.is_undefined import IsUndefinedExpression
-from vellum.workflows.expressions.not_between import NotBetweenExpression
-from vellum.workflows.nodes.bases.base import BaseNode
-from vellum.workflows.references.execution_count import ExecutionCountReference
-from vellum.workflows.references.output import OutputReference
-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
-from vellum_ee.workflows.display.utils.vellum import primitive_to_vellum_value
-from vellum_ee.workflows.display.vellum import GenericNodeDisplayData
-
-_BaseNodeType = TypeVar("_BaseNodeType", bound=BaseNode)
-
-
-class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeType]):
-    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
-        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}"))
-
-            if port._condition_type:
-                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
-                        ),
-                    }
-                )
-            else:
-                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__,
-            "type": "GENERIC",
-            "display_data": self.get_generic_node_display_data().dict(),
-            "base": self.get_base().dict(),
-            "definition": self.get_definition().dict(),
-            "trigger": {
-                "id": str(uuid4_from_hash(f"{node_id}|trigger")),
-                "merge_behavior": node.Trigger.merge_behavior.value,
-            },
-            "ports": ports,
-            "adornments": None,
-            "attributes": attributes,
-            "outputs": outputs,
-        }
-
-    def get_generic_node_display_data(self) -> GenericNodeDisplayData:
-        explicit_value = self._get_explicit_node_display_attr("display_data", GenericNodeDisplayData)
-        return explicit_value if explicit_value else GenericNodeDisplayData()
-
-    def serialize_condition(self, display_context: WorkflowDisplayContext, condition: BaseDescriptor) -> JsonObject:
-        if isinstance(
-            condition,
-            (
-                IsNullExpression,
-                IsNotNullExpression,
-                IsNilExpression,
-                IsNotNilExpression,
-                IsUndefinedExpression,
-                IsNotUndefinedExpression,
-            ),
-        ):
-            lhs = self.serialize_value(display_context, condition._expression)
-            return {
-                "type": "UNARY_EXPRESSION",
-                "lhs": lhs,
-                "operator": convert_descriptor_to_operator(condition),
-            }
-        elif isinstance(condition, (BetweenExpression, NotBetweenExpression)):
-            base = self.serialize_value(display_context, condition._value)
-            lhs = self.serialize_value(display_context, condition._start)
-            rhs = self.serialize_value(display_context, condition._end)
-
-            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]
-
-            return {
-                "type": "BINARY_EXPRESSION",
-                "lhs": lhs,
-                "operator": convert_descriptor_to_operator(condition),
-                "rhs": rhs,
-            }
-
-    def serialize_value(self, display_context: WorkflowDisplayContext, value: BaseDescriptor) -> JsonObject:
-        if isinstance(value, WorkflowInputReference):
-            workflow_input_display = display_context.global_workflow_input_displays[value]
-            return {
-                "type": "WORKFLOW_INPUT",
-                "input_variable_id": str(workflow_input_display.id),
-            }
-
-        if isinstance(value, OutputReference):
-            upstream_node, output_display = display_context.global_node_output_displays[value]
-            upstream_node_display = display_context.global_node_displays[upstream_node]
-
-            return {
-                "type": "NODE_OUTPUT",
-                "node_id": str(upstream_node_display.node_id),
-                "node_output_id": str(output_display.id),
-            }
-
-        if isinstance(value, VellumSecretReference):
-            return {
-                "type": "VELLUM_SECRET",
-                "vellum_secret_name": value.name,
-            }
-
-        if isinstance(value, ExecutionCountReference):
-            node_class_display = display_context.global_node_displays[value.node_class]
-
-            return {
-                "type": "EXECUTION_COUNTER",
-                "node_id": str(node_class_display.node_id),
-            }
-
-        if not isinstance(value, BaseDescriptor):
-            vellum_value = primitive_to_vellum_value(value)
-            return {
-                "type": "CONSTANT_VALUE",
-                "value": vellum_value.dict(),
-            }
-
-        # 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)