vellum-ai 0.14.63__py3-none-any.whl → 1.13.5__py3-none-any.whl

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

@@ -28,6 +28,7 @@ def test_serialize_workflow():
             "required": True,
             "default": None,
             "extensions": {"color": None},
+            "schema": {"type": "string"},
         }
     ]
 
@@ -54,26 +55,26 @@ def test_serialize_workflow():
         "type": "ENTRYPOINT",
         "inputs": [],
         "data": {"label": "Entrypoint Node", "source_handle_id": "8b8d52a2-844f-44fe-a6c4-142fa70d391b"},
-        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "display_data": {"position": {"x": 0.0, "y": -50.0}},
         "base": None,
         "definition": None,
     }
 
     final_output_node = workflow_raw_data["nodes"][1]
     assert final_output_node == {
-        "id": "620ec17b-e330-4212-b619-3c39dc63fb22",
+        "id": "3944559b-fb23-45fe-90db-4a4c7f88bd63",
         "type": "TERMINAL",
         "data": {
             "label": "Basic Final Output Node",
             "name": "value",
-            "target_handle_id": "0173d3c6-11d1-44b7-b070-ca9ff5119046",
-            "output_id": "aa63e3f6-fde3-4d19-84ef-29982d44d709",
+            "target_handle_id": "24099320-8607-431b-acf2-de593cce3b43",
+            "output_id": "f331936d-2cce-4dd7-ab02-b650bc5260df",
             "output_type": "STRING",
-            "node_input_id": "5322567a-f40c-400a-96b3-c3b054db543e",
+            "node_input_id": "ea92ef63-e7f0-4ee6-87da-206a96ca202c",
         },
         "inputs": [
             {
-                "id": "5322567a-f40c-400a-96b3-c3b054db543e",
+                "id": "ea92ef63-e7f0-4ee6-87da-206a96ca202c",
                 "key": "node_input",
                 "value": {
                     "rules": [
@@ -86,7 +87,7 @@ def test_serialize_workflow():
                 },
             }
         ],
-        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "display_data": {"position": {"x": 200.0, "y": -50.0}},
         "base": {
             "name": "FinalOutputNode",
             "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -97,10 +98,16 @@ def test_serialize_workflow():
         },
         "outputs": [
             {
-                "id": "aa63e3f6-fde3-4d19-84ef-29982d44d709",
+                "id": "f331936d-2cce-4dd7-ab02-b650bc5260df",
                 "name": "value",
                 "type": "STRING",
                 "value": {"type": "WORKFLOW_INPUT", "input_variable_id": "e39a7b63-de15-490a-ae9b-8112c767aea0"},
+                "schema": {"type": "string"},
             }
         ],
+        "trigger": {
+            "id": "24099320-8607-431b-acf2-de593cce3b43",
+            "merge_behavior": "AWAIT_ANY",
+        },
+        "ports": [],
     }

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

@@ -0,0 +1,89 @@
+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 (json is not exposed as workflow output)
+    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) == 3
+    json_output = next(o for o in outputs if o["name"] == "json")
+    text_output = next(o for o in outputs if o["name"] == "text")
+    chat_history_output = next(o for o in outputs if o["name"] == "chat_history")
+    assert json_output["type"] == "JSON"
+    assert text_output["type"] == "STRING"
+    assert chat_history_output["type"] == "CHAT_HISTORY"

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

@@ -0,0 +1,184 @@
+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"
+    assert function_attributes["name"] == "functions"
+    assert function_attributes["value"]["type"] == "CONSTANT_VALUE"
+    assert function_attributes["value"]["value"]["type"] == "JSON"
+    inline_workflow_tool = function_attributes["value"]["value"]["value"][0]
+    assert inline_workflow_tool["type"] == "INLINE_WORKFLOW"
+    assert inline_workflow_tool["name"] == "BasicInlineSubworkflowWorkflow"
+    assert (
+        inline_workflow_tool["description"] == "\n    A workflow that gets the weather for a given city and date.\n    "
+    )
+    assert inline_workflow_tool["exec_config"]["input_variables"] == [
+        {
+            "id": "fa73da37-34c3-47a9-be58-69cc6cdbfca5",
+            "key": "city",
+            "type": "STRING",
+            "default": None,
+            "required": True,
+            "extensions": {"color": None},
+            "schema": {"type": "string"},
+        },
+        {
+            "id": "aba1e6e0-dfa7-4c15-a4e6-aec6feebfaca",
+            "key": "date",
+            "type": "STRING",
+            "default": None,
+            "required": True,
+            "extensions": {"color": None},
+            "schema": {"type": "string"},
+        },
+    ]
+    assert inline_workflow_tool["exec_config"]["output_variables"] == [
+        {
+            "id": "99afb757-2782-465d-ab55-80ccf50552b9",
+            "key": "temperature",
+            "type": "NUMBER",
+        },
+        {
+            "id": "7444a019-081a-4e10-a528-3249299159f7",
+            "key": "reasoning",
+            "type": "STRING",
+        },
+    ]
+    assert inline_workflow_tool["exec_config"]["state_variables"] == []
+    inline_workflow_data = inline_workflow_tool["exec_config"]["workflow_raw_data"]
+    assert inline_workflow_data["display_data"] == {"viewport": {"x": 0.0, "y": 0.0, "zoom": 1.0}}
+    assert inline_workflow_data["definition"] == {
+        "name": "BasicInlineSubworkflowWorkflow",
+        "module": [
+            "tests",
+            "workflows",
+            "basic_tool_calling_node_inline_workflow",
+            "workflow",
+        ],
+    }
+    assert inline_workflow_data["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",
+            },
+        },
+    ]
+    inner_start_node = next(
+        node for node in inline_workflow_data["nodes"] if node["type"] == "GENERIC" and node["label"] == "Start Node"
+    )
+    assert inner_start_node == {
+        "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,
+                "schema": {"type": "number"},
+            },
+            {
+                "id": "8616509d-fecb-4bbf-afdc-bd4c5de35ce7",
+                "name": "reasoning",
+                "type": "STRING",
+                "value": None,
+                "schema": {"type": "string"},
+            },
+        ],
+    }

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

