vellum-ai 0.14.41__py3-none-any.whl → 0.14.43__py3-none-any.whl

vellum_ee/workflows/display/nodes/base_node_display.py

@@ -30,6 +30,7 @@ from vellum.workflows.expressions.contains import ContainsExpression
 from vellum.workflows.expressions.does_not_begin_with import DoesNotBeginWithExpression
 from vellum.workflows.expressions.does_not_contain import DoesNotContainExpression
 from vellum.workflows.expressions.does_not_end_with import DoesNotEndWithExpression
+from vellum.workflows.expressions.does_not_equal import DoesNotEqualExpression
 from vellum.workflows.expressions.ends_with import EndsWithExpression
 from vellum.workflows.expressions.equals import EqualsExpression
 from vellum.workflows.expressions.greater_than import GreaterThanExpression
@@ -177,29 +178,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
             existing_adornments = adornments if adornments is not None else []
             return display_class().serialize(display_context, adornments=existing_adornments + [adornment])
 
-        ports: JsonArray = []
-        for port in node.Ports:
-            id = str(self.get_node_port_display(port).id)
-
-            if port._condition_type:
-                ports.append(
-                    {
-                        "id": id,
-                        "name": port.name,
-                        "type": port._condition_type.value,
-                        "expression": (
-                            self.serialize_condition(display_context, port._condition) if port._condition else None
-                        ),
-                    }
-                )
-            else:
-                ports.append(
-                    {
-                        "id": id,
-                        "name": port.name,
-                        "type": "DEFAULT",
-                    }
-                )
+        ports = self.serialize_ports(display_context)
 
         outputs: JsonArray = []
         for output in node.Outputs:
@@ -236,6 +215,35 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
             "outputs": outputs,
         }
 
+    def serialize_ports(self, display_context: "WorkflowDisplayContext") -> JsonArray:
+        """Serialize the ports of the node."""
+        node = self._node
+        ports: JsonArray = []
+
+        for port in node.Ports:
+            id = str(self.get_node_port_display(port).id)
+            if port._condition_type:
+                ports.append(
+                    {
+                        "id": id,
+                        "name": port.name,
+                        "type": port._condition_type.value,
+                        "expression": (
+                            self.serialize_condition(display_context, port._condition) if port._condition else None
+                        ),
+                    }
+                )
+            else:
+                ports.append(
+                    {
+                        "id": id,
+                        "name": port.name,
+                        "type": "DEFAULT",
+                    }
+                )
+
+        return ports
+
     def get_base(self) -> CodeResourceDefinition:
         node = self._node
 
@@ -438,6 +446,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 DoesNotBeginWithExpression,
                 DoesNotContainExpression,
                 DoesNotEndWithExpression,
+                DoesNotEqualExpression,
                 EndsWithExpression,
                 EqualsExpression,
                 GreaterThanExpression,

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

@@ -192,4 +192,5 @@ class BaseAPINodeDisplay(BaseNodeDisplay[_APINodeType], Generic[_APINodeType]):
             "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
+            "ports": self.serialize_ports(display_context),
         }

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

@@ -98,4 +98,5 @@ class BaseCodeExecutionNodeDisplay(BaseNodeDisplay[_CodeExecutionNodeType], Gene
             "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
+            "ports": self.serialize_ports(display_context),
         }

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

