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

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

@@ -0,0 +1,173 @@
+"""Tests for IntegrationTrigger attribute type validation during serialization."""
+
+import pytest
+from unittest.mock import MagicMock, patch
+from typing import Dict
+
+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
+
+
+class LinearIssueTrigger(IntegrationTrigger):
+    """Custom Linear issue trigger for testing."""
+
+    action: str
+    data: dict
+    type: str
+    url: str
+
+    class Config:
+        provider = "COMPOSIO"
+        integration_name = "LINEAR"
+        slug = "LINEAR_ISSUE_CREATED_TRIGGER"
+        setup_attributes = {"team_id": "test-team-id"}
+
+
+class ProcessNode(BaseNode):
+    """Node that processes the trigger."""
+
+    class Outputs(BaseNode.Outputs):
+        result = LinearIssueTrigger.action
+
+    def run(self) -> Outputs:
+        return self.Outputs()
+
+
+class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+    graph = LinearIssueTrigger >> ProcessNode
+
+
+def _create_mock_tool_definition(properties: Dict[str, dict]) -> MagicMock:
+    """Helper to create a mock tool definition with output_parameters as JSON Schema.
+
+    For triggers, output_parameters contains the webhook payload schema,
+    while input_parameters contains setup/config arguments.
+    """
+    mock_tool_def = MagicMock()
+    mock_tool_def.name = "LINEAR_ISSUE_CREATED_TRIGGER"
+    # output_parameters is a JSON Schema object containing the payload schema
+    mock_tool_def.output_parameters = {
+        "type": "object",
+        "properties": properties,
+        "required": list(properties.keys()),
+    }
+    return mock_tool_def
+
+
+def test_integration_trigger_validation__matching_types():
+    """
+    Tests that serialization succeeds when trigger attribute types match the API definition.
+    """
+    # GIVEN a tool definition from the API with matching types (JSON Schema format)
+    mock_tool_def = _create_mock_tool_definition(
+        {
+            "action": {"type": "string"},
+            "data": {"type": "object"},
+            "type": {"type": "string"},
+            "url": {"type": "string"},
+        }
+    )
+
+    # WHEN we serialize the workflow with mocked API
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+
+    with patch.object(
+        workflow_display._client.integrations,
+        "retrieve_integration_tool_definition",
+        return_value=mock_tool_def,
+    ):
+        # THEN serialization should succeed without raising an error
+        result = workflow_display.serialize()
+
+    # AND the trigger should be serialized correctly
+    assert "triggers" in result
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 1
+
+
+def test_integration_trigger_validation__type_mismatch():
+    """
+    Tests that serialization raises TriggerValidationError when attribute types don't match.
+    """
+    # GIVEN a tool definition from the API with mismatched types (JSON Schema format)
+    # The API says 'action' should be object (JSON), but our trigger defines it as STRING
+    mock_tool_def = _create_mock_tool_definition(
+        {
+            "action": {"type": "object"},
+            "data": {"type": "object"},
+            "type": {"type": "string"},
+            "url": {"type": "string"},
+        }
+    )
+
+    # WHEN we serialize the workflow with mocked API
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+
+    with patch.object(
+        workflow_display._client.integrations,
+        "retrieve_integration_tool_definition",
+        return_value=mock_tool_def,
+    ):
+        # THEN serialization should raise TriggerValidationError
+        with pytest.raises(TriggerValidationError) as exc_info:
+            workflow_display.serialize()
+
+    # AND the error message should indicate the type mismatch with expected and actual types
+    assert "action" in str(exc_info.value)
+    assert "STRING" in str(exc_info.value)
+    assert "expected type 'JSON'" in str(exc_info.value)
+    assert "The trigger configuration is invalid or contains unsupported values" in str(exc_info.value)
+
+
+def test_integration_trigger_validation__api_error():
+    """
+    Tests that serialization continues gracefully when the API returns an error.
+    """
+    # GIVEN an API that raises an exception
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+
+    with patch.object(
+        workflow_display._client.integrations,
+        "retrieve_integration_tool_definition",
+        side_effect=Exception("API Error"),
+    ):
+        # WHEN we serialize the workflow
+        # THEN serialization should succeed (validation is skipped on API error)
+        result = workflow_display.serialize()
+
+    # AND the trigger should still be serialized
+    assert "triggers" in result
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 1
+
+
+def test_integration_trigger_validation__no_properties():
+    """
+    Tests that serialization continues gracefully when the API response has no properties.
+    """
+    # GIVEN a tool definition with empty properties in JSON Schema
+    mock_tool_def = _create_mock_tool_definition({})
+
+    # WHEN we serialize the workflow with mocked API
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+
+    with patch.object(
+        workflow_display._client.integrations,
+        "retrieve_integration_tool_definition",
+        return_value=mock_tool_def,
+    ):
+        # THEN serialization should succeed (validation is skipped when no output_parameters)
+        result = workflow_display.serialize()
+
+    # AND the trigger should still be serialized
+    assert "triggers" in result
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 1

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

