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

vellum/workflows/__init__.py

@@ -1,5 +1,89 @@
+from .constants import APIRequestMethod, AuthorizationType
+from .errors.types import WorkflowErrorCode
+from .exceptions import NodeException
+from .inputs import BaseInputs, DatasetRow
+from .nodes import (
+    APINode,
+    BaseInlinePromptNode,
+    BaseNode,
+    BasePromptDeploymentNode,
+    BaseSearchNode,
+    CodeExecutionNode,
+    ConditionalNode,
+    ErrorNode,
+    FinalOutputNode,
+    GuardrailNode,
+    InlinePromptNode,
+    InlineSubworkflowNode,
+    MapNode,
+    NoteNode,
+    PromptDeploymentNode,
+    RetryNode,
+    SearchNode,
+    SubworkflowDeploymentNode,
+    TemplatingNode,
+    TryNode,
+    WebSearchNode,
+)
+from .nodes.displayable.tool_calling_node import ToolCallingNode
+from .nodes.mocks import MockNodeExecution
+from .ports import Port
+from .references.environment_variable import EnvironmentVariableReference
+from .references.lazy import LazyReference
+from .runner import WorkflowRunner
+from .sandbox import WorkflowSandboxRunner
+from .state.base import BaseState
+from .triggers import ChatMessageTrigger, IntegrationTrigger, ScheduleTrigger
+from .types.core import Json, MergeBehavior
+from .types.definition import DeploymentDefinition, MCPServer, VellumIntegrationToolDefinition
+from .utils.functions import tool, use_tool_inputs
 from .workflows import BaseWorkflow
 
 __all__ = [
+    "APINode",
+    "APIRequestMethod",
+    "AuthorizationType",
+    "BaseInlinePromptNode",
+    "BaseInputs",
+    "BaseNode",
+    "BasePromptDeploymentNode",
+    "BaseSearchNode",
+    "BaseState",
     "BaseWorkflow",
+    "ChatMessageTrigger",
+    "CodeExecutionNode",
+    "ConditionalNode",
+    "DatasetRow",
+    "DeploymentDefinition",
+    "EnvironmentVariableReference",
+    "ErrorNode",
+    "FinalOutputNode",
+    "GuardrailNode",
+    "InlinePromptNode",
+    "InlineSubworkflowNode",
+    "IntegrationTrigger",
+    "Json",
+    "LazyReference",
+    "MapNode",
+    "MCPServer",
+    "MergeBehavior",
+    "MockNodeExecution",
+    "NodeException",
+    "NoteNode",
+    "Port",
+    "PromptDeploymentNode",
+    "RetryNode",
+    "ScheduleTrigger",
+    "SearchNode",
+    "SubworkflowDeploymentNode",
+    "TemplatingNode",
+    "tool",
+    "ToolCallingNode",
+    "TryNode",
+    "use_tool_inputs",
+    "VellumIntegrationToolDefinition",
+    "WebSearchNode",
+    "WorkflowErrorCode",
+    "WorkflowRunner",
+    "WorkflowSandboxRunner",
 ]

vellum/workflows/constants.py

@@ -22,6 +22,9 @@ class _UndefMeta(type):
 
         return super().__getattribute__(name)
 
+    def __str__(cls) -> str:
+        return ""
+
     def __bool__(cls) -> bool:
         return False
 
@@ -55,3 +58,7 @@ class APIRequestMethod(Enum):
 class AuthorizationType(Enum):
     BEARER_TOKEN = "BEARER_TOKEN"
     API_KEY = "API_KEY"
+
+
+class VellumIntegrationProviderType(Enum):
+    COMPOSIO = "COMPOSIO"

vellum/workflows/context.py

@@ -1,10 +1,11 @@
 from contextlib import contextmanager
 from dataclasses import field
 import threading
-from uuid import UUID
+from uuid import UUID, uuid4
 from typing import Iterator, Optional, cast
 
 from vellum.client.core import UniversalBaseModel
+from vellum.workflows.events.context import MonitoringContextStore
 from vellum.workflows.events.types import ParentContext
 
 
