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

vellum_ee/workflows/display/workflows/get_vellum_workflow_display_class.py

@@ -1,7 +1,10 @@
+import importlib
+import re
 import types
 from typing import TYPE_CHECKING, Generic, Optional, Type, TypeVar
 
 from vellum.client import Vellum as VellumClient
+from vellum.workflows import BaseWorkflow
 from vellum.workflows.types.generics import WorkflowType
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 from vellum_ee.workflows.display.utils.registry import get_from_workflow_display_registry
@@ -10,6 +13,28 @@ if TYPE_CHECKING:
     from vellum_ee.workflows.display.workflows import BaseWorkflowDisplay
 
 
+def _ensure_display_module_imported(workflow_class: Type[WorkflowType]) -> None:
+    """
+    Best-effort import of the workflow's display module to ensure any custom
+    WorkflowDisplay subclass is registered before we look it up in the registry.
+
+    This allows workflows to work without a display/__init__.py file that
+    re-exports from .workflow and .nodes.
+    """
+    module_name = workflow_class.__module__
+
+    if module_name == BaseWorkflow.__module__:
+        return
+
+    if module_name.endswith(".workflow"):
+        root = re.sub(r"\.workflow$", "", module_name)
+        display_workflow_module = f"{root}.display.workflow"
+        try:
+            importlib.import_module(display_workflow_module)
+        except ImportError:
+            pass
+
+
 def _get_workflow_display_class(*, workflow_class: Type[WorkflowType]) -> Type["BaseWorkflowDisplay"]:
     workflow_display_class = get_from_workflow_display_registry(workflow_class)
     if workflow_display_class:
@@ -42,6 +67,7 @@ def get_workflow_display(
     root_workflow_class: Optional[Type[WorkflowType]] = None,
     base_display_class: Optional[Type["BaseWorkflowDisplay"]] = None,
 ) -> "BaseWorkflowDisplay":
+    _ensure_display_module_imported(workflow_class)
     return _get_workflow_display_class(workflow_class=workflow_class)(
         parent_display_context=parent_display_context,
         client=client,

vellum_ee/workflows/display/workflows/tests/test_workflow_display.py

@@ -11,6 +11,7 @@ from vellum.workflows.nodes.core.try_node.node import TryNode
 from vellum.workflows.nodes.displayable.final_output_node.node import FinalOutputNode
 from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state.base import BaseState
+from vellum.workflows.triggers.integration import IntegrationTrigger
 from vellum.workflows.types.core import JsonObject
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.editor.types import NodeDisplayData, NodeDisplayPosition
@@ -18,6 +19,7 @@ from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.vellum.retry_node import BaseRetryNodeDisplay
 from vellum_ee.workflows.display.nodes.vellum.try_node import BaseTryNodeDisplay
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum_ee.workflows.display.utils.exceptions import UserFacingException
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 
@@ -41,7 +43,7 @@ def test_serialize_workflow__node_referenced_in_workflow_outputs_not_in_graph():
     workflow_display = get_workflow_display(workflow_class=Workflow)
 
     # THEN it should raise an error
-    with pytest.raises(ValueError) as exc_info:
+    with pytest.raises(UserFacingException) as exc_info:
         workflow_display.serialize()
 
     # AND the error message should be user friendly
@@ -61,17 +63,31 @@ def test_serialize_workflow__workflow_outputs_reference_non_node_outputs():
 
     # WHEN we serialize it
     workflow_display = get_workflow_display(workflow_class=Workflow)
+    serialized_workflow = workflow_display.serialize()
+
+    # THEN it should successfully serialize the workflow output reference to a constant
+    assert isinstance(serialized_workflow, dict)
+    output_variables = serialized_workflow["output_variables"]
+    assert isinstance(output_variables, list)
+    assert output_variables == [{"id": "2b32416b-ccfc-4231-a3a6-d08e76327815", "key": "final", "type": "STRING"}]
+
+    # AND the output value should be a constant value
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    assert isinstance(workflow_raw_data, dict)
+    output_values = workflow_raw_data["output_values"]
+    assert isinstance(output_values, list)
+    assert output_values == [
+        {
+            "output_variable_id": "2b32416b-ccfc-4231-a3a6-d08e76327815",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "bar"}},
+        }
+    ]
 
