vellum-ai 0.14.8__py3-none-any.whl → 0.14.9__py3-none-any.whl

vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.8",
+            "X-Fern-SDK-Version": "0.14.9",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/workflows/descriptors/base.py

@@ -29,6 +29,7 @@ if TYPE_CHECKING:
     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 import BaseNode
     from vellum.workflows.state.base import BaseState
 
@@ -349,3 +350,8 @@ class BaseDescriptor(Generic[_T]):
         from vellum.workflows.expressions.is_not_blank import IsNotBlankExpression
 
         return IsNotBlankExpression(expression=self)
+
+    def parse_json(self) -> "ParseJsonExpression[_T]":
+        from vellum.workflows.expressions.parse_json import ParseJsonExpression
+
+        return ParseJsonExpression(expression=self)

vellum/workflows/descriptors/tests/test_utils.py

@@ -96,6 +96,13 @@ class DummyNode(BaseNode[FixtureState]):
             ).does_not_contain("test"),
             False,
         ),
+        (ConstantValueReference('{"foo": "bar"}').parse_json(), {"foo": "bar"}),
+        (ConstantValueReference('{"foo": "bar"}').parse_json()["foo"], "bar"),
+        (ConstantValueReference("[1, 2, 3]").parse_json(), [1, 2, 3]),
+        (ConstantValueReference("[1, 2, 3]").parse_json()[0], 1),
+        (ConstantValueReference(b'{"foo": "bar"}').parse_json(), {"foo": "bar"}),
+        (ConstantValueReference(bytearray(b'{"foo": "bar"}')).parse_json(), {"foo": "bar"}),
+        (ConstantValueReference(b'{"key": "\xf0\x9f\x8c\x9f"}').parse_json(), {"key": "🌟"}),
     ],
     ids=[
         "or",
@@ -143,6 +150,13 @@ class DummyNode(BaseNode[FixtureState]):
         "list_index",
         "error_contains",
         "error_does_not_contain",
+        "parse_json_constant",
+        "parse_json_accessor",
+        "parse_json_list",
+        "parse_json_list_index",
+        "parse_json_bytes",
+        "parse_json_bytearray",
+        "parse_json_bytes_with_utf8_chars",
     ],
 )
 def test_resolve_value__happy_path(descriptor, expected_value):

vellum/workflows/events/tests/test_event.py

@@ -4,6 +4,7 @@ from uuid import UUID
 
 from deepdiff import DeepDiff
 
+from vellum.workflows.constants import undefined
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
 from vellum.workflows.events.node import (
     NodeExecutionFulfilledBody,
@@ -86,6 +87,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     "inputs": {
                         "foo": "bar",
                     },
+                    "display_context": None,
                 },
                 "parent": None,
             },
@@ -330,6 +332,43 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                 "parent": None,
             },
         ),
+        (
+            NodeExecutionFulfilledEvent(
+                id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                timestamp=datetime(2024, 1, 1, 12, 0, 0),
+                trace_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                body=NodeExecutionFulfilledBody(
+                    node_definition=MockNode,
+                    outputs=MockNode.Outputs(
+                        example=undefined,  # type: ignore[arg-type]
+                    ),
+                    invoked_ports={MockNode.Ports.default},
+                ),
+            ),
+            {
+                "id": "123e4567-e89b-12d3-a456-426614174000",
+                "api_version": "2024-10-25",
+                "timestamp": "2024-01-01T12:00:00",
+                "trace_id": "123e4567-e89b-12d3-a456-426614174000",
+                "span_id": "123e4567-e89b-12d3-a456-426614174000",
+                "name": "node.execution.fulfilled",
+                "body": {
+                    "node_definition": {
+                        "id": mock_node_uuid,
+                        "name": "MockNode",
+                        "module": module_root + ["events", "tests", "test_event"],
+                    },
+                    "outputs": {},
+                    "invoked_ports": [
+                        {
+                            "name": "default",
+                        }
+                    ],
+                },
+                "parent": None,
+            },
+        ),
     ],
     ids=[
         "workflow.execution.initiated",
@@ -339,6 +378,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
         "workflow.execution.rejected",
         "node.execution.streaming",
         "node.execution.fulfilled",
+        "fulfilled_node_with_undefined_outputs",
     ],
 )
 def test_event_serialization(event, expected_json):

vellum/workflows/events/workflow.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Any, Dict, Generator, Generic, Iterable, Literal, Type, Union
+from uuid import UUID
+from typing import TYPE_CHECKING, Any, Dict, Generator, Generic, Iterable, Literal, Optional, Type, Union
 
 from pydantic import field_serializer
 
@@ -38,8 +39,26 @@ class _BaseWorkflowEvent(BaseEvent):
         return self.body.workflow_definition
 
 
+class NodeDisplay(UniversalBaseModel):
+    input_display: Dict[str, UUID]
+    output_display: Dict[str, UUID]
+    port_display: Dict[str, UUID]
+
+
+class WorkflowEventDisplayContext(UniversalBaseModel):
+    node_displays: Dict[str, NodeDisplay]
+    workflow_inputs: Dict[str, UUID]
+    workflow_outputs: Dict[str, UUID]
+
+
 class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[InputsType]):
     inputs: InputsType
+    # It is still the responsibility of the workflow server to populate this context. The SDK's
+    # Workflow Runner will always leave this field None.
+    #
+    # It's conceivable in a future where all `id`s are agnostic to display and reside in a third location,
+    # that the Workflow Runner can begin populating this field then.
+    display_context: Optional[WorkflowEventDisplayContext] = None
 
     @field_serializer("inputs")
     def serialize_inputs(self, inputs: InputsType, _info: Any) -> Dict[str, Any]:

vellum/workflows/expressions/greater_than.py

@@ -1,10 +1,21 @@
-from typing import Generic, TypeVar, Union
+from typing import Any, Generic, Protocol, TypeVar, Union, runtime_checkable
+from typing_extensions import TypeGuard
 
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
+
+@runtime_checkable
+class SupportsGreaterThan(Protocol):
+    def __gt__(self, other: Any) -> bool: ...
+
+
+def has_gt(obj: Any) -> TypeGuard[SupportsGreaterThan]:
+    return hasattr(obj, "__gt__")
+
+
 LHS = TypeVar("LHS")
 RHS = TypeVar("RHS")
 
@@ -21,14 +32,10 @@ class GreaterThanExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         self._rhs = rhs
 
     def resolve(self, state: "BaseState") -> bool:
