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

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

@@ -0,0 +1,106 @@
+import pytest
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
+from vellum.workflows.nodes.displayable.tool_calling_node.node import ToolCallingNode
+from vellum_ee.workflows.display.utils.exceptions import UnsupportedSerializationException
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_serialize_workflow__code_tool_with_node_reference__raises_error():
+    """
+    Tests that a serialization error is raised when a code tool references a workflow node.
+    """
+
+    # GIVEN a function that references a node class
+    def my_tool_with_node_reference(query: str) -> str:
+        return str(InlinePromptNode)
+
+    # AND a tool calling node that uses this function
+    class MyToolCallingNode(ToolCallingNode):
+        functions = [my_tool_with_node_reference]
+
+    # AND a workflow with the tool calling node
+    class TestWorkflow(BaseWorkflow):
+        graph = MyToolCallingNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = MyToolCallingNode.Outputs.text
+
+    # WHEN we try to serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+
+    # THEN a serialization error should be raised
+    with pytest.raises(UnsupportedSerializationException) as exc_info:
+        workflow_display.serialize()
+
+    # AND the error message should mention the node class and provide guidance
+    error_message = str(exc_info.value)
+    assert "InlinePromptNode" in error_message
+    assert "Code tools cannot reference workflow nodes" in error_message
+    assert "Inline Subworkflow tool" in error_message
+
+
+def test_serialize_workflow__code_tool_without_node_reference__no_error():
+    """
+    Tests that no error is raised when a code tool does not reference any workflow nodes,
+    even if the module has node imports at the top level.
+    """
+
+    # GIVEN a function that does NOT reference any node class (even though InlinePromptNode
+    # is imported at the module level)
+    def my_simple_tool(query: str) -> str:
+        return query.upper()
+
+    # AND a tool calling node that uses this function
+    class MyToolCallingNode(ToolCallingNode):
+        functions = [my_simple_tool]
+
+    # AND a workflow with the tool calling node
+    class TestWorkflow(BaseWorkflow):
+        graph = MyToolCallingNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = MyToolCallingNode.Outputs.text
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    serialized_workflow = workflow_display.serialize()
+
+    # THEN no error should be raised and the workflow should serialize successfully
+    assert serialized_workflow is not None
+    assert "workflow_raw_data" in serialized_workflow
+
+
+def test_serialize_workflow__code_tool_with_node_instantiation__raises_error():
+    """
+    Tests that a serialization error is raised when a code tool instantiates a node and calls its run method.
+    """
+
+    # GIVEN a function that instantiates a node and calls its run method
+    def my_tool():
+        node: InlinePromptNode = InlinePromptNode()
+        return node.run()
+
+    # AND a tool calling node that uses this function
+    class MyToolCallingNode(ToolCallingNode):
+        functions = [my_tool]
+
+    # AND a workflow with the tool calling node
+    class TestWorkflow(BaseWorkflow):
+        graph = MyToolCallingNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = MyToolCallingNode.Outputs.text
+
+    # WHEN we try to serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+
+    # THEN a serialization error should be raised
+    with pytest.raises(UnsupportedSerializationException) as exc_info:
+        workflow_display.serialize()
+
+    # AND the error message should mention the node class
+    error_message = str(exc_info.value)
+    assert "InlinePromptNode" in error_message
+    assert "Code tools cannot reference workflow nodes" in error_message

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

@@ -2,6 +2,7 @@ import pytest
 
 from deepdiff import DeepDiff
 
+from vellum_ee.workflows.display.utils.exceptions import WorkflowValidationError
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 from tests.workflows.complex_final_output_node.missing_final_output_node import MissingFinalOutputNodeWorkflow
@@ -31,7 +32,7 @@ def test_serialize_workflow__missing_final_output_node():
     workflow_raw_data = serialized_workflow["workflow_raw_data"]
     assert isinstance(workflow_raw_data, dict)
 
