vellum-ai 0.14.13__py3-none-any.whl → 0.14.15__py3-none-any.whl

vellum/client/core/client_wrapper.py

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

vellum/client/core/pydantic_utilities.py

@@ -133,12 +133,11 @@ class UniversalBaseModel(pydantic.BaseModel):
         #
         # We'd ideally do the same for Pydantic V2, but it shells out to a library to serialize models
         # that we have less control over, and this is less intrusive than custom serializers for now.
-        kwargs = {
-            **kwargs,
-            "warnings": False,
-        }
-
         if IS_PYDANTIC_V2:
+            kwargs = {
+                **kwargs,
+                "warnings": False,
+            }
             kwargs_with_defaults_exclude_unset: typing.Any = {
                 **kwargs,
                 "by_alias": True,

vellum/client/types/logical_operator.py

@@ -26,6 +26,7 @@ LogicalOperator = typing.Union[
         "notBlank",
         "coalesce",
         "accessField",
+        "parseJson",
         "and",
         "or",
     ],

vellum/plugins/utils.py

@@ -1,11 +1,19 @@
-from pydantic.plugin import _loader as _pydantic_plugin_loader
-
-from vellum.plugins.pydantic import pydantic_plugin
+import pydantic
 
+IS_PYDANTIC_V1 = pydantic.VERSION.startswith("1.")
 _loaded = False
 
 
 def load_runtime_plugins() -> None:
+    if IS_PYDANTIC_V1:
+        # Pydantic plugins are only available in v2, so we defer the imports
+        # below until we confirm we are running a supported version of pydantic
+        return
+
+    from pydantic.plugin import _loader as _pydantic_plugin_loader
+
+    from vellum.plugins.pydantic import pydantic_plugin
+
     global _loaded
     if _loaded:
         return

vellum/workflows/events/node.py

@@ -93,6 +93,7 @@ class NodeExecutionStreamingEvent(_BaseNodeEvent):
 class NodeExecutionFulfilledBody(_BaseNodeExecutionBody, Generic[OutputsType]):
     outputs: OutputsType
     invoked_ports: InvokedPorts = None
+    mocked: Optional[bool] = None
 
     @field_serializer("outputs")
     def serialize_outputs(self, outputs: OutputsType, _info: Any) -> Dict[str, Any]:
@@ -117,6 +118,10 @@ class NodeExecutionFulfilledEvent(_BaseNodeEvent, Generic[OutputsType]):
     def invoked_ports(self) -> InvokedPorts:
         return self.body.invoked_ports
 
+    @property
+    def mocked(self) -> Optional[bool]:
+        return self.body.mocked
+
 
 class NodeExecutionRejectedBody(_BaseNodeExecutionBody):
     error: WorkflowError

vellum/workflows/events/tests/test_event.py

@@ -328,6 +328,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                             "name": "default",
                         }
                     ],
+                    "mocked": None,
                 },
                 "parent": None,
             },
@@ -365,6 +366,40 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                             "name": "default",
                         }
                     ],
+                    "mocked": None,
+                },
+                "parent": None,
+            },
+        ),
+        (
+            NodeExecutionFulfilledEvent(
+                id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                timestamp=datetime(2024, 1, 1, 12, 0, 0),
+                trace_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                body=NodeExecutionFulfilledBody(
+                    node_definition=MockNode,
+                    outputs=MockNode.Outputs(
+                        example="foo",
+                    ),
+                    mocked=True,
+                ),
+            ),
+            {
+                "id": "123e4567-e89b-12d3-a456-426614174000",
+                "api_version": "2024-10-25",
+                "timestamp": "2024-01-01T12:00:00",
+                "trace_id": "123e4567-e89b-12d3-a456-426614174000",
+                "span_id": "123e4567-e89b-12d3-a456-426614174000",
+                "name": "node.execution.fulfilled",
+                "body": {
+                    "node_definition": {
+                        "id": mock_node_uuid,
+                        "name": "MockNode",
+                        "module": module_root + ["events", "tests", "test_event"],
+                    },
+                    "outputs": {"example": "foo"},
+                    "mocked": True,
                 },
                 "parent": None,
             },
@@ -379,6 +414,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
         "node.execution.streaming",
         "node.execution.fulfilled",
         "fulfilled_node_with_undefined_outputs",
+        "mocked_node",
     ],
 )
 def test_event_serialization(event, expected_json):

vellum/workflows/nodes/core/retry_node/tests/test_node.py

@@ -33,6 +33,29 @@ def test_retry_node__retry_on_error_code__successfully_retried():
     assert outputs.execution_count == 3
 
 
+def test_retry_node__retry_on_error_code_all():
+    # GIVEN a retry node that is configured to retry on all errors
+    @RetryNode.wrap(max_attempts=3)
+    class TestNode(BaseNode):
+        attempt_number = RetryNode.SubworkflowInputs.attempt_number
+
+        class Outputs(BaseOutputs):
+            execution_count: int
+
+        def run(self) -> Outputs:
+            if self.attempt_number < 3:
+                raise NodeException(message="This will be retried", code=WorkflowErrorCode.PROVIDER_ERROR)
+
+            return self.Outputs(execution_count=self.attempt_number)
+
+    # WHEN the node is run and throws a None
+    node = TestNode(state=BaseState())
+    outputs = node.run()
+
+    # THEN the exception is retried
+    assert outputs.execution_count == 3
+
+
 def test_retry_node__retry_on_error_code__missed():
     # GIVEN a retry node that is configured to retry on PROVIDER_ERROR
     @RetryNode.wrap(max_attempts=3, retry_on_error_code=WorkflowErrorCode.PROVIDER_ERROR)

vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py

@@ -283,3 +283,19 @@ def test_templating_node__function_call_as_json():
     # AND we can access fields directly
     assert outputs.result["arguments"] == {"key": "value"}
     assert outputs.result["name"] == "test_function"
+
+
+def test_templating_node__empty_string_to_list():
+    """Test that an empty string output with list output type casts to an empty array."""
+
+    # GIVEN a templating node that outputs an empty string but has List output type
+    class EmptyStringToListTemplateNode(TemplatingNode[BaseState, List[str]]):
+        template = """{{ "" }}"""
+        inputs = {}
+
+    # WHEN the node is run
+    node = EmptyStringToListTemplateNode()
+    outputs = node.run()
+
+    # THEN the output should be an empty list, not raise an exception
+    assert outputs.result == []

vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py

@@ -64,3 +64,32 @@ def test_api_node_raises_error_when_api_call_fails(vellum_client):
 
     # AND the API call should have been made
     assert vellum_client.execute_api.call_count == 1
+
+
+def test_api_node_defaults_to_get_method(vellum_client):
+    # GIVEN a successful API response
+    vellum_client.execute_api.return_value = ExecuteApiResponse(
+        status_code=200,
+        text='{"status": 200, "data": [1, 2, 3]}',
+        json_={"data": [1, 2, 3]},
+        headers={"X-Response-Header": "bar"},
+    )
+
+    # AND an API node without a method specified
+    class SimpleAPINodeWithoutMethod(APINode):
+        authorization_type = AuthorizationType.BEARER_TOKEN
+        url = "https://api.vellum.ai"
+        headers = {
+            "X-Test-Header": "foo",
+        }
+        bearer_token_value = VellumSecret(name="secret")
+
+    node = SimpleAPINodeWithoutMethod()
+
+    # WHEN we run the node
+    node.run()
+
+    # THEN the API call should be made with GET method
+    assert vellum_client.execute_api.call_count == 1
+    method = vellum_client.execute_api.call_args.kwargs["method"]
+    assert method == APIRequestMethod.GET.value

vellum/workflows/nodes/displayable/bases/api_node/node.py

@@ -29,7 +29,7 @@ class BaseAPINode(BaseNode, Generic[StateType]):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
     url: str
-    method: APIRequestMethod
+    method: Optional[APIRequestMethod] = APIRequestMethod.GET
     data: Optional[str] = None
     json: Optional[Json] = None
     headers: Optional[Dict[str, Union[str, VellumSecret]]] = None
