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

vellum_cli/pull.py

@@ -173,10 +173,13 @@ def pull_command(
                     target.write(content)
 
     if metadata_json:
-        workflow_config.container_image_name = metadata_json.get("runner_config", {}).get("container_image_name")
-        workflow_config.container_image_tag = metadata_json.get("runner_config", {}).get("container_image_tag")
-        if workflow_config.container_image_name and not workflow_config.container_image_tag:
-            workflow_config.container_image_tag = "latest"
+        runner_config = metadata_json.get("runner_config")
+
+        if runner_config:
+            workflow_config.container_image_name = runner_config.get("container_image_name")
+            workflow_config.container_image_tag = runner_config.get("container_image_tag")
+            if workflow_config.container_image_name and not workflow_config.container_image_tag:
+                workflow_config.container_image_tag = "latest"
 
     if include_json:
         logger.warning(

vellum_cli/tests/conftest.py

@@ -18,11 +18,13 @@ class MockModuleResult:
 
 
 @pytest.fixture
-def mock_module() -> Generator[MockModuleResult, None, None]:
+def mock_module(request) -> Generator[MockModuleResult, None, None]:
     current_dir = os.getcwd()
     temp_dir = tempfile.mkdtemp()
     os.chdir(temp_dir)
-    module = "examples.mock"
+
+    # Use the test name to create a unique module path
+    module = f"examples.mock.{request.node.name}"
     workflow_sandbox_id = str(uuid4())
 
     def set_pyproject_toml(vellum_config: Dict[str, Any]) -> None:

vellum_cli/tests/test_push.py

@@ -110,13 +110,17 @@ class ExampleWorkflow(BaseWorkflow):
     # THEN it should succeed
     assert result.exit_code == 0
 
+    # Get the last part of the module path and format it
+    expected_label = mock_module.module.split(".")[-1].replace("_", " ").title()
+    expected_artifact_name = f"{mock_module.module.replace('.', '__')}.tar.gz"
+
     # AND we should have called the push API with the correct args
     vellum_client.workflows.push.assert_called_once()
     call_args = vellum_client.workflows.push.call_args.kwargs
     assert json.loads(call_args["exec_config"])["workflow_raw_data"]["definition"]["name"] == "ExampleWorkflow"
-    assert call_args["label"] == "Mock"
+    assert call_args["label"] == expected_label
     assert is_valid_uuid(call_args["workflow_sandbox_id"])
-    assert call_args["artifact"].name == "examples__mock.tar.gz"
+    assert call_args["artifact"].name == expected_artifact_name
     assert "deplyment_config" not in call_args
 
     extracted_files = _extract_tar_gz(call_args["artifact"].read())
@@ -160,13 +164,17 @@ class ExampleWorkflow(BaseWorkflow):
     # THEN it should succeed
     assert result.exit_code == 0
 
+    # Get the last part of the module path and format it
+    expected_label = mock_module.module.split(".")[-1].replace("_", " ").title()
+    expected_artifact_name = f"{mock_module.module.replace('.', '__')}.tar.gz"
+
     # AND we should have called the push API with the correct args
     vellum_client.workflows.push.assert_called_once()
     call_args = vellum_client.workflows.push.call_args.kwargs
     assert json.loads(call_args["exec_config"])["workflow_raw_data"]["definition"]["name"] == "ExampleWorkflow"
-    assert call_args["label"] == "Mock"
+    assert call_args["label"] == expected_label
     assert is_valid_uuid(call_args["workflow_sandbox_id"])
-    assert call_args["artifact"].name == "examples__mock.tar.gz"
+    assert call_args["artifact"].name == expected_artifact_name
     assert call_args["deployment_config"] == "{}"
 
     extracted_files = _extract_tar_gz(call_args["artifact"].read())
@@ -231,6 +239,6 @@ class ExampleWorkflow(BaseWorkflow):
 
     # AND the report should be in the output
     assert "## Errors" in result.output
-    # assert "Serialization is not supported." in result.output
+    assert "Serialization is not supported." in result.output
     assert "## Proposed Diffs" in result.output
     assert "iterable_item_added" in result.output

vellum_ee/workflows/display/nodes/base_node_display.py

@@ -25,7 +25,7 @@ from vellum.workflows.types.utils import get_original_base
 from vellum.workflows.utils.names import pascal_to_title_case
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay, PortDisplayOverrides
-from vellum_ee.workflows.display.vellum import CodeResourceDefinition, NodeDefinition
+from vellum_ee.workflows.display.vellum import CodeResourceDefinition
 
 if TYPE_CHECKING:
     from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -54,18 +54,25 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
     def serialize(self, display_context: "WorkflowDisplayContext", **kwargs: Any) -> JsonObject:
         raise NotImplementedError(f"Serialization for nodes of type {self._node.__name__} is not supported.")
 
-    def get_definition(self) -> NodeDefinition:
+    def get_base(self) -> CodeResourceDefinition:
         node = self._node
-        node_definition = NodeDefinition(
+
+        base_node_classes = [base for base in node.__bases__ if issubclass(base, BaseNode)]
+        if len(base_node_classes) != 1:
+            raise ValueError(f"Node {node.__name__} must extend from exactly one parent node class.")
+
+        base_node_class = base_node_classes[0]
+
+        return CodeResourceDefinition(
+            name=base_node_class.__name__,
+            module=base_node_class.__module__.split("."),
+        )
+
+    def get_definition(self) -> CodeResourceDefinition:
+        node = self._node
+        node_definition = CodeResourceDefinition(
             name=node.__name__,
             module=node.__module__.split("."),
-            bases=[
-                CodeResourceDefinition(
-                    name=base.__name__,
-                    module=base.__module__.split("."),
-                )
-                for base in node.__bases__
-            ],
         )
         return node_definition
 

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

@@ -197,5 +197,6 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
                 "status_code_output_id": str(status_code_output_display.id),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

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

@@ -1,10 +1,23 @@
 from typing import Any, Generic, TypeVar
 
+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.types.core import JsonObject
+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_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)
@@ -15,17 +28,40 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
         node = self._node
         node_id = self.node_id
 
+        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,
+                        "type": port._condition_type.value,
+                        "expression": (
+                            self.serialize_condition(display_context, port._condition) if port._condition else None
+                        ),
+                    }
+                )
+            else:
+                ports.append(
+                    {
+                        "id": id,
+                        "type": "DEFAULT",
+                    }
+                )
+
         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": ports,
             "adornments": None,
             "attributes": [],
         }
