vellum-ai 1.4.0__py3-none-any.whl → 1.4.2__py3-none-any.whl

vellum_cli/tests/test_push.py

@@ -721,6 +721,7 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
     vellum_client_class.assert_called_once_with(
         api_key="aaabbbcccddd",
         environment=mock.ANY,
+        api_version=None,
     )
 
     # AND the vellum lock file should have been updated with the correct workspace
@@ -882,6 +883,7 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
     vellum_client_class.assert_called_once_with(
         api_key="aaabbbcccddd",
         environment=mock.ANY,
+        api_version=None,
     )
 
     # AND the vellum lock file should have the same two workflows

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

@@ -163,9 +163,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         elif callable(function):
             normalized_functions = compile_function_definition(function)
         elif isinstance(function, DeploymentDefinition):
-            normalized_functions = compile_workflow_deployment_function_definition(
-                function.model_dump(), display_context.client
-            )
+            normalized_functions = compile_workflow_deployment_function_definition(function, display_context.client)
         else:
             raise ValueError(f"Unsupported function type: {type(function)}")
         return {

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

@@ -0,0 +1,78 @@
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes import BaseNode
+from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
+from vellum.workflows.state.base import BaseState
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_final_output_node_display__serialize_with_valid_types():
+    # GIVEN a node that outputs a str
+    class StringNode(BaseNode):
+        class Outputs:
+            result: str
+
+    # AND a FinalOutputNode with matching type to that node
+    class CorrectOutput(FinalOutputNode[BaseState, str]):
+        class Outputs(FinalOutputNode.Outputs):
+            value = StringNode.Outputs.result
+
+    # AND a workflow referencing the node
+    class MyWorkflow(BaseWorkflow):
+        graph = StringNode >> CorrectOutput
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = CorrectOutput.Outputs.value
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+
+    # THEN serialization should succeed without raising validation errors
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # AND the node should be properly serialized
+    assert "workflow_raw_data" in serialized_workflow
+    assert "nodes" in serialized_workflow["workflow_raw_data"]
+
+    # Find the terminal node in the serialized output
+    terminal_node = next(
+        node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["type"] == "TERMINAL"
+    )
+    assert terminal_node is not None
+    assert terminal_node["id"] == str(CorrectOutput.__id__)
+
+
+def test_final_output_node_display__serialize_with_invalid_types_should_raise_error():
+    # GIVEN a node that outputs a str
+    class StringNode(BaseNode):
+        class Outputs:
+            result: str
+
+    # AND a FinalOutputNode with mismatched types (expects list but gets str)
+    class BadOutput(FinalOutputNode[BaseState, list]):
+        """Output with type mismatch."""
+
+        class Outputs(FinalOutputNode.Outputs):
+            value = StringNode.Outputs.result  # str type, conflicts with list
+
+    # AND a workflow referencing the node
+    class MyWorkflow(BaseWorkflow):
+        graph = StringNode >> BadOutput
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = BadOutput.Outputs.value
+
+    # WHEN we attempt to serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+
+    # THEN serialization should complete without raising an exception
+    serialized_workflow = workflow_display.serialize()
+
+    # AND the error should be captured in workflow_display.errors
+    errors = list(workflow_display.display_context.errors)
+    assert len(errors) == 1
+    assert "Output type mismatch" in str(errors[0])
+    assert "list" in str(errors[0])
+    assert "str" in str(errors[0])
+
+    # AND the serialized workflow should still be created
+    assert "workflow_raw_data" in serialized_workflow

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

@@ -437,6 +437,11 @@ def test_serialize_workflow():
                 "name": "max_prompt_iterations",
                 "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5.0}},
             },
+            {
+                "id": "f92dc3ec-a19a-4491-a98a-2b2df322e2e3",
+                "name": "settings",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+            },
         ],
         "outputs": [
             {"id": "e62bc785-a914-4066-b79e-8c89a5d0ec6c", "name": "text", "type": "STRING", "value": None},

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

@@ -206,6 +206,11 @@ def test_serialize_workflow():
                 "name": "max_prompt_iterations",
                 "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5.0}},
             },
+            {
+                "id": "f92dc3ec-a19a-4491-a98a-2b2df322e2e3",
+                "name": "settings",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+            },
         ],
         "outputs": [
             {"id": "e62bc785-a914-4066-b79e-8c89a5d0ec6c", "name": "text", "type": "STRING", "value": None},

vellum_ee/workflows/display/types.py

@@ -62,6 +62,9 @@ class WorkflowDisplayContext:
 
         raise error
 
+    def add_validation_error(self, error: Exception) -> None:
+        self._errors.append(error)
+
     def add_invalid_node(self, node: Type[BaseNode]) -> None:
         """Track a node that failed to serialize."""
         if node not in self._invalid_nodes:

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -196,6 +196,12 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             node_display = self.display_context.node_displays[node]
 
             try:
+                try:
+                    node.__validate__()
+                except ValueError as validation_error:
+                    # Only collect node validation errors directly to errors list, don't raise them
+                    self.display_context.add_validation_error(validation_error)
+
                 serialized_node = node_display.serialize(self.display_context)
             except (NotImplementedError, NodeValidationError) as e:
                 self.display_context.add_error(e)