vellum-ai 0.14.63__py3-none-any.whl → 1.13.5__py3-none-any.whl

vellum_ee/workflows/display/nodes/vellum/tests/test_try_node.py

@@ -42,7 +42,7 @@ def test_try_node_display__serialize_with_error_output() -> None:
             {
                 "data": {
                     "node_id": str(MyNode.__wrapped_node__.__id__),
-                    "output_id": "c8fbe459-c9ee-4639-a82d-961180cf9411",
+                    "output_id": "75bb6e13-0cf0-4651-9141-658be1d5acaa",
                 },
                 "type": "NODE_OUTPUT",
             }
@@ -54,7 +54,7 @@ def test_try_node_display__serialize_with_error_output() -> None:
             {
                 "data": {
                     "node_id": str(MyNode.__wrapped_node__.__id__),
-                    "output_id": "efe6e307-3ea4-4862-a26f-4c4416bb4537",
+                    "output_id": "16b4d0ee-d309-4622-b812-3bd8f8c8a73c",
                 },
                 "type": "NODE_OUTPUT",
             }

vellum_ee/workflows/display/nodes/vellum/tests/test_utils.py

@@ -1,4 +1,5 @@
 import pytest
+from unittest.mock import patch
 from uuid import UUID, uuid4
 from typing import List
 
