vellum-ai 0.10.8__py3-none-any.whl → 0.10.9__py3-none-any.whl

vellum/client/core/client_wrapper.py

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

vellum/client/types/logical_operator.py

@@ -24,6 +24,8 @@ LogicalOperator = typing.Union[
         "notBetween",
         "blank",
         "notBlank",
+        "coalesce",
+        "accessField",
     ],
     typing.Any,
 ]

vellum/workflows/descriptors/utils.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, Optional, Sequence, Set, TypeVar, Union, cast, ove
 
 from pydantic import BaseModel
 
+from vellum.workflows.constants import UNDEF
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.state.base import BaseState
 
@@ -88,3 +89,29 @@ def resolve_value(
         return cast(_T, set_value)
 
     return value
+
+
+def is_unresolved(value: Any) -> bool:
+    """
+    Recursively checks if a value has an unresolved value, represented by UNDEF.
+    """
+
+    if value is UNDEF:
+        return True
+
+    if dataclasses.is_dataclass(value):
+        return any(is_unresolved(getattr(value, field.name)) for field in dataclasses.fields(value))
+
+    if isinstance(value, BaseModel):
+        return any(is_unresolved(getattr(value, key)) for key in value.model_fields.keys())
+
+    if isinstance(value, Mapping):
+        return any(is_unresolved(item) for item in value.values())
+
+    if isinstance(value, Sequence):
+        return any(is_unresolved(item) for item in value)
+
+    if isinstance(value, Set):
+        return any(is_unresolved(item) for item in value)
+
+    return False

vellum/workflows/events/__init__.py

@@ -5,7 +5,6 @@ from .node import (
     NodeExecutionRejectedEvent,
     NodeExecutionStreamingEvent,
 )
-from .types import WorkflowEventType
 from .workflow import (
     WorkflowEvent,
     WorkflowEventStream,
@@ -27,5 +26,4 @@ __all__ = [
     "WorkflowExecutionStreamingEvent",
     "WorkflowEvent",
     "WorkflowEventStream",
-    "WorkflowEventType",
 ]

vellum/workflows/events/tests/test_event.py

@@ -100,7 +100,8 @@ module_root = name_parts[: name_parts.index("events")]
                     node_definition=MockNode,
                     span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
                     parent=WorkflowParentContext(
-                        workflow_definition=MockWorkflow, span_id=UUID("123e4567-e89b-12d3-a456-426614174000")
+                        workflow_definition=MockWorkflow,
+                        span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
                     ),
                 ),
             ),

vellum/workflows/events/types.py

@@ -2,23 +2,14 @@ from datetime import datetime
 from enum import Enum
 import json
 from uuid import UUID, uuid4
-from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Type, Union
+from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
-from pydantic import Field, field_serializer
+from pydantic import BeforeValidator, Field
 
 from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types.utils import datetime_now
 
