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

vellum/client/types/logical_operator.py

@@ -24,6 +24,8 @@ LogicalOperator = typing.Union[
         "notBetween",
         "blank",
         "notBlank",
+        "coalesce",
+        "accessField",
     ],
     typing.Any,
 ]

vellum/evaluations/resources.py

@@ -1,17 +1,14 @@
 from __future__ import annotations
 
+from functools import cached_property
 import logging
 import time
-from functools import cached_property
-from typing import Callable, Generator, List, cast, Iterable
 from uuid import UUID
+from typing import Callable, Generator, Iterable, List, cast
 
-from vellum import TestSuiteRunRead, TestSuiteRunMetricNumberOutput
-from vellum.client import Vellum, OMIT
-from vellum.evaluations.constants import (
-    DEFAULT_MAX_POLLING_DURATION_MS,
-    DEFAULT_POLLING_INTERVAL_MS,
-)
+from vellum import TestSuiteRunMetricNumberOutput, TestSuiteRunRead
+from vellum.client import OMIT, Vellum
+from vellum.evaluations.constants import DEFAULT_MAX_POLLING_DURATION_MS, DEFAULT_POLLING_INTERVAL_MS
 from vellum.evaluations.exceptions import TestSuiteRunResultsException
 from vellum.evaluations.utils.env import get_api_key
 from vellum.evaluations.utils.paginator import PaginatedResults, get_all_results
@@ -21,9 +18,9 @@ from vellum.types import (
     ExternalTestCaseExecutionRequest,
     NamedTestCaseVariableValueRequest,
     TestCaseVariableValue,
-    TestSuiteRunExternalExecConfigRequest,
     TestSuiteRunExecution,
     TestSuiteRunExternalExecConfigDataRequest,
+    TestSuiteRunExternalExecConfigRequest,
     TestSuiteRunMetricOutput,
     TestSuiteRunState,
 )
@@ -161,9 +158,7 @@ class VellumTestSuiteRunResults:
 
         metric_outputs: list[TestSuiteRunMetricNumberOutput] = []
 
