vellum-ai 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

vellum_ee/workflows/display/nodes/vellum/final_output_node.py

@@ -2,7 +2,7 @@ from uuid import UUID
 from typing import ClassVar, Generic, Optional, TypeVar
 
 from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
-from vellum.workflows.types.core import JsonObject
+from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import to_kebab_case
@@ -19,6 +19,10 @@ NODE_INPUT_KEY = "node_input"
 class BaseFinalOutputNodeDisplay(BaseNodeDisplay[_FinalOutputNodeType], Generic[_FinalOutputNodeType]):
     output_name: ClassVar[Optional[str]] = None
 
+    def serialize_ports(self, display_context: "WorkflowDisplayContext") -> JsonArray:
+        """Final output nodes have no ports."""
+        return []
+
     def serialize(self, display_context: WorkflowDisplayContext, **_kwargs) -> JsonObject:
         node = self._node
         node_id = self.node_id
@@ -45,9 +49,7 @@ class BaseFinalOutputNodeDisplay(BaseNodeDisplay[_FinalOutputNodeType], Generic[
                 "node_input_id": str(node_input.id),
             },
             "inputs": [node_input.dict()],
-            "display_data": self.get_display_data().dict(),
-            "base": self.get_base().dict(),
-            "definition": self.get_definition().dict(),
+            **self.serialize_generic_fields(display_context),
             "outputs": [
                 {
                     "id": str(self._get_output_id()),

vellum_ee/workflows/display/nodes/vellum/guardrail_node.py

@@ -45,8 +45,5 @@ class BaseGuardrailNodeDisplay(BaseNodeDisplay[_GuardrailNodeType], Generic[_Gua
                 "metric_definition_id": str(raise_if_descriptor(node.metric_definition)),
                 "release_tag": raise_if_descriptor(node.release_tag),
             },
-            "display_data": self.get_display_data().dict(),
-            "base": self.get_base().dict(),
-            "definition": self.get_definition().dict(),
-            "ports": self.serialize_ports(display_context),
+            **self.serialize_generic_fields(display_context),
         }

vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -1,11 +1,17 @@
 from uuid import UUID
-from typing import Callable, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union
+from typing import TYPE_CHECKING, Callable, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union
 
 from vellum import FunctionDefinition, PromptBlock, RichTextChildBlock, VellumVariable
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.nodes import InlinePromptNode
 from vellum.workflows.types.core import JsonObject
-from vellum.workflows.utils.functions import compile_function_definition
+from vellum.workflows.types.definition import DeploymentDefinition
+from vellum.workflows.types.generics import is_workflow_class
+from vellum.workflows.utils.functions import (
+    compile_function_definition,
+    compile_inline_workflow_function_definition,
+    compile_workflow_deployment_function_definition,
+)
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
@@ -14,6 +20,9 @@ from vellum_ee.workflows.display.types import WorkflowDisplayContext
 from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
 from vellum_ee.workflows.display.vellum import NodeInput
 
+if TYPE_CHECKING:
+    from vellum.workflows.workflows.base import BaseWorkflow
+
 
 def _contains_descriptors(obj):
     """Check if an object contains any descriptors or references that need special handling."""
@@ -69,7 +78,10 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
             ]
 
         functions = (
-            [self._generate_function_tools(function, i) for i, function in enumerate(function_definitions)]
+            [
+                self._generate_function_tools(function, i, display_context)
+                for i, function in enumerate(function_definitions)
+            ]
             if isinstance(function_definitions, list)
             else []
         )
@@ -97,19 +109,12 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
                 },
                 "ml_model_name": ml_model,
             },
-            "display_data": self.get_display_data().dict(),
-            "base": self.get_base().dict(),
-            "definition": self.get_definition().dict(),
-            "trigger": {
-                "id": str(self.get_target_handle_id()),
-                "merge_behavior": node.Trigger.merge_behavior.value,
-            },
+            **self.serialize_generic_fields(display_context),
             "outputs": [
                 {"id": str(json_display.id), "name": "json", "type": "JSON", "value": None},
                 {"id": str(output_display.id), "name": "text", "type": "STRING", "value": None},
                 {"id": str(array_display.id), "name": "results", "type": "ARRAY", "value": None},
             ],
-            "ports": self.serialize_ports(display_context),
         }
         attributes = self._serialize_attributes(display_context)
         if attributes:
@@ -145,10 +150,24 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
 
         return node_inputs, prompt_inputs
 
