vellum-ai 0.14.17__tar.gz → 0.14.19__tar.gz

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/PKG-INFO

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

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -129,13 +129,16 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 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)),
-                }
-            )
+            try:
+                attributes.append(
+                    {
+                        "id": id,
+                        "name": attribute.name,
+                        "value": self.serialize_value(display_context, attribute.instance),
+                    }
+                )
+            except ValueError as e:
+                raise ValueError(f"Failed to serialize attribute '{attribute.name}': {e}")
 
         adornments = kwargs.get("adornments", None)
         wrapped_node = get_wrapped_node(node)
@@ -369,7 +372,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 "rhs": rhs,
             }
 
-    def serialize_value(self, display_context: "WorkflowDisplayContext", value: BaseDescriptor) -> JsonObject:
+    def serialize_value(self, display_context: "WorkflowDisplayContext", value: Any) -> JsonObject:
         if isinstance(value, ConstantValueReference):
             return self.serialize_value(display_context, value._value)
 
@@ -415,6 +418,9 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
                 "node_id": str(node_class_display.node_id),
             }
 
+        if isinstance(value, dict) and any(isinstance(v, BaseDescriptor) for v in value.values()):
+            raise ValueError("Nested references are not supported.")
+
         if not isinstance(value, BaseDescriptor):
             vellum_value = primitive_to_vellum_value(value)
             return {

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/ee/vellum_ee/workflows/display/nodes/vellum/code_execution_node.py

@@ -15,9 +15,6 @@ _CodeExecutionNodeType = TypeVar("_CodeExecutionNodeType", bound=CodeExecutionNo
 
 
 class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType], Generic[_CodeExecutionNodeType]):
-    code_input_id: ClassVar[Optional[UUID]] = None
-    runtime_input_id: ClassVar[Optional[UUID]] = None
-
     output_id: ClassVar[Optional[UUID]] = None
     log_output_id: ClassVar[Optional[UUID]] = None
 
@@ -52,19 +49,22 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
             for variable_name, variable_value in code_inputs.items()
         ]
 
+        code_input_id = self.node_input_ids_by_name.get(CodeExecutionNode.code.name)
         code_node_input = create_node_input(
             node_id=node_id,
             input_name="code",
             value=code_value,
             display_context=display_context,
-            input_id=self.code_input_id,
+            input_id=code_input_id,
         )
+
+        runtime_input_id = self.node_input_ids_by_name.get(CodeExecutionNode.runtime.name)
         runtime_node_input = create_node_input(
             node_id=node_id,
             input_name="runtime",
             value=node.runtime,
             display_context=display_context,
-            input_id=self.runtime_input_id,
+            input_id=runtime_input_id,
         )
         inputs.extend([code_node_input, runtime_node_input])
 
@@ -84,8 +84,8 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
                 "error_output_id": str(error_output_id) if error_output_id else None,
                 "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
                 "target_handle_id": str(self.get_target_handle_id()),
-                "code_input_id": str(self.code_input_id) if self.code_input_id else code_node_input.id,
-                "runtime_input_id": str(self.runtime_input_id) if self.runtime_input_id else runtime_node_input.id,
+                "code_input_id": code_node_input.id,
+                "runtime_input_id": runtime_node_input.id,
                 "output_type": output_type,
                 "packages": [package.dict() for package in packages] if packages is not None else [],
                 "output_id": str(self.output_id) if self.output_id else str(output_display.id),

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -19,7 +19,6 @@ _InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
 class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType], Generic[_InlinePromptNodeType]):
     output_id: ClassVar[Optional[UUID]] = None
     array_output_id: ClassVar[Optional[UUID]] = None
