vellum-ai 0.14.12__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.12",
+            "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/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/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_ai-0.14.12.dist-info → vellum_ai-0.14.13.dist-info}/METADATA

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

{vellum_ai-0.14.12.dist-info → vellum_ai-0.14.13.dist-info}/RECORD

@@ -23,9 +23,9 @@ vellum_ee/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 vellum_ee/workflows/display/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/base.py,sha256=ak29FIsawhaFa9_paZUHThlZRFJ1xB486JWKuSt1PYY,1965
 vellum_ee/workflows/display/nodes/__init__.py,sha256=436iSAh_Ex5tC68oEYvNgPu05ZVIAVXnS4PKGrQeZ0Y,321
-vellum_ee/workflows/display/nodes/base_node_display.py,sha256=h4_JqwH_AsT92OK14S3kqssZDjL-uyXnJfo0XcLijK0,16492
+vellum_ee/workflows/display/nodes/base_node_display.py,sha256=p6orKsqEo8u6PWDbpp60D_E4UtjWNzWI8aVe8aknpyc,17097
 vellum_ee/workflows/display/nodes/base_node_vellum_display.py,sha256=pLO0dORfRu--Ne9NgoyFT_CNjfpr5fGCsgbsMkUF5GM,2845
-vellum_ee/workflows/display/nodes/get_node_display_class.py,sha256=0S6ksPp53WXWh1RQVH71nj2bkCWBj4ZaFYhTxW3N2F4,1230
+vellum_ee/workflows/display/nodes/get_node_display_class.py,sha256=67J_TGFNoISq8wZqOBCu5BNMY4kpQBq3Lt65FPH3Gt0,1594
 vellum_ee/workflows/display/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/nodes/tests/test_base_node_display.py,sha256=QqR3Ly0RNrXwOeLdW5nERDFt0gRPf76n1bPES6o5UN4,1093
 vellum_ee/workflows/display/nodes/types.py,sha256=St1BB6no528OyELGiyRabWao0GGw6mLhstQAvEACbGk,247
@@ -61,7 +61,7 @@ vellum_ee/workflows/display/tests/test_vellum_workflow_display.py,sha256=cdpUoDN
 vellum_ee/workflows/display/tests/workflow_serialization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/conftest.py,sha256=A1-tIpC5KIKG9JA_rkd1nLS8zUG3Kb4QiVdvb3boFxE,2509
-vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_adornments_serialization.py,sha256=jw8keqLNwqtaRSAqStsMqSH_OuuaTQm2MvIx8NTWAa4,14905
+vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_adornments_serialization.py,sha256=mFmxXfnUPrwndaBurW9E-VSBUQjF3cGv3JpRuNmwWh8,15475
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py,sha256=1cszL6N6FNGVm61MOa7AEiHnF0QjZWqDQuPOp4yiG94,18277
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_outputs_serialization.py,sha256=-12ZkZb3f5gyoNASV2yeQtMo5HmNsVEo8nXwL6IC-I8,6261
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_ports_serialization.py,sha256=6th6kCwzql6lddjkTQx4Jbvvs4ChqtJwctW-B4QuBhI,37352
@@ -90,9 +90,9 @@ vellum_ee/workflows/display/utils/expressions.py,sha256=9FpOslDI-RCR5m4TgAu9KCHh
 vellum_ee/workflows/display/utils/vellum.py,sha256=UjK_RxnSEmlIu9klGCPWU5RAQBmgZ7cRbRdgxaTbubE,8081
 vellum_ee/workflows/display/vellum.py,sha256=7mqQaKZPPrLMcXSAQkPIxCy5x8HkKs5PbCu3GRaC2o8,8507
 vellum_ee/workflows/display/workflows/__init__.py,sha256=kapXsC67VJcgSuiBMa86FdePG5A9kMB5Pi4Uy1O2ob4,207
-vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=Z9s_rtqAH5IfBtXOw40gbiT0GZeN6JRdFwGgPT-DIYM,20143
+vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=yDjMk2tml2TzitcFdP5M7PFXm4G_Bz6aYLYby7riXGQ,20137
 vellum_ee/workflows/display/workflows/get_vellum_workflow_display_class.py,sha256=kp0u8LN_2IwshLrhMImhpZx1hRyAcD5gXY-kDuuaGMQ,1269
-vellum_ee/workflows/display/workflows/tests/test_workflow_display.py,sha256=STVSG0eL97mdnwBA5nOOgW8AuK8k-b8kWDyHKatNXIA,4259
+vellum_ee/workflows/display/workflows/tests/test_workflow_display.py,sha256=JRTTM8gX182pBMP5eI_-B_X7LaK0kiSS07KqDdIfrQc,4962
 vellum_ee/workflows/display/workflows/vellum_workflow_display.py,sha256=mbAzCpswOek34ITeTkesbVreCXpulj4NFjIg3RcdVZ8,18243
 vellum_ee/workflows/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/server/virtual_file_loader.py,sha256=X_DdNK7MfyOjKWekk6YQpOSCT6klKcdjT6nVJcBH1sM,1481
@@ -123,7 +123,7 @@ vellum/client/README.md,sha256=JkCJjmMZl4jrPj46pkmL9dpK4gSzQQmP5I7z4aME4LY,4749
 vellum/client/__init__.py,sha256=tKtdM1_GqmGq1gpi9ydWD_T-MM7fPn8QdHh8ww19cNI,117564
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=MP_Nnw3gVGA7BJKaD9TBDDwVxta-T1ASzBcOv7dF4nU,1869
+vellum/client/core/client_wrapper.py,sha256=rm58d4E5Lrfg-SwnN1AtE5vFfVb1Qy6a5GyVyEmNWvU,1869
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=X9IbmkZmB2bB_DpmZAO3crWdXagOakAyn6UCOCImCPg,2322
 vellum/client/core/http_client.py,sha256=R0pQpCppnEtxccGvXl4uJ76s7ro_65Fo_erlNNLp_AI,19228
@@ -1299,7 +1299,7 @@ vellum/workflows/__init__.py,sha256=CssPsbNvN6rDhoLuqpEv7MMKGa51vE6dvAh6U31Pcio,
 vellum/workflows/constants.py,sha256=2yg4_uo5gpqViy3ZLSwfC8qTybleYCtOnhA4Rj6bacM,1310
 vellum/workflows/context.py,sha256=DwSf8lO9NHABiqOoD3exgrjUoRuNsKtutaL5TgRbD-A,1441
 vellum/workflows/descriptors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/descriptors/base.py,sha256=jtT11I5oB-CPWlJBZmc1RcVe4_xOKjimBthiHQHQuT0,14597
+vellum/workflows/descriptors/base.py,sha256=bvF3MWsc4Xyw5Z2s1A0fbsfMCebIbPYcGvbQ9uoa_Pg,14655
 vellum/workflows/descriptors/exceptions.py,sha256=gUy4UD9JFUKSeQnQpeuDSLiRqWjWiIsxLahB7p_q3JY,54
 vellum/workflows/descriptors/tests/test_utils.py,sha256=xoojJMyG5WLG9xGtmUjirz3lDFCcDsAcxjrtbdG8dNE,6060
 vellum/workflows/descriptors/utils.py,sha256=gmVXJjf2yWmvlYey41J2FZHeSou0JuCHKb3826K_Jok,3838
@@ -1316,7 +1316,7 @@ vellum/workflows/events/node.py,sha256=uHT6If0esgZ3nLjrjmUPTKf3qbjGhoV_x5YKpjDBD
 vellum/workflows/events/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/events/tests/test_event.py,sha256=uRfMwSOqU-ROeZKCEngGvvJYlOZuxBhnC3qH5AGi3fM,15399
 vellum/workflows/events/types.py,sha256=AeTJaQt_fNHDLI4nyBzo7XrW9QQybRC09AKzu3kEYEE,3575
