vellum-ai 1.7.4__py3-none-any.whl → 1.7.6__py3-none-any.whl

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -37,6 +37,7 @@ from vellum_ee.workflows.display.base import (
     WorkflowInputsDisplay,
     WorkflowMetaDisplay,
     WorkflowOutputDisplay,
+    get_trigger_type_mapping,
 )
 from vellum_ee.workflows.display.editor.types import NodeDisplayData, NodeDisplayPosition
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
@@ -408,22 +409,83 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             except Exception as e:
                 self.display_context.add_error(e)
 
-        return {
-            "workflow_raw_data": {
-                "nodes": cast(JsonArray, nodes_dict_list),
-                "edges": edges,
-                "display_data": self.display_context.workflow_display.display_data.dict(),
-                "definition": {
-                    "name": self._workflow.__name__,
-                    "module": cast(JsonArray, self._workflow.__module__.split(".")),
-                },
-                "output_values": output_values,
+        # Serialize workflow-level trigger if present
+        triggers: Optional[JsonArray] = self._serialize_workflow_trigger()
+
+        workflow_raw_data: JsonObject = {
+            "nodes": cast(JsonArray, nodes_dict_list),
+            "edges": edges,
+            "display_data": self.display_context.workflow_display.display_data.dict(),
+            "definition": {
+                "name": self._workflow.__name__,
+                "module": cast(JsonArray, self._workflow.__module__.split(".")),
             },
+            "output_values": output_values,
+        }
+
+        result: JsonObject = {
+            "workflow_raw_data": workflow_raw_data,
             "input_variables": input_variables,
             "state_variables": state_variables,
             "output_variables": output_variables,
         }
 
+        if triggers is not None:
+            result["triggers"] = triggers
+
+        return result
+
+    def _serialize_workflow_trigger(self) -> Optional[JsonArray]:
+        """
+        Serialize workflow-level trigger information.
+
+        Returns:
+            JsonArray with trigger data if a trigger is present, None otherwise.
+            Each trigger in the array has: id (UUID), type (str), attributes (list)
+        """
+        # Get all trigger edges from the workflow's subgraphs
+        trigger_edges = []
+        for subgraph in self._workflow.get_subgraphs():
+            trigger_edges.extend(list(subgraph.trigger_edges))
+
+        if not trigger_edges:
+            # No workflow-level trigger defined
+            return None
+
+        # Get the trigger class from the first edge
+        trigger_class = trigger_edges[0].trigger_class
+
+        # Validate that all trigger edges use the same trigger type
+        trigger_type_mapping = get_trigger_type_mapping()
+        for edge in trigger_edges:
+            if edge.trigger_class != trigger_class:
+                raise ValueError(
+                    f"Mixed trigger types not supported. Found {trigger_class.__name__} and "
+                    f"{edge.trigger_class.__name__} in the same workflow."
+                )
+
+        # Get the trigger type from the mapping
+        trigger_type = trigger_type_mapping.get(trigger_class)
+        if trigger_type is None:
+            raise ValueError(
+                f"Unknown trigger type: {trigger_class.__name__}. "
+                f"Please add it to the trigger type mapping in get_trigger_type_mapping()."
+            )
+
+        # Return as a list with a single trigger object matching Django schema
+        trigger_id = uuid4_from_hash(f"{trigger_class.__module__} | {trigger_class.__qualname__}")
+
+        return cast(
+            JsonArray,
+            [
+                {
+                    "id": str(trigger_id),
+                    "type": trigger_type.value,
+                    "attributes": [],
+                }
+            ],
+        )
+
     def _serialize_edge_display_data(self, edge_display: EdgeDisplay) -> Optional[JsonObject]:
         """Serialize edge display data, returning None if no display data is present."""
         if edge_display.z_index is not None:

vellum_ee/workflows/tests/test_server.py

@@ -536,10 +536,49 @@ class BrokenNode(BaseNode)  # Missing colon
 
     # AND the error message should be user-friendly
     error_message = str(exc_info.value)
-    assert "Failed to load workflow module:" in error_message
+    assert "Syntax Error raised while loading Workflow:" in error_message
     assert "invalid syntax" in error_message or "expected ':'" in error_message
 
 
+def test_load_from_module__name_error_in_node_file():
+    """
+    Tests that a NameError in a node file raises WorkflowInitializationException with user-facing message.
+    """
+    # GIVEN a workflow module with a node file containing a NameError (undefined class reference)
+    files = {
+        "__init__.py": "",
+        "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from .nodes.broken_node import BrokenNode
+
+class Workflow(BaseWorkflow):
+    graph = BrokenNode
+""",
+        "nodes/__init__.py": "",
+        "nodes/broken_node.py": """\
+from vellum.workflows.nodes import BaseNode
+
+class BrokenNode(BaseNode):
+    some_attribute = UndefinedClass()
+""",
+    }
+
+    namespace = str(uuid4())
+
+    # AND the virtual file loader is registered
+    sys.meta_path.append(VirtualFileFinder(files, namespace))
+
+    # WHEN we attempt to load the workflow
+    # THEN it should raise WorkflowInitializationException
+    with pytest.raises(WorkflowInitializationException) as exc_info:
+        BaseWorkflow.load_from_module(namespace)
+
+    # AND the error message should be user-friendly
+    error_message = str(exc_info.value)
+    assert "Invalid variable reference:" in error_message
+    assert "UndefinedClass" in error_message or "not defined" in error_message
+
+
 def test_serialize_module__tool_calling_node_with_single_tool():
     """Test that serialize_module works with a tool calling node that has a single tool."""