vellum-ai 0.14.41__py3-none-any.whl → 1.11.2__py3-none-any.whl

vellum/workflows/expressions/less_than.py

@@ -4,6 +4,7 @@ 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.expressions.comparison_utils import prepare_comparison_operands
 from vellum.workflows.state.base import BaseState
 
 LHS = TypeVar("LHS")
@@ -34,7 +35,13 @@ class LessThanExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         lhs = resolve_value(self._lhs, state)
         rhs = resolve_value(self._rhs, state)
 
+        # Parse string operands as numbers when comparing with numeric types
+        lhs, rhs = prepare_comparison_operands(lhs, rhs)
+
         if not has_lt(lhs):
             raise InvalidExpressionException(f"'{lhs.__class__.__name__}' must support the '<' operator")
 
-        return lhs < rhs
+        try:
+            return lhs < rhs
+        except TypeError as e:
+            raise InvalidExpressionException(str(e))

vellum/workflows/expressions/less_than_or_equal_to.py

@@ -4,6 +4,7 @@ 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.expressions.comparison_utils import prepare_comparison_operands
 from vellum.workflows.state.base import BaseState
 
 LHS = TypeVar("LHS")
@@ -34,7 +35,13 @@ class LessThanOrEqualToExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         lhs = resolve_value(self._lhs, state)
         rhs = resolve_value(self._rhs, state)
 
+        # Parse string operands as numbers when comparing with numeric types
+        lhs, rhs = prepare_comparison_operands(lhs, rhs)
+
         if not has_le(lhs):
             raise InvalidExpressionException(f"'{lhs.__class__.__name__}' must support the '<=' operator")
 
-        return lhs <= rhs
+        try:
+            return lhs <= rhs
+        except TypeError as e:
+            raise InvalidExpressionException(str(e))

vellum/workflows/expressions/minus.py

@@ -0,0 +1,41 @@
+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 SupportsMinus(Protocol):
+    def __sub__(self, other: Any) -> Any: ...
+
+
+def has_sub(obj: Any) -> TypeGuard[SupportsMinus]:
+    return hasattr(obj, "__sub__")
+
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class MinusExpression(BaseDescriptor[Any], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} - {rhs}", types=(object,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> Any:
+        lhs = resolve_value(self._lhs, state)
+        rhs = resolve_value(self._rhs, state)
+
+        if not has_sub(lhs):
+            raise InvalidExpressionException(f"'{lhs.__class__.__name__}' must support the '-' operator")
+
+        return lhs - rhs

vellum/workflows/expressions/tests/test_accessor.py

