vellum-ai 1.1.5__py3-none-any.whl → 1.2.1__py3-none-any.whl

vellum_ee/workflows/display/nodes/vellum/tests/test_tool_calling_node.py

@@ -1,12 +1,31 @@
+from datetime import datetime
+
 from vellum.client.types.prompt_parameters import PromptParameters
+from vellum.client.types.release_review_reviewer import ReleaseReviewReviewer
+from vellum.client.types.workflow_deployment_release import (
+    ReleaseEnvironment,
+    ReleaseReleaseTag,
+    SlimReleaseReview,
+    WorkflowDeploymentRelease,
+    WorkflowDeploymentReleaseWorkflowDeployment,
+    WorkflowDeploymentReleaseWorkflowVersion,
+)
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.displayable.code_execution_node.node import CodeExecutionNode
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
 from vellum.workflows.nodes.displayable.tool_calling_node.node import ToolCallingNode
 from vellum.workflows.nodes.displayable.tool_calling_node.state import ToolCallingState
 from vellum.workflows.nodes.displayable.tool_calling_node.utils import create_router_node, create_tool_prompt_node
+from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState
-from vellum.workflows.types.definition import AuthorizationType, EnvironmentVariableReference, MCPServer
+from vellum.workflows.types.definition import (
+    AuthorizationType,
+    DeploymentDefinition,
+    EnvironmentVariableReference,
+    MCPServer,
+)
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
@@ -184,6 +203,58 @@ def test_serialize_node__tool_calling_node__mcp_server_api_key():
     }
 
 