@@ -17,16 +18,37 @@ _CONTEXT_KEY = "_execution_context"
 
 local = threading.local()
 
+monitoring_context_store = MonitoringContextStore()
+
 
 def get_execution_context() -> ExecutionContext:
-    """Retrieve the current execution context."""
-    return getattr(local, _CONTEXT_KEY, ExecutionContext())
+    """Get the current monitoring execution context, with intelligent fallback."""
+    context = getattr(local, _CONTEXT_KEY, ExecutionContext())
+    if context.parent_context:
+        return context
+
+    # If no thread-local context, try to restore from global store using current trace_id
+    context = monitoring_context_store.retrieve_context()
+    if context and context.parent_context:
+        set_execution_context(context)
+        return context
+    return ExecutionContext()
 
 
 def set_execution_context(context: ExecutionContext) -> None:
-    """Set the current execution context."""
+    """Set the current monitoring execution context and persist it for cross-boundary access."""
     setattr(local, _CONTEXT_KEY, context)
 
+    # Always store in global store for cross-thread access
+    monitoring_context_store.store_context(context)
+
+
+def clear_execution_context() -> None:
+    """Clear the current monitoring execution context."""
+    if hasattr(local, _CONTEXT_KEY):
+        delattr(local, _CONTEXT_KEY)
+    monitoring_context_store.clear_context()
+
 
 def get_parent_context() -> ParentContext:
     return cast(ParentContext, get_execution_context().parent_context)
@@ -38,11 +60,7 @@ def execution_context(
 ) -> Iterator[None]:
     """Context manager for handling execution context."""
     prev_context = get_execution_context()
-    set_trace_id = (
-        prev_context.trace_id
-        if int(prev_context.trace_id)
-        else trace_id or UUID("00000000-0000-0000-0000-000000000000")
-    )
+    set_trace_id = prev_context.trace_id if int(prev_context.trace_id) else trace_id or uuid4()
     set_parent_context = parent_context or prev_context.parent_context
     set_context = ExecutionContext(parent_context=set_parent_context, trace_id=set_trace_id)
     try:

vellum/workflows/descriptors/base.py

@@ -1,11 +1,16 @@
 from typing import TYPE_CHECKING, Any, Generic, Optional, Tuple, Type, TypeVar, Union, cast, overload
 
+from pydantic import GetCoreSchemaHandler, ValidationInfo
+from pydantic_core import core_schema
+
 if TYPE_CHECKING:
     from vellum.workflows.expressions.accessor import AccessorExpression
+    from vellum.workflows.expressions.add import AddExpression
     from vellum.workflows.expressions.and_ import AndExpression
     from vellum.workflows.expressions.begins_with import BeginsWithExpression
     from vellum.workflows.expressions.between import BetweenExpression
     from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
+    from vellum.workflows.expressions.concat import ConcatExpression
     from vellum.workflows.expressions.contains import ContainsExpression
     from vellum.workflows.expressions.does_not_begin_with import DoesNotBeginWithExpression
     from vellum.workflows.expressions.does_not_contain import DoesNotContainExpression
@@ -17,6 +22,7 @@ if TYPE_CHECKING:
     from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
     from vellum.workflows.expressions.in_ import InExpression
     from vellum.workflows.expressions.is_blank import IsBlankExpression
+    from vellum.workflows.expressions.is_error import IsErrorExpression
     from vellum.workflows.expressions.is_nil import IsNilExpression
     from vellum.workflows.expressions.is_not_blank import IsNotBlankExpression
     from vellum.workflows.expressions.is_not_nil import IsNotNilExpression
@@ -24,8 +30,10 @@ if TYPE_CHECKING:
     from vellum.workflows.expressions.is_not_undefined import IsNotUndefinedExpression
     from vellum.workflows.expressions.is_null import IsNullExpression
     from vellum.workflows.expressions.is_undefined import IsUndefinedExpression
+    from vellum.workflows.expressions.length import LengthExpression
     from vellum.workflows.expressions.less_than import LessThanExpression
     from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