@@ -33,3 +69,62 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
     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, (AndExpression, OrExpression)):
+            return {}
+        elif isinstance(condition, (IsNullExpression, IsNotNullExpression)):
+            return {}
+        elif isinstance(condition, (BetweenExpression, NotBetweenExpression)):
+            return {}
+        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.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(),
+            }
+
+        raise ValueError(f"Unsupported descriptor type: {value.__class__.__name__}")

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

@@ -92,5 +92,6 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
                 "log_output_id": str(self.log_output_id) if self.log_output_id else str(log_output_display.id),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

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

@@ -4,34 +4,16 @@ from typing import Any, ClassVar, Dict, Generic, List, Optional, Tuple, TypeVar,
 
 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 import ConditionalNode
 from vellum.workflows.types.core import ConditionType, JsonObject
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
-from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
+from vellum_ee.workflows.display.nodes.vellum.utils import convert_descriptor_to_operator, create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 from vellum_ee.workflows.display.vellum import NodeInput
 
@@ -113,7 +95,7 @@ but the defined conditions have length {len(condition_ids)}"""
                 )
                 node_inputs.append(expression_node_input)
                 field_node_input_id = expression_node_input.id
-                operator = self._convert_descriptor_to_operator(descriptor)
+                operator = convert_descriptor_to_operator(descriptor)
 
             elif isinstance(descriptor, (BetweenExpression, NotBetweenExpression)):
                 field_node_input = create_node_input(
@@ -127,7 +109,7 @@ but the defined conditions have length {len(condition_ids)}"""
                     value_node_input_id,
                 )
                 node_inputs.extend([field_node_input, value_node_input])
-                operator = self._convert_descriptor_to_operator(descriptor)
+                operator = convert_descriptor_to_operator(descriptor)
                 field_node_input_id = field_node_input.id
                 value_node_input_id = value_node_input.id
 
@@ -147,7 +129,7 @@ but the defined conditions have length {len(condition_ids)}"""
                     node_inputs.append(rhs_node_input)
                     value_node_input_id = rhs_node_input.id
 
-                operator = self._convert_descriptor_to_operator(descriptor)
+                operator = convert_descriptor_to_operator(descriptor)
                 field_node_input_id = lhs_node_input.id
 
             return {
@@ -218,49 +200,10 @@ but the defined conditions have length {len(condition_ids)}"""
                 "version": "2",
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }
 
-    def _convert_descriptor_to_operator(self, descriptor: BaseDescriptor) -> str:
-        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"
-        else:
-            raise ValueError(f"Unsupported descriptor type: {descriptor}")
-
     def get_nested_rule_details_by_path(
         self, rule_ids: List[RuleIdMap], path: List[int]
     ) -> Union[Tuple[str, Optional[str], Optional[str]], None]:

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

