vellum-ai 0.14.8__py3-none-any.whl → 0.14.10__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.10",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

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/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,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/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