vellum-ai 0.14.41__py3-none-any.whl → 1.11.2__py3-none-any.whl

vellum_ee/workflows/display/utils/registry.py

@@ -1,10 +1,14 @@
+from uuid import UUID
 from typing import TYPE_CHECKING, Dict, Optional, Type
 
+from vellum.workflows.events.types import BaseEvent
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.workflows.base import BaseWorkflow
 
 if TYPE_CHECKING:
+    from vellum.workflows.events.types import ParentContext
     from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
+    from vellum_ee.workflows.display.types import WorkflowDisplayContext
     from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 
 
@@ -14,6 +18,9 @@ _workflow_display_registry: Dict[Type[BaseWorkflow], Type["BaseWorkflowDisplay"]
 # Used to store the mapping between node types and their display classes
 _node_display_registry: Dict[Type[BaseNode], Type["BaseNodeDisplay"]] = {}
 
+# Registry to store active workflow display contexts by span ID for nested workflow inheritance
+_active_workflow_display_contexts: Dict[UUID, "WorkflowDisplayContext"] = {}
+
 
 def get_from_workflow_display_registry(workflow_class: Type[BaseWorkflow]) -> Optional[Type["BaseWorkflowDisplay"]]:
     return _workflow_display_registry.get(workflow_class)
@@ -35,3 +42,42 @@ def get_from_node_display_registry(node_class: Type[BaseNode]) -> Optional[Type[
 
 def register_node_display_class(node_class: Type[BaseNode], node_display_class: Type["BaseNodeDisplay"]) -> None:
     _node_display_registry[node_class] = node_display_class
+
+
+def register_workflow_display_context(span_id: UUID, display_context: "WorkflowDisplayContext") -> None:
+    """Register a workflow display context by span ID for nested workflow inheritance."""
+    _active_workflow_display_contexts[span_id] = display_context
+
+
+def _get_parent_display_context_for_span(span_id: UUID) -> Optional["WorkflowDisplayContext"]:
+    """Get the parent display context for a given span ID."""
+    return _active_workflow_display_contexts.get(span_id)
+
+
+def get_parent_display_context_from_event(event: BaseEvent) -> Optional["WorkflowDisplayContext"]:
+    """Extract parent display context from an event by traversing the parent chain.
+
+    This function traverses up the parent chain starting from the event's parent,
+    looking for workflow parents and attempting to get their display context.
+
+    Args:
+        event: The event to extract parent display context from
+
+    Returns:
+        The parent workflow display context if found, None otherwise
+    """
+    if not event.parent:
+        return None
+
+    current_parent: Optional["ParentContext"] = event.parent
+    while current_parent:
+        if current_parent.type == "WORKFLOW":
+            # Found a parent workflow, try to get its display context
+            parent_span_id = current_parent.span_id
+            parent_display_context = _get_parent_display_context_for_span(parent_span_id)
+            if parent_display_context:
+                return parent_display_context
+        # Move up the parent chain
+        current_parent = current_parent.parent
+
+    return None

vellum_ee/workflows/display/utils/tests/test_auto_layout.py

@@ -0,0 +1,56 @@
+from uuid import uuid4
+
+from vellum_ee.workflows.display.base import EdgeDisplay
+from vellum_ee.workflows.display.editor.types import NodeDisplayData, NodeDisplayPosition
+from vellum_ee.workflows.display.utils.auto_layout import auto_layout_nodes
+
+
+def test_auto_layout_basic():
+    """Test basic auto layout functionality with a simple linear graph."""
+    nodes = [
+        ("node1", NodeDisplayData(position=NodeDisplayPosition(x=0, y=0), width=100, height=80)),
+        ("node2", NodeDisplayData(position=NodeDisplayPosition(x=0, y=0), width=120, height=90)),
+        ("node3", NodeDisplayData(position=NodeDisplayPosition(x=0, y=0), width=110, height=85)),
+    ]
+
+    edges = [
+        ("node1", "node2", EdgeDisplay(id=uuid4())),
+        ("node2", "node3", EdgeDisplay(id=uuid4())),
+    ]
+
+    positioned_nodes = auto_layout_nodes(nodes, edges)
+
+    node_positions = {node_id: data.position for node_id, data in positioned_nodes}
+
+    assert node_positions["node1"].x < node_positions["node2"].x
+    assert node_positions["node2"].x < node_positions["node3"].x
+
+
+def test_auto_layout_parallel_branches():
+    """Test auto layout with parallel branches."""
+    nodes = [
+        ("start", NodeDisplayData(position=NodeDisplayPosition(x=0, y=0), width=100, height=80)),
+        ("branch1", NodeDisplayData(position=NodeDisplayPosition(x=0, y=0), width=100, height=80)),
+        ("branch2", NodeDisplayData(position=NodeDisplayPosition(x=0, y=0), width=100, height=80)),
+        ("end", NodeDisplayData(position=NodeDisplayPosition(x=0, y=0), width=100, height=80)),
+    ]
+
+    edges = [
+        ("start", "branch1", EdgeDisplay(id=uuid4())),
+        ("start", "branch2", EdgeDisplay(id=uuid4())),
+        ("branch1", "end", EdgeDisplay(id=uuid4())),
+        ("branch2", "end", EdgeDisplay(id=uuid4())),
+    ]
+
+    positioned_nodes = auto_layout_nodes(nodes, edges)
+
+    node_positions = {node_id: data.position for node_id, data in positioned_nodes}
+
+    assert node_positions["start"].x < node_positions["branch1"].x
+    assert node_positions["start"].x < node_positions["branch2"].x
+
+    assert node_positions["branch1"].x == node_positions["branch2"].x
+    assert node_positions["branch1"].x < node_positions["end"].x
+
+    assert node_positions["branch1"].x < node_positions["end"].x
+    assert node_positions["branch2"].x < node_positions["end"].x

vellum_ee/workflows/display/utils/tests/test_events.py

@@ -0,0 +1,185 @@
+import pytest
+from uuid import uuid4
+from typing import Optional
+
+from vellum.workflows.events.types import NodeParentContext, WorkflowDeploymentParentContext
+from vellum.workflows.events.workflow import (
+    WorkflowExecutionFulfilledBody,
+    WorkflowExecutionFulfilledEvent,
+    WorkflowExecutionInitiatedBody,
+    WorkflowExecutionInitiatedEvent,
+)
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.utils.events import event_enricher
+
+
+@pytest.mark.parametrize(
+    "is_dynamic,expected_config",
+    [
+        (False, None),
+        (
+            True,
+            {
+                "workflow_raw_data": {
+                    "nodes": [
+                        {
+                            "id": "86607b18-7872-49f3-a592-fda1428f70aa",
+                            "type": "ENTRYPOINT",
+                            "inputs": [],
+                            "data": {
+                                "label": "Entrypoint Node",
+                                "source_handle_id": "d1fe8f4c-53d7-43a0-b210-73ebdc60bf57",
+                            },
+                            "display_data": {"position": {"x": 0.0, "y": -50.0}},
+                            "base": None,
+                            "definition": None,
+                        }
+                    ],
+                    "edges": [],
+                    "display_data": {"viewport": {"x": 0.0, "y": 0.0, "zoom": 1.0}},
+                    "definition": {
+                        "name": "TestWorkflow",
+                        "module": ["vellum_ee", "workflows", "display", "utils", "tests", "test_events"],
+                    },
+                    "output_values": [],
+                },
+                "input_variables": [],
+                "state_variables": [],
+                "output_variables": [],
+            },
+        ),
+    ],
+)
+def test_event_enricher_static_workflow(vellum_client, is_dynamic: bool, expected_config: Optional[dict]):
+    """Test event_enricher with a static workflow (is_dynamic=False)."""
+    # GIVEN a workflow class with the specified is_dynamic value
+    _is_dynamic = is_dynamic
+
+    class TestWorkflow(BaseWorkflow):
+        is_dynamic = _is_dynamic
+
+    event: WorkflowExecutionInitiatedEvent = WorkflowExecutionInitiatedEvent(
+        trace_id=uuid4(),
+        span_id=uuid4(),
+        body=WorkflowExecutionInitiatedBody(
+            workflow_definition=TestWorkflow,
+            inputs=BaseInputs(),
+        ),
+    )
+
+    # WHEN the event_enricher is called with mocked dependencies
+    event_enricher(event, vellum_client)
+
+    # THEN workflow_version_exec_config is set to the expected config
+    assert event.body.workflow_version_exec_config == expected_config
+
+    assert event.body.display_context is not None
+    assert hasattr(event.body.display_context, "node_displays")
+    assert hasattr(event.body.display_context, "workflow_inputs")
+    assert hasattr(event.body.display_context, "workflow_outputs")
+
+
+def test_event_enricher_marks_subworkflow_deployment_as_dynamic(vellum_client):
+    """Test that event_enricher treats subworkflow deployments as dynamic."""
+
+    class TestWorkflow(BaseWorkflow):
+        is_dynamic = False
+
+        class Outputs(BaseOutputs):
+            pass
+
+    event: WorkflowExecutionInitiatedEvent = WorkflowExecutionInitiatedEvent(
+        trace_id=uuid4(),
+        span_id=uuid4(),
+        parent=WorkflowDeploymentParentContext(
+            span_id=uuid4(),
+            deployment_id=uuid4(),
+            deployment_name="test-deployment",
+            deployment_history_item_id=uuid4(),
+            release_tag_id=uuid4(),
+            release_tag_name="test-tag",
+            workflow_version_id=uuid4(),
+            external_id=None,
+            metadata=None,
+            parent=NodeParentContext(
+                span_id=uuid4(),
+                node_definition=TestWorkflow,
+                parent=None,
+            ),
+        ),
+        body=WorkflowExecutionInitiatedBody(
+            workflow_definition=TestWorkflow,
+            inputs=BaseInputs(),
+        ),
+    )
+
+    enriched_event = event_enricher(event, vellum_client)
+
+    assert enriched_event.name == "workflow.execution.initiated"
+    assert hasattr(enriched_event.body, "workflow_version_exec_config")
+    assert enriched_event.body.workflow_version_exec_config is not None
+
+    assert enriched_event.body.display_context is not None
+    assert hasattr(enriched_event.body.display_context, "node_displays")
+    assert hasattr(enriched_event.body.display_context, "workflow_inputs")
+    assert hasattr(enriched_event.body.display_context, "workflow_outputs")
+
+
+def test_event_enricher_with_metadata(vellum_client):
+    """Test that event_enricher attaches metadata to server_metadata field."""
+
+    # GIVEN a workflow class
+    class TestWorkflow(BaseWorkflow):
+        is_dynamic = False
+
+    # AND an event
+    event: WorkflowExecutionInitiatedEvent = WorkflowExecutionInitiatedEvent(
+        trace_id=uuid4(),
+        span_id=uuid4(),
+        body=WorkflowExecutionInitiatedBody(
+            workflow_definition=TestWorkflow,
+            inputs=BaseInputs(),
+        ),
+    )
+
+    # AND some metadata
+    metadata = {"custom_key": "custom_value", "another_key": 123}
+
+    # WHEN the event_enricher is called with metadata
+    enriched_event = event_enricher(event, vellum_client, metadata=metadata)
+
+    # THEN the metadata should be attached to server_metadata
+    assert enriched_event.name == "workflow.execution.initiated"
+    assert enriched_event.body.server_metadata == metadata
+
+
+def test_event_enricher_with_metadata_for_fulfilled_event(vellum_client):
+    """Test that event_enricher attaches metadata to server_metadata field for fulfilled events."""
+
+    # GIVEN a workflow class
+    class TestWorkflow(BaseWorkflow):
+        is_dynamic = False
+
+        class Outputs(BaseOutputs):
+            pass
+
+    event: WorkflowExecutionFulfilledEvent = WorkflowExecutionFulfilledEvent(
+        trace_id=uuid4(),
+        span_id=uuid4(),
+        body=WorkflowExecutionFulfilledBody(
+            workflow_definition=TestWorkflow,
+            outputs=TestWorkflow.Outputs(),
+        ),
+    )
+
+    # AND some metadata
+    metadata = {"execution_time_ms": 1234, "server_id": "server-abc"}
+
+    # WHEN the event_enricher is called with metadata
+    enriched_event = event_enricher(event, vellum_client, metadata=metadata)
+
+    # THEN the metadata should be attached to server_metadata
+    assert enriched_event.name == "workflow.execution.fulfilled"
+    assert enriched_event.body.server_metadata == metadata

vellum_ee/workflows/display/utils/tests/test_expressions.py

@@ -0,0 +1,92 @@
+import pytest
+
+from vellum.workflows.expressions.add import AddExpression
+from vellum.workflows.expressions.begins_with import BeginsWithExpression
+from vellum.workflows.expressions.between import BetweenExpression
+from vellum.workflows.expressions.concat import ConcatExpression
+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_error import IsErrorExpression
+from vellum.workflows.expressions.is_not_null import IsNotNullExpression
+from vellum.workflows.expressions.is_null import IsNullExpression
+from vellum.workflows.expressions.less_than import LessThanExpression
+from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
+from vellum.workflows.expressions.minus import MinusExpression
+from vellum.workflows.expressions.not_between import NotBetweenExpression
+from vellum.workflows.expressions.not_in import NotInExpression
+from vellum_ee.workflows.display.utils.expressions import convert_descriptor_to_operator
+
+
+def binary_expressions_with_lhs_and_rhs():
+    return [
+        (EqualsExpression(lhs="123", rhs="456"), "="),
+        (DoesNotEqualExpression(lhs="123", rhs="456"), "!="),
+        (LessThanExpression(lhs="123", rhs="456"), "<"),
+        (GreaterThanExpression(lhs="123", rhs="456"), ">"),
+        (LessThanOrEqualToExpression(lhs="123", rhs="456"), "<="),
+        (GreaterThanOrEqualToExpression(lhs="123", rhs="456"), ">="),
+        (ContainsExpression(lhs="123", rhs="456"), "contains"),
+        (BeginsWithExpression(lhs="123", rhs="456"), "beginsWith"),
+        (EndsWithExpression(lhs="123", rhs="456"), "endsWith"),
+        (DoesNotContainExpression(lhs="123", rhs="456"), "doesNotContain"),
+        (DoesNotBeginWithExpression(lhs="123", rhs="456"), "doesNotBeginWith"),
+        (DoesNotEndWithExpression(lhs="123", rhs="456"), "doesNotEndWith"),
+        (InExpression(lhs="123", rhs="456"), "in"),
+        (NotInExpression(lhs="123", rhs="456"), "notIn"),
+        (AddExpression(lhs=5, rhs=3), "+"),
+        (MinusExpression(lhs=10, rhs=3), "-"),
+        (ConcatExpression(lhs=[1, 2], rhs=[3, 4]), "concat"),
+    ]
+
+
+def unary_expressions_with_expression():
+    return [
+        (IsErrorExpression(expression="123"), "isError"),
+        (IsNullExpression(expression="123"), "null"),
+        (IsNotNullExpression(expression="123"), "notNull"),
+    ]
+
+
+def ternary_expressions_with_value_and_start_and_end():
+    return [
+        (BetweenExpression(value="123", start="456", end="789"), "between"),
+        (NotBetweenExpression(value="123", start="456", end="789"), "notBetween"),
+    ]
+
+
+@pytest.mark.parametrize("expression, expected_operator", binary_expressions_with_lhs_and_rhs())
+def test_convert_descriptor_to_operator__binary_expressions(expression, expected_operator):
+    # GIVEN a binary expression descriptor
+    # WHEN we convert it to an operator string
+    result = convert_descriptor_to_operator(expression)
+
+    # THEN we should get the expected operator string
+    assert result == expected_operator
+
+
+@pytest.mark.parametrize("expression, expected_operator", unary_expressions_with_expression())
+def test_convert_descriptor_to_operator__unary_expressions(expression, expected_operator):
+    # GIVEN a unary expression descriptor
+    # WHEN we convert it to an operator string
+    result = convert_descriptor_to_operator(expression)
+
+    # THEN we should get the expected operator string
+    assert result == expected_operator
+
+
+@pytest.mark.parametrize("expression, expected_operator", ternary_expressions_with_value_and_start_and_end())
+def test_convert_descriptor_to_operator__ternary_expressions(expression, expected_operator):
+    # GIVEN a ternary expression descriptor
+    # WHEN we convert it to an operator string
+    result = convert_descriptor_to_operator(expression)
+
+    # THEN we should get the expected operator string
+    assert result == expected_operator

vellum_ee/workflows/display/utils/vellum.py

@@ -1,47 +1,22 @@
 from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 
+from vellum.client.core.api_error import ApiError
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.array_vellum_value import ArrayVellumValue
-from vellum.client.types.logical_operator import LogicalOperator
 from vellum.client.types.vellum_value import VellumValue
 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.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.expressions.or_ import OrExpression
-from vellum.workflows.expressions.parse_json import ParseJsonExpression
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
+from vellum.workflows.nodes.utils import get_unadorned_node
 from vellum.workflows.references import OutputReference, WorkflowInputReference
+from vellum.workflows.references.environment_variable import EnvironmentVariableReference
 from vellum.workflows.references.execution_count import ExecutionCountReference
 from vellum.workflows.references.lazy import LazyReference
 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.utils.exceptions import UnsupportedSerializationException
+from vellum_ee.workflows.display.utils.exceptions import InvalidInputReferenceError, UnsupportedSerializationException
 from vellum_ee.workflows.display.utils.expressions import get_child_descriptor
 
 if TYPE_CHECKING:
@@ -94,12 +69,22 @@ class ExecutionCounterPointer(UniversalBaseModel):
     data: ExecutionCounterData
 
 
+class EnvironmentVariableData(UniversalBaseModel):
+    environment_variable: str
+
+
+class EnvironmentVariablePointer(UniversalBaseModel):
+    type: Literal["ENVIRONMENT_VARIABLE"] = "ENVIRONMENT_VARIABLE"
+    data: EnvironmentVariableData
+
+
 NodeInputValuePointerRule = Union[
     NodeOutputPointer,
     InputVariablePointer,
     ConstantValuePointer,
     WorkspaceSecretPointer,
     ExecutionCounterPointer,
+    EnvironmentVariablePointer,
 ]
 
 
@@ -129,12 +114,20 @@ def create_node_input_value_pointer_rule(
     if isinstance(value, OutputReference):
         if value not in display_context.global_node_output_displays:
             if issubclass(value.outputs_class, BaseNode.Outputs):
-                raise ValueError(f"Reference to node '{value.outputs_class._node_class.__name__}' not found in graph.")
+                raise ValueError(
+                    f"Reference to node '{value.outputs_class.__parent_class__.__name__}' not found in graph."
+                )
 
             raise ValueError(f"Reference to outputs '{value.outputs_class.__qualname__}' is invalid.")
 
-        upstream_node, output_display = display_context.global_node_output_displays[value]
-        upstream_node_display = display_context.global_node_displays[upstream_node]
+        output_display = display_context.global_node_output_displays[value]
+
+        upstream_node_class = value.outputs_class.__parent_class__
+        if not issubclass(upstream_node_class, BaseNode):
+            raise ValueError(f"Output references must be to a node, not {upstream_node_class}")
+        unadorned_upstream_node_class = get_unadorned_node(upstream_node_class)
+        upstream_node_display = display_context.global_node_displays[unadorned_upstream_node_class]
+
         return NodeOutputPointer(
             data=NodeOutputData(node_id=str(upstream_node_display.node_id), output_id=str(output_display.id)),
         )
@@ -142,17 +135,27 @@ def create_node_input_value_pointer_rule(
         child_descriptor = get_child_descriptor(value, display_context)
         return create_node_input_value_pointer_rule(child_descriptor, display_context)
     if isinstance(value, WorkflowInputReference):
+        if value not in display_context.global_workflow_input_displays:
+            raise InvalidInputReferenceError(
+                message=f"Inputs class '{value.inputs_class.__qualname__}' has no attribute '{value.name}'",
+                inputs_class_name=value.inputs_class.__qualname__,
+                attribute_name=value.name,
+            )
         workflow_input_display = display_context.global_workflow_input_displays[value]
         return InputVariablePointer(data=InputVariableData(input_variable_id=str(workflow_input_display.id)))
     if isinstance(value, VellumSecretReference):
-        vellum_client = create_vellum_client()
-        workspace_secret = vellum_client.workspace_secrets.retrieve(
-            id=value.name,
-        )
+        try:
+            workspace_secret = display_context.client.workspace_secrets.retrieve(
+                id=value.name,
+            )
+            workspace_secret_id: Optional[str] = str(workspace_secret.id)
+        except ApiError:
+            workspace_secret_id = None
+
         return WorkspaceSecretPointer(
             data=WorkspaceSecretData(
                 type="STRING",
-                workspace_secret_id=str(workspace_secret.id),
+                workspace_secret_id=workspace_secret_id,
             ),
         )
     if isinstance(value, ExecutionCountReference):
@@ -160,58 +163,18 @@ def create_node_input_value_pointer_rule(
         return ExecutionCounterPointer(
             data=ExecutionCounterData(node_id=str(node_class_display.node_id)),
         )
+    if isinstance(value, EnvironmentVariableReference):
+        if value.serialize_as_constant:
+            vellum_value = primitive_to_vellum_value(value.name)
+            return ConstantValuePointer(type="CONSTANT_VALUE", data=vellum_value)
+        return EnvironmentVariablePointer(
+            data=EnvironmentVariableData(
+                environment_variable=value.name,
+            ),
+        )
 
     if not isinstance(value, BaseDescriptor):
         vellum_value = primitive_to_vellum_value(value)
         return ConstantValuePointer(type="CONSTANT_VALUE", data=vellum_value)
 
     raise UnsupportedSerializationException(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"
-    elif isinstance(descriptor, CoalesceExpression):
-        return "coalesce"
-    elif isinstance(descriptor, ParseJsonExpression):
-        return "parseJson"
-    else:
-        raise ValueError(f"Unsupported descriptor type: {descriptor}")