vellum-ai 0.13.28__py3-none-any.whl → 0.14.0__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.13.28",
+            "X-Fern-SDK-Version": "0.14.0",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/workflows/constants.py

@@ -4,11 +4,11 @@ from typing import Any, cast
 
 class _UndefMeta(type):
     def __repr__(cls) -> str:
-        return "UNDEF"
+        return "undefined"
 
     def __getattribute__(cls, name: str) -> Any:
         if name == "__class__":
-            # ensures that UNDEF.__class__ == UNDEF
+            # ensures that undefined.__class__ == undefined
             return cls
 
         return super().__getattribute__(name)
@@ -17,7 +17,12 @@ class _UndefMeta(type):
         return False
 
 
-class UNDEF(metaclass=_UndefMeta):
+class undefined(metaclass=_UndefMeta):
+    """
+    A singleton class that represents an `undefined` value, mirroring the behavior of the `undefined`
+    value in TypeScript.
+    """
+
     pass
 
 

vellum/workflows/descriptors/tests/test_utils.py

@@ -1,6 +1,7 @@
 import pytest
 
 from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.references.constant import ConstantValueReference
 from vellum.workflows.state.base import BaseState
@@ -77,6 +78,24 @@ class DummyNode(BaseNode[FixtureState]):
         (FixtureState.zeta["foo"], "bar"),
         (ConstantValueReference(1), 1),
         (FixtureState.theta[0], "baz"),
+        (
+            ConstantValueReference(
+                WorkflowError(
+                    message="This is a test",
+                    code=WorkflowErrorCode.USER_DEFINED_ERROR,
+                )
+            ).contains("test"),
+            True,
+        ),
+        (
+            ConstantValueReference(
+                WorkflowError(
+                    message="This is a test",
+                    code=WorkflowErrorCode.USER_DEFINED_ERROR,
+                )
+            ).does_not_contain("test"),
+            False,
+        ),
     ],
     ids=[
         "or",
@@ -122,6 +141,8 @@ class DummyNode(BaseNode[FixtureState]):
         "accessor",
         "constants",
         "list_index",
+        "error_contains",
+        "error_does_not_contain",
     ],
 )
 def test_resolve_value__happy_path(descriptor, expected_value):

vellum/workflows/descriptors/utils.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, Optional, Sequence, Set, TypeVar, Union, cast, ove
 
 from pydantic import BaseModel
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.state.base import BaseState
 
