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

vellum/plugins/utils.py

@@ -1,11 +1,19 @@
-from pydantic.plugin import _loader as _pydantic_plugin_loader
-
-from vellum.plugins.pydantic import pydantic_plugin
+import pydantic
 
+IS_PYDANTIC_V1 = pydantic.VERSION.startswith("1.")
 _loaded = False
 
 
 def load_runtime_plugins() -> None:
+    if IS_PYDANTIC_V1:
+        # Pydantic plugins are only available in v2, so we defer the imports
+        # below until we confirm we are running a supported version of pydantic
+        return
+
+    from pydantic.plugin import _loader as _pydantic_plugin_loader
+
+    from vellum.plugins.pydantic import pydantic_plugin
+
     global _loaded
     if _loaded:
         return

vellum/workflows/events/node.py

@@ -93,6 +93,7 @@ class NodeExecutionStreamingEvent(_BaseNodeEvent):
 class NodeExecutionFulfilledBody(_BaseNodeExecutionBody, Generic[OutputsType]):
     outputs: OutputsType
     invoked_ports: InvokedPorts = None
+    mocked: Optional[bool] = None
 
     @field_serializer("outputs")
     def serialize_outputs(self, outputs: OutputsType, _info: Any) -> Dict[str, Any]:
@@ -117,6 +118,10 @@ class NodeExecutionFulfilledEvent(_BaseNodeEvent, Generic[OutputsType]):
     def invoked_ports(self) -> InvokedPorts:
         return self.body.invoked_ports
 
+    @property
+    def mocked(self) -> Optional[bool]:
+        return self.body.mocked
+
 
 class NodeExecutionRejectedBody(_BaseNodeExecutionBody):
     error: WorkflowError

vellum/workflows/events/tests/test_event.py

@@ -328,6 +328,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                             "name": "default",
                         }
                     ],
+                    "mocked": None,
                 },
                 "parent": None,
             },
@@ -365,6 +366,40 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                             "name": "default",
                         }
                     ],
+                    "mocked": None,
+                },
+                "parent": None,
+            },
+        ),
+        (
+            NodeExecutionFulfilledEvent(
+                id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                timestamp=datetime(2024, 1, 1, 12, 0, 0),
+                trace_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                body=NodeExecutionFulfilledBody(
+                    node_definition=MockNode,
+                    outputs=MockNode.Outputs(
+                        example="foo",
+                    ),
+                    mocked=True,
+                ),
+            ),
+            {
+                "id": "123e4567-e89b-12d3-a456-426614174000",
+                "api_version": "2024-10-25",
+                "timestamp": "2024-01-01T12:00:00",
+                "trace_id": "123e4567-e89b-12d3-a456-426614174000",
+                "span_id": "123e4567-e89b-12d3-a456-426614174000",
+                "name": "node.execution.fulfilled",
+                "body": {
+                    "node_definition": {
+                        "id": mock_node_uuid,
+                        "name": "MockNode",
+                        "module": module_root + ["events", "tests", "test_event"],
+                    },
+                    "outputs": {"example": "foo"},
+                    "mocked": True,
                 },
                 "parent": None,
             },
@@ -379,6 +414,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
         "node.execution.streaming",
         "node.execution.fulfilled",
         "fulfilled_node_with_undefined_outputs",
+        "mocked_node",
     ],
 )
 def test_event_serialization(event, expected_json):

vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py

@@ -283,3 +283,19 @@ def test_templating_node__function_call_as_json():
     # AND we can access fields directly
     assert outputs.result["arguments"] == {"key": "value"}
     assert outputs.result["name"] == "test_function"
+
+
+def test_templating_node__empty_string_to_list():
+    """Test that an empty string output with list output type casts to an empty array."""
+
+    # GIVEN a templating node that outputs an empty string but has List output type
+    class EmptyStringToListTemplateNode(TemplatingNode[BaseState, List[str]]):
+        template = """{{ "" }}"""
+        inputs = {}
+
+    # WHEN the node is run
+    node = EmptyStringToListTemplateNode()
+    outputs = node.run()
+
+    # THEN the output should be an empty list, not raise an exception
+    assert outputs.result == []