-    def _generate_function_tools(self, function: Union[FunctionDefinition, Callable], index: int) -> JsonObject:
-        normalized_functions = (
-            function if isinstance(function, FunctionDefinition) else compile_function_definition(function)
-        )
+    def _generate_function_tools(
+        self,
+        function: Union[FunctionDefinition, Callable, DeploymentDefinition, Type["BaseWorkflow"]],
+        index: int,
+        display_context: WorkflowDisplayContext,
+    ) -> JsonObject:
+        if isinstance(function, FunctionDefinition):
+            normalized_functions = function
+        elif is_workflow_class(function):
+            normalized_functions = compile_inline_workflow_function_definition(function)
+        elif callable(function):
+            normalized_functions = compile_function_definition(function)
+        elif isinstance(function, DeploymentDefinition):
+            normalized_functions = compile_workflow_deployment_function_definition(
+                function.model_dump(), display_context.client
+            )
+        else:
+            raise ValueError(f"Unsupported function type: {type(function)}")
         return {
             "id": str(uuid4_from_hash(f"{self.node_id}-FUNCTION_DEFINITION-{index}")),
             "block_type": "FUNCTION_DEFINITION",

vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py

@@ -55,10 +55,7 @@ class BaseInlineSubworkflowNodeDisplay(
                 "input_variables": [workflow_input.dict() for workflow_input in workflow_inputs],
                 "output_variables": [workflow_output.dict() for workflow_output in workflow_outputs],
             },
-            "display_data": self.get_display_data().dict(),
-            "base": self.get_base().dict(),
-            "definition": self.get_definition().dict(),
-            "ports": self.serialize_ports(display_context),
+            **self.serialize_generic_fields(display_context),
         }
 
     def _generate_node_and_workflow_inputs(

vellum_ee/workflows/display/nodes/vellum/map_node.py

@@ -79,8 +79,5 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
                 "item_input_id": item_workflow_input_id,
                 "index_input_id": index_workflow_input_id,
             },
-            "display_data": self.get_display_data().dict(),
-            "base": self.get_base().dict(),
-            "definition": self.get_definition().dict(),
-            "ports": self.serialize_ports(display_context),
+            **self.serialize_generic_fields(display_context),
         }

vellum_ee/workflows/display/nodes/vellum/merge_node.py

@@ -47,10 +47,7 @@ class BaseMergeNodeDisplay(BaseNodeDisplay[_MergeNodeType], Generic[_MergeNodeTy
                 "target_handles": [{"id": str(target_handle_id)} for target_handle_id in target_handle_ids],
                 "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
             },
-            "display_data": self.get_display_data().dict(),
-            "base": self.get_base().dict(),
-            "definition": self.get_definition().dict(),
-            "ports": self.serialize_ports(display_context),
+            **self.serialize_generic_fields(display_context),
         }
 
     def get_target_handle_ids(self) -> Optional[List[UUID]]:

vellum_ee/workflows/display/nodes/vellum/note_node.py

@@ -13,7 +13,7 @@ class BaseNoteNodeDisplay(BaseNodeDisplay[_NoteNodeType], Generic[_NoteNodeType]
     style: ClassVar[Union[Dict[str, Any], None]] = None
 
     def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
-        del display_context, kwargs  # Unused parameters
+        del kwargs  # Unused parameters
         node_id = self.node_id
 
         return {
@@ -25,7 +25,5 @@ class BaseNoteNodeDisplay(BaseNodeDisplay[_NoteNodeType], Generic[_NoteNodeType]
                 "text": self.text,
                 "style": self.style,
             },
-            "display_data": self.get_display_data().dict(),
-            "base": self.get_base().dict(),
-            "definition": self.get_definition().dict(),
+            **self.serialize_generic_fields(display_context),
         }

vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py

@@ -64,10 +64,7 @@ class BasePromptDeploymentNodeDisplay(BaseNodeDisplay[_PromptDeploymentNodeType]
                 "release_tag": raise_if_descriptor(node.release_tag),
                 "ml_model_fallbacks": list(ml_model_fallbacks) if ml_model_fallbacks else None,
             },
-            "display_data": self.get_display_data().dict(),
-            "base": self.get_base().dict(),
-            "definition": self.get_definition().dict(),
-            "ports": self.serialize_ports(display_context),
+            **self.serialize_generic_fields(display_context),
             "outputs": [
                 {"id": str(json_display.id), "name": "json", "type": "JSON", "value": None},
                 {"id": str(output_display.id), "name": "text", "type": "STRING", "value": None},

vellum_ee/workflows/display/nodes/vellum/search_node.py

@@ -74,10 +74,7 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
                 "external_id_filters_node_input_id": str(node_inputs["external_id_filters"].id),
                 "metadata_filters_node_input_id": str(node_inputs["metadata_filters"].id),
             },
-            "display_data": self.get_display_data().dict(),
-            "base": self.get_base().dict(),
-            "definition": self.get_definition().dict(),
-            "ports": self.serialize_ports(display_context),
+            **self.serialize_generic_fields(display_context),
         }
 
     def _generate_search_node_inputs(

vellum_ee/workflows/display/nodes/vellum/subworkflow_deployment_node.py

@@ -61,8 +61,5 @@ class BaseSubworkflowDeploymentNodeDisplay(
                 "workflow_deployment_id": str(deployment.id),
                 "release_tag": raise_if_descriptor(node.release_tag),
             },
-            "display_data": self.get_display_data().dict(),
-            "base": self.get_base().dict(),
-            "definition": self.get_definition().dict(),
-            "ports": self.serialize_ports(display_context),
+            **self.serialize_generic_fields(display_context),
         }