-    # AND we should create synthetic terminal nodes for each output variable
+    # AND we should NOT create synthetic terminal nodes for each output variable
     final_output_nodes = [node for node in workflow_raw_data["nodes"] if node["type"] == "TERMINAL"]
     assert not DeepDiff(
         [
@@ -79,6 +80,7 @@ def test_serialize_workflow__missing_final_output_node():
                             "type": "WORKFLOW_INPUT",
                             "input_variable_id": "da086239-d743-4246-b666-5c91e22fb88c",
                         },
+                        "schema": {"type": "string"},
                     }
                 ],
                 "trigger": {
@@ -87,45 +89,8 @@ def test_serialize_workflow__missing_final_output_node():
                 },
                 "ports": [],
             },
-            {
-                "id": "bb88768d-472e-4997-b7ea-de09163d1b4c",
-                "type": "TERMINAL",
-                "data": {
-                    "label": "Final Output",
-                    "name": "beta",
-                    "target_handle_id": "5e337b19-cef6-45af-802b-46da4ad7e794",
-                    "output_id": "5e6d3ea6-ef91-4937-8fff-f33e07446e6a",
-                    "output_type": "STRING",
-                    "node_input_id": "590161f1-20ed-4339-9ce3-61aade3a142a",
-                },
-                "inputs": [
-                    {
-                        "id": "590161f1-20ed-4339-9ce3-61aade3a142a",
-                        "key": "node_input",
-                        "value": {
-                            "rules": [
-                                {
-                                    "type": "NODE_OUTPUT",
-                                    "data": {
-                                        "node_id": "74b891e0-5573-4c7a-a0ef-c3c210187738",
-                                        "output_id": "ae21fc3f-dd81-4174-b08a-97bc96422a8f",
-                                    },
-                                }
-                            ],
-                            "combinator": "OR",
-                        },
-                    }
-                ],
-                "display_data": {"position": {"x": 400.0, "y": -50.0}},
-                "base": {
-                    "name": "FinalOutputNode",
-                    "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
-                },
-                "definition": None,
-            },
         ],
         final_output_nodes,
-        ignore_order=True,
     )
 
 
@@ -133,8 +98,11 @@ def test_serialize_workflow__missing_workflow_output():
     # GIVEN a Workflow that contains a terminal node that is unreferenced by the Workflow's Outputs
     workflow_display = get_workflow_display(workflow_class=MissingWorkflowOutputWorkflow)
 
-    # WHEN we serialize it, it should throw an error
-    with pytest.raises(ValueError) as exc_info:
+    # WHEN we serialize it, it should throw a WorkflowValidationError
+    with pytest.raises(WorkflowValidationError) as exc_info:
         workflow_display.serialize()
 
-    assert exc_info.value.args[0] == "Unable to serialize terminal nodes that are not referenced by workflow outputs."
+    # THEN the error message should indicate the terminal node is not referenced
+    error_message = str(exc_info.value)
+    assert "MissingWorkflowOutputWorkflow" in error_message
+    assert "terminal nodes that are not referenced by workflow outputs" in error_message

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