vellum/workflows/nodes/tests/test_utils.py

@@ -0,0 +1,133 @@
+import pytest
+from typing import List, Union
+
+from pydantic import BaseModel
+
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.utils import parse_type_from_str
+from vellum.workflows.types.core import Json
+
+
+class Person(BaseModel):
+    name: str
+    age: int
+
+
+class FunctionCall(BaseModel):
+    name: str
+    args: List[int]
+
+
+@pytest.mark.parametrize(
+    "input_str, output_type, expected_result",
+    [
+        ("hello", str, "hello"),
+        ("3.14", float, 3.14),
+        ("42", int, 42),
+        ("True", bool, True),
+        ("", List[str], []),  # Empty string should return an empty list
+        ("[1, 2, 3]", List[int], [1, 2, 3]),
+        ('["a", "b", "c"]', List[str], ["a", "b", "c"]),
+        ('{"name": "Alice", "age": 30}', Json, {"name": "Alice", "age": 30}),
+        (
+            '{"type": "FUNCTION_CALL", "value": {"name": "test", "args": [1, 2]}}',
+            Json,
+            {"name": "test", "args": [1, 2]},
+        ),
+        ("42", Union[int, str], 42),
+        ("hello", Union[int, str], "hello"),
+    ],
+    ids=[
+        "str",
+        "float",
+        "int",
+        "bool",
+        "empty_list",
+        "list_of_int",
+        "list_of_str",
+        "simple_json",
+        "function_call_json",
+        "union_int",
+        "union_str",
+    ],
+)
+def test_parse_type_from_str_basic_cases(input_str, output_type, expected_result):
+    result = parse_type_from_str(input_str, output_type)
+    assert result == expected_result
+
+
+def test_parse_type_from_str_pydantic_models():
+    person_json = '{"name": "Alice", "age": 30}'
+    person = parse_type_from_str(person_json, Person)
+    assert isinstance(person, Person)
+    assert person.name == "Alice"
+    assert person.age == 30
+
+    function_json = '{"name": "test", "args": [1, 2]}'
+    function = parse_type_from_str(function_json, FunctionCall)
+    assert isinstance(function, FunctionCall)
+    assert function.name == "test"
+    assert function.args == [1, 2]
+
+    function_call_json = '{"value": {"name": "test", "args": [1, 2]}}'
+    function = parse_type_from_str(function_call_json, FunctionCall)
+    assert isinstance(function, FunctionCall)
+    assert function.name == "test"
+    assert function.args == [1, 2]
+
+
+def test_parse_type_from_str_list_of_models():
+    person_list_json = '[{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]'
+    persons = parse_type_from_str(person_list_json, List[Person])
+    assert len(persons) == 2
+    assert all(isinstance(p, Person) for p in persons)
+    assert persons[0].name == "Alice"
+    assert persons[0].age == 30
+    assert persons[1].name == "Bob"
+    assert persons[1].age == 25
+
+
+@pytest.mark.parametrize(
+    "input_str, output_type, expected_exception, expected_code, expected_message",
+    [
+        (
+            "{invalid json}",
+            List[str],
+            NodeException,
+            WorkflowErrorCode.INVALID_OUTPUTS,
+            "Invalid JSON Array format for result_as_str",
+        ),
+        (
+            "{invalid json}",
+            Person,
+            NodeException,
+            WorkflowErrorCode.INVALID_OUTPUTS,
+            "Invalid JSON format for result_as_str",
+        ),
+        (
+            "{invalid json}",
+            Json,
+            NodeException,
+            WorkflowErrorCode.INVALID_OUTPUTS,
+            "Invalid JSON format for result_as_str",
+        ),
+        ('{"name": "Alice"}', List[str], ValueError, None, "Expected a list of items for result_as_str, received dict"),
+        ("data", object, ValueError, None, "Unsupported output type: <class 'object'>"),
+    ],
+    ids=[
+        "invalid_json_list",
+        "invalid_json_model",
+        "invalid_json_json_type",
+        "non_list_for_list",
+        "unsupported_type",
+    ],
+)
+def test_parse_type_from_str_error_cases(input_str, output_type, expected_exception, expected_code, expected_message):
+    with pytest.raises(expected_exception) as excinfo:
+        parse_type_from_str(input_str, output_type)
+
+    if expected_code:
+        assert excinfo.value.code == expected_code
+
+    assert expected_message in str(excinfo.value)