+    from vellum.workflows.expressions.minus import MinusExpression
     from vellum.workflows.expressions.not_between import NotBetweenExpression
     from vellum.workflows.expressions.not_in import NotInExpression
     from vellum.workflows.expressions.or_ import OrExpression
@@ -42,11 +50,15 @@ class BaseDescriptor(Generic[_T]):
     _name: str
     _types: Tuple[Type[_T], ...]
     _instance: Optional[_T]
+    _is_sensitive: bool = False
 
-    def __init__(self, *, name: str, types: Tuple[Type[_T], ...], instance: Optional[_T] = None) -> None:
+    def __init__(
+        self, *, name: str, types: Tuple[Type[_T], ...], instance: Optional[_T] = None, is_sensitive: bool = False
+    ) -> None:
         self._name = name
         self._types = types
         self._instance = instance
+        self._is_sensitive = is_sensitive
 
     @property
     def name(self) -> str:
@@ -56,6 +68,15 @@ class BaseDescriptor(Generic[_T]):
     def types(self) -> Tuple[Type[_T], ...]:
         return self._types
 
+    @property
+    def normalized_type(self) -> Type:
+        all_types = self._types
+        if len(all_types) == 1:
+            return all_types[0]
+        else:
+            # Union should be considered a type, but mypy doesn't agree
+            return Union[all_types]  # type: ignore[return-value]
+
     @property
     def instance(self) -> Optional[_T]:
         return self._instance
@@ -63,6 +84,10 @@ class BaseDescriptor(Generic[_T]):
     def resolve(self, state: "BaseState") -> _T:
         raise NotImplementedError("Descriptor must implement resolve method")
 
+    @property
+    def is_sensitive(self) -> bool:
+        return self._is_sensitive
+
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, type(self)):
             return False
@@ -125,11 +150,14 @@ class BaseDescriptor(Generic[_T]):
 
         return CoalesceExpression(lhs=self, rhs=other)
 
-    def __getitem__(self, field: Union[str, int]) -> "AccessorExpression":
+    def __getitem__(self, field: Union[str, int, "BaseDescriptor[str]", "BaseDescriptor[int]"]) -> "AccessorExpression":
         from vellum.workflows.expressions.accessor import AccessorExpression
 
         return AccessorExpression(base=self, field=field)
 
+    def __iter__(self) -> None:
+        raise TypeError(f"'{type(self).__name__}' object is not iterable")
+
     @overload
     def equals(self, other: "BaseDescriptor[_O]") -> "EqualsExpression[_T, _O]": ...
 
@@ -163,6 +191,17 @@ class BaseDescriptor(Generic[_T]):
 
         return LessThanExpression(lhs=self, rhs=other)
 
+    @overload
+    def __lt__(self, other: "BaseDescriptor[_O]") -> "LessThanExpression[_T, _O]": ...  # type: ignore[misc]
+
+    @overload
+    def __lt__(self, other: _O) -> "LessThanExpression[_T, _O]": ...
+
+    def __lt__(self, other: "Union[BaseDescriptor[_O], _O]") -> "LessThanExpression[_T, _O]":
+        from vellum.workflows.expressions.less_than import LessThanExpression
+
+        return LessThanExpression(lhs=self, rhs=other)
+
     @overload
     def greater_than(self, other: "BaseDescriptor[_O]") -> "GreaterThanExpression[_T, _O]": ...
 
@@ -174,6 +213,17 @@ class BaseDescriptor(Generic[_T]):
 
         return GreaterThanExpression(lhs=self, rhs=other)
 
+    @overload
+    def __gt__(self, other: "BaseDescriptor[_O]") -> "GreaterThanExpression[_T, _O]": ...  # type: ignore[misc]
+
+    @overload
+    def __gt__(self, other: _O) -> "GreaterThanExpression[_T, _O]": ...
+
+    def __gt__(self, other: "Union[BaseDescriptor[_O], _O]") -> "GreaterThanExpression[_T, _O]":
+        from vellum.workflows.expressions.greater_than import GreaterThanExpression
+
+        return GreaterThanExpression(lhs=self, rhs=other)
+
     @overload
     def less_than_or_equal_to(self, other: "BaseDescriptor[_O]") -> "LessThanOrEqualToExpression[_T, _O]": ...
 
