vellum-ai 0.12.2__tar.gz → 0.12.4__tar.gz

{vellum_ai-0.12.2 → vellum_ai-0.12.4}/PKG-INFO

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

{vellum_ai-0.12.2 → vellum_ai-0.12.4}/ee/vellum_ee/workflows/display/nodes/vellum/conditional_node.py

@@ -16,8 +16,12 @@ from vellum.workflows.expressions.equals import EqualsExpression
 from vellum.workflows.expressions.greater_than import GreaterThanExpression
 from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
 from vellum.workflows.expressions.in_ import InExpression
+from vellum.workflows.expressions.is_nil import IsNilExpression
+from vellum.workflows.expressions.is_not_nil import IsNotNilExpression
 from vellum.workflows.expressions.is_not_null import IsNotNullExpression
+from vellum.workflows.expressions.is_not_undefined import IsNotUndefinedExpression
 from vellum.workflows.expressions.is_null import IsNullExpression
+from vellum.workflows.expressions.is_undefined import IsUndefinedExpression
 from vellum.workflows.expressions.less_than import LessThanExpression
 from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
 from vellum.workflows.expressions.not_between import NotBetweenExpression
@@ -242,9 +246,9 @@ but the defined conditions have length {len(condition_ids)}"""
             return "doesNotBeginWith"
         elif isinstance(descriptor, DoesNotEndWithExpression):
             return "doesNotEndWith"
-        elif isinstance(descriptor, IsNullExpression):
+        elif isinstance(descriptor, (IsNullExpression, IsNilExpression, IsUndefinedExpression)):
             return "null"
-        elif isinstance(descriptor, IsNotNullExpression):
+        elif isinstance(descriptor, (IsNotNullExpression, IsNotNilExpression, IsNotUndefinedExpression)):
             return "notNull"
         elif isinstance(descriptor, InExpression):
             return "in"

{vellum_ai-0.12.2 → vellum_ai-0.12.4}/ee/vellum_ee/workflows/display/utils/vellum.py

@@ -9,7 +9,6 @@ from vellum.workflows.references import OutputReference, WorkflowInputReference
 from vellum.workflows.references.execution_count import ExecutionCountReference
 from vellum.workflows.references.node import NodeReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
-from vellum.workflows.types.core import VellumValuePrimitive
 from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
 from vellum.workflows.vellum_client import create_vellum_client
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -93,7 +92,7 @@ def create_node_input_value_pointer_rule(
     raise ValueError(f"Unsupported descriptor type: {value.__class__.__name__}")
 
 
-def primitive_to_vellum_value(value: VellumValuePrimitive) -> VellumValue:
+def primitive_to_vellum_value(value: Any) -> VellumValue:
     """Converts a python primitive to a VellumVariableValue"""
 
     if isinstance(value, str):

{vellum_ai-0.12.2 → vellum_ai-0.12.4}/pyproject.toml

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

{vellum_ai-0.12.2 → vellum_ai-0.12.4}/src/vellum/client/core/client_wrapper.py

@@ -1,10 +1,11 @@
 # This file was auto-generated by Fern from our API Definition.
 
-from ..environment import VellumEnvironment
 import typing
+
 import httpx
-from .http_client import HttpClient
-from .http_client import AsyncHttpClient
+
+from ..environment import VellumEnvironment
+from .http_client import AsyncHttpClient, HttpClient
 
 
 class BaseClientWrapper:
@@ -17,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.12.2",
+            "X-Fern-SDK-Version": "0.12.4",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.12.2 → vellum_ai-0.12.4}/src/vellum/client/types/prompt_request_json_input.py

@@ -13,7 +13,7 @@ class PromptRequestJsonInput(UniversalBaseModel):
     """
 
     type: typing.Literal["JSON"] = "JSON"
-    value: typing.Dict[str, typing.Optional[typing.Any]]
+    value: 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

{vellum_ai-0.12.2 → vellum_ai-0.12.4}/src/vellum/plugins/vellum_mypy.py

@@ -172,41 +172,39 @@ class VellumMypyPlugin(Plugin):
 
     def _dynamic_output_node_class_hook(self, ctx: ClassDefContext, attribute_name: str) -> None:
         """
-        We use this hook to properly annotate the Outputs class for Templating Node using the resolved type
-        of the TemplatingNode's class _OutputType generic.
+        We use this hook to properly annotate the Outputs class for Templating Node and
+        Code Execution Node using the resolved type
+        of the TemplatingNode's and CodeExecutionNode's class _OutputType generic.
         """
