vellum-ai 0.14.12__py3-none-any.whl → 0.14.14__py3-none-any.whl

vellum/workflows/nodes/mocks.py

@@ -1,10 +1,102 @@
-from typing import Sequence, Union
+from functools import reduce
+from uuid import UUID
+from typing import TYPE_CHECKING, Any, List, Literal, Optional, Sequence, Type, Union
 
-from pydantic import ConfigDict
+from pydantic import ConfigDict, ValidationError
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.client.types.array_vellum_value import ArrayVellumValue
+from vellum.client.types.vellum_value import VellumValue
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import WorkflowInitializationException
 from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.references.constant import ConstantValueReference
+
+if TYPE_CHECKING:
+    from vellum.workflows import BaseWorkflow
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class _RawLogicalCondition(UniversalBaseModel):
+    type: Literal["LOGICAL_CONDITION"] = "LOGICAL_CONDITION"
+    lhs_variable_id: UUID
+    operator: Literal["==", ">", ">=", "<", "<=", "!="]
+    rhs_variable_id: UUID
+
+
+class _RawLogicalConditionGroup(UniversalBaseModel):
+    type: Literal["LOGICAL_CONDITION_GROUP"] = "LOGICAL_CONDITION_GROUP"
+    conditions: List["_RawLogicalExpression"]
+    combinator: Literal["AND", "OR"]
+    negated: bool
+
+
+_RawLogicalExpression = Union[_RawLogicalCondition, _RawLogicalConditionGroup]
+
+
+class _RawLogicalExpressionVariable(UniversalBaseModel):
+    id: UUID
+
+
+class _RawMockWorkflowNodeExecutionConstantValuePointer(_RawLogicalExpressionVariable):
+    type: Literal["CONSTANT_VALUE"] = "CONSTANT_VALUE"
+    variable_value: VellumValue
+
+
+class _RawMockWorkflowNodeExecutionNodeExecutionCounterPointer(_RawLogicalExpressionVariable):
+    type: Literal["EXECUTION_COUNTER"] = "EXECUTION_COUNTER"
+    node_id: UUID
+
+
+class _RawMockWorkflowNodeExecutionInputVariablePointer(_RawLogicalExpressionVariable):
+    type: Literal["INPUT_VARIABLE"] = "INPUT_VARIABLE"
+    input_variable_id: UUID
+
+
+class _RawMockWorkflowNodeExecutionNodeOutputPointer(_RawLogicalExpressionVariable):
+    type: Literal["NODE_OUTPUT"] = "NODE_OUTPUT"
+    node_id: UUID
+    input_id: UUID
+
+
+class _RawMockWorkflowNodeExecutionNodeInputPointer(_RawLogicalExpressionVariable):
+    type: Literal["NODE_INPUT"] = "NODE_INPUT"
+    node_id: UUID
+    input_id: UUID
+
+
+_RawMockWorkflowNodeExecutionValuePointer = Union[
+    _RawMockWorkflowNodeExecutionConstantValuePointer,
+    _RawMockWorkflowNodeExecutionNodeExecutionCounterPointer,
+    _RawMockWorkflowNodeExecutionInputVariablePointer,
+    _RawMockWorkflowNodeExecutionNodeOutputPointer,
+    _RawMockWorkflowNodeExecutionNodeInputPointer,
+]
+
+
+class _RawMockWorkflowNodeWhenCondition(UniversalBaseModel):
+    expression: _RawLogicalExpression
+    variables: List[_RawMockWorkflowNodeExecutionValuePointer]
+
+
+class _RawMockWorkflowNodeThenOutput(UniversalBaseModel):
+    output_id: UUID
+    value: _RawMockWorkflowNodeExecutionValuePointer
+
+
+class _RawMockWorkflowNodeExecution(UniversalBaseModel):
+    when_condition: _RawMockWorkflowNodeWhenCondition
+    then_outputs: List[_RawMockWorkflowNodeThenOutput]
+
+
+class _RawMockWorkflowNodeConfig(UniversalBaseModel):
+    type: Literal["WORKFLOW_NODE_OUTPUT"] = "WORKFLOW_NODE_OUTPUT"
+    node_id: UUID
+    mock_executions: List[_RawMockWorkflowNodeExecution]
 
 
 class MockNodeExecution(UniversalBaseModel):