@@ -45,8 +45,8 @@ class BaseAPINode(BaseNode, Generic[StateType]):
 
     def _run(
         self,
-        method: APIRequestMethod,
         url: str,
+        method: Optional[APIRequestMethod] = APIRequestMethod.GET,
         data: Optional[Union[str, Any]] = None,
         json: Any = None,
         headers: Any = None,

vellum/workflows/nodes/tests/test_utils.py

@@ -0,0 +1,133 @@
+import pytest
+from typing import List, Union
+
+from pydantic import BaseModel
+
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.utils import parse_type_from_str
+from vellum.workflows.types.core import Json
+
+
+class Person(BaseModel):
+    name: str
+    age: int
+
+
+class FunctionCall(BaseModel):
+    name: str
+    args: List[int]
+
+
+@pytest.mark.parametrize(
+    "input_str, output_type, expected_result",
+    [
+        ("hello", str, "hello"),
+        ("3.14", float, 3.14),
+        ("42", int, 42),
+        ("True", bool, True),
+        ("", List[str], []),  # Empty string should return an empty list
+        ("[1, 2, 3]", List[int], [1, 2, 3]),
+        ('["a", "b", "c"]', List[str], ["a", "b", "c"]),
+        ('{"name": "Alice", "age": 30}', Json, {"name": "Alice", "age": 30}),
+        (
+            '{"type": "FUNCTION_CALL", "value": {"name": "test", "args": [1, 2]}}',
+            Json,
+            {"name": "test", "args": [1, 2]},
+        ),
+        ("42", Union[int, str], 42),
+        ("hello", Union[int, str], "hello"),
+    ],
+    ids=[
+        "str",
+        "float",
+        "int",
+        "bool",
+        "empty_list",
+        "list_of_int",
+        "list_of_str",
+        "simple_json",
+        "function_call_json",
+        "union_int",
+        "union_str",
+    ],
+)
+def test_parse_type_from_str_basic_cases(input_str, output_type, expected_result):
+    result = parse_type_from_str(input_str, output_type)
+    assert result == expected_result
+
+
+def test_parse_type_from_str_pydantic_models():
+    person_json = '{"name": "Alice", "age": 30}'
+    person = parse_type_from_str(person_json, Person)
+    assert isinstance(person, Person)
+    assert person.name == "Alice"
+    assert person.age == 30
+
+    function_json = '{"name": "test", "args": [1, 2]}'
+    function = parse_type_from_str(function_json, FunctionCall)
+    assert isinstance(function, FunctionCall)
+    assert function.name == "test"
+    assert function.args == [1, 2]
+
+    function_call_json = '{"value": {"name": "test", "args": [1, 2]}}'
+    function = parse_type_from_str(function_call_json, FunctionCall)
+    assert isinstance(function, FunctionCall)
+    assert function.name == "test"
+    assert function.args == [1, 2]
+
+
+def test_parse_type_from_str_list_of_models():
+    person_list_json = '[{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]'
+    persons = parse_type_from_str(person_list_json, List[Person])
+    assert len(persons) == 2
+    assert all(isinstance(p, Person) for p in persons)
+    assert persons[0].name == "Alice"
+    assert persons[0].age == 30
+    assert persons[1].name == "Bob"
+    assert persons[1].age == 25
+
+
+@pytest.mark.parametrize(
+    "input_str, output_type, expected_exception, expected_code, expected_message",
+    [
+        (
+            "{invalid json}",
+            List[str],
+            NodeException,
+            WorkflowErrorCode.INVALID_OUTPUTS,
+            "Invalid JSON Array format for result_as_str",
+        ),
+        (
+            "{invalid json}",
+            Person,
+            NodeException,
+            WorkflowErrorCode.INVALID_OUTPUTS,
+            "Invalid JSON format for result_as_str",
+        ),
+        (
+            "{invalid json}",
+            Json,
+            NodeException,
+            WorkflowErrorCode.INVALID_OUTPUTS,
+            "Invalid JSON format for result_as_str",
+        ),
+        ('{"name": "Alice"}', List[str], ValueError, None, "Expected a list of items for result_as_str, received dict"),
+        ("data", object, ValueError, None, "Unsupported output type: <class 'object'>"),
+    ],
+    ids=[
+        "invalid_json_list",
+        "invalid_json_model",
+        "invalid_json_json_type",
+        "non_list_for_list",
+        "unsupported_type",
+    ],
+)
+def test_parse_type_from_str_error_cases(input_str, output_type, expected_exception, expected_code, expected_message):
+    with pytest.raises(expected_exception) as excinfo:
+        parse_type_from_str(input_str, output_type)
+
+    if expected_code:
+        assert excinfo.value.code == expected_code
+
+    assert expected_message in str(excinfo.value)

vellum/workflows/nodes/utils.py

@@ -95,10 +95,18 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
         return bool(result_as_str)
 
     if get_origin(output_type) is list:
+        # Handle empty string case for list types by returning an empty list
+        if not result_as_str.strip():
+            return []
+
         try:
             data = json.loads(result_as_str)
         except json.JSONDecodeError:
-            raise ValueError("Invalid JSON Array format for result_as_str")
+            # raise ValueError("Invalid JSON Array format for result_as_str")
+            raise NodeException(
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+                message="Invalid JSON Array format for result_as_str",
+            )
 
         if not isinstance(data, list):
             raise ValueError(f"Expected a list of items for result_as_str, received {data.__class__.__name__}")
@@ -117,7 +125,10 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
                 return data["value"]
             return data
         except json.JSONDecodeError:
-            raise ValueError("Invalid JSON format for result_as_str")
+            raise NodeException(
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+                message="Invalid JSON format for result_as_str",
+            )
 
     if get_origin(output_type) is Union:
         for inner_type in get_args(output_type):
@@ -140,7 +151,10 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
                 data = data["value"]
             return output_type.model_validate(data)
         except json.JSONDecodeError:
-            raise ValueError("Invalid JSON format for result_as_str")
+            raise NodeException(
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+                message="Invalid JSON format for result_as_str",
+            )
 
     raise ValueError(f"Unsupported output type: {output_type}")
 

vellum/workflows/runner/runner.py

@@ -200,7 +200,7 @@ class WorkflowRunner(Generic[StateType]):
                 parent=parent_context,
             )
             node_run_response: NodeRunResponse
-            was_mocked = False
+            was_mocked: Optional[bool] = None
             mock_candidates = self.workflow.context.node_output_mocks_map.get(node.Outputs) or []
             for mock_candidate in mock_candidates:
                 if mock_candidate.when_condition.resolve(node.state):
@@ -315,6 +315,7 @@ class WorkflowRunner(Generic[StateType]):
                         node_definition=node.__class__,
                         outputs=outputs,
                         invoked_ports=invoked_ports,
+                        mocked=was_mocked,
                     ),
                     parent=parent_context,
                 )

