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

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

@@ -105,7 +105,13 @@ def test_serialize_node__retry(serialize_node):
                 }
             ],
             "outputs": [
-                {"id": "78eece53-8a20-40a1-8a86-ffebe256282b", "name": "output", "type": "STRING", "value": None}
+                {
+                    "id": "78eece53-8a20-40a1-8a86-ffebe256282b",
+                    "name": "output",
+                    "type": "STRING",
+                    "value": None,
+                    "schema": {"type": "string"},
+                }
             ],
         },
         serialized_node,
@@ -197,7 +203,13 @@ def test_serialize_node__try(serialize_node):
                 }
             ],
             "outputs": [
-                {"id": "d8d0c9a8-0804-4b43-a874-28a7e7d6aec8", "name": "output", "type": "STRING", "value": None}
+                {
+                    "id": "d8d0c9a8-0804-4b43-a874-28a7e7d6aec8",
+                    "name": "output",
+                    "type": "STRING",
+                    "value": None,
+                    "schema": {"type": "string"},
+                }
             ],
         },
         serialized_node,

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

@@ -190,6 +190,115 @@ def test_serialize_node__lazy_reference_with_string():
     ]
 
 
+def test_serialize_node__lazy_reference_workflow_output():
+    """Test that LazyReference to workflow output serializes as WORKFLOW_OUTPUT type."""
+
+    # GIVEN a node with a LazyReference to a workflow output
+    class NodeWithWorkflowOutputReference(BaseNode):
+        workflow_output_ref = LazyReference(lambda: TestWorkflow.Outputs.final_result)
+
+    class TestNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str = "test result"
+
+    # AND a workflow that defines an output
+    class TestWorkflow(BaseWorkflow):
+        graph = NodeWithWorkflowOutputReference >> TestNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = TestNode.Outputs.result
+
+    # WHEN the node is serialized in the context of the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the workflow output reference
+    node_with_lazy_reference = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(NodeWithWorkflowOutputReference.__id__)
+    )
+
+    # AND the workflow output reference should serialize as WORKFLOW_OUTPUT type
+    assert len(node_with_lazy_reference["attributes"]) == 1
+    attr = node_with_lazy_reference["attributes"][0]
+    assert attr["name"] == "workflow_output_ref"
+    assert attr["value"]["type"] == "WORKFLOW_OUTPUT"
+
+    # AND the output_variable_id should match the workflow output
+    workflow_output = next(
+        output for output in serialized_workflow["output_variables"] if output["key"] == "final_result"
+    )
+    assert attr["value"]["output_variable_id"] == workflow_output["id"]
+
+
+def test_serialize_node__lazy_reference_workflow_output_with_string():
+    """Test that string-based LazyReference to workflow output serializes as WORKFLOW_OUTPUT type."""
+
+    # GIVEN a node with a string-based LazyReference to a workflow output
+    class NodeWithWorkflowOutputReference(BaseNode):
+        workflow_output_ref = LazyReference[str]("StringWorkflow.Outputs.final_result")
+
+    class TestNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str = "test result"
+
+    # AND a workflow that defines an output
+    class StringWorkflow(BaseWorkflow):
+        graph = NodeWithWorkflowOutputReference >> TestNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = TestNode.Outputs.result
+
+    # WHEN the node is serialized in the context of the workflow
+    workflow_display = get_workflow_display(workflow_class=StringWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the workflow output reference
+    node_with_lazy_reference = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(NodeWithWorkflowOutputReference.__id__)
+    )
+
+    # AND the workflow output reference should serialize as WORKFLOW_OUTPUT type
+    assert len(node_with_lazy_reference["attributes"]) == 1
+    attr = node_with_lazy_reference["attributes"][0]
+    assert attr["name"] == "workflow_output_ref"
+    assert attr["value"]["type"] == "WORKFLOW_OUTPUT"
+
+    # AND the output_variable_id should match the workflow output
+    workflow_output = next(
+        output for output in serialized_workflow["output_variables"] if output["key"] == "final_result"
+    )
+    assert attr["value"]["output_variable_id"] == workflow_output["id"]
+
+
+def test_serialize_node__lazy_reference_with_string__class_not_found():
+    """Test that InvalidOutputReferenceError is added to display context when the referenced class is not found."""
+
+    # GIVEN a node with a string-based LazyReference to a non-existent class
+    class NodeWithInvalidReference(BaseNode):
+        invalid_ref = LazyReference[str]("NonExistentClass.Outputs.result")
+
+    # AND a workflow that contains the node
+    class TestWorkflow(BaseWorkflow):
+        graph = NodeWithInvalidReference
+
+    # WHEN we try to serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    workflow_display.serialize()
+
+    # THEN the error should be added to the display context
+    errors = list(workflow_display.display_context.errors)
+    assert len(errors) == 1
+
+    # AND the error message should mention the class that could not be found
+    error_message = str(errors[0])
+    assert "NonExistentClass" in error_message
+    assert "Could not find node or workflow class" in error_message
+
+
 def test_serialize_node__workflow_input(serialize_node):
     class WorkflowInputGenericNode(BaseNode):
         attr: str = Inputs.input

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