+def test_serialize_node__tool_calling_node__mcp_server_no_authorization():
+    # GIVEN a tool calling node with an mcp server
+    class MyToolCallingNode(ToolCallingNode):
+        functions = [
+            MCPServer(
+                name="my-mcp-server",
+                url="https://my-mcp-server.com",
+            )
+        ]
+
+    # AND a workflow with the tool calling node
+    class Workflow(BaseWorkflow):
+        graph = MyToolCallingNode
+
+    # 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 mcp server
+    my_tool_calling_node = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(MyToolCallingNode.__id__)
+    )
+
+    functions_attribute = next(
+        attribute for attribute in my_tool_calling_node["attributes"] if attribute["name"] == "functions"
+    )
+
+    assert functions_attribute == {
+        "id": "c8957551-cb3d-49af-8053-acd256c1d852",
+        "name": "functions",
+        "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": [
+                    {
+                        "type": "MCP_SERVER",
+                        "name": "my-mcp-server",
+                        "url": "https://my-mcp-server.com",
+                        "authorization_type": None,
+                        "bearer_token_value": None,
+                        "api_key_header_key": None,
+                        "api_key_header_value": None,
+                    }
+                ],
+            },
+        },
+    }
+
+
 def test_serialize_tool_router_node():
     """
     Test that the tool router node created by create_router_node serializes successfully.
@@ -243,7 +314,7 @@ def test_serialize_tool_router_node():
         },
         "display_data": {"position": {"x": 0.0, "y": 0.0}},
         "id": "690c66e1-1e18-4984-b695-84beb0157541",
-        "label": "RouterNode",
+        "label": "Router Node",
         "outputs": [],
         "ports": [
             {
@@ -332,3 +403,244 @@ def test_serialize_tool_router_node():
         "trigger": {"id": "73a96f44-c2dd-40cc-96f6-49b9f914b166", "merge_behavior": "AWAIT_ATTRIBUTES"},
         "type": "GENERIC",
     }
+
+
+def test_serialize_node__tool_calling_node__subworkflow_with_parent_input_reference():
+    """
+    Test that a tool calling node with a subworkflow that references parent inputs serializes correctly
+    """
+
+    # GIVEN a workflow inputs class
+    class MyInputs(BaseInputs):
+        text: str
+        greeting: str
+
+    # AND a code execution node that references parent inputs
+    class CodeExecution(CodeExecutionNode[BaseState, str]):
+        code = ""
+        code_inputs = {
+            "text": MyInputs.text,
+        }
+        runtime = "PYTHON_3_11_6"
+        packages = []
+
+    # AND a subworkflow that uses the code execution node
+    class FunctionSubworkflow(BaseWorkflow):
+        graph = CodeExecution
+
+        class Outputs(BaseWorkflow.Outputs):
+            output = CodeExecution.Outputs.result
+
+    # AND a tool calling node that uses the subworkflow
+    class MyToolCallingNode(ToolCallingNode):
+        ml_model = "gpt-4.1"
+        prompt_inputs = {
+            "text": MyInputs.text,
+        }
+        blocks = []
+        parameters = PromptParameters()
+        functions = [FunctionSubworkflow]
+
+    # AND a workflow with the tool calling node
+    class Workflow(BaseWorkflow[MyInputs, BaseState]):
+        graph = MyToolCallingNode
+
+    # 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 functions with parent input references
+    my_tool_calling_node = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(MyToolCallingNode.__id__)
+    )
+
+    functions_attribute = next(
+        attribute for attribute in my_tool_calling_node["attributes"] if attribute["name"] == "functions"
+    )
+
+    data = functions_attribute["value"]["value"]["value"][0]
+    nodes = data["exec_config"]["workflow_raw_data"]["nodes"]
+    code_exec_node = next((node for node in nodes if node["type"] == "CODE_EXECUTION"), None)
+
+    assert code_exec_node is not None
+    text_input = next((input for input in code_exec_node["inputs"] if input["key"] == "text"), None)
+    assert text_input == {
+        "id": "da92a1c4-d37c-4008-a1ab-c0bcc0cd20d0",
+        "key": "text",
+        "value": {
+            "rules": [
+                {"type": "INPUT_VARIABLE", "data": {"input_variable_id": "6f0c1889-3f08-4c5c-bb24-f7b94169105c"}}
+            ],
+            "combinator": "OR",
+        },
+    }
+
+
+def test_serialize_tool_prompt_node_with_inline_workflow():
+    """
+    Test that the tool prompt node created by create_tool_prompt_node serializes successfully with inline workflow.
+    """
+
+    # GIVEN a simple inline workflow for tool calling
+    class SimpleWorkflowInputs(BaseInputs):
+        message: str
+
+    class SimpleNode(BaseNode):
+        message = SimpleWorkflowInputs.message
+
+        class Outputs(BaseOutputs):
+            result: str
+
+        def run(self) -> Outputs:
+            return self.Outputs(result=f"Processed: {self.message}")
+
+    class SimpleInlineWorkflow(BaseWorkflow[SimpleWorkflowInputs, BaseState]):
+        """A simple workflow for testing inline tool serialization."""
+
+        graph = SimpleNode
+
+        class Outputs(BaseOutputs):
+            result = SimpleNode.Outputs.result
+
+    # WHEN we create a tool prompt node using create_tool_prompt_node with inline workflow
+    tool_prompt_node = create_tool_prompt_node(
+        ml_model="gpt-4o-mini",
+        blocks=[],
+        functions=[SimpleInlineWorkflow],
+        prompt_inputs=None,
+        parameters=PromptParameters(),
+    )
+
+    tool_prompt_node_display_class = get_node_display_class(tool_prompt_node)
+    tool_prompt_node_display = tool_prompt_node_display_class()
+
+    # AND we create a workflow that uses this tool prompt node
+    class TestWorkflow(BaseWorkflow[BaseInputs, ToolCallingState]):
+        graph = tool_prompt_node
+
+    # WHEN we serialize the entire workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    display_context = workflow_display.display_context
+    serialized_tool_prompt_node = tool_prompt_node_display.serialize(display_context)
+
+    # THEN prompt inputs should be serialized correctly
+    attributes = serialized_tool_prompt_node["attributes"]
+    assert isinstance(attributes, list)
+    prompt_inputs_attr = next(
+        (attr for attr in attributes if isinstance(attr, dict) and attr["name"] == "prompt_inputs"), None
+    )
+    assert prompt_inputs_attr == {
+        "id": "bc1320a2-23e4-4238-8b00-efbf88e91856",
+        "name": "prompt_inputs",
+        "value": {
+            "type": "DICTIONARY_REFERENCE",
+            "entries": [
+                {
+                    "id": "76ceec7b-ec37-474f-ba38-2bfd27cecc5d",
+                    "key": "chat_history",
+                    "value": {
+                        "type": "BINARY_EXPRESSION",
+                        "lhs": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": []}},
+                        "operator": "concat",
+                        "rhs": {
+                            "type": "WORKFLOW_STATE",
+                            "state_variable_id": "7a1caaf5-99df-487a-8b2d-6512df2d871a",
+                        },
+                    },
+                }
+            ],
+        },
+    }
+
+
+def test_serialize_tool_prompt_node_with_workflow_deployment(vellum_client):
+    """
+    Test that the tool prompt node serializes successfully with a workflow deployment.
+    """
+    vellum_client.workflow_deployments.retrieve_workflow_deployment_release.return_value = WorkflowDeploymentRelease(
+        id="test-id",
+        created=datetime.now(),
+        environment=ReleaseEnvironment(
+            id="test-id",
+            name="test-name",
+            label="test-label",
+        ),
+        created_by=None,
+        workflow_version=WorkflowDeploymentReleaseWorkflowVersion(
+            id="test-id",
+            input_variables=[],
+            output_variables=[],
+        ),
+        deployment=WorkflowDeploymentReleaseWorkflowDeployment(name="test-name"),
+        description="test-description",
+        release_tags=[
+            ReleaseReleaseTag(
+                name="test-name",
+                source="USER",
+            )
+        ],
+        reviews=[
+            SlimReleaseReview(
+                id="test-id",
+                created=datetime.now(),
+                reviewer=ReleaseReviewReviewer(
+                    id="test-id",
+                    full_name="test-name",
+                ),
+                state="APPROVED",
+            )
+        ],
+    )
+
+    # GIVEN a workflow deployment
+    workflow_deployment = DeploymentDefinition(
+        deployment="test-deployment",
+        release_tag="test-release-tag",
+    )
+
+    # WHEN we create a tool prompt node using create_tool_prompt_node with a workflow deployment
+    tool_prompt_node = create_tool_prompt_node(
+        ml_model="gpt-4o-mini",
+        blocks=[],
+        functions=[workflow_deployment],
+        prompt_inputs=None,
+        parameters=PromptParameters(),
+    )
+
+    tool_prompt_node_display_class = get_node_display_class(tool_prompt_node)
+    tool_prompt_node_display = tool_prompt_node_display_class()
+
+    # AND we create a workflow that uses this tool prompt node
+    class TestWorkflow(BaseWorkflow[BaseInputs, ToolCallingState]):
+        graph = tool_prompt_node
+
+    # WHEN we serialize the entire workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    display_context = workflow_display.display_context
+    serialized_tool_prompt_node = tool_prompt_node_display.serialize(display_context)
+
+    # THEN functions attribute should be serialized correctly
+    attributes = serialized_tool_prompt_node["attributes"]
+    assert isinstance(attributes, list)
+    functions_attr = next((attr for attr in attributes if isinstance(attr, dict) and attr["name"] == "functions"), None)
+    assert functions_attr == {
+        "id": "6326ccc4-7cf6-4235-ba3c-a6e860b0c48b",
+        "name": "functions",
+        "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": [
+                    {
+                        "type": "WORKFLOW_DEPLOYMENT",
+                        "name": "test-name",
+                        "description": "test-description",
+                        "deployment": "test-deployment",
+                        "release_tag": "test-release-tag",
+                    }
+                ],
+            },
+        },
+    }

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

@@ -43,7 +43,7 @@ class BaseTryNodeDisplay(BaseAdornmentNodeDisplay[_TryNodeType], Generic[_TryNod
 
         adornment: JsonObject = {
             "id": str(node_id),
-            "label": node.__qualname__,
+            "label": self.label,
             "base": self.get_base().dict(),
             "attributes": attributes,
         }

vellum_ee/workflows/display/tests/test_base_workflow_display.py

@@ -2,7 +2,8 @@ from uuid import UUID
 from typing import Dict
 
 from vellum.workflows.inputs import BaseInputs
-from vellum.workflows.nodes import BaseNode
+from vellum.workflows.nodes import BaseNode, InlineSubworkflowNode
+from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.ports.port import Port
 from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state import BaseState
@@ -327,3 +328,54 @@ def test_serialize__port_with_lazy_reference():
             },
         }
     ]
+
+
+def test_global_propagation_deep_nested_subworkflows():
+    # GIVEN the root workflow, a middle workflow, and an inner workflow
+
+    class RootInputs(BaseInputs):
+        root_param: str
+
+    class MiddleInputs(BaseInputs):
+        middle_param: str
+
+    class InnerInputs(BaseInputs):
+        inner_param: str
+
+    class InnerNode(BaseNode):
+        class Outputs(BaseOutputs):
+            done: bool
+
+        def run(self) -> Outputs:
+            return self.Outputs(done=True)
+
+    class InnerWorkflow(BaseWorkflow[InnerInputs, BaseState]):
+        graph = InnerNode
+
+    class MiddleInlineSubworkflowNode(InlineSubworkflowNode):
+        subworkflow_inputs = {"inner_param": "x"}
+        subworkflow = InnerWorkflow
+
+    class MiddleWorkflow(BaseWorkflow[MiddleInputs, BaseState]):
+        graph = MiddleInlineSubworkflowNode
+
+    class OuterInlineSubworkflowNode(InlineSubworkflowNode):
+        subworkflow_inputs = {"middle_param": "y"}
+        subworkflow = MiddleWorkflow
+
+    class RootWorkflow(BaseWorkflow[RootInputs, BaseState]):
+        graph = OuterInlineSubworkflowNode
+
+    # WHEN we build the displays
+    root_display = get_workflow_display(workflow_class=RootWorkflow)
+    middle_display = get_workflow_display(
+        workflow_class=MiddleWorkflow, parent_display_context=root_display.display_context
+    )
+    inner_display = get_workflow_display(
+        workflow_class=InnerWorkflow, parent_display_context=middle_display.display_context
+    )
+
+    # THEN the deepest display must include root + middle + inner inputs in its GLOBAL view
+    inner_global_names = {ref.name for ref in inner_display.display_context.global_workflow_input_displays.keys()}
+
+    assert inner_global_names == {"middle_param", "inner_param", "root_param"}

vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_adornments_serialization.py

@@ -47,7 +47,7 @@ def test_serialize_node__retry(serialize_node):
     assert not DeepDiff(
         {
             "id": "188b50aa-e518-4b7b-a5e0-e2585fb1d7b5",
-            "label": "test_serialize_node__retry.<locals>.InnerRetryGenericNode",
+            "label": "Inner Retry Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -68,7 +68,7 @@ def test_serialize_node__retry(serialize_node):
             "adornments": [
                 {
                     "id": "5be7d260-74f7-4734-b31b-a46a94539586",
-                    "label": "RetryNode",
+                    "label": "Retry Node",
                     "base": {
                         "name": "RetryNode",
                         "module": ["vellum", "workflows", "nodes", "core", "retry_node", "node"],
@@ -154,7 +154,7 @@ def test_serialize_node__try(serialize_node):
     assert not DeepDiff(
         {
             "id": str(InnerTryGenericNode.__wrapped_node__.__id__),
-            "label": "test_serialize_node__try.<locals>.InnerTryGenericNode",
+            "label": "Inner Try Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -175,7 +175,7 @@ def test_serialize_node__try(serialize_node):
             "adornments": [
                 {
                     "id": "3344083c-a32c-4a32-920b-0fb5093448fa",
-                    "label": "TryNode",
+                    "label": "Try Node",
                     "base": {
                         "name": "TryNode",
                         "module": ["vellum", "workflows", "nodes", "core", "try_node", "node"],
@@ -248,7 +248,7 @@ def test_serialize_node__stacked():
     assert not DeepDiff(
         {
             "id": "074833b0-e142-4bbc-8dec-209a35e178a3",
-            "label": "test_serialize_node__stacked.<locals>.InnerStackedGenericNode",
+            "label": "Inner Stacked Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 200.0, "y": -50.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -272,7 +272,7 @@ def test_serialize_node__stacked():
             "adornments": [
                 {
                     "id": "3344083c-a32c-4a32-920b-0fb5093448fa",
-                    "label": "TryNode",
+                    "label": "Try Node",
                     "base": {
                         "name": "TryNode",
                         "module": ["vellum", "workflows", "nodes", "core", "try_node", "node"],
@@ -287,7 +287,7 @@ def test_serialize_node__stacked():
                 },
                 {
                     "id": "5be7d260-74f7-4734-b31b-a46a94539586",
-                    "label": "RetryNode",
+                    "label": "Retry Node",
                     "base": {
                         "name": "RetryNode",
                         "module": ["vellum", "workflows", "nodes", "core", "retry_node", "node"],
@@ -351,5 +351,5 @@ def test_serialize_node__adornment_order_matches_decorator_order():
 
     adornments = cast(List[Dict[str, Any]], my_node["adornments"])
     assert len(adornments) == 2
-    assert adornments[0]["label"] == "TryNode"
-    assert adornments[1]["label"] == "RetryNode"
+    assert adornments[0]["label"] == "Try Node"
+    assert adornments[1]["label"] == "Retry Node"

vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py

@@ -34,7 +34,7 @@ def test_serialize_node__constant_value(serialize_node):
     assert not DeepDiff(
         {
             "id": "67e07859-7f67-4287-9854-06ab4199e576",
-            "label": "test_serialize_node__constant_value.<locals>.ConstantValueGenericNode",
+            "label": "Constant Value Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -104,7 +104,7 @@ def test_serialize_node__constant_value_reference(serialize_node):
     assert not DeepDiff(
         {
             "id": "73643f17-e49e-47d2-bd01-bb9c3eab6ae9",
-            "label": "test_serialize_node__constant_value_reference.<locals>.ConstantValueReferenceGenericNode",
+            "label": "Constant Value Reference Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -146,7 +146,7 @@ def test_serialize_node__lazy_reference(serialize_node):
     assert not DeepDiff(
         {
             "id": "3d6bfe3b-263a-40a6-8a05-98288e9559a4",
-            "label": "test_serialize_node__lazy_reference.<locals>.LazyReferenceGenericNode",
+            "label": "Lazy Reference Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -229,7 +229,7 @@ def test_serialize_node__workflow_input(serialize_node):
     assert not DeepDiff(
         {
             "id": "30116483-6f38-40e0-baf2-32de0e14e9a3",
-            "label": "test_serialize_node__workflow_input.<locals>.WorkflowInputGenericNode",
+            "label": "Workflow Input Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -292,7 +292,7 @@ def test_serialize_node__workflow_input_as_nested_chat_history():
     assert not DeepDiff(
         {
             "id": "11be9d37-0069-4695-a317-14a3b6519d4e",
-            "label": "test_serialize_node__workflow_input_as_nested_chat_history.<locals>.GenericNode",
+            "label": "Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 200.0, "y": -50.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -362,7 +362,7 @@ def test_serialize_node__node_output(serialize_node):
     assert not DeepDiff(
         {
             "id": "7210742f-8c3e-4379-9800-8b4b7f5dd7ed",
-            "label": "test_serialize_node__node_output.<locals>.GenericNodeReferencingOutput",
+            "label": "Generic Node Referencing Output",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -412,7 +412,7 @@ def test_serialize_node__vellum_secret(serialize_node):
     assert not DeepDiff(
         {
             "id": "0e75bd8f-882e-4ab7-8348-061319b574f7",
-            "label": "test_serialize_node__vellum_secret.<locals>.VellumSecretGenericNode",
+            "label": "Vellum Secret Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -465,7 +465,7 @@ def test_serialize_node__node_execution(serialize_node):
     assert not DeepDiff(
         {
             "id": "f42dda6b-e856-49bd-b203-46c9dd66c08b",
-            "label": "test_serialize_node__node_execution.<locals>.GenericNodeReferencingExecutions",
+            "label": "Generic Node Referencing Executions",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -561,7 +561,7 @@ def test_serialize_node__coalesce(serialize_node):
     assert not DeepDiff(
         {
             "id": "bb99f326-7d2a-4b5e-95f3-6039114798da",
-            "label": "test_serialize_node__coalesce.<locals>.CoalesceNodeFinal",
+            "label": "Coalesce Node Final",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},

vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_outputs_serialization.py

@@ -23,7 +23,7 @@ def test_serialize_node__annotated_output(serialize_node):
     assert not DeepDiff(
         {
             "id": "e33ddf79-f48c-4057-ba17-d41a3a60ac98",
-            "label": "test_serialize_node__annotated_output.<locals>.AnnotatedOutputGenericNode",
+            "label": "Annotated Output Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -71,7 +71,7 @@ def test_serialize_node__workflow_input(serialize_node):
     assert not DeepDiff(
         {
             "id": "30116483-6f38-40e0-baf2-32de0e14e9a3",
-            "label": "test_serialize_node__workflow_input.<locals>.WorkflowInputGenericNode",
+            "label": "Workflow Input Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -134,7 +134,7 @@ def test_serialize_node__node_output_reference(serialize_node):
     assert not DeepDiff(
         {
             "id": "ac067acc-6a6f-44b1-ae84-428e965ce691",
-            "label": "test_serialize_node__node_output_reference.<locals>.GenericNodeReferencingOutput",
+            "label": "Generic Node Referencing Output",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},