-        # Support any type that implements the > operator
-        # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
-        if not isinstance(lhs, (int, float)):
-            raise InvalidExpressionException(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
-
         rhs = resolve_value(self._rhs, state)
-        if not isinstance(rhs, (int, float)):
-            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+
+        if not has_gt(lhs):
+            raise InvalidExpressionException(f"'{lhs.__class__.__name__}' must support the '>' operator")
 
         return lhs > rhs

vellum/workflows/expressions/greater_than_or_equal_to.py

@@ -1,4 +1,5 @@
-from typing import Generic, TypeVar, Union
+from typing import Any, Generic, Protocol, TypeVar, Union, runtime_checkable
+from typing_extensions import TypeGuard
 
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.exceptions import InvalidExpressionException
@@ -9,6 +10,15 @@ LHS = TypeVar("LHS")
 RHS = TypeVar("RHS")
 
 
+@runtime_checkable
+class SupportsGreaterThanOrEqualTo(Protocol):
+    def __ge__(self, other: Any) -> bool: ...
+
+
+def has_ge(obj: Any) -> TypeGuard[SupportsGreaterThanOrEqualTo]:
+    return hasattr(obj, "__ge__")
+
+
 class GreaterThanOrEqualToExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
     def __init__(
         self,
@@ -21,14 +31,10 @@ class GreaterThanOrEqualToExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         self._rhs = rhs
 
     def resolve(self, state: "BaseState") -> bool:
-        # Support any type that implements the >= operator
-        # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
-        if not isinstance(lhs, (int, float)):
-            raise InvalidExpressionException(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
-
         rhs = resolve_value(self._rhs, state)
-        if not isinstance(rhs, (int, float)):
-            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+
+        if not has_ge(lhs):
+            raise InvalidExpressionException(f"'{lhs.__class__.__name__}' must support the '>=' operator")
 
         return lhs >= rhs

vellum/workflows/expressions/less_than.py

@@ -1,4 +1,5 @@
-from typing import Generic, TypeVar, Union
+from typing import Any, Generic, Protocol, TypeVar, Union, runtime_checkable
+from typing_extensions import TypeGuard
 
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.exceptions import InvalidExpressionException
@@ -9,6 +10,15 @@ LHS = TypeVar("LHS")
 RHS = TypeVar("RHS")
 
 
+@runtime_checkable
+class SupportsLessThan(Protocol):
+    def __lt__(self, other: Any) -> bool: ...
+
+
+def has_lt(obj: Any) -> TypeGuard[SupportsLessThan]:
+    return hasattr(obj, "__lt__")
+
+
 class LessThanExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
     def __init__(
         self,
@@ -21,14 +31,10 @@ class LessThanExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         self._rhs = rhs
 
     def resolve(self, state: "BaseState") -> bool:
-        # Support any type that implements the < operator
-        # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
-        if not isinstance(lhs, (int, float)):
-            raise InvalidExpressionException(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
-
         rhs = resolve_value(self._rhs, state)
-        if not isinstance(rhs, (int, float)):
-            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+
+        if not has_lt(lhs):
+            raise InvalidExpressionException(f"'{lhs.__class__.__name__}' must support the '<' operator")
 
         return lhs < rhs

vellum/workflows/expressions/less_than_or_equal_to.py

@@ -1,4 +1,5 @@
-from typing import Generic, TypeVar, Union
+from typing import Any, Generic, Protocol, TypeVar, Union, runtime_checkable
+from typing_extensions import TypeGuard
 
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.exceptions import InvalidExpressionException
@@ -9,6 +10,15 @@ LHS = TypeVar("LHS")
 RHS = TypeVar("RHS")
 
 
+@runtime_checkable
+class SupportsLessThanOrEqualTo(Protocol):
+    def __le__(self, other: Any) -> bool: ...
+
+
+def has_le(obj: Any) -> TypeGuard[SupportsLessThanOrEqualTo]:
+    return hasattr(obj, "__le__")
+
+
 class LessThanOrEqualToExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
     def __init__(
         self,
@@ -21,14 +31,10 @@ class LessThanOrEqualToExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         self._rhs = rhs
 
     def resolve(self, state: "BaseState") -> bool:
-        # Support any type that implements the <= operator
-        # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
-        if not isinstance(lhs, (int, float)):
-            raise InvalidExpressionException(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
-
         rhs = resolve_value(self._rhs, state)
-        if not isinstance(rhs, (int, float)):
-            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+
+        if not has_le(lhs):
+            raise InvalidExpressionException(f"'{lhs.__class__.__name__}' must support the '<=' operator")
 
         return lhs <= rhs

vellum/workflows/expressions/parse_json.py

@@ -0,0 +1,30 @@
+import json
+from typing import Any, Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+_T = TypeVar("_T")
+
+
+class ParseJsonExpression(BaseDescriptor[Any], Generic[_T]):
+    def __init__(
+        self,
+        *,
+        expression: Union[BaseDescriptor[_T], _T],
+    ) -> None:
+        super().__init__(name=f"parse_json({expression})", types=(Any,))  # type: ignore[arg-type]
+        self._expression = expression
+
+    def resolve(self, state: "BaseState") -> Any:
+        value = resolve_value(self._expression, state)
+
+        if not isinstance(value, (str, bytes, bytearray)):
+            raise InvalidExpressionException(f"Expected a string, but got {value} of type {type(value)}")
+
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError as e:
+            raise InvalidExpressionException(f"Failed to parse JSON: {e}") from e

vellum/workflows/expressions/tests/test_expressions.py

@@ -0,0 +1,310 @@
+import pytest
+
+from vellum.workflows.expressions.greater_than import GreaterThanExpression
+from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
+from vellum.workflows.expressions.less_than import LessThanExpression
+from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
+from vellum.workflows.state.base import BaseState
+
+
+class Comparable:
+    """A custom class with two values, where comparisons use a computed metric (multiplication)."""
+
+    def __init__(self, value1, value2):
+        self.value1 = value1  # First numerical value
+        self.value2 = value2  # Second numerical value
+
+    def computed_value(self):
+        return self.value1 * self.value2  # Multiply for comparison
+
+    def __ge__(self, other):
+        if isinstance(other, Comparable):
+            return self.computed_value() >= other.computed_value()
+        elif isinstance(other, (int, float)):
+            return self.computed_value() >= other
+        return NotImplemented
+
+    def __gt__(self, other):
+        if isinstance(other, Comparable):
+            return self.computed_value() > other.computed_value()
+        elif isinstance(other, (int, float)):
+            return self.computed_value() > other
+        return NotImplemented
+
+    def __le__(self, other):
+        if isinstance(other, Comparable):
+            return self.computed_value() <= other.computed_value()
+        elif isinstance(other, (int, float)):
+            return self.computed_value() <= other
+        return NotImplemented
+
+    def __lt__(self, other):
+        if isinstance(other, Comparable):
+            return self.computed_value() < other.computed_value()
+        elif isinstance(other, (int, float)):
+            return self.computed_value() < other
+        return NotImplemented
+
+
+class NonComparable:
+    """A custom class that does not support comparisons."""
+
+    def __init__(self, value1, value2):
+        self.value1 = value1
+        self.value2 = value2
+
+
+class TestState(BaseState):
+    pass
+
+
+def test_greater_than_or_equal_to():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)  # Computed: 4 × 5 = 20
+    obj2 = Comparable(2, 10)  # Computed: 2 × 10 = 20
+    obj3 = Comparable(3, 6)  # Computed: 3 × 6 = 18
+    obj4 = Comparable(5, 5)  # Computed: 5 × 5 = 25
+
+    state = TestState()
+
+    # WHEN comparing objects
+    assert GreaterThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state) is True  # 20 >= 20
+    assert GreaterThanOrEqualToExpression(lhs=obj1, rhs=obj3).resolve(state) is True  # 20 >= 18
+    assert GreaterThanOrEqualToExpression(lhs=obj3, rhs=obj4).resolve(state) is False  # 18 < 25
+
+    # WHEN comparing to raw numbers
+    assert GreaterThanOrEqualToExpression(lhs=obj1, rhs=19).resolve(state) is True  # 20 >= 19
+    assert GreaterThanOrEqualToExpression(lhs=obj3, rhs=20).resolve(state) is False  # 18 < 20
+
+
+def test_greater_than_or_equal_to_invalid():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = "invalid"
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>=' not supported between instances of 'Comparable' and 'str'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>=' not supported between instances of 'str' and 'Comparable'"
+
+
+def test_greater_than_or_equal_to_non_comparable():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = NonComparable(2, 10)
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>=' not supported between instances of 'Comparable' and 'NonComparable'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>=' not supported between instances of 'NonComparable' and 'Comparable'"
+
+
+def test_greater_than():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)  # Computed: 4 × 5 = 20
+    obj2 = Comparable(2, 10)  # Computed: 2 × 10 = 20
+    obj3 = Comparable(3, 6)  # Computed: 3 × 6 = 18
+    obj4 = Comparable(5, 5)  # Computed: 5 × 5 = 25
+
+    state = TestState()
+
+    # WHEN comparing objects
+    assert GreaterThanExpression(lhs=obj1, rhs=obj2).resolve(state) is False  # 20 > 20
+    assert GreaterThanExpression(lhs=obj1, rhs=obj3).resolve(state) is True  # 20 > 18
+    assert GreaterThanExpression(lhs=obj3, rhs=obj4).resolve(state) is False  # 18 < 25
+
+    # WHEN comparing to raw numbers
+    assert GreaterThanExpression(lhs=obj1, rhs=19).resolve(state) is True  # 20 > 19
+    assert GreaterThanExpression(lhs=obj3, rhs=20).resolve(state) is False  # 18 < 20
+
+
+def test_greater_than_invalid():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = "invalid"
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>' not supported between instances of 'Comparable' and 'str'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>' not supported between instances of 'str' and 'Comparable'"
+
+
+def test_greater_than_non_comparable():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = NonComparable(2, 10)
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>' not supported between instances of 'Comparable' and 'NonComparable'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>' not supported between instances of 'NonComparable' and 'Comparable'"
+
+
+def test_less_than_or_equal_to():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)  # Computed: 4 × 5 = 20
+    obj2 = Comparable(2, 10)  # Computed: 2 × 10 = 20
+    obj3 = Comparable(3, 6)  # Computed: 3 × 6 = 18
+    obj4 = Comparable(5, 5)  # Computed: 5 × 5 = 25
+
+    state = TestState()
+
+    # WHEN comparing objects
+    assert LessThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state) is True  # 20 <= 20
+    assert LessThanOrEqualToExpression(lhs=obj1, rhs=obj3).resolve(state) is False  # 20 > 18
+    assert LessThanOrEqualToExpression(lhs=obj3, rhs=obj4).resolve(state) is True  # 18 <= 25
+
+    # WHEN comparing to raw numbers
+    assert LessThanOrEqualToExpression(lhs=obj1, rhs=21).resolve(state) is True  # 20 <= 21
+    assert LessThanOrEqualToExpression(lhs=obj3, rhs=17).resolve(state) is False  # 18 > 17
+
+
+def test_less_than_or_equal_to_invalid():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = "invalid"
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<=' not supported between instances of 'Comparable' and 'str'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<=' not supported between instances of 'str' and 'Comparable'"
+
+
+def test_less_than_or_equal_to_non_comparable():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = NonComparable(2, 10)
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<=' not supported between instances of 'Comparable' and 'NonComparable'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<=' not supported between instances of 'NonComparable' and 'Comparable'"
+
+
+def test_less_than():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)  # Computed: 4 × 5 = 20
+    obj2 = Comparable(2, 10)  # Computed: 2 × 10 = 20
+    obj3 = Comparable(3, 6)  # Computed: 3 × 6 = 18
+    obj4 = Comparable(5, 5)  # Computed: 5 × 5 = 25
+
+    state = TestState()
+
+    # WHEN comparing objects
+    assert LessThanExpression(lhs=obj1, rhs=obj2).resolve(state) is False  # 20 < 20
+    assert LessThanExpression(lhs=obj1, rhs=obj3).resolve(state) is False  # 20 < 18
+    assert LessThanExpression(lhs=obj3, rhs=obj4).resolve(state) is True  # 18 < 25
+
+    # WHEN comparing to raw numbers
+    assert LessThanExpression(lhs=obj1, rhs=21).resolve(state) is True  # 20 < 21
+    assert LessThanExpression(lhs=obj3, rhs=17).resolve(state) is False  # 18 > 17
+
+
+def test_less_than_invalid():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = "invalid"
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<' not supported between instances of 'Comparable' and 'str'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<' not supported between instances of 'str' and 'Comparable'"
+
+
+def test_less_than_non_comparable():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = NonComparable(2, 10)
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<' not supported between instances of 'Comparable' and 'NonComparable'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<' not supported between instances of 'NonComparable' and 'Comparable'"

vellum/workflows/expressions/tests/test_parse_json.py

@@ -0,0 +1,31 @@
+import pytest
+
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.state.base import BaseState
+
+
+def test_parse_json_invalid_json():
+    # GIVEN an invalid JSON string
+    state = BaseState()
+    expression = ConstantValueReference('{"key": value}').parse_json()
+
+    # WHEN we attempt to resolve the expression
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        expression.resolve(state)
+
+    # THEN an exception should be raised
+    assert "Failed to parse JSON" in str(exc_info.value)
+
+
+def test_parse_json_invalid_type():
+    # GIVEN a non-string value
+    state = BaseState()
+    expression = ConstantValueReference(123).parse_json()
+
+    # WHEN we attempt to resolve the expression
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        expression.resolve(state)
+
+    # THEN an exception should be raised
+    assert "Expected a string, but got 123 of type <class 'int'>" == str(exc_info.value)

vellum/workflows/nodes/bases/base.py

@@ -318,9 +318,12 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
             original_base = get_original_base(self.__class__)
 
             args = get_args(original_base)
-            state_type = args[0]
 
-            if isinstance(state_type, TypeVar):
+            if args and len(args) > 0:
+                state_type = args[0]
+                if isinstance(state_type, TypeVar):
+                    state_type = BaseState
+            else:
                 state_type = BaseState
 
             self.state = state_type()

vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py

@@ -5,7 +5,6 @@ from vellum.client.core.api_error import ApiError
 from vellum.workflows.constants import APIRequestMethod, AuthorizationType
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes import APINode
-from vellum.workflows.state import BaseState
 from vellum.workflows.types.core import VellumSecret
 
 
@@ -29,7 +28,7 @@ def test_run_workflow__secrets(vellum_client):
         }
         bearer_token_value = VellumSecret(name="secret")
 
