vellum-ai 1.1.4__py3-none-any.whl → 1.2.0__py3-none-any.whl

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

@@ -34,7 +34,7 @@ def test_serialize_node__constant_value(serialize_node):
     assert not DeepDiff(
         {
             "id": "67e07859-7f67-4287-9854-06ab4199e576",
-            "label": "test_serialize_node__constant_value.<locals>.ConstantValueGenericNode",
+            "label": "Constant Value Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -104,7 +104,7 @@ def test_serialize_node__constant_value_reference(serialize_node):
     assert not DeepDiff(
         {
             "id": "73643f17-e49e-47d2-bd01-bb9c3eab6ae9",
-            "label": "test_serialize_node__constant_value_reference.<locals>.ConstantValueReferenceGenericNode",
+            "label": "Constant Value Reference Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -146,7 +146,7 @@ def test_serialize_node__lazy_reference(serialize_node):
     assert not DeepDiff(
         {
             "id": "3d6bfe3b-263a-40a6-8a05-98288e9559a4",
-            "label": "test_serialize_node__lazy_reference.<locals>.LazyReferenceGenericNode",
+            "label": "Lazy Reference Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -229,7 +229,7 @@ def test_serialize_node__workflow_input(serialize_node):
     assert not DeepDiff(
         {
             "id": "30116483-6f38-40e0-baf2-32de0e14e9a3",
-            "label": "test_serialize_node__workflow_input.<locals>.WorkflowInputGenericNode",
+            "label": "Workflow Input Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -292,7 +292,7 @@ def test_serialize_node__workflow_input_as_nested_chat_history():
     assert not DeepDiff(
         {
             "id": "11be9d37-0069-4695-a317-14a3b6519d4e",
-            "label": "test_serialize_node__workflow_input_as_nested_chat_history.<locals>.GenericNode",
+            "label": "Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 200.0, "y": -50.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -362,7 +362,7 @@ def test_serialize_node__node_output(serialize_node):
     assert not DeepDiff(
         {
             "id": "7210742f-8c3e-4379-9800-8b4b7f5dd7ed",
-            "label": "test_serialize_node__node_output.<locals>.GenericNodeReferencingOutput",
+            "label": "Generic Node Referencing Output",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -412,7 +412,7 @@ def test_serialize_node__vellum_secret(serialize_node):
     assert not DeepDiff(
         {
             "id": "0e75bd8f-882e-4ab7-8348-061319b574f7",
-            "label": "test_serialize_node__vellum_secret.<locals>.VellumSecretGenericNode",
+            "label": "Vellum Secret Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -465,7 +465,7 @@ def test_serialize_node__node_execution(serialize_node):
     assert not DeepDiff(
         {
             "id": "f42dda6b-e856-49bd-b203-46c9dd66c08b",
-            "label": "test_serialize_node__node_execution.<locals>.GenericNodeReferencingExecutions",
+            "label": "Generic Node Referencing Executions",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -561,7 +561,7 @@ def test_serialize_node__coalesce(serialize_node):
     assert not DeepDiff(
         {
             "id": "bb99f326-7d2a-4b5e-95f3-6039114798da",
-            "label": "test_serialize_node__coalesce.<locals>.CoalesceNodeFinal",
+            "label": "Coalesce Node Final",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -670,3 +670,53 @@ def test_serialize_node__pydantic_with_node_output_reference(serialize_node):
     assert any(
         entry["key"] == "node_ref" and entry["value"]["type"] == "NODE_OUTPUT" for entry in attr_value["entries"]
     )
+
+
+def test_serialize_node__comment_expanded_true_when_content_exists(serialize_node):
+    """
+    Tests that node comment serialization sets expanded=True when comment has content.
+    """
+
+    class NodeWithComment(BaseNode):
+        """This is a test comment for the node."""
+
+        pass
+
+    serialized_node = serialize_node(NodeWithComment)
+
+    # WHEN the node is serialized
+    display_data = serialized_node["display_data"]
+
+    # THEN the comment should have expanded=True
+    assert "comment" in display_data
+    assert display_data["comment"]["value"] == "This is a test comment for the node."
+    assert display_data["comment"]["expanded"] is True
+
+
+def test_serialize_node__comment_expanded_preserved_when_explicitly_set(serialize_node):
+    """
+    Tests that explicitly set expanded value is preserved during serialization.
+    """
+    from vellum_ee.workflows.display.editor.types import NodeDisplayComment, NodeDisplayData
+    from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
+
+    class NodeWithExplicitComment(BaseNode):
+        """This is a test comment."""
+
+        pass
+
+    class NodeWithExplicitCommentDisplay(BaseNodeDisplay[NodeWithExplicitComment]):
+        display_data = NodeDisplayData(comment=NodeDisplayComment(value="Custom comment", expanded=False))
+
+    serialized_node = serialize_node(
+        NodeWithExplicitComment,
+        global_node_displays={NodeWithExplicitComment: NodeWithExplicitCommentDisplay()},
+    )
+
+    # WHEN the node is serialized
+    display_data = serialized_node["display_data"]
+
+    # THEN the comment should preserve expanded=False
+    assert "comment" in display_data
+    assert display_data["comment"]["value"] == "This is a test comment."
+    assert display_data["comment"]["expanded"] is False

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

@@ -23,7 +23,7 @@ def test_serialize_node__annotated_output(serialize_node):
     assert not DeepDiff(
         {
             "id": "e33ddf79-f48c-4057-ba17-d41a3a60ac98",
-            "label": "test_serialize_node__annotated_output.<locals>.AnnotatedOutputGenericNode",
+            "label": "Annotated Output Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -71,7 +71,7 @@ def test_serialize_node__workflow_input(serialize_node):
     assert not DeepDiff(
         {
             "id": "30116483-6f38-40e0-baf2-32de0e14e9a3",
-            "label": "test_serialize_node__workflow_input.<locals>.WorkflowInputGenericNode",
+            "label": "Workflow Input Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -134,7 +134,7 @@ def test_serialize_node__node_output_reference(serialize_node):
     assert not DeepDiff(
         {
             "id": "ac067acc-6a6f-44b1-ae84-428e965ce691",
-            "label": "test_serialize_node__node_output_reference.<locals>.GenericNodeReferencingOutput",
+            "label": "Generic Node Referencing Output",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},

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

@@ -20,11 +20,10 @@ def test_serialize_node__basic(serialize_node):
         pass
 
     serialized_node = serialize_node(BasicGenericNode)
-
     assert not DeepDiff(
         {
             "id": "8d7cbfe4-72ca-4367-a401-8d28723d2f00",
-            "label": "test_serialize_node__basic.<locals>.BasicGenericNode",
+            "label": "Basic Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -70,7 +69,7 @@ def test_serialize_node__if(serialize_node):
     assert not DeepDiff(
         {
             "id": "bba4b15a-dea0-48c9-a79b-4e12e99db00f",
-            "label": "test_serialize_node__if.<locals>.IfGenericNode",
+            "label": "If Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -132,7 +131,7 @@ def test_serialize_node__if_else(serialize_node):
     assert not DeepDiff(
         {
             "id": "25c9c3f1-4014-47ac-90cf-5216de10d05c",
-            "label": "test_serialize_node__if_else.<locals>.IfElseGenericNode",
+            "label": "If Else Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -201,7 +200,7 @@ def test_serialize_node__if_elif_else(serialize_node):
     assert not DeepDiff(
         {
             "id": "7b2b9cfc-12aa-432c-940d-cbe53e71de9c",
-            "label": "test_serialize_node__if_elif_else.<locals>.IfElifElseGenericNode",
+            "label": "If Elif Else Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -300,7 +299,7 @@ def test_serialize_node__node_output_reference(serialize_node):
     assert not DeepDiff(
         {
             "id": "ac067acc-6a6f-44b1-ae84-428e965ce691",
-            "label": "test_serialize_node__node_output_reference.<locals>.GenericNodeReferencingOutput",
+            "label": "Generic Node Referencing Output",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "definition": {
@@ -363,7 +362,7 @@ def test_serialize_node__vellum_secret_reference(serialize_node):
     assert not DeepDiff(
         {
             "id": "feb4b331-e25f-4a5c-9840-c5575b1efd5c",
-            "label": "test_serialize_node__vellum_secret_reference.<locals>.GenericNodeReferencingSecret",
+            "label": "Generic Node Referencing Secret",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "definition": {
@@ -429,7 +428,7 @@ def test_serialize_node__execution_count_reference(serialize_node):
     assert not DeepDiff(
         {
             "id": "0b4fe8a6-6d0c-464e-9372-10110e2b0e13",
-            "label": "test_serialize_node__execution_count_reference.<locals>.GenericNodeReferencingExecutions",
+            "label": "Generic Node Referencing Executions",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "definition": {
@@ -490,7 +489,7 @@ def test_serialize_node__null(serialize_node):
     assert not DeepDiff(
         {
             "id": "1838ce1f-9c07-4fd0-9fd4-2a3a841ea402",
-            "label": "test_serialize_node__null.<locals>.NullGenericNode",
+            "label": "Null Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -548,7 +547,7 @@ def test_serialize_node__between(serialize_node):
     assert not DeepDiff(
         {
             "id": "f2f5a1f2-a12d-4ce0-bfe9-42190ffe5328",
-            "label": "test_serialize_node__between.<locals>.BetweenGenericNode",
+            "label": "Between Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -617,7 +616,7 @@ def test_serialize_node__or(serialize_node):
     assert not DeepDiff(
         {
             "id": "5386abad-3378-4378-b3a8-831b4b77dc23",
-            "label": "test_serialize_node__or.<locals>.OrGenericNode",
+            "label": "Or Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -700,7 +699,7 @@ def test_serialize_node__and_then_or(serialize_node):
     assert not DeepDiff(
         {
             "id": "4d3995b1-437b-48d9-8878-9f57a8b725f1",
-            "label": "test_serialize_node__and_then_or.<locals>.AndThenOrGenericNode",
+            "label": "And Then Or Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -802,7 +801,7 @@ def test_serialize_node__parenthesized_and_then_or(serialize_node):
     assert not DeepDiff(
         {
             "id": "223864c9-0088-4c05-9b7d-e5b1c9ec936d",
-            "label": "test_serialize_node__parenthesized_and_then_or.<locals>.ParenthesizedAndThenOrGenericNode",
+            "label": "Parenthesized And Then Or Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -904,7 +903,7 @@ def test_serialize_node__or_then_and(serialize_node):
     assert not DeepDiff(
         {
             "id": "a946342e-4ede-4e96-8e3d-f396748d9f7c",
-            "label": "test_serialize_node__or_then_and.<locals>.OrThenAndGenericNode",
+            "label": "Or Then And Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -1005,7 +1004,7 @@ def test_serialize_node__parse_json(serialize_node):
     assert not DeepDiff(
         {
             "id": "bfc3f81b-242a-4f43-9e1c-648223d77768",
-            "label": "test_serialize_node__parse_json.<locals>.ParseJsonGenericNode",
+            "label": "Parse Json Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},

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

@@ -2,7 +2,11 @@ from deepdiff import DeepDiff
 
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
+from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.core import MergeBehavior
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 
 class Inputs(BaseInputs):
@@ -17,7 +21,7 @@ def test_serialize_node__basic(serialize_node):
     assert not DeepDiff(
         {
             "id": "8d7cbfe4-72ca-4367-a401-8d28723d2f00",
-            "label": "test_serialize_node__basic.<locals>.BasicGenericNode",
+            "label": "Basic Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -59,7 +63,7 @@ def test_serialize_node__await_any(serialize_node):
     assert not DeepDiff(
         {
             "id": "42e17f0e-8496-415f-9c72-f85250ba6f0b",
-            "label": "test_serialize_node__await_any.<locals>.AwaitAnyGenericNode",
+            "label": "Await Any Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -101,7 +105,7 @@ def test_serialize_node__await_all(serialize_node):
     assert not DeepDiff(
         {
             "id": "b3e1145a-5f41-456b-9382-6d0a1e828c2f",
-            "label": "test_serialize_node__await_all.<locals>.AwaitAllGenericNode",
+            "label": "Await All Generic Node",
             "type": "GENERIC",
             "display_data": {"position": {"x": 0.0, "y": 0.0}},
             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
@@ -132,3 +136,54 @@ def test_serialize_node__await_all(serialize_node):
         serialized_node,
         ignore_order=True,
     )
+
+
+def test_serialize_node__inline_prompt_await_all():
+    """
+    Tests that InlinePromptNode with AWAIT_ALL merge behavior can be defined and serializes without errors.
+    """
+
+    # GIVEN an InlinePromptNode with AWAIT_ALL merge behavior
+    class AwaitAllInlinePromptNode(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = []
+
+        class Trigger(InlinePromptNode.Trigger):
+            merge_behavior = MergeBehavior.AWAIT_ALL
+
+    class TestWorkflow(BaseWorkflow[Inputs, BaseState]):
+        graph = AwaitAllInlinePromptNode
+
+    # WHEN we serialize the workflow containing the node
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    serialized = workflow_display.serialize()
+
+    # THEN the workflow should serialize successfully
+    assert "workflow_raw_data" in serialized  # type: ignore
+    assert "nodes" in serialized["workflow_raw_data"]  # type: ignore
+
+    # AND the workflow should contain the InlinePromptNode
+    nodes = serialized["workflow_raw_data"]["nodes"]  # type: ignore
+    prompt_nodes = [node for node in nodes if node["type"] == "PROMPT"]  # type: ignore
+    assert len(prompt_nodes) == 1
+
+    prompt_node = prompt_nodes[0]
+
+    # AND the node should have the correct type and base
+    assert prompt_node["type"] == "PROMPT"  # type: ignore
+    assert prompt_node["base"]["name"] == "InlinePromptNode"  # type: ignore
+    assert prompt_node["base"]["module"] == [  # type: ignore
+        "vellum",
+        "workflows",
+        "nodes",
+        "displayable",
+        "inline_prompt_node",
+        "node",
+    ]
+
+    # AND the node should have the expected structure (InlinePromptNode doesn't serialize trigger info)
+    assert "data" in prompt_node  # type: ignore
+    assert "ml_model_name" in prompt_node["data"]  # type: ignore
+    assert prompt_node["data"]["ml_model_name"] == "gpt-4o"  # type: ignore
+
+    assert prompt_node["trigger"]["merge_behavior"] == "AWAIT_ALL"  # type: ignore

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_code_execution_node_serialization.py

@@ -591,7 +591,7 @@ def test_serialize_workflow__try_wrapped():
         "adornments": [
             {
                 "id": "3344083c-a32c-4a32-920b-0fb5093448fa",
-                "label": "TryNode",
+                "label": "Try Node",
                 "base": {"name": "TryNode", "module": ["vellum", "workflows", "nodes", "core", "try_node", "node"]},
                 "attributes": [
                     {

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_inline_prompt_node_serialization.py

@@ -165,6 +165,10 @@ def test_serialize_workflow():
                 "name": "ExampleBaseInlinePromptNodeWithFunctions",
                 "module": ["tests", "workflows", "basic_inline_prompt_node_with_functions", "workflow"],
             },
+            "trigger": {
+                "id": "c2dccecb-8a41-40a8-95af-325d3ab8bfe5",
+                "merge_behavior": "AWAIT_ANY",
+            },
             "outputs": [
                 {"id": "9557bd86-702d-4b45-b8c1-c3980bffe28f", "name": "json", "type": "JSON", "value": None},
                 {"id": "ead0ccb5-092f-4d9b-a9ec-5eb83d498188", "name": "text", "type": "STRING", "value": None},

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_inline_subworkflow_serialization.py

@@ -129,7 +129,7 @@ def test_serialize_workflow():
                         },
                         {
                             "id": "1381c078-efa2-4255-89a1-7b4cb742c7fc",
-                            "label": "StartNode",
+                            "label": "Start Node",
                             "type": "GENERIC",
                             "display_data": {"position": {"x": 200.0, "y": -50.0}},
                             "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py

@@ -40,11 +40,14 @@ def test_serialize_workflow():
     tool_calling_node = workflow_raw_data["nodes"][1]
     assert tool_calling_node == {
         "id": "21f29cac-da87-495f-bba1-093d423f4e46",
-        "label": "GetCurrentWeatherNode",
+        "label": "Get Current Weather Node",
         "type": "GENERIC",
         "display_data": {
             "position": {"x": 200.0, "y": -50.0},
-            "comment": {"value": "\n    A tool calling node that calls the get_current_weather function.\n    "},
+            "comment": {
+                "expanded": True,
+                "value": "\n    A tool calling node that calls the get_current_weather function.\n    ",
+            },
         },
         "base": {
             "name": "ToolCallingNode",
@@ -150,7 +153,7 @@ def test_serialize_workflow():
                                             },
                                             {
                                                 "id": "1381c078-efa2-4255-89a1-7b4cb742c7fc",
-                                                "label": "StartNode",
+                                                "label": "Start Node",
                                                 "type": "GENERIC",
                                                 "display_data": {"position": {"x": 200.0, "y": -50.0}},
                                                 "base": {

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py

@@ -40,11 +40,14 @@ def test_serialize_workflow():
     tool_calling_node = workflow_raw_data["nodes"][1]
     assert tool_calling_node == {
         "id": "21f29cac-da87-495f-bba1-093d423f4e46",
-        "label": "GetCurrentWeatherNode",
+        "label": "Get Current Weather Node",
         "type": "GENERIC",
         "display_data": {
             "position": {"x": 200.0, "y": -50.0},
-            "comment": {"value": "\n    A tool calling node that calls the get_current_weather function.\n    "},
+            "comment": {
+                "expanded": True,
+                "value": "\n    A tool calling node that calls the get_current_weather function.\n    ",
+            },
         },
         "base": {
             "name": "ToolCallingNode",

vellum_ee/workflows/display/types.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, Iterator, List, Tuple, Type
+from typing import TYPE_CHECKING, Dict, Iterator, List, Optional, Tuple, Type
 
 from vellum.client import Vellum as VellumClient
 from vellum.workflows.descriptors.base import BaseDescriptor
@@ -52,15 +52,26 @@ class WorkflowDisplayContext:
     edge_displays: EdgeDisplays = field(default_factory=dict)
     port_displays: PortDisplays = field(default_factory=dict)
     _errors: List[Exception] = field(default_factory=list)
+    _invalid_nodes: List[Type[BaseNode]] = field(default_factory=list)
     _dry_run: bool = False
 
-    def add_error(self, error: Exception) -> None:
+    def add_error(self, error: Exception, node: Optional[Type[BaseNode]] = None) -> None:
         if self._dry_run:
             self._errors.append(error)
             return
 
         raise error
 
+    def add_invalid_node(self, node: Type[BaseNode]) -> None:
+        """Track a node that failed to serialize."""
+        if node not in self._invalid_nodes:
+            self._invalid_nodes.append(node)
+
     @property
     def errors(self) -> Iterator[Exception]:
         return iter(self._errors)
+
+    @property
+    def invalid_nodes(self) -> Iterator[Type[BaseNode]]:
+        """Get an iterator over nodes that failed to serialize."""
+        return iter(self._invalid_nodes)

vellum_ee/workflows/display/utils/expressions.py

@@ -349,7 +349,11 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
     if is_workflow_class(value):
         from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
-        workflow_display = get_workflow_display(workflow_class=value)
+        # Pass the parent display context so the subworkflow can resolve parent workflow inputs
+        workflow_display = get_workflow_display(
+            workflow_class=value,
+            parent_display_context=display_context,
+        )
         serialized_value: dict = workflow_display.serialize()
         name = serialized_value["workflow_raw_data"]["definition"]["name"]
         description = value.__doc__ or ""

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -3,6 +3,7 @@ import fnmatch
 from functools import cached_property
 import importlib
 import inspect
+import json
 import logging
 import os
 from uuid import UUID
@@ -15,12 +16,14 @@ from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.edges import Edge
 from vellum.workflows.events.workflow import NodeEventDisplayContext, WorkflowEventDisplayContext
+from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.nodes.displayable.final_output_node.node import FinalOutputNode
 from vellum.workflows.nodes.utils import get_unadorned_node, get_unadorned_port, get_wrapped_node
 from vellum.workflows.ports import Port
 from vellum.workflows.references import OutputReference, WorkflowInputReference
+from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types.core import Json, JsonArray, JsonObject
 from vellum.workflows.types.generics import WorkflowType
 from vellum.workflows.types.utils import get_original_base
@@ -72,6 +75,7 @@ IGNORE_PATTERNS = [
 class WorkflowSerializationResult(UniversalBaseModel):
     exec_config: Dict[str, Any]
     errors: List[str]
+    dataset: Optional[List[Dict[str, Any]]] = None
 
 
 class BaseWorkflowDisplay(Generic[WorkflowType]):
@@ -194,6 +198,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                 serialized_node = node_display.serialize(self.display_context)
             except (NotImplementedError, NodeValidationError) as e:
                 self.display_context.add_error(e)
+                self.display_context.add_invalid_node(node)
                 continue
 
             serialized_nodes[node_display.node_id] = serialized_node
@@ -319,6 +324,10 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
         # Add an edge for each edge in the workflow
         for target_node, entrypoint_display in self.display_context.entrypoint_displays.items():
             unadorned_target_node = get_unadorned_node(target_node)
+            # Skip edges to invalid nodes
+            if self._is_node_invalid(unadorned_target_node):
+                continue
+
             target_node_display = self.display_context.node_displays[unadorned_target_node]
             edges.append(
                 {
@@ -335,6 +344,12 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             unadorned_source_node_port = get_unadorned_port(source_node_port)
             unadorned_target_node = get_unadorned_node(target_node)
 
+            # Skip edges that reference invalid nodes
+            if self._is_node_invalid(unadorned_target_node) or self._is_node_invalid(
+                unadorned_source_node_port.node_class
+            ):
+                continue
+
             source_node_port_display = self.display_context.port_displays[unadorned_source_node_port]
             target_node_display = self.display_context.node_displays[unadorned_target_node]
 
@@ -881,9 +896,25 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
         if additional_files:
             exec_config["module_data"] = {"additional_files": cast(JsonObject, additional_files)}
 
+        dataset = None
+        try:
+            sandbox_module_path = f"{module}.sandbox"
+            sandbox_module = importlib.import_module(sandbox_module_path)
+            if hasattr(sandbox_module, "dataset"):
+                dataset_attr = getattr(sandbox_module, "dataset")
+                if dataset_attr and isinstance(dataset_attr, list):
+                    dataset = []
+                    for i, inputs_obj in enumerate(dataset_attr):
+                        if isinstance(inputs_obj, BaseInputs):
+                            serialized_inputs = json.loads(json.dumps(inputs_obj, cls=DefaultStateEncoder))
+                            dataset.append({"label": f"Scenario {i + 1}", "inputs": serialized_inputs})
+        except (ImportError, AttributeError):
+            pass
+
         return WorkflowSerializationResult(
             exec_config=exec_config,
             errors=[str(error) for error in workflow_display.display_context.errors],
+            dataset=dataset,
         )
 
     def _gather_additional_module_files(self, module_path: str) -> Dict[str, str]:
@@ -939,5 +970,9 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
         is_required = not has_default and not is_optional
         return is_required
 
+    def _is_node_invalid(self, node: Type[BaseNode]) -> bool:
+        """Check if a node failed to serialize and should be considered invalid."""
+        return node in self.display_context.invalid_nodes
+
 
 register_workflow_display_class(workflow_class=BaseWorkflow, workflow_display_class=BaseWorkflowDisplay)