vellum-ai 0.11.7__py3-none-any.whl → 0.11.9__py3-none-any.whl

vellum/client/core/client_wrapper.py

@@ -17,7 +17,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.11.7",
+            "X-Fern-SDK-Version": "0.11.9",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.11.7.dist-info → vellum_ai-0.11.9.dist-info}/METADATA

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

{vellum_ai-0.11.7.dist-info → vellum_ai-0.11.9.dist-info}/RECORD

@@ -1,17 +1,17 @@
 vellum_cli/CONTRIBUTING.md,sha256=FtDC7BGxSeMnwCXAUssFsAIElXtmJE-O5Z7BpolcgvI,2935
 vellum_cli/README.md,sha256=2NudRoLzWxNKqnuVy1JuQ7DerIaxWGYkrH8kMd-asIE,90
-vellum_cli/__init__.py,sha256=pftUQ6FiyfebNEB8xcfwzLjpfFDCAiH15xHBU6xr_wY,6733
+vellum_cli/__init__.py,sha256=XG6aC1NSPfBjNFzqiy9Lbk4DnELCKO8lpIZ3jeJR0r0,6990
 vellum_cli/aliased_group.py,sha256=ugW498j0yv4ALJ8vS9MsO7ctDW7Jlir9j6nE_uHAP8c,3363
 vellum_cli/config.py,sha256=wJQnv3tCgu1BOugg0AOP94yQ-x1yAg8juX_QoFN9Y7w,5223
 vellum_cli/image_push.py,sha256=SJwhwWJsLjwGNezNVd_oCVpFMfPsAB3dfLWmriZZUtw,4419
 vellum_cli/logger.py,sha256=PuRFa0WCh4sAGFS5aqWB0QIYpS6nBWwPJrIXpWxugV4,1022
-vellum_cli/pull.py,sha256=6wIiorqSx2rmR6atZJHHBuLSviocxK_n0DQxEDGmCzo,4008
+vellum_cli/pull.py,sha256=EkQirsTe0KCpJ8oHTE3S9_M2XHSrb2wrXNq4hTkMZng,5770
 vellum_cli/push.py,sha256=kbvlzZ9KnkS5DxxKHQP5ZvHHk1-CbCDg9LqnIRAWyt4,5258
 vellum_cli/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_cli/tests/conftest.py,sha256=eFGwBxib3Nki830lIFintB0b6r4x8T_KMnmzhlTY5x0,1337
 vellum_cli/tests/test_config.py,sha256=uvKGDc8BoVyT9_H0Z-g8469zVxomn6Oi3Zj-vK7O_wU,2631
 vellum_cli/tests/test_main.py,sha256=qDZG-aQauPwBwM6A2DIu1494n47v3pL28XakTbLGZ-k,272
-vellum_cli/tests/test_pull.py,sha256=N6ZphvHYGokclbpbTpgOmpu_m2GtocDEesbdeHFjO5Y,13194
+vellum_cli/tests/test_pull.py,sha256=pGqpBkahC360UITDE8BlcJ7LPd9DyRPn4NrCNdkQmAQ,15907
 vellum_cli/tests/test_push.py,sha256=V2iGcskh2X3OHj2uV5Vx_BhmtyfmUkyx0lrp8DDOExc,5824
 vellum_ee/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -39,7 +39,7 @@ vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=AqUlItgSZij12qRKguKV
 vellum_ee/workflows/display/nodes/vellum/merge_node.py,sha256=BM3nfL0-D8x91xW0MGhnJFo45ZgGLXDqdbiSGoSuXN0,3244
 vellum_ee/workflows/display/nodes/vellum/note_node.py,sha256=9VpC3h0RYOxJuRbjDwidBYlLKakkmlEnDMBh2C7lHcY,1107
 vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py,sha256=gLRkizwyw21-Z12IyDbdOJpXayiZZd4HWd6qgZQg8sc,3106
