vellum-ai 0.13.27__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.27",
+            "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/exceptions.py

@@ -0,0 +1,2 @@
+class InvalidExpressionException(Exception):
+    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/accessor.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, GetCoreSchemaHandler
 from pydantic_core import core_schema
 
 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
 
@@ -32,13 +33,13 @@ class AccessorExpression(BaseDescriptor[Any]):
 
         if dataclasses.is_dataclass(base):
             if isinstance(self._field, int):
-                raise ValueError("Cannot access field by index on a dataclass")
+                raise InvalidExpressionException("Cannot access field by index on a dataclass")
 
             return getattr(base, self._field)
 
         if isinstance(base, BaseModel):
             if isinstance(self._field, int):
-                raise ValueError("Cannot access field by index on a BaseModel")
+                raise InvalidExpressionException("Cannot access field by index on a BaseModel")
 
             return getattr(base, self._field)
 
@@ -49,7 +50,7 @@ class AccessorExpression(BaseDescriptor[Any]):
             index = int(self._field)
             return base[index]
 
-        raise ValueError(f"Cannot get field {self._field} from {base}")
+        raise InvalidExpressionException(f"Cannot get field {self._field} from {base}")
 
     @classmethod
     def __get_pydantic_core_schema__(

vellum/workflows/expressions/begins_with.py

@@ -1,6 +1,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.state.base import BaseState
 
@@ -23,9 +24,9 @@ class BeginsWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         lhs = resolve_value(self._lhs, state)
         rhs = resolve_value(self._rhs, state)
         if not isinstance(lhs, str):
-            raise ValueError(f"Expected LHS to be a string, got {type(lhs)}")
+            raise InvalidExpressionException(f"Expected LHS to be a string, got {type(lhs)}")
 
         if not isinstance(rhs, str):
-            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+            raise InvalidExpressionException(f"Expected RHS to be a string, got {type(rhs)}")
 
         return lhs.startswith(rhs)

vellum/workflows/expressions/between.py

@@ -1,6 +1,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.state.base import BaseState
 
@@ -25,14 +26,14 @@ class BetweenExpression(BaseDescriptor[bool], Generic[_V, _S, _E]):
     def resolve(self, state: "BaseState") -> bool:
         value = resolve_value(self._value, state)
         if not isinstance(value, (int, float)):
-            raise ValueError(f"Expected a numeric value, got: {value.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric value, got: {value.__class__.__name__}")
 
         start = resolve_value(self._start, state)
         if not isinstance(start, (int, float)):
-            raise ValueError(f"Expected a numeric start value, got: {start.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric start value, got: {start.__class__.__name__}")
 
         end = resolve_value(self._end, state)
         if not isinstance(end, (int, float)):
-            raise ValueError(f"Expected a numeric end value, got: {end.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric end value, got: {end.__class__.__name__}")
 
         return start <= value <= end

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,7 +1,10 @@
 from typing import Generic, TypeVar, Union
 
+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")
@@ -23,8 +26,13 @@ class ContainsExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # Support any type that implements the in operator
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
-        if not isinstance(lhs, (list, tuple, set, dict, str)):
-            raise ValueError(f"Expected a LHS that supported contains, got: {lhs.__class__.__name__}")
+        # assumes that lack of is also false
+        if lhs is undefined:
+            return False
+        if not isinstance(lhs, (list, tuple, set, dict, str, WorkflowError)):
+            raise InvalidExpressionException(
+                f"Expected a LHS that supported `contains`, got `{lhs.__class__.__name__}`"
+            )
 
         rhs = resolve_value(self._rhs, state)
         return rhs in lhs

vellum/workflows/expressions/does_not_begin_with.py

@@ -1,6 +1,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.state.base import BaseState
 
@@ -23,9 +24,9 @@ class DoesNotBeginWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         lhs = resolve_value(self._lhs, state)
         rhs = resolve_value(self._rhs, state)
         if not isinstance(lhs, str):
-            raise ValueError(f"Expected LHS to be a string, got {type(lhs)}")
+            raise InvalidExpressionException(f"Expected LHS to be a string, got {type(lhs)}")
 
         if not isinstance(rhs, str):
-            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+            raise InvalidExpressionException(f"Expected RHS to be a string, got {type(rhs)}")
 
         return not lhs.startswith(rhs)

vellum/workflows/expressions/does_not_contain.py

@@ -1,7 +1,9 @@
 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")
@@ -23,8 +25,10 @@ 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)):
-            raise ValueError(f"Expected a LHS that supported contains, got: {lhs.__class__.__name__}")
+        if not isinstance(lhs, (list, tuple, set, dict, str, WorkflowError)):
+            raise InvalidExpressionException(
+                f"Expected a LHS that supported `contains`, got `{lhs.__class__.__name__}`"
+            )
 
         rhs = resolve_value(self._rhs, state)
         return rhs not in lhs

vellum/workflows/expressions/does_not_end_with.py

@@ -1,6 +1,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.state.base import BaseState
 
@@ -23,9 +24,9 @@ class DoesNotEndWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         lhs = resolve_value(self._lhs, state)
         rhs = resolve_value(self._rhs, state)
         if not isinstance(lhs, str):
-            raise ValueError(f"Expected LHS to be a string, got {type(lhs)}")
+            raise InvalidExpressionException(f"Expected LHS to be a string, got {type(lhs)}")
 
         if not isinstance(rhs, str):