vellum/workflows/nodes/utils.py

@@ -95,10 +95,18 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
         return bool(result_as_str)
 
     if get_origin(output_type) is list:
+        # Handle empty string case for list types by returning an empty list
+        if not result_as_str.strip():
+            return []
+
         try:
             data = json.loads(result_as_str)
         except json.JSONDecodeError:
-            raise ValueError("Invalid JSON Array format for result_as_str")
+            # raise ValueError("Invalid JSON Array format for result_as_str")
+            raise NodeException(
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+                message="Invalid JSON Array format for result_as_str",
+            )
 
         if not isinstance(data, list):
             raise ValueError(f"Expected a list of items for result_as_str, received {data.__class__.__name__}")
@@ -117,7 +125,10 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
                 return data["value"]
             return data
         except json.JSONDecodeError:
-            raise ValueError("Invalid JSON format for result_as_str")
+            raise NodeException(
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+                message="Invalid JSON format for result_as_str",
+            )
 
     if get_origin(output_type) is Union:
         for inner_type in get_args(output_type):
@@ -140,7 +151,10 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
                 data = data["value"]
             return output_type.model_validate(data)
         except json.JSONDecodeError:
-            raise ValueError("Invalid JSON format for result_as_str")
+            raise NodeException(
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+                message="Invalid JSON format for result_as_str",
+            )
 
     raise ValueError(f"Unsupported output type: {output_type}")
 

vellum/workflows/runner/runner.py

@@ -200,7 +200,7 @@ class WorkflowRunner(Generic[StateType]):
                 parent=parent_context,
             )
             node_run_response: NodeRunResponse
-            was_mocked = False
+            was_mocked: Optional[bool] = None
             mock_candidates = self.workflow.context.node_output_mocks_map.get(node.Outputs) or []
             for mock_candidate in mock_candidates:
                 if mock_candidate.when_condition.resolve(node.state):
@@ -315,6 +315,7 @@ class WorkflowRunner(Generic[StateType]):
                         node_definition=node.__class__,
                         outputs=outputs,
                         invoked_ports=invoked_ports,
+                        mocked=was_mocked,
                     ),
                     parent=parent_context,
                 )

{vellum_ai-0.14.13.dist-info → vellum_ai-0.14.14.dist-info}/METADATA

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

{vellum_ai-0.14.13.dist-info → vellum_ai-0.14.14.dist-info}/RECORD

@@ -123,7 +123,7 @@ vellum/client/README.md,sha256=JkCJjmMZl4jrPj46pkmL9dpK4gSzQQmP5I7z4aME4LY,4749
 vellum/client/__init__.py,sha256=tKtdM1_GqmGq1gpi9ydWD_T-MM7fPn8QdHh8ww19cNI,117564
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=rm58d4E5Lrfg-SwnN1AtE5vFfVb1Qy6a5GyVyEmNWvU,1869
+vellum/client/core/client_wrapper.py,sha256=F65g9wG6SXfGPkAao7k0GN7doBs1E434iyOswOpG3iE,1869
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=X9IbmkZmB2bB_DpmZAO3crWdXagOakAyn6UCOCImCPg,2322
 vellum/client/core/http_client.py,sha256=R0pQpCppnEtxccGvXl4uJ76s7ro_65Fo_erlNNLp_AI,19228