-vellum_ee/workflows/display/nodes/vellum/search_node.py,sha256=YkHGcjcoI3LqBkT5dmRZjHZt7mOIllwwvP6zaDKUjGU,8682
+vellum_ee/workflows/display/nodes/vellum/search_node.py,sha256=yH_xeb03kLsfTbhrZL7HPjNLGP9SepFcBjDHY7CggOo,8692
 vellum_ee/workflows/display/nodes/vellum/subworkflow_deployment_node.py,sha256=zOp4voBSgB3MR1R93wTOrsiiara_hxEAYFupLl_SvTA,2657
 vellum_ee/workflows/display/nodes/vellum/templating_node.py,sha256=UNYxoE-89agE8ugK0aWg_uN61jPqlC2VSxWHk568sN4,3324
 vellum_ee/workflows/display/nodes/vellum/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -58,6 +58,7 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_inline_subwo
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_map_node_serialization.py,sha256=H1bVDG_mFPokJ7OYrnl9rM9M3gEa5bctGmhUuKccB4U,15950
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_merge_node_serialization.py,sha256=vm-dRH_Y-qU9whkwBUNnhVPYL_Ua6cqpaDsDSEgRkxo,9998
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_prompt_deployment_serialization.py,sha256=NkpgaTbu6nLr3iwgsSNtiHyiNDCUaFakd1JaoW6CC6Y,9489
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_search_node_serialization.py,sha256=9R6ELHBn9tsp3cy15q1qp1OByyCxFOVdrM67EwCYY50,12984
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_subworkflow_deployment_serialization.py,sha256=8bz0vm_EyQKSjnwS5vqqgnjE9ygvm-CaPKcwCfeOrlo,12704
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py,sha256=xG8nKA1iKXxUe1fnD2X6qm7cUGW14iq2P-L16zhcKC8,4271
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py,sha256=1_02RbghUwhKMr8VtRaPjHOXAX59hgWw1rJ2EDyKs-E,2880
@@ -78,7 +79,7 @@ vellum/client/README.md,sha256=JkCJjmMZl4jrPj46pkmL9dpK4gSzQQmP5I7z4aME4LY,4749
 vellum/client/__init__.py,sha256=o4m7iRZWEV8rP3GkdaztHAjNmjxjWERlarviFoHzuKI,110927
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=eghuX9VDHvuYYt-Wqvz8ty2UvE1SVCNJ9e3eEKHptZA,1890
+vellum/client/core/client_wrapper.py,sha256=7ETrjiHmBNoSjt9dOpoOQoV1KfdagFOllIIAwyOIi8U,1890
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=X9IbmkZmB2bB_DpmZAO3crWdXagOakAyn6UCOCImCPg,2322
 vellum/client/core/http_client.py,sha256=R0pQpCppnEtxccGvXl4uJ76s7ro_65Fo_erlNNLp_AI,19228
@@ -1377,8 +1378,8 @@ vellum/workflows/vellum_client.py,sha256=ODrq_TSl-drX2aezXegf7pizpWDVJuTXH-j6528
 vellum/workflows/workflows/__init__.py,sha256=KY45TqvavCCvXIkyCFMEc0dc6jTMOUci93U2DUrlZYc,66
 vellum/workflows/workflows/base.py,sha256=mnI-kZ78yt7u6NFSTUo-tYjDnarP-RJ7uZjwjCn6PCQ,16795
 vellum/workflows/workflows/event_filters.py,sha256=-uQcMB7IpPd-idMku8f2QNVhPXPFWo6FZLlGjRf8rCo,1996
-vellum_ai-0.11.7.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.11.7.dist-info/METADATA,sha256=Ctay-bB1zitkr2zkIvFyJ5Rp9ocF0Vy0_2WpFR9Qd1U,5128
-vellum_ai-0.11.7.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-vellum_ai-0.11.7.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.11.7.dist-info/RECORD,,
+vellum_ai-0.11.9.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.11.9.dist-info/METADATA,sha256=mbIOikcPuEIU344kVitGc9qdEQCbVQn5_-GrKT7XgdI,5128
+vellum_ai-0.11.9.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+vellum_ai-0.11.9.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.11.9.dist-info/RECORD,,

