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

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

@@ -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 → vellum_ai-0.14.9}/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.9}/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.9}/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.9}/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 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_ai-0.14.8 → vellum_ai-0.14.9}/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.9}/pyproject.toml

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

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

{vellum_ai-0.14.8 → vellum_ai-0.14.9}/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.9}/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.9}/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.9}/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,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_ai-0.14.8 → vellum_ai-0.14.9}/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.9}/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.9}/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.9}/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.9/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