vellum-ai 0.12.13__tar.gz → 0.12.14__tar.gz

{vellum_ai-0.12.13 → vellum_ai-0.12.14}/PKG-INFO

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

vellum_ai-0.12.14/ee/vellum_ee/workflows/server/virtual_file_loader.py

@@ -0,0 +1,42 @@
+import importlib
+
+
+class VirtualFileLoader(importlib.abc.Loader):
+    def __init__(self, code: str, is_package: bool):
+        self.code = code
+        self.is_package = is_package
+
+    def create_module(self, spec):
+        return None  # use default module creation
+
+    def exec_module(self, module):
+        if not self.is_package:
+            exec(self.code, module.__dict__)
+
+
+class VirtualFileFinder(importlib.abc.MetaPathFinder, importlib.abc.Loader):
+    def __init__(self, files: dict[str, str], namespace: str):
+        self.files = files
+        self.namespace = namespace
+
+    def find_spec(self, fullname, path, target=None):
+        # Do the namespacing on the fly to avoid having to copy the file dict
+        prefixed_name = fullname if fullname.startswith(self.namespace) else f"{self.namespace}.{fullname}"
+
+        key_name = "__init__" if fullname == self.namespace else fullname.replace(f"{self.namespace}.", "")
+
+        files_key = f"{key_name.replace('.', '/')}.py"
+        if not self.files.get(files_key):
+            files_key = f"{key_name.replace('.', '/')}/__init__.py"
+
+        file = self.files.get(files_key)
+        is_package = "__init__" in files_key
+
+        if file:
+            return importlib.machinery.ModuleSpec(
+                prefixed_name,
+                VirtualFileLoader(file, is_package),
+                origin=prefixed_name,
+                is_package=is_package,
+            )
+        return None

{vellum_ai-0.12.13 → vellum_ai-0.12.14}/pyproject.toml

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

{vellum_ai-0.12.13 → vellum_ai-0.12.14}/src/vellum/__init__.py

@@ -1,4 +1,7 @@
 # This file was auto-generated by Fern from our API Definition.
+from .plugins.utils import load_runtime_plugins
+
+load_runtime_plugins()
 
 from .types import (
     AdHocExecutePromptEvent,

{vellum_ai-0.12.13 → vellum_ai-0.12.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.12.13",
+            "X-Fern-SDK-Version": "0.12.14",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.12.13 → vellum_ai-0.12.14}/src/vellum/plugins/pydantic.py

@@ -1,3 +1,4 @@
+from functools import lru_cache
 from typing import Any, Dict, Literal, Optional, Tuple, Union
 
 from pydantic.plugin import (
@@ -10,12 +11,20 @@ from pydantic.plugin import (
 )
 from pydantic_core import CoreSchema
 
-from vellum.workflows.descriptors.base import BaseDescriptor
+
+@lru_cache(maxsize=1)
+def import_base_descriptor():
+    """
+    We have to avoid importing from vellum.* in this file because it will cause a circular import.
+    """
+    from vellum.workflows.descriptors.base import BaseDescriptor
+
+    return BaseDescriptor
 
 
 # https://docs.pydantic.dev/2.8/concepts/plugins/#build-a-plugin
 class OnValidatePython(ValidatePythonHandlerProtocol):
-    tracked_descriptors: Dict[str, BaseDescriptor] = {}
+    tracked_descriptors: Dict[str, Any] = {}
 
     def on_enter(
         self,
@@ -31,6 +40,7 @@ class OnValidatePython(ValidatePythonHandlerProtocol):
             return
 
         self.tracked_descriptors = {}
+        BaseDescriptor = import_base_descriptor()
 
         for key, value in input.items():
             if isinstance(value, BaseDescriptor):

{vellum_ai-0.12.13 → vellum_ai-0.12.14}/src/vellum/workflows/descriptors/tests/test_utils.py

@@ -2,6 +2,7 @@ import pytest
 
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.references.constant import ConstantValueReference
 from vellum.workflows.state.base import BaseState
 
 
@@ -73,6 +74,7 @@ class DummyNode(BaseNode[FixtureState]):
             True,
         ),
         (FixtureState.zeta["foo"], "bar"),
+        (ConstantValueReference(1), 1),
     ],
     ids=[
         "or",
@@ -116,6 +118,7 @@ class DummyNode(BaseNode[FixtureState]):
         "is_not_blank",
         "or_and",
         "accessor",
+        "constants",
     ],
 )
 def test_resolve_value__happy_path(descriptor, expected_value):

