vellum-ai 1.7.4__py3-none-any.whl → 1.7.5__py3-none-any.whl

vellum/workflows/graph/graph.py

@@ -3,11 +3,13 @@ from typing import TYPE_CHECKING, Iterator, List, Optional, Set, Type, Union
 from orderly_set import OrderedSet
 
 from vellum.workflows.edges.edge import Edge
+from vellum.workflows.edges.trigger_edge import TriggerEdge
 from vellum.workflows.types.generics import NodeType
 
 if TYPE_CHECKING:
     from vellum.workflows.nodes.bases.base import BaseNode
     from vellum.workflows.ports.port import Port
+    from vellum.workflows.triggers.base import BaseTrigger
 
 
 class NoPortsNode:
@@ -46,16 +48,19 @@ class Graph:
     _entrypoints: Set[Union["Port", "NoPortsNode"]]
     _edges: List[Edge]
     _terminals: Set[Union["Port", "NoPortsNode"]]
+    _trigger_edges: List[TriggerEdge]
 
     def __init__(
         self,
         entrypoints: Set[Union["Port", "NoPortsNode"]],
         edges: List[Edge],
         terminals: Set[Union["Port", "NoPortsNode"]],
+        trigger_edges: Optional[List[TriggerEdge]] = None,
     ):
         self._edges = edges
         self._entrypoints = entrypoints
         self._terminals = terminals
+        self._trigger_edges = trigger_edges or []
 
     @staticmethod
     def from_port(port: "Port") -> "Graph":
@@ -96,12 +101,79 @@ class Graph:
     def from_edge(edge: Edge) -> "Graph":
         return Graph(entrypoints={edge.from_port}, edges=[edge], terminals={port for port in edge.to_node.Ports})
 
+    @staticmethod
+    def from_trigger_edge(edge: TriggerEdge) -> "Graph":
+        """
+        Create a graph from a single TriggerEdge (Trigger >> Node).
+
+        Args:
+            edge: TriggerEdge connecting a trigger to a node
+
+        Returns:
+            Graph with the trigger edge and the target node's ports as terminals
+        """
+        ports = {port for port in edge.to_node.Ports}
+        if not ports:
+            no_ports_node = NoPortsNode(edge.to_node)
+            return Graph(
+                entrypoints={no_ports_node},
+                edges=[],
+                terminals={no_ports_node},
+                trigger_edges=[edge],
+            )
+        return Graph(
+            entrypoints=set(ports),
+            edges=[],
+            terminals=set(ports),
+            trigger_edges=[edge],
+        )
+
+    @staticmethod
+    def from_trigger_edges(edges: List[TriggerEdge]) -> "Graph":
+        """
+        Create a graph from multiple TriggerEdges (e.g., Trigger >> {NodeA, NodeB}).
+
+        Args:
+            edges: List of TriggerEdges
+
+        Returns:
+            Graph with all trigger edges and target nodes' ports as entrypoints/terminals
+        """
+        entrypoints: Set[Union["Port", NoPortsNode]] = set()
+        terminals: Set[Union["Port", NoPortsNode]] = set()
+
+        for edge in edges:
+            ports = {port for port in edge.to_node.Ports}
+            if not ports:
+                no_ports_node = NoPortsNode(edge.to_node)
+                entrypoints.add(no_ports_node)
+                terminals.add(no_ports_node)
+            else:
+                entrypoints.update(ports)
+                terminals.update(ports)
+
+        return Graph(
+            entrypoints=entrypoints,
+            edges=[],
+            terminals=terminals,
+            trigger_edges=edges,
+        )
+
     @staticmethod
     def empty() -> "Graph":
         """Create an empty graph with no entrypoints, edges, or terminals."""
         return Graph(entrypoints=set(), edges=[], terminals=set())
 
     def __rshift__(self, other: GraphTarget) -> "Graph":
+        # Check for trigger target (class-level only)
+        from vellum.workflows.triggers.base import BaseTrigger
+
+        if isinstance(other, type) and issubclass(other, BaseTrigger):
+            raise TypeError(
+                f"Cannot create edge targeting trigger {other.__name__}. "
+                f"Triggers must be at the start of a graph path, not as targets."
+            )
+
         if not self._edges and not self._entrypoints:
             raise ValueError("Graph instance can only create new edges from nodes within existing edges")
 
@@ -179,9 +251,30 @@ class Graph:
     def edges(self) -> Iterator[Edge]:
         return iter(self._edges)
 