-        for output in self.get_metric_outputs(
-            metric_identifier=metric_identifier, output_identifier=output_identifier
-        ):
+        for output in self.get_metric_outputs(metric_identifier=metric_identifier, output_identifier=output_identifier):
             if output.type != "NUMBER":
                 raise TestSuiteRunResultsException(
                     f"Expected a numeric metric output, but got a {output.type} output instead."

vellum/evaluations/utils/env.py

@@ -6,8 +6,6 @@ from .exceptions import VellumClientException
 def get_api_key() -> str:
     api_key = os.environ.get("VELLUM_API_KEY")
     if api_key is None:
-        raise VellumClientException(
-            "`VELLUM_API_KEY` environment variable is required to be set."
-        )
+        raise VellumClientException("`VELLUM_API_KEY` environment variable is required to be set.")
 
     return api_key

vellum/evaluations/utils/paginator.py

@@ -1,7 +1,6 @@
 from dataclasses import dataclass
 from typing import Callable, Generator, Generic, List, TypeVar, Union
 
-
 Result = TypeVar("Result")
 
 

vellum/evaluations/utils/typing.py

@@ -1,4 +1,4 @@
-from typing import TypeVar, Optional
+from typing import Optional, TypeVar
 
 _T = TypeVar("_T")
 

vellum/evaluations/utils/uuid.py

@@ -1,5 +1,5 @@
-from typing import Union
 import uuid
+from typing import Union
 
 
 def is_valid_uuid(val: Union[str, uuid.UUID, None]) -> bool:

vellum/plugins/vellum_mypy.py

@@ -154,7 +154,9 @@ class VellumMypyPlugin(Plugin):
     def _base_class_hook(self, ctx: ClassDefContext) -> None:
         if _is_subclass(ctx.cls.info, "vellum.workflows.nodes.core.templating_node.node.TemplatingNode"):
             self._dynamic_output_node_class_hook(ctx, "result")
-        elif _is_subclass(ctx.cls.info, "vellum.workflows.nodes.displayable.code_execution_node.node.CodeExecutionNode"):
+        elif _is_subclass(
+            ctx.cls.info, "vellum.workflows.nodes.displayable.code_execution_node.node.CodeExecutionNode"
+        ):
             self._dynamic_output_node_class_hook(ctx, "result")
         elif _is_subclass(ctx.cls.info, "vellum.workflows.nodes.displayable.final_output_node.node.FinalOutputNode"):
             self._dynamic_output_node_class_hook(ctx, "value")

vellum/workflows/descriptors/utils.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, Optional, Sequence, Set, TypeVar, Union, cast, ove
 
 from pydantic import BaseModel
 
+from vellum.workflows.constants import UNDEF
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.state.base import BaseState
 
@@ -88,3 +89,29 @@ def resolve_value(
         return cast(_T, set_value)
 
     return value
+
+
+def is_unresolved(value: Any) -> bool:
+    """
+    Recursively checks if a value has an unresolved value, represented by UNDEF.
+    """
+
+    if value is UNDEF:
+        return True
+
+    if dataclasses.is_dataclass(value):
+        return any(is_unresolved(getattr(value, field.name)) for field in dataclasses.fields(value))
+
+    if isinstance(value, BaseModel):
+        return any(is_unresolved(getattr(value, key)) for key in value.model_fields.keys())
+
+    if isinstance(value, Mapping):
+        return any(is_unresolved(item) for item in value.values())
+
+    if isinstance(value, Sequence):
+        return any(is_unresolved(item) for item in value)
+
+    if isinstance(value, Set):
+        return any(is_unresolved(item) for item in value)
+
+    return False

vellum/workflows/events/__init__.py

@@ -5,7 +5,6 @@ from .node import (
     NodeExecutionRejectedEvent,
     NodeExecutionStreamingEvent,
 )
-from .types import WorkflowEventType
 from .workflow import (
     WorkflowEvent,
     WorkflowEventStream,
@@ -27,5 +26,4 @@ __all__ = [
     "WorkflowExecutionStreamingEvent",
     "WorkflowEvent",
     "WorkflowEventStream",
-    "WorkflowEventType",
 ]

vellum/workflows/events/node.py

@@ -1,12 +1,10 @@
-from typing import Any, Dict, Generic, Iterable, List, Literal, Optional, Set, Type, Union
+from typing import TYPE_CHECKING, Any, Dict, Generic, List, Literal, Optional, Set, Type, Union
 
-from pydantic import ConfigDict, SerializerFunctionWrapHandler, field_serializer, model_serializer
-from pydantic.main import IncEx
+from pydantic import SerializerFunctionWrapHandler, field_serializer, model_serializer
 
 from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.errors import VellumError
 from vellum.workflows.expressions.accessor import AccessorExpression
-from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.ports.port import Port
 from vellum.workflows.references.node import NodeReference
@@ -14,9 +12,12 @@ from vellum.workflows.types.generics import OutputsType
 
 from .types import BaseEvent, default_serializer, serialize_type_encoder
 
+if TYPE_CHECKING:
+    from vellum.workflows.nodes.bases import BaseNode
+
 
 class _BaseNodeExecutionBody(UniversalBaseModel):
-    node_definition: Type[BaseNode]
+    node_definition: Type["BaseNode"]
 
     @field_serializer("node_definition")
     def serialize_node_definition(self, node_definition: Type, _info: Any) -> Dict[str, Any]:
@@ -36,7 +37,7 @@ class _BaseNodeEvent(BaseEvent):
     body: _BaseNodeExecutionBody
 
     @property
-    def node_definition(self) -> Type[BaseNode]:
+    def node_definition(self) -> Type["BaseNode"]:
         return self.body.node_definition
 
 

vellum/workflows/events/tests/test_event.py

@@ -1,6 +1,5 @@
 import pytest
 from datetime import datetime
-import json
 from uuid import UUID
 
 from deepdiff import DeepDiff
@@ -100,7 +99,8 @@ module_root = name_parts[: name_parts.index("events")]
                     node_definition=MockNode,
                     span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
                     parent=WorkflowParentContext(
-                        workflow_definition=MockWorkflow, span_id=UUID("123e4567-e89b-12d3-a456-426614174000")
+                        workflow_definition=MockWorkflow,
+                        span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
                     ),
                 ),
             ),

vellum/workflows/events/types.py

@@ -1,24 +1,14 @@
 from datetime import datetime
-from enum import Enum
 import json
 from uuid import UUID, uuid4
-from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Type, Union
+from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
-from pydantic import Field, field_serializer
+from pydantic import BeforeValidator, Field
 
 from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types.utils import datetime_now
 
-if TYPE_CHECKING:
-    from vellum.workflows.nodes.bases.base import BaseNode
-    from vellum.workflows.workflows.base import BaseWorkflow
-
-
-class WorkflowEventType(Enum):
-    NODE = "NODE"
-    WORKFLOW = "WORKFLOW"
-
 
 def default_datetime_factory() -> datetime:
     """
@@ -47,9 +37,25 @@ def default_serializer(obj: Any) -> Any:
     )
 
 
+class CodeResourceDefinition(UniversalBaseModel):
+    name: str
+    module: List[str]
+
+    @staticmethod
+    def encode(obj: type) -> "CodeResourceDefinition":
+        return CodeResourceDefinition(**serialize_type_encoder(obj))
+
+
+VellumCodeResourceDefinition = Annotated[
+    CodeResourceDefinition,
+    BeforeValidator(lambda d: (d if type(d) is dict else serialize_type_encoder(d))),
+]
+
+
 class BaseParentContext(UniversalBaseModel):
     span_id: UUID
-    parent: Optional['ParentContext'] = None
+    parent: Optional["ParentContext"] = None
+    type: str
 
 
 class BaseDeploymentParentContext(BaseParentContext):
@@ -73,29 +79,28 @@ class PromptDeploymentParentContext(BaseDeploymentParentContext):
 
 class NodeParentContext(BaseParentContext):
     type: Literal["WORKFLOW_NODE"] = "WORKFLOW_NODE"
-    node_definition: Type['BaseNode']
-
-    @field_serializer("node_definition")
-    def serialize_node_definition(self, definition: Type, _info: Any) -> Dict[str, Any]:
-        return serialize_type_encoder(definition)
+    node_definition: VellumCodeResourceDefinition
 
 
 class WorkflowParentContext(BaseParentContext):
     type: Literal["WORKFLOW"] = "WORKFLOW"
-    workflow_definition: Type['BaseWorkflow']
-
-    @field_serializer("workflow_definition")
-    def serialize_workflow_definition(self, definition: Type, _info: Any) -> Dict[str, Any]:
-        return serialize_type_encoder(definition)
-
-
-ParentContext = Union[
-    NodeParentContext,
-    WorkflowParentContext,
-    PromptDeploymentParentContext,
-    WorkflowDeploymentParentContext,
+    workflow_definition: VellumCodeResourceDefinition
+
+
+# Define the discriminated union
+ParentContext = Annotated[
+    Union[
+        WorkflowParentContext,
+        NodeParentContext,
+        WorkflowDeploymentParentContext,
+        PromptDeploymentParentContext,
+    ],
+    Field(discriminator="type"),
 ]
 
+# Update the forward references
+BaseParentContext.model_rebuild()
+
 
 class BaseEvent(UniversalBaseModel):
     id: UUID = Field(default_factory=uuid4)

vellum/workflows/events/workflow.py

@@ -3,11 +3,10 @@ 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.outputs.base import BaseOutput
 from vellum.workflows.references import ExternalInputReference
-from vellum.workflows.types.generics import OutputsType, WorkflowInputsType
+from vellum.workflows.types.generics import OutputsType, StateType, WorkflowInputsType
 
 from .node import (
     NodeExecutionFulfilledEvent,
@@ -31,6 +30,14 @@ class _BaseWorkflowExecutionBody(UniversalBaseModel):
         return serialize_type_encoder(workflow_definition)
 
 
+class _BaseWorkflowEvent(BaseEvent):
+    body: _BaseWorkflowExecutionBody
+
+    @property
+    def workflow_definition(self) -> Type["BaseWorkflow"]:
+        return self.body.workflow_definition
+
+
 class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[WorkflowInputsType]):
     inputs: WorkflowInputsType
 
@@ -39,7 +46,7 @@ class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[Workflo
         return default_serializer(inputs)
 
 
-class WorkflowExecutionInitiatedEvent(BaseEvent, Generic[WorkflowInputsType]):
+class WorkflowExecutionInitiatedEvent(_BaseWorkflowEvent, Generic[WorkflowInputsType]):
     name: Literal["workflow.execution.initiated"] = "workflow.execution.initiated"
     body: WorkflowExecutionInitiatedBody[WorkflowInputsType]
 
@@ -56,7 +63,7 @@ class WorkflowExecutionStreamingBody(_BaseWorkflowExecutionBody):
         return default_serializer(output)
 
 
-class WorkflowExecutionStreamingEvent(BaseEvent):
+class WorkflowExecutionStreamingEvent(_BaseWorkflowEvent):
     name: Literal["workflow.execution.streaming"] = "workflow.execution.streaming"
     body: WorkflowExecutionStreamingBody
 
@@ -73,7 +80,7 @@ class WorkflowExecutionFulfilledBody(_BaseWorkflowExecutionBody, Generic[Outputs
         return default_serializer(outputs)
 
 
-class WorkflowExecutionFulfilledEvent(BaseEvent, Generic[OutputsType]):
+class WorkflowExecutionFulfilledEvent(_BaseWorkflowEvent, Generic[OutputsType]):
     name: Literal["workflow.execution.fulfilled"] = "workflow.execution.fulfilled"
     body: WorkflowExecutionFulfilledBody[OutputsType]
 
@@ -86,7 +93,7 @@ class WorkflowExecutionRejectedBody(_BaseWorkflowExecutionBody):
     error: VellumError
 
 
-class WorkflowExecutionRejectedEvent(BaseEvent):
+class WorkflowExecutionRejectedEvent(_BaseWorkflowEvent):
     name: Literal["workflow.execution.rejected"] = "workflow.execution.rejected"
     body: WorkflowExecutionRejectedBody
 
@@ -99,7 +106,7 @@ class WorkflowExecutionPausedBody(_BaseWorkflowExecutionBody):
     external_inputs: Iterable[ExternalInputReference]
 
 
-class WorkflowExecutionPausedEvent(BaseEvent):
+class WorkflowExecutionPausedEvent(_BaseWorkflowEvent):
     name: Literal["workflow.execution.paused"] = "workflow.execution.paused"
     body: WorkflowExecutionPausedBody
 
@@ -112,11 +119,28 @@ class WorkflowExecutionResumedBody(_BaseWorkflowExecutionBody):
     pass
 
 
-class WorkflowExecutionResumedEvent(BaseEvent):
+class WorkflowExecutionResumedEvent(_BaseWorkflowEvent):
     name: Literal["workflow.execution.resumed"] = "workflow.execution.resumed"
     body: WorkflowExecutionResumedBody
 
 
+class WorkflowExecutionSnapshottedBody(_BaseWorkflowExecutionBody, Generic[StateType]):
+    state: StateType
+
+    @field_serializer("state")
+    def serialize_state(self, state: StateType, _info: Any) -> Dict[str, Any]:
+        return default_serializer(state)
+
+
+class WorkflowExecutionSnapshottedEvent(_BaseWorkflowEvent, Generic[StateType]):
+    name: Literal["workflow.execution.snapshotted"] = "workflow.execution.snapshotted"
+    body: WorkflowExecutionSnapshottedBody[StateType]
+
+    @property
+    def state(self) -> StateType:
+        return self.body.state
+
+
 GenericWorkflowEvent = Union[
     WorkflowExecutionStreamingEvent,
     WorkflowExecutionRejectedEvent,
@@ -134,6 +158,7 @@ WorkflowEvent = Union[
     GenericWorkflowEvent,
     WorkflowExecutionInitiatedEvent,
     WorkflowExecutionFulfilledEvent,
+    WorkflowExecutionSnapshottedEvent,
 ]
 
 WorkflowEventStream = Generator[WorkflowEvent, None, None]

vellum/workflows/nodes/bases/base.py

@@ -1,12 +1,12 @@
 from functools import cached_property, reduce
 import inspect
 from types import MappingProxyType
+from uuid import UUID
 from typing import Any, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, Union, cast, get_args
 
 from vellum.workflows.constants import UNDEF
 from vellum.workflows.descriptors.base import BaseDescriptor
-from vellum.workflows.descriptors.utils import resolve_value
-from vellum.workflows.edges.edge import Edge
+from vellum.workflows.descriptors.utils import is_unresolved, resolve_value
 from vellum.workflows.errors.types import VellumErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.graph import Graph
@@ -44,7 +44,11 @@ class BaseNodeMeta(type):
         if "Outputs" not in dct:
             for base in reversed(bases):
                 if hasattr(base, "Outputs"):
-                    dct["Outputs"] = type(f"{name}.Outputs", (base.Outputs,), {"__module__": dct["__module__"]})
+                    dct["Outputs"] = type(
+                        f"{name}.Outputs",
+                        (base.Outputs,),
+                        {"__module__": dct["__module__"]},
+                    )
                     break
             else:
                 raise ValueError("Outputs class not found in base classes")
@@ -66,13 +70,20 @@ class BaseNodeMeta(type):
         if "Execution" not in dct:
             for base in reversed(bases):
                 if issubclass(base, BaseNode):
-                    dct["Execution"] = type(f"{name}.Execution", (base.Execution,), {"__module__": dct["__module__"]})
+                    dct["Execution"] = type(
+                        f"{name}.Execution",
+                        (base.Execution,),
+                        {"__module__": dct["__module__"]},
+                    )
                     break
 
         if "Trigger" not in dct:
             for base in reversed(bases):
                 if issubclass(base, BaseNode):
-                    trigger_dct = {**base.Trigger.__dict__, "__module__": dct["__module__"]}
+                    trigger_dct = {
+                        **base.Trigger.__dict__,
+                        "__module__": dct["__module__"],
+                    }
                     dct["Trigger"] = type(f"{name}.Trigger", (base.Trigger,), trigger_dct)
                     break
 
@@ -225,34 +236,40 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
 
         @classmethod
         def should_initiate(
-            cls, state: StateType, dependencies: Set["Type[BaseNode]"], invoked_by: "Optional[Edge]" = None
+            cls,
+            state: StateType,
+            dependencies: Set["Type[BaseNode]"],
+            node_span_id: UUID,
         ) -> bool:
             """
             Determines whether a Node's execution should be initiated. Override this method to define custom
             trigger criteria.
             """
 
-            if cls.merge_behavior == MergeBehavior.AWAIT_ANY:
-                if not invoked_by:
-                    return True
-
-                is_ready = not state.meta.node_execution_cache.is_node_initiated(cls.node_class)
+            if cls.merge_behavior == MergeBehavior.AWAIT_ATTRIBUTES:
+                if state.meta.node_execution_cache.is_node_execution_initiated(cls.node_class, node_span_id):
+                    return False
 
-                invoked_identifier = str(invoked_by.from_port.node_class)
-                node_identifier = str(cls.node_class)
+                is_ready = True
+                for descriptor in cls.node_class:
+                    if not descriptor.instance:
+                        continue
 
-                dependencies_invoked = state.meta.node_execution_cache.dependencies_invoked[node_identifier]
-                dependencies_invoked.add(invoked_identifier)
-                if all(str(dep) in dependencies_invoked for dep in dependencies):
-                    del state.meta.node_execution_cache.dependencies_invoked[node_identifier]
+                    resolved_value = resolve_value(descriptor.instance, state, path=descriptor.name)
+                    if is_unresolved(resolved_value):
+                        is_ready = False
+                        break
 
                 return is_ready
 
-            if cls.merge_behavior == MergeBehavior.AWAIT_ALL:
-                if not invoked_by:
-                    return True
+            if cls.merge_behavior == MergeBehavior.AWAIT_ANY:
+                if state.meta.node_execution_cache.is_node_execution_initiated(cls.node_class, node_span_id):
+                    return False
+
+                return True
 
-                if state.meta.node_execution_cache.is_node_initiated(cls.node_class):
+            if cls.merge_behavior == MergeBehavior.AWAIT_ALL:
+                if state.meta.node_execution_cache.is_node_execution_initiated(cls.node_class, node_span_id):
                     return False
 
                 """
@@ -260,20 +277,26 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
                 when all of its dependencies have been executed N times.
                 """
                 current_node_execution_count = state.meta.node_execution_cache.get_execution_count(cls.node_class)
-                is_ready_outcome = all(
+                return all(
                     state.meta.node_execution_cache.get_execution_count(dep) == current_node_execution_count + 1
                     for dep in dependencies
                 )
 
-                return is_ready_outcome
-
-            raise NodeException(message="Invalid Trigger Node Specification", code=VellumErrorCode.INVALID_INPUTS)
+            raise NodeException(
+                message="Invalid Trigger Node Specification",
+                code=VellumErrorCode.INVALID_INPUTS,
+            )
 
     class Execution(metaclass=_BaseNodeExecutionMeta):
         node_class: Type["BaseNode"]
         count: int
 
-    def __init__(self, *, state: Optional[StateType] = None, context: Optional[WorkflowContext] = None):
+    def __init__(
+        self,
+        *,
+        state: Optional[StateType] = None,
+        context: Optional[WorkflowContext] = None,
+    ):
         if state:
             self.state = state
         else:

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

@@ -1,7 +1,6 @@
 from typing import Optional
 
 from vellum.core.pydantic_utilities import UniversalBaseModel
-
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.state.base import BaseState, StateMeta

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

@@ -87,6 +87,7 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
 
         result: _OutputType - The result of the template rendering
         """
+
         # We use our mypy plugin to override the _OutputType with the actual output type
         # for downstream references to this output.
         result: _OutputType  # type: ignore[valid-type]

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

@@ -1,6 +1,6 @@
 import sys
 from types import ModuleType
-from typing import TYPE_CHECKING, Any, Callable, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, cast
+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.exceptions import NodeException
@@ -8,7 +8,9 @@ from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
 from vellum.workflows.nodes.utils import ADORNMENT_MODULE_NAME
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
+from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.generics import StateType
+from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 if TYPE_CHECKING:
     from vellum.workflows import BaseWorkflow
@@ -44,6 +46,14 @@ class _TryNodeMeta(BaseNodeMeta):
 
         return node_class
 
+    def __getattribute__(cls, name: str) -> Any:
+        try:
+            return super().__getattribute__(name)
+        except AttributeError:
+            if name != "__wrapped_node__" and issubclass(cls, TryNode):
+                return getattr(cls.__wrapped_node__, name)
+            raise
+
 
 class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
     """
@@ -53,6 +63,7 @@ class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
     subworkflow: Type["BaseWorkflow"] - The Subworkflow to execute
     """
 
+    __wrapped_node__: Optional[Type["BaseNode"]] = None
     on_error_code: Optional[VellumErrorCode] = None
     subworkflow: Type["BaseWorkflow"]
 
@@ -62,15 +73,20 @@ class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
     def run(self) -> Iterator[BaseOutput]:
         subworkflow = self.subworkflow(
             parent_state=self.state,
-            context=self._context,
+            context=WorkflowContext(
+                _vellum_client=self._context._vellum_client,
+            ),
+        )
+        subworkflow_stream = subworkflow.stream(
+            event_filter=all_workflow_event_filter,
         )
-        subworkflow_stream = subworkflow.stream()
 
         outputs: Optional[BaseOutputs] = None
         exception: Optional[NodeException] = None
         fulfilled_output_names: Set[str] = set()
 
         for event in subworkflow_stream:
+            self._context._emit_subworkflow_event(event)
             if exception:
                 continue
 
@@ -122,8 +138,9 @@ Message: {event.error.message}""",
             # https://app.shortcut.com/vellum/story/4116
             from vellum.workflows import BaseWorkflow
 
+            inner_cls._is_wrapped_node = True
+
             class Subworkflow(BaseWorkflow):
-                inner_cls._is_wrapped_node = True
                 graph = inner_cls
 
                 # mypy is wrong here, this works and is defined
@@ -139,6 +156,7 @@ Message: {event.error.message}""",
                 cls.__name__,
                 (TryNode,),
                 {
+                    "__wrapped_node__": inner_cls,
                     "__module__": dynamic_module,
                     "on_error_code": _on_error_code,
                     "subworkflow": Subworkflow,