@@ -720,7 +720,7 @@ vellum/evaluations/utils/exceptions.py,sha256=dXMAkzqbHV_AP5FjjbegPlfUE0zQDlpA3q
 vellum/evaluations/utils/paginator.py,sha256=rEED_BJAXAM6tM1yMwHePNzszjq_tTq4NbQvi1jWQ_Q,697
 vellum/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/plugins/pydantic.py,sha256=BMUwC4OkxtNf6hpLwb0T4MBUKgkGy55T_5Ww7GHpHYo,3068
-vellum/plugins/utils.py,sha256=U9ZY9KdE3RRvbcG01hXxu9CvfJD6Fo7nJDgcHjQn0FI,606
+vellum/plugins/utils.py,sha256=cPmxE9R2CK1bki2jKE8rB-G9zMf2pzHjSPDHFPXwd3Q,878
 vellum/plugins/vellum_mypy.py,sha256=QTuMSq6PiZW1dyTUZ5Bf1d4XkgFj0TKAgZLP8f4UgL4,27914
 vellum/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/prompts/blocks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1312,9 +1312,9 @@ vellum/workflows/environment/environment.py,sha256=0XhJPBs8YASWmvPx8bkSdCvcbDmzp
 vellum/workflows/errors/__init__.py,sha256=tWGPu5xyAU8gRb8_bl0fL7OfU3wxQ9UH6qVwy4X4P_Q,113
 vellum/workflows/errors/types.py,sha256=tVW7Il9zalnwWzdoDLqYPIvRTOhXIv6FPORZAbU7n5Q,3640
 vellum/workflows/events/__init__.py,sha256=6pxxceJo2dcaRkWtkDAYlUQZ-PHBQSZytIoyuUK48Qw,759
-vellum/workflows/events/node.py,sha256=uHT6If0esgZ3nLjrjmUPTKf3qbjGhoV_x5YKpjDBDcU,5280
+vellum/workflows/events/node.py,sha256=jbmNHjdp331Q1IRK-AWtAxwF6Lidb9R7__N5rQuilE8,5401
 vellum/workflows/events/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/events/tests/test_event.py,sha256=uRfMwSOqU-ROeZKCEngGvvJYlOZuxBhnC3qH5AGi3fM,15399
+vellum/workflows/events/tests/test_event.py,sha256=sHcKhZPDPtzZfTmehL4NORA_StR4M6nZDcx9kz3Avo0,16866
 vellum/workflows/events/types.py,sha256=AeTJaQt_fNHDLI4nyBzo7XrW9QQybRC09AKzu3kEYEE,3575
 vellum/workflows/events/workflow.py,sha256=QoSHyIOpuVacbR7POf7h104miTOhCjtO2udnYximJGs,6851
 vellum/workflows/exceptions.py,sha256=NiBiR3ggfmPxBVqD-H1SqmjI-7mIn0EStSN1BqApvCM,1213
@@ -1383,7 +1383,7 @@ vellum/workflows/nodes/core/retry_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TI
 vellum/workflows/nodes/core/retry_node/tests/test_node.py,sha256=RM_OHwxrHwyxvlQQBJPqVBxpedFuWQ9h2-Xa3kP75sc,4399
 vellum/workflows/nodes/core/templating_node/__init__.py,sha256=GmyuYo81_A1_Bz6id69ozVFS6FKiuDsZTiA3I6MaL2U,70
 vellum/workflows/nodes/core/templating_node/node.py,sha256=-JIqLUv6Xpx_LTVZt7whQ2X2VatgHDdTxjMrz64luEs,3721
-vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py,sha256=ldnmSASx0TfAnT3ZvU0AXtN0diZGrfySiXipuJIIzWU,9055
+vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py,sha256=MHofz-BwAgt7EXkab8VIyacYznDEIJ7Er7MJUaxNQQo,9614
 vellum/workflows/nodes/core/try_node/__init__.py,sha256=JVD4DrldTIqFQQFrubs9KtWCCc0YCAc7Fzol5ZWIWeM,56
 vellum/workflows/nodes/core/try_node/node.py,sha256=5ux1l2HO12FBFFyhz6j-4yfBYVrqgT2maTAne_GnNDk,4434
 vellum/workflows/nodes/core/try_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1453,7 +1453,8 @@ vellum/workflows/nodes/experimental/openai_chat_completion_node/node.py,sha256=1
 vellum/workflows/nodes/mocks.py,sha256=a1FjWEIocseMfjzM-i8DNozpUsaW0IONRpZmXBoWlyc,10455
 vellum/workflows/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/tests/test_mocks.py,sha256=mfPvrs75PKcsNsbJLQAN6PDFoVqs9TmQxpdyFKDdO60,7837
-vellum/workflows/nodes/utils.py,sha256=uaTPGYp4utenz_QDghqQ23Q1iCsGHQ40nNZh1g9H9WI,7117
+vellum/workflows/nodes/tests/test_utils.py,sha256=7PtdV_fzl56agx0IDitdqOmqUO9cQZmJww-3ToxzSqA,4174
+vellum/workflows/nodes/utils.py,sha256=b-U8xjUpGswaoEiav5tU_OFKB26GkYFzuko9XCMU_Fo,7627
 vellum/workflows/outputs/__init__.py,sha256=AyZ4pRh_ACQIGvkf0byJO46EDnSix1ZCAXfvh-ms1QE,94
 vellum/workflows/outputs/base.py,sha256=b4Dnha1miKu3uFJYptKKflIHNuajPF2BNKy0BTt8Tjc,8622
 vellum/workflows/ports/__init__.py,sha256=bZuMt-R7z5bKwpu4uPW7LlJeePOQWmCcDSXe5frUY5g,101
@@ -1475,7 +1476,7 @@ vellum/workflows/references/workflow_input.py,sha256=86IuhlBz-9cGxeUzizyjdp482aj
 vellum/workflows/resolvers/__init__.py,sha256=eH6hTvZO4IciDaf_cf7aM2vs-DkBDyJPycOQevJxQnI,82
 vellum/workflows/resolvers/base.py,sha256=WHra9LRtlTuB1jmuNqkfVE2JUgB61Cyntn8f0b0WZg4,411
 vellum/workflows/runner/__init__.py,sha256=i1iG5sAhtpdsrlvwgH6B-m49JsINkiWyPWs8vyT-bqM,72
-vellum/workflows/runner/runner.py,sha256=_p19T1woplSxZGabZuSUFBKSYBrXADrM7b_1YnWVN3g,31013
+vellum/workflows/runner/runner.py,sha256=fS21u0LIyhxT4T6YQPgonVuH8X8TgD5BrsbVxPUWfuM,31071
 vellum/workflows/sandbox.py,sha256=GVJzVjMuYzOBnSrboB0_6MMRZWBluAyQ2o7syeaeBd0,2235
 vellum/workflows/state/__init__.py,sha256=yUUdR-_Vl7UiixNDYQZ-GEM_kJI9dnOia75TtuNEsnE,60
 vellum/workflows/state/base.py,sha256=Vkhneko3VlQrPsMLU1PYSzXU_W1u7_AraJsghiv5O-4,15512
@@ -1511,8 +1512,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=NRteiICyJvDM5zrtUfq2fZoXcGQVaWC9xmNlLLVW0cU,7979
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-0.14.13.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.13.dist-info/METADATA,sha256=y44fYKH3DaYDbx8hhtZFAtWbGESUBWDUV-2W_JL-XiI,5408
-vellum_ai-0.14.13.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.13.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.13.dist-info/RECORD,,
+vellum_ai-0.14.14.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.14.dist-info/METADATA,sha256=UKCcEJ4XtYH1PteNKqVZjzrWn3-WMYYFFEl9SLs_lF4,5408
+vellum_ai-0.14.14.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.14.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.14.dist-info/RECORD,,