+    @property
+    def trigger_edges(self) -> Iterator[TriggerEdge]:
+        """Get all trigger edges in this graph."""
+        return iter(self._trigger_edges)
+
+    @property
+    def triggers(self) -> Iterator[Type["BaseTrigger"]]:
+        """Get all unique trigger classes in this graph."""
+        seen_triggers = set()
+        for trigger_edge in self._trigger_edges:
+            if trigger_edge.trigger_class not in seen_triggers:
+                seen_triggers.add(trigger_edge.trigger_class)
+                yield trigger_edge.trigger_class
+
     @property
     def nodes(self) -> Iterator[Type["BaseNode"]]:
         nodes = set()
+
+        # Include nodes from trigger edges
+        for trigger_edge in self._trigger_edges:
+            if trigger_edge.to_node not in nodes:
+                nodes.add(trigger_edge.to_node)
+                yield trigger_edge.to_node
+
         if not self._edges:
             for node in self.entrypoints:
                 if node not in nodes:

vellum/workflows/graph/tests/test_graph.py

@@ -1,7 +1,10 @@
+import pytest
+
 from vellum.workflows.edges.edge import Edge
 from vellum.workflows.graph.graph import Graph
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.ports.port import Port
+from vellum.workflows.triggers import ManualTrigger
 
 
 def test_graph__empty():
@@ -617,3 +620,167 @@ def test_graph__from_node_with_empty_ports():
 
     # THEN the graph should have exactly 1 node
     assert len(list(graph.nodes)) == 1
+
+
+def test_graph__manual_trigger_to_node():
+    # GIVEN a node
+    class MyNode(BaseNode):
+        pass
+
+    # WHEN we create graph with ManualTrigger >> Node (class-level, no instantiation)
+    graph = ManualTrigger >> MyNode
+
+    # THEN the graph has one trigger edge
+    trigger_edges = list(graph.trigger_edges)
+    assert len(trigger_edges) == 1
+    assert trigger_edges[0].trigger_class == ManualTrigger
+    assert trigger_edges[0].to_node == MyNode
+
+    # AND the graph has one trigger
+    triggers = list(graph.triggers)
+    assert len(triggers) == 1
+    assert triggers[0] == ManualTrigger
+
+    # AND the graph has one node
+    assert len(list(graph.nodes)) == 1
+    assert MyNode in list(graph.nodes)
+
+
+def test_graph__manual_trigger_to_set_of_nodes():
+    # GIVEN two nodes
+    class NodeA(BaseNode):
+        pass
+
+    class NodeB(BaseNode):
+        pass
+
+    # WHEN we create graph with ManualTrigger >> {NodeA, NodeB}
+    graph = ManualTrigger >> {NodeA, NodeB}
+
+    # THEN the graph has two trigger edges
+    trigger_edges = list(graph.trigger_edges)
+    assert len(trigger_edges) == 2
+
+    # AND both edges connect to the same ManualTrigger class
+    assert all(edge.trigger_class == ManualTrigger for edge in trigger_edges)
+
+    # AND edges connect to both nodes
+    target_nodes = {edge.to_node for edge in trigger_edges}
+    assert target_nodes == {NodeA, NodeB}
+
+    # AND the graph has one unique trigger
+    triggers = list(graph.triggers)
+    assert len(triggers) == 1
+
+    # AND the graph has two nodes
+    assert len(list(graph.nodes)) == 2
+
+
+def test_graph__manual_trigger_to_graph():
+    # GIVEN a graph of nodes
+    class NodeA(BaseNode):
+        pass
+
+    class NodeB(BaseNode):
+        pass
+
+    node_graph = NodeA >> NodeB
+
+    # WHEN we create graph with ManualTrigger >> Graph
+    graph = ManualTrigger >> node_graph
+
+    # THEN the graph has a trigger edge to the entrypoint
+    trigger_edges = list(graph.trigger_edges)
+    assert len(trigger_edges) == 1
+    assert trigger_edges[0].to_node == NodeA
+
+    # AND the graph preserves the original edges
+    edges = list(graph.edges)
+    assert len(edges) == 1
+    assert edges[0].to_node == NodeB
+
+    # AND the graph has both nodes
+    nodes = list(graph.nodes)
+    assert len(nodes) == 2
+    assert NodeA in nodes
+    assert NodeB in nodes
+
+
+def test_graph__manual_trigger_to_set_of_graphs_preserves_edges():
+    # GIVEN two graphs of nodes
+    class NodeA(BaseNode):
+        pass
+
+    class NodeB(BaseNode):
+        pass
+
+    class NodeC(BaseNode):
+        pass
+
+    class NodeD(BaseNode):
+        pass
+
+    graph_one = NodeA >> NodeB
+    graph_two = NodeC >> NodeD
+
+    # WHEN we create a graph with ManualTrigger >> {Graph1, Graph2}
+    combined_graph = ManualTrigger >> {graph_one, graph_two}
+
+    # THEN the combined graph has trigger edges to both entrypoints
+    trigger_edges = list(combined_graph.trigger_edges)
+    assert len(trigger_edges) == 2
+    assert {edge.to_node for edge in trigger_edges} == {NodeA, NodeC}
+
+    # AND the combined graph preserves all downstream edges
+    edges = list(combined_graph.edges)
+    assert len(edges) == 2
+    assert {(edge.from_port.node_class, edge.to_node) for edge in edges} == {
+        (NodeA, NodeB),
+        (NodeC, NodeD),
+    }
+
+    # AND the combined graph still exposes all nodes
+    nodes = list(combined_graph.nodes)
+    assert {NodeA, NodeB, NodeC, NodeD}.issubset(nodes)
+
+
+def test_graph__node_to_trigger_raises():
+    # GIVEN a node and trigger
+    class MyNode(BaseNode):
+        pass
+
+    # WHEN we try to create Node >> Trigger (class-level)
+    # THEN it raises TypeError
+    with pytest.raises(TypeError, match="Cannot create edge targeting trigger"):
+        MyNode >> ManualTrigger
+
+    # WHEN we try to create Node >> Trigger (instance-level)
+    # THEN it also raises TypeError
+    with pytest.raises(TypeError, match="Cannot create edge targeting trigger"):
+        MyNode >> ManualTrigger
+
+
+def test_graph__trigger_then_graph_then_node():
+    # GIVEN a trigger, a node, and another node
+    class StartNode(BaseNode):
+        pass
+
+    class EndNode(BaseNode):
+        pass
+
+    # WHEN we create Trigger >> Node >> Node
+    graph = ManualTrigger >> StartNode >> EndNode
+
+    # THEN the graph has one trigger edge
+    trigger_edges = list(graph.trigger_edges)
+    assert len(trigger_edges) == 1
+    assert trigger_edges[0].to_node == StartNode
+
+    # AND the graph has one regular edge
+    edges = list(graph.edges)
+    assert len(edges) == 1
+    assert edges[0].to_node == EndNode
+
+    # AND the graph has both nodes
+    nodes = list(graph.nodes)
+    assert len(nodes) == 2

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