-vellum/workflows/events/workflow.py,sha256=sLO29djAeHGVd4hLhaNtOQ48uwUjfl-DotZQt06PxQA,6033
+vellum/workflows/events/workflow.py,sha256=QoSHyIOpuVacbR7POf7h104miTOhCjtO2udnYximJGs,6851
 vellum/workflows/exceptions.py,sha256=NiBiR3ggfmPxBVqD-H1SqmjI-7mIn0EStSN1BqApvCM,1213
 vellum/workflows/expressions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/expressions/accessor.py,sha256=ItZF7fMLzVTqsdAiaXb5SiDupXmX0X9xbIus1W6hRds,1870
@@ -1356,13 +1356,13 @@ vellum/workflows/graph/graph.py,sha256=GGR8cGpSuNWPIiTWNWsj6l70upb5nIxAyFcn7VdaJ
 vellum/workflows/graph/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/graph/tests/test_graph.py,sha256=q0wxLvPPxc-6en4a_XuAZwVfLURMd9Ikvoreq4bpJ9s,11839
 vellum/workflows/inputs/__init__.py,sha256=AbFEteIYEvCb14fM3EK7bhM-40-6s494rSlIhQ4Dsss,62
-vellum/workflows/inputs/base.py,sha256=Bj0TO72ucLmPFGgoKDr8LZZbxzk51C6P4Rod0Nv5PwQ,3733
+vellum/workflows/inputs/base.py,sha256=eVTjtn6GielKYogQ-LPA6n4iZO3-WIfyxWpBKkN-dPs,3959
 vellum/workflows/inputs/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/inputs/tests/test_inputs.py,sha256=Haa0Px0obef7rgIddO6wwHF_bzmvz9Yp8OErdx2mQss,1759
+vellum/workflows/inputs/tests/test_inputs.py,sha256=g--YqWTNWzMk5Ktoj__gq988kvBReefc2tsyUl6H2kg,1775
 vellum/workflows/logging.py,sha256=_a217XogktV4Ncz6xKFz7WfYmZAzkfVRVuC0rWob8ls,437
 vellum/workflows/nodes/__init__.py,sha256=aVdQVv7Y3Ro3JlqXGpxwaU2zrI06plDHD2aumH5WUIs,1157
 vellum/workflows/nodes/bases/__init__.py,sha256=cniHuz_RXdJ4TQgD8CBzoiKDiPxg62ErdVpCbWICX64,58
-vellum/workflows/nodes/bases/base.py,sha256=lVHODc1mjUFCorhZfK01zHohOWz9CYz7dnUzA-KENJ4,15036
+vellum/workflows/nodes/bases/base.py,sha256=Y5xv0tFSSDafKDhVsxC5xTNrH15sj93jok6POzgWO0E,15351
 vellum/workflows/nodes/bases/base_adornment_node.py,sha256=eFTgsPCYb3eyGS0-kw7C6crFnwFx437R5wh9-8bWYts,2905
 vellum/workflows/nodes/bases/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/bases/tests/test_base_node.py,sha256=4SOdZzvugVtN8CIuo5RrapAxSYGXnxUwQ77dXJ64oTU,6295
@@ -1370,13 +1370,13 @@ vellum/workflows/nodes/core/__init__.py,sha256=5zDMCmyt1v0HTJzlUBwq3U9L825yZGZhT
 vellum/workflows/nodes/core/error_node/__init__.py,sha256=g7RRnlHhqu4qByfLjBwCunmgGA8dI5gNsjS3h6TwlSI,60
 vellum/workflows/nodes/core/error_node/node.py,sha256=MFHU5vITYSK-L9CuMZ49In2ZeNLWnhZD0f8r5dWvb5Y,1270
 vellum/workflows/nodes/core/inline_subworkflow_node/__init__.py,sha256=nKNEH1QTl-1PcvmYoqSWEl0-t6gAur8GLTXHzklRQfM,84
