vellum-ai 0.14.39__tar.gz → 0.14.41__tar.gz

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/PKG-INFO

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

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_cli/push.py

@@ -17,7 +17,6 @@ from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_cli.config import DEFAULT_WORKSPACE_CONFIG, WorkflowConfig, WorkflowDeploymentConfig, load_vellum_cli_config
 from vellum_cli.logger import load_cli_logger
 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
 
 
 def push_command(
@@ -105,7 +104,6 @@ def push_command(
     # https://app.shortcut.com/vellum/story/5585
     workflow = BaseWorkflow.load_from_module(workflow_config.module)
     workflow_display = get_workflow_display(
-        base_display_class=VellumWorkflowDisplay,
         workflow_class=workflow,
         dry_run=dry_run or False,
     )

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_ee/workflows/display/base.py

@@ -1,10 +1,12 @@
 from dataclasses import dataclass, field
 from uuid import UUID
-from typing import Optional
+from typing import Optional, Type
 
 from pydantic import Field
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.editor.types import NodeDisplayData
 
 
@@ -25,6 +27,17 @@ class WorkflowMetaDisplay:
     entrypoint_node_display: NodeDisplayData = Field(default_factory=NodeDisplayData)
     display_data: WorkflowDisplayData = field(default_factory=WorkflowDisplayData)
 
+    @classmethod
+    def get_default(cls, workflow: Type[BaseWorkflow]) -> "WorkflowMetaDisplay":
+        entrypoint_node_id = uuid4_from_hash(f"{workflow.__id__}|entrypoint_node_id")
+        entrypoint_node_source_handle_id = uuid4_from_hash(f"{workflow.__id__}|entrypoint_node_source_handle_id")
+
+        return WorkflowMetaDisplay(
+            entrypoint_node_id=entrypoint_node_id,
+            entrypoint_node_source_handle_id=entrypoint_node_source_handle_id,
+            entrypoint_node_display=NodeDisplayData(),
+        )
+
 
 @dataclass
 class WorkflowMetaDisplayOverrides(WorkflowMetaDisplay):

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -21,18 +21,35 @@ from vellum.client.types.code_resource_definition import CodeResourceDefinition
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.expressions.accessor import AccessorExpression
+from vellum.workflows.expressions.and_ import AndExpression
+from vellum.workflows.expressions.begins_with import BeginsWithExpression
 from vellum.workflows.expressions.between import BetweenExpression
+from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
+from vellum.workflows.expressions.contains import ContainsExpression
+from vellum.workflows.expressions.does_not_begin_with import DoesNotBeginWithExpression
+from vellum.workflows.expressions.does_not_contain import DoesNotContainExpression
+from vellum.workflows.expressions.does_not_end_with import DoesNotEndWithExpression
+from vellum.workflows.expressions.ends_with import EndsWithExpression
+from vellum.workflows.expressions.equals import EqualsExpression
+from vellum.workflows.expressions.greater_than import GreaterThanExpression
+from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
+from vellum.workflows.expressions.in_ import InExpression
 from vellum.workflows.expressions.is_nil import IsNilExpression
 from vellum.workflows.expressions.is_not_nil import IsNotNilExpression
 from vellum.workflows.expressions.is_not_null import IsNotNullExpression
 from vellum.workflows.expressions.is_not_undefined import IsNotUndefinedExpression
 from vellum.workflows.expressions.is_null import IsNullExpression
 from vellum.workflows.expressions.is_undefined import IsUndefinedExpression
+from vellum.workflows.expressions.less_than import LessThanExpression
+from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
 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.nodes.utils import get_wrapped_node
+from vellum.workflows.nodes.utils import get_unadorned_node, get_wrapped_node
 from vellum.workflows.ports import Port
 from vellum.workflows.references import OutputReference
 from vellum.workflows.references.constant import ConstantValueReference
@@ -47,10 +64,12 @@ from vellum.workflows.types.utils import get_original_base
 from vellum.workflows.utils.names import pascal_to_title_case
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
-from vellum_ee.workflows.display.editor.types import NodeDisplayData
+from vellum_ee.workflows.display.editor.types import NodeDisplayComment, NodeDisplayData
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay, PortDisplayOverrides
+from vellum_ee.workflows.display.utils.exceptions import UnsupportedSerializationException
 from vellum_ee.workflows.display.utils.expressions import get_child_descriptor
+from vellum_ee.workflows.display.utils.registry import register_node_display_class
 from vellum_ee.workflows.display.utils.vellum import convert_descriptor_to_operator
 
 if TYPE_CHECKING:
@@ -121,9 +140,6 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
     # Once all nodes are Generic Nodes, we may replace this with a trigger_id or trigger attribute
     target_handle_id: ClassVar[Optional[UUID]] = None
 
-    # Used to store the mapping between node types and their display classes
-    _node_display_registry: Dict[Type[NodeType], Type["BaseNodeDisplay"]] = {}
-
     def serialize(self, display_context: "WorkflowDisplayContext", **kwargs: Any) -> JsonObject:
         node = self._node
         node_id = self.node_id
@@ -149,7 +165,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
         adornments = kwargs.get("adornments", None)
         wrapped_node = get_wrapped_node(node)
         if wrapped_node is not None:
-            display_class = get_node_display_class(BaseNodeDisplay, wrapped_node)
+            display_class = get_node_display_class(wrapped_node)
 
             adornment: JsonObject = {
                 "id": str(node_id),
@@ -207,7 +223,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
             "id": str(node_id),
             "label": node.__qualname__,
             "type": "GENERIC",
-            "display_data": self._get_generic_node_display_data().dict(),
+            "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
             "trigger": {
@@ -260,6 +276,13 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
 
         return PortDisplay(id=port_id, node_id=self.node_id)
 
+    def get_source_handle_id(self, port_displays: Dict[Port, PortDisplay]) -> UUID:
+        unadorned_node = get_unadorned_node(self._node)
+        default_port = unadorned_node.Ports.default
+
+        default_port_display = port_displays[default_port]
+        return default_port_display.id
+
     def get_trigger_id(self) -> UUID:
         return self.get_target_handle_id()
 
@@ -280,10 +303,6 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
 
         return self.get_target_handle_id()
 
-    @classmethod
-    def get_from_node_display_registry(cls, node_class: Type[NodeType]) -> Optional[Type["BaseNodeDisplay"]]:
-        return cls._node_display_registry.get(node_class)
-
     @cached_property
     def node_id(self) -> UUID:
         """Can be overridden as a class attribute to specify a custom node id."""
@@ -344,18 +363,39 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
 
     def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
-        if not cls._node_display_registry:
-            cls._node_display_registry[BaseNode] = BaseNodeDisplay
 
         node_class = cls.infer_node_class()
         if node_class is BaseNode:
             return
 
-        cls._node_display_registry[node_class] = cls
+        register_node_display_class(node_class=node_class, node_display_class=cls)
 
-    def _get_generic_node_display_data(self) -> NodeDisplayData:
+    def get_display_data(self) -> NodeDisplayData:
         explicit_value = self._get_explicit_node_display_attr("display_data", NodeDisplayData)
-        return explicit_value if explicit_value else NodeDisplayData()
+        docstring = self._node.__doc__
+
+        if explicit_value and explicit_value.comment and docstring:
+            comment = (
+                NodeDisplayComment(value=docstring, expanded=explicit_value.comment.expanded)
+                if explicit_value.comment.expanded
+                else NodeDisplayComment(value=docstring)
+            )
+            return NodeDisplayData(
+                position=explicit_value.position,
+                width=explicit_value.width,
+                height=explicit_value.height,
+                comment=comment,
+            )
+
+        if explicit_value:
+            return explicit_value
+
+        if docstring:
+            return NodeDisplayData(
+                comment=NodeDisplayComment(value=docstring),
+            )
+
+        return NodeDisplayData()
 
     def serialize_condition(self, display_context: "WorkflowDisplayContext", condition: BaseDescriptor) -> JsonObject:
         if isinstance(
@@ -388,9 +428,29 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 "lhs": lhs,
                 "rhs": rhs,
             }
-        else:
-            lhs = self.serialize_value(display_context, condition._lhs)  # type: ignore[attr-defined]
-            rhs = self.serialize_value(display_context, condition._rhs)  # type: ignore[attr-defined]
+        elif isinstance(
+            condition,
+            (
+                AndExpression,
+                BeginsWithExpression,
+                CoalesceExpression,
+                ContainsExpression,
+                DoesNotBeginWithExpression,
+                DoesNotContainExpression,
+                DoesNotEndWithExpression,
+                EndsWithExpression,
+                EqualsExpression,
+                GreaterThanExpression,
+                GreaterThanOrEqualToExpression,
+                InExpression,
+                LessThanExpression,
+                LessThanOrEqualToExpression,
+                NotInExpression,
+                OrExpression,
+            ),
+        ):
+            lhs = self.serialize_value(display_context, condition._lhs)
+            rhs = self.serialize_value(display_context, condition._rhs)
 
             return {
                 "type": "BINARY_EXPRESSION",
@@ -398,6 +458,15 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 "operator": convert_descriptor_to_operator(condition),
                 "rhs": rhs,
             }
+        elif isinstance(condition, AccessorExpression):
+            return {
+                "type": "BINARY_EXPRESSION",
+                "lhs": self.serialize_value(display_context, condition._base),
+                "operator": "accessField",
+                "rhs": self.serialize_value(display_context, condition._field),
+            }
+
+        raise UnsupportedSerializationException(f"Unsupported condition type: {condition.__class__.__name__}")
 
     def serialize_value(self, display_context: "WorkflowDisplayContext", value: Any) -> JsonObject:
         if isinstance(value, ConstantValueReference):
@@ -458,3 +527,6 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
         # If it's not any of the references we know about,
         # then try to serialize it as a nested value
         return self.serialize_condition(display_context, value)
+
+
+register_node_display_class(node_class=BaseNode, node_display_class=BaseNodeDisplay)

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_ee/workflows/display/nodes/get_node_display_class.py

@@ -1,33 +1,27 @@
 import types
 from uuid import UUID
-from typing import TYPE_CHECKING, Any, Dict, Optional, Type
+from typing import TYPE_CHECKING, Any, Dict, Generic, Type, TypeVar
 
 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.utils.registry import get_from_node_display_registry
 
 if TYPE_CHECKING:
     from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 
 
-def get_node_display_class(
-    base_class: Type["BaseNodeDisplay"], node_class: Type[NodeType], root_node_class: Optional[Type[NodeType]] = None
-) -> Type["BaseNodeDisplay"]:
-    node_display_class = base_class.get_from_node_display_registry(node_class)
+def get_node_display_class(node_class: Type[NodeType]) -> Type["BaseNodeDisplay"]:
+    node_display_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 = get_node_display_class(node_class.__bases__[0])
 
+    # mypy gets upset at dynamic TypeVar's, but it's technically allowed by python
+    _NodeClassType = TypeVar(f"_{node_class.__name__}Type", bound=node_class)  # type: ignore[misc]
     # `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]
+    NodeDisplayBaseClass = base_node_display_class[_NodeClassType]  # type: ignore[index]
 
     def _get_node_input_ids_by_ref(path: str, inst: Any):
         if isinstance(inst, dict):
@@ -51,7 +45,7 @@ def get_node_display_class(
 
     NodeDisplayClass = types.new_class(
         f"{node_class.__name__}Display",
-        bases=(NodeDisplayBaseClass,),
+        bases=(NodeDisplayBaseClass, Generic[_NodeClassType]),
         exec_body=exec_body,
     )
 

vellum_ai-0.14.41/ee/vellum_ee/workflows/display/nodes/tests/test_base_node_display.py

@@ -0,0 +1,102 @@
+import pytest
+from uuid import UUID
+
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.ports.port import Port
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
+from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+
+
+@pytest.fixture
+def node_with_implicit_properties():
+    class MyNode(BaseNode):
+        pass
+
+    class MyNodeDisplay(BaseNodeDisplay[MyNode]):
+        pass
+
+    expected_id = UUID("ace7f746-4fe6-45c7-8207-fc8a4d0c7f6f")
+
+    return MyNodeDisplay, expected_id
+
+
+@pytest.fixture
+def node_with_explicit_properties():
+    explicit_id = UUID("a422f67a-1d37-43f0-bdfc-1e4618c9496d")
+
+    class MyNode(BaseNode):
+        pass
+
+    class MyNodeDisplay(BaseNodeDisplay[MyNode]):
+        node_id = explicit_id
+
+    return MyNodeDisplay, explicit_id
+
+
+@pytest.fixture(
+    params=[
+        "node_with_implicit_properties",
+        "node_with_explicit_properties",
+    ]
+)
+def node_info(request):
+    return request.getfixturevalue(request.param)
+
+
+def test_get_id(node_info):
+    node_display, expected_id = node_info
+
+    assert node_display().node_id == expected_id
+    assert node_display.infer_node_class().__id__ == expected_id
+
+
+def test_serialize_condition__accessor_expression():
+    # GIVEN a node with an accessor expression in a Port
+    class MyNode(BaseNode):
+        class Ports(BaseNode.Ports):
+            foo = Port.on_if(ConstantValueReference({"hello": "world"})["hello"])
+
+    # WHEN we serialize the node
+    node_display_class = get_node_display_class(MyNode)
+    data = node_display_class().serialize(WorkflowDisplayContext())
+
+    # THEN the condition should be serialized correctly
+    assert data["ports"] == [
+        {
+            "id": "7de6ea94-7f6c-475e-8f38-ec8ac317fd19",
+            "name": "foo",
+            "type": "IF",
+            "expression": {
+                "type": "BINARY_EXPRESSION",
+                "lhs": {
+                    "type": "CONSTANT_VALUE",
+                    "value": {
+                        "type": "JSON",
+                        "value": {"hello": "world"},
+                    },
+                },
+                "operator": "accessField",
+                "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "hello"}},
+            },
+        }
+    ]
+
+
+def test_serialize_display_data():
+    # GIVEN a node with an accessor expression in a Port
+    class MyNode(BaseNode):
+        """I hope this works"""
+
+        pass
+
+    # WHEN we serialize the node
+    node_display_class = get_node_display_class(MyNode)
+    data = node_display_class().serialize(WorkflowDisplayContext())
+
+    # THEN the condition should be serialized correctly
+    assert data["display_data"] == {
+        "position": {"x": 0.0, "y": 0.0},
+        "comment": {"value": "I hope this works"},
+    }

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_ee/workflows/display/nodes/vellum/api_node.py

@@ -4,7 +4,7 @@ from typing import Any, ClassVar, Dict, Generic, Optional, TypeVar, cast
 from vellum.workflows.nodes.displayable import APINode
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
-from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -13,7 +13,7 @@ from vellum_ee.workflows.display.utils.vellum import WorkspaceSecretPointer
 _APINodeType = TypeVar("_APINodeType", bound=APINode)
 
 
-class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeType]):
+class BaseAPINodeDisplay(BaseNodeDisplay[_APINodeType], Generic[_APINodeType]):
     # A mapping between node input keys and their ids for inputs representing additional header keys
     additional_header_key_input_ids: ClassVar[Optional[Dict[str, UUID]]] = None
 

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_ee/workflows/display/nodes/vellum/base_adornment_node.py

@@ -10,10 +10,10 @@ 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.nodes.types import NodeOutputDisplay
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum_ee.workflows.display.utils.registry import register_node_display_class
 
 _BaseAdornmentNodeType = TypeVar("_BaseAdornmentNodeType", bound=BaseAdornmentNode)
 
@@ -31,7 +31,7 @@ def _recursively_replace_wrapped_node(node_class: Type[BaseNode], wrapped_node_d
     # 1. The node display class' parameterized type
     original_base_node_display = get_original_base(wrapped_node_display_class)
     original_base_node_display.__args__ = (wrapped_node_class,)
-    wrapped_node_display_class._node_display_registry[wrapped_node_class] = wrapped_node_display_class
+    register_node_display_class(node_class=wrapped_node_class, node_display_class=wrapped_node_display_class)
     wrapped_node_display_class.__annotate_node__()
 
     # 2. The node display class' output displays
@@ -71,7 +71,7 @@ def _recursively_replace_wrapped_node(node_class: Type[BaseNode], wrapped_node_d
         )
 
 
-class BaseAdornmentNodeDisplay(BaseNodeVellumDisplay[_BaseAdornmentNodeType], Generic[_BaseAdornmentNodeType]):
+class BaseAdornmentNodeDisplay(BaseNodeDisplay[_BaseAdornmentNodeType], Generic[_BaseAdornmentNodeType]):
     __wrapped_node_display__: Optional[Type[BaseNodeDisplay]] = None
 
     def serialize(
@@ -89,7 +89,7 @@ class BaseAdornmentNodeDisplay(BaseNodeVellumDisplay[_BaseAdornmentNodeType], Ge
                 "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_class = get_node_display_class(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)

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_ee/workflows/display/nodes/vellum/code_execution_node.py

@@ -6,7 +6,7 @@ from vellum.workflows.nodes.displayable.code_execution_node import CodeExecution
 from vellum.workflows.nodes.displayable.code_execution_node.utils import read_file_from_path
 from vellum.workflows.types.core import JsonObject
 from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
-from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -14,7 +14,7 @@ from vellum_ee.workflows.display.types import WorkflowDisplayContext
 _CodeExecutionNodeType = TypeVar("_CodeExecutionNodeType", bound=CodeExecutionNode)
 
 
-class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType], Generic[_CodeExecutionNodeType]):
+class BaseCodeExecutionNodeDisplay(BaseNodeDisplay[_CodeExecutionNodeType], Generic[_CodeExecutionNodeType]):
     output_id: ClassVar[Optional[UUID]] = None
     log_output_id: ClassVar[Optional[UUID]] = None
 

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_ee/workflows/display/nodes/vellum/conditional_node.py

@@ -16,7 +16,7 @@ from vellum.workflows.expressions.or_ import OrExpression
 from vellum.workflows.nodes.displayable import ConditionalNode
 from vellum.workflows.types.core import ConditionType, JsonObject
 from vellum.workflows.utils.uuids import uuid4_from_hash
-from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 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.utils.vellum import convert_descriptor_to_operator
@@ -40,7 +40,7 @@ class ConditionId:
     rule_group_id: Optional[str]
 
 
-class BaseConditionalNodeDisplay(BaseNodeVellumDisplay[_ConditionalNodeType], Generic[_ConditionalNodeType]):
+class BaseConditionalNodeDisplay(BaseNodeDisplay[_ConditionalNodeType], Generic[_ConditionalNodeType]):
     source_handle_ids: ClassVar[Dict[int, UUID]]
     rule_ids: ClassVar[List[RuleIdMap]]
     condition_ids: ClassVar[list[ConditionId]]

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_ee/workflows/display/nodes/vellum/error_node.py

@@ -3,7 +3,7 @@ from typing import ClassVar, Generic, Optional, TypeVar
 
 from vellum.workflows.nodes import ErrorNode
 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.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -11,7 +11,7 @@ from vellum_ee.workflows.display.types import WorkflowDisplayContext
 _ErrorNodeType = TypeVar("_ErrorNodeType", bound=ErrorNode)
 
 
-class BaseErrorNodeDisplay(BaseNodeVellumDisplay[_ErrorNodeType], Generic[_ErrorNodeType]):
+class BaseErrorNodeDisplay(BaseNodeDisplay[_ErrorNodeType], Generic[_ErrorNodeType]):
     error_output_id: ClassVar[Optional[UUID]] = None
 
     name: ClassVar[str] = "error-node"

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_ee/workflows/display/nodes/vellum/final_output_node.py

@@ -4,7 +4,7 @@ from typing import Any, ClassVar, Generic, Optional, TypeVar
 from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
 from vellum.workflows.types.core import JsonObject
 from vellum.workflows.utils.uuids import uuid4_from_hash
-from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import to_kebab_case
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -13,7 +13,7 @@ from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
 _FinalOutputNodeType = TypeVar("_FinalOutputNodeType", bound=FinalOutputNode)
 
 
-class BaseFinalOutputNodeDisplay(BaseNodeVellumDisplay[_FinalOutputNodeType], Generic[_FinalOutputNodeType]):
+class BaseFinalOutputNodeDisplay(BaseNodeDisplay[_FinalOutputNodeType], Generic[_FinalOutputNodeType]):
     output_id: ClassVar[Optional[UUID]] = None
     output_name: ClassVar[Optional[str]] = None
     node_input_id: ClassVar[Optional[UUID]] = None

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_ee/workflows/display/nodes/vellum/guardrail_node.py

@@ -3,7 +3,7 @@ from typing import Generic, Optional, TypeVar
 
 from vellum.workflows.nodes import GuardrailNode
 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.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -11,7 +11,7 @@ from vellum_ee.workflows.display.types import WorkflowDisplayContext
 _GuardrailNodeType = TypeVar("_GuardrailNodeType", bound=GuardrailNode)
 
 
-class BaseGuardrailNodeDisplay(BaseNodeVellumDisplay[_GuardrailNodeType], Generic[_GuardrailNodeType]):
+class BaseGuardrailNodeDisplay(BaseNodeDisplay[_GuardrailNodeType], Generic[_GuardrailNodeType]):
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -6,7 +6,7 @@ from vellum.workflows.nodes import InlinePromptNode
 from vellum.workflows.types.core import JsonObject
 from vellum.workflows.utils.functions import compile_function_definition
 from vellum.workflows.utils.uuids import uuid4_from_hash
-from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -16,7 +16,7 @@ from vellum_ee.workflows.display.vellum import NodeInput
 _InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
 
 
-class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType], Generic[_InlinePromptNodeType]):
+class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generic[_InlinePromptNodeType]):
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py

@@ -5,7 +5,7 @@ from vellum import VellumVariable
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes import InlineSubworkflowNode
 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.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -17,7 +17,7 @@ _InlineSubworkflowNodeType = TypeVar("_InlineSubworkflowNodeType", bound=InlineS
 
 
 class BaseInlineSubworkflowNodeDisplay(
-    BaseNodeVellumDisplay[_InlineSubworkflowNodeType], Generic[_InlineSubworkflowNodeType]
+    BaseNodeDisplay[_InlineSubworkflowNodeType], Generic[_InlineSubworkflowNodeType]
 ):
     workflow_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
 

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_ee/workflows/display/nodes/vellum/merge_node.py

@@ -4,13 +4,13 @@ from typing import Any, ClassVar, Generic, List, Optional, TypeVar
 from vellum.workflows.nodes.displayable import MergeNode
 from vellum.workflows.types.core import JsonObject
 from vellum.workflows.utils.uuids import uuid4_from_hash
-from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 
 _MergeNodeType = TypeVar("_MergeNodeType", bound=MergeNode)
 
 
-class BaseMergeNodeDisplay(BaseNodeVellumDisplay[_MergeNodeType], Generic[_MergeNodeType]):
+class BaseMergeNodeDisplay(BaseNodeDisplay[_MergeNodeType], Generic[_MergeNodeType]):
     target_handle_ids: ClassVar[List[UUID]]
 
     def __init__(self):

{vellum_ai-0.14.39 → vellum_ai-0.14.41}/ee/vellum_ee/workflows/display/nodes/vellum/note_node.py

@@ -2,13 +2,13 @@ from typing import Any, ClassVar, Dict, Generic, TypeVar, Union
 
 from vellum.workflows.nodes import NoteNode
 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.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 
 _NoteNodeType = TypeVar("_NoteNodeType", bound=NoteNode)
 
 
-class BaseNoteNodeDisplay(BaseNodeVellumDisplay[_NoteNodeType], Generic[_NoteNodeType]):
+class BaseNoteNodeDisplay(BaseNodeDisplay[_NoteNodeType], Generic[_NoteNodeType]):
     text: ClassVar[str] = ""
     style: ClassVar[Union[Dict[str, Any], None]] = None