vellum-ai 0.14.19__tar.gz → 0.14.21__tar.gz

{vellum_ai-0.14.19 → vellum_ai-0.14.21}/PKG-INFO

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

{vellum_ai-0.14.19 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/base.py

@@ -46,17 +46,17 @@ StateValueDisplayOverridesType = TypeVar("StateValueDisplayOverridesType", bound
 
 
 @dataclass
-class EdgeDisplayOverrides:
+class EdgeDisplay:
     id: UUID
 
 
 @dataclass
-class EdgeDisplay(EdgeDisplayOverrides):
-    pass
-
+class EdgeDisplayOverrides(EdgeDisplay):
+    """
+    DEPRECATED: Use EdgeDisplay instead. Will be removed in 0.15.0
+    """
 
-EdgeDisplayType = TypeVar("EdgeDisplayType", bound=EdgeDisplay)
-EdgeDisplayOverridesType = TypeVar("EdgeDisplayOverridesType", bound=EdgeDisplayOverrides)
+    pass
 
 
 @dataclass

{vellum_ai-0.14.19 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -115,6 +115,10 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
     port_displays: Dict[Port, PortDisplayOverrides] = {}
     node_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
 
+    # Used to explicitly set the target handle id for a node
+    # Once all nodes are Generic Nodes, we may replace this with a trigger_id or trigger attribute
+    target_handle_id: ClassVar[Optional[UUID]] = None
+
     # Used to store the mapping between node types and their display classes
     _node_display_registry: Dict[Type[NodeType], Type["BaseNodeDisplay"]] = {}
 
@@ -205,7 +209,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
             "trigger": {
-                "id": str(self.get_trigger_id()),
+                "id": str(self.get_target_handle_id()),
                 "merge_behavior": node.Trigger.merge_behavior.value,
             },
             "ports": ports,
@@ -255,7 +259,24 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
         return PortDisplay(id=port_id, node_id=self.node_id)
 
     def get_trigger_id(self) -> UUID:
-        return uuid4_from_hash(f"{self.node_id}|trigger")
+        return self.get_target_handle_id()
+
+    def get_target_handle_id(self) -> UUID:
+        """
+        Is the same as `get_trigger_id()` but kept for legacy workflows. Once all workflows have been updated to
+        become Generic Nodes, we should be able to drive off of only `get_trigger_id()` going forward
+        """
+
+        return self._get_node_display_uuid("target_handle_id")
+
+    def get_target_handle_id_by_source_node_id(self, source_node_id: UUID) -> UUID:
+        """
+        In the vast majority of cases, nodes will only have a single target handle and can be retrieved independently
+        of the source node. However, in rare cases (such as legacy Merge nodes), this method can be overridden to
+        account for the case of retrieving one amongst multiple target handles on a node.
+        """
+
+        return self.get_target_handle_id()
 
     @classmethod
     def get_from_node_display_registry(cls, node_class: Type[NodeType]) -> Optional[Type["BaseNodeDisplay"]]:
@@ -315,6 +336,10 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
 
         raise ValueError(f"Node {cls.__name__} must define an explicit {attribute} of type {attribute_type.__name__}.")
 
+    def _get_node_display_uuid(self, attribute: str) -> UUID:
+        explicit_value = self._get_explicit_node_display_attr(attribute, UUID)
+        return explicit_value if explicit_value else uuid4_from_hash(f"{self.node_id}|{attribute}")
+
     def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
         if not cls._node_display_registry:

{vellum_ai-0.14.19 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/nodes/base_node_vellum_display.py

@@ -4,7 +4,6 @@ from typing import ClassVar, Dict, Optional
 from vellum.workflows.nodes.utils import get_unadorned_node
 from vellum.workflows.ports import Port
 from vellum.workflows.types.generics import NodeType
-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.types import PortDisplay
 from vellum_ee.workflows.display.vellum import NodeDisplayComment, NodeDisplayData
@@ -14,13 +13,6 @@ class BaseNodeVellumDisplay(BaseNodeDisplay[NodeType]):
     # Used to explicitly set display data for a node
     display_data: ClassVar[Optional[NodeDisplayData]] = None
 
-    # Used to explicitly set the target handle id for a node
-    target_handle_id: ClassVar[Optional[UUID]] = None
-
-    def _get_node_display_uuid(self, attribute: str) -> UUID:
-        explicit_value = self._get_explicit_node_display_attr(attribute, UUID)
-        return explicit_value if explicit_value else uuid4_from_hash(f"{self.node_id}|{attribute}")
-
     def get_display_data(self) -> NodeDisplayData:
         explicit_value = self._get_explicit_node_display_attr("display_data", NodeDisplayData)
         docstring = self._node.__doc__
@@ -40,18 +32,6 @@ class BaseNodeVellumDisplay(BaseNodeDisplay[NodeType]):
 
         return explicit_value if explicit_value else NodeDisplayData()
 
-    def get_target_handle_id(self) -> UUID:
-        return self._get_node_display_uuid("target_handle_id")
-
-    def get_target_handle_id_by_source_node_id(self, source_node_id: UUID) -> UUID:
-        """
-        In the vast majority of cases, nodes will only have a single target handle and can be retrieved independently
-        of the source node. However, in rare cases (such as legacy Merge nodes), this method can be overridden to
-        account for the case of retrieving one amongst multiple target handles on a node.
-        """
-
-        return self.get_target_handle_id()
-
     def get_source_handle_id(self, port_displays: Dict[Port, PortDisplay]) -> UUID:
         unadorned_node = get_unadorned_node(self._node)
         default_port = unadorned_node.Ports.default

{vellum_ai-0.14.19 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/nodes/get_node_display_class.py

@@ -7,12 +7,12 @@ from vellum.workflows.types.generics import NodeType
 from vellum.workflows.utils.uuids import uuid4_from_hash
 
 if TYPE_CHECKING:
-    from vellum_ee.workflows.display.types import NodeDisplayType
+    from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 
 
 def get_node_display_class(
-    base_class: Type["NodeDisplayType"], node_class: Type[NodeType], root_node_class: Optional[Type[NodeType]] = None
-) -> Type["NodeDisplayType"]:
+    base_class: Type["BaseNodeDisplay"], node_class: Type[NodeType], root_node_class: Optional[Type[NodeType]] = None
+) -> Type["BaseNodeDisplay"]:
     node_display_class = base_class.get_from_node_display_registry(node_class)
     if node_display_class:
         if not issubclass(node_display_class, base_class):

{vellum_ai-0.14.19 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/nodes/vellum/api_node.py

@@ -14,15 +14,6 @@ _APINodeType = TypeVar("_APINodeType", bound=APINode)
 
 
 class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeType]):
-    url_input_id: ClassVar[Optional[UUID]] = None
-    method_input_id: ClassVar[Optional[UUID]] = None
-    body_input_id: ClassVar[Optional[UUID]] = None
-
-    authorization_type_input_id: ClassVar[Optional[UUID]] = None
-    bearer_token_value_input_id: ClassVar[Optional[UUID]] = None
-    api_key_header_key_input_id: ClassVar[Optional[UUID]] = None
-    api_key_header_value_input_id: ClassVar[Optional[UUID]] = None
-
     # A mapping between node input keys and their ids for inputs representing additional header keys
     additional_header_key_input_ids: ClassVar[Optional[Dict[str, UUID]]] = None
 
@@ -41,7 +32,7 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
             input_name="url",
             value=node_url,
             display_context=display_context,
-            input_id=self.url_input_id,
+            input_id=self.node_input_ids_by_name.get(APINode.url.name),
         )
 
         node_method = raise_if_descriptor(node.method)
@@ -50,7 +41,7 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
             input_name="method",
             value=node_method,
             display_context=display_context,
-            input_id=self.method_input_id,
+            input_id=self.node_input_ids_by_name.get(APINode.method.name),
         )
 
         node_data = raise_if_descriptor(node.data)
@@ -60,7 +51,9 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
             input_name="body",
             value=node_data if node_data else node_json,
             display_context=display_context,
-            input_id=self.body_input_id,
+            input_id=self.node_input_ids_by_name.get(APINode.json.name)
+            # Kept for backwards compatibility with a bug in previous versions of SDK serialization
+            or self.node_input_ids_by_name.get("body"),
         )
 
         headers = raise_if_descriptor(node.headers)