{vellum_ai-0.12.13 → vellum_ai-0.12.14}/src/vellum/workflows/nodes/bases/base.py

@@ -214,6 +214,9 @@ class _BaseNodeExecutionMeta(type):
         return self_execution_class.node_class.__name__ == other_execution_class.node_class.__name__
 
 
+NodeRunResponse = Union[BaseOutputs, Iterator[BaseOutput]]
+
+
 class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
     __id__: UUID = uuid4_from_hash(__qualname__)
     state: StateType
@@ -350,7 +353,7 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
 
         self._inputs = MappingProxyType(all_inputs)
 
-    def run(self) -> Union[BaseOutputs, Iterator[BaseOutput]]:
+    def run(self) -> NodeRunResponse:
         return self.Outputs()
 
     def __repr__(self) -> str:

vellum_ai-0.12.14/src/vellum/workflows/nodes/bases/base_adornment_node.py

@@ -0,0 +1,75 @@
+from typing import TYPE_CHECKING, Any, Dict, Generic, Optional, Tuple, Type
+
+from vellum.workflows.nodes.bases.base import BaseNode, BaseNodeMeta
+from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.references.output import OutputReference
+from vellum.workflows.types.generics import StateType
+
+if TYPE_CHECKING:
+    from vellum.workflows import BaseWorkflow
+
+
+class _BaseAdornmentNodeMeta(BaseNodeMeta):
+    def __new__(cls, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
+        node_class = super().__new__(cls, name, bases, dct)
+
+        subworkflow_attribute = dct.get("subworkflow")
+        if not subworkflow_attribute:
+            return node_class
+
+        if not issubclass(node_class, BaseAdornmentNode):
+            raise ValueError("BaseAdornableNodeMeta can only be used on subclasses of BaseAdornableNode")
+
+        subworkflow_outputs = getattr(subworkflow_attribute, "Outputs")
+        if not issubclass(subworkflow_outputs, BaseOutputs):
+            raise ValueError("subworkflow.Outputs must be a subclass of BaseOutputs")
+
+        outputs_class = dct.get("Outputs")
+        if not outputs_class:
+            raise ValueError("Outputs class not found in base classes")
+
+        if not issubclass(outputs_class, BaseNode.Outputs):
+            raise ValueError("Outputs class must be a subclass of BaseNode.Outputs")
+
+        for descriptor in subworkflow_outputs:
+            node_class.__annotate_outputs_class__(outputs_class, descriptor)
+
+        return node_class
+
+    def __getattribute__(cls, name: str) -> Any:
+        try:
+            return super().__getattribute__(name)
+        except AttributeError:
+            if name != "__wrapped_node__" and issubclass(cls, BaseAdornmentNode):
+                return getattr(cls.__wrapped_node__, name)
+            raise
+
+    @property
+    def _localns(cls) -> Dict[str, Any]:
+        if not hasattr(cls, "SubworkflowInputs"):
+            return super()._localns
+
+        return {
+            **super()._localns,
+            "SubworkflowInputs": getattr(cls, "SubworkflowInputs"),
+        }
+
+
+class BaseAdornmentNode(
+    BaseNode[StateType],
+    Generic[StateType],
+    metaclass=_BaseAdornmentNodeMeta,
+):
+    """
+    A base node that enables the node to be used as an adornment - meaning it can wrap another node. The
+    wrapped node is stored in the `__wrapped_node__` attribute and is redefined as a single-node subworkflow.
+    """
+
+    __wrapped_node__: Optional[Type["BaseNode"]] = None
+    subworkflow: Type["BaseWorkflow"]
+
+    @classmethod
+    def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:
+        # Subclasses of BaseAdornableNode can override this method to provider their own
+        # approach to annotating the outputs class based on the `subworkflow.Outputs`
+        setattr(outputs_class, reference.name, reference)

{vellum_ai-0.12.13 → vellum_ai-0.12.14}/src/vellum/workflows/nodes/bases/tests/test_base_node.py

@@ -1,6 +1,7 @@
 from uuid import UUID
 from typing import Optional
 
+from vellum.client.types.string_vellum_value_request import StringVellumValueRequest
 from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
@@ -135,3 +136,15 @@ def test_base_node__default_id():
 
     # THEN it should equal the hash of `test_base_node__default_id.<locals>.MyNode`
     assert my_id == UUID("8e71bea7-ce68-492f-9abe-477c788e6273")
+
+
+def test_base_node__node_resolution__descriptor_in_fern_pydantic():
+    class State(BaseState):
+        foo: str
+
+    class SomeNode(BaseNode):
+        model = StringVellumValueRequest(value=State.foo)
+
+    node = SomeNode(state=State(foo="bar"))
+
+    assert node.model.value == "bar"

{vellum_ai-0.12.13 → vellum_ai-0.12.14}/src/vellum/workflows/nodes/core/inline_subworkflow_node/node.py

@@ -10,6 +10,7 @@ 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 StateType, WorkflowInputsType
+from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 if TYPE_CHECKING:
     from vellum.workflows.workflows.base import BaseWorkflow
@@ -36,6 +37,7 @@ class InlineSubworkflowNode(BaseNode[StateType], Generic[StateType, WorkflowInpu
             )
             subworkflow_stream = subworkflow.stream(
                 inputs=self._compile_subworkflow_inputs(),
+                event_filter=all_workflow_event_filter,
             )
 
         outputs: Optional[BaseOutputs] = None

{vellum_ai-0.12.13 → vellum_ai-0.12.14}/src/vellum/workflows/nodes/core/map_node/node.py

@@ -9,21 +9,21 @@ from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.events.types import ParentContext
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
-from vellum.workflows.nodes.bases import BaseNode
+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.state.base import BaseState
+from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.context import WorkflowContext
-from vellum.workflows.types.generics import NodeType, StateType
+from vellum.workflows.types.generics import StateType
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 if TYPE_CHECKING:
-    from vellum.workflows import BaseWorkflow
     from vellum.workflows.events.workflow import WorkflowEvent
 
 MapNodeItemType = TypeVar("MapNodeItemType")
 
 
-class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
+class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType]):
     """
     Used to map over a list of items and execute a Subworkflow on each iteration.
 
@@ -33,11 +33,10 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
     """
 
     items: List[MapNodeItemType]