-    node = SimpleBaseAPINode(state=BaseState())
+    node = SimpleBaseAPINode()
     terminal = node.run()
 
     assert vellum_client.execute_api.call_count == 1
@@ -39,7 +38,7 @@ def test_run_workflow__secrets(vellum_client):
 
 
 def test_api_node_raises_error_when_api_call_fails(vellum_client):
-    # Mock the vellum_client to raise an ApiError
+    # GIVEN an API call that fails
     vellum_client.execute_api.side_effect = ApiError(status_code=400, body="API Error")
 
     class SimpleAPINode(APINode):
@@ -54,14 +53,14 @@ def test_api_node_raises_error_when_api_call_fails(vellum_client):
         }
         bearer_token_value = VellumSecret(name="api_key")
 
-    node = SimpleAPINode(state=BaseState())
+    node = SimpleAPINode()
 
-    # Assert that the NodeException is raised
+    # WHEN we run the node
     with pytest.raises(NodeException) as excinfo:
         node.run()
 
-    # Verify that the exception contains some error message
+    # THEN an exception should be raised
     assert "Failed to prepare HTTP request" in str(excinfo.value)
 
-    # Verify the vellum_client was called
+    # AND the API call should have been made
     assert vellum_client.execute_api.call_count == 1

vellum/workflows/nodes/displayable/code_execution_node/node.py