-    # THEN it should raise an error
-    with pytest.raises(ValueError) as exc_info:
-        workflow_display.serialize()
-
-    # AND the error message should be user friendly
-    assert (
-        str(exc_info.value)
-        == """Failed to serialize output 'final': Reference to outputs \
-'test_serialize_workflow__workflow_outputs_reference_non_node_outputs.<locals>.FirstWorkflow.Outputs' is invalid."""
-    )
+    first_output_variable = output_variables[0]
+    assert isinstance(first_output_variable, dict)
+    first_output_value = output_values[0]
+    assert isinstance(first_output_value, dict)
+    assert first_output_variable["id"] == first_output_value["output_variable_id"]
 
 
 def test_serialize_workflow__node_display_class_not_registered():
@@ -288,6 +304,38 @@ def test_get_event_display_context__workflow_output_display_with_none():
     assert display_context.workflow_outputs.keys() == {"foo", "bar"}
 
 
+def test_get_event_display_context__trigger_attributes_included():
+    """Trigger attributes should be included in workflow_inputs for display in executions list."""
+
+    # GIVEN a workflow with an integration trigger that has attributes
+    class SlackTrigger(IntegrationTrigger):
+        message: str
+        channel: str
+
+        class Config:
+            provider = "COMPOSIO"
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    class ProcessNode(BaseNode):
+        pass
+
+    class MyWorkflow(BaseWorkflow):
+        graph = SlackTrigger >> ProcessNode
+
+    # WHEN we gather the event display context
+    display_context = get_workflow_display(workflow_class=MyWorkflow).get_event_display_context()
+
+    # THEN the trigger attributes should be included in workflow_inputs
+    assert "message" in display_context.workflow_inputs
+    assert "channel" in display_context.workflow_inputs
+
+    # AND the IDs should match the trigger attribute IDs
+    trigger_attr_refs = SlackTrigger.attribute_references()
+    assert display_context.workflow_inputs["message"] == trigger_attr_refs["message"].id
+    assert display_context.workflow_inputs["channel"] == trigger_attr_refs["channel"].id
+
+
 def test_serialize_workflow__inherited_node_display_class_not_registered():
     # GIVEN a node meant to be used as a base
     class StartNode(BaseNode):
@@ -528,8 +576,14 @@ def test_serialize_workflow__array_reference():
     # THEN it should serialize as an ARRAY_REFERENCE
     assert isinstance(data["workflow_raw_data"], dict)
     assert isinstance(data["workflow_raw_data"]["nodes"], list)
-    assert len(data["workflow_raw_data"]["nodes"]) == 5
-    second_node = data["workflow_raw_data"]["nodes"][2]
+    second_node = next(
+        node
+        for node in data["workflow_raw_data"]["nodes"]
+        if isinstance(node, dict)
+        and "definition" in node
+        and isinstance(node["definition"], dict)
+        and node["definition"]["name"] == "SecondNode"
+    )
     assert isinstance(second_node, dict)
 
     assert "outputs" in second_node
@@ -828,17 +882,6 @@ def test_serialize_workflow__empty_rules_indexerror():
     assert len(output_variables) == 1
     assert output_variables[0]["key"] == "problematic_output"
 
-    # AND the workflow raw data should contain nodes including terminal node
-    workflow_raw_data = result["workflow_raw_data"]
-    assert "nodes" in workflow_raw_data
-    nodes = workflow_raw_data["nodes"]
-
-    assert len(nodes) >= 3
-
-    terminal_nodes = [node for node in nodes if node.get("type") == "TERMINAL"]
-    assert len(terminal_nodes) == 1
-    assert terminal_nodes[0]["data"]["name"] == "problematic_output"
-
 
 def test_serialize_workflow__input_variables():
     # GIVEN a workflow with inputs
