vellum-ai 0.14.41__py3-none-any.whl → 1.11.2__py3-none-any.whl

vellum/workflows/nodes/bases/base.py

@@ -1,15 +1,36 @@
+from abc import ABC, ABCMeta, abstractmethod
+from collections.abc import Callable as CollectionsCallable
 from dataclasses import field
 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 uuid import UUID, uuid4
+from typing import (
+    Any,
+    Callable as TypingCallable,
+    Dict,
+    Generic,
+    Iterator,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    get_args,
+    get_origin,
+)
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import is_unresolved, resolve_value
 from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.events.node import NodeExecutionStreamingEvent
 from vellum.workflows.exceptions import NodeException
+from vellum.workflows.executable import BaseExecutable
+from vellum.workflows.expressions.accessor import AccessorExpression
 from vellum.workflows.graph import Graph
 from vellum.workflows.graph.graph import GraphTarget
 from vellum.workflows.inputs.base import BaseInputs
@@ -28,7 +49,7 @@ from vellum.workflows.types.utils import get_class_attr_names, get_original_base
 from vellum.workflows.utils.uuids import uuid4_from_hash
 
 
-def is_nested_class(nested: Any, parent: Type) -> bool:
+def _is_nested_class(nested: Any, parent: Type) -> bool:
     return (
         inspect.isclass(nested)
         # If a class is defined within a function, we don't consider it nested in the class defining that function
@@ -36,14 +57,22 @@ def is_nested_class(nested: Any, parent: Type) -> bool:
         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__))
