vellum-ai 1.8.1__py3-none-any.whl → 1.8.2__py3-none-any.whl

vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.8.1",
+            "User-Agent": "vellum-ai/1.8.2",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.8.1",
+            "X-Fern-SDK-Version": "1.8.2",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

vellum/workflows/nodes/displayable/final_output_node/node.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Generic, Tuple, Type, TypeVar, get_args
+from typing import Any, Dict, Generic, Tuple, Type, TypeVar, get_args, get_origin
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.nodes.bases import BaseNode
@@ -74,6 +74,12 @@ class _FinalOutputNodeMeta(BaseNodeMeta):
                 if descriptor_type == declared_output_type:
                     type_mismatch = False
                     break
+                if (
+                    get_origin(descriptor_type) == declared_output_type
+                    or get_origin(declared_output_type) == descriptor_type
+                ):
+                    type_mismatch = False
+                    break
                 try:
                     if issubclass(descriptor_type, declared_output_type) or issubclass(
                         declared_output_type, descriptor_type

vellum/workflows/nodes/displayable/final_output_node/tests/test_node.py

@@ -1,8 +1,10 @@
 import pytest
+from typing import Any, Dict
 
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
 from vellum.workflows.nodes.displayable.inline_prompt_node import InlinePromptNode
+from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.base import BaseState
 
 
@@ -57,3 +59,29 @@ def test_final_output_node__matching_output_type_should_pass_validation():
         CorrectOutput.__validate__()
     except ValueError:
         pytest.fail("Validation should not raise an exception for correct type matching")
+
+
+def test_final_output_node__dict_and_Dict_should_be_compatible():
+    """
+    Tests that FinalOutputNode validation recognizes dict and Dict[str, Any] as compatible types.
+    """
+
+    # GIVEN a FinalOutputNode declared with dict output type
+    # AND the value descriptor has Dict[str, Any] type
+    class DictOutputNode(FinalOutputNode[BaseState, dict]):
+        """Output with dict type."""
+
+        class Outputs(FinalOutputNode.Outputs):
+            value = OutputReference(
+                name="value",
+                types=(Dict[str, Any],),
+                instance=None,
+                outputs_class=FinalOutputNode.Outputs,
+            )
+
+    # WHEN attempting to validate the node class
+    # THEN validation should pass without raising an exception
+    try:
+        DictOutputNode.__validate__()
+    except ValueError as e:
+        pytest.fail(f"Validation should not raise an exception for dict/Dict compatibility: {e}")

{vellum_ai-1.8.1.dist-info → vellum_ai-1.8.2.dist-info}/METADATA

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

{vellum_ai-1.8.1.dist-info → vellum_ai-1.8.2.dist-info}/RECORD

@@ -121,11 +121,12 @@ vellum_ee/workflows/display/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeR
 vellum_ee/workflows/display/utils/auto_layout.py,sha256=f4GiLn_LazweupfqTpubcdtdfE_vrOcmZudSsnYIY9E,3906
 vellum_ee/workflows/display/utils/events.py,sha256=XcaQSfmk2s9ZNiU8__ZqH_zfp6KUVACczz9TBWVy7Jc,2208
 vellum_ee/workflows/display/utils/exceptions.py,sha256=E8Lvo7LY1BoZ54M_NR_opDjJsAAiCUfow1HgoHcTHmg,989
-vellum_ee/workflows/display/utils/expressions.py,sha256=9rcpoXhUIxcWy407Ziu-zJfP5OEFq3pHIh7XSZZ1Y6E,21169
+vellum_ee/workflows/display/utils/expressions.py,sha256=q6jgr13gET3rsAtz9XAPqtWQ2RKq_ZMq2OwrtyPhlRg,21345
 vellum_ee/workflows/display/utils/registry.py,sha256=1qXiBTdsnro6FeCX0FGBEK7CIf6wa--Jt50iZ_nEp_M,3460
 vellum_ee/workflows/display/utils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/utils/tests/test_auto_layout.py,sha256=vfXI769418s9vda5Gb5NFBH747WMOwSgHRXeLCTLVm8,2356
 vellum_ee/workflows/display/utils/tests/test_events.py,sha256=CiBx4WxeNAf1WGfgRdJ_I-Hc12RDfza73CMLB5HkOFg,6688
+vellum_ee/workflows/display/utils/tests/test_expressions.py,sha256=s8aHAwuuJS1_WI1B9geJCpTVKPk83XqrCI_ofVG80TI,4268
 vellum_ee/workflows/display/utils/vellum.py,sha256=Bt7kdLdXoBsHn5dVEY2uKcF542VL09jwu8J_30rl2vk,6413
 vellum_ee/workflows/display/vellum.py,sha256=J2mdJZ1sdLW535DDUkq_Vm8Z572vhuxHxVZF9deKSdk,391
 vellum_ee/workflows/display/workflows/__init__.py,sha256=JTB9ObEV3l4gGGdtfBHwVJtTTKC22uj-a-XjTVwXCyA,148
@@ -163,7 +164,7 @@ vellum/client/README.md,sha256=flqu57ubZNTfpq60CdLtJC9gp4WEkyjb_n_eZ4OYf9w,6497
 vellum/client/__init__.py,sha256=-nugZzQKoUJsStXe6PnOD__8kbDLKKokceDgpGxQ_q0,74576
 vellum/client/core/__init__.py,sha256=lTcqUPXcx4112yLDd70RAPeqq6tu3eFMe1pKOqkW9JQ,1562
 vellum/client/core/api_error.py,sha256=44vPoTyWN59gonCIZMdzw7M1uspygiLnr3GNFOoVL2Q,614
-vellum/client/core/client_wrapper.py,sha256=Nc6y6FZVXFJVLzna3Fwov3q7K_kZe-vhjAth09SQMUI,2840
+vellum/client/core/client_wrapper.py,sha256=R9FHIr5oH88cTW8SR-0nEW7PPcwHvfHMVIJ5NT-rUHM,2840
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 vellum/client/core/force_multipart.py,sha256=awxh5MtcRYe74ehY8U76jzv6fYM_w_D3Rur7KQQzSDk,429
@@ -1965,9 +1966,9 @@ vellum/workflows/nodes/displayable/conditional_node/__init__.py,sha256=AS_EIqFdU
 vellum/workflows/nodes/displayable/conditional_node/node.py,sha256=2g32hWosE3zwVaK2UPFnVEer1Nbn04s3friF2rGztmE,1195
 vellum/workflows/nodes/displayable/conftest.py,sha256=K2kLM2JGAfcrmmd92u8DXInUO5klFdggPWblg5RVcx4,5729
 vellum/workflows/nodes/displayable/final_output_node/__init__.py,sha256=G7VXM4OWpubvSJtVkGmMNeqgb9GkM7qZT838eL18XU4,72
-vellum/workflows/nodes/displayable/final_output_node/node.py,sha256=1_F9S7w-gIEUoXIdilgpqDeCKxJ0_J0oTYvE35dbjHk,4908
+vellum/workflows/nodes/displayable/final_output_node/node.py,sha256=ypetAGBaTjVozKqAos-C1LG5HHZ3iUekw7v2mnnUlOw,5175
 vellum/workflows/nodes/displayable/final_output_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/final_output_node/tests/test_node.py,sha256=FR7lWUJlcWW1e9q_3vefi-b8_LA7CayZgTWZAnlAiLg,2387
+vellum/workflows/nodes/displayable/final_output_node/tests/test_node.py,sha256=Drj7tMNEBDzHIYQ5iLkIK0zHHj-NxiswCtefVbfDFRo,3418
 vellum/workflows/nodes/displayable/guardrail_node/__init__.py,sha256=Ab5eXmOoBhyV4dMWdzh32HLUmnPIBEK_zFCT38C4Fng,68
 vellum/workflows/nodes/displayable/guardrail_node/node.py,sha256=axYUojar_kdB3gi4LG3g9euJ8VkOxNtiFxJNI46v-SQ,5869
 vellum/workflows/nodes/displayable/guardrail_node/test_node.py,sha256=SAGv6hSFcBwQkudn1VxtaKNsXSXWWELl3eK05zM6tS0,5410
@@ -2098,8 +2099,8 @@ vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnad
 vellum/workflows/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/workflows/tests/test_base_workflow.py,sha256=Boa-_m9ii2Qsa1RvVM-VYniF7zCpzGgEGy-OnPZkrHg,23941
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-1.8.1.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-1.8.1.dist-info/METADATA,sha256=DWOrpnEfvfz7WdwnejydRvKJau7iQDUFZZCSpLQZ3xE,5547
-vellum_ai-1.8.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-1.8.1.dist-info/entry_points.txt,sha256=xVavzAKN4iF_NbmhWOlOkHluka0YLkbN_pFQ9pW3gLI,117
-vellum_ai-1.8.1.dist-info/RECORD,,
+vellum_ai-1.8.2.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-1.8.2.dist-info/METADATA,sha256=nwlFb3WTY_gf483WFZdyHF2D8rUblIoUSF900h7Gn3o,5547
+vellum_ai-1.8.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-1.8.2.dist-info/entry_points.txt,sha256=xVavzAKN4iF_NbmhWOlOkHluka0YLkbN_pFQ9pW3gLI,117
+vellum_ai-1.8.2.dist-info/RECORD,,

vellum_ee/workflows/display/utils/expressions.py

@@ -27,6 +27,7 @@ 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_error import IsErrorExpression
 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
@@ -105,6 +106,8 @@ def convert_descriptor_to_operator(descriptor: BaseDescriptor) -> LogicalOperato
         return "doesNotBeginWith"
     elif isinstance(descriptor, DoesNotEndWithExpression):
         return "doesNotEndWith"
+    elif isinstance(descriptor, IsErrorExpression):
+        return "isError"
     elif isinstance(descriptor, (IsNullExpression, IsNilExpression, IsUndefinedExpression)):
         return "null"
     elif isinstance(descriptor, (IsNotNullExpression, IsNotNilExpression, IsNotUndefinedExpression)):
@@ -166,6 +169,7 @@ def _serialize_condition(
     if isinstance(
         condition,
         (
+            IsErrorExpression,
             IsNullExpression,
             IsNotNullExpression,
             IsNilExpression,

vellum_ee/workflows/display/utils/tests/test_expressions.py

@@ -0,0 +1,86 @@
+import pytest
+
+from vellum.workflows.expressions.begins_with import BeginsWithExpression
+from vellum.workflows.expressions.between import BetweenExpression
+from vellum.workflows.expressions.contains import ContainsExpression
+from vellum.workflows.expressions.does_not_begin_with import DoesNotBeginWithExpression
+from vellum.workflows.expressions.does_not_contain import DoesNotContainExpression
+from vellum.workflows.expressions.does_not_end_with import DoesNotEndWithExpression
+from vellum.workflows.expressions.does_not_equal import DoesNotEqualExpression
+from vellum.workflows.expressions.ends_with import EndsWithExpression
+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_error import IsErrorExpression
+from vellum.workflows.expressions.is_not_null import IsNotNullExpression
+from vellum.workflows.expressions.is_null import IsNullExpression
+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
+from vellum.workflows.expressions.not_in import NotInExpression
+from vellum_ee.workflows.display.utils.expressions import convert_descriptor_to_operator
+
+
+def binary_expressions_with_lhs_and_rhs():
+    return [
+        (EqualsExpression(lhs="123", rhs="456"), "="),
+        (DoesNotEqualExpression(lhs="123", rhs="456"), "!="),
+        (LessThanExpression(lhs="123", rhs="456"), "<"),
+        (GreaterThanExpression(lhs="123", rhs="456"), ">"),
+        (LessThanOrEqualToExpression(lhs="123", rhs="456"), "<="),
+        (GreaterThanOrEqualToExpression(lhs="123", rhs="456"), ">="),
+        (ContainsExpression(lhs="123", rhs="456"), "contains"),
+        (BeginsWithExpression(lhs="123", rhs="456"), "beginsWith"),
+        (EndsWithExpression(lhs="123", rhs="456"), "endsWith"),
+        (DoesNotContainExpression(lhs="123", rhs="456"), "doesNotContain"),
+        (DoesNotBeginWithExpression(lhs="123", rhs="456"), "doesNotBeginWith"),
+        (DoesNotEndWithExpression(lhs="123", rhs="456"), "doesNotEndWith"),
+        (InExpression(lhs="123", rhs="456"), "in"),
+        (NotInExpression(lhs="123", rhs="456"), "notIn"),
+    ]
+
+
+def unary_expressions_with_expression():
+    return [
+        (IsErrorExpression(expression="123"), "isError"),
+        (IsNullExpression(expression="123"), "null"),
+        (IsNotNullExpression(expression="123"), "notNull"),
+    ]
+
+
+def ternary_expressions_with_value_and_start_and_end():
+    return [
+        (BetweenExpression(value="123", start="456", end="789"), "between"),
+        (NotBetweenExpression(value="123", start="456", end="789"), "notBetween"),
+    ]
+
+
+@pytest.mark.parametrize("expression, expected_operator", binary_expressions_with_lhs_and_rhs())
+def test_convert_descriptor_to_operator__binary_expressions(expression, expected_operator):
+    # GIVEN a binary expression descriptor
+    # WHEN we convert it to an operator string
+    result = convert_descriptor_to_operator(expression)
+
+    # THEN we should get the expected operator string
+    assert result == expected_operator
+
+
+@pytest.mark.parametrize("expression, expected_operator", unary_expressions_with_expression())
+def test_convert_descriptor_to_operator__unary_expressions(expression, expected_operator):
+    # GIVEN a unary expression descriptor
+    # WHEN we convert it to an operator string
+    result = convert_descriptor_to_operator(expression)
+
+    # THEN we should get the expected operator string
+    assert result == expected_operator
+
+
+@pytest.mark.parametrize("expression, expected_operator", ternary_expressions_with_value_and_start_and_end())
+def test_convert_descriptor_to_operator__ternary_expressions(expression, expected_operator):
+    # GIVEN a ternary expression descriptor
+    # WHEN we convert it to an operator string
+    result = convert_descriptor_to_operator(expression)
+
+    # THEN we should get the expected operator string
+    assert result == expected_operator