@@ -19,6 +19,7 @@ from vellum import (
     VellumError,
     VellumValue,
 )
+from vellum.client.core.api_error import ApiError
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
 from vellum.core import RequestOptions
 from vellum.workflows.errors.types import WorkflowErrorCode
@@ -103,14 +104,23 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
             input_values = self._compile_code_inputs()
             expected_output_type = primitive_type_to_vellum_variable_type(output_type)
 
-            code_execution_result = self._context.vellum_client.execute_code(
-                input_values=input_values,
-                code=code,
-                runtime=self.runtime,
-                output_type=expected_output_type,
-                packages=self.packages or [],
-                request_options=self.request_options,
-            )
+            try:
+                code_execution_result = self._context.vellum_client.execute_code(
+                    input_values=input_values,
+                    code=code,
+                    runtime=self.runtime,
+                    output_type=expected_output_type,
+                    packages=self.packages or [],
+                    request_options=self.request_options,
+                )
+            except ApiError as e:
+                if e.status_code == 400 and isinstance(e.body, dict) and "message" in e.body:
+                    raise NodeException(
+                        message=e.body["message"],
+                        code=WorkflowErrorCode.INVALID_INPUTS,
+                    )
+
+                raise
 
             if code_execution_result.output.type != expected_output_type:
                 actual_type = code_execution_result.output.type

vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py

@@ -5,6 +5,7 @@ from typing import Any, List, Union
 from pydantic import BaseModel
 
 from vellum import CodeExecutorResponse, NumberVellumValue, StringInput, StringVellumValue
+from vellum.client.errors.bad_request_error import BadRequestError
 from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.code_execution_package import CodeExecutionPackage
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
@@ -17,6 +18,7 @@ from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.displayable.code_execution_node import CodeExecutionNode
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.state.base import BaseState, StateMeta
+from vellum.workflows.types.core import Json
 
 
 def test_run_node__happy_path(vellum_client):
@@ -690,3 +692,54 @@ def main():
         "result": [ChatMessage(role="USER", content=StringChatMessageContent(value="Hello, world!"))],
         "log": "",
     }
+
+
+def test_run_node__execute_code_api_fails__node_exception(vellum_client):
+    # GIVEN a node that will throw a JSON.parse error
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, Json]):
+        code = """\
+async function main(inputs: {
+  data: string,
+}): Promise<string> {
+  return JSON.parse(inputs.data)
+}
+"""
+        code_inputs = {
+            "data": "not a valid json string",
+        }
+        runtime = "TYPESCRIPT_5_3_3"
+
+    # AND the execute_code API will fail
+    message = """\
+Code execution error (exit code 1): undefined:1
+not a valid json string
+ ^
+
+SyntaxError: Unexpected token 'o', \"not a valid\"... is not valid JSON
+    at JSON.parse (<anonymous>)
+    at Object.eval (eval at execute (/workdir/runner.js:16:18), <anonymous>:40:40)
+    at step (eval at execute (/workdir/runner.js:16:18), <anonymous>:32:23)
+    at Object.eval [as next] (eval at execute (/workdir/runner.js:16:18), <anonymous>:13:53)
+    at eval (eval at execute (/workdir/runner.js:16:18), <anonymous>:7:71)
+    at new Promise (<anonymous>)
+    at __awaiter (eval at execute (/workdir/runner.js:16:18), <anonymous>:3:12)
+    at Object.main (eval at execute (/workdir/runner.js:16:18), <anonymous>:38:12)
+    at execute (/workdir/runner.js:17:33)
+    at Interface.<anonymous> (/workdir/runner.js:58:5)
+
+Node.js v21.7.3
+"""
+    vellum_client.execute_code.side_effect = BadRequestError(
+        body={
+            "message": message,
+            "log": "",
+        }
+    )
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # AND the error should contain the execution error details
+    assert exc_info.value.message == message

vellum/workflows/runner/runner.py

@@ -1,5 +1,6 @@
 from collections import defaultdict
 from copy import deepcopy
+from dataclasses import dataclass
 import logging
 from queue import Empty, Queue
 from threading import Event as ThreadingEvent, Thread
@@ -63,6 +64,12 @@ ExternalInputsArg = Dict[ExternalInputReference, Any]
 BackgroundThreadItem = Union[BaseState, WorkflowEvent, None]
 
 
+@dataclass
+class ActiveNode(Generic[StateType]):
+    node: BaseNode[StateType]
+    was_outputs_streamed: bool = False
+
+
 class WorkflowRunner(Generic[StateType]):
     _entrypoints: Iterable[Type[BaseNode]]
 
@@ -136,7 +143,7 @@ class WorkflowRunner(Generic[StateType]):
         self._dependencies: Dict[Type[BaseNode], Set[Type[BaseNode]]] = defaultdict(set)
         self._state_forks: Set[StateType] = {self._initial_state}
 
-        self._active_nodes_by_execution_id: Dict[UUID, BaseNode[StateType]] = {}
+        self._active_nodes_by_execution_id: Dict[UUID, ActiveNode[StateType]] = {}
         self._cancel_signal = cancel_signal
         self._execution_context = init_execution_context or get_execution_context()
         self._parent_context = self._execution_context.parent_context
@@ -404,7 +411,7 @@ class WorkflowRunner(Generic[StateType]):
             current_parent = get_parent_context()
             node = node_class(state=state, context=self.workflow.context)
             state.meta.node_execution_cache.initiate_node_execution(node_class, node_span_id)
