vellum-ai 1.7.5__py3-none-any.whl → 1.7.7__py3-none-any.whl

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -410,7 +410,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                 self.display_context.add_error(e)
 
         # Serialize workflow-level trigger if present
-        trigger_data: Optional[JsonObject] = self._serialize_workflow_trigger()
+        triggers: Optional[JsonArray] = self._serialize_workflow_trigger()
 
         workflow_raw_data: JsonObject = {
             "nodes": cast(JsonArray, nodes_dict_list),
@@ -423,22 +423,25 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             "output_values": output_values,
         }
 
-        if trigger_data is not None:
-            workflow_raw_data["trigger"] = trigger_data
-
-        return {
+        result: JsonObject = {
             "workflow_raw_data": workflow_raw_data,
             "input_variables": input_variables,
             "state_variables": state_variables,
             "output_variables": output_variables,
         }
 
-    def _serialize_workflow_trigger(self) -> Optional[JsonObject]:
+        if triggers is not None:
+            result["triggers"] = triggers
+
+        return result
+
+    def _serialize_workflow_trigger(self) -> Optional[JsonArray]:
         """
         Serialize workflow-level trigger information.
 
         Returns:
-            JsonObject with trigger data if a trigger is present, None otherwise
+            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 = []
@@ -469,13 +472,19 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                 f"Please add it to the trigger type mapping in get_trigger_type_mapping()."
             )
 
-        return {
-            "type": trigger_type.value,
-            "definition": {
-                "name": trigger_class.__name__,
-                "module": cast(JsonArray, trigger_class.__module__.split(".")),
-            },
-        }
+        # 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."""

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."""