@@ -0,0 +1,208 @@
+"""Tests for duplicate trigger name validation during serialization."""
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.triggers.integration import IntegrationTrigger
+from vellum_ee.workflows.display.utils.exceptions import TriggerValidationError
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_duplicate_trigger_names__same_slug_produces_error():
+    """
+    Tests that two integration triggers with the same slug produce a validation error.
+    """
+
+    # GIVEN two IntegrationTrigger subclasses with the same slug
+    class SlackTrigger1(IntegrationTrigger):
+        message: str
+
+        class Config:
+            provider = "COMPOSIO"
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    class SlackTrigger2(IntegrationTrigger):
+        channel: str
+
+        class Config:
+            provider = "COMPOSIO"
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    # AND nodes for each trigger
+    class ProcessNode1(BaseNode):
+        pass
+
+    class ProcessNode2(BaseNode):
+        pass
+
+    # AND a workflow with both triggers
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = {
+            SlackTrigger1 >> ProcessNode1,
+            SlackTrigger2 >> ProcessNode2,
+        }
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    workflow_display.serialize()
+
+    # THEN the display_context should contain a TriggerValidationError
+    errors = list(workflow_display.display_context.errors)
+    trigger_errors = [e for e in errors if isinstance(e, TriggerValidationError)]
+    assert len(trigger_errors) == 1
+
+    # AND the error should mention duplicate trigger name
+    error = trigger_errors[0]
+    assert "Duplicate trigger name" in str(error)
+    assert "slack_new_message" in str(error)
+
+
+def test_different_trigger_names__no_error():
+    """
+    Tests that two integration triggers with different slugs do not produce a validation error.
+    """
+
+    # GIVEN two IntegrationTrigger subclasses with different slugs
+    class SlackTrigger(IntegrationTrigger):
+        message: str
+
+        class Config:
+            provider = "COMPOSIO"
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    class GmailTrigger(IntegrationTrigger):
+        email: str
+
+        class Config:
+            provider = "COMPOSIO"
+            integration_name = "GMAIL"
+            slug = "gmail_new_email"
+
+    # AND nodes for each trigger
+    class ProcessSlack(BaseNode):
+        pass
+
+    class ProcessGmail(BaseNode):
+        pass
+
+    # AND a workflow with both triggers
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = {
+            SlackTrigger >> ProcessSlack,
+            GmailTrigger >> ProcessGmail,
+        }
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    result: dict = workflow_display.serialize()
+
+    # THEN there should be no TriggerValidationError about duplicate names
+    errors = list(workflow_display.display_context.errors)
+    duplicate_errors = [
+        e for e in errors if isinstance(e, TriggerValidationError) and "Duplicate trigger name" in str(e)
+    ]
+    assert len(duplicate_errors) == 0
+
+    # AND both triggers should be serialized with their respective names
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 2
+    trigger_names = {t["name"] for t in triggers}
+    assert trigger_names == {"slack_new_message", "gmail_new_email"}
+
+
+def test_trigger_name_serialization__chat_trigger():
+    """
+    Tests that ChatMessageTrigger serializes with name 'chat'.
+    """
+    from vellum.workflows.triggers.chat_message import ChatMessageTrigger
+
+    # GIVEN a ChatMessageTrigger subclass
+    class MyChatTrigger(ChatMessageTrigger):
+        pass
+
+    # AND a simple node
+    class ProcessNode(BaseNode):
+        pass
+
+    # AND a workflow with the chat trigger
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = MyChatTrigger >> ProcessNode
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    result: dict = workflow_display.serialize()
+
+    # THEN the trigger should have name 'chat'
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 1
+    assert triggers[0]["name"] == "chat"
+
+
+def test_trigger_name_serialization__scheduled_trigger():
+    """
+    Tests that ScheduleTrigger serializes with name 'scheduled'.
+    """
+    from vellum.workflows.triggers.schedule import ScheduleTrigger
+
+    # GIVEN a ScheduleTrigger subclass
+    class MyScheduledTrigger(ScheduleTrigger):
+        class Config(ScheduleTrigger.Config):
+            cron = "0 9 * * *"
+            timezone = "UTC"
+
+    # AND a simple node
+    class ProcessNode(BaseNode):
+        pass
+
+    # AND a workflow with the scheduled trigger
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = MyScheduledTrigger >> ProcessNode
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    result: dict = workflow_display.serialize()
+
+    # THEN the trigger should have name 'scheduled'
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 1
+    assert triggers[0]["name"] == "scheduled"
+
+
+def test_trigger_name_serialization__integration_trigger():
+    """
+    Tests that IntegrationTrigger serializes with name equal to its slug.
+    """
+
+    # GIVEN an IntegrationTrigger subclass with a specific slug
+    class MySlackTrigger(IntegrationTrigger):
+        message: str
+
+        class Config:
+            provider = "COMPOSIO"
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    # AND a simple node
+    class ProcessNode(BaseNode):
+        pass
+
+    # AND a workflow with the integration trigger
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = MySlackTrigger >> ProcessNode
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    result: dict = workflow_display.serialize()
+
+    # THEN the trigger should have name equal to the slug
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 1
+    assert triggers[0]["name"] == "slack_new_message"

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