@@ -0,0 +1,248 @@
+import pytest
+from dataclasses import dataclass
+from typing import Dict, List
+
+from pydantic import BaseModel
+
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.expressions.accessor import AccessorExpression
+from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.references.output import OutputReference
+from vellum.workflows.state.base import BaseState
+
+
+@dataclass
+class TestDataclass:
+    name: str
+    value: int
+
+
+class TestBaseModel(BaseModel):
+    name: str
+    value: int
+
+
+class TestState(BaseState):
+    pass
+
+
+def test_accessor_expression_dict_valid_key():
+    state = TestState()
+    base_ref = ConstantValueReference({"name": "test", "value": 42})
+    accessor = AccessorExpression(base=base_ref, field="name")
+
+    result = accessor.resolve(state)
+
+    assert result == "test"
+
+
+def test_accessor_expression_dict_invalid_key():
+    state = TestState()
+    base_ref = ConstantValueReference({"name": "test", "value": 42})
+    accessor = AccessorExpression(base=base_ref, field="missing_key")
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Key 'missing_key' not found in mapping" in str(exc_info.value)
+
+
+def test_accessor_expression_list_valid_index():
+    state = TestState()
+    base_ref = ConstantValueReference(["first", "second", "third"])
+    accessor = AccessorExpression(base=base_ref, field=1)
+
+    result = accessor.resolve(state)
+
+    assert result == "second"
+
+
+def test_accessor_expression_list_invalid_index():
+    state = TestState()
+    base_ref = ConstantValueReference(["first", "second"])
+    accessor = AccessorExpression(base=base_ref, field=5)
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Index 5 is out of bounds for sequence of length 2" in str(exc_info.value)
+
+
+def test_accessor_expression_list_negative_index():
+    state = TestState()
+    base_ref = ConstantValueReference(["first", "second", "third"])
+    accessor = AccessorExpression(base=base_ref, field=-1)
+
+    result = accessor.resolve(state)
+
+    assert result == "third"
+
+
+def test_accessor_expression_list_invalid_negative_index():
+    state = TestState()
+    base_ref = ConstantValueReference(["first", "second"])
+    accessor = AccessorExpression(base=base_ref, field=-5)
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Index -5 is out of bounds for sequence of length 2" in str(exc_info.value)
+
+
+def test_accessor_expression_list_string_index():
+    state = TestState()
+    base_ref = ConstantValueReference(["first", "second", "third"])
+    accessor = AccessorExpression(base=base_ref, field="1")
+
+    result = accessor.resolve(state)
+
+    assert result == "second"
+
+
+def test_accessor_expression_list_invalid_string_index():
+    state = TestState()
+    base_ref = ConstantValueReference(["first", "second"])
+    accessor = AccessorExpression(base=base_ref, field="invalid")
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Invalid index 'invalid' for sequence access" in str(exc_info.value)
+
+
+def test_accessor_expression_dataclass_valid_field():
+    state = TestState()
+    test_obj = TestDataclass(name="test", value=42)
+    base_ref = ConstantValueReference(test_obj)
+    accessor = AccessorExpression(base=base_ref, field="name")
+
+    result = accessor.resolve(state)
+
+    assert result == "test"
+
+
+def test_accessor_expression_dataclass_invalid_field():
+    state = TestState()
+    test_obj = TestDataclass(name="test", value=42)
+    base_ref = ConstantValueReference(test_obj)
+    accessor = AccessorExpression(base=base_ref, field="missing_field")
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Field 'missing_field' not found on dataclass TestDataclass" in str(exc_info.value)
+
+
+def test_accessor_expression_basemodel_valid_field():
+    state = TestState()
+    test_obj = TestBaseModel(name="test", value=42)
+    base_ref = ConstantValueReference(test_obj)
+    accessor = AccessorExpression(base=base_ref, field="name")
+
+    result = accessor.resolve(state)
+
+    assert result == "test"
+
+
+def test_accessor_expression_basemodel_invalid_field():
+    state = TestState()
+    test_obj = TestBaseModel(name="test", value=42)
+    base_ref = ConstantValueReference(test_obj)
+    accessor = AccessorExpression(base=base_ref, field="missing_field")
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Field 'missing_field' not found on BaseModel TestBaseModel" in str(exc_info.value)
+
+
+def test_accessor_expression_dataclass_index_access():
+    state = TestState()
+    test_obj = TestDataclass(name="test", value=42)
+    base_ref = ConstantValueReference(test_obj)
+    accessor = AccessorExpression(base=base_ref, field=0)
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Cannot access field by index on a dataclass" in str(exc_info.value)
+
+
+def test_accessor_expression_basemodel_index_access():
+    state = TestState()
+    test_obj = TestBaseModel(name="test", value=42)
+    base_ref = ConstantValueReference(test_obj)
+    accessor = AccessorExpression(base=base_ref, field=0)
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Cannot access field by index on a BaseModel" in str(exc_info.value)
+
+
+def test_accessor_expression_unsupported_type():
+    state = TestState()
+    base_ref = ConstantValueReference(42)
+    accessor = AccessorExpression(base=base_ref, field="field")
+
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        accessor.resolve(state)
+
+    assert "Cannot get field field from 42" in str(exc_info.value)
+
+
+def test_accessor_expression_list_type_inference():
+    """Test that accessor expressions correctly infer element types from List[str]."""
+    base_ref: OutputReference = OutputReference(
+        name="test_list",
+        types=(List[str],),
+        instance=None,
+        outputs_class=BaseOutputs,
+    )
+
+    accessor = AccessorExpression(base=base_ref, field=0)
+
+    assert accessor.types == (str,)
+
+
+def test_accessor_expression_tuple_type_inference():
+    """Test that accessor expressions correctly infer element types from Tuple types."""
+    base_ref: OutputReference = OutputReference(
+        name="test_tuple",
+        types=(tuple,),
+        instance=None,
+        outputs_class=BaseOutputs,
+    )
+
+    accessor = AccessorExpression(base=base_ref, field=0)
+
+    assert accessor.types == ()
+
+
+def test_accessor_expression_dict_type_inference():
+    """Test that accessor expressions correctly infer value types from Dict types."""
+    base_ref: OutputReference = OutputReference(
+        name="test_dict",
+        types=(Dict[str, int],),
+        instance=None,
+        outputs_class=BaseOutputs,
+    )
+
+    accessor = AccessorExpression(base=base_ref, field="some_key")
+
+    assert accessor.types == (int,)
+
+
+def test_accessor_expression_empty_base_types():
+    """Test that accessor expressions handle empty base types gracefully."""
+    base_ref: OutputReference = OutputReference(
+        name="test_empty",
+        types=(),
+        instance=None,
+        outputs_class=BaseOutputs,
+    )
+
+    accessor = AccessorExpression(base=base_ref, field=0)
+
+    assert accessor.types == ()

