vellum-ai 0.14.68__py3-none-any.whl → 0.14.70__py3-none-any.whl

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

@@ -2,8 +2,10 @@ from uuid import UUID
 from typing import ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar
 
 from vellum import VellumVariable
+from vellum.workflows.constants import undefined
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes import InlineSubworkflowNode
+from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.types.core import JsonObject
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
@@ -24,7 +26,7 @@ class BaseInlineSubworkflowNodeDisplay(
     __serializable_inputs__ = {InlineSubworkflowNode.subworkflow_inputs}
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id
@@ -100,6 +102,12 @@ class BaseInlineSubworkflowNodeDisplay(
                 id=node_inputs_by_key[descriptor.name].id,
                 key=descriptor.name,
                 type=infer_vellum_variable_type(descriptor),
+                required=descriptor.instance is undefined,
+                default=(
+                    primitive_to_vellum_value(descriptor.instance).dict()
+                    if descriptor.instance is not undefined
+                    else None
+                ),
             )
             for descriptor in subworkflow_inputs_class
         ]

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

@@ -17,7 +17,7 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
     __serializable_inputs__ = {MapNode.items}  # type: ignore[misc]
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id

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

@@ -17,7 +17,7 @@ class BaseMergeNodeDisplay(BaseNodeDisplay[_MergeNodeType], Generic[_MergeNodeTy
         super().__init__()
         self._target_handle_iterator = 0
 
-    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+    def serialize(self, display_context: WorkflowDisplayContext, **_kwargs: Any) -> JsonObject:
         node = self._node
         node_id = self.node_id
 

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

@@ -13,6 +13,7 @@ class BaseNoteNodeDisplay(BaseNodeDisplay[_NoteNodeType], Generic[_NoteNodeType]
     style: ClassVar[Union[Dict[str, Any], None]] = None
 
     def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+        del display_context, kwargs  # Unused parameters
         node_id = self.node_id
 
         return {

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

@@ -15,7 +15,7 @@ class BasePromptDeploymentNodeDisplay(BaseNodeDisplay[_PromptDeploymentNodeType]
     __serializable_inputs__ = {PromptDeploymentNode.prompt_inputs}
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id

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

@@ -18,7 +18,7 @@ _RetryNodeType = TypeVar("_RetryNodeType", bound=RetryNode)
 
 
 class BaseRetryNodeDisplay(BaseAdornmentNodeDisplay[_RetryNodeType], Generic[_RetryNodeType]):
-    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+    def serialize(self, display_context: WorkflowDisplayContext, **_kwargs: Any) -> JsonObject:
         node = self._node
         node_id = self.node_id
 

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

@@ -42,7 +42,7 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
     }
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id

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

@@ -17,7 +17,7 @@ class BaseSubworkflowDeploymentNodeDisplay(
     __serializable_inputs__ = {SubworkflowDeploymentNode.subworkflow_inputs}
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id

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

@@ -18,7 +18,7 @@ class BaseTemplatingNodeDisplay(BaseNodeDisplay[_TemplatingNodeType], Generic[_T
     __serializable_inputs__ = {TemplatingNode.inputs}
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id

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

@@ -0,0 +1,88 @@
+from typing import Optional
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes import InlineSubworkflowNode
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.state.base import BaseState
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_serialize_node__inline_subworkflow_inputs():
+    # GIVEN a main workflow with inputs
+    class MainInputs(BaseInputs):
+        pass
+
+    # AND an inline subworkflow with inputs
+    class NestedInputs(BaseInputs):
+        input: str
+        input_with_default: str = "default"
+        optional_input: Optional[str] = None
+        optional_input_with_default: Optional[str] = "optional_default"
+
+    class NestedNode(BaseNode):
+        input = NestedInputs.input
+        input_with_default = NestedInputs.input_with_default
+
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+        def run(self) -> Outputs:
+            return self.Outputs(result=f"{self.input}-{self.input_with_default}")
+
+    class NestedWorkflow(BaseWorkflow[NestedInputs, BaseState]):
+        graph = NestedNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = NestedNode.Outputs.result
+
+    class MyInlineSubworkflowNode(InlineSubworkflowNode):
+        subworkflow_inputs = {
+            "input": "input",
+            "input_with_default": "input_with_default",
+            "optional_input": "optional_input",
+            "optional_input_with_default": "optional_input_with_default",
+        }
+        subworkflow = NestedWorkflow
+
+    class MainWorkflow(BaseWorkflow[MainInputs, BaseState]):
+        graph = MyInlineSubworkflowNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = MyInlineSubworkflowNode.Outputs.result
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(workflow_class=MainWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the inline subworkflow node should have the correct input variables
+    inline_subworkflow_node = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(MyInlineSubworkflowNode.__id__)
+    )
+
+    input_variables = inline_subworkflow_node["data"]["input_variables"]
+    assert len(input_variables) == 4
+
+    input_var = next(var for var in input_variables if var["key"] == "input")
+    assert input_var["required"] is True
+    assert input_var["default"] is None
+    assert input_var["type"] == "STRING"
+
+    input_with_default_var = next(var for var in input_variables if var["key"] == "input_with_default")
+    assert input_with_default_var["required"] is False
+    assert input_with_default_var["default"] == {"type": "STRING", "value": "default"}
+    assert input_with_default_var["type"] == "STRING"
+
+    optional_input_var = next(var for var in input_variables if var["key"] == "optional_input")
+    assert optional_input_var["required"] is False
+    assert optional_input_var["default"] == {"type": "JSON", "value": None}
+    assert optional_input_var["type"] == "STRING"
+
+    optional_input_with_default_var = next(
+        var for var in input_variables if var["key"] == "optional_input_with_default"
+    )
+    assert optional_input_with_default_var["required"] is False
+    assert optional_input_with_default_var["default"] == {"type": "STRING", "value": "optional_default"}
+    assert optional_input_with_default_var["type"] == "STRING"

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

@@ -7,6 +7,7 @@ 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.environment_variable import EnvironmentVariableReference
 from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.state.base import BaseState
@@ -475,6 +476,21 @@ def test_serialize_node__node_execution(serialize_node):
     )
 
 
+def test_serialize_node__environment_variable(serialize_node):
+    class EnvironmentVariableGenericNode(BaseNode):
+        attr = EnvironmentVariableReference(name="API_KEY")
+
+    serialized_node = serialize_node(EnvironmentVariableGenericNode)
+
+    expected_value = {
+        "type": "ENVIRONMENT_VARIABLE",
+        "environment_variable": "API_KEY",
+    }
+
+    actual_value = serialized_node["attributes"][0]["value"]
+    assert actual_value == expected_value
+
+
 def test_serialize_node__coalesce(serialize_node):
     class CoalesceNodeA(BaseNode):
         class Outputs(BaseNode.Outputs):

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

@@ -1,5 +1,11 @@
 from deepdiff import DeepDiff
 
+from vellum import ChatMessagePromptBlock, FunctionDefinition, JinjaPromptBlock
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes import InlinePromptNode
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.state import BaseState
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 from tests.workflows.basic_inline_prompt_node_with_functions.workflow import BasicInlinePromptWithFunctionsWorkflow
@@ -185,6 +191,27 @@ def test_serialize_workflow():
                         ],
                     },
                 },
+                {
+                    "id": "8107682b-2ca0-4967-88f9-284455936575",
+                    "name": "functions",
+                    "value": {
+                        "type": "CONSTANT_VALUE",
+                        "value": {
+                            "type": "JSON",
+                            "value": [
+                                {
+                                    "state": None,
+                                    "cache_config": None,
+                                    "name": "favorite_noun",
+                                    "description": "Returns the favorite noun of the user",
+                                    "parameters": {},
+                                    "forced": None,
+                                    "strict": None,
+                                }
+                            ],
+                        },
+                    },
+                },
             ],
         },
         prompt_node,
@@ -274,3 +301,57 @@ def test_serialize_workflow():
         "name": "BasicInlinePromptWithFunctionsWorkflow",
         "module": ["tests", "workflows", "basic_inline_prompt_node_with_functions", "workflow"],
     }
