vellum-ai 0.14.4__py3-none-any.whl → 0.14.5__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.4",
+            "X-Fern-SDK-Version": "0.14.5",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/workflows/context.py

@@ -1,5 +1,6 @@
 from contextlib import contextmanager
 import threading
+from uuid import UUID
 from typing import Iterator, Optional, cast
 
 from vellum.client.core import UniversalBaseModel
@@ -8,6 +9,7 @@ from vellum.workflows.events.types import ParentContext
 
 class ExecutionContext(UniversalBaseModel):
     parent_context: Optional[ParentContext] = None
+    trace_id: Optional[UUID] = None
 
 
 _CONTEXT_KEY = "_execution_context"
@@ -30,11 +32,14 @@ def get_parent_context() -> ParentContext:
 
 
 @contextmanager
-def execution_context(parent_context: Optional[ParentContext] = None) -> Iterator[None]:
+def execution_context(
+    parent_context: Optional[ParentContext] = None, trace_id: Optional[UUID] = None
+) -> Iterator[None]:
     """Context manager for handling execution context."""
     prev_context = get_execution_context()
-    set_context = ExecutionContext(parent_context=parent_context) if parent_context else prev_context
-
+    set_trace_id = prev_context.trace_id or trace_id
+    set_parent_context = parent_context or prev_context.parent_context
+    set_context = ExecutionContext(parent_context=set_parent_context, trace_id=set_trace_id)
     try:
         set_execution_context(set_context)
         yield

vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py

@@ -1,12 +1,16 @@
 import pytest
 import os
-from typing import Any, Union
+from typing import Any, List, Union
+
+from pydantic import BaseModel
 
 from vellum import CodeExecutorResponse, NumberVellumValue, StringInput, StringVellumValue
+from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.code_execution_package import CodeExecutionPackage
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
 from vellum.client.types.function_call import FunctionCall
 from vellum.client.types.number_input import NumberInput
+from vellum.client.types.string_chat_message_content import StringChatMessageContent
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
@@ -610,3 +614,79 @@ def main(arg1: list[bool]) -> int:
 
     # AND the error should contain the execution error details
     assert outputs == {"result": 3, "log": ""}
+
+
+def test_run_node__union_output_type__pydantic_children():
+    # GIVEN a node that is a union type with a pydantic child
+    class OptionOne(BaseModel):
+        foo: str
+
+    class OptionTwo(BaseModel):
+        bar: int
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, Union[OptionOne, OptionTwo]]):
+        code = """\
+def main():
+    return { "foo": "hello" }
+"""
+        runtime = "PYTHON_3_11_6"
+        code_inputs = {}
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+
+    # THEN it should run successfully
+    outputs = node.run()
+
+    # AND the result should be the correct type
+    assert outputs == {"result": OptionOne(foo="hello"), "log": ""}
+
+
+def test_run_node__union_output_type__miss():
+    # GIVEN a node that is a union type
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, Union[int, float]]):
+        code = """\
+def main():
+    return "hello"
+"""
+        runtime = "PYTHON_3_11_6"
+        code_inputs = {}
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+
+    # THEN it should raise a NodeException with the execution error
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # AND the error should contain the execution error details
+    assert exc_info.value.message == "Expected an output of type 'int | float', but received 'str'"
+
+
+def test_run_node__chat_history_output_type():
+    # GIVEN a node that that has a chat history return type
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, List[ChatMessage]]):
+        code = """\
+def main():
+    return [
+        {
+            "role": "USER",
+            "content": {
+                "type": "STRING",
+                "value": "Hello, world!",
+            }
+        }
+    ]
+"""
+        code_inputs = {}
+        runtime = "PYTHON_3_11_6"
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # AND the error should contain the execution error details
+    assert outputs == {
+        "result": [ChatMessage(role="USER", content=StringChatMessageContent(value="Hello, world!"))],
+        "log": "",
+    }

vellum/workflows/nodes/displayable/code_execution_node/utils.py

@@ -67,6 +67,49 @@ def _clean_for_dict_wrapper(obj):
     return obj
 
 
