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

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

@@ -0,0 +1,87 @@
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_tool_calling_node_with_composio_tool.workflow import (
+    BasicToolCallingNodeWithComposioToolWorkflow,
+)
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a tool calling node with a composio tool
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=BasicToolCallingNodeWithComposioToolWorkflow)
+
+    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",
+        "state_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 2
+
+    # Find the text and chat_history outputs
+    text_output = next(var for var in output_variables if var["key"] == "text")
+    chat_history_output = next(var for var in output_variables if var["key"] == "chat_history")
+
+    assert text_output["type"] == "STRING"
+    assert chat_history_output["type"] == "CHAT_HISTORY"
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    tool_calling_node = workflow_raw_data["nodes"][1]
+
+    # AND the tool calling node should have the composio tool properly serialized
+    functions_attribute = next(attr for attr in tool_calling_node["attributes"] if attr["name"] == "functions")
+    assert functions_attribute["value"]["type"] == "CONSTANT_VALUE"
+    assert functions_attribute["value"]["value"]["type"] == "JSON"
+
+    functions_list = functions_attribute["value"]["value"]["value"]
+    assert len(functions_list) == 1
+
+    composio_function = functions_list[0]
+    assert composio_function == {
+        "type": "COMPOSIO",
+        "toolkit": "GITHUB",
+        "action": "GITHUB_CREATE_AN_ISSUE",
+        "description": "Create a new issue in a GitHub repository",
+        "user_id": None,
+        "name": "github_create_an_issue",
+    }
+
+    # AND the rest of the node structure should be correct
+    assert tool_calling_node["type"] == "GENERIC"
+    assert tool_calling_node["base"]["name"] == "ToolCallingNode"
+    assert tool_calling_node["definition"]["name"] == "ComposioToolCallingNode"
+
+    # AND the blocks should be properly serialized
+    blocks_attribute = next(attr for attr in tool_calling_node["attributes"] if attr["name"] == "blocks")
+    assert blocks_attribute["value"]["type"] == "CONSTANT_VALUE"
+    blocks_list = blocks_attribute["value"]["value"]["value"]
+    assert len(blocks_list) == 2
+    assert blocks_list[0]["chat_role"] == "SYSTEM"
+    assert blocks_list[1]["chat_role"] == "USER"
+
+    # AND the prompt inputs should be properly serialized
+    prompt_inputs_attribute = next(attr for attr in tool_calling_node["attributes"] if attr["name"] == "prompt_inputs")
+    assert prompt_inputs_attribute["value"]["type"] == "DICTIONARY_REFERENCE"
+    entries = prompt_inputs_attribute["value"]["entries"]
+    assert len(entries) == 1
+    assert entries[0]["key"] == "question"
+    assert entries[0]["value"]["type"] == "WORKFLOW_INPUT"
+
+    # AND the outputs should be correct
+    outputs = tool_calling_node["outputs"]
+    assert len(outputs) == 2
+    assert outputs[0]["name"] == "text"
+    assert outputs[0]["type"] == "STRING"
+    assert outputs[1]["name"] == "chat_history"
+    assert outputs[1]["type"] == "CHAT_HISTORY"

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

