vellum-ai 0.14.12__tar.gz → 0.14.14__tar.gz

{vellum_ai-0.14.12 → vellum_ai-0.14.14}/PKG-INFO

@@ -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

{vellum_ai-0.14.12 → vellum_ai-0.14.14}/ee/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_ai-0.14.12 → vellum_ai-0.14.14}/ee/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_ai-0.14.12 → vellum_ai-0.14.14}/ee/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_ai-0.14.12 → vellum_ai-0.14.14}/ee/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_ai-0.14.12 → vellum_ai-0.14.14}/ee/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):

{vellum_ai-0.14.12 → vellum_ai-0.14.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.14.12"
+version = "0.14.14"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.14.12 → vellum_ai-0.14.14}/src/vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.12",
+            "X-Fern-SDK-Version": "0.14.14",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.14.12 → vellum_ai-0.14.14}/src/vellum/plugins/utils.py

@@ -1,11 +1,19 @@
-from pydantic.plugin import _loader as _pydantic_plugin_loader
-
-from vellum.plugins.pydantic import pydantic_plugin
+import pydantic
 
+IS_PYDANTIC_V1 = pydantic.VERSION.startswith("1.")
 _loaded = False
 
 
 def load_runtime_plugins() -> None:
+    if IS_PYDANTIC_V1:
+        # Pydantic plugins are only available in v2, so we defer the imports
+        # below until we confirm we are running a supported version of pydantic
+        return
+
+    from pydantic.plugin import _loader as _pydantic_plugin_loader
+
+    from vellum.plugins.pydantic import pydantic_plugin
+
     global _loaded
     if _loaded:
         return

{vellum_ai-0.14.12 → vellum_ai-0.14.14}/src/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_ai-0.14.12 → vellum_ai-0.14.14}/src/vellum/workflows/events/node.py

@@ -93,6 +93,7 @@ class NodeExecutionStreamingEvent(_BaseNodeEvent):
 class NodeExecutionFulfilledBody(_BaseNodeExecutionBody, Generic[OutputsType]):
     outputs: OutputsType
     invoked_ports: InvokedPorts = None
+    mocked: Optional[bool] = None
 
     @field_serializer("outputs")
     def serialize_outputs(self, outputs: OutputsType, _info: Any) -> Dict[str, Any]:
@@ -117,6 +118,10 @@ class NodeExecutionFulfilledEvent(_BaseNodeEvent, Generic[OutputsType]):
     def invoked_ports(self) -> InvokedPorts:
         return self.body.invoked_ports
 
+    @property
+    def mocked(self) -> Optional[bool]:
+        return self.body.mocked
+
 
 class NodeExecutionRejectedBody(_BaseNodeExecutionBody):
     error: WorkflowError

{vellum_ai-0.14.12 → vellum_ai-0.14.14}/src/vellum/workflows/events/tests/test_event.py

@@ -328,6 +328,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                             "name": "default",
                         }
                     ],
+                    "mocked": None,
                 },
                 "parent": None,
             },
@@ -365,6 +366,40 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                             "name": "default",
                         }
                     ],
+                    "mocked": None,
+                },
+                "parent": None,
+            },
+        ),
+        (
+            NodeExecutionFulfilledEvent(
+                id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                timestamp=datetime(2024, 1, 1, 12, 0, 0),
+                trace_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                body=NodeExecutionFulfilledBody(
+                    node_definition=MockNode,
+                    outputs=MockNode.Outputs(
+                        example="foo",
+                    ),
+                    mocked=True,
+                ),
+            ),
+            {
+                "id": "123e4567-e89b-12d3-a456-426614174000",
+                "api_version": "2024-10-25",
+                "timestamp": "2024-01-01T12:00:00",
+                "trace_id": "123e4567-e89b-12d3-a456-426614174000",
+                "span_id": "123e4567-e89b-12d3-a456-426614174000",
+                "name": "node.execution.fulfilled",
+                "body": {
+                    "node_definition": {
+                        "id": mock_node_uuid,
+                        "name": "MockNode",
+                        "module": module_root + ["events", "tests", "test_event"],
+                    },
+                    "outputs": {"example": "foo"},
+                    "mocked": True,
                 },
                 "parent": None,
             },
@@ -379,6 +414,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
         "node.execution.streaming",
         "node.execution.fulfilled",
         "fulfilled_node_with_undefined_outputs",
+        "mocked_node",
     ],
 )
 def test_event_serialization(event, expected_json):

{vellum_ai-0.14.12 → vellum_ai-0.14.14}/src/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_ai-0.14.12 → vellum_ai-0.14.14}/src/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_ai-0.14.12 → vellum_ai-0.14.14}/src/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_ai-0.14.12 → vellum_ai-0.14.14}/src/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_ai-0.14.12 → vellum_ai-0.14.14}/src/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_ai-0.14.12 → vellum_ai-0.14.14}/src/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_ai-0.14.12 → vellum_ai-0.14.14}/src/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_ai-0.14.12 → vellum_ai-0.14.14}/src/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_ai-0.14.12 → vellum_ai-0.14.14}/src/vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py

@@ -283,3 +283,19 @@ def test_templating_node__function_call_as_json():
     # AND we can access fields directly
     assert outputs.result["arguments"] == {"key": "value"}
     assert outputs.result["name"] == "test_function"
+
+
+def test_templating_node__empty_string_to_list():
+    """Test that an empty string output with list output type casts to an empty array."""
+
+    # GIVEN a templating node that outputs an empty string but has List output type
+    class EmptyStringToListTemplateNode(TemplatingNode[BaseState, List[str]]):
+        template = """{{ "" }}"""
+        inputs = {}
+
+    # WHEN the node is run
+    node = EmptyStringToListTemplateNode()
+    outputs = node.run()
+
+    # THEN the output should be an empty list, not raise an exception
+    assert outputs.result == []

{vellum_ai-0.14.12 → vellum_ai-0.14.14}/src/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)