vellum_cli/__init__.py

@@ -148,6 +148,11 @@ def pull(
 Should only be used for debugging purposes.""",
 )
 @click.option("--workflow-sandbox-id", type=str, help="Pull the Workflow from a specific Sandbox ID")
+@click.option(
+    "--workflow-deployment",
+    type=str,
+    help="""Pull the Workflow from a specific Deployment. Can use the name or the ID of the Deployment.""",
+)
 @click.option(
     "--exclude-code",
     is_flag=True,
@@ -158,6 +163,7 @@ def workflows_pull(
     module: Optional[str],
     include_json: Optional[bool],
     workflow_sandbox_id: Optional[str],
+    workflow_deployment: Optional[str],
     exclude_code: Optional[bool],
 ) -> None:
     """
@@ -169,6 +175,7 @@ def workflows_pull(
         module=module,
         include_json=include_json,
         workflow_sandbox_id=workflow_sandbox_id,
+        workflow_deployment=workflow_deployment,
         exclude_code=exclude_code,
     )
 

vellum_cli/pull.py

@@ -1,39 +1,84 @@
 import io
 import os
 from pathlib import Path
+from uuid import UUID
 import zipfile
-from typing import Optional
+from typing import Optional, Union
 
 from dotenv import load_dotenv
+from pydash import snake_case
 
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.vellum_client import create_vellum_client
 from vellum_cli.config import VellumCliConfig, WorkflowConfig, load_vellum_cli_config
 from vellum_cli.logger import load_cli_logger
 
 
-def resolve_workflow_config(
+def _is_valid_uuid(val: Union[str, UUID, None]) -> bool:
+    try:
+        UUID(str(val))
+        return True
+    except (ValueError, TypeError):
+        return False
+
+
+class WorkflowConfigResolutionResult(UniversalBaseModel):
+    workflow_config: Optional[WorkflowConfig] = None
+    pk: Optional[str] = None
+
+
+def _resolve_workflow_config(
     config: VellumCliConfig,
     module: Optional[str] = None,
     workflow_sandbox_id: Optional[str] = None,
-) -> Optional[WorkflowConfig]:
+    workflow_deployment: Optional[str] = None,
+) -> WorkflowConfigResolutionResult:
+    if workflow_sandbox_id and workflow_deployment:
+        raise ValueError("Cannot specify both workflow_sandbox_id and workflow_deployment")
+
     if module:
-        return next((w for w in config.workflows if w.module == module), None)
+        workflow_config = next((w for w in config.workflows if w.module == module), None)
+        return WorkflowConfigResolutionResult(
+            workflow_config=workflow_config,
+            pk=workflow_config.workflow_sandbox_id if workflow_config else None,
+        )
     elif workflow_sandbox_id:
         workflow_config = WorkflowConfig(
             workflow_sandbox_id=workflow_sandbox_id,
             module=f"workflow_{workflow_sandbox_id.split('-')[0]}",
         )
         config.workflows.append(workflow_config)
-        return workflow_config
+        return WorkflowConfigResolutionResult(
+            workflow_config=workflow_config,
+            pk=workflow_config.workflow_sandbox_id,
+        )
+    elif workflow_deployment:
+        module = (
+            f"workflow_{workflow_deployment.split('-')[0]}"
+            if _is_valid_uuid(workflow_deployment)
+            else snake_case(workflow_deployment)
+        )
+        workflow_config = WorkflowConfig(
+            module=module,
+        )
+        config.workflows.append(workflow_config)
+        return WorkflowConfigResolutionResult(
+            workflow_config=workflow_config,
+            pk=workflow_deployment,
+        )
     elif config.workflows:
-        return config.workflows[0]
+        return WorkflowConfigResolutionResult(
+            workflow_config=config.workflows[0],
+            pk=config.workflows[0].workflow_sandbox_id,
+        )
 
-    return None
+    return WorkflowConfigResolutionResult()
 
 
 def pull_command(
     module: Optional[str] = None,
     workflow_sandbox_id: Optional[str] = None,
+    workflow_deployment: Optional[str] = None,
     include_json: Optional[bool] = None,
     exclude_code: Optional[bool] = None,
 ) -> None:
@@ -41,17 +86,20 @@ def pull_command(
     logger = load_cli_logger()
     config = load_vellum_cli_config()
 
-    workflow_config = resolve_workflow_config(
-        config,
-        module,
-        workflow_sandbox_id,
+    workflow_config_result = _resolve_workflow_config(
+        config=config,
+        module=module,
+        workflow_sandbox_id=workflow_sandbox_id,
+        workflow_deployment=workflow_deployment,
     )
     save_lock_file = not module
 
+    workflow_config = workflow_config_result.workflow_config
     if not workflow_config:
         raise ValueError("No workflow config found in project to pull from.")
 
-    if not workflow_config.workflow_sandbox_id:
+    pk = workflow_config_result.pk
+    if not pk:
         raise ValueError("No workflow sandbox ID found in project to pull from.")
 
     logger.info(f"Pulling workflow into {workflow_config.module}")
@@ -63,7 +111,7 @@ def pull_command(
         query_parameters["exclude_code"] = exclude_code
 
     response = client.workflows.pull(
-        workflow_config.workflow_sandbox_id,
+        pk,
         request_options={"additional_query_parameters": query_parameters},
     )
 

vellum_cli/tests/test_pull.py

@@ -164,6 +164,86 @@ def test_pull__sandbox_id_with_other_workflow_configured(vellum_client, mock_mod
         assert f.read() == "print('hello')"
 
 
+def test_pull__workflow_deployment_with_no_config(vellum_client):
+    # GIVEN a workflow deployment
+    workflow_deployment = "my-deployment"
+
+    # AND the workflow pull API call returns a zip file
+    vellum_client.workflows.pull.return_value = iter([_zip_file_map({"workflow.py": "print('hello')"})])
+
+    # AND we are currently in a new directory
+    current_dir = os.getcwd()
+    temp_dir = tempfile.mkdtemp()
+    os.chdir(temp_dir)
+
+    # WHEN the user runs the pull command with the workflow deployment
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["workflows", "pull", "--workflow-deployment", workflow_deployment])
+    os.chdir(current_dir)
+
+    # THEN the command returns successfully
+    assert result.exit_code == 0
+
+    # AND the pull api is called with the workflow deployment
+    vellum_client.workflows.pull.assert_called_once()
+    workflow_py = os.path.join(temp_dir, "my_deployment", "workflow.py")
+    assert os.path.exists(workflow_py)
+    with open(workflow_py) as f:
+        assert f.read() == "print('hello')"
+
+    # AND the vellum.lock.json file is created
+    vellum_lock_json = os.path.join(temp_dir, "vellum.lock.json")
+    assert os.path.exists(vellum_lock_json)
+    with open(vellum_lock_json) as f:
+        lock_data = json.loads(f.read())
+        assert lock_data == {
+            "version": "1.0",
+            "workflows": [
+                {
+                    "module": "my_deployment",
+                    "workflow_sandbox_id": None,
+                    "ignore": None,
+                    "deployments": [],
+                }
+            ],
+        }
+
+
+def test_pull__both_workflow_sandbox_id_and_deployment(vellum_client):
+    # GIVEN a workflow sandbox id
+    workflow_sandbox_id = "87654321-0000-0000-0000-000000000000"
+
+    # AND a workflow deployment
+    workflow_deployment = "my-deployment"
+
+    # AND the workflow pull API call returns a zip file
+    vellum_client.workflows.pull.return_value = iter([_zip_file_map({"workflow.py": "print('hello')"})])
+
+    # AND we are currently in a new directory
+    current_dir = os.getcwd()
+    temp_dir = tempfile.mkdtemp()
+    os.chdir(temp_dir)
+
+    # WHEN the user runs the pull command with the workflow deployment
+    runner = CliRunner()
+    result = runner.invoke(
+        cli_main,
+        [
+            "workflows",
+            "pull",
+            "--workflow-sandbox-id",
+            workflow_sandbox_id,
+            "--workflow-deployment",
+            workflow_deployment,
+        ],
+    )
+    os.chdir(current_dir)
+
+    # THEN the command returns successfully
+    assert result.exit_code == 1
+    assert "Cannot specify both workflow_sandbox_id and workflow_deployment" == str(result.exception)
+
+
 def test_pull__remove_missing_files(vellum_client, mock_module):
     # GIVEN a module on the user's filesystem
     temp_dir = mock_module.temp_dir

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

@@ -154,12 +154,12 @@ class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_Sea
             lhs_query_input_id = (
                 self.input_variable_ids_by_logical_id[lhs_variable_id]
                 if self.input_variable_ids_by_logical_id
-                else uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}")
+                else str(uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}"))
             )
             rhs_query_input_id = (
                 self.input_variable_ids_by_logical_id[rhs_variable_id]
                 if self.input_variable_ids_by_logical_id
-                else uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}")
+                else str(uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}"))
             )
 
             return (

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

@@ -0,0 +1,308 @@
+from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_search_node.workflow import BasicSearchWorkflow
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow with a search node
+    # WHEN we serialize it
+
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay, workflow_class=BasicSearchWorkflow
+    )
+
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN we should get a serialized representation of the workflow
+    assert serialized_workflow.keys() == {"workflow_raw_data", "input_variables", "output_variables"}
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+    assert input_variables == [
+        {
+            "id": "6e405c6c-36eb-4c06-9d54-ae06cccce585",
+            "key": "query",
+            "type": "STRING",
+            "default": None,
+            "required": True,
+            "extensions": {"color": None},
+        }
+    ]
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 1
+    assert output_variables == [{"id": "27424f7d-9767-4059-bdcf-c2be8b798fd7", "key": "text", "type": "STRING"}]
+
+    # AND its raw data is what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    assert workflow_raw_data.keys() == {"nodes", "edges", "display_data", "definition"}
+    assert len(workflow_raw_data["nodes"]) == 3
+    assert len(workflow_raw_data["edges"]) == 2
+
+    # AND each node should be serialized correctly
+    entrypoint_node = workflow_raw_data["nodes"][0]
+    assert entrypoint_node == {
+        "id": "06671b25-5c6b-4675-8c74-6c396a608728",
+        "type": "ENTRYPOINT",
+        "inputs": [],
+        "data": {"label": "Entrypoint Node", "source_handle_id": "df80b4aa-2ba1-49a2-8375-fb1f78eee31f"},
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "definition": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"], "bases": []},
+    }
+
+    search_node = workflow_raw_data["nodes"][1]
+    assert search_node == {
+        "id": "ab3a1413-c7b5-4cb0-a2d4-f5ab7d1d65b4",
+        "type": "SEARCH",
+        "inputs": [
+            {
+                "id": "49d21956-6e62-472b-b62a-7ec65faea1fd",
+                "key": "query",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "INPUT_VARIABLE",
+                            "data": {"input_variable_id": "6e405c6c-36eb-4c06-9d54-ae06cccce585"},
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "8cb28a69-088d-410d-bd0d-886d57ce7b64",
+                "key": "document_index_id",
+                "value": {
+                    "rules": [{"type": "CONSTANT_VALUE", "data": {"type": "STRING", "value": "name"}}],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "983f2b7f-ad86-45cf-b04b-08724af27236",
+                "key": "weights",
+                "value": {
+                    "rules": [{"type": "CONSTANT_VALUE", "data": {"type": "JSON", "value": None}}],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "8072ec05-5fe4-47db-bc48-4c20ce49e123",
+                "key": "limit",
+                "value": {
+                    "rules": [{"type": "CONSTANT_VALUE", "data": {"type": "JSON", "value": None}}],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "051c5d2e-4667-4ae2-9202-1076b21adf7b",
+                "key": "separator",
+                "value": {
+                    "rules": [{"type": "CONSTANT_VALUE", "data": {"type": "STRING", "value": "\n\n#####\n\n"}}],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "8aac5dac-209e-48f3-97e1-0a39e4cd98d5",
+                "key": "result_merging_enabled",
+                "value": {
+                    "rules": [{"type": "CONSTANT_VALUE", "data": {"type": "STRING", "value": "False"}}],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "036dee8f-194a-4b92-9739-69c98a4aa1b9",
+                "key": "external_id_filters",
+                "value": {
+                    "rules": [{"type": "CONSTANT_VALUE", "data": {"type": "JSON", "value": None}}],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "855d3f57-e633-467e-a348-a394360247df",
+                "key": "metadata_filters",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "CONSTANT_VALUE",
+                            "data": {
+                                "type": "JSON",
+                                "value": {
+                                    "type": "LOGICAL_CONDITION_GROUP",
+                                    "combinator": "AND",
+                                    "conditions": [
+                                        {
+                                            "type": "LOGICAL_CONDITION",
+                                            "lhs_variable_id": "a6322ca2-8b65-4d26-b3a1-f926dcada0fa",
+                                            "operator": "=",
+                                            "rhs_variable_id": "c539a2e2-0873-43b0-ae21-81790bb1c4cb",
+                                        },
+                                        {
+                                            "type": "LOGICAL_CONDITION",
+                                            "lhs_variable_id": "a89483b6-6850-4105-8c4e-ec0fd197cd43",
+                                            "operator": "=",
+                                            "rhs_variable_id": "847b8ee0-2c37-4e41-9dea-b4ba3579e2c1",
+                                        },
+                                    ],
+                                    "negated": False,
+                                },
+                            },
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "a6322ca2-8b65-4d26-b3a1-f926dcada0fa",
+                "key": "vellum-query-builder-variable-a6322ca2-8b65-4d26-b3a1-f926dcada0fa",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "INPUT_VARIABLE",
+                            "data": {"input_variable_id": "8ffffeb2-79b3-4105-acc7-78b0267da955"},
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "c539a2e2-0873-43b0-ae21-81790bb1c4cb",
+                "key": "vellum-query-builder-variable-c539a2e2-0873-43b0-ae21-81790bb1c4cb",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "INPUT_VARIABLE",
+                            "data": {"input_variable_id": "8ffffeb2-79b3-4105-acc7-78b0267da955"},
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "a89483b6-6850-4105-8c4e-ec0fd197cd43",
+                "key": "vellum-query-builder-variable-a89483b6-6850-4105-8c4e-ec0fd197cd43",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "INPUT_VARIABLE",
+                            "data": {"input_variable_id": "f5eee974-b0c3-4775-bc8a-679a9e99d7ba"},
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "847b8ee0-2c37-4e41-9dea-b4ba3579e2c1",
+                "key": "vellum-query-builder-variable-847b8ee0-2c37-4e41-9dea-b4ba3579e2c1",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "INPUT_VARIABLE",
+                            "data": {"input_variable_id": "f5eee974-b0c3-4775-bc8a-679a9e99d7ba"},
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            },
+        ],
+        "data": {
+            "label": "Simple Search Node",
+            "results_output_id": "e27fa934-589a-48f7-92a9-dcc90710ec7b",
+            "text_output_id": "3f3bd066-ce73-46ee-84f1-d8ece69ecd8c",
+            "error_output_id": None,
+            "source_handle_id": "00ae06b3-f8d9-4ae6-9fbf-e4ff4d520e9b",
+            "target_handle_id": "6d50305f-588b-469f-a042-b0767d3f99b1",
+            "query_node_input_id": "49d21956-6e62-472b-b62a-7ec65faea1fd",
+            "document_index_node_input_id": "8cb28a69-088d-410d-bd0d-886d57ce7b64",
+            "weights_node_input_id": "983f2b7f-ad86-45cf-b04b-08724af27236",
+            "limit_node_input_id": "8072ec05-5fe4-47db-bc48-4c20ce49e123",
+            "separator_node_input_id": "051c5d2e-4667-4ae2-9202-1076b21adf7b",
+            "result_merging_enabled_node_input_id": "8aac5dac-209e-48f3-97e1-0a39e4cd98d5",
+            "external_id_filters_node_input_id": "036dee8f-194a-4b92-9739-69c98a4aa1b9",
+            "metadata_filters_node_input_id": "855d3f57-e633-467e-a348-a394360247df",
+        },
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "definition": {
+            "name": "SimpleSearchNode",
+            "module": ["tests", "workflows", "basic_search_node", "workflow"],
+            "bases": [
+                {"name": "SearchNode", "module": ["vellum", "workflows", "nodes", "displayable", "search_node", "node"]}
+            ],
+        },
+    }
+
+    final_output_node = workflow_raw_data["nodes"][2]
+    assert final_output_node == {
+        "id": "4e466510-6756-403f-a182-56e5a2b85d94",
+        "type": "TERMINAL",
+        "data": {
+            "label": "Final Output",
+            "name": "text",
+            "target_handle_id": "cd8c736f-1b77-493d-b857-d8feb5c03b15",
+            "output_id": "27424f7d-9767-4059-bdcf-c2be8b798fd7",
+            "output_type": "STRING",
+            "node_input_id": "008eaf1d-98c0-4098-8839-5b94121394d7",
+        },
+        "inputs": [
+            {
+                "id": "008eaf1d-98c0-4098-8839-5b94121394d7",
+                "key": "node_input",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "NODE_OUTPUT",
+                            "data": {
+                                "node_id": "ab3a1413-c7b5-4cb0-a2d4-f5ab7d1d65b4",
+                                "output_id": "3f3bd066-ce73-46ee-84f1-d8ece69ecd8c",
+                            },
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            }
+        ],
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "definition": {
+            "name": "FinalOutputNode",
+            "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
+            "bases": [{"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"], "bases": []}],
+        },
+    }
+
+    # AND each edge should be serialized correctly
+    serialized_edges = workflow_raw_data["edges"]
+    assert serialized_edges == [
+        {
+            "id": "06533904-4897-4a7a-aa8d-50419b3d33ae",
+            "source_node_id": "06671b25-5c6b-4675-8c74-6c396a608728",
+            "source_handle_id": "df80b4aa-2ba1-49a2-8375-fb1f78eee31f",
+            "target_node_id": "ab3a1413-c7b5-4cb0-a2d4-f5ab7d1d65b4",
+            "target_handle_id": "6d50305f-588b-469f-a042-b0767d3f99b1",
+            "type": "DEFAULT",
+        },
+        {
+            "id": "cb918deb-f546-47b5-8b6b-db0d22a29fd1",
+            "source_node_id": "ab3a1413-c7b5-4cb0-a2d4-f5ab7d1d65b4",
+            "source_handle_id": "00ae06b3-f8d9-4ae6-9fbf-e4ff4d520e9b",
+            "target_node_id": "4e466510-6756-403f-a182-56e5a2b85d94",
+            "target_handle_id": "cd8c736f-1b77-493d-b857-d8feb5c03b15",
+            "type": "DEFAULT",
+        },
+    ]
+
+    # AND the display data is what we expect
+    display_data = workflow_raw_data["display_data"]
+    assert display_data == {"viewport": {"x": 0.0, "y": 0.0, "zoom": 1.0}}
+
+    # AND the definition is what we expect
+    definition = workflow_raw_data["definition"]
+    assert definition == {
+        "name": "BasicSearchWorkflow",
+        "module": [
+            "tests",
+            "workflows",
+            "basic_search_node",
+            "workflow",
+        ],
+    }