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

vellum/__init__.py

@@ -83,6 +83,7 @@ from .types import (
     DocumentIndexIndexingConfigRequest,
     DocumentIndexRead,
     DocumentProcessingState,
+    DocumentPromptBlock,
     DocumentRead,
     DocumentStatus,
     DocumentVellumValue,
@@ -623,6 +624,7 @@ __all__ = [
     "DocumentIndexRead",
     "DocumentIndexesListRequestStatus",
     "DocumentProcessingState",
+    "DocumentPromptBlock",
     "DocumentRead",
     "DocumentStatus",
     "DocumentVellumValue",

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.7",
+            "X-Fern-SDK-Version": "0.14.9",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/client/types/__init__.py

@@ -87,6 +87,7 @@ from .document_index_indexing_config import DocumentIndexIndexingConfig
 from .document_index_indexing_config_request import DocumentIndexIndexingConfigRequest
 from .document_index_read import DocumentIndexRead
 from .document_processing_state import DocumentProcessingState
+from .document_prompt_block import DocumentPromptBlock
 from .document_read import DocumentRead
 from .document_status import DocumentStatus
 from .document_vellum_value import DocumentVellumValue
@@ -611,6 +612,7 @@ __all__ = [
     "DocumentIndexIndexingConfigRequest",
     "DocumentIndexRead",
     "DocumentProcessingState",
+    "DocumentPromptBlock",
     "DocumentRead",
     "DocumentStatus",
     "DocumentVellumValue",

vellum/client/types/document_prompt_block.py

@@ -0,0 +1,29 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from .prompt_block_state import PromptBlockState
+from .ephemeral_prompt_cache_config import EphemeralPromptCacheConfig
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class DocumentPromptBlock(UniversalBaseModel):
+    """
+    A block that represents a document in a prompt template.
+    """
+
+    block_type: typing.Literal["DOCUMENT"] = "DOCUMENT"
+    state: typing.Optional[PromptBlockState] = None
+    cache_config: typing.Optional[EphemeralPromptCacheConfig] = None
+    src: str
+    metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vellum/client/types/prompt_block.py

@@ -8,6 +8,7 @@ from .rich_text_prompt_block import RichTextPromptBlock
 from .audio_prompt_block import AudioPromptBlock
 from .function_call_prompt_block import FunctionCallPromptBlock
 from .image_prompt_block import ImagePromptBlock
+from .document_prompt_block import DocumentPromptBlock
 import typing
 
 if typing.TYPE_CHECKING:
@@ -20,4 +21,5 @@ PromptBlock = typing.Union[
     AudioPromptBlock,
     FunctionCallPromptBlock,
     ImagePromptBlock,
+    DocumentPromptBlock,
 ]

vellum/types/document_prompt_block.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.document_prompt_block import *

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