+def _get_type_name(obj: Any) -> str:
+    if isinstance(obj, type):
+        return obj.__name__
+
+    if get_origin(obj) is Union:
+        children = [_get_type_name(child) for child in get_args(obj)]
+        return " | ".join(children)
+
+    return str(obj)
+
+
+def _cast_to_output_type(result: Any, output_type: Any) -> Any:
+    is_valid_output_type = isinstance(output_type, type)
+    if get_origin(output_type) is Union:
+        allowed_types = get_args(output_type)
+        for allowed_type in allowed_types:
+            try:
+                return _cast_to_output_type(result, allowed_type)
+            except NodeException:
+                continue
+    elif get_origin(output_type) is list:
+        allowed_item_type = get_args(output_type)[0]
+        if isinstance(result, list):
+            return [_cast_to_output_type(item, allowed_item_type) for item in result]
+    elif is_valid_output_type and issubclass(output_type, BaseModel) and not isinstance(result, output_type):
+        try:
+            return output_type.model_validate(result)
+        except ValidationError as e:
+            raise NodeException(
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+                message=re.sub(r"\s+For further information visit [^\s]+", "", str(e)),
+            ) from e
+    elif is_valid_output_type and isinstance(result, output_type):
+        return result
+
+    output_type_name = _get_type_name(output_type)
+    result_type_name = _get_type_name(type(result))
+    raise NodeException(
+        code=WorkflowErrorCode.INVALID_OUTPUTS,
+        message=f"Expected an output of type '{output_type_name}', but received '{result_type_name}'",
+    )
+
+
 def run_code_inline(
     code: str,
     inputs: EntityInputsInterface,
@@ -112,25 +155,6 @@ __arg__out = main({", ".join(run_args)})
     result = exec_globals["__arg__out"]
 
     if output_type != Any:
-        if get_origin(output_type) is Union:
-            allowed_types = get_args(output_type)
-            if not isinstance(result, allowed_types):
-                raise NodeException(
-                    code=WorkflowErrorCode.INVALID_OUTPUTS,
-                    message=f"Expected output to be in types {allowed_types}, but received '{type(result).__name__}'",
-                )
-        elif issubclass(output_type, BaseModel) and not isinstance(result, output_type):
-            try:
-                result = output_type.model_validate(result)
-            except ValidationError as e:
-                raise NodeException(
-                    code=WorkflowErrorCode.INVALID_OUTPUTS,
-                    message=re.sub(r"\s+For further information visit [^\s]+", "", str(e)),
-                ) from e
-        elif not isinstance(result, output_type):
-            raise NodeException(
-                code=WorkflowErrorCode.INVALID_OUTPUTS,
-                message=f"Expected an output of type '{output_type.__name__}', but received '{type(result).__name__}'",
-            )
+        result = _cast_to_output_type(result, output_type)
 
     return logs, result

vellum/workflows/nodes/displayable/prompt_deployment_node/node.py

@@ -1,3 +1,4 @@
+import json
 from typing import Iterator
 
 from vellum.workflows.errors import WorkflowErrorCode
@@ -44,13 +45,19 @@ class PromptDeploymentNode(BasePromptDeploymentNode[StateType]):
                 code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
-        string_output = next((output for output in outputs if output.type == "STRING"), None)
-        if not string_output or string_output.value is None:
-            output_types = {output.type for output in outputs}
-            is_plural = len(output_types) > 1
-            raise NodeException(
-                message=f"Expected to receive a non-null string output from Prompt. Only found outputs of type{'s' if is_plural else ''}: {', '.join(output_types)}",  # noqa: E501
-                code=WorkflowErrorCode.INTERNAL_ERROR,
-            )
-
-        yield BaseOutput(name="text", value=string_output.value)
+        string_outputs = []
+        for output in outputs:
+            if output.value is None:
+                continue
+
+            if output.type == "STRING":
+                string_outputs.append(output.value)
+            elif output.type == "JSON":
+                string_outputs.append(json.dumps(output.value, indent=4))
+            elif output.type == "FUNCTION_CALL":
+                string_outputs.append(output.value.model_dump_json(indent=4))
+            else:
+                string_outputs.append(output.value.message)
+
+        value = "\n".join(string_outputs)
+        yield BaseOutput(name="text", value=value)

vellum/workflows/workflows/base.py

@@ -221,6 +221,28 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
                     nodes.add(node)
                     yield node
 
+    @classmethod
+    def get_unused_subgraphs(cls) -> List[Graph]:
+        """
+        Returns a list of subgraphs that are defined but not used in the graph
+        """
+        if not hasattr(cls, "unused_graphs"):
+            return []
+
+        graphs = []
+        for item in cls.unused_graphs:
+            if isinstance(item, Graph):
+                graphs.append(item)
+            elif isinstance(item, set):
+                for subitem in item:
+                    if isinstance(subitem, Graph):
+                        graphs.append(subitem)
+                    elif issubclass(subitem, BaseNode):
+                        graphs.append(Graph.from_node(subitem))
+            elif issubclass(item, BaseNode):
+                graphs.append(Graph.from_node(item))
+        return graphs
+
     @classmethod
     def get_unused_nodes(cls) -> Iterator[Type[BaseNode]]:
         """
@@ -230,30 +252,25 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
             yield from ()
         else:
             nodes = set()
-            for item in cls.unused_graphs:
-                if isinstance(item, Graph):
-                    # Item is a graph
-                    for node in item.nodes:
-                        if node not in nodes:
-                            nodes.add(node)
-                            yield node
-                elif isinstance(item, set):
-                    # Item is a set of graphs or nodes
-                    for subitem in item:
-                        if isinstance(subitem, Graph):
-                            for node in subitem.nodes:
-                                if node not in nodes:
-                                    nodes.add(node)
-                                    yield node
-                        elif issubclass(subitem, BaseNode):
-                            if subitem not in nodes:
-                                nodes.add(subitem)
-                                yield subitem
-                elif issubclass(item, BaseNode):
-                    # Item is a node
-                    if item not in nodes:
-                        nodes.add(item)
-                        yield item
+            subgraphs = cls.get_unused_subgraphs()
+            for subgraph in subgraphs:
+                for node in subgraph.nodes:
+                    if node not in nodes:
+                        nodes.add(node)
+                        yield node
+
+    @classmethod
+    def get_unused_edges(cls) -> Iterator[Edge]:
+        """
+        Returns an iterator over edges that are defined but not used in the graph.
+        """
+        edges = set()
+        subgraphs = cls.get_unused_subgraphs()
+        for subgraph in subgraphs:
+            for edge in subgraph.edges:
+                if edge not in edges:
+                    edges.add(edge)
+                    yield edge
 
     @classmethod
     def get_entrypoints(cls) -> Iterable[Type[BaseNode]]:

vellum/workflows/workflows/tests/test_base_workflow.py

@@ -1,5 +1,6 @@
 import pytest
 
+from vellum.workflows.edges.edge import Edge
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
@@ -166,3 +167,49 @@ def test_workflow__node_in_both_graph_and_unused():
 
     # THEN it should raise an error
     assert "Node(s) NodeA cannot appear in both graph and unused_graphs" in str(exc_info.value)
+
+
+def test_workflow__get_unused_edges():
+    """
+    Test that get_unused_edges correctly identifies edges that are defined but not used in the workflow graph.
+    """
+
+    class NodeA(BaseNode):
+        pass
+
+    class NodeB(BaseNode):
+        pass
+
+    class NodeC(BaseNode):
+        pass
+
+    class NodeD(BaseNode):
+        pass
+
+    class NodeE(BaseNode):
+        pass
+
+    class NodeF(BaseNode):
+        pass
+
+    class NodeG(BaseNode):
+        pass
+
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = NodeA >> NodeB
+        unused_graphs = {NodeC >> {NodeD >> NodeE, NodeF} >> NodeG}
+
+    edge_c_to_d = Edge(from_port=NodeC.Ports.default, to_node=NodeD)
+    edge_c_to_f = Edge(from_port=NodeC.Ports.default, to_node=NodeF)
+    edge_d_to_e = Edge(from_port=NodeD.Ports.default, to_node=NodeE)
+    edge_e_to_g = Edge(from_port=NodeE.Ports.default, to_node=NodeG)
+    edge_f_to_g = Edge(from_port=NodeF.Ports.default, to_node=NodeG)
+
+    # Collect unused edges
+    unused_edges = set(TestWorkflow.get_unused_edges())
+
+    # Expected unused edges
+    expected_unused_edges = {edge_c_to_d, edge_c_to_f, edge_d_to_e, edge_e_to_g, edge_f_to_g}
+
+    # TEST that unused edges are correctly identified
+    assert unused_edges == expected_unused_edges, f"Expected {expected_unused_edges}, but got {unused_edges}"

vellum/workflows/workflows/tests/test_context.py

@@ -0,0 +1,60 @@
+from uuid import UUID, uuid4
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.context import execution_context, get_execution_context
+from vellum.workflows.events.types import NodeParentContext, WorkflowParentContext
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes import BaseNode
+from vellum.workflows.references import VellumSecretReference
+from vellum.workflows.state import BaseState
+
+
+class MockInputs(BaseInputs):
+    foo: str
+
+
+class MockNode(BaseNode):
+    node_foo = MockInputs.foo
+    node_secret = VellumSecretReference("secret")
+
+    class Outputs(BaseNode.Outputs):
+        example: str
+
+
+class MockWorkflow(BaseWorkflow[MockInputs, BaseState]):
+    graph = MockNode
+
+
+def test_context_trace_and_parent():
+    trace_id = uuid4()
+    parent_context = NodeParentContext(
+        node_definition=MockNode,
+        span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+        parent=WorkflowParentContext(
+            workflow_definition=MockWorkflow,
+            span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+        ),
+    )
+    second_parent_context = WorkflowParentContext(
+        workflow_definition=MockWorkflow, span_id=uuid4(), parent=parent_context
+    )
+    # When using execution context , if we set trace id within
+    with execution_context(parent_context=parent_context, trace_id=trace_id):
+        test = get_execution_context()
+        assert test.trace_id == trace_id
+        assert test.parent_context == parent_context
+        with execution_context(parent_context=second_parent_context):
+            test1 = get_execution_context()
+            assert test1.trace_id == trace_id
+            assert test1.parent_context == second_parent_context
+            # then we can assume trace id will not change
+            with execution_context(trace_id=uuid4()):
+                test3 = get_execution_context()
+                assert test3.trace_id == trace_id
+            with execution_context(parent_context=parent_context, trace_id=uuid4()):
+                test3 = get_execution_context()
+                assert test3.trace_id == trace_id
+    # and if we have a new context, the trace will differ
+    with execution_context(parent_context=parent_context, trace_id=uuid4()):
+        test = get_execution_context()
+        assert test.trace_id != trace_id

{vellum_ai-0.14.4.dist-info → vellum_ai-0.14.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.14.4
+Version: 0.14.5
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0

{vellum_ai-0.14.4.dist-info → vellum_ai-0.14.5.dist-info}/RECORD

@@ -28,8 +28,9 @@ vellum_ee/workflows/display/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5J
 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=VHx6wSs9wuuiFlZpSQSd3mhECz4SUy2wEBuTSv--_As,1578
+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/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
@@ -37,11 +38,11 @@ vellum_ee/workflows/display/nodes/vellum/final_output_node.py,sha256=p-PvlnxpBQ7
 vellum_ee/workflows/display/nodes/vellum/guardrail_node.py,sha256=aYZSJTxknU4LMiQdWk9LcK6CkhdozeDEMiRxfAyUNEc,2202
 vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py,sha256=aNZhjw5CwpUO8IcLJ2nhYrzn96RJ3FWeJXdfDizuPzw,8491
 vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py,sha256=MU9I8CB1X1TgL1aa1eT6DHWwNJ-2v79t74xl0oy-fBo,5510
-vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=VlO3UwkspCOdDQ-h3v8k16-7JZwWNSLpOLT4p-eirIs,3740
+vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=8CPnn06HIBxBOiECevUffeVmQmCpec6WtPQnNl9gj9Y,3748
 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=i0XGbKecLiHtf7mBf2rbqldPgLcs1TitIphzcHRIvkA,341
+vellum_ee/workflows/display/nodes/vellum/retry_node.py,sha256=hVqTtuHjlw_cYJ3ydNAvUHfGEoQi5YocVONZUo4i_Gs,1717
 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
@@ -50,20 +51,20 @@ vellum_ee/workflows/display/nodes/vellum/tests/test_error_node.py,sha256=ulrpoYU
 vellum_ee/workflows/display/nodes/vellum/tests/test_prompt_node.py,sha256=bg9INsXiWfyK047u8TD1oEOFYrqDq8GC7Hvgz69n7BE,1988
 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=3uT7Gbc0f_mQ3u8uZuCWd0mJ4GtWbz2gbUMySYaVlNE,3774
-vellum_ee/workflows/display/nodes/vellum/try_node.py,sha256=EoU1J7HfcszAZr7ROy_xsNhaDBRiI95-wTK-OzgBwvg,5861
+vellum_ee/workflows/display/nodes/vellum/try_node.py,sha256=HBfGz4yt9GlmMW9JxzaCacPnHBDNIeXE8Jhqr9DqLLw,6191
 vellum_ee/workflows/display/nodes/vellum/utils.py,sha256=OEGHjQSbuUgJexXI1aubYW33z2F_YdkhQ8REahfz864,4320
 vellum_ee/workflows/display/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/tests/test_vellum_workflow_display.py,sha256=1EEvkKQRfOKlnpLxE9-hKSsVLLaelM39LY7007LM5dg,4983
 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=KYdohS5pRgHM0DcUaK0tHa40f0gSvDKi2K5On0zNEU8,8305
+vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_adornments_serialization.py,sha256=7Fc-TtPw7hz_pvQ-TWz3G8Vy9h2AztukpyDK0p7REGU,9071
 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_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=PiHqgj-vLhlaOHoQFVVEW2YydYWLI0mX6nq_sbzZiy4,29233
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_code_execution_node_serialization.py,sha256=V__y7uu-dy6TJjPeu4UDvaoO2yYwBRbPiW9uJdzWRx4,29828
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_conditional_node_serialization.py,sha256=R8DW1DUb0DOSLtnF2E1HaCTmtpG-ski0LfcM2WeLVNo,47672
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_default_state_serialization.py,sha256=z9FSufJeV-003R87wi_Lx4mZewdeeOeTPCGNc9vg8vY,8819
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_error_node_serialization.py,sha256=wgedEa2IVP2ssH_FLghoEmLgpJR41AY-iNIw1SESeqA,6106
@@ -78,7 +79,7 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_search_node_
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_subworkflow_deployment_serialization.py,sha256=BzFNl9ECeGh0krm-CUjbBQQq0g7krANsp0Sh-j5dAkc,11322
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_node_serialization.py,sha256=xXtW915v9yxxKlyu5ObzKHyJYMvobvev3ermX61SGx4,7818
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py,sha256=NdhE3lm7RMQ8DqkraPSq24IbOxNla9unbs4tsMWRzm4,3781
-vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py,sha256=gHKU8Vg960ooV3uXqM2LMnVS-mGbv3aagGozQuTVTjI,2455
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py,sha256=eD5686C9nWC5s6t08vbAnm9qf9t53gYQM-E1FwAa75c,3035
 vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_node_serialization.py,sha256=huKAOeMJ2MKmp6XtbvMJTUadqynoV40Ypoz9jsBEBEQ,7431
 vellum_ee/workflows/display/types.py,sha256=xDC1zy4rWKNqDtSr-h6MQfWnJ6scZ_Sadxp4t8Q3PY4,2897
 vellum_ee/workflows/display/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -119,7 +120,7 @@ vellum/client/README.md,sha256=JkCJjmMZl4jrPj46pkmL9dpK4gSzQQmP5I7z4aME4LY,4749
 vellum/client/__init__.py,sha256=j6zi0NZ4BMC6JrwckvzMWuG5x8KoOvO4KqsLhvVCa68,117624
 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=pxEwlQ6QCqqK61MR38NnSRA28GMZgrYhfxlyjX2Sy-Y,1868
+vellum/client/core/client_wrapper.py,sha256=XW9zEBd9XlCTI0wEOgZ6LI4dCsGwvpW4NO7KogWDgao,1868
 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
@@ -1271,7 +1272,7 @@ vellum/version.py,sha256=jq-1PlAYxN9AXuaZqbYk9ak27SgE2lw9Ia5gx1b1gVI,76
 vellum/workflows/README.md,sha256=MLNm-ihc0ao6I8gwwOhXQQBf0jOf-EsA9C519ALYI1o,3610
 vellum/workflows/__init__.py,sha256=CssPsbNvN6rDhoLuqpEv7MMKGa51vE6dvAh6U31Pcio,71
 vellum/workflows/constants.py,sha256=2yg4_uo5gpqViy3ZLSwfC8qTybleYCtOnhA4Rj6bacM,1310
-vellum/workflows/context.py,sha256=R8qdsFbD_0p7B6PWnyvSrZ_aOgMtGw-_uk0P0UAmwLA,1230
+vellum/workflows/context.py,sha256=DwSf8lO9NHABiqOoD3exgrjUoRuNsKtutaL5TgRbD-A,1441
 vellum/workflows/descriptors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/descriptors/base.py,sha256=gSib3vJpcI_UC8y8jhdp-hOK3_TGTF-SuwdhxF6x5iQ,14332
 vellum/workflows/descriptors/exceptions.py,sha256=gUy4UD9JFUKSeQnQpeuDSLiRqWjWiIsxLahB7p_q3JY,54
@@ -1380,8 +1381,8 @@ vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=_yrQn_uLwy
 vellum/workflows/nodes/displayable/code_execution_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/code_execution_node/tests/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/code_execution_node/tests/fixtures/main.py,sha256=5QsbmkzSlSbcbWTG_JmIqcP-JNJzOPTKxGzdHos19W4,79
-vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py,sha256=5WHsW_uEKDn1ukM9_O2FsGCYELfONz-2h_kYnNRNYHE,18333
-vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=rdWD1wtxPKHbdHRHEdTeRMSJi9sgAm2t0FqeAWuQHlQ,4534
+vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py,sha256=4ADDKsObtUs0PhcWyAjWyQcAF7PGUYE0CxjYp8d-1NM,20637
+vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=BQraIN4I3DCzXLEuBlRYCyp7ote7hQmnnKHu4jFHCCA,5174
 vellum/workflows/nodes/displayable/conditional_node/__init__.py,sha256=AS_EIqFdU1F9t8aLmbZU-rLh9ry6LCJ0uj0D8F0L5Uw,72
 vellum/workflows/nodes/displayable/conditional_node/node.py,sha256=Qjfl33gZ3JEgxBA1EgzSUebboGvsARthIxxcQyvx5Gg,1152
 vellum/workflows/nodes/displayable/final_output_node/__init__.py,sha256=G7VXM4OWpubvSJtVkGmMNeqgb9GkM7qZT838eL18XU4,72
@@ -1397,7 +1398,7 @@ vellum/workflows/nodes/displayable/merge_node/node.py,sha256=nZtGGVAvY4fvGg8vwV6
 vellum/workflows/nodes/displayable/note_node/__init__.py,sha256=KWA3P4fyYJ-fOTky8qNGlcOotQ-HeHJ9AjZt6mRQmCE,58
 vellum/workflows/nodes/displayable/note_node/node.py,sha256=sIN1VBQ7zeT3GhN0kupXbFfdpvgedWV79k4woJNp5IQ,394
 vellum/workflows/nodes/displayable/prompt_deployment_node/__init__.py,sha256=krX1Hds-TSVYZsx0wJFX4wsAKkEFYOX1ifwRGiIM-EA,82
-vellum/workflows/nodes/displayable/prompt_deployment_node/node.py,sha256=ruOgvpg_9KV_HkovPQeu6TKpur9DT_J4CYQo50tULCY,2680
+vellum/workflows/nodes/displayable/prompt_deployment_node/node.py,sha256=pb-KbrnfTRL7mmNtVAMmiCiys8raXkl5Od7sIu682xU,2707
 vellum/workflows/nodes/displayable/prompt_deployment_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/prompt_deployment_node/tests/test_node.py,sha256=ymEwMwrwRuQGyvkTnqeRZvfK7dhnf-kmRJTuwlycNjI,3939
 vellum/workflows/nodes/displayable/search_node/__init__.py,sha256=hpBpvbrDYf43DElRZFLzieSn8weXiwNiiNOJurERQbs,62
@@ -1470,12 +1471,13 @@ vellum/workflows/utils/uuids.py,sha256=DFzPv9RCvsKhvdTEIQyfSek2A31D6S_QcmeLPbgrg
 vellum/workflows/utils/vellum_variables.py,sha256=fC2aSLvlS31D15dOWu43LBRR0QsgUKNXBiCUvvaLXSs,3231
 vellum/workflows/vellum_client.py,sha256=ODrq_TSl-drX2aezXegf7pizpWDVJuTXH-j6528t75s,683
 vellum/workflows/workflows/__init__.py,sha256=KY45TqvavCCvXIkyCFMEc0dc6jTMOUci93U2DUrlZYc,66
-vellum/workflows/workflows/base.py,sha256=eHa5iojvXFl3_vSb3jCoYt24dZdjppoohAqv99z8xRY,22096
+vellum/workflows/workflows/base.py,sha256=MNwWXt0xosrGAjbkQ_lhmBPlHzsJVX1Cr2qy7guFRK8,22446
 vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnadGsrSZGa7t7LpJA,2008
 vellum/workflows/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/workflows/tests/test_base_workflow.py,sha256=dTwC2VIqXNJ5yJ3MPwGNB9QpVzVzycT2kiBIljxhCwM,4836
-vellum_ai-0.14.4.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.4.dist-info/METADATA,sha256=cV7wQcYIgzVrVDPeufin7dSQ5sRFUGtzbAhDw9kYKKc,5407
-vellum_ai-0.14.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.4.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.4.dist-info/RECORD,,
+vellum/workflows/workflows/tests/test_base_workflow.py,sha256=DTfXqHUF0SJELTVSA9PCOWHVoAylqpDNFZTkQM44CdU,6215
+vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
+vellum_ai-0.14.5.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.5.dist-info/METADATA,sha256=_53R_GRMep--gP15bdsMgW6SYTC9AD_W9yvPkQp94w0,5407
+vellum_ai-0.14.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.5.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.5.dist-info/RECORD,,

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

@@ -1,4 +1,5 @@
 from .api_node import BaseAPINodeDisplay
+from .base_adornment_node import BaseAdornmentNodeDisplay
 from .code_execution_node import BaseCodeExecutionNodeDisplay
 from .conditional_node import BaseConditionalNodeDisplay
 from .error_node import BaseErrorNodeDisplay
@@ -18,6 +19,7 @@ from .try_node import BaseTryNodeDisplay
 
 # All node display classes must be imported here to be registered in BaseNodeDisplay's node display registry
 __all__ = [
+    "BaseAdornmentNodeDisplay",
     "BaseAPINodeDisplay",
     "BaseCodeExecutionNodeDisplay",
     "BaseConditionalNodeDisplay",

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

@@ -0,0 +1,39 @@
+from uuid import UUID
+from typing import Any, Callable, Generic, Optional, TypeVar, cast
+
+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_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
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+
+_BaseAdornmentNodeType = TypeVar("_BaseAdornmentNodeType", bound=BaseAdornmentNode)
+
+
+class BaseAdornmentNodeDisplay(BaseNodeVellumDisplay[_BaseAdornmentNodeType], Generic[_BaseAdornmentNodeType]):
+    def serialize(
+        self,
+        display_context: "WorkflowDisplayContext",
+        **kwargs: Any,
+    ) -> dict:
+        node = self._node
+        adornment = cast(Optional[JsonObject], kwargs.get("adornment"))
+        get_additional_kwargs = cast(Optional[Callable[[UUID], dict]], kwargs.get("get_additional_kwargs"))
+
+        wrapped_node = get_wrapped_node(node)
+        if not wrapped_node:
+            raise NotImplementedError(
+                "Unable to serialize standalone adornment nodes. Please use adornment nodes as a decorator."
+            )
+
+        wrapped_node_display_class = get_node_display_class(BaseNodeDisplay, wrapped_node)
+        wrapped_node_display = wrapped_node_display_class()
+        additional_kwargs = get_additional_kwargs(wrapped_node_display.node_id) if get_additional_kwargs else {}
+        serialized_wrapped_node = wrapped_node_display.serialize(display_context, **kwargs, **additional_kwargs)
+
+        adornments = cast(JsonArray, serialized_wrapped_node.get("adornments")) or []
+        serialized_wrapped_node["adornments"] = adornments + [adornment] if adornment else adornments
+
+        return serialized_wrapped_node

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

@@ -3,8 +3,8 @@ from typing import Dict, Generic, List, Optional, TypeVar, cast
 
 from vellum.workflows.nodes import MapNode
 from vellum.workflows.types.core import JsonObject
-from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
+from vellum_ee.workflows.display.nodes.vellum.base_adornment_node import BaseAdornmentNodeDisplay
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
@@ -12,7 +12,7 @@ from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class imp
 _MapNodeType = TypeVar("_MapNodeType", bound=MapNode)
 
 
-class BaseMapNodeDisplay(BaseNodeVellumDisplay[_MapNodeType], Generic[_MapNodeType]):
+class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNodeType]):
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:

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

@@ -1,10 +1,42 @@
-from typing import Generic, TypeVar
+import inspect
+from typing import Any, Generic, TypeVar, cast
 
+from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.nodes.core.retry_node.node import RetryNode
-from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
+from vellum.workflows.types.core import JsonArray, JsonObject
+from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.nodes.vellum.base_adornment_node import BaseAdornmentNodeDisplay
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
 
 _RetryNodeType = TypeVar("_RetryNodeType", bound=RetryNode)
 
 
-class BaseRetryNodeDisplay(BaseNodeDisplay[_RetryNodeType], Generic[_RetryNodeType]):
-    pass
+class BaseRetryNodeDisplay(BaseAdornmentNodeDisplay[_RetryNodeType], Generic[_RetryNodeType]):
+    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+        node = self._node
+        node_id = self.node_id
+
+        attributes: JsonArray = []
+        for attribute in node:
+            if inspect.isclass(attribute.instance) and issubclass(attribute.instance, BaseWorkflow):
+                # We don't need to serialize attributes that are workflows
+                continue
+
+            id = str(uuid4_from_hash(f"{node_id}|{attribute.name}"))
+            attributes.append(
+                {
+                    "id": id,
+                    "name": attribute.name,
+                    "value": self.serialize_value(display_context, cast(BaseDescriptor, attribute.instance)),
+                }
+            )
+
+        adornment: JsonObject = {
+            "id": str(node_id),
+            "label": node.__qualname__,
+            "base": self.get_base().dict(),
+            "attributes": attributes,
+        }
+
+        return super().serialize(display_context, adornment=adornment)

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

@@ -1,55 +1,69 @@
+import inspect
 from uuid import UUID
 from typing import Any, Callable, ClassVar, Generic, Optional, Tuple, Type, TypeVar, cast
 
+from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.try_node.node import TryNode
-from vellum.workflows.nodes.utils import ADORNMENT_MODULE_NAME, get_wrapped_node
+from vellum.workflows.nodes.utils import ADORNMENT_MODULE_NAME
 from vellum.workflows.references.output import OutputReference
-from vellum.workflows.types.core import JsonObject
+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
-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
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
-from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
+from vellum_ee.workflows.display.nodes.vellum.base_adornment_node import BaseAdornmentNodeDisplay
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 
 _TryNodeType = TypeVar("_TryNodeType", bound=TryNode)
 
 
-class BaseTryNodeDisplay(BaseNodeVellumDisplay[_TryNodeType], Generic[_TryNodeType]):
+class BaseTryNodeDisplay(BaseAdornmentNodeDisplay[_TryNodeType], Generic[_TryNodeType]):
     error_output_id: ClassVar[Optional[UUID]] = None
 
-    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+    def serialize(self, display_context: "WorkflowDisplayContext", **kwargs: Any) -> JsonObject:
         node = self._node
+        node_id = self.node_id
+
+        # We let the inner node serialize first and then append to it
+        attributes: JsonArray = []
+        for attribute in node:
+            if inspect.isclass(attribute.instance) and issubclass(attribute.instance, BaseWorkflow):
+                # We don't need to serialize attributes that are workflows
+                continue
+
+            id = str(uuid4_from_hash(f"{node_id}|{attribute.name}"))
+            attributes.append(
+                {
+                    "id": id,
+                    "name": attribute.name,
+                    "value": self.serialize_value(display_context, cast(BaseDescriptor, attribute.instance)),
+                }
+            )
 
-        inner_node = get_wrapped_node(node)
-        if not inner_node:
-            subworkflow = raise_if_descriptor(node.subworkflow)
-            if not isinstance(subworkflow.graph, type) or not issubclass(subworkflow.graph, BaseNode):
-                raise NotImplementedError(
-                    "Unable to serialize Try Nodes that wrap subworkflows containing more than one Node."
-                )
-
-            inner_node = subworkflow.graph
-        elif inner_node.__bases__[0] is BaseNode:
-            # If the wrapped node is a generic node, we let generic node do adornment handling
-            class TryBaseNodeDisplay(BaseNodeDisplay[node]):  # type: ignore[valid-type]
-                pass
-
-            return TryBaseNodeDisplay().serialize(display_context)
-
-        # We need the node display class of the underlying node because
-        # it contains the logic for serializing the node and potential display overrides
-        node_display_class = get_node_display_class(BaseNodeDisplay, inner_node)
-        node_display = node_display_class()
-
-        serialized_node = node_display.serialize(
+        adornment: JsonObject = {
+            "id": str(node_id),
+            "label": node.__qualname__,
+            "base": self.get_base().dict(),
+            "attributes": attributes,
+        }
+
+        # We need the inner node's ID to generate the error output ID
+        # Long term we want to hoist error_output_id append from inner node displays to this display,
+        # But that's a lot of work and this allows us to punt a little longer
+        serialized_node = super().serialize(
             display_context,
-            error_output_id=self.error_output_id or uuid4_from_hash(f"{node_display.node_id}|error_output_id"),
+            adornment=adornment,
+            get_additional_kwargs=lambda node_id: {
+                "error_output_id": self.error_output_id or uuid4_from_hash(f"{node_id}|error_output_id")
+            },
         )
 
+        if serialized_node["type"] == "GENERIC":
+            return serialized_node
+
         serialized_node_definition = serialized_node.get("definition")
         if isinstance(serialized_node_definition, dict):
             serialized_node_definition_module = serialized_node_definition.get("module")

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

@@ -1,3 +1,4 @@
+import pytest
 from uuid import uuid4
 
 from deepdiff import DeepDiff
@@ -11,6 +12,7 @@ from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.base import WorkflowInputsDisplay
 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.vellum.retry_node import BaseRetryNodeDisplay
 from vellum_ee.workflows.display.nodes.vellum.try_node import BaseTryNodeDisplay
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 from vellum_ee.workflows.display.workflows.vellum_workflow_display import VellumWorkflowDisplay
@@ -32,7 +34,7 @@ class InnerRetryGenericNodeDisplay(BaseNodeDisplay[InnerRetryGenericNode.__wrapp
     pass
 
 
-class OuterRetryNodeDisplay(BaseNodeDisplay[InnerRetryGenericNode]):
+class OuterRetryNodeDisplay(BaseRetryNodeDisplay[InnerRetryGenericNode]):  # type: ignore
     pass
 
 
@@ -213,3 +215,25 @@ def test_serialize_node__try(serialize_node):
         },
         serialized_node,
     )
+
+
+@pytest.mark.skip(reason="Not implemented")
+def test_serialize_node__stacked():
+    @TryNode.wrap()
+    @RetryNode.wrap(max_attempts=5)
+    class InnerStackedGenericNode(BaseNode):
+        pass
+
+    # AND a workflow that uses the adornment node
+    class StackedWorkflow(BaseWorkflow):
+        graph = InnerStackedGenericNode
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay,
+        workflow_class=StackedWorkflow,
+    )
+    exec_config = workflow_display.serialize()
+
+    # THEN the workflow display is created successfully
+    assert exec_config is not None

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

@@ -596,6 +596,20 @@ def test_serialize_workflow__try_wrapped():
             ],
             "name": "TryNode",
         },
+        "adornments": [
+            {
+                "id": "3344083c-a32c-4a32-920b-0fb5093448fa",
+                "label": "TryNode",
+                "base": {"name": "TryNode", "module": ["vellum", "workflows", "nodes", "core", "try_node", "node"]},
+                "attributes": [
+                    {
+                        "id": "ab2fbab0-e2a0-419b-b1ef-ce11ecf11e90",
+                        "name": "on_error_code",
+                        "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                    }
+                ],
+            }
+        ],
     }
 
     final_output_nodes = workflow_raw_data["nodes"][2:]

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

@@ -1,9 +1,11 @@
+import pytest
+
 from deepdiff import DeepDiff
 
 from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
-from tests.workflows.basic_try_node.workflow import SimpleTryExample
+from tests.workflows.basic_try_node.workflow import SimpleTryExample, StandaloneTryExample
 
 
 def test_serialize_workflow():
@@ -69,3 +71,19 @@ def test_serialize_workflow():
 
     try_node = workflow_raw_data["nodes"][1]
     assert try_node["id"] == "1381c078-efa2-4255-89a1-7b4cb742c7fc"
+
+
+def test_serialize_workflow__standalone():
+    # GIVEN a Workflow with a standalone TryNode
+    # WHEN we serialize it
+    with pytest.raises(NotImplementedError) as exc:
+        workflow_display = get_workflow_display(
+            base_display_class=VellumWorkflowDisplay, workflow_class=StandaloneTryExample
+        )
+        workflow_display.serialize()
+
+    # THEN we should get an error
+    assert (
+        exc.value.args[0]
+        == "Unable to serialize standalone adornment nodes. Please use adornment nodes as a decorator."
+    )