@@ -44,5 +44,6 @@ class BaseErrorNodeDisplay(BaseNodeVellumDisplay[_ErrorNodeType], Generic[_Error
                 "error_output_id": str(self.error_output_id),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

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

@@ -45,6 +45,7 @@ class BaseFinalOutputNodeDisplay(BaseNodeVellumDisplay[_FinalOutputNodeType], Ge
             },
             "inputs": [node_input.dict()],
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }
 

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

@@ -45,5 +45,6 @@ class BaseGuardrailNodeDisplay(BaseNodeVellumDisplay[_GuardrailNodeType], Generi
                 "release_tag": raise_if_descriptor(node.release_tag),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

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

@@ -59,6 +59,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
                 "ml_model_name": raise_if_descriptor(node.ml_model),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }
 

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

@@ -52,6 +52,7 @@ class BaseInlineSubworkflowNodeDisplay(
                 "output_variables": [workflow_output.dict() for workflow_output in workflow_outputs],
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }
 

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

@@ -75,5 +75,6 @@ class BaseMapNodeDisplay(BaseNodeVellumDisplay[_MapNodeType], Generic[_MapNodeTy
                 "index_input_id": index_workflow_input_id,
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

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

@@ -45,6 +45,7 @@ class BaseMergeNodeDisplay(BaseNodeVellumDisplay[_MergeNodeType], Generic[_Merge
                 "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }
 

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

@@ -26,5 +26,6 @@ class BaseNoteNodeDisplay(BaseNodeVellumDisplay[_NoteNodeType], Generic[_NoteNod
                 "style": json.dumps(self.style) if self.style else None,
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

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

@@ -64,5 +64,6 @@ class BasePromptDeploymentNodeDisplay(
                 "release_tag": raise_if_descriptor(node.release_tag),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

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

@@ -65,6 +65,7 @@ class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_Sea
                 "metadata_filters_node_input_id": str(node_inputs["metadata_filters"].id),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }
 

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

@@ -56,5 +56,6 @@ class BaseSubworkflowDeploymentNodeDisplay(
                 "release_tag": raise_if_descriptor(node.release_tag),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

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

@@ -73,5 +73,6 @@ class BaseTemplatingNodeDisplay(BaseNodeVellumDisplay[_TemplatingNodeType], Gene
                 "output_type": inferred_output_type,
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

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

@@ -2,7 +2,29 @@ from uuid import UUID
 from typing import Any, List, Optional, Type, Union, cast
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.expressions.begins_with import BeginsWithExpression
+from vellum.workflows.expressions.between import BetweenExpression
 from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
+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.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
@@ -109,3 +131,44 @@ def create_pointer(
         return ConstantValuePointer(type="CONSTANT_VALUE", data=vellum_variable_value)
     else:
         raise ValueError(f"Pointer type {pointer_type} not supported")
+
+
+def convert_descriptor_to_operator(descriptor: BaseDescriptor) -> str:
+    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"
+    else:
+        raise ValueError(f"Unsupported descriptor type: {descriptor}")

vellum_ee/workflows/display/tests/test_vellum_workflow_display.py

@@ -30,11 +30,8 @@ def test_vellum_workflow_display__serialize_empty_workflow():
             "nodes": [
                 {
                     "data": {"label": "Entrypoint Node", "source_handle_id": "508b8b82-3517-4672-a155-18c9c7b9c545"},
-                    "definition": {
-                        "bases": [],
-                        "module": ["vellum", "workflows", "nodes", "bases", "base"],
-                        "name": "BaseNode",
-                    },
+                    "base": None,
+                    "definition": None,
                     "display_data": {"position": {"x": 0.0, "y": 0.0}},
                     "id": "9eef0c18-f322-4d56-aa89-f088d3e53f6a",
                     "inputs": [],

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

@@ -1,16 +1,29 @@
 import pytest
 from uuid import uuid4
+from typing import Dict, Tuple, Type
 
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.references.output import OutputReference
+from vellum.workflows.references.workflow_input import WorkflowInputReference
+from vellum.workflows.types.core import JsonObject
+from vellum.workflows.types.generics import NodeType
+from vellum_ee.workflows.display.base import WorkflowInputsDisplayType
 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.nodes.vellum.base_node import BaseNodeDisplay
-from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum_ee.workflows.display.types import NodeDisplayType, WorkflowDisplayContext
 from vellum_ee.workflows.display.vellum import NodeDisplayData, WorkflowMetaVellumDisplay
 from vellum_ee.workflows.display.workflows.vellum_workflow_display import VellumWorkflowDisplay
 
 
 @pytest.fixture()
 def serialize_node():
-    def _serialize_node(node_class) -> dict:
+    def _serialize_node(
+        node_class: Type[NodeType],
+        global_workflow_input_displays: Dict[WorkflowInputReference, WorkflowInputsDisplayType] = {},
+        global_node_displays: Dict[Type[BaseNode], NodeDisplayType] = {},
+        global_node_output_displays: Dict[OutputReference, Tuple[Type[BaseNode], NodeOutputDisplay]] = {},
+    ) -> JsonObject:
         node_display_class = get_node_display_class(BaseNodeDisplay, node_class)
         node_display = node_display_class()
 
@@ -22,6 +35,9 @@ def serialize_node():
                 entrypoint_node_display=NodeDisplayData(),
             ),
             node_displays={node_class: node_display},
+            global_workflow_input_displays=global_workflow_input_displays,
+            global_node_displays=global_node_displays,
+            global_node_output_displays=global_node_output_displays,
         )
         return node_display.serialize(context)