-vellum/workflows/nodes/core/inline_subworkflow_node/node.py,sha256=WE_N8PocCF-xc87nRwbQ_WTBqOQ75JJlUZCdlocp7u0,5953
+vellum/workflows/nodes/core/inline_subworkflow_node/node.py,sha256=B1ant-Pwg1AGFs5BYXynHf2i4rAen1bkr7nbLmiVwHo,6175
 vellum/workflows/nodes/core/inline_subworkflow_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/core/inline_subworkflow_node/tests/test_node.py,sha256=n0-821Ov9ZfRFX_lbzLy5o2rX8fEw2qoxz0aFWCOxVg,1547
+vellum/workflows/nodes/core/inline_subworkflow_node/tests/test_node.py,sha256=6AG-oTyJaw5a1KWGQFNZaKl6_Pu_fW3nI_WA3XNRFWY,2439
 vellum/workflows/nodes/core/map_node/__init__.py,sha256=MXpZYmGfhsMJHqqlpd64WiJRtbAtAMQz-_3fCU_cLV0,56
-vellum/workflows/nodes/core/map_node/node.py,sha256=Q-9DlfIJYT7duG_3Up3P5uA96YDnFH6ykwRS4Ugr3uA,8327
+vellum/workflows/nodes/core/map_node/node.py,sha256=dY27Xm11LHsqD7hnZnVYYDIazZ-XfL4_zatvWKTi6CU,9243
 vellum/workflows/nodes/core/map_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/core/map_node/tests/test_node.py,sha256=8ZXs4IIYrXpa4pZz4BSx9t0fx_Usgk3_KF6r3kcy9tE,2547
+vellum/workflows/nodes/core/map_node/tests/test_node.py,sha256=uMR0AyIFn539LqTKHdwuBswnx1i-PHyqPpgtYrnmYMY,3496
 vellum/workflows/nodes/core/retry_node/__init__.py,sha256=lN2bIy5a3Uzhs_FYCrooADyYU6ZGShtvLKFWpelwPvo,60
 vellum/workflows/nodes/core/retry_node/node.py,sha256=Vt3fx4G-DRIb9a-IHIUfaAclgfbzOPEQVkcumwhl9HE,4355
 vellum/workflows/nodes/core/retry_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1385,9 +1385,9 @@ vellum/workflows/nodes/core/templating_node/__init__.py,sha256=GmyuYo81_A1_Bz6id
 vellum/workflows/nodes/core/templating_node/node.py,sha256=-JIqLUv6Xpx_LTVZt7whQ2X2VatgHDdTxjMrz64luEs,3721
 vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py,sha256=ldnmSASx0TfAnT3ZvU0AXtN0diZGrfySiXipuJIIzWU,9055
 vellum/workflows/nodes/core/try_node/__init__.py,sha256=JVD4DrldTIqFQQFrubs9KtWCCc0YCAc7Fzol5ZWIWeM,56
-vellum/workflows/nodes/core/try_node/node.py,sha256=_0df2_6kim8pW4hB7IXUJOYS4fLduaeGDH4rRhYYvcg,4212
+vellum/workflows/nodes/core/try_node/node.py,sha256=5ux1l2HO12FBFFyhz6j-4yfBYVrqgT2maTAne_GnNDk,4434
 vellum/workflows/nodes/core/try_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/core/try_node/tests/test_node.py,sha256=Wc2kLl-MkffsBxl3IiFaqLd16e2Iosxhk7qBnojPvQg,4092
+vellum/workflows/nodes/core/try_node/tests/test_node.py,sha256=h6eUc3SggvhzBWlOD0PrPUlkoCSQHwjqYn81VkxSIxU,4948
 vellum/workflows/nodes/displayable/__init__.py,sha256=6F_4DlSwvHuilWnIalp8iDjjDXl0Nmz4QzJV2PYe5RI,1023
 vellum/workflows/nodes/displayable/api_node/__init__.py,sha256=MoxdQSnidIj1Nf_d-hTxlOxcZXaZnsWFDbE-PkTK24o,56
 vellum/workflows/nodes/displayable/api_node/node.py,sha256=QdpsyGVxo5PcN8nwGZpcpW_YMKHr3_VvmbK1BlrdOFk,2547