-    subworkflow: Type["BaseWorkflow"]
     concurrency: Optional[int] = None
 
-    class Outputs(BaseOutputs):
-        mapped_items: list
+    class Outputs(BaseAdornmentNode.Outputs):
+        pass
 
     class SubworkflowInputs(BaseInputs):
         # TODO: Both type: ignore's below are believed to be incorrect and both have the following error:
@@ -54,6 +53,7 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
             mapped_items[output_descripter.name] = [None] * len(self.items)
 
         self._event_queue: Queue[Tuple[int, WorkflowEvent]] = Queue()
+        self._concurrency_queue: Queue[Thread] = Queue()
         fulfilled_iterations: List[bool] = []
         for index, item in enumerate(self.items):
             fulfilled_iterations.append(False)
@@ -66,11 +66,21 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
                     "parent_context": parent_context,
                 },
             )
-            thread.start()
+            if self.concurrency is None:
+                thread.start()
+            else:
+                self._concurrency_queue.put(thread)
+
+        if self.concurrency is not None:
+            concurrency_count = 0
+            while concurrency_count < self.concurrency:
+                is_empty = self._start_thread()
+                if is_empty:
+                    break
+
+                concurrency_count += 1
 
         try:
-            # We should consolidate this logic with the logic workflow runner uses
-            # https://app.shortcut.com/vellum/story/4736
             while map_node_event := self._event_queue.get():
                 index = map_node_event[0]
                 terminal_event = map_node_event[1]
@@ -86,6 +96,9 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
                     fulfilled_iterations[index] = True
                     if all(fulfilled_iterations):
                         break
+
+                    if self.concurrency is not None:
+                        self._start_thread()
                 elif terminal_event.name == "workflow.execution.paused":
                     raise NodeException(
                         code=WorkflowErrorCode.INVALID_OUTPUTS,
@@ -98,7 +111,12 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
                     )
         except Empty:
             pass