@@ -870,6 +913,7 @@ def test_serialize_workflow__input_variables():
         "default": {"type": "STRING", "value": ""},
         "required": False,
         "extensions": {"color": None},
+        "schema": {"type": "string"},
     }
 
     input_1 = next(var for var in input_variables if isinstance(var, dict) and var["key"] == "input_1")
@@ -880,6 +924,7 @@ def test_serialize_workflow__input_variables():
         "default": None,
         "required": True,
         "extensions": {"color": None},
+        "schema": {"type": "string"},
     }
 
     input_2 = next(var for var in input_variables if isinstance(var, dict) and var["key"] == "input_2")
@@ -890,6 +935,7 @@ def test_serialize_workflow__input_variables():
         "default": None,
         "required": False,
         "extensions": {"color": None},
+        "schema": {"anyOf": [{"type": "string"}, {"type": "null"}]},
     }
 
     input_3 = next(var for var in input_variables if isinstance(var, dict) and var["key"] == "input_3")
@@ -900,6 +946,7 @@ def test_serialize_workflow__input_variables():
         "default": {"type": "NUMBER", "value": 1.0},
         "required": False,
         "extensions": {"color": None},
+        "schema": {"type": "integer"},
     }
 
     input_4 = next(var for var in input_variables if isinstance(var, dict) and var["key"] == "input_4")
@@ -910,6 +957,7 @@ def test_serialize_workflow__input_variables():
         "default": {"type": "NUMBER", "value": 2.0},
         "required": False,
         "extensions": {"color": None},
+        "schema": {"anyOf": [{"type": "integer"}, {"type": "null"}]},
     }
 
 