-if TYPE_CHECKING:
-    from vellum.workflows.nodes.bases.base import BaseNode
-    from vellum.workflows.workflows.base import BaseWorkflow
-
-
-class WorkflowEventType(Enum):
-    NODE = "NODE"
-    WORKFLOW = "WORKFLOW"
-
 
 def default_datetime_factory() -> datetime:
     """
@@ -47,9 +38,25 @@ def default_serializer(obj: Any) -> Any:
     )
 
 
+class CodeResourceDefinition(UniversalBaseModel):
+    name: str
+    module: List[str]
+
+    @staticmethod
+    def encode(obj: type) -> "CodeResourceDefinition":
+        return CodeResourceDefinition(**serialize_type_encoder(obj))
+
+
+VellumCodeResourceDefinition = Annotated[
+    CodeResourceDefinition,
+    BeforeValidator(lambda d: (d if type(d) is dict else serialize_type_encoder(d))),
+]
+
+
 class BaseParentContext(UniversalBaseModel):
     span_id: UUID
-    parent: Optional['ParentContext'] = None
+    parent: Optional["ParentContext"] = None
+    type: str
 
 
 class BaseDeploymentParentContext(BaseParentContext):
@@ -73,29 +80,28 @@ class PromptDeploymentParentContext(BaseDeploymentParentContext):
 
 class NodeParentContext(BaseParentContext):
     type: Literal["WORKFLOW_NODE"] = "WORKFLOW_NODE"
-    node_definition: Type['BaseNode']
-
-    @field_serializer("node_definition")
-    def serialize_node_definition(self, definition: Type, _info: Any) -> Dict[str, Any]:
-        return serialize_type_encoder(definition)
+    node_definition: VellumCodeResourceDefinition
 
 
 class WorkflowParentContext(BaseParentContext):
     type: Literal["WORKFLOW"] = "WORKFLOW"
-    workflow_definition: Type['BaseWorkflow']
-
-    @field_serializer("workflow_definition")
-    def serialize_workflow_definition(self, definition: Type, _info: Any) -> Dict[str, Any]:
-        return serialize_type_encoder(definition)
-
-
-ParentContext = Union[
-    NodeParentContext,
-    WorkflowParentContext,
-    PromptDeploymentParentContext,
-    WorkflowDeploymentParentContext,
+    workflow_definition: VellumCodeResourceDefinition
+
+
+# Define the discriminated union
+ParentContext = Annotated[
+    Union[
+        WorkflowParentContext,
+        NodeParentContext,
+        WorkflowDeploymentParentContext,
+        PromptDeploymentParentContext,
+    ],
+    Field(discriminator="type"),
 ]
 
+# Update the forward references
+BaseParentContext.model_rebuild()
+
 
 class BaseEvent(UniversalBaseModel):
     id: UUID = Field(default_factory=uuid4)

vellum/workflows/events/workflow.py

@@ -3,7 +3,6 @@ from typing import TYPE_CHECKING, Any, Dict, Generator, Generic, Iterable, Liter
 from pydantic import field_serializer
 
 from vellum.core.pydantic_utilities import UniversalBaseModel
-
 from vellum.workflows.errors import VellumError
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.references import ExternalInputReference
@@ -31,6 +30,14 @@ class _BaseWorkflowExecutionBody(UniversalBaseModel):
         return serialize_type_encoder(workflow_definition)
 
 
+class _BaseWorkflowEvent(BaseEvent):
+    body: _BaseWorkflowExecutionBody
+
+    @property
+    def workflow_definition(self) -> Type["BaseWorkflow"]:
+        return self.body.workflow_definition
+
+
 class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[WorkflowInputsType]):
     inputs: WorkflowInputsType
 
@@ -39,7 +46,7 @@ class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[Workflo
         return default_serializer(inputs)
 
 
-class WorkflowExecutionInitiatedEvent(BaseEvent, Generic[WorkflowInputsType]):
+class WorkflowExecutionInitiatedEvent(_BaseWorkflowEvent, Generic[WorkflowInputsType]):
     name: Literal["workflow.execution.initiated"] = "workflow.execution.initiated"
     body: WorkflowExecutionInitiatedBody[WorkflowInputsType]
 
@@ -56,7 +63,7 @@ class WorkflowExecutionStreamingBody(_BaseWorkflowExecutionBody):
         return default_serializer(output)
 
 
-class WorkflowExecutionStreamingEvent(BaseEvent):
+class WorkflowExecutionStreamingEvent(_BaseWorkflowEvent):
     name: Literal["workflow.execution.streaming"] = "workflow.execution.streaming"
     body: WorkflowExecutionStreamingBody
 
@@ -73,7 +80,7 @@ class WorkflowExecutionFulfilledBody(_BaseWorkflowExecutionBody, Generic[Outputs
         return default_serializer(outputs)
 
 
-class WorkflowExecutionFulfilledEvent(BaseEvent, Generic[OutputsType]):
+class WorkflowExecutionFulfilledEvent(_BaseWorkflowEvent, Generic[OutputsType]):
     name: Literal["workflow.execution.fulfilled"] = "workflow.execution.fulfilled"
     body: WorkflowExecutionFulfilledBody[OutputsType]
 
@@ -86,7 +93,7 @@ class WorkflowExecutionRejectedBody(_BaseWorkflowExecutionBody):
     error: VellumError
 
 
-class WorkflowExecutionRejectedEvent(BaseEvent):
+class WorkflowExecutionRejectedEvent(_BaseWorkflowEvent):
     name: Literal["workflow.execution.rejected"] = "workflow.execution.rejected"
     body: WorkflowExecutionRejectedBody
 
@@ -99,7 +106,7 @@ class WorkflowExecutionPausedBody(_BaseWorkflowExecutionBody):
     external_inputs: Iterable[ExternalInputReference]
 
 
-class WorkflowExecutionPausedEvent(BaseEvent):
+class WorkflowExecutionPausedEvent(_BaseWorkflowEvent):
     name: Literal["workflow.execution.paused"] = "workflow.execution.paused"
     body: WorkflowExecutionPausedBody
 
@@ -112,7 +119,7 @@ class WorkflowExecutionResumedBody(_BaseWorkflowExecutionBody):
     pass
 
 
-class WorkflowExecutionResumedEvent(BaseEvent):
+class WorkflowExecutionResumedEvent(_BaseWorkflowEvent):
     name: Literal["workflow.execution.resumed"] = "workflow.execution.resumed"
     body: WorkflowExecutionResumedBody
 

vellum/workflows/nodes/bases/base.py

@@ -1,13 +1,15 @@
 from functools import cached_property, reduce
 import inspect
 from types import MappingProxyType
+from uuid import UUID
 from typing import Any, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, Union, cast, get_args
 
 from vellum.workflows.constants import UNDEF
 from vellum.workflows.descriptors.base import BaseDescriptor
-from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.descriptors.utils import is_unresolved, resolve_value
 from vellum.workflows.edges.edge import Edge
 from vellum.workflows.errors.types import VellumErrorCode
+from vellum.workflows.events.types import ParentContext
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.graph import Graph
 from vellum.workflows.graph.graph import GraphTarget
@@ -30,9 +32,15 @@ def is_nested_class(nested: Any, parent: Type) -> bool:
         inspect.isclass(nested)
         # If a class is defined within a function, we don't consider it nested in the class defining that function
         # The example of this is a Subworkflow defined within TryNode.wrap()
-        and (len(nested.__qualname__.split(".")) < 2 or nested.__qualname__.split(".")[-2] != "<locals>")
+        and (
+            len(nested.__qualname__.split(".")) < 2
+            or nested.__qualname__.split(".")[-2] != "<locals>"
+        )
         and nested.__module__ == parent.__module__
-        and (nested.__qualname__.startswith(parent.__name__) or nested.__qualname__.startswith(parent.__qualname__))
+        and (
+            nested.__qualname__.startswith(parent.__name__)
+            or nested.__qualname__.startswith(parent.__qualname__)
+        )
     ) or any(is_nested_class(nested, base) for base in parent.__bases__)
 
 
@@ -44,7 +52,11 @@ class BaseNodeMeta(type):
         if "Outputs" not in dct:
             for base in reversed(bases):
                 if hasattr(base, "Outputs"):
-                    dct["Outputs"] = type(f"{name}.Outputs", (base.Outputs,), {"__module__": dct["__module__"]})
+                    dct["Outputs"] = type(
+                        f"{name}.Outputs",
+                        (base.Outputs,),
+                        {"__module__": dct["__module__"]},
+                    )
                     break
             else:
                 raise ValueError("Outputs class not found in base classes")
@@ -66,14 +78,23 @@ class BaseNodeMeta(type):
         if "Execution" not in dct:
             for base in reversed(bases):
                 if issubclass(base, BaseNode):
-                    dct["Execution"] = type(f"{name}.Execution", (base.Execution,), {"__module__": dct["__module__"]})
+                    dct["Execution"] = type(
+                        f"{name}.Execution",
+                        (base.Execution,),
+                        {"__module__": dct["__module__"]},
+                    )
                     break
 
         if "Trigger" not in dct:
             for base in reversed(bases):
                 if issubclass(base, BaseNode):
-                    trigger_dct = {**base.Trigger.__dict__, "__module__": dct["__module__"]}
-                    dct["Trigger"] = type(f"{name}.Trigger", (base.Trigger,), trigger_dct)
+                    trigger_dct = {
+                        **base.Trigger.__dict__,
+                        "__module__": dct["__module__"],
+                    }
+                    dct["Trigger"] = type(
+                        f"{name}.Trigger", (base.Trigger,), trigger_dct
+                    )
                     break
 
         cls = super().__new__(mcs, name, bases, dct)
@@ -118,7 +139,9 @@ class BaseNodeMeta(type):
 
     def __rshift__(cls, other_cls: GraphTarget) -> Graph:
         if not issubclass(cls, BaseNode):
-            raise ValueError("BaseNodeMeta can only be extended from subclasses of BaseNode")
+            raise ValueError(
+                "BaseNodeMeta can only be extended from subclasses of BaseNode"
+            )
 
         if not cls.Ports._default_port:
             raise ValueError("No default port found on node")
@@ -130,7 +153,9 @@ class BaseNodeMeta(type):
 
     def __rrshift__(cls, other_cls: GraphTarget) -> Graph:
         if not issubclass(cls, BaseNode):
-            raise ValueError("BaseNodeMeta can only be extended from subclasses of BaseNode")
+            raise ValueError(
+                "BaseNodeMeta can only be extended from subclasses of BaseNode"
+            )
 
         if not isinstance(other_cls, set):
             other_cls = {other_cls}
@@ -168,13 +193,18 @@ class _BaseNodeTriggerMeta(type):
         if not isinstance(other, _BaseNodeTriggerMeta):
             return False
 
-        if not self.__name__.endswith(".Trigger") or not other.__name__.endswith(".Trigger"):
+        if not self.__name__.endswith(".Trigger") or not other.__name__.endswith(
+            ".Trigger"
+        ):
             return super().__eq__(other)
 
         self_trigger_class = cast(Type["BaseNode.Trigger"], self)
         other_trigger_class = cast(Type["BaseNode.Trigger"], other)
 
-        return self_trigger_class.node_class.__name__ == other_trigger_class.node_class.__name__
+        return (
+            self_trigger_class.node_class.__name__
+            == other_trigger_class.node_class.__name__
+        )
 
 
 class _BaseNodeExecutionMeta(type):
@@ -192,13 +222,18 @@ class _BaseNodeExecutionMeta(type):
         if not isinstance(other, _BaseNodeExecutionMeta):
             return False
 
-        if not self.__name__.endswith(".Execution") or not other.__name__.endswith(".Execution"):
+        if not self.__name__.endswith(".Execution") or not other.__name__.endswith(
+            ".Execution"
+        ):
             return super().__eq__(other)
 
         self_execution_class = cast(Type["BaseNode.Execution"], self)
         other_execution_class = cast(Type["BaseNode.Execution"], other)
 
-        return self_execution_class.node_class.__name__ == other_execution_class.node_class.__name__
+        return (
+            self_execution_class.node_class.__name__
+            == other_execution_class.node_class.__name__
+        )
 
 
 class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
@@ -225,55 +260,78 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
 
         @classmethod
         def should_initiate(
-            cls, state: StateType, dependencies: Set["Type[BaseNode]"], invoked_by: "Optional[Edge]" = None
+            cls,
+            state: StateType,
+            dependencies: Set["Type[BaseNode]"],
+            node_span_id: UUID,
         ) -> bool:
             """
             Determines whether a Node's execution should be initiated. Override this method to define custom
             trigger criteria.
             """
 
-            if cls.merge_behavior == MergeBehavior.AWAIT_ANY:
-                if not invoked_by:
-                    return True
-
-                is_ready = not state.meta.node_execution_cache.is_node_initiated(cls.node_class)
+            if cls.merge_behavior == MergeBehavior.AWAIT_ATTRIBUTES:
+                if state.meta.node_execution_cache.is_node_execution_initiated(
+                    cls.node_class, node_span_id
+                ):
+                    return False
 
-                invoked_identifier = str(invoked_by.from_port.node_class)
-                node_identifier = str(cls.node_class)
+                is_ready = True
+                for descriptor in cls.node_class:
+                    if not descriptor.instance:
+                        continue
 
-                dependencies_invoked = state.meta.node_execution_cache.dependencies_invoked[node_identifier]
-                dependencies_invoked.add(invoked_identifier)
-                if all(str(dep) in dependencies_invoked for dep in dependencies):
-                    del state.meta.node_execution_cache.dependencies_invoked[node_identifier]
+                    resolved_value = resolve_value(
+                        descriptor.instance, state, path=descriptor.name
+                    )
+                    if is_unresolved(resolved_value):
+                        is_ready = False
+                        break
 
                 return is_ready
 
-            if cls.merge_behavior == MergeBehavior.AWAIT_ALL:
-                if not invoked_by:
-                    return True
+            if cls.merge_behavior == MergeBehavior.AWAIT_ANY:
+                if state.meta.node_execution_cache.is_node_execution_initiated(
+                    cls.node_class, node_span_id
+                ):
+                    return False
+
+                return True
 
-                if state.meta.node_execution_cache.is_node_initiated(cls.node_class):
+            if cls.merge_behavior == MergeBehavior.AWAIT_ALL:
+                if state.meta.node_execution_cache.is_node_execution_initiated(
+                    cls.node_class, node_span_id
+                ):
                     return False
 
                 """
                 A node utilizing an AWAIT_ALL merge strategy will only be considered ready for the Nth time
                 when all of its dependencies have been executed N times.
                 """
-                current_node_execution_count = state.meta.node_execution_cache.get_execution_count(cls.node_class)
-                is_ready_outcome = all(
-                    state.meta.node_execution_cache.get_execution_count(dep) == current_node_execution_count + 1
+                current_node_execution_count = (
+                    state.meta.node_execution_cache.get_execution_count(cls.node_class)
+                )
+                return all(
+                    state.meta.node_execution_cache.get_execution_count(dep)
+                    == current_node_execution_count + 1
                     for dep in dependencies
                 )
 
-                return is_ready_outcome
-
-            raise NodeException(message="Invalid Trigger Node Specification", code=VellumErrorCode.INVALID_INPUTS)
+            raise NodeException(
+                message="Invalid Trigger Node Specification",
+                code=VellumErrorCode.INVALID_INPUTS,
+            )
 
     class Execution(metaclass=_BaseNodeExecutionMeta):
         node_class: Type["BaseNode"]
         count: int
 
-    def __init__(self, *, state: Optional[StateType] = None, context: Optional[WorkflowContext] = None):
+    def __init__(
+        self,
+        *,
+        state: Optional[StateType] = None,
+        context: Optional[WorkflowContext] = None,
+    ):
         if state:
             self.state = state
         else:
@@ -295,7 +353,9 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
             if not descriptor.instance:
                 continue
 
-            resolved_value = resolve_value(descriptor.instance, self.state, path=descriptor.name, memo=inputs)
+            resolved_value = resolve_value(
+                descriptor.instance, self.state, path=descriptor.name, memo=inputs
+            )
             setattr(self, descriptor.name, resolved_value)
 
         # Resolve descriptors set as defaults to the outputs class
@@ -319,7 +379,9 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
         for key, value in inputs.items():
             path_parts = key.split(".")
             node_attribute_discriptor = getattr(self.__class__, path_parts[0])
-            inputs_key = reduce(lambda acc, part: acc[part], path_parts[1:], node_attribute_discriptor)
+            inputs_key = reduce(
+                lambda acc, part: acc[part], path_parts[1:], node_attribute_discriptor
+            )
             all_inputs[inputs_key] = value
 
         self._inputs = MappingProxyType(all_inputs)

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

@@ -1,5 +1,5 @@
 import sys
-from types import ModuleType
+from types import MappingProxyType, ModuleType
 from typing import TYPE_CHECKING, Any, Callable, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, cast
 
 from vellum.workflows.errors.types import VellumError, VellumErrorCode
@@ -8,7 +8,9 @@ from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
 from vellum.workflows.nodes.utils import ADORNMENT_MODULE_NAME
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
+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
 
 if TYPE_CHECKING:
     from vellum.workflows import BaseWorkflow
@@ -44,6 +46,14 @@ class _TryNodeMeta(BaseNodeMeta):
 
         return node_class
 
+    def __getattribute__(cls, name: str) -> Any:
+        try:
+            return super().__getattribute__(name)
+        except AttributeError:
+            if name != "__wrapped_node__" and issubclass(cls, TryNode):
+                return getattr(cls.__wrapped_node__, name)
+            raise
+
 
 class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
     """