vellum/workflows/expressions/tests/test_add.py

@@ -0,0 +1,72 @@
+import pytest
+
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.expressions.add import AddExpression
+from vellum.workflows.state.base import BaseState
+
+
+class TestState(BaseState):
+    number_value: int = 5
+    string_value: str = "hello"
+
+
+def test_add_expression_numbers():
+    """
+    Tests that AddExpression correctly adds two numbers.
+    """
+
+    state = TestState()
+
+    expression = TestState.number_value.add(10)
+
+    result = expression.resolve(state)
+    assert result == 15
+
+
+def test_add_expression_strings():
+    """
+    Tests that AddExpression correctly concatenates two strings.
+    """
+
+    state = TestState()
+
+    expression = TestState.string_value.add(" world")
+
+    result = expression.resolve(state)
+    assert result == "hello world"
+
+
+def test_add_expression_unsupported_type():
+    """
+    Tests that AddExpression raises an exception for unsupported types.
+    """
+
+    class NoAddSupport:
+        pass
+
+    no_add_obj = NoAddSupport()
+    expression = AddExpression(lhs=no_add_obj, rhs=5)
+    state = TestState()
+
+    with pytest.raises(InvalidExpressionException, match="'NoAddSupport' must support the '\\+' operator"):
+        expression.resolve(state)
+
+
+def test_add_expression_name():
+    """
+    Tests that AddExpression has the correct name.
+    """
+
+    expression = AddExpression(lhs=5, rhs=3)
+
+    assert expression.name == "5 + 3"
+
+
+def test_add_expression_types():
+    """
+    Tests that AddExpression has the correct types.
+    """
+
+    expression = AddExpression(lhs=5, rhs=3)
+
+    assert expression.types == (object,)

vellum/workflows/expressions/tests/test_concat.py

@@ -0,0 +1,108 @@
+import pytest
+
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.state.base import BaseState
+
+
+class TestState(BaseState):
+    pass
+
+
+def test_concat_expression_happy_path():
+    # GIVEN two lists
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2, 3])
+    rhs_ref = ConstantValueReference([4, 5, 6])
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the lists should be concatenated
+    assert result == [1, 2, 3, 4, 5, 6]
+
+
+def test_concat_expression_lhs_fail():
+    # GIVEN a non-list lhs and a list rhs
+    state = TestState()
+    lhs_ref = ConstantValueReference(0)
+    rhs_ref = ConstantValueReference([4, 5, 6])
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we attempt to resolve the expression
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        concat_expr.resolve(state)
+
+    # THEN an exception should be raised
+    assert "Expected LHS to be a list, got <class 'int'>" in str(exc_info.value)
+
+
+def test_concat_expression_with_single_item():
+    # GIVEN a list and a single item
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2, 3])
+    rhs_ref = ConstantValueReference(4)
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the item should be appended to the list
+    assert result == [1, 2, 3, 4]
+
+
+def test_concat_expression_with_string():
+    # GIVEN a list and a string item
+    state = TestState()
+    lhs_ref = ConstantValueReference(["hello", "world"])
+    rhs_ref = ConstantValueReference("!")
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the string should be appended to the list
+    assert result == ["hello", "world", "!"]
+
+
+def test_concat_expression_with_none():
+    # GIVEN a list and None item
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2])
+    rhs_ref = ConstantValueReference(None)
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN None should be appended to the list
+    assert result == [1, 2, None]
+
+
+def test_concat_expression_with_list_item():
+    # GIVEN a list and another list
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2])
+    rhs_ref = ConstantValueReference([3, 4])
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the lists should be concatenated normally
+    assert result == [1, 2, 3, 4]
+
+
+def test_concat_expression_empty_list():
+    # GIVEN an empty list and an item
+    state = TestState()
+    lhs_ref: ConstantValueReference[list] = ConstantValueReference([])
+    rhs_ref = ConstantValueReference("first")
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the item should be appended to the empty list
+    assert result == ["first"]

vellum/workflows/expressions/tests/test_contains.py