@@ -937,7 +985,7 @@ def test_serialize_workflow__state_variables():
 
     empty_string = next(var for var in state_variables if isinstance(var, dict) and var["key"] == "empty_string")
     assert empty_string == {
-        "id": "0ed1f179-1734-487f-b3ed-9e6026390d90",
+        "id": "c69e2507-f610-4a6f-84cc-a5bc2aa48551",
         "key": "empty_string",
         "type": "STRING",
         "default": {"type": "STRING", "value": ""},
@@ -947,7 +995,7 @@ def test_serialize_workflow__state_variables():
 
     state_1 = next(var for var in state_variables if isinstance(var, dict) and var["key"] == "state_1")
     assert state_1 == {
-        "id": "83c5b71d-56eb-42a5-84df-97e3591370c2",
+        "id": "151113d2-9bbf-428d-a1c1-0a9cf4fdedf3",
         "key": "state_1",
         "type": "STRING",
         "default": {"type": "STRING", "value": "hello"},
@@ -957,7 +1005,7 @@ def test_serialize_workflow__state_variables():
 
     state_2 = next(var for var in state_variables if isinstance(var, dict) and var["key"] == "state_2")
     assert state_2 == {
-        "id": "9b0cfeec-aa66-42b3-8f31-aa7eb8ac30ea",
+        "id": "9a8d7a55-8bd2-497d-820c-dee665144a48",
         "key": "state_2",
         "type": "STRING",
         "default": None,
@@ -967,7 +1015,7 @@ def test_serialize_workflow__state_variables():
 
     state_3 = next(var for var in state_variables if isinstance(var, dict) and var["key"] == "state_3")
     assert state_3 == {
-        "id": "3e19c570-6b46-4eab-ad81-d8d97028496f",
+        "id": "ffde4327-12c4-4c55-82d6-3ab88f0b1037",
         "key": "state_3",
         "type": "NUMBER",
         "default": {"type": "NUMBER", "value": 1.0},
@@ -977,7 +1025,7 @@ def test_serialize_workflow__state_variables():
 
     state_4 = next(var for var in state_variables if isinstance(var, dict) and var["key"] == "state_4")
     assert state_4 == {
-        "id": "50c735de-f269-4d0a-b511-c9a1104451bb",
+        "id": "2467c1e6-b6aa-42d7-b079-84c8a650fbca",
         "key": "state_4",
         "type": "NUMBER",
         "default": {"type": "NUMBER", "value": 2.0},

vellum_ee/workflows/server/namespaces.py

@@ -0,0 +1,18 @@
+"""Namespace utilities for workflow server."""
+
+import random
+import string
+
+
+def get_random_namespace() -> str:
+    """
+    Generate a random namespace for virtual file loading.
+
+    This generates a workflow_tmp_* namespace like vembda uses for loading
+    workflows dynamically.
+
+    Returns:
+        A random namespace string in the format "workflow_tmp_{random_suffix}"
+    """
+    random_suffix = "".join(random.choices(string.ascii_letters + string.digits, k=16))
+    return f"workflow_tmp_{random_suffix}"

vellum_ee/workflows/tests/test_display_meta.py

@@ -16,6 +16,8 @@ def files() -> dict[str, str]:
 
     for root, _, filenames in os.walk(base_directory):
         for filename in filenames:
+            if filename.endswith(".pyc"):
+                continue
             file_path = os.path.join(root, filename)
             # Key will be the relative path inside `local_files`
             relative_path = str(os.path.relpath(file_path, start=base_directory))

vellum_ee/workflows/tests/test_serialize_module.py

@@ -11,6 +11,8 @@ from pytest_mock import MockerFixture
 from vellum.workflows.exceptions import WorkflowInitializationException
 from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 
+from tests.workflows.test_node_output_mock_when_conditions.workflow import ProcessNode
+
 
 @pytest.fixture
 def temp_module_path():
@@ -66,7 +68,7 @@ def test_serialize_module_with_actual_dataset():
     assert result.dataset[1]["inputs"]["message"] == "DatasetRow Test"
 
 
-def test_serialize_module_with_actual_dataset_with_trigger(metadata_trigger_factory):
+def test_serialize_module_with_actual_dataset_with_scheduled_trigger(metadata_trigger_factory):
     """Test that serialize_module correctly serializes dataset with trigger"""
     module_path = "tests.workflows.test_dataset_with_trigger_serialization"
 
@@ -84,6 +86,12 @@ def test_serialize_module_with_actual_dataset_with_trigger(metadata_trigger_fact
     assert result.dataset[0]["label"] == "Scenario 1"
     assert result.dataset[0]["workflow_trigger_id"] == str(metadata_trigger_id)
 
+    inputs = result.dataset[0]["inputs"]
+    assert len(inputs) == 2
+
+    assert "current_run_at" in inputs
+    assert "next_run_at" in inputs
+
 
 def test_serialize_module_happy_path():
     """Test that serialize_module works with a valid module path."""
@@ -100,34 +108,82 @@ def test_serialize_module_happy_path():
     assert "output_variables" in result.exec_config
 
 
+def test_serialize_module__includes_runner_config():
+    """
+    Tests that serialize_module includes runner_config in exec_config.
+    """
+    # GIVEN a valid module path without metadata.json runner_config
+    module_path = "tests.workflows.trivial"
+
+    # WHEN we serialize the module
+    result = BaseWorkflowDisplay.serialize_module(module_path)
+
+    # THEN the exec_config should contain runner_config
+    assert "runner_config" in result.exec_config
+
+    # AND runner_config should be an empty dict when no metadata.json runner_config exists
+    runner_config = result.exec_config["runner_config"]
+    assert isinstance(runner_config, dict)
+
+
+def test_serialize_module__runner_config_from_metadata():
+    """
+    Tests that serialize_module reads runner_config from metadata.json.
+    """
+    # GIVEN a module path with metadata.json containing runner_config
+    module_path = "ee.vellum_ee.workflows.tests.local_workflow"
+
+    # WHEN we serialize the module
+    result = BaseWorkflowDisplay.serialize_module(module_path)
+
+    # THEN the exec_config should contain runner_config
+    assert "runner_config" in result.exec_config
+
+    # AND runner_config should be a dict (loaded from metadata.json)
+    runner_config = result.exec_config["runner_config"]
+    assert isinstance(runner_config, dict)
+
+
 def test_serialize_module_includes_additional_files():
-    """Test that serialize_module includes additional files from the module directory."""
+    """
+    Tests that serialize_module includes only Python files from the module directory.
+
+    Non-Python files (like .txt) should be excluded from additional_files.
+    """
+    # GIVEN a module path with additional files including both .py and non-.py files
     module_path = "tests.workflows.module_with_additional_files"
 
+    # WHEN we serialize the module
     result = BaseWorkflowDisplay.serialize_module(module_path)
 
+    # THEN the result should have the expected structure
     assert hasattr(result, "exec_config")
     assert hasattr(result, "errors")
     assert isinstance(result.exec_config, dict)
     assert isinstance(result.errors, list)
 
+    # AND module_data should contain additional_files
     assert "module_data" in result.exec_config
     assert "additional_files" in result.exec_config["module_data"]
 
     additional_files = result.exec_config["module_data"]["additional_files"]
     assert isinstance(additional_files, dict)
 
+    # AND Python helper files should be included
     assert "helper.py" in additional_files
-    assert "data.txt" in additional_files
     assert "utils/constants.py" in additional_files
+    assert "utils/__init__.py" in additional_files
+
+    # AND non-Python files should NOT be included
+    assert "data.txt" not in additional_files
 
+    # AND serialized workflow files should NOT be included
     assert "workflow.py" not in additional_files
     assert "__init__.py" not in additional_files
-    assert "utils/__init__.py" in additional_files
     assert "nodes/test_node.py" not in additional_files
 
+    # AND the Python file contents should be correct
     assert "def helper_function():" in additional_files["helper.py"]
-    assert "sample data file" in additional_files["data.txt"]
     assert "CONSTANT_VALUE" in additional_files["utils/constants.py"]
 
 
@@ -154,7 +210,11 @@ def test_serialize_module_with_pydantic_array():
     items_input = input_variables[0]
     assert items_input["key"] == "items"
     assert items_input["type"] == "JSON"
-    # TODO: In the future, this should be a custom type based on an OpenAPI schema (important-comment)
+    # The schema field now includes the OpenAPI spec for the input type
+    assert items_input["schema"] == {
+        "type": "array",
+        "items": {"$ref": "#/$defs/tests.workflows.pydantic_array_serialization.workflow.CustomItem"},
+    }
 
     assert result.dataset is not None
     assert isinstance(result.dataset, list)
@@ -204,7 +264,8 @@ def test_serialize_module_with_dataset_row_id_from_metadata():
 
     assert result.dataset[2]["label"] == "Scenario 3 without ID"
     assert result.dataset[2]["inputs"]["message"] == "No ID"
-    assert "id" not in result.dataset[2]
+    # AND the third row should have a deterministic hash-based ID since it has no explicit ID
+    assert result.dataset[2]["id"] == "cc40aa9b-179a-43fc-8fda-d40ea8a8e300"
 
 
 def test_serialize_module_with_base_inputs_and_metadata():
@@ -231,6 +292,112 @@ def test_serialize_module_with_base_inputs_and_metadata():
     assert result.dataset[1]["id"] == "base-inputs-id-2"
 
 
+def test_serialize_module_with_node_output_mock_when_conditions():
+    """
+    Tests that serialize_module correctly serializes node output mocks with when conditions.
+
+    Verifies that when conditions involving workflow inputs and node execution counters
+    are properly serialized in the dataset.
+    """
+    module_path = "tests.workflows.test_node_output_mock_when_conditions"
+
+    # WHEN we serialize the module
+    result = BaseWorkflowDisplay.serialize_module(module_path)
+
+    assert hasattr(result, "dataset")
+    assert result.dataset is not None
+    assert isinstance(result.dataset, list)
+    assert len(result.dataset) == 2
+
+    first_scenario = result.dataset[0]
+    assert first_scenario["label"] == "Scenario 1"
+    assert first_scenario["inputs"]["threshold"] == 5
+
+    assert "mocks" in first_scenario
+    assert isinstance(first_scenario["mocks"], list)
+    assert len(first_scenario["mocks"]) == 2
+
+    first_mock = first_scenario["mocks"][0]
+    workflow_input_id = first_mock["when_condition"]["lhs"]["lhs"]["input_variable_id"]
+    node_id = str(ProcessNode.__id__)
+
+    assert first_mock == {
+        "type": "NODE_EXECUTION",
+        "node_id": node_id,
+        "when_condition": {
+            "type": "BINARY_EXPRESSION",
+            "lhs": {
+                "type": "BINARY_EXPRESSION",
+                "lhs": {"type": "WORKFLOW_INPUT", "input_variable_id": workflow_input_id},
+                "operator": "=",
+                "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5.0}},
+            },
+            "operator": "and",
+            "rhs": {
+                "type": "BINARY_EXPRESSION",
+                "lhs": {"type": "EXECUTION_COUNTER", "node_id": node_id},
+                "operator": "=",
+                "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 0.0}},
+            },
+        },
+        "then_outputs": {"result": "first_execution_threshold_5"},
+    }
+
+    second_mock = first_scenario["mocks"][1]
+    assert second_mock == {
+        "type": "NODE_EXECUTION",
+        "node_id": node_id,
+        "when_condition": {
+            "type": "BINARY_EXPRESSION",
+            "lhs": {
+                "type": "BINARY_EXPRESSION",
+                "lhs": {"type": "WORKFLOW_INPUT", "input_variable_id": workflow_input_id},
+                "operator": "=",
+                "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5.0}},
+            },
+            "operator": "and",
+            "rhs": {
+                "type": "BINARY_EXPRESSION",
+                "lhs": {"type": "EXECUTION_COUNTER", "node_id": node_id},
+                "operator": "=",
+                "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 1.0}},
+            },
+        },
+        "then_outputs": {"result": "second_execution_threshold_5"},
+    }
+
+    second_scenario = result.dataset[1]
+    assert second_scenario["label"] == "Scenario 2"
+    assert second_scenario["inputs"]["threshold"] == 10
+
+    assert "mocks" in second_scenario
+    assert isinstance(second_scenario["mocks"], list)
+    assert len(second_scenario["mocks"]) == 1
+
+    third_mock = second_scenario["mocks"][0]
+    assert third_mock == {
+        "type": "NODE_EXECUTION",
+        "node_id": node_id,
+        "when_condition": {
+            "type": "BINARY_EXPRESSION",
+            "lhs": {
+                "type": "BINARY_EXPRESSION",
+                "lhs": {"type": "WORKFLOW_INPUT", "input_variable_id": workflow_input_id},
+                "operator": "=",
+                "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 10.0}},
+            },
+            "operator": "and",
+            "rhs": {
+                "type": "BINARY_EXPRESSION",
+                "lhs": {"type": "EXECUTION_COUNTER", "node_id": node_id},
+                "operator": "=",
+                "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 0.0}},
+            },
+        },
+        "then_outputs": {"result": "first_execution_threshold_10"},
+    }
+
+
 def test_serialize_module__with_invalid_nested_set_graph(temp_module_path):
     """
     Tests that serialize_module raises a clear user-facing exception for workflows with nested sets in graph attribute.

vellum_ee/workflows/tests/test_server.py

@@ -945,9 +945,6 @@ from vellum.workflows.nodes import BaseNode
 class StartNode(BaseNode):
     class Outputs(BaseNode.Outputs):
         result: str = "test output"
-""",
-        "display/nodes/__init__.py": """\
-from .start_node import StartNodeDisplay
 """,
         "display/nodes/start_node.py": """\
 from uuid import UUID

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

@@ -1,14 +0,0 @@
-from typing import Generic, TypeVar
-
-from vellum.workflows.nodes.displayable.tool_calling_node.utils import FunctionNode
-from vellum_ee.workflows.display.editor.types import NodeDisplayData
-from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
-
-_FunctionNodeType = TypeVar("_FunctionNodeType", bound=FunctionNode)
-
-
-class FunctionNodeDisplay(BaseNodeDisplay[_FunctionNodeType], Generic[_FunctionNodeType]):
-    display_data = NodeDisplayData(
-        icon="vellum:icon:rectangle-code",
-        color="purple",
-    )