vellum-ai 0.13.21__py3-none-any.whl → 0.13.22__py3-none-any.whl

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

@@ -5,6 +5,8 @@ from typing import Any, Iterator, List
 
 from vellum.client.core.api_error import ApiError
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.client.types.chat_message import ChatMessage
+from vellum.client.types.chat_message_request import ChatMessageRequest
 from vellum.client.types.execute_prompt_event import ExecutePromptEvent
 from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
 from vellum.client.types.function_call import FunctionCall
@@ -12,6 +14,7 @@ from vellum.client.types.function_call_vellum_value import FunctionCallVellumVal
 from vellum.client.types.function_definition import FunctionDefinition
 from vellum.client.types.initiated_execute_prompt_event import InitiatedExecutePromptEvent
 from vellum.client.types.prompt_output import PromptOutput
+from vellum.client.types.prompt_request_chat_history_input import PromptRequestChatHistoryInput
 from vellum.client.types.prompt_request_json_input import PromptRequestJsonInput
 from vellum.client.types.string_vellum_value import StringVellumValue
 from vellum.workflows.errors.types import WorkflowErrorCode
@@ -181,3 +184,49 @@ def test_inline_prompt_node__api_error__invalid_inputs_node_exception(
     # THEN the node raises the correct NodeException
     assert e.value.code == expected_code
     assert e.value.message == expected_message
+
+
+def test_inline_prompt_node__chat_history_inputs(vellum_adhoc_prompt_client):
+    # GIVEN a prompt node with a chat history input
+    class MyNode(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = []
+        prompt_inputs = {
+            "chat_history": [ChatMessageRequest(role="USER", text="Hello, how are you?")],
+        }
+
+    # AND a known response from invoking an inline prompt
+    expected_outputs: List[PromptOutput] = [
+        StringVellumValue(value="Great!"),
+    ]
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=expected_outputs,
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the node is run
+    events = list(MyNode().run())
+
+    # THEN the prompt is executed with the correct inputs
+    assert events[-1].value == "Great!"
+
+    # AND the prompt is executed with the correct inputs
+    mock_api = vellum_adhoc_prompt_client.adhoc_execute_prompt_stream
+    assert mock_api.call_count == 1
+    assert mock_api.call_args.kwargs["input_values"] == [
+        PromptRequestChatHistoryInput(
+            key="chat_history",
+            type="CHAT_HISTORY",
+            value=[ChatMessage(role="USER", text="Hello, how are you?")],
+        ),
+    ]
+    assert mock_api.call_args.kwargs["input_variables"][0].type == "CHAT_HISTORY"

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

@@ -0,0 +1,93 @@
+from uuid import uuid4
+from typing import Any, Iterator, List
+
+from vellum.client.types.chat_history_input_request import ChatHistoryInputRequest
+from vellum.client.types.chat_message_request import ChatMessageRequest
+from vellum.client.types.execute_prompt_event import ExecutePromptEvent
+from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
+from vellum.client.types.initiated_execute_prompt_event import InitiatedExecutePromptEvent
+from vellum.client.types.json_input_request import JsonInputRequest
+from vellum.client.types.string_vellum_value import StringVellumValue
+from vellum.workflows.nodes.displayable.prompt_deployment_node.node import PromptDeploymentNode
+
+
+def test_run_node__chat_history_input(vellum_client):
+    """Confirm that we can successfully invoke a Prompt Deployment Node that uses Chat History Inputs"""
+
+    # GIVEN a Prompt Deployment Node
+    class ExamplePromptDeploymentNode(PromptDeploymentNode):
+        deployment = "example_prompt_deployment"
+        prompt_inputs = {
+            "chat_history": [ChatMessageRequest(role="USER", text="Hello, how are you?")],
+        }
+
+    # AND we know what the Prompt Deployment will respond with
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=[
+                    StringVellumValue(value="Great!"),
+                ],
+            ),
+        ]
+        yield from events
+
+    vellum_client.execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN we run the node
+    node = ExamplePromptDeploymentNode()
+    events = list(node.run())
+
+    # THEN the node should have completed successfully
+    assert events[-1].value == "Great!"
+
+    # AND we should have invoked the Prompt Deployment with the expected inputs
+    call_kwargs = vellum_client.execute_prompt_stream.call_args.kwargs
+    assert call_kwargs["inputs"] == [
+        ChatHistoryInputRequest(
+            name="chat_history", value=[ChatMessageRequest(role="USER", text="Hello, how are you?")]
+        ),
+    ]
+
+
+def test_run_node__any_array_input(vellum_client):
+    """Confirm that we can successfully invoke a Prompt Deployment Node that uses any array input"""
+
+    # GIVEN a Prompt Deployment Node
+    class ExamplePromptDeploymentNode(PromptDeploymentNode):
+        deployment = "example_prompt_deployment"
+        prompt_inputs = {
+            "fruits": ["apple", "banana", "cherry"],
+        }
+
+    # AND we know what the Prompt Deployment will respond with
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=[
+                    StringVellumValue(value="Great!"),
+                ],
+            ),
+        ]
+        yield from events
+
+    vellum_client.execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN we run the node
+    node = ExamplePromptDeploymentNode()
+    events = list(node.run())
+
+    # THEN the node should have completed successfully
+    assert events[-1].value == "Great!"
+
+    # AND we should have invoked the Prompt Deployment with the expected inputs
+    call_kwargs = vellum_client.execute_prompt_stream.call_args.kwargs
+    assert call_kwargs["inputs"] == [
+        JsonInputRequest(name="fruits", value=["apple", "banana", "cherry"]),
+    ]

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