@@ -13,5 +105,140 @@ class MockNodeExecution(UniversalBaseModel):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
+    @staticmethod
+    def validate_all(
+        raw_mock_workflow_node_configs: Optional[List[Any]],
+        workflow: Type["BaseWorkflow"],
+    ) -> Optional[List["MockNodeExecution"]]:
+        if not raw_mock_workflow_node_configs:
+            return None
+
+        ArrayVellumValue.model_rebuild()
+        try:
+            mock_workflow_node_configs = [
+                _RawMockWorkflowNodeConfig.model_validate(raw_mock_workflow_node_config)
+                for raw_mock_workflow_node_config in raw_mock_workflow_node_configs
+            ]
+        except ValidationError as e:
+            raise WorkflowInitializationException(
+                message="Failed to validate mock node executions",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            ) from e
+
+        nodes = {node.__id__: node for node in workflow.get_nodes()}
+        node_output_name_by_id = {
+            node.__output_ids__[output.name]: output.name for node in workflow.get_nodes() for output in node.Outputs
+        }
+
+        # We need to support the old way that the Vellum App's WorkflowRunner used to define Node Mocks in order to
+        # avoid needing to update the mock resolution strategy that it and the frontend uses. The path towards
+        # cleaning this up will go as follows:
+        # 1. Release Mock support in SDK-Enabled Workflows
+        # 2. Deprecate Mock support in non-SDK enabled Workflows, encouraging users to migrate to SDK-enabled Workflows
+        # 3. Remove the old mock resolution strategy
+        # 4. Update this SDK to handle the new mock resolution strategy with WorkflowValueDescriptors
+        # 5. Cutover the Vellum App to the new mock resolution strategy
+        # 6. Remove the old mock resolution strategy from this SDK
+        def _translate_raw_logical_expression(
+            raw_logical_expression: _RawLogicalExpression,
+            raw_variables: List[_RawMockWorkflowNodeExecutionValuePointer],
+        ) -> BaseDescriptor:
+            if raw_logical_expression.type == "LOGICAL_CONDITION":
+                return _translate_raw_logical_condition(raw_logical_expression, raw_variables)
+            else:
+                return _translate_raw_logical_condition_group(raw_logical_expression, raw_variables)
+
+        def _translate_raw_logical_condition_group(
+            raw_logical_condition_group: _RawLogicalConditionGroup,
+            raw_variables: List[_RawMockWorkflowNodeExecutionValuePointer],
+        ) -> BaseDescriptor:
+            if not raw_logical_condition_group.conditions:
+                return ConstantValueReference(True)
+
+            conditions = [
+                _translate_raw_logical_expression(condition, raw_variables)
+                for condition in raw_logical_condition_group.conditions
+            ]
+            return reduce(
+                lambda acc, condition: (
+                    acc and condition if raw_logical_condition_group.combinator == "AND" else acc or condition
+                ),
+                conditions,
+            )
+
+        def _translate_raw_logical_condition(
+            raw_logical_condition: _RawLogicalCondition,
+            raw_variables: List[_RawMockWorkflowNodeExecutionValuePointer],
+        ) -> BaseDescriptor:
+            variable_by_id = {v.id: v for v in raw_variables}
+            lhs = _translate_raw_logical_expression_variable(variable_by_id[raw_logical_condition.lhs_variable_id])
+            rhs = _translate_raw_logical_expression_variable(variable_by_id[raw_logical_condition.rhs_variable_id])
+            if raw_logical_condition.operator == ">":
+                return lhs.greater_than(rhs)
+            elif raw_logical_condition.operator == ">=":
+                return lhs.greater_than_or_equal_to(rhs)
+            elif raw_logical_condition.operator == "<":
+                return lhs.less_than(rhs)
+            elif raw_logical_condition.operator == "<=":
+                return lhs.less_than_or_equal_to(rhs)
+            elif raw_logical_condition.operator == "==":
+                return lhs.equals(rhs)
+            elif raw_logical_condition.operator == "!=":
+                return lhs.does_not_equal(rhs)
+            else:
+                raise WorkflowInitializationException(f"Unsupported logical operator: {raw_logical_condition.operator}")
+
+        def _translate_raw_logical_expression_variable(
+            raw_variable: _RawMockWorkflowNodeExecutionValuePointer,
+        ) -> BaseDescriptor:
+            if raw_variable.type == "CONSTANT_VALUE":
+                return ConstantValueReference(raw_variable.variable_value.value)
+            elif raw_variable.type == "EXECUTION_COUNTER":
+                node = nodes[raw_variable.node_id]
+                return node.Execution.count
+            else:
+                raise WorkflowInitializationException(f"Unsupported logical expression type: {raw_variable.type}")
+
+        mock_node_executions = []
+        for mock_workflow_node_config in mock_workflow_node_configs:
+            for mock_execution in mock_workflow_node_config.mock_executions:
+                try:
+                    when_condition = _translate_raw_logical_expression(
+                        mock_execution.when_condition.expression,
+                        mock_execution.when_condition.variables,
+                    )
+
+                    then_outputs = nodes[mock_workflow_node_config.node_id].Outputs()
+                    for then_output in mock_execution.then_outputs:
+                        node_output_name = node_output_name_by_id.get(then_output.output_id)
+                        if node_output_name is None:
+                            raise WorkflowInitializationException(
+                                f"Output {then_output.output_id} not found in node {mock_workflow_node_config.node_id}"
+                            )
+
+                        resolved_output_reference = _translate_raw_logical_expression_variable(then_output.value)
+                        if isinstance(resolved_output_reference, ConstantValueReference):
+                            setattr(
+                                then_outputs,
+                                node_output_name,
+                                resolved_output_reference._value,
+                            )
+                        else:
+                            raise WorkflowInitializationException(
+                                f"Unsupported resolved output reference type: {type(resolved_output_reference)}"
+                            )
+
+                    mock_node_executions.append(
+                        MockNodeExecution(
+                            when_condition=when_condition,
+                            then_outputs=then_outputs,
+                        )
+                    )
+                except Exception as e:
+                    logger.exception("Failed to validate mock node execution", exc_info=e)
+                    continue
+
+        return mock_node_executions
+
 
 MockNodeExecutionArg = Sequence[Union[BaseOutputs, MockNodeExecution]]