@@ -0,0 +1,313 @@
+from deepdiff import DeepDiff
+
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_tool_calling_node_inline_workflow.workflow import BasicToolCallingNodeInlineWorkflowWorkflow
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a generic node
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=BasicToolCallingNodeInlineWorkflowWorkflow)
+
+    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",
+        "state_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 2
+    assert not DeepDiff(
+        [
+            {"id": "dbedc4ee-be3b-4135-8c26-3643c0b6a530", "key": "text", "type": "STRING"},
+            {"id": "c5733df5-03bb-498e-a770-8ef9bff85df3", "key": "chat_history", "type": "CHAT_HISTORY"},
+        ],
+        output_variables,
+        ignore_order=True,
+    )
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    tool_calling_node = workflow_raw_data["nodes"][1]
+    function_attributes = next(
+        attribute for attribute in tool_calling_node["attributes"] if attribute["name"] == "functions"
+    )
+    assert function_attributes == {
+        "id": "102d8447-5232-4e96-8192-9b1ca0f02650",
+        "name": "functions",
+        "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": [
+                    {
+                        "type": "INLINE_WORKFLOW",
+                        "name": "BasicInlineSubworkflowWorkflow",
+                        "description": "\n    A workflow that gets the weather for a given city and date.\n    ",  # noqa: E501
+                        "exec_config": {
+                            "workflow_raw_data": {
+                                "nodes": [
+                                    {
+                                        "id": "6358dcfe-b162-4e19-99ca-401d1ada9bdc",
+                                        "type": "ENTRYPOINT",
+                                        "inputs": [],
+                                        "data": {
+                                            "label": "Entrypoint Node",
+                                            "source_handle_id": "c344fdee-282b-40c9-8c97-6dd08830948c",
+                                        },
+                                        "display_data": {"position": {"x": 0.0, "y": -50.0}},
+                                        "base": None,
+                                        "definition": None,
+                                    },
+                                    {
+                                        "id": "07a83d1a-7948-4a23-9f46-9a60382d3a48",
+                                        "label": "Start Node",
+                                        "type": "GENERIC",
+                                        "should_file_merge": True,
+                                        "display_data": {"position": {"x": 200.0, "y": -50.0}},
+                                        "base": {
+                                            "name": "BaseNode",
+                                            "module": ["vellum", "workflows", "nodes", "bases", "base"],
+                                        },
+                                        "definition": {
+                                            "name": "StartNode",
+                                            "module": [
+                                                "tests",
+                                                "workflows",
+                                                "basic_tool_calling_node_inline_workflow",
+                                                "workflow",
+                                            ],
+                                        },
+                                        "trigger": {
+                                            "id": "8a7854a7-a595-44ce-8197-1f9cd2c78f10",
+                                            "merge_behavior": "AWAIT_ATTRIBUTES",
+                                        },
+                                        "ports": [
+                                            {
+                                                "id": "ee444f1a-b126-4480-8eb2-d22506640763",
+                                                "name": "default",
+                                                "type": "DEFAULT",
+                                            }
+                                        ],
+                                        "adornments": None,
+                                        "attributes": [
+                                            {
+                                                "id": "b5e2d415-4368-43c1-826c-ff6511bf6942",
+                                                "name": "city",
+                                                "value": {
+                                                    "type": "WORKFLOW_INPUT",
+                                                    "input_variable_id": "fa73da37-34c3-47a9-be58-69cc6cdbfca5",
+                                                },
+                                            },
+                                            {
+                                                "id": "5b3ed6d0-8cd6-41b6-ad55-d380b41f943b",
+                                                "name": "date",
+                                                "value": {
+                                                    "type": "WORKFLOW_INPUT",
+                                                    "input_variable_id": "aba1e6e0-dfa7-4c15-a4e6-aec6feebfaca",
+                                                },
+                                            },
+                                        ],
+                                        "outputs": [
+                                            {
+                                                "id": "272eccdb-6903-4f32-8159-8bfb87c65c2e",
+                                                "name": "temperature",
+                                                "type": "NUMBER",
+                                                "value": None,
+                                            },
+                                            {
+                                                "id": "8616509d-fecb-4bbf-afdc-bd4c5de35ce7",
+                                                "name": "reasoning",
+                                                "type": "STRING",
+                                                "value": None,
+                                            },
+                                        ],
+                                    },
+                                    {
+                                        "id": "0779b232-82ab-4dbe-a340-6a85e6ab3368",
+                                        "type": "TERMINAL",
+                                        "data": {
+                                            "label": "Final Output",
+                                            "name": "temperature",
+                                            "target_handle_id": "9e077063-c394-4c7b-b0c6-e6686df67984",
+                                            "output_id": "99afb757-2782-465d-ab55-80ccf50552b9",
+                                            "output_type": "NUMBER",
+                                            "node_input_id": "7761c5e1-cc2e-43ab-bfd2-f66c3d47b3b9",
+                                        },
+                                        "inputs": [
+                                            {
+                                                "id": "7761c5e1-cc2e-43ab-bfd2-f66c3d47b3b9",
+                                                "key": "node_input",
+                                                "value": {
+                                                    "rules": [
+                                                        {
+                                                            "type": "NODE_OUTPUT",
+                                                            "data": {
+                                                                "node_id": "07a83d1a-7948-4a23-9f46-9a60382d3a48",  # noqa: E501
+                                                                "output_id": "272eccdb-6903-4f32-8159-8bfb87c65c2e",  # noqa: E501
+                                                            },
+                                                        }
+                                                    ],
+                                                    "combinator": "OR",
+                                                },
+                                            }
+                                        ],
+                                        "display_data": {"position": {"x": 400.0, "y": -175.0}},
+                                        "base": {
+                                            "name": "FinalOutputNode",
+                                            "module": [
+                                                "vellum",
+                                                "workflows",
+                                                "nodes",
+                                                "displayable",
+                                                "final_output_node",
+                                                "node",
+                                            ],
+                                        },
+                                        "definition": None,
+                                    },
+                                    {
+                                        "id": "31b74695-3f1c-47cf-8be8-a4d86cc589e8",
+                                        "type": "TERMINAL",
+                                        "data": {
+                                            "label": "Final Output",
+                                            "name": "reasoning",
+                                            "target_handle_id": "8b525943-6c27-414b-a329-e29c0b217f72",
+                                            "output_id": "7444a019-081a-4e10-a528-3249299159f7",
+                                            "output_type": "STRING",
+                                            "node_input_id": "c1833b54-95b6-4365-8e57-51b09c8e2606",
+                                        },
+                                        "inputs": [
+                                            {
+                                                "id": "c1833b54-95b6-4365-8e57-51b09c8e2606",
+                                                "key": "node_input",
+                                                "value": {
+                                                    "rules": [
+                                                        {
+                                                            "type": "NODE_OUTPUT",
+                                                            "data": {
+                                                                "node_id": "07a83d1a-7948-4a23-9f46-9a60382d3a48",  # noqa: E501
+                                                                "output_id": "8616509d-fecb-4bbf-afdc-bd4c5de35ce7",  # noqa: E501
+                                                            },
+                                                        }
+                                                    ],
+                                                    "combinator": "OR",
+                                                },
+                                            }
+                                        ],
+                                        "display_data": {"position": {"x": 400.0, "y": 75.0}},
+                                        "base": {
+                                            "name": "FinalOutputNode",
+                                            "module": [
+                                                "vellum",
+                                                "workflows",
+                                                "nodes",
+                                                "displayable",
+                                                "final_output_node",
+                                                "node",
+                                            ],
+                                        },
+                                        "definition": None,
+                                    },
+                                ],
+                                "edges": [
+                                    {
+                                        "id": "1c333b1c-a1b7-437e-9dfc-bdca8db2cff5",
+                                        "source_node_id": "6358dcfe-b162-4e19-99ca-401d1ada9bdc",
+                                        "source_handle_id": "c344fdee-282b-40c9-8c97-6dd08830948c",
+                                        "target_node_id": "07a83d1a-7948-4a23-9f46-9a60382d3a48",
+                                        "target_handle_id": "8a7854a7-a595-44ce-8197-1f9cd2c78f10",
+                                        "type": "DEFAULT",
+                                    },
+                                    {
+                                        "id": "3c5d8990-48f5-42e1-893e-bc8308d2110a",
+                                        "source_node_id": "07a83d1a-7948-4a23-9f46-9a60382d3a48",
+                                        "source_handle_id": "ee444f1a-b126-4480-8eb2-d22506640763",
+                                        "target_node_id": "0779b232-82ab-4dbe-a340-6a85e6ab3368",
+                                        "target_handle_id": "9e077063-c394-4c7b-b0c6-e6686df67984",
+                                        "type": "DEFAULT",
+                                    },
+                                    {
+                                        "id": "de0b8090-a26e-4e09-9173-9f7400a5be4c",
+                                        "source_node_id": "07a83d1a-7948-4a23-9f46-9a60382d3a48",
+                                        "source_handle_id": "ee444f1a-b126-4480-8eb2-d22506640763",
+                                        "target_node_id": "31b74695-3f1c-47cf-8be8-a4d86cc589e8",
+                                        "target_handle_id": "8b525943-6c27-414b-a329-e29c0b217f72",
+                                        "type": "DEFAULT",
+                                    },
+                                ],
+                                "display_data": {"viewport": {"x": 0.0, "y": 0.0, "zoom": 1.0}},
+                                "definition": {
+                                    "name": "BasicInlineSubworkflowWorkflow",
+                                    "module": [
+                                        "tests",
+                                        "workflows",
+                                        "basic_tool_calling_node_inline_workflow",
+                                        "workflow",
+                                    ],
+                                },
+                                "output_values": [
+                                    {
+                                        "output_variable_id": "99afb757-2782-465d-ab55-80ccf50552b9",
+                                        "value": {
+                                            "type": "NODE_OUTPUT",
+                                            "node_id": "07a83d1a-7948-4a23-9f46-9a60382d3a48",
+                                            "node_output_id": "272eccdb-6903-4f32-8159-8bfb87c65c2e",
+                                        },
+                                    },
+                                    {
+                                        "output_variable_id": "7444a019-081a-4e10-a528-3249299159f7",
+                                        "value": {
+                                            "type": "NODE_OUTPUT",
+                                            "node_id": "07a83d1a-7948-4a23-9f46-9a60382d3a48",
+                                            "node_output_id": "8616509d-fecb-4bbf-afdc-bd4c5de35ce7",
+                                        },
+                                    },
+                                ],
+                            },
+                            "input_variables": [
+                                {
+                                    "id": "fa73da37-34c3-47a9-be58-69cc6cdbfca5",
+                                    "key": "city",
+                                    "type": "STRING",
+                                    "default": None,
+                                    "required": True,
+                                    "extensions": {"color": None},
+                                },
+                                {
+                                    "id": "aba1e6e0-dfa7-4c15-a4e6-aec6feebfaca",
+                                    "key": "date",
+                                    "type": "STRING",
+                                    "default": None,
+                                    "required": True,
+                                    "extensions": {"color": None},
+                                },
+                            ],
+                            "state_variables": [],
+                            "output_variables": [
+                                {
+                                    "id": "99afb757-2782-465d-ab55-80ccf50552b9",
+                                    "key": "temperature",
+                                    "type": "NUMBER",
+                                },
+                                {
+                                    "id": "7444a019-081a-4e10-a528-3249299159f7",
+                                    "key": "reasoning",
+                                    "type": "STRING",
+                                },
+                            ],
+                        },
+                    }
+                ],
+            },
+        },
+    }

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

