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

vellum/workflows/nodes/bases/base.py

@@ -1,15 +1,36 @@
+from abc import ABC, ABCMeta
+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, uuid4
-from typing import Any, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, Union, cast, get_args
+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
@@ -25,7 +46,7 @@ from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.core import MergeBehavior
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_class_attr_names, get_original_base, infer_types
-from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum.workflows.utils.uuids import generate_entity_id_from_path, uuid4_from_hash
 
 
 def _is_nested_class(nested: Any, parent: Type) -> bool:
@@ -39,18 +60,18 @@ def _is_nested_class(nested: Any, parent: Type) -> bool:
     ) or any(_is_nested_class(nested, base) for base in parent.__bases__)
 
 
-def _is_annotated(cls: Type, name: str) -> bool:
+def _is_annotated(cls: Type, name: str) -> Any:
     if name in cls.__annotations__:
-        return True
+        return cls.__annotations__[name]
 
     for base in cls.__bases__:
-        if _is_annotated(base, name):
-            return True
+        if annotation := _is_annotated(base, name):
+            return annotation
 
-    return False
+    return None
 
 
-class BaseNodeMeta(type):
+class BaseNodeMeta(ABCMeta):
     def __new__(mcs, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
         if "Outputs" in dct:
             outputs_class = dct["Outputs"]
@@ -91,7 +112,31 @@ 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" in dct:
+            display_class = dct["Display"]
+            parent_display_class = next(
+                (base.Display for base in bases if hasattr(base, "Display")),
+                None,
+            )
+            # Ensure user-defined Display class inherits from parent's Display
+            if parent_display_class and not issubclass(display_class, parent_display_class):
+                filtered_bases = tuple(base for base in display_class.__bases__ if base is not object)
+                dct["Display"] = type(
+                    f"{name}.Display",
+                    (parent_display_class,) + filtered_bases,
+                    {**display_class.__dict__, "__module__": dct["__module__"]},
+                )
+        else:
+            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:
@@ -117,17 +162,20 @@ 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:
             port.node_class = node_class
-            port.validate()
 
         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)
+        # generate_entity_id_from_path normalizes the module path to filter out UUID namespace for stable ID generation
+        node_class.__id__ = generate_entity_id_from_path(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
@@ -148,8 +196,10 @@ class BaseNodeMeta(type):
         try:
             attribute = super().__getattribute__(name)
         except AttributeError as e:
-            if _is_annotated(cls, name):
-                attribute = None
+            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
 
@@ -258,25 +308,31 @@ 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
+        x: Optional[float] = None
+        y: Optional[float] = None
+        z_index: Optional[int] = None
+
     class Trigger(metaclass=_BaseNodeTriggerMeta):
         node_class: Type["BaseNode"]
         merge_behavior = MergeBehavior.AWAIT_ATTRIBUTES
@@ -300,7 +356,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
 
@@ -327,8 +390,11 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
                 all_deps_invoked = all(dep in node_classes_invoked for dep in dependencies)
                 return all_deps_invoked
 
+            if cls.merge_behavior == MergeBehavior.CUSTOM:
+                return False
+
             raise NodeException(
-                message="Invalid Trigger Node Specification",
+                message=f"Invalid Trigger Node Specification: {cls.merge_behavior}",
                 code=WorkflowErrorCode.INVALID_INPUTS,
             )
 
@@ -356,41 +422,15 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
                 state.meta.node_execution_cache._dependencies_invoked[execution_id].add(invoked_by)
                 return execution_id
 
-            # For AWAIT_ANY in workflows, we have two cases:
-            # 1. The node is being re-executed because of a fork
-            # 2. The node is being re-executed because of a loop
-            # For case 1, we need to remove the fork id from the node_to_fork_id mapping
-            # For case 2, we need to check if the node is in a loop
+            # 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
-            # Default to true, will be set to false if the merged node has already been triggered
-            should_retrigger = True
             if cls.merge_behavior == MergeBehavior.AWAIT_ANY:
-                # Get the node that triggered the current execution
-                invoked_by_node = state.meta.node_execution_cache.__node_execution_lookup__.get(invoked_by)
-
-                # Check if invoked by node is a forked node
-                if invoked_by_node is not None:
-                    fork_id = state.meta.node_execution_cache.__node_to_fork_id__.get(invoked_by_node, None)
-                    if fork_id:
-                        # If the invoked by node has a fork id and that fork id is in __all_fork_ids__
-                        #   We will
-                        #   1. remove the fork id from __all_fork_ids__
-                        #   2. remove the fork id from the __node_to_fork_id__ mapping
-                        # else (this mean the fork has already been triggered)
-                        #   remove the id from the node_to_fork_id mapping and not retrigger again
-                        all_fork_ids = state.meta.node_execution_cache.__all_fork_ids__
-                        if fork_id in all_fork_ids:
-                            # When the next forked node merge, it will not trigger the node again
-                            # We should consider adding a lock here to prevent race condition
-                            all_fork_ids.remove(fork_id)
-                            state.meta.node_execution_cache.__node_to_fork_id__.pop(invoked_by_node, None)
-                        else:
-                            should_retrigger = False
-                            state.meta.node_execution_cache.__node_to_fork_id__.pop(invoked_by_node, None)
-
-                # If should_retrigger is false, then we will not trigger the node already
-                # So we don't need to check loop behavior
-                if should_retrigger:
+                # 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
@@ -416,15 +456,18 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
                             current_execution_id
                         )
 