-    ) or any(is_nested_class(nested, base) for base in parent.__bases__)
+    ) or any(_is_nested_class(nested, base) for base in parent.__bases__)
 
 
-class BaseNodeMeta(type):
-    def __new__(mcs, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
-        # TODO: Inherit the inner Output classes from every base class.
-        #   https://app.shortcut.com/vellum/story/4007/support-auto-inheriting-parent-node-outputs
+def _is_annotated(cls: Type, name: str) -> Any:
+    if name in cls.__annotations__:
+        return cls.__annotations__[name]
+
+    for base in cls.__bases__:
+        if annotation := _is_annotated(base, name):
+            return annotation
+
+    return None
+
 
+class BaseNodeMeta(ABCMeta):
+    def __new__(mcs, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
         if "Outputs" in dct:
             outputs_class = dct["Outputs"]
             if not any(issubclass(base, BaseOutputs) for base in outputs_class.__bases__):
@@ -83,7 +112,17 @@ class BaseNodeMeta(type):
                 if issubclass(base, BaseNode):
                     ports_dct = {p.name: Port(default=p.default) for p in base.Ports}
                     ports_dct["__module__"] = dct["__module__"]
-                    dct["Ports"] = type(f"{name}.Ports", (NodePorts,), ports_dct)
+                    dct["Ports"] = type(f"{name}.Ports", (base.Ports,), ports_dct)
+                    break
+
+        if "Display" not in dct:
+            for base in reversed(bases):
+                if issubclass(base, BaseNode):
+                    dct["Display"] = type(
+                        f"{name}.Display",
+                        (base.Display,),
+                        {"__module__": dct["__module__"]},
+                    )
                     break
 
         if "Execution" not in dct:
@@ -109,7 +148,7 @@ class BaseNodeMeta(type):
         cls = super().__new__(mcs, name, bases, dct)
         node_class = cast(Type["BaseNode"], cls)
 
-        node_class.Outputs._node_class = node_class
+        node_class.Outputs.__parent_class__ = node_class
 
         # Add cls to relevant nested classes, since python should've been doing this by default
         for port in node_class.Ports:
@@ -118,7 +157,10 @@ class BaseNodeMeta(type):
         node_class.Execution.node_class = node_class
         node_class.Trigger.node_class = node_class
         node_class.ExternalInputs.__parent_class__ = node_class
-        node_class.__id__ = uuid4_from_hash(node_class.__qualname__)
+
+        # Use new ID generation (module + qualname)
+        node_class.__id__ = uuid4_from_hash(f"{node_class.__module__}.{node_class.__qualname__}")
+
         node_class.__output_ids__ = {
             ref.name: uuid4_from_hash(f"{node_class.__id__}|{ref.name}")
             for ref in node_class.Outputs
@@ -133,12 +175,23 @@ class BaseNodeMeta(type):
         return {"BaseWorkflow": BaseWorkflow}
 
     def __getattribute__(cls, name: str) -> Any:
-        attribute = super().__getattribute__(name)
+        if name.startswith("_"):
+            return super().__getattribute__(name)
+
+        try:
+            attribute = super().__getattribute__(name)
+        except AttributeError as e:
+            annotation = _is_annotated(cls, name)
+            origin_annotation = get_origin(annotation)
+            if origin_annotation is not CollectionsCallable and origin_annotation is not TypingCallable:
+                attribute = undefined
+            else:
+                raise e
+
         if (
-            name.startswith("_")
-            or inspect.isfunction(attribute)
+            inspect.isfunction(attribute)
             or inspect.ismethod(attribute)
-            or is_nested_class(attribute, cls)
+            or _is_nested_class(attribute, cls)
             or isinstance(attribute, (property, cached_property))
             or not issubclass(cls, BaseNode)
         ):
@@ -194,6 +247,17 @@ class BaseNodeMeta(type):
                 yield attr_value
                 yielded_attr_names.add(attr_name)
 
+    @abstractmethod
+    def __validate__(cls) -> None:
+        """
+        Validates the node.
+        Subclasses can override this method to implement their specific validation logic.
+        Called during serialization or explicit validation.
+
+        Default implementation performs no validation.
+        """
+        pass
+
 
 class _BaseNodeTriggerMeta(type):
     def __eq__(self, other: Any) -> bool:
@@ -240,25 +304,28 @@ class _BaseNodeExecutionMeta(type):
 NodeRunResponse = Union[BaseOutputs, Iterator[BaseOutput]]
 
 
-class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
-    __id__: UUID = uuid4_from_hash(__qualname__)
-    __output_ids__: Dict[str, UUID] = {}
+class BaseNode(Generic[StateType], ABC, BaseExecutable, metaclass=BaseNodeMeta):
     state: StateType
     _context: WorkflowContext
-    _inputs: MappingProxyType[NodeReference, Any]
+    _inputs: MappingProxyType[Union[NodeReference, AccessorExpression], Any]
+
+    __exclude_from_monitoring__: bool = False
 
     class ExternalInputs(BaseInputs):
         __descriptor_class__ = ExternalInputReference
 
-    # TODO: Consider using metaclasses to prevent the need for users to specify that the
-    #   "Outputs" class inherits from "BaseOutputs" and do so automatically.
-    #   https://app.shortcut.com/vellum/story/4008/auto-inherit-basenodeoutputs-in-outputs-classes
     class Outputs(BaseOutputs):
-        _node_class: Type["BaseNode"] = field(init=False)
+        __parent_class__: Type["BaseNode"] = field(init=False)
 
     class Ports(NodePorts):
         default = Port(default=True)
 
+    class Display:
+        """Optional display metadata for visual representation."""
+
+        icon: Optional[str] = None
+        color: Optional[str] = None
+
     class Trigger(metaclass=_BaseNodeTriggerMeta):
         node_class: Type["BaseNode"]
         merge_behavior = MergeBehavior.AWAIT_ATTRIBUTES
@@ -282,7 +349,14 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
                     if not descriptor.instance:
                         continue
 
-                    resolved_value = resolve_value(descriptor.instance, state, path=descriptor.name)
+                    try:
+                        resolved_value = resolve_value(descriptor.instance, state, path=descriptor.name)
+                    except InvalidExpressionException as e:
+                        raise NodeException(
+                            message=str(e),
+                            code=WorkflowErrorCode.INVALID_INPUTS,
+                        ) from e
+
                     if is_unresolved(resolved_value):
                         return False
 
@@ -298,8 +372,15 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
                 """
                 # Check if all dependencies have invoked this node
                 dependencies_invoked = state.meta.node_execution_cache._dependencies_invoked.get(node_span_id, set())
-                all_deps_invoked = all(dep in dependencies_invoked for dep in dependencies)
-
+                node_classes_invoked = {
+                    state.meta.node_execution_cache.__node_execution_lookup__[dep]
+                    for dep in dependencies_invoked
+                    if dep in state.meta.node_execution_cache.__node_execution_lookup__
+                }
+                if len(node_classes_invoked) != len(dependencies):
+                    return False
+
+                all_deps_invoked = all(dep in node_classes_invoked for dep in dependencies)
                 return all_deps_invoked
 
             raise NodeException(
@@ -307,6 +388,88 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
                 code=WorkflowErrorCode.INVALID_INPUTS,
             )
 
+        @classmethod
+        def _queue_node_execution(
+            cls, state: StateType, dependencies: Set["Type[BaseNode]"], invoked_by: Optional[UUID] = None
+        ) -> UUID:
+            """
+            Queues a future execution of a node, returning the span id of the execution.
+
+            We may combine this into the should_initiate method, but we'll keep it separate for now to avoid
+            breaking changes until the 0.15.0 release.
+            """
+
+            execution_id = uuid4()
+            if not invoked_by:
+                return execution_id
+
+            if invoked_by not in state.meta.node_execution_cache.__node_execution_lookup__:
+                return execution_id
+
+            if cls.merge_behavior not in {MergeBehavior.AWAIT_ANY, MergeBehavior.AWAIT_ALL}:
+                # Keep track of the dependencies that have invoked this node
+                # This would be needed while climbing the history in the loop
+                state.meta.node_execution_cache._dependencies_invoked[execution_id].add(invoked_by)
+                return execution_id
+
+            # For AWAIT_ANY in workflows, we need to detect if the node is in a loop
+            # If the node is in a loop, we can trigger the node again
+            in_loop = False
+            if cls.merge_behavior == MergeBehavior.AWAIT_ANY:
+                # Get the latest fulfilled execution ID of current node
+                fulfilled_stack = state.meta.node_execution_cache._node_executions_fulfilled[cls.node_class]
+                current_latest_fulfilled_id = fulfilled_stack.peek() if not fulfilled_stack.is_empty() else None
+                # If the current node has not been fulfilled yet, we don't need to check for loop
+                if current_latest_fulfilled_id is not None:
+                    # Trace back through the dependency chain to detect if this node triggers itself
+                    visited = set()
+                    current_execution_id = invoked_by
+
+                    # Walk backwards through the dependency chain
+                    while current_execution_id and current_execution_id not in visited:
+                        visited.add(current_execution_id)
+
+                        # Get the dependencies that triggered this execution
+                        dependencies_for_current = state.meta.node_execution_cache._dependencies_invoked.get(
+                            current_execution_id, set()
+                        )
+
+                        # If we've reached the end of the chain, it means the node is not in a loop
+                        # we can break out of the loop
+                        if not dependencies_for_current:
+                            break
+
+                        # Move to the previous node in the dependency chain
+                        current_execution_id = next(iter(dependencies_for_current))
+
+                        current_node_class = state.meta.node_execution_cache.__node_execution_lookup__.get(
+                            current_execution_id
+                        )
+
+                        # If we've found our target node class in the chain
+                        if current_node_class == cls.node_class:
+                            # Check if the execution id is the same as the latest fulfilled execution id
+                            # If yes, we're in a loop
+                            if current_execution_id == current_latest_fulfilled_id:
+                                in_loop = True
+                            # If not, current node has been triggered by other node,
+                            # we can break out of the loop
+                            break
+
+            for queued_node_execution_id in state.meta.node_execution_cache._node_executions_queued[cls.node_class]:
+                if (
+                    invoked_by not in state.meta.node_execution_cache._dependencies_invoked[queued_node_execution_id]
+                    and not in_loop
+                ):
+                    state.meta.node_execution_cache._invoke_dependency(
+                        queued_node_execution_id, cls.node_class, invoked_by, dependencies
+                    )
+                    return queued_node_execution_id
+
+            state.meta.node_execution_cache._node_executions_queued[cls.node_class].append(execution_id)
+            state.meta.node_execution_cache._invoke_dependency(execution_id, cls.node_class, invoked_by, dependencies)
+            return execution_id
+
     class Execution(metaclass=_BaseNodeExecutionMeta):
         node_class: Type["BaseNode"]
         count: int
@@ -316,6 +479,7 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
         *,
         state: Optional[StateType] = None,
         context: Optional[WorkflowContext] = None,
+        inputs: Optional[Dict[str, Any]] = None,
     ):
         if state:
             self.state = state
@@ -336,37 +500,42 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
             self.state = state_type()
 
         self._context = context or WorkflowContext()
-        inputs: Dict[str, Any] = {}
+        inputs_memo: Dict[str, Any] = inputs.copy() if inputs else {}
+        if inputs:
+            for input_key, input_value in inputs.items():
+                path_parts = input_key.split(".")
+                dir_path = path_parts[:-1]
+                leaf = path_parts[-1]
+                base: Any = self.__class__
+
+                for attr_name in dir_path:
+                    if hasattr(base, attr_name):
+                        base = getattr(base, attr_name)
+                    elif isinstance(base, dict) and attr_name in base:
+                        base = base[attr_name]
+                    else:
+                        break
+
+                if isinstance(base, dict):
+                    base[leaf] = input_value
+                else:
+                    setattr(base, leaf, input_value)
+
         for descriptor in self.__class__:
-            if not descriptor.instance:
+            if descriptor.instance is undefined:
+                setattr(self, descriptor.name, undefined)
                 continue
 
             if any(isinstance(t, type) and issubclass(t, BaseDescriptor) for t in descriptor.types):
                 # We don't want to resolve attributes that are _meant_ to be descriptors
                 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_memo)
             setattr(self, descriptor.name, resolved_value)
 
-        # Resolve descriptors set as defaults to the outputs class
-        def _outputs_post_init(outputs_self: "BaseNode.Outputs", **kwargs: Any) -> None:
-            for node_output_descriptor in self.Outputs:
-                if node_output_descriptor.name in kwargs:
-                    continue
-
-                if isinstance(node_output_descriptor.instance, BaseDescriptor):
-                    setattr(
-                        outputs_self,
-                        node_output_descriptor.name,
-                        node_output_descriptor.instance.resolve(self.state),
-                    )
-            delattr(self.Outputs, "_outputs_post_init")
-
-        setattr(self.Outputs, "_outputs_post_init", _outputs_post_init)
-
         # We only want to store the attributes that were actually set as inputs, not every attribute that exists.
         all_inputs = {}
-        for key, value in inputs.items():
+        for key, value in inputs_memo.items():
             path_parts = key.split(".")
             node_attribute_descriptor = getattr(self.__class__, path_parts[0])
             inputs_key = reduce(lambda acc, part: acc[part], path_parts[1:], node_attribute_descriptor)
@@ -377,5 +546,28 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
     def run(self) -> NodeRunResponse:
         return self.Outputs()
 
+    def __cancel__(self, message: str) -> None:
+        """
+        Called when the node should be cancelled. Override this method to propagate
+        cancellation to nested workflows or other resources.
+
+        Args:
+            message: The error message describing why the node is being cancelled
+        """
+        pass
+
     def __repr__(self) -> str:
         return str(self.__class__)
+
+    __simulates_workflow_output__ = False
+
+    def __directly_emit_workflow_output__(
+        self, event: NodeExecutionStreamingEvent, workflow_output_descriptor: OutputReference
+    ) -> bool:
+        """
+        In the legacy workflow runner, there was support for emitting streaming workflow outputs for prompt nodes
+        connected to terminal nodes. These two private methods provides a hacky, intentionally short-lived workaround
+        for us to enable this until we can directly reference prompt outputs from the UI.
+        """
+
+        return False

vellum/workflows/nodes/bases/base_adornment_node.py

@@ -1,8 +1,12 @@
-from typing import TYPE_CHECKING, Any, Dict, Generic, Optional, Tuple, Type
+from abc import ABC
+from uuid import UUID
+from typing import TYPE_CHECKING, Any, Dict, Generic, Optional, Set, Tuple, Type
 
+from vellum.workflows.inputs.base import BaseInputs
 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.core import MergeBehavior
 from vellum.workflows.types.generics import StateType
 
 if TYPE_CHECKING:
@@ -13,6 +17,14 @@ class _BaseAdornmentNodeMeta(BaseNodeMeta):
     def __new__(cls, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
         node_class = super().__new__(cls, name, bases, dct)
 
+        SubworkflowInputs = dct.get("SubworkflowInputs")
+        if (
+            isinstance(SubworkflowInputs, type)
+            and issubclass(SubworkflowInputs, BaseInputs)
+            and SubworkflowInputs.__parent_class__ is type(None)
+        ):
+            SubworkflowInputs.__parent_class__ = node_class
+
         subworkflow_attribute = dct.get("subworkflow")
         if not subworkflow_attribute:
             return node_class
@@ -58,6 +70,7 @@ class _BaseAdornmentNodeMeta(BaseNodeMeta):
 class BaseAdornmentNode(
     BaseNode[StateType],
     Generic[StateType],
+    ABC,
     metaclass=_BaseAdornmentNodeMeta,
 ):
     """
@@ -68,6 +81,56 @@ class BaseAdornmentNode(
     __wrapped_node__: Optional[Type["BaseNode"]] = None
     subworkflow: Type["BaseWorkflow"]
 
+    class Trigger(BaseNode.Trigger):
+        """
+        Trigger class for adornment nodes that delegates to the wrapped node's Trigger
+        for proper merge behavior handling.
+        """
+
+        @classmethod
+        def should_initiate(
+            cls,
+            state: StateType,
+            dependencies: Set["Type[BaseNode]"],
+            node_span_id: UUID,
+        ) -> bool:
+            """
+            Delegates to the wrapped node's Trigger.should_initiate method to ensure
+            proper merge behavior (like AWAIT_ALL) is respected for initiation logic.
+            """
+            # Get the wrapped node's Trigger class
+            wrapped_node = cls.node_class.__wrapped_node__
+            if wrapped_node is not None:
+                wrapped_trigger = wrapped_node.Trigger
+                # Only delegate if the wrapped node has a specific merge behavior
+                # that differs from the default AWAIT_ATTRIBUTES
+                if (
+                    hasattr(wrapped_trigger, "merge_behavior")
+                    and wrapped_trigger.merge_behavior != MergeBehavior.AWAIT_ATTRIBUTES
+                ):
+                    return wrapped_trigger.should_initiate(state, dependencies, node_span_id)
+
+            # Fallback to the base implementation if no wrapped node
+            return super().should_initiate(state, dependencies, node_span_id)
+
+        @classmethod
+        def _queue_node_execution(
+            cls, state: StateType, dependencies: set[Type[BaseNode]], invoked_by: Optional[UUID] = None
+        ) -> UUID:
+            """
+            Delegates to the wrapped node's Trigger._queue_node_execution method to ensure
+            proper merge behavior (like AWAIT_ALL) is respected for dependency tracking.
+            """
+            # Get the wrapped node's Trigger class
+            wrapped_node = cls.node_class.__wrapped_node__
+            if wrapped_node is not None:
+                wrapped_trigger = wrapped_node.Trigger
+                # Delegate to the wrapped node's trigger logic for queuing
+                return wrapped_trigger._queue_node_execution(state, dependencies, invoked_by)
+
+            # Fallback to the base implementation if no wrapped node
+            return super()._queue_node_execution(state, dependencies, invoked_by)
+
     @classmethod
     def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:
         # Subclasses of BaseAdornableNode can override this method to provider their own

vellum/workflows/nodes/bases/tests/test_base_adornment_node.py

@@ -0,0 +1,31 @@
+from typing import Callable, Type
+
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
+from vellum.workflows.nodes.utils import create_adornment
+
+
+def test_base_adornment_node__output_references_of_same_name():
+    # GIVEN a custom adornment node
+    class CustomAdornmentNode(BaseAdornmentNode):
+        @classmethod
+        def wrap(cls) -> Callable[..., Type["CustomAdornmentNode"]]:
+            return create_adornment(cls)
+
+    # AND two nodes wrapped by the adornment with the same output
+    @CustomAdornmentNode.wrap()
+    class AppleNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            fruit: str
+
+    @CustomAdornmentNode.wrap()
+    class OrangeNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            fruit: str
+
+    # WHEN get output references of these outputs
+    apple_output_reference = AppleNode.Outputs.fruit
+    orange_output_reference = OrangeNode.Outputs.fruit
+
+    # THEN the output references should not be equal
+    assert apple_output_reference != orange_output_reference, "Output references should not be equal"

vellum/workflows/nodes/bases/tests/test_base_node.py

@@ -1,15 +1,18 @@
 import pytest
 from uuid import UUID
-from typing import Optional
+from typing import Optional, Set
 
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.string_vellum_value_request import StringVellumValueRequest
-from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.tests.test_utils import FixtureState
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes import FinalOutputNode
 from vellum.workflows.nodes.bases.base import BaseNode
-from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
+from vellum.workflows.ports.port import Port
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.references.node import NodeReference
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.base import BaseState, StateMeta
 
@@ -141,7 +144,7 @@ def test_base_node__default_id():
     my_id = MyNode.__id__
 
     # THEN it should equal the hash of `test_base_node__default_id.<locals>.MyNode`
-    assert my_id == UUID("8e71bea7-ce68-492f-9abe-477c788e6273")
+    assert my_id == UUID("3207dd3d-b26f-4476-969f-37697683f850")
 
 
 def test_base_node__node_resolution__descriptor_in_fern_pydantic():
@@ -283,3 +286,96 @@ def test_node_outputs__inherits_instance():
     assert foo_output.instance is undefined
     assert isinstance(bar_output, OutputReference)
     assert bar_output.instance == "hello"
+
+
+def test_base_node__iterate_over_attributes__preserves_order():
+    # GIVEN a node with two attributes
+    class MyNode(BaseNode):
+        foo = "foo"
+        bar = "bar"
+
+    # AND a node that inherits from MyNode
+    class InheritedNode(MyNode):
+        baz = "baz"
+        qux = "qux"
+        quux = "quux"
+
+    # WHEN we iterate over the attributes, multiple times
+    for i in range(10):
+        attribute_names = [attr.name for attr in InheritedNode]
+
+        # THEN the attributes are in the correct order
+        assert attribute_names == ["baz", "qux", "quux", "foo", "bar"], f"Iteration {i} failed"
+
+
+def test_base_node__node_reference_of_annotation():
+    # GIVEN a node with an annotated attribute
+    class MyNode(BaseNode):
+        foo: str
+
+    # WHEN we reference the attribute
+    node_reference = MyNode.foo
+
+    # THEN the node reference is of the correct type
+    assert isinstance(node_reference, NodeReference)
+    assert node_reference.name == "foo"
+
+
+def test_base_node__node_reference_of_inherited_annotation():
+    # GIVEN a node with an annotated attribute
+    class MyNode(BaseNode):
+        foo: str
+
+    class InheritedNode(MyNode):
+        bar: str
+
+    # WHEN we reference the attribute
+    node_reference = InheritedNode.foo
+
+    # THEN the node reference is of the correct type
+    assert isinstance(node_reference, NodeReference)
+    assert node_reference.name == "foo"
+
+
+def test_base_node__ports_inheritance():
+    # GIVEN a node with one port
+    class MyNode(BaseNode):
+        class Ports(BaseNode.Ports):
+            foo = Port.on_if(ConstantValueReference(True))
+
+            def __lt__(self, output: BaseOutput) -> Set[Port]:
+                return {self.foo}
+
+    # AND a node that inherits from MyNode
+    class InheritedNode(MyNode):
+        pass
+
+    # WHEN we collect the ports
+    ports = [port.name for port in InheritedNode.Ports]
+
+    # THEN the inheritance is correct
+    inherited_ports = InheritedNode.Ports()
+    assert inherited_ports.__lt__(BaseOutput(name="foo")) == {InheritedNode.Ports.foo}
+
+    # AND the ports are correct
+    assert ports == ["foo"]
+
+
+def test_base_node__ports_inheritance__cumulative_ports():
+    # GIVEN a node with one port
+    class MyNode(BaseNode):
+        class Ports(BaseNode.Ports):
+            foo = Port.on_if(ConstantValueReference(True))
+
+    # AND a node that inherits from MyNode with another port
+    class InheritedNode(MyNode):
+        class Ports(MyNode.Ports):
+            bar = Port.on_if(ConstantValueReference(True))
+
+    # WHEN we collect the ports
+    ports = [port.name for port in InheritedNode.Ports]
+
+    # THEN the ports are correct
+    # Potentially in the future, we support inheriting ports from multiple parents.
+    # For now, we take only the declared ports, so that not all nodes have the default port.
+    assert ports == ["bar"]