@@ -50,6 +50,7 @@ def test_serialize_node__annotated_output(serialize_node):
                     "name": "output",
                     "type": "NUMBER",
                     "value": None,
+                    "schema": {"type": "integer"},
                 }
             ],
         },
@@ -102,6 +103,7 @@ def test_serialize_node__workflow_input(serialize_node):
                         "type": "WORKFLOW_INPUT",
                         "input_variable_id": str(input_id),
                     },
+                    "schema": {"type": "string"},
                 }
             ],
         },
@@ -168,6 +170,7 @@ def test_serialize_node__node_output_reference(serialize_node):
                         "node_id": "40fcba1f-9b25-4fed-8f15-a2fd80ff85a1",
                         "node_output_id": str(node_output_id),
                     },
+                    "schema": {"type": "string"},
                 }
             ],
         },

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

@@ -1,14 +1,22 @@
 from uuid import uuid4
+from typing import cast
 
 from deepdiff import DeepDiff
 
+from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.ports.port import Port
 from vellum.workflows.references.vellum_secret import VellumSecretReference
-from vellum_ee.workflows.display.base import WorkflowInputsDisplay
+from vellum.workflows.types.core import JsonArray, JsonObject
+from vellum_ee.workflows.display.base import 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.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.exceptions import UnsupportedSerializationException
+from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 
 
 class Inputs(BaseInputs):
@@ -1001,6 +1009,133 @@ def test_serialize_node__or_then_and(serialize_node):
     )
 
 