@@ -0,0 +1,84 @@
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_tool_calling_node_inline_workflow_tool_wrapper.workflow import (
+    BasicToolCallingNodeInlineWorkflowToolWrapperWorkflow,
+)
+
+
+def test_serialize_workflow__inline_workflow_with_tool_wrapper():
+    """
+    Tests that an inline workflow with tool wrapper serializes correctly with definition containing inputs and examples.
+    """
+
+    # GIVEN a workflow that uses an inline workflow with tool wrapper
+    workflow_class = BasicToolCallingNodeInlineWorkflowToolWrapperWorkflow
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=workflow_class)
+    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 include both query and context
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 2
+    input_keys = {var["key"] for var in input_variables}
+    assert input_keys == {"query", "context"}
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 2
+    output_keys = {var["key"] for var in output_variables}
+    assert output_keys == {"text", "chat_history"}
+
+    # AND the inline workflow tool should have the definition attribute serialized
+    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["value"]["type"] == "CONSTANT_VALUE"
+    assert function_attributes["value"]["value"]["type"] == "JSON"
+    inline_workflow_tool = function_attributes["value"]["value"]["value"][0]
+
+    # AND the inline workflow tool should have the correct type
+    assert inline_workflow_tool["type"] == "INLINE_WORKFLOW"
+    assert inline_workflow_tool["name"] == "BasicInlineSubworkflowWorkflow"
+
+    # AND the inline workflow tool should have a definition attribute (like code tool)
+    assert "definition" in inline_workflow_tool
+    definition = inline_workflow_tool["definition"]
+
+    # AND the definition should match the expected structure with inputs and examples
+    context_var = next(var for var in input_variables if var["key"] == "context")
+    context_input_variable_id = context_var["id"]
+
+    assert definition == {
+        "state": None,
+        "cache_config": None,
+        "name": "basic_inline_subworkflow_workflow",
+        "description": "\n    A workflow that gets the weather for a given city and date with context.\n    ",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "city": {"type": "string"},
+                "date": {"type": "string"},
+            },
+            "required": ["city", "date"],
+            "examples": [{"city": "San Francisco", "date": "2025-01-01"}],
+        },
+        "inputs": {
+            "context": {
+                "type": "WORKFLOW_INPUT",
+                "input_variable_id": context_input_variable_id,
+            }
+        },
+        "forced": None,
+        "strict": None,
+    }

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

@@ -0,0 +1,104 @@
+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": "ARRAY_REFERENCE",
+            "items": [
+                {
+                    "type": "DICTIONARY_REFERENCE",
+                    "entries": [
+                        {
+                            "id": "85eb3714-5810-4935-9abe-a6112d4c406c",
+                            "key": "type",
+                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "MCP_SERVER"}},
+                        },
+                        {
+                            "id": "c9cc0249-c8bd-4b67-9347-c0a210646bcc",
+                            "key": "name",
+                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "github"}},
+                        },
+                        {
+                            "id": "b8f99ea6-ae33-4e62-b958-351e7e975bdc",
+                            "key": "description",
+                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": ""}},
+                        },
+                        {
+                            "id": "07d62347-5a1b-4b91-90f7-1e313238f2b2",
+                            "key": "url",
+                            "value": {
+                                "type": "CONSTANT_VALUE",
+                                "value": {"type": "STRING", "value": "https://api.githubcopilot.com/mcp/"},
+                            },
+                        },
+                        {
+                            "id": "b9ef2156-dd84-4a84-91ce-ce590fe2087b",
+                            "key": "authorization_type",
+                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "BEARER_TOKEN"}},
+                        },
+                        {
+                            "id": "df799ea3-77bb-40a1-82a1-a5fe343ba68b",
+                            "key": "bearer_token_value",
+                            "value": {
+                                "type": "ENVIRONMENT_VARIABLE",
+                                "environment_variable": "GITHUB_PERSONAL_ACCESS_TOKEN",
+                            },
+                        },
+                        {
+                            "id": "6e940707-ffe9-4cfb-813e-ddc3a9204ba4",
+                            "key": "api_key_header_key",
+                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                        },
+                        {
+                            "id": "2e3db081-7596-4057-b977-be69971d7f87",
+                            "key": "api_key_header_value",
+                            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                        },
+                    ],
+                    "definition": {"name": "MCPServer", "module": ["vellum", "workflows", "types", "definition"]},
+                }
+            ],
+        },
+    }

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
+                    }
+                ],
+            },
+        },
+    }