vellum-ai 0.11.10__py3-none-any.whl → 0.12.0__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.11.10",
+            "X-Fern-SDK-Version": "0.12.0",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/workflows/descriptors/base.py

@@ -258,12 +258,12 @@ class BaseDescriptor(Generic[_T]):
 
         return DoesNotEndWithExpression(lhs=self, rhs=other)
 
-    def is_none(self) -> "IsNullExpression":
+    def is_null(self) -> "IsNullExpression":
         from vellum.workflows.expressions.is_null import IsNullExpression
 
         return IsNullExpression(expression=self)
 
-    def is_not_none(self) -> "IsNotNullExpression":
+    def is_not_null(self) -> "IsNotNullExpression":
         from vellum.workflows.expressions.is_not_null import IsNotNullExpression
 
         return IsNotNullExpression(expression=self)

vellum/workflows/descriptors/tests/test_utils.py

@@ -35,8 +35,8 @@ class FixtureState(BaseState):
         (FixtureState.gamma.does_not_contain(FixtureState.delta), False),
         (FixtureState.gamma.does_not_begin_with(FixtureState.delta), True),
         (FixtureState.gamma.does_not_end_with(FixtureState.delta), True),
-        (FixtureState.alpha.is_none(), False),
-        (FixtureState.alpha.is_not_none(), True),
+        (FixtureState.alpha.is_null(), False),
+        (FixtureState.alpha.is_not_null(), True),
         (FixtureState.delta.in_(FixtureState.gamma), True),
         (FixtureState.delta.not_in(FixtureState.gamma), False),
         (FixtureState.alpha.between(FixtureState.beta, FixtureState.epsilon), False),
@@ -66,8 +66,8 @@ class FixtureState(BaseState):
         "does_not_contain",
         "does_not_begin_with",
         "does_not_end_with",
-        "is_none",
-        "is_not_none",
+        "is_null",
+        "is_not_null",
         "in_",
         "not_in",
         "between",

vellum/workflows/errors/__init__.py

@@ -1,6 +1,6 @@
-from .types import VellumError, VellumErrorCode
+from .types import WorkflowError, WorkflowErrorCode
 
 __all__ = [
-    "VellumError",
-    "VellumErrorCode",
+    "WorkflowError",
+    "WorkflowErrorCode",
 ]

vellum/workflows/errors/types.py

@@ -1,20 +1,63 @@
 from dataclasses import dataclass
 from enum import Enum
+from typing import Dict
 
+from vellum.client.types.vellum_error import VellumError
+from vellum.client.types.vellum_error_code_enum import VellumErrorCodeEnum
+from vellum.client.types.workflow_event_error import WorkflowEventError
+from vellum.client.types.workflow_execution_event_error_code import WorkflowExecutionEventErrorCode
 
-class VellumErrorCode(Enum):
+
+class WorkflowErrorCode(Enum):
     INVALID_WORKFLOW = "INVALID_WORKFLOW"
     INVALID_INPUTS = "INVALID_INPUTS"
     INVALID_OUTPUTS = "INVALID_OUTPUTS"
     INVALID_STATE = "INVALID_STATE"
     INVALID_TEMPLATE = "INVALID_TEMPLATE"
     INTERNAL_ERROR = "INTERNAL_ERROR"
+    NODE_EXECUTION = "NODE_EXECUTION"
     PROVIDER_ERROR = "PROVIDER_ERROR"
     USER_DEFINED_ERROR = "USER_DEFINED_ERROR"
     WORKFLOW_CANCELLED = "WORKFLOW_CANCELLED"
 
 
 @dataclass(frozen=True)
-class VellumError:
+class WorkflowError:
     message: str