@@ -185,6 +235,17 @@ class BaseDescriptor(Generic[_T]):
 
         return LessThanOrEqualToExpression(lhs=self, rhs=other)
 
+    @overload
+    def __le__(self, other: "BaseDescriptor[_O]") -> "LessThanOrEqualToExpression[_T, _O]": ...  # type: ignore[misc]
+
+    @overload
+    def __le__(self, other: _O) -> "LessThanOrEqualToExpression[_T, _O]": ...
+
+    def __le__(self, other: "Union[BaseDescriptor[_O], _O]") -> "LessThanOrEqualToExpression[_T, _O]":
+        from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
+
+        return LessThanOrEqualToExpression(lhs=self, rhs=other)
+
     @overload
     def greater_than_or_equal_to(self, other: "BaseDescriptor[_O]") -> "GreaterThanOrEqualToExpression[_T, _O]": ...
 
@@ -198,6 +259,17 @@ class BaseDescriptor(Generic[_T]):
 
         return GreaterThanOrEqualToExpression(lhs=self, rhs=other)
 
+    @overload
+    def __ge__(self, other: "BaseDescriptor[_O]") -> "GreaterThanOrEqualToExpression[_T, _O]": ...  # type: ignore[misc]
+
+    @overload
+    def __ge__(self, other: _O) -> "GreaterThanOrEqualToExpression[_T, _O]": ...
+
+    def __ge__(self, other: "Union[BaseDescriptor[_O], _O]") -> "GreaterThanOrEqualToExpression[_T, _O]":
+        from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
+
+        return GreaterThanOrEqualToExpression(lhs=self, rhs=other)
+
     @overload
     def contains(self, other: "BaseDescriptor[_O]") -> "ContainsExpression[_T, _O]": ...
 
@@ -358,3 +430,98 @@ class BaseDescriptor(Generic[_T]):
         from vellum.workflows.expressions.parse_json import ParseJsonExpression
 
         return ParseJsonExpression(expression=self)
+
+    def is_error(self) -> "IsErrorExpression":
+        from vellum.workflows.expressions.is_error import IsErrorExpression
+
+        return IsErrorExpression(expression=self)
+
+    @overload
+    def concat(self, other: "BaseDescriptor[_O]") -> "ConcatExpression[_T, _O]": ...
+
+    @overload
+    def concat(self, other: _O) -> "ConcatExpression[_T, _O]": ...
+
+    def concat(self, other: "Union[BaseDescriptor[_O], _O]") -> "ConcatExpression[_T, _O]":
+        from vellum.workflows.expressions.concat import ConcatExpression
+
+        return ConcatExpression(lhs=self, rhs=other)
+
+    def length(self) -> "LengthExpression[_T]":
+        from vellum.workflows.expressions.length import LengthExpression
+
+        return LengthExpression(expression=self)
+
+    @overload
+    def add(self, other: "BaseDescriptor[_O]") -> "AddExpression[_T, _O]": ...
+
+    @overload
+    def add(self, other: _O) -> "AddExpression[_T, _O]": ...
+
+    def add(self, other: "Union[BaseDescriptor[_O], _O]") -> "AddExpression[_T, _O]":
+        from vellum.workflows.expressions.add import AddExpression
+
+        return AddExpression(lhs=self, rhs=other)
+
+    @overload
+    def __add__(self, other: "BaseDescriptor[_O]") -> "AddExpression[_T, _O]": ...
+
+    @overload
+    def __add__(self, other: _O) -> "AddExpression[_T, _O]": ...
+
+    def __add__(self, other: "Union[BaseDescriptor[_O], _O]") -> "AddExpression[_T, _O]":
+        from vellum.workflows.expressions.add import AddExpression
+
+        return AddExpression(lhs=self, rhs=other)
+
+    @overload
+    def minus(self, other: "BaseDescriptor[_O]") -> "MinusExpression[_T, _O]": ...
+
+    @overload
+    def minus(self, other: _O) -> "MinusExpression[_T, _O]": ...
+
+    def minus(self, other: "Union[BaseDescriptor[_O], _O]") -> "MinusExpression[_T, _O]":
+        from vellum.workflows.expressions.minus import MinusExpression
+
+        return MinusExpression(lhs=self, rhs=other)
+
+    @overload
+    def __sub__(self, other: "BaseDescriptor[_O]") -> "MinusExpression[_T, _O]": ...
+
+    @overload
+    def __sub__(self, other: _O) -> "MinusExpression[_T, _O]": ...
+
+    def __sub__(self, other: "Union[BaseDescriptor[_O], _O]") -> "MinusExpression[_T, _O]":
+        from vellum.workflows.expressions.minus import MinusExpression
+
+        return MinusExpression(lhs=self, rhs=other)
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Type[Any], handler: GetCoreSchemaHandler
+    ) -> core_schema.CoreSchema:
+        def validate(value: Any, info: ValidationInfo) -> Any:
+            if isinstance(value, cls):
+                return value
+
+            if not isinstance(value, dict):
+                raise TypeError(f"Value must be an instance of {cls.__name__} or a dict")
+
+            context = info.context
+            if not isinstance(context, dict):
+                raise TypeError(f"Unexpected type for context: {type(context)}")
+
+            validator = context.get("descriptor_validator")
+            if validator and callable(validator):
+                return validator(value)
+
+            from vellum.workflows.references.constant import ConstantValueReference
+
+            return ConstantValueReference(value)
+
+        return core_schema.union_schema(
+            [
+                core_schema.is_instance_schema(cls),
+                core_schema.with_info_after_validator_function(validate, core_schema.dict_schema()),
+            ]
+        )