{vellum_ai-0.14.13.dist-info → vellum_ai-0.14.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.14.13
+Version: 0.14.15
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0
@@ -33,7 +33,7 @@ Requires-Dist: pydantic-core (>=2.18.2,<3.0.0)
 Requires-Dist: pydash (==7.0.6)
 Requires-Dist: python-dotenv (==1.0.1)
 Requires-Dist: pytz (==2025.1)
-Requires-Dist: pyyaml (==6.0.1)
+Requires-Dist: pyyaml (==6.0.2)
 Requires-Dist: requests (==2.32.3)
 Requires-Dist: tomli (==2.0.2)
 Requires-Dist: typing_extensions (>=4.0.0)

{vellum_ai-0.14.13.dist-info → vellum_ai-0.14.15.dist-info}/RECORD

@@ -23,16 +23,16 @@ vellum_ee/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 vellum_ee/workflows/display/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/base.py,sha256=ak29FIsawhaFa9_paZUHThlZRFJ1xB486JWKuSt1PYY,1965
 vellum_ee/workflows/display/nodes/__init__.py,sha256=436iSAh_Ex5tC68oEYvNgPu05ZVIAVXnS4PKGrQeZ0Y,321
-vellum_ee/workflows/display/nodes/base_node_display.py,sha256=p6orKsqEo8u6PWDbpp60D_E4UtjWNzWI8aVe8aknpyc,17097
-vellum_ee/workflows/display/nodes/base_node_vellum_display.py,sha256=pLO0dORfRu--Ne9NgoyFT_CNjfpr5fGCsgbsMkUF5GM,2845
-vellum_ee/workflows/display/nodes/get_node_display_class.py,sha256=67J_TGFNoISq8wZqOBCu5BNMY4kpQBq3Lt65FPH3Gt0,1594
+vellum_ee/workflows/display/nodes/base_node_display.py,sha256=pYmIdmC2dxLyRlZEBlgARIJMLcBX3GxZPpWZISv5Bbg,17170
+vellum_ee/workflows/display/nodes/base_node_vellum_display.py,sha256=ZLKQ8Xa3h9nGkj4t4V_7OeU7CBFWY3gXB9CkaCLOhEk,2699
+vellum_ee/workflows/display/nodes/get_node_display_class.py,sha256=RWCGm29-Tabi-qgVEIi_sdTWBv4bEzxAgwAoYI5T-Cc,2566
 vellum_ee/workflows/display/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/nodes/tests/test_base_node_display.py,sha256=QqR3Ly0RNrXwOeLdW5nERDFt0gRPf76n1bPES6o5UN4,1093
 vellum_ee/workflows/display/nodes/types.py,sha256=St1BB6no528OyELGiyRabWao0GGw6mLhstQAvEACbGk,247
 vellum_ee/workflows/display/nodes/utils.py,sha256=sloya5TpXsnot1HURc9L51INwflRqUzHxRVnCS9Cd-4,973
 vellum_ee/workflows/display/nodes/vellum/__init__.py,sha256=nUIgH2s0-7IbQRNrBhLPyRNe8YIrx3Yo9HeeW-aXXFk,1668
 vellum_ee/workflows/display/nodes/vellum/api_node.py,sha256=hoV-cUtS6H9kmRQXHd2py95GRWI_dAnnaPwvlNBkDOQ,8571
-vellum_ee/workflows/display/nodes/vellum/base_adornment_node.py,sha256=UlfX8ifleaAaRCmGlj6XNubEMJnHOgCXSBRk6LAZw38,1995
+vellum_ee/workflows/display/nodes/vellum/base_adornment_node.py,sha256=t-KSaai6cXRLkNkzCvEbM5SHh03B9fqPwVTH-Gei_-0,4419
 vellum_ee/workflows/display/nodes/vellum/code_execution_node.py,sha256=z00Z3L0d4PsUQo4S8FRDTtOFLtjdi17TJbatNVF4nM8,4288
 vellum_ee/workflows/display/nodes/vellum/conditional_node.py,sha256=ybLIa4uclqVIy3VAQvI1ivg2tnK5Ug_1R5a69DFqL7E,11104
 vellum_ee/workflows/display/nodes/vellum/error_node.py,sha256=I1Jkp2htRINJATtv1e-zs9BrReFX842djpiVgBPHDYg,2186
@@ -44,27 +44,27 @@ vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=8CPnn06HIBxBOiECevUf
 vellum_ee/workflows/display/nodes/vellum/merge_node.py,sha256=HkNMgdQELiON42jdO-xDLmqrEKdGx1RVqrz2DXNTLS8,3239
 vellum_ee/workflows/display/nodes/vellum/note_node.py,sha256=TMb8txILu2uWjzoxaghjgjlzeBAgzn4vkP_8zSh2qoE,1151
 vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py,sha256=LFjLUrH6sJ4czPnExdRqFr0PB_yKBMLXLvK5GAzIAgc,3273
-vellum_ee/workflows/display/nodes/vellum/retry_node.py,sha256=-eH41LUcpUeZ8Jt5f40-e7bn2nymeKnsYsmuprVSo7g,5805
+vellum_ee/workflows/display/nodes/vellum/retry_node.py,sha256=LgokATi7sSS38Fil-XjqoR4t7AMOJ-GzXRw6p606Svo,3397
 vellum_ee/workflows/display/nodes/vellum/search_node.py,sha256=TxcAGZDl_hvJ7Y1hUi9YVEVrj9Ie0hKkASdpfRL4_cs,9227
 vellum_ee/workflows/display/nodes/vellum/subworkflow_deployment_node.py,sha256=62baAElKoRKIoba0lLhnrXGWWx96B73VxKGxh7BaIxc,2612
-vellum_ee/workflows/display/nodes/vellum/templating_node.py,sha256=JVIMPR3WpveOCWZubHKZkE04mavnTdb_9QY_r3XliRg,3424
+vellum_ee/workflows/display/nodes/vellum/templating_node.py,sha256=wP-ZAZq6ZmkS1fj0WkFtRkYqi8c6MWKLh4CEw8JD9mg,3207
 vellum_ee/workflows/display/nodes/vellum/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/nodes/vellum/tests/test_error_node.py,sha256=ulrpoYUW-5kIxfG4Lf5F2p0k_EoYKhmahEbF3P_eruM,1648
 vellum_ee/workflows/display/nodes/vellum/tests/test_prompt_node.py,sha256=bg9INsXiWfyK047u8TD1oEOFYrqDq8GC7Hvgz69n7BE,1988
 vellum_ee/workflows/display/nodes/vellum/tests/test_retry_node.py,sha256=NuIw8Yb42KUdoGi3Ur8_7VPg50IC4hNrwAkCociwqNk,2091
 vellum_ee/workflows/display/nodes/vellum/tests/test_try_node.py,sha256=mtzB8LJlFCHVFM4H5AanLp29gQfaVmnN4A4iaRGJHoI,2427
 vellum_ee/workflows/display/nodes/vellum/tests/test_utils.py,sha256=4YUaTeD_OWF-UaPMyOTBTu9skGC1jgSHlAYrzbH7Z04,5039
-vellum_ee/workflows/display/nodes/vellum/try_node.py,sha256=HBfGz4yt9GlmMW9JxzaCacPnHBDNIeXE8Jhqr9DqLLw,6191
+vellum_ee/workflows/display/nodes/vellum/try_node.py,sha256=0ipBZMYm521tuwefQFgHOvTyTgiWVTkzxpQtnnmOAI0,4203
 vellum_ee/workflows/display/nodes/vellum/utils.py,sha256=F_0BrlSszllK_BhryPbojIleLq2dGXOfQD1rVp3fNFg,4733
 vellum_ee/workflows/display/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum_ee/workflows/display/tests/test_vellum_workflow_display.py,sha256=cdpUoDNli8ULlNTrU6rnT4TZAIR8mzsG9ZbLrikPybU,8518
+vellum_ee/workflows/display/tests/test_vellum_workflow_display.py,sha256=VD-4USiRlCcdC3Qe9WfdkxwFdircai0vqvuZCbELR84,9556
 vellum_ee/workflows/display/tests/workflow_serialization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/conftest.py,sha256=A1-tIpC5KIKG9JA_rkd1nLS8zUG3Kb4QiVdvb3boFxE,2509
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_adornments_serialization.py,sha256=mFmxXfnUPrwndaBurW9E-VSBUQjF3cGv3JpRuNmwWh8,15475
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py,sha256=1cszL6N6FNGVm61MOa7AEiHnF0QjZWqDQuPOp4yiG94,18277
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_outputs_serialization.py,sha256=-12ZkZb3f5gyoNASV2yeQtMo5HmNsVEo8nXwL6IC-I8,6261
-vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_ports_serialization.py,sha256=6th6kCwzql6lddjkTQx4Jbvvs4ChqtJwctW-B4QuBhI,37352
+vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_ports_serialization.py,sha256=FD94h96w5wWYlLVC8_tqr2aUHPyO2UQh4f03jDX4re4,39783
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_trigger_serialization.py,sha256=EbVgg_3_ipTt3MOop4RARX0fmNjwqZtkhIXzx9nGw7Y,4487
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_api_node_serialization.py,sha256=IRazH2QR6F8RGqNemEnHueyj5DtEa6rFTYhT16S4jI8,15917
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_code_execution_node_serialization.py,sha256=V__y7uu-dy6TJjPeu4UDvaoO2yYwBRbPiW9uJdzWRx4,29828
@@ -87,12 +87,12 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_n
 vellum_ee/workflows/display/types.py,sha256=ixfmcQn51Rhsm4_0hWfG0_WpzLE89ZrDZpeYBklsP1Q,2592
 vellum_ee/workflows/display/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/utils/expressions.py,sha256=9FpOslDI-RCR5m4TgAu9KCHh4aTVnh7CHR2ykyMUDw0,1151
-vellum_ee/workflows/display/utils/vellum.py,sha256=UjK_RxnSEmlIu9klGCPWU5RAQBmgZ7cRbRdgxaTbubE,8081
+vellum_ee/workflows/display/utils/vellum.py,sha256=EVPQUSsZ3OIeLTEbV6LHPor37t9fnj9kJxDqP4PmTLQ,8234
 vellum_ee/workflows/display/vellum.py,sha256=7mqQaKZPPrLMcXSAQkPIxCy5x8HkKs5PbCu3GRaC2o8,8507
 vellum_ee/workflows/display/workflows/__init__.py,sha256=kapXsC67VJcgSuiBMa86FdePG5A9kMB5Pi4Uy1O2ob4,207
-vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=yDjMk2tml2TzitcFdP5M7PFXm4G_Bz6aYLYby7riXGQ,20137
+vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=QKMSmV--UoE8L7pYmKvZqtaatygrxmSm9PDSH71Yr0Y,19937
 vellum_ee/workflows/display/workflows/get_vellum_workflow_display_class.py,sha256=kp0u8LN_2IwshLrhMImhpZx1hRyAcD5gXY-kDuuaGMQ,1269
-vellum_ee/workflows/display/workflows/tests/test_workflow_display.py,sha256=JRTTM8gX182pBMP5eI_-B_X7LaK0kiSS07KqDdIfrQc,4962
+vellum_ee/workflows/display/workflows/tests/test_workflow_display.py,sha256=TzLziIh1fJ429LRUYoe88yd_HZflEQAw60TW8PAvvnk,6917
 vellum_ee/workflows/display/workflows/vellum_workflow_display.py,sha256=mbAzCpswOek34ITeTkesbVreCXpulj4NFjIg3RcdVZ8,18243
 vellum_ee/workflows/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/server/virtual_file_loader.py,sha256=X_DdNK7MfyOjKWekk6YQpOSCT6klKcdjT6nVJcBH1sM,1481
@@ -123,12 +123,12 @@ vellum/client/README.md,sha256=JkCJjmMZl4jrPj46pkmL9dpK4gSzQQmP5I7z4aME4LY,4749
 vellum/client/__init__.py,sha256=tKtdM1_GqmGq1gpi9ydWD_T-MM7fPn8QdHh8ww19cNI,117564
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=rm58d4E5Lrfg-SwnN1AtE5vFfVb1Qy6a5GyVyEmNWvU,1869
+vellum/client/core/client_wrapper.py,sha256=x6cZlx3EA5bHNlGRnX0klOVCrqkvqWv_oUW4xjYEehU,1869
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=X9IbmkZmB2bB_DpmZAO3crWdXagOakAyn6UCOCImCPg,2322
 vellum/client/core/http_client.py,sha256=R0pQpCppnEtxccGvXl4uJ76s7ro_65Fo_erlNNLp_AI,19228
 vellum/client/core/jsonable_encoder.py,sha256=qaF1gtgH-kQZb4kJskETwcCsOPUof-NnYVdszHkb-dM,3656
-vellum/client/core/pydantic_utilities.py,sha256=vPw05-aAxUB_jinMTmP7m8dAjRurZ8XqNZruXZdWORs,12056
+vellum/client/core/pydantic_utilities.py,sha256=6ev3gtER-hjlq7PcPL9XT_YSCdgyCE8ZKHJ9Uc-gHIg,12071
 vellum/client/core/query_encoder.py,sha256=ekulqNd0j8TgD7ox-Qbz7liqX8-KP9blvT9DsRCenYM,2144
 vellum/client/core/remove_none_from_dict.py,sha256=EU9SGgYidWq7SexuJbNs4-PZ-5Bl3Vppd864mS6vQZw,342
 vellum/client/core/request_options.py,sha256=5cCGt5AEGgtP5xifDl4oVQUmSjlIA8FmRItAlJawM18,1417
@@ -367,7 +367,7 @@ vellum/client/types/json_input.py,sha256=ZUA2O9YueBCx0IMMdB8uYNSWJiSDZxMm5ogwbwC
 vellum/client/types/json_input_request.py,sha256=x5sA-VXxF4QH-98xRcIKPZhsMVbnJNUQofiUQqyfGk4,768
 vellum/client/types/json_vellum_value.py,sha256=8irlw6NkRRVafysfTc1Q5BFFhRrWJYzdwrDYTdJK4JY,689
 vellum/client/types/json_vellum_value_request.py,sha256=IUlkdwFGgBeLl9sCmAJhoaxomWiEMpWgRcLa_WnlK8g,696
-vellum/client/types/logical_operator.py,sha256=3IJNJf8Esrq8-RzcgUJgeM6qns1RHdk01DG7gYs3Az8,596
+vellum/client/types/logical_operator.py,sha256=_3-gBnfsz4g5-sw5_ThRuS0NdNLQ2n2vV2Dl1RqbXe4,617
 vellum/client/types/logprobs_enum.py,sha256=D_458cZX2CAb6dX_ovrQ6HARlJkYcZRadKwsi1Cr-JM,151
 vellum/client/types/map_node_result.py,sha256=e2YqEP-aKig2TbbZIlfn5LCeVEVhEJJBR7o7xTBKXaY,752
 vellum/client/types/map_node_result_data.py,sha256=3xJXC1JrS9lo3-3_u1S79sYwLxMknNntDyspN24vQzY,699
@@ -720,7 +720,7 @@ vellum/evaluations/utils/exceptions.py,sha256=dXMAkzqbHV_AP5FjjbegPlfUE0zQDlpA3q
 vellum/evaluations/utils/paginator.py,sha256=rEED_BJAXAM6tM1yMwHePNzszjq_tTq4NbQvi1jWQ_Q,697
 vellum/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/plugins/pydantic.py,sha256=BMUwC4OkxtNf6hpLwb0T4MBUKgkGy55T_5Ww7GHpHYo,3068
-vellum/plugins/utils.py,sha256=U9ZY9KdE3RRvbcG01hXxu9CvfJD6Fo7nJDgcHjQn0FI,606
+vellum/plugins/utils.py,sha256=cPmxE9R2CK1bki2jKE8rB-G9zMf2pzHjSPDHFPXwd3Q,878
 vellum/plugins/vellum_mypy.py,sha256=QTuMSq6PiZW1dyTUZ5Bf1d4XkgFj0TKAgZLP8f4UgL4,27914
 vellum/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/prompts/blocks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1312,9 +1312,9 @@ vellum/workflows/environment/environment.py,sha256=0XhJPBs8YASWmvPx8bkSdCvcbDmzp
 vellum/workflows/errors/__init__.py,sha256=tWGPu5xyAU8gRb8_bl0fL7OfU3wxQ9UH6qVwy4X4P_Q,113
 vellum/workflows/errors/types.py,sha256=tVW7Il9zalnwWzdoDLqYPIvRTOhXIv6FPORZAbU7n5Q,3640
 vellum/workflows/events/__init__.py,sha256=6pxxceJo2dcaRkWtkDAYlUQZ-PHBQSZytIoyuUK48Qw,759
-vellum/workflows/events/node.py,sha256=uHT6If0esgZ3nLjrjmUPTKf3qbjGhoV_x5YKpjDBDcU,5280
+vellum/workflows/events/node.py,sha256=jbmNHjdp331Q1IRK-AWtAxwF6Lidb9R7__N5rQuilE8,5401
 vellum/workflows/events/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/events/tests/test_event.py,sha256=uRfMwSOqU-ROeZKCEngGvvJYlOZuxBhnC3qH5AGi3fM,15399
+vellum/workflows/events/tests/test_event.py,sha256=sHcKhZPDPtzZfTmehL4NORA_StR4M6nZDcx9kz3Avo0,16866
 vellum/workflows/events/types.py,sha256=AeTJaQt_fNHDLI4nyBzo7XrW9QQybRC09AKzu3kEYEE,3575
 vellum/workflows/events/workflow.py,sha256=QoSHyIOpuVacbR7POf7h104miTOhCjtO2udnYximJGs,6851
 vellum/workflows/exceptions.py,sha256=NiBiR3ggfmPxBVqD-H1SqmjI-7mIn0EStSN1BqApvCM,1213
@@ -1380,10 +1380,10 @@ vellum/workflows/nodes/core/map_node/tests/test_node.py,sha256=uMR0AyIFn539LqTKH
 vellum/workflows/nodes/core/retry_node/__init__.py,sha256=lN2bIy5a3Uzhs_FYCrooADyYU6ZGShtvLKFWpelwPvo,60
 vellum/workflows/nodes/core/retry_node/node.py,sha256=Vt3fx4G-DRIb9a-IHIUfaAclgfbzOPEQVkcumwhl9HE,4355
 vellum/workflows/nodes/core/retry_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/core/retry_node/tests/test_node.py,sha256=RM_OHwxrHwyxvlQQBJPqVBxpedFuWQ9h2-Xa3kP75sc,4399
+vellum/workflows/nodes/core/retry_node/tests/test_node.py,sha256=fNgDufkIsrTC-6ftvogqSpWhqqBj9iNESdfK19B1Yx0,5159
 vellum/workflows/nodes/core/templating_node/__init__.py,sha256=GmyuYo81_A1_Bz6id69ozVFS6FKiuDsZTiA3I6MaL2U,70
 vellum/workflows/nodes/core/templating_node/node.py,sha256=-JIqLUv6Xpx_LTVZt7whQ2X2VatgHDdTxjMrz64luEs,3721
-vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py,sha256=ldnmSASx0TfAnT3ZvU0AXtN0diZGrfySiXipuJIIzWU,9055
+vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py,sha256=MHofz-BwAgt7EXkab8VIyacYznDEIJ7Er7MJUaxNQQo,9614
 vellum/workflows/nodes/core/try_node/__init__.py,sha256=JVD4DrldTIqFQQFrubs9KtWCCc0YCAc7Fzol5ZWIWeM,56
 vellum/workflows/nodes/core/try_node/node.py,sha256=5ux1l2HO12FBFFyhz6j-4yfBYVrqgT2maTAne_GnNDk,4434
 vellum/workflows/nodes/core/try_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1392,10 +1392,10 @@ vellum/workflows/nodes/displayable/__init__.py,sha256=6F_4DlSwvHuilWnIalp8iDjjDX
 vellum/workflows/nodes/displayable/api_node/__init__.py,sha256=MoxdQSnidIj1Nf_d-hTxlOxcZXaZnsWFDbE-PkTK24o,56
 vellum/workflows/nodes/displayable/api_node/node.py,sha256=QdpsyGVxo5PcN8nwGZpcpW_YMKHr3_VvmbK1BlrdOFk,2547
 vellum/workflows/nodes/displayable/api_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py,sha256=RtQWnFfq0HNqY2A6c5SdwHl8A91K4Vq8un5UJwwnkSw,2180
+vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py,sha256=fiskhfcI4c6CxFlbSWb1JKsuq-98zAeUWOExc848ALw,3130
 vellum/workflows/nodes/displayable/bases/__init__.py,sha256=0mWIx3qUrzllV7jqt7wN03vWGMuI1WrrLZeMLT2Cl2c,304
 vellum/workflows/nodes/displayable/bases/api_node/__init__.py,sha256=1jwx4WC358CLA1jgzl_UD-rZmdMm2v9Mps39ndwCD7U,64
-vellum/workflows/nodes/displayable/bases/api_node/node.py,sha256=-LOKjU_rY1UWgD0DS5LJwAClBI8N7zrdmwigE3y5rhc,4000
+vellum/workflows/nodes/displayable/bases/api_node/node.py,sha256=Ev_So7D_4Qfvl2_E8veVfxAxWfbJIA2ujyW5istLg5I,4066
 vellum/workflows/nodes/displayable/bases/base_prompt_node/__init__.py,sha256=Org3xTvgp1pA0uUXFfnJr29D3HzCey2lEdYF4zbIUgo,70
 vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=nvhoWb8EyRlgtyotYp-wh194n30yQP81UnOH_a8FghY,3140
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/__init__.py,sha256=Hl35IAoepRpE-j4cALaXVJIYTYOF3qszyVbxTj4kS1s,82
@@ -1453,7 +1453,8 @@ vellum/workflows/nodes/experimental/openai_chat_completion_node/node.py,sha256=1
 vellum/workflows/nodes/mocks.py,sha256=a1FjWEIocseMfjzM-i8DNozpUsaW0IONRpZmXBoWlyc,10455
 vellum/workflows/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/tests/test_mocks.py,sha256=mfPvrs75PKcsNsbJLQAN6PDFoVqs9TmQxpdyFKDdO60,7837
-vellum/workflows/nodes/utils.py,sha256=uaTPGYp4utenz_QDghqQ23Q1iCsGHQ40nNZh1g9H9WI,7117
+vellum/workflows/nodes/tests/test_utils.py,sha256=7PtdV_fzl56agx0IDitdqOmqUO9cQZmJww-3ToxzSqA,4174
+vellum/workflows/nodes/utils.py,sha256=b-U8xjUpGswaoEiav5tU_OFKB26GkYFzuko9XCMU_Fo,7627
 vellum/workflows/outputs/__init__.py,sha256=AyZ4pRh_ACQIGvkf0byJO46EDnSix1ZCAXfvh-ms1QE,94
 vellum/workflows/outputs/base.py,sha256=b4Dnha1miKu3uFJYptKKflIHNuajPF2BNKy0BTt8Tjc,8622
 vellum/workflows/ports/__init__.py,sha256=bZuMt-R7z5bKwpu4uPW7LlJeePOQWmCcDSXe5frUY5g,101
@@ -1475,7 +1476,7 @@ vellum/workflows/references/workflow_input.py,sha256=86IuhlBz-9cGxeUzizyjdp482aj
 vellum/workflows/resolvers/__init__.py,sha256=eH6hTvZO4IciDaf_cf7aM2vs-DkBDyJPycOQevJxQnI,82
 vellum/workflows/resolvers/base.py,sha256=WHra9LRtlTuB1jmuNqkfVE2JUgB61Cyntn8f0b0WZg4,411
 vellum/workflows/runner/__init__.py,sha256=i1iG5sAhtpdsrlvwgH6B-m49JsINkiWyPWs8vyT-bqM,72
-vellum/workflows/runner/runner.py,sha256=_p19T1woplSxZGabZuSUFBKSYBrXADrM7b_1YnWVN3g,31013
+vellum/workflows/runner/runner.py,sha256=fS21u0LIyhxT4T6YQPgonVuH8X8TgD5BrsbVxPUWfuM,31071
 vellum/workflows/sandbox.py,sha256=GVJzVjMuYzOBnSrboB0_6MMRZWBluAyQ2o7syeaeBd0,2235
 vellum/workflows/state/__init__.py,sha256=yUUdR-_Vl7UiixNDYQZ-GEM_kJI9dnOia75TtuNEsnE,60
 vellum/workflows/state/base.py,sha256=Vkhneko3VlQrPsMLU1PYSzXU_W1u7_AraJsghiv5O-4,15512
@@ -1511,8 +1512,8 @@ vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnad
 vellum/workflows/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/workflows/tests/test_base_workflow.py,sha256=NRteiICyJvDM5zrtUfq2fZoXcGQVaWC9xmNlLLVW0cU,7979
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-0.14.13.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.13.dist-info/METADATA,sha256=y44fYKH3DaYDbx8hhtZFAtWbGESUBWDUV-2W_JL-XiI,5408
-vellum_ai-0.14.13.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.13.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.13.dist-info/RECORD,,
+vellum_ai-0.14.15.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.15.dist-info/METADATA,sha256=8TM16vJdsQpUXVDgasscuRmbLESHxIgmMj8QlKoLUQU,5408
+vellum_ai-0.14.15.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.15.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.15.dist-info/RECORD,,

vellum_ee/workflows/display/nodes/base_node_display.py

@@ -4,6 +4,7 @@ from uuid import UUID
 from typing import (
     TYPE_CHECKING,
     Any,
+    ClassVar,
     Dict,
     ForwardRef,
     Generic,
@@ -59,17 +60,20 @@ _NodeDisplayAttrType = TypeVar("_NodeDisplayAttrType")
 class BaseNodeDisplayMeta(type):
     def __new__(mcs, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
         cls = super().__new__(mcs, name, bases, dct)
+        return cls.__annotate_node__()
+
+    def __annotate_node__(cls):
         base_node_display_class = cast(Type["BaseNodeDisplay"], cls)
         node_class = base_node_display_class.infer_node_class()
         if not issubclass(node_class, BaseNode):
             return cls
 
-        display_node_id = dct.get("node_id")
+        display_node_id = getattr(cls, "node_id", None)
         if isinstance(display_node_id, UUID):
             # Display classes are able to override the id of the node class it's parameterized by
             node_class.__id__ = display_node_id
 
-        output_display = dct.get("output_display")
+        output_display = getattr(cls, "output_display", None)
         if isinstance(output_display, dict):
             # And the node class' output ids
             for reference, node_output_display in output_display.items():
@@ -86,6 +90,7 @@ class BaseNodeDisplayMeta(type):
 class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
     output_display: Dict[OutputReference, NodeOutputDisplay] = {}
     port_displays: Dict[Port, PortDisplayOverrides] = {}
+    node_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
 
     # Used to store the mapping between node types and their display classes
     _node_display_registry: Dict[Type[NodeType], Type["BaseNodeDisplay"]] = {}
@@ -326,6 +331,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 IsNotNilExpression,
                 IsUndefinedExpression,
                 IsNotUndefinedExpression,
+                ParseJsonExpression,
             ),
         ):
             lhs = self.serialize_value(display_context, condition._expression)
@@ -403,9 +409,6 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 "node_id": str(node_class_display.node_id),
             }
 