@@ -47,7 +47,7 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
     functions: ClassVar[List[Tool]] = []
     prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
     parameters: PromptParameters = DEFAULT_PROMPT_PARAMETERS
-    max_prompt_iterations: ClassVar[Optional[int]] = 5
+    max_prompt_iterations: ClassVar[Optional[int]] = 25
     settings: ClassVar[Optional[Union[PromptSettings, Dict[str, Any]]]] = None
 
     class Outputs(BaseOutputs):

vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -89,7 +89,7 @@ class FunctionCallNodeMixin:
 
 
 class ToolPromptNode(InlinePromptNode[ToolCallingState]):
-    max_prompt_iterations: Optional[int] = 5
+    max_prompt_iterations: Optional[int] = 25
 
     class Trigger(InlinePromptNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ATTRIBUTES

vellum/workflows/ports/port.py

@@ -61,6 +61,17 @@ class Port:
         return iter(self._edges)
 
     def __rshift__(self, other: GraphTarget) -> Graph:
+        # Check for trigger target (class-level only)
+        from vellum.workflows.triggers.base import BaseTrigger
+
+        # Check if other is a trigger class
+        if isinstance(other, type) and issubclass(other, BaseTrigger):
+            raise TypeError(
+                f"Cannot create edge targeting trigger {other.__name__}. "
+                f"Triggers must be at the start of a graph path, not as targets. "
+                f"Did you mean: {other.__name__} >> {self.node_class.__name__}?"
+            )
+
         if isinstance(other, set) or isinstance(other, Graph):
             return Graph.from_port(self) >> other
 

vellum/workflows/runner/runner.py

@@ -74,6 +74,7 @@ from vellum.workflows.references import ExternalInputReference, OutputReference
 from vellum.workflows.references.state_value import StateValueReference
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.delta import StateDelta
+from vellum.workflows.types.core import CancelSignal
 from vellum.workflows.types.generics import InputsType, OutputsType, StateType
 
 if TYPE_CHECKING:
@@ -103,7 +104,7 @@ class WorkflowRunner(Generic[StateType]):
         entrypoint_nodes: Optional[RunFromNodeArg] = None,
         external_inputs: Optional[ExternalInputsArg] = None,
         previous_execution_id: Optional[Union[str, UUID]] = None,
-        cancel_signal: Optional[ThreadingEvent] = None,
+        cancel_signal: Optional[CancelSignal] = None,
         node_output_mocks: Optional[MockNodeExecutionArg] = None,
         max_concurrency: Optional[int] = None,
         init_execution_context: Optional[ExecutionContext] = None,
@@ -799,13 +800,14 @@ class WorkflowRunner(Generic[StateType]):
             parent=self._execution_context.parent_context,
         )
 