@@ -75,7 +68,7 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
                 input_name="authorization_type",
                 value=authorization_type,
                 display_context=display_context,
-                input_id=self.authorization_type_input_id,
+                input_id=self.node_input_ids_by_name.get(APINode.authorization_type.name),
             )
             if authorization_type
             else None
@@ -85,7 +78,7 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
             input_name="bearer_token_value",
             value=bearer_token_value,
             display_context=display_context,
-            input_id=self.bearer_token_value_input_id,
+            input_id=self.node_input_ids_by_name.get(APINode.bearer_token_value.name),
             pointer_type=WorkspaceSecretPointer,
         )
         api_key_header_key_node_input = (
@@ -94,7 +87,7 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
                 input_name="api_key_header_key",
                 value=api_key_header_key,
                 display_context=display_context,
-                input_id=self.api_key_header_key_input_id,
+                input_id=self.node_input_ids_by_name.get(APINode.api_key_header_key.name),
             )
             if api_key_header_key
             else None
@@ -104,7 +97,7 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
             input_name="api_key_header_value",
             value=api_key_header_value,
             display_context=display_context,
-            input_id=self.api_key_header_value_input_id,
+            input_id=self.node_input_ids_by_name.get(APINode.api_key_header_value.name),
             pointer_type=WorkspaceSecretPointer,
         )
 