-    json_output_id: ClassVar[Optional[UUID]] = None
     prompt_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
 
     def serialize(
@@ -33,6 +32,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
 
         _, output_display = display_context.global_node_output_displays[node.Outputs.text]
         _, array_display = display_context.global_node_output_displays[node.Outputs.results]
+        _, json_display = display_context.global_node_output_displays[node.Outputs.json]
         node_blocks = raise_if_descriptor(node.blocks)
         function_definitions = raise_if_descriptor(node.functions)
 
@@ -71,6 +71,11 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
             "display_data": self.get_display_data().dict(),
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
+            "outputs": [
+                {"id": str(json_display.id), "name": "json", "type": "JSON", "value": None},
+                {"id": str(output_display.id), "name": "text", "type": "STRING", "value": None},
+                {"id": str(array_display.id), "name": "results", "type": "ARRAY", "value": None},
+            ],
         }
 
     def _generate_node_and_prompt_inputs(

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/ee/vellum_ee/workflows/display/nodes/vellum/templating_node.py

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import ClassVar, Generic, Optional, TypeVar
+from typing import Generic, Optional, TypeVar
 
 from vellum.workflows.nodes.core.templating_node import TemplatingNode
 from vellum.workflows.types.core import JsonObject
@@ -11,23 +11,21 @@ from vellum_ee.workflows.display.types import WorkflowDisplayContext
 
 _TemplatingNodeType = TypeVar("_TemplatingNodeType", bound=TemplatingNode)
 
-TEMPLATE_INPUT_NAME = "template"
+TEMPLATE_INPUT_NAME = TemplatingNode.template.name
 
 
 class BaseTemplatingNodeDisplay(BaseNodeVellumDisplay[_TemplatingNodeType], Generic[_TemplatingNodeType]):
-    template_input_id: ClassVar[Optional[UUID]] = None
-
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id
 
-        template_input_id = self.template_input_id or self.node_input_ids_by_name.get(TEMPLATE_INPUT_NAME)
+        template_input_id = self.node_input_ids_by_name.get(TEMPLATE_INPUT_NAME)
 
         template_node_input = create_node_input(
             node_id=node_id,
-            input_name="template",
+            input_name=TEMPLATE_INPUT_NAME,
             value=node.template,
             display_context=display_context,
             input_id=template_input_id,
@@ -39,7 +37,8 @@ class BaseTemplatingNodeDisplay(BaseNodeVellumDisplay[_TemplatingNodeType], Gene
                 input_name=variable_name,
                 value=variable_value,
                 display_context=display_context,
-                input_id=self.node_input_ids_by_name.get(variable_name),
+                input_id=self.node_input_ids_by_name.get(f"{TemplatingNode.inputs.name}.{variable_name}")
+                or self.node_input_ids_by_name.get(variable_name),
             )
             for variable_name, variable_value in template_node_inputs.items()
             if variable_name != TEMPLATE_INPUT_NAME

vellum_ai-0.14.19/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_templating_node.py

@@ -0,0 +1,97 @@
+import pytest
+from uuid import UUID
+from typing import Type
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes.core.templating_node.node import TemplatingNode
+from vellum_ee.workflows.display.nodes.vellum.templating_node import BaseTemplatingNodeDisplay
+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 _no_display_class(Node: Type[TemplatingNode]):
+    return None
+
+
+def _display_class_with_node_input_ids_by_name(Node: Type[TemplatingNode]):
+    class TemplatingNodeDisplay(BaseTemplatingNodeDisplay[Node]):  # type: ignore[valid-type]
+        node_input_ids_by_name = {"foo": UUID("fba6a4d5-835a-4e99-afb7-f6a4aed15110")}
+
+    return TemplatingNodeDisplay
+
+
+def _display_class_with_node_input_ids_by_name_with_inputs_prefix(Node: Type[TemplatingNode]):
+    class TemplatingNodeDisplay(BaseTemplatingNodeDisplay[Node]):  # type: ignore[valid-type]
+        node_input_ids_by_name = {"inputs.foo": UUID("fba6a4d5-835a-4e99-afb7-f6a4aed15110")}
+
+    return TemplatingNodeDisplay
+
+
+@pytest.mark.parametrize(
+    ["GetDisplayClass", "expected_input_id"],
+    [
+        (_no_display_class, "d3519cec-590c-416d-8eb1-96051aed5ddd"),
+        (_display_class_with_node_input_ids_by_name, "fba6a4d5-835a-4e99-afb7-f6a4aed15110"),
+        (_display_class_with_node_input_ids_by_name_with_inputs_prefix, "fba6a4d5-835a-4e99-afb7-f6a4aed15110"),
+    ],
+    ids=[
+        "no_display_class",
+        "display_class_with_node_input_ids_by_name",
+        "display_class_with_node_input_ids_by_name_with_inputs_prefix",
+    ],
+)
+def test_serialize_node__templating_node_inputs(GetDisplayClass, expected_input_id):
+    # GIVEN a templating node with inputs
+    class MyTemplatingNode(TemplatingNode):
+        inputs = {"foo": "bar"}
+
+    # AND a workflow with the templating node
+    class Workflow(BaseWorkflow):
+        graph = MyTemplatingNode
+
+    # AND a display class
+    GetDisplayClass(MyTemplatingNode)
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(base_display_class=VellumWorkflowDisplay, workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the inputs
+    my_templating_node = next(
+        node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["type"] == "TEMPLATING"
+    )
+
+    assert my_templating_node["inputs"] == [
+        {
+            "id": "b7d971ee-9156-46b2-9bf0-9292875211f8",
+            "key": "template",
+            "value": {
+                "combinator": "OR",
+                "rules": [
+                    {
+                        "type": "CONSTANT_VALUE",
+                        "data": {
+                            "type": "STRING",
+                            "value": "",
+                        },
+                    }
+                ],
+            },
+        },
+        {
+            "id": expected_input_id,
+            "key": "foo",
+            "value": {
+                "combinator": "OR",
+                "rules": [
+                    {
+                        "type": "CONSTANT_VALUE",
+                        "data": {
+                            "type": "STRING",
+                            "value": "bar",
+                        },
+                    }
+                ],
+            },
+        },
+    ]

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/ee/vellum_ee/workflows/display/nodes/vellum/utils.py

@@ -54,7 +54,7 @@ def create_node_input_value_pointer_rules(
 
     if isinstance(value, BaseDescriptor):
         if isinstance(value, NodeReference):
-            if not value.instance:
+            if value.instance is None:
                 raise ValueError(f"Expected NodeReference {value.name} to have an instance")
             value = cast(BaseDescriptor, value.instance)
 

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/ee/vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py

@@ -1,12 +1,16 @@
+import pytest
 from uuid import uuid4
+from typing import List
 
 from deepdiff import DeepDiff
 
+from vellum.client.types.chat_message import ChatMessage
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.references.constant import ConstantValueReference
 from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
+from vellum.workflows.state.base import BaseState
 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
@@ -237,6 +241,33 @@ def test_serialize_node__workflow_input(serialize_node):
     )
 
 
+def test_serialize_node__workflow_input_as_nested_chat_history():
+    # GIVEN workflow inputs as chat history
+    class Inputs(BaseInputs):
+        chat_history: List[ChatMessage]
+
+    # AND a node referencing the workflow input
+    class GenericNode(BaseNode):
+        attr = {
+            "hello": Inputs.chat_history,
+        }
+
+    # AND a workflow with the node
+    class Workflow(BaseWorkflow[Inputs, BaseState]):
+        graph = GenericNode
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay,
+        workflow_class=Workflow,
+    )
+    with pytest.raises(Exception) as exc_info:
+        workflow_display.serialize()
+
+    # THEN we should raise a user facing error
+    assert str(exc_info.value) == "Failed to serialize attribute 'attr': Nested references are not supported."
+
+
 def test_serialize_node__node_output(serialize_node):
     class NodeWithOutput(BaseNode):
         class Outputs(BaseNode.Outputs):

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_node_serialization.py

@@ -85,7 +85,7 @@ def test_serialize_workflow():
                     },
                 },
                 {
-                    "id": "bb712499-4265-4d71-bc14-0c3d8ca6a7de",
+                    "id": "e6c9d062-1a4f-4d4d-a258-59b75c6062fc",
                     "key": "info",
                     "value": {
                         "rules": [

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/ee/vellum_ee/workflows/display/vellum.py

@@ -1,11 +1,10 @@
 from dataclasses import dataclass, field
-from enum import Enum
 from uuid import UUID
 from typing import List, Literal, Optional, Union
 
 from pydantic import Field
 
-from vellum import PromptParameters, VellumVariable, VellumVariableType
+from vellum import VellumVariableType
 from vellum.client.types.array_vellum_value import ArrayVellumValue
 from vellum.client.types.vellum_value import VellumValue
 from vellum.core import UniversalBaseModel
@@ -138,24 +137,6 @@ class WorkflowOutputVellumDisplay(WorkflowOutputVellumDisplayOverrides):
     pass
 
 
-class WorkflowNodeType(str, Enum):
-    PROMPT = "PROMPT"
-    TEMPLATING = "TEMPLATING"
-    NOTE = "NOTE"
-    CODE_EXECUTION = "CODE_EXECUTION"
-    METRIC = "METRIC"
-    SEARCH = "SEARCH"
-    WEBHOOK = "WEBHOOK"
-    MERGE = "MERGE"
-    CONDITIONAL = "CONDITIONAL"
-    API = "API"
-    ENTRYPOINT = "ENTRYPOINT"
-    TERMINAL = "TERMINAL"
-    SUBWORKFLOW = "SUBWORKFLOW"
-    MAP = "MAP"
-    ERROR = "ERROR"
-
-
 class ConstantValuePointer(UniversalBaseModel):
     type: Literal["CONSTANT_VALUE"] = "CONSTANT_VALUE"
     data: VellumValue
@@ -220,131 +201,3 @@ class NodeInput(UniversalBaseModel):
     id: str
     key: str
     value: NodeInputValuePointer
-
-
-class BaseWorkflowNode(UniversalBaseModel):
-    id: str
-    inputs: List[NodeInput]
-    type: str
-    display_data: Optional[NodeDisplayData] = None
-    base: CodeResourceDefinition
-    definition: CodeResourceDefinition
-
-
-class EntrypointNodeData(UniversalBaseModel):
-    source_handle_id: str
-
-
-class EntrypointNode(BaseWorkflowNode):
-    type: Literal[WorkflowNodeType.ENTRYPOINT] = WorkflowNodeType.ENTRYPOINT
-    data: EntrypointNodeData
-
-
-class PromptTemplateBlockData(UniversalBaseModel):
-    version: Literal[1] = 1
-    # blocks: List[PromptBlockRequest]
-
-
-class PromptVersionExecConfig(UniversalBaseModel):
-    parameters: PromptParameters
-    input_variables: List[VellumVariable]
-    prompt_template_block_data: PromptTemplateBlockData
-
-
-class BasePromptNodeData(UniversalBaseModel):
-    label: str
-    output_id: str
-    error_output_id: Optional[str] = None
-    array_output_id: str
-    source_handle_id: str
-    target_handle_id: str
-
-
-class InlinePromptNodeData(BasePromptNodeData):
-    variant: Literal["INLINE"] = "INLINE"
-    exec_config: PromptVersionExecConfig
-    ml_model_name: str
-
-
-class DeploymentPromptNodeData(BasePromptNodeData):
-    variant: Literal["DEPLOYMENT"] = "DEPLOYMENT"
-    deployment_id: str
-    release_tag: str
-
-
-PromptNodeData = Union[
-    InlinePromptNodeData,
-    DeploymentPromptNodeData,
-]
-
-
-class PromptNode(BaseWorkflowNode):
-    type: Literal[WorkflowNodeType.PROMPT] = WorkflowNodeType.PROMPT
-    data: PromptNodeData
-
-
-class SearchNodeData(UniversalBaseModel):
-    label: str
-
-    results_output_id: str
-    text_output_id: str
-    error_output_id: Optional[str] = None
-
-    source_handle_id: str
-    target_handle_id: str
-
-    query_node_input_id: str
-    document_index_node_input_id: str
-    weights_node_input_id: str
-    limit_node_input_id: str
-    separator_node_input_id: str
-    result_merging_enabled_node_input_id: str
-    external_id_filters_node_input_id: str
-    metadata_filters_node_input_id: str
-
-
-class SearchNode(BaseWorkflowNode):
-    type: Literal[WorkflowNodeType.SEARCH] = WorkflowNodeType.SEARCH
-    data: SearchNodeData
-
-
-class FinalOutputNodeData(UniversalBaseModel):
-    label: str
-    name: str
-    target_handle_id: str
-    output_id: str
-    output_type: VellumVariableType
-    node_input_id: str
-
-
-class FinalOutputNode(BaseWorkflowNode):
-    type: Literal[WorkflowNodeType.TERMINAL] = WorkflowNodeType.TERMINAL
-    data: FinalOutputNodeData
-
-
-WorkflowNode = Union[
-    EntrypointNode,
-    PromptNode,
-    SearchNode,
-    FinalOutputNode,
-]
-
-
-class WorkflowEdge(UniversalBaseModel):
-    id: str
-    source_node_id: str
-    source_handle_id: str
-    target_node_id: str
-    target_handle_id: str
-
-
-class WorkflowRawData(UniversalBaseModel):
-    nodes: List[WorkflowNode]
-    edges: List[WorkflowEdge]
-    display_data: Optional[WorkflowDisplayData] = None
-
-
-class WorkflowVersionExecConfig(UniversalBaseModel):
-    workflow_raw_data: WorkflowRawData
-    input_variables: List[VellumVariable]
-    output_variables: List[VellumVariable]

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -429,7 +429,7 @@ class BaseWorkflowDisplay(
                     )
                     subworkflow_display_context = subworkflow_display.get_event_display_context()
 
-            node_event_displays[str(node_id)] = NodeEventDisplayContext(
+            node_event_displays[node_id] = NodeEventDisplayContext(
                 input_display=input_display,
                 output_display=output_display,
                 port_display=port_display_meta,

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/ee/vellum_ee/workflows/display/workflows/tests/test_workflow_display.py

@@ -114,8 +114,8 @@ def test_get_event_display_context__node_display_filled_without_base_display():
     display_context = VellumWorkflowDisplay(MyWorkflow).get_event_display_context()
 
     # THEN the node display should be included
-    assert str(StartNode.__id__) in display_context.node_displays
-    node_event_display = display_context.node_displays[str(StartNode.__id__)]
+    assert StartNode.__id__ in display_context.node_displays
+    node_event_display = display_context.node_displays[StartNode.__id__]
 
     # AND so should their output ids
     assert StartNode.__output_ids__ == node_event_display.output_display
@@ -137,8 +137,8 @@ def test_get_event_display_context__node_display_filled_without_output_display()
     display_context = VellumWorkflowDisplay(MyWorkflow).get_event_display_context()
 
     # THEN the node display should be included
-    assert str(StartNode.__id__) in display_context.node_displays
-    node_event_display = display_context.node_displays[str(StartNode.__id__)]
+    assert StartNode.__id__ in display_context.node_displays
+    node_event_display = display_context.node_displays[StartNode.__id__]
 
     # AND so should their output ids
     assert node_event_display.output_display.keys() == {"foo"}
@@ -163,11 +163,11 @@ def test_get_event_display_context__node_display_to_include_subworkflow_display(
     display_context = VellumWorkflowDisplay(MyWorkflow).get_event_display_context()
 
     # THEN the subworkflow display should be included
-    assert str(SubworkflowNode.__id__) in display_context.node_displays
-    node_event_display = display_context.node_displays[str(SubworkflowNode.__id__)]
+    assert SubworkflowNode.__id__ in display_context.node_displays
+    node_event_display = display_context.node_displays[SubworkflowNode.__id__]
 
     assert node_event_display.subworkflow_display is not None
-    assert str(InnerNode.__id__) in node_event_display.subworkflow_display.node_displays
+    assert InnerNode.__id__ in node_event_display.subworkflow_display.node_displays
 
 
 @pytest.mark.parametrize(
@@ -204,13 +204,13 @@ def test_get_event_display_context__node_display_for_adornment_nodes(
     display_context = VellumWorkflowDisplay(MyWorkflow).get_event_display_context()
 
     # THEN the subworkflow display should be included
-    assert str(adornment_node_id) in display_context.node_displays
-    node_event_display = display_context.node_displays[str(adornment_node_id)]
+    assert adornment_node_id in display_context.node_displays
+    node_event_display = display_context.node_displays[adornment_node_id]
     assert node_event_display.subworkflow_display is not None
-    assert str(inner_node_id) in node_event_display.subworkflow_display.node_displays
+    assert inner_node_id in node_event_display.subworkflow_display.node_displays
 
     # AND the inner node should have the correct outputs
-    inner_node_display = node_event_display.subworkflow_display.node_displays[str(inner_node_id)]
+    inner_node_display = node_event_display.subworkflow_display.node_displays[inner_node_id]
     assert inner_node_display.output_display.keys() == {"foo"}
     assert node_event_display.output_display.keys() == expected_adornment_output_names
 
@@ -231,7 +231,7 @@ def test_get_event_display_context__templating_node_input_display():
     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 MyNode.__id__ in display_context.node_displays
+    node_event_display = display_context.node_displays[MyNode.__id__]
 
     assert node_event_display.input_display.keys() == {"inputs.foo"}

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/ee/vellum_ee/workflows/tests/test_display_meta.py

@@ -1,7 +1,7 @@
 import pytest
 import os
 import sys
-from uuid import UUID, uuid4
+from uuid import uuid4
 
 from vellum.workflows import BaseWorkflow
 from vellum_ee.workflows.display.workflows import BaseWorkflowDisplay
@@ -35,22 +35,22 @@ def test_base_class_dynamic_import(files):
         "node_displays": {
             "533c6bd8-6088-4abc-a168-8c1758abcd33": {
                 "input_display": {
-                    "example_var_1": UUID("a0d1d7cf-242a-4bd9-a437-d308a7ced9b3"),
-                    "template": UUID("f97d721a-e685-498e-90c3-9c3d9358fdad"),
+                    "example_var_1": "a0d1d7cf-242a-4bd9-a437-d308a7ced9b3",
+                    "template": "f97d721a-e685-498e-90c3-9c3d9358fdad",
                 },
-                "output_display": {"result": UUID("423bc529-1a1a-4f72-af4d-cbdb5f0a5929")},
-                "port_display": {"default": UUID("afda9a19-0618-42e1-9b63-5d0db2a88f62")},
+                "output_display": {"result": "423bc529-1a1a-4f72-af4d-cbdb5f0a5929"},
+                "port_display": {"default": "afda9a19-0618-42e1-9b63-5d0db2a88f62"},
                 "subworkflow_display": None,
             },
             "f3ef4b2b-fec9-4026-9cc6-e5eac295307f": {
-                "input_display": {"node_input": UUID("fe6cba85-2423-4b5e-8f85-06311a8be5fb")},
-                "output_display": {"value": UUID("5469b810-6ea6-4362-9e79-e360d44a1405")},
+                "input_display": {"node_input": "fe6cba85-2423-4b5e-8f85-06311a8be5fb"},
+                "output_display": {"value": "5469b810-6ea6-4362-9e79-e360d44a1405"},
                 "port_display": {},
                 "subworkflow_display": None,
             },
         },
-        "workflow_inputs": {"input_value": UUID("2268a996-bd17-4832-b3ff-f5662d54b306")},
-        "workflow_outputs": {"final_output": UUID("5469b810-6ea6-4362-9e79-e360d44a1405")},
+        "workflow_inputs": {"input_value": "2268a996-bd17-4832-b3ff-f5662d54b306"},
+        "workflow_outputs": {"final_output": "5469b810-6ea6-4362-9e79-e360d44a1405"},
     }
     assert display_meta
-    assert display_meta.dict() == expected_result
+    assert display_meta.model_dump(mode="json") == expected_result

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.14.17"
+version = "0.14.19"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/src/vellum/__init__.py

@@ -229,6 +229,7 @@ from .types import (
     NodeInputCompiledJsonValue,
     NodeInputCompiledNumberValue,
     NodeInputCompiledSearchResultsValue,
+    NodeInputCompiledSecretValue,
     NodeInputCompiledStringValue,
     NodeInputVariableCompiledValue,
     NodeOutputCompiledArrayValue,
@@ -777,6 +778,7 @@ __all__ = [
     "NodeInputCompiledJsonValue",
     "NodeInputCompiledNumberValue",
     "NodeInputCompiledSearchResultsValue",
+    "NodeInputCompiledSecretValue",
     "NodeInputCompiledStringValue",
     "NodeInputVariableCompiledValue",
     "NodeOutputCompiledArrayValue",

{vellum_ai-0.14.17 → vellum_ai-0.14.19}/src/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.17",
+            "X-Fern-SDK-Version": "0.14.19",
         }
         headers["X_API_KEY"] = self.api_key
         return headers