vellum-ai 0.14.13__tar.gz → 0.14.15__tar.gz

{vellum_ai-0.14.13 → vellum_ai-0.14.15}/PKG-INFO

@@ -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 → vellum_ai-0.14.15}/ee/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_ai-0.14.13 → vellum_ai-0.14.15}/ee/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_ai-0.14.15/ee/vellum_ee/workflows/display/nodes/get_node_display_class.py

@@ -0,0 +1,67 @@
+import types
+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:
+    from vellum_ee.workflows.display.types import NodeDisplayType
+
+
+def get_node_display_class(
+    base_class: Type["NodeDisplayType"], node_class: Type[NodeType], root_node_class: Optional[Type[NodeType]] = None
+) -> Type["NodeDisplayType"]:
+    node_display_class = base_class.get_from_node_display_registry(node_class)
+    if node_display_class:
+        if not issubclass(node_display_class, base_class):
+            raise TypeError(
+                f"Expected to find a subclass of '{base_class.__name__}' for node class '{node_class.__name__}'"
+            )
+
+        return node_display_class
+
+    base_node_display_class = get_node_display_class(
+        base_class, node_class.__bases__[0], node_class if root_node_class is None else root_node_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,
+    )
+
+    return NodeDisplayClass

vellum_ai-0.14.15/ee/vellum_ee/workflows/display/nodes/vellum/base_adornment_node.py

@@ -0,0 +1,93 @@
+import re
+import types
+from uuid import UUID
+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
+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
+
+    @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_ai-0.14.13 → vellum_ai-0.14.15}/ee/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_ai-0.14.13 → vellum_ai-0.14.15}/ee/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_ai-0.14.13 → vellum_ai-0.14.15}/ee/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_ai-0.14.13 → vellum_ai-0.14.15}/ee/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_ai-0.14.13 → vellum_ai-0.14.15}/ee/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_ai-0.14.13 → vellum_ai-0.14.15}/ee/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_ai-0.14.13 → vellum_ai-0.14.15}/ee/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_ai-0.14.13 → vellum_ai-0.14.15}/ee/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"}