-    def _fulfill_workflow_event(self, outputs: OutputsType) -> WorkflowExecutionFulfilledEvent:
+    def _fulfill_workflow_event(self, outputs: OutputsType, final_state: StateType) -> WorkflowExecutionFulfilledEvent:
         return WorkflowExecutionFulfilledEvent(
             trace_id=self._execution_context.trace_id,
             span_id=self._initial_state.meta.span_id,
             body=WorkflowExecutionFulfilledBody(
                 workflow_definition=self.workflow.__class__,
                 outputs=outputs,
+                final_state=final_state,
             ),
             parent=self._execution_context.parent_context,
         )
@@ -961,7 +963,7 @@ class WorkflowRunner(Generic[StateType]):
                     descriptor.instance.resolve(final_state),
                 )
 
-        self._workflow_event_outer_queue.put(self._fulfill_workflow_event(fulfilled_outputs))
+        self._workflow_event_outer_queue.put(self._fulfill_workflow_event(fulfilled_outputs, final_state))
 
     def _run_background_thread(self) -> None:
         state_class = self.workflow.get_state_class()

vellum/workflows/triggers/__init__.py

@@ -0,0 +1,4 @@
+from vellum.workflows.triggers.base import BaseTrigger
+from vellum.workflows.triggers.manual import ManualTrigger
+
+__all__ = ["BaseTrigger", "ManualTrigger"]

vellum/workflows/triggers/base.py