-        return self.Outputs(**mapped_items)
+
+        outputs = self.Outputs()
+        for output_name, output_list in mapped_items.items():
+            setattr(outputs, output_name, output_list)
+
+        return outputs
 
     def _context_run_subworkflow(
         self, *, item: MapNodeItemType, index: int, parent_context: Optional[ParentContext] = None
@@ -109,7 +127,10 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
 
     def _run_subworkflow(self, *, item: MapNodeItemType, index: int) -> None:
         context = WorkflowContext(vellum_client=self._context.vellum_client)
-        subworkflow = self.subworkflow(parent_state=self.state, context=context)
+        subworkflow = self.subworkflow(
+            parent_state=self.state,
+            context=context,
+        )
         events = subworkflow.stream(
             inputs=self.SubworkflowInputs(index=index, item=item, all_items=self.items),
             event_filter=all_workflow_event_filter,
@@ -118,6 +139,14 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
         for event in events:
             self._event_queue.put((index, event))
 
+    def _start_thread(self) -> bool:
+        if self._concurrency_queue.empty():
+            return False
+
+        thread = self._concurrency_queue.get()
+        thread.start()
+        return True
+
     @overload
     @classmethod
     def wrap(cls, items: List[MapNodeItemType]) -> Callable[..., Type["MapNode[StateType, MapNodeItemType]"]]: ...
@@ -134,37 +163,12 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
     def wrap(
         cls, items: Union[List[MapNodeItemType], BaseDescriptor[List[MapNodeItemType]]]
     ) -> Callable[..., Type["MapNode[StateType, MapNodeItemType]"]]:
-        _items = items
+        return create_adornment(cls, attributes={"items": items})
 
-        def decorator(inner_cls: Type[NodeType]) -> Type["MapNode[StateType, MapNodeItemType]"]:
-            # Investigate how to use dependency injection to avoid circular imports
-            # https://app.shortcut.com/vellum/story/4116
-            from vellum.workflows import BaseWorkflow
-
-            class Subworkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
-                graph = inner_cls
-
-                # mypy is wrong here, this works and is defined
-                class Outputs(inner_cls.Outputs):  # type: ignore[name-defined]
-                    pass
-
-            class WrappedNodeOutputs(BaseOutputs):
-                pass
-
-            WrappedNodeOutputs.__annotations__ = {
-                # TODO: We'll need to infer the type T of Subworkflow.Outputs[name] so we could do List[T] here
-                # https://app.shortcut.com/vellum/story/4119
-                descriptor.name: List
-                for descriptor in inner_cls.Outputs
-            }
-
-            class WrappedNode(MapNode[StateType, MapNodeItemType]):
-                items = _items
-                subworkflow = Subworkflow
-
-                class Outputs(WrappedNodeOutputs):
-                    pass
-
-            return WrappedNode
+    @classmethod
+    def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:
+        parameter_type = reference.types[0]
+        annotation = List[parameter_type]  # type: ignore[valid-type]
 
-        return decorator
+        previous_annotations = {prev: annotation for prev in outputs_class.__annotations__ if not prev.startswith("_")}
+        outputs_class.__annotations__ = {**previous_annotations, reference.name: annotation}

{vellum_ai-0.12.13 → vellum_ai-0.12.14}/src/vellum/workflows/nodes/core/retry_node/node.py

@@ -1,27 +1,16 @@
-from typing import TYPE_CHECKING, Any, Callable, Dict, Generic, Optional, Type
+from typing import Callable, Generic, Optional, Type
 
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
-from vellum.workflows.nodes.bases.base import BaseNodeMeta
-from vellum.workflows.state.base import BaseState
+from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
+from vellum.workflows.nodes.utils import create_adornment
+from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.generics import StateType
 
-if TYPE_CHECKING:
-    from vellum.workflows import BaseWorkflow
 
-
-class _RetryNodeMeta(BaseNodeMeta):
-    @property
-    def _localns(cls) -> Dict[str, Any]:
-        return {
-            **super()._localns,
-            "SubworkflowInputs": getattr(cls, "SubworkflowInputs"),
-        }
-
-
-class RetryNode(BaseNode[StateType], Generic[StateType], metaclass=_RetryNodeMeta):
+class RetryNode(BaseAdornmentNode[StateType], Generic[StateType]):
     """
     Used to retry a Subworkflow a specified number of times.
 
@@ -32,7 +21,6 @@ class RetryNode(BaseNode[StateType], Generic[StateType], metaclass=_RetryNodeMet
 
     max_attempts: int
     retry_on_error_code: Optional[WorkflowErrorCode] = None
-    subworkflow: Type["BaseWorkflow[SubworkflowInputs, BaseState]"]
 
     class SubworkflowInputs(BaseInputs):
         attempt_number: int
@@ -41,9 +29,10 @@ class RetryNode(BaseNode[StateType], Generic[StateType], metaclass=_RetryNodeMet
         last_exception = Exception("max_attempts must be greater than 0")
         for index in range(self.max_attempts):
             attempt_number = index + 1
+            context = WorkflowContext(vellum_client=self._context.vellum_client)
             subworkflow = self.subworkflow(
                 parent_state=self.state,
-                context=self._context,
+                context=context,
             )
             terminal_event = subworkflow.run(
                 inputs=self.SubworkflowInputs(attempt_number=attempt_number),
@@ -78,30 +67,6 @@ Message: {terminal_event.error.message}""",
     def wrap(
         cls, max_attempts: int, retry_on_error_code: Optional[WorkflowErrorCode] = None
     ) -> Callable[..., Type["RetryNode"]]:
-        _max_attempts = max_attempts
-        _retry_on_error_code = retry_on_error_code
-
-        def decorator(inner_cls: Type[BaseNode]) -> Type["RetryNode"]:
-            # Investigate how to use dependency injection to avoid circular imports
-            # https://app.shortcut.com/vellum/story/4116
-            from vellum.workflows import BaseWorkflow
-
-            class Subworkflow(BaseWorkflow[RetryNode.SubworkflowInputs, BaseState]):
-                graph = inner_cls
-
-                # mypy is wrong here, this works and is defined
-                class Outputs(inner_cls.Outputs):  # type: ignore[name-defined]
-                    pass
-
-            class WrappedNode(RetryNode[StateType]):
-                max_attempts = _max_attempts
-                retry_on_error_code = _retry_on_error_code
-
-                subworkflow = Subworkflow
-
-                class Outputs(Subworkflow.Outputs):
-                    pass
-
-            return WrappedNode
-
-        return decorator
+        return create_adornment(
+            cls, attributes={"max_attempts": max_attempts, "retry_on_error_code": retry_on_error_code}
+        )

vellum_ai-0.12.14/src/vellum/workflows/nodes/core/try_node/node.py

@@ -0,0 +1,94 @@
+from typing import Callable, Generic, Iterator, Optional, Set, Type
+
+from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
+from vellum.workflows.nodes.utils import create_adornment
+from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
+from vellum.workflows.references.output import OutputReference
+from vellum.workflows.state.context import WorkflowContext
+from vellum.workflows.types.generics import StateType
+from vellum.workflows.workflows.event_filters import all_workflow_event_filter
+
+
+class TryNode(BaseAdornmentNode[StateType], Generic[StateType]):
+    """
+    Used to execute a Subworkflow and handle errors.
+
+    on_error_code: Optional[VellumErrorCode] = None - The error code to handle
+    subworkflow: Type["BaseWorkflow"] - The Subworkflow to execute
+    """
+
+    on_error_code: Optional[WorkflowErrorCode] = None
+
+    class Outputs(BaseNode.Outputs):
+        error: Optional[WorkflowError] = None
+
+    def run(self) -> Iterator[BaseOutput]:
+        subworkflow = self.subworkflow(
+            parent_state=self.state,
+            context=WorkflowContext(vellum_client=self._context.vellum_client),
+        )
+        subworkflow_stream = subworkflow.stream(
+            event_filter=all_workflow_event_filter,
+        )
+
+        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 event.name == "workflow.execution.streaming":
+                if event.output.is_fulfilled:
+                    fulfilled_output_names.add(event.output.name)
+                yield event.output
+            elif event.name == "workflow.execution.fulfilled":
+                outputs = event.outputs
+            elif event.name == "workflow.execution.paused":
+                exception = NodeException(
+                    code=WorkflowErrorCode.INVALID_OUTPUTS,
+                    message="Subworkflow unexpectedly paused within Try Node",
+                )
+            elif event.name == "workflow.execution.rejected":
+                if self.on_error_code and self.on_error_code != event.error.code:
+                    exception = NodeException(
+                        code=WorkflowErrorCode.INVALID_OUTPUTS,
+                        message=f"""Unexpected rejection: {event.error.code.value}.
+Message: {event.error.message}""",
+                    )
+                else:
+                    outputs = self.Outputs(error=event.error)
+
+        if exception:
+            raise exception
+
+        if outputs is None:
+            raise NodeException(
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+                message="Expected to receive outputs from Try Node's subworkflow",
+            )
+
+        # For any outputs somehow in our final fulfilled outputs array,
+        # but not fulfilled by the stream.
+        for descriptor, value in outputs:
+            if descriptor.name not in fulfilled_output_names:
+                yield BaseOutput(
+                    name=descriptor.name,
+                    value=value,
+                )
+
+    @classmethod
+    def wrap(cls, on_error_code: Optional[WorkflowErrorCode] = None) -> Callable[..., Type["TryNode"]]:
+        return create_adornment(cls, attributes={"on_error_code": on_error_code})
+
+    @classmethod
+    def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:
+        if reference.name == "error":
+            raise ValueError("`error` is a reserved name for TryNode.Outputs")
+
+        setattr(outputs_class, reference.name, reference)