{vellum_ai-0.14.19 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/nodes/vellum/code_execution_node.py

@@ -24,17 +24,20 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
         node = self._node
         node_id = self.node_id
         raw_code = raise_if_descriptor(node.code)
+        filepath = raise_if_descriptor(node.filepath)
 
         code_value: Optional[str]
         if raw_code:
             code_value = raw_code
-        else:
+        elif filepath:
             node_file_path = inspect.getfile(node)
             file_code = read_file_from_path(
                 node_filepath=node_file_path,
-                script_filepath=(raise_if_descriptor(node.filepath)),  # type: ignore
+                script_filepath=filepath,
             )
             code_value = file_code
+        else:
+            code_value = ""
 
         code_inputs = raise_if_descriptor(node.code_inputs)
 
@@ -44,7 +47,8 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
                 input_name=variable_name,
                 value=variable_value,
                 display_context=display_context,
-                input_id=self.node_input_ids_by_name.get(variable_name),
+                input_id=self.node_input_ids_by_name.get(f"{CodeExecutionNode.code_inputs.name}.{variable_name}")
+                or self.node_input_ids_by_name.get(variable_name),
             )
             for variable_name, variable_value in code_inputs.items()
         ]

{vellum_ai-0.14.19 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import Callable, ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union
+from typing import Callable, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union
 
 from vellum import FunctionDefinition, PromptBlock, RichTextChildBlock, VellumVariable
 from vellum.workflows.nodes import InlinePromptNode
@@ -17,10 +17,6 @@ _InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
 
 
 class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType], Generic[_InlinePromptNodeType]):
-    output_id: ClassVar[Optional[UUID]] = None
-    array_output_id: ClassVar[Optional[UUID]] = None
-    prompt_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
-
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:
@@ -98,7 +94,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
                 input_name=variable_name,
                 value=variable_value,
                 display_context=display_context,
-                input_id=self.prompt_input_ids_by_name.get(variable_name),
+                input_id=self.node_input_ids_by_name.get(variable_name),
             )
             vellum_variable_type = infer_vellum_variable_type(variable_value)
             node_inputs.append(node_input)