@@ -0,0 +1,45 @@
+import pytest
+
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.utils.exceptions import WorkflowValidationError
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+class Inputs(BaseInputs):
+    input_value: str
+
+
+class UnreferencedFinalOutputNode(FinalOutputNode):
+    class Outputs(FinalOutputNode.Outputs):
+        value = Inputs.input_value
+
+
+class WorkflowWithUnreferencedFinalOutputNode(BaseWorkflow[Inputs, BaseState]):
+    graph = UnreferencedFinalOutputNode
+
+    class Outputs(BaseWorkflow.Outputs):
+        # Intentionally NOT referencing UnreferencedFinalOutputNode.Outputs.value
+        result = Inputs.input_value
+
+
+def test_serialize_workflow__final_output_node_not_referenced_by_workflow_outputs():
+    """
+    Tests that serialization raises a WorkflowValidationError when a workflow has a final output node
+    but the workflow outputs don't reference it.
+    """
+
+    # GIVEN a Workflow with a FinalOutputNode that is not referenced by workflow outputs
+    workflow_display = get_workflow_display(workflow_class=WorkflowWithUnreferencedFinalOutputNode)
+
+    # WHEN we serialize it
+    # THEN it should raise a WorkflowValidationError about unreferenced terminal nodes
+    with pytest.raises(WorkflowValidationError) as exc_info:
+        workflow_display.serialize()
+
+    # AND the error message should indicate the terminal node is not referenced
+    error_message = str(exc_info.value)
+    assert "WorkflowWithUnreferencedFinalOutputNode" in error_message
+    assert "terminal nodes that are not referenced by workflow outputs" in error_message

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

@@ -0,0 +1,66 @@
+import pytest
+
+from vellum.workflows import BaseWorkflow
+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.state.base import BaseState
+from vellum_ee.workflows.display.utils.exceptions import WorkflowValidationError
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_workflow_serialization_error__node_points_to_itself():
+    """
+    Tests that serialization raises an error when a node creates an infinite loop by pointing to itself.
+    """
+
+    # GIVEN a simple workflow where a node points to itself
+    class StartNode(BaseNode[BaseState]):
+        pass
+
+    class InfiniteLoopWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = StartNode >> StartNode
+
+    # WHEN we attempt to serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=InfiniteLoopWorkflow)
+
+    # THEN it should raise a WorkflowValidationError about the self-edge
+    with pytest.raises(WorkflowValidationError) as exc_info:
+        workflow_display.serialize()
+
+    # AND the error message should be exact and descriptive
+    error_message = str(exc_info.value)
+    assert error_message == (
+        "Workflow validation error in InfiniteLoopWorkflow: " "Graph contains a self-edge (StartNode >> StartNode)."
+    )
+
+
+def test_workflow_serialization__node_with_conditional_loop_is_valid():
+    """
+    Tests that a node with conditional ports (one looping back, one going forward) is valid.
+    """
+
+    # GIVEN a workflow where a node has ports with one looping back to itself and one going to another node
+    class State(BaseState):
+        should_loop: bool = False
+
+    class StartNode(BaseNode[State]):
+        class Ports(BaseNode.Ports):
+            loop = Port.on_if(State.should_loop.equals(True))
+            end = Port.on_else()
+
+    class EndNode(BaseNode[State]):
+        pass
+
+    class ConditionalLoopWorkflow(BaseWorkflow[BaseInputs, State]):
+        graph = {
+            StartNode.Ports.loop >> StartNode,
+            StartNode.Ports.end >> EndNode,
+        }
+
+    # WHEN we attempt to serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=ConditionalLoopWorkflow)
+
+    # THEN it should NOT raise a WorkflowValidationError
+    result = workflow_display.serialize()
+    assert result is not None

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

