vellum-ai 0.14.12__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.12",
+            "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/descriptors/base.py

@@ -71,6 +71,9 @@ class BaseDescriptor(Generic[_T]):
     def __hash__(self) -> int:
         return hash(self._name)
 
+    def __repr__(self) -> str:
+        return self._name
+
     @overload
     def __get__(self, instance: "BaseNode", owner: Type["BaseNode"]) -> _T: ...
 

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/events/workflow.py

@@ -1,5 +1,6 @@
 from uuid import UUID
 from typing import TYPE_CHECKING, Any, Dict, Generator, Generic, Iterable, Literal, Optional, Type, Union
+from typing_extensions import TypeGuard
 
 from pydantic import field_serializer
 
@@ -182,3 +183,25 @@ WorkflowEvent = Union[
 ]
 
 WorkflowEventStream = Generator[WorkflowEvent, None, None]
+
+WorkflowExecutionEvent = Union[
+    WorkflowExecutionInitiatedEvent,
+    WorkflowExecutionStreamingEvent,
+    WorkflowExecutionRejectedEvent,
+    WorkflowExecutionPausedEvent,
+    WorkflowExecutionResumedEvent,
+    WorkflowExecutionFulfilledEvent,
+    WorkflowExecutionSnapshottedEvent,
+]
+
+
+def is_workflow_event(event: WorkflowEvent) -> TypeGuard[WorkflowExecutionEvent]:
+    return (
+        event.name == "workflow.execution.initiated"
+        or event.name == "workflow.execution.fulfilled"
+        or event.name == "workflow.execution.streaming"
+        or event.name == "workflow.execution.snapshotted"
+        or event.name == "workflow.execution.paused"
+        or event.name == "workflow.execution.resumed"
+        or event.name == "workflow.execution.rejected"
+    )

vellum/workflows/inputs/base.py

@@ -42,38 +42,46 @@ class BaseInputs(metaclass=_BaseInputsMeta):
     __parent_class__: Type = type(None)
 
     def __init__(self, **kwargs: Any) -> None:
+        """
+        Initialize BaseInputs with provided keyword arguments.
+
+        Validation logic:
+        1. Ensures all required fields (non-Optional types) either:
+        - Have a value provided in kwargs, or
+        - Have a default value defined in the class
+        2. Validates that no None values are provided for required fields
+        3. Sets all provided values as attributes on the instance
+
+        Args:
+            **kwargs: Keyword arguments corresponding to the class's type annotations
+
+        Raises:
+            WorkflowInitializationException: If a required field is missing or None
+        """
         for name, field_type in self.__class__.__annotations__.items():
-            if name not in kwargs and name not in vars(self.__class__):
+            # Get the value (either from kwargs or class default)
+            value = kwargs.get(name)
+            has_default = name in vars(self.__class__)
+
+            if value is None and not has_default:
+                # Check if field_type allows None
                 origin = get_origin(field_type)
                 args = get_args(field_type)
                 if not (origin is Union and type(None) in args):
                     raise WorkflowInitializationException(
-                        message="Required input variables should have defined value",
+                        message=f"Required input variables {name} should have defined value",
                         code=WorkflowErrorCode.INVALID_INPUTS,
                     )
 
-        for name, value in kwargs.items():
-            field_type = self.__class__.__annotations__.get(name)
-            if field_type:
-                self._validate_input(value, field_type)
-            setattr(self, name, value)
+            # If value provided in kwargs, set it on the instance
+            if name in kwargs:
+                setattr(self, name, value)
 
     def __iter__(self) -> Iterator[Tuple[InputReference, Any]]:
         for input_descriptor in self.__class__:
             if hasattr(self, input_descriptor.name):
                 yield (input_descriptor, getattr(self, input_descriptor.name))
 