@@ -1,3 +1,4 @@
+import json
 from uuid import UUID
 from typing import Any, ClassVar, Dict, Generic, Iterator, List, Optional, Set, Union, cast
 
@@ -11,11 +12,13 @@ from vellum import (
     WorkflowRequestNumberInputRequest,
     WorkflowRequestStringInputRequest,
 )
+from vellum.client.types.chat_message_request import ChatMessageRequest
 from vellum.core import RequestOptions
 from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT
 from vellum.workflows.context import get_parent_context
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.errors.types import workflow_event_error_to_workflow_error
+from vellum.workflows.events.types import default_serializer
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput
@@ -66,7 +69,9 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
                         value=input_value,
                     )
                 )
-            elif isinstance(input_value, list) and all(isinstance(message, ChatMessage) for message in input_value):
+            elif isinstance(input_value, list) and all(
+                isinstance(message, (ChatMessage, ChatMessageRequest)) for message in input_value
+            ):
                 compiled_inputs.append(
                     WorkflowRequestChatHistoryInputRequest(
                         name=input_name,
@@ -88,9 +93,19 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
                     )
                 )
             else:
-                raise NodeException(
-                    message=f"Unrecognized input type for input '{input_name}'",
-                    code=WorkflowErrorCode.INVALID_INPUTS,
+                try:
+                    input_value = default_serializer(input_value)
+                except json.JSONDecodeError as e:
+                    raise NodeException(
+                        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,
+                        value=input_value,
+                    )
                 )
 
         return compiled_inputs

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

@@ -0,0 +1,128 @@
+from datetime import datetime
+from uuid import uuid4
+from typing import Any, Iterator, List
+
+from vellum.client.types.chat_message_request import ChatMessageRequest
+from vellum.client.types.workflow_execution_workflow_result_event import WorkflowExecutionWorkflowResultEvent
+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_result_event import WorkflowResultEvent
+from vellum.client.types.workflow_stream_event import WorkflowStreamEvent
+from vellum.workflows.nodes.displayable.subworkflow_deployment_node.node import SubworkflowDeploymentNode
+
+
+def test_run_workflow__chat_history_input(vellum_client):
+    """Confirm that we can successfully invoke a Subworkflow Deployment Node that uses Chat History Inputs"""
+
+    # GIVEN a Subworkflow Deployment Node
+    class ExampleSubworkflowDeploymentNode(SubworkflowDeploymentNode):
+        deployment = "example_subworkflow_deployment"
+        subworkflow_inputs = {
+            "chat_history": [ChatMessageRequest(role="USER", text="Hello, how are you?")],
+        }
+
+    # 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"] == [
+        WorkflowRequestChatHistoryInputRequest(
+            name="chat_history", value=[ChatMessageRequest(role="USER", text="Hello, how are you?")]
+        ),
+    ]
+
+
+def test_run_workflow__any_array(vellum_client):
+    """Confirm that we can successfully invoke a Subworkflow Deployment Node that uses any array input"""
+
+    # GIVEN a Subworkflow Deployment Node
+    class ExampleSubworkflowDeploymentNode(SubworkflowDeploymentNode):
+        deployment = "example_subworkflow_deployment"
+        subworkflow_inputs = {
+            "fruits": ["apple", "banana", "cherry"],
+        }
+
+    # 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=["apple", "banana", "cherry"]),
+    ]

vellum/workflows/nodes/mocks.py