@@ -0,0 +1,40 @@
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes import FinalOutputNode
+from vellum.workflows.state import BaseState
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+class IntInputs(BaseInputs):
+    count: int
+
+
+class OutputNode(FinalOutputNode):
+    class Outputs(FinalOutputNode.Outputs):
+        value = IntInputs.count
+
+
+class IntInputWorkflow(BaseWorkflow[IntInputs, BaseState]):
+    graph = OutputNode
+
+    class Outputs(BaseWorkflow.Outputs):
+        value = OutputNode.Outputs.value
+
+
+def test_serialize_workflow__int_input_schema_preserved():
+    """
+    Tests that an int input has its schema preserved during serialization.
+    """
+
+    # GIVEN a Workflow that has an int input
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=IntInputWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the input variables should include the schema field with type "integer"
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+
+    # AND the schema should preserve the int type
+    assert input_variables[0]["type"] == "NUMBER"
+    assert input_variables[0]["schema"] == {"type": "integer"}

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

@@ -187,8 +187,9 @@ def test_trigger_module_paths_are_canonical():
 
 
 def test_integration_trigger_no_entrypoint_node():
-    """IntegrationTrigger workflows now create ENTRYPOINT nodes and route edges through them."""
+    """IntegrationTrigger-only workflows should NOT have an ENTRYPOINT node when all branches are trigger-sourced."""
 
+    # GIVEN an IntegrationTrigger workflow where all branches are sourced from the trigger
     class SlackMessageTrigger(IntegrationTrigger):
         message: str
 
@@ -203,9 +204,10 @@ def test_integration_trigger_no_entrypoint_node():
     class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
         graph = SlackMessageTrigger >> ProcessNode
 
+    # WHEN we serialize the workflow
     result = get_workflow_display(workflow_class=TestWorkflow).serialize()
 
-    # Get trigger ID
+    # THEN the trigger should be serialized
     triggers = result["triggers"]
     assert isinstance(triggers, list)
     assert len(triggers) == 1
@@ -213,29 +215,21 @@ def test_integration_trigger_no_entrypoint_node():
     assert isinstance(trigger, dict)
     trigger_id = trigger["id"]
 
-    # Verify ENTRYPOINT node exists
+    # AND there should be NO ENTRYPOINT node (all branches are trigger-sourced)
     workflow_raw_data = result["workflow_raw_data"]
     assert isinstance(workflow_raw_data, dict)
     nodes = workflow_raw_data["nodes"]
     assert isinstance(nodes, list)
     entrypoint_nodes = [n for n in nodes if isinstance(n, dict) and n.get("type") == "ENTRYPOINT"]
-    assert len(entrypoint_nodes) == 1, "IntegrationTrigger workflows should have an ENTRYPOINT node"
-
-    entrypoint_node = entrypoint_nodes[0]
-    assert isinstance(entrypoint_node, dict)
-    entrypoint_node_id = entrypoint_node["id"]
+    assert len(entrypoint_nodes) == 0, "IntegrationTrigger-only workflows should NOT have an ENTRYPOINT node"
 
+    # AND edges should use trigger ID as source_node_id
     edges = workflow_raw_data["edges"]
     assert isinstance(edges, list)
-    entrypoint_edges = [e for e in edges if isinstance(e, dict) and e.get("source_node_id") == entrypoint_node_id]
-    assert len(entrypoint_edges) == 0
-
-    # Verify edges use trigger ID as sourceNodeId (not ENTRYPOINT)
     trigger_edges = [e for e in edges if isinstance(e, dict) and e.get("source_node_id") == trigger_id]
     assert len(trigger_edges) > 0, "Should have edges from trigger ID"
 
-    # Verify the edge connects trigger to first node
-    # ProcessNode should be the only non-terminal, non-entrypoint node
+    # AND the edge should connect trigger to the process node
     process_nodes = [n for n in nodes if isinstance(n, dict) and n.get("type") not in ("TERMINAL", "ENTRYPOINT")]
     assert len(process_nodes) > 0, "Should have at least one process node"
     process_node = process_nodes[0]