-    code: VellumErrorCode
+    code: WorkflowErrorCode
+
+
+_VELLUM_ERROR_CODE_TO_WORKFLOW_ERROR_CODE: Dict[VellumErrorCodeEnum, WorkflowErrorCode] = {
+    "INVALID_REQUEST": WorkflowErrorCode.INVALID_INPUTS,
+    "INVALID_INPUTS": WorkflowErrorCode.INVALID_INPUTS,
+    "PROVIDER_ERROR": WorkflowErrorCode.PROVIDER_ERROR,
+    "REQUEST_TIMEOUT": WorkflowErrorCode.PROVIDER_ERROR,
+    "INTERNAL_SERVER_ERROR": WorkflowErrorCode.INTERNAL_ERROR,
+    "USER_DEFINED_ERROR": WorkflowErrorCode.USER_DEFINED_ERROR,
+}
+
+
+def vellum_error_to_workflow_error(error: VellumError) -> WorkflowError:
+    return WorkflowError(
+        message=error.message,
+        code=_VELLUM_ERROR_CODE_TO_WORKFLOW_ERROR_CODE.get(error.code, WorkflowErrorCode.INTERNAL_ERROR),
+    )
+
+
+_WORKFLOW_EVENT_ERROR_CODE_TO_WORKFLOW_ERROR_CODE: Dict[WorkflowExecutionEventErrorCode, WorkflowErrorCode] = {
+    "WORKFLOW_INITIALIZATION": WorkflowErrorCode.INVALID_WORKFLOW,
+    "WORKFLOW_CANCELLED": WorkflowErrorCode.WORKFLOW_CANCELLED,
+    "NODE_EXECUTION_COUNT_LIMIT_REACHED": WorkflowErrorCode.INVALID_STATE,
+    "INTERNAL_SERVER_ERROR": WorkflowErrorCode.INTERNAL_ERROR,
+    "NODE_EXECUTION": WorkflowErrorCode.NODE_EXECUTION,
+    "LLM_PROVIDER": WorkflowErrorCode.PROVIDER_ERROR,
+    "INVALID_TEMPLATE": WorkflowErrorCode.INVALID_TEMPLATE,
+    "USER_DEFINED_ERROR": WorkflowErrorCode.USER_DEFINED_ERROR,
+}
+
+
+def workflow_event_error_to_workflow_error(error: WorkflowEventError) -> WorkflowError:
+    return WorkflowError(
+        message=error.message,
+        code=_WORKFLOW_EVENT_ERROR_CODE_TO_WORKFLOW_ERROR_CODE.get(error.code, WorkflowErrorCode.INTERNAL_ERROR),
+    )

vellum/workflows/events/node.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, Any, Dict, Generic, List, Literal, Optional, S
 from pydantic import SerializerFunctionWrapHandler, field_serializer, model_serializer
 
 from vellum.core.pydantic_utilities import UniversalBaseModel
-from vellum.workflows.errors import VellumError
+from vellum.workflows.errors import WorkflowError
 from vellum.workflows.expressions.accessor import AccessorExpression
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.ports.port import Port
@@ -119,7 +119,7 @@ class NodeExecutionFulfilledEvent(_BaseNodeEvent, Generic[OutputsType]):
 
 
 class NodeExecutionRejectedBody(_BaseNodeExecutionBody):
-    error: VellumError
+    error: WorkflowError
 
 
 class NodeExecutionRejectedEvent(_BaseNodeEvent):
@@ -127,7 +127,7 @@ class NodeExecutionRejectedEvent(_BaseNodeEvent):
     body: NodeExecutionRejectedBody
 
     @property
-    def error(self) -> VellumError:
+    def error(self) -> WorkflowError:
         return self.body.error
 
 

vellum/workflows/events/tests/test_event.py

@@ -4,7 +4,7 @@ from uuid import UUID
 
 from deepdiff import DeepDiff
 