@@ -0,0 +1,17 @@
+from typing import Sequence, Union
+
+from pydantic import ConfigDict
+
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.outputs.base import BaseOutputs
+
+
+class MockNodeExecution(UniversalBaseModel):
+    when_condition: BaseDescriptor
+    then_outputs: BaseOutputs
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+MockNodeExecutionArg = Sequence[Union[BaseOutputs, MockNodeExecution]]

vellum/workflows/runner/runner.py

@@ -4,21 +4,7 @@ import logging
 from queue import Empty, Queue
 from threading import Event as ThreadingEvent, Thread
 from uuid import UUID
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    Generic,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Type,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Dict, Generic, Iterable, Iterator, Optional, Sequence, Set, Tuple, Type, Union
 
 from vellum.workflows.constants import UNDEF
 from vellum.workflows.context import execution_context, get_parent_context
@@ -59,12 +45,12 @@ from vellum.workflows.events.workflow import (
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import NodeRunResponse
+from vellum.workflows.nodes.mocks import MockNodeExecutionArg
 from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.ports.port import Port
 from vellum.workflows.references import ExternalInputReference, OutputReference
 from vellum.workflows.state.base import BaseState
-from vellum.workflows.types.cycle_map import CycleMap
 from vellum.workflows.types.generics import InputsType, OutputsType, StateType
 
 if TYPE_CHECKING:
@@ -88,7 +74,7 @@ class WorkflowRunner(Generic[StateType]):
         entrypoint_nodes: Optional[RunFromNodeArg] = None,
         external_inputs: Optional[ExternalInputsArg] = None,
         cancel_signal: Optional[ThreadingEvent] = None,
-        node_output_mocks: Optional[List[BaseOutputs]] = None,
+        node_output_mocks: Optional[MockNodeExecutionArg] = None,
         parent_context: Optional[ParentContext] = None,
         max_concurrency: Optional[int] = None,
     ):
@@ -144,7 +130,6 @@ class WorkflowRunner(Generic[StateType]):
 
         self._dependencies: Dict[Type[BaseNode], Set[Type[BaseNode]]] = defaultdict(set)
         self._state_forks: Set[StateType] = {self._initial_state}
-        self._mocks_by_node_outputs_class = CycleMap(items=node_output_mocks or [], key_by=lambda mock: mock.__class__)
 
         self._active_nodes_by_execution_id: Dict[UUID, BaseNode[StateType]] = {}
         self._cancel_signal = cancel_signal
@@ -156,6 +141,7 @@ class WorkflowRunner(Generic[StateType]):
             lambda s: self._snapshot_state(s),
         )
         self.workflow.context._register_event_queue(self._workflow_event_inner_queue)
+        self.workflow.context._register_node_output_mocks(node_output_mocks or [])
 
     def _snapshot_state(self, state: StateType) -> StateType:
         self._workflow_event_inner_queue.put(
@@ -201,11 +187,18 @@ class WorkflowRunner(Generic[StateType]):
                 parent=parent_context,
             )
             node_run_response: NodeRunResponse
-            if node.Outputs not in self._mocks_by_node_outputs_class:
+            was_mocked = False
+            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):
+                    node_run_response = mock_candidate.then_outputs
+                    was_mocked = True
+                    break
+
+            if not was_mocked:
                 with execution_context(parent_context=updated_parent_context):
                     node_run_response = node.run()
-            else:
-                node_run_response = self._mocks_by_node_outputs_class[node.Outputs]
+
             ports = node.Ports()
             if not isinstance(node_run_response, (BaseOutputs, Iterator)):
                 raise NodeException(
@@ -519,19 +512,6 @@ class WorkflowRunner(Generic[StateType]):
         )
 
     def _stream(self) -> None:
-        # TODO: We should likely handle this during initialization
-        # https://app.shortcut.com/vellum/story/4327
-        if not self._entrypoints:
-            self._workflow_event_outer_queue.put(
-                self._reject_workflow_event(
-                    WorkflowError(
-                        message="No entrypoints defined",
-                        code=WorkflowErrorCode.INVALID_WORKFLOW,
-                    )
-                )
-            )
-            return
-
         for edge in self.workflow.get_edges():
             self._dependencies[edge.to_node].add(edge.from_port.node_class)
 

vellum/workflows/state/context.py

@@ -1,9 +1,12 @@
 from functools import cached_property
 from queue import Queue
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Dict, List, Optional, Type
 
 from vellum import Vellum
 from vellum.workflows.events.types import ParentContext