@@ -0,0 +1,125 @@
+from abc import ABC, ABCMeta
+from typing import TYPE_CHECKING, Any, Type, cast
+
+if TYPE_CHECKING:
+    from vellum.workflows.graph.graph import Graph, GraphTarget
+
+
+class BaseTriggerMeta(ABCMeta):
+    """
+    Metaclass for BaseTrigger that enables class-level >> operator.
+
+    This allows triggers to be used at the class level, similar to nodes:
+        ManualTrigger >> MyNode  # Class-level, no instantiation
+    """
+
+    def __rshift__(cls, other: "GraphTarget") -> "Graph":  # type: ignore[misc]
+        """
+        Enable Trigger class >> Node syntax (class-level only).
+
+        Args:
+            other: The target to connect to - can be a Node, Graph, or set of Nodes
+
+        Returns:
+            Graph: A graph object with trigger edges
+
+        Examples:
+            ManualTrigger >> MyNode
+            ManualTrigger >> {NodeA, NodeB}
+            ManualTrigger >> (NodeA >> NodeB)
+        """
+        from vellum.workflows.edges.trigger_edge import TriggerEdge
+        from vellum.workflows.graph.graph import Graph
+        from vellum.workflows.nodes.bases.base import BaseNode as BaseNodeClass
+
+        # Cast cls to the proper type for TriggerEdge
+        trigger_cls = cast("Type[BaseTrigger]", cls)
+
+        if isinstance(other, set):
+            # Trigger >> {NodeA, NodeB}
+            trigger_edges = []
+            graph_items = []
+            for item in other:
+                if isinstance(item, type) and issubclass(item, BaseNodeClass):
+                    trigger_edges.append(TriggerEdge(trigger_cls, item))
+                elif isinstance(item, Graph):
+                    # Trigger >> {Graph1, Graph2}
+                    graph_items.append(item)
+                    for entrypoint in item.entrypoints:
+                        trigger_edges.append(TriggerEdge(trigger_cls, entrypoint))
+                else:
+                    raise TypeError(
+                        f"Cannot connect trigger to {type(item).__name__}. " f"Expected BaseNode or Graph in set."
+                    )
+
+            result_graph = Graph.from_trigger_edges(trigger_edges)
+
+            for graph_item in graph_items:
+                result_graph._extend_edges(graph_item.edges)
+                result_graph._terminals.update(graph_item._terminals)
+                for existing_trigger_edge in graph_item._trigger_edges:
+                    if existing_trigger_edge not in result_graph._trigger_edges:
+                        result_graph._trigger_edges.append(existing_trigger_edge)
+
+            return result_graph
+
+        elif isinstance(other, Graph):
+            # Trigger >> Graph
+            edges = [TriggerEdge(trigger_cls, entrypoint) for entrypoint in other.entrypoints]
+            result_graph = Graph.from_trigger_edges(edges)
+            # Also include the edges from the original graph
+            result_graph._extend_edges(other.edges)
+            result_graph._terminals = other._terminals
+            return result_graph
+
+        elif isinstance(other, type) and issubclass(other, BaseNodeClass):
+            # Trigger >> Node
+            edge = TriggerEdge(trigger_cls, other)
+            return Graph.from_trigger_edge(edge)
+
+        else:
+            raise TypeError(
+                f"Cannot connect trigger to {type(other).__name__}. " f"Expected BaseNode, Graph, or set of BaseNodes."
+            )
+
+    def __rrshift__(cls, other: Any) -> "Graph":
+        """
+        Prevent Node >> Trigger class syntax.
+
+        Raises:
+            TypeError: Always, as this operation is not allowed
+        """
+        raise TypeError(
+            f"Cannot create edge targeting trigger {cls.__name__}. "
+            f"Triggers must be at the start of a graph path, not as targets. "
+            f"Did you mean: {cls.__name__} >> {other.__name__ if hasattr(other, '__name__') else other}?"
+        )
+
+
+class BaseTrigger(ABC, metaclass=BaseTriggerMeta):
+    """
+    Base class for workflow triggers - first-class graph elements.
+
+    Triggers define how and when a workflow execution is initiated. They are integrated
+    into the workflow graph using the >> operator and can connect to nodes at the class level.
+
+    Examples:
+        # Class-level usage (consistent with nodes)
+        ManualTrigger >> MyNode
+        ManualTrigger >> {NodeA, NodeB}
+        ManualTrigger >> (NodeA >> NodeB)
+
+    Subclass Hierarchy:
+        - ManualTrigger: Explicit workflow invocation (default)
+        - IntegrationTrigger: External service triggers (base for Slack, GitHub, etc.)
+        - ScheduledTrigger: Time-based triggers with cron/interval schedules
+
+    Important:
+        Triggers can only appear at the start of graph paths. Attempting to create
+        edges targeting triggers (Node >> Trigger) will raise a TypeError.
+
+    Note:
+        Like nodes, triggers work at the class level only. Do not instantiate triggers.
+    """
+
+    pass

vellum/workflows/triggers/manual.py

@@ -0,0 +1,37 @@
+from vellum.workflows.triggers.base import BaseTrigger
+
+
+class ManualTrigger(BaseTrigger):
+    """
+    Default trigger representing explicit workflow invocation.
+
+    ManualTrigger is used when workflows are explicitly invoked via:
+    - workflow.run() method calls
+    - workflow.stream() method calls
+    - API calls to execute the workflow
+
+    This is the default trigger for all workflows. When no trigger is specified
+    in a workflow's graph definition, ManualTrigger is implicitly added.
+
+    Examples:
+        # Explicit ManualTrigger (equivalent to implicit)
+        class MyWorkflow(BaseWorkflow):
+            graph = ManualTrigger >> MyNode
+
+        # Implicit ManualTrigger (normalized to above)
+        class MyWorkflow(BaseWorkflow):
+            graph = MyNode
+
+    Characteristics:
+        - Provides no trigger-specific inputs
+        - Always ready to execute when invoked
+        - Simplest trigger type with no configuration
+        - Default behavior for backward compatibility
+
+    Comparison with other triggers:
+        - IntegrationTrigger: Responds to external events (webhooks, API calls)
+        - ScheduledTrigger: Executes based on time/schedule configuration
+        - ManualTrigger: Executes when explicitly called
+    """
+
+    pass

