vellum-ai 0.14.72__tar.gz → 0.14.74__tar.gz

{vellum_ai-0.14.72 → vellum_ai-0.14.74}/PKG-INFO

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

{vellum_ai-0.14.72 → vellum_ai-0.14.74}/ee/vellum_cli/push.py

@@ -13,10 +13,9 @@ from vellum.client.core.api_error import ApiError
 from vellum.resources.workflows.client import OMIT
 from vellum.types import WorkflowPushDeploymentConfigRequest
 from vellum.workflows.vellum_client import create_vellum_client
-from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_cli.config import DEFAULT_WORKSPACE_CONFIG, WorkflowConfig, WorkflowDeploymentConfig, load_vellum_cli_config
 from vellum_cli.logger import handle_cli_error, load_cli_logger
-from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 
 
 def push_command(
@@ -106,13 +105,12 @@ def push_command(
 
     # Remove this once we could serialize using the artifact in Vembda
     # https://app.shortcut.com/vellum/story/5585
-    workflow = BaseWorkflow.load_from_module(workflow_config.module)
-    workflow_display = get_workflow_display(
-        workflow_class=workflow,
+    serialization_result = BaseWorkflowDisplay.serialize_module(
+        workflow_config.module,
         client=client,
         dry_run=dry_run or False,
     )
-    exec_config = workflow_display.serialize()
+    exec_config = serialization_result.exec_config
 
     container_tag = workflow_config.container_image_tag
     if workflow_config.container_image_name and not workflow_config.container_image_tag:
@@ -229,7 +227,7 @@ def push_command(
         raise e
 
     if dry_run:
-        error_messages = [str(e) for e in workflow_display.errors]
+        error_messages = serialization_result.errors
         error_message = "\n".join(error_messages) if error_messages else "No errors found."
         logger.info(
             f"""\
@@ -243,7 +241,7 @@ def push_command(
 """
         )  # type: ignore[attr-defined]
 
-        error_list = list(workflow_display.errors)
+        error_list = serialization_result.errors
         has_errors = len(error_list) > 0
         has_diffs = response.proposed_diffs is not None and response.proposed_diffs
 

{vellum_ai-0.14.72 → vellum_ai-0.14.74}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -15,6 +15,20 @@ from vellum_ee.workflows.display.utils.expressions import serialize_value
 from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
 from vellum_ee.workflows.display.vellum import NodeInput
 
+
+def _contains_descriptors(obj):
+    """Check if an object contains any descriptors or references that need special handling."""
+    if isinstance(obj, BaseDescriptor):
+        return True
+    elif isinstance(obj, dict):
+        return any(_contains_descriptors(v) for v in obj.values())
+    elif isinstance(obj, (list, tuple)):
+        return any(_contains_descriptors(item) for item in obj)
+    elif hasattr(obj, "__dict__"):
+        return any(_contains_descriptors(getattr(obj, field)) for field in obj.__dict__)
+    return False
+
+
 _InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
 
 
@@ -23,7 +37,6 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         InlinePromptNode.prompt_inputs,
     }
     __unserializable_attributes__ = {
-        InlinePromptNode.parameters,
         InlinePromptNode.settings,
         InlinePromptNode.expand_meta,
         InlinePromptNode.request_options,
@@ -46,11 +59,15 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
 
         ml_model = str(raise_if_descriptor(node.ml_model))
 
-        blocks: list = [
-            self._generate_prompt_block(block, input_variable_id_by_name, [i])
-            for i, block in enumerate(node_blocks)
-            if not isinstance(block, BaseDescriptor)
-        ]
+        has_descriptors = _contains_descriptors(node_blocks)
+
+        blocks: list = []
+        if not has_descriptors:
+            blocks = [
+                self._generate_prompt_block(block, input_variable_id_by_name, [i])
+                for i, block in enumerate(node_blocks)
+                if not isinstance(block, BaseDescriptor)
+            ]
 
         functions = (
             [self._generate_function_tools(function, i) for i, function in enumerate(function_definitions)]
@@ -72,7 +89,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
                 "target_handle_id": str(self.get_target_handle_id()),
                 "variant": "INLINE",
                 "exec_config": {
-                    "parameters": raise_if_descriptor(node.parameters).dict(),
+                    "parameters": self._serialize_parameters(node.parameters, display_context),
                     "input_variables": [prompt_input.dict() for prompt_input in prompt_inputs],
                     "prompt_template_block_data": {
                         "version": 1,
@@ -156,6 +173,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
             }
 
         elif prompt_block.block_type == "CHAT_MESSAGE":
+
             chat_properties: JsonObject = {
                 "chat_role": prompt_block.chat_role,
                 "chat_source": prompt_block.chat_source,
@@ -253,3 +271,14 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
                 raise ValueError(f"Failed to serialize attribute '{attribute.name}': {e}")
 
         return attributes
+
+    def _serialize_parameters(self, parameters, display_context: "WorkflowDisplayContext") -> JsonObject:
+        """Serialize parameters, returning empty object when nested descriptors are detected."""
+        params = raise_if_descriptor(parameters)
+        if not params:
+            return {}
+
+        if _contains_descriptors(params):
+            return {}
+
+        return params.dict()

{vellum_ai-0.14.72 → vellum_ai-0.14.74}/ee/vellum_ee/workflows/display/nodes/vellum/subworkflow_deployment_node.py

@@ -1,6 +1,7 @@
 from uuid import UUID
 from typing import Generic, Optional, TypeVar
 
+from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes import SubworkflowDeploymentNode
 from vellum.workflows.types.core import JsonObject
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
@@ -23,6 +24,12 @@ class BaseSubworkflowDeploymentNodeDisplay(
         node_id = self.node_id
 
         subworkflow_inputs = raise_if_descriptor(node.subworkflow_inputs)
+
+        if isinstance(subworkflow_inputs, BaseInputs):
+            input_items = [(input_descriptor.name, input_value) for input_descriptor, input_value in subworkflow_inputs]
+        else:
+            input_items = list(subworkflow_inputs.items())
+
         node_inputs = [
             create_node_input(
                 node_id=node_id,
@@ -34,7 +41,7 @@ class BaseSubworkflowDeploymentNodeDisplay(
                 )
                 or self.node_input_ids_by_name.get(variable_name),
             )
-            for variable_name, variable_value in subworkflow_inputs.items()
+            for variable_name, variable_value in input_items
         ]
 
         deployment = display_context.client.workflow_deployments.retrieve(

{vellum_ai-0.14.72 → vellum_ai-0.14.74}/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_prompt_node.py

@@ -2,6 +2,7 @@ import pytest
 from uuid import UUID
 from typing import Type
 
+from vellum.client.types.prompt_parameters import PromptParameters
 from vellum.client.types.variable_prompt_block import VariablePromptBlock
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.inputs import BaseInputs
@@ -280,3 +281,104 @@ def test_serialize_node__port_groups():
 
     # AND the legacy source_handle_id should be the default port
     assert my_prompt_node["data"]["source_handle_id"] == "149d97a4-3da3-44a9-95f7-ea7b8d38b877"
+
+
+def test_serialize_node__prompt_parameters__dynamic_references():
+    # GIVEN input definition
+    class MyInputs(BaseInputs):
+        input_value: str
+
+    # AND a prompt node with PromptParameters containing dynamic references
+    class DynamicPromptNode(InlinePromptNode):
+        blocks = []
+        ml_model = "gpt-4o"
+        parameters = PromptParameters(custom_parameters={"json_schema": MyInputs.input_value})
+
+    # AND a workflow with the prompt node
+    class Workflow(BaseWorkflow[MyInputs, BaseState]):
+        graph = DynamicPromptNode
+
+    # 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 PromptParameters
+    dynamic_prompt_node = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(DynamicPromptNode.__id__)
+    )
+
+    # AND the parameters should be properly serialized in exec_config
+    exec_config = dynamic_prompt_node["data"]["exec_config"]
+    assert "parameters" in exec_config
+
+    parameters = exec_config["parameters"]
+    assert parameters == {}
+
+    # AND the parameters should also be serialized in the attributes array
+    parameters_attribute = next(
+        (attr for attr in dynamic_prompt_node.get("attributes", []) if attr["name"] == "parameters"), None
+    )
+    assert parameters_attribute is not None
+    assert parameters_attribute["name"] == "parameters"
+    assert parameters_attribute["value"]["type"] == "DICTIONARY_REFERENCE"
+    assert parameters_attribute["value"]["entries"] == [
+        {
+            "id": "6b63ff96-a2eb-4c6e-bad1-bde01605fa86",
+            "key": "stop",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "265a1c17-2089-4ac1-b2ce-361b6b9a3335",
+            "key": "temperature",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "699976ec-8ec2-476a-a011-7cf810a8a307",
+            "key": "max_tokens",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "a87e23da-9794-41ff-ba80-c3a77e976e75",
+            "key": "top_p",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "18eb53c2-ec1a-4115-9f21-083af430df67",
+            "key": "top_k",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "295509a2-5837-452c-893d-f47b67c63c8a",
+            "key": "frequency_penalty",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "5fc64379-5566-426a-a909-dd56c3305aa5",
+            "key": "presence_penalty",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "5d326da0-c096-4425-8bf1-3a18764e96e3",
+            "key": "logit_bias",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "cd1a0e1b-6667-48a0-9964-257e1ec8851d",
+            "key": "custom_parameters",
+            "value": {
+                "entries": [
+                    {
+                        "id": "a9a3092e-dd18-4533-b6b5-24588ebd8f7f",
+                        "key": "json_schema",
+                        "value": {
+                            "input_variable_id": "c02d1201-86d1-4364-b3b3-4fc6824db8a4",
+                            "type": "WORKFLOW_INPUT",
+                        },
+                    }
+                ],
+                "type": "DICTIONARY_REFERENCE",
+            },
+        },
+    ]

{vellum_ai-0.14.72 → vellum_ai-0.14.74}/ee/vellum_ee/workflows/display/tests/test_base_workflow_display.py

@@ -39,7 +39,7 @@ def test_base_workflow_display__serialize_empty_workflow():
                     "data": {"label": "Entrypoint Node", "source_handle_id": "0af025a4-3b25-457d-a7ae-e3a7ba15c86c"},
                     "base": None,
                     "definition": None,
-                    "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                    "display_data": {"position": {"x": 0.0, "y": -50.0}},
                     "id": "3c41cdd9-999a-48b8-9088-f6dfa1369bfd",
                     "inputs": [],
                     "type": "ENTRYPOINT",

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

@@ -249,7 +249,7 @@ def test_serialize_node__stacked():
             "id": "074833b0-e142-4bbc-8dec-209a35e178a3",
             "label": "test_serialize_node__stacked.<locals>.InnerStackedGenericNode",
             "type": "GENERIC",
-            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "display_data": {"position": {"x": 200.0, "y": -50.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
             "definition": {
                 "name": "InnerStackedGenericNode",

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

@@ -1,7 +1,10 @@
+import pytest
+from dataclasses import dataclass
 from uuid import uuid4
 from typing import List
 
 from deepdiff import DeepDiff
+from pydantic import BaseModel
 
 from vellum.client.types.chat_message import ChatMessage
 from vellum.workflows.inputs.base import BaseInputs
@@ -70,6 +73,28 @@ def test_serialize_node__constant_value(serialize_node):
     )
 
 
+@pytest.mark.parametrize(
+    "boolean_value, expected_value",
+    [
+        (True, True),
+        (False, False),
+    ],
+)
+def test_serialize_node__constant_boolean_value(serialize_node, boolean_value, expected_value):
+    class BooleanValueGenericNode(BaseNode):
+        attr: bool = boolean_value
+
+    serialized_node = serialize_node(BooleanValueGenericNode)
+
+    assert serialized_node["attributes"][0]["value"] == {
+        "type": "CONSTANT_VALUE",
+        "value": {
+            "type": "JSON",
+            "value": expected_value,
+        },
+    }
+
+
 def test_serialize_node__constant_value_reference(serialize_node):
     class ConstantValueReferenceGenericNode(BaseNode):
         attr: str = ConstantValueReference("hello")
@@ -269,7 +294,7 @@ def test_serialize_node__workflow_input_as_nested_chat_history():
             "id": "11be9d37-0069-4695-a317-14a3b6519d4e",
             "label": "test_serialize_node__workflow_input_as_nested_chat_history.<locals>.GenericNode",
             "type": "GENERIC",
-            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "display_data": {"position": {"x": 200.0, "y": -50.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
             "definition": {
                 "name": "GenericNode",
@@ -580,3 +605,68 @@ def test_serialize_node__coalesce(serialize_node):
         serialized_node,
         ignore_order=True,
     )
+
+
+def test_serialize_node__dataclass_with_node_output_reference(serialize_node):
+    @dataclass
+    class MyDataClass:
+        name: str
+        node_ref: str
+
+    class NodeWithOutput(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+    class NodeWithOutputDisplay(BaseNodeDisplay[NodeWithOutput]):
+        pass
+
+    class GenericNodeWithDataclass(BaseNode):
+        attr = MyDataClass(name="test", node_ref=NodeWithOutput.Outputs.result)
+
+    node_output_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=GenericNodeWithDataclass,
+        global_node_displays={NodeWithOutput: NodeWithOutputDisplay()},
+        global_node_output_displays={
+            NodeWithOutput.Outputs.result: (NodeWithOutput, NodeOutputDisplay(id=node_output_id, name="result"))
+        },
+    )
+
+    attr_value = serialized_node["attributes"][0]["value"]
+    assert attr_value["type"] == "DICTIONARY_REFERENCE"
+
+    assert any(
+        entry["key"] == "node_ref" and entry["value"]["type"] == "NODE_OUTPUT" for entry in attr_value["entries"]
+    )
+
+
+def test_serialize_node__pydantic_with_node_output_reference(serialize_node):
+    class MyPydanticModel(BaseModel):
+        name: str
+        node_ref: str
+
+    class NodeWithOutput(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+    class NodeWithOutputDisplay(BaseNodeDisplay[NodeWithOutput]):
+        pass
+
+    class GenericNodeWithPydantic(BaseNode):
+        attr = MyPydanticModel(name="test", node_ref=NodeWithOutput.Outputs.result)
+
+    node_output_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=GenericNodeWithPydantic,
+        global_node_displays={NodeWithOutput: NodeWithOutputDisplay()},
+        global_node_output_displays={
+            NodeWithOutput.Outputs.result: (NodeWithOutput, NodeOutputDisplay(id=node_output_id, name="result"))
+        },
+    )
+
+    attr_value = serialized_node["attributes"][0]["value"]
+    assert attr_value["type"] == "DICTIONARY_REFERENCE"
+
+    assert any(
+        entry["key"] == "node_ref" and entry["value"]["type"] == "NODE_OUTPUT" for entry in attr_value["entries"]
+    )

{vellum_ai-0.14.72 → vellum_ai-0.14.74}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_api_node_serialization.py

@@ -64,7 +64,7 @@ def test_serialize_workflow(vellum_client):
         "type": "ENTRYPOINT",
         "inputs": [],
         "data": {"label": "Entrypoint Node", "source_handle_id": "8eaa7f02-25ff-4a00-9b0a-5185718d89b3"},
-        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "display_data": {"position": {"x": 0.0, "y": -50.0}},
         "base": None,
         "definition": None,
     }
@@ -184,7 +184,7 @@ def test_serialize_workflow(vellum_client):
                 "json_output_id": "12e4a99d-883d-4da5-aa51-35817d94013e",
                 "status_code_output_id": "fecc16c3-400e-4fd3-8223-08366070e3b1",
             },
-            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "display_data": {"position": {"x": 200.0, "y": -50.0}},
             "base": {
                 "name": "APINode",
                 "module": ["vellum", "workflows", "nodes", "displayable", "api_node", "node"],
@@ -230,7 +230,7 @@ def test_serialize_workflow(vellum_client):
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 400.0, "y": 200.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -266,7 +266,7 @@ def test_serialize_workflow(vellum_client):
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 400.0, "y": -50.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -302,7 +302,7 @@ def test_serialize_workflow(vellum_client):
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 400.0, "y": -300.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],

{vellum_ai-0.14.72 → vellum_ai-0.14.74}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_code_execution_node_serialization.py

@@ -50,7 +50,7 @@ def test_serialize_workflow_with_filepath():
         "type": "ENTRYPOINT",
         "inputs": [],
         "data": {"label": "Entrypoint Node", "source_handle_id": "118e4298-aa79-467c-b8b4-2df540905e86"},
-        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "display_data": {"position": {"x": 0.0, "y": -50.0}},
         "base": None,
         "definition": None,
     }
@@ -94,7 +94,7 @@ def test_serialize_workflow_with_filepath():
             "output_id": "0fde9607-353f-42c2-85c4-20f720ebc1ec",
             "log_output_id": "7cac05e3-b7c3-475e-8df8-422b496c3398",
         },
-        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "display_data": {"position": {"x": 200.0, "y": -50.0}},
         "base": {
             "module": [
                 "vellum",
@@ -143,7 +143,7 @@ def test_serialize_workflow_with_filepath():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 400.0, "y": -175.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -179,7 +179,7 @@ def test_serialize_workflow_with_filepath():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 400.0, "y": 75.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -289,7 +289,7 @@ def test_serialize_workflow_with_code():
         "type": "ENTRYPOINT",
         "inputs": [],
         "data": {"label": "Entrypoint Node", "source_handle_id": "e82390bb-c68c-48c1-9f87-7fbfff494c45"},
-        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "display_data": {"position": {"x": 0.0, "y": -50.0}},
         "base": None,
         "definition": None,
     }
@@ -333,7 +333,7 @@ def test_serialize_workflow_with_code():
             "output_id": "0fde9607-353f-42c2-85c4-20f720ebc1ec",
             "log_output_id": "7cac05e3-b7c3-475e-8df8-422b496c3398",
         },
-        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "display_data": {"position": {"x": 200.0, "y": -50.0}},
         "base": {
             "name": "CodeExecutionNode",
             "module": ["vellum", "workflows", "nodes", "displayable", "code_execution_node", "node"],
@@ -375,7 +375,7 @@ def test_serialize_workflow_with_code():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 400.0, "y": -175.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -411,7 +411,7 @@ def test_serialize_workflow_with_code():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 400.0, "y": 75.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -522,7 +522,7 @@ def test_serialize_workflow__try_wrapped():
         "base": None,
         "definition": None,
         "display_data": {
-            "position": {"x": 0.0, "y": 0.0},
+            "position": {"x": 0.0, "y": -50.0},
         },
     }
 
@@ -565,7 +565,7 @@ def test_serialize_workflow__try_wrapped():
             "output_id": "0fde9607-353f-42c2-85c4-20f720ebc1ec",
             "log_output_id": "7cac05e3-b7c3-475e-8df8-422b496c3398",
         },
-        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "display_data": {"position": {"x": 200.0, "y": -50.0}},
         "base": {
             "module": [
                 "vellum",
@@ -637,7 +637,7 @@ def test_serialize_workflow__try_wrapped():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 400.0, "y": 75.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -673,7 +673,7 @@ def test_serialize_workflow__try_wrapped():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 400.0, "y": -175.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],

{vellum_ai-0.14.72 → vellum_ai-0.14.74}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_conditional_node_serialization.py

@@ -111,7 +111,7 @@ def test_serialize_workflow():
             "source_handle_id": "c2f0871d-0d9d-417f-8b0e-c813ccf880ac",
         },
         "display_data": {
-            "position": {"x": 0.0, "y": 0.0},
+            "position": {"x": 0.0, "y": -50.0},
         },
     }
 
@@ -415,7 +415,7 @@ def test_serialize_workflow():
                 ],
                 "version": "2",
             },
-            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "display_data": {"position": {"x": 200.0, "y": -50.0}},
             "base": {
                 "name": "ConditionalNode",
                 "module": ["vellum", "workflows", "nodes", "displayable", "conditional_node", "node"],
@@ -544,7 +544,7 @@ def test_serialize_workflow():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 600.0, "y": -50.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -580,7 +580,7 @@ def test_serialize_workflow():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 600.0, "y": -550.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -616,7 +616,7 @@ def test_serialize_workflow():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 600.0, "y": 200.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -652,7 +652,7 @@ def test_serialize_workflow():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 600.0, "y": -300.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -688,7 +688,7 @@ def test_serialize_workflow():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 600.0, "y": 450.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -943,7 +943,7 @@ def test_conditional_node_serialize_all_operators_with_lhs_and_rhs(descriptor, o
                 ],
                 "version": "2",
             },
-            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "display_data": {"position": {"x": 200.0, "y": -50.0}},
             "base": {
                 "name": "ConditionalNode",
                 "module": ["vellum", "workflows", "nodes", "displayable", "conditional_node", "node"],
@@ -1054,7 +1054,7 @@ def test_conditional_node_serialize_all_operators_with_expression(descriptor, op
                 ],
                 "version": "2",
             },
-            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "display_data": {"position": {"x": 200.0, "y": -50.0}},
             "base": {
                 "name": "ConditionalNode",
                 "module": ["vellum", "workflows", "nodes", "displayable", "conditional_node", "node"],
@@ -1177,7 +1177,7 @@ def test_conditional_node_serialize_all_operators_with_value_and_start_and_end(d
                 ],
                 "version": "2",
             },
-            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "display_data": {"position": {"x": 200.0, "y": -50.0}},
             "base": {
                 "name": "ConditionalNode",
                 "module": ["vellum", "workflows", "nodes", "displayable", "conditional_node", "node"],