@@ -1450,10 +1450,12 @@ vellum/workflows/nodes/experimental/README.md,sha256=eF6DfIL8t-HbF9-mcofOMymKrra
 vellum/workflows/nodes/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/experimental/openai_chat_completion_node/__init__.py,sha256=lsyD9laR9p7kx5-BXGH2gUTM242UhKy8SMV0SR6S2iE,90
 vellum/workflows/nodes/experimental/openai_chat_completion_node/node.py,sha256=1EGeiaT-Zoo6pttQFKKBcdf3dmhAbjKGaErYD5FFwlc,10185
-vellum/workflows/nodes/mocks.py,sha256=gvM2tyoe-V84jFbFdhQsyGAPyQBzmjn_CkhT_yxccgY,499
+vellum/workflows/nodes/mocks.py,sha256=a1FjWEIocseMfjzM-i8DNozpUsaW0IONRpZmXBoWlyc,10455
+vellum/workflows/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vellum/workflows/nodes/tests/test_mocks.py,sha256=mfPvrs75PKcsNsbJLQAN6PDFoVqs9TmQxpdyFKDdO60,7837
 vellum/workflows/nodes/utils.py,sha256=uaTPGYp4utenz_QDghqQ23Q1iCsGHQ40nNZh1g9H9WI,7117
 vellum/workflows/outputs/__init__.py,sha256=AyZ4pRh_ACQIGvkf0byJO46EDnSix1ZCAXfvh-ms1QE,94
-vellum/workflows/outputs/base.py,sha256=W5KL9FaWfSbZuF7lOQ677giHO839Do-MXmuzkDuzPqk,8607
+vellum/workflows/outputs/base.py,sha256=b4Dnha1miKu3uFJYptKKflIHNuajPF2BNKy0BTt8Tjc,8622
 vellum/workflows/ports/__init__.py,sha256=bZuMt-R7z5bKwpu4uPW7LlJeePOQWmCcDSXe5frUY5g,101
 vellum/workflows/ports/node_ports.py,sha256=g4A-8iUAvEJSkaWppbvzAR8XU02R9U-qLN4rP2Kq4Aw,2743
 vellum/workflows/ports/port.py,sha256=eI2SOZPZ5rsC3jMsxW6Rbn0NpaYQsrR7AapiIbbiy8Q,3635
@@ -1509,8 +1511,8 @@ vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnad
 vellum/workflows/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/workflows/tests/test_base_workflow.py,sha256=NRteiICyJvDM5zrtUfq2fZoXcGQVaWC9xmNlLLVW0cU,7979
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-0.14.12.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.12.dist-info/METADATA,sha256=1EKavjMZSN9SKB-BwKDVMb4xfc-TnvoUWiYD7JMCqLk,5408
-vellum_ai-0.14.12.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.12.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.12.dist-info/RECORD,,
+vellum_ai-0.14.13.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.13.dist-info/METADATA,sha256=y44fYKH3DaYDbx8hhtZFAtWbGESUBWDUV-2W_JL-XiI,5408
+vellum_ai-0.14.13.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.13.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.13.dist-info/RECORD,,

vellum_ee/workflows/display/nodes/base_node_display.py