@@ -0,0 +1,65 @@
+from deepdiff import DeepDiff
+
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_tool_calling_node_mcp_tool.workflow import BasicToolCallingNodeMCPWorkflow
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a generic node
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=BasicToolCallingNodeMCPWorkflow)
+
+    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",
+        "state_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 2
+    assert not DeepDiff(
+        [
+            {"id": "3934525a-4807-4dd3-a44f-8569033fece1", "key": "text", "type": "STRING"},
+            {"id": "a6ba35f0-306b-45a4-ad79-c1e9b9a5515c", "key": "chat_history", "type": "CHAT_HISTORY"},
+        ],
+        output_variables,
+        ignore_order=True,
+    )
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    tool_calling_node = workflow_raw_data["nodes"][1]
+    function_attributes = next(
+        (attribute for attribute in tool_calling_node["attributes"] if attribute["name"] == "functions"),
+    )
+    assert function_attributes == {
+        "id": "80ed138a-1127-4c77-ba27-a66a37c92717",
+        "name": "functions",
+        "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": [
+                    {
+                        "type": "MCP_SERVER",
+                        "name": "github",
+                        "description": "",
+                        "url": "https://api.githubcopilot.com/mcp/",
+                        "authorization_type": "BEARER_TOKEN",
+                        "bearer_token_value": "GITHUB_PERSONAL_ACCESS_TOKEN",
+                        "api_key_header_key": None,
+                        "api_key_header_value": None,
+                    }
+                ],
+            },
+        },
+    }

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