+
+
+def test_serialize_workflow_with_descriptor_functions():
+    """Test that serialization handles BaseDescriptor instances in functions list."""
+
+    class TestInputs(BaseInputs):
+        noun: str
+
+    class MockMCPClientNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            tools: list[FunctionDefinition]
+
+    class TestInlinePromptNodeWithDescriptorFunctions(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = [
+            ChatMessagePromptBlock(
+                chat_role="SYSTEM",
+                blocks=[JinjaPromptBlock(template="Test {{noun}}")],
+            ),
+        ]
+        prompt_inputs = {"noun": TestInputs.noun}
+        functions = MockMCPClientNode.Outputs.tools  # type: ignore
+
+    class TestWorkflow(BaseWorkflow[TestInputs, BaseState]):
+        graph = MockMCPClientNode >> TestInlinePromptNodeWithDescriptorFunctions
+
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    serialized: dict = workflow_display.serialize()
+
+    prompt_nodes = [node for node in serialized["workflow_raw_data"]["nodes"] if node["type"] == "PROMPT"]
+    assert len(prompt_nodes) == 1
+
+    prompt_node = prompt_nodes[0]
+    assert isinstance(prompt_node, dict)
+    blocks = prompt_node["data"]["exec_config"]["prompt_template_block_data"]["blocks"]
+    assert isinstance(blocks, list)
+
+    function_blocks = [
+        block for block in blocks if isinstance(block, dict) and block.get("block_type") == "FUNCTION_DEFINITION"
+    ]
+    assert len(function_blocks) == 0  # We don't serialize the legacy function blocks when dynamic
+
+    assert "attributes" in prompt_node
+    assert isinstance(prompt_node["attributes"], list)
+    functions_attr = next(
+        (attr for attr in prompt_node["attributes"] if isinstance(attr, dict) and attr["name"] == "functions"), None
+    )
+    assert isinstance(functions_attr, dict), "functions attribute should be present in serialized attributes"
+
+    assert functions_attr["value"] == {
+        "node_id": "cb1186e0-8ff1-4145-823e-96b3fc05a39a",
+        "node_output_id": "470fadb9-b8b5-477e-a502-5209d398bcf9",
+        "type": "NODE_OUTPUT",
+    }

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

@@ -301,7 +301,15 @@ def test_serialize_workflow():
                         },
                     ],
                 },
-                "input_variables": [{"id": "704c4640-bfda-44f0-8da3-e9cfc4f21cf2", "key": "metro", "type": "STRING"}],
+                "input_variables": [
+                    {
+                        "id": "704c4640-bfda-44f0-8da3-e9cfc4f21cf2",
+                        "key": "metro",
+                        "type": "STRING",
+                        "required": True,
+                        "default": None,
+                    }
+                ],
                 "output_variables": [
                     {"id": "2fc57139-7420-49e5-96a6-dcbb3ff5d622", "key": "temperature", "type": "NUMBER"},
                     {"id": "fad5dd9f-3328-4e70-ad55-65a5325a4a82", "key": "reasoning", "type": "STRING"},