@@ -53,6 +63,7 @@ class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
     subworkflow: Type["BaseWorkflow"] - The Subworkflow to execute
     """
 
+    __wrapped_node__: Optional[Type["BaseNode"]] = None
     on_error_code: Optional[VellumErrorCode] = None
     subworkflow: Type["BaseWorkflow"]
 
@@ -62,15 +73,20 @@ class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
     def run(self) -> Iterator[BaseOutput]:
         subworkflow = self.subworkflow(
             parent_state=self.state,
-            context=self._context,
+            context=WorkflowContext(
+                _vellum_client=self._context._vellum_client,
+            ),
+        )
+        subworkflow_stream = subworkflow.stream(
+            event_filter=all_workflow_event_filter,
         )
-        subworkflow_stream = subworkflow.stream()
 
         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
 
@@ -122,8 +138,9 @@ Message: {event.error.message}""",
             # https://app.shortcut.com/vellum/story/4116
             from vellum.workflows import BaseWorkflow
 
+            inner_cls._is_wrapped_node = True
+
             class Subworkflow(BaseWorkflow):
-                inner_cls._is_wrapped_node = True
                 graph = inner_cls
 
                 # mypy is wrong here, this works and is defined
@@ -139,6 +156,7 @@ Message: {event.error.message}""",
                 cls.__name__,
                 (TryNode,),
                 {
+                    "__wrapped_node__": inner_cls,
                     "__module__": dynamic_module,
                     "on_error_code": _on_error_code,
                     "subworkflow": Subworkflow,

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

@@ -111,3 +111,18 @@ def test_try_node__use_parent_execution_context():
     # THEN the inner node had access to the key
     assert len(outputs) == 1
     assert outputs[-1] == BaseOutput(name="key", value="test-key")
+
+
+def test_try_node__resolved_inputs():
+    """
+    This test ensures that node attributes of TryNodes are correctly resolved.
+    """
+
+    class State(BaseState):
+        counter = 3.0
+
+    @TryNode.wrap()
+    class MyNode(BaseNode[State]):
+        foo = State.counter
+
+    assert MyNode.foo.types == (float,)