@@ -0,0 +1,89 @@
+from deepdiff import DeepDiff
+
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_tool_calling_node_parent_input.workflow import BasicToolCallingNodeParentInputWorkflow
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a generic node
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=BasicToolCallingNodeParentInputWorkflow)
+
+    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",
+        "state_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 2
+    assert not DeepDiff(
+        [
+            {"id": "e2e36cfc-cf24-42fd-ba8f-cce39c53d47b", "key": "text", "type": "STRING"},
+            {"id": "08ca9519-e421-47e8-a42d-44f49f6aab16", "key": "chat_history", "type": "CHAT_HISTORY"},
+        ],
+        output_variables,
+        ignore_order=True,
+    )
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    tool_calling_node = workflow_raw_data["nodes"][2]
+
+    attributes = tool_calling_node["attributes"]
+    function_attributes = next(attribute for attribute in attributes if attribute["name"] == "functions")
+    assert function_attributes == {
+        "id": "e2695720-919b-497e-8d01-ae6aa705f7bb",
+        "name": "functions",
+        "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": [
+                    {
+                        "type": "CODE_EXECUTION",
+                        "name": "get_string",
+                        "description": "\n    Get a string with the parent input, dummy input, and the populated input.\n    ",  # noqa: E501
+                        "definition": {
+                            "state": None,
+                            "cache_config": None,
+                            "name": "get_string",
+                            "description": "\n    Get a string with the parent input, dummy input, and the populated input.\n    ",  # noqa: E501
+                            "parameters": {
+                                "type": "object",
+                                "properties": {"populated_input": {"type": "string"}},
+                                "required": ["populated_input"],
+                            },
+                            "inputs": {
+                                "parent_input": {
+                                    "type": "WORKFLOW_INPUT",
+                                    "input_variable_id": "4bf1f0e7-76c6-4204-9f8c-bd9c3b73a8db",
+                                },
+                                "dummy_input": {
+                                    "type": "NODE_OUTPUT",
+                                    "node_id": "72f78142-e0a2-40a9-ae70-0230ccf3b503",
+                                    "node_output_id": "6e639661-d0dc-4586-9393-e64e95e0d3ef",
+                                },
+                                "constant_input": {
+                                    "type": "CONSTANT_VALUE",
+                                    "value": {"type": "STRING", "value": "constant_input"},
+                                },
+                            },
+                            "forced": None,
+                            "strict": None,
+                        },
+                        "src": 'from vellum.workflows.utils.functions import use_tool_inputs\n\nfrom .inputs import ParentInputs\nfrom .nodes.dummy_node import DummyNode\n\n\n@use_tool_inputs(\n    parent_input=ParentInputs.parent_input,\n    dummy_input=DummyNode.Outputs.text,\n    constant_input="constant_input",\n)\ndef get_string(parent_input: str, dummy_input: str, constant_input: str, populated_input: str) -> str:\n    """\n    Get a string with the parent input, dummy input, and the populated input.\n    """\n    return f"parent input: {parent_input}, dummy input: {dummy_input}, constant input: {constant_input}, populated input: {populated_input}"  # noqa: E501\n',  # noqa: E501
+                    }
+                ],
+            },
+        },
+    }