-
-        templating_node_info = ctx.cls.info
-        templating_node_bases = ctx.cls.info.bases
-        if not templating_node_bases:
+        node_info = ctx.cls.info
+        node_bases = ctx.cls.info.bases
+        if not node_bases:
             return
-        if not isinstance(templating_node_bases[0], Instance):
+        if not isinstance(node_bases[0], Instance):
             return
 
-        base_templating_args = templating_node_bases[0].args
-        base_templating_node = templating_node_bases[0].type
-        if not _is_subclass(base_templating_node, "vellum.workflows.nodes.core.templating_node.node.TemplatingNode"):
-            return
+        base_args = node_bases[0].args
+        base_node = node_bases[0].type
 
-        if len(base_templating_args) != 2:
+        if len(base_args) != 2:
             return
 
-        base_templating_node_resolved_type = base_templating_args[1]
-        if isinstance(base_templating_node_resolved_type, AnyType):
-            base_templating_node_resolved_type = ctx.api.named_type("builtins.str")
+        base_node_resolved_type = base_args[1]
+        if isinstance(base_node_resolved_type, AnyType):
+            base_node_resolved_type = ctx.api.named_type("builtins.str")
 
-        base_templating_node_outputs = base_templating_node.names.get("Outputs")
-        if not base_templating_node_outputs:
+        base_node_outputs = base_node.names.get("Outputs")
+        if not base_node_outputs:
             return
 
-        current_templating_node_outputs = templating_node_info.names.get("Outputs")
-        if not current_templating_node_outputs:
-            templating_node_info.names["Outputs"] = base_templating_node_outputs.copy()
-            new_outputs_sym = templating_node_info.names["Outputs"].node
+        current_node_outputs = node_info.names.get("Outputs")
+        if not current_node_outputs:
+            node_info.names["Outputs"] = base_node_outputs.copy()
+            new_outputs_sym = node_info.names["Outputs"].node
             if isinstance(new_outputs_sym, TypeInfo):
                 result_sym = new_outputs_sym.names[attribute_name].node
                 if isinstance(result_sym, Var):