@@ -93,10 +93,10 @@ def resolve_value(
 
 def is_unresolved(value: Any) -> bool:
     """
-    Recursively checks if a value has an unresolved value, represented by UNDEF.
+    Recursively checks if a value has an unresolved value, represented by undefined.
     """
 
-    if value is UNDEF:
+    if value is undefined:
         return True
 
     if dataclasses.is_dataclass(value):

vellum/workflows/errors/types.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from enum import Enum
-from typing import Dict
+from typing import Any, Dict
 
 from vellum.client.types.vellum_error import VellumError
 from vellum.client.types.vellum_error_code_enum import VellumErrorCodeEnum
@@ -26,6 +26,9 @@ class WorkflowError:
     message: str
     code: WorkflowErrorCode
 
+    def __contains__(self, item: Any) -> bool:
+        return item in self.message
+
 
 _VELLUM_ERROR_CODE_TO_WORKFLOW_ERROR_CODE: Dict[VellumErrorCodeEnum, WorkflowErrorCode] = {
     "INVALID_REQUEST": WorkflowErrorCode.INVALID_INPUTS,

vellum/workflows/expressions/coalesce_expression.py

@@ -1,6 +1,6 @@
 from typing import TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -27,7 +27,7 @@ class CoalesceExpression(BaseDescriptor[Union[LHS, RHS]]):
 
     def resolve(self, state: "BaseState") -> Union[LHS, RHS]:
         lhs = resolve_value(self._lhs, state)
-        if lhs is not UNDEF and lhs is not None:
+        if lhs is not undefined and lhs is not None:
             return lhs
 
         return resolve_value(self._rhs, state)

vellum/workflows/expressions/contains.py

@@ -1,9 +1,10 @@
 from typing import Generic, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 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.errors.types import WorkflowError
 from vellum.workflows.state.base import BaseState
 
 LHS = TypeVar("LHS")
@@ -26,9 +27,9 @@ class ContainsExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
         # assumes that lack of is also false
-        if lhs is UNDEF:
+        if lhs is undefined:
             return False
-        if not isinstance(lhs, (list, tuple, set, dict, str)):
+        if not isinstance(lhs, (list, tuple, set, dict, str, WorkflowError)):
             raise InvalidExpressionException(
                 f"Expected a LHS that supported `contains`, got `{lhs.__class__.__name__}`"
             )

vellum/workflows/expressions/does_not_contain.py

@@ -3,6 +3,7 @@ from typing import 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.errors.types import WorkflowError
 from vellum.workflows.state.base import BaseState
 
 LHS = TypeVar("LHS")
@@ -24,7 +25,7 @@ class DoesNotContainExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # Support any type that implements the not in operator
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
-        if not isinstance(lhs, (list, tuple, set, dict, str)):
+        if not isinstance(lhs, (list, tuple, set, dict, str, WorkflowError)):
             raise InvalidExpressionException(
                 f"Expected a LHS that supported `contains`, got `{lhs.__class__.__name__}`"
             )

vellum/workflows/expressions/is_nil.py

@@ -1,6 +1,6 @@
 from typing import Generic, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -19,4 +19,4 @@ class IsNilExpression(BaseDescriptor[bool], Generic[_T]):
 
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
-        return expression is None or expression is UNDEF
+        return expression is None or expression is undefined

vellum/workflows/expressions/is_not_nil.py

@@ -1,6 +1,6 @@
 from typing import Generic, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -19,4 +19,4 @@ class IsNotNilExpression(BaseDescriptor[bool], Generic[_T]):
 
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
-        return expression is not None and expression is not UNDEF
+        return expression is not None and expression is not undefined

vellum/workflows/expressions/is_not_undefined.py

@@ -1,6 +1,6 @@
 from typing import Generic, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -19,4 +19,4 @@ class IsNotUndefinedExpression(BaseDescriptor[bool], Generic[_T]):
 
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
-        return expression is not UNDEF
+        return expression is not undefined

vellum/workflows/expressions/is_undefined.py

@@ -1,6 +1,6 @@
 from typing import Generic, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -19,4 +19,4 @@ class IsUndefinedExpression(BaseDescriptor[bool], Generic[_T]):
 
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
-        return expression is UNDEF
+        return expression is undefined

vellum/workflows/nodes/bases/base.py

@@ -5,7 +5,7 @@ from types import MappingProxyType
 from uuid import UUID
 from typing import Any, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, Union, cast, get_args
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import is_unresolved, resolve_value
 from vellum.workflows.errors.types import WorkflowErrorCode
@@ -43,7 +43,23 @@ class BaseNodeMeta(type):
         # TODO: Inherit the inner Output classes from every base class.
         #   https://app.shortcut.com/vellum/story/4007/support-auto-inheriting-parent-node-outputs
 
-        if "Outputs" not in dct:
+        if "Outputs" in dct:
+            outputs_class = dct["Outputs"]
+            if not any(issubclass(base, BaseOutputs) for base in outputs_class.__bases__):
+                parent_outputs_class = next(
+                    (base.Outputs for base in bases if hasattr(base, "Outputs")),
+                    BaseOutputs,  # Default to BaseOutputs only if no parent has Outputs
+                )
+
+                # Filter out object from bases while preserving other inheritance
+                filtered_bases = tuple(base for base in outputs_class.__bases__ if base is not object)
+
+                dct["Outputs"] = type(
+                    f"{name}.Outputs",
+                    (parent_outputs_class,) + filtered_bases,
+                    {**outputs_class.__dict__, "__module__": dct["__module__"]},
+                )
+        else:
             for base in reversed(bases):
                 if hasattr(base, "Outputs"):
                     dct["Outputs"] = type(
@@ -165,7 +181,7 @@ class BaseNodeMeta(type):
                 if attr_name in yielded_attr_names:
                     continue
 
-                attr_value = getattr(resolved_cls, attr_name, UNDEF)
+                attr_value = getattr(resolved_cls, attr_name, undefined)
                 if not isinstance(attr_value, NodeReference):
                     continue
 

vellum/workflows/nodes/bases/tests/test_base_node.py

@@ -5,6 +5,7 @@ from vellum.client.types.string_vellum_value_request import StringVellumValueReq
 from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState, StateMeta
 
 
@@ -148,3 +149,86 @@ def test_base_node__node_resolution__descriptor_in_fern_pydantic():
     node = SomeNode(state=State(foo="bar"))
 
     assert node.model.value == "bar"
+
+
+def test_base_node__inherit_base_outputs():
+    class MyNode(BaseNode):
+        class Outputs:
+            foo: str
+
+        def run(self):
+            return self.Outputs(foo="bar")  # type: ignore
+
+    # TEST that the Outputs class is a subclass of BaseOutputs
+    assert issubclass(MyNode.Outputs, BaseOutputs)
+
+    # TEST that the Outputs class does not inherit from object
+    assert object not in MyNode.Outputs.__bases__
+
+    # TEST that the Outputs class has the correct attributes
+    assert hasattr(MyNode.Outputs, "foo")
+
+    # WHEN the node is run
+    node = MyNode()
+    outputs = node.run()
+
+    # THEN the outputs should be correct
+    assert outputs.foo == "bar"
+
+
+def test_child_node__inherits_base_outputs_when_no_parent_outputs():
+    class ParentNode(BaseNode):  # No Outputs class here
+        pass
+
+    class ChildNode(ParentNode):
+        class Outputs:
+            foo: str
+
+        def run(self):
+            return self.Outputs(foo="bar")  # type: ignore
+
+    # TEST that ChildNode.Outputs is a subclass of BaseOutputs (since ParentNode has no Outputs)
+    assert issubclass(ChildNode.Outputs, BaseOutputs)
+
+    # TEST that ChildNode.Outputs has the correct attributes
+    assert hasattr(ChildNode.Outputs, "foo")
+
+    # WHEN the node is run
+    node = ChildNode()
+    outputs = node.run()
+
+    # THEN the outputs should be correct
+    assert outputs.foo == "bar"
+
+
+def test_outputs_preserves_non_object_bases():
+    class ParentNode(BaseNode):
+        class Outputs:
+            foo: str
+
+    class Foo:
+        bar: str
+
+    class ChildNode(ParentNode):
+        class Outputs(ParentNode.Outputs, Foo):
+            pass
+
+        def run(self):
+            return self.Outputs(foo="bar", bar="baz")  # type: ignore
+
+    # TEST that Outputs is a subclass of Foo and ParentNode.Outputs
+    assert Foo in ChildNode.Outputs.__bases__, "Foo should be preserved in bases"
+    assert ParentNode.Outputs in ChildNode.Outputs.__bases__, "ParentNode.Outputs should be preserved in bases"
+    assert object not in ChildNode.Outputs.__bases__, "object should not be in bases"
+
+    # TEST that Outputs has the correct attributes
+    assert hasattr(ChildNode.Outputs, "foo")
+    assert hasattr(ChildNode.Outputs, "bar")
+
+    # WHEN Outputs is instantiated
+    node = ChildNode()
+    outputs = node.run()
+
+    # THEN the output values should be correct
+    assert outputs.foo == "bar"
+    assert outputs.bar == "baz"

vellum/workflows/nodes/core/inline_subworkflow_node/node.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
@@ -67,7 +67,7 @@ class InlineSubworkflowNode(
     """
 
     subworkflow: Type["BaseWorkflow[InputsType, InnerStateType]"]
-    subworkflow_inputs: ClassVar[Union[EntityInputsInterface, BaseInputs, Type[UNDEF]]] = UNDEF
+    subworkflow_inputs: ClassVar[Union[EntityInputsInterface, BaseInputs, Type[undefined]]] = undefined
 
     def run(self) -> Iterator[BaseOutput]:
         with execution_context(parent_context=get_parent_context() or self._context.parent_context):
@@ -112,7 +112,7 @@ class InlineSubworkflowNode(
 
     def _compile_subworkflow_inputs(self) -> InputsType:
         inputs_class = self.subworkflow.get_inputs_class()
-        if self.subworkflow_inputs is UNDEF:
+        if self.subworkflow_inputs is undefined:
             inputs_dict = {}
             for descriptor in inputs_class:
                 if hasattr(self, descriptor.name):

vellum/workflows/nodes/core/map_node/node.py

@@ -66,6 +66,11 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
         for output_descripter in self.subworkflow.Outputs:
             mapped_items[output_descripter.name] = [None] * len(self.items)
 
+        if not self.items:
+            for output_name, output_list in mapped_items.items():
+                yield BaseOutput(name=output_name, value=output_list)
+            return
+
         self._event_queue: Queue[Tuple[int, WorkflowEvent]] = Queue()
         self._concurrency_queue: Queue[Thread] = Queue()
         fulfilled_iterations: List[bool] = []

vellum/workflows/nodes/core/map_node/tests/test_node.py

@@ -63,3 +63,25 @@ def test_map_node__use_parallelism():
     # THEN the node should have ran in parallel
     run_time = (end_ts - start_ts) / 10**9
     assert run_time < 0.2
+
+
+def test_map_node__empty_list():
+    # GIVEN a map node that is configured to use the parent's inputs and state
+    @MapNode.wrap(items=[])
+    class TestNode(BaseNode):
+        item = MapNode.SubworkflowInputs.item
+
+        class Outputs(BaseOutputs):
+            value: int
+
+        def run(self) -> Outputs:
+            time.sleep(0.03)
+            return self.Outputs(value=self.item + 1)
+
+    # WHEN the node is run
+    node = TestNode()
+    outputs = list(node.run())
+
+    # THEN the node should return an empty output
+    fulfilled_output = outputs[-1]
+    assert fulfilled_output == BaseOutput(name="value", value=[])

vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py

@@ -1,8 +1,8 @@
 import pytest
 import os
-from typing import Any
+from typing import Any, Union
 
-from vellum import CodeExecutorResponse, NumberVellumValue, StringInput
+from vellum import CodeExecutorResponse, NumberVellumValue, StringInput, StringVellumValue
 from vellum.client.types.code_execution_package import CodeExecutionPackage
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
 from vellum.client.types.function_call import FunctionCall
@@ -493,3 +493,69 @@ def main(word: str) -> dict:
         },
         "log": "",
     }
+
+
+def test_run_node__array_input_with_vellum_values(vellum_client):
+    """Confirm that CodeExecutionNodes can handle arrays containing VellumValue objects."""
+
+    # GIVEN a node that subclasses CodeExecutionNode that processes an array of VellumValues
+    class State(BaseState):
+        pass
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, str]):
+        code = """\
+from typing import List, Dict
+def main(arg1: List[Dict]) -> str:
+    return arg1[0]["value"] + " " + arg1[1]["value"]
+"""
+        runtime = "PYTHON_3_11_6"
+
+        code_inputs = {
+            "arg1": [
+                StringVellumValue(type="STRING", value="Hello", name="First"),
+                StringVellumValue(type="STRING", value="World", name="Second"),
+            ],
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode(state=State())
+    outputs = node.run()
+
+    # THEN the node should successfully concatenate the values
+    assert outputs == {"result": "Hello World", "log": ""}
+
+    # AND we should not have invoked the Code via Vellum since it's running inline
+    vellum_client.execute_code.assert_not_called()
+
+
+def test_run_node__union_output_type(vellum_client):
+    """Confirm that CodeExecutionNodes can handle Union output types."""
+
+    # GIVEN a node that subclasses CodeExecutionNode that returns a Union type
+    class State(BaseState):
+        pass
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, Union[float, int]]):
+        code = """\
+from typing import List, Dict
+def main(arg1: List[Dict]) -> float:
+    return arg1[0]["value"] + arg1[1]["value"]
+"""
+        runtime = "PYTHON_3_11_6"
+
+        code_inputs = {
+            "arg1": [
+                NumberVellumValue(type="NUMBER", value=1.0, name="First"),
+                NumberVellumValue(type="NUMBER", value=2.0, name="Second"),
+            ],
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode(state=State())
+    outputs = node.run()
+
+    # THEN the node should successfully sum the values
+    assert outputs == {"result": 3.0, "log": ""}
+
+    # AND we should not have invoked the Code via Vellum since it's running inline
+    vellum_client.execute_code.assert_not_called()

vellum/workflows/nodes/displayable/code_execution_node/utils.py

@@ -1,10 +1,11 @@
 import io
 import os
 import re
-from typing import Any, List, Tuple, Union
+from typing import Any, List, Tuple, Union, get_args, get_origin
 
 from pydantic import BaseModel, ValidationError
 
+from vellum import VellumValue
 from vellum.client.types.code_executor_input import CodeExecutorInput
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
@@ -74,8 +75,25 @@ def run_code_inline(
 ) -> Tuple[str, Any]:
     log_buffer = io.StringIO()
 
+    VELLUM_TYPES = get_args(VellumValue)
+
+    def wrap_value(value):
+        if isinstance(value, list):
+            return ListWrapper(
+                [
+                    # Convert VellumValue to dict with its fields
+                    (
+                        item.model_dump()
+                        if isinstance(item, VELLUM_TYPES)
+                        else _clean_for_dict_wrapper(item) if isinstance(item, (dict, list)) else item
+                    )
+                    for item in value
+                ]
+            )
+        return _clean_for_dict_wrapper(value)
+
     exec_globals = {
-        "__arg__inputs": {input_value.name: _clean_for_dict_wrapper(input_value.value) for input_value in input_values},
+        "__arg__inputs": {input_value.name: wrap_value(input_value.value) for input_value in input_values},
         "__arg__out": None,
         "print": lambda *args, **kwargs: log_buffer.write(f"{' '.join(args)}\n"),
     }
@@ -92,7 +110,14 @@ __arg__out = main({", ".join(run_args)})
     result = exec_globals["__arg__out"]
 
     if output_type != Any:
-        if issubclass(output_type, BaseModel) and not isinstance(result, output_type):
+        if get_origin(output_type) is Union:
+            allowed_types = get_args(output_type)
+            if not isinstance(result, allowed_types):
+                raise NodeException(
+                    code=WorkflowErrorCode.INVALID_OUTPUTS,
+                    message=f"Expected output to be in types {allowed_types}, but received '{type(result).__name__}'",
+                )
+        elif issubclass(output_type, BaseModel) and not isinstance(result, output_type):
             try:
                 result = output_type.model_validate(result)
             except ValidationError as e:
@@ -100,12 +125,10 @@ __arg__out = main({", ".join(run_args)})
                     code=WorkflowErrorCode.INVALID_OUTPUTS,
                     message=re.sub(r"\s+For further information visit [^\s]+", "", str(e)),
                 ) from e
-
-        if not isinstance(result, output_type):
+        elif not isinstance(result, output_type):
             raise NodeException(
                 code=WorkflowErrorCode.INVALID_OUTPUTS,
-                message=f"Expected an output of type '{output_type.__name__}',"
-                f" but received '{result.__class__.__name__}'",
+                message=f"Expected an output of type '{output_type.__name__}', but received '{type(result).__name__}'",
             )
 
     return logs, result