vellum/workflows/nodes/tests/test_mocks.py

@@ -0,0 +1,207 @@
+import uuid
+
+from vellum.client.types.string_vellum_value import StringVellumValue
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes import InlinePromptNode
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.mocks import MockNodeExecution
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
+from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
+
+
+def test_mocks__parse_from_app():
+    # GIVEN a PromptNode
+    class PromptNode(InlinePromptNode):
+        pass
+
+    # AND a workflow class with that PromptNode
+    class MyWorkflow(BaseWorkflow):
+        graph = PromptNode
+
+    # AND a mock workflow node execution from the app
+    raw_mock_workflow_node_execution = [
+        {
+            "type": "WORKFLOW_NODE_OUTPUT",
+            "node_id": str(PromptNode.__id__),
+            "mock_executions": [
+                {
+                    "when_condition": {
+                        "expression": {
+                            "type": "LOGICAL_CONDITION_GROUP",
+                            "combinator": "AND",
+                            "negated": False,
+                            "conditions": [
+                                {
+                                    "type": "LOGICAL_CONDITION",
+                                    "lhs_variable_id": "e60902d5-6892-4916-80c1-f0130af52322",
+                                    "operator": ">=",
+                                    "rhs_variable_id": "5c1bbb24-c288-49cb-a9b7-0c6f38a86037",
+                                }
+                            ],
+                        },
+                        "variables": [
+                            {
+                                "type": "EXECUTION_COUNTER",
+                                "node_id": str(PromptNode.__id__),
+                                "id": "e60902d5-6892-4916-80c1-f0130af52322",
+                            },
+                            {
+                                "type": "CONSTANT_VALUE",
+                                "variable_value": {"type": "NUMBER", "value": 0},
+                                "id": "5c1bbb24-c288-49cb-a9b7-0c6f38a86037",
+                            },
+                        ],
+                    },
+                    "then_outputs": [
+                        {
+                            "output_id": "9e6dc5d3-8ea0-4346-8a2a-7cce5495755b",
+                            "value": {
+                                "id": "27006b2a-fa81-430c-a0b2-c66a9351fc68",
+                                "type": "CONSTANT_VALUE",
+                                "variable_value": {"type": "STRING", "value": "Hello"},
+                            },
+                        },
+                        {
+                            "output_id": "60305ffd-60b0-42aa-b54e-4fdae0f8c28a",
+                            "value": {
+                                "id": "4559c778-6e27-4cfe-a460-734ba62a5082",
+                                "type": "CONSTANT_VALUE",
+                                "variable_value": {"type": "ARRAY", "value": [{"type": "STRING", "value": "Hello"}]},
+                            },
+                        },
+                    ],
+                }
+            ],
+        }
+    ]
+
+    # WHEN we parse the mock workflow node execution
+    node_output_mocks = MockNodeExecution.validate_all(
+        raw_mock_workflow_node_execution,
+        MyWorkflow,
+    )
+
+    # THEN we get a list of MockNodeExecution objects
+    assert node_output_mocks
+    assert len(node_output_mocks) == 1
+    assert node_output_mocks[0] == MockNodeExecution(
+        when_condition=PromptNode.Execution.count.greater_than_or_equal_to(0.0),
+        then_outputs=PromptNode.Outputs(
+            text="Hello",
+            results=[
+                StringVellumValue(value="Hello"),
+            ],
+        ),
+    )
+
+
+def test_mocks__parse_none_still_runs():
+    # GIVEN a Base Node
+    class StartNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            foo: str
+
+    # AND a workflow class with that Node
+    class MyWorkflow(BaseWorkflow):
+        graph = StartNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_value = StartNode.Outputs.foo
+
+    # AND we parsed `None` on `MockNodeExecution`
+    node_output_mocks = MockNodeExecution.validate_all(
+        None,
+        MyWorkflow,
+    )
+
+    # WHEN we run the workflow
+    workflow = MyWorkflow()
+    final_event = workflow.run(node_output_mocks=node_output_mocks)
+
+    # THEN it was successful
+    assert final_event.name == "workflow.execution.fulfilled"
+
+
+def test_mocks__use_id_from_display():
+    # GIVEN a Base Node
+    class StartNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            foo: str
+
+    # AND a workflow class with that Node
+    class MyWorkflow(BaseWorkflow):
+        graph = StartNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_value = StartNode.Outputs.foo
+
+    # AND a display class on that Base Node
+    node_output_id = uuid.uuid4()
+
+    class StartNodeDisplay(BaseNodeDisplay[StartNode]):
+        output_display = {StartNode.Outputs.foo: NodeOutputDisplay(id=node_output_id, name="foo")}
+
+    # AND a mock workflow node execution from the app
+    raw_mock_workflow_node_execution = [
+        {
+            "type": "WORKFLOW_NODE_OUTPUT",
+            "node_id": str(StartNode.__id__),
+            "mock_executions": [
+                {
+                    "when_condition": {
+                        "expression": {
+                            "type": "LOGICAL_CONDITION_GROUP",
+                            "combinator": "AND",
+                            "negated": False,
+                            "conditions": [
+                                {
+                                    "type": "LOGICAL_CONDITION",
+                                    "lhs_variable_id": "e60902d5-6892-4916-80c1-f0130af52322",
+                                    "operator": ">=",
+                                    "rhs_variable_id": "5c1bbb24-c288-49cb-a9b7-0c6f38a86037",
+                                }
+                            ],
+                        },
+                        "variables": [
+                            {
+                                "type": "EXECUTION_COUNTER",
+                                "node_id": str(StartNode.__id__),
+                                "id": "e60902d5-6892-4916-80c1-f0130af52322",
+                            },
+                            {
+                                "type": "CONSTANT_VALUE",
+                                "variable_value": {"type": "NUMBER", "value": 0},
+                                "id": "5c1bbb24-c288-49cb-a9b7-0c6f38a86037",
+                            },
+                        ],
+                    },
+                    "then_outputs": [
+                        {
+                            "output_id": str(node_output_id),
+                            "value": {
+                                "id": "27006b2a-fa81-430c-a0b2-c66a9351fc68",
+                                "type": "CONSTANT_VALUE",
+                                "variable_value": {"type": "STRING", "value": "Hello"},
+                            },
+                        },
+                    ],
+                }
+            ],
+        }
+    ]
+
+    # WHEN we parsed the raw data on `MockNodeExecution`
+    node_output_mocks = MockNodeExecution.validate_all(
+        raw_mock_workflow_node_execution,
+        MyWorkflow,
+    )
+
+    # THEN we get the expected list of MockNodeExecution objects
+    assert node_output_mocks
+    assert len(node_output_mocks) == 1
+    assert node_output_mocks[0] == MockNodeExecution(
+        when_condition=StartNode.Execution.count.greater_than_or_equal_to(0.0),
+        then_outputs=StartNode.Outputs(
+            foo="Hello",
+        ),
+    )

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/outputs/base.py

@@ -201,7 +201,7 @@ class BaseOutputs(metaclass=_BaseOutputsMeta):
             self._outputs_post_init(**kwargs)
 
     def __eq__(self, other: object) -> bool:
-        if not isinstance(other, dict):
+        if not isinstance(other, (dict, BaseOutputs)):
             return super().__eq__(other)
 
         outputs = {ref.name: value for ref, value in self if value is not undefined}

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.12.dist-info → vellum_ai-0.14.14.dist-info}/METADATA

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