@@ -8,10 +9,15 @@ from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.references import LazyReference
+from vellum.workflows.references.state_value import StateValueReference
+from vellum.workflows.references.trigger import TriggerAttributeReference
+from vellum.workflows.state import BaseState
+from vellum.workflows.triggers.base import BaseTrigger
+from vellum_ee.workflows.display.base import StateValueDisplay, WorkflowInputsDisplay, WorkflowMetaDisplay
 from vellum_ee.workflows.display.editor.types import NodeDisplayData
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
-from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input_value_pointer_rules
+from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input, create_node_input_value_pointer_rules
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 from vellum_ee.workflows.display.utils.vellum import (
     ConstantValuePointer,
@@ -20,8 +26,12 @@ from vellum_ee.workflows.display.utils.vellum import (
     NodeInputValuePointerRule,
     NodeOutputData,
     NodeOutputPointer,
+    TriggerAttributeData,
+    TriggerAttributePointer,
+    WorkflowStateData,
+    WorkflowStatePointer,
+    create_node_input_value_pointer_rule,
 )
-from vellum_ee.workflows.display.vellum import WorkflowInputsVellumDisplayOverrides, WorkflowMetaVellumDisplay
 from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 
 
@@ -57,7 +67,7 @@ class MyNodeB(BaseNode):
             [
                 NodeOutputPointer(
                     data=NodeOutputData(
-                        node_id="b48fa5e0-d7d3-4fe3-ae48-615415011cc5",
+                        node_id="f2f8f47a-25de-474c-95d7-df4f9b4cb5ac",
                         output_id="4b16a629-11a1-4b3f-a965-a57b872d13b8",
                     )
                 )
@@ -68,7 +78,7 @@ class MyNodeB(BaseNode):
             [
                 NodeOutputPointer(
                     data=NodeOutputData(
-                        node_id="b48fa5e0-d7d3-4fe3-ae48-615415011cc5",
+                        node_id="f2f8f47a-25de-474c-95d7-df4f9b4cb5ac",
                         output_id="4b16a629-11a1-4b3f-a965-a57b872d13b8",
                     ),
                 ),
@@ -92,7 +102,7 @@ class MyNodeB(BaseNode):
             [
                 NodeOutputPointer(
                     data=NodeOutputData(
-                        node_id="b48fa5e0-d7d3-4fe3-ae48-615415011cc5",
+                        node_id="f2f8f47a-25de-474c-95d7-df4f9b4cb5ac",
                         output_id="4b16a629-11a1-4b3f-a965-a57b872d13b8",
                     ),
                 ),
@@ -110,25 +120,119 @@ def test_create_node_input_value_pointer_rules(
         descriptor,
         WorkflowDisplayContext(
             workflow_display_class=BaseWorkflowDisplay,
-            workflow_display=WorkflowMetaVellumDisplay(
+            workflow_display=WorkflowMetaDisplay(
                 entrypoint_node_id=uuid4(),
                 entrypoint_node_source_handle_id=uuid4(),
                 entrypoint_node_display=NodeDisplayData(),
             ),
             global_workflow_input_displays={
-                Inputs.example_workflow_input: WorkflowInputsVellumDisplayOverrides(
+                Inputs.example_workflow_input: WorkflowInputsDisplay(
                     id=UUID("a154c29d-fac0-4cd0-ba88-bc52034f5470"),
                 ),
             },
             global_node_output_displays={
-                MyNodeA.Outputs.output: (
-                    MyNodeA,
-                    NodeOutputDisplay(id=UUID("4b16a629-11a1-4b3f-a965-a57b872d13b8"), name="output"),
+                MyNodeA.Outputs.output: NodeOutputDisplay(
+                    id=UUID("4b16a629-11a1-4b3f-a965-a57b872d13b8"), name="output"
                 ),
             },
             global_node_displays={
                 MyNodeA: MyNodeADisplay(),
             },
         ),
+        uuid4(),
     )
     assert rules == expected_rules
+
+
+class MyState(BaseState):
+    my_attribute: str
+
+
+def test_create_node_input_value_pointer_rule__state_value_reference() -> None:
+    """
+    Tests that StateValueReference is serialized to WorkflowStatePointer using the display override ID.
+    """
+
+    # GIVEN a StateValueReference
+    state_value_reference: StateValueReference[str] = MyState.my_attribute  # type: ignore[assignment]
+
+    # AND a display context with a state value display override
+    override_id = uuid4()
+    display_context = WorkflowDisplayContext(
+        global_state_value_displays={
+            state_value_reference: StateValueDisplay(id=override_id),
+        },
+    )
+
+    # WHEN we create a node input value pointer rule
+    result = create_node_input_value_pointer_rule(state_value_reference, display_context)
+
+    # THEN we should get a WorkflowStatePointer with the overridden display ID
+    assert isinstance(result, WorkflowStatePointer)
+    assert result.type == "WORKFLOW_STATE"
+    assert isinstance(result.data, WorkflowStateData)
+    assert result.data.state_variable_id == str(override_id)
+
+
+class MyTrigger(BaseTrigger):
+    my_attribute: str
+
+
+def test_create_node_input_value_pointer_rule__trigger_attribute_reference() -> None:
+    """
+    Tests that TriggerAttributeReference is serialized to TriggerAttributePointer.
+    """
+
+    # GIVEN a TriggerAttributeReference
+    trigger_attribute_reference: TriggerAttributeReference[str] = MyTrigger.my_attribute  # type: ignore[assignment]
+
+    # AND a display context
+    display_context = WorkflowDisplayContext()
+
+    # WHEN we create a node input value pointer rule
+    result = create_node_input_value_pointer_rule(trigger_attribute_reference, display_context)
+
+    # THEN we should get a TriggerAttributePointer with the correct data
+    assert isinstance(result, TriggerAttributePointer)
+    assert result.type == "TRIGGER_ATTRIBUTE"
+    assert isinstance(result.data, TriggerAttributeData)
+    assert result.data.trigger_id == str(MyTrigger.__id__)
+    assert result.data.attribute_id == str(trigger_attribute_reference.id)
+
+
+def test_create_node_input__unexpected_error_returns_node_input_with_empty_rules() -> None:
+    """
+    Tests that when create_node_input_value_pointer_rules raises an unexpected error,
+    create_node_input still returns a NodeInput with empty rules and adds the error to display context.
+    """
+
+    # GIVEN a display context
+    display_context = WorkflowDisplayContext()
+
+    # AND a node_id and input_name
+    node_id = uuid4()
+    input_name = "test_input"
+
+    # AND create_node_input_value_pointer_rules will raise an unexpected error
+    unexpected_error = RuntimeError("Unexpected error during serialization")
+    with patch(
+        "vellum_ee.workflows.display.nodes.vellum.utils.create_node_input_value_pointer_rules",
+        side_effect=unexpected_error,
+    ):
+        # WHEN we call create_node_input
+        result = create_node_input(
+            node_id=node_id,
+            input_name=input_name,
+            value="test_value",
+            display_context=display_context,
+        )
+
+    # THEN we should still get a NodeInput with empty rules
+    assert result.key == input_name
+    assert result.value.rules == []
+    assert result.value.combinator == "OR"
+
+    # AND the error should be added to the display context
+    errors = list(display_context.errors)
+    assert len(errors) == 1
+    assert errors[0] is unexpected_error

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

@@ -1,8 +1,7 @@
 import inspect
 from uuid import UUID
-from typing import Any, ClassVar, Generic, Optional, Tuple, Type, TypeVar
+from typing import Any, ClassVar, Generic, Optional, TypeVar
 
-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
 from vellum.workflows.references.output import OutputReference
@@ -37,13 +36,13 @@ class BaseTryNodeDisplay(BaseAdornmentNodeDisplay[_TryNodeType], Generic[_TryNod
                 {
                     "id": id,
                     "name": attribute.name,
-                    "value": serialize_value(display_context, attribute.instance),
+                    "value": serialize_value(node_id, display_context, attribute.instance),
                 }
             )
 
         adornment: JsonObject = {
             "id": str(node_id),
-            "label": node.__qualname__,
+            "label": self.label,
             "base": self.get_base().dict(),
             "attributes": attributes,
         }
@@ -76,7 +75,7 @@ class BaseTryNodeDisplay(BaseAdornmentNodeDisplay[_TryNodeType], Generic[_TryNod
 
         return serialized_node
 
-    def get_node_output_display(self, output: OutputReference) -> Tuple[Type[BaseNode], NodeOutputDisplay]:
+    def get_node_output_display(self, output: OutputReference) -> NodeOutputDisplay:
         inner_node = self._node.__wrapped_node__
         if not inner_node:
             return super().get_node_output_display(output)
@@ -84,7 +83,7 @@ class BaseTryNodeDisplay(BaseAdornmentNodeDisplay[_TryNodeType], Generic[_TryNod
         node_display_class = get_node_display_class(inner_node)
         node_display = node_display_class()
         if output.name == "error":
-            return inner_node, NodeOutputDisplay(
+            return NodeOutputDisplay(
                 id=self.error_output_id or uuid4_from_hash(f"{node_display.node_id}|error_output_id"),
                 name="error",
             )

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

@@ -1,6 +1,8 @@
+import logging
 from uuid import UUID
 from typing import Any, List, Optional, Type, Union, cast
 
+from vellum.client.types.json_vellum_value import JsonVellumValue
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
 from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
@@ -8,8 +10,12 @@ from vellum.workflows.references import NodeReference
 from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
-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.exceptions import (
+    InvalidOutputReferenceError,
+    UnsupportedSerializationException,
+    UserFacingException,
+)
+from vellum_ee.workflows.display.utils.expressions import get_child_descriptor, serialize_value
 from vellum_ee.workflows.display.utils.vellum import (
     ConstantValuePointer,
     ExecutionCounterData,
@@ -23,6 +29,8 @@ from vellum_ee.workflows.display.utils.vellum import (
 )
 from vellum_ee.workflows.display.vellum import NodeInput, NodeInputValuePointer
 
+logger = logging.getLogger(__name__)
+
 
 def create_node_input(
     node_id: UUID,
@@ -33,7 +41,13 @@ def create_node_input(
     pointer_type: Optional[Type[NodeInputValuePointerRule]] = ConstantValuePointer,
 ) -> NodeInput:
     input_id = str(input_id) if input_id else str(uuid4_from_hash(f"{node_id}|{input_name}"))
-    rules = create_node_input_value_pointer_rules(value, display_context, pointer_type=pointer_type)
+    try:
+        rules = create_node_input_value_pointer_rules(value, display_context, node_id, pointer_type=pointer_type)
+    except UserFacingException:
+        raise
+    except Exception as e:
+        display_context.add_validation_error(e)
+        rules = []
     return NodeInput(
         id=input_id,
         key=input_name,
@@ -44,9 +58,21 @@ def create_node_input(
     )
 
 
+def _contains_descriptor(value: Any) -> bool:
+    """Check if a value contains any BaseDescriptor objects."""
+    if isinstance(value, BaseDescriptor):
+        return True
+    if isinstance(value, dict):
+        return any(_contains_descriptor(v) for v in value.values())
+    if isinstance(value, list):
+        return any(_contains_descriptor(item) for item in value)
+    return False
+
+
 def create_node_input_value_pointer_rules(
     value: Any,
     display_context: WorkflowDisplayContext,
+    node_id: UUID,
     existing_rules: Optional[List[NodeInputValuePointerRule]] = None,
     pointer_type: Optional[Type[NodeInputValuePointerRule]] = None,
 ) -> List[NodeInputValuePointerRule]:
@@ -59,33 +85,49 @@ def create_node_input_value_pointer_rules(
             value = cast(BaseDescriptor, value.instance)
 
         if isinstance(value, LazyReference):
-            child_descriptor = get_child_descriptor(value, display_context)
+            try:
+                child_descriptor = get_child_descriptor(value, display_context)
+            except InvalidOutputReferenceError as e:
+                logger.warning("Failed to parse lazy reference '%s', skipping serialization", value.name)
+                display_context.add_validation_error(e)
+                return node_input_value_pointer_rules
             return create_node_input_value_pointer_rules(
-                child_descriptor, display_context, [], pointer_type=pointer_type
+                child_descriptor, display_context, node_id, existing_rules=[], pointer_type=pointer_type
             )
 
         if isinstance(value, CoalesceExpression):
-            # Recursively handle the left-hand side
-            lhs_rules = create_node_input_value_pointer_rules(value.lhs, display_context, [], pointer_type=pointer_type)
+            lhs_rules = create_node_input_value_pointer_rules(
+                value.lhs, display_context, node_id, existing_rules=[], pointer_type=pointer_type
+            )
             node_input_value_pointer_rules.extend(lhs_rules)
 
-            # Handle the right-hand side
             if not isinstance(value.rhs, CoalesceExpression):
                 rhs_rules = create_node_input_value_pointer_rules(
-                    value.rhs, display_context, [], pointer_type=pointer_type
+                    value.rhs, display_context, node_id, existing_rules=[], pointer_type=pointer_type
                 )
                 node_input_value_pointer_rules.extend(rhs_rules)
         else:
-            # Non-CoalesceExpression case
             try:
                 rule = create_node_input_value_pointer_rule(value, display_context)
             except UnsupportedSerializationException:
                 return node_input_value_pointer_rules
 
             node_input_value_pointer_rules.append(rule)
+    elif isinstance(value, (dict, list)) and _contains_descriptor(value):
+        display_context.add_validation_error(
+            UnsupportedSerializationException(
+                "The Vellum UI does not support nested references for this Node attribute. "
+                "Consider flattening the references."
+            )
+        )
+        serialized = serialize_value(node_id, display_context, value)
+        serialized_pointer = ConstantValuePointer(
+            data=JsonVellumValue(value=serialized),
+        )
+        node_input_value_pointer_rules.append(serialized_pointer)
     else:
-        pointer = create_pointer(value, pointer_type)
-        node_input_value_pointer_rules.append(pointer)
+        constant_pointer = create_pointer(value, pointer_type)
+        node_input_value_pointer_rules.append(constant_pointer)
 
     return node_input_value_pointer_rules