-                        # If we've found our target node class in the chain, we're in a loop
+                        # If we've found our target node class in the chain
                         if current_node_class == cls.node_class:
-                            in_loop = True
+                            # 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]:
-                # When should_retrigger is false, it means the merged node has already been triggered
-                # So we don't need to trigger the node again
-                if not should_retrigger or (
+                if (
                     invoked_by not in state.meta.node_execution_cache._dependencies_invoked[queued_node_execution_id]
                     and not in_loop
                 ):
@@ -446,6 +489,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
@@ -466,37 +510,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)
@@ -507,5 +556,39 @@ 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
+
+    @classmethod
+    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

vellum/workflows/nodes/bases/base_adornment_node.py

@@ -1,9 +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:
@@ -67,6 +70,7 @@ class _BaseAdornmentNodeMeta(BaseNodeMeta):
 class BaseAdornmentNode(
     BaseNode[StateType],
     Generic[StateType],
+    ABC,
     metaclass=_BaseAdornmentNodeMeta,
 ):
     """
@@ -77,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_node.py

@@ -1,18 +1,23 @@
 import pytest
 from uuid import UUID
-from typing import Optional
+from typing import Any, Dict, 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 import BaseWorkflow
 from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.tests.test_utils import FixtureState
+from vellum.workflows.errors.types import WorkflowErrorCode
 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
+from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 
 def test_base_node__node_resolution__unset_pydantic_fields():
@@ -142,7 +147,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():
@@ -333,3 +338,147 @@ def test_base_node__node_reference_of_inherited_annotation():
     # 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"]
+
+
+def test_base_node__trigger_should_initiate__invalid_merge_behavior():
+    """
+    Tests that an invalid merge behavior raises a NodeException with the invalid value in the error message.
+    """
+
+    # GIVEN a node with an invalid merge behavior
+    class InvalidMergeBehaviorNode(BaseNode):
+        class Trigger(BaseNode.Trigger):
+            merge_behavior = "INVALID_MERGE_BEHAVIOR"  # type: ignore[assignment]
+
+    # AND a workflow that uses the node
+    class InvalidMergeBehaviorWorkflow(BaseWorkflow):
+        graph = InvalidMergeBehaviorNode
+
+    # WHEN we stream the workflow
+    workflow = InvalidMergeBehaviorWorkflow()
+    events = list(workflow.stream(event_filter=all_workflow_event_filter))
+
+    # THEN the workflow should reject
+    workflow_rejected_event = events[-1]
+    assert workflow_rejected_event.name == "workflow.execution.rejected"
+
+    # AND the error should have the correct code
+    assert workflow_rejected_event.error.code == WorkflowErrorCode.INVALID_INPUTS
+
+    # AND the error message should contain the invalid merge behavior
+    assert "INVALID_MERGE_BEHAVIOR" in workflow_rejected_event.error.message
+
+
+def test_base_node__int_input_preserves_type_when_float_passed():
+    """
+    Tests that an int workflow input is correctly coerced to int when a float value is passed.
+    """
+
+    # GIVEN an Inputs class with an int field
+    class Inputs(BaseInputs):
+        total_requests: int
+
+    # AND a custom node that references the int input
+    class CustomNode(BaseNode):
+        total_requests = Inputs.total_requests
+
+        class Outputs(BaseOutputs):
+            result: int
+
+        def run(self) -> BaseOutputs:
+            # This should work without error - range() requires an int, not a float
+            result = len(range(self.total_requests))
+            return self.Outputs(result=result)
+
+    # AND a workflow that uses the custom node
+    class IntInputWorkflow(BaseWorkflow[Inputs, BaseState]):
+        graph = CustomNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = CustomNode.Outputs.result
+
+    # WHEN we run the workflow with a float value for an int input
+    # This simulates what happens when the API returns a NUMBER value as a float
+    workflow = IntInputWorkflow()
+    raw_inputs: Dict[str, Any] = {"total_requests": 5.0}
+    inputs = Inputs(**raw_inputs)
+
+    # THEN the input should be coerced to an integer at construction time
+    assert inputs.total_requests == 5
+    assert type(inputs.total_requests) is int
+
+    # AND the workflow should complete successfully
+    final_event = workflow.run(inputs=inputs)
+    assert final_event.name == "workflow.execution.fulfilled"
+
+    # AND the result should be correct
+    assert final_event.outputs.result == 5
+
+
+def test_base_node__bytes_output_raises_serialization_error():
+    """Test that returning bytes in node outputs rejects the workflow execution."""
+
+    class BytesOutputNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+        def run(self) -> "BytesOutputNode.Outputs":
+            b = b"hello"
+            return self.Outputs(result=b)  # type: ignore[arg-type]
+
+    class BytesWorkflow(BaseWorkflow):
+        graph = BytesOutputNode
+
+    workflow = BytesWorkflow()
+
+    # WHEN we run the workflow
+    result = workflow.run()
+
+    # THEN the execution is rejected with a helpful error
+    assert result.name == "workflow.execution.rejected"
+    assert result.error.code == WorkflowErrorCode.INVALID_OUTPUTS
+    assert "bytes" in result.error.message.lower()

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

@@ -1,20 +1,29 @@
-from typing import ClassVar, Union
+from typing import ClassVar, Generic, Union
 
 from vellum.client.types.vellum_error import VellumError
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode, vellum_error_to_workflow_error
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.ports import NodePorts
+from vellum.workflows.types.generics import StateType
 
 
-class ErrorNode(BaseNode):
+class ErrorNode(BaseNode[StateType], Generic[StateType]):
     """
     Used to raise an error to reject the surrounding Workflow.
 
     error: Union[str, VellumError] - The error to raise.
     """
 
+    class Display(BaseNode.Display):
+        icon = "vellum:icon:hexagon-exclamation"
+        color = "lipstick"
+
     error: ClassVar[Union[str, WorkflowError, VellumError]]
 
+    class Ports(NodePorts):
+        pass
+
     def run(self) -> BaseNode.Outputs:
         if isinstance(self.error, str):
             raise NodeException(message=self.error, code=WorkflowErrorCode.USER_DEFINED_ERROR)