vellum_ee/workflows/display/nodes/vellum/templating_node.py

@@ -66,8 +66,5 @@ class BaseTemplatingNodeDisplay(BaseNodeDisplay[_TemplatingNodeType], Generic[_T
                 "template_node_input_id": str(template_node_input.id),
                 "output_type": inferred_output_type,
             },
-            "display_data": self.get_display_data().dict(),
-            "base": self.get_base().dict(),
-            "definition": self.get_definition().dict(),
-            "ports": self.serialize_ports(display_context),
+            **self.serialize_generic_fields(display_context),
         }

vellum_ee/workflows/display/nodes/vellum/tests/test_code_execution_node.py

@@ -251,6 +251,7 @@ def test_serialize_node__with_non_exist_code_input_path_with_dry_run():
                         ],
                     },
                     "ports": [{"id": "7afa3858-f50c-4116-936a-a401e3b2c60f", "name": "default", "type": "DEFAULT"}],
+                    "trigger": {"id": "3a39ea63-9f86-4891-a902-0216a7190720", "merge_behavior": "AWAIT_ANY"},
                 },
             ],
             "edges": [

vellum_ee/workflows/display/nodes/vellum/tests/test_tool_calling_node.py

@@ -1,13 +1,31 @@
+from datetime import datetime
+
 from vellum.client.types.prompt_parameters import PromptParameters
+from vellum.client.types.release_review_reviewer import ReleaseReviewReviewer
+from vellum.client.types.workflow_deployment_release import (
+    ReleaseEnvironment,
+    ReleaseReleaseTag,
+    SlimReleaseReview,
+    WorkflowDeploymentRelease,
+    WorkflowDeploymentReleaseWorkflowDeployment,
+    WorkflowDeploymentReleaseWorkflowVersion,
+)
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.displayable.code_execution_node.node import CodeExecutionNode
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
 from vellum.workflows.nodes.displayable.tool_calling_node.node import ToolCallingNode
 from vellum.workflows.nodes.displayable.tool_calling_node.state import ToolCallingState
 from vellum.workflows.nodes.displayable.tool_calling_node.utils import create_router_node, create_tool_prompt_node
+from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState
-from vellum.workflows.types.definition import AuthorizationType, EnvironmentVariableReference, MCPServer
+from vellum.workflows.types.definition import (
+    AuthorizationType,
+    DeploymentDefinition,
+    EnvironmentVariableReference,
+    MCPServer,
+)
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
@@ -185,6 +203,58 @@ def test_serialize_node__tool_calling_node__mcp_server_api_key():
     }
 
 