{vellum_ai-0.14.19 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/nodes/vellum/merge_node.py

@@ -6,7 +6,6 @@ from vellum.workflows.types.core import JsonObject
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
-from vellum_ee.workflows.display.vellum import EdgeVellumDisplay
 
 _MergeNodeType = TypeVar("_MergeNodeType", bound=MergeNode)
 
@@ -22,16 +21,20 @@ class BaseMergeNodeDisplay(BaseNodeVellumDisplay[_MergeNodeType], Generic[_Merge
         node = self._node
         node_id = self.node_id
 
-        all_edges: List[EdgeVellumDisplay] = [edge_display for _, edge_display in display_context.edge_displays.items()]
-        merged_edges = [edge for edge in all_edges if edge.target_node_id == self.node_id]
+        merged_source_ports = [
+            source_node_port
+            for (source_node_port, target_node), _ in display_context.edge_displays.items()
+            if target_node.__id__ == self.node_id
+        ]
 
         target_handle_ids = self.get_target_handle_ids()
 
         if target_handle_ids is None:
             target_handle_ids = [
-                uuid4_from_hash(f"{node_id}|target_handle|{edge.source_node_id}") for edge in merged_edges
+                uuid4_from_hash(f"{node_id}|target_handle|{source_node_port.node_class.__id__}")
+                for source_node_port in merged_source_ports
             ]
-        elif len(target_handle_ids) != len(merged_edges):
+        elif len(target_handle_ids) != len(merged_source_ports):
             raise ValueError("If you explicitly specify target_handle_ids, you must specify one for each incoming edge")
 
         return {

{vellum_ai-0.14.19 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import ClassVar, Dict, Generic, Optional, TypeVar, cast
+from typing import Generic, Optional, TypeVar, cast
 
 from vellum.workflows.nodes.displayable.prompt_deployment_node import PromptDeploymentNode
 from vellum.workflows.references import OutputReference
@@ -16,10 +16,6 @@ _PromptDeploymentNodeType = TypeVar("_PromptDeploymentNodeType", bound=PromptDep
 class BasePromptDeploymentNodeDisplay(
     BaseNodeVellumDisplay[_PromptDeploymentNodeType], Generic[_PromptDeploymentNodeType]
 ):
-    output_id: ClassVar[Optional[UUID]] = None
-    array_output_id: ClassVar[Optional[UUID]] = None
-    prompt_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
-
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:
@@ -34,7 +30,7 @@ class BasePromptDeploymentNodeDisplay(
                     input_name=variable_name,
                     value=variable_value,
                     display_context=display_context,
-                    input_id=self.prompt_input_ids_by_name.get(variable_name),
+                    input_id=self.node_input_ids_by_name.get(variable_name),
                 )
                 for variable_name, variable_value in prompt_inputs.items()
             ]

vellum_ai-0.14.21/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_code_execution_node.py

@@ -0,0 +1,113 @@
+import pytest
+from uuid import UUID
+from typing import Type
+
+from vellum.workflows.nodes.displayable.code_execution_node.node import CodeExecutionNode
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.nodes.vellum.code_execution_node import BaseCodeExecutionNodeDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+from vellum_ee.workflows.display.workflows.vellum_workflow_display import VellumWorkflowDisplay
+
+
+def _no_display_class(Node: Type[CodeExecutionNode]):
+    return None
+
+
+def _display_class_with_node_input_ids_by_name(Node: Type[CodeExecutionNode]):
+    class CodeExecutionNodeDisplay(BaseCodeExecutionNodeDisplay[Node]):  # type: ignore[valid-type]
+        node_input_ids_by_name = {"foo": UUID("fba6a4d5-835a-4e99-afb7-f6a4aed15110")}
+
+    return CodeExecutionNodeDisplay
+
+
+def _display_class_with_node_input_ids_by_name_with_inputs_prefix(Node: Type[CodeExecutionNode]):
+    class CodeExecutionNodeDisplay(BaseCodeExecutionNodeDisplay[Node]):  # type: ignore[valid-type]
+        node_input_ids_by_name = {"code_inputs.foo": UUID("fba6a4d5-835a-4e99-afb7-f6a4aed15110")}
+
+    return CodeExecutionNodeDisplay
+
+
+@pytest.mark.parametrize(
+    ["GetDisplayClass", "expected_input_id"],
+    [
+        (_no_display_class, "e3cdb222-324e-4ad1-abb2-bdd7881b3a0e"),
+        (_display_class_with_node_input_ids_by_name, "fba6a4d5-835a-4e99-afb7-f6a4aed15110"),
+        (_display_class_with_node_input_ids_by_name_with_inputs_prefix, "fba6a4d5-835a-4e99-afb7-f6a4aed15110"),
+    ],
+    ids=[
+        "no_display_class",
+        "display_class_with_node_input_ids_by_name",
+        "display_class_with_node_input_ids_by_name_with_inputs_prefix",
+    ],
+)
+def test_serialize_node__code_node_inputs(GetDisplayClass, expected_input_id):
+    # GIVEN a code node with inputs
+    class MyCodeExecutionNode(CodeExecutionNode):
+        code_inputs = {"foo": "bar"}
+
+    # AND a workflow with the code node
+    class Workflow(BaseWorkflow):
+        graph = MyCodeExecutionNode
+
+    # AND a display class
+    GetDisplayClass(MyCodeExecutionNode)
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(base_display_class=VellumWorkflowDisplay, workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the inputs
+    my_code_execution_node = next(
+        node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["type"] == "CODE_EXECUTION"
+    )
+
+    assert my_code_execution_node["inputs"] == [
+        {
+            "id": expected_input_id,
+            "key": "foo",
+            "value": {
+                "combinator": "OR",
+                "rules": [
+                    {
+                        "type": "CONSTANT_VALUE",
+                        "data": {
+                            "type": "STRING",
+                            "value": "bar",
+                        },
+                    }
+                ],
+            },
+        },
+        {
+            "id": "9774d864-c76d-4a1a-8181-b632ed3ab87c",
+            "key": "code",
+            "value": {
+                "combinator": "OR",
+                "rules": [
+                    {
+                        "type": "CONSTANT_VALUE",
+                        "data": {
+                            "type": "STRING",
+                            "value": "",
+                        },
+                    }
+                ],
+            },
+        },
+        {
+            "id": "34742235-5699-45cd-9d34-bce3745e743d",
+            "key": "runtime",
+            "value": {
+                "combinator": "OR",
+                "rules": [
+                    {
+                        "type": "CONSTANT_VALUE",
+                        "data": {
+                            "type": "STRING",
+                            "value": "PYTHON_3_11_6",
+                        },
+                    }
+                ],
+            },
+        },
+    ]

{vellum_ai-0.14.19 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/conftest.py

@@ -12,7 +12,7 @@ from vellum_ee.workflows.display.base import StateValueDisplayType, WorkflowInpu
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
-from vellum_ee.workflows.display.types import NodeDisplayType, WorkflowDisplayContext
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
 from vellum_ee.workflows.display.vellum import NodeDisplayData, WorkflowMetaVellumDisplay
 from vellum_ee.workflows.display.workflows.vellum_workflow_display import VellumWorkflowDisplay
 
@@ -24,7 +24,7 @@ def serialize_node():
         base_class: type[BaseNodeDisplay[Any]] = BaseNodeDisplay,
         global_workflow_input_displays: Dict[WorkflowInputReference, WorkflowInputsDisplayType] = {},
         global_state_value_displays: Dict[StateValueReference, StateValueDisplayType] = {},
-        global_node_displays: Dict[Type[BaseNode], NodeDisplayType] = {},
+        global_node_displays: Dict[Type[BaseNode], BaseNodeDisplay] = {},
         global_node_output_displays: Dict[OutputReference, Tuple[Type[BaseNode], NodeOutputDisplay]] = {},
     ) -> JsonObject:
         node_display_class = get_node_display_class(base_class, node_class)

{vellum_ai-0.14.19 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_adornments_serialization.py

@@ -64,7 +64,7 @@ def test_serialize_node__retry(serialize_node):
                     "test_adornments_serialization",
                 ],
             },
-            "trigger": {"id": "d38a83bf-23d1-4f9d-a875-a08dc27cf397", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "75fbe874-c00b-4fc2-9ade-52f4fe9209fa", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "078650c9-f775-4cd0-a08c-23af9983a361", "name": "default", "type": "DEFAULT"}],
             "adornments": [
                 {
@@ -175,7 +175,7 @@ def test_serialize_node__try(serialize_node):
                     "test_adornments_serialization",
                 ],
             },
-            "trigger": {"id": "16bc1522-c408-47ad-9a22-0ef136384abf", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "bbb343ff-2b7a-4793-a8cf-fb05132ca46a", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "8d25f244-4b12-4f8b-b202-8948698679a0", "name": "default", "type": "DEFAULT"}],
             "adornments": [
                 {
@@ -283,7 +283,7 @@ def test_serialize_node__stacked():
                                 "test_adornments_serialization",
                             ],
                         },
-                        "trigger": {"id": "f206358d-04a5-41c9-beee-0871a074fa48", "merge_behavior": "AWAIT_ATTRIBUTES"},
+                        "trigger": {"id": "6e4af17f-bbee-4777-b10d-af042cd6e16a", "merge_behavior": "AWAIT_ATTRIBUTES"},
                         "ports": [{"id": "408cd5fb-3a3e-4eb2-9889-61111bd6a129", "name": "default", "type": "DEFAULT"}],
                         "adornments": [
                             {
@@ -342,7 +342,7 @@ def test_serialize_node__stacked():
                         "source_node_id": "c14c1c9b-a7a4-4d2c-84fb-c940cfb09525",
                         "source_handle_id": "51a5eb25-af14-4bee-9ced-d2aa534ea8e9",
                         "target_node_id": "074833b0-e142-4bbc-8dec-209a35e178a3",
-                        "target_handle_id": "f206358d-04a5-41c9-beee-0871a074fa48",
+                        "target_handle_id": "6e4af17f-bbee-4777-b10d-af042cd6e16a",
                         "type": "DEFAULT",
                     }
                 ],

{vellum_ai-0.14.19 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py

@@ -48,7 +48,7 @@ def test_serialize_node__constant_value(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "5d41f6fc-fc1a-4a19-9a06-6a0ea9d38557", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "e2cde904-de60-4755-87cf-55052ea23a51", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "96ac6512-0128-4cf7-ba51-2725b4807c8f", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
@@ -96,7 +96,7 @@ def test_serialize_node__constant_value_reference(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "174f3a8e-99c2-4045-8327-ad2dc658889e", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "dc2f90b9-14a1-457a-a9f9-dec7a04f74eb", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "61adfacf-c3a9-4aea-a3da-bcdbc03273c6", "name": "default", "type": "DEFAULT"}],
             "adornments": None,
             "attributes": [
@@ -138,7 +138,7 @@ def test_serialize_node__lazy_reference(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "a3598540-7464-4965-8a2f-f022a011007d", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "14ec4d19-13e5-4db3-94fa-4e15274bffc7", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "2dba7224-a376-4780-8414-2b50601f9283", "name": "default", "type": "DEFAULT"}],
             "adornments": None,
             "attributes": [
@@ -221,7 +221,7 @@ def test_serialize_node__workflow_input(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "dcb92d51-1fbd-4d41-ab89-c8f490d2bb38", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "debf37b9-720d-48dd-9699-69283966f927", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "20d91130-ca86-4420-b2e7-a962c0f1a509", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
@@ -309,7 +309,7 @@ def test_serialize_node__node_output(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "aa7f0dce-0413-4802-b1dd-f96a2d2eb8e5", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "d4b08664-bb78-4fdd-83a2-877c4ca4175a", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "a345665a-decd-4f6b-af38-387bd41c2643", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
@@ -359,7 +359,7 @@ def test_serialize_node__vellum_secret(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "c5006d90-90cc-4e97-9092-f75785fa61ec", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "70a3d4c0-83e3-428d-ac84-bf9e5644a84d", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "6d1c2139-64bd-4433-84d7-3fe08850134b", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
@@ -412,7 +412,7 @@ def test_serialize_node__node_execution(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "2fc95236-b5bc-4574-bade-2c9f0933b18c", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "0c06baa5-55b6-494a-a89d-9535dfa5f24b", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "59844b72-ac5e-43c5-b3a7-9c57ba73ec8c", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [
@@ -493,7 +493,7 @@ def test_serialize_node__coalesce(serialize_node):
                     "test_attributes_serialization",
                 ],
             },
-            "trigger": {"id": "0302231d-73f2-4587-8a62-8ed3640f0f91", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "b9894d9a-1887-416d-895d-a4129aac37b8", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "9d97a0c9-6a79-433a-bcdf-e07aa10c0f3c", "name": "default", "type": "DEFAULT"}],
             "adornments": None,
             "attributes": [

{vellum_ai-0.14.19 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_outputs_serialization.py

@@ -39,7 +39,7 @@ def test_serialize_node__annotated_output(serialize_node):
                     "test_outputs_serialization",
                 ],
             },
-            "trigger": {"id": "753f7ef1-8724-4af2-939a-794f74ffc21b", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "e66c7dde-02c9-4f6d-84a6-16117b54cd88", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "d83b7a5d-bbac-47ee-9277-1fbed71e83e8", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [],
@@ -87,7 +87,7 @@ def test_serialize_node__workflow_input(serialize_node):
                     "test_outputs_serialization",
                 ],
             },
-            "trigger": {"id": "dcb92d51-1fbd-4d41-ab89-c8f490d2bb38", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "debf37b9-720d-48dd-9699-69283966f927", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "20d91130-ca86-4420-b2e7-a962c0f1a509", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [],
@@ -150,7 +150,7 @@ def test_serialize_node__node_output_reference(serialize_node):
                     "test_outputs_serialization",
                 ],
             },
-            "trigger": {"id": "e949426f-9f3c-425e-a4de-8c0c5f6a8945", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "trigger": {"id": "c8804b97-9f84-41b6-ade8-aa74544d6846", "merge_behavior": "AWAIT_ATTRIBUTES"},
             "ports": [{"id": "383dc10a-d8f3-4bac-b995-8b95bc6deb21", "type": "DEFAULT", "name": "default"}],
             "adornments": None,
             "attributes": [],