vellum/workflows/descriptors/exceptions.py

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

vellum/workflows/descriptors/tests/test_utils.py

@@ -1,9 +1,13 @@
 import pytest
+from typing import Any, Dict
 
+from vellum.client.types.vellum_error import VellumError
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.references.node import NodeReference
 from vellum.workflows.state.base import BaseState
 
 
@@ -96,6 +100,27 @@ class DummyNode(BaseNode[FixtureState]):
             ).does_not_contain("test"),
             False,
         ),
+        (
+            ConstantValueReference(
+                WorkflowError(
+                    message="This is a test",
+                    code=WorkflowErrorCode.USER_DEFINED_ERROR,
+                )
+            ).is_error(),
+            True,
+        ),
+        (
+            ConstantValueReference(
+                VellumError(
+                    message="This is a test",
+                    code="USER_DEFINED_ERROR",
+                )
+            ).is_error(),
+            True,
+        ),
+        (FixtureState.alpha.is_error(), False),
+        (FixtureState.eta.is_error(), False),
+        (DummyNode.Outputs.empty.is_error(), False),
         (ConstantValueReference('{"foo": "bar"}').parse_json(), {"foo": "bar"}),
         (ConstantValueReference('{"foo": "bar"}').parse_json()["foo"], "bar"),
         (ConstantValueReference("[1, 2, 3]").parse_json(), [1, 2, 3]),
@@ -103,6 +128,15 @@ class DummyNode(BaseNode[FixtureState]):
         (ConstantValueReference(b'{"foo": "bar"}').parse_json(), {"foo": "bar"}),
         (ConstantValueReference(bytearray(b'{"foo": "bar"}')).parse_json(), {"foo": "bar"}),
         (ConstantValueReference(b'{"key": "\xf0\x9f\x8c\x9f"}').parse_json(), {"key": "🌟"}),
