vellum-ai 0.10.4__py3-none-any.whl → 0.10.7__py3-none-any.whl

vellum/workflows/nodes/displayable/__init__.py

@@ -9,6 +9,7 @@ from .final_output_node import FinalOutputNode
 from .guardrail_node import GuardrailNode
 from .inline_prompt_node import InlinePromptNode
 from .merge_node import MergeNode
+from .note_node import NoteNode
 from .prompt_deployment_node import PromptDeploymentNode
 from .search_node import SearchNode
 from .subworkflow_deployment_node import SubworkflowDeploymentNode
@@ -23,6 +24,7 @@ __all__ = [
     "GuardrailNode",
     "MapNode",
     "MergeNode",
+    "NoteNode",
     "SubworkflowDeploymentNode",
     "PromptDeploymentNode",
     "SearchNode",

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

@@ -8,7 +8,7 @@ from vellum.workflows.errors.types import VellumErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs import BaseOutputs
-from vellum.workflows.types.core import JsonObject, VellumSecret
+from vellum.workflows.types.core import Json, JsonObject, VellumSecret
 from vellum.workflows.types.generics import StateType
 
 
@@ -26,11 +26,11 @@ class BaseAPINode(BaseNode, Generic[StateType]):
     url: str
     method: APIRequestMethod
     data: Optional[str] = None
-    json: Optional["JsonObject"] = None
+    json: Optional["Json"] = None
     headers: Optional[Dict[str, Union[str, VellumSecret]]] = None
 
     class Outputs(BaseOutputs):
-        json: Optional["JsonObject"]
+        json: Optional["Json"]
         headers: Dict[str, str]
         status_code: int
         text: str

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

@@ -19,7 +19,6 @@ from vellum import (
     VellumValue,
 )
 from vellum.core import RequestOptions
-
 from vellum.workflows.errors.types import VellumErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
@@ -44,7 +43,11 @@ class _CodeExecutionNodeMeta(BaseNodeMeta):
         if not isinstance(parent, _CodeExecutionNodeMeta):
             raise ValueError("CodeExecutionNode must be created with the CodeExecutionNodeMeta metaclass")
 
-        parent.__dict__["Outputs"].__annotations__["result"] = parent.get_output_type()
+        annotations = parent.__dict__["Outputs"].__annotations__
+        parent.__dict__["Outputs"].__annotations__ = {
+            **annotations,
+            "result": parent.get_output_type(),
+        }
         return parent
 
     def get_output_type(cls) -> Type:

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

@@ -1,4 +1,4 @@
-from typing import Iterable
+from typing import Set
 
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutputs
@@ -15,7 +15,7 @@ class ConditionalNode(BaseNode):
     """
 
     class Ports(NodePorts):
-        def __call__(self, outputs: BaseOutputs, state: BaseState) -> Iterable[Port]:
+        def __call__(self, outputs: BaseOutputs, state: BaseState) -> Set[Port]:    
             all_ports = [port for port in self.__class__]
             enforce_single_invoked_port = validate_ports(all_ports)
 

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

@@ -16,9 +16,13 @@ class _FinalOutputNodeMeta(BaseNodeMeta):
 
         # We use the compiled class to infer the output type for the Outputs.value descriptor.
         if not isinstance(parent, _FinalOutputNodeMeta):
-            raise ValueError("CodeExecutionNode must be created with the CodeExecutionNodeMeta metaclass")
+            raise ValueError("FinalOutputNode must be created with the FinalOutputNodeMeta metaclass")
 
-        parent.__dict__["Outputs"].__annotations__["value"] = parent.get_output_type()
+        annotations = parent.__dict__["Outputs"].__annotations__
+        parent.__dict__["Outputs"].__annotations__ = {
+            **annotations,
+            "value": parent.get_output_type(),
+        }
         return parent
 
     def get_output_type(cls) -> Type:

vellum/workflows/nodes/displayable/note_node/__init__.py

@@ -0,0 +1,5 @@
+from .node import NoteNode
+
+__all__ = [
+    "NoteNode",
+]

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

@@ -0,0 +1,10 @@
+from vellum.workflows.nodes.bases import BaseNode
+
+
+class NoteNode(BaseNode):
+    """
+    A no-op Node purely used to display a note in the Vellum UI.
+    """
+
+    def run(self) -> BaseNode.Outputs:
+        raise RuntimeError("NoteNode should never be run")

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

@@ -11,13 +11,12 @@ from vellum import (
     StringVellumValue,
     VellumError,
 )
-
-from vellum.workflows.constants import UNDEF
-from vellum.workflows.errors import VellumError as WacVellumError
+from vellum.workflows.errors import VellumError as SdkVellumError
 from vellum.workflows.errors.types import VellumErrorCode
 from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes import InlinePromptNode
 from vellum.workflows.nodes.core.try_node.node import TryNode
+from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.state import BaseState
 from vellum.workflows.state.base import StateMeta
 
@@ -136,13 +135,13 @@ def test_inline_text_prompt_node__catch_provider_error(vellum_adhoc_prompt_clien
             meta=StateMeta(workflow_inputs=Inputs(input="Say something.")),
         )
     )
-    outputs = node.run()
+    outputs = list(node.run())
 
     # THEN the node should have produced the outputs we expect
-    # We need mypy support for annotations to remove these type ignores
-    # https://app.shortcut.com/vellum/story/4890
-    assert outputs.error == WacVellumError(  # type: ignore[attr-defined]
-        message="OpenAI failed",
-        code=VellumErrorCode.PROVIDER_ERROR,
-    )
-    assert outputs.text is UNDEF  # type: ignore[attr-defined]
+    assert BaseOutput(
+        name="error",
+        value=SdkVellumError(
+            message="OpenAI failed",
+            code=VellumErrorCode.PROVIDER_ERROR,
+        ),
+    ) in outputs

vellum/workflows/nodes/utils.py

@@ -5,6 +5,8 @@ from vellum.workflows.nodes import BaseNode
 from vellum.workflows.references import NodeReference
 from vellum.workflows.types.generics import NodeType
 
+ADORNMENT_MODULE_NAME = "<adornment>"
+
 
 @cache
 def get_wrapped_node(node: Type[NodeType]) -> Type[BaseNode]:

vellum/workflows/outputs/base.py

@@ -5,6 +5,7 @@ from pydantic import GetCoreSchemaHandler
 from pydantic_core import core_schema
 
 from vellum.workflows.constants import UNDEF
+from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.utils import get_class_attr_names, infer_types
 
@@ -76,6 +77,23 @@ class BaseOutput(Generic[_Delta, _Accumulated]):
 
         return data
 
+    def __repr__(self) -> str:
+        if self.value is not UNDEF:
+            return f"{self.__class__.__name__}({self.name}={self.value})"
+        elif self.delta is not UNDEF:
+            return f"{self.__class__.__name__}({self.name}={self.delta})"
+        else:
+            return f"{self.__class__.__name__}(name='{self.name}')"
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, BaseOutput):
+            return False
+
+        return self.name == other.name and self.value == other.value and self.delta == other.delta
+    
+    def __hash__(self) -> int:
+        return hash((self._name, self._value, self._value))
+
 
 @dataclass_transform(kw_only_default=True)
 class _BaseOutputsMeta(type):
@@ -175,7 +193,9 @@ class BaseOutputs(metaclass=_BaseOutputsMeta):
         if not isinstance(other, dict):
             return super().__eq__(other)
 
-        outputs = {name: value for name, value in vars(self).items() if not name.startswith("_") and value is not UNDEF}
+        outputs = {
+            name: value for name, value in vars(self).items() if not name.startswith("_") and value is not UNDEF
+        }
         return outputs == other
 
     def __repr__(self) -> str:
@@ -184,7 +204,11 @@ class BaseOutputs(metaclass=_BaseOutputsMeta):
 
     def __iter__(self) -> Iterator[Tuple[OutputReference, Any]]:
         for output_descriptor in self.__class__:
-            yield (output_descriptor, getattr(self, output_descriptor.name, output_descriptor.instance))
+            output_value = getattr(self, output_descriptor.name, UNDEF)
+            if isinstance(output_value, BaseDescriptor):
+                output_value = UNDEF
+
+            yield (output_descriptor, output_value)
 
     def __getitem__(self, key: str) -> Any:
         return getattr(self, key)

vellum/workflows/ports/node_ports.py

@@ -33,7 +33,7 @@ class _NodePortsMeta(type):
 
 
 class NodePorts(metaclass=_NodePortsMeta):
-    def __call__(self, outputs: BaseOutputs, state: BaseState) -> Iterable[Port]:
+    def __call__(self, outputs: BaseOutputs, state: BaseState) -> Set[Port]:
         """
         Invokes the appropriate ports based on the fulfilled outputs and state.
         """
@@ -67,7 +67,7 @@ class NodePorts(metaclass=_NodePortsMeta):
 
         return invoked_ports
 
-    def __lt__(self, output: BaseOutput) -> Iterable[Port]:
+    def __lt__(self, output: BaseOutput) -> Set[Port]:
         """
         Invokes the appropriate ports based on the streamed output
         """

vellum/workflows/ports/port.py

@@ -1,5 +1,8 @@
 from typing import TYPE_CHECKING, Any, Iterator, List, Optional, Type
 
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import core_schema
+
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.edges.edge import Edge
 from vellum.workflows.graph import Graph, GraphTarget
@@ -73,3 +76,14 @@ class Port:
 
         value = self._condition.resolve(state)
         return bool(value)
+
+    def serialize(self) -> dict:
+        return {
+            "name": self.name,
+        }
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Type[Any], handler: GetCoreSchemaHandler
+    ) -> core_schema.CoreSchema:
+        return core_schema.is_instance_schema(cls)

vellum/workflows/references/__init__.py

@@ -4,6 +4,7 @@ from .lazy import LazyReference
 from .node import NodeReference
 from .output import OutputReference
 from .state_value import StateValueReference
+from .vellum_secret import VellumSecretReference
 from .workflow_input import WorkflowInputReference
 
 __all__ = [
@@ -13,5 +14,6 @@ __all__ = [
     "NodeReference",
     "OutputReference",
     "StateValueReference",
+    "VellumSecretReference",
     "WorkflowInputReference",
 ]

vellum/workflows/runner/runner.py

@@ -170,32 +170,37 @@ class WorkflowRunner(Generic[StateType]):
                 streaming_output_queues: Dict[str, Queue] = {}
                 outputs = node.Outputs()
 
+                def initiate_node_streaming_output(output: BaseOutput) -> None:
+                    streaming_output_queues[output.name] = Queue()
+                    output_descriptor = OutputReference(
+                        name=output.name,
+                        types=(type(output.delta),),
+                        instance=None,
+                        outputs_class=node.Outputs,
+                    )
+                    node.state.meta.node_outputs[output_descriptor] = streaming_output_queues[output.name]
+                    self._work_item_event_queue.put(
+                        WorkItemEvent(
+                            node=node,
+                            event=NodeExecutionStreamingEvent(
+                                trace_id=node.state.meta.trace_id,
+                                span_id=span_id,
+                                body=NodeExecutionStreamingBody(
+                                    node_definition=node.__class__,
+                                    output=BaseOutput(name=output.name),
+                                    invoked_ports=invoked_ports,
+                                ),
+                            ),
+                        )
+                    )
+
                 for output in node_run_response:
                     invoked_ports = output > ports
-                    if not output.is_fulfilled:
+                    if output.is_initiated:
+                        initiate_node_streaming_output(output)
+                    elif output.is_streaming:
                         if output.name not in streaming_output_queues:
-                            streaming_output_queues[output.name] = Queue()
-                            output_descriptor = OutputReference(
-                                name=output.name,
-                                types=(type(output.delta),),
-                                instance=None,
-                                outputs_class=node.Outputs,
-                            )
-                            node.state.meta.node_outputs[output_descriptor] = streaming_output_queues[output.name]
-                            self._work_item_event_queue.put(
-                                WorkItemEvent(
-                                    node=node,
-                                    event=NodeExecutionStreamingEvent(
-                                        trace_id=node.state.meta.trace_id,
-                                        span_id=span_id,
-                                        body=NodeExecutionStreamingBody(
-                                            node_definition=node.__class__,
-                                            output=BaseOutput(name=output.name),
-                                        ),
-                                    ),
-                                    invoked_ports=invoked_ports,
-                                )
-                            )
+                            initiate_node_streaming_output(output)
 
                         streaming_output_queues[output.name].put(output.delta)
                         self._work_item_event_queue.put(
@@ -207,12 +212,12 @@ class WorkflowRunner(Generic[StateType]):
                                     body=NodeExecutionStreamingBody(
                                         node_definition=node.__class__,
                                         output=output,
+                                        invoked_ports=invoked_ports,
                                     ),
                                 ),
-                                invoked_ports=invoked_ports,
                             )
                         )
-                    else:
+                    elif output.is_fulfilled:
                         if output.name in streaming_output_queues:
                             streaming_output_queues[output.name].put(UNDEF)
 
@@ -226,13 +231,18 @@ class WorkflowRunner(Generic[StateType]):
                                     body=NodeExecutionStreamingBody(
                                         node_definition=node.__class__,
                                         output=output,
+                                        invoked_ports=invoked_ports,
                                     ),
                                 ),
-                                invoked_ports=invoked_ports,
                             )
                         )
 
             for descriptor, output_value in outputs:
+                if output_value is UNDEF:
+                    if descriptor in node.state.meta.node_outputs:
+                        del node.state.meta.node_outputs[descriptor]
+                    continue
+
                 node.state.meta.node_outputs[descriptor] = output_value
 
             invoked_ports = ports(outputs, node.state)
@@ -247,9 +257,9 @@ class WorkflowRunner(Generic[StateType]):
                         body=NodeExecutionFulfilledBody(
                             node_definition=node.__class__,
                             outputs=outputs,
+                            invoked_ports=invoked_ports,
                         ),
                     ),
-                    invoked_ports=invoked_ports,
                 )
             )
         except NodeException as e:
@@ -329,7 +339,6 @@ class WorkflowRunner(Generic[StateType]):
     def _handle_work_item_event(self, work_item_event: WorkItemEvent[StateType]) -> Optional[VellumError]:
         node = work_item_event.node
         event = work_item_event.event
-        invoked_ports = work_item_event.invoked_ports
 
         if event.name == "node.execution.initiated":
             return None
@@ -358,13 +367,13 @@ class WorkflowRunner(Generic[StateType]):
                     )
                 )
 
-            self._handle_invoked_ports(node.state, invoked_ports)
+            self._handle_invoked_ports(node.state, event.invoked_ports)
 
             return None
 
         if event.name == "node.execution.fulfilled":
             self._active_nodes_by_execution_id.pop(event.span_id)
-            self._handle_invoked_ports(node.state, invoked_ports)
+            self._handle_invoked_ports(node.state, event.invoked_ports)
 
             return None
 
@@ -540,11 +549,15 @@ class WorkflowRunner(Generic[StateType]):
         )
 
     def stream(self) -> WorkflowEventStream:
-        background_thread = Thread(target=self._run_background_thread)
+        background_thread = Thread(
+            target=self._run_background_thread, name=f"{self.workflow.__class__.__name__}.background_thread"
+        )
         background_thread.start()
 
         if self._cancel_signal:
-            cancel_thread = Thread(target=self._run_cancel_thread)
+            cancel_thread = Thread(
+                target=self._run_cancel_thread, name=f"{self.workflow.__class__.__name__}.cancel_thread"
+            )
             cancel_thread.start()
 
         event: WorkflowEvent
@@ -557,7 +570,7 @@ class WorkflowRunner(Generic[StateType]):
         self._initial_state.meta.is_terminated = False
 
         # The extra level of indirection prevents the runner from waiting on the caller to consume the event stream
-        stream_thread = Thread(target=self._stream)
+        stream_thread = Thread(target=self._stream, name=f"{self.workflow.__class__.__name__}.stream_thread")
         stream_thread.start()
 
         while stream_thread.is_alive():

vellum/workflows/runner/types.py

@@ -1,18 +1,16 @@
 """Only intenral types and enums for WorkflowRunner should be defined in this module."""
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Generic, Iterable, Optional
+from typing import TYPE_CHECKING, Generic
 
 from vellum.workflows.types.generics import StateType
 
 if TYPE_CHECKING:
     from vellum.workflows.events import NodeEvent
     from vellum.workflows.nodes.bases import BaseNode
-    from vellum.workflows.ports import Port
 
 
 @dataclass(frozen=True)
 class WorkItemEvent(Generic[StateType]):
     node: "BaseNode[StateType]"
     event: "NodeEvent"
-    invoked_ports: Optional[Iterable["Port"]] = None

vellum/workflows/state/encoder.py

@@ -9,6 +9,7 @@ from pydantic import BaseModel
 
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
+from vellum.workflows.ports.port import Port
 from vellum.workflows.state.base import BaseState, NodeExecutionCache
 
 
@@ -22,7 +23,7 @@ class DefaultStateEncoder(JSONEncoder):
         if isinstance(obj, (BaseInputs, BaseOutputs)):
             return {descriptor.name: value for descriptor, value in obj}
 
-        if isinstance(obj, BaseOutput):
+        if isinstance(obj, (BaseOutput, Port)):
             return obj.serialize()
 
         if isinstance(obj, NodeExecutionCache):

vellum/workflows/types/tests/test_utils.py

@@ -1,6 +1,8 @@
 import pytest
-from typing import ClassVar, Generic, List, TypeVar, Union
+from typing import Any, ClassVar, Generic, List, TypeVar, Union
 
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.core.try_node.node import TryNode
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.utils import get_class_attr_names, infer_types
@@ -18,6 +20,7 @@ class ExampleClass:
     )
     zeta: ClassVar[str]
     eta: List[str]
+    kappa: Any
 
 
 T = TypeVar("T")
@@ -30,6 +33,11 @@ class ExampleGenericClass(Generic[T]):
 class ExampleInheritedClass(ExampleClass):
     theta: int
 
+@TryNode.wrap()
+class ExampleNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        iota: str
+
 
 @pytest.mark.parametrize(
     "cls, attr_name, expected_type",
@@ -45,6 +53,8 @@ class ExampleInheritedClass(ExampleClass):
         (ExampleInheritedClass, "theta", (int,)),
         (ExampleInheritedClass, "alpha", (str,)),
         (ExampleInheritedClass, "beta", (int,)),
+        (ExampleNode.Outputs, "iota", (str,)),
+        (ExampleClass, "kappa", (Any,)),
     ],
     ids=[
         "str",
@@ -58,6 +68,8 @@ class ExampleInheritedClass(ExampleClass):
         "inherited_int",
         "inherited_parent_annotation",
         "inherited_parent_class_var",
+        "try_node_output",
+        "any",
     ],
 )
 def test_infer_types(cls, attr_name, expected_type):
@@ -67,9 +79,9 @@ def test_infer_types(cls, attr_name, expected_type):
 @pytest.mark.parametrize(
     "cls, expected_attr_names",
     [
-        (ExampleClass, {"alpha", "beta", "gamma", "epsilon", "zeta", "eta"}),
+        (ExampleClass, {"alpha", "beta", "gamma", "epsilon", "zeta", "eta", "kappa"}),
         (ExampleGenericClass, {"delta"}),
-        (ExampleInheritedClass, {"alpha", "beta", "gamma", "epsilon", "zeta", "eta", "theta"}),
+        (ExampleInheritedClass, {"alpha", "beta", "gamma", "epsilon", "zeta", "eta", "theta", "kappa"}),
     ],
 )
 def test_class_attr_names(cls, expected_attr_names):

vellum/workflows/types/utils.py

@@ -1,6 +1,7 @@
 from copy import deepcopy
 from datetime import datetime
 import importlib
+import sys
 from typing import (
     Any,
     ClassVar,
@@ -12,13 +13,13 @@ from typing import (
     Type,
     TypeVar,
     Union,
+    cast,
     get_args,
     get_origin,
     get_type_hints,
 )
 
 from vellum import ArrayVellumValue, ArrayVellumValueRequest, ChatMessagePromptBlock
-
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.types.core import Json, SpecialGenericAlias, UnderGenericAlias, UnionGenericAlias
 
@@ -81,6 +82,8 @@ def infer_types(object_: Type, attr_name: str, localns: Optional[Dict[str, Any]]
                 if type_hint in type_var_mapping:
                     return (type_var_mapping[type_hint],)
                 return type_hint.__constraints__
+            if type_hint is Any:
+                return cast(Tuple[Type[Any], ...], (Any,))
 
         for base in reversed(class_.__mro__):
             class_attributes = vars(base)

vellum/workflows/utils/vellum_variables.py

@@ -1,3 +1,4 @@
+import typing
 from typing import List, Tuple, Type, Union, get_args, get_origin
 
 from vellum import (
@@ -17,8 +18,8 @@ from vellum import (
     VellumValueRequest,
     VellumVariableType,
 )
-
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.types.core import Json
 
 
 def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -> VellumVariableType:
@@ -32,6 +33,17 @@ def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -
             return "JSON"
 
         if len(types) != 1:
+            # Check explicitly for our internal JSON type.
+            # Matches the type found at vellum.workflows.utils.vellum_variables.Json
+            if types == [
+                bool,
+                int,
+                float,
+                str,
+                typing.List[typing.ForwardRef('Json')],  # type: ignore [misc]
+                typing.Dict[str, typing.ForwardRef('Json')],  # type: ignore [misc]
+            ]:
+                return "JSON"
             raise ValueError(f"Expected Descriptor to only have one type, got {types}")
 
         type_ = type_.types[0]

vellum/workflows/workflows/base.py

@@ -35,11 +35,17 @@ from vellum.workflows.emitters.base import BaseWorkflowEmitter
 from vellum.workflows.errors import VellumError, VellumErrorCode
 from vellum.workflows.events.node import (
     NodeExecutionFulfilledBody,
+    NodeExecutionFulfilledEvent,
     NodeExecutionInitiatedBody,
+    NodeExecutionInitiatedEvent,
     NodeExecutionPausedBody,
+    NodeExecutionPausedEvent,
     NodeExecutionRejectedBody,
+    NodeExecutionRejectedEvent,
     NodeExecutionResumedBody,
+    NodeExecutionResumedEvent,
     NodeExecutionStreamingBody,
+    NodeExecutionStreamingEvent,
 )
 from vellum.workflows.events.types import WorkflowEventType
 from vellum.workflows.events.workflow import (
@@ -55,6 +61,7 @@ from vellum.workflows.events.workflow import (
     WorkflowExecutionResumedBody,
     WorkflowExecutionResumedEvent,
     WorkflowExecutionStreamingBody,
+    WorkflowExecutionStreamingEvent,
 )
 from vellum.workflows.graph import Graph
 from vellum.workflows.inputs.base import BaseInputs
@@ -204,7 +211,9 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
                 trace_id=uuid4(),
                 span_id=uuid4(),
                 body=WorkflowExecutionRejectedBody(
-                    error=VellumError(code=VellumErrorCode.INTERNAL_ERROR, message="Initiated event was never emitted"),
+                    error=VellumError(
+                        code=VellumErrorCode.INTERNAL_ERROR, message="Initiated event was never emitted"
+                    ),
                     workflow_definition=self.__class__,
                 ),
             )
@@ -363,3 +372,17 @@ NodeExecutionRejectedBody.model_rebuild()
 NodeExecutionPausedBody.model_rebuild()
 NodeExecutionResumedBody.model_rebuild()
 NodeExecutionStreamingBody.model_rebuild()
+
+WorkflowExecutionInitiatedEvent.model_rebuild()
+WorkflowExecutionFulfilledEvent.model_rebuild()
+WorkflowExecutionRejectedEvent.model_rebuild()
+WorkflowExecutionPausedEvent.model_rebuild()
+WorkflowExecutionResumedEvent.model_rebuild()
+WorkflowExecutionStreamingEvent.model_rebuild()
+
+NodeExecutionInitiatedEvent.model_rebuild()
+NodeExecutionFulfilledEvent.model_rebuild()
+NodeExecutionRejectedEvent.model_rebuild()
+NodeExecutionPausedEvent.model_rebuild()
+NodeExecutionResumedEvent.model_rebuild()
+NodeExecutionStreamingEvent.model_rebuild()