@@ -0,0 +1,175 @@
+import pytest
+
+from vellum.workflows.constants import undefined
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.expressions.contains import ContainsExpression
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.state.base import BaseState
+
+
+class TestState(BaseState):
+    dict_value: dict = {"key": "value"}
+    list_value: list = [1, 2, 3]
+    string_value: str = "hello world"
+
+
+def test_dict_contains_dict_raises_error():
+    """
+    Tests that ContainsExpression raises clear error for dict-contains-dict scenarios.
+    """
+    state = TestState()
+    lhs_dict = {"foo": "bar"}
+    rhs_dict = {"foo": "bar"}
+
+    expression = ContainsExpression(lhs=lhs_dict, rhs=rhs_dict)
+
+    with pytest.raises(InvalidExpressionException, match="Cannot use dict as right-hand side"):
+        expression.resolve(state)
+
+
+def test_dict_contains_different_dict_raises_error():
+    """
+    Tests that ContainsExpression raises clear error for different dict-contains-dict scenarios.
+    """
+    state = TestState()
+    lhs_dict = {"foo": "bar"}
+    rhs_dict = {"hello": "world"}
+
+    expression = ContainsExpression(lhs=lhs_dict, rhs=rhs_dict)
+
+    with pytest.raises(InvalidExpressionException, match="Cannot use dict as right-hand side"):
+        expression.resolve(state)
+
+
+def test_string_contains_dict_raises_error():
+    """
+    Tests that ContainsExpression raises clear error for string-contains-dict scenarios.
+    """
+    state = TestState()
+    lhs_string = 'Response: {"status": "success"} was returned'
+    rhs_dict = {"status": "success"}
+
+    expression = ContainsExpression(lhs=lhs_string, rhs=rhs_dict)
+
+    with pytest.raises(InvalidExpressionException, match="Cannot use dict as right-hand side"):
+        expression.resolve(state)
+
+
+def test_nested_dict_contains_dict_raises_error():
+    """
+    Tests that ContainsExpression raises clear error for nested dict scenarios.
+    """
+    state = TestState()
+    lhs_dict = {"user": {"name": "john", "age": 30}}
+    rhs_dict = {"age": 30, "name": "john"}
+
+    expression = ContainsExpression(lhs=lhs_dict, rhs=rhs_dict)
+
+    with pytest.raises(InvalidExpressionException, match="Cannot use dict as right-hand side"):
+        expression.resolve(state)
+
+
+def test_list_contains_string():
+    """
+    Tests that ContainsExpression preserves original list functionality.
+    """
+    state = TestState()
+
+    expression = TestState.list_value.contains(2)
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_string_contains_substring():
+    """
+    Tests that ContainsExpression preserves original string functionality.
+    """
+    state = TestState()
+
+    expression = TestState.string_value.contains("world")
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_set_contains_item():
+    """
+    Tests that ContainsExpression works with sets.
+    """
+    state = TestState()
+    lhs_set = {1, 2, 3}
+    rhs_item = 2
+
+    expression = ContainsExpression(lhs=lhs_set, rhs=rhs_item)
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_tuple_contains_item():
+    """
+    Tests that ContainsExpression works with tuples.
+    """
+    state = TestState()
+    lhs_tuple = (1, 2, 3)
+    rhs_item = 2
+
+    expression = ContainsExpression(lhs=lhs_tuple, rhs=rhs_item)
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_invalid_lhs_type():
+    """
+    Tests that ContainsExpression raises exception for invalid LHS types.
+    """
+
+    class NoContainsSupport:
+        pass
+
+    state = TestState()
+    no_contains_obj = NoContainsSupport()
+    expression = ContainsExpression(lhs=no_contains_obj, rhs="test")
+
+    with pytest.raises(
+        InvalidExpressionException, match="Expected a LHS that supported `contains`, got `NoContainsSupport`"
+    ):
+        expression.resolve(state)
+
+
+def test_undefined_lhs_returns_false():
+    """
+    Tests that ContainsExpression returns False for undefined LHS.
+    """
+    state = TestState()
+    expression = ContainsExpression(lhs=undefined, rhs="test")
+
+    result = expression.resolve(state)
+
+    assert result is False
+
+
+def test_contains_with_constant_value_reference():
+    """
+    Tests ContainsExpression with ConstantValueReference for valid operations.
+    """
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2, 3])
+    rhs_ref = ConstantValueReference(2)
+
+    expression: ContainsExpression = ContainsExpression(lhs=lhs_ref, rhs=rhs_ref)
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_expression_metadata():
+    """
+    Tests that ContainsExpression has correct name and types properties.
+    """
+    expression = ContainsExpression(lhs=[1, 2, 3], rhs=2)
+
+    assert expression.name == "[1, 2, 3] contains 2"
+    assert expression.types == (bool,)