-            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+            raise InvalidExpressionException(f"Expected RHS to be a string, got {type(rhs)}")
 
         return not lhs.endswith(rhs)

vellum/workflows/expressions/ends_with.py

@@ -1,6 +1,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.state.base import BaseState
 
@@ -23,9 +24,9 @@ class EndsWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         lhs = resolve_value(self._lhs, state)
         rhs = resolve_value(self._rhs, state)
         if not isinstance(lhs, str):
-            raise ValueError(f"Expected LHS to be a string, got {type(lhs)}")
+            raise InvalidExpressionException(f"Expected LHS to be a string, got {type(lhs)}")
 
         if not isinstance(rhs, str):
-            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+            raise InvalidExpressionException(f"Expected RHS to be a string, got {type(rhs)}")
 
         return lhs.endswith(rhs)

vellum/workflows/expressions/greater_than.py

@@ -1,6 +1,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.state.base import BaseState
 
@@ -24,10 +25,10 @@ class GreaterThanExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
         if not isinstance(lhs, (int, float)):
-            raise ValueError(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
+            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 ValueError(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
 
         return lhs > rhs

vellum/workflows/expressions/greater_than_or_equal_to.py

@@ -1,6 +1,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.state.base import BaseState
 
@@ -24,10 +25,10 @@ class GreaterThanOrEqualToExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
         if not isinstance(lhs, (int, float)):
-            raise ValueError(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
+            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 ValueError(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
 
         return lhs >= rhs

vellum/workflows/expressions/in_.py

@@ -1,6 +1,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.state.base import BaseState
 
@@ -26,6 +27,6 @@ class InExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
 
         rhs = resolve_value(self._rhs, state)
         if not isinstance(rhs, (list, tuple, set, dict, str)):
-            raise ValueError(f"Expected a RHS that supported in, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a RHS that supported in, got: {rhs.__class__.__name__}")
 
         return lhs in rhs

vellum/workflows/expressions/is_blank.py

@@ -1,6 +1,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.state.base import BaseState
 
@@ -19,6 +20,6 @@ class IsBlankExpression(BaseDescriptor[bool], Generic[_T]):
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
         if not isinstance(expression, str):
-            raise ValueError(f"Expected a string expression, got: {expression.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a string expression, got: {expression.__class__.__name__}")
 
         return len(expression) == 0

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_blank.py

@@ -1,6 +1,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.state.base import BaseState
 
@@ -19,6 +20,6 @@ class IsNotBlankExpression(BaseDescriptor[bool], Generic[_T]):
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
         if not isinstance(expression, str):
-            raise ValueError(f"Expected a string expression, got: {expression.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a string expression, got: {expression.__class__.__name__}")
 
         return len(expression) != 0

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/expressions/less_than.py

@@ -1,6 +1,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.state.base import BaseState
 
@@ -24,10 +25,10 @@ class LessThanExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
         if not isinstance(lhs, (int, float)):
-            raise ValueError(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
+            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 ValueError(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
 
         return lhs < rhs

vellum/workflows/expressions/less_than_or_equal_to.py

@@ -1,6 +1,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.state.base import BaseState
 
@@ -24,10 +25,10 @@ class LessThanOrEqualToExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
         if not isinstance(lhs, (int, float)):
-            raise ValueError(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
+            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 ValueError(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
 
         return lhs <= rhs

vellum/workflows/expressions/not_between.py

@@ -1,6 +1,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.state.base import BaseState
 
@@ -25,14 +26,14 @@ class NotBetweenExpression(BaseDescriptor[bool], Generic[_V, _S, _E]):
     def resolve(self, state: "BaseState") -> bool:
         value = resolve_value(self._value, state)
         if not isinstance(value, (int, float)):
-            raise ValueError(f"Expected a numeric value, got: {value.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric value, got: {value.__class__.__name__}")
 
         start = resolve_value(self._start, state)
         if not isinstance(start, (int, float)):
-            raise ValueError(f"Expected a numeric start value, got: {start.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric start value, got: {start.__class__.__name__}")
 
         end = resolve_value(self._end, state)
         if not isinstance(end, (int, float)):
-            raise ValueError(f"Expected a numeric end value, got: {end.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric end value, got: {end.__class__.__name__}")
 
         return value < start or value > end

vellum/workflows/expressions/not_in.py

@@ -1,6 +1,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.state.base import BaseState
 
@@ -26,6 +27,6 @@ class NotInExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
 
         rhs = resolve_value(self._rhs, state)
         if not isinstance(rhs, (list, tuple, set, dict, str)):
-            raise ValueError(f"Expected a RHS that supported contains, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a RHS that supported contains, got: {rhs.__class__.__name__}")
 
         return lhs not in rhs

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
 
@@ -255,17 +271,15 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
                 return False
 
             if cls.merge_behavior == MergeBehavior.AWAIT_ATTRIBUTES:
-                is_ready = True
                 for descriptor in cls.node_class:
                     if not descriptor.instance:
                         continue
 
                     resolved_value = resolve_value(descriptor.instance, state, path=descriptor.name)
                     if is_unresolved(resolved_value):
-                        is_ready = False
-                        break
+                        return False
 
-                return is_ready
+                return True
 
             if cls.merge_behavior == MergeBehavior.AWAIT_ANY:
                 return True