-            self._active_nodes_by_execution_id[node_span_id] = node
+            self._active_nodes_by_execution_id[node_span_id] = ActiveNode(node=node)
 
             worker_thread = Thread(
                 target=self._context_run_work_item,
@@ -413,10 +420,11 @@ class WorkflowRunner(Generic[StateType]):
             worker_thread.start()
 
     def _handle_work_item_event(self, event: WorkflowEvent) -> Optional[WorkflowError]:
-        node = self._active_nodes_by_execution_id.get(event.span_id)
-        if not node:
+        active_node = self._active_nodes_by_execution_id.get(event.span_id)
+        if not active_node:
             return None
 
+        node = active_node.node
         if event.name == "node.execution.rejected":
             self._active_nodes_by_execution_id.pop(event.span_id)
             return event.error
@@ -431,6 +439,7 @@ class WorkflowRunner(Generic[StateType]):
                 if node_output_descriptor.name != event.output.name:
                     continue
 
+                active_node.was_outputs_streamed = True
                 self._workflow_event_outer_queue.put(
                     self._stream_workflow_event(
                         BaseOutput(
@@ -447,6 +456,26 @@ class WorkflowRunner(Generic[StateType]):
 
         if event.name == "node.execution.fulfilled":
             self._active_nodes_by_execution_id.pop(event.span_id)
+            if not active_node.was_outputs_streamed:
+                for event_node_output_descriptor, node_output_value in event.outputs:
+                    for workflow_output_descriptor in self.workflow.Outputs:
+                        node_output_descriptor = workflow_output_descriptor.instance
+                        if not isinstance(node_output_descriptor, OutputReference):
+                            continue
+                        if node_output_descriptor.outputs_class != event.node_definition.Outputs:
+                            continue
+                        if node_output_descriptor.name != event_node_output_descriptor.name:
+                            continue
+
+                        self._workflow_event_outer_queue.put(
+                            self._stream_workflow_event(
+                                BaseOutput(
+                                    name=workflow_output_descriptor.name,
+                                    value=node_output_value,
+                                )
+                            )
+                        )
+
             self._handle_invoked_ports(node.state, event.invoked_ports)
 
             return None

vellum/workflows/state/encoder.py

@@ -8,6 +8,7 @@ from typing import Any, Callable, Dict, Type
 
 from pydantic import BaseModel
 
+from vellum.workflows.constants import undefined
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.ports.port import Port
@@ -22,7 +23,7 @@ class DefaultStateEncoder(JSONEncoder):
             return dict(obj)
 
         if isinstance(obj, (BaseInputs, BaseOutputs)):
-            return {descriptor.name: value for descriptor, value in obj}
+            return {descriptor.name: value for descriptor, value in obj if value is not undefined}
 
         if isinstance(obj, (BaseOutput, Port)):
             return obj.serialize()

{vellum_ai-0.14.8.dist-info → vellum_ai-0.14.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.14.8
+Version: 0.14.9
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0

{vellum_ai-0.14.8.dist-info → vellum_ai-0.14.9.dist-info}/RECORD

@@ -23,7 +23,7 @@ vellum_ee/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 vellum_ee/workflows/display/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/base.py,sha256=ak29FIsawhaFa9_paZUHThlZRFJ1xB486JWKuSt1PYY,1965
 vellum_ee/workflows/display/nodes/__init__.py,sha256=436iSAh_Ex5tC68oEYvNgPu05ZVIAVXnS4PKGrQeZ0Y,321
-vellum_ee/workflows/display/nodes/base_node_display.py,sha256=H0sOYd8H7bz9ggSPEs5fwqyp27NAIu4YPNuNB9g0dQA,16289
+vellum_ee/workflows/display/nodes/base_node_display.py,sha256=h4_JqwH_AsT92OK14S3kqssZDjL-uyXnJfo0XcLijK0,16492
 vellum_ee/workflows/display/nodes/base_node_vellum_display.py,sha256=pLO0dORfRu--Ne9NgoyFT_CNjfpr5fGCsgbsMkUF5GM,2845
 vellum_ee/workflows/display/nodes/get_node_display_class.py,sha256=0S6ksPp53WXWh1RQVH71nj2bkCWBj4ZaFYhTxW3N2F4,1230
 vellum_ee/workflows/display/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -56,7 +56,7 @@ vellum_ee/workflows/display/nodes/vellum/tests/test_utils.py,sha256=4YUaTeD_OWF-
 vellum_ee/workflows/display/nodes/vellum/try_node.py,sha256=HBfGz4yt9GlmMW9JxzaCacPnHBDNIeXE8Jhqr9DqLLw,6191
 vellum_ee/workflows/display/nodes/vellum/utils.py,sha256=F_0BrlSszllK_BhryPbojIleLq2dGXOfQD1rVp3fNFg,4733
 vellum_ee/workflows/display/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum_ee/workflows/display/tests/test_vellum_workflow_display.py,sha256=yfTwpPgOzxJBrUz4cb-T8QQf8lF3TYm-Of40usUNOnc,7494
+vellum_ee/workflows/display/tests/test_vellum_workflow_display.py,sha256=cdpUoDNli8ULlNTrU6rnT4TZAIR8mzsG9ZbLrikPybU,8518
 vellum_ee/workflows/display/tests/workflow_serialization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/conftest.py,sha256=A1-tIpC5KIKG9JA_rkd1nLS8zUG3Kb4QiVdvb3boFxE,2509
@@ -83,13 +83,13 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_n
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py,sha256=NdhE3lm7RMQ8DqkraPSq24IbOxNla9unbs4tsMWRzm4,3781
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py,sha256=eD5686C9nWC5s6t08vbAnm9qf9t53gYQM-E1FwAa75c,3035
 vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_node_serialization.py,sha256=huKAOeMJ2MKmp6XtbvMJTUadqynoV40Ypoz9jsBEBEQ,7431
-vellum_ee/workflows/display/types.py,sha256=xDC1zy4rWKNqDtSr-h6MQfWnJ6scZ_Sadxp4t8Q3PY4,2897
+vellum_ee/workflows/display/types.py,sha256=ixfmcQn51Rhsm4_0hWfG0_WpzLE89ZrDZpeYBklsP1Q,2592
 vellum_ee/workflows/display/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/utils/expressions.py,sha256=9FpOslDI-RCR5m4TgAu9KCHh4aTVnh7CHR2ykyMUDw0,1151
 vellum_ee/workflows/display/utils/vellum.py,sha256=UjK_RxnSEmlIu9klGCPWU5RAQBmgZ7cRbRdgxaTbubE,8081
 vellum_ee/workflows/display/vellum.py,sha256=7mqQaKZPPrLMcXSAQkPIxCy5x8HkKs5PbCu3GRaC2o8,8507
 vellum_ee/workflows/display/workflows/__init__.py,sha256=kapXsC67VJcgSuiBMa86FdePG5A9kMB5Pi4Uy1O2ob4,207
-vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=hTX1PQGSpuEiuAjlonyxE9V48UzTy4ReczX-dn8oPeY,18655
+vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=p9Lt1AypyC0Y6WHOUCsk4lYmlgODwg5oz-IDo0UA-1o,18678
 vellum_ee/workflows/display/workflows/get_vellum_workflow_display_class.py,sha256=kp0u8LN_2IwshLrhMImhpZx1hRyAcD5gXY-kDuuaGMQ,1269
 vellum_ee/workflows/display/workflows/tests/test_workflow_display.py,sha256=_yB3-u7_bWdD4lUBWpRdWztJmJL-DXkkZaw9Vy9HH6g,3245
 vellum_ee/workflows/display/workflows/vellum_workflow_display.py,sha256=mbAzCpswOek34ITeTkesbVreCXpulj4NFjIg3RcdVZ8,18243
@@ -115,14 +115,14 @@ vellum_ee/workflows/tests/local_workflow/nodes/final_output.py,sha256=ZX7zBv87zi
 vellum_ee/workflows/tests/local_workflow/nodes/templating_node.py,sha256=NQwFN61QkHfI3Vssz-B0NKGfupK8PU0FDSAIAhYBLi0,325
 vellum_ee/workflows/tests/local_workflow/workflow.py,sha256=A4qOzOPNwePYxWbcAgIPLsmrVS_aVEZEc-wULSv787Q,393
 vellum_ee/workflows/tests/test_display_meta.py,sha256=pzdqND4KLWs7EUIbpXuqgso7BIRpoUsO3T_bgeENs0Q,2205
-vellum_ee/workflows/tests/test_server.py,sha256=SvKUrUPmOf3sIInXcFjETekql60npb4cAn1GPbF0bPs,391
+vellum_ee/workflows/tests/test_server.py,sha256=M6vvQ2hjIpDWtQdDM9EPbMvUrZ93niAuYnxMNJWOjPA,511
 vellum_ee/workflows/tests/test_virtual_files.py,sha256=TJEcMR0v2S8CkloXNmCHA0QW0K6pYNGaIjraJz7sFvY,2762
 vellum/__init__.py,sha256=a_aM1_A04XGma4MAIDNeBF9BKzWbiQaVVMRzImHuxjA,36438
 vellum/client/README.md,sha256=JkCJjmMZl4jrPj46pkmL9dpK4gSzQQmP5I7z4aME4LY,4749
 vellum/client/__init__.py,sha256=tKtdM1_GqmGq1gpi9ydWD_T-MM7fPn8QdHh8ww19cNI,117564
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=NOBkPB9txdePCb8-MgjYVJwNHQWPG9yrRX2B7sxaT-o,1868
+vellum/client/core/client_wrapper.py,sha256=RhAfDORGTXyVqWFHTHUIONrGJRy7OCD049LPC0pwN_k,1868
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=X9IbmkZmB2bB_DpmZAO3crWdXagOakAyn6UCOCImCPg,2322
 vellum/client/core/http_client.py,sha256=R0pQpCppnEtxccGvXl4uJ76s7ro_65Fo_erlNNLp_AI,19228
@@ -1298,9 +1298,9 @@ vellum/workflows/__init__.py,sha256=CssPsbNvN6rDhoLuqpEv7MMKGa51vE6dvAh6U31Pcio,
 vellum/workflows/constants.py,sha256=2yg4_uo5gpqViy3ZLSwfC8qTybleYCtOnhA4Rj6bacM,1310
 vellum/workflows/context.py,sha256=DwSf8lO9NHABiqOoD3exgrjUoRuNsKtutaL5TgRbD-A,1441
 vellum/workflows/descriptors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/descriptors/base.py,sha256=gSib3vJpcI_UC8y8jhdp-hOK3_TGTF-SuwdhxF6x5iQ,14332
+vellum/workflows/descriptors/base.py,sha256=jtT11I5oB-CPWlJBZmc1RcVe4_xOKjimBthiHQHQuT0,14597
 vellum/workflows/descriptors/exceptions.py,sha256=gUy4UD9JFUKSeQnQpeuDSLiRqWjWiIsxLahB7p_q3JY,54
-vellum/workflows/descriptors/tests/test_utils.py,sha256=yrXgu6J6pwqCxJKY3w-i-9t9KKzAkMR7SIICzdcII4k,5266
+vellum/workflows/descriptors/tests/test_utils.py,sha256=xoojJMyG5WLG9xGtmUjirz3lDFCcDsAcxjrtbdG8dNE,6060
 vellum/workflows/descriptors/utils.py,sha256=gmVXJjf2yWmvlYey41J2FZHeSou0JuCHKb3826K_Jok,3838
 vellum/workflows/edges/__init__.py,sha256=wSkmAnz9xyi4vZwtDbKxwlplt2skD7n3NsxkvR_pUus,50
 vellum/workflows/edges/edge.py,sha256=N0SnY3gKVuxImPAdCbPMPlHJIXbkQ3fwq_LbJRvVMFc,677
@@ -1313,9 +1313,9 @@ vellum/workflows/errors/types.py,sha256=tVW7Il9zalnwWzdoDLqYPIvRTOhXIv6FPORZAbU7
 vellum/workflows/events/__init__.py,sha256=6pxxceJo2dcaRkWtkDAYlUQZ-PHBQSZytIoyuUK48Qw,759
 vellum/workflows/events/node.py,sha256=uHT6If0esgZ3nLjrjmUPTKf3qbjGhoV_x5YKpjDBDcU,5280
 vellum/workflows/events/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/events/tests/test_event.py,sha256=9rbp92dQXpGFad-LjE2nYU17neKkiHxQz9X8RsoCWs4,13718
+vellum/workflows/events/tests/test_event.py,sha256=uRfMwSOqU-ROeZKCEngGvvJYlOZuxBhnC3qH5AGi3fM,15399
 vellum/workflows/events/types.py,sha256=cjRE8WL8tYCFradd9NOGl_H0mN3LiWWnA1uHmyT2Q0Q,3412
-vellum/workflows/events/workflow.py,sha256=lveoWXtVRLjdO_nu0z6VlKeTqlGimogamiFR-jYihlE,5184
+vellum/workflows/events/workflow.py,sha256=XtmGG7NRp0TQ4memOJPcaNOs7qMUBbd4WKSZVlxWrCk,5937
 vellum/workflows/exceptions.py,sha256=NiBiR3ggfmPxBVqD-H1SqmjI-7mIn0EStSN1BqApvCM,1213
 vellum/workflows/expressions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/expressions/accessor.py,sha256=ItZF7fMLzVTqsdAiaXb5SiDupXmX0X9xbIus1W6hRds,1870
@@ -1330,8 +1330,8 @@ vellum/workflows/expressions/does_not_end_with.py,sha256=idw2OSuIk02XwBM5CXYOESf
 vellum/workflows/expressions/does_not_equal.py,sha256=LNiCibRZZIxaIrwotjW3SIsKYHWR7BpOItFI-x5KuKU,764
 vellum/workflows/expressions/ends_with.py,sha256=FkWZjAudc_DFM-fK-A3_tr6WXavfs_Qi7F6JtVgMglw,1117
 vellum/workflows/expressions/equals.py,sha256=gbI6BKQR7cLQih226-ge_BFSLprgEjqbdiIxo7WFg_E,758
-vellum/workflows/expressions/greater_than.py,sha256=fTM2YF3FY_eOkRtGpgVWcv8qNt4K3lazONUIqcD8oe8,1263
-vellum/workflows/expressions/greater_than_or_equal_to.py,sha256=sazL_-Jsgjo4jcQeE-6EC0BFHZACriaYMQH4rn0dqEo,1275
+vellum/workflows/expressions/greater_than.py,sha256=1sbUH6Obf-VoBgs7ilIncwYBHYfXliKmShppTuLMtCI,1247
+vellum/workflows/expressions/greater_than_or_equal_to.py,sha256=tsD5ZalB4SlryvEsvVtDkSr5Z13B2pABmHB8oHD8ojs,1276
 vellum/workflows/expressions/in_.py,sha256=RgiAIFntXGN4eWoOVBj1gqLymnBxSiw5hYD3TngF3dk,1123
 vellum/workflows/expressions/is_blank.py,sha256=vOOmK5poXmiNRVH7MR0feIFnL4rwKn7vmmTkJ9TcfVU,904
 vellum/workflows/expressions/is_nil.py,sha256=xCHwhKlm2UnfC-bVedmGgENCrzNtcn4ZeCYwNflVWbU,748
@@ -1341,11 +1341,15 @@ vellum/workflows/expressions/is_not_null.py,sha256=EoHXFgZScKP_BM2a5Z7YFQN6l7RME
 vellum/workflows/expressions/is_not_undefined.py,sha256=9s-RUQBqM17-_nIRvwsHuarLdHVtrxVuwnqBNJEtmh0,735
 vellum/workflows/expressions/is_null.py,sha256=C75ALGlG_sTGcxI46tm9HtgPVfJ7DwTIyKzX8qtEiDU,660
 vellum/workflows/expressions/is_undefined.py,sha256=uUBK3rxYbwoeRq36AGFc7d61hXzTp8UacQAi-1JbaW0,724
-vellum/workflows/expressions/less_than.py,sha256=BcfkUH6Bb2inwR8jILn1hebUiyC74foVijBA-JymwT0,1260
-vellum/workflows/expressions/less_than_or_equal_to.py,sha256=4i1FR6FzlKam29cZPPnXUqACslO242Ww-wZZY4CEK6A,1272
+vellum/workflows/expressions/less_than.py,sha256=chY9puJ6jDB2EinjfyGNrSplJ1NJC-BB-GGSSB33bqI,1237
+vellum/workflows/expressions/less_than_or_equal_to.py,sha256=JtTDBa8yFKy3fGaCOA1tb_5s1JkY8FFnH6kpoeXGnT4,1267
 vellum/workflows/expressions/not_between.py,sha256=ZtRJeJDSSlOvajL8YoBoh5o_khjIn9xSSeQCnXYbHFE,1506
 vellum/workflows/expressions/not_in.py,sha256=pFvwkFPsn3WJw61ssFgM2U1dqWEeglfz4FVT4xwm5Mc,1144
 vellum/workflows/expressions/or_.py,sha256=s-8YdMSSCDS2yijR38kguwok3iqmDMMgDYKV93b4O4s,914
+vellum/workflows/expressions/parse_json.py,sha256=xsk6j3HF7bU1yF6fwt5P9Ugcyd5D9ZXrdng11FRilUI,1088
+vellum/workflows/expressions/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vellum/workflows/expressions/tests/test_expressions.py,sha256=3b6k8xs-CItBBw95NygFLUNoNPKxI4VA1GyWbkMtqyI,11623
+vellum/workflows/expressions/tests/test_parse_json.py,sha256=zpB_qE5_EwWQL7ULQUJm0o1PRSfWZdAqZNW6Ah13oJE,1059
 vellum/workflows/graph/__init__.py,sha256=3sHlay5d_-uD7j3QJXiGl0WHFZZ_QScRvgyDhN2GhHY,74
 vellum/workflows/graph/graph.py,sha256=GGR8cGpSuNWPIiTWNWsj6l70upb5nIxAyFcn7VdaJIs,5506
 vellum/workflows/graph/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1357,7 +1361,7 @@ vellum/workflows/inputs/tests/test_inputs.py,sha256=Haa0Px0obef7rgIddO6wwHF_bzmv
 vellum/workflows/logging.py,sha256=_a217XogktV4Ncz6xKFz7WfYmZAzkfVRVuC0rWob8ls,437
 vellum/workflows/nodes/__init__.py,sha256=aVdQVv7Y3Ro3JlqXGpxwaU2zrI06plDHD2aumH5WUIs,1157
 vellum/workflows/nodes/bases/__init__.py,sha256=cniHuz_RXdJ4TQgD8CBzoiKDiPxg62ErdVpCbWICX64,58
-vellum/workflows/nodes/bases/base.py,sha256=O_O4pVZy0_H-4t2umBMumh_a9TCpmQsBGLcLjlS0vtE,14928
+vellum/workflows/nodes/bases/base.py,sha256=lVHODc1mjUFCorhZfK01zHohOWz9CYz7dnUzA-KENJ4,15036
 vellum/workflows/nodes/bases/base_adornment_node.py,sha256=eFTgsPCYb3eyGS0-kw7C6crFnwFx437R5wh9-8bWYts,2905
 vellum/workflows/nodes/bases/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/bases/tests/test_base_node.py,sha256=4SOdZzvugVtN8CIuo5RrapAxSYGXnxUwQ77dXJ64oTU,6295
@@ -1387,7 +1391,7 @@ vellum/workflows/nodes/displayable/__init__.py,sha256=6F_4DlSwvHuilWnIalp8iDjjDX
 vellum/workflows/nodes/displayable/api_node/__init__.py,sha256=MoxdQSnidIj1Nf_d-hTxlOxcZXaZnsWFDbE-PkTK24o,56
 vellum/workflows/nodes/displayable/api_node/node.py,sha256=QdpsyGVxo5PcN8nwGZpcpW_YMKHr3_VvmbK1BlrdOFk,2547
 vellum/workflows/nodes/displayable/api_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py,sha256=Ta-ZkZvllPHpLamiDRdEtVlwBJUFcvBHpyKLY6q06_A,2309
+vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py,sha256=RtQWnFfq0HNqY2A6c5SdwHl8A91K4Vq8un5UJwwnkSw,2180
 vellum/workflows/nodes/displayable/bases/__init__.py,sha256=0mWIx3qUrzllV7jqt7wN03vWGMuI1WrrLZeMLT2Cl2c,304
 vellum/workflows/nodes/displayable/bases/api_node/__init__.py,sha256=1jwx4WC358CLA1jgzl_UD-rZmdMm2v9Mps39ndwCD7U,64
 vellum/workflows/nodes/displayable/bases/api_node/node.py,sha256=-LOKjU_rY1UWgD0DS5LJwAClBI8N7zrdmwigE3y5rhc,4000
@@ -1403,11 +1407,11 @@ vellum/workflows/nodes/displayable/bases/tests/test_utils.py,sha256=eqdqbKNRWVMD
 vellum/workflows/nodes/displayable/bases/types.py,sha256=C37B2Qh2YP7s7pUjd-EYKc2Zl1TbnCgI_mENuUSb8bo,1706
 vellum/workflows/nodes/displayable/bases/utils.py,sha256=ckMUenSsNkiYmSw6FmjSMHYaCk8Y8_sUjL6lkFFEqts,5412
 vellum/workflows/nodes/displayable/code_execution_node/__init__.py,sha256=0FLWMMktpzSnmBMizQglBpcPrP80fzVsoJwJgf822Cg,76
-vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=_yrQn_uLwy8zVW1RjFMoeomDEsbpbbKK7ifMGEBfNlk,9120
+vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=pdDrjI8wdqMyf52kK6TlSjSU-MRxV2SKDwKcK2LCgkU,9547
 vellum/workflows/nodes/displayable/code_execution_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/code_execution_node/tests/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/code_execution_node/tests/fixtures/main.py,sha256=5QsbmkzSlSbcbWTG_JmIqcP-JNJzOPTKxGzdHos19W4,79
-vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py,sha256=4ADDKsObtUs0PhcWyAjWyQcAF7PGUYE0CxjYp8d-1NM,20637
+vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py,sha256=OTnw5jgX90xWVB3vKryL5QSIr2YnGBz-W0q9C9LpNoc,22471
 vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=BQraIN4I3DCzXLEuBlRYCyp7ote7hQmnnKHu4jFHCCA,5174
 vellum/workflows/nodes/displayable/conditional_node/__init__.py,sha256=AS_EIqFdU1F9t8aLmbZU-rLh9ry6LCJ0uj0D8F0L5Uw,72
 vellum/workflows/nodes/displayable/conditional_node/node.py,sha256=Qjfl33gZ3JEgxBA1EgzSUebboGvsARthIxxcQyvx5Gg,1152
@@ -1466,12 +1470,12 @@ vellum/workflows/references/workflow_input.py,sha256=86IuhlBz-9cGxeUzizyjdp482aj
 vellum/workflows/resolvers/__init__.py,sha256=eH6hTvZO4IciDaf_cf7aM2vs-DkBDyJPycOQevJxQnI,82
 vellum/workflows/resolvers/base.py,sha256=WHra9LRtlTuB1jmuNqkfVE2JUgB61Cyntn8f0b0WZg4,411
 vellum/workflows/runner/__init__.py,sha256=i1iG5sAhtpdsrlvwgH6B-m49JsINkiWyPWs8vyT-bqM,72
-vellum/workflows/runner/runner.py,sha256=XUaAdkG0AEkfPc0ri1j0KXUUqrUfTKmUfQXllgE1yq8,29854
+vellum/workflows/runner/runner.py,sha256=VUGw-QlUNyfwRWjXgBZ1VqKRuYdFC7YdtAmQcsgR6I0,31206
 vellum/workflows/sandbox.py,sha256=GVJzVjMuYzOBnSrboB0_6MMRZWBluAyQ2o7syeaeBd0,2235
 vellum/workflows/state/__init__.py,sha256=yUUdR-_Vl7UiixNDYQZ-GEM_kJI9dnOia75TtuNEsnE,60
 vellum/workflows/state/base.py,sha256=Vkhneko3VlQrPsMLU1PYSzXU_W1u7_AraJsghiv5O-4,15512
 vellum/workflows/state/context.py,sha256=yePVr4CCTQn5bjo1697JOO24fKFQpVNzooL07xL4gL0,2702
-vellum/workflows/state/encoder.py,sha256=WdUidpOaBDx5lilJl8V8McFDHQYiCLCJR9dmktdzdZY,1836
+vellum/workflows/state/encoder.py,sha256=TnOQojc5lTQ83g9QbpA4UCqShJvutmTMxbpKt-9gNe4,1911
 vellum/workflows/state/store.py,sha256=VYGBQgN1bpd1as5eGiouV_7scg8QsRs4_1aqZAGIsRQ,793
 vellum/workflows/state/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/state/tests/test_state.py,sha256=jBynFR4m74Vn51DdmKBLkxb1loTy1CnJPtzPmdAFQUo,5159
@@ -1502,8 +1506,8 @@ vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnad
 vellum/workflows/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/workflows/tests/test_base_workflow.py,sha256=NRteiICyJvDM5zrtUfq2fZoXcGQVaWC9xmNlLLVW0cU,7979
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-0.14.8.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.8.dist-info/METADATA,sha256=rjXn1UMzW7AdriljPfHof7rjjp7GseRXLTfRswDoSBc,5407
-vellum_ai-0.14.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.8.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.8.dist-info/RECORD,,
+vellum_ai-0.14.9.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.9.dist-info/METADATA,sha256=JO_Tqa4ayXrL4ytBbrfiXfly8yXeiPyQc-4NOoL9kDk,5407
+vellum_ai-0.14.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.9.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.9.dist-info/RECORD,,

vellum_ee/workflows/display/nodes/base_node_display.py

@@ -27,6 +27,7 @@ from vellum.workflows.expressions.is_not_undefined import IsNotUndefinedExpressi
 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.expressions.parse_json import ParseJsonExpression
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.utils import get_wrapped_node
 from vellum.workflows.ports import Port
@@ -386,6 +387,9 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 "node_id": str(node_class_display.node_id),
             }
 
+        if isinstance(value, ParseJsonExpression):
+            raise ValueError("ParseJsonExpression is not supported in the UI")
+
         if not isinstance(value, BaseDescriptor):
             vellum_value = primitive_to_vellum_value(value)
             return {

vellum_ee/workflows/display/tests/test_vellum_workflow_display.py

@@ -1,3 +1,4 @@
+import pytest
 from uuid import UUID
 from typing import Dict
 
@@ -228,3 +229,33 @@ def test_vellum_workflow_display__serialize_with_unused_nodes_and_edges():
             break
 
     assert edge_found, "Edge between unused nodes NodeB and NodeC not found in serialized output"
+
+
+def test_parse_json_not_supported_in_ui():
+    """
+    Test that verifies ParseJsonExpression is not yet supported in the UI.
+    This test should fail once UI support is added, at which point it should be updated.
+    """
+    # GIVEN a workflow that uses the parse_json function
+    from vellum.workflows.references.constant import ConstantValueReference
+
+    class JsonNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            json_result = ConstantValueReference('{"key": "value"}').parse_json()
+
+    class Workflow(BaseWorkflow):
+        graph = JsonNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final = JsonNode.Outputs.json_result
+
+    # WHEN we attempt to serialize it
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay,
+        workflow_class=Workflow,
+    )
+
+    with pytest.raises(ValueError) as exc_info:
+        workflow_display.serialize()
+
+    assert "ParseJsonExpression is not supported in the UI" == str(exc_info.value)

vellum_ee/workflows/display/types.py

@@ -1,9 +1,8 @@
 from dataclasses import dataclass, field
-from uuid import UUID
 from typing import TYPE_CHECKING, Dict, Generic, Tuple, Type, TypeVar
 
-from vellum.client.core import UniversalBaseModel
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.events.workflow import WorkflowEventDisplayContext  # noqa: F401
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.ports import Port
 from vellum.workflows.references import OutputReference, StateValueReference, WorkflowInputReference
@@ -25,18 +24,6 @@ NodeDisplayType = TypeVar("NodeDisplayType", bound="BaseNodeDisplay")
 WorkflowDisplayType = TypeVar("WorkflowDisplayType", bound="BaseWorkflowDisplay")
 
 
-class NodeDisplay(UniversalBaseModel):
-    input_display: Dict[str, UUID]
-    output_display: Dict[str, UUID]
-    port_display: Dict[str, UUID]
-
-
-class WorkflowEventDisplayContext(UniversalBaseModel):
-    node_displays: Dict[str, NodeDisplay]
-    workflow_inputs: Dict[str, UUID]
-    workflow_outputs: Dict[str, UUID]
-
-
 @dataclass
 class WorkflowDisplayContext(
     Generic[

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -9,6 +9,7 @@ from typing import Any, Dict, Generic, Iterator, List, Optional, Tuple, Type, Un
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.edges import Edge
+from vellum.workflows.events.workflow import NodeDisplay, WorkflowEventDisplayContext
 from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.utils import get_wrapped_node
@@ -33,12 +34,7 @@ from vellum_ee.workflows.display.base import (
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay, PortDisplayOverrides
-from vellum_ee.workflows.display.types import (
-    NodeDisplay,
-    NodeDisplayType,
-    WorkflowDisplayContext,
-    WorkflowEventDisplayContext,
-)
+from vellum_ee.workflows.display.types import NodeDisplayType, WorkflowDisplayContext
 
 logger = logging.getLogger(__name__)
 

vellum_ee/workflows/tests/test_server.py

@@ -2,6 +2,7 @@ from vellum.client.core.pydantic_utilities import UniversalBaseModel
 
 
 def test_load_workflow_event_display_context():
+    # DEPRECATED: Use `vellum.workflows.events.workflow.WorkflowEventDisplayContext` instead. Will be removed in 0.15.0
     from vellum_ee.workflows.display.types import WorkflowEventDisplayContext
 
     # We are actually just ensuring there are no circular dependencies when