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

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/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/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)

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

@@ -70,8 +70,10 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
                         value=input_value,
                     )
                 )
-            elif isinstance(input_value, list) and all(
-                isinstance(message, (ChatMessage, ChatMessageRequest)) for message in input_value
+            elif (
+                isinstance(input_value, list)
+                and len(input_value) > 0
+                and all(isinstance(message, (ChatMessage, ChatMessageRequest)) for message in input_value)
             ):
                 chat_history = [
                     (
@@ -95,7 +97,7 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
                         value=cast(Dict[str, Any], input_value),
                     )
                 )
-            elif isinstance(input_value, float):
+            elif isinstance(input_value, (int, float)):
                 compiled_inputs.append(
                     WorkflowRequestNumberInputRequest(
                         name=input_name,
@@ -110,7 +112,6 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
                         message=f"Failed to serialize input '{input_name}' of type '{input_value.__class__}': {e}",
                         code=WorkflowErrorCode.INVALID_INPUTS,
                     )
-
                 compiled_inputs.append(
                     WorkflowRequestJsonInputRequest(
                         name=input_name,

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

@@ -10,6 +10,7 @@ from vellum.client.types.workflow_execution_workflow_result_event import Workflo
 from vellum.client.types.workflow_output_string import WorkflowOutputString
 from vellum.client.types.workflow_request_chat_history_input_request import WorkflowRequestChatHistoryInputRequest
 from vellum.client.types.workflow_request_json_input_request import WorkflowRequestJsonInputRequest
+from vellum.client.types.workflow_request_number_input_request import WorkflowRequestNumberInputRequest
 from vellum.client.types.workflow_result_event import WorkflowResultEvent
 from vellum.client.types.workflow_stream_event import WorkflowStreamEvent
 from vellum.workflows.errors import WorkflowErrorCode
@@ -134,6 +135,116 @@ def test_run_workflow__any_array(vellum_client):
     ]
 
 
+def test_run_workflow__empty_array(vellum_client):
+    # GIVEN a Subworkflow Deployment Node
+    class ExampleSubworkflowDeploymentNode(SubworkflowDeploymentNode):
+        deployment = "example_subworkflow_deployment"
+        subworkflow_inputs = {
+            "fruits": [],
+        }
+
+    # AND we know what the Subworkflow Deployment will respond with
+    def generate_subworkflow_events(*args: Any, **kwargs: Any) -> Iterator[WorkflowStreamEvent]:
+        execution_id = str(uuid4())
+        expected_events: List[WorkflowStreamEvent] = [
+            WorkflowExecutionWorkflowResultEvent(
+                execution_id=execution_id,
+                data=WorkflowResultEvent(
+                    id=str(uuid4()),
+                    state="INITIATED",
+                    ts=datetime.now(),
+                ),
+            ),
+            WorkflowExecutionWorkflowResultEvent(
+                execution_id=execution_id,
+                data=WorkflowResultEvent(
+                    id=str(uuid4()),
+                    state="FULFILLED",
+                    ts=datetime.now(),
+                    outputs=[
+                        WorkflowOutputString(
+                            id=str(uuid4()),
+                            name="greeting",
+                            value="Great!",
+                        )
+                    ],
+                ),
+            ),
+        ]
+        yield from expected_events
+
+    vellum_client.execute_workflow_stream.side_effect = generate_subworkflow_events
+
+    # WHEN we run the node
+    node = ExampleSubworkflowDeploymentNode()
+    events = list(node.run())
+
+    # THEN the node should have completed successfully
+    assert events[-1].name == "greeting"
+    assert events[-1].value == "Great!"
+
+    # AND we should have invoked the Subworkflow Deployment with the expected inputs
+    call_kwargs = vellum_client.execute_workflow_stream.call_args.kwargs
+    assert call_kwargs["inputs"] == [
+        WorkflowRequestJsonInputRequest(name="fruits", value=[]),
+    ]
+
+
+def test_run_workflow__int_input(vellum_client):
+    # GIVEN a Subworkflow Deployment Node
+    class ExampleSubworkflowDeploymentNode(SubworkflowDeploymentNode):
+        deployment = "example_subworkflow_deployment"
+        subworkflow_inputs = {
+            "number": 42,
+        }
+
+    # AND we know what the Subworkflow Deployment will respond with
+    def generate_subworkflow_events(*args: Any, **kwargs: Any) -> Iterator[WorkflowStreamEvent]:
+        execution_id = str(uuid4())
+        expected_events: List[WorkflowStreamEvent] = [
+            WorkflowExecutionWorkflowResultEvent(
+                execution_id=execution_id,
+                data=WorkflowResultEvent(
+                    id=str(uuid4()),
+                    state="INITIATED",
+                    ts=datetime.now(),
+                ),
+            ),
+            WorkflowExecutionWorkflowResultEvent(
+                execution_id=execution_id,
+                data=WorkflowResultEvent(
+                    id=str(uuid4()),
+                    state="FULFILLED",
+                    ts=datetime.now(),
+                    outputs=[
+                        WorkflowOutputString(
+                            id=str(uuid4()),
+                            name="greeting",
+                            value="Great!",
+                        )
+                    ],
+                ),
+            ),
+        ]
+        yield from expected_events
+
+    vellum_client.execute_workflow_stream.side_effect = generate_subworkflow_events
+
+    # WHEN we run the node
+    node = ExampleSubworkflowDeploymentNode()
+    events = list(node.run())
+
+    # THEN the node should have completed successfully
+    assert events[-1].name == "greeting"
+    assert events[-1].value == "Great!"
+
+    # AND we should have invoked the Subworkflow Deployment with the expected inputs
+    call_kwargs = vellum_client.execute_workflow_stream.call_args.kwargs
+    assert call_kwargs["inputs"] == [
+        WorkflowRequestNumberInputRequest(name="number", value=42),
+    ]
+
+
 def test_run_workflow__no_deployment():
     """Confirm that we raise error when running a subworkflow deployment node with no deployment attribute set"""