+        # Test + operator
+        (FixtureState.alpha + FixtureState.beta, 3),
+        (FixtureState.gamma + FixtureState.delta, "helloel"),
+        (FixtureState.theta + FixtureState.theta, ["baz", "baz"]),
+        # Test comparison operators
+        (FixtureState.alpha < FixtureState.beta, True),
+        (FixtureState.alpha > FixtureState.beta, False),
+        (FixtureState.alpha <= FixtureState.beta, True),
+        (FixtureState.alpha >= FixtureState.beta, False),
     ],
     ids=[
         "or",
@@ -150,6 +184,11 @@ class DummyNode(BaseNode[FixtureState]):
         "list_index",
         "error_contains",
         "error_does_not_contain",
+        "is_error_on_workflow_error",
+        "is_error_on_vellum_error",
+        "is_error_on_value",
+        "is_error_on_null",
+        "is_error_on_undefined",
         "parse_json_constant",
         "parse_json_accessor",
         "parse_json_list",
@@ -157,8 +196,35 @@ class DummyNode(BaseNode[FixtureState]):
         "parse_json_bytes",
         "parse_json_bytearray",
         "parse_json_bytes_with_utf8_chars",
+        "add_integers",
+        "add_strings",
+        "add_lists",
+        "lt_operator",
+        "gt_operator",
+        "le_operator",
+        "ge_operator",
     ],
 )
 def test_resolve_value__happy_path(descriptor, expected_value):
     actual_value = resolve_value(descriptor, FixtureState())
     assert actual_value == expected_value
+
+
+def test_resolve_value__node_reference_without_is_sensitive__raises_node_exception():
+    """
+    Tests that resolve_value handles NodeReference (which bypasses BaseDescriptor.__init__) gracefully.
+    """
+
+    # GIVEN a NodeReference that doesn't have _is_sensitive defined
+    node_ref = NodeReference(name="test_node", types=(str,), node_class=DummyNode)
+
+    # AND a state object
+    state = FixtureState()
+
+    # AND a memo dict to track resolved values (important-comment)
+    memo: Dict[str, Any] = {}
+
+    # WHEN we call resolve_value with this NodeReference (important-comment)
+    # THEN it should raise NodeException (not AttributeError)
+    with pytest.raises(NodeException, match="NodeDescriptors cannot be resolved during runtime"):
+        resolve_value(node_ref, state, path="test.path", memo=memo)

vellum/workflows/descriptors/utils.py

@@ -1,7 +1,8 @@
 from collections.abc import Mapping
 import dataclasses
 import inspect
-from typing import Any, Dict, Optional, Sequence, Set, TypeVar, Union, cast, overload
+from typing import Any, Dict, Optional, Sequence, Set, Type, TypeVar, Union, cast, overload
+from typing_extensions import TypeGuard
 
 from pydantic import BaseModel
 
@@ -32,13 +33,19 @@ def resolve_value(
     from the `_T` generic.
     """
 
+    if memo is not None and path in memo:
+        return cast(_T, memo[path])
+
     if inspect.isclass(value):
         return cast(_T, value)
 
     if isinstance(value, BaseDescriptor):
         resolved_value = value.resolve(state)
         if memo is not None:
-            memo[path] = resolved_value
+            if value.is_sensitive:
+                memo[path] = value
+            else:
+                memo[path] = resolved_value
         return resolved_value
 
     if isinstance(value, property) or callable(value):
@@ -103,7 +110,7 @@ def is_unresolved(value: Any) -> bool:
         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())
+        return any(is_unresolved(getattr(value, key)) for key in value.__class__.model_fields.keys())
 
     if isinstance(value, Mapping):
         return any(is_unresolved(item) for item in value.values())
@@ -115,3 +122,20 @@ def is_unresolved(value: Any) -> bool:
         return any(is_unresolved(item) for item in value)
 
     return False
+
+
+_ResolvedType = TypeVar("_ResolvedType")
+
+
+def is_resolved_instance(value: Any, type_: Type[_ResolvedType]) -> TypeGuard[_ResolvedType]:
+    """
+    Checks if a value is an instance of a type or a descriptor that resolves to that type.
+    """
+
+    if isinstance(value, type_):
+        return True
+
+    if isinstance(value, BaseDescriptor) and value.types:
+        return issubclass(value.types[0], type_)
+
+    return False

vellum/workflows/edges/__init__.py

@@ -1,5 +1,7 @@
 from .edge import Edge
+from .trigger_edge import TriggerEdge
 
 __all__ = [
     "Edge",
+    "TriggerEdge",
 ]