@@ -59,11 +59,27 @@ _NodeDisplayAttrType = TypeVar("_NodeDisplayAttrType")
 class BaseNodeDisplayMeta(type):
     def __new__(mcs, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
         cls = super().__new__(mcs, name, bases, dct)
-        if isinstance(dct.get("node_id"), UUID):
+        base_node_display_class = cast(Type["BaseNodeDisplay"], cls)
+        node_class = base_node_display_class.infer_node_class()
+        if not issubclass(node_class, BaseNode):
+            return cls
+
+        display_node_id = dct.get("node_id")
+        if isinstance(display_node_id, UUID):
             # Display classes are able to override the id of the node class it's parameterized by
-            base_node_display_class = cast(Type["BaseNodeDisplay"], cls)
-            node_class = base_node_display_class.infer_node_class()
-            node_class.__id__ = dct["node_id"]
+            node_class.__id__ = display_node_id
+
+        output_display = dct.get("output_display")
+        if isinstance(output_display, dict):
+            # And the node class' output ids
+            for reference, node_output_display in output_display.items():
+                if not isinstance(reference, OutputReference):
+                    continue
+                if not isinstance(node_output_display, NodeOutputDisplay):
+                    continue
+
+                node_class.__output_ids__[reference.name] = node_output_display.id
+
         return cls
 
 

vellum_ee/workflows/display/nodes/get_node_display_class.py

@@ -2,6 +2,7 @@ import types
 from typing import TYPE_CHECKING, Optional, Type
 
 from vellum.workflows.types.generics import NodeType
+from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
 
 if TYPE_CHECKING:
     from vellum_ee.workflows.display.types import NodeDisplayType
@@ -29,4 +30,12 @@ def get_node_display_class(
         f"{node_class.__name__}Display",
         bases=(NodeDisplayBaseClass,),
     )
+    output_display = {
+        ref: NodeOutputDisplay(id=node_class.__output_ids__[ref.name], name=ref.name)
+        for ref in node_class.Outputs
+        if ref.name in node_class.__output_ids__
+    }
+    if output_display:
+        setattr(NodeDisplayClass, "output_display", output_display)
+
     return NodeDisplayClass

vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_adornments_serialization.py

@@ -115,7 +115,8 @@ def test_serialize_node__retry(serialize_node):
     )
 
 
-def test_serialize_node__retry__no_display():  # GIVEN an adornment node
+def test_serialize_node__retry__no_display():
+    # GIVEN an adornment node
     @RetryNode.wrap(max_attempts=5)
     class StartNode(BaseNode):
         pass
@@ -212,6 +213,28 @@ def test_serialize_node__try(serialize_node):
     )
 
 
+def test_serialize_node__try__no_display():
+    # GIVEN an adornment node
+    @TryNode.wrap()
+    class StartNode(BaseNode):
+        pass
+
+    # AND a workflow that uses the adornment node
+    class MyWorkflow(BaseWorkflow):
+        graph = StartNode
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay,
+        workflow_class=MyWorkflow,
+    )
+
+    exec_config = workflow_display.serialize()
+
+    # THEN the workflow display is created successfully
+    assert exec_config is not None
+
+
 def test_serialize_node__stacked():
     @TryNode.wrap()
     @RetryNode.wrap(max_attempts=5)

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -411,7 +411,7 @@ class BaseWorkflowDisplay(
             input_display = {}
             if isinstance(current_node_display, BaseNodeVellumDisplay):
                 input_display = current_node_display.node_input_ids_by_name
-            node_display_meta = {
+            output_display = {
                 output.name: current_node_display.output_display[output].id
                 for output in current_node_display.output_display
             }
@@ -434,7 +434,7 @@ class BaseWorkflowDisplay(
 
             node_event_displays[node_id] = NodeEventDisplayContext(
                 input_display=input_display,
-                output_display=node_display_meta,
+                output_display=output_display,
                 port_display=port_display_meta,
                 subworkflow_display=subworkflow_display_context,
             )

vellum_ee/workflows/display/workflows/tests/test_workflow_display.py

@@ -95,6 +95,26 @@ def test_serialize_workflow__node_display_class_not_registered():
     assert data is not None
 
 
+def test_get_event_display_context__node_display_filled_without_base_display():
+    # GIVEN a simple workflow
+    class StartNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            foo: str
+
+    class MyWorkflow(BaseWorkflow):
+        graph = StartNode
+
+    # WHEN we gather the event display context
+    display_context = VellumWorkflowDisplay(MyWorkflow).get_event_display_context()
+
+    # THEN the node display should be included
+    assert str(StartNode.__id__) in display_context.node_displays
+    node_event_display = display_context.node_displays[str(StartNode.__id__)]
+
+    # AND so should their output ids
+    assert StartNode.__output_ids__ == node_event_display.output_display
+
+
 def test_get_event_display_context__node_display_to_include_subworkflow_display():
     # GIVEN a simple workflow
     class InnerNode(BaseNode):