-    def _validate_input(self, value: Any, field_type: Any) -> None:
-        if value is None:
-            # Check if field_type is Optional
-            origin = get_origin(field_type)
-            args = get_args(field_type)
-            if not (origin is Union and type(None) in args):
-                raise WorkflowInitializationException(
-                    message="Required input variables should have defined value",
-                    code=WorkflowErrorCode.INVALID_INPUTS,
-                )
-
     @classmethod
     def __get_pydantic_core_schema__(
         cls, source_type: Type[Any], handler: GetCoreSchemaHandler

vellum/workflows/inputs/tests/test_inputs.py

@@ -34,7 +34,7 @@ def test_base_inputs_empty_value():
 
     # THEN it should raise a NodeException with the correct error message and code
     assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
-    assert "Required input variables should have defined value" in str(exc_info.value)
+    assert "Required input variables required_string should have defined value" == str(exc_info.value)
 
 
 def test_base_inputs_with_default():

vellum/workflows/nodes/bases/base.py

@@ -19,6 +19,7 @@ from vellum.workflows.ports.port import Port
 from vellum.workflows.references import ExternalInputReference
 from vellum.workflows.references.execution_count import ExecutionCountReference
 from vellum.workflows.references.node import NodeReference
+from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.core import MergeBehavior
@@ -118,6 +119,11 @@ class BaseNodeMeta(type):
         node_class.Trigger.node_class = node_class
         node_class.ExternalInputs.__parent_class__ = node_class
         node_class.__id__ = uuid4_from_hash(node_class.__qualname__)
+        node_class.__output_ids__ = {
+            ref.name: uuid4_from_hash(f"{node_class.__id__}|{ref.name}")
+            for ref in node_class.Outputs
+            if isinstance(ref, OutputReference)
+        }
         return node_class
 
     @property
@@ -236,6 +242,7 @@ NodeRunResponse = Union[BaseOutputs, Iterator[BaseOutput]]
 
 class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
     __id__: UUID = uuid4_from_hash(__qualname__)
+    __output_ids__: Dict[str, UUID] = {}
     state: StateType
     _context: WorkflowContext
     _inputs: MappingProxyType[NodeReference, Any]

vellum/workflows/nodes/core/inline_subworkflow_node/node.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterator, Option
 from vellum.workflows.constants import undefined
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.events.workflow import is_workflow_event
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode, BaseNodeMeta
@@ -86,6 +87,12 @@ class InlineSubworkflowNode(
 
         for event in subworkflow_stream:
             self._context._emit_subworkflow_event(event)
+
+            if not is_workflow_event(event):
+                continue
+            if event.workflow_definition != self.subworkflow:
+                continue
+
             if event.name == "workflow.execution.streaming":
                 if event.output.is_fulfilled:
                     fulfilled_output_names.add(event.output.name)

vellum/workflows/nodes/core/inline_subworkflow_node/tests/test_node.py

@@ -3,6 +3,7 @@ import pytest
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
+from vellum.workflows.nodes.core.try_node.node import TryNode
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.workflows.base import BaseWorkflow
@@ -55,3 +56,34 @@ def test_inline_subworkflow_node__support_inputs_as_attributes():
     assert events == [
         BaseOutput(name="out", value="bar"),
     ]
+
+
+def test_inline_subworkflow_node__nested_try():
+    """
+    Ensure that the nested try node doesn't affect the subworkflow node's outputs
+    """
+
+    # GIVEN a nested try node
+    @TryNode.wrap()
+    class InnerNode(BaseNode):
+        class Outputs:
+            foo = "hello"
+
+    # AND a subworkflow
+    class Subworkflow(BaseWorkflow):
+        graph = InnerNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            bar = InnerNode.Outputs.foo
+
+    # AND an outer try node referencing that subworkflow
+    class OuterNode(InlineSubworkflowNode):
+        subworkflow = Subworkflow
+
+    # WHEN we run the try node
+    stream = OuterNode().run()
+    events = list(stream)
+
+    # THEN we only have the outer node's outputs
+    valid_events = [e for e in events if e.name == "bar"]
+    assert len(valid_events) == len(events)

vellum/workflows/nodes/core/map_node/node.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+import logging
 from queue import Empty, Queue
 from threading import Thread
 from typing import (
@@ -19,6 +20,7 @@ from typing import (
 from vellum.workflows.context import ExecutionContext, execution_context, get_execution_context
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.events.workflow import is_workflow_event
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
@@ -33,6 +35,8 @@ from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 if TYPE_CHECKING:
     from vellum.workflows.events.workflow import WorkflowEvent
 
+logger = logging.getLogger(__name__)
+
 MapNodeItemType = TypeVar("MapNodeItemType")
 
 
@@ -104,19 +108,36 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
                 subworkflow_event = map_node_event[1]
                 self._context._emit_subworkflow_event(subworkflow_event)
 
+                if not is_workflow_event(subworkflow_event):
+                    continue
+
+                if subworkflow_event.workflow_definition != self.subworkflow:
+                    continue
+
                 if subworkflow_event.name == "workflow.execution.initiated":
                     for output_name in mapped_items.keys():
                         yield BaseOutput(name=output_name, delta=(None, index, "INITIATED"))
 
                 elif subworkflow_event.name == "workflow.execution.fulfilled":
-                    workflow_output_vars = vars(subworkflow_event.outputs)
-
-                    for output_name in workflow_output_vars:
-                        output_mapped_items = mapped_items[output_name]
-                        output_mapped_items[index] = workflow_output_vars[output_name]
+                    for output_reference, output_value in subworkflow_event.outputs:
+                        if not isinstance(output_reference, OutputReference):
+                            logger.error(
+                                "Invalid key to map node's subworkflow event outputs",
+                                extra={"output_reference_type": type(output_reference)},
+                            )
+                            continue
+
+                        output_mapped_items = mapped_items[output_reference.name]
+                        if index < 0 or index >= len(output_mapped_items):
+                            logger.error(
+                                "Invalid map node index", extra={"index": index, "output_name": output_reference.name}
+                            )
+                            continue
+
+                        output_mapped_items[index] = output_value
                         yield BaseOutput(
-                            name=output_name,
-                            delta=(output_mapped_items[index], index, "FULFILLED"),
+                            name=output_reference.name,
+                            delta=(output_value, index, "FULFILLED"),
                         )
 
                     fulfilled_iterations[index] = True

vellum/workflows/nodes/core/map_node/tests/test_node.py

@@ -3,8 +3,10 @@ import time
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.core.map_node.node import MapNode
+from vellum.workflows.nodes.core.try_node.node import TryNode
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.state.base import BaseState, StateMeta
+from vellum.workflows.workflows.base import BaseWorkflow
 
 
 def test_map_node__use_parent_inputs_and_state():
@@ -85,3 +87,32 @@ def test_map_node__empty_list():
     # THEN the node should return an empty output
     fulfilled_output = outputs[-1]
     assert fulfilled_output == BaseOutput(name="value", value=[])
+
+
+def test_map_node__inner_try():
+    # GIVEN a try wrapped node
+    @TryNode.wrap()
+    class InnerNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            foo: str
+
+    # AND a workflow using that node
+    class SimpleMapNodeWorkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
+        graph = InnerNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_output = InnerNode.Outputs.foo
+
+    # AND a map node referencing that workflow
+    class SimpleMapNode(MapNode):
+        items = ["hello", "world"]
+        subworkflow = SimpleMapNodeWorkflow
+        max_concurrency = 4
+
+    # WHEN we run the workflow
+    stream = SimpleMapNode().run()
+    outputs = list(stream)
+
+    # THEN the workflow should succeed
+    assert outputs[-1].name == "final_output"
+    assert len(outputs[-1].value) == 2

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/core/try_node/node.py

@@ -2,6 +2,7 @@ from typing import Callable, Generic, Iterator, Optional, Set, Type
 
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
+from vellum.workflows.events.workflow import is_workflow_event
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
@@ -47,6 +48,12 @@ class TryNode(BaseAdornmentNode[StateType], Generic[StateType]):
             if exception:
                 continue
 
+            if not is_workflow_event(event):
+                continue
+
+            if event.workflow_definition != self.subworkflow:
+                continue
+
             if event.name == "workflow.execution.streaming":
                 if event.output.is_fulfilled:
                     fulfilled_output_names.add(event.output.name)

vellum/workflows/nodes/core/try_node/tests/test_node.py

@@ -10,6 +10,7 @@ from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.state.base import BaseState, StateMeta
 from vellum.workflows.state.context import WorkflowContext
+from vellum.workflows.workflows.base import BaseWorkflow
 
 
 def test_try_node__on_error_code__successfully_caught():
@@ -126,3 +127,34 @@ def test_try_node__resolved_inputs():
         foo = State.counter
 
     assert MyNode.foo.types == (float,)
+
+
+def test_try_node__nested_try():
+    """
+    Ensure that the nested try node doesn't affect the outer try node's outputs
+    """
+
+    # GIVEN a nested try node
+    @TryNode.wrap()
+    class InnerNode(BaseNode):
+        class Outputs:
+            foo = "hello"
+
+    # AND a subworkflow
+    class Subworkflow(BaseWorkflow):
+        graph = InnerNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            bar = InnerNode.Outputs.foo
+
+    # AND an outer try node referencing that subworkflow
+    class OuterNode(TryNode):
+        subworkflow = Subworkflow
+
+    # WHEN we run the try node
+    stream = OuterNode().run()
+    events = list(stream)
+
+    # THEN we only have the outer node's outputs
+    valid_events = [e for e in events if e.name == "bar"]
+    assert len(valid_events) == len(events)