vellum-ai 0.14.63__py3-none-any.whl → 1.13.5__py3-none-any.whl

vellum/workflows/nodes/core/inline_subworkflow_node/node.py

@@ -1,3 +1,4 @@
+from threading import Event as ThreadingEvent
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, Union
 
 from vellum.workflows.constants import undefined
@@ -13,7 +14,6 @@ from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.core import EntityInputsInterface
 from vellum.workflows.types.generics import InputsType, StateType
-from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 if TYPE_CHECKING:
@@ -72,6 +72,8 @@ class InlineSubworkflowNode(
     subworkflow_inputs: ClassVar[Union[EntityInputsInterface, BaseInputs, Type[undefined]]] = undefined
 
     def run(self) -> Iterator[BaseOutput]:
+        self._child_cancel_signal = ThreadingEvent()
+
         with execution_context(parent_context=get_parent_context()):
             subworkflow = self.subworkflow(
                 parent_state=self.state,
@@ -81,13 +83,18 @@ class InlineSubworkflowNode(
                 inputs=self._compile_subworkflow_inputs(),
                 event_filter=all_workflow_event_filter,
                 node_output_mocks=self._context._get_all_node_output_mocks(),
+                cancel_signal=self._child_cancel_signal,
+                event_max_size=self._context.event_max_size,
             )
 
         outputs: Optional[BaseOutputs] = None
+        exception: Optional[NodeException] = None
         fulfilled_output_names: Set[str] = set()
 
         for event in subworkflow_stream:
             self._context._emit_subworkflow_event(event)
+            if exception:
+                continue
 
             if not is_workflow_event(event):
                 continue
@@ -101,7 +108,15 @@ class InlineSubworkflowNode(
             elif event.name == "workflow.execution.fulfilled":
                 outputs = event.outputs
             elif event.name == "workflow.execution.rejected":
-                raise NodeException.of(event.error)
+                exception = NodeException.of(event.error)
+            elif event.name == "workflow.execution.paused":
+                exception = NodeException(
+                    code=WorkflowErrorCode.INVALID_OUTPUTS,
+                    message="Subworkflow unexpectedly paused",
+                )
+
+        if exception:
+            raise exception
 
         if outputs is None:
             raise NodeException(
@@ -118,7 +133,19 @@ class InlineSubworkflowNode(
                     value=output_value,
                 )
 
+    def __cancel__(self, message: str) -> None:
+        """
+        Propagate cancellation to the nested workflow by setting its cancel signal.
+        """
+        if hasattr(self, "_child_cancel_signal"):
+            self._child_cancel_signal.set()
+
     def _compile_subworkflow_inputs(self) -> InputsType:
+        if self.subworkflow is None:
+            raise NodeException(
+                message="InlineSubworkflowNode requires a subworkflow to be defined",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
         inputs_class = self.subworkflow.get_inputs_class()
         try:
             if self.subworkflow_inputs is undefined:
@@ -145,4 +172,4 @@ class InlineSubworkflowNode(
         if cls.__output_ids__ is None:
             cls.__output_ids__ = {}
 
-        cls.__output_ids__[reference.name] = uuid4_from_hash(f"{cls.__id__}|{reference.name}")
+        cls.__output_ids__[reference.name] = reference.id

vellum/workflows/nodes/core/inline_subworkflow_node/tests/test_node.py

@@ -9,6 +9,7 @@ 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
+from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 
 class Inputs(BaseInputs):
@@ -115,7 +116,7 @@ def test_inline_subworkflow_node__base_inputs_validation():
 
     # AND the error message should indicate the missing required input
     assert e.value.code == WorkflowErrorCode.INVALID_INPUTS
-    assert "Required input variables required_input should have defined value" == str(e.value)
+    assert "Required input variables 'required_input' should have defined value" == str(e.value)
 
 
 def test_inline_subworkflow_node__with_adornment():
@@ -143,3 +144,37 @@ def test_inline_subworkflow_node__with_adornment():
     outputs = list(node.run())
 
     assert outputs[-1].name == "final_output" and outputs[-1].value == "hello"
+
+
+@pytest.mark.skip(reason="Enable after we set is_dynamic on the subworkflow class")
+def test_inline_subworkflow_node__is_dynamic_subworkflow():
+    """Test that InlineSubworkflowNode sets is_dynamic=True on the subworkflow class"""
+
+    # GIVEN a subworkflow class
+    class TestSubworkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = MyInnerNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            out = MyInnerNode.Outputs.out
+
+    # AND a node that uses this subworkflow
+    class TestNode(InlineSubworkflowNode):
+        subworkflow = TestSubworkflow
+
+    # AND a workflow that uses this node
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = TestNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            out = TestNode.Outputs.out
+
+    # WHEN the workflow is executed
+    workflow = TestWorkflow()
+    events = list(workflow.stream(event_filter=all_workflow_event_filter))
+
+    # AND we should find workflow execution initiated events
+    initiated_events = [event for event in events if event.name == "workflow.execution.initiated"]
+    assert len(initiated_events) == 2  # Main workflow + inline workflow
+
+    assert initiated_events[0].body.workflow_definition.is_dynamic is False  # Main workflow
+    assert initiated_events[1].body.workflow_definition.is_dynamic is True  # Inline workflow

vellum/workflows/nodes/core/map_node/node.py

@@ -17,6 +17,7 @@ from typing import (
     overload,
 )
 
+from vellum.workflows.constants import undefined
 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
@@ -27,9 +28,11 @@ from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
 from vellum.workflows.nodes.utils import create_adornment
 from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.references.node import NodeReference
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.generics import StateType
+from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 if TYPE_CHECKING:
@@ -66,23 +69,24 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
 
     def run(self) -> Iterator[BaseOutput]:
         mapped_items: Dict[str, List] = defaultdict(list)
+        items = self.items or []
         for output_descripter in self.subworkflow.Outputs:
-            mapped_items[output_descripter.name] = [None] * len(self.items)
+            mapped_items[output_descripter.name] = [None] * len(items)
 
-        if not self.items:
+        if not items:
             for output_name, output_list in mapped_items.items():
                 yield BaseOutput(name=output_name, value=output_list)
             return
 
         self._event_queue: Queue[Tuple[int, WorkflowEvent]] = Queue()
-        fulfilled_iterations: List[bool] = [False] * len(self.items)
+        fulfilled_iterations: List[bool] = [False] * len(items)
 
-        max_workers = self.max_concurrency if self.max_concurrency is not None else len(self.items)
+        max_workers = self.max_concurrency if self.max_concurrency is not None else len(items)
 
         with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
             futures = []
             current_execution_context = get_execution_context()
-            for index, item in enumerate(self.items):
+            for index, item in enumerate(items):
                 future = executor.submit(
                     self._context_run_subworkflow,
                     item=item,
@@ -96,6 +100,7 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
                     map_node_event = self._event_queue.get(block=False)
                     index = map_node_event[0]
                     subworkflow_event = map_node_event[1]
+
                     self._context._emit_subworkflow_event(subworkflow_event)
 
                     if not is_workflow_event(subworkflow_event):
@@ -176,6 +181,7 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
             inputs=SubworkflowInputsClass(index=index, item=item, items=self.items),
             node_output_mocks=self._context._get_all_node_output_mocks(),
             event_filter=all_workflow_event_filter,
+            event_max_size=self._context.event_max_size,
         )
 
         for event in events:
@@ -207,8 +213,29 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
 
     @classmethod
     def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:
-        parameter_type = reference.types[0]
+        parameter_type = reference.types[0] if len(reference.types) > 0 else object
         annotation = List[parameter_type]  # type: ignore[valid-type]
 
         previous_annotations = {prev: annotation for prev in outputs_class.__annotations__ if not prev.startswith("_")}
+        # Map node output is a list of the same type so we use annotation=List[parameter_type] and not reference
+        # class Outputs(BaseOutputs):
+        #     value: List[str]
         outputs_class.__annotations__ = {**previous_annotations, reference.name: annotation}
+
+        # Create a NEW OutputReference with the List-wrapped type for discoverability during iteration
+        map_output_reference = OutputReference(
+            name=reference.name,
+            types=(annotation,),
+            instance=undefined,
+            outputs_class=outputs_class,
+        )
+        setattr(outputs_class, reference.name, map_output_reference)
+
+        subworkflow_class = cls.subworkflow.instance if isinstance(cls.subworkflow, NodeReference) else None
+        if subworkflow_class:
+            output_id = subworkflow_class.__output_ids__.get(reference.name) or uuid4_from_hash(
+                f"{cls.__id__}|{reference.name}"
+            )
+        else:
+            output_id = uuid4_from_hash(f"{cls.__id__}|{reference.name}")
+        cls.__output_ids__[reference.name] = output_id

vellum/workflows/nodes/core/map_node/tests/test_node.py

@@ -3,6 +3,7 @@ import threading
 import time
 
 from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes import FinalOutputNode
 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
@@ -70,6 +71,8 @@ def test_map_node__use_parallelism():
 
 
 def test_map_node__empty_list():
+    """Tests that a map node with an empty list returns an empty output."""
+
     # GIVEN a map node that is configured to use the parent's inputs and state
     @MapNode.wrap(items=[])
     class TestNode(BaseNode):
@@ -91,6 +94,37 @@ def test_map_node__empty_list():
     assert fulfilled_output == BaseOutput(name="value", value=[])
 
 
+def test_map_node__none_items():
+    """Tests that a map node with None items treats it as an empty array and fulfills successfully."""
+
+    # GIVEN a map node with items set to None
+    class TestNode(BaseNode):
+        item = MapNode.SubworkflowInputs.item
+
+        class Outputs(BaseOutputs):
+            value: str
+
+        def run(self) -> Outputs:
+            return self.Outputs(value=str(self.item))
+
+    class TestSubworkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
+        graph = TestNode
+
+        class Outputs(BaseOutputs):
+            value = TestNode.Outputs.value
+
+    class TestMapNode(MapNode):
+        subworkflow = TestSubworkflow
+
+    # WHEN the node is run
+    node = TestMapNode()
+    outputs = list(node.run())
+
+    # THEN the node should return an empty output without error
+    fulfilled_output = outputs[-1]
+    assert fulfilled_output == BaseOutput(name="value", value=[])
+
+
 def test_map_node__inner_try():
     # GIVEN a try wrapped node
     @TryNode.wrap()
@@ -118,6 +152,7 @@ def test_map_node__inner_try():
     # THEN the workflow should succeed
     assert outputs[-1].name == "final_output"
     assert len(outputs[-1].value) == 2
+    assert len(SimpleMapNode.__output_ids__) == 1
 
 
 def test_map_node__nested_map_node():
@@ -221,3 +256,74 @@ def test_map_node_parallel_execution_with_workflow():
     # AND each item should have run on a different thread
     thread_ids_list = list(thread_ids.values())
     assert len(set(thread_ids_list)) == 3
+
+
+def test_map_node__shared_state_race_condition():
+    processed_items = []
+
+    # GIVEN a templating node that processes items
+    class TemplatingNode(BaseNode):
+        item = MapNode.SubworkflowInputs.item
+
+        class Outputs(BaseOutputs):
+            processed_item: str
+
+        def run(self) -> Outputs:
+            processed_item = f"{self.item}!"
+            return self.Outputs(processed_item=processed_item)
+
+    # AND a final output node
+    class FinalOutput(FinalOutputNode[BaseState, str]):
+        class Outputs(FinalOutputNode.Outputs):
+            value = TemplatingNode.Outputs.processed_item
+
+        def run(self) -> Outputs:
+            outputs = super().run()
+            processed_items.append(outputs.value)
+            return outputs  # type: ignore[return-value]
+
+    # AND a workflow using those nodes
+    class ProcessItemWorkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
+        graph = TemplatingNode >> FinalOutput
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = FinalOutput.Outputs.value
+
+    # AND a map node with high concurrency
+    class RaceConditionMapNode(MapNode):
+        items = ["a", "b", "c", "d", "e", "f"]
+        subworkflow = ProcessItemWorkflow
+        max_concurrency = 1
+
+    # WHEN we run the map node multiple times to see pass consistently
+    num_runs = 50
+    for index in range(num_runs):
+        processed_items.clear()
+        node = RaceConditionMapNode(state=BaseState())
+        outputs = list(node.run())
+        final_result = outputs[-1].value
+
+        # THEN the state is unique among each run
+        assert len(set(processed_items)) == 6
+
+        # AND all results should be in correct order
+        expected_result = ["a!", "b!", "c!", "d!", "e!", "f!"]
+        assert final_result == expected_result, f"Failed on run {index}"
+
+
+def test_map_node__output_ids():
+    class TestNode(BaseNode):
+        class Outputs(BaseOutputs):
+            value: str
+
+    class SimpleMapNodeWorkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
+        graph = TestNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_output = TestNode.Outputs.value
+
+    class TestMapNode(MapNode):
+        items = [1, 2, 3]
+        subworkflow = SimpleMapNodeWorkflow
+
+    assert len(TestMapNode.__output_ids__) == 1

vellum/workflows/nodes/core/retry_node/node.py

@@ -52,6 +52,7 @@ class RetryNode(BaseAdornmentNode[StateType], Generic[StateType]):
                     inputs=inputs_class(attempt_number=attempt_number),
                     event_filter=all_workflow_event_filter,
                     node_output_mocks=self._context._get_all_node_output_mocks(),
+                    event_max_size=self._context.event_max_size,
                 )
 
             node_outputs: Optional[BaseNode.Outputs] = None

vellum/workflows/nodes/core/retry_node/tests/test_node.py

@@ -6,7 +6,6 @@ from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.core.retry_node.node import RetryNode
 from vellum.workflows.outputs import BaseOutputs
-from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state.base import BaseState, StateMeta
 
 
@@ -44,7 +43,7 @@ def test_retry_node__retry_on_error_code__missed():
 
         def run(self) -> Outputs:
             if self.attempt_number < 3:
-                raise Exception("This will not be retried")
+                raise NodeException(message="This will not be retried", code=WorkflowErrorCode.INTERNAL_ERROR)
 
             return self.Outputs(execution_count=self.attempt_number)
 
@@ -102,7 +101,7 @@ def test_retry_node__condition_arg_successfully_retries():
     # AND a retry node that retries on a condition
     @RetryNode.wrap(
         max_attempts=5,
-        retry_on_condition=LazyReference(lambda: State.count.less_than(3)),
+        retry_on_condition=State.count.less_than(3),
     )
     class TestNode(BaseNode[State]):
         attempt_number = RetryNode.SubworkflowInputs.attempt_number

vellum/workflows/nodes/core/templating_node/node.py

@@ -7,7 +7,7 @@ from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
-from vellum.workflows.nodes.utils import parse_type_from_str
+from vellum.workflows.nodes.utils import parse_type_from_str, wrap_inputs_for_backward_compatibility
 from vellum.workflows.types.core import EntityInputsInterface
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_original_base
@@ -47,6 +47,10 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
     Useful for lightweight data transformations and complex string templating.
     """
 
+    class Display(BaseNode.Display):
+        icon = "vellum:icon:stamp"
+        color = "brown"
+
     # The Jinja template to render.
     template: ClassVar[str] = ""
 
@@ -86,9 +90,10 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
 
     def _render_template(self) -> str:
         try:
+            wrapped_inputs = wrap_inputs_for_backward_compatibility(self.inputs)
             return render_sandboxed_jinja_template(
                 template=self.template,
-                input_values=self.inputs,
+                input_values=wrapped_inputs,
                 jinja_custom_filters={**self.jinja_custom_filters},
                 jinja_globals=self.jinja_globals,
             )

vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py

@@ -1,6 +1,6 @@
 import pytest
 import json
-from typing import List, Union
+from typing import Any, Dict, List, Union
 
 from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.function_call import FunctionCall
@@ -32,6 +32,54 @@ def test_templating_node__dict_output():
     assert json.loads(dump) == {"key": "value"}
 
 
+def test_templating_node__dict_type_output():
+    """Tests that TemplatingNode correctly parses dict outputs when using dict type annotation."""
+
+    # GIVEN a templating node with dict output type that returns a dict
+    class DictTemplateNode(TemplatingNode[BaseState, dict]):
+        template = "{{ data }}"
+        inputs = {"data": {"key": "value"}}
+
+    # WHEN the node is run
+    node = DictTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected dict
+    assert outputs.result == {"key": "value"}
+
+
+def test_templating_node__any_type_output():
+    """Tests that TemplatingNode correctly parses dict outputs when using Any type annotation."""
+
+    # GIVEN a templating node with Any output type that returns a dict
+    class AnyTemplateNode(TemplatingNode[BaseState, Any]):
+        template = "{{ data }}"
+        inputs = {"data": {"key": "value"}}
+
+    # WHEN the node is run
+    node = AnyTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected dict
+    assert outputs.result == {"key": "value"}
+
+
+def test_templating_node__dict_str_any_type_output():
+    """Tests that TemplatingNode correctly parses dict outputs when using Dict[str, Any] type annotation."""
+
+    # GIVEN a templating node with Dict[str, Any] output type that returns a dict
+    class DictStrAnyTemplateNode(TemplatingNode[BaseState, Dict[str, Any]]):
+        template = "{{ data }}"
+        inputs = {"data": {"key": "value"}}
+
+    # WHEN the node is run
+    node = DictStrAnyTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected dict
+    assert outputs.result == {"key": "value"}
+
+
 def test_templating_node__int_output():
     # GIVEN a templating node that outputs an integer
     class IntTemplateNode(TemplatingNode[BaseState, int]):
@@ -317,3 +365,148 @@ def test_api_error_templating_node():
 
     # THEN the output should be empty string
     assert outputs.result == ""
+
+
+@pytest.mark.parametrize(
+    "template,inputs,expected_result",
+    [
+        # String value access
+        ("{{ text_input.value }}", {"text_input": "hello world"}, "hello world"),
+        # Function call value access
+        (
+            "{{ func.value.name }}",
+            {"func": FunctionCall(name="test_function", arguments={"key": "value"})},
+            "test_function",
+        ),
+        # Array item value access
+        ("{{ items[0].value }}", {"items": ["apple"]}, "apple"),
+    ],
+    ids=["string_value", "function_call_value", "array_item_value"],
+)
+def test_templating_node__value_access_patterns_str(template, inputs, expected_result):
+    # GIVEN a templating node that accesses wrapper value properties
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        pass
+
+    # Set template and inputs dynamically
+    TemplateNode.template = template
+    TemplateNode.inputs = inputs
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN the value is accessible
+    assert outputs.result == expected_result
+
+
+@pytest.mark.parametrize(
+    "template,inputs,expected_result",
+    [
+        # Dict value access
+        ("{{ data.value }}", {"data": {"name": "test", "score": 42}}, {"name": "test", "score": 42}),
+        # List value access
+        ("{{ items.value }}", {"items": ["item1", "item2", "item3"]}, ["item1", "item2", "item3"]),
+    ],
+    ids=["dict_value", "list_value"],
+)
+def test_templating_node__value_access_patterns_json(template, inputs, expected_result):
+    # GIVEN a templating node that accesses wrapper value properties
+    class TemplateNode(TemplatingNode[BaseState, Json]):
+        pass
+
+    # Set template and inputs dynamically
+    TemplateNode.template = template
+    TemplateNode.inputs = inputs
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN the value is accessible
+    assert outputs.result == expected_result
+
+
+@pytest.mark.parametrize(
+    "template,inputs,expected_result",
+    [
+        # String type access
+        ("{{ text_input.type }}", {"text_input": "hello world"}, "STRING"),
+        # Function call type access
+        ("{{ func.type }}", {"func": FunctionCall(name="test_function", arguments={"key": "value"})}, "FUNCTION_CALL"),
+    ],
+    ids=["string_type", "function_call_type"],
+)
+def test_templating_node__type_access_patterns(template, inputs, expected_result):
+    # GIVEN a templating node that accesses wrapper type properties
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        pass
+
+    # Set template and inputs dynamically
+    TemplateNode.template = template
+    TemplateNode.inputs = inputs
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN the type is accessible
+    assert outputs.result == expected_result
+
+
+def test_templating_node__nested_dict_access():
+    # GIVEN a templating node with nested dict access
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{{ data.user.name }}"
+        inputs = {"data": {"user": {"name": "John Doe", "age": 30}, "status": "active"}}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN nested properties are accessible
+    assert outputs.result == "John Doe"
+
+
+def test_templating_node__list_iteration_wrapper_access():
+    # GIVEN a templating node that iterates over list with wrapper access
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{% for item in items %}{{ item.value }}{% if not loop.last %},{% endif %}{% endfor %}"
+        inputs = {"items": ["apple", "banana", "cherry"]}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN list iteration with wrapper access works
+    assert outputs.result == "apple,banana,cherry"
+
+
+def test_templating_node__conditional_type_checking():
+    # GIVEN a templating node with conditional type checking
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{% if input.type == 'STRING' %}{{ input.value }}{% else %}unknown{% endif %}"
+        inputs = {"input": "test string"}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN conditional type checking works
+    assert outputs.result == "test string"
+
+
+def test_templating_node__dict_wrapper_nonexistent_attribute_is_none():
+    """Test that non-existent attributes on DictWrapper evaluate to None."""
+
+    # GIVEN a templating node with nonexistent attr in the template
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{% if data.nonexistent_attr is none %}none_value{% else %}{{ data.nonexistent_attr }}{% endif %}"
+        inputs = {"data": {"existing_key": "existing_value"}}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN it should recognize the non-existent attribute as ""
+    assert outputs.result == ""

vellum/workflows/nodes/core/try_node/node.py

@@ -36,6 +36,7 @@ class TryNode(BaseAdornmentNode[StateType], Generic[StateType]):
             subworkflow_stream = subworkflow.stream(
                 event_filter=all_workflow_event_filter,
                 node_output_mocks=self._context._get_all_node_output_mocks(),
+                event_max_size=self._context.event_max_size,
             )
 
         outputs: Optional[BaseOutputs] = None

vellum/workflows/nodes/displayable/__init__.py

@@ -12,7 +12,10 @@ from .merge_node import MergeNode
 from .note_node import NoteNode
 from .prompt_deployment_node import PromptDeploymentNode
 from .search_node import SearchNode
+from .set_state_node import SetStateNode
 from .subworkflow_deployment_node import SubworkflowDeploymentNode
+from .tool_calling_node import ToolCallingNode
+from .web_search_node import WebSearchNode
 
 __all__ = [
     "APINode",
@@ -28,6 +31,9 @@ __all__ = [
     "SubworkflowDeploymentNode",
     "PromptDeploymentNode",
     "SearchNode",
+    "SetStateNode",
     "TemplatingNode",
+    "ToolCallingNode",
+    "WebSearchNode",
     "FinalOutputNode",
 ]