@@ -16,9 +16,13 @@ from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class imp
 def test_integration_trigger_with_explicit_entrypoint_node_id():
     """
     Tests that a workflow with an IntegrationTrigger and explicit entrypoint_node_id
-    creates an ENTRYPOINT node using the explicit ID (not the trigger's ID).
+    does NOT create an ENTRYPOINT node when all branches are trigger-sourced.
+
+    Even with explicit IDs provided, if all graph branches originate from triggers,
+    the ENTRYPOINT node should be skipped.
     """
 
+    # GIVEN an IntegrationTrigger workflow with explicit entrypoint_node_id
     class SlackMessageTrigger(IntegrationTrigger):
         message: str
 
@@ -53,8 +57,10 @@ def test_integration_trigger_with_explicit_entrypoint_node_id():
             )
         }
 
+    # WHEN we serialize the workflow
     result: dict = get_workflow_display(workflow_class=TestWorkflow).serialize()
 
+    # THEN the trigger should be serialized
     assert "workflow_raw_data" in result
     workflow_raw_data = result["workflow_raw_data"]
     assert isinstance(workflow_raw_data, dict)
@@ -67,22 +73,19 @@ def test_integration_trigger_with_explicit_entrypoint_node_id():
     assert isinstance(trigger, dict)
     trigger_id = trigger["id"]
 
+    # AND there should be NO ENTRYPOINT node (all branches are trigger-sourced)
     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 with explicit entrypoint_node_id should create an ENTRYPOINT node"