+def test_serialize_node__tool_calling_node__mcp_server_no_authorization():
+    # GIVEN a tool calling node with an mcp server
+    class MyToolCallingNode(ToolCallingNode):
+        functions = [
+            MCPServer(
+                name="my-mcp-server",
+                url="https://my-mcp-server.com",
+            )
+        ]
+
+    # AND a workflow with the tool calling node
+    class Workflow(BaseWorkflow):
+        graph = MyToolCallingNode
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the mcp server
+    my_tool_calling_node = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(MyToolCallingNode.__id__)
+    )
+
+    functions_attribute = next(
+        attribute for attribute in my_tool_calling_node["attributes"] if attribute["name"] == "functions"
+    )
+
+    assert functions_attribute == {
+        "id": "c8957551-cb3d-49af-8053-acd256c1d852",
+        "name": "functions",
+        "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": [
+                    {
+                        "type": "MCP_SERVER",
+                        "name": "my-mcp-server",
+                        "url": "https://my-mcp-server.com",
+                        "authorization_type": None,
+                        "bearer_token_value": None,
+                        "api_key_header_key": None,
+                        "api_key_header_value": None,
+                    }
+                ],
+            },
+        },
+    }
+
+
 def test_serialize_tool_router_node():
     """
     Test that the tool router node created by create_router_node serializes successfully.
@@ -406,3 +476,171 @@ def test_serialize_node__tool_calling_node__subworkflow_with_parent_input_refere
             "combinator": "OR",
         },
     }
+
+
+def test_serialize_tool_prompt_node_with_inline_workflow():
+    """
+    Test that the tool prompt node created by create_tool_prompt_node serializes successfully with inline workflow.
+    """
+
+    # GIVEN a simple inline workflow for tool calling
+    class SimpleWorkflowInputs(BaseInputs):
+        message: str
+
+    class SimpleNode(BaseNode):
+        message = SimpleWorkflowInputs.message
+
+        class Outputs(BaseOutputs):
+            result: str
+
+        def run(self) -> Outputs:
+            return self.Outputs(result=f"Processed: {self.message}")
+
+    class SimpleInlineWorkflow(BaseWorkflow[SimpleWorkflowInputs, BaseState]):
+        """A simple workflow for testing inline tool serialization."""
+
+        graph = SimpleNode
+
+        class Outputs(BaseOutputs):
+            result = SimpleNode.Outputs.result
+
+    # WHEN we create a tool prompt node using create_tool_prompt_node with inline workflow
+    tool_prompt_node = create_tool_prompt_node(
+        ml_model="gpt-4o-mini",
+        blocks=[],
+        functions=[SimpleInlineWorkflow],
+        prompt_inputs=None,
+        parameters=PromptParameters(),
+    )
+
+    tool_prompt_node_display_class = get_node_display_class(tool_prompt_node)
+    tool_prompt_node_display = tool_prompt_node_display_class()
+
+    # AND we create a workflow that uses this tool prompt node
+    class TestWorkflow(BaseWorkflow[BaseInputs, ToolCallingState]):
+        graph = tool_prompt_node
+
+    # WHEN we serialize the entire workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    display_context = workflow_display.display_context
+    serialized_tool_prompt_node = tool_prompt_node_display.serialize(display_context)
+
+    # THEN prompt inputs should be serialized correctly
+    attributes = serialized_tool_prompt_node["attributes"]
+    assert isinstance(attributes, list)
+    prompt_inputs_attr = next(
+        (attr for attr in attributes if isinstance(attr, dict) and attr["name"] == "prompt_inputs"), None
+    )
+    assert prompt_inputs_attr == {
+        "id": "bc1320a2-23e4-4238-8b00-efbf88e91856",
+        "name": "prompt_inputs",
+        "value": {
+            "type": "DICTIONARY_REFERENCE",
+            "entries": [
+                {
+                    "id": "76ceec7b-ec37-474f-ba38-2bfd27cecc5d",
+                    "key": "chat_history",
+                    "value": {
+                        "type": "BINARY_EXPRESSION",
+                        "lhs": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": []}},
+                        "operator": "concat",
+                        "rhs": {
+                            "type": "WORKFLOW_STATE",
+                            "state_variable_id": "7a1caaf5-99df-487a-8b2d-6512df2d871a",
+                        },
+                    },
+                }
+            ],
+        },
+    }
+
+
+def test_serialize_tool_prompt_node_with_workflow_deployment(vellum_client):
+    """
+    Test that the tool prompt node serializes successfully with a workflow deployment.
+    """
+    vellum_client.workflow_deployments.retrieve_workflow_deployment_release.return_value = WorkflowDeploymentRelease(
+        id="test-id",
+        created=datetime.now(),
+        environment=ReleaseEnvironment(
+            id="test-id",
+            name="test-name",
+            label="test-label",
+        ),
+        created_by=None,
+        workflow_version=WorkflowDeploymentReleaseWorkflowVersion(
+            id="test-id",
+            input_variables=[],
+            output_variables=[],
+        ),
+        deployment=WorkflowDeploymentReleaseWorkflowDeployment(name="test-name"),
+        description="test-description",
+        release_tags=[
+            ReleaseReleaseTag(
+                name="test-name",
+                source="USER",
+            )
+        ],
+        reviews=[
+            SlimReleaseReview(
+                id="test-id",
+                created=datetime.now(),
+                reviewer=ReleaseReviewReviewer(
+                    id="test-id",
+                    full_name="test-name",
+                ),
+                state="APPROVED",
+            )
+        ],
+    )
+
+    # GIVEN a workflow deployment
+    workflow_deployment = DeploymentDefinition(
+        deployment="test-deployment",
+        release_tag="test-release-tag",
+    )
+
+    # WHEN we create a tool prompt node using create_tool_prompt_node with a workflow deployment
+    tool_prompt_node = create_tool_prompt_node(
+        ml_model="gpt-4o-mini",
+        blocks=[],
+        functions=[workflow_deployment],
+        prompt_inputs=None,
+        parameters=PromptParameters(),
+    )
+
+    tool_prompt_node_display_class = get_node_display_class(tool_prompt_node)
+    tool_prompt_node_display = tool_prompt_node_display_class()
+
+    # AND we create a workflow that uses this tool prompt node
+    class TestWorkflow(BaseWorkflow[BaseInputs, ToolCallingState]):
+        graph = tool_prompt_node
+
+    # WHEN we serialize the entire workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    display_context = workflow_display.display_context
+    serialized_tool_prompt_node = tool_prompt_node_display.serialize(display_context)
+
+    # THEN functions attribute should be serialized correctly
+    attributes = serialized_tool_prompt_node["attributes"]
+    assert isinstance(attributes, list)
+    functions_attr = next((attr for attr in attributes if isinstance(attr, dict) and attr["name"] == "functions"), None)
+    assert functions_attr == {
+        "id": "6326ccc4-7cf6-4235-ba3c-a6e860b0c48b",
+        "name": "functions",
+        "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": [
+                    {
+                        "type": "WORKFLOW_DEPLOYMENT",
+                        "name": "test-name",
+                        "description": "test-description",
+                        "deployment": "test-deployment",
+                        "release_tag": "test-release-tag",
+                    }
+                ],
+            },
+        },
+    }

vellum_ee/workflows/display/tests/test_base_workflow_display.py

@@ -2,7 +2,8 @@ from uuid import UUID
 from typing import Dict
 
 from vellum.workflows.inputs import BaseInputs
-from vellum.workflows.nodes import BaseNode
+from vellum.workflows.nodes import BaseNode, InlineSubworkflowNode
+from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.ports.port import Port
 from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state import BaseState
@@ -327,3 +328,54 @@ def test_serialize__port_with_lazy_reference():
             },
         }
     ]
+
+
+def test_global_propagation_deep_nested_subworkflows():
+    # GIVEN the root workflow, a middle workflow, and an inner workflow
+
+    class RootInputs(BaseInputs):
+        root_param: str
+
+    class MiddleInputs(BaseInputs):
+        middle_param: str
+
+    class InnerInputs(BaseInputs):
+        inner_param: str
+
+    class InnerNode(BaseNode):
+        class Outputs(BaseOutputs):
+            done: bool
+
+        def run(self) -> Outputs:
+            return self.Outputs(done=True)
+
+    class InnerWorkflow(BaseWorkflow[InnerInputs, BaseState]):
+        graph = InnerNode
+
+    class MiddleInlineSubworkflowNode(InlineSubworkflowNode):
+        subworkflow_inputs = {"inner_param": "x"}
+        subworkflow = InnerWorkflow
+
+    class MiddleWorkflow(BaseWorkflow[MiddleInputs, BaseState]):
+        graph = MiddleInlineSubworkflowNode
+
+    class OuterInlineSubworkflowNode(InlineSubworkflowNode):
+        subworkflow_inputs = {"middle_param": "y"}
+        subworkflow = MiddleWorkflow
+
+    class RootWorkflow(BaseWorkflow[RootInputs, BaseState]):
+        graph = OuterInlineSubworkflowNode
+
+    # WHEN we build the displays
+    root_display = get_workflow_display(workflow_class=RootWorkflow)
+    middle_display = get_workflow_display(
+        workflow_class=MiddleWorkflow, parent_display_context=root_display.display_context
+    )
+    inner_display = get_workflow_display(
+        workflow_class=InnerWorkflow, parent_display_context=middle_display.display_context
+    )
+
+    # THEN the deepest display must include root + middle + inner inputs in its GLOBAL view
+    inner_global_names = {ref.name for ref in inner_display.display_context.global_workflow_input_displays.keys()}
+
+    assert inner_global_names == {"middle_param", "inner_param", "root_param"}

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_api_node_serialization.py

@@ -203,6 +203,10 @@ def test_serialize_workflow(vellum_client):
                 "name": "SimpleAPINode",
                 "module": ["tests", "workflows", "basic_api_node", "workflow"],
             },
+            "trigger": {
+                "id": "14b538a5-aedb-41f3-b579-039956b7c7ed",
+                "merge_behavior": "AWAIT_ANY",
+            },
             "ports": [{"id": "7c33b4d3-9204-4bd5-9371-80ee34f83073", "name": "default", "type": "DEFAULT"}],
         },
         api_node,

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_code_execution_node_serialization.py

@@ -110,6 +110,10 @@ def test_serialize_workflow_with_filepath():
             "module": ["tests", "workflows", "basic_code_execution_node", "workflow"],
             "name": "SimpleCodeExecutionNode",
         },
+        "trigger": {
+            "id": "e02a2701-22c0-4533-8b00-175998e7350a",
+            "merge_behavior": "AWAIT_ANY",
+        },
         "ports": [{"id": "832f81ec-427b-42a8-825c-e62c43c1f961", "name": "default", "type": "DEFAULT"}],
     }
     assert not DeepDiff(
@@ -342,6 +346,10 @@ def test_serialize_workflow_with_code():
             "name": "SimpleCodeExecutionNode",
             "module": ["tests", "workflows", "basic_code_execution_node", "workflow_with_code"],
         },
+        "trigger": {
+            "id": "e02a2701-22c0-4533-8b00-175998e7350a",
+            "merge_behavior": "AWAIT_ANY",
+        },
         "ports": [{"id": "832f81ec-427b-42a8-825c-e62c43c1f961", "name": "default", "type": "DEFAULT"}],
     }
     assert not DeepDiff(
@@ -602,6 +610,10 @@ def test_serialize_workflow__try_wrapped():
                 ],
             }
         ],
+        "trigger": {
+            "id": "e02a2701-22c0-4533-8b00-175998e7350a",
+            "merge_behavior": "AWAIT_ANY",
+        },
         "ports": [{"id": "832f81ec-427b-42a8-825c-e62c43c1f961", "name": "default", "type": "DEFAULT"}],
     }
 

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_conditional_node_serialization.py

@@ -424,6 +424,10 @@ def test_serialize_workflow():
                 "name": "CategoryConditionalNode",
                 "module": ["tests", "workflows", "basic_conditional_node", "workflow"],
             },
+            "trigger": {
+                "id": "dd89e228-a23e-422b-80b2-34362c1c050e",
+                "merge_behavior": "AWAIT_ANY",
+            },
             "ports": [
                 {
                     "id": "3a45b81f-95e4-4cbd-8997-bfdbe30251e8",
@@ -952,6 +956,10 @@ def test_conditional_node_serialize_all_operators_with_lhs_and_rhs(descriptor, o
                 "name": "SimpleConditionalNode",
                 "module": ["tests", "workflows", "basic_conditional_node", "workflow_with_only_one_conditional_node"],
             },
+            "trigger": {
+                "id": "c6e99e94-bc8e-47a4-b75c-cc96c6bedbb0",
+                "merge_behavior": "AWAIT_ANY",
+            },
             "ports": [
                 {
                     "id": "2ff87aa6-37cf-43dd-af9d-13b9198ab70a",
@@ -1063,6 +1071,10 @@ def test_conditional_node_serialize_all_operators_with_expression(descriptor, op
                 "name": "SimpleConditionalNode",
                 "module": ["tests", "workflows", "basic_conditional_node", "workflow_with_only_one_conditional_node"],
             },
+            "trigger": {
+                "id": "c6e99e94-bc8e-47a4-b75c-cc96c6bedbb0",
+                "merge_behavior": "AWAIT_ANY",
+            },
             "ports": [
                 {
                     "id": "2ff87aa6-37cf-43dd-af9d-13b9198ab70a",
@@ -1186,6 +1198,10 @@ def test_conditional_node_serialize_all_operators_with_value_and_start_and_end(d
                 "name": "SimpleConditionalNode",
                 "module": ["tests", "workflows", "basic_conditional_node", "workflow_with_only_one_conditional_node"],
             },
+            "trigger": {
+                "id": "c6e99e94-bc8e-47a4-b75c-cc96c6bedbb0",
+                "merge_behavior": "AWAIT_ANY",
+            },
             "ports": [
                 {
                     "id": "2ff87aa6-37cf-43dd-af9d-13b9198ab70a",