-                    result_sym.type = base_templating_node_resolved_type
+                    result_sym.type = base_node_resolved_type
 
     def _base_node_class_hook(self, ctx: ClassDefContext) -> None:
         """
@@ -233,7 +231,6 @@ class VellumMypyPlugin(Plugin):
             type_ = sym.node.type
             if not type_:
                 continue
-
             sym.node.type = self._get_resolvable_type(
                 lambda fullname, types: ctx.api.named_type(fullname, types), type_
             )

{vellum_ai-0.12.2 → vellum_ai-0.12.4}/src/vellum/workflows/descriptors/base.py

@@ -17,7 +17,9 @@ if TYPE_CHECKING:
     from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
     from vellum.workflows.expressions.in_ import InExpression
     from vellum.workflows.expressions.is_blank import IsBlankExpression
+    from vellum.workflows.expressions.is_nil import IsNilExpression
     from vellum.workflows.expressions.is_not_blank import IsNotBlankExpression
+    from vellum.workflows.expressions.is_not_nil import IsNotNilExpression
     from vellum.workflows.expressions.is_not_null import IsNotNullExpression
     from vellum.workflows.expressions.is_not_undefined import IsNotUndefinedExpression
     from vellum.workflows.expressions.is_null import IsNullExpression
@@ -268,6 +270,16 @@ class BaseDescriptor(Generic[_T]):
 
         return IsNotNullExpression(expression=self)
 
+    def is_nil(self) -> "IsNilExpression":
+        from vellum.workflows.expressions.is_nil import IsNilExpression
+
+        return IsNilExpression(expression=self)
+
+    def is_not_nil(self) -> "IsNotNilExpression":
+        from vellum.workflows.expressions.is_not_nil import IsNotNilExpression
+
+        return IsNotNilExpression(expression=self)
+
     def is_undefined(self) -> "IsUndefinedExpression":
         from vellum.workflows.expressions.is_undefined import IsUndefinedExpression
 

{vellum_ai-0.12.2 → vellum_ai-0.12.4}/src/vellum/workflows/descriptors/tests/test_utils.py

@@ -1,6 +1,7 @@
 import pytest
 
 from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.state.base import BaseState
 
 
@@ -16,6 +17,13 @@ class FixtureState(BaseState):
         "foo": "bar",
     }
 
+    eta = None
+
+
+class DummyNode(BaseNode[FixtureState]):
+    class Outputs(BaseNode.Outputs):
+        empty: str
+
 
 @pytest.mark.parametrize(
     ["descriptor", "expected_value"],
@@ -36,7 +44,23 @@ class FixtureState(BaseState):
         (FixtureState.gamma.does_not_begin_with(FixtureState.delta), True),
         (FixtureState.gamma.does_not_end_with(FixtureState.delta), True),
         (FixtureState.alpha.is_null(), False),
+        (FixtureState.eta.is_null(), True),
+        (DummyNode.Outputs.empty.is_null(), False),
         (FixtureState.alpha.is_not_null(), True),
+        (FixtureState.eta.is_not_null(), False),
+        (DummyNode.Outputs.empty.is_not_null(), True),
+        (FixtureState.alpha.is_nil(), False),
+        (FixtureState.eta.is_nil(), True),
+        (DummyNode.Outputs.empty.is_nil(), True),
+        (FixtureState.alpha.is_not_nil(), True),
+        (FixtureState.eta.is_not_nil(), False),
+        (DummyNode.Outputs.empty.is_not_nil(), False),
+        (FixtureState.alpha.is_undefined(), False),
+        (FixtureState.eta.is_undefined(), False),
+        (DummyNode.Outputs.empty.is_undefined(), True),
+        (FixtureState.alpha.is_not_undefined(), True),
+        (FixtureState.eta.is_not_undefined(), True),
+        (DummyNode.Outputs.empty.is_not_undefined(), False),
         (FixtureState.delta.in_(FixtureState.gamma), True),
         (FixtureState.delta.not_in(FixtureState.gamma), False),
         (FixtureState.alpha.between(FixtureState.beta, FixtureState.epsilon), False),
@@ -66,8 +90,24 @@ class FixtureState(BaseState):
         "does_not_contain",
         "does_not_begin_with",
         "does_not_end_with",
-        "is_null",
-        "is_not_null",
+        "is_null_on_value",
+        "is_null_on_null",
+        "is_null_on_undefined",
+        "is_not_null_on_value",
+        "is_not_null_on_null",
+        "is_not_null_on_undefined",
+        "is_nil_on_value",
+        "is_nil_on_null",
+        "is_nil_on_undefined",
+        "is_not_nil_on_value",
+        "is_not_nil_on_null",
+        "is_not_nil_on_undefined",
+        "is_undefined_on_value",
+        "is_undefined_on_null",
+        "is_undefined_on_undefined",
+        "is_not_undefined_on_value",
+        "is_not_undefined_on_null",
+        "is_not_undefined_on_undefined",
         "in_",
         "not_in",
         "between",

vellum_ai-0.12.4/src/vellum/workflows/expressions/is_nil.py

@@ -0,0 +1,22 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.constants import UNDEF
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+_T = TypeVar("_T")
+
+
+class IsNilExpression(BaseDescriptor[bool], Generic[_T]):
+    def __init__(
+        self,
+        *,
+        expression: Union[BaseDescriptor[_T], _T],
+    ) -> None:
+        super().__init__(name=f"{expression} is null or undefined", types=(bool,))
+        self._expression = expression
+
+    def resolve(self, state: "BaseState") -> bool:
+        expression = resolve_value(self._expression, state)
+        return expression is None or expression is UNDEF

vellum_ai-0.12.4/src/vellum/workflows/expressions/is_not_nil.py

@@ -0,0 +1,22 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.constants import UNDEF
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+_T = TypeVar("_T")
+
+
+class IsNotNilExpression(BaseDescriptor[bool], Generic[_T]):
+    def __init__(
+        self,
+        *,
+        expression: Union[BaseDescriptor[_T], _T],
+    ) -> None:
+        super().__init__(name=f"{expression} is not null and not undefined", types=(bool,))
+        self._expression = expression
+
+    def resolve(self, state: "BaseState") -> bool:
+        expression = resolve_value(self._expression, state)
+        return expression is not None and expression is not UNDEF

{vellum_ai-0.12.2 → vellum_ai-0.12.4}/src/vellum/workflows/expressions/is_not_null.py

@@ -13,7 +13,7 @@ class IsNotNullExpression(BaseDescriptor[bool], Generic[_T]):
         *,
         expression: Union[BaseDescriptor[_T], _T],
     ) -> None:
-        super().__init__(name=f"{expression} is not None", types=(bool,))
+        super().__init__(name=f"{expression} is not null", types=(bool,))
         self._expression = expression
 
     def resolve(self, state: "BaseState") -> bool:

{vellum_ai-0.12.2 → vellum_ai-0.12.4}/src/vellum/workflows/expressions/is_null.py

@@ -13,7 +13,7 @@ class IsNullExpression(BaseDescriptor[bool], Generic[_T]):
         *,
         expression: Union[BaseDescriptor[_T], _T],
     ) -> None:
-        super().__init__(name=f"{expression} is None", types=(bool,))
+        super().__init__(name=f"{expression} is null", types=(bool,))
         self._expression = expression
 
     def resolve(self, state: "BaseState") -> bool:

{vellum_ai-0.12.2 → vellum_ai-0.12.4}/src/vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -1,3 +1,4 @@
+import json
 from uuid import uuid4
 from typing import ClassVar, Generic, Iterator, List, Optional, Tuple, cast
 
@@ -18,6 +19,7 @@ from vellum.client import RequestOptions
 from vellum.workflows.constants import OMIT
 from vellum.workflows.context import get_parent_context
 from vellum.workflows.errors import WorkflowErrorCode
+from vellum.workflows.events.types import default_serializer
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases.base_prompt_node import BasePromptNode
 from vellum.workflows.nodes.displayable.bases.inline_prompt_node.constants import DEFAULT_PROMPT_PARAMETERS
@@ -108,19 +110,30 @@ class BaseInlinePromptNode(BasePromptNode, Generic[StateType]):
                         value=cast(List[ChatMessage], input_value),
                     )
                 )
-            elif isinstance(input_value, dict):
-                # Note: We may want to fail early here if we know that input_value is not
-                #   JSON serializable.
+            else:
+                try:
+                    input_value = default_serializer(input_value)
+                except json.JSONDecodeError as e:
+                    raise NodeException(
+                        message=f"Failed to serialize input '{input_name}' of type '{input_value.__class__}': {e}",
+                        code=WorkflowErrorCode.INVALID_INPUTS,
+                    )
+
+                input_variables.append(
+                    VellumVariable(
+                        # TODO: Determine whether or not we actually need an id here and if we do,
+                        #   figure out how to maintain stable id references.
+                        #   https://app.shortcut.com/vellum/story/4080
+                        id=str(uuid4()),
+                        key=input_name,
+                        type="JSON",
+                    )
+                )
                 input_values.append(
                     PromptRequestJsonInput(
                         key=input_name,
                         value=input_value,
                     )
                 )
-            else:
-                raise NodeException(
-                    message=f"Unrecognized input type for input '{input_name}': {input_value.__class__}",
-                    code=WorkflowErrorCode.INVALID_INPUTS,
-                )
 
         return input_variables, input_values

vellum_ai-0.12.4/src/vellum/workflows/nodes/displayable/inline_prompt_node/tests/test_node.py

@@ -0,0 +1,64 @@
+from dataclasses import dataclass
+from uuid import uuid4
+from typing import Any, Iterator, List
+
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.client.types.execute_prompt_event import ExecutePromptEvent
+from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
+from vellum.client.types.initiated_execute_prompt_event import InitiatedExecutePromptEvent
+from vellum.client.types.prompt_output import PromptOutput
+from vellum.client.types.prompt_request_json_input import PromptRequestJsonInput
+from vellum.client.types.string_vellum_value import StringVellumValue
+from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
+
+
+def test_inline_prompt_node__json_inputs(vellum_adhoc_prompt_client):
+    # GIVEN a prompt node with various inputs
+    @dataclass
+    class MyDataClass:
+        hello: str
+
+    class MyPydantic(UniversalBaseModel):
+        example: str
+
+    class MyNode(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = []
+        prompt_inputs = {
+            "a_dict": {"foo": "bar"},
+            "a_list": [1, 2, 3],
+            "a_dataclass": MyDataClass(hello="world"),
+            "a_pydantic": MyPydantic(example="example"),
+        }
+
+    # AND a known response from invoking an inline prompt
+    expected_outputs: List[PromptOutput] = [
+        StringVellumValue(value="Test"),
+    ]
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=expected_outputs,
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the node is run
+    list(MyNode().run())
+
+    # THEN the prompt is executed with the correct inputs
+    mock_api = vellum_adhoc_prompt_client.adhoc_execute_prompt_stream
+    assert mock_api.call_count == 1
+    assert mock_api.call_args.kwargs["input_values"] == [
+        PromptRequestJsonInput(key="a_dict", type="JSON", value={"foo": "bar"}),
+        PromptRequestJsonInput(key="a_list", type="JSON", value=[1, 2, 3]),
+        PromptRequestJsonInput(key="a_dataclass", type="JSON", value={"hello": "world"}),
+        PromptRequestJsonInput(key="a_pydantic", type="JSON", value={"example": "example"}),
+    ]
+    assert len(mock_api.call_args.kwargs["input_variables"]) == 4

vellum_ai-0.12.4/src/vellum/workflows/types/core.py

@@ -0,0 +1,42 @@
+from enum import Enum
+from typing import (  # type: ignore[attr-defined]
+    Any,
+    Dict,
+    List,
+    Union,
+    _GenericAlias,
+    _SpecialGenericAlias,
+    _UnionGenericAlias,
+)
+
+JsonArray = List["Json"]
+JsonObject = Dict[str, "Json"]
+Json = Union[None, bool, int, float, str, JsonArray, JsonObject]
+
+# Unions and Generics inherit from `_GenericAlias` instead of `type`
+# In future versions of python, we'll see `_UnionGenericAlias`
+UnderGenericAlias = _GenericAlias
+SpecialGenericAlias = _SpecialGenericAlias
+UnionGenericAlias = _UnionGenericAlias
+
+
+class VellumSecret:
+    name: str
+
+    def __init__(self, name: str):
+        self.name = name
+
+
+EntityInputsInterface = Dict[str, Any]
+
+
+class MergeBehavior(Enum):
+    AWAIT_ALL = "AWAIT_ALL"
+    AWAIT_ANY = "AWAIT_ANY"
+    AWAIT_ATTRIBUTES = "AWAIT_ATTRIBUTES"
+
+
+class ConditionType(Enum):
+    IF = "IF"
+    ELIF = "ELIF"
+    ELSE = "ELSE"

vellum_ai-0.12.2/src/vellum/workflows/types/core.py

@@ -1,92 +0,0 @@
-from enum import Enum
-from typing import (  # type: ignore[attr-defined]
-    Dict,
-    List,
-    Union,
-    _GenericAlias,
-    _SpecialGenericAlias,
-    _UnionGenericAlias,
-)
-
-from vellum import (
-    ChatMessage,
-    FunctionCall,
-    FunctionCallRequest,
-    SearchResult,
-    SearchResultRequest,
-    VellumAudio,
-    VellumAudioRequest,
-    VellumError,
-    VellumErrorRequest,
-    VellumImage,
-    VellumImageRequest,
-    VellumValue,
-    VellumValueRequest,
-)
-
-JsonArray = List["Json"]
-JsonObject = Dict[str, "Json"]
-Json = Union[None, bool, int, float, str, JsonArray, JsonObject]
-
-# Unions and Generics inherit from `_GenericAlias` instead of `type`
-# In future versions of python, we'll see `_UnionGenericAlias`
-UnderGenericAlias = _GenericAlias
-SpecialGenericAlias = _SpecialGenericAlias
-UnionGenericAlias = _UnionGenericAlias
-
-
-class VellumSecret:
-    name: str
-
-    def __init__(self, name: str):
-        self.name = name
-
-
-VellumValuePrimitive = Union[
-    # String inputs
-    str,
-    # Chat history inputs
-    List[ChatMessage],
-    List[ChatMessage],
-    # Search results inputs
-    List[SearchResultRequest],
-    List[SearchResult],
-    # JSON inputs
-    Json,
-    # Number inputs
-    float,
-    # Function Call Inputs
-    FunctionCall,
-    FunctionCallRequest,
-    # Error Inputs
-    VellumError,
-    VellumErrorRequest,
-    # Array Inputs
-    List[VellumValueRequest],
-    List[VellumValue],
-    # Image Inputs
-    VellumImage,
-    VellumImageRequest,
-    # Audio Inputs
-    VellumAudio,
-    VellumAudioRequest,
-    # Vellum Secrets
-    VellumSecret,
-]
-
-EntityInputsInterface = Dict[
-    str,
-    VellumValuePrimitive,
-]
-
-
-class MergeBehavior(Enum):
-    AWAIT_ALL = "AWAIT_ALL"
-    AWAIT_ANY = "AWAIT_ANY"
-    AWAIT_ATTRIBUTES = "AWAIT_ATTRIBUTES"
-
-
-class ConditionType(Enum):
-    IF = "IF"
-    ELIF = "ELIF"
-    ELSE = "ELSE"