vellum-ai 0.14.13__tar.gz → 0.14.14__tar.gz

{vellum_ai-0.14.13 → vellum_ai-0.14.14}/PKG-INFO

@@ -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 → vellum_ai-0.14.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.14.13"
+version = "0.14.14"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.14.13 → vellum_ai-0.14.14}/src/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_ai-0.14.13 → vellum_ai-0.14.14}/src/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_ai-0.14.13 → vellum_ai-0.14.14}/src/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_ai-0.14.13 → vellum_ai-0.14.14}/src/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_ai-0.14.13 → vellum_ai-0.14.14}/src/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_ai-0.14.14/src/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_ai-0.14.13 → vellum_ai-0.14.14}/src/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_ai-0.14.13 → vellum_ai-0.14.14}/src/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,
                 )