-from vellum.workflows.errors.types import VellumError, VellumErrorCode
+from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
 from vellum.workflows.events.node import (
     NodeExecutionFulfilledBody,
     NodeExecutionFulfilledEvent,
@@ -213,9 +213,9 @@ module_root = name_parts[: name_parts.index("events")]
                 span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
                 body=WorkflowExecutionRejectedBody(
                     workflow_definition=MockWorkflow,
-                    error=VellumError(
+                    error=WorkflowError(
                         message="Workflow failed",
-                        code=VellumErrorCode.USER_DEFINED_ERROR,
+                        code=WorkflowErrorCode.USER_DEFINED_ERROR,
                     ),
                 ),
             ),

vellum/workflows/events/workflow.py

@@ -3,7 +3,7 @@ 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.errors import WorkflowError
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.references import ExternalInputReference
 from vellum.workflows.types.generics import OutputsType, StateType, WorkflowInputsType
@@ -90,7 +90,7 @@ class WorkflowExecutionFulfilledEvent(_BaseWorkflowEvent, Generic[OutputsType]):
 
 
 class WorkflowExecutionRejectedBody(_BaseWorkflowExecutionBody):
-    error: VellumError
+    error: WorkflowError
 
 
 class WorkflowExecutionRejectedEvent(_BaseWorkflowEvent):
@@ -98,7 +98,7 @@ class WorkflowExecutionRejectedEvent(_BaseWorkflowEvent):
     body: WorkflowExecutionRejectedBody
 
     @property
-    def error(self) -> VellumError:
+    def error(self) -> WorkflowError:
         return self.body.error
 
 

vellum/workflows/exceptions.py

@@ -1,15 +1,19 @@
-from vellum.workflows.errors import VellumError, VellumErrorCode
+from vellum.workflows.errors import WorkflowError, WorkflowErrorCode
 
 
 class NodeException(Exception):
-    def __init__(self, message: str, code: VellumErrorCode):
+    def __init__(self, message: str, code: WorkflowErrorCode):
         self.message = message
         self.code = code
         super().__init__(message)
 
     @property
-    def error(self) -> VellumError:
-        return VellumError(
+    def error(self) -> WorkflowError:
+        return WorkflowError(
             message=self.message,
             code=self.code,
         )
+
+    @staticmethod
+    def of(workflow_error: WorkflowError) -> "NodeException":
+        return NodeException(message=workflow_error.message, code=workflow_error.code)

vellum/workflows/nodes/bases/base.py

@@ -7,7 +7,7 @@ from typing import Any, Dict, Generic, Iterator, Optional, Set, Tuple, Type, Typ
 from vellum.workflows.constants import UNDEF
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import is_unresolved, resolve_value
-from vellum.workflows.errors.types import VellumErrorCode
+from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.graph import Graph
 from vellum.workflows.graph.graph import GraphTarget
@@ -23,6 +23,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
 
 
 def is_nested_class(nested: Any, parent: Type) -> bool:
@@ -99,6 +100,7 @@ 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__)
         return node_class
 
     @property
@@ -213,6 +215,7 @@ class _BaseNodeExecutionMeta(type):
 
 
 class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
+    __id__: UUID = uuid4_from_hash(__qualname__)
     state: StateType
     _context: WorkflowContext
     _inputs: MappingProxyType[NodeReference, Any]
@@ -284,7 +287,7 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
 
             raise NodeException(
                 message="Invalid Trigger Node Specification",
-                code=VellumErrorCode.INVALID_INPUTS,
+                code=WorkflowErrorCode.INVALID_INPUTS,
             )
 
     class Execution(metaclass=_BaseNodeExecutionMeta):
@@ -352,3 +355,7 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
 
     def __repr__(self) -> str:
         return str(self.__class__)
+
+
+class MyNode2(BaseNode):
+    pass

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

@@ -1,3 +1,4 @@
+from uuid import UUID
 from typing import Optional
 
 from vellum.core.pydantic_utilities import UniversalBaseModel
@@ -122,3 +123,15 @@ def test_base_node__node_resolution__coalesce_constants():
 
     # THEN the node is initialized with the correct data
     assert node.value == "world"
+
+
+def test_base_node__default_id():
+    # GIVEN a node
+    class MyNode(BaseNode):
+        pass
+
+    # WHEN the node is accessed
+    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")

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

@@ -1,6 +1,7 @@
 from typing import ClassVar, Union
 
-from vellum.workflows.errors.types import VellumError, VellumErrorCode
+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
 
@@ -12,15 +13,18 @@ class ErrorNode(BaseNode):
     error: Union[str, VellumError] - The error to raise.
     """
 
-    error: ClassVar[Union[str, VellumError]]
+    error: ClassVar[Union[str, WorkflowError, VellumError]]
 
     def run(self) -> BaseNode.Outputs:
         if isinstance(self.error, str):
-            raise NodeException(message=self.error, code=VellumErrorCode.USER_DEFINED_ERROR)
-        elif isinstance(self.error, VellumError):
+            raise NodeException(message=self.error, code=WorkflowErrorCode.USER_DEFINED_ERROR)
+        elif isinstance(self.error, WorkflowError):
             raise NodeException(message=self.error.message, code=self.error.code)
+        elif isinstance(self.error, VellumError):
+            workflow_error = vellum_error_to_workflow_error(self.error)
+            raise NodeException(message=workflow_error.message, code=workflow_error.code)
         else:
             raise NodeException(
                 message=f"Error node received an unexpected input type: {self.error.__class__}",
-                code=VellumErrorCode.INVALID_INPUTS,
+                code=WorkflowErrorCode.INVALID_INPUTS,
             )

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

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING, Generic, Iterator, Optional, Set, Type, TypeVar
 
 from vellum.workflows.context import execution_context, get_parent_context
-from vellum.workflows.errors.types import VellumErrorCode
+from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases.base_subworkflow_node import BaseSubworkflowNode
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
@@ -49,22 +49,12 @@ class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, W
             elif event.name == "workflow.execution.fulfilled":
                 outputs = event.outputs
             elif event.name == "workflow.execution.rejected":
-                error = event.error
-                if error.code in VellumErrorCode._value2member_map_:
-                    raise NodeException(
-                        message=error.message,
-                        code=VellumErrorCode(error.code),
-                    )
-                else:
-                    raise NodeException(
-                        message=error.message,
-                        code=VellumErrorCode.INTERNAL_ERROR,
-                    )
+                raise NodeException.of(event.error)
 
         if outputs is None:
             raise NodeException(
                 message="Expected to receive outputs from Workflow Deployment",
-                code=VellumErrorCode.INVALID_OUTPUTS,
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
             )
 
         # For any outputs somehow in our final fulfilled outputs array,

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

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Callable, Dict, Generic, List, Optional, Tuple
 
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.descriptors.base import BaseDescriptor
-from vellum.workflows.errors.types import VellumErrorCode
+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
@@ -88,7 +88,7 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
                         break
                 elif terminal_event.name == "workflow.execution.paused":
                     raise NodeException(
-                        code=VellumErrorCode.INVALID_OUTPUTS,
+                        code=WorkflowErrorCode.INVALID_OUTPUTS,
                         message=f"Subworkflow unexpectedly paused on iteration {index}",
                     )
                 elif terminal_event.name == "workflow.execution.rejected":

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

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Any, Callable, Dict, Generic, Optional, Type
 
-from vellum.workflows.errors.types import VellumErrorCode
+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
@@ -31,7 +31,7 @@ class RetryNode(BaseNode[StateType], Generic[StateType], metaclass=_RetryNodeMet
     """
 
     max_attempts: int
-    retry_on_error_code: Optional[VellumErrorCode] = None
+    retry_on_error_code: Optional[WorkflowErrorCode] = None
     subworkflow: Type["BaseWorkflow[SubworkflowInputs, BaseState]"]
 
     class SubworkflowInputs(BaseInputs):
@@ -58,13 +58,13 @@ class RetryNode(BaseNode[StateType], Generic[StateType], metaclass=_RetryNodeMet
                 return node_outputs
             elif terminal_event.name == "workflow.execution.paused":
                 last_exception = NodeException(
-                    code=VellumErrorCode.INVALID_OUTPUTS,
+                    code=WorkflowErrorCode.INVALID_OUTPUTS,
                     message=f"Subworkflow unexpectedly paused on attempt {attempt_number}",
                 )
                 break
             elif self.retry_on_error_code and self.retry_on_error_code != terminal_event.error.code:
                 last_exception = NodeException(
-                    code=VellumErrorCode.INVALID_OUTPUTS,
+                    code=WorkflowErrorCode.INVALID_OUTPUTS,
                     message=f"""Unexpected rejection on attempt {attempt_number}: {terminal_event.error.code.value}.
 Message: {terminal_event.error.message}""",
                 )
@@ -76,7 +76,7 @@ Message: {terminal_event.error.message}""",
 
     @classmethod
     def wrap(
-        cls, max_attempts: int, retry_on_error_code: Optional[VellumErrorCode] = None
+        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

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

@@ -1,6 +1,6 @@
 import pytest
 
-from vellum.workflows.errors.types import VellumErrorCode
+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
@@ -11,7 +11,7 @@ from vellum.workflows.state.base import BaseState, StateMeta
 
 def test_retry_node__retry_on_error_code__successfully_retried():
     # GIVEN a retry node that is configured to retry on PROVIDER_ERROR
-    @RetryNode.wrap(max_attempts=3, retry_on_error_code=VellumErrorCode.PROVIDER_ERROR)
+    @RetryNode.wrap(max_attempts=3, retry_on_error_code=WorkflowErrorCode.PROVIDER_ERROR)
     class TestNode(BaseNode):
         attempt_number = RetryNode.SubworkflowInputs.attempt_number
 
@@ -20,7 +20,7 @@ def test_retry_node__retry_on_error_code__successfully_retried():
 
         def run(self) -> Outputs:
             if self.attempt_number < 3:
-                raise NodeException(message="This will be retried", code=VellumErrorCode.PROVIDER_ERROR)
+                raise NodeException(message="This will be retried", code=WorkflowErrorCode.PROVIDER_ERROR)
 
             return self.Outputs(execution_count=self.attempt_number)
 
@@ -34,7 +34,7 @@ def test_retry_node__retry_on_error_code__successfully_retried():
 
 def test_retry_node__retry_on_error_code__missed():
     # GIVEN a retry node that is configured to retry on PROVIDER_ERROR
-    @RetryNode.wrap(max_attempts=3, retry_on_error_code=VellumErrorCode.PROVIDER_ERROR)
+    @RetryNode.wrap(max_attempts=3, retry_on_error_code=WorkflowErrorCode.PROVIDER_ERROR)
     class TestNode(BaseNode):
         attempt_number = RetryNode.SubworkflowInputs.attempt_number
 
@@ -57,7 +57,7 @@ def test_retry_node__retry_on_error_code__missed():
         exc_info.value.message
         == "Unexpected rejection on attempt 1: INTERNAL_ERROR.\nMessage: This will not be retried"
     )
-    assert exc_info.value.code == VellumErrorCode.INVALID_OUTPUTS
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_OUTPUTS
 
 
 def test_retry_node__use_parent_inputs_and_state():
@@ -69,7 +69,7 @@ def test_retry_node__use_parent_inputs_and_state():
         bar: str
 
     # AND a retry node that uses the parent's inputs and state
-    @RetryNode.wrap(max_attempts=3, retry_on_error_code=VellumErrorCode.PROVIDER_ERROR)
+    @RetryNode.wrap(max_attempts=3, retry_on_error_code=WorkflowErrorCode.PROVIDER_ERROR)
     class TestNode(BaseNode):
         foo = Inputs.foo
         bar = State.bar

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

@@ -10,7 +10,7 @@ import pydash
 import pytz
 import yaml
 
-from vellum.workflows.errors import VellumErrorCode
+from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
@@ -130,4 +130,4 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
                 jinja_globals=self.jinja_globals,
             )
         except JinjaTemplateError as e:
-            raise NodeException(message=str(e), code=VellumErrorCode.INVALID_TEMPLATE)
+            raise NodeException(message=str(e), code=WorkflowErrorCode.INVALID_TEMPLATE)

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

@@ -2,7 +2,7 @@ import sys
 from types import ModuleType
 from typing import TYPE_CHECKING, Any, Callable, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar
 
-from vellum.workflows.errors.types import VellumError, VellumErrorCode
+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 import BaseNodeMeta
@@ -64,11 +64,11 @@ class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
     """
 
     __wrapped_node__: Optional[Type["BaseNode"]] = None
-    on_error_code: Optional[VellumErrorCode] = None
+    on_error_code: Optional[WorkflowErrorCode] = None
     subworkflow: Type["BaseWorkflow"]
 
     class Outputs(BaseNode.Outputs):
-        error: Optional[VellumError] = None
+        error: Optional[WorkflowError] = None
 
     def run(self) -> Iterator[BaseOutput]:
         subworkflow = self.subworkflow(
@@ -98,13 +98,13 @@ class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
                 outputs = event.outputs
             elif event.name == "workflow.execution.paused":
                 exception = NodeException(
-                    code=VellumErrorCode.INVALID_OUTPUTS,
+                    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=VellumErrorCode.INVALID_OUTPUTS,
+                        code=WorkflowErrorCode.INVALID_OUTPUTS,
                         message=f"""Unexpected rejection: {event.error.code.value}.
 Message: {event.error.message}""",
                     )
@@ -116,7 +116,7 @@ Message: {event.error.message}""",
 
         if outputs is None:
             raise NodeException(
-                code=VellumErrorCode.INVALID_OUTPUTS,
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
                 message="Expected to receive outputs from Try Node's subworkflow",
             )
 
@@ -130,7 +130,7 @@ Message: {event.error.message}""",
                 )
 
     @classmethod
-    def wrap(cls, on_error_code: Optional[VellumErrorCode] = None) -> Callable[..., Type["TryNode"]]:
+    def wrap(cls, on_error_code: Optional[WorkflowErrorCode] = None) -> Callable[..., Type["TryNode"]]:
         _on_error_code = on_error_code
 
         def decorator(inner_cls: Type[BaseNode]) -> Type["TryNode"]:

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

@@ -1,7 +1,7 @@
 import pytest
 
 from vellum.client import Vellum
-from vellum.workflows.errors.types import VellumError, VellumErrorCode
+from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
@@ -14,13 +14,13 @@ from vellum.workflows.state.context import WorkflowContext
 
 def test_try_node__on_error_code__successfully_caught():
     # GIVEN a try node that is configured to catch PROVIDER_ERROR
-    @TryNode.wrap(on_error_code=VellumErrorCode.PROVIDER_ERROR)
+    @TryNode.wrap(on_error_code=WorkflowErrorCode.PROVIDER_ERROR)
     class TestNode(BaseNode):
         class Outputs(BaseOutputs):
             value: int
 
         def run(self) -> Outputs:
-            raise NodeException(message="This will be caught", code=VellumErrorCode.PROVIDER_ERROR)
+            raise NodeException(message="This will be caught", code=WorkflowErrorCode.PROVIDER_ERROR)
 
     # WHEN the node is run and throws a PROVIDER_ERROR
     node = TestNode(state=BaseState())
@@ -30,19 +30,21 @@ def test_try_node__on_error_code__successfully_caught():
     assert len(outputs) == 2
     assert set(outputs) == {
         BaseOutput(name="value"),
-        BaseOutput(name="error", value=VellumError(message="This will be caught", code=VellumErrorCode.PROVIDER_ERROR)),
+        BaseOutput(
+            name="error", value=WorkflowError(message="This will be caught", code=WorkflowErrorCode.PROVIDER_ERROR)
+        ),
     }
 
 
 def test_try_node__retry_on_error_code__missed():
     # GIVEN a try node that is configured to catch PROVIDER_ERROR
-    @TryNode.wrap(on_error_code=VellumErrorCode.PROVIDER_ERROR)
+    @TryNode.wrap(on_error_code=WorkflowErrorCode.PROVIDER_ERROR)
     class TestNode(BaseNode):
         class Outputs(BaseOutputs):
             value: int
 
         def run(self) -> Outputs:
-            raise NodeException(message="This will be missed", code=VellumErrorCode.INTERNAL_ERROR)
+            raise NodeException(message="This will be missed", code=WorkflowErrorCode.INTERNAL_ERROR)
 
     # WHEN the node is run and throws a different exception
     node = TestNode(state=BaseState())
@@ -51,7 +53,7 @@ def test_try_node__retry_on_error_code__missed():
 
     # THEN the exception is not caught
     assert exc_info.value.message == "Unexpected rejection: INTERNAL_ERROR.\nMessage: This will be missed"
-    assert exc_info.value.code == VellumErrorCode.INVALID_OUTPUTS
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_OUTPUTS
 
 
 def test_try_node__use_parent_inputs_and_state():

vellum/workflows/nodes/displayable/bases/api_node/node.py

@@ -4,7 +4,7 @@ from requests import Request, RequestException, Session
 from requests.exceptions import JSONDecodeError
 
 from vellum.workflows.constants import APIRequestMethod
-from vellum.workflows.errors.types import VellumErrorCode
+from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs import BaseOutputs
@@ -49,13 +49,13 @@ class BaseAPINode(BaseNode, Generic[StateType]):
         try:
             prepped = Request(method=method.value, url=url, data=data, json=json, headers=headers).prepare()
         except Exception as e:
-            raise NodeException(f"Failed to prepare HTTP request: {e}", code=VellumErrorCode.PROVIDER_ERROR)
+            raise NodeException(f"Failed to prepare HTTP request: {e}", code=WorkflowErrorCode.PROVIDER_ERROR)
 
         try:
             with Session() as session:
                 response = session.send(prepped)
         except RequestException as e:
-            raise NodeException(f"HTTP request failed: {e}", code=VellumErrorCode.PROVIDER_ERROR)
+            raise NodeException(f"HTTP request failed: {e}", code=WorkflowErrorCode.PROVIDER_ERROR)
 
         try:
             json = response.json()