@@ -217,6 +217,7 @@ but the defined conditions have length {len(condition_ids)}"""
             "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
+            "ports": self.serialize_ports(display_context),
         }
 
     def get_nested_rule_details_by_path(

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

@@ -12,11 +12,11 @@ from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
 
 _FinalOutputNodeType = TypeVar("_FinalOutputNodeType", bound=FinalOutputNode)
 
+NODE_INPUT_KEY = "node_input"
+
 
 class BaseFinalOutputNodeDisplay(BaseNodeDisplay[_FinalOutputNodeType], Generic[_FinalOutputNodeType]):
-    output_id: ClassVar[Optional[UUID]] = None
     output_name: ClassVar[Optional[str]] = None
-    node_input_id: ClassVar[Optional[UUID]] = None
 
     def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
         node = self._node
@@ -24,7 +24,7 @@ class BaseFinalOutputNodeDisplay(BaseNodeDisplay[_FinalOutputNodeType], Generic[
 
         node_input = create_node_input(
             node_id,
-            "node_input",
+            NODE_INPUT_KEY,
             # Get the pointer that the Terminal Node's output is referencing
             node.Outputs.value.instance,
             display_context,
@@ -58,13 +58,13 @@ class BaseFinalOutputNodeDisplay(BaseNodeDisplay[_FinalOutputNodeType], Generic[
         }
 
     def _get_output_id(self) -> UUID:
-        explicit_value = self._get_explicit_node_display_attr("output_id", UUID)
-        return explicit_value if explicit_value else uuid4_from_hash(f"{self.node_id}|output_id")
+        explicit_value = self.output_display.get(self._node.Outputs.value)
+        return explicit_value.id if explicit_value else uuid4_from_hash(f"{self.node_id}|output_id")
 
     def _get_output_name(self) -> str:
         explicit_value = self._get_explicit_node_display_attr("output_name", str)
         return explicit_value if explicit_value else to_kebab_case(self._node.__name__)
 
     def _get_node_input_id(self) -> UUID:
-        explicit_value = self._get_explicit_node_display_attr("node_input_id", UUID)
+        explicit_value = self.node_input_ids_by_name.get(NODE_INPUT_KEY)
         return explicit_value if explicit_value else uuid4_from_hash(f"{self.node_id}|node_input_id")

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

@@ -46,4 +46,5 @@ class BaseGuardrailNodeDisplay(BaseNodeDisplay[_GuardrailNodeType], Generic[_Gua
             "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
+            "ports": self.serialize_ports(display_context),
         }

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

@@ -72,6 +72,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
                 {"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),
         }
 
     def _generate_node_and_prompt_inputs(

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

@@ -54,6 +54,7 @@ class BaseInlineSubworkflowNodeDisplay(
             "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
+            "ports": self.serialize_ports(display_context),
         }
 
     def _generate_node_and_workflow_inputs(

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

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import Dict, Generic, List, Optional, TypeVar, cast
+from typing import Generic, Optional, TypeVar, cast
 
 from vellum.workflows.nodes import MapNode
 from vellum.workflows.types.core import JsonObject
@@ -36,24 +36,26 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
             parent_display_context=display_context,
         )
         serialized_subworkflow = subworkflow_display.serialize()
+        if not isinstance(serialized_subworkflow["input_variables"], list):
+            raise ValueError("input_variables must be a list")
 
-        renamed_input_variables = []
-        for input_variable in cast(List[Dict[str, str]], serialized_subworkflow["input_variables"]):
-            if input_variable["key"] == "all_items":
-                renamed_item = {**input_variable, "key": "items"}
-                renamed_input_variables.append(renamed_item)
-            else:
-                renamed_input_variables.append(input_variable)
+        input_variables = serialized_subworkflow["input_variables"]
 
         # Note: This must match the items input ID for the map node's node input
         items_workflow_input_id = next(
-            input_variable["id"] for input_variable in renamed_input_variables if input_variable["key"] == "items"
+            input_variable["id"]
+            for input_variable in input_variables
+            if isinstance(input_variable, dict) and input_variable["key"] == "items"
         )
         item_workflow_input_id = next(
-            input_variable["id"] for input_variable in renamed_input_variables if input_variable["key"] == "item"
+            input_variable["id"]
+            for input_variable in input_variables
+            if isinstance(input_variable, dict) and input_variable["key"] == "item"
         )
         index_workflow_input_id = next(
-            input_variable["id"] for input_variable in renamed_input_variables if input_variable["key"] == "index"
+            input_variable["id"]
+            for input_variable in input_variables
+            if isinstance(input_variable, dict) and input_variable["key"] == "index"
         )
 
         return {
@@ -67,7 +69,7 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
                 "target_handle_id": str(self.get_target_handle_id()),
                 "variant": "INLINE",
                 "workflow_raw_data": serialized_subworkflow["workflow_raw_data"],
-                "input_variables": cast(JsonObject, renamed_input_variables),
+                "input_variables": cast(JsonObject, input_variables),
                 "output_variables": serialized_subworkflow["output_variables"],
                 "concurrency": raise_if_descriptor(node.max_concurrency),
                 "items_input_id": items_workflow_input_id,
@@ -77,4 +79,5 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
             "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
+            "ports": self.serialize_ports(display_context),
         }

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

@@ -50,6 +50,7 @@ class BaseMergeNodeDisplay(BaseNodeDisplay[_MergeNodeType], Generic[_MergeNodeTy
             "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
+            "ports": self.serialize_ports(display_context),
         }
 
     def get_target_handle_ids(self) -> Optional[List[UUID]]:

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

@@ -66,4 +66,5 @@ class BasePromptDeploymentNodeDisplay(BaseNodeDisplay[_PromptDeploymentNodeType]
             "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
+            "ports": self.serialize_ports(display_context),
         }

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

@@ -68,6 +68,7 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
             "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
+            "ports": self.serialize_ports(display_context),
         }
 
     def _generate_search_node_inputs(

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

@@ -57,4 +57,5 @@ class BaseSubworkflowDeploymentNodeDisplay(
             "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
+            "ports": self.serialize_ports(display_context),
         }

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

@@ -67,4 +67,5 @@ class BaseTemplatingNodeDisplay(BaseNodeDisplay[_TemplatingNodeType], Generic[_T
             "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
+            "ports": self.serialize_ports(display_context),
         }

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

@@ -194,6 +194,7 @@ def test_serialize_workflow(vellum_client):
                 "name": "SimpleAPINode",
                 "module": ["tests", "workflows", "basic_api_node", "workflow"],
             },
+            "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

@@ -111,6 +111,7 @@ def test_serialize_workflow_with_filepath():
             "module": ["tests", "workflows", "basic_code_execution_node", "workflow"],
             "name": "SimpleCodeExecutionNode",
         },
+        "ports": [{"id": "832f81ec-427b-42a8-825c-e62c43c1f961", "name": "default", "type": "DEFAULT"}],
     }
     assert not DeepDiff(
         [
@@ -343,6 +344,7 @@ def test_serialize_workflow_with_code():
             "name": "SimpleCodeExecutionNode",
             "module": ["tests", "workflows", "basic_code_execution_node", "workflow_with_code"],
         },
+        "ports": [{"id": "832f81ec-427b-42a8-825c-e62c43c1f961", "name": "default", "type": "DEFAULT"}],
     }
     assert not DeepDiff(
         [
@@ -603,6 +605,7 @@ def test_serialize_workflow__try_wrapped():
                 ],
             }
         ],
+        "ports": [{"id": "832f81ec-427b-42a8-825c-e62c43c1f961", "name": "default", "type": "DEFAULT"}],
     }
 
     final_output_nodes = workflow_raw_data["nodes"][2:]

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

@@ -425,6 +425,87 @@ def test_serialize_workflow():
                 "name": "CategoryConditionalNode",
                 "module": ["tests", "workflows", "basic_conditional_node", "workflow"],
             },
+            "ports": [
+                {
+                    "id": "3a45b81f-95e4-4cbd-8997-bfdbe30251e8",
+                    "name": "category_question",
+                    "type": "IF",
+                    "expression": {
+                        "type": "BINARY_EXPRESSION",
+                        "lhs": {"type": "WORKFLOW_INPUT", "input_variable_id": "eece050a-432e-4a2c-8c87-9480397e4cbf"},
+                        "operator": "=",
+                        "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "question"}},
+                    },
+                },
+                {
+                    "id": "7202f702-1ebc-4067-ab1e-ec67e49158ee",
+                    "name": "category_complaint",
+                    "type": "ELIF",
+                    "expression": {
+                        "type": "BINARY_EXPRESSION",
+                        "lhs": {"type": "WORKFLOW_INPUT", "input_variable_id": "eece050a-432e-4a2c-8c87-9480397e4cbf"},
+                        "operator": "=",
+                        "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "complaint"}},
+                    },
+                },
+                {
+                    "id": "cf45705d-1a47-43a6-9d24-a7fdf78baae0",
+                    "name": "category_compliment",
+                    "type": "ELIF",
+                    "expression": {
+                        "type": "BINARY_EXPRESSION",
+                        "lhs": {"type": "WORKFLOW_INPUT", "input_variable_id": "eece050a-432e-4a2c-8c87-9480397e4cbf"},
+                        "operator": "=",
+                        "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "compliment"}},
+                    },
+                },
+                {
+                    "id": "f04610dd-61cf-41b0-b337-2235e101cdb0",
+                    "name": "category_statement",
+                    "type": "ELIF",
+                    "expression": {
+                        "type": "BINARY_EXPRESSION",
+                        "lhs": {
+                            "type": "BINARY_EXPRESSION",
+                            "lhs": {
+                                "type": "WORKFLOW_INPUT",
+                                "input_variable_id": "eece050a-432e-4a2c-8c87-9480397e4cbf",
+                            },
+                            "operator": "=",
+                            "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "statement"}},
+                        },
+                        "operator": "and",
+                        "rhs": {
+                            "type": "BINARY_EXPRESSION",
+                            "lhs": {
+                                "type": "BINARY_EXPRESSION",
+                                "lhs": {
+                                    "type": "WORKFLOW_INPUT",
+                                    "input_variable_id": "eece050a-432e-4a2c-8c87-9480397e4cbf",
+                                },
+                                "operator": "=",
+                                "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "statement"}},
+                            },
+                            "operator": "and",
+                            "rhs": {
+                                "type": "BINARY_EXPRESSION",
+                                "lhs": {
+                                    "type": "WORKFLOW_INPUT",
+                                    "input_variable_id": "eece050a-432e-4a2c-8c87-9480397e4cbf",
+                                },
+                                "operator": "=",
+                                "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "statement"}},
+                            },
+                        },
+                    },
+                },
+                {
+                    "id": "f9dde637-ea90-465f-a871-caf8380ae377",
+                    "name": "category_fallthrough",
+                    "type": "ELSE",
+                    "expression": None,
+                },
+            ],
         },
         conditional_node,
         ignore_order=True,
@@ -873,6 +954,25 @@ 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"],
             },
+            "ports": [
+                {
+                    "id": "2ff87aa6-37cf-43dd-af9d-13b9198ab70a",
+                    "name": "text_str",
+                    "type": "IF",
+                    "expression": {
+                        "type": "BINARY_EXPRESSION",
+                        "lhs": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "123"}},
+                        "operator": f"{operator}",
+                        "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "123"}},
+                    },
+                },
+                {
+                    "id": "9a7e8c2e-0228-4321-8f74-61cb5778f3df",
+                    "name": "text_fallthrough",
+                    "type": "ELSE",
+                    "expression": None,
+                },
+            ],
         },
         conditional_node,
         ignore_order=True,
@@ -966,6 +1066,24 @@ 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"],
             },
+            "ports": [
+                {
+                    "id": "2ff87aa6-37cf-43dd-af9d-13b9198ab70a",
+                    "name": "text_str",
+                    "type": "IF",
+                    "expression": {
+                        "type": "UNARY_EXPRESSION",
+                        "lhs": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "123"}},
+                        "operator": f"{operator}",
+                    },
+                },
+                {
+                    "id": "9a7e8c2e-0228-4321-8f74-61cb5778f3df",
+                    "name": "text_fallthrough",
+                    "type": "ELSE",
+                    "expression": None,
+                },
+            ],
         },
         conditional_node,
         ignore_order=True,
@@ -1072,6 +1190,26 @@ 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"],
             },
+            "ports": [
+                {
+                    "id": "2ff87aa6-37cf-43dd-af9d-13b9198ab70a",
+                    "name": "text_str",
+                    "type": "IF",
+                    "expression": {
+                        "type": "TERNARY_EXPRESSION",
+                        "base": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "123"}},
+                        "operator": f"{operator}",
+                        "lhs": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "123"}},
+                        "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "123"}},
+                    },
+                },
+                {
+                    "id": "9a7e8c2e-0228-4321-8f74-61cb5778f3df",
+                    "name": "text_fallthrough",
+                    "type": "ELSE",
+                    "expression": None,
+                },
+            ],
         },
         conditional_node,
         ignore_order=True,

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

@@ -118,6 +118,7 @@ def test_serialize_workflow():
             "module": ["tests", "workflows", "basic_guardrail_node", "workflow"],
             "name": "ExampleGuardrailNode",
         },
+        "ports": [{"id": "0ed87407-697e-4ae9-ab9b-6c5cc2e57cf7", "name": "default", "type": "DEFAULT"}],
     }
 
     final_output_node = workflow_raw_data["nodes"][2]

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

@@ -299,6 +299,7 @@ def test_serialize_workflow():
                 "name": "ExampleInlineSubworkflowNode",
                 "module": ["tests", "workflows", "basic_inline_subworkflow", "workflow"],
             },
+            "ports": [{"id": "cfd831bc-ee7f-44d0-8d76-0ba0cd0277dc", "name": "default", "type": "DEFAULT"}],
         },
         subworkflow_node,
         ignore_order=True,

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

@@ -254,7 +254,7 @@ def test_serialize_workflow():
                         "extensions": {"color": None},
                     },
                     {
-                        "id": "d6fc6c7a-235f-4b98-86f3-e258d1198f93",
+                        "id": "0acef1e7-caa1-4d9f-bb69-6981729af18d",
                         "key": "items",
                         "type": "JSON",
                         "required": True,
@@ -264,7 +264,7 @@ def test_serialize_workflow():
                 ],
                 "output_variables": [{"id": "2a957315-fae0-4366-8a35-f0b315c5eade", "key": "count", "type": "NUMBER"}],
                 "concurrency": None,
-                "items_input_id": "d6fc6c7a-235f-4b98-86f3-e258d1198f93",
+                "items_input_id": "0acef1e7-caa1-4d9f-bb69-6981729af18d",
                 "item_input_id": "b29bb546-9bc8-4136-857d-8c7a464ba9d4",
                 "index_input_id": "17e7ca49-668f-450d-a792-e1f97d13db67",
             },
@@ -277,6 +277,7 @@ def test_serialize_workflow():
                 "name": "MapFruitsNode",
                 "module": ["tests", "workflows", "basic_map_node", "workflow"],
             },
+            "ports": [{"id": "a2171a61-0657-43ad-b6d9-cf93ce3270d0", "name": "default", "type": "DEFAULT"}],
         },
         map_node,
         ignore_order=True,

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

@@ -84,6 +84,7 @@ def test_serialize_workflow__await_all():
                 "module": ["tests", "workflows", "basic_merge_node", "await_all_workflow"],
                 "name": "AwaitAllMergeNode",
             },
+            "ports": [{"id": "3bbc469f-0fb0-4b3d-a28b-746fefec2818", "name": "default", "type": "DEFAULT"}],
         },
         merge_node,
         ignore_order_func=lambda x: x.path() == "root['data']['target_handles']",

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

@@ -157,6 +157,7 @@ def test_serialize_workflow(vellum_client):
             "module": ["tests", "workflows", "basic_text_prompt_deployment", "workflow"],
             "name": "ExamplePromptDeploymentNode",
         },
+        "ports": [{"id": "2f26c7e0-283d-4f04-b639-adebb56bc679", "name": "default", "type": "DEFAULT"}],
     }
 
     final_output_node = workflow_raw_data["nodes"][2]

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

@@ -239,6 +239,7 @@ def test_serialize_workflow():
             "name": "SimpleSearchNode",
             "module": ["tests", "workflows", "basic_search_node", "workflow"],
         },
+        "ports": [{"id": "00ae06b3-f8d9-4ae6-9fbf-e4ff4d520e9b", "name": "default", "type": "DEFAULT"}],
     }
 
     final_output_node = workflow_raw_data["nodes"][2]

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

@@ -154,6 +154,7 @@ def test_serialize_workflow(vellum_client):
             "module": ["tests", "workflows", "basic_subworkflow_deployment", "workflow"],
             "name": "ExampleSubworkflowDeploymentNode",
         },
+        "ports": [{"id": "ab0db8a9-7b53-4d88-8667-273b31303273", "name": "default", "type": "DEFAULT"}],
     }
 
     assert not DeepDiff(

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

@@ -113,6 +113,7 @@ def test_serialize_workflow():
                 "name": "ExampleTemplatingNode",
                 "module": ["tests", "workflows", "basic_templating_node", "workflow_with_json_input"],
             },
+            "ports": [{"id": "39317827-df43-4f5a-bfbc-20bffc839748", "name": "default", "type": "DEFAULT"}],
         },
         templating_node,
     )

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

@@ -68,7 +68,7 @@ def test_serialize_workflow():
             "label": "Basic Final Output Node",
             "name": "basic-final-output-node",
             "target_handle_id": "0173d3c6-11d1-44b7-b070-ca9ff5119046",
-            "output_id": "97349956-d228-4b51-a64b-1331f788373f",
+            "output_id": "aa63e3f6-fde3-4d19-84ef-29982d44d709",
             "output_type": "STRING",
             "node_input_id": "5322567a-f40c-400a-96b3-c3b054db543e",
         },
@@ -98,7 +98,7 @@ def test_serialize_workflow():
         },
         "outputs": [
             {
-                "id": "97349956-d228-4b51-a64b-1331f788373f",
+                "id": "aa63e3f6-fde3-4d19-84ef-29982d44d709",
                 "name": "value",
                 "type": "STRING",
                 "value": {"type": "WORKFLOW_INPUT", "input_variable_id": "e39a7b63-de15-490a-ae9b-8112c767aea0"},

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

@@ -92,7 +92,7 @@ def test_serialize_workflow__missing_final_output_node():
                     "label": "First Final Output Node",
                     "name": "first-final-output-node",
                     "target_handle_id": "a0c2eb7a-398e-4f28-b63d-f3bae9b563ee",
-                    "output_id": "5517e50d-7f40-4f7c-acb2-e329d79a25bf",
+                    "output_id": "0cd02933-c5b9-47c9-aede-e97c5870e8aa",
                     "output_type": "STRING",
                     "node_input_id": "16363762-c14a-4162-8fab-525079d3cffe",
                 },
@@ -122,7 +122,7 @@ def test_serialize_workflow__missing_final_output_node():
                 },
                 "outputs": [
                     {
-                        "id": "5517e50d-7f40-4f7c-acb2-e329d79a25bf",
+                        "id": "0cd02933-c5b9-47c9-aede-e97c5870e8aa",
                         "name": "value",
                         "type": "STRING",
                         "value": {

vellum/client/types/node_event_display_context.py

@@ -1,30 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from __future__ import annotations
-from ..core.pydantic_utilities import UniversalBaseModel
-import typing
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
-import pydantic
-from ..core.pydantic_utilities import update_forward_refs
-
-
-class NodeEventDisplayContext(UniversalBaseModel):
-    input_display: typing.Dict[str, str]
-    output_display: typing.Dict[str, str]
-    port_display: typing.Dict[str, str]
-    subworkflow_display: typing.Optional["WorkflowEventDisplayContext"] = None
-
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
-    else:
-
-        class Config:
-            frozen = True
-            smart_union = True
-            extra = pydantic.Extra.allow
-
-
-from .workflow_event_display_context import WorkflowEventDisplayContext  # noqa: E402
-
-update_forward_refs(WorkflowEventDisplayContext, NodeEventDisplayContext=NodeEventDisplayContext)
-update_forward_refs(NodeEventDisplayContext)