vellum-ai 0.14.8__tar.gz → 0.14.10__tar.gz

{vellum_ai-0.14.8 → vellum_ai-0.14.10}/PKG-INFO

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

{vellum_ai-0.14.8 → vellum_ai-0.14.10}/ee/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_ai-0.14.8 → vellum_ai-0.14.10}/ee/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_ai-0.14.8 → vellum_ai-0.14.10}/ee/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_ai-0.14.8 → vellum_ai-0.14.10}/ee/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 NodeEventDisplayContext, 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,9 @@ 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.nodes.utils import raise_if_descriptor
+from vellum_ee.workflows.display.types import NodeDisplayType, WorkflowDisplayContext
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 logger = logging.getLogger(__name__)
 
@@ -387,10 +385,15 @@ class BaseWorkflowDisplay(
         except ModuleNotFoundError:
             return None
 
-        display_context = display_class.WorkflowDisplay(workflow_class).display_context
-        if not isinstance(display_context, WorkflowDisplayContext):
+        workflow_display = display_class.WorkflowDisplay(workflow_class)
+        if not isinstance(workflow_display, BaseWorkflowDisplay):
             return None
 
+        return workflow_display.get_event_display_context()
+
+    def get_event_display_context(self):
+        display_context = self.display_context
+
         workflow_outputs = {
             output.name: display_context.workflow_output_displays[output].id
             for output in display_context.workflow_output_displays
@@ -402,27 +405,44 @@ class BaseWorkflowDisplay(
         node_displays = {
             str(node.__id__): display_context.node_displays[node] for node in display_context.node_displays
         }
-        temp_node_displays = {}
-        for node in node_displays:
-            current_node = node_displays[node]
+        node_event_displays = {}
+        for node_id in node_displays:
+            current_node_display = node_displays[node_id]
             input_display = {}
-            if isinstance(current_node, BaseNodeVellumDisplay):
-                input_display = current_node.node_input_ids_by_name
+            if isinstance(current_node_display, BaseNodeVellumDisplay):
+                input_display = current_node_display.node_input_ids_by_name
             node_display_meta = {
-                output.name: current_node.output_display[output].id for output in current_node.output_display
+                output.name: current_node_display.output_display[output].id
+                for output in current_node_display.output_display
             }
-            port_display_meta = {port.name: current_node.port_displays[port].id for port in current_node.port_displays}
-
-            temp_node_displays[node] = NodeDisplay(
+            port_display_meta = {
+                port.name: current_node_display.port_displays[port].id for port in current_node_display.port_displays
+            }
+            node = current_node_display._node
+            subworkflow_display_context: Optional[WorkflowEventDisplayContext] = None
+            if hasattr(node, "subworkflow"):
+                # All nodes that have a subworkflow attribute are currently expected to call them `subworkflow`
+                # This will change if in the future we decide to support multiple subworkflows on a single node
+                subworkflow_attribute = raise_if_descriptor(getattr(node, "subworkflow"))
+                if issubclass(subworkflow_attribute, BaseWorkflow):
+                    subworkflow_display = get_workflow_display(
+                        base_display_class=display_context.workflow_display_class,
+                        workflow_class=subworkflow_attribute,
+                        parent_display_context=display_context,
+                    )
+                    subworkflow_display_context = subworkflow_display.get_event_display_context()
+
+            node_event_displays[node_id] = NodeEventDisplayContext(
                 input_display=input_display,
                 output_display=node_display_meta,
                 port_display=port_display_meta,
+                subworkflow_display=subworkflow_display_context,
             )
 
         display_meta = WorkflowEventDisplayContext(
             workflow_outputs=workflow_outputs,
             workflow_inputs=workflow_inputs,
-            node_displays=temp_node_displays,
+            node_displays=node_event_displays,
         )
         return display_meta
 

{vellum_ai-0.14.8 → vellum_ai-0.14.10}/ee/vellum_ee/workflows/display/workflows/tests/test_workflow_display.py

@@ -1,6 +1,7 @@
 import pytest
 
 from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.nodes import BaseNodeDisplay
 from vellum_ee.workflows.display.vellum import NodeDisplayData, NodeDisplayPosition
@@ -92,3 +93,29 @@ def test_serialize_workflow__node_display_class_not_registered():
 
     # THEN it should should succeed
     assert data is not None
+
+
+def test_get_event_display_context__node_display_to_include_subworkflow_display():
+    # GIVEN a simple workflow
+    class InnerNode(BaseNode):
+        pass
+
+    class Subworkflow(BaseWorkflow):
+        graph = InnerNode
+
+    # AND a workflow that includes the subworkflow
+    class SubworkflowNode(InlineSubworkflowNode):
+        subworkflow = Subworkflow
+
+    class MyWorkflow(BaseWorkflow):
+        graph = SubworkflowNode
+
+    # WHEN we gather the event display context
+    display_context = VellumWorkflowDisplay(MyWorkflow).get_event_display_context()
+
+    # THEN the subworkflow display should be included
+    assert str(SubworkflowNode.__id__) in display_context.node_displays
+    node_event_display = display_context.node_displays[str(SubworkflowNode.__id__)]
+
+    assert node_event_display.subworkflow_display is not None
+    assert str(InnerNode.__id__) in node_event_display.subworkflow_display.node_displays

{vellum_ai-0.14.8 → vellum_ai-0.14.10}/ee/vellum_ee/workflows/tests/test_display_meta.py

@@ -40,11 +40,13 @@ def test_base_class_dynamic_import(files):
                 },
                 "output_display": {"result": UUID("423bc529-1a1a-4f72-af4d-cbdb5f0a5929")},
                 "port_display": {"default": UUID("afda9a19-0618-42e1-9b63-5d0db2a88f62")},
+                "subworkflow_display": None,
             },
             "f3ef4b2b-fec9-4026-9cc6-e5eac295307f": {
                 "input_display": {"node_input": UUID("fe6cba85-2423-4b5e-8f85-06311a8be5fb")},
                 "output_display": {"value": UUID("5469b810-6ea6-4362-9e79-e360d44a1405")},
                 "port_display": {},
+                "subworkflow_display": None,
             },
         },
         "workflow_inputs": {"input_value": UUID("2268a996-bd17-4832-b3ff-f5662d54b306")},

{vellum_ai-0.14.8 → vellum_ai-0.14.10}/ee/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

{vellum_ai-0.14.8 → vellum_ai-0.14.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.14.8"
+version = "0.14.10"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.14.8 → vellum_ai-0.14.10}/src/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.10",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.14.8 → vellum_ai-0.14.10}/src/vellum/utils/templating/render.py

@@ -2,6 +2,7 @@ import json
 from typing import Any, Dict, Optional
 
 from jinja2.sandbox import SandboxedEnvironment
+from pydantic import BaseModel
 
 from vellum.utils.templating.constants import FilterFunc
 from vellum.utils.templating.exceptions import JinjaTemplateError
@@ -12,6 +13,9 @@ def finalize(obj: Any) -> str:
     if isinstance(obj, (dict, list)):
         return json.dumps(obj, cls=DefaultStateEncoder)
 
+    if isinstance(obj, BaseModel):
+        return json.dumps(obj.model_dump(), cls=DefaultStateEncoder)
+
     return str(obj)
 
 
@@ -23,7 +27,6 @@ def render_sandboxed_jinja_template(
     jinja_globals: Optional[Dict[str, Any]] = None,
 ) -> str:
     """Render a Jinja template within a sandboxed environment."""
-
     try:
         environment = SandboxedEnvironment(
             keep_trailing_newline=True,

{vellum_ai-0.14.8 → vellum_ai-0.14.10}/src/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_ai-0.14.8 → vellum_ai-0.14.10}/src/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_ai-0.14.8 → vellum_ai-0.14.10}/src/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_ai-0.14.8 → vellum_ai-0.14.10}/src/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,27 @@ class _BaseWorkflowEvent(BaseEvent):
         return self.body.workflow_definition
 
 
+class NodeEventDisplayContext(UniversalBaseModel):
+    input_display: Dict[str, UUID]
+    output_display: Dict[str, UUID]
+    port_display: Dict[str, UUID]
+    subworkflow_display: Optional["WorkflowEventDisplayContext"] = None
+
+
+class WorkflowEventDisplayContext(UniversalBaseModel):
+    node_displays: Dict[str, NodeEventDisplayContext]
+    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_ai-0.14.8 → vellum_ai-0.14.10}/src/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_ai-0.14.8 → vellum_ai-0.14.10}/src/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_ai-0.14.8 → vellum_ai-0.14.10}/src/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_ai-0.14.8 → vellum_ai-0.14.10}/src/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_ai-0.14.10/src/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