+from vellum.workflows.nodes.mocks import MockNodeExecution, MockNodeExecutionArg
+from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.references.constant import ConstantValueReference
 from vellum.workflows.vellum_client import create_vellum_client
 
 if TYPE_CHECKING:
@@ -20,6 +23,7 @@ class WorkflowContext:
         self._vellum_client = vellum_client
         self._parent_context = parent_context
         self._event_queue: Optional[Queue["WorkflowEvent"]] = None
+        self._node_output_mocks_map: Dict[Type[BaseOutputs], List[MockNodeExecution]] = {}
 
     @cached_property
     def vellum_client(self) -> Vellum:
@@ -34,9 +38,33 @@ class WorkflowContext:
             return self._parent_context
         return None
 
+    @cached_property
+    def node_output_mocks_map(self) -> Dict[Type[BaseOutputs], List[MockNodeExecution]]:
+        return self._node_output_mocks_map
+
     def _emit_subworkflow_event(self, event: "WorkflowEvent") -> None:
         if self._event_queue:
             self._event_queue.put(event)
 
     def _register_event_queue(self, event_queue: Queue["WorkflowEvent"]) -> None:
         self._event_queue = event_queue
+
+    def _register_node_output_mocks(self, node_output_mocks: MockNodeExecutionArg) -> None:
+        for mock in node_output_mocks:
+            if isinstance(mock, MockNodeExecution):
+                key = mock.then_outputs.__class__
+                value = mock
+            else:
+                key = mock.__class__
+                value = MockNodeExecution(
+                    when_condition=ConstantValueReference(True),
+                    then_outputs=mock,
+                )
+
+            if key not in self._node_output_mocks_map:
+                self._node_output_mocks_map[key] = [value]
+            else:
+                self._node_output_mocks_map[key].append(value)
+
+    def _get_all_node_output_mocks(self) -> List[MockNodeExecution]:
+        return [mock for mocks in self._node_output_mocks_map.values() for mock in mocks]

vellum/workflows/workflows/base.py

@@ -61,6 +61,7 @@ from vellum.workflows.events.workflow import (
 from vellum.workflows.graph import Graph
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.mocks import MockNodeExecutionArg
 from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.resolvers.base import BaseWorkflowResolver
 from vellum.workflows.runner import WorkflowRunner
@@ -187,7 +188,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         entrypoint_nodes: Optional[RunFromNodeArg] = None,
         external_inputs: Optional[ExternalInputsArg] = None,
         cancel_signal: Optional[ThreadingEvent] = None,
-        node_output_mocks: Optional[List[BaseOutputs]] = None,
+        node_output_mocks: Optional[MockNodeExecutionArg] = None,
         max_concurrency: Optional[int] = None,
     ) -> TerminalWorkflowEvent:
         """
@@ -214,8 +215,9 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         cancel_signal: Optional[ThreadingEvent] = None
             A threading event that can be used to cancel the Workflow Execution.
 
-        node_output_mocks: Optional[List[Outputs]] = None
-            A list of Outputs to mock for Nodes during Workflow Execution.
+        node_output_mocks: Optional[MockNodeExecutionArg] = None
+            A list of Outputs to mock for Nodes during Workflow Execution. Each mock can include a `when_condition`
+            that must be met for the mock to be used.
 
         max_concurrency: Optional[int] = None
             The max number of concurrent threads to run the Workflow with. If not provided, the Workflow will run
@@ -295,7 +297,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         entrypoint_nodes: Optional[RunFromNodeArg] = None,
         external_inputs: Optional[ExternalInputsArg] = None,
         cancel_signal: Optional[ThreadingEvent] = None,
-        node_output_mocks: Optional[List[BaseOutputs]] = None,
+        node_output_mocks: Optional[MockNodeExecutionArg] = None,
         max_concurrency: Optional[int] = None,
     ) -> WorkflowEventStream:
         """
@@ -323,8 +325,9 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         cancel_signal: Optional[ThreadingEvent] = None
             A threading event that can be used to cancel the Workflow Execution.
 
-        node_output_mocks: Optional[List[Outputs]] = None
-            A list of Outputs to mock for Nodes during Workflow Execution.
+        node_output_mocks: Optional[MockNodeExecutionArg] = None
+            A list of Outputs to mock for Nodes during Workflow Execution. Each mock can include a `when_condition`
+            that must be met for the mock to be used.
 
         max_concurrency: Optional[int] = None
             The max number of concurrent threads to run the Workflow with. If not provided, the Workflow will run

{vellum_ai-0.13.21.dist-info → vellum_ai-0.13.22.dist-info}/METADATA

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