vellum-ai 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

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

@@ -47,8 +47,9 @@ class FunctionCallNodeMixin:
 
     def _extract_function_arguments(self) -> dict:
         """Extract arguments from function call output."""
-        if self.function_call_output and len(self.function_call_output) > 0:
-            function_call = self.function_call_output[0]
+        current_index = getattr(self, "state").current_prompt_output_index
+        if self.function_call_output and len(self.function_call_output) > current_index:
+            function_call = self.function_call_output[current_index]
             if function_call.type == "FUNCTION_CALL" and function_call.value is not None:
                 return function_call.value.arguments or {}
         return {}
@@ -66,7 +67,7 @@ class FunctionCallNodeMixin:
             state.current_prompt_output_index += 1
 
 
-class ToolRouterNode(InlinePromptNode[ToolCallingState]):
+class ToolPromptNode(InlinePromptNode[ToolCallingState]):
     max_prompt_iterations: Optional[int] = 5
 
     class Trigger(InlinePromptNode.Trigger):
@@ -115,13 +116,7 @@ class ToolRouterNode(InlinePromptNode[ToolCallingState]):
 class RouterNode(BaseNode[ToolCallingState]):
     """Router node that handles routing to function nodes based on outputs."""
 
-    class Trigger(BaseNode.Trigger):
-        merge_behavior = MergeBehavior.AWAIT_ATTRIBUTES
-
-    def run(self) -> Iterator[BaseOutput]:
-        # Router node doesn't process outputs or create chat messages
-        # It just handles the routing logic via its ports
-        yield from []
+    pass
 
 
 class DynamicSubworkflowDeploymentNode(SubworkflowDeploymentNode[ToolCallingState], FunctionCallNodeMixin):