-
-    entrypoint_node = entrypoint_nodes[0]
-    assert isinstance(entrypoint_node, dict)
-    entrypoint_node_id = entrypoint_node["id"]
-
-    assert entrypoint_node_id == str(explicit_entrypoint_node_id), (
-        f"Entrypoint node ID should be {explicit_entrypoint_node_id} from workflow_display, "
-        f"not {trigger_id} from trigger"
+    assert len(entrypoint_nodes) == 0, (
+        "IntegrationTrigger-only workflows should NOT create an ENTRYPOINT node "
+        "even with explicit entrypoint_node_id, since all branches are trigger-sourced"
     )
 
-    assert entrypoint_node_id != trigger_id, "Entrypoint node should not use the trigger's ID"
+    # AND edges should use trigger ID as source_node_id
+    edges = workflow_raw_data["edges"]
+    assert isinstance(edges, list)
+    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"

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

@@ -49,7 +49,11 @@ def test_serialize_workflow_with_list_vellum_document():
     input_var = input_variables[0]
     assert input_var["key"] == "documents"
     assert input_var["type"] == "JSON"
-    # NOTE: Once custom type serialization is supported, we will want to represent this using an openapi spec
+    # The schema field now includes the OpenAPI spec for the input type
+    assert input_var["schema"] == {
+        "type": "array",
+        "items": {"$ref": "#/$defs/vellum.client.types.vellum_document.VellumDocument"},
+    }
     assert input_var["required"] is True
     assert input_var["default"] is None
     assert input_var["extensions"] == {"color": None}

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

@@ -24,7 +24,12 @@ def test_manual_trigger_serialization():
     assert isinstance(triggers, list)
 
     assert len(triggers) == 1
-    assert triggers[0] == {"id": "b3c8ab56-001f-4157-bbc2-4a7fe5ebf8c6", "type": "MANUAL", "attributes": []}
+    assert triggers[0] == {
+        "id": "b3c8ab56-001f-4157-bbc2-4a7fe5ebf8c6",
+        "type": "MANUAL",
+        "name": "manual",
+        "attributes": [],
+    }
 
 
 def test_manual_trigger_multiple_entrypoints():
@@ -54,7 +59,12 @@ def test_manual_trigger_multiple_entrypoints():
     assert isinstance(triggers, list)
 
     assert len(triggers) == 1
-    assert triggers[0] == {"id": "b3c8ab56-001f-4157-bbc2-4a7fe5ebf8c6", "type": "MANUAL", "attributes": []}
+    assert triggers[0] == {
+        "id": "b3c8ab56-001f-4157-bbc2-4a7fe5ebf8c6",
+        "type": "MANUAL",
+        "name": "manual",
+        "attributes": [],
+    }
 
 
 def test_unknown_trigger_type():

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

@@ -97,3 +97,114 @@ def test_manual_and_slack_trigger_same_node():
     assert slack_edge is not None, (
         f"Should have edge from Slack trigger ({slack_trigger_id}) " f"to ProcessNode ({process_node_id})"
     )
+
+
+def test_two_integration_triggers_same_node_unique_edge_ids():
+    """
+    Tests that when two IntegrationTriggers point to the same node,
+    each trigger edge gets a unique ID (not duplicates).
+    """
+
+    # GIVEN two different IntegrationTriggers
+    class SlackMessageTrigger(IntegrationTrigger):
+        message: str
+
+        class Config(IntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    class GithubPRTrigger(IntegrationTrigger):
+        pr_title: str
+
+        class Config(IntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "GITHUB"
+            slug = "github_pr_opened"
+
+    class ProcessNode(BaseNode):
+        pass
+
+    # AND a workflow where both triggers point to the same node
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = {
+            SlackMessageTrigger >> ProcessNode,
+            GithubPRTrigger >> ProcessNode,
+        }
+
+    # WHEN we serialize the workflow
+    result = get_workflow_display(workflow_class=TestWorkflow).serialize()
+
+    # THEN we should have two triggers
+    triggers = result["triggers"]
+    assert isinstance(triggers, list)
+    assert len(triggers) == 2
+
+    def get_integration_name(trigger: dict) -> str:
+        exec_config = trigger.get("exec_config")
+        if isinstance(exec_config, dict):
+            name = exec_config.get("integration_name")
+            return str(name) if name else ""
+        return ""
+
+    slack_trigger = next(
+        (t for t in triggers if isinstance(t, dict) and get_integration_name(t) == "SLACK"),
+        None,
+    )
+    assert slack_trigger is not None
+    assert isinstance(slack_trigger, dict)
+    slack_trigger_id = slack_trigger["id"]
+
+    github_trigger = next(
+        (t for t in triggers if isinstance(t, dict) and get_integration_name(t) == "GITHUB"),
+        None,
+    )
+    assert github_trigger is not None
+    assert isinstance(github_trigger, dict)
+    github_trigger_id = github_trigger["id"]
+
+    # AND we should have edges from both triggers
+    workflow_raw_data = result["workflow_raw_data"]
+    assert isinstance(workflow_raw_data, dict)
+    edges = workflow_raw_data["edges"]
+    assert isinstance(edges, list)
+
+    nodes = workflow_raw_data["nodes"]
+    assert isinstance(nodes, list)
+    process_nodes = [n for n in nodes if isinstance(n, dict) and n.get("type") not in ("TERMINAL", "ENTRYPOINT")]
+    assert len(process_nodes) > 0
+    process_node = process_nodes[0]
+    assert isinstance(process_node, dict)
+    process_node_id = process_node["id"]
+
+    slack_edge = next(
+        (
+            e
+            for e in edges
+            if isinstance(e, dict)
+            and e.get("source_node_id") == slack_trigger_id
+            and e.get("target_node_id") == process_node_id
+        ),
+        None,
+    )
+    assert slack_edge is not None, "Should have edge from Slack trigger to ProcessNode"
+    assert isinstance(slack_edge, dict)
+
+    github_edge = next(
+        (
+            e
+            for e in edges
+            if isinstance(e, dict)
+            and e.get("source_node_id") == github_trigger_id
+            and e.get("target_node_id") == process_node_id
+        ),
+        None,
+    )
+    assert github_edge is not None, "Should have edge from GitHub trigger to ProcessNode"
+    assert isinstance(github_edge, dict)
+
+    # AND the edge IDs should be unique (not duplicates)
+    assert slack_edge["id"] != github_edge["id"], (
+        f"Edge IDs should be unique but both are {slack_edge['id']}. "
+        "Multiple triggers targeting the same node should have distinct edge IDs."
+    )

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

@@ -0,0 +1,64 @@
+"""Tests for validation when a workflow has no triggers and no entrypoint node."""
+
+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_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__no_triggers_no_entrypoint():
+    """
+    Tests that serialization adds an error when a workflow has no triggers and no entrypoint node.
+    """
+
+    # GIVEN a workflow with an empty graph (no triggers and no entrypoint nodes)
+    class EmptyWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = set()
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=EmptyWorkflow)
+    workflow_display.serialize()
+
+    # THEN the display_context should contain a WorkflowValidationError
+    errors = list(workflow_display.display_context.errors)
+    validation_errors = [e for e in errors if isinstance(e, WorkflowValidationError)]
+    assert len(validation_errors) == 1
+
+    # AND the error message should be exact and descriptive
+    error = validation_errors[0]
+    assert str(error) == (
+        "Workflow validation error in EmptyWorkflow: "
+        "Workflow has no triggers and no entrypoint nodes. "
+        "A workflow must have at least one trigger or one node in its graph."
+    )
+
+
+def test_workflow_serialization_error__no_triggers_no_entrypoint_with_unused_graphs():
+    """
+    Tests that serialization adds an error even when a workflow has nodes in unused_graphs
+    but no triggers and no entrypoint nodes in the main graph.
+    """
+
+    # GIVEN a workflow with nodes only in unused_graphs (no triggers and no entrypoint nodes in main graph)
+    class UnusedNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+    class WorkflowWithOnlyUnusedGraphs(BaseWorkflow[BaseInputs, BaseState]):
+        graph = set()
+        unused_graphs = {UnusedNode}
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=WorkflowWithOnlyUnusedGraphs)
+    workflow_display.serialize()
+
+    # THEN the display_context should contain a WorkflowValidationError
+    errors = list(workflow_display.display_context.errors)
+    validation_errors = [e for e in errors if isinstance(e, WorkflowValidationError)]
+    assert len(validation_errors) == 1
+
+    # AND the error message should indicate the workflow has no triggers and no entrypoint nodes
+    error = validation_errors[0]
+    assert "no triggers and no entrypoint nodes" in str(error)

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

@@ -0,0 +1,55 @@
+"""Tests for partial WorkflowMetaDisplay override 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_ee.workflows.display.base import WorkflowDisplayData, WorkflowDisplayDataViewport, WorkflowMetaDisplay
+from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_triggerless_workflow_with_partial_display_override_creates_entrypoint():
+    """
+    Tests that a triggerless workflow with partial WorkflowMetaDisplay overrides
+    (only display_data set) still creates an ENTRYPOINT node with backfilled IDs.
+    """
+
+    # GIVEN a simple triggerless workflow
+    class ProcessNode(BaseNode):
+        pass
+
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = ProcessNode
+
+    # AND a display class that only overrides display_data (viewport), not entrypoint IDs
+    class TestWorkflowDisplay(BaseWorkflowDisplay[TestWorkflow]):
+        workflow_display = WorkflowMetaDisplay(
+            display_data=WorkflowDisplayData(viewport=WorkflowDisplayDataViewport(x=100.0, y=200.0, zoom=1.5))
+        )
+
+    # WHEN we serialize the workflow
+    result = get_workflow_display(workflow_class=TestWorkflow).serialize()
+
+    # THEN the workflow should have an ENTRYPOINT node
+    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, "Triggerless workflow with partial overrides should have an ENTRYPOINT node"
+
+    # AND the ENTRYPOINT node should have valid IDs (not None)
+    entrypoint_node = entrypoint_nodes[0]
+    assert isinstance(entrypoint_node, dict)
+    assert entrypoint_node["id"] is not None, "ENTRYPOINT node should have a non-None id"
+    entrypoint_data = entrypoint_node["data"]
+    assert isinstance(entrypoint_data, dict)
+    source_handle_id = entrypoint_data["source_handle_id"]
+    assert source_handle_id is not None, "ENTRYPOINT node should have a non-None source_handle_id"
+
+    # AND there should be an edge from ENTRYPOINT to the process node
+    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, "Should have edges from ENTRYPOINT node"