vellum-ai 0.11.10__py3-none-any.whl → 0.12.1__py3-none-any.whl

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

@@ -3,7 +3,7 @@ from typing import ClassVar, Generator, Generic, Iterator, List, Optional, Union
 
 from vellum import AdHocExecutePromptEvent, ExecutePromptEvent, PromptOutput
 from vellum.core import RequestOptions
-from vellum.workflows.errors.types import VellumErrorCode
+from vellum.workflows.errors.types import WorkflowErrorCode, vellum_error_to_workflow_error
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
@@ -29,7 +29,7 @@ class BasePromptNode(BaseNode, Generic[StateType]):
         if outputs is None:
             raise NodeException(
                 message="Expected to receive outputs from Prompt",
-                code=VellumErrorCode.INTERNAL_ERROR,
+                code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
     def _process_prompt_event_stream(self) -> Generator[BaseOutput, None, Optional[List[PromptOutput]]]:
@@ -45,15 +45,7 @@ class BasePromptNode(BaseNode, Generic[StateType]):
                 outputs = event.outputs
                 yield BaseOutput(name="results", value=event.outputs)
             elif event.state == "REJECTED":
-                if event.error.code in VellumErrorCode._value2member_map_:
-                    raise NodeException(
-                        message=event.error.message,
-                        code=VellumErrorCode(event.error.code),
-                    )
-                else:
-                    raise NodeException(
-                        message=event.error.message,
-                        code=VellumErrorCode.INTERNAL_ERROR,
-                    )
+                workflow_error = vellum_error_to_workflow_error(event.error)
+                raise NodeException.of(workflow_error)
 
         return outputs

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

@@ -17,7 +17,7 @@ from vellum import (
 from vellum.client import RequestOptions
 from vellum.workflows.constants import OMIT
 from vellum.workflows.context import get_parent_context
-from vellum.workflows.errors import VellumErrorCode
+from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases.base_prompt_node import BasePromptNode
 from vellum.workflows.nodes.displayable.bases.inline_prompt_node.constants import DEFAULT_PROMPT_PARAMETERS
@@ -120,7 +120,7 @@ class BaseInlinePromptNode(BasePromptNode, Generic[StateType]):
             else:
                 raise NodeException(
                     message=f"Unrecognized input type for input '{input_name}': {input_value.__class__}",
-                    code=VellumErrorCode.INVALID_INPUTS,
+                    code=WorkflowErrorCode.INVALID_INPUTS,
                 )
 
         return input_variables, input_values

vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py

@@ -14,7 +14,7 @@ from vellum import (
 from vellum.client import RequestOptions
 from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT
 from vellum.workflows.context import get_parent_context
-from vellum.workflows.errors import VellumErrorCode
+from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases.base_prompt_node import BasePromptNode
 from vellum.workflows.types.generics import StateType
@@ -101,7 +101,7 @@ class BasePromptDeploymentNode(BasePromptNode, Generic[StateType]):
             else:
                 raise NodeException(
                     message=f"Unrecognized input type for input '{input_name}': {input_value.__class__}",
-                    code=VellumErrorCode.INVALID_INPUTS,
+                    code=WorkflowErrorCode.INVALID_INPUTS,
                 )
 
         return compiled_inputs

vellum/workflows/nodes/displayable/bases/search_node.py

@@ -12,7 +12,7 @@ from vellum import (
     SearchWeightsRequest,
 )
 from vellum.core import ApiError, RequestOptions
-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.outputs import BaseOutputs
@@ -83,12 +83,12 @@ class BaseSearchNode(BaseNode[StateType], Generic[StateType]):
         except NotFoundError:
             raise NodeException(
                 message=f"Document Index '{self.document_index}' not found",
-                code=VellumErrorCode.INVALID_INPUTS,
+                code=WorkflowErrorCode.INVALID_INPUTS,
             )
         except ApiError:
             raise NodeException(
                 message=f"An error occurred while searching against Document Index '{self.document_index}'",  # noqa: E501
-                code=VellumErrorCode.INTERNAL_ERROR,
+                code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
     def run(self) -> Outputs:

vellum/workflows/nodes/displayable/code_execution_node/node.py

@@ -20,7 +20,7 @@ from vellum import (
     VellumValue,
 )
 from vellum.core import RequestOptions
-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.nodes.bases.base import BaseNodeMeta
@@ -102,7 +102,7 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
 
         if code_execution.output.type != expected_output_type:
             raise NodeException(
-                code=VellumErrorCode.INVALID_OUTPUTS,
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
                 message=f"Expected an output of type '{expected_output_type}', received '{code_execution.output.type}'",
             )
 
@@ -185,7 +185,7 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
             else:
                 raise NodeException(
                     message=f"Unrecognized input type for input '{input_name}'",
-                    code=VellumErrorCode.INVALID_INPUTS,
+                    code=WorkflowErrorCode.INVALID_INPUTS,
                 )
 
         return compiled_inputs
@@ -194,7 +194,7 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
         if self.code and self.filepath:
             raise NodeException(
                 message="Cannot specify both `code` and `filepath` for a CodeExecutionNode",
-                code=VellumErrorCode.INVALID_INPUTS,
+                code=WorkflowErrorCode.INVALID_INPUTS,
             )
 
         if self.code:
@@ -203,7 +203,7 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
         if not self.filepath:
             raise NodeException(
                 message="Must specify either `code` or `filepath` for a CodeExecutionNode",
-                code=VellumErrorCode.INVALID_INPUTS,
+                code=WorkflowErrorCode.INVALID_INPUTS,
             )
 
         root = inspect.getfile(self.__class__)
@@ -211,7 +211,7 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
         if not code:
             raise NodeException(
                 message=f"Filepath '{self.filepath}' does not exist",
-                code=VellumErrorCode.INVALID_INPUTS,
+                code=WorkflowErrorCode.INVALID_INPUTS,
             )
 
         return code

vellum/workflows/nodes/displayable/guardrail_node/node.py

@@ -4,7 +4,7 @@ from typing import Any, ClassVar, Dict, Generic, List, Optional, Union, cast
 from vellum import ChatHistoryInput, ChatMessage, JsonInput, MetricDefinitionInput, NumberInput, StringInput
 from vellum.core import RequestOptions
 from vellum.workflows.constants import LATEST_RELEASE_TAG
-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.base import BaseOutputs
@@ -46,7 +46,7 @@ class GuardrailNode(BaseNode[StateType], Generic[StateType]):
         if not isinstance(score, float):
             raise NodeException(
                 message="Metric execution must have one output named 'score' with type 'float'",
-                code=VellumErrorCode.INVALID_OUTPUTS,
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
             )
 
         metric_outputs.pop("score")
@@ -90,7 +90,7 @@ class GuardrailNode(BaseNode[StateType], Generic[StateType]):
             else:
                 raise NodeException(
                     message=f"Unrecognized input type for input '{input_name}'",
-                    code=VellumErrorCode.INVALID_INPUTS,
+                    code=WorkflowErrorCode.INVALID_INPUTS,
                 )
 
         return compiled_inputs

vellum/workflows/nodes/displayable/inline_prompt_node/node.py

@@ -1,6 +1,6 @@
 from typing import Iterator
 
-from vellum.workflows.errors import VellumErrorCode
+from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases import BaseInlinePromptNode as BaseInlinePromptNode
 from vellum.workflows.outputs import BaseOutput
@@ -34,7 +34,7 @@ class InlinePromptNode(BaseInlinePromptNode[StateType]):
         if not outputs:
             raise NodeException(
                 message="Expected to receive outputs from Prompt",
-                code=VellumErrorCode.INTERNAL_ERROR,
+                code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
         string_output = next((output for output in outputs if output.type == "STRING"), None)
@@ -43,7 +43,7 @@ class InlinePromptNode(BaseInlinePromptNode[StateType]):
             is_plural = len(output_types) > 1
             raise NodeException(
                 message=f"Expected to receive a non-null string output from Prompt. Only found outputs of type{'s' if is_plural else ''}: {', '.join(output_types)}",  # noqa: E501
-                code=VellumErrorCode.INTERNAL_ERROR,
+                code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
         yield BaseOutput(name="text", value=string_output.value)

vellum/workflows/nodes/displayable/prompt_deployment_node/node.py

@@ -1,6 +1,6 @@
 from typing import Iterator
 
-from vellum.workflows.errors import VellumErrorCode
+from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases import BasePromptDeploymentNode as BasePromptDeploymentNode
 from vellum.workflows.outputs import BaseOutput
@@ -37,7 +37,7 @@ class PromptDeploymentNode(BasePromptDeploymentNode[StateType]):
         if not outputs:
             raise NodeException(
                 message="Expected to receive outputs from Prompt",
-                code=VellumErrorCode.INTERNAL_ERROR,
+                code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
         string_output = next((output for output in outputs if output.type == "STRING"), None)
@@ -46,7 +46,7 @@ class PromptDeploymentNode(BasePromptDeploymentNode[StateType]):
             is_plural = len(output_types) > 1
             raise NodeException(
                 message=f"Expected to receive a non-null string output from Prompt. Only found outputs of type{'s' if is_plural else ''}: {', '.join(output_types)}",  # noqa: E501
-                code=VellumErrorCode.INTERNAL_ERROR,
+                code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
         yield BaseOutput(name="text", value=string_output.value)

vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py

@@ -14,7 +14,8 @@ from vellum import (
 from vellum.core import RequestOptions
 from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT
 from vellum.workflows.context import get_parent_context
-from vellum.workflows.errors import VellumErrorCode
+from vellum.workflows.errors import WorkflowErrorCode
+from vellum.workflows.errors.types import workflow_event_error_to_workflow_error
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases.base_subworkflow_node.node import BaseSubworkflowNode
 from vellum.workflows.outputs.base import BaseOutput
@@ -84,7 +85,7 @@ class SubworkflowDeploymentNode(BaseSubworkflowNode[StateType], Generic[StateTyp
             else:
                 raise NodeException(
                     message=f"Unrecognized input type for input '{input_name}'",
-                    code=VellumErrorCode.INVALID_INPUTS,
+                    code=WorkflowErrorCode.INVALID_INPUTS,
                 )
 
         return compiled_inputs
@@ -136,23 +137,15 @@ class SubworkflowDeploymentNode(BaseSubworkflowNode[StateType], Generic[StateTyp
                 if not error:
                     raise NodeException(
                         message="Expected to receive an error from REJECTED event",
-                        code=VellumErrorCode.INTERNAL_ERROR,
-                    )
-                elif 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,
+                        code=WorkflowErrorCode.INTERNAL_ERROR,
                     )
+                workflow_error = workflow_event_error_to_workflow_error(error)
+                raise NodeException.of(workflow_error)
 
         if outputs is None:
             raise NodeException(
                 message="Expected to receive outputs from Workflow Deployment",
-                code=VellumErrorCode.INTERNAL_ERROR,
+                code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
         # For any outputs somehow in our final fulfilled outputs array,

vellum/workflows/nodes/displayable/tests/test_inline_text_prompt_node.py

@@ -11,8 +11,8 @@ from vellum import (
     StringVellumValue,
     VellumError,
 )
-from vellum.workflows.errors import VellumError as SdkVellumError
-from vellum.workflows.errors.types import VellumErrorCode
+from vellum.workflows.errors import WorkflowError as SdkVellumError
+from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes import InlinePromptNode
 from vellum.workflows.nodes.core.try_node.node import TryNode
@@ -104,7 +104,7 @@ def test_inline_text_prompt_node__catch_provider_error(vellum_adhoc_prompt_clien
     class State(BaseState):
         pass
 
-    @TryNode.wrap(on_error_code=VellumErrorCode.PROVIDER_ERROR)
+    @TryNode.wrap(on_error_code=WorkflowErrorCode.PROVIDER_ERROR)
     class MyInlinePromptNode(InlinePromptNode):
         ml_model = "gpt-4o"
         prompt_inputs = {}
@@ -143,7 +143,7 @@ def test_inline_text_prompt_node__catch_provider_error(vellum_adhoc_prompt_clien
             name="error",
             value=SdkVellumError(
                 message="OpenAI failed",
-                code=VellumErrorCode.PROVIDER_ERROR,
+                code=WorkflowErrorCode.PROVIDER_ERROR,
             ),
         )
         in outputs

vellum/workflows/nodes/utils.py

@@ -2,7 +2,6 @@ from functools import cache
 from typing import Type
 
 from vellum.workflows.nodes import BaseNode
-from vellum.workflows.references import NodeReference
 from vellum.workflows.types.generics import NodeType
 
 ADORNMENT_MODULE_NAME = "<adornment>"
@@ -10,20 +9,17 @@ ADORNMENT_MODULE_NAME = "<adornment>"
 
 @cache
 def get_wrapped_node(node: Type[NodeType]) -> Type[BaseNode]:
-    if hasattr(node, "subworkflow"):
-        subworkflow = node.subworkflow
-        if isinstance(subworkflow, NodeReference) and subworkflow.instance:
-            graph = subworkflow.instance.graph
-            if issubclass(graph, BaseNode):
-                return graph
+    wrapped_node = getattr(node, "__wrapped_node__", None)
+    if wrapped_node is None:
+        raise AttributeError("Wrapped node not found")
 
-    raise TypeError("Wrapped subworkflow contains more than one node")
+    return wrapped_node
 
 
 def has_wrapped_node(node: Type[NodeType]) -> bool:
     try:
         get_wrapped_node(node)
-    except TypeError:
+    except AttributeError:
         return False
 
     return True

vellum/workflows/references/external_input.py

@@ -5,7 +5,7 @@ from pydantic_core import core_schema
 
 from vellum.workflows.constants import UNDEF
 from vellum.workflows.descriptors.base import BaseDescriptor
-from vellum.workflows.errors.types import VellumErrorCode
+from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 
 if TYPE_CHECKING:
@@ -40,7 +40,7 @@ class ExternalInputReference(BaseDescriptor[_InputType], Generic[_InputType]):
         if state.meta.parent:
             return self.resolve(state.meta.parent)
 
-        raise NodeException(f"Missing required Node Input: {self._name}", code=VellumErrorCode.INVALID_INPUTS)
+        raise NodeException(f"Missing required Node Input: {self._name}", code=WorkflowErrorCode.INVALID_INPUTS)
 
     @classmethod
     def __get_pydantic_core_schema__(

vellum/workflows/references/node.py

@@ -4,7 +4,7 @@ from pydantic import GetCoreSchemaHandler
 from pydantic_core import core_schema
 
 from vellum.workflows.descriptors.base import BaseDescriptor
-from vellum.workflows.errors.types import VellumErrorCode
+from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 
 if TYPE_CHECKING:
@@ -30,7 +30,7 @@ class NodeReference(BaseDescriptor[_T]):
     def resolve(self, state: "BaseState") -> _T:
         raise NodeException(
             f"NodeDescriptors cannot be resolved during runtime. Got: {self._name}",
-            code=VellumErrorCode.INTERNAL_ERROR,
+            code=WorkflowErrorCode.INTERNAL_ERROR,
         )
 
     def __repr__(self) -> str:

vellum/workflows/references/state_value.py

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING, TypeVar, cast
 
 from vellum.workflows.descriptors.base import BaseDescriptor
-from vellum.workflows.errors.types import VellumErrorCode
+from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 
 if TYPE_CHECKING:
@@ -20,4 +20,4 @@ class StateValueReference(BaseDescriptor[_T]):
         if state.meta.parent:
             return self.resolve(state.meta.parent)
 
-        raise NodeException(f"Missing required Workflow state: {self._name}", code=VellumErrorCode.INVALID_STATE)
+        raise NodeException(f"Missing required Workflow state: {self._name}", code=WorkflowErrorCode.INVALID_STATE)

vellum/workflows/references/workflow_input.py

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING, Generic, Optional, Tuple, Type, TypeVar, cast
 
 from vellum.workflows.descriptors.base import BaseDescriptor
-from vellum.workflows.errors.types import VellumErrorCode
+from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 
 if TYPE_CHECKING:
@@ -35,7 +35,7 @@ class WorkflowInputReference(BaseDescriptor[_InputType], Generic[_InputType]):
         if state.meta.parent:
             return self.resolve(state.meta.parent)
 
-        raise NodeException(f"Missing required Workflow input: {self._name}", code=VellumErrorCode.INVALID_INPUTS)
+        raise NodeException(f"Missing required Workflow input: {self._name}", code=WorkflowErrorCode.INVALID_INPUTS)
 
     def __repr__(self) -> str:
         return f"{self._inputs_class.__qualname__}.{self.name}"

vellum/workflows/runner/runner.py

@@ -10,7 +10,7 @@ from vellum.workflows.constants import UNDEF
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.edges.edge import Edge
-from vellum.workflows.errors import VellumError, VellumErrorCode
+from vellum.workflows.errors import WorkflowError, WorkflowErrorCode
 from vellum.workflows.events import (
     NodeExecutionFulfilledEvent,
     NodeExecutionInitiatedEvent,
@@ -184,14 +184,14 @@ class WorkflowRunner(Generic[StateType]):
             if not isinstance(node_run_response, (BaseOutputs, Iterator)):
                 raise NodeException(
                     message=f"Node {node.__class__.__name__} did not return a valid node run response",
-                    code=VellumErrorCode.INVALID_OUTPUTS,
+                    code=WorkflowErrorCode.INVALID_OUTPUTS,
                 )
 
             if isinstance(node_run_response, BaseOutputs):
                 if not isinstance(node_run_response, node.Outputs):
                     raise NodeException(
                         message=f"Node {node.__class__.__name__} did not return a valid outputs object",
-                        code=VellumErrorCode.INVALID_OUTPUTS,
+                        code=WorkflowErrorCode.INVALID_OUTPUTS,
                     )
 
                 outputs = node_run_response
@@ -312,9 +312,9 @@ class WorkflowRunner(Generic[StateType]):
                     span_id=span_id,
                     body=NodeExecutionRejectedBody(
                         node_definition=node.__class__,
-                        error=VellumError(
+                        error=WorkflowError(
                             message=str(e),
-                            code=VellumErrorCode.INTERNAL_ERROR,
+                            code=WorkflowErrorCode.INTERNAL_ERROR,
                         ),
                     ),
                     parent=parent_context,
@@ -375,7 +375,7 @@ class WorkflowRunner(Generic[StateType]):
             )
             worker_thread.start()
 
-    def _handle_work_item_event(self, event: WorkflowEvent) -> Optional[VellumError]:
+    def _handle_work_item_event(self, event: WorkflowEvent) -> Optional[WorkflowError]:
         node = self._active_nodes_by_execution_id.get(event.span_id)
         if not node:
             return None
@@ -449,7 +449,7 @@ class WorkflowRunner(Generic[StateType]):
             parent=self._parent_context,
         )
 
-    def _reject_workflow_event(self, error: VellumError) -> WorkflowExecutionRejectedEvent:
+    def _reject_workflow_event(self, error: WorkflowError) -> WorkflowExecutionRejectedEvent:
         return WorkflowExecutionRejectedEvent(
             trace_id=self._initial_state.meta.trace_id,
             span_id=self._initial_state.meta.span_id,
@@ -486,9 +486,9 @@ class WorkflowRunner(Generic[StateType]):
         if not self._entrypoints:
             self._workflow_event_outer_queue.put(
                 self._reject_workflow_event(
-                    VellumError(
+                    WorkflowError(
                         message="No entrypoints defined",
-                        code=VellumErrorCode.INVALID_WORKFLOW,
+                        code=WorkflowErrorCode.INVALID_WORKFLOW,
                     )
                 )
             )
@@ -515,12 +515,12 @@ class WorkflowRunner(Generic[StateType]):
                 logger.exception(err_message)
                 self._workflow_event_outer_queue.put(
                     self._reject_workflow_event(
-                        VellumError(code=VellumErrorCode.INTERNAL_ERROR, message=err_message),
+                        WorkflowError(code=WorkflowErrorCode.INTERNAL_ERROR, message=err_message),
                     )
                 )
                 return
 
-        rejection_error: Optional[VellumError] = None
+        rejection_error: Optional[WorkflowError] = None
 
         while True:
             if not self._active_nodes_by_execution_id:
@@ -602,8 +602,8 @@ class WorkflowRunner(Generic[StateType]):
         self._cancel_signal.wait()
         self._workflow_event_outer_queue.put(
             self._reject_workflow_event(
-                VellumError(
-                    code=VellumErrorCode.WORKFLOW_CANCELLED,
+                WorkflowError(
+                    code=WorkflowErrorCode.WORKFLOW_CANCELLED,
                     message="Workflow run cancelled",
                 )
             )
@@ -666,8 +666,8 @@ class WorkflowRunner(Generic[StateType]):
 
         if not self._is_terminal_event(event):
             yield self._reject_workflow_event(
-                VellumError(
-                    code=VellumErrorCode.INTERNAL_ERROR,
+                WorkflowError(
+                    code=WorkflowErrorCode.INTERNAL_ERROR,
                     message="An unexpected error occurred while streaming Workflow events",
                 )
             )

{vellum_ee/workflows/display → vellum/workflows}/utils/tests/test_uuids.py

@@ -1,7 +1,7 @@
 import pytest
 from uuid import UUID
 
-from vellum_ee.workflows.display.utils.uuids import uuid4_from_hash
+from vellum.workflows.utils.uuids import uuid4_from_hash
 
 
 @pytest.mark.parametrize(

vellum/workflows/workflows/base.py

@@ -34,7 +34,7 @@ from typing import (
 
 from vellum.workflows.edges import Edge
 from vellum.workflows.emitters.base import BaseWorkflowEmitter
-from vellum.workflows.errors import VellumError, VellumErrorCode
+from vellum.workflows.errors import WorkflowError, WorkflowErrorCode
 from vellum.workflows.events.node import (
     NodeExecutionFulfilledBody,
     NodeExecutionFulfilledEvent,
@@ -234,8 +234,8 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
                 trace_id=uuid4(),
                 span_id=uuid4(),
                 body=WorkflowExecutionRejectedBody(
-                    error=VellumError(
-                        code=VellumErrorCode.INTERNAL_ERROR,
+                    error=WorkflowError(
+                        code=WorkflowErrorCode.INTERNAL_ERROR,
                         message="No events were emitted",
                     ),
                     workflow_definition=self.__class__,
@@ -247,8 +247,8 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
                 trace_id=uuid4(),
                 span_id=uuid4(),
                 body=WorkflowExecutionRejectedBody(
-                    error=VellumError(
-                        code=VellumErrorCode.INTERNAL_ERROR,
+                    error=WorkflowError(
+                        code=WorkflowErrorCode.INTERNAL_ERROR,
                         message="Initiated event was never emitted",
                     ),
                     workflow_definition=self.__class__,
@@ -267,8 +267,8 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
             span_id=first_event.span_id,
             body=WorkflowExecutionRejectedBody(
                 workflow_definition=self.__class__,
-                error=VellumError(
-                    code=VellumErrorCode.INTERNAL_ERROR,
+                error=WorkflowError(
+                    code=WorkflowErrorCode.INTERNAL_ERROR,
                     message=f"Unexpected last event name found: {last_event.name}",
                 ),
             ),

{vellum_ai-0.11.10.dist-info → vellum_ai-0.12.1.dist-info}/METADATA

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