-        if isinstance(value, ParseJsonExpression):
-            raise ValueError("ParseJsonExpression is not supported in the UI")
-
         if not isinstance(value, BaseDescriptor):
             vellum_value = primitive_to_vellum_value(value)
             return {

vellum_ee/workflows/display/nodes/base_node_vellum_display.py

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import ClassVar, Dict, Optional, Union
+from typing import ClassVar, Dict, Optional
 
 from vellum.workflows.nodes.utils import get_unadorned_node
 from vellum.workflows.ports import Port
@@ -17,9 +17,6 @@ class BaseNodeVellumDisplay(BaseNodeDisplay[NodeType]):
     # Used to explicitly set the target handle id for a node
     target_handle_id: ClassVar[Optional[UUID]] = None
 
-    # Used to explicitly set the node input ids by name for a node
-    node_input_ids_by_name: ClassVar[Dict[str, Union[UUID, str]]] = {}
-
     def _get_node_display_uuid(self, attribute: str) -> UUID:
         explicit_value = self._get_explicit_node_display_attr(attribute, UUID)
         return explicit_value if explicit_value else uuid4_from_hash(f"{self.node_id}|{attribute}")

vellum_ee/workflows/display/nodes/get_node_display_class.py

@@ -1,7 +1,10 @@
 import types
-from typing import TYPE_CHECKING, Optional, Type
+from uuid import UUID
+from typing import TYPE_CHECKING, Any, Dict, Optional, Type
 
+from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.types.generics import NodeType
+from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
 
 if TYPE_CHECKING:
@@ -26,16 +29,39 @@ def get_node_display_class(
 
     # `base_node_display_class` is always a Generic class, so it's safe to index into it
     NodeDisplayBaseClass = base_node_display_class[node_class]  # type: ignore[index]
+
+    def _get_node_input_ids_by_ref(path: str, inst: Any):
+        if isinstance(inst, dict):
+            node_input_ids_by_name: Dict[str, UUID] = {}
+            for key, value in inst.items():
+                node_input_ids_by_name.update(_get_node_input_ids_by_ref(f"{path}.{key}", value))
+            return node_input_ids_by_name
+
+        if isinstance(inst, BaseDescriptor):
+            return {path: uuid4_from_hash(f"{node_class.__id__}|{path}")}
+
+        return {}
+
+    def exec_body(ns: Dict):
+        output_display = {
+            ref: NodeOutputDisplay(id=node_class.__output_ids__[ref.name], name=ref.name)
+            for ref in node_class.Outputs
+            if ref.name in node_class.__output_ids__
+        }
+        if output_display:
+            ns["output_display"] = output_display
+
+        node_input_ids_by_name: Dict[str, UUID] = {}
+        for ref in node_class:
+            node_input_ids_by_name.update(_get_node_input_ids_by_ref(ref.name, ref.instance))
+
+        if node_input_ids_by_name:
+            ns["node_input_ids_by_name"] = node_input_ids_by_name
+
     NodeDisplayClass = types.new_class(
         f"{node_class.__name__}Display",
         bases=(NodeDisplayBaseClass,),
+        exec_body=exec_body,
     )
-    output_display = {
-        ref: NodeOutputDisplay(id=node_class.__output_ids__[ref.name], name=ref.name)
-        for ref in node_class.Outputs
-        if ref.name in node_class.__output_ids__
-    }
-    if output_display:
-        setattr(NodeDisplayClass, "output_display", output_display)
 
     return NodeDisplayClass

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

@@ -1,9 +1,14 @@
+import re
+import types
 from uuid import UUID
-from typing import Any, Callable, Generic, Optional, TypeVar, cast
+from typing import Any, Callable, Dict, Generic, Optional, Type, TypeVar, cast
 
+from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
 from vellum.workflows.nodes.utils import get_wrapped_node
 from vellum.workflows.types.core import JsonArray, JsonObject
+from vellum.workflows.types.utils import get_original_base
+from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
@@ -37,3 +42,52 @@ class BaseAdornmentNodeDisplay(BaseNodeVellumDisplay[_BaseAdornmentNodeType], Ge
         serialized_wrapped_node["adornments"] = adornments + [adornment] if adornment else adornments
 
         return serialized_wrapped_node
+
+    @classmethod
+    def wrap(cls, **kwargs: Any) -> Callable[..., Type[BaseNodeDisplay]]:
+        NodeDisplayType = TypeVar("NodeDisplayType", bound=BaseNodeDisplay)
+
+        def decorator(inner_cls: Type[NodeDisplayType]) -> Type[NodeDisplayType]:
+            node_class = inner_cls.infer_node_class()
+            wrapped_node_class = cast(Type[BaseNode], node_class.__wrapped_node__)
+
+            # `mypy` is wrong here, `cls` is indexable bc it's Generic
+            BaseAdornmentDisplay = cls[node_class]  # type: ignore[index]
+
+            def exec_body(ns: Dict):
+                for key, kwarg in kwargs.items():
+                    ns[key] = kwarg
+
+                if "node_id" not in kwargs:
+                    ns["node_id"] = uuid4_from_hash(node_class.__qualname__)
+
+            AdornmentDisplay = types.new_class(
+                re.sub(r"^Base", "", cls.__name__), bases=(BaseAdornmentDisplay,), exec_body=exec_body
+            )
+
+            setattr(inner_cls, "__adorned_by__", AdornmentDisplay)
+
+            # We must edit the node display class to use __wrapped_node__ everywhere it
+            # references the adorned node class, which is three places:
+
+            # 1. The node display class' parameterized type
+            original_base_node_display = get_original_base(inner_cls)
+            original_base_node_display.__args__ = (wrapped_node_class,)
+            inner_cls._node_display_registry[wrapped_node_class] = inner_cls
+            inner_cls.__annotate_node__()
+
+            # 2. The node display class' output displays
+            old_outputs = list(inner_cls.output_display.keys())
+            for old_output in old_outputs:
+                new_output = getattr(wrapped_node_class.Outputs, old_output.name)
+                inner_cls.output_display[new_output] = inner_cls.output_display.pop(old_output)
+
+            # 3. The node display class' port displays
+            old_ports = list(inner_cls.port_displays.keys())
+            for old_port in old_ports:
+                new_port = getattr(wrapped_node_class.Ports, old_port.name)
+                inner_cls.port_displays[new_port] = inner_cls.port_displays.pop(old_port)
+
+            return inner_cls
+
+        return decorator

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

@@ -1,14 +1,12 @@
 import inspect
-from typing import Any, Callable, Generic, Optional, Tuple, Type, TypeVar, cast
+from typing import Any, Generic, Tuple, Type, TypeVar, cast
 
 from vellum.workflows.descriptors.base import BaseDescriptor
-from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.retry_node.node import RetryNode
 from vellum.workflows.nodes.utils import ADORNMENT_MODULE_NAME
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
-from vellum.workflows.types.utils import get_original_base
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
@@ -79,54 +77,3 @@ class BaseRetryNodeDisplay(BaseAdornmentNodeDisplay[_RetryNodeType], Generic[_Re
 
         inner_output = getattr(inner_node.Outputs, output.name)
         return node_display.get_node_output_display(inner_output)
-
-    @classmethod
-    def wrap(
-        cls,
-        max_attempts: int,
-        delay: Optional[float] = None,
-        retry_on_error_code: Optional[WorkflowErrorCode] = None,
-        retry_on_condition: Optional[BaseDescriptor] = None,
-    ) -> Callable[..., Type["BaseRetryNodeDisplay"]]:
-        _max_attempts = max_attempts
-        _delay = delay
-        _retry_on_error_code = retry_on_error_code
-        _retry_on_condition = retry_on_condition
-
-        NodeDisplayType = TypeVar("NodeDisplayType", bound=BaseNodeDisplay)
-
-        def decorator(inner_cls: Type[NodeDisplayType]) -> Type[NodeDisplayType]:
-            node_class = inner_cls.infer_node_class()
-            wrapped_node_class = cast(Type[BaseNode], node_class.__wrapped_node__)
-
-            class RetryNodeDisplay(BaseRetryNodeDisplay[node_class]):  # type: ignore[valid-type]
-                max_attempts = _max_attempts
-                delay = _delay
-                retry_on_error_code = _retry_on_error_code
-                retry_on_condition = _retry_on_condition
-
-            setattr(inner_cls, "__adorned_by__", RetryNodeDisplay)
-
-            # We must edit the node display class to use __wrapped_node__ everywhere it
-            # references the adorned node class, which is three places:
-
-            # 1. The node display class' parameterized type
-            original_base_node_display = get_original_base(inner_cls)
-            original_base_node_display.__args__ = (wrapped_node_class,)
-            inner_cls._node_display_registry[wrapped_node_class] = inner_cls
-
-            # 2. The node display class' output displays
-            old_outputs = list(inner_cls.output_display.keys())
-            for old_output in old_outputs:
-                new_output = getattr(wrapped_node_class.Outputs, old_output.name)
-                inner_cls.output_display[new_output] = inner_cls.output_display.pop(old_output)
-
-            # 3. The node display class' port displays
-            old_ports = list(inner_cls.port_displays.keys())
-            for old_port in old_ports:
-                new_port = getattr(wrapped_node_class.Ports, old_port.name)
-                inner_cls.port_displays[new_port] = inner_cls.port_displays.pop(old_port)
-
-            return inner_cls
-
-        return decorator

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

@@ -23,14 +23,7 @@ class BaseTemplatingNodeDisplay(BaseNodeVellumDisplay[_TemplatingNodeType], Gene
         node = self._node
         node_id = self.node_id
 
-        template_input_id = self.template_input_id or next(
-            (
-                UUID(input_id) if isinstance(input_id, str) else input_id
-                for input_name, input_id in self.node_input_ids_by_name.items()
-                if input_name == TEMPLATE_INPUT_NAME
-            ),
-            None,
-        )
+        template_input_id = self.template_input_id or self.node_input_ids_by_name.get(TEMPLATE_INPUT_NAME)
 
         template_node_input = create_node_input(
             node_id=node_id,

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

@@ -1,6 +1,6 @@
 import inspect
 from uuid import UUID
-from typing import Any, Callable, ClassVar, Generic, Optional, Tuple, Type, TypeVar, cast
+from typing import Any, ClassVar, Generic, Optional, Tuple, Type, TypeVar, cast
 
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.nodes.bases.base import BaseNode
@@ -8,7 +8,6 @@ from vellum.workflows.nodes.core.try_node.node import TryNode
 from vellum.workflows.nodes.utils import ADORNMENT_MODULE_NAME
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
-from vellum.workflows.types.utils import get_original_base
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
@@ -93,43 +92,3 @@ class BaseTryNodeDisplay(BaseAdornmentNodeDisplay[_TryNodeType], Generic[_TryNod
 
         inner_output = getattr(inner_node.Outputs, output.name)
         return node_display.get_node_output_display(inner_output)
-
-    @classmethod
-    def wrap(cls, error_output_id: Optional[UUID] = None) -> Callable[..., Type["BaseTryNodeDisplay"]]:
-        _error_output_id = error_output_id
-
-        NodeDisplayType = TypeVar("NodeDisplayType", bound=BaseNodeDisplay)
-
-        def decorator(inner_cls: Type[NodeDisplayType]) -> Type[NodeDisplayType]:
-            node_class = inner_cls.infer_node_class()
-            wrapped_node_class = cast(Type[BaseNode], node_class.__wrapped_node__)
-
-            # Mypy gets mad about dynamic parameter types like this, but it's fine
-            class TryNodeDisplay(BaseTryNodeDisplay[node_class]):  # type: ignore[valid-type]
-                error_output_id = _error_output_id
-
-            setattr(inner_cls, "__adorned_by__", TryNodeDisplay)
-
-            # We must edit the node display class to use __wrapped_node__ everywhere it
-            # references the adorned node class, which is three places:
-
-            # 1. The node display class' parameterized type
-            original_base_node_display = get_original_base(inner_cls)
-            original_base_node_display.__args__ = (wrapped_node_class,)
-            inner_cls._node_display_registry[wrapped_node_class] = inner_cls
-
-            # 2. The node display class' output displays
-            old_outputs = list(inner_cls.output_display.keys())
-            for old_output in old_outputs:
-                new_output = getattr(wrapped_node_class.Outputs, old_output.name)
-                inner_cls.output_display[new_output] = inner_cls.output_display.pop(old_output)
-
-            # 3. The node display class' port displays
-            old_ports = list(inner_cls.port_displays.keys())
-            for old_port in old_ports:
-                new_port = getattr(wrapped_node_class.Ports, old_port.name)
-                inner_cls.port_displays[new_port] = inner_cls.port_displays.pop(old_port)
-
-            return inner_cls
-
-        return decorator

vellum_ee/workflows/display/tests/test_vellum_workflow_display.py

@@ -1,4 +1,3 @@
-import pytest
 from uuid import UUID
 from typing import Dict
 
@@ -231,11 +230,7 @@ def test_vellum_workflow_display__serialize_with_unused_nodes_and_edges():
     assert edge_found, "Edge between unused nodes NodeB and NodeC not found in serialized output"
 
 
-def test_parse_json_not_supported_in_ui():
-    """
-    Test that verifies ParseJsonExpression is not yet supported in the UI.
-    This test should fail once UI support is added, at which point it should be updated.
-    """
+def test_vellum_workflow_display__serialize_with_parse_json_expression():
     # GIVEN a workflow that uses the parse_json function
     from vellum.workflows.references.constant import ConstantValueReference
 
@@ -249,13 +244,55 @@ def test_parse_json_not_supported_in_ui():
         class Outputs(BaseWorkflow.Outputs):
             final = JsonNode.Outputs.json_result
 
-    # WHEN we attempt to serialize it
+    # AND a display class for this workflow
     workflow_display = get_workflow_display(
         base_display_class=VellumWorkflowDisplay,
         workflow_class=Workflow,
     )
 
-    with pytest.raises(ValueError) as exc_info:
-        workflow_display.serialize()
+    # WHEN we serialize the workflow
+    exec_config = workflow_display.serialize()
+
+    # THEN the serialized workflow contains the parse_json expression
+    raw_data = exec_config["workflow_raw_data"]
+    assert isinstance(raw_data, dict)
 
-    assert "ParseJsonExpression is not supported in the UI" == str(exc_info.value)
+    nodes = raw_data["nodes"]
+    assert isinstance(nodes, list)
+
+    json_node = None
+    for node in nodes:
+        assert isinstance(node, dict)
+        definition = node.get("definition")
+        if node.get("type") == "GENERIC" and isinstance(definition, dict) and definition.get("name") == "JsonNode":
+            json_node = node
+            break
+
+    assert json_node is not None
+
+    outputs = json_node.get("outputs", [])
+    assert isinstance(outputs, list)
+
+    json_result = None
+    for output in outputs:
+        assert isinstance(output, dict)
+        if output.get("name") == "json_result":
+            json_result = output
+            break
+
+    assert json_result == {
+        "id": "44c7d94c-a76a-4151-9b95-85a31764f18f",
+        "name": "json_result",
+        "type": "JSON",
+        "value": {
+            "type": "UNARY_EXPRESSION",
+            "lhs": {
+                "type": "CONSTANT_VALUE",
+                "value": {
+                    "type": "STRING",
+                    "value": '{"key": "value"}',
+                },
+            },
+            "operator": "parseJson",
+        },
+    }

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

@@ -1003,3 +1003,70 @@ def test_serialize_node__or_then_and(serialize_node):
         serialized_node,
         ignore_order=True,
     )
+
+
+class ParseJsonGenericNode(BaseNode):
+    class Ports(BaseNode.Ports):
+        if_branch = Port.on_if(Inputs.input.parse_json().equals({"key": "value"}))
+
+
+def test_serialize_node__parse_json(serialize_node):
+    input_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=ParseJsonGenericNode,
+        global_workflow_input_displays={Inputs.input: WorkflowInputsDisplay(id=input_id)},
+    )
+
+    assert not DeepDiff(
+        {
+            "id": "60edd9b2-9bad-470f-832c-c5f1aa9a253e",
+            "label": "ParseJsonGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "ParseJsonGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_ports_serialization",
+                ],
+            },
+            "trigger": {"id": "0ccc19cb-174b-440b-8d08-6c84c571fb8f", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [
+                {
+                    "id": "abe1e6db-14df-4d3c-b059-d17933ab8c02",
+                    "type": "IF",
+                    "name": "if_branch",
+                    "expression": {
+                        "type": "BINARY_EXPRESSION",
+                        "lhs": {
+                            "type": "UNARY_EXPRESSION",
+                            "lhs": {
+                                "type": "WORKFLOW_INPUT",
+                                "input_variable_id": str(input_id),
+                            },
+                            "operator": "parseJson",
+                        },
+                        "operator": "=",
+                        "rhs": {
+                            "type": "CONSTANT_VALUE",
+                            "value": {
+                                "type": "JSON",
+                                "value": {"key": "value"},
+                            },
+                        },
+                    },
+                }
+            ],
+            "adornments": None,
+            "attributes": [],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )

vellum_ee/workflows/display/utils/vellum.py

@@ -28,6 +28,7 @@ from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualTo
 from vellum.workflows.expressions.not_between import NotBetweenExpression
 from vellum.workflows.expressions.not_in import NotInExpression
 from vellum.workflows.expressions.or_ import OrExpression
+from vellum.workflows.expressions.parse_json import ParseJsonExpression
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.references import OutputReference, WorkflowInputReference
@@ -163,5 +164,7 @@ def convert_descriptor_to_operator(descriptor: BaseDescriptor) -> LogicalOperato
         return "or"
     elif isinstance(descriptor, CoalesceExpression):
         return "coalesce"
+    elif isinstance(descriptor, ParseJsonExpression):
+        return "parseJson"
     else:
         raise ValueError(f"Unsupported descriptor type: {descriptor}")

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -212,8 +212,6 @@ class BaseWorkflowDisplay(
 
         port_displays: Dict[Port, PortDisplay] = {}
 
-        # TODO: We should still serialize nodes that are in the workflow's directory but aren't used in the graph.
-        # https://app.shortcut.com/vellum/story/5394
         for node in self._workflow.get_nodes():
             extracted_node_displays = self._extract_node_displays(node)
 
@@ -403,11 +401,11 @@ class BaseWorkflowDisplay(
             for input in display_context.workflow_input_displays
         }
         node_displays = {
-            str(node.__id__): display_context.node_displays[node] for node in display_context.node_displays
+            node.__id__: (node, display_context.node_displays[node]) for node in display_context.node_displays
         }
         node_event_displays = {}
         for node_id in node_displays:
-            current_node_display = node_displays[node_id]
+            node, current_node_display = node_displays[node_id]
             input_display = {}
             if isinstance(current_node_display, BaseNodeVellumDisplay):
                 input_display = current_node_display.node_input_ids_by_name
@@ -418,7 +416,6 @@ class BaseWorkflowDisplay(
             port_display_meta = {
                 port.name: current_node_display.port_displays[port].id for port in current_node_display.port_displays
             }
-            node = current_node_display._node
             subworkflow_display_context: Optional[WorkflowEventDisplayContext] = None
             if hasattr(node, "subworkflow"):
                 # All nodes that have a subworkflow attribute are currently expected to call them `subworkflow`
@@ -432,7 +429,7 @@ class BaseWorkflowDisplay(
                     )
                     subworkflow_display_context = subworkflow_display.get_event_display_context()
 
-            node_event_displays[node_id] = NodeEventDisplayContext(
+            node_event_displays[str(node_id)] = NodeEventDisplayContext(
                 input_display=input_display,
                 output_display=output_display,
                 port_display=port_display_meta,

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

@@ -1,9 +1,13 @@
 import pytest
+from uuid import uuid4
 
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
+from vellum.workflows.nodes.core.retry_node.node import RetryNode
+from vellum.workflows.nodes.core.templating_node.node import TemplatingNode
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.nodes import BaseNodeDisplay
+from vellum_ee.workflows.display.nodes.vellum.retry_node import BaseRetryNodeDisplay
 from vellum_ee.workflows.display.vellum import NodeDisplayData, NodeDisplayPosition
 from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
@@ -139,3 +143,51 @@ def test_get_event_display_context__node_display_to_include_subworkflow_display(
 
     assert node_event_display.subworkflow_display is not None
     assert str(InnerNode.__id__) in node_event_display.subworkflow_display.node_displays
+
+
+def test_get_event_display_context__node_display_for_adornment_nodes():
+    # GIVEN a simple workflow with a retry node adornment
+    @RetryNode.wrap(max_attempts=4)
+    class MyNode(BaseNode):
+        pass
+
+    class MyWorkflow(BaseWorkflow):
+        graph = MyNode
+
+    # AND a display class for the node
+    inner_node_id = uuid4()
+
+    @BaseRetryNodeDisplay.wrap()
+    class MyNodeDisplay(BaseNodeDisplay[MyNode]):
+        node_id = inner_node_id
+
+    # WHEN we gather the event display context
+    display_context = VellumWorkflowDisplay(MyWorkflow).get_event_display_context()
+
+    # THEN the subworkflow display should be included
+    assert str(MyNode.__id__) in display_context.node_displays
+    node_event_display = display_context.node_displays[str(MyNode.__id__)]
+    assert node_event_display.subworkflow_display is not None
+    assert str(inner_node_id) in node_event_display.subworkflow_display.node_displays
+
+
+def test_get_event_display_context__templating_node_input_display():
+    # GIVEN a simple workflow with a templating node referencing another node output
+    class DataNode(BaseNode):
+        class Outputs:
+            bar: str
+
+    class MyNode(TemplatingNode):
+        inputs = {"foo": DataNode.Outputs.bar}
+
+    class MyWorkflow(BaseWorkflow):
+        graph = DataNode >> MyNode
+
+    # WHEN we gather the event display context
+    display_context = VellumWorkflowDisplay(MyWorkflow).get_event_display_context()
+
+    # THEN the subworkflow display should be included
+    assert str(MyNode.__id__) in display_context.node_displays
+    node_event_display = display_context.node_displays[str(MyNode.__id__)]
+
+    assert node_event_display.input_display.keys() == {"inputs.foo"}