vellum/workflows/workflows/base.py

@@ -4,7 +4,6 @@ from functools import lru_cache
 import importlib
 import inspect
 import logging
-from threading import Event as ThreadingEvent
 from uuid import UUID, uuid4
 from typing import (
     Any,
@@ -76,6 +75,7 @@ from vellum.workflows.runner.runner import ExternalInputsArg, RunFromNodeArg
 from vellum.workflows.state.base import BaseState, StateMeta
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.state.store import Store
+from vellum.workflows.types import CancelSignal
 from vellum.workflows.types.generics import InputsType, StateType
 from vellum.workflows.types.utils import get_original_base
 from vellum.workflows.utils.uuids import uuid4_from_hash
@@ -227,12 +227,12 @@ class BaseWorkflow(Generic[InputsType, StateType], BaseExecutable, metaclass=_Ba
     WorkflowEvent = Union[  # type: ignore
         GenericWorkflowEvent,
         WorkflowExecutionInitiatedEvent[InputsType, StateType],  # type: ignore[valid-type]
-        WorkflowExecutionFulfilledEvent[Outputs],
+        WorkflowExecutionFulfilledEvent[Outputs, StateType],  # type: ignore[valid-type]
         WorkflowExecutionSnapshottedEvent[StateType],  # type: ignore[valid-type]
     ]
 
     TerminalWorkflowEvent = Union[
-        WorkflowExecutionFulfilledEvent[Outputs],
+        WorkflowExecutionFulfilledEvent[Outputs, StateType],  # type: ignore[valid-type]
         WorkflowExecutionRejectedEvent,
         WorkflowExecutionPausedEvent,
     ]
@@ -374,7 +374,7 @@ class BaseWorkflow(Generic[InputsType, StateType], BaseExecutable, metaclass=_Ba
         entrypoint_nodes: Optional[RunFromNodeArg] = None,
         external_inputs: Optional[ExternalInputsArg] = None,
         previous_execution_id: Optional[Union[str, UUID]] = None,
-        cancel_signal: Optional[ThreadingEvent] = None,
+        cancel_signal: Optional[CancelSignal] = None,
         node_output_mocks: Optional[MockNodeExecutionArg] = None,
         max_concurrency: Optional[int] = None,
     ) -> TerminalWorkflowEvent:
@@ -402,8 +402,8 @@ class BaseWorkflow(Generic[InputsType, StateType], BaseExecutable, metaclass=_Ba
         previous_execution_id: Optional[Union[str, UUID]] = None
             The execution ID of the previous execution to resume from.
 
-        cancel_signal: Optional[ThreadingEvent] = None
-            A threading event that can be used to cancel the Workflow Execution.
+        cancel_signal: Optional[CancelSignal] = None
+            A cancel signal that can be used to cancel the Workflow Execution.
 
         node_output_mocks: Optional[MockNodeExecutionArg] = None
             A list of Outputs to mock for Nodes during Workflow Execution. Each mock can include a `when_condition`
@@ -493,7 +493,7 @@ class BaseWorkflow(Generic[InputsType, StateType], BaseExecutable, metaclass=_Ba
         entrypoint_nodes: Optional[RunFromNodeArg] = None,
         external_inputs: Optional[ExternalInputsArg] = None,
         previous_execution_id: Optional[Union[str, UUID]] = None,
-        cancel_signal: Optional[ThreadingEvent] = None,
+        cancel_signal: Optional[CancelSignal] = None,
         node_output_mocks: Optional[MockNodeExecutionArg] = None,
         max_concurrency: Optional[int] = None,
     ) -> WorkflowEventStream:
@@ -522,8 +522,8 @@ class BaseWorkflow(Generic[InputsType, StateType], BaseExecutable, metaclass=_Ba
         previous_execution_id: Optional[Union[str, UUID]] = None
             The execution ID of the previous execution to resume from.
 
-        cancel_signal: Optional[ThreadingEvent] = None
-            A threading event that can be used to cancel the Workflow Execution.
+        cancel_signal: Optional[CancelSignal] = None
+            A cancel signal that can be used to cancel the Workflow Execution.
 
         node_output_mocks: Optional[MockNodeExecutionArg] = None
             A list of Outputs to mock for Nodes during Workflow Execution. Each mock can include a `when_condition`

{vellum_ai-1.7.4.dist-info → vellum_ai-1.7.5.dist-info}/METADATA

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