+def test_serialize_node__blank(serialize_node):
+    """
+    Tests that a node with an is_blank() port condition serializes correctly.
+    """
+
+    # GIVEN a node with an is_blank() port condition
+    class BlankGenericNode(BaseNode):
+
+        class Ports(BaseNode.Ports):
+            if_branch = Port.on_if(Inputs.input.is_blank())
+
+    input_id = uuid4()
+
+    # WHEN we serialize the node
+    serialized_node = serialize_node(
+        node_class=BlankGenericNode, global_workflow_input_displays={Inputs.input: WorkflowInputsDisplay(id=input_id)}
+    )
+
+    # THEN the serialized node should have the correct structure with a UNARY_EXPRESSION and "blank" operator
+    assert not DeepDiff(
+        {
+            "id": "a9067b0e-6c3b-4ed0-8b0a-a4eb861f75a8",
+            "label": "Blank Generic Node",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "BlankGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_ports_serialization",
+                ],
+            },
+            "trigger": {"id": "f4cc239d-9feb-4eeb-84d9-62633a7883e7", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [
+                {
+                    "id": "3ac47591-d4dc-470b-be44-74e1445518e2",
+                    "type": "IF",
+                    "name": "if_branch",
+                    "expression": {
+                        "type": "UNARY_EXPRESSION",
+                        "lhs": {
+                            "type": "WORKFLOW_INPUT",
+                            "input_variable_id": str(input_id),
+                        },
+                        "operator": "blank",
+                    },
+                }
+            ],
+            "adornments": None,
+            "attributes": [],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )
+
+
+def test_serialize_node__not_blank(serialize_node):
+    """
+    Tests that a node with an is_not_blank() port condition serializes correctly.
+    """
+
+    # GIVEN a node with an is_not_blank() port condition
+    class NotBlankGenericNode(BaseNode):
+
+        class Ports(BaseNode.Ports):
+            if_branch = Port.on_if(Inputs.input.is_not_blank())
+
+    input_id = uuid4()
+
+    # WHEN we serialize the node
+    serialized_node = serialize_node(
+        node_class=NotBlankGenericNode,
+        global_workflow_input_displays={Inputs.input: WorkflowInputsDisplay(id=input_id)},
+    )
+
+    # THEN the serialized node should have the correct structure with a UNARY_EXPRESSION and "notBlank" operator
+    assert not DeepDiff(
+        {
+            "id": "a9349004-bd02-458e-af66-7b515cdd4d3a",
+            "label": "Not Blank Generic Node",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "NotBlankGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_ports_serialization",
+                ],
+            },
+            "trigger": {"id": "60521d64-adc6-4f49-8605-0bf617a23a2d", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [
+                {
+                    "id": "4824d11b-9d44-4183-8e7f-c4eb21262cc8",
+                    "type": "IF",
+                    "name": "if_branch",
+                    "expression": {
+                        "type": "UNARY_EXPRESSION",
+                        "lhs": {
+                            "type": "WORKFLOW_INPUT",
+                            "input_variable_id": str(input_id),
+                        },
+                        "operator": "notBlank",
+                    },
+                }
+            ],
+            "adornments": None,
+            "attributes": [],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )
+
+
 def test_serialize_node__parse_json(serialize_node):
 
     class ParseJsonGenericNode(BaseNode):
@@ -1067,3 +1202,54 @@ def test_serialize_node__parse_json(serialize_node):
         serialized_node,
         ignore_order=True,
     )
+
+
+def test_serialize_node__unsupported_descriptor_type():
+    """
+    Tests that serializing a generic node with an unsupported descriptor type
+    returns the node with an empty expression and adds the error to the display context.
+    """
+
+    # GIVEN a custom descriptor that is not a supported expression type
+    class UnsupportedDescriptor(BaseDescriptor[bool]):
+        def __init__(self) -> None:
+            super().__init__(name="unsupported", types=(bool,), instance=None)
+
+    # AND a generic node that uses this unsupported descriptor in a port condition
+    class UnsupportedDescriptorNode(BaseNode):
+        class Ports(BaseNode.Ports):
+            if_branch = Port.on_if(UnsupportedDescriptor())
+
+    # AND a display context with dry_run=True to capture errors
+    node_display_class = get_node_display_class(UnsupportedDescriptorNode)
+    node_display = node_display_class()
+
+    context = WorkflowDisplayContext(
+        workflow_display_class=BaseWorkflowDisplay,
+        workflow_display=WorkflowMetaDisplay(
+            entrypoint_node_id=uuid4(),
+            entrypoint_node_source_handle_id=uuid4(),
+            entrypoint_node_display=NodeDisplayData(),
+        ),
+        node_displays={UnsupportedDescriptorNode: node_display},
+        dry_run=True,
+    )
+
+    # WHEN we serialize the node
+    serialized_node = node_display.serialize(context)
+
+    # THEN the node should still be returned
+    assert serialized_node["type"] == "GENERIC"
+
+    # AND the port should have a None expression
+    ports = cast(JsonArray, serialized_node["ports"])
+    assert len(ports) == 1
+    port = cast(JsonObject, ports[0])
+    assert port["type"] == "IF"
+    assert port["expression"] is None
+
+    # AND the error should be added to the display context
+    errors = list(context.errors)
+    assert len(errors) == 1
+    assert isinstance(errors[0], UnsupportedSerializationException)
+    assert "Unsupported condition type" in str(errors[0])