@@ -134,8 +129,8 @@ class DynamicSubworkflowDeploymentNode(SubworkflowDeploymentNode[ToolCallingStat
         # we do in the `__init__` method. Long term, instead of the function_call_output attribute above, we
         # want to do:
         # ```python
-        # subworkflow_inputs = tool_router_node.Outputs.results[0]['value']['arguments'].if_(
-        #     tool_router_node.Outputs.results[0]['type'].equals('FUNCTION_CALL'),
+        # subworkflow_inputs = tool_prompt_node.Outputs.results[0]['value']['arguments'].if_(
+        #     tool_prompt_node.Outputs.results[0]['type'].equals('FUNCTION_CALL'),
         #     {},
         # )
         # ```
@@ -255,10 +250,10 @@ class ElseNode(BaseNode[ToolCallingState]):
 
     class Ports(BaseNode.Ports):
         # Redefined in the create_else_node function, but defined here to resolve mypy errors
-        loop = Port.on_if(
-            ToolCallingState.current_prompt_output_index.less_than(1)
-            | ToolCallingState.current_function_calls_processed.greater_than(0)
+        loop_to_router = Port.on_if(
+            ToolCallingState.current_prompt_output_index.less_than(ToolPromptNode.Outputs.results.length())
         )
+        loop_to_prompt = Port.on_elif(ToolCallingState.current_function_calls_processed.greater_than(0))
         end = Port.on_else()
 
     def run(self) -> BaseNode.Outputs:
@@ -317,46 +312,22 @@ def hydrate_mcp_tool_definitions(server_def: MCPServer) -> List[MCPToolDefinitio
         return []
 
 
-def create_tool_router_node(
+def create_tool_prompt_node(
     ml_model: str,
     blocks: List[Union[PromptBlock, Dict[str, Any]]],
     functions: List[Tool],
     prompt_inputs: Optional[EntityInputsInterface],
     parameters: PromptParameters,
     max_prompt_iterations: Optional[int] = None,
-) -> Type[ToolRouterNode]:
+) -> Type[ToolPromptNode]:
     if functions and len(functions) > 0:
-        # Create dynamic ports and convert functions in a single loop
-        Ports = type("Ports", (), {})
         prompt_functions: List[Union[Tool, FunctionDefinition]] = []
 
-        # Avoid using lambda to capture function_name
-        # lambda will capture the function_name by reference,
-        # and if the function_name is changed, the port_condition will also change.
-        def create_port_condition(fn_name):
-            return Port.on_if(
-                LazyReference(
-                    lambda: (
-                        ToolCallingState.current_prompt_output_index.less_than(node.Outputs.results.length())
-                        & node.Outputs.results[ToolCallingState.current_prompt_output_index]["type"].equals(
-                            "FUNCTION_CALL"
-                        )
-                        & node.Outputs.results[ToolCallingState.current_prompt_output_index]["value"]["name"].equals(
-                            fn_name
-                        )
-                    )
-                )
-            )
-
         for function in functions:
             if isinstance(function, ComposioToolDefinition):
                 # Get Composio tool details and hydrate the function definition
                 enhanced_function = _hydrate_composio_tool_definition(function)
                 prompt_functions.append(enhanced_function)
-                # Create port for this function (using original function for get_function_name)
-                function_name = get_function_name(function)
-                port = create_port_condition(function_name)
-                setattr(Ports, function_name, port)
             elif isinstance(function, MCPServer):
                 tool_functions: List[MCPToolDefinition] = hydrate_mcp_tool_definitions(function)
                 for tool_function in tool_functions:
@@ -368,19 +339,9 @@ def create_tool_router_node(
                             parameters=tool_function.parameters,
                         )
                     )
-                    port = create_port_condition(name)
-                    setattr(Ports, name, port)
             else:
                 prompt_functions.append(function)
-                function_name = get_function_name(function)
-                port = create_port_condition(function_name)
-                setattr(Ports, function_name, port)
-
-        # Add the else port for when no function conditions match
-        setattr(Ports, "default", Port.on_else())
     else:
-        # If no functions exist, create a simple Ports class with just a default port
-        Ports = type("Ports", (), {"default": Port(default=True)})
         prompt_functions = []
 
     # Add a chat history block to blocks only if one doesn't already exist
@@ -416,10 +377,10 @@ def create_tool_router_node(
     }
 
     node = cast(
-        Type[ToolRouterNode],
+        Type[ToolPromptNode],
         type(
-            "ToolRouterNode",
-            (ToolRouterNode,),
+            "ToolPromptNode",
+            (ToolPromptNode,),
             {
                 "ml_model": ml_model,
                 "blocks": blocks,
@@ -427,7 +388,6 @@ def create_tool_router_node(
                 "prompt_inputs": node_prompt_inputs,
                 "parameters": parameters,
                 "max_prompt_iterations": max_prompt_iterations,
-                "Ports": Ports,
                 "__module__": __name__,
             },
         ),
@@ -437,25 +397,28 @@ def create_tool_router_node(
 
 def create_router_node(
     functions: List[Tool],
-    tool_router_node: Type[ToolRouterNode],
+    tool_prompt_node: Type[InlinePromptNode[ToolCallingState]],
 ) -> Type[RouterNode]:
-    """Create a RouterNode with the same ports as ToolRouterNode."""
+    """Create a RouterNode with dynamic ports that route based on tool_prompt_node outputs."""
 
     if functions and len(functions) > 0:
         # Create dynamic ports and convert functions in a single loop
         Ports = type("Ports", (), {})
 
+        # Avoid using lambda to capture function_name
+        # lambda will capture the function_name by reference,
+        # and if the function_name is changed, the port_condition will also change.
         def create_port_condition(fn_name):
             return Port.on_if(
                 LazyReference(
                     lambda: (
                         ToolCallingState.current_prompt_output_index.less_than(
-                            tool_router_node.Outputs.results.length()
+                            tool_prompt_node.Outputs.results.length()
                         )
-                        & tool_router_node.Outputs.results[ToolCallingState.current_prompt_output_index]["type"].equals(
+                        & tool_prompt_node.Outputs.results[ToolCallingState.current_prompt_output_index]["type"].equals(
                             "FUNCTION_CALL"
                         )
-                        & tool_router_node.Outputs.results[ToolCallingState.current_prompt_output_index]["value"][
+                        & tool_prompt_node.Outputs.results[ToolCallingState.current_prompt_output_index]["value"][
                             "name"
                         ].equals(fn_name)
                     )
@@ -491,6 +454,7 @@ def create_router_node(
             (RouterNode,),
             {
                 "Ports": Ports,
+                "prompt_outputs": tool_prompt_node.Outputs.results,
                 "__module__": __name__,
             },
         ),
@@ -500,7 +464,7 @@ def create_router_node(
 
 def create_function_node(
     function: ToolBase,
-    tool_router_node: Type[ToolRouterNode],
+    tool_prompt_node: Type[ToolPromptNode],
 ) -> Type[BaseNode]:
     """
     Create a FunctionNode class for a given function.
@@ -510,7 +474,7 @@ def create_function_node(
 
     Args:
         function: The function to create a node for
-        tool_router_node: The tool router node class
+        tool_prompt_node: The tool prompt node class
     """
     if isinstance(function, DeploymentDefinition):
         deployment = function.deployment_id or function.deployment_name
@@ -522,7 +486,7 @@ def create_function_node(
             {
                 "deployment": deployment,
                 "release_tag": release_tag,
-                "function_call_output": tool_router_node.Outputs.results,
+                "function_call_output": tool_prompt_node.Outputs.results,
                 "__module__": __name__,
             },
         )
@@ -535,7 +499,7 @@ def create_function_node(
             (ComposioNode,),
             {
                 "composio_tool": function,
-                "function_call_output": tool_router_node.Outputs.results,
+                "function_call_output": tool_prompt_node.Outputs.results,
                 "__module__": __name__,
             },
         )
@@ -546,7 +510,7 @@ def create_function_node(
             (DynamicInlineSubworkflowNode,),
             {
                 "subworkflow": function,
-                "function_call_output": tool_router_node.Outputs.results,
+                "function_call_output": tool_prompt_node.Outputs.results,
                 "__module__": __name__,
             },
         )
@@ -556,8 +520,8 @@ def create_function_node(
             f"FunctionNode_{function.__name__}",
             (FunctionNode,),
             {
-                "function_definition": lambda self, **kwargs: function(**kwargs),
-                "function_call_output": tool_router_node.Outputs.results,
+                "function_definition": lambda self, **kwargs: function(**kwargs),  # ← Revert back to lambda
+                "function_call_output": tool_prompt_node.Outputs.results,
                 "__module__": __name__,
             },
         )
@@ -567,14 +531,14 @@ def create_function_node(
 
 def create_mcp_tool_node(
     tool_def: MCPToolDefinition,
-    tool_router_node: Type[ToolRouterNode],
+    tool_prompt_node: Type[ToolPromptNode],
 ) -> Type[BaseNode]:
     node = type(
         f"MCPNode_{tool_def.name}",
         (MCPNode,),
         {
             "mcp_tool": tool_def,
-            "function_call_output": tool_router_node.Outputs.results,
+            "function_call_output": tool_prompt_node.Outputs.results,
             "__module__": __name__,
         },
     )
@@ -582,22 +546,25 @@ def create_mcp_tool_node(
 
 
 def create_else_node(
-    tool_router_node: Type[ToolRouterNode],
+    tool_prompt_node: Type[ToolPromptNode],
 ) -> Type[ElseNode]:
     class Ports(ElseNode.Ports):
-        loop = Port.on_if(
-            ToolCallingState.current_prompt_output_index.less_than(tool_router_node.Outputs.results.length())
-            | ToolCallingState.current_function_calls_processed.greater_than(0)
+        loop_to_router = Port.on_if(
+            ToolCallingState.current_prompt_output_index.less_than(tool_prompt_node.Outputs.results.length())
         )
+        loop_to_prompt = Port.on_elif(ToolCallingState.current_function_calls_processed.greater_than(0))
         end = Port.on_else()
 
-    node = type(
-        f"{tool_router_node.__name__}_ElseNode",
-        (ElseNode,),
-        {
-            "Ports": Ports,
-            "__module__": __name__,
-        },
+    node = cast(
+        Type[ElseNode],
+        type(
+            f"{tool_prompt_node.__name__}_ElseNode",
+            (ElseNode,),
+            {
+                "Ports": Ports,
+                "__module__": __name__,
+            },
+        ),
     )
     return node
 

vellum/workflows/references/environment_variable.py

@@ -15,8 +15,10 @@ class EnvironmentVariableReference(BaseDescriptor[str]):
         name: str,
         # DEPRECATED - to be removed in 0.15.0 release
         default: Optional[str] = None,
+        serialize_as_constant: bool = False,
     ):
         super().__init__(name=name, types=(str,))
+        self._serialize_as_constant = serialize_as_constant
 
     def resolve(self, state: "BaseState") -> Any:
         env_value = os.environ.get(self.name)
@@ -24,3 +26,11 @@ class EnvironmentVariableReference(BaseDescriptor[str]):
             return env_value
 
         return undefined
+
+    @property
+    def serialize_as_constant(self) -> bool:
+        return self._serialize_as_constant
+
+    @serialize_as_constant.setter
+    def serialize_as_constant(self, value: bool):
+        self._serialize_as_constant = value

vellum/workflows/runner/runner.py

@@ -515,8 +515,24 @@ class WorkflowRunner(Generic[StateType]):
 
             all_deps = self._dependencies[node_class]
             node_span_id = node_class.Trigger._queue_node_execution(state, all_deps, invoked_by)
-            if not node_class.Trigger.should_initiate(state, all_deps, node_span_id):
-                return
+
+            try:
+                if not node_class.Trigger.should_initiate(state, all_deps, node_span_id):
+                    return
+            except NodeException as e:
+                execution = get_execution_context()
+
+                self._workflow_event_outer_queue.put(
+                    WorkflowExecutionRejectedEvent(
+                        trace_id=execution.trace_id,
+                        span_id=node_span_id,
+                        body=WorkflowExecutionRejectedBody(
+                            workflow_definition=self.workflow.__class__,
+                            error=e.error,
+                        ),
+                    )
+                )
+                raise e
 
             execution = get_execution_context()
             node = node_class(state=state, context=self.workflow.context)

vellum/workflows/state/context.py

@@ -1,10 +1,12 @@
 from functools import cached_property
+import inspect
 from queue import Queue
 from uuid import uuid4
 from typing import TYPE_CHECKING, Dict, List, Optional, Type
 
 from vellum import Vellum
-from vellum.workflows.context import ExecutionContext, get_execution_context
+from vellum.workflows.context import ExecutionContext, get_execution_context, set_execution_context
+from vellum.workflows.emitters.vellum_emitter import VellumEmitter
 from vellum.workflows.events.types import ExternalParentContext
 from vellum.workflows.nodes.mocks import MockNodeExecution, MockNodeExecutionArg
 from vellum.workflows.outputs.base import BaseOutputs
@@ -12,6 +14,7 @@ from vellum.workflows.references.constant import ConstantValueReference
 from vellum.workflows.vellum_client import create_vellum_client
 
 if TYPE_CHECKING:
+    from vellum.workflows.emitters.base import BaseWorkflowEmitter
     from vellum.workflows.events.workflow import WorkflowEvent
 
 
@@ -26,17 +29,36 @@ class WorkflowContext:
         self._vellum_client = vellum_client
         self._event_queue: Optional[Queue["WorkflowEvent"]] = None
         self._node_output_mocks_map: Dict[Type[BaseOutputs], List[MockNodeExecution]] = {}
-        self._execution_context = get_execution_context()
-
-        if execution_context is not None:
-
-            self._execution_context.trace_id = execution_context.trace_id
-
-            if execution_context.parent_context is not None:
-                self._execution_context.parent_context = execution_context.parent_context
-
-        if self._execution_context.parent_context is None:
-            self._execution_context.parent_context = ExternalParentContext(span_id=uuid4())
+        # Clone the current thread-local execution context to avoid mutating global state
+        current_execution_context = get_execution_context()
+
+        # Resolve parent_context preference: provided > current > new external
+        resolved_parent_context = (
+            execution_context.parent_context
+            if execution_context is not None and execution_context.parent_context is not None
+            else current_execution_context.parent_context
+        )
+        if resolved_parent_context is None:
+            resolved_parent_context = ExternalParentContext(span_id=uuid4())
+
+        # Resolve trace_id preference: provided (if set) > current (if set) > new uuid
+        if execution_context is not None and int(execution_context.trace_id) != 0:
+            resolved_trace_id = execution_context.trace_id
+        elif int(current_execution_context.trace_id) != 0:
+            resolved_trace_id = current_execution_context.trace_id
+        else:
+            resolved_trace_id = uuid4()
+
+        # Construct a single, resolved execution context for this workflow instance
+        self._execution_context = ExecutionContext(
+            parent_context=resolved_parent_context,
+            trace_id=resolved_trace_id,
+        )
+
+        # Ensure the thread-local context has a parent_context for nodes that read it directly
+        if current_execution_context.parent_context is None:
+            current_execution_context.parent_context = resolved_parent_context
+            set_execution_context(current_execution_context)
 
         self._generated_files = generated_files
 
@@ -59,6 +81,73 @@ class WorkflowContext:
     def node_output_mocks_map(self) -> Dict[Type[BaseOutputs], List[MockNodeExecution]]:
         return self._node_output_mocks_map
 
+    @property
+    def monitoring_url(self) -> Optional[str]:
+        """
+        Get the base monitoring URL for this workflow context.
+
+        Returns the base URL to view executions in Vellum UI.
+        """
+        # Get UI URL from the Vellum client's API URL
+        api_url = self.vellum_client._client_wrapper.get_environment().default
+        return self._get_ui_url_from_api_url(api_url)
+
+    def get_monitoring_url(self, span_id: str) -> Optional[str]:
+        """
+        Generate the monitoring URL for this workflow execution.
+
+        Args:
+        span_id: The span ID from the workflow execution result.
+
+        Returns:
+        The URL to view execution details in Vellum UI, or None if monitoring is disabled.
+        """
+        base_url = self.monitoring_url
+        if base_url is None:
+            return None
+
+        return f"{base_url}/workflows/executions/{span_id}"
+
+    def _get_ui_url_from_api_url(self, api_url: str) -> str:
+        """
+        Convert an API URL to the corresponding UI URL.
+
+        Args:
+        api_url: The API base URL (e.g., https://api.vellum.ai or http://localhost:8000)
+
+        Returns:
+        The corresponding UI URL (e.g., https://app.vellum.ai or http://localhost:3000)
+        """
+        if "localhost" in api_url:
+            # For local development: localhost:8000 (API) -> localhost:3000 (UI)
+            return api_url.replace(":8000", ":3000")
+        elif "api.vellum.ai" in api_url:
+            # For production: api.vellum.ai -> app.vellum.ai
+            return api_url.replace("api.vellum.ai", "app.vellum.ai")
+        else:
+            # For custom domains, assume the same pattern: api.* -> app.*
+            return api_url.replace("api.", "app.", 1)
+
+    def get_emitters_for_workflow(self) -> List["BaseWorkflowEmitter"]:
+        """
+        Get the default emitters that should be attached to workflows using this context.
+
+        Returns:
+            List of emitters, including VellumEmitter if monitoring is enabled.
+        """
+        try:
+            frame = inspect.currentframe()
+            caller = frame.f_back if frame else None
+            if caller and "self" in caller.f_locals:
+                workflow_instance = caller.f_locals["self"]
+                class_level_emitters = getattr(workflow_instance.__class__, "emitters", None)
+                if isinstance(class_level_emitters, list) and len(class_level_emitters) > 0:
+                    return class_level_emitters
+        except Exception:
+            pass
+
+        return [VellumEmitter()]
+
     def _emit_subworkflow_event(self, event: "WorkflowEvent") -> None:
         if self._event_queue:
             self._event_queue.put(event)

vellum/workflows/types/definition.py

@@ -122,13 +122,23 @@ class MCPServer(UniversalBaseModel):
     type: Literal["MCP_SERVER"] = "MCP_SERVER"
     name: str
     url: str
-    authorization_type: AuthorizationType = AuthorizationType.BEARER_TOKEN
+    authorization_type: Optional[AuthorizationType] = None
     bearer_token_value: Optional[Union[str, EnvironmentVariableReference]] = None
     api_key_header_key: Optional[str] = None
     api_key_header_value: Optional[Union[str, EnvironmentVariableReference]] = None
 
     model_config = {"arbitrary_types_allowed": True}
 
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Override to automatically set serialization flags for environment variables."""
+        super().__setattr__(name, value)
+
+        if name == "bearer_token_value" and isinstance(value, EnvironmentVariableReference):
+            value.serialize_as_constant = True
+
+        if name == "api_key_header_value" and isinstance(value, EnvironmentVariableReference):
+            value.serialize_as_constant = True
+
 
 class MCPToolDefinition(UniversalBaseModel):
     name: str

vellum/workflows/types/tests/test_definition.py

@@ -124,3 +124,22 @@ def test_mcp_tool_definition_creation_api_key():
         },
         "required": ["repository_name"],
     }
+
+
+def test_mcp_tool_definition_creation_no_authorization():
+    """Test that MCPToolDefinition can be created with no authorization."""
+    mcp_tool = MCPToolDefinition(
+        name="create_repository",
+        server=MCPServer(
+            name="github",
+            url="https://api.githubcopilot.com/mcp/",
+        ),
+    )
+
+    assert mcp_tool.name == "create_repository"
+    assert mcp_tool.server.name == "github"
+    assert mcp_tool.server.url == "https://api.githubcopilot.com/mcp/"
+    assert mcp_tool.server.authorization_type is None
+    assert mcp_tool.server.bearer_token_value is None
+    assert mcp_tool.server.api_key_header_key is None
+    assert mcp_tool.server.api_key_header_value is None

vellum/workflows/utils/vellum_variables.py

@@ -1,7 +1,7 @@
 import typing
 from typing import List, Tuple, Type, Union, get_args, get_origin
 
-from vellum import (
+from vellum import (  # VellumVideo,; VellumVideoRequest,
     ChatMessage,
     ChatMessageRequest,
     FunctionCall,
@@ -65,10 +65,12 @@ def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -
         return "NUMBER"
     elif _is_type_optionally_in(type_, (FunctionCall, FunctionCallRequest)):
         return "FUNCTION_CALL"
-    elif _is_type_optionally_in(type_, (VellumImage, VellumImageRequest)):
-        return "IMAGE"
     elif _is_type_optionally_in(type_, (VellumAudio, VellumAudioRequest)):
         return "AUDIO"
+    # elif _is_type_optionally_in(type_, (VellumVideo, VellumVideoRequest)):
+    #     return "VIDEO"
+    elif _is_type_optionally_in(type_, (VellumImage, VellumImageRequest)):
+        return "IMAGE"
     elif _is_type_optionally_in(type_, (VellumDocument, VellumDocumentRequest)):
         return "DOCUMENT"
     elif _is_type_optionally_in(type_, (VellumError, VellumErrorRequest)):
@@ -101,10 +103,12 @@ def vellum_variable_type_to_openapi_type(vellum_type: VellumVariableType) -> str
         return "array"
     elif vellum_type == "FUNCTION_CALL":
         return "object"
-    elif vellum_type == "IMAGE":
-        return "object"
     elif vellum_type == "AUDIO":
         return "object"
+    elif vellum_type == "VIDEO":
+        return "object"
+    elif vellum_type == "IMAGE":
+        return "object"
     elif vellum_type == "DOCUMENT":
         return "object"
     elif vellum_type == "NULL":

vellum/workflows/workflows/base.py

@@ -240,12 +240,16 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         store: Optional[Store] = None,
     ):
         self._parent_state = parent_state
-        self.emitters = emitters or (self.emitters if hasattr(self, "emitters") else [])
-        self.resolvers = resolvers or (self.resolvers if hasattr(self, "resolvers") else [])
         self._context = context or WorkflowContext()
+        self.emitters = emitters or self._context.get_emitters_for_workflow()
+        self.resolvers = resolvers or (self.resolvers if hasattr(self, "resolvers") else [])
         self._store = store or Store()
         self._execution_context = self._context.execution_context
 
+        # Register context with all emitters
+        for emitter in self.emitters:
+            emitter.register_context(self._context)
+
         self.validate()
 
     @property
@@ -413,7 +417,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
             last_event = event
 
         if not last_event:
-            return WorkflowExecutionRejectedEvent(
+            rejected_event = WorkflowExecutionRejectedEvent(
                 trace_id=self._execution_context.trace_id,
                 span_id=uuid4(),
                 body=WorkflowExecutionRejectedBody(
@@ -424,9 +428,10 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
                     workflow_definition=self.__class__,
                 ),
             )
+            return rejected_event
 
         if not first_event:
-            return WorkflowExecutionRejectedEvent(
+            rejected_event = WorkflowExecutionRejectedEvent(
                 trace_id=self._execution_context.trace_id,
                 span_id=uuid4(),
                 body=WorkflowExecutionRejectedBody(
@@ -437,6 +442,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
                     workflow_definition=self.__class__,
                 ),
             )
+            return rejected_event
 
         if (
             last_event.name == "workflow.execution.rejected"
@@ -445,7 +451,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         ):
             return last_event
 
-        return WorkflowExecutionRejectedEvent(
+        rejected_event = WorkflowExecutionRejectedEvent(
             trace_id=self._execution_context.trace_id,
             span_id=first_event.span_id,
             body=WorkflowExecutionRejectedBody(
@@ -456,6 +462,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
                 ),
             ),
         )
+        return rejected_event
 
     def stream(
         self,

{vellum_ai